Windows, c++ et wav

Windows, c++ et wav - Programmation

Marsh Posté le 12-11-2001 à 22:41:57    

J'aimerais savoir comment on fait pour jouer un fichier wav. J'ai regardé whotsit.org, g trouvé ce que cherchais mais je comprend pas énormément de trucs vu que c'est assez énorme. En plus y'a juste le format et pas le code en c++ pour le lire... Ouais faut pas rêver...
Mais j'aimerais bien pouvoir faire ça et vu que c'est pas une priorité, j'aimerais bien ne pas avoir à me casser le cerveau en 2...
Merci

Reply

Marsh Posté le 12-11-2001 à 22:41:57   

Reply

Marsh Posté le 13-11-2001 à 01:36:41    

Adapté depuis des routines de gdmag :
 
PlayWav.h
 

Code :
  1. // PlayWav.h
  3. // Utilisation :
  4. // CloseSound()
  5. // InitSound(hwnd)
  6. // int wavnum= LoadWav("c:\son.wav" )
  7. // ...
  8. // et dans ta boucle principale : PlayWav(wavnum)
  11. #include <Win32Headers++.pch++>
  12. #include <windows.h>
  14. bool InitSound(HWND hwnd);
  15. int LoadWav(char * name);
  16. void PlayWav(int nsnd);
  17. void CloseSound();


 
 
 
 
 
 
 
PlayWav.cpp
 

