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

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

VC书籍

开发平台：

Visual C++

CPI_Player_Output_DirectSound.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"
  7. #define DIRECTSOUND_VERSION 0x0500  
  8. #include <dsound.h> 
  9. #include <math.h> 
  11. #define CPC_OUTPUTBLOCKSIZE 0x10000 
  12. #define CPC_MAXFILLAMOUNT (CPC_OUTPUTBLOCKSIZE>>4) 
  13. #define CPC_INVALIDCURSORPOS 0xFFFFFFFF
  15. typedef struct __CPs_OutputContext_DirectSound
  16. {
  17.     LPDIRECTSOUNDBUFFER lpDSB;
  18.     LPDIRECTSOUND lpDirectSound;
  19.     WAVEFORMATEX WaveFile;
  20.     DWORD m_WriteCursor;
  21.     BOOL m_TermState_Wrapped;
  22.     DWORD m_TermState_WriteCursor;
  23.     DWORD m_TermState_HighestPlayPos;
  24.     DWORD m_TimerId;
  25.     BOOL m_bStreamRunning;
  26.     CPs_EqualiserModule* m_pEqualiser;
  27.     BYTE* m_pShadowBuffer;
  28. } CPs_OutputContext_DirectSound;
  29. //
  30. void CPP_OMDS_Initialise(CPs_OutputModule* pModule, const CPs_FileInfo* pFileInfo, CP_HEQUALISER hEqualiser);
  31. void CPP_OMDS_Uninitialise(CPs_OutputModule* pModule);
  32. void CPP_OMDS_RefillBuffers(CPs_OutputModule* pModule);
  33. void CPP_OMDS_SetPause(CPs_OutputModule* pModule, const BOOL bPause);
  34. BOOL CPP_OMDS_IsOutputComplete(CPs_OutputModule* pModule);
  35. void CPP_OMDS_Flush(CPs_OutputModule* pModule);
  36. void CPP_OMDS_SetVolume(CPs_OutputModule* pModule, int iVolume);
  37. void CPP_OMDS_GetVolume(CPs_OutputModule* pModule, int *iVolume, HANDLE waitevent);
  38. void CPP_OMDS_EnablePlay(CPs_OutputModule* pModule, const BOOL bEnable);
  39. void CPP_OMDS_OnEQChanged(CPs_OutputModule* pModule);
  40. void CPP_OMDS_SetInternalVolume(CPs_OutputModule* pModule, const int iNewVolume);
  41. ////////////////////////////////////////////////////////////////////////////////
  43. void CPI_Player_Output_Initialise_DirectSound(CPs_OutputModule* pModule)
  44. {
  45.     pModule->Initialise = CPP_OMDS_Initialise;
  46.     pModule->Uninitialise = CPP_OMDS_Uninitialise;
  47.     pModule->RefillBuffers = CPP_OMDS_RefillBuffers;
  48.     pModule->SetPause = CPP_OMDS_SetPause;
  49.     pModule->IsOutputComplete = CPP_OMDS_IsOutputComplete;
  50.     pModule->Flush = CPP_OMDS_Flush;
  51.     pModule->OnEQChanged = CPP_OMDS_OnEQChanged;
  52.     pModule->SetInternalVolume = CPP_OMDS_SetInternalVolume;
  53.     pModule->m_pModuleCookie = NULL;
  54.     pModule->m_pcModuleName = "DirectSound Plugout";
  55.     pModule->m_pCoDec = NULL;
  56.     pModule->m_pEqualiser = NULL;
  57. }
  58. //
  59. void CPP_OMDS_Initialise(CPs_OutputModule* pModule, const CPs_FileInfo* pFileInfo, CP_HEQUALISER hEqualiser)
  60. {
  61.     
  62.     DSBUFFERDESC dsbd;
  63.     HRESULT hrRetVal;
  65.     CPs_OutputContext_DirectSound* pContext;
  66.     CP_ASSERT(pModule->m_pModuleCookie == NULL);
  67.     pContext = (CPs_OutputContext_DirectSound*)malloc(sizeof(CPs_OutputContext_DirectSound));
  68.     pModule->m_pModuleCookie = pContext;
  69.     CP_TRACE0("DirectSound initialising");
  71.     pModule->m_evtBlockFree = CreateEvent(NULL, FALSE, FALSE, NULL);
  73.     if(DirectSoundCreate(NULL,&(pContext->lpDirectSound), NULL))
  74.     {
  75.         CP_FAIL("Cannot create DirectSound Object");
  76.     }
  78.     if(IDirectSound_SetCooperativeLevel(pContext->lpDirectSound, windows.wnd_main, DSSCL_NORMAL))
  79.     {
  80.         CPP_OMDS_Uninitialise(pModule);
  81.         CP_FAIL("Can't set DirectSound Cooperative level");
  82.     }
  84.     if(!pContext->lpDirectSound)
  85.     {
  86.         CPP_OMDS_Uninitialise(pModule);
  87.         CP_FAIL("Unable to initialise DirectSound");
  88.     }
  90.     pContext->WaveFile.wFormatTag = WAVE_FORMAT_PCM;
  91.     pContext->WaveFile.nChannels = pFileInfo->m_bStereo ? 2 : 1;
  92.     pContext->WaveFile.nSamplesPerSec = pFileInfo->m_iFreq_Hz;
  93.     pContext->WaveFile.wBitsPerSample = pFileInfo->m_b16bit ? 16 : 8;
  94.     pContext->WaveFile.nBlockAlign = (pContext->WaveFile.nChannels * pContext->WaveFile.wBitsPerSample)>>3;
  95.     pContext->WaveFile.nAvgBytesPerSec = pContext->WaveFile.nSamplesPerSec * pContext->WaveFile.nBlockAlign;
  96.     pContext->WaveFile.cbSize = 0;
  98.     memset(&dsbd, 0, sizeof(DSBUFFERDESC));
  99.     dsbd.dwSize = sizeof(DSBUFFERDESC);
  100.     dsbd.dwFlags = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_GLOBALFOCUS | DSBCAPS_CTRLVOLUME;
  101.     dsbd.dwBufferBytes = CPC_OUTPUTBLOCKSIZE;
  102.     dsbd.lpwfxFormat = &pContext->WaveFile;
  103.     hrRetVal = IDirectSound_CreateSoundBuffer(pContext->lpDirectSound,
  104.                &dsbd,
  105.                &(pContext->lpDSB),
  106.                NULL);
  107.     if(FAILED(hrRetVal))
  108.     {
  109.         pContext->lpDSB = NULL;
  110.         CP_FAIL("Cannot create soundbuffer");
  111.     }
  113.     {
  114.         BYTE *pbData = NULL;
  115.         DWORD dwLength;
  117.         IDirectSoundBuffer_Lock(pContext->lpDSB,
  118.                                 0,
  119.                                 CPC_OUTPUTBLOCKSIZE,
  120.                                 &pbData,
  121.                                 &dwLength,
  122.                                 NULL,
  123.                                 NULL,
  124.                                 0);
  126.         if(pbData)
  127.             memset(pbData, 0, dwLength);
  129.         IDirectSoundBuffer_Unlock(pContext->lpDSB,
  130.                                   pbData,
  131.                                   dwLength,
  132.                                   NULL,
  133.                                   0L);
  134.     }
  136.     pContext->m_WriteCursor = CPC_INVALIDCURSORPOS;
  137.     pContext->m_TermState_Wrapped = FALSE;
  138.     pContext->m_TermState_WriteCursor = CPC_INVALIDCURSORPOS;
  139.     pContext->m_TermState_HighestPlayPos = CPC_INVALIDCURSORPOS;
  140.     pContext->m_TimerId = 0;
  141.     pContext->m_bStreamRunning = FALSE;
  143.     pContext->m_pShadowBuffer = (BYTE*)malloc(CPC_OUTPUTBLOCKSIZE);
  144.     memset(pContext->m_pShadowBuffer, 0, CPC_OUTPUTBLOCKSIZE);
  146.     SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
  147.     pModule->m_pEqualiser = hEqualiser;
  148. }
  149. //
  150. void CPP_OMDS_Uninitialise(CPs_OutputModule* pModule)
  151. {
  152.     CPs_OutputContext_DirectSound* pContext = (CPs_OutputContext_DirectSound*)pModule->m_pModuleCookie;
  153.     CP_CHECKOBJECT(pContext);
  154.     CP_TRACE0("DirectSound shutting down");
  155.     SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
  157.     if(pContext->lpDSB)
  158.     {
  159.         IDirectSoundBuffer_Release(pContext->lpDSB);
  160.     }
  162.     if(pContext->lpDirectSound)
  163.     {
  164.         IDirectSound_Release(pContext->lpDirectSound);
  165.         DeleteObject(pModule->m_evtBlockFree);
  166.     }
  168.     if(pContext->m_TimerId)
  169.     {
  170.         timeKillEvent(pContext->m_TimerId);
  171.         pContext->m_TimerId = 0;
  172.     }
  174.     pContext->lpDirectSound=NULL;
  175.     pContext->lpDSB=NULL;
  176.     free(pContext->m_pShadowBuffer);
  177.     free(pContext);
  178.     pContext=NULL;
  179.     pModule->m_pModuleCookie = NULL;
  180. }
  182. void GetPlayPosAndInvalidLength(CPs_OutputContext_DirectSound* pContext, DWORD* pdwPlayPos, DWORD* pdwLength)
  183. {
  184.     HRESULT hrResult;
  186.     hrResult = IDirectSoundBuffer_GetCurrentPosition(pContext->lpDSB, pdwPlayPos, NULL);
  187.     if(FAILED(hrResult))
  188.         CP_TRACE0("Failed call to IDirectSoundBuffer_GetCurrentPosition");
  190.     if(pContext->m_WriteCursor != CPC_INVALIDCURSORPOS)
  191.     {
  192.         if(pContext->m_WriteCursor >= *pdwPlayPos)
  193.             *pdwLength = (CPC_OUTPUTBLOCKSIZE - pContext->m_WriteCursor) + *pdwPlayPos;
  194.         else
  195.             *pdwLength = *pdwPlayPos - pContext->m_WriteCursor;
  196.     }
  197.     else
  198.     {
  199.         pContext->m_WriteCursor = 0;
  200.         *pdwLength = CPC_OUTPUTBLOCKSIZE;
  201.     }
  202. }
  203. //
  205. void CPP_OMDS_RefillBuffers(CPs_OutputModule* pModule)
  206. {
  207.     HRESULT hrRetVal;
  208.     BYTE *pbData;
  209.     DWORD dwLength=0;
  210.     BOOL bMoreData=TRUE;
  211.     DWORD RealLength;
  212.     DWORD dwAmountToFill, dwCurrentPlayCursor;
  213.     CPs_OutputContext_DirectSound* pContext = (CPs_OutputContext_DirectSound*)pModule->m_pModuleCookie;
  214.     CP_CHECKOBJECT(pContext);
  216.     if(!pContext->lpDirectSound)
  217.         return;
  219.     GetPlayPosAndInvalidLength(pContext, &dwCurrentPlayCursor, &dwAmountToFill);
  221.     
  222.     if(dwAmountToFill > CPC_MAXFILLAMOUNT && pContext->m_bStreamRunning == FALSE)
  223.         dwAmountToFill = CPC_MAXFILLAMOUNT;
  225.     
  226.     if(dwAmountToFill > 0)
  227.     {
  228.         hrRetVal = IDirectSoundBuffer_Lock(pContext->lpDSB,
  229.                                            0,
  230.                                            CPC_OUTPUTBLOCKSIZE,
  231.                                            &pbData,
  232.                                            &dwLength,
  233.                                            NULL,
  234.                                            NULL,
  235.                                            0);
  236.         if(FAILED(hrRetVal))
  237.         {
  238.             CPP_OMDS_Uninitialise(pModule);
  239.             CP_FAIL("Cannot lock soundbuffer");
  240.         }
  242.         if( (pContext->m_WriteCursor + dwAmountToFill) >= CPC_OUTPUTBLOCKSIZE)
  243.             RealLength = CPC_OUTPUTBLOCKSIZE - pContext->m_WriteCursor;
  244.         else
  245.             RealLength = dwAmountToFill;
  246.         if(RealLength)
  247.         {
  248.             bMoreData = pModule->m_pCoDec->GetPCMBlock(pModule->m_pCoDec, pContext->m_pShadowBuffer + pContext->m_WriteCursor, &RealLength);
  249.             memcpy(pbData + pContext->m_WriteCursor, pContext->m_pShadowBuffer + pContext->m_WriteCursor, RealLength);
  250.         }
  252.         {
  253.             CPs_EqualiserModule* pEQModule = (CPs_EqualiserModule*)pModule->m_pEqualiser;
  254.             if(RealLength)
  255.                 pEQModule->ApplyEQToBlock_Inplace(pEQModule, pbData + pContext->m_WriteCursor, RealLength);
  256.         }
  258.         pContext->m_WriteCursor += RealLength;
  259.         if(pContext->m_WriteCursor >= CPC_OUTPUTBLOCKSIZE)
  260.             pContext->m_WriteCursor -= CPC_OUTPUTBLOCKSIZE;
  262.         hrRetVal = IDirectSoundBuffer_Unlock(pContext->lpDSB,
  263.                                              pbData,
  264.                                              dwLength,
  265.                                              NULL,
  266.                                              0L);
  267.         if(FAILED(hrRetVal))
  268.         {
  269.             CPP_OMDS_Uninitialise(pModule);
  270.             CP_FAIL("Cannot Unlock soundbuffer");
  271.         }
  272.     }
  274.     if(bMoreData == FALSE)
  275.     {
  276.         CP_TRACE0("Stream exhausted");
  277.         pModule->m_pCoDec->CloseFile(pModule->m_pCoDec);
  278.         pModule->m_pCoDec = NULL;
  279.     }
  281.     pContext->m_TermState_Wrapped = FALSE;
  282.     pContext->m_TermState_WriteCursor = CPC_INVALIDCURSORPOS;
  283.     pContext->m_TermState_HighestPlayPos = CPC_INVALIDCURSORPOS;
  284.     if(!pContext->m_bStreamRunning)
  285.         CPP_OMDS_EnablePlay(pModule, TRUE);
  286. }
  287. //
  288. void CPP_OMDS_SetPause(CPs_OutputModule* pModule, const BOOL bPause)
  289. {
  290.     CPs_OutputContext_DirectSound* pContext = (CPs_OutputContext_DirectSound*)pModule->m_pModuleCookie;
  291.     CP_CHECKOBJECT(pContext);
  292.     if(!pContext->lpDirectSound)
  293.         return;
  295.     CPP_OMDS_EnablePlay(pModule, !bPause);
  296. }
  297. //
  298. BOOL CPP_OMDS_IsOutputComplete(CPs_OutputModule* pModule)
  299. {
  300.     CPs_OutputContext_DirectSound* pContext = (CPs_OutputContext_DirectSound*)pModule->m_pModuleCookie;
  301.     DWORD dwCurrentPlayCursor, dwInvalidLength;
  302.     CP_CHECKOBJECT(pContext);
  304.     if(!pContext->lpDirectSound)
  305.         return TRUE;
  307.     if(pContext->m_WriteCursor == CPC_INVALIDCURSORPOS)
  308.         return TRUE;
  310.     if(pContext->m_TermState_WriteCursor == CPC_INVALIDCURSORPOS)
  311.         pContext->m_TermState_WriteCursor = pContext->m_WriteCursor;
  313.     if(pModule->m_pCoDec)
  314.         return FALSE;
  316.     GetPlayPosAndInvalidLength(pContext, &dwCurrentPlayCursor, &dwInvalidLength);
  318.     if(dwInvalidLength > 0)
  319.     {
  320.         BYTE *pbData = NULL;
  321.         DWORD dwLength=0;
  323.         IDirectSoundBuffer_Lock(pContext->lpDSB,
  324.                                 pContext->m_WriteCursor,
  325.                                 dwInvalidLength,
  326.                                 &pbData,
  327.                                 &dwLength,
  328.                                 NULL,
  329.                                 NULL,
  330.                                 0);
  332.         if(pbData)
  333.             memset(pbData, 0, dwLength);
  335.         IDirectSoundBuffer_Unlock(pContext->lpDSB,
  336.                                   pbData,
  337.                                   dwLength,
  338.                                   NULL,
  339.                                   0L);
  341.         pContext->m_WriteCursor += dwInvalidLength;
  342.         if(pContext->m_WriteCursor >= CPC_OUTPUTBLOCKSIZE)
  343.             pContext->m_WriteCursor -= CPC_OUTPUTBLOCKSIZE;
  345.     }
  347.     if(pContext->m_TermState_HighestPlayPos == CPC_INVALIDCURSORPOS || pContext->m_TermState_HighestPlayPos < dwCurrentPlayCursor)
  348.         pContext->m_TermState_HighestPlayPos = dwCurrentPlayCursor;
  349.     else
  350.         pContext->m_TermState_Wrapped = TRUE;
  352.     if(pContext->m_TermState_Wrapped == FALSE)
  353.         return FALSE;
  355.     if(dwCurrentPlayCursor > pContext->m_TermState_WriteCursor)
  356.         return TRUE;
  358.     return FALSE;
  359. }
  360. //
  361. void CPP_OMDS_Flush(CPs_OutputModule* pModule)
  362. {
  363.     DWORD dwCurrentPlayCursor;
  364.     CPs_OutputContext_DirectSound* pContext = (CPs_OutputContext_DirectSound*)pModule->m_pModuleCookie;
  365.     CP_CHECKOBJECT(pContext);
  366.     if(!pContext->lpDirectSound)
  367.         return;
  369.     CPP_OMDS_EnablePlay(pModule, FALSE);
  370.     IDirectSoundBuffer_GetCurrentPosition(pContext->lpDSB, &dwCurrentPlayCursor, NULL);
  371.     pContext->m_WriteCursor = dwCurrentPlayCursor;
  372. }
  373. //
  374. void CPP_OMDS_EnablePlay(CPs_OutputModule* pModule, const BOOL bEnable)
  375. {
  376.     CPs_OutputContext_DirectSound* pContext = (CPs_OutputContext_DirectSound*)pModule->m_pModuleCookie;
  377.     CP_CHECKOBJECT(pContext);
  378.     pContext->m_bStreamRunning = bEnable;
  380.     if(bEnable)
  381.     {
  382.         IDirectSoundBuffer_Play(pContext->lpDSB,0,0,DSBPLAY_LOOPING);
  384.         if(pContext->m_TimerId == 0)
  385.         {
  386.             pContext->m_TimerId = timeSetEvent(20,
  387.                                                10,
  388.                                                (LPTIMECALLBACK)pModule->m_evtBlockFree,
  389.                                                0,
  390.                                                TIME_PERIODIC | TIME_CALLBACK_EVENT_SET);
  391.         }
  392.     }
  393.     else
  394.     {
  395.         IDirectSoundBuffer_Stop(pContext->lpDSB);
  396.         timeKillEvent(pContext->m_TimerId);
  397.         pContext->m_TimerId = 0;
  398.     }
  399. }
  400. //
  401. void CPP_OMDS_OnEQChanged(CPs_OutputModule* pModule)
  402. {
  403.     CPs_OutputContext_DirectSound* pContext = (CPs_OutputContext_DirectSound*)pModule->m_pModuleCookie;
  404.     BYTE *pbData = NULL;
  405.     DWORD dwLength=0;
  406. //    DWORD dwPlayPos;
  407. //    CPs_EqualiserModule* pEQModule;
  408.     CP_CHECKOBJECT(pContext);
  410.   /*  
  411.     IDirectSoundBuffer_GetCurrentPosition(pContext->lpDSB, &dwPlayPos, NULL);
  413.     IDirectSoundBuffer_Lock(pContext->lpDSB,
  414.                             0,
  415.                             CPC_OUTPUTBLOCKSIZE,
  416.                             &pbData,
  417.                             &dwLength,
  418.                             NULL,
  419.                             NULL,
  420.                             0);
  422.     if(pbData)
  423.         memcpy(pbData, pContext->m_pShadowBuffer, dwLength);
  425.    
  426.     pEQModule = (CPs_EqualiserModule*)pModule->m_pEqualiser;
  427.     if(pContext->m_WriteCursor > dwPlayPos)
  428.     {
  429.         
  430.         if(pContext->m_WriteCursor != CPC_INVALIDCURSORPOS)
  431.             pEQModule->ApplyEQToBlock_Inplace(pEQModule, pbData + dwPlayPos, pContext->m_WriteCursor - dwPlayPos);
  432.     }
  433.     else
  434.     {
  435.        
  436.      
  437.         pEQModule->ApplyEQToBlock_Inplace(pEQModule, pbData + dwPlayPos, CPC_OUTPUTBLOCKSIZE - dwPlayPos);
  438.         pEQModule->ApplyEQToBlock_Inplace(pEQModule, pbData, pContext->m_WriteCursor);
  439.     }
  441.     IDirectSoundBuffer_Unlock(pContext->lpDSB,
  442.                               pbData,
  443.                               dwLength,
  444.                               NULL,
  445.                               0L);
  446.   */
  447. }
  449. void CPP_OMDS_SetInternalVolume(CPs_OutputModule* pModule, const int iNewVolume)
  450. {
  451.     CPs_OutputContext_DirectSound* pContext = (CPs_OutputContext_DirectSound*)pModule->m_pModuleCookie;
  452.     LONG lVolume;
  453.     CP_CHECKOBJECT(pContext);
  455.     lVolume = (int)( pow((double)(100-iNewVolume)*0.01, 3) * (double)DSBVOLUME_MIN);  //((100-iNewVolume) * DSBVOLUME_MIN) / 500;
  456.     IDirectSoundBuffer_SetVolume(pContext->lpDSB, lVolume);
  457. }