Italiano
HOME | PROGETTI | CLASSI C++ | Sorgenti c\c++ | Galleria | Guestbook | Server BW | Contattami | Login

Internet:
HTTP Download

Matematica:
Matrici

Windows:
WIN Audio


<< WIN Audio >>

visiste: 833


WIN Audio una classe scritta in C++ che gestisce la registrazione e la riproduzione di tracce audio registrate con il microfono del computer.

  1. //WIN Audio Class
  2. //by mamo139
  3. //dipendenze: windows.h
  4.  
  5. #ifndef _WIN_AUDIO_H_
  6. #define _WIN_AUDIO_H_ 1
  7.  
  8. #define WIN_AUDIO_CLASS_VERSION "0.01.01"
  9.  
  10. #include <stdio.h>
  11. #include <tchar.h>
  12. #include <math.h>
  13. #include <iostream>
  14. #include <windows.h>
  15. #pragma comment(lib,"Winmm.lib")
  16.  
  17. #define WA_CAMPIONI_PER_SECONDO 8000
  18. #define WA_BIT_PER_CAMPIONE 8
  19.  
  20.  
  21. class win_audio {
  22.  
  23. private:
  24. int campioni_per_secondo;
  25. int bit_per_campione;
  26. int canali;
  27.  
  28. int recording_event;
  29. int playing_event;
  30.  
  31. HWAVEIN input_device;
  32. WAVEHDR wave_in_struct;
  33.  
  34. HWAVEOUT output_device;
  35. WAVEHDR wave_out_struct;
  36.  
  37. char *audio_buffer;
  38. long audio_buffer_size;
  39. int audio_buffer_setted;
  40.  
  41. int err, err_size;
  42. char *err_buffer;
  43.  
  44. public:
  45. win_audio();
  46. ~win_audio();
  47.  
  48. //registrare da microfono a buffer
  49. int input_open_device(); //impostiamo dispositivo di registrazione
  50. int input_set_buffer(long lBuffer); //settiamo il buffer audio_buffer
  51. int input_record(); //iniziamo la registrazione
  52. int input_close_device(); //chiudiamo il dispositivo di registrazione
  53.  
  54. //riproduzione di un buffer
  55. int output_open_device(); //impostiamo dispositivo di riproduzione
  56. int output_set_buffer(char *buffer, long lBuffer); //settiamo il buffer da riprodurre
  57. int output_play(); //iniziamo la riproduzione
  58. int output_close_device(); //chiudiamo dispositivo di riproduzione
  59.  
  60. //altri metodi
  61. char * get_audio_buffer();
  62. long get_audio_buffer_size();
  63.  
  64. //callbacks
  65. friend void CALLBACK waveOutProc(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
  66. friend void CALLBACK waveInProc(HWAVEIN hwi, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
  67.  
  68. };
  69.  
  70.  
  71. #endif


  1. #include "win_audio.h"
  2.  
  3. win_audio::win_audio(){
  4.  
  5. campioni_per_secondo = WA_CAMPIONI_PER_SECONDO;
  6. bit_per_campione = WA_BIT_PER_CAMPIONE;
  7. canali = 1;
  8.  
  9. playing_event = 0;
  10. recording_event = 0;
  11.  
  12. input_device = NULL;
  13. output_device = NULL;
  14.  
  15. audio_buffer = NULL;
  16. audio_buffer_size = 0;
  17. audio_buffer_setted = 0;
  18.  
  19. err = 0;
  20. err_size = 2000;
  21. err_buffer = new char[err_size];
  22. }
  23.  
  24. win_audio::~win_audio(){
  25.  
  26. delete [] err_buffer;
  27.  
  28. if(audio_buffer_setted == 1)
  29. delete [] audio_buffer;
  30.  
  31. printf("win_audio distrutta...\n");
  32. }
  33.  
  34. int win_audio::input_open_device(){
  35.  
  36. WAVEFORMATEX formato_wave;
  37. formato_wave.wFormatTag = WAVE_FORMAT_PCM;
  38. formato_wave.nChannels = canali;
  39. formato_wave.nSamplesPerSec = campioni_per_secondo;
  40. formato_wave.nAvgBytesPerSec = campioni_per_secondo*bit_per_campione*canali/8;
  41. formato_wave.nBlockAlign = canali*bit_per_campione/8;
  42. formato_wave.wBitsPerSample = bit_per_campione;
  43. formato_wave.cbSize = sizeof(WAVEFORMATEX);
  44.  
  45. err = waveInOpen(&input_device, WAVE_MAPPER, &formato_wave, (DWORD_PTR)waveInProc, (DWORD_PTR)this, CALLBACK_FUNCTION);
  46. if(err != MMSYSERR_NOERROR ){
  47. waveInGetErrorText(err, err_buffer, err_size);
  48. printf("waveInOpen err: %d %s\n",err, err_buffer);
  49. getchar();
  50. return 0;
  51. }
  52.  
  53. return 1;
  54. }
  55.  
  56. int win_audio::input_set_buffer(long lBuffer){
  57.  
  58. if(audio_buffer_setted == 1)
  59. delete [] audio_buffer;
  60. audio_buffer = new char[lBuffer];
  61. audio_buffer_size = lBuffer;
  62. audio_buffer_setted = 1;
  63.  
  64. memset(&wave_in_struct, 0, sizeof(WAVEHDR));
  65. wave_in_struct.lpData = audio_buffer;
  66. wave_in_struct.dwBufferLength = lBuffer;
  67.  
  68. err = waveInPrepareHeader(input_device, &wave_in_struct, sizeof(WAVEHDR));
  69. if(err != MMSYSERR_NOERROR ){
  70. waveInGetErrorText(err, err_buffer, err_size);
  71. printf("err: %d %s\n",err, err_buffer);
  72. getchar();
  73. return 0;
  74. }
  75.  
  76. return 1;
  77. }
  78.  
  79. int win_audio::input_record(){
  80.  
  81. recording_event = 1;
  82.  
  83. err = waveInAddBuffer(input_device, &wave_in_struct, sizeof(WAVEHDR));
  84. if(err != MMSYSERR_NOERROR ){
  85. waveInGetErrorText(err, err_buffer, err_size);
  86. printf("waveInAddBuffer err: %d %s\n",err, err_buffer);
  87. getchar();
  88. return 0;
  89. }
  90.  
  91. err = waveInStart(input_device);
  92. if(err != MMSYSERR_NOERROR ){
  93. waveInGetErrorText(err, err_buffer, err_size);
  94. printf("waveInStart err: %d %s\n",err, err_buffer);
  95. getchar();
  96. return 0;
  97. }
  98.  
  99. while(recording_event == 1){
  100. Sleep(5);
  101. }
  102.  
  103. err = waveInStop(input_device);
  104. if(err != MMSYSERR_NOERROR ){
  105. waveInGetErrorText(err, err_buffer, err_size);
  106. printf("waveInStop err: %d %s\n",err, err_buffer);
  107. getchar();
  108. return 0;
  109. }
  110.  
  111. return 1;
  112. }
  113.  
  114. int win_audio::input_close_device(){
  115.  
  116. err = waveInClose(input_device);
  117. if(err != MMSYSERR_NOERROR ){
  118. waveInGetErrorText(err, err_buffer, err_size);
  119. printf("waveInClose err: %d %s\n",err, err_buffer);
  120. getchar();
  121. return 0;
  122. }
  123.  
  124. return 1;
  125. }
  126.  
  127. int win_audio::output_open_device(){
  128.  
  129. WAVEFORMATEX formato_wave;
  130. formato_wave.wFormatTag = WAVE_FORMAT_PCM;
  131. formato_wave.nChannels = canali;
  132. formato_wave.nSamplesPerSec = campioni_per_secondo;
  133. formato_wave.nAvgBytesPerSec = campioni_per_secondo*bit_per_campione*canali/8;
  134. formato_wave.nBlockAlign = canali*bit_per_campione/8;
  135. formato_wave.wBitsPerSample = bit_per_campione;
  136. formato_wave.cbSize = sizeof(WAVEFORMATEX);
  137.  
  138. err = waveOutOpen(&output_device, WAVE_MAPPER, &formato_wave, (DWORD_PTR)waveOutProc, (DWORD_PTR)this, CALLBACK_FUNCTION);
  139. if(err != MMSYSERR_NOERROR ){
  140. waveOutGetErrorText(err, err_buffer, err_size);
  141. printf("waveOutOpen err: %d %s\n",err, err_buffer);
  142. getchar();
  143. return 0;
  144. }
  145.  
  146. return 1;
  147. }
  148.  
  149. int win_audio::output_set_buffer(char *buffer, long lBuffer){
  150.  
  151. memset(&wave_out_struct, 0, sizeof(WAVEHDR));
  152. wave_out_struct.lpData = buffer;
  153. wave_out_struct.dwBufferLength = lBuffer;
  154.  
  155. err = waveOutPrepareHeader(output_device, &wave_out_struct,sizeof(WAVEHDR));
  156. if(err != MMSYSERR_NOERROR ){
  157. waveOutGetErrorText(err, err_buffer, err_size);
  158. printf("waveOutPrepareHeader err: %d %s\n",err, err_buffer);
  159. getchar();
  160. return 0;
  161. }
  162.  
  163. return 1;
  164. }
  165.  
  166. int win_audio::output_play(){
  167.  
  168. playing_event = 1;
  169.  
  170. err = waveOutWrite(output_device, &wave_out_struct,sizeof(WAVEHDR));
  171. if(err != MMSYSERR_NOERROR ){
  172. waveOutGetErrorText(err, err_buffer, err_size);
  173. printf("waveOutWrite err: %d %s\n",err, err_buffer);
  174. getchar();
  175. return 0;
  176. }
  177.  
  178. //waveOutWrite non bloccante, quindi aspettiamo
  179. while(playing_event == 1){
  180. Sleep(5);
  181. }
  182.  
  183. return 1;
  184. }
  185.  
  186. int win_audio::output_close_device(){
  187.  
  188. err = waveOutClose(output_device);
  189. if(err != MMSYSERR_NOERROR ){
  190. waveOutGetErrorText(err, err_buffer, err_size);
  191. printf("waveOutClose err: %d %s\n",err, err_buffer);
  192. getchar();
  193. return 0;
  194. }
  195.  
  196. return 1;
  197. }
  198.  
  199. char * win_audio::get_audio_buffer(){
  200. return audio_buffer;
  201. }
  202.  
  203. long win_audio::get_audio_buffer_size(){
  204. return audio_buffer_size;
  205. }
  206.  
  207. void CALLBACK waveOutProc(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2){
  208. win_audio *classe;
  209. classe = (win_audio *) dwInstance;
  210.  
  211. if(uMsg == WOM_OPEN)
  212. printf("waveOutProc: WOM_OPEN\n");
  213. else if(uMsg == WOM_DONE){
  214. //avvisiamo che la registrazione terminata
  215. classe->playing_event = 0;
  216. printf("waveOutProc: WOM_DONE\n");
  217. }
  218. else if(uMsg == WOM_CLOSE)
  219. printf("waveOutProc: WOM_CLOSE\n");
  220. else
  221. printf("waveOutProc: messaggio non riconosciuto...\n");
  222.  
  223. }
  224. void CALLBACK waveInProc(HWAVEIN hwi, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2){
  225. win_audio *classe;
  226. classe = (win_audio *) dwInstance;
  227.  
  228. if(uMsg == WIM_OPEN)
  229. printf("waveInProc: WIM_OPEN\n");
  230. else if(uMsg == WIM_DATA){
  231. //avvisiamo che la registrazione terminata
  232. classe->recording_event = 0;
  233. printf("waveInProc: WIM_DATA\n");
  234. }
  235. else if(uMsg == WIM_CLOSE)
  236. printf("waveInProc: WIM_CLOSE\n");
  237. else
  238. printf("waveInProc: messaggio non riconosciuto...\n");
  239.  
  240. }
Versione sito: 1.03.01 by mamo139. - Tutti i sorgenti presenti su questo sito sono rilasciati sotto licenza "GNU GPL version 3".