利用DirectSound实现声卡录音【老毕改版】【Part3】

1. //--------------------------------------------------------------------------------------
2. // File: WaveFile.h
3. //
4. // Copyright (c) Microsoft Corporation. All rights reserved.
5. //--------------------------------------------------------------------------------------
6. #pragma comment(lib, "winmm.lib")
7. #pragma once
9. #include <windows.h>
10. #include <mmsystem.h>
11. #include <mmreg.h>
12. #define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p) = NULL; } }
13. #define SAFE_DELETE_ARRAY(p) { if(p) { delete [](p); (p) = NULL; } }
14. #define SAFE_DELETE(p) { if(p) { delete (p); (p) = NULL; } }
16. //-----------------------------------------------------------------------------
17. // Typing macros 
18. //-----------------------------------------------------------------------------
19. #define WAVEFILE_READ   1
20. #define WAVEFILE_WRITE  2
22. class CWaveFile
23. {
24. public:
25.     WAVEFORMATEX* m_pwfx;        // Pointer to WAVEFORMATEX structure
26.     HMMIO m_hmmio;       // MM I/O handle for the WAVE
27.     MMCKINFO m_ck;          // Multimedia RIFF chunk
28.     MMCKINFO m_ckRiff;      // Use in opening a WAVE file
29.     DWORD m_dwSize;      // The size of the wave file
30.     MMIOINFO m_mmioinfoOut;
31.     DWORD m_dwFlags;
32.     BOOL m_bIsReadingFromMemory;
33.     BYTE* m_pbData;
34.     BYTE* m_pbDataCur;
35.     ULONG m_ulDataSize;
36.     CHAR* m_pResourceBuffer;
38. protected:
39.     HRESULT ReadMMIO();
40.     HRESULT WriteMMIO( WAVEFORMATEX* pwfxDest );
42. public:
43.     CWaveFile();
44.     ~CWaveFile();
46.     HRESULT Open( LPTSTR strFileName, WAVEFORMATEX* pwfx, DWORD dwFlags );
47.     HRESULT OpenFromMemory( BYTE* pbData, ULONG ulDataSize, WAVEFORMATEX* pwfx, DWORD dwFlags );
48.     HRESULT Close();
50.     HRESULT Read( BYTE* pBuffer, DWORD dwSizeToRead, DWORD* pdwSizeRead );
51.     HRESULT Write( UINT nSizeToWrite, BYTE* pbData, UINT* pnSizeWrote );
53.     DWORD   GetSize();
54.     HRESULT ResetFile();
55.     WAVEFORMATEX* GetFormat()
56.     {
57.         return m_pwfx;
58.     };
59. };
61. //--------------------------------------------------------------------------------------
62. // File: WaveFile.cpp
63. //
64. // Copyright (c) Microsoft Corporation. All rights reserved.
65. //--------------------------------------------------------------------------------------
66. #include "stdafx.h"
67. #include "WaveFile.h"
69. //-----------------------------------------------------------------------------
70. // Name: CWaveFile::CWaveFile()
71. // Desc: Constructs the class.  Call Open() to open a wave file for reading.
72. //       Then call Read() as needed.  Calling the destructor or Close()
73. //       will close the file.
74. //-----------------------------------------------------------------------------
75. CWaveFile::CWaveFile()
76. {
77.     m_pwfx = NULL;
78.     m_hmmio = NULL;
79.     m_pResourceBuffer = NULL;
80.     m_dwSize = 0;
81.     m_bIsReadingFromMemory = FALSE;
82. }
85. //-----------------------------------------------------------------------------
86. // Name: CWaveFile::~CWaveFile()
87. // Desc: Destructs the class
88. //-----------------------------------------------------------------------------
89. CWaveFile::~CWaveFile()
90. {
91.     Close();
93.     if( !m_bIsReadingFromMemory )
94.         SAFE_DELETE_ARRAY( m_pwfx );
95. }
98. //-----------------------------------------------------------------------------
99. // Name: CWaveFile::Open()
100. // Desc: Opens a wave file for reading
101. //-----------------------------------------------------------------------------
102. HRESULT CWaveFile::Open( LPTSTR strFileName, WAVEFORMATEX* pwfx, DWORD dwFlags )
103. {
104.     HRESULT hr;
106.     m_dwFlags = dwFlags;
107.     m_bIsReadingFromMemory = FALSE;
109.     if( m_dwFlags == WAVEFILE_READ )
110.     {
111.         if( strFileName == NULL )
112.             return E_INVALIDARG;
113.         SAFE_DELETE_ARRAY( m_pwfx );
115.         m_hmmio = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF | MMIO_READ );
117.         if( NULL == m_hmmio )
118.         {
119.             HRSRC hResInfo;
120.             HGLOBAL hResData;
121.             DWORD dwSize;
122.             VOID* pvRes;
124.             // Loading it as a file failed, so try it as a resource
125.             if( NULL == ( hResInfo = FindResource( NULL, strFileName, TEXT( "WAVE" ) ) ) )
126.             {
127.                 if( NULL == ( hResInfo = FindResource( NULL, strFileName, TEXT( "WAV" ) ) ) )
128.                     return E_FAIL;
129.             }
131.             if( NULL == ( hResData = LoadResource( GetModuleHandle( NULL ), hResInfo ) ) )
132.                 return E_FAIL;
134.             if( 0 == ( dwSize = SizeofResource( GetModuleHandle( NULL ), hResInfo ) ) )
135.                 return E_FAIL;
137.             if( NULL == ( pvRes = LockResource( hResData ) ) )
138.                 return E_FAIL;
140.             m_pResourceBuffer = new CHAR[ dwSize ];
141.             if( m_pResourceBuffer == NULL )
142.                 return E_OUTOFMEMORY;
143.             memcpy( m_pResourceBuffer, pvRes, dwSize );
145.             MMIOINFO mmioInfo;
146.             ZeroMemory( &mmioInfo, sizeof( mmioInfo ) );
147.             mmioInfo.fccIOProc = FOURCC_MEM;
148.             mmioInfo.cchBuffer = dwSize;
149.             mmioInfo.pchBuffer = ( CHAR* )m_pResourceBuffer;
151.             m_hmmio = mmioOpen( NULL, &mmioInfo, MMIO_ALLOCBUF | MMIO_READ );
152.         }
154.         if( FAILED( hr = ReadMMIO() ) )
155.         {
156.             // ReadMMIO will fail if its an not a wave file
157.             mmioClose( m_hmmio, 0 );
158.             return hr;
159.         }
161.         if( FAILED( hr = ResetFile() ) )
162.             return hr;
164.         // After the reset, the size of the wav file is m_ck.cksize so store it now
165.         m_dwSize = m_ck.cksize;
166.     }
167.     else
168.     {
169.         m_hmmio = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF |
170.             MMIO_READWRITE |
171.             MMIO_CREATE );
172.         if( NULL == m_hmmio )
173.             return E_FAIL;
175.         if( FAILED( hr = WriteMMIO( pwfx ) ) )
176.         {
177.             mmioClose( m_hmmio, 0 );
178.             return hr;
179.         }
181.         if( FAILED( hr = ResetFile() ) )
182.             return hr;
183.     }
185.     return hr;
186. }
189. //-----------------------------------------------------------------------------
190. // Name: CWaveFile::OpenFromMemory()
191. // Desc: copy data to CWaveFile member variable from memory
192. //-----------------------------------------------------------------------------
193. HRESULT CWaveFile::OpenFromMemory( BYTE* pbData, ULONG ulDataSize,
194.                                   WAVEFORMATEX* pwfx, DWORD dwFlags )
195. {
196.     m_pwfx = pwfx;
197.     m_ulDataSize = ulDataSize;
198.     m_pbData = pbData;
199.     m_pbDataCur = m_pbData;
200.     m_bIsReadingFromMemory = TRUE;
202.     if( dwFlags != WAVEFILE_READ )
203.         return E_NOTIMPL;
205.     return S_OK;
206. }
209. //-----------------------------------------------------------------------------
210. // Name: CWaveFile::ReadMMIO()
211. // Desc: Support function for reading from a multimedia I/O stream.
212. //       m_hmmio must be valid before calling.  This function uses it to
213. //       update m_ckRiff, and m_pwfx.
214. //-----------------------------------------------------------------------------
215. HRESULT CWaveFile::ReadMMIO()
216. {
217.     MMCKINFO ckIn;           // chunk info. for general use.
218.     PCMWAVEFORMAT pcmWaveFormat;  // Temp PCM structure to load in.
220.     m_pwfx = NULL;
222.     if( ( 0 != mmioDescend( m_hmmio, &m_ckRiff, NULL, 0 ) ) )
223.         return E_FAIL;
225.     // Check to make sure this is a valid wave file
226.     if( ( m_ckRiff.ckid != FOURCC_RIFF ) ||
227.         ( m_ckRiff.fccType != mmioFOURCC( 'W', 'A', 'V', 'E' ) ) )
228.         return E_FAIL;
230.     // Search the input file for for the 'fmt ' chunk.
231.     ckIn.ckid = mmioFOURCC( 'f', 'm', 't', ' ' );
232.     if( 0 != mmioDescend( m_hmmio, &ckIn, &m_ckRiff, MMIO_FINDCHUNK ) )
233.         return E_FAIL;
235.     // Expect the 'fmt' chunk to be at least as large as <PCMWAVEFORMAT>;
236.     // if there are extra parameters at the end, we'll ignore them
237.     if( ckIn.cksize < ( LONG )sizeof( PCMWAVEFORMAT ) )
238.         return E_FAIL;
240.     // Read the 'fmt ' chunk into <pcmWaveFormat>.
241.     if( mmioRead( m_hmmio, ( HPSTR )&pcmWaveFormat,
242.         sizeof( pcmWaveFormat ) ) != sizeof( pcmWaveFormat ) )
243.         return E_FAIL;
245.     // Allocate the waveformatex, but if its not pcm format, read the next
246.     // word, and thats how many extra bytes to allocate.
247.     if( pcmWaveFormat.wf.wFormatTag == WAVE_FORMAT_PCM )
248.     {
249.         m_pwfx = ( WAVEFORMATEX* )new CHAR[ sizeof( WAVEFORMATEX ) ];
250.         if( NULL == m_pwfx )
251.             return E_FAIL;
253.         // Copy the bytes from the pcm structure to the waveformatex structure
254.         memcpy( m_pwfx, &pcmWaveFormat, sizeof( pcmWaveFormat ) );
255.         m_pwfx->cbSize = 0;
256.     }
257.     else
258.     {
259.         // Read in length of extra bytes.
260.         WORD cbExtraBytes = 0L;
261.         if( mmioRead( m_hmmio, ( CHAR* )&cbExtraBytes, sizeof( WORD ) ) != sizeof( WORD ) )
262.             return E_FAIL;
264.         m_pwfx = ( WAVEFORMATEX* )new CHAR[ sizeof( WAVEFORMATEX ) + cbExtraBytes ];
265.         if( NULL == m_pwfx )
266.             return E_FAIL;
268.         // Copy the bytes from the pcm structure to the waveformatex structure
269.         memcpy( m_pwfx, &pcmWaveFormat, sizeof( pcmWaveFormat ) );
270.         m_pwfx->cbSize = cbExtraBytes;
272.         // Now, read those extra bytes into the structure, if cbExtraAlloc != 0.
273.         if( mmioRead( m_hmmio, ( CHAR* )( ( ( BYTE* )&( m_pwfx->cbSize ) ) + sizeof( WORD ) ),
274.             cbExtraBytes ) != cbExtraBytes )
275.         {
276.             SAFE_DELETE_ARRAY( m_pwfx );
277.             return E_FAIL;
278.         }
279.     }
281.     // Ascend the input file out of the 'fmt ' chunk.
282.     if( 0 != mmioAscend( m_hmmio, &ckIn, 0 ) )
283.     {
284.         SAFE_DELETE_ARRAY( m_pwfx );
285.         return E_FAIL;
286.     }
288.     return S_OK;
289. }
292. //-----------------------------------------------------------------------------
293. // Name: CWaveFile::GetSize()
294. // Desc: Retuns the size of the read access wave file
295. //-----------------------------------------------------------------------------
296. DWORD CWaveFile::GetSize()
297. {
298.     return m_dwSize;
299. }
302. //-----------------------------------------------------------------------------
303. // Name: CWaveFile::ResetFile()
304. // Desc: Resets the internal m_ck pointer so reading starts from the
305. //       beginning of the file again
306. //-----------------------------------------------------------------------------
307. HRESULT CWaveFile::ResetFile()
308. {
309.     if( m_bIsReadingFromMemory )
310.     {
311.         m_pbDataCur = m_pbData;
312.     }
313.     else
314.     {
315.         if( m_hmmio == NULL )
316.             return CO_E_NOTINITIALIZED;
318.         if( m_dwFlags == WAVEFILE_READ )
319.         {
320.             // Seek to the data
321.             if( -1 == mmioSeek( m_hmmio, m_ckRiff.dwDataOffset + sizeof( FOURCC ),
322.                 SEEK_SET ) )
323.                 return E_FAIL;
325.             // Search the input file for the 'data' chunk.
326.             m_ck.ckid = mmioFOURCC( 'd', 'a', 't', 'a' );
327.             if( 0 != mmioDescend( m_hmmio, &m_ck, &m_ckRiff, MMIO_FINDCHUNK ) )
328.                 return E_FAIL;
329.         }
330.         else
331.         {
332.             // Create the 'data' chunk that holds the waveform samples.
333.             m_ck.ckid = mmioFOURCC( 'd', 'a', 't', 'a' );
334.             m_ck.cksize = 0;
336.             if( 0 != mmioCreateChunk( m_hmmio, &m_ck, 0 ) )
337.                 return E_FAIL;
339.             if( 0 != mmioGetInfo( m_hmmio, &m_mmioinfoOut, 0 ) )
340.                 return E_FAIL;
341.         }
342.     }
344.     return S_OK;
345. }
348. //-----------------------------------------------------------------------------
349. // Name: CWaveFile::Read()
350. // Desc: Reads section of data from a wave file into pBuffer and returns
351. //       how much read in pdwSizeRead, reading not more than dwSizeToRead.
352. //       This uses m_ck to determine where to start reading from.  So
353. //       subsequent calls will be continue where the last left off unless
354. //       Reset() is called.
355. //-----------------------------------------------------------------------------
356. HRESULT CWaveFile::Read( BYTE* pBuffer, DWORD dwSizeToRead, DWORD* pdwSizeRead )
357. {
358.     if( m_bIsReadingFromMemory )
359.     {
360.         if( m_pbDataCur == NULL )
361.             return CO_E_NOTINITIALIZED;
362.         if( pdwSizeRead != NULL )
363.             *pdwSizeRead = 0;
365.         if( ( BYTE* )( m_pbDataCur + dwSizeToRead ) >
366.             ( BYTE* )( m_pbData + m_ulDataSize ) )
367.         {
368.             dwSizeToRead = m_ulDataSize - ( DWORD )( m_pbDataCur - m_pbData );
369.         }
371.         CopyMemory( pBuffer, m_pbDataCur, dwSizeToRead );
373.         if( pdwSizeRead != NULL )
374.             *pdwSizeRead = dwSizeToRead;
376.         return S_OK;
377.     }
378.     else
379.     {
380.         MMIOINFO mmioinfoIn; // current status of m_hmmio
382.         if( m_hmmio == NULL )
383.             return CO_E_NOTINITIALIZED;
384.         if( pBuffer == NULL || pdwSizeRead == NULL )
385.             return E_INVALIDARG;
387.         if( pdwSizeRead != NULL )
388.             *pdwSizeRead = 0;
390.         if( 0 != mmioGetInfo( m_hmmio, &mmioinfoIn, 0 ) )
391.             return E_FAIL;
393.         UINT cbDataIn = dwSizeToRead;
394.         if( cbDataIn > m_ck.cksize )
395.             cbDataIn = m_ck.cksize;
397.         m_ck.cksize -= cbDataIn;
399.         for( DWORD cT = 0; cT < cbDataIn; cT++ )
400.         {
401.             // Copy the bytes from the io to the buffer.
402.             if( mmioinfoIn.pchNext == mmioinfoIn.pchEndRead )
403.             {
404.                 if( 0 != mmioAdvance( m_hmmio, &mmioinfoIn, MMIO_READ ) )
405.                     return E_FAIL;
407.                 if( mmioinfoIn.pchNext == mmioinfoIn.pchEndRead )
408.                     return E_FAIL;
409.             }
411.             // Actual copy.
412.             *( ( BYTE* )pBuffer + cT ) = *( ( BYTE* )mmioinfoIn.pchNext );
413.             mmioinfoIn.pchNext++;
414.         }
416.         if( 0 != mmioSetInfo( m_hmmio, &mmioinfoIn, 0 ) )
417.             return E_FAIL;
419.         if( pdwSizeRead != NULL )
420.             *pdwSizeRead = cbDataIn;
422.         return S_OK;
423.     }
424. }
427. //-----------------------------------------------------------------------------
428. // Name: CWaveFile::Close()
429. // Desc: Closes the wave file
430. //-----------------------------------------------------------------------------
431. HRESULT CWaveFile::Close()
432. {
433.     if( m_dwFlags == WAVEFILE_READ )
434.     {
435.         mmioClose( m_hmmio, 0 );
436.         m_hmmio = NULL;
437.         SAFE_DELETE_ARRAY( m_pResourceBuffer );
438.     }
439.     else
440.     {
441.         m_mmioinfoOut.dwFlags |= MMIO_DIRTY;
443.         if( m_hmmio == NULL )
444.             return CO_E_NOTINITIALIZED;
446.         if( 0 != mmioSetInfo( m_hmmio, &m_mmioinfoOut, 0 ) )
447.             return E_FAIL;
449.         // Ascend the output file out of the 'data' chunk -- this will cause
450.         // the chunk size of the 'data' chunk to be written.
451.         if( 0 != mmioAscend( m_hmmio, &m_ck, 0 ) )
452.             return E_FAIL;
454.         // Do this here instead...
455.         if( 0 != mmioAscend( m_hmmio, &m_ckRiff, 0 ) )
456.             return E_FAIL;
458.         mmioSeek( m_hmmio, 0, SEEK_SET );
460.         if( 0 != ( INT )mmioDescend( m_hmmio, &m_ckRiff, NULL, 0 ) )
461.             return E_FAIL;
463.         m_ck.ckid = mmioFOURCC( 'f', 'a', 'c', 't' );
465.         if( 0 == mmioDescend( m_hmmio, &m_ck, &m_ckRiff, MMIO_FINDCHUNK ) )
466.         {
467.             DWORD dwSamples = 0;
468.             mmioWrite( m_hmmio, ( HPSTR )&dwSamples, sizeof( DWORD ) );
469.             mmioAscend( m_hmmio, &m_ck, 0 );
470.         }
472.         // Ascend the output file out of the 'RIFF' chunk -- this will cause
473.         // the chunk size of the 'RIFF' chunk to be written.
474.         if( 0 != mmioAscend( m_hmmio, &m_ckRiff, 0 ) )
475.             return E_FAIL;
477.         mmioClose( m_hmmio, 0 );
478.         m_hmmio = NULL;
479.     }
481.     return S_OK;
482. }
485. //-----------------------------------------------------------------------------
486. // Name: CWaveFile::WriteMMIO()
487. // Desc: Support function for reading from a multimedia I/O stream
488. //       pwfxDest is the WAVEFORMATEX for this new wave file.
489. //       m_hmmio must be valid before calling.  This function uses it to
490. //       update m_ckRiff, and m_ck.
491. //-----------------------------------------------------------------------------
492. HRESULT CWaveFile::WriteMMIO( WAVEFORMATEX* pwfxDest )
493. {
494.     DWORD dwFactChunk; // Contains the actual fact chunk. Garbage until WaveCloseWriteFile.
495.     MMCKINFO ckOut1;
497.     dwFactChunk = ( DWORD )-1;
499.     // Create the output file RIFF chunk of form type 'WAVE'.
500.     m_ckRiff.fccType = mmioFOURCC( 'W', 'A', 'V', 'E' );
501.     m_ckRiff.cksize = 0;
503.     if( 0 != mmioCreateChunk( m_hmmio, &m_ckRiff, MMIO_CREATERIFF ) )
504.         return E_FAIL;
506.     // We are now descended into the 'RIFF' chunk we just created.
507.     // Now create the 'fmt ' chunk. Since we know the size of this chunk,
508.     // specify it in the MMCKINFO structure so MMIO doesn't have to seek
509.     // back and set the chunk size after ascending from the chunk.
510.     m_ck.ckid = mmioFOURCC( 'f', 'm', 't', ' ' );
511.     m_ck.cksize = sizeof( PCMWAVEFORMAT );
513.     if( 0 != mmioCreateChunk( m_hmmio, &m_ck, 0 ) )
514.         return E_FAIL;
516.     // Write the PCMWAVEFORMAT structure to the 'fmt ' chunk if its that type.
517.     if( pwfxDest->wFormatTag == WAVE_FORMAT_PCM )
518.     {
519.         if( mmioWrite( m_hmmio, ( HPSTR )pwfxDest,
520.             sizeof( PCMWAVEFORMAT ) ) != sizeof( PCMWAVEFORMAT ) )
521.             return E_FAIL;
522.     }
523.     else
524.     {
525.         // Write the variable length size.
526.         if( ( UINT )mmioWrite( m_hmmio, ( HPSTR )pwfxDest,
527.             sizeof( *pwfxDest ) + pwfxDest->cbSize ) !=
528.             ( sizeof( *pwfxDest ) + pwfxDest->cbSize ) )
529.             return E_FAIL;
530.     }
532.     // Ascend out of the 'fmt ' chunk, back into the 'RIFF' chunk.
533.     if( 0 != mmioAscend( m_hmmio, &m_ck, 0 ) )
534.         return E_FAIL;
536.     // Now create the fact chunk, not required for PCM but nice to have.  This is filled
537.     // in when the close routine is called.
538.     ckOut1.ckid = mmioFOURCC( 'f', 'a', 'c', 't' );
539.     ckOut1.cksize = 0;
541.     if( 0 != mmioCreateChunk( m_hmmio, &ckOut1, 0 ) )
542.         return E_FAIL;
544.     if( mmioWrite( m_hmmio, ( HPSTR )&dwFactChunk, sizeof( dwFactChunk ) ) !=
545.         sizeof( dwFactChunk ) )
546.         return E_FAIL;
548.     // Now ascend out of the fact chunk...
549.     if( 0 != mmioAscend( m_hmmio, &ckOut1, 0 ) )
550.         return E_FAIL;
552.     return S_OK;
553. }
556. //-----------------------------------------------------------------------------
557. // Name: CWaveFile::Write()
558. // Desc: Writes data to the open wave file
559. //-----------------------------------------------------------------------------
560. HRESULT CWaveFile::Write( UINT nSizeToWrite, BYTE* pbSrcData, UINT* pnSizeWrote )
561. {
562.     UINT cT;
564.     if( m_bIsReadingFromMemory )
565.         return E_NOTIMPL;
566.     if( m_hmmio == NULL )
567.         return CO_E_NOTINITIALIZED;
568.     if( pnSizeWrote == NULL || pbSrcData == NULL )
569.         return E_INVALIDARG;
571.     *pnSizeWrote = 0;
573.     for( cT = 0; cT < nSizeToWrite; cT++ )
574.     {
575.         if( m_mmioinfoOut.pchNext == m_mmioinfoOut.pchEndWrite )
576.         {
577.             m_mmioinfoOut.dwFlags |= MMIO_DIRTY;
578.             if( 0 != mmioAdvance( m_hmmio, &m_mmioinfoOut, MMIO_WRITE ) )
579.                 return E_FAIL;
580.         }
582.         *( ( BYTE* )m_mmioinfoOut.pchNext ) = *( ( BYTE* )pbSrcData + cT );
583.         ( BYTE* )m_mmioinfoOut.pchNext++;
585.         ( *pnSizeWrote )++;
586.     }
588.     return S_OK;
589. }