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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
CPI_Player_CoDec_WinAmpPlugin.c
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：24k
源码类别：

多媒体编程

开发平台：

Visual C++

CPI_Player_CoDec_WinAmpPlugin.c：源码内容
  2. ////////////////////////////////////////////////////////////////////////////////
  6. #include "stdafx.h"
  7. #include "globals.h"
  8. #include "CPI_Player_CoDec.h"
  9. #include "CP_WinAmpStructs.h"
  10. #include "CPI_CircleBuffer.h"
  12. ////////////////////////////////////////////////////////////////////////////////
  13. //
  14. // This is the CoDec module - the basic idea is that the file will be opened and
  15. // data will be sucked through the CoDec via calls to CPI_CoDec__GetPCMBlock
  16. //
  17. //
  18. ////////////////////////////////////////////////////////////////////////////////
  21. ////////////////////////////////////////////////////////////////////////////////
  22. //
  23. //
  24. // Module functions
  25. void CPP_OMAPLG_Uninitialise(CPs_CoDecModule* pModule);
  26. BOOL CPP_OMAPLG_OpenFile(CPs_CoDecModule* pModule, const char* pcFilename, DWORD dwCookie, HWND hWndOwner);
  27. void CPP_OMAPLG_CloseFile(CPs_CoDecModule* pModule);
  28. void CPP_OMAPLG_Seek(CPs_CoDecModule* pModule, const int iNumerator, const int iDenominator);
  29. void CPP_OMAPLG_GetFileInfo(CPs_CoDecModule* pModule, CPs_FileInfo* pInfo);
  30. //
  31. BOOL CPP_OMAPLG_GetPCMBlock(CPs_CoDecModule* pModule, void* pBlock, DWORD* pdwBlockSize);
  32. int CPP_OMAPLG_GetCurrentPos_secs(CPs_CoDecModule* pModule);
  33. //
  34. ////////////////////////////////////////////////////////////////////////////////
  37. ////////////////////////////////////////////////////////////////////////////////
  38. // Dummy functions used by the in module (but we don't need 'em)
  39. void CP_Dummy_SAVSAInit(int maxlatency_in_ms, int srate) {}
  40. void CP_Dummy_SAVSADeInit() {}
  41. void CP_Dummy_SAAddPCMData(void *PCMData, int nch, int bps, int timestamp) {}
  42. int CP_Dummy_SAGetMode() { return 0; }
  43. void CP_Dummy_SAAdd(void *data, int timestamp, int csa) {}
  44. void CP_Dummy_VSAAddPCMData(void *PCMData, int nch, int bps, int timestamp) {}
  45. int CP_Dummy_VSAGetMode(int *specNch, int *waveNch) { return 0; }
  46. void CP_Dummy_VSAAdd(void *data, int timestamp) {}
  47. int CP_Dummy_dsp_isactive() { return 0; }
  48. int CP_Dummy_dsp_dosamples(short int *samples, int numsamples, int bps, int nch, int srate) { return 0; }
  49. //
  50. void CP_Dummy_VSASetInfo(int nch, int srate) {}
  51. int CP_Dummy_SetInfo(int bitrate, int srate, int stereo, int synched) { return 0; }
  52. //
  53. // Dummy output functions
  54. int CP_Dummy_Pause(int pause) { return 0; }
  55. void CP_Dummy_SetVolume(int volume) {}
  56. void CP_Dummy_SetPan(int pan) {}
  57. int CP_Dummy_GetOutputTime() { return 0; }
  58. int CP_Dummy_GetWrittenTime() { return 0; }
  59. ////////////////////////////////////////////////////////////////////////////////
  63. ////////////////////////////////////////////////////////////////////////////////
  64. //
  65. typedef struct __CPs_CoDec_WinAmpPlugin
  66. {
  67.     CP_PlugInModule* m_pFirstPlugIn;
  69.     CP_PlugInModule* m_pActivePluginModule;
  70.     HMODULE m_hModPlugin;
  71.     In_Module* m_pInModule;
  72.     BOOL m_bModuleIsPlaying;
  74.     Out_Module m_FakeOutModule;
  76. } CPs_CoDec_WinAmpPlugin;
  77. //
  78. ////////////////////////////////////////////////////////////////////////////////
  81. #define CIC_CIRCLE_DATABUFFER_SIZE 0x10000 //64Kb
  82. #define CIC_WAITTIMEOUT 2000 // 2Secs
  83. ////////////////////////////////////////////////////////////////////////////////
  84. // Callback interface (WinAmp doesn't "DO" cookies so we have to have this global
  85. // variable) - this means that we can only have one thread (the plugins prob aren't
  86. // thread safe anyhow) - but there we go!
  87. //
  88. struct CPs_OutputGlobalData
  89. {
  90.     CRITICAL_SECTION m_csGlobal;
  91.     BOOL m_bStreamIsComplete;
  92.     int m_iCurrentTime_ms;
  94.     // Stuff for the file information
  95.     HANDLE m_evtFileInfoValid;
  96.     CPs_FileInfo m_FileInfo;
  98.     // Stuff for the data buffer
  99.     CPs_CircleBuffer* m_pCBuffer;
  101.     HANDLE m_evtSeekComplete;
  103. } glb_OutputData;
  104. //
  105. //
  106. //
  107. int CP_OutPI_Open(int samplerate, int numchannels, int bitspersamp, int bufferlenms, int prebufferms)
  108. {
  109.     // returns >=0 on success, <0 on failure
  110.     // NOTENOTENOTE: bufferlenms and prebufferms are ignored in most if not all output plug-ins.
  111.     //    ... so don't expect the max latency returned to be what you asked for.
  112.     // returns max latency in ms (0 for diskwriters, etc)
  113.     // bufferlenms and prebufferms must be in ms. 0 to use defaults.
  114.     // prebufferms must be <= bufferlenms
  116.     if(bitspersamp != 8 && bitspersamp != 16)
  117.     {
  118.         CP_TRACE0("Inappropriate stream type");
  119.         return -1;
  120.     }
  122.     if(numchannels != 1 && numchannels != 2)
  123.     {
  124.         CP_TRACE0("Inappropriate stream type");
  125.         return -1;
  126.     }
  128.     // Setup the global info struct
  129.     {
  130.         EnterCriticalSection(&glb_OutputData.m_csGlobal);
  132.         glb_OutputData.m_FileInfo.m_iFileLength_Secs = 0;
  133.         glb_OutputData.m_FileInfo.m_iBitRate_Kbs = 0;
  134.         glb_OutputData.m_FileInfo.m_iFreq_Hz = samplerate;
  135.         glb_OutputData.m_FileInfo.m_bStereo = (numchannels>1) ? TRUE : FALSE;
  136.         glb_OutputData.m_FileInfo.m_b16bit = (bitspersamp==16) ? TRUE : FALSE;
  138.         LeaveCriticalSection(&glb_OutputData.m_csGlobal);
  140.         SetEvent(glb_OutputData.m_evtFileInfoValid);
  141.     }
  143.     return 1;
  144. }
  145. //
  146. //
  147. //
  148. void CP_OutPI_Close()
  149. {
  150.     CP_TRACE0("CP_OutPI_Close");
  151.     EnterCriticalSection(&glb_OutputData.m_csGlobal);
  153.     if(glb_OutputData.m_pCBuffer)
  154.         glb_OutputData.m_pCBuffer->SetComplete(glb_OutputData.m_pCBuffer);
  156.     LeaveCriticalSection(&glb_OutputData.m_csGlobal);
  157. }
  158. //
  159. //
  160. //
  161. int CP_OutPI_CanWrite()
  162. {
  163.     int iNumBytesFree;
  164.     // returns number of bytes possible to write at a given time.
  165.     // Never will decrease unless you call Write (or Close, heh)
  167.     EnterCriticalSection(&glb_OutputData.m_csGlobal);
  169.     if(glb_OutputData.m_pCBuffer == NULL)
  170.         iNumBytesFree = 0xFFFFFFFF;
  171.     else
  172.         iNumBytesFree = glb_OutputData.m_pCBuffer->GetFreeSize(glb_OutputData.m_pCBuffer);
  174.     LeaveCriticalSection(&glb_OutputData.m_csGlobal);
  176.     return iNumBytesFree;
  177. }
  178. //
  179. //
  180. //
  181. int CP_OutPI_Write(char *buf, int len)
  182. {
  183.     // 0 on success. Len == bytes to write (<= 8192 always). buf is straight audio data.
  184.     // 1 returns not able to write (yet). Non-blocking, always.
  185.     if(len > CP_OutPI_CanWrite())
  186.         return 1;
  188.     EnterCriticalSection(&glb_OutputData.m_csGlobal);
  190.     if(glb_OutputData.m_pCBuffer)
  191.         glb_OutputData.m_pCBuffer->Write(glb_OutputData.m_pCBuffer, buf, len);
  193.     // Update the current time
  194.     {
  195.         int iBytesPerSample = (glb_OutputData.m_FileInfo.m_bStereo ? 2 : 1)
  196.                               << (glb_OutputData.m_FileInfo.m_b16bit ? 1 : 0);
  198.         glb_OutputData.m_iCurrentTime_ms += ((len / iBytesPerSample)*1000) / glb_OutputData.m_FileInfo.m_iFreq_Hz;
  199.     }
  201.     LeaveCriticalSection(&glb_OutputData.m_csGlobal);
  202.     return 0;
  203. }
  204. //
  205. //
  206. //
  207. void CP_OutPI_Flush(int iNewTime)
  208. {
  209.     EnterCriticalSection(&glb_OutputData.m_csGlobal);
  210.     if(glb_OutputData.m_pCBuffer)
  211.         glb_OutputData.m_pCBuffer->Flush(glb_OutputData.m_pCBuffer);
  212.     glb_OutputData.m_iCurrentTime_ms = iNewTime;
  213.     SetEvent(glb_OutputData.m_evtSeekComplete);
  214.     LeaveCriticalSection(&glb_OutputData.m_csGlobal);
  215. }
  216. //
  217. //
  218. //
  219. int CP_OutPI_IsPlaying()
  220. {
  221.     CP_TRACE0("CP_OutPI_IsPlaying");
  222.     EnterCriticalSection(&glb_OutputData.m_csGlobal);
  224.     if(glb_OutputData.m_pCBuffer)
  225.         glb_OutputData.m_pCBuffer->SetComplete(glb_OutputData.m_pCBuffer);
  227.     LeaveCriticalSection(&glb_OutputData.m_csGlobal);
  229.     return 0;
  230. }
  231. //
  232. //
  233. ////////////////////////////////////////////////////////////////////////////////
  236. #define CP_INVALIDCHARPOS -1
  237. typedef In_Module* (*wp_winampGetInModule2)();
  238. ////////////////////////////////////////////////////////////////////////////////
  239. //
  240. //
  241. //
  242. void ProbeWinAmpModule(CPs_CoDecModule* pCoDec, const char* pcModulePath)
  243. {
  244.     CPs_CoDec_WinAmpPlugin *pContext;
  245.     HMODULE hModPlugin;
  246.     wp_winampGetInModule2 pfnGetInModule;
  247.     In_Module* pInModule;
  248.     pContext = (CPs_CoDec_WinAmpPlugin*)pCoDec->m_pModuleCookie;
  249.     CP_CHECKOBJECT(pContext);
  251.     // Load plugin and get EP
  252.     hModPlugin = LoadLibrary(pcModulePath);
  253.     if(!hModPlugin)
  254.         return;
  255.     pfnGetInModule = (wp_winampGetInModule2)GetProcAddress(hModPlugin, "winampGetInModule2");
  256.     if(!pfnGetInModule)
  257.     {
  258.         FreeLibrary(hModPlugin);
  259.         return;
  260.     }
  262.     // Get the plug in descriptor
  263.     pInModule = pfnGetInModule();
  265.     // Skip modules that we cannot support
  266.     if(!pInModule->UsesOutputPlug)
  267.     {
  268.         CP_TRACE1(""%s" Cannot be supported (not an output user)", pcModulePath);
  269.         FreeLibrary(hModPlugin);
  270.         return;
  271.     }
  273.     // Get the extensions supported by this plugin
  274.     if(pInModule && pInModule->FileExtensions && pInModule->FileExtensions[0])
  275.     {
  276.         char* pExtensions = pInModule->FileExtensions;
  277.         CP_PlugInModule* pNewPlugInModule = (CP_PlugInModule*)malloc(sizeof(CP_PlugInModule));
  279.         // Create new plug in module and add it to our list
  280.         pNewPlugInModule->m_pNext = pContext->m_pFirstPlugIn;
  281.         STR_AllocSetString(&pNewPlugInModule->m_pcModuleName, pcModulePath, FALSE);
  282.         pContext->m_pFirstPlugIn = pNewPlugInModule;
  284.         // Attach etensions to this module
  285.         CP_TRACE1("Probing module: "%s"", pcModulePath);
  286.         while(*pExtensions)
  287.         {
  288.             char* pDescription = pExtensions + strlen(pExtensions) + 1;
  289.             CP_TRACE2("Extensions: "%s" type:"%s"", pExtensions, pDescription);
  291.             // The extensions are in the format EXT1;EXT2;EXT3  - split these and
  292.             // add them to the player's extension list
  293.             {
  294.                 char* pcExtensionCursor;
  295.                 char* pcLastExtensionStart = pExtensions;
  297.                 for(pcExtensionCursor = pExtensions; *pcExtensionCursor; pcExtensionCursor++)
  298.                 {
  299.                     // Look for an extension break
  300.                     if(*pcExtensionCursor == ';' && pcExtensionCursor != pcLastExtensionStart)
  301.                     {
  302.                         const int iExtensionLen = pcExtensionCursor - pcLastExtensionStart;
  303.                         char* pcExtensionCopy = (char*)malloc(iExtensionLen+1);
  305.                         memcpy(pcExtensionCopy, pcLastExtensionStart, iExtensionLen);
  306.                         pcExtensionCopy[iExtensionLen] = '';
  308.                         CPFA_AddFileAssociation(pCoDec, pcExtensionCopy, (DWORD)pNewPlugInModule);
  310.                         free(pcExtensionCopy);
  311.                         pcLastExtensionStart = pcExtensionCursor+1;
  312.                     }
  313.                 }
  315.                 // Add last extension
  316.                 if(*pcLastExtensionStart)
  317.                     CPFA_AddFileAssociation(pCoDec, pcLastExtensionStart, (DWORD)pNewPlugInModule);
  318.             }
  320.             // Move cursor to next extension set
  321.             pExtensions = pDescription + strlen(pDescription) + 1;
  322.         }
  323.     }
  325.     // Free plugin
  326.     FreeLibrary(hModPlugin);
  327. }
  328. //
  329. //
  330. //
  331. void AddWinAmpModulesInPath(CPs_CoDecModule* pCoDec, const char* pcFileInPath)
  332. {
  333.     WIN32_FIND_DATA finddata;
  334.     HANDLE hFileFind;
  335.     char pcModuleDirectory[MAX_PATH];
  336.     char pcSearchWildcard[MAX_PATH];
  338.     strcpy(pcModuleDirectory, pcFileInPath);
  340.     // Work out the module directory
  341.     {
  342.         int iLastSlashPos, iCharIDX;
  344.         iLastSlashPos = CP_INVALIDCHARPOS;
  345.         for(iCharIDX=0; pcModuleDirectory[iCharIDX]; iCharIDX++)
  346.         {
  347.             if(pcModuleDirectory[iCharIDX] == '\')
  348.                 iLastSlashPos = iCharIDX;
  349.         }
  350.         // We must exist in some kind of directory!!!
  351.         CP_ASSERT(iLastSlashPos != CP_INVALIDCHARPOS);
  352.         pcModuleDirectory[iLastSlashPos+1] = '';
  353.     }
  355.     // Setup wildcard
  356.     strcpy(pcSearchWildcard,pcModuleDirectory);
  357.     strcat(pcSearchWildcard, "in_*.dll");
  359.     // Load each module to find out the file extensions that it supports
  360.     // ProbeWinAmpModule will also produce a linked list of module names
  361.     // and assign them to the FileAssociation cookie
  362.     hFileFind = FindFirstFile(pcSearchWildcard, &finddata);
  363.     if(hFileFind != INVALID_HANDLE_VALUE)
  364.     {
  365.         do
  366.         {
  367.             char pcFullPath[MAX_PATH];
  368.             strcpy(pcFullPath,pcModuleDirectory);
  369.             strcat(pcFullPath, finddata.cFileName);
  371.             ProbeWinAmpModule(pCoDec, pcFullPath);
  373.         } while(FindNextFile(hFileFind, &finddata) != 0);
  375.         FindClose(hFileFind);
  376.     }
  377. }
  378. //
  379. //
  380. //
  381. void CP_InitialiseCodec_WinAmpPlugin(CPs_CoDecModule* pCoDec)
  382. {
  383.     CPs_CoDec_WinAmpPlugin *pContext;
  385.     // Setup functions
  386.     pCoDec->Uninitialise = CPP_OMAPLG_Uninitialise;
  387.     pCoDec->OpenFile = CPP_OMAPLG_OpenFile;
  388.     pCoDec->CloseFile = CPP_OMAPLG_CloseFile;
  389.     pCoDec->Seek = CPP_OMAPLG_Seek;
  390.     pCoDec->GetFileInfo = CPP_OMAPLG_GetFileInfo;
  392.     pCoDec->GetPCMBlock = CPP_OMAPLG_GetPCMBlock;
  393.     pCoDec->GetCurrentPos_secs = CPP_OMAPLG_GetCurrentPos_secs;
  395.     // Setup private data
  396.     pCoDec->m_pModuleCookie = malloc(sizeof(CPs_CoDec_WinAmpPlugin));
  397.     pContext = (CPs_CoDec_WinAmpPlugin*)pCoDec->m_pModuleCookie;
  399.     pContext->m_pFirstPlugIn = 0L;
  400.     pContext->m_pActivePluginModule = NULL;
  401.     pContext->m_hModPlugin = NULL;
  402.     pContext->m_pInModule = NULL;
  403.     pContext->m_bModuleIsPlaying = FALSE;
  404.     memset(&pContext->m_FakeOutModule, 0, sizeof(pContext->m_FakeOutModule));
  405.     pContext->m_FakeOutModule.version = OUT_VER;
  406.     pContext->m_FakeOutModule.Open = CP_OutPI_Open;
  407.     pContext->m_FakeOutModule.Close = CP_OutPI_Close;
  408.     pContext->m_FakeOutModule.Write = CP_OutPI_Write;
  409.     pContext->m_FakeOutModule.CanWrite = CP_OutPI_CanWrite;
  410.     pContext->m_FakeOutModule.IsPlaying = CP_OutPI_IsPlaying;
  411.     pContext->m_FakeOutModule.Flush = CP_OutPI_Flush;
  413.     pContext->m_FakeOutModule.Pause = CP_Dummy_Pause;
  414.     pContext->m_FakeOutModule.SetVolume = CP_Dummy_SetVolume;
  415.     pContext->m_FakeOutModule.SetPan = CP_Dummy_SetPan;
  416.     pContext->m_FakeOutModule.GetOutputTime = CP_Dummy_GetOutputTime;
  417.     pContext->m_FakeOutModule.GetWrittenTime = CP_Dummy_GetWrittenTime;
  419.     // Global data
  420.     InitializeCriticalSection(&glb_OutputData.m_csGlobal);
  421.     glb_OutputData.m_evtFileInfoValid = NULL;
  422.     memset(&glb_OutputData.m_FileInfo, 0, sizeof(glb_OutputData.m_FileInfo));
  423.     glb_OutputData.m_pCBuffer = NULL;
  424.     glb_OutputData.m_iCurrentTime_ms = 0;
  425.     glb_OutputData.m_evtSeekComplete = NULL;
  426.     CPFA_InitialiseFileAssociations(pCoDec);
  428.     // Look in the current directory for WinAmp plugins - these have the format
  429.     // in_*.dll
  430.     {
  431.         char pcCurrentModuleDirectory[MAX_PATH];
  432. main_get_program_path(GetModuleHandle(NULL), pcCurrentModuleDirectory, MAX_PATH);
  433.         AddWinAmpModulesInPath(pCoDec, pcCurrentModuleDirectory);
  434.     }
  437.     /*
  439.       Some plugins have problems running outside of the WinAmp directory - so we will only
  440.       use plugins from the current dir (until someone has inspiration!!) 
  442.     */
  443.     /*
  444.      // Try to track down the WinAmp plugins directory (and add them too)
  445.      {
  446.      LONG lResult;
  447.      HKEY hKeyWinAmp;
  449.      lResult = RegOpenKey(HKEY_CLASSES_ROOT,
  450.      "WinAmp.File\shell\open\command",
  451.      &hKeyWinAmp);
  452.      if(lResult == ERROR_SUCCESS)
  453.      {
  454.      char cWinAmpPath[255];
  455.      char* pcValue;
  456.      LONG iValueLen;
  458.      RegQueryValue(hKeyWinAmp, NULL, NULL, &iValueLen);
  459.      pcValue = (char*)malloc(iValueLen);
  460.      RegQueryValue(hKeyWinAmp, NULL, pcValue, &iValueLen);
  462.      if(sscanf(pcValue, ""%255[^"]", cWinAmpPath) == 1)
  463.      {
  464.      int iLastSlashPos, iCharIDX;
  466.      // Remove the WinAmp exe name
  467.      iLastSlashPos = CP_INVALIDCHARPOS;
  468.      for(iCharIDX=0; cWinAmpPath[iCharIDX]; iCharIDX++)
  469.      {
  470.      if(cWinAmpPath[iCharIDX] == '\')
  471.      iLastSlashPos = iCharIDX;
  472.      }
  473.      // We must exist in some kind of directory!!!
  474.      CP_ASSERT(iLastSlashPos != CP_INVALIDCHARPOS);
  475.      cWinAmpPath[iLastSlashPos+1] = '';
  477.      // Append the Plugins folder
  478.      strcat(cWinAmpPath, "Plugins\");
  479.      AddWinAmpModulesInPath(pCoDec, cWinAmpPath);
  480.      }
  482.      // Cleanup
  483.      free(pcValue);
  484.      RegCloseKey(hKeyWinAmp);
  485.      }
  486.      }
  487.     */
  488. }
  489. //
  490. //
  491. //
  492. void CPP_OMAPLG_Uninitialise(CPs_CoDecModule* pModule)
  493. {
  494.     CPs_CoDec_WinAmpPlugin *pContext = (CPs_CoDec_WinAmpPlugin*)pModule->m_pModuleCookie;
  495.     CP_PlugInModule* pPlugInCursor;
  496.     CP_PlugInModule* pPlugInCursor_Next;
  497.     CP_CHECKOBJECT(pContext);
  499.     // Cleanup plug in module list
  500.     pPlugInCursor_Next = NULL;
  501.     for(pPlugInCursor = pContext->m_pFirstPlugIn; pPlugInCursor; pPlugInCursor = pPlugInCursor_Next)
  502.     {
  503.         pPlugInCursor_Next = (CP_PlugInModule*)pPlugInCursor->m_pNext;
  505.         free(pPlugInCursor->m_pcModuleName);
  506.         free(pPlugInCursor);
  507.     }
  509.     // Global output data
  510.     DeleteCriticalSection(&glb_OutputData.m_csGlobal);
  512.     free(pContext);
  513.     CPFA_EmptyFileAssociations(pModule);
  514. }
  515. //
  516. //
  517. //
  518. void InitialiseGlobalData()
  519. {
  520.     EnterCriticalSection(&glb_OutputData.m_csGlobal);
  522.     // Stuff for the file information
  523.     CP_ASSERT(!glb_OutputData.m_evtFileInfoValid);
  524.     glb_OutputData.m_evtFileInfoValid = CreateEvent(NULL, TRUE, FALSE, NULL);
  525.     memset(&glb_OutputData.m_FileInfo, 0, sizeof(glb_OutputData.m_FileInfo));
  527.     // Stuff for the data buffer
  528.     CP_ASSERT(!glb_OutputData.m_pCBuffer);
  529.     glb_OutputData.m_pCBuffer = CP_CreateCircleBuffer(CIC_CIRCLE_DATABUFFER_SIZE);
  530.     glb_OutputData.m_iCurrentTime_ms = 0;
  532.     CP_ASSERT(!glb_OutputData.m_evtSeekComplete);
  533.     glb_OutputData.m_evtSeekComplete = CreateEvent(NULL, FALSE, FALSE, NULL);
  535.     LeaveCriticalSection(&glb_OutputData.m_csGlobal);
  536. }
  537. //
  538. //
  539. //
  540. void UnitialiseGlobalData()
  541. {
  542.     EnterCriticalSection(&glb_OutputData.m_csGlobal);
  544.     // Stuff for the file information
  545.     CP_ASSERT(glb_OutputData.m_evtFileInfoValid);
  546.     CloseHandle(glb_OutputData.m_evtFileInfoValid);
  547.     glb_OutputData.m_evtFileInfoValid = NULL;
  549.     // Stuff for the data buffer
  550.     CP_ASSERT(glb_OutputData.m_pCBuffer);
  551.     glb_OutputData.m_pCBuffer->Uninitialise(glb_OutputData.m_pCBuffer);
  552.     glb_OutputData.m_pCBuffer = NULL;
  554.     CP_ASSERT(glb_OutputData.m_evtSeekComplete);
  555.     CloseHandle(glb_OutputData.m_evtSeekComplete);
  556.     glb_OutputData.m_evtSeekComplete = NULL;
  558.     LeaveCriticalSection(&glb_OutputData.m_csGlobal);
  559. }
  560. //
  561. //
  562. //
  563. void CloseCurrentModule(CPs_CoDec_WinAmpPlugin *pContext)
  564. {
  565.     CP_CHECKOBJECT(pContext);
  566.     CP_ASSERT(pContext->m_pActivePluginModule);
  567.     CP_ASSERT(pContext->m_hModPlugin);
  568.     CP_ASSERT(pContext->m_pInModule);
  569.     CP_ASSERT(pContext->m_pInModule->Stop);
  570.     CP_ASSERT(pContext->m_pInModule->Quit);
  572.     CP_TRACE1("Free module: "%s"", pContext->m_pActivePluginModule->m_pcModuleName);
  574.     if(pContext->m_bModuleIsPlaying)
  575.         pContext->m_pInModule->Stop();
  576.     pContext->m_pInModule->Quit();
  577.     FreeLibrary(pContext->m_hModPlugin);
  579.     pContext->m_pActivePluginModule = NULL;
  580.     pContext->m_hModPlugin = NULL;
  581.     pContext->m_pInModule = NULL;
  582.     pContext->m_bModuleIsPlaying = FALSE;
  583. }
  584. //
  585. //
  586. //
  587. void SetupCurrentInputPluginModule(CPs_CoDec_WinAmpPlugin *pContext)
  588. {
  589.     CP_CHECKOBJECT(pContext);
  590.     CP_ASSERT(pContext->m_pActivePluginModule);
  591.     CP_ASSERT(pContext->m_hModPlugin);
  592.     CP_ASSERT(pContext->m_pInModule);
  594.     pContext->m_pInModule->hMainWindow = (HWND)0x2398;
  595.     pContext->m_pInModule->hDllInstance = pContext->m_hModPlugin;
  597.     // Setup functions
  598.     pContext->m_pInModule->SAVSAInit = CP_Dummy_SAVSAInit;
  599.     pContext->m_pInModule->SAVSADeInit = CP_Dummy_SAVSADeInit;
  600.     pContext->m_pInModule->SAAddPCMData = CP_Dummy_SAAddPCMData;
  601.     pContext->m_pInModule->SAGetMode = CP_Dummy_SAGetMode;
  602.     pContext->m_pInModule->SAAdd = CP_Dummy_SAAdd;
  604.     pContext->m_pInModule->VSAAddPCMData = CP_Dummy_VSAAddPCMData;
  605.     pContext->m_pInModule->VSAGetMode = CP_Dummy_VSAGetMode;
  606.     pContext->m_pInModule->VSAAdd = CP_Dummy_VSAAdd;
  608.     pContext->m_pInModule->dsp_isactive = CP_Dummy_dsp_isactive;
  609.     pContext->m_pInModule->dsp_dosamples = CP_Dummy_dsp_dosamples;
  611.     pContext->m_pInModule->VSASetInfo = CP_Dummy_VSASetInfo;
  612.     pContext->m_pInModule->SetInfo = CP_Dummy_SetInfo;
  614.     pContext->m_pInModule->outMod = &pContext->m_FakeOutModule;
  615. }
  616. //
  617. //
  618. //
  619. BOOL CPP_OMAPLG_OpenFile(CPs_CoDecModule* pModule, const char* pcFilename, DWORD dwCookie, HWND hWndOwner)
  620. {
  621.     CPs_CoDec_WinAmpPlugin *pContext = (CPs_CoDec_WinAmpPlugin*)pModule->m_pModuleCookie;
  622.     CP_PlugInModule* pSelectedPlugInModule = (CP_PlugInModule*)dwCookie;
  623.     int iError;
  624.     CP_CHECKOBJECT(pContext);
  625. if(!pSelectedPlugInModule) return FALSE;
  627.     // Open output module
  628.     {
  629.         // Module has changed
  630.         wp_winampGetInModule2 pfnGetInModule;
  631.         if(pContext->m_pActivePluginModule)
  632.             CloseCurrentModule(pContext);
  634.         // Load plugin and get EP
  635.         CP_TRACE1("Load module: "%s"", pSelectedPlugInModule->m_pcModuleName);
  636.         pContext->m_hModPlugin = LoadLibrary(pSelectedPlugInModule->m_pcModuleName);
  637.         if(!pContext->m_hModPlugin)
  638.             return FALSE;
  640.         pfnGetInModule = (wp_winampGetInModule2)GetProcAddress(pContext->m_hModPlugin, "winampGetInModule2");
  641.         if(!pfnGetInModule)
  642.         {
  643.             FreeLibrary(pContext->m_hModPlugin);
  644.             pContext->m_hModPlugin = NULL;
  645.             return FALSE;
  646.         }
  648.         pContext->m_pActivePluginModule = pSelectedPlugInModule;
  649.         pContext->m_pInModule = pfnGetInModule();
  650.         SetupCurrentInputPluginModule(pContext);
  651.         pContext->m_pInModule->Init();
  652.         InitialiseGlobalData();
  653.     }
  655.     iError = pContext->m_pInModule->Play(pcFilename);
  656.     if(iError != 0)
  657.     {
  658.         CP_TRACE1("**** Failed to open file: "%s"", pcFilename);
  659.         CloseCurrentModule(pContext);
  660.         UnitialiseGlobalData();
  661.         return FALSE;
  662.     }
  664.     pContext->m_bModuleIsPlaying = TRUE;
  665.     return TRUE; // Success
  666. }
  667. //
  668. //
  669. //
  670. void CPP_OMAPLG_CloseFile(CPs_CoDecModule* pModule)
  671. {
  672.     CPs_CoDec_WinAmpPlugin *pContext = (CPs_CoDec_WinAmpPlugin*)pModule->m_pModuleCookie;
  673.     CP_CHECKOBJECT(pContext);
  675.     UnitialiseGlobalData();
  677.     if(pContext->m_pActivePluginModule)
  678.         CloseCurrentModule(pContext);
  679. }
  680. //
  681. //
  682. //
  683. void CPP_OMAPLG_Seek(CPs_CoDecModule* pModule, const int iNumerator, const int iDenominator)
  684. {
  685.     CPs_CoDec_WinAmpPlugin *pContext = (CPs_CoDec_WinAmpPlugin*)pModule->m_pModuleCookie;
  686.     int iStreamLength_ms;
  687.     CP_CHECKOBJECT(pContext);
  688.     CP_ASSERT(pContext->m_pActivePluginModule);
  690.     iStreamLength_ms = pContext->m_pInModule->GetLength();
  691.     pContext->m_pInModule->SetOutputTime( (iNumerator*iStreamLength_ms) / iDenominator);
  692.     WaitForSingleObject(glb_OutputData.m_evtSeekComplete, CIC_WAITTIMEOUT);
  693. }
  694. //
  695. //
  696. //
  697. BOOL CPP_OMAPLG_GetPCMBlock(CPs_CoDecModule* pModule, void* _pBlock, DWORD* pdwBlockSize)
  698. {
  699.     CPs_CoDec_WinAmpPlugin *pContext = (CPs_CoDec_WinAmpPlugin*)pModule->m_pModuleCookie;
  700.     CP_CHECKOBJECT(pContext);
  702.     return glb_OutputData.m_pCBuffer->Read(glb_OutputData.m_pCBuffer, _pBlock, *pdwBlockSize, pdwBlockSize);
  703. }
  704. //
  705. //
  706. //
  707. void CPP_OMAPLG_GetFileInfo(CPs_CoDecModule* pModule, CPs_FileInfo* pInfo)
  708. {
  709.     CPs_CoDec_WinAmpPlugin *pContext = (CPs_CoDec_WinAmpPlugin*)pModule->m_pModuleCookie;
  710.     DWORD dwWaitResult;
  711.     CP_CHECKOBJECT(pContext);
  712.     CP_ASSERT(pContext->m_pActivePluginModule);
  714.     // Wait up to 1 second for the plugin to return the stream format - if it doesn't
  715.     // set the file info into something that we know will be unsupported
  716.     dwWaitResult = WaitForSingleObject(glb_OutputData.m_evtFileInfoValid, CIC_WAITTIMEOUT);
  717.     if(dwWaitResult == WAIT_OBJECT_0)
  718.     {
  719.         EnterCriticalSection(&glb_OutputData.m_csGlobal);
  720.         memcpy(pInfo, &glb_OutputData.m_FileInfo, sizeof(*pInfo));
  721.         LeaveCriticalSection(&glb_OutputData.m_csGlobal);
  722.     }
  723.     else
  724.     {
  725.         CP_TRACE0("Module did not respond in time - setting bogus stream params");
  726.         memset(pInfo, 0, sizeof(*pInfo));
  727.     }
  729.     pInfo->m_iFileLength_Secs = pContext->m_pInModule->GetLength() / 1000;
  730. }
  731. //
  732. //
  733. //
  734. int CPP_OMAPLG_GetCurrentPos_secs(CPs_CoDecModule* pModule)
  735. {
  736.     CPs_CoDec_WinAmpPlugin *pContext = (CPs_CoDec_WinAmpPlugin*)pModule->m_pModuleCookie;
  737.     int iCurrentPos_secs;
  738.     CP_CHECKOBJECT(pContext);
  739.     CP_ASSERT(pContext->m_pActivePluginModule);
  741.     EnterCriticalSection(&glb_OutputData.m_csGlobal);
  742.     iCurrentPos_secs = glb_OutputData.m_iCurrentTime_ms / 1000;
  743.     LeaveCriticalSection(&glb_OutputData.m_csGlobal);
  745.     return iCurrentPos_secs;
  746. }
  747. //
  748. //
  749. //