moteur audio

moteur audio - C++ - Programmation

Marsh Posté le 14-03-2007 à 15:07:19    

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 :
  1. #include <windows.h>
  2. #include "stdafx.h"
  3. #include "resource.h"
  4. #include <mmsystem.h>
  5. #include <malloc.h>
  6. #include <stdio.h>
  7. #include <commctrl.h>
  9. #define BUFFER_SIZE 16384
  10. #define SAMPLERATE 44100
  11. #define CANAUX 2
  12. #define OCTETS 2
  14. HWND DlgMain;
  15. PBYTE Buffer;
  16. HWAVEIN hWaveIn;
  17. HWAVEOUT hWaveOut;
  18. PBYTE pBufferIn1, pBufferIn2, pBufferIn3, pBufferOut1, pBufferOut2, pBufferOut3;
  19. PWAVEHDR pWaveHdrIn1, pWaveHdrIn2, pWaveHdrIn3, pWaveHdrOut1, pWaveHdrOut2, pWaveHdrOut3;
  20. WAVEFORMATEX waveform;
  21. BOOL flag_in_open = FALSE;
  22. BOOL flag_out_open = FALSE;
  24. HANDLE WorkerThreadHandleIn;
  25. DWORD WorkerThreadIdIn;
  26. HANDLE WorkerThreadHandleOut;
  27. DWORD WorkerThreadIdOut;
  29. //****************************************************************************
  31. DWORD WINAPI WorkerThreadProcIn (void *Arg)
  32. {
  33.   SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_TIME_CRITICAL);
  34.   MSG Msg;
  36.   while (GetMessage (&Msg, NULL, 0, 0) == TRUE)
  37.    {
  38.     switch (Msg.message)
  39.      {
  40.       case MM_WIM_OPEN:
  41.        {
  42.         MessageBox(DlgMain,"In open","RTA",MB_OK);
  43.         flag_in_open = TRUE;
  44.         waveInAddBuffer(hWaveIn,pWaveHdrIn1,sizeof(WAVEHDR));
  45.         waveInAddBuffer(hWaveIn,pWaveHdrIn2,sizeof(WAVEHDR));
  46.         waveInAddBuffer(hWaveIn,pWaveHdrIn3,sizeof(WAVEHDR));
  47.         waveInStart(hWaveIn);   
  48.         break;
  49.        }
  51.       case MM_WIM_DATA:
  52.        {
  53.         WAVEHDR *Hdr = (WAVEHDR *)Msg.lParam;
  54.         CopyMemory(Buffer,Hdr->lpData,BUFFER_SIZE);
  55.         waveInAddBuffer (hWaveIn, Hdr, sizeof (*Hdr));
  56.         break;
  57.        }
  58.      }
  59.    }
  60.   return 0;  
  61. }
  63. //****************************************************************************
  65. DWORD WINAPI WorkerThreadProcOut (void *Arg)
  66. {
  67.   SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_TIME_CRITICAL);
  68.   MSG Msg;
  70.   while (GetMessage (&Msg, NULL, 0, 0) == TRUE)
  71.    {
  72.     switch (Msg.message)
  73.      {
  74.       case MM_WOM_OPEN:
  75.        {
  76.         MessageBox(DlgMain,"Out open","RTA",MB_OK);
  77.         flag_out_open = TRUE;
  78.         waveOutPrepareHeader(hWaveOut,pWaveHdrOut1,sizeof(WAVEHDR));
  79.         waveOutWrite(hWaveOut,pWaveHdrOut1,sizeof(WAVEHDR));
  80.         waveOutPrepareHeader(hWaveOut,pWaveHdrOut2,sizeof(WAVEHDR));
  81.         waveOutWrite(hWaveOut,pWaveHdrOut2,sizeof(WAVEHDR));
  82.         waveOutPrepareHeader(hWaveOut,pWaveHdrOut3,sizeof(WAVEHDR));
  83.         waveOutWrite(hWaveOut,pWaveHdrOut3,sizeof(WAVEHDR));
  84.         break;
  85.        }
  87.       case MM_WOM_DONE:
  88.        {
  89.         WAVEHDR *Hdr = (WAVEHDR *)Msg.lParam;
  90.         waveOutPrepareHeader (hWaveOut, Hdr, sizeof (*Hdr));
  91.         waveOutWrite (hWaveOut, Hdr, sizeof (*Hdr));
  92.         CopyMemory(Hdr->lpData,Buffer,BUFFER_SIZE);
  93.         break;
  94.        }
  95.      }
  96.    }
  97.   return 0;  
  98. }
  100. //****************************************************************************
  102. BOOL CALLBACK DlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  103. {   
  106.   static int volume_general;
  108.   if (msg == WM_INITDIALOG)
  109.    {
  110.     DlgMain = hWnd;
  111.     return 0;
  112.    }
  120.   if (msg == WM_COMMAND)
  121.    {
  122.     if (wParam == ID_START)
  123.      {
  124.       if(flag_in_open == TRUE)
  125.        {
  126.         MessageBox(hWnd,"périphérique déjà ouvert","Erreur",0);
  127.         return 0;
  128.        }
  129.        
  130.       WorkerThreadHandleIn = CreateThread (NULL, 0, WorkerThreadProcIn, NULL, 0, &WorkerThreadIdIn );
  131.       WorkerThreadHandleOut = CreateThread (NULL, 0, WorkerThreadProcOut, NULL, 0, &WorkerThreadIdOut );
  132.       pWaveHdrIn1 = (PWAVEHDR) malloc(sizeof(WAVEHDR));
  133.       pWaveHdrIn2 = (PWAVEHDR) malloc(sizeof(WAVEHDR));
  134.       pWaveHdrIn3 = (PWAVEHDR) malloc(sizeof(WAVEHDR));
  135.       pWaveHdrOut1 = (PWAVEHDR) malloc(sizeof(WAVEHDR));
  136.       pWaveHdrOut2 = (PWAVEHDR) malloc(sizeof(WAVEHDR));
  137.       pWaveHdrOut3 = (PWAVEHDR) malloc(sizeof(WAVEHDR));
  138.        
  139.       Buffer   = (PBYTE)malloc(BUFFER_SIZE);
  140.       pBufferIn1 = (PBYTE)malloc(BUFFER_SIZE);
  141.       pBufferIn2 = (PBYTE)malloc(BUFFER_SIZE);
  142.       pBufferIn3 = (PBYTE)malloc(BUFFER_SIZE);
  143.       pBufferOut1 = (PBYTE)malloc(BUFFER_SIZE);
  144.       pBufferOut2 = (PBYTE)malloc(BUFFER_SIZE);
  145.       pBufferOut3 = (PBYTE)malloc(BUFFER_SIZE);
  146.      
  147.       if(!pBufferIn1 || !pBufferIn2 || !pBufferIn3 || !pBufferOut1 || !pBufferOut2 || !pBufferOut3)
  148.        {
  149.         if(pBufferIn1) free (pBufferIn1);
  150.         if(pBufferIn2) free (pBufferIn2);
  151.         if(pBufferIn3) free (pBufferIn3);
  152.         if(pBufferOut1) free (pBufferOut1);
  153.         if(pBufferOut2) free (pBufferOut2);
  154.         if(pBufferOut3) free (pBufferOut3);
  155.         MessageBox(hWnd,"Erreur d'allocation de mémoire","Erreur",0);
  156.         return TRUE;
  157.        }     
  158.      
  159.       waveform.nChannels = CANAUX; // 1 pour mono 2 pour stereo
  160.       waveform.wBitsPerSample = 8 * OCTETS; // 8 ou 16 bit
  161.       waveform.nAvgBytesPerSec = SAMPLERATE * waveform.nChannels * waveform.wBitsPerSample/8; // nombre d'octets par seconde
  162.       waveform.wFormatTag = 1; // 1 pour PCM
  163.       waveform.nSamplesPerSec = SAMPLERATE; // frequence d'echantillonnage
  164.       waveform.nBlockAlign = 1;
  165.       waveform.cbSize = 0;
  167.       if(waveInOpen(&hWaveIn,WAVE_MAPPER,&waveform,(DWORD)WorkerThreadIdIn,0,CALLBACK_THREAD))
  168.        {
  169.         free(pBufferIn1);
  170.         free(pBufferIn2);
  171.         free(pBufferIn3);
  172.         MessageBox(hWnd,"ouverture du périphérique d'entrée impossible","WARNING",MB_OK);
  173.         return 0;
  174.        }
  176.       pWaveHdrIn1->lpData          = (LPSTR)pBufferIn1;
  177.       pWaveHdrIn1->dwBufferLength  = BUFFER_SIZE;
  178.       pWaveHdrIn1->dwBytesRecorded = 0;
  179.       pWaveHdrIn1->dwUser          = 0;
  180.       pWaveHdrIn1->dwFlags         = 0;
  181.       pWaveHdrIn1->dwLoops         = 0;
  182.       pWaveHdrIn1->lpNext          = NULL;
  183.       pWaveHdrIn1->reserved        = 0;     
  184.       waveInPrepareHeader(hWaveIn,pWaveHdrIn1,sizeof(WAVEHDR));
  185.      
  186.       pWaveHdrIn2->lpData          = (LPSTR)pBufferIn2;
  187.       pWaveHdrIn2->dwBufferLength  = BUFFER_SIZE;
  188.       pWaveHdrIn2->dwBytesRecorded = 0;
  189.       pWaveHdrIn2->dwUser          = 0;
  190.       pWaveHdrIn2->dwFlags         = 0;
  191.       pWaveHdrIn2->dwLoops         = 0;
  192.       pWaveHdrIn2->lpNext          = NULL;
  193.       pWaveHdrIn2->reserved        = 0;     
  194.       waveInPrepareHeader(hWaveIn,pWaveHdrIn2,sizeof(WAVEHDR));
  196.       pWaveHdrIn3->lpData          = (LPSTR)pBufferIn3;
  197.       pWaveHdrIn3->dwBufferLength  = BUFFER_SIZE;
  198.       pWaveHdrIn3->dwBytesRecorded = 0;
  199.       pWaveHdrIn3->dwUser          = 0;
  200.       pWaveHdrIn3->dwFlags         = 0;
  201.       pWaveHdrIn3->dwLoops         = 0;
  202.       pWaveHdrIn3->lpNext          = NULL;
  203.       pWaveHdrIn3->reserved        = 0;     
  204.       waveInPrepareHeader(hWaveIn,pWaveHdrIn3,sizeof(WAVEHDR));       
  206.       if(waveOutOpen(&hWaveOut,WAVE_MAPPER,&waveform,(DWORD)WorkerThreadIdOut,0,CALLBACK_THREAD))
  207.        {
  208.         free(pBufferOut1);
  209.         free(pBufferOut2);
  210.         free(pBufferOut3);
  211.         MessageBox(hWnd,"ouverture du périphérique de sortie impossible","WARNING",MB_OK);
  212.         return 0;
  213.        }     
  215.       pWaveHdrOut1->lpData = (LPSTR)pBufferOut1;
  216.       pWaveHdrOut1->dwBufferLength = BUFFER_SIZE;
  217.       pWaveHdrOut1->dwBytesRecorded = 0;
  218.       pWaveHdrOut1->dwUser = 0;
  219.       pWaveHdrOut1->dwFlags = 0;
  220.       pWaveHdrOut1->dwLoops = 0;
  221.       pWaveHdrOut1->lpNext = NULL;
  222.       pWaveHdrOut1->reserved = 0;     
  223.       waveOutPrepareHeader(hWaveOut,pWaveHdrOut1,sizeof(WAVEHDR));
  224.      
  225.       pWaveHdrOut2->lpData = (LPSTR)pBufferOut2;
  226.       pWaveHdrOut2->dwBufferLength = BUFFER_SIZE;
  227.       pWaveHdrOut2->dwBytesRecorded = 0;
  228.       pWaveHdrOut2->dwUser = 0;
  229.       pWaveHdrOut2->dwFlags = 0;
  230.       pWaveHdrOut2->dwLoops = 0;
  231.       pWaveHdrOut2->lpNext = NULL;
  232.       pWaveHdrOut2->reserved = 0;     
  233.       waveOutPrepareHeader(hWaveOut,pWaveHdrOut2,sizeof(WAVEHDR));
  234.      
  235.       pWaveHdrOut3->lpData =(LPSTR)pBufferOut3;
  236.       pWaveHdrOut3->dwBufferLength =BUFFER_SIZE;
  237.       pWaveHdrOut3->dwBytesRecorded =0;
  238.       pWaveHdrOut3->dwUser =0;
  239.       pWaveHdrOut3->dwFlags =0;
  240.       pWaveHdrOut3->dwLoops =0;
  241.       pWaveHdrOut3->lpNext =NULL;
  242.       pWaveHdrOut3->reserved =0;     
  243.       waveOutPrepareHeader(hWaveOut,pWaveHdrOut3,sizeof(WAVEHDR));       
  245.       return 0;
  246.      }
  248.     if (wParam == IDCANCEL)
  249.      {
  250.       if(MessageBox(hWnd, "Voulez-vous vraiment arrêter l'application en cours ?", "Real Time Audio",MB_YESNO|MB_ICONEXCLAMATION|MB_DEFBUTTON2) == IDNO)
  251.        {
  252.         return TRUE;
  253.        }
  254.       EndDialog(hWnd, 0);
  255.       return 0;
  256.      }
  257.    }
  261.   return 0;
  262. }
  264. //****************************************************************************
  265.  
  266. int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
  267. {
  268.   InitCommonControls();
  269.   DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1),HWND_DESKTOP,DlgProc);
  270.   return 0;
  271. }
  273. //****************************************************************************

