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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
afl.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：23k
源码类别：

midi

开发平台：

Unix_Linux

afl.c：源码内容
  1. /*
  2.  * $Id: 7cb0eb8f180ed1c925df4f5a39ad37340f83437f $
  3.  *
  4.  * Copyright (C) 1998 Patrick Stridvall
  5.  * Copyright (C) 1999 Eric Pouech
  6.  *
  7.  * Originally distributed under LPGL 2.1 (or later) by the Wine project.
  8.  *
  9.  * Modified for use with MPlayer, detailed CVS changelog at
  10.  * http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
  11.  *
  12.  * File now distributed as part of VLC media player with no modifications.
  13.  *
  14.  * This program is free software; you can redistribute it and/or modify
  15.  * it under the terms of the GNU General Public License as published by
  16.  * the Free Software Foundation; either version 2 of the License, or
  17.  * (at your option) any later version.
  18.  *
  19.  * This program is distributed in the hope that it will be useful,
  20.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22.  * GNU General Public License for more details.
  23.  *
  24.  * You should have received a copy of the GNU General Public License
  25.  * along with this program; if not, write to the Free Software
  26.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  27.  */
  29. /**************************************************************************
  32.   This file will contain an interface to ACM drivers.
  33.   Its content will be based mainly on wine/dlls/msacm32
  34.   actually, for audio decompression only the following functions
  35.   are needed:
  36.   
  37.   acmStreamOpen ( takes formats of src and dest, returns stream handle )
  38.   acmStreamPrepareHeader ( takes stream handler and info on data )
  39.   acmStreamConvert ( the same as PrepareHeader )
  40.   acmStreamUnprepareHeader
  41.   acmStreamClose
  42.   acmStreamSize
  43.   maybe acmStreamReset
  44.   
  45.   In future I'll also add functions for format enumeration, 
  46.   but not right now.
  48.   Modified for use with MPlayer, detailed CVS changelog at
  49.   http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
  50.   
  51. ***************************************************************************/
  52. #include "config.h"
  54. #include "wine/winbase.h"
  55. #include "wine/windef.h"
  56. #include "wine/winuser.h"
  57. #include "wine/vfw.h"
  58. #include "wine/winestring.h"
  59. #include "wine/driver.h"
  60. #include "wine/winerror.h"
  61. #include "wine/msacm.h"
  62. #include "wine/msacmdrv.h"
  63. #include "wineacm.h"
  64. #ifndef __MINGW32__
  65. #include "ext.h"
  66. #endif
  67. #include "driver.h"
  69. #include <stdio.h>
  70. #include <stdlib.h>
  71. #include <string.h>
  72. #pragma pack(1)
  73. #define OpenDriverA DrvOpen
  74. #define CloseDriver DrvClose
  76. static inline PWINE_ACMSTREAM ACM_GetStream(HACMSTREAM has)
  77. {
  78.     return (PWINE_ACMSTREAM)has;
  79. }
  81. /***********************************************************************
  82.  *           acmDriverAddA (MSACM32.2)
  83.  */
  84. MMRESULT WINAPI acmDriverAddA(PHACMDRIVERID phadid, HINSTANCE hinstModule,
  85.       LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
  86. {
  87.     if (!phadid)
  88. return MMSYSERR_INVALPARAM;
  89.     
  90.     /* Check if any unknown flags */
  91.     if (fdwAdd & 
  92. ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
  93.   ACM_DRIVERADDF_GLOBAL))
  94. return MMSYSERR_INVALFLAG;
  95.     
  96.     /* Check if any incompatible flags */
  97.     if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) && 
  98. (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
  99. return MMSYSERR_INVALFLAG;
  100.     
  101.     /* FIXME: in fact, should GetModuleFileName(hinstModule) and do a 
  102.      * LoadDriver on it, to be sure we can call SendDriverMessage on the
  103.      * hDrvr handle.
  104.      */
  105.     *phadid = (HACMDRIVERID) MSACM_RegisterDriver(NULL, 0, hinstModule);
  106.     
  107.     /* FIXME: lParam, dwPriority and fdwAdd ignored */
  108.     
  109.     return MMSYSERR_NOERROR;
  110. }
  112. /***********************************************************************
  113.  *           acmDriverClose (MSACM32.4)
  114.  */
  115. MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose)
  116. {
  117.     PWINE_ACMDRIVER  p;
  118.     PWINE_ACMDRIVER* tp;
  119.     
  120.     if (fdwClose)
  121. return MMSYSERR_INVALFLAG;
  122.     
  123.     p = MSACM_GetDriver(had);
  124.     if (!p)
  125. return MMSYSERR_INVALHANDLE;
  127.     for (tp = &(p->obj.pACMDriverID->pACMDriverList); *tp; *tp = (*tp)->pNextACMDriver) {
  128. if (*tp == p) {
  129.     *tp = (*tp)->pNextACMDriver;
  130.     break;
  131. }
  132.     }
  133.     
  134.     if (p->hDrvr && !p->obj.pACMDriverID->pACMDriverList)
  135. CloseDriver(p->hDrvr);
  136.     
  137.     HeapFree(MSACM_hHeap, 0, p);
  138.     
  139.     return MMSYSERR_NOERROR;
  140. }
  142. /***********************************************************************
  143.  *           acmDriverEnum (MSACM32.7)
  144.  */
  145. MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
  146. {
  147.     PWINE_ACMDRIVERID p;
  148.     DWORD fdwSupport;
  150.     if (!fnCallback) {
  151. return MMSYSERR_INVALPARAM;
  152.     }
  153.     
  154.     if (fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED)) {
  155. return MMSYSERR_INVALFLAG;
  156.     }
  157.     
  158.     for (p = MSACM_pFirstACMDriverID; p; p = p->pNextACMDriverID) {
  159. fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
  160. if (!p->bEnabled) {
  161.     if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
  162. fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
  163.     else
  164. continue;
  165. }
  166. (*fnCallback)((HACMDRIVERID) p, dwInstance, fdwSupport);
  167.     }
  168.     
  169.     return MMSYSERR_NOERROR;
  170. }
  172. /***********************************************************************
  173.  *           acmDriverID (MSACM32.8)
  174.  */
  175. MMRESULT WINAPI acmDriverID(HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
  176. {
  177.     PWINE_ACMOBJ pao;
  178.     
  179.     pao = MSACM_GetObj(hao);
  180.     if (!pao)
  181. return MMSYSERR_INVALHANDLE;
  182.     
  183.     if (!phadid)
  184. return MMSYSERR_INVALPARAM;
  185.     
  186.     if (fdwDriverID)
  187. return MMSYSERR_INVALFLAG;
  188.     
  189.     *phadid = (HACMDRIVERID) pao->pACMDriverID;
  190.     
  191.     return MMSYSERR_NOERROR;
  192. }
  194. /***********************************************************************
  195.  *           acmDriverMessage (MSACM32.9)
  196.  * FIXME
  197.  *   Not implemented
  198.  */
  199. LRESULT WINAPI acmDriverMessage(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
  200. {
  201.     PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
  202.     if (!pad)
  203. return MMSYSERR_INVALPARAM;
  204.     
  205.     /* FIXME: Check if uMsg legal */
  206.     
  207.     if (!SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2))
  208. return MMSYSERR_NOTSUPPORTED;
  209.     
  210.     return MMSYSERR_NOERROR;
  211. }
  214. /***********************************************************************
  215.  *           acmDriverOpen (MSACM32.10)
  216.  */
  217. MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
  218. {
  219.     PWINE_ACMDRIVERID padid;
  220.     PWINE_ACMDRIVER pad;
  221.     ICOPEN icopen;
  222.     HDRVR hdrv;
  225.     TRACE("(%p, %x, %08lu)n", phad, hadid, fdwOpen);
  227.     if (!phad)
  228. return MMSYSERR_INVALPARAM;
  229.     
  230.     padid = MSACM_GetDriverID(hadid); 
  231.     if (!padid)
  232. return MMSYSERR_INVALHANDLE;
  233.     
  234.     if (fdwOpen)
  235. return MMSYSERR_INVALFLAG;
  236.     
  237.     pad = (PWINE_ACMDRIVER) HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
  238.     if (!pad)
  239. return MMSYSERR_NOMEM;
  241.     pad->obj.pACMDriverID = padid;
  242.     icopen.fccType = mmioFOURCC('a', 'u', 'd', 'c');
  243.     icopen.fccHandler = (long)padid->pszFileName;
  244.     icopen.dwSize = sizeof(ICOPEN);
  245.     icopen.dwFlags = 0;
  247.     icopen.pV1Reserved = padid->pszFileName;
  248.     if (!padid->hInstModule)
  249. pad->hDrvr = OpenDriverA((long)&icopen);
  250.     else
  251. pad->hDrvr = padid->hInstModule;
  252.     
  253.     if (!pad->hDrvr) {
  254. HeapFree(MSACM_hHeap, 0, pad);
  255. return MMSYSERR_ERROR;
  256.     }
  258.     pad->pfnDriverProc = GetProcAddress(pad->hDrvr, "DriverProc");
  260.     /* insert new pad at beg of list */
  261.     pad->pNextACMDriver = padid->pACMDriverList;
  262.     padid->pACMDriverList = pad;
  264.     /* FIXME: Create a WINE_ACMDRIVER32 */
  265.     *phad = (HACMDRIVER)pad;
  267.     return MMSYSERR_NOERROR;
  268. }
  270. /***********************************************************************
  271.  *           acmDriverRemove (MSACM32.12)
  272.  */
  273. MMRESULT WINAPI acmDriverRemove(HACMDRIVERID hadid, DWORD fdwRemove)
  274. {
  275.     PWINE_ACMDRIVERID padid;
  276.     
  277.     padid = MSACM_GetDriverID(hadid);
  278.     if (!padid)
  279. return MMSYSERR_INVALHANDLE;
  280.     
  281.     if (fdwRemove)
  282. return MMSYSERR_INVALFLAG;
  283.     
  284.     MSACM_UnregisterDriver(padid);
  285.     
  286.     return MMSYSERR_NOERROR;
  287. }
  291. /**********************************************************************/
  293. HANDLE MSACM_hHeap = (HANDLE) NULL;
  294. PWINE_ACMDRIVERID MSACM_pFirstACMDriverID = NULL;
  295. PWINE_ACMDRIVERID MSACM_pLastACMDriverID = NULL;
  297. /***********************************************************************
  298.  *           MSACM_RegisterDriver32() 
  299.  */
  300. PWINE_ACMDRIVERID MSACM_RegisterDriver(const char* pszFileName,
  301.        WORD wFormatTag,
  302.        HINSTANCE hinstModule)
  303. {
  304.     PWINE_ACMDRIVERID padid;
  306.     TRACE("('%s', '%x', 0x%08x)n", pszFileName, wFormatTag, hinstModule);
  308. #ifndef WIN32_LOADER
  309. MSACM_hHeap = GetProcessHeap();
  310. #endif
  311.     padid = (PWINE_ACMDRIVERID) HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVERID));
  312.     padid->pszFileName = (char*)malloc(strlen(pszFileName)+1);
  313.     strcpy(padid->pszFileName, pszFileName);
  314. //    1~strdup(pszDriverAlias);
  315.     padid->wFormatTag = wFormatTag;
  316.     padid->hInstModule = hinstModule;
  317.     padid->bEnabled = TRUE;
  318.     padid->pACMDriverList = NULL;
  319.     padid->pNextACMDriverID = NULL;
  320.     padid->pPrevACMDriverID = MSACM_pLastACMDriverID;
  321.     if (MSACM_pLastACMDriverID)
  322. MSACM_pLastACMDriverID->pNextACMDriverID = padid;
  323.     MSACM_pLastACMDriverID = padid;
  324.     if (!MSACM_pFirstACMDriverID)
  325. MSACM_pFirstACMDriverID = padid;
  326.     
  327.     return padid;
  328. }
  331. /***********************************************************************
  332.  *           MSACM_UnregisterDriver32()
  333.  */
  334. PWINE_ACMDRIVERID MSACM_UnregisterDriver(PWINE_ACMDRIVERID p)
  335. {
  336.     PWINE_ACMDRIVERID pNextACMDriverID;
  337.     
  338.     while (p->pACMDriverList)
  339. acmDriverClose((HACMDRIVER) p->pACMDriverList, 0);
  340.     
  341.     free( p->pszFileName );
  342.     
  343.     if (p == MSACM_pFirstACMDriverID)
  344. MSACM_pFirstACMDriverID = p->pNextACMDriverID;
  345.     if (p == MSACM_pLastACMDriverID)
  346. MSACM_pLastACMDriverID = p->pPrevACMDriverID;
  348.     if (p->pPrevACMDriverID)
  349. p->pPrevACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
  350.     if (p->pNextACMDriverID)
  351. p->pNextACMDriverID->pPrevACMDriverID = p->pPrevACMDriverID;
  352.     
  353.     pNextACMDriverID = p->pNextACMDriverID;
  354.     
  355.     HeapFree(MSACM_hHeap, 0, p);
  356.     
  357.     return pNextACMDriverID;
  358. }
  360. /***********************************************************************
  361.  *           MSACM_UnregisterAllDrivers32()
  362.  * FIXME
  363.  *   Where should this function be called?
  364.  */
  365. void MSACM_UnregisterAllDrivers(void)
  366. {
  367.     PWINE_ACMDRIVERID p;
  369.     for (p = MSACM_pFirstACMDriverID; p; p = MSACM_UnregisterDriver(p));
  370. }
  372. /***********************************************************************
  373.  *           MSACM_GetDriverID32() 
  374.  */
  375. PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID)
  376. {
  377.     return (PWINE_ACMDRIVERID)hDriverID;
  378. }
  380. /***********************************************************************
  381.  *           MSACM_GetDriver32()
  382.  */
  383. PWINE_ACMDRIVER MSACM_GetDriver(HACMDRIVER hDriver)
  384. {
  385.     return (PWINE_ACMDRIVER)hDriver;
  386. }
  388. /***********************************************************************
  389.  *           MSACM_GetObj32()
  390.  */
  391. PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj)
  392. {
  393.     return (PWINE_ACMOBJ)hObj;
  394. }
  398. /***********************************************************************
  399.  *           acmStreamOpen (MSACM32.40)
  400.  */
  401. MMRESULT WINAPI acmStreamOpen(PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
  402.       PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
  403.       DWORD dwInstance, DWORD fdwOpen)
  404. {
  405.     PWINE_ACMSTREAM was;
  406.     PWINE_ACMDRIVER wad;
  407.     MMRESULT ret;
  408.     int wfxSrcSize;
  409.     int wfxDstSize;
  410.     
  411.     TRACE("(%p, 0x%08x, %p, %p, %p, %ld, %ld, %ld)n",
  412.   phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
  414.     TRACE("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]n", 
  415.   pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec, 
  416.   pwfxSrc->nBlockAlign, pwfxSrc->wBitsPerSample, pwfxSrc->cbSize);
  418.     TRACE("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]n", 
  419.   pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec, 
  420.   pwfxDst->nBlockAlign, pwfxDst->wBitsPerSample, pwfxDst->cbSize);
  422. #define SIZEOF_WFX(wfx) (sizeof(WAVEFORMATEX) + ((wfx->wFormatTag == WAVE_FORMAT_PCM) ? 0 : wfx->cbSize))
  423.     wfxSrcSize = SIZEOF_WFX(pwfxSrc);
  424.     wfxDstSize = SIZEOF_WFX(pwfxDst);
  425. #undef SIZEOF_WFX
  427.     was = (PWINE_ACMSTREAM) HeapAlloc(MSACM_hHeap, 0, sizeof(*was) + wfxSrcSize + wfxDstSize + ((pwfltr) ? sizeof(WAVEFILTER) : 0));
  428.     if (was == NULL)
  429. return MMSYSERR_NOMEM;
  430.     was->drvInst.cbStruct = sizeof(was->drvInst);
  431.     was->drvInst.pwfxSrc = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was));
  432.     memcpy(was->drvInst.pwfxSrc, pwfxSrc, wfxSrcSize);
  433.     // LHACM is checking for 0x1
  434.     // but if this will not help
  435.     // was->drvInst.pwfxSrc->wFormatTag = 1;
  436.     was->drvInst.pwfxDst = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was) + wfxSrcSize);
  437.     memcpy(was->drvInst.pwfxDst, pwfxDst, wfxDstSize);
  438.     if (pwfltr) {
  439. was->drvInst.pwfltr = (PWAVEFILTER)((LPSTR)was + sizeof(*was) + wfxSrcSize + wfxDstSize);
  440. memcpy(was->drvInst.pwfltr, pwfltr, sizeof(WAVEFILTER));
  441.     } else {
  442. was->drvInst.pwfltr = NULL;
  443.     }
  444.     was->drvInst.dwCallback = dwCallback;    
  445.     was->drvInst.dwInstance = dwInstance;
  446.     was->drvInst.fdwOpen = fdwOpen;
  447.     was->drvInst.fdwDriver = 0L;  
  448.     was->drvInst.dwDriver = 0L;     
  449.     was->drvInst.has = (HACMSTREAM)was;
  450.     
  451.     if (had) {
  452. if (!(wad = MSACM_GetDriver(had))) {
  453.     ret = MMSYSERR_INVALPARAM;
  454.     goto errCleanUp;
  455. }
  457. was->obj.pACMDriverID = wad->obj.pACMDriverID;
  458. was->pDrv = wad;
  459. was->hAcmDriver = 0; /* not to close it in acmStreamClose */
  461. ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
  462. if (ret != MMSYSERR_NOERROR)
  463.     goto errCleanUp;
  464.     } else {
  465. PWINE_ACMDRIVERID wadi;
  466. short drv_tag;
  467. ret = ACMERR_NOTPOSSIBLE;
  468. /* if(pwfxSrc->wFormatTag==1)//compression
  469.     drv_tag=pwfxDst->wFormatTag;
  470.     else
  471.     if(pwfxDst->wFormatTag==1)//decompression
  472. drv_tag=pwfxSrc->wFormatTag;
  473. else
  474. goto errCleanUp;
  476.     ret=acmDriverOpen2(drv_tag); 
  477.     if (ret == MMSYSERR_NOERROR) {
  478. if ((wad = MSACM_GetDriver(had)) != 0) {
  479.     was->obj.pACMDriverID = wad->obj.pACMDriverID;
  480.     was->pDrv = wad;
  481.     was->hAcmDriver = had;
  482.     
  483.     ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
  484.     if (ret == MMSYSERR_NOERROR) {
  485. if (fdwOpen & ACM_STREAMOPENF_QUERY) {
  486.     acmDriverClose(had, 0L);
  487. }
  488. break;
  489.     }
  490. }
  491. acmDriverClose(had, 0L);*/
  492. //if(MSACM_pFirstACMDriverID==NULL)
  493. //    MSACM_RegisterAllDrivers();
  495. for (wadi = MSACM_pFirstACMDriverID; wadi; wadi = wadi->pNextACMDriverID)
  496. {
  497.     /* Check Format */
  498.     if ((int)wadi->wFormatTag != (int)pwfxSrc->wFormatTag) continue;
  500.     ret = acmDriverOpen(&had, (HACMDRIVERID)wadi, 0L);
  501.     if (ret == MMSYSERR_NOERROR) {
  502. if ((wad = MSACM_GetDriver(had)) != NULL) {
  503.     was->obj.pACMDriverID = wad->obj.pACMDriverID;
  504.     was->pDrv = wad;
  505.     was->hAcmDriver = had;
  506.     
  507.     ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
  508.     //lhacm - crash printf("RETOPEN %dn", ret);
  509.                     //ret = 0;
  510.     if (ret == MMSYSERR_NOERROR) {
  511. if (fdwOpen & ACM_STREAMOPENF_QUERY) {
  512.     acmDriverClose(had, 0L);
  513. }
  514. break;
  515.     }
  516. }
  517. // no match, close this acm driver and try next one 
  518. acmDriverClose(had, 0L);
  519.     }
  520. }
  521. if (ret != MMSYSERR_NOERROR) {
  522.     ret = ACMERR_NOTPOSSIBLE;
  523.     goto errCleanUp;
  524. }
  525.     }
  526.     ret = MMSYSERR_NOERROR;
  527.     if (!(fdwOpen & ACM_STREAMOPENF_QUERY)) {
  528. if (phas)
  529.     *phas = (HACMSTREAM)was;
  530. TRACE("=> (%d)n", ret);
  531. #ifdef WIN32_LOADER
  532.         CodecAlloc();
  533. #endif
  534. return ret;
  535.     }
  536. errCleanUp:
  537.     if (phas)
  538. *phas = (HACMSTREAM)0;
  539.     HeapFree(MSACM_hHeap, 0, was);
  540.     TRACE("=> (%d)n", ret);
  541.     return ret;
  542. }
  545. MMRESULT WINAPI acmStreamClose(HACMSTREAM has, DWORD fdwClose)
  546. {
  547.     PWINE_ACMSTREAM was;
  548.     MMRESULT ret;
  550.     TRACE("(0x%08x, %ld)n", has, fdwClose);
  551.     
  552.     if ((was = ACM_GetStream(has)) == NULL) {
  553. return MMSYSERR_INVALHANDLE;
  554.     }
  555.     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_CLOSE, (DWORD)&was->drvInst, 0);
  556.     if (ret == MMSYSERR_NOERROR) {
  557. if (was->hAcmDriver)
  558.     acmDriverClose(was->hAcmDriver, 0L);
  559. HeapFree(MSACM_hHeap, 0, was);
  560. #ifdef WIN32_LOADER
  561.         CodecRelease();
  562. #endif
  563.     }
  564.     TRACE("=> (%d)n", ret);
  565.     return ret;
  566. }
  568. /***********************************************************************
  569.  *           acmStreamConvert (MSACM32.38)
  570.  */
  571. MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash, 
  572.  DWORD fdwConvert)
  573. {
  574.     PWINE_ACMSTREAM was;
  575.     MMRESULT ret = MMSYSERR_NOERROR;
  576.     PACMDRVSTREAMHEADER padsh;
  578.     TRACE("(0x%08x, %p, %ld)n", has, pash, fdwConvert);
  580.     if ((was = ACM_GetStream(has)) == NULL)
  581. return MMSYSERR_INVALHANDLE;
  582.     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER))
  583. return MMSYSERR_INVALPARAM;
  585.     if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED))
  586. return ACMERR_UNPREPARED;
  588.     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
  589.      * size. some fields are private to msacm internals, and are exposed
  590.      * in ACMSTREAMHEADER in the dwReservedDriver array
  591.      */
  592.     padsh = (PACMDRVSTREAMHEADER)pash;
  594.     /* check that pointers have not been modified */
  595.     if (padsh->pbPreparedSrc != padsh->pbSrc ||
  596. padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
  597. padsh->pbPreparedDst != padsh->pbDst ||
  598. padsh->cbPreparedDstLength < padsh->cbDstLength) {
  599. return MMSYSERR_INVALPARAM;
  600.     }
  602.     padsh->fdwConvert = fdwConvert;
  604.     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_CONVERT, (DWORD)&was->drvInst, (DWORD)padsh);
  605.     if (ret == MMSYSERR_NOERROR) {
  606. padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_DONE;
  607.     }
  608.     TRACE("=> (%d)n", ret);
  609.     return ret;
  610. }
  613. /***********************************************************************
  614.  *           acmStreamPrepareHeader (MSACM32.41)
  615.  */
  616. MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, 
  617.        DWORD fdwPrepare)
  618. {
  619.     PWINE_ACMSTREAM was;
  620.     MMRESULT ret = MMSYSERR_NOERROR;
  621.     PACMDRVSTREAMHEADER padsh;
  623.     TRACE("(0x%08x, %p, %ld)n", has, pash, fdwPrepare);
  624.     
  625.     if ((was = ACM_GetStream(has)) == NULL)
  626. return MMSYSERR_INVALHANDLE;
  627.     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER))
  628. return MMSYSERR_INVALPARAM;
  629.     if (fdwPrepare)
  630. ret = MMSYSERR_INVALFLAG;
  632.     if (pash->fdwStatus & ACMSTREAMHEADER_STATUSF_DONE)
  633. return MMSYSERR_NOERROR;
  635.     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
  636.      * size. some fields are private to msacm internals, and are exposed
  637.      * in ACMSTREAMHEADER in the dwReservedDriver array
  638.      */
  639.     padsh = (PACMDRVSTREAMHEADER)pash;
  641.     padsh->fdwConvert = fdwPrepare;
  642.     padsh->padshNext = NULL;
  643.     padsh->fdwDriver = padsh->dwDriver = 0L;
  645.     padsh->fdwPrepared = 0;
  646.     padsh->dwPrepared = 0;
  647.     padsh->pbPreparedSrc = 0;
  648.     padsh->cbPreparedSrcLength = 0;
  649.     padsh->pbPreparedDst = 0;
  650.     padsh->cbPreparedDstLength = 0;
  652.     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_PREPARE, (DWORD)&was->drvInst, (DWORD)padsh);
  653.     if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
  654. ret = MMSYSERR_NOERROR;
  655. padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE);
  656. padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_PREPARED;
  657. padsh->fdwPrepared = padsh->fdwStatus;
  658. padsh->dwPrepared = 0;
  659. padsh->pbPreparedSrc = padsh->pbSrc;
  660. padsh->cbPreparedSrcLength = padsh->cbSrcLength;
  661. padsh->pbPreparedDst = padsh->pbDst;
  662. padsh->cbPreparedDstLength = padsh->cbDstLength;
  663.     } else {
  664. padsh->fdwPrepared = 0;
  665. padsh->dwPrepared = 0;
  666. padsh->pbPreparedSrc = 0;
  667. padsh->cbPreparedSrcLength = 0;
  668. padsh->pbPreparedDst = 0;
  669. padsh->cbPreparedDstLength = 0;
  670.     }
  671.     TRACE("=> (%d)n", ret);
  672.     return ret;
  673. }
  675. /***********************************************************************
  676.  *           acmStreamReset (MSACM32.42)
  677.  */
  678. MMRESULT WINAPI acmStreamReset(HACMSTREAM has, DWORD fdwReset)
  679. {
  680.     PWINE_ACMSTREAM was;
  681.     MMRESULT ret = MMSYSERR_NOERROR;
  683.     TRACE("(0x%08x, %ld)n", has, fdwReset);
  685.     if (fdwReset) {
  686. ret = MMSYSERR_INVALFLAG;
  687.     } else if ((was = ACM_GetStream(has)) == NULL) {
  688. return MMSYSERR_INVALHANDLE;
  689.     } else if (was->drvInst.fdwOpen & ACM_STREAMOPENF_ASYNC) {
  690. ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_RESET, (DWORD)&was->drvInst, 0);
  691.     }
  692.     TRACE("=> (%d)n", ret);
  693.     return ret;
  694. }
  696. /***********************************************************************
  697.  *           acmStreamSize (MSACM32.43)
  698.  */
  699. MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput, 
  700.       LPDWORD pdwOutputBytes, DWORD fdwSize)
  701. {
  702.     PWINE_ACMSTREAM was;
  703.     ACMDRVSTREAMSIZE adss;
  704.     MMRESULT ret;
  705.     
  706.     TRACE("(0x%08x, %ld, %p, %ld)n", has, cbInput, pdwOutputBytes, fdwSize);
  707.     
  708.     if ((was = ACM_GetStream(has)) == NULL) {
  709. return MMSYSERR_INVALHANDLE;
  710.     }
  711.     if ((fdwSize & ~ACM_STREAMSIZEF_QUERYMASK) != 0) {
  712. return MMSYSERR_INVALFLAG;
  713.     }
  715.     *pdwOutputBytes = 0L;
  716.     
  717.     switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
  718.     case ACM_STREAMSIZEF_DESTINATION:
  719. adss.cbDstLength = cbInput;
  720. adss.cbSrcLength = 0;
  721. break;
  722.     case ACM_STREAMSIZEF_SOURCE:
  723. adss.cbSrcLength = cbInput;
  724. adss.cbDstLength = 0;
  725. break;
  726.     default:
  727. return MMSYSERR_INVALFLAG;
  728.     }
  729.     
  730.     adss.cbStruct = sizeof(adss);
  731.     adss.fdwSize = fdwSize;
  732.     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_SIZE, 
  733.     (DWORD)&was->drvInst, (DWORD)&adss);
  734.     if (ret == MMSYSERR_NOERROR) {
  735. switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
  736. case ACM_STREAMSIZEF_DESTINATION:
  737.     *pdwOutputBytes = adss.cbSrcLength;
  738.     break;
  739. case ACM_STREAMSIZEF_SOURCE:
  740.     *pdwOutputBytes = adss.cbDstLength;
  741.     break;
  742. }
  743.     }
  744.     TRACE("=> (%d) [%lu]n", ret, *pdwOutputBytes);
  745.     return ret;
  746. }
  748. /***********************************************************************
  749.  *           acmStreamUnprepareHeader (MSACM32.44)
  750.  */
  751. MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, 
  752.  DWORD fdwUnprepare)
  753. {
  754.     PWINE_ACMSTREAM was;
  755.     MMRESULT ret = MMSYSERR_NOERROR;
  756.     PACMDRVSTREAMHEADER padsh;
  758.     TRACE("(0x%08x, %p, %ld)n", has, pash, fdwUnprepare);
  759.     
  760.     if ((was = ACM_GetStream(has)) == NULL)
  761. return MMSYSERR_INVALHANDLE;
  762.     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER))
  763. return MMSYSERR_INVALPARAM;
  765.     if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED))
  766. return ACMERR_UNPREPARED;
  768.     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
  769.      * size. some fields are private to msacm internals, and are exposed
  770.      * in ACMSTREAMHEADER in the dwReservedDriver array
  771.      */
  772.     padsh = (PACMDRVSTREAMHEADER)pash;
  774.     /* check that pointers have not been modified */
  775.     if (padsh->pbPreparedSrc != padsh->pbSrc ||
  776. padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
  777. padsh->pbPreparedDst != padsh->pbDst ||
  778. padsh->cbPreparedDstLength < padsh->cbDstLength) {
  779. return MMSYSERR_INVALPARAM;
  780.     }
  782.     padsh->fdwConvert = fdwUnprepare;
  784.     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_UNPREPARE, (DWORD)&was->drvInst, (DWORD)padsh);
  785.     if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
  786. ret = MMSYSERR_NOERROR;
  787. padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE|ACMSTREAMHEADER_STATUSF_PREPARED);
  788.     }
  789.     TRACE("=> (%d)n", ret);
  790.     return ret;
  791. }