Code :
  1. // PlayWav.cpp
  3. #include <dsound.h>
  4. #include <stdlib.h>
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <malloc.h>
  8. #include "PlayWav.h"
  11. LPDIRECTSOUND lpDS;
  12. const int MaxStreams=32; // voies disponibles
  13. const int MaxSounds=512;     // sons charges en memoire  
  15. static bool IsAvailable=false;
  17. HRESULT CreatDSBuffer(LPDIRECTSOUND lpDS, LPDIRECTSOUNDBUFFER * lplpDSB, DWORD SoundBytes,
  18.      DWORD frequence, int isStereo, int is16bit);
  20. HRESULT CreatDSBuffer(LPDIRECTSOUND lpDS, LPDIRECTSOUNDBUFFER * lplpDSB, DWORD SoundBytes,
  21.      DWORD frequence, int isStereo, int is16bit)
  22. {
  23. DSBUFFERDESC dsbd;
  24. PCMWAVEFORMAT fmt;
  25. fmt.wf.nChannels=(isStereo)?2:1;
  26. fmt.wBitsPerSample=(is16bit)?16:8;
  27. fmt.wf.nSamplesPerSec=frequence;
  28. fmt.wf.nBlockAlign=fmt.wf.nChannels*(fmt.wBitsPerSample>>3);
  29. fmt.wf.nAvgBytesPerSec=fmt.wf.nSamplesPerSec*fmt.wf.nBlockAlign;
  30. fmt.wf.wFormatTag=WAVE_FORMAT_PCM;
  31. memset(&dsbd, 0, sizeof(dsbd));
  32. dsbd.lpwfxFormat=(LPWAVEFORMATEX)&fmt;
  33. dsbd.dwSize=sizeof(DSBUFFERDESC);
  34. dsbd.dwBufferBytes=SoundBytes;
  35. dsbd.dwFlags=0;
  36. return (lpDS->CreateSoundBuffer(&dsbd, lplpDSB, 0));
  37. }
  39. HRESULT LoadSoundData(LPDIRECTSOUNDBUFFER lpDSB, char * SoundDataPtr, DWORD TotalBytes);
  40. HRESULT LoadSoundData(LPDIRECTSOUNDBUFFER lpDSB, char * SoundDataPtr, DWORD TotalBytes)
  41. {
  42. LPVOID ptr1,ptr2;
  43. DWORD len1,len2;
  44. HRESULT result;
  45. TryLockAgainLabel:
  46. result=lpDSB->Lock(0,TotalBytes, &ptr1, &len1, &ptr2, & len2, 0);
  47. switch(result)
  48. {
  49.  case DS_OK:
  50.   memcpy(ptr1, SoundDataPtr, len1);
  51.   if(ptr2)
  52.    memcpy(ptr2, SoundDataPtr+len1, len2);
  53.   lpDSB->Unlock(ptr1, len1, ptr2, len2);
  54.   break;
  55.  case DSERR_BUFFERLOST:
  56.   result=lpDSB->Restore();
  57.   if (result==DS_OK)
  58.    goto TryLockAgainLabel ;
  59.   break;
  60. }
  61. return result;
  62. }
  64. typedef struct DSSTREAMTAG
  65. {
  66. int Playing, PleaseClose;
  67. char * CurrentPosition;
  68. DWORD BytesLeft, NoCallbacks, HalfBufferPoint, LastHalf;
  69. int CloseOnNext;
  70. LPDIRECTSOUNDBUFFER lpDSB;
  71. char SilenceByte;
  72. } DSSTREAM;
  74. static void StreamCopy(DSSTREAM * s, char * ptr, DWORD len)
  75. {
  76. DWORD amt;
  77. amt=(len>s->BytesLeft)?s->BytesLeft:len;
  78. if (amt)
  79. {
  80.  memcpy(ptr,s->CurrentPosition, amt);
  81.  s->CurrentPosition+=amt;
  82.  s->BytesLeft-=amt;
  83. }
  84. len-=amt;
  85. if(len)
  86. {
  87.  memset(ptr+amt, s->SilenceByte, len);
  88.  s->CloseOnNext=1;
  89. }
  90. }
  92. static void StreamFillAHalf(DSSTREAM * s, DWORD Half)
  93. {
  94. char* ptr1, *ptr2;
  95. DWORD len1,len2;
  96. TryLockAgainLabel:
  97. switch(s->lpDSB->Lock(Half,s->HalfBufferPoint, &ptr1, &len1, &ptr2, & len2, 0))
  98. {
  99.  case DS_OK:
  100.   StreamCopy(s, ptr1, len1);
  101.   if(ptr2)
  102.    StreamCopy(s, ptr2, len2);
  103.   s->lpDSB->Unlock(ptr1, len1, ptr2, len2);
  104.   break;
  105.  case DSERR_BUFFERLOST:
  106.   if (s->lpDSB->Restore()==DS_OK)
  107.    goto TryLockAgainLabel ;
  108.   break;
  109. }
  110. }
  112. static void CALLBACK StreamTimer(UINT id, UINT msg, DWORD user, DWORD dw1, DWORD dw2)
  113. {
  114. DWORD playp, writep;
  115. DWORD WhichHalf;
  116. DSSTREAM * s=(DSSTREAM*)user;
  117. if(s->NoCallbacks++==0)
  118. {
  119.  if(s->PleaseClose)
  120.  {
  121.  ShutDownStreamingLabel:
  122.   timeKillEvent(id);
  123.   timeEndPeriod(62);
  124.   s->lpDSB->Stop();
  125.   s->lpDSB->Release();
  126.   s->Playing=0;
  127.   return;
  128.  }
  129.  s->lpDSB->GetCurrentPosition(& playp, &writep);
  130.  WhichHalf=(playp<s->HalfBufferPoint)?0:s->HalfBu
  131. fferPoint;
  132.  if(WhichHalf!=s->LastHalf)
  133.  {
  134.   if(s->CloseOnNext)
  135.    goto ShutDownStreamingLabel;
  136.   StreamFillAHalf(s, s->LastHalf);
  137.   s->LastHalf= WhichHalf;
  138.  }
  139. }
  140. s->NoCallbacks--;
  141. }
  143. void StartStreaming(DSSTREAM * s, void * addr, DWORD len, LPDIRECTSOUND lpDS, LPWAVEFORMATEX format);
  145. void StartStreaming(DSSTREAM * s, void * addr, DWORD len, LPDIRECTSOUND lpDS, LPWAVEFORMATEX format)
  146. {
  147. DSBUFFERDESC dsbd;
  148. if (s)
  149. {
  150.  memset(s, 0, sizeof(DSSTREAM));
  151.  if((addr)&&(lpDS)&&(format))
  152.  {
  153.   memset(&dsbd, 0, sizeof(dsbd));
  154.   dsbd.lpwfxFormat=format;
  155.   dsbd.dwSize=sizeof(DSBUFFERDESC);
  156.   dsbd.dwBufferBytes=((format->nAvgBytesPerSec/4)+2047)&~2047;
  157.   dsbd.dwFlags=0;
  158.   if(lpDS->CreateSoundBuffer(&dsbd, & s->lpDSB, 0)!=DS_OK)
  159.    return;
  160.   s->NoCallbacks=1;
  161.   s->Playing=1;
  162.   timeBeginPeriod(62);
  163.   if(timeSetEvent(62, 0, StreamTimer, (DWORD)s, TIME_PERIODIC)==0)
  164.   {
  165.    timeEndPeriod(62);
  166.    s->lpDSB->Release();
  167.   }
  168.   else
  169.   {
  170.    s->HalfBufferPoint=dsbd.dwBufferBytes/2;
  171.    s->CurrentPosition=(char*)addr;
  172.    s->BytesLeft=len;
  173.    s->SilenceByte=(format->wBitsPerSample==16)?0:128;
  175.    StreamFillAHalf(s, 0);
  176.    StreamFillAHalf(s, s->HalfBufferPoint);
  177.    s->CloseOnNext=0;
  178.    s->lpDSB->Play(0,0,DSBPLAY_LOOPING);
  179.    s->NoCallbacks=0;
  180.   }
  181.  }
  182. }
  183. }
  185. volatile DSSTREAM Streams[MaxStreams];
  186. void * SoundData[MaxSounds];
  187. WAVEFORMATEX SoundHeader[MaxSounds+1];
  188. int FreeSound=0;
  189. DWORD SoundSize[MaxSounds+1];
  191. bool InitSound(HWND hwnd)
  192. {
  193. int i;
  194. if(DirectSoundCreate(NULL, & lpDS, NULL)!=DS_OK)
  195. {
  196.  IsAvailable=false;
  197.   {
  198.    //fprintf(debugf,"Direct Sound Initialization failed.\n" );
  199.    return false;
  200.   }
  201. }
  202. lpDS->SetCooperativeLevel(hwnd,DSSCL_NORMAL);
  203. //fprintf(debugf,"Direct Sound Initialized.\n" );
  204. for (i=0;i<MaxStreams;i++)
  205.  Streams[i].Playing=0;
  206. IsAvailable=true;
  207.  return true;
  208. }
  210. int LoadWav(char * name)
  211. {
  213. if(!IsAvailable){return -1;}
  214. if (FreeSound>=MaxSounds)
  215. {
  216.  return -1;
  217. }
  218. FILE * fh=fopen(name, "rb" );
  219. if (fh==NULL)
  220. {
  221.  return -1;
  222. }
  223. fseek(fh, 12, 0);
  224. unsigned long tag,size;
  225. short ChannelCount=0,BitsPerSample=0;
  226. long SampleRate=0,SampleSize=0;
  227. char unsigned * psample;
  228. while(!feof(fh))
  229. {
  230.  tag=0;
  231.  if (fread((char *)&tag,4,1,fh)==0)
  232.   break;
  233.  fread((char*)&size,4,1,fh);
  234.  if (tag==0x20746d66)
  235.  {
  236.   fseek(fh,2,SEEK_CUR);
  237.   fread((char*)&ChannelCount,2,1,fh);
  238.   fread((char*)&SampleRate,4,1,fh);
  239.   fseek(fh,6,SEEK_CUR);
  240.   fread((char*)&BitsPerSample,2,1,fh);
  241.   if (size>16)
  242.    fseek(fh,size-16,SEEK_CUR);
  243.  }
  244.  else if (tag==0x61746164)
  245.  {
  246.   psample=(char unsigned*)malloc(size);
  247.   if(psample)
  248.   {
  249.    SampleSize=size;
  250.    fread((char*)psample,size,1,fh);
  251.   }
  252.  }
  253.  else
  254.  {
  255.   fseek(fh,size,SEEK_CUR);
  256.  }
  257. }
  258. fclose(fh);
  259. SoundData[FreeSound]=psample;
  260. SoundSize[FreeSound]=size;
  261. SoundHeader[FreeSound].wFormatTag=WAVE_FORMAT_PCM;
  262. SoundHeader[FreeSound].nChannels=ChannelCount;
  263. SoundHeader[FreeSound].nSamplesPerSec=SampleRate;
  264. SoundHeader[FreeSound].wBitsPerSample=BitsPerSample;
  265. SoundHeader[FreeSound].cbSize=0;
  266. SoundHeader[FreeSound].nBlockAlign=SoundHeader[FreeSound].nChannels*(SoundHeader[FreeSound].wBitsPerSample/8);
  267. SoundHeader[FreeSound].nAvgBytesPerSec=SoundHeader[FreeSound].nBlockAlign*SoundHeader[FreeSound].nSamplesPerSec;
  268. FreeSound++;
  269. return FreeSound-1;
  270. }
  272. void PlayWav(int nsnd)
  273. {
  274. if(!IsAvailable){return;}
  275. if (nsnd==-1)
  276.  return;
  277. int i;
  278. for (i=0; i<MaxStreams; i++)
  279.  if (!Streams[i].Playing)
  280.   break;
  281. if (i < MaxStreams)
  282.  StartStreaming((DSSTREAM *)(Streams+i), SoundData[nsnd], SoundSize[nsnd], lpDS, SoundHeader+nsnd);
  283. else
  284. // fprintf(debugf,"Error playing sound handle %d :Not Enough Channels\n",nsnd);
  285. }
  287. void CloseSound()
  288. {
  289. if(!IsAvailable){return;}
  290. IsAvailable=false;
  291. int i;
  292. for (i=0; i<MaxStreams; i++)
  293.  if (Streams[i].Playing)
  294.   Streams[i].PleaseClose=1;
  295. for (i=0; i<MaxStreams; i++)
  296.  while(Streams[i].Playing){}
  297. for (i=0; i<FreeSound; i++)
  298.  if (SoundData[i]!=NULL)
  299.  free(SoundData[i]);
  300. lpDS->Release();
  301. //fprintf(debugf,"Direct Sound Released.\n" );
  302. }