Reply

Marsh Posté le 14-03-2007 à 15:07:19   

Reply

Marsh Posté le 14-03-2007 à 18:58:48    

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
Reply

Marsh Posté le 14-03-2007 à 20:53:39    

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.


Reply

Marsh Posté le 14-03-2007 à 21:57:01    

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 ...)

Reply

Marsh Posté le 14-03-2007 à 22:10:27    

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

Reply

Marsh Posté le 14-03-2007 à 22:31:40    

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.

Reply

Marsh Posté le 14-03-2007 à 22:33:45    

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

Reply

Marsh Posté le 14-03-2007 à 22:41:39    

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 ?

Reply

Marsh Posté le 14-03-2007 à 22:56:31    

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).

Reply

Marsh Posté le 14-03-2007 à 23:00:01    

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 ?

Reply

Marsh Posté le 14-03-2007 à 23:00:01   

Reply

Marsh Posté le 14-03-2007 à 23:11:15    

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

Reply

Marsh Posté le 16-03-2007 à 21:41:57    

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

Reply

Marsh Posté le 16-03-2007 à 23:24:40    

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.

Reply

Marsh Posté le 16-03-2007 à 23:31:55    

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
Reply

Marsh Posté le 16-03-2007 à 23:37:24    

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 :D

Message cité 1 fois
Reply

