C++

moteur audio

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : moteur audio

gabuzomeuh2

bonjour

j'ai ecrit un moteur audio temps reel pour faire du traitement de signal en direct. J'ai ajouté un SetThreadPriority pour chaque procédure In et Out mais ca ne change rien, quand la fenêtre est réduite ou restaurée, il y a une courte interruption du processus. Quelqu'un a une piste ?

Code :

#include <windows.h>
#include "stdafx.h"
#include "resource.h"
#include <mmsystem.h>
#include <malloc.h>
#include <stdio.h>
#include <commctrl.h>
#define BUFFER_SIZE 16384
#define SAMPLERATE 44100
#define CANAUX 2
#define OCTETS 2
HWND DlgMain;
PBYTE Buffer;
HWAVEIN hWaveIn;
HWAVEOUT hWaveOut;
PBYTE pBufferIn1, pBufferIn2, pBufferIn3, pBufferOut1, pBufferOut2, pBufferOut3;
PWAVEHDR pWaveHdrIn1, pWaveHdrIn2, pWaveHdrIn3, pWaveHdrOut1, pWaveHdrOut2, pWaveHdrOut3;
WAVEFORMATEX waveform;
BOOL flag_in_open = FALSE;
BOOL flag_out_open = FALSE;
HANDLE WorkerThreadHandleIn;
DWORD WorkerThreadIdIn;
HANDLE WorkerThreadHandleOut;
DWORD WorkerThreadIdOut;
//****************************************************************************
DWORD WINAPI WorkerThreadProcIn (void *Arg)
{
SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_TIME_CRITICAL);
MSG Msg;
while (GetMessage (&Msg, NULL, 0, 0) == TRUE)
{
switch (Msg.message)
{
case MM_WIM_OPEN:
{
MessageBox(DlgMain,"In open","RTA",MB_OK);
flag_in_open = TRUE;
waveInAddBuffer(hWaveIn,pWaveHdrIn1,sizeof(WAVEHDR));
waveInAddBuffer(hWaveIn,pWaveHdrIn2,sizeof(WAVEHDR));
waveInAddBuffer(hWaveIn,pWaveHdrIn3,sizeof(WAVEHDR));
waveInStart(hWaveIn);
break;
}
case MM_WIM_DATA:
{
WAVEHDR *Hdr = (WAVEHDR *)Msg.lParam;
CopyMemory(Buffer,Hdr->lpData,BUFFER_SIZE);
waveInAddBuffer (hWaveIn, Hdr, sizeof (*Hdr));
break;
}
}
}
return 0;
}
//****************************************************************************
DWORD WINAPI WorkerThreadProcOut (void *Arg)
{
SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_TIME_CRITICAL);
MSG Msg;
while (GetMessage (&Msg, NULL, 0, 0) == TRUE)
{
switch (Msg.message)
{
case MM_WOM_OPEN:
{
MessageBox(DlgMain,"Out open","RTA",MB_OK);
flag_out_open = TRUE;
waveOutPrepareHeader(hWaveOut,pWaveHdrOut1,sizeof(WAVEHDR));
waveOutWrite(hWaveOut,pWaveHdrOut1,sizeof(WAVEHDR));
waveOutPrepareHeader(hWaveOut,pWaveHdrOut2,sizeof(WAVEHDR));
waveOutWrite(hWaveOut,pWaveHdrOut2,sizeof(WAVEHDR));
waveOutPrepareHeader(hWaveOut,pWaveHdrOut3,sizeof(WAVEHDR));
waveOutWrite(hWaveOut,pWaveHdrOut3,sizeof(WAVEHDR));
break;
}
case MM_WOM_DONE:
{
WAVEHDR *Hdr = (WAVEHDR *)Msg.lParam;
waveOutPrepareHeader (hWaveOut, Hdr, sizeof (*Hdr));
waveOutWrite (hWaveOut, Hdr, sizeof (*Hdr));
CopyMemory(Hdr->lpData,Buffer,BUFFER_SIZE);
break;
}
}
}
return 0;
}
//****************************************************************************
BOOL CALLBACK DlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
static int volume_general;
if (msg == WM_INITDIALOG)
{
DlgMain = hWnd;
return 0;
}
if (msg == WM_COMMAND)
{
if (wParam == ID_START)
{
if(flag_in_open == TRUE)
{
MessageBox(hWnd,"périphérique déjà ouvert","Erreur",0);
return 0;
}
WorkerThreadHandleIn = CreateThread (NULL, 0, WorkerThreadProcIn, NULL, 0, &WorkerThreadIdIn );
WorkerThreadHandleOut = CreateThread (NULL, 0, WorkerThreadProcOut, NULL, 0, &WorkerThreadIdOut );
pWaveHdrIn1 = (PWAVEHDR) malloc(sizeof(WAVEHDR));
pWaveHdrIn2 = (PWAVEHDR) malloc(sizeof(WAVEHDR));
pWaveHdrIn3 = (PWAVEHDR) malloc(sizeof(WAVEHDR));
pWaveHdrOut1 = (PWAVEHDR) malloc(sizeof(WAVEHDR));
pWaveHdrOut2 = (PWAVEHDR) malloc(sizeof(WAVEHDR));
pWaveHdrOut3 = (PWAVEHDR) malloc(sizeof(WAVEHDR));
Buffer = (PBYTE)malloc(BUFFER_SIZE);
pBufferIn1 = (PBYTE)malloc(BUFFER_SIZE);
pBufferIn2 = (PBYTE)malloc(BUFFER_SIZE);
pBufferIn3 = (PBYTE)malloc(BUFFER_SIZE);
pBufferOut1 = (PBYTE)malloc(BUFFER_SIZE);
pBufferOut2 = (PBYTE)malloc(BUFFER_SIZE);
pBufferOut3 = (PBYTE)malloc(BUFFER_SIZE);
if(!pBufferIn1 || !pBufferIn2 || !pBufferIn3 || !pBufferOut1 || !pBufferOut2 || !pBufferOut3)
{
if(pBufferIn1) free (pBufferIn1);
if(pBufferIn2) free (pBufferIn2);
if(pBufferIn3) free (pBufferIn3);
if(pBufferOut1) free (pBufferOut1);
if(pBufferOut2) free (pBufferOut2);
if(pBufferOut3) free (pBufferOut3);
MessageBox(hWnd,"Erreur d'allocation de mémoire","Erreur",0);
return TRUE;
}
waveform.nChannels = CANAUX; // 1 pour mono 2 pour stereo
waveform.wBitsPerSample = 8 * OCTETS; // 8 ou 16 bit
waveform.nAvgBytesPerSec = SAMPLERATE * waveform.nChannels * waveform.wBitsPerSample/8; // nombre d'octets par seconde
waveform.wFormatTag = 1; // 1 pour PCM
waveform.nSamplesPerSec = SAMPLERATE; // frequence d'echantillonnage
waveform.nBlockAlign = 1;
waveform.cbSize = 0;
if(waveInOpen(&hWaveIn,WAVE_MAPPER,&waveform,(DWORD)WorkerThreadIdIn,0,CALLBACK_THREAD))
{
free(pBufferIn1);
free(pBufferIn2);
free(pBufferIn3);
MessageBox(hWnd,"ouverture du périphérique d'entrée impossible","WARNING",MB_OK);
return 0;
}
pWaveHdrIn1->lpData = (LPSTR)pBufferIn1;
pWaveHdrIn1->dwBufferLength = BUFFER_SIZE;
pWaveHdrIn1->dwBytesRecorded = 0;
pWaveHdrIn1->dwUser = 0;
pWaveHdrIn1->dwFlags = 0;
pWaveHdrIn1->dwLoops = 0;
pWaveHdrIn1->lpNext = NULL;
pWaveHdrIn1->reserved = 0;
waveInPrepareHeader(hWaveIn,pWaveHdrIn1,sizeof(WAVEHDR));
pWaveHdrIn2->lpData = (LPSTR)pBufferIn2;
pWaveHdrIn2->dwBufferLength = BUFFER_SIZE;
pWaveHdrIn2->dwBytesRecorded = 0;
pWaveHdrIn2->dwUser = 0;
pWaveHdrIn2->dwFlags = 0;
pWaveHdrIn2->dwLoops = 0;
pWaveHdrIn2->lpNext = NULL;
pWaveHdrIn2->reserved = 0;
waveInPrepareHeader(hWaveIn,pWaveHdrIn2,sizeof(WAVEHDR));
pWaveHdrIn3->lpData = (LPSTR)pBufferIn3;
pWaveHdrIn3->dwBufferLength = BUFFER_SIZE;
pWaveHdrIn3->dwBytesRecorded = 0;
pWaveHdrIn3->dwUser = 0;
pWaveHdrIn3->dwFlags = 0;
pWaveHdrIn3->dwLoops = 0;
pWaveHdrIn3->lpNext = NULL;
pWaveHdrIn3->reserved = 0;
waveInPrepareHeader(hWaveIn,pWaveHdrIn3,sizeof(WAVEHDR));
if(waveOutOpen(&hWaveOut,WAVE_MAPPER,&waveform,(DWORD)WorkerThreadIdOut,0,CALLBACK_THREAD))
{
free(pBufferOut1);
free(pBufferOut2);
free(pBufferOut3);
MessageBox(hWnd,"ouverture du périphérique de sortie impossible","WARNING",MB_OK);
return 0;
}
pWaveHdrOut1->lpData = (LPSTR)pBufferOut1;
pWaveHdrOut1->dwBufferLength = BUFFER_SIZE;
pWaveHdrOut1->dwBytesRecorded = 0;
pWaveHdrOut1->dwUser = 0;
pWaveHdrOut1->dwFlags = 0;
pWaveHdrOut1->dwLoops = 0;
pWaveHdrOut1->lpNext = NULL;
pWaveHdrOut1->reserved = 0;
waveOutPrepareHeader(hWaveOut,pWaveHdrOut1,sizeof(WAVEHDR));
pWaveHdrOut2->lpData = (LPSTR)pBufferOut2;
pWaveHdrOut2->dwBufferLength = BUFFER_SIZE;
pWaveHdrOut2->dwBytesRecorded = 0;
pWaveHdrOut2->dwUser = 0;
pWaveHdrOut2->dwFlags = 0;
pWaveHdrOut2->dwLoops = 0;
pWaveHdrOut2->lpNext = NULL;
pWaveHdrOut2->reserved = 0;
waveOutPrepareHeader(hWaveOut,pWaveHdrOut2,sizeof(WAVEHDR));
pWaveHdrOut3->lpData =(LPSTR)pBufferOut3;
pWaveHdrOut3->dwBufferLength =BUFFER_SIZE;
pWaveHdrOut3->dwBytesRecorded =0;
pWaveHdrOut3->dwUser =0;
pWaveHdrOut3->dwFlags =0;
pWaveHdrOut3->dwLoops =0;
pWaveHdrOut3->lpNext =NULL;
pWaveHdrOut3->reserved =0;
waveOutPrepareHeader(hWaveOut,pWaveHdrOut3,sizeof(WAVEHDR));
return 0;
}
if (wParam == IDCANCEL)
{
if(MessageBox(hWnd, "Voulez-vous vraiment arrêter l'application en cours ?", "Real Time Audio",MB_YESNO|MB_ICONEXCLAMATION|MB_DEFBUTTON2) == IDNO)
{
return TRUE;
}
EndDialog(hWnd, 0);
return 0;
}
}
return 0;
}
//****************************************************************************
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
InitCommonControls();
DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1),HWND_DESKTOP,DlgProc);
return 0;
}
//****************************************************************************

Publicité

karlkox

Hésite pas a augmenter ton buffer_size, je le fixera à 65536.
De plus, je ferais un sleep entre chaque filling de buffer tant que celui ci n'a pas son flag à WHDR_DONE.

Message cité 1 fois

gabuzomeuh2

merci je vais essayer
65536 c'est super long comme retatd c'est plus vraiment du temps reel Y' a pas mieux comme solution ?

karlkox a écrit :

Hésite pas a augmenter ton buffer_size, je le fixera à 65536.
De plus, je ferais un sleep entre chaque filling de buffer tant que celui ci n'a pas son flag à WHDR_DONE.

karlkox

Déjà, ce que tu peux faire, c'est un tableau de WAVEHDR, dans ton thread, tu incrémenteras une variable (à locker) qui indiquera le buffer en cours de traitement, tu pourras ainsi pointer sur le bon WAVEHDR, tu l'écrit sur le device puis tu attends que son flag soit sur WHDR_DONE.
C'est ce que fait la SDL (je me suis basé la dessus) et ça a réglé le même problème que le tient que j'ai eu. (mais j'ai du augmenter le buffer size, driver creative inside ...)

Ace17

C'est quoi le probleme avec les drivers creative rapport a la latence?

karlkox

Disons que Creative fait du bon matos mais que niveau ingénierie logiciel, ils peuvent mieux faire, ce n'est pas à la hauteur du matos qu'ils font en tout cas.

gabuzomeuh2

bon bah moi en attendant je reécris comme tu as indiqué et je mettrais le nouveau code ici.

Ace17

J'aurais aime une reponse plus precise, car je fais de l'acquisition audio sur une carte creative avec une precision temporelle de l'ordre de la milliseconde avec un buffer de 96 echantillons, et ca marche plutot pas mal. Quelles sont les tares cachees du driver ?

karlkox

J'ai une Creative moi aussi et je tape dans du 2ms sans problème, ce n'est pas forcément un problème de latence mais un problème plus global : stabilité, grésillement possible, impossibilité de reprogrammer le spu sans passer par un sdk (qui n'est fournis que si on fait partis d'une grosse boite de dev).

Ace17

oui, maintenant que tu le dis, une fois sur dix environ, j'ai une acquisition qui foire, et a place du joli bip de reference que je suis cense enregistrer, j'ai des gresillements. Ca viendrait donc du driver ?

Publicité

karlkox

Le problème de grésillement est assez récurant chez Creative malheureusement SAUF sur la X-Fi Elite Pro (que j'ai).

gabuzomeuh2

Bonjour

Moi je ne comprends pas tres bien comment introduire CreateEvent, WaitForSingleObject, SetEvent, WHDR_DONE etc... dans mon code.

Quelqu'un peut il m'aider svp ?

merci

karlkox

Tu as ce qu'il te faut ici, ça utilise le WaveIn mais ça s'utilise exactement de la même manière pour le WaveOut.

gabuzomeuh2

est ce que j'ai le droit de traiter le MM_WIM_DATA et le MM_WOM_DONE par le meme thread ?

Message cité 1 fois

bjone

Insert booze to continue

le directsound serait pas moins pire que le WaveOut ?

parceque quand j'entends parler de grésillements, et que je vois que c'est une approche par message, j'ai peur

Message cité 1 fois

Ace17

bjone a écrit :

le directsound serait pas moins pire que le WaveOut ?

parceque quand j'entends parler de grésillements, et que je vois que c'est une approche par message, j'ai peur

Y'a aussi possibilite d'utiliser des vrais callbacks dans WaveOut

gabuzomeuh2

Ah bon ? ca peut etre interessant que tu modifies mon code pour montrer comment

merci

Ace17

La fonction waveOutOpen accepte comme dernier parametre
CALLBACK_FUNCTION au lieu de CALLBACK_THREAD. cf la msdn

gabuzomeuh2

oui je connais CALLBACK_FUNCTION mais le probleme est d'introduire et gerer le partage des ressources avec CreateEvent, WaitForSingleObject, SetEvent, WHDR_DONE etc.

breizhbugs

Je sais pas si c'est adéquat, mais il y a moyen de trouver des drivers ASIO pour les creatives sur le net...
http://forum.hardware.fr/hfr/Video [...] 8445_1.htm

Message édité par breizhbugs le 17-03-2007 à 11:28:57

karlkox

gabuzomeuh2 a écrit :

est ce que j'ai le droit de traiter le MM_WIM_DATA et le MM_WOM_DONE par le meme thread ?

Oui bien sûr, aucun problème.

bjone>ce n'est pas tant un problème de driver de sortie son mais un problème d'implémentation de celui ci, il suffit de faire abstraction du driver avant de s'attaquer vraiment à la partie API sonore (dsound, winmm, oal ...).
Perso, j'utilise les threads et aucun problème, ça m'a aussi permis de ne plus avoir ce problème de grésillement qui est dû à une mauvaise synchronisation entre la notification windows et le buffer à remplir.

breizhbugs>les pilotes ASIO font partis intégrante des pilotes. (CTASIO)

Message édité par karlkox le 17-03-2007 à 13:54:39

gabuzomeuh2

Voila j'ai tout réecrit. On dirait que ca marche.
Tu peux me dire ce que tu en penses KarLKox ?

Code :

#include <windows.h>
#include "stdafx.h"
#include "resource.h"
#include <mmsystem.h>
#include <malloc.h>
#define TAILLE_BLOC 4096
#define NB_BUFFER 3
#define CANAUX 2
#define OCTETS 2
#define BUFFER_SIZE CANAUX * OCTETS * TAILLE_BLOC
#define SAMPLERATE 44100
BOOL OpenedIn = FALSE;
HANDLE recordDone;
HWAVEIN hWaveIn;
DWORD threadidIn;
HANDLE RecordHandle;
PWAVEHDR pWaveHeaderIn[NB_BUFFER];
PBYTE pBufferIn[NB_BUFFER];
BOOL OpenedOut = FALSE;
HANDLE playDone;
HWAVEOUT hWaveOut;
DWORD threadidOut;
HANDLE PlayHandle;
PWAVEHDR pWaveHeaderOut[NB_BUFFER];
PBYTE pBufferOut[NB_BUFFER];
char Buffer[BUFFER_SIZE];
HWND DlgMain;
CRITICAL_SECTION CriticalSection;
//****************************************************************************
void copier_buffer(char dest[], char src[], long taille)
{
__asm
{
mov ecx, taille
cmp ecx, 0
je fin
mov edi, dest
mov esi, src
debut: mov al, [esi]
mov [edi], al
inc esi
inc edi
loop debut
fin:
}
}
//****************************************************************************
void CALLBACK waveInProc(HWAVEIN hwi, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
{
if (uMsg == WIM_OPEN)
{
MessageBox(DlgMain,"WIM_OPEN","RTA",MB_OK);
OpenedIn = TRUE;
}
if (uMsg == WIM_CLOSE)
{
MessageBox(DlgMain,"WIM_CLOSE","RTA",MB_OK);
}
if (uMsg == WIM_DATA)
{
SetEvent(recordDone);
}
}
//****************************************************************************
// 01 WHDR_DONE indique que c'est fini avec ce buffer.
// 02 WHDR_PREPARED indique que le buffer a ete prepare (waveInPrepareHeader ou waveOutPrepareHeader)
// 04 WHDR_BEGINLOOP indique que ce buffer est le premier dans une boucle, drapeau utilisé seulement en sortie.
// 08 WHDR_ENDLOOP indique que ce buffer est le dernier dans une boucle. Ce drapeau est utilisé seulement en sortie.
// 10 WHDR_INQUEUE indique que le buffer est mis en queue pour la sortie.
//****************************************************************************
DWORD WINAPI InThreadProc(LPVOID lpParam)
{
int i=0;
for(;;)
{
WaitForSingleObject(recordDone, INFINITE);
if (!(pWaveHeaderIn[i]->dwFlags & WHDR_DONE)) continue;
EnterCriticalSection(&CriticalSection );
copier_buffer(Buffer, pWaveHeaderIn[i]->lpData, BUFFER_SIZE); // sauvegarder bloc recu
LeaveCriticalSection(&CriticalSection );
waveInUnprepareHeader(hWaveIn, pWaveHeaderIn[i], sizeof(WAVEHDR));
pWaveHeaderIn[i]->dwFlags = 0;
waveInPrepareHeader(hWaveIn, pWaveHeaderIn[i], sizeof(WAVEHDR));
waveInAddBuffer(hWaveIn, pWaveHeaderIn[i], sizeof(WAVEHDR));
__asm
{
mov eax, i
mov ebx, NB_BUFFER
inc eax // i++
cmp eax, ebx // compare i et NB_BUFFER
jb fin1 // si i < NB_BUFFER goto fin1
xor eax, eax // si i = NB_BUFFER i=0
fin1: mov i, eax
}
}
waveInReset(hWaveIn);
waveInClose(hWaveIn);
MessageBox(DlgMain,"FIN","RTA",MB_OK);
OpenedIn = FALSE;
return 0;
}
//****************************************************************************
void CALLBACK waveOutProc(HWAVEOUT hwo, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
{
if (uMsg == WOM_OPEN)
{
MessageBox(DlgMain,"WOM_OPEN","RTA",MB_OK);
OpenedOut = TRUE;
}
if (uMsg == WOM_CLOSE)
{
MessageBox(DlgMain,"WOM_CLOSE","RTA",MB_OK);
}
if (uMsg == WOM_DONE)
{
SetEvent(playDone);
}
}
//****************************************************************************
DWORD WINAPI OutThreadProc(LPVOID lpParam)
{
int i=0;
for(;;)
{
WaitForSingleObject(playDone, INFINITE);
if (!(pWaveHeaderOut[i]->dwFlags & WHDR_DONE)) continue;
copier_buffer(pWaveHeaderOut[i]->lpData, Buffer, BUFFER_SIZE); // reprendre bloc recu
waveOutUnprepareHeader(hWaveOut, pWaveHeaderOut[i], sizeof(WAVEHDR));
pWaveHeaderOut[i]->dwFlags = 0;
waveOutPrepareHeader(hWaveOut, pWaveHeaderOut[i], sizeof(WAVEHDR));
waveOutWrite(hWaveOut, pWaveHeaderOut[i], sizeof(WAVEHDR));
__asm
{
mov eax, i
mov ebx, NB_BUFFER
inc eax // i++
cmp eax, ebx // compare i et NB_BUFFER
jb fin1 // si i < NB_BUFFER goto fin1
xor eax, eax // si i = NB_BUFFER i=0
fin1: mov i, eax
}
}
return 0;
}
//****************************************************************************
int openWaveDev()
{
int i;
WAVEFORMATEX WaveFormat;
WaveFormat.nChannels = CANAUX; // 1 pour mono 2 pour stereo
WaveFormat.wBitsPerSample = 8 * OCTETS; // 8 ou 16 bit
WaveFormat.nAvgBytesPerSec = SAMPLERATE * WaveFormat.nChannels * WaveFormat.wBitsPerSample/8; // nombre d'octets par seconde
WaveFormat.wFormatTag = 1; // 1 pour PCM
WaveFormat.nSamplesPerSec = SAMPLERATE; // frequence d'echantillonnage
WaveFormat.nBlockAlign = 1;
WaveFormat.cbSize = 0;
for(i=0; i<NB_BUFFER; i++)
{
pWaveHeaderIn[i] = (PWAVEHDR) malloc(sizeof(WAVEHDR));
pBufferIn[i] = (PBYTE)malloc(BUFFER_SIZE);
}
InitializeCriticalSection(&CriticalSection);
if (waveInOpen(&hWaveIn, WAVE_MAPPER, &WaveFormat, (DWORD)waveInProc, (DWORD)&CriticalSection, CALLBACK_FUNCTION))
{
MessageBox(DlgMain,"Ouverture périphérique d'entrée impossible","RTA",MB_OK);
return 0;
}
for(i=0; i<NB_BUFFER; i++)
{
pWaveHeaderIn[i]->lpData = (LPSTR)pBufferIn[i];
pWaveHeaderIn[i]->dwBufferLength = BUFFER_SIZE;
pWaveHeaderIn[i]->dwBytesRecorded = 0;
pWaveHeaderIn[i]->dwUser = 0;
pWaveHeaderIn[i]->dwFlags = 0;
pWaveHeaderIn[i]->dwLoops = 0;
pWaveHeaderIn[i]->lpNext = NULL;
pWaveHeaderIn[i]->reserved = 0;
}
for(i=0; i<NB_BUFFER; i++)
{
if (waveInPrepareHeader(hWaveIn, pWaveHeaderIn[i], sizeof(WAVEHDR)))
{
MessageBox(DlgMain,"Erreur PrepareHeader","RTA",MB_OK);
return 0;
}
}
for(i=0; i<NB_BUFFER; i++)
{
if (waveInAddBuffer(hWaveIn, pWaveHeaderIn[i], sizeof(WAVEHDR)))
{
MessageBox(DlgMain,"Erreur AddBuffer","RTA",MB_OK);
return 0;
}
}
ResetEvent(recordDone);
if (waveInStart(hWaveIn))
{
waveInClose(hWaveIn);
}
//****
for(i=0; i<NB_BUFFER; i++)
{
pWaveHeaderOut[i] = (PWAVEHDR) malloc(sizeof(WAVEHDR));
pBufferOut[i] = (PBYTE)malloc(BUFFER_SIZE);
}
if (waveOutOpen(&hWaveOut, WAVE_MAPPER, &WaveFormat, (DWORD)waveOutProc, 0L, CALLBACK_FUNCTION))
{
MessageBox(DlgMain,"Ouverture périphérique de sortie impossible","RTA",MB_OK);
return 0;
}
for(i=0; i<NB_BUFFER; i++)
{
pWaveHeaderOut[i]->lpData = (LPSTR)pBufferOut[i];
pWaveHeaderOut[i]->dwBufferLength = BUFFER_SIZE;
pWaveHeaderOut[i]->dwBytesRecorded = 0;
pWaveHeaderOut[i]->dwUser = 0;
pWaveHeaderOut[i]->dwFlags = 0;
pWaveHeaderOut[i]->dwLoops = 0;
pWaveHeaderOut[i]->lpNext = NULL;
pWaveHeaderOut[i]->reserved = 0;
}
for(i=0; i<NB_BUFFER; i++)
{
if (waveOutPrepareHeader(hWaveOut, pWaveHeaderOut[i], sizeof(WAVEHDR)))
{
MessageBox(DlgMain,"Erreur PrepareHeader","RTA",MB_OK);
return 0;
}
}
for(i=0; i<NB_BUFFER; i++)
{
if (waveOutWrite(hWaveOut, pWaveHeaderOut[i], sizeof(WAVEHDR)))
{
MessageBox(DlgMain,"Erreur OutWrite","RTA",MB_OK);
return 0;
}
}
ResetEvent(playDone);
//*******
return 0;
}
//****************************************************************************
BOOL CALLBACK DlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (msg == WM_INITDIALOG)
{
DlgMain = hWnd;
return 0;
}
if (msg == WM_COMMAND)
{
if (wParam == IDC_START)
{
if(OpenedIn == TRUE)
{
MessageBox(DlgMain,"Déjà ouvert","RTA",MB_OK);
return 0;
}
SetDlgItemText(DlgMain, IDC_STATIC1, "" );
recordDone = CreateEvent(0, FALSE, FALSE, 0);
ResetEvent(recordDone);
RecordHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) InThreadProc, NULL, 0, &threadidIn);
playDone = CreateEvent(0, FALSE, FALSE, 0);
ResetEvent(playDone);
PlayHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) OutThreadProc, NULL, 0, &threadidOut);
openWaveDev();
return 0;
}
if (wParam == IDCANCEL)
{
EndDialog(hWnd, 0);
return 0;
}
}
return 0;
}
//****************************************************************************
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
HANDLE hMutex;
hMutex = CreateMutex (NULL,FALSE, "RTA" );
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
MessageBox(NULL,"Ce programme est déjà en service !","WARNING",MB_OK|MB_ICONEXCLAMATION);
return 0;
}
DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1),HWND_DESKTOP,DlgProc);
return 0;
}
//****************************************************************************