Reply

Marsh Posté le 13-11-2001 à 07:53:13    

gooopil a écrit a écrit :

J'aimerais savoir comment on fait pour jouer un fichier wav. J'ai regardé whotsit.org, g trouvé ce que cherchais mais je comprend pas énormément de trucs vu que c'est assez énorme. En plus y'a juste le format et pas le code en c++ pour le lire... Ouais faut pas rêver...
Mais j'aimerais bien pouvoir faire ça et vu que c'est pas une priorité, j'aimerais bien ne pas avoir à me casser le cerveau en 2...
Merci  




 
Je ne te parlerai pas de directSound parce que je ne connais pas.
Par contre, pour te renseigner sur les fonctions basiques pour jouer de la musique, regarde les suivantes:
 
- lecture des entêtes de fichier wav: mmioOpen, mmioRead, etc...
mais si tu veux lire toi même l'entête, tu peux aussi le faire (moi c'est ce que je fais souvent).
 
- pour le record:
waveInOpen, waveInUnprepareHeader, waveInPrepareHeader? waveInAddBuffer
 
- pour le play:
waveOutOpen, waveOutUnprepareHeader, waveOutPrepareHeader, waveOutWrite.
 
Ce sont les fonctions principales. En cherchant tout cela dans le MSDN, tu devrais t'en sortir assez rapidement.
 
