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

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

VC书籍

开发平台：

Visual C++

CPI_Player_Output_Wave.c：源码内容
  1. #include "stdafx.h"
  2. #include "globals.h"
  3. #include "CPI_Player.h"
  4. #include "CPI_Player_CoDec.h"
  5. #include "CPI_Player_Output.h"
  6. #include "CPI_Equaliser.h"
  8. #define CPC_NUMBEROFOUTPUTBLOCKS 16
  9. #define CPC_OUTPUTBLOCKSIZE 0x8000 
  11. typedef struct __CPs_OutputContext_Wave
  12. {
  13.     HWAVEOUT m_hWaveOut;
  14.     WAVEHDR m_aryWaveBlocks[CPC_NUMBEROFOUTPUTBLOCKS];
  15.     DWORD m_aryBlockSizes[CPC_NUMBEROFOUTPUTBLOCKS];
  16.     void* m_pBlockBase;
  17.     int m_iLastReadBlockIDX;
  19.     CPs_EqualiserModule* m_pEqualiser;
  21. } CPs_OutputContext_Wave;
  22. ////////////////////////////////////////////////////////////////////////////////
  23. void CPP_OMWV_Initialise(CPs_OutputModule* pModule, const CPs_FileInfo* pFileInfo, CP_HEQUALISER hEqualiser);
  24. void CPP_OMWV_Uninitialise(CPs_OutputModule* pModule);
  25. void CPP_OMWV_RefillBuffers(CPs_OutputModule* pModule);
  26. void CPP_OMWV_SetPause(CPs_OutputModule* pModule, const BOOL bPause);
  27. BOOL CPP_OMWV_IsOutputComplete(CPs_OutputModule* pModule);
  28. void CPP_OMWV_Flush(CPs_OutputModule* pModule);
  29. void CPP_OMWV_OnEQChanged(CPs_OutputModule* pModule);
  30. void CPP_OMWV_SetInternalVolume(CPs_OutputModule* pModule, const int iNewVolume);
  31. ////////////////////////////////////////////////////////////////////////////////
  32. void CPI_Player_Output_Initialise_WaveMapper(CPs_OutputModule* pModule)
  33. {
  34.     pModule->Initialise = CPP_OMWV_Initialise;
  35.     pModule->Uninitialise = CPP_OMWV_Uninitialise;
  36.     pModule->RefillBuffers = CPP_OMWV_RefillBuffers;
  37.     pModule->SetPause = CPP_OMWV_SetPause;
  38.     pModule->IsOutputComplete = CPP_OMWV_IsOutputComplete;
  39.     pModule->Flush = CPP_OMWV_Flush;
  40.     pModule->OnEQChanged = CPP_OMWV_OnEQChanged;
  41.     pModule->SetInternalVolume = CPP_OMWV_SetInternalVolume;
  42.     pModule->m_pModuleCookie = NULL;
  43.     pModule->m_pcModuleName = "Cooler Wave mapper";
  44.     pModule->m_pCoDec = NULL;
  45.     pModule->m_pEqualiser = NULL;
  46. }
  48. void CPP_OMWV_Initialise(CPs_OutputModule* pModule, const CPs_FileInfo* pFileInfo, CP_HEQUALISER hEqualiser)
  49. {
  50.     MMRESULT mmErr;
  52.     CPs_OutputContext_Wave* pContext;
  53.     CP_ASSERT(pModule->m_pModuleCookie == NULL);
  54.     pContext = (CPs_OutputContext_Wave*)malloc(sizeof(CPs_OutputContext_Wave));
  55.     pModule->m_pModuleCookie = pContext;
  56.     CP_TRACE0("Wave out initialising");
  58.     pModule->m_evtBlockFree = CreateEvent(NULL, FALSE, FALSE, NULL);
  60.     {
  61.         WAVEFORMATEX waveformatex;
  62.         waveformatex.wFormatTag = WAVE_FORMAT_PCM;
  63.         waveformatex.nChannels = pFileInfo->m_bStereo ? 2 : 1;
  64.         waveformatex.nSamplesPerSec = pFileInfo->m_iFreq_Hz;
  65.         waveformatex.wBitsPerSample = pFileInfo->m_b16bit ? 16 : 8;
  66.         waveformatex.nBlockAlign = (waveformatex.nChannels * waveformatex.wBitsPerSample)>>3;
  67.         waveformatex.nAvgBytesPerSec = waveformatex.nSamplesPerSec * waveformatex.nBlockAlign;
  68.         waveformatex.cbSize = 0;
  69.         mmErr = waveOutOpen( &pContext->m_hWaveOut,
  70.                              WAVE_MAPPER,
  71.                              &waveformatex,
  72.                              (DWORD)pModule->m_evtBlockFree,
  73.                              0, CALLBACK_EVENT);
  75.         if(mmErr != MMSYSERR_NOERROR)
  76.         {
  77.             CP_TRACE1("Wave Open error 0x%X", mmErr);
  78.             pContext->m_hWaveOut = NULL;
  79.             DeleteObject(pModule->m_evtBlockFree);
  80.         }
  82.     }
  84.     pContext->m_pBlockBase = VirtualAlloc( NULL,
  85.                                            CPC_OUTPUTBLOCKSIZE * (CPC_NUMBEROFOUTPUTBLOCKS<<1),
  86.                                            MEM_COMMIT, PAGE_READWRITE);
  87.     pContext->m_iLastReadBlockIDX = 0;
  89.     {
  90.         void* pBlockCursor = pContext->m_pBlockBase;
  91.         int iWaveBlockIDX;
  92.         for(iWaveBlockIDX=0; iWaveBlockIDX < CPC_NUMBEROFOUTPUTBLOCKS; iWaveBlockIDX++)
  93.         {
  94.             pContext->m_aryWaveBlocks[iWaveBlockIDX].dwFlags = 0;
  95.             pContext->m_aryWaveBlocks[iWaveBlockIDX].lpData = pBlockCursor;
  96.             pContext->m_aryWaveBlocks[iWaveBlockIDX].dwBufferLength = CPC_OUTPUTBLOCKSIZE;
  98.             waveOutPrepareHeader(pContext->m_hWaveOut, pContext->m_aryWaveBlocks + iWaveBlockIDX, sizeof(*pContext->m_aryWaveBlocks));
  99.             pBlockCursor = (void*)( (BYTE*)pBlockCursor + CPC_OUTPUTBLOCKSIZE);
  100.         }
  101.     }
  103.     SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
  104.     pModule->m_pEqualiser = hEqualiser;
  105. }
  106. void CPP_OMWV_Uninitialise(CPs_OutputModule* pModule)
  107. {
  108.     CPs_OutputContext_Wave* pContext = (CPs_OutputContext_Wave*)pModule->m_pModuleCookie;
  109.     CP_CHECKOBJECT(pContext);
  110.     CP_TRACE0("Wave out shutting down");
  111.     SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
  113.     if(pContext->m_hWaveOut)
  114.     {
  115.         waveOutRestart(pContext->m_hWaveOut);
  116.         waveOutReset(pContext->m_hWaveOut);
  118.         {
  119.             int iWaveBlockIDX;
  120.             for(iWaveBlockIDX=0; iWaveBlockIDX < CPC_NUMBEROFOUTPUTBLOCKS; iWaveBlockIDX++)
  121.                 waveOutUnprepareHeader(pContext->m_hWaveOut, pContext->m_aryWaveBlocks + iWaveBlockIDX, sizeof(*pContext->m_aryWaveBlocks));
  122.         }
  124.         VirtualFree(pContext->m_pBlockBase, 0, MEM_RELEASE);
  126.         waveOutClose(pContext->m_hWaveOut);
  127.         DeleteObject(pModule->m_evtBlockFree);
  128.     }
  129.     free(pContext);
  130.     pModule->m_pModuleCookie = NULL;
  131. }
  132. //
  133. void CPP_OMWV_RefillBuffers(CPs_OutputModule* pModule)
  134. {
  135.     int iBlockIDX;
  137.     CPs_OutputContext_Wave* pContext = (CPs_OutputContext_Wave*)pModule->m_pModuleCookie;
  138.     CP_CHECKOBJECT(pContext);
  139.     if(!pContext->m_hWaveOut)
  140.         return;
  141.     for(iBlockIDX = 0; iBlockIDX < CPC_NUMBEROFOUTPUTBLOCKS; iBlockIDX++)
  142.     {
  143.         WAVEHDR* pOutputBlock = pContext->m_aryWaveBlocks + iBlockIDX;
  144.         if( (pOutputBlock->dwFlags & WHDR_INQUEUE) == 0)
  145.         {
  146.             BOOL bMoreData;
  148.             pOutputBlock->dwBufferLength = CPC_OUTPUTBLOCKSIZE;
  149.             bMoreData = pModule->m_pCoDec->GetPCMBlock(pModule->m_pCoDec, pOutputBlock->lpData, &pOutputBlock->dwBufferLength);
  151.             pContext->m_iLastReadBlockIDX = iBlockIDX;
  152.             pContext->m_aryBlockSizes[iBlockIDX] = pOutputBlock->dwBufferLength;
  153.             memcpy( ((BYTE*)pOutputBlock->lpData) + (CPC_OUTPUTBLOCKSIZE * CPC_NUMBEROFOUTPUTBLOCKS),
  154.                     pOutputBlock->lpData,
  155.                     pOutputBlock->dwBufferLength);
  157.             {
  158.                 CPs_EqualiserModule* pEQModule = (CPs_EqualiserModule*)pModule->m_pEqualiser;
  159.                 pEQModule->ApplyEQToBlock_Inplace(pEQModule, pOutputBlock->lpData, pOutputBlock->dwBufferLength);
  160.             }
  162.             if(pOutputBlock->dwBufferLength > 0)
  163.                 waveOutWrite(pContext->m_hWaveOut, pOutputBlock, sizeof(*pOutputBlock));
  165.             if(bMoreData == FALSE)
  166.             {
  167.                 pModule->m_pCoDec->CloseFile(pModule->m_pCoDec);
  168.                 pModule->m_pCoDec = NULL;
  169.                 break;
  170.             }
  172.         }
  173.     }
  174. }
  175. //
  176. void CPP_OMWV_SetPause(CPs_OutputModule* pModule, const BOOL bPause)
  177. {
  178.     CPs_OutputContext_Wave* pContext = (CPs_OutputContext_Wave*)pModule->m_pModuleCookie;
  179.     CP_CHECKOBJECT(pContext);
  180.     if(!pContext->m_hWaveOut)
  181.         return;
  183.     if(bPause == TRUE)
  184.         waveOutPause(pContext->m_hWaveOut);
  185.     else
  186.         waveOutRestart(pContext->m_hWaveOut);
  187. }
  188. //
  189. BOOL CPP_OMWV_IsOutputComplete(CPs_OutputModule* pModule)
  190. {
  191.     int iBlockIDX;
  192.     CPs_OutputContext_Wave* pContext = (CPs_OutputContext_Wave*)pModule->m_pModuleCookie;
  193.     CP_CHECKOBJECT(pContext);
  194.     if(!pContext->m_hWaveOut)
  195.         return TRUE;
  197.     for(iBlockIDX = 0; iBlockIDX < CPC_NUMBEROFOUTPUTBLOCKS; iBlockIDX++)
  198.     {
  199.         if( (pContext->m_aryWaveBlocks[iBlockIDX].dwFlags & WHDR_INQUEUE))
  200.             return FALSE;
  201.     }
  203.     return TRUE;
  204. }
  205. //
  206. void CPP_OMWV_OnEQChanged(CPs_OutputModule* pModule)
  207. {
  208.     CPs_OutputContext_Wave* pContext = (CPs_OutputContext_Wave*)pModule->m_pModuleCookie;
  209.     int iBlockIDX;
  211.     CP_CHECKOBJECT(pContext);
  212.     if(!pContext->m_hWaveOut)
  213.         return;
  215.     for(iBlockIDX = pContext->m_iLastReadBlockIDX + 1; iBlockIDX < CPC_NUMBEROFOUTPUTBLOCKS; iBlockIDX++)
  216.     {
  217.         if( (pContext->m_aryWaveBlocks[iBlockIDX].dwFlags & (WHDR_INQUEUE | WHDR_DONE) ))
  218.         {
  219.             WAVEHDR* pOutputBlock = pContext->m_aryWaveBlocks + iBlockIDX;
  221.             pOutputBlock->dwBufferLength = pContext->m_aryBlockSizes[iBlockIDX];
  222.             memcpy( pOutputBlock->lpData,
  223.                     ((BYTE*)pOutputBlock->lpData) + (CPC_OUTPUTBLOCKSIZE * CPC_NUMBEROFOUTPUTBLOCKS),
  224.                     pOutputBlock->dwBufferLength);
  226.             {
  227.                 CPs_EqualiserModule* pEQModule = (CPs_EqualiserModule*)pModule->m_pEqualiser;
  228.                 pEQModule->ApplyEQToBlock_Inplace(pEQModule, pOutputBlock->lpData, pOutputBlock->dwBufferLength);
  229.             }
  230.         }
  231.     }
  232.     for(iBlockIDX = 0; iBlockIDX <= pContext->m_iLastReadBlockIDX; iBlockIDX++)
  233.     {
  234.         if( (pContext->m_aryWaveBlocks[iBlockIDX].dwFlags & (WHDR_INQUEUE | WHDR_DONE) ))
  235.         {
  236.             WAVEHDR* pOutputBlock = pContext->m_aryWaveBlocks + iBlockIDX;
  238.             pOutputBlock->dwBufferLength = pContext->m_aryBlockSizes[iBlockIDX];
  239.             memcpy( pOutputBlock->lpData,
  240.                     ((BYTE*)pOutputBlock->lpData) + (CPC_OUTPUTBLOCKSIZE * CPC_NUMBEROFOUTPUTBLOCKS),
  241.                     pOutputBlock->dwBufferLength);
  243.             {
  244.                 CPs_EqualiserModule* pEQModule = (CPs_EqualiserModule*)pModule->m_pEqualiser;
  245.                 pEQModule->ApplyEQToBlock_Inplace(pEQModule, pOutputBlock->lpData, pOutputBlock->dwBufferLength);
  246.             }
  247.         }
  248.     }
  249. }
  250. void CPP_OMWV_Flush(CPs_OutputModule* pModule)
  251. {
  252.     CPs_OutputContext_Wave* pContext = (CPs_OutputContext_Wave*)pModule->m_pModuleCookie;
  254.     CP_CHECKOBJECT(pContext);
  255.     if(!pContext->m_hWaveOut)
  256.         return;
  258.     waveOutRestart(pContext->m_hWaveOut);
  259.     waveOutReset(pContext->m_hWaveOut);
  261.     CP_ASSERT(CPP_OMWV_IsOutputComplete(pModule));
  262. }
  263. //
  264. void CPP_OMWV_SetInternalVolume(CPs_OutputModule* pModule, const int iNewVolume)
  265. {
  266.     CPs_OutputContext_Wave* pContext = (CPs_OutputContext_Wave*)pModule->m_pModuleCookie;
  267.     int iNewVolume_DWORD;
  268.     CP_CHECKOBJECT(pContext);
  269.     if(!pContext->m_hWaveOut)
  270.         return;
  272.     iNewVolume_DWORD = iNewVolume * 656;
  273.     if(iNewVolume_DWORD > 0xFFFF)
  274.         iNewVolume_DWORD = 0xFFFF;
  275.     iNewVolume_DWORD |= (iNewVolume_DWORD<<16);
  277.     waveOutSetVolume(pContext->m_hWaveOut, iNewVolume_DWORD);
  278. }
  279. //