开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
AudioSource.cpp
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：24k
源码类别：

VC书籍

开发平台：

Visual C++

AudioSource.cpp：源码内容
  1. // VirtualDub - Video processing and capture application
  2. // Copyright (C) 1998-2001 Avery Lee
  3. //
  4. // This program is free software; you can redistribute it and/or modify
  5. // it under the terms of the GNU General Public License as published by
  6. // the Free Software Foundation; either version 2 of the License, or
  7. // (at your option) any later version.
  8. //
  9. // This program is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. // GNU General Public License for more details.
  13. //
  14. // You should have received a copy of the GNU General Public License
  15. // along with this program; if not, write to the Free Software
  16. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. #include <stdio.h>
  19. #include <stdlib.h>
  21. #include <windows.h>
  22. #include <vfw.h>
  24. #include "AudioSource.h"
  25. #include "AVIReadHandler.h"
  26. #include "AC3FileSrc.h"
  30. AudioSourceWAV::AudioSourceWAV(char *szFile, LONG inputBufferSize) {
  31. MMIOINFO mmi;
  33. memset(&mmi,0,sizeof mmi);
  34. mmi.cchBuffer = inputBufferSize;
  35. hmmioFile = mmioOpen(szFile, &mmi, MMIO_READ | MMIO_ALLOCBUF);
  36. }
  38. AudioSourceWAV::~AudioSourceWAV() {
  39. mmioClose(hmmioFile, 0);
  40. }
  42. BOOL AudioSourceWAV::init() {
  43. if (!hmmioFile) return FALSE;
  45. chunkRIFF.fccType = mmioFOURCC('W','A','V','E');
  46. if (MMSYSERR_NOERROR != mmioDescend(hmmioFile, &chunkRIFF, NULL, MMIO_FINDRIFF))
  47. return FALSE;
  49. chunkDATA.ckid = mmioFOURCC('f','m','t',' ');
  50. if (MMSYSERR_NOERROR != mmioDescend(hmmioFile, &chunkDATA, &chunkRIFF, MMIO_FINDCHUNK))
  51. return FALSE;
  53. if (!allocFormat(chunkDATA.cksize)) return FALSE;
  54. if (chunkDATA.cksize != mmioRead(hmmioFile, (char *)getWaveFormat(), chunkDATA.cksize))
  55. return FALSE;
  57. if (MMSYSERR_NOERROR != mmioAscend(hmmioFile, &chunkDATA, 0))
  58. return FALSE;
  60. chunkDATA.ckid = mmioFOURCC('d','a','t','a');
  61. if (MMSYSERR_NOERROR != mmioDescend(hmmioFile, &chunkDATA, &chunkRIFF, MMIO_FINDCHUNK))
  62. return FALSE;
  64. bytesPerSample = getWaveFormat()->nBlockAlign; //getWaveFormat()->nAvgBytesPerSec / getWaveFormat()->nSamplesPerSec;
  65. lSampleFirst = 0;
  66. lSampleLast = chunkDATA.cksize / bytesPerSample;
  67. lCurrentSample = 0;
  69. streamInfo.fccType = streamtypeAUDIO;
  70. streamInfo.fccHandler = 0;
  71. streamInfo.dwFlags = 0;
  72. streamInfo.wPriority = 0;
  73. streamInfo.wLanguage = 0;
  74. streamInfo.dwInitialFrames = 0;
  75. streamInfo.dwScale = bytesPerSample;
  76. streamInfo.dwRate = getWaveFormat()->nAvgBytesPerSec;
  77. streamInfo.dwStart = 0;
  78. streamInfo.dwLength = chunkDATA.cksize / bytesPerSample;
  79. streamInfo.dwSuggestedBufferSize = 0;
  80. streamInfo.dwQuality = 0xffffffff;
  81. streamInfo.dwSampleSize = bytesPerSample;
  83. return TRUE;
  84. }
  86. int AudioSourceWAV::_read(LONG lStart, LONG lCount, LPVOID buffer, LONG cbBuffer, LONG *lBytesRead, LONG *lSamplesRead) {
  87. LONG lBytes = lCount * bytesPerSample;
  89. if (buffer) {
  90. if (lStart != lCurrentSample)
  91. if (-1 == mmioSeek(hmmioFile, chunkDATA.dwDataOffset + bytesPerSample*lStart, SEEK_SET))
  92. return AVIERR_FILEREAD;
  94. if (lBytes != mmioRead(hmmioFile, (char *)buffer, lBytes))
  95. return AVIERR_FILEREAD;
  97. lCurrentSample = lStart + lCount;
  98. }
  100. *lSamplesRead = lCount;
  101. *lBytesRead = lBytes;
  103. return AVIERR_OK;
  104. }
  106. ///////////////////////////
  108. AudioSourceAVI::AudioSourceAVI(IAVIReadHandler *pAVI) {
  109. pAVIFile = pAVI;
  110. pAVIStream = NULL;
  111. }
  113. AudioSourceAVI::~AudioSourceAVI() {
  114. if (pAVIStream)
  115. delete pAVIStream;
  116. }
  118. BOOL AudioSourceAVI::init() {
  119. LONG format_len;
  121. pAVIStream = pAVIFile->GetStream(streamtypeAUDIO, 0);
  122. if (!pAVIStream) return FALSE;
  124. if (pAVIStream->Info(&streamInfo, sizeof streamInfo))
  125. return FALSE;
  127. pAVIStream->FormatSize(0, &format_len);
  129. if (!allocFormat(format_len)) return FALSE;
  131. if (pAVIStream->ReadFormat(0, getFormat(), &format_len))
  132. return FALSE;
  134. lSampleFirst = pAVIStream->Start();
  135. lSampleLast = pAVIStream->End();
  137. return TRUE;
  138. }
  140. void AudioSourceAVI::Reinit() {
  141. pAVIStream->Info(&streamInfo, sizeof streamInfo);
  142. lSampleFirst = pAVIStream->Start();
  143. lSampleLast = pAVIStream->End();
  144. }
  146. bool AudioSourceAVI::isStreaming() {
  147. return pAVIStream->isStreaming();
  148. }
  150. void AudioSourceAVI::streamBegin(bool fRealTime) {
  151. pAVIStream->BeginStreaming(lSampleFirst, lSampleLast, fRealTime ? 1000 : 2000);
  152. }
  154. void AudioSourceAVI::streamEnd() {
  155. pAVIStream->EndStreaming();
  157. }
  159. BOOL AudioSourceAVI::_isKey(LONG lSample) {
  160. return pAVIStream->IsKeyFrame(lSample);
  161. }
  162. int AudioSourceAVI::_read(LONG lStart, LONG lCount, LPVOID lpBuffer, LONG cbBuffer, LONG *lpBytesRead, LONG *lpSamplesRead) {
  163. int err;
  164. long lBytes, lSamples;
  166. // There are some video clips roaming around with truncated audio streams
  167. // (audio streams that state their length as being longer than they
  168. // really are).  We use a kludge here to get around the problem.
  170. err = pAVIStream->Read(lStart, lCount, lpBuffer, cbBuffer, lpBytesRead, lpSamplesRead);
  172. if (err != AVIERR_FILEREAD)
  173. return err;
  175. // Suspect a truncated stream.
  176. //
  177. // AVISTREAMREAD_CONVENIENT will tell us if we're actually encountering a
  178. // true read error or not.  At least for the AVI handler, it returns
  179. // AVIERR_ERROR if we've broached the end.  
  181. *lpBytesRead = *lpSamplesRead = 0;
  183. while(lCount > 0) {
  184. err = pAVIStream->Read(lStart, AVISTREAMREAD_CONVENIENT, NULL, 0, &lBytes, &lSamples);
  186. if (err)
  187. return 0;
  189. if (!lSamples) return AVIERR_OK;
  191. if (lSamples > lCount) lSamples = lCount;
  193. err = pAVIStream->Read(lStart, lSamples, lpBuffer, cbBuffer, &lBytes, &lSamples);
  195. if (err)
  196. return err;
  198. lpBuffer = (LPVOID)((char *)lpBuffer + lBytes);
  199. cbBuffer -= lBytes;
  200. lCount -= lSamples;
  202. *lpBytesRead += lBytes;
  203. *lpSamplesRead += lSamples;
  204. }
  206. return AVIERR_OK;
  207. }
  210. ///////////////////////////////////////////////////////////////////////////////////////////////////
  212. // Dummy CRC pointer
  213. Crc16 *crc;
  215. AudioSourceMP3::AudioSourceMP3(char *szFile) {
  217. stream = new Ibitstream(szFile);
  218. header = new Header;
  220. f = fopen( szFile, "rb" );
  221. }
  223. AudioSourceMP3::~AudioSourceMP3() {
  225. if( f ) fclose( f );
  227. delete header;
  228. delete stream;
  229. }
  231. BOOL AudioSourceMP3::init() {
  233. if( !f ) return FALSE;
  235. if (!header->read_header(stream, &crc)){
  236. return FALSE;
  237. }
  238. do {
  239. } while( header->read_header(stream, &crc) );
  241. real s_len = (stream->current_frame()+1)*header->ms_per_frame()/1000;
  243. if (!allocFormat(sizeof MPEGLAYER3WAVEFORMAT)) return FALSE;
  246. MPEGLAYER3WAVEFORMAT *mp3format = (MPEGLAYER3WAVEFORMAT *)getWaveFormat();
  247. mp3format->wfx.wFormatTag = WAVE_FORMAT_MPEGLAYER3; /* format type */
  248.     mp3format->wfx.nChannels = (header->mode() == single_channel) ? 1 : 2; /* number of channels (i.e. mono, stereo...) */
  249.     mp3format->wfx.nSamplesPerSec = header->frequency(); /* sample rate */
  250.     mp3format->wfx.nAvgBytesPerSec = stream->file_size()/s_len; /* for buffer estimation */
  251.     mp3format->wfx.nBlockAlign = 1152; /* block size of data */
  252.     mp3format->wfx.wBitsPerSample = 0; /* Number of bits per sample of mono data */
  253. mp3format->wfx.cbSize = 12; /* The count in bytes of the size of
  254. extra information (after cbSize) */
  255. mp3format->wID = 1;
  256. mp3format->fdwFlags = 2;
  257. mp3format->nBlockSize = stream->file_size()/(stream->current_frame()+1);
  258. mp3format->nFramesPerBlock = 1;
  259. mp3format->nCodecDelay = 0;
  262. lSampleFirst = 0;
  263. lSampleLast = stream->current_frame()+1;
  266. streamInfo.fccType = streamtypeAUDIO;
  267. streamInfo.fccHandler = 0;
  268. streamInfo.dwFlags = 0;
  269. streamInfo.wPriority = 0;
  270. streamInfo.wLanguage = 0;
  271. streamInfo.dwInitialFrames = 0;
  272. streamInfo.dwScale = 1152;
  273. streamInfo.dwRate = header->frequency();
  274. streamInfo.dwStart = 0;
  275. streamInfo.dwLength = lSampleLast;
  276. streamInfo.dwSuggestedBufferSize = 0;
  277. streamInfo.dwQuality = 0xffffffff;
  278. streamInfo.dwSampleSize = 0;
  281. delete header;
  282. header = new Header;
  283. stream->reset();
  284. pos = 0;
  285. header->read_header(stream, &crc);
  287. return TRUE;
  288. }
  290. int AudioSourceMP3::_read(LONG lStart, LONG lCount, LPVOID buffer, LONG cbBuffer, LONG *lBytesRead, LONG *lSamplesRead)
  291. {
  292. *lSamplesRead = 0;
  293. *lBytesRead = 0;
  295. if( buffer )
  296. {
  297. if (lStart != stream->current_frame())
  298. {
  299. delete header;
  300. header = new Header;
  301. stream->reset();
  302. while( stream->current_frame() != lStart )
  303. {
  304. pos = stream->file_pos();
  305. header->read_header(stream, &crc);
  306. }
  307. }
  309. uint32 frame_size = stream->file_pos() - pos;
  310. if( frame_size>cbBuffer ) return AVIERR_OK;
  312. fseek( f, pos, SEEK_SET );
  313. fread( buffer, frame_size, 1, f );
  314. cbBuffer -= frame_size;
  315. buffer = (void *)(((unsigned long)buffer)+frame_size);
  316. (*lBytesRead) += frame_size;
  317. pos = stream->file_pos();
  318. header->read_header(stream, &crc);
  320. (*lSamplesRead) = 1;
  322. }
  323.     
  324. return AVIERR_OK;
  325. }
  327. ///////////////////////////////////////////////////////////////////////////////////////////////////
  329. AudioSourceOggVorbis::AudioSourceOggVorbis(char *szFile) {
  331. f = fopen( szFile, "rb" );
  332. pos = 0;
  334. }
  336. AudioSourceOggVorbis::~AudioSourceOggVorbis() {
  338. if( f ) fclose( f );
  340. }
  342. #ifndef _WAVEFORMATEXTENSIBLE_
  343. #define _WAVEFORMATEXTENSIBLE_
  344. #pragma pack(1)
  345. typedef struct {
  346.     WAVEFORMATEX    Format;
  347.     union {
  348.         WORD wValidBitsPerSample;       /* bits of precision  */
  349.         WORD wSamplesPerBlock;          /* valid if wBitsPerSample==0 */
  350.         WORD wReserved;                 /* If neither applies, set to zero. */
  351.     } Samples;
  352.     DWORD           dwChannelMask;      /* which channels are */
  353.                                         /* present in stream  */
  354.     GUID            SubFormat;
  355. } WAVEFORMATEXTENSIBLE, *PWAVEFORMATEXTENSIBLE;
  356. #pragma pack()
  357. #endif // !_WAVEFORMATEXTENSIBLE_
  361. BOOL AudioSourceOggVorbis::streamInit() {
  363. char *buffer;
  364. int bytes;
  366. eos = 0;
  368. while( ogg_sync_pageout( &oy, &og )!=1 ) {
  369. buffer = ogg_sync_buffer( &oy, 1 );
  370. bytes = fread( buffer, 1, 1, f );
  371. ogg_sync_wrote( &oy, bytes );
  372. }
  374. ogg_stream_init( &os, ogg_page_serialno( &og ) );
  376. vorbis_info_init( &vi );
  377. vorbis_comment_init( &vc );
  378. if( ogg_stream_pagein( &os, &og )<0 ) { 
  379. return FALSE;
  380. }
  381. if( ogg_stream_packetout( &os, &op )!=1 ) { 
  382. return FALSE;
  383. }
  384. if( vorbis_synthesis_headerin( &vi, &vc, &op )<0 ) { 
  385. return FALSE;
  386. }
  389. int i = 0;
  390. while( i<2 ) {
  391. while( i<2 ) {
  392. int result = ogg_sync_pageout( &oy, &og );
  393. if( result==0 ) break; /* Need more data */
  394. /* Don't complain about missing or corrupt data yet.  We'll
  395. catch it at the packet output phase */
  396. if( result==1 ) {
  397. ogg_stream_pagein( &os, &og ); /* we can ignore any errors here
  398. as they'll also become apparent
  399. at packetout */
  400. while( i<2 ) {
  401. result = ogg_stream_packetout( &os, &op );
  402. if( result==0 ) break;
  403. if( result<0 ) {
  404. /* Uh oh; data at some point was corrupted or missing!
  405. We can't tolerate that in a header.  Die. */
  406. return FALSE;
  407. }
  408. vorbis_synthesis_headerin( &vi, &vc, &op );
  409. i++;
  410. }
  411. }
  412. }
  413. /* no harm in not checking before adding more */
  414. buffer = ogg_sync_buffer( &oy, 1 );
  415. bytes = fread( buffer, 1, 1, f );
  416. if( bytes==0 && i<2 ) {
  417. return FALSE;
  418. }
  419. ogg_sync_wrote( &oy, bytes );
  420. }
  421. fgetpos( f, &pos );
  422. --pos;
  424. vorbis_synthesis_init( &vd, &vi );
  425. vorbis_block_init( &vd, &vb );
  427. return TRUE;
  428. }
  431. typedef unsigned __int8 uint8;
  432. //typedef unsigned __int32 uint32;
  433. typedef unsigned __int64 uint64;
  435. bool splitHeader( const uint8* Buffer, size_t BufferSize, size_t& SplitPosition, uint8** Header,size_t*HeaderSize )
  436. {
  437. // Just for your information, here's the format of an Ogg Page header:
  438. #pragma pack(1)
  439.  struct PageHeader
  440.  {
  441.  // Flag values
  442. enum
  443. {
  444. CONTINUED=1
  445. ,BOS=2
  446. ,EOS=4
  447. };
  449. char Magic[4]; // The String "OggS" in ASCII
  450. uint8 Version; // Currently 0
  451. uint8 Flags; // Enf of stream, Beginning of stream
  452. uint64 GranulePos; // Not used for header packets. This is big endian !!!
  453. uint32 Serial; // serial number of the stream used for multiplexing/chaining
  454. uint32 PageNumber; // Page number within the stream
  455. uint32 CRC; // CRC value, similar to the ZIP CRC32, but with swapped bits. For more info I can provide a small Java class.
  457. uint8 LacingCount;
  458.  };
  459. #pragma pack()
  461.  uint8*HeaderStart[3]={Header[0],Header[1],Header[2]};
  462.  const uint8*BufferStart=Buffer;
  464.  for(size_t PacketIndex=0;PacketIndex<3;)
  465.  {
  466.  // Read the next header
  467.  if(BufferSize<sizeof(PageHeader))
  468.  return false; // No data available for fixed header
  470.  // Read the fixed header
  471.  const PageHeader*CurrentPageHeader=reinterpret_cast<const PageHeader*>(Buffer);
  472.  Buffer+=sizeof(PageHeader);
  473.  BufferSize-=sizeof(PageHeader);
  475.  // Verify some fields
  476.  if(CurrentPageHeader->Magic[0]!='O'
  477.  ||CurrentPageHeader->Magic[1]!='g'
  478.  ||CurrentPageHeader->Magic[2]!='g'
  479.  ||CurrentPageHeader->Magic[3]!='S'
  480.  )
  481.  return false; // Our minimum requirement failed, see above for details
  483.  if(CurrentPageHeader->LacingCount>BufferSize)
  484.  return false; // No data available for lacing values
  485.  const uint8*CurrentLacings=Buffer;
  486.  Buffer+=CurrentPageHeader->LacingCount;
  487.  BufferSize-=CurrentPageHeader->LacingCount;
  489.  for(uint8 LacingIndex=0;PacketIndex<3&&LacingIndex<CurrentPageHeader->LacingCount;)
  490.  {
  491.  for(;PacketIndex<3&&LacingIndex<CurrentPageHeader->LacingCount;++LacingIndex)
  492.  {
  493.  if(BufferSize<CurrentLacings[LacingIndex])
  494.  return false; // No more data for the current part
  496.  // Copy the data
  497.  if(HeaderSize[PacketIndex]<CurrentLacings[LacingIndex])
  498.  return false; // No more space in output buffer
  499.  memcpy(Header[PacketIndex],Buffer,CurrentLacings[LacingIndex]);
  500.  HeaderSize[PacketIndex]-=CurrentLacings[LacingIndex];
  501.  Header[PacketIndex]+=CurrentLacings[LacingIndex];
  502.  Buffer+=CurrentLacings[LacingIndex];
  504.  if(CurrentLacings[LacingIndex]<255)
  505.  {
  506.  // Found new end of packet. If this is the last header
  507.  // packet, we must be at the page end.
  508.  if(PacketIndex==2&&LacingIndex<(CurrentPageHeader->LacingCount-1))
  509.  return false;
  511.  ++PacketIndex;
  512.  }
  513.  }
  514.  }
  515.  }
  517.  // Buffer points to the end of the last header page
  518.  SplitPosition=Buffer-BufferStart;
  519.  for(size_t i=0;i<3;++i)
  520.  {
  521. HeaderSize[i]=Header[i]-HeaderStart[i];
  522. Header[i]=HeaderStart[i];
  523.  }
  525.  return true;
  526. }
  529. BOOL AudioSourceOggVorbis::init() {
  531. if( !f ) return FALSE;
  533. char *buffer;
  534. int bytes;
  536. ogg_sync_init(&oy); /* Now we can read pages */
  538. if( streamInit()==FALSE ) return FALSE;
  540. fseek( f, 0, SEEK_SET );
  541. uint8* Buffer = (uint8*)malloc( pos );
  542. size_t Size = fread( Buffer, 1, pos, f );
  544. uint8* Header = (uint8*)malloc( pos );
  545. uint8* Comments = (uint8*)malloc( pos );
  546. uint8* Codebook = (uint8*)malloc( pos );
  548. if( Buffer==NULL || Header==NULL || Comments==NULL || Codebook==NULL ) {
  549. failed:
  550. if( Buffer ) free( Buffer );
  551. if( Header ) free( Header );
  552. if( Comments ) free( Comments );
  553. if( Codebook ) free( Codebook );
  554. return FALSE;
  555. }
  557. size_t SplitPosition;
  558. size_t PacketSizes[] = { pos, pos, pos };
  559. uint8* PacketAddresses[] = { Header, Comments, Codebook };
  561. if( splitHeader( Buffer, Size, SplitPosition, PacketAddresses, PacketSizes )==FALSE )
  562. goto failed;
  564. int s = sizeof(WAVEFORMATEXTENSIBLE)+3*sizeof(size_t)+PacketSizes[0]+PacketSizes[1]+PacketSizes[2];
  565. s = (s+7) & -8;
  566. if( !allocFormat( s ) )
  567. goto failed;
  569. // prepare WAVEFORMAT
  570. WAVEFORMATEXTENSIBLE *wfext = (WAVEFORMATEXTENSIBLE *)getWaveFormat();
  572.     wfext->Format.wFormatTag = 0xFFFE; // WAVE_FORMAT_EXTENSIBLE
  573.     wfext->Format.nChannels = vi.channels;
  574.     wfext->Format.nSamplesPerSec = vi.rate;
  575.     wfext->Format.nAvgBytesPerSec = 176400;
  576.     wfext->Format.nBlockAlign = 20000; // ahem, testing...
  577.     wfext->Format.wBitsPerSample = 0;
  578.     wfext->Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)
  579. +3*sizeof(size_t)
  580. +PacketSizes[0]+PacketSizes[1]+PacketSizes[2]
  581. -sizeof(WAVEFORMATEX);
  583. //  wfext->Samples.wValidBitsPerSample = 0;       /* bits of precision  */
  584. //  wfext->Samples.wSamplesPerBlock = 0;          /* valid if wBitsPerSample==0 */
  585.     wfext->Samples.wReserved = 0;                 /* If neither applies, set to zero. */
  587. wfext->dwChannelMask = (1<<vi.channels)-1;
  589. // {6BA47966-3F83-4178-9665-00F0BF6292E5}
  590. // DEFINE_GUID(MEDIASUBTYPE_VorbisStream,0x6ba47966, 0x3f83, 0x4178, 0x96, 0x65, 0x0, 0xf0, 0xbf, 0x62, 0x92, 0xe5);
  591. GUID guid = { 0x6ba47966, 0x3f83, 0x4178, { 0x96, 0x65, 0x0, 0xf0, 0xbf, 0x62, 0x92, 0xe5 } };
  592. wfext->SubFormat = guid;
  594. // append the Ogg headers to the Wav header
  595. char* p = (char*)getWaveFormat()+sizeof(WAVEFORMATEXTENSIBLE);
  596. *(size_t*)p = PacketSizes[0]; p += sizeof(size_t);
  597. *(size_t*)p = PacketSizes[1]; p += sizeof(size_t);
  598. *(size_t*)p = PacketSizes[2]; p += sizeof(size_t);
  599. memcpy( p, PacketAddresses[0], PacketSizes[0] ); p += PacketSizes[0];
  600. memcpy( p, PacketAddresses[1], PacketSizes[1] ); p += PacketSizes[1];
  601. memcpy( p, PacketAddresses[2], PacketSizes[2] ); p += PacketSizes[2];
  604. // We need to know the length of the stream. Sure, there are other methods...
  606. int tot_pcm_samples = 0;
  608. // vorbis_synthesis_init( &vd, &vi );
  609. // vorbis_block_init( &vd, &vb );
  610. while( !eos ) {
  611. while( !eos ) {
  612. int result = ogg_sync_pageout( &oy, &og );
  613. if( result==0 ) break;
  614. if( result<0 ){
  615. //fprintf(stderr,"Corrupt or missing data in bitstream; continuing...n");
  616. }else{
  617. ogg_stream_pagein( &os, &og );
  618. while( TRUE ) {
  619. result = ogg_stream_packetout( &os, &op );
  620. if( result==0 ) break;
  621. if( result<0 ) {
  622. /* no reason to complain; already complained above */
  623. }else{
  624. int samples;
  625. float **pcm;
  627. if( vorbis_synthesis( &vb, &op )==0 ) /* test for success! */
  628. vorbis_synthesis_blockin( &vd, &vb );
  630. if( (samples=vorbis_synthesis_pcmout( &vd, &pcm ))>0) {
  632. tot_pcm_samples += samples;
  634. vorbis_synthesis_read( &vd, samples );
  635. }     
  636. }
  637. }
  638. if( ogg_page_eos( &og ) ) eos = 1;
  639. }
  640. }
  641. if( !eos ) {
  642. buffer = ogg_sync_buffer( &oy, 1 );
  643. bytes = fread( buffer, 1, 1, f);
  644. ogg_sync_wrote( &oy, bytes );
  645. if( bytes==0 ) eos = 1;
  646. }
  647. }
  649. ogg_stream_clear( &os );
  651. vorbis_block_clear( &vb );
  652. vorbis_dsp_clear( &vd );
  653. vorbis_comment_clear( &vc );
  654. vorbis_info_clear( &vi );
  657. // init some variables
  658. lSampleFirst = 0;
  659. lSampleLast = (tot_pcm_samples/20000)+1;
  661. pcm_samples = 0;
  662. pcm_written = 0;
  664. // reset the input
  666. fseek( f, 0, SEEK_SET );
  668. streamInit();
  669. while( pcm_samples<20000 ) {
  670. readPage();
  671. decodePage();
  672. }
  674. lCurrentSample = 0;
  676. if( Buffer ) free( Buffer );
  677. if( Header ) free( Header );
  678. if( Comments ) free( Comments );
  679. if( Codebook ) free( Codebook );
  681. // prepare StreamInfo
  682. streamInfo.fccType = streamtypeAUDIO;
  683. streamInfo.fccHandler = 0;
  684. streamInfo.dwFlags = 0;
  685. streamInfo.wPriority = 0;
  686. streamInfo.wLanguage = 0;
  687. streamInfo.dwInitialFrames = 0;
  688. streamInfo.dwScale = 20000;
  689. streamInfo.dwRate = vi.rate;
  690. streamInfo.dwStart = 0;
  691. streamInfo.dwLength = lSampleLast;
  692. streamInfo.dwSuggestedBufferSize = 0;
  693. streamInfo.dwQuality = 0xffffffff;
  694. streamInfo.dwSampleSize = 0;
  696. return TRUE;
  697. }
  700. void AudioSourceOggVorbis::readPage() 
  701. {
  702. char *buffer;
  703. int bytes;
  705. while( eos==0 && ogg_sync_pageout( &oy, &og )!=1 ) {
  706. buffer = ogg_sync_buffer( &oy, 1 );
  707. bytes = fread( buffer, 1, 1, f );
  708. ogg_sync_wrote( &oy, bytes );
  709. if( bytes==0 ) eos = 1;
  710. }
  711. }
  714. void AudioSourceOggVorbis::decodePage() 
  715. {
  716. ogg_stream_pagein( &os, &og );
  717. while( TRUE ) {
  718. int result = ogg_stream_packetout( &os, &op );
  719. if( result==0 ) break;
  720. if( result<0 ) {
  721. /* no reason to complain; already complained above */
  722. }else{
  723. int samples;
  724. float **pcm;
  726. if( vorbis_synthesis( &vb, &op )==0 ) /* test for success! */
  727. vorbis_synthesis_blockin( &vd, &vb );
  729. if( (samples=vorbis_synthesis_pcmout( &vd, &pcm ))>0) {
  731. pcm_samples += samples;
  733. vorbis_synthesis_read( &vd, samples );
  734. }     
  735. }
  736. }
  737. if( ogg_page_eos( &og ) ) eos = 1;
  738. }
  741. int AudioSourceOggVorbis::_read(LONG lStart, LONG lCount, LPVOID buffer, LONG cbBuffer, LONG *lBytesRead, LONG *lSamplesRead)
  742. {
  743. *lSamplesRead = 0;
  744. *lBytesRead = 0;
  746. if( buffer ) {
  748. if (lStart != lCurrentSample) {
  750. ogg_stream_clear( &os );
  751. vorbis_block_clear( &vb );
  752. vorbis_dsp_clear( &vd );
  753. vorbis_comment_clear( &vc );
  754. vorbis_info_clear( &vi );
  755. fseek( f, 0, SEEK_SET );
  756. streamInit();
  758. readPage();
  759. lCurrentSample = 0;
  761. while( lStart != lCurrentSample ) {
  762. fgetpos( f, &pos );
  763. readPage();
  765. lCurrentSample++;
  766. }
  767. }
  769. __int64 pos2;
  770. fgetpos( f, &pos2 );
  771. uint32 frame_size = (uint32)pos2 - pos;
  772. if( frame_size>cbBuffer ) return AVIERR_OK;
  774. fseek( f, pos, SEEK_SET );
  775. fread( buffer, frame_size, 1, f );
  777. cbBuffer -= frame_size;
  778. buffer = (void *)(((unsigned long)buffer)+frame_size);
  779. (*lBytesRead) += frame_size;
  781. pcm_samples -= 20000;
  783. pos = pos2;
  784. while( pcm_samples<20000 ) {
  785. readPage();
  786. decodePage();
  787. }
  789. lCurrentSample++;
  790. (*lSamplesRead) = 1;
  791. }
  793. return AVIERR_OK;
  794. }
  796. ///////////////////////////////////////////////////////////////////////////////////////////////////////
  798. AudioSourceAC3::AudioSourceAC3(char *szFile, LONG inputBufferSize) 
  799. {
  800. ac3File = fopen(szFile,"rb");
  801. }
  804. AudioSourceAC3::~AudioSourceAC3() 
  805. {
  806. if (ac3File!=NULL) fclose(ac3File);
  807. }
  809. BOOL AudioSourceAC3::init() 
  810. {
  811. WAVEFORMATEX *fmt, ac3WFmt;
  813. if( ac3File==NULL ) return FALSE;
  815. // extract WAVEFORMATEX from the AC3 file
  817. AC3FileSrc *ac3Src = new AC3FileSrc(ac3File);
  819. if( !ac3Src->Parse(&ac3WFmt) ) {
  820. delete ac3Src;
  821. return FALSE;
  822. }
  824. delete ac3Src;
  826. // allocate format structure
  827. if (!(fmt=(WAVEFORMATEX *) allocFormat(sizeof(WAVEFORMATEX)))) return FALSE;
  829. *fmt = ac3WFmt;
  830. {
  831. char szBuf[256];
  832. sprintf(szBuf, "FmtTag: 0x%x, SampFreq: %d, Channels: %d, bitrate: %d kb/s",
  833. fmt->wFormatTag,
  834. fmt->nSamplesPerSec,
  835. fmt->nChannels,
  836. (fmt->nAvgBytesPerSec*8)/1000);
  837. MessageBox(NULL,szBuf,"AC3 file parameters",MB_OK);
  838. }
  840. // get the length of the file
  841. fseek(ac3File,0,SEEK_END); 
  842. chunkDATA.cksize = ftell(ac3File);
  843. chunkDATA.dwDataOffset = 0;
  844. fseek(ac3File,0,SEEK_SET);
  846. bytesPerSample= getWaveFormat()->nBlockAlign; //getWaveFormat()->nAvgBytesPerSec / getWaveFormat()->nSamplesPerSec;
  847. lSampleFirst = 0;
  848. lSampleLast = chunkDATA.cksize / bytesPerSample;
  849. lCurrentSample= 0;
  851. streamInfo.fccType = streamtypeAUDIO;
  852. streamInfo.fccHandler = 0;
  853. streamInfo.dwFlags = 0;
  854. streamInfo.wPriority = 0;
  855. streamInfo.wLanguage = 0;
  856. streamInfo.dwInitialFrames = 0;
  857. streamInfo.dwScale = bytesPerSample;
  858. streamInfo.dwRate = getWaveFormat()->nAvgBytesPerSec;
  859. streamInfo.dwStart = 0;
  860. streamInfo.dwLength = chunkDATA.cksize / bytesPerSample;
  861. streamInfo.dwSuggestedBufferSize = 0;
  862. streamInfo.dwQuality = 0xffffffff;
  863. streamInfo.dwSampleSize = bytesPerSample;
  865. return TRUE;
  866. }
  868. int AudioSourceAC3::_read(LONG lStart, LONG lCount, LPVOID buffer, LONG cbBuffer, LONG *lBytesRead, LONG *lSamplesRead) 
  869. {
  870. LONG lBytes = lCount * bytesPerSample;
  872. if (lStart != lCurrentSample)
  873. if (-1 == fseek(ac3File, chunkDATA.dwDataOffset + bytesPerSample*lStart, SEEK_SET))
  874. return AVIERR_FILEREAD;
  876. if (lBytes != fread((char *)buffer, 1, lBytes, ac3File))
  877. return AVIERR_FILEREAD;
  879. *lSamplesRead = lCount;
  880. *lBytesRead = lBytes;
  882. lCurrentSample = lStart + lCount;
  884. return AVIERR_OK;
  885. }