bon courage. Mais moi je m'étais bien marré à faire ça :D

Reply

Marsh Posté le 13-11-2001 à 08:08:43    

waou gooopil ton topic marche mieux que le mien !

Reply

Marsh Posté le 13-11-2001 à 12:00:54    

sans se casser doit avoir un truc genre PlaySound qui te lit un vaw
 
si c juste pour faire pouet pouet de tps a autre c OK, mais si tu veux quelque chose de plus evoluer (genre tu fais un jeu), faudra te tourner vers directSound
 
le code pour lire le .wav je l'ai, mais pas la, si ca t'interesse fodra attendre un ptit peu (ce soir)

Reply

Marsh Posté le 13-11-2001 à 15:55:45    

ca NOUS interresse (je programme avec gooopil) donc envoie ca dès que tu peut :jap:

Reply

Marsh Posté le 13-11-2001 à 16:19:15    

woue OK, enfin il fait rien de plus que de lire un wav alacon non-compresse, hein ?

Reply

Marsh Posté le 14-11-2001 à 00:14:58    

chrisbk a écrit a écrit :

woue OK, enfin il fait rien de plus que de lire un wav alacon non-compresse, hein ?  




 
C'est ça, je veux juste jouer un wav à la con, c'est juste pour faire plus abouti dans notre projet. Merci tgrx pour ton source

Reply

Marsh Posté le 14-11-2001 à 08:27:05    

youps sorry ca m'est sorti de la tete  
 
je la retente ce soir

Reply

Sujets relatifs:

Leave a Replay

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