Ace17

Pourquoi diable avoir mis de l'assembleur la dedans? Ensuite cherche du cote de l'instruction "movsb" et meme "rep movsb", ce que tu implementes via une boucle, le processeur sait deja le faire :-)
Et pour finir, un simple memcpy aurait fait l'affaire non?

karlkox

Ca me parait déjà plus clean et efficient, bon pour la boucle asm, en effet, un memcpy est aussi rapide donc pas besoin de passer par la, à la limite en simd (sse/sse2), histoire de copier plus de bloc par cycle.

gabuzomeuh2

En effet ca a l'air plus efficient et il n'y a plus d'interruption de processus quand la Fenetre est reduite ou restaurée.
Malgré tout, on dirait que le InThreadPRoc et OutThreadProc finissent par se marcher dessus au bout d'un cerain nombre de tours. Qqn a une solution ?

gabuzomeuh2

J'aimerai mettre le traitement de WIM_DATA et WOM_DONE dans le mm thread.

Publicité

FORUM HardWare.fr

Programmation

C++

moteur audio

Sujets relatifs
[Audio][C++] Quelle librairie utiliser pour générer des sons ?	Booleen sur Moteur de Recherche ... c'est du SQL ?
moteur de recherche et Flash (UTF8)	Choix d'un moteur 3D
Moteur de recherche de bureau (Desktop Search Engine)	liens audio dans un texte
[PHP/MySQL] Je sers la Science (moteur cataloguage recherche pdf)	synchronisation de la capture audio sur une source de temps externe
Moteur de recherche interne	moteur de recherche sans pub
Plus de sujets relatifs à : moteur audio

Page générée en 0.103 secondes