Marsh Posté le 17-03-2007 à 07:16:21    

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 :D


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

Reply

Marsh Posté le 17-03-2007 à 07:18:11    

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

Reply

Marsh Posté le 17-03-2007 à 07:25:40    

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

Reply

Marsh Posté le 17-03-2007 à 07:28:05    

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

Reply

Marsh Posté le 17-03-2007 à 11:26:45    

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
Reply

Marsh Posté le 17-03-2007 à 13:54:13    

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
Reply

Marsh Posté le 25-03-2007 à 05:35:05    

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

Code :
  1. #include <windows.h>
  2. #include "stdafx.h"
  3. #include "resource.h"
  4. #include <mmsystem.h>
  5. #include <malloc.h>
  7. #define TAILLE_BLOC   4096
  8. #define NB_BUFFER     3
  9. #define CANAUX        2
  10. #define OCTETS        2
  11. #define BUFFER_SIZE   CANAUX * OCTETS * TAILLE_BLOC
  12. #define SAMPLERATE    44100
  14. BOOL OpenedIn = FALSE;
  15. HANDLE recordDone;
  16. HWAVEIN hWaveIn;
  17. DWORD threadidIn;
  18. HANDLE RecordHandle;
  19. PWAVEHDR pWaveHeaderIn[NB_BUFFER];
  20. PBYTE pBufferIn[NB_BUFFER];
  22. BOOL OpenedOut = FALSE;
  23. HANDLE playDone;
  24. HWAVEOUT hWaveOut;
  25. DWORD threadidOut;
  26. HANDLE PlayHandle;
  27. PWAVEHDR pWaveHeaderOut[NB_BUFFER];
  28. PBYTE pBufferOut[NB_BUFFER];
  30. char Buffer[BUFFER_SIZE];
  32. HWND DlgMain;
  34. CRITICAL_SECTION CriticalSection;
  36. //****************************************************************************
  38. void copier_buffer(char dest[], char src[], long taille)
  39. {
  40.   __asm
  41.    {
  42.        mov  ecx,   taille
  43.        cmp  ecx,   0
  44.        je   fin
  45.        mov  edi,   dest
  46.        mov  esi,   src
  47. debut: mov  al,    [esi]
  48.        mov  [edi], al
  49.        inc  esi
  50.        inc  edi
  51.        loop debut
  52. fin:       
  53.    }
  54. }
  56. //****************************************************************************
  58. void CALLBACK waveInProc(HWAVEIN hwi, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
  59. {
  60.   if (uMsg == WIM_OPEN)
  61.    {
  62.     MessageBox(DlgMain,"WIM_OPEN","RTA",MB_OK);
  63.     OpenedIn = TRUE;
  64.    }
  66.   if (uMsg == WIM_CLOSE)
  67.    {
  68.     MessageBox(DlgMain,"WIM_CLOSE","RTA",MB_OK);
  69.    }
  71.   if (uMsg == WIM_DATA)  
  72.    {
  73.     SetEvent(recordDone);     
  74.    }
  75. }
  77. //****************************************************************************
  78. // 01 WHDR_DONE      indique que c'est fini avec ce buffer.
  79. // 02 WHDR_PREPARED  indique que le buffer a ete prepare (waveInPrepareHeader ou waveOutPrepareHeader)
  80. // 04 WHDR_BEGINLOOP indique que ce buffer est le premier dans une boucle, drapeau utilisé seulement en sortie.
  81. // 08 WHDR_ENDLOOP   indique que ce buffer est le dernier dans une boucle. Ce drapeau est utilisé seulement en sortie.
  82. // 10 WHDR_INQUEUE   indique que le buffer est mis en queue pour la sortie.
  83. //****************************************************************************
  85. DWORD WINAPI InThreadProc(LPVOID lpParam)
  86. {   
  87.   int i=0;
  89.   for(;;)
  90.    {
  91.     WaitForSingleObject(recordDone, INFINITE);
  92.     if (!(pWaveHeaderIn[i]->dwFlags & WHDR_DONE)) continue;
  93.      
  94.     EnterCriticalSection(&CriticalSection );
  95.      
  96.     copier_buffer(Buffer, pWaveHeaderIn[i]->lpData, BUFFER_SIZE); // sauvegarder bloc recu
  97.      
  98.     LeaveCriticalSection(&CriticalSection );
  100.     waveInUnprepareHeader(hWaveIn, pWaveHeaderIn[i], sizeof(WAVEHDR));
  101.     pWaveHeaderIn[i]->dwFlags = 0;
  102.     waveInPrepareHeader(hWaveIn, pWaveHeaderIn[i], sizeof(WAVEHDR));
  103.     waveInAddBuffer(hWaveIn, pWaveHeaderIn[i], sizeof(WAVEHDR));
  105.     __asm
  106.      {
  107.       mov eax, i
  108.       mov ebx, NB_BUFFER
  109.       inc eax            // i++
  110.       cmp eax, ebx       // compare i et NB_BUFFER
  111.       jb  fin1           // si i < NB_BUFFER goto fin1
  112.       xor eax, eax       // si i = NB_BUFFER i=0
  113. fin1: mov i,   eax
  114.      }
  116.    }
  117.   waveInReset(hWaveIn);
  118.   waveInClose(hWaveIn);
  119.   MessageBox(DlgMain,"FIN","RTA",MB_OK);
  120.   OpenedIn = FALSE;
  121.   return 0;
  122. }
  124. //****************************************************************************
  126. void CALLBACK waveOutProc(HWAVEOUT hwo, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
  127. {
  128.   if (uMsg == WOM_OPEN)
  129.    {
  130.     MessageBox(DlgMain,"WOM_OPEN","RTA",MB_OK);
  131.     OpenedOut = TRUE;
  132.    }
  134.   if (uMsg == WOM_CLOSE)
  135.    {
  136.     MessageBox(DlgMain,"WOM_CLOSE","RTA",MB_OK);
  137.    }
  139.   if (uMsg == WOM_DONE)  
  140.    {
  141.     SetEvent(playDone);     
  142.    }
  143. }
  145. //****************************************************************************
  147. DWORD WINAPI OutThreadProc(LPVOID lpParam)
  148. {   
  149.   int i=0;
  151.   for(;;)
  152.    {
  153.     WaitForSingleObject(playDone, INFINITE);     
  155.     if (!(pWaveHeaderOut[i]->dwFlags & WHDR_DONE)) continue;
  156.      
  157.     copier_buffer(pWaveHeaderOut[i]->lpData, Buffer, BUFFER_SIZE); // reprendre bloc recu
  158.     waveOutUnprepareHeader(hWaveOut, pWaveHeaderOut[i], sizeof(WAVEHDR));
  159.     pWaveHeaderOut[i]->dwFlags = 0;
  160.     waveOutPrepareHeader(hWaveOut, pWaveHeaderOut[i], sizeof(WAVEHDR));
  161.     waveOutWrite(hWaveOut, pWaveHeaderOut[i], sizeof(WAVEHDR));
  163.     __asm
  164.      {
  165.       mov eax, i
  166.       mov ebx, NB_BUFFER
  167.       inc eax            // i++
  168.       cmp eax, ebx       // compare i et NB_BUFFER
  169.       jb  fin1           // si i < NB_BUFFER goto fin1
  170.       xor eax, eax       // si i = NB_BUFFER i=0
  171. fin1: mov i,   eax
  172.      }
  175.    }
  176.   return 0;
  177. }
  179. //****************************************************************************
  181. int openWaveDev()
  182. {
  183.   int i;
  184.   WAVEFORMATEX WaveFormat;
  185.    
  186.   WaveFormat.nChannels = CANAUX; // 1 pour mono 2 pour stereo
  187.   WaveFormat.wBitsPerSample = 8 * OCTETS; // 8 ou 16 bit
  188.   WaveFormat.nAvgBytesPerSec = SAMPLERATE * WaveFormat.nChannels * WaveFormat.wBitsPerSample/8; // nombre d'octets par seconde
  189.   WaveFormat.wFormatTag = 1; // 1 pour PCM
  190.   WaveFormat.nSamplesPerSec = SAMPLERATE; // frequence d'echantillonnage
  191.   WaveFormat.nBlockAlign = 1;
  192.   WaveFormat.cbSize = 0;
  194.   for(i=0; i<NB_BUFFER; i++)
  195.    {
  196.     pWaveHeaderIn[i] = (PWAVEHDR) malloc(sizeof(WAVEHDR));
  197.     pBufferIn[i] = (PBYTE)malloc(BUFFER_SIZE);
  198.    }
  199.    
  200.   InitializeCriticalSection(&CriticalSection);
  202.   if (waveInOpen(&hWaveIn, WAVE_MAPPER, &WaveFormat, (DWORD)waveInProc, (DWORD)&CriticalSection, CALLBACK_FUNCTION))
  203.    {
  204.     MessageBox(DlgMain,"Ouverture périphérique d'entrée impossible","RTA",MB_OK);
  205.     return 0;
  206.    }
  208.   for(i=0; i<NB_BUFFER; i++)
  209.    {
  210.     pWaveHeaderIn[i]->lpData          = (LPSTR)pBufferIn[i];
  211.     pWaveHeaderIn[i]->dwBufferLength  = BUFFER_SIZE;
  212.     pWaveHeaderIn[i]->dwBytesRecorded = 0;
  213.     pWaveHeaderIn[i]->dwUser          = 0;
  214.     pWaveHeaderIn[i]->dwFlags         = 0;
  215.     pWaveHeaderIn[i]->dwLoops         = 0;
  216.     pWaveHeaderIn[i]->lpNext          = NULL;
  217.     pWaveHeaderIn[i]->reserved        = 0;
  218.    }
  220.   for(i=0; i<NB_BUFFER; i++)
  221.    {
  222.     if (waveInPrepareHeader(hWaveIn, pWaveHeaderIn[i], sizeof(WAVEHDR)))
  223.      {
  224.       MessageBox(DlgMain,"Erreur PrepareHeader","RTA",MB_OK);
  225.       return 0;
  226.      }
  227.    }
  229.   for(i=0; i<NB_BUFFER; i++)
  230.    {
  231.     if (waveInAddBuffer(hWaveIn, pWaveHeaderIn[i], sizeof(WAVEHDR)))
  232.      {
  233.       MessageBox(DlgMain,"Erreur AddBuffer","RTA",MB_OK);
  234.       return 0;
  235.      }
  236.    }
  238.   ResetEvent(recordDone);
  240.   if (waveInStart(hWaveIn))
  241.    {
  242.     waveInClose(hWaveIn);
  243.    }
  247. //****
  248.   for(i=0; i<NB_BUFFER; i++)
  249.    {
  250.     pWaveHeaderOut[i] = (PWAVEHDR) malloc(sizeof(WAVEHDR));
  251.     pBufferOut[i] = (PBYTE)malloc(BUFFER_SIZE);
  252.    }
  254.   if (waveOutOpen(&hWaveOut, WAVE_MAPPER, &WaveFormat, (DWORD)waveOutProc, 0L, CALLBACK_FUNCTION))
  255.    {
  256.     MessageBox(DlgMain,"Ouverture périphérique de sortie impossible","RTA",MB_OK);
  257.     return 0;
  258.    }
  260.   for(i=0; i<NB_BUFFER; i++)
  261.    {
  262.     pWaveHeaderOut[i]->lpData          = (LPSTR)pBufferOut[i];
  263.     pWaveHeaderOut[i]->dwBufferLength  = BUFFER_SIZE;
  264.     pWaveHeaderOut[i]->dwBytesRecorded = 0;
  265.     pWaveHeaderOut[i]->dwUser          = 0;
  266.     pWaveHeaderOut[i]->dwFlags         = 0;
  267.     pWaveHeaderOut[i]->dwLoops         = 0;
  268.     pWaveHeaderOut[i]->lpNext          = NULL;
  269.     pWaveHeaderOut[i]->reserved        = 0;
  270.    }
  272.   for(i=0; i<NB_BUFFER; i++)
  273.    {
  274.     if (waveOutPrepareHeader(hWaveOut, pWaveHeaderOut[i], sizeof(WAVEHDR)))
  275.      {
  276.       MessageBox(DlgMain,"Erreur PrepareHeader","RTA",MB_OK);
  277.       return 0;
  278.      }
  279.    }
  281.   for(i=0; i<NB_BUFFER; i++)
  282.    {
  283.     if (waveOutWrite(hWaveOut, pWaveHeaderOut[i], sizeof(WAVEHDR)))
  284.      {
  285.       MessageBox(DlgMain,"Erreur OutWrite","RTA",MB_OK);
  286.       return 0;
  287.      }
  288.    }
  289.   ResetEvent(playDone);
  290. //*******
  293.   return 0;
  294. }
  296. //****************************************************************************
  298. BOOL CALLBACK DlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  299. {
  300.   if (msg == WM_INITDIALOG)
  301.    {
  302.     DlgMain = hWnd;
  303.     return 0;
  304.    }
  305.    
  306.    
  307.    
  308.    
  309.   if (msg == WM_COMMAND)
  310.    {
  311.     if (wParam == IDC_START)
  312.      {
  313.       if(OpenedIn == TRUE)
  314.        {       
  315.         MessageBox(DlgMain,"Déjà ouvert","RTA",MB_OK);
  316.         return 0;
  317.        }       
  318.       SetDlgItemText(DlgMain, IDC_STATIC1, "" );
  320.       recordDone = CreateEvent(0, FALSE, FALSE, 0);
  321.       ResetEvent(recordDone);
  322.       RecordHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) InThreadProc, NULL, 0, &threadidIn);
  324.       playDone = CreateEvent(0, FALSE, FALSE, 0);
  325.       ResetEvent(playDone);
  326.       PlayHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) OutThreadProc, NULL, 0, &threadidOut);
  328.       openWaveDev();       
  329.       return 0;
  330.      }
  331.    
  332.   if (wParam == IDCANCEL)
  333.      {
  334.       EndDialog(hWnd, 0);
  335.       return 0;
  336.      }
  337.    }
  342.   return 0;
  343. }
  345. //****************************************************************************
  346.  
  347. int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
  348. {
  349.   HANDLE hMutex;
  350.   hMutex = CreateMutex (NULL,FALSE, "RTA" );
  351.   if (GetLastError() == ERROR_ALREADY_EXISTS)
  352.    {
  353.     MessageBox(NULL,"Ce programme est déjà en service !","WARNING",MB_OK|MB_ICONEXCLAMATION);
  354.     return 0;
  355.    }
  357.   DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1),HWND_DESKTOP,DlgProc);
  358.   return 0;
  359. }
  361. //****************************************************************************

Reply

Marsh Posté le 25-03-2007 à 17:59:14    

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?

Reply

Marsh Posté le 25-03-2007 à 21:05:02    

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.

Reply

Marsh Posté le 25-03-2007 à 21:59:59    

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 ?

Reply

Marsh Posté le 25-03-2007 à 22:01:35    

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

Reply

Marsh Posté le    

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed