loader/afl.c

   1 /*
   2  * $Id$
   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  */
  28
  29 /**************************************************************************
  30
  31
  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.
  47
  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"
  53
  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"
  68
  69 #include <stdio.h>
  70 #include <stdlib.h>
  71 #include <string.h>
  72 #pragma pack(1)
  73 #define OpenDriverA DrvOpen
  74 #define CloseDriver DrvClose
  75
  76 static inline PWINE_ACMSTREAM ACM_GetStream(HACMSTREAM has)
  77 {
  78     return (PWINE_ACMSTREAM)has;
  79 }
  80
  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 }
 111
 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;
 126
 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 }
 141
 142 /***********************************************************************
 143  *           acmDriverEnum (MSACM32.7)
 144  */
 145 MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
 146 {
 147     PWINE_ACMDRIVERID   p;
 148     DWORD               fdwSupport;
 149
 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 }
 171
 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 }
 193
 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 }
 212
 213
 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;
 223
 224
 225     TRACE("(%p, %x, %08lu)\n", phad, hadid, fdwOpen);
 226
 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;
 240
 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;
 246
 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     }
 257
 258     pad->pfnDriverProc = GetProcAddress(pad->hDrvr, "DriverProc");
 259
 260     /* insert new pad at beg of list */
 261     pad->pNextACMDriver = padid->pACMDriverList;
 262     padid->pACMDriverList = pad;
 263
 264     /* FIXME: Create a WINE_ACMDRIVER32 */
 265     *phad = (HACMDRIVER)pad;
 266
 267     return MMSYSERR_NOERROR;
 268 }
 269
 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 }
 288
 289
 290
 291 /**********************************************************************/
 292
 293 HANDLE MSACM_hHeap = (HANDLE) NULL;
 294 PWINE_ACMDRIVERID MSACM_pFirstACMDriverID = NULL;
 295 PWINE_ACMDRIVERID MSACM_pLastACMDriverID = NULL;
 296
 297 /***********************************************************************
 298  *           MSACM_RegisterDriver32()
 299  */
 300 PWINE_ACMDRIVERID MSACM_RegisterDriver(const char* pszFileName,
 301                                        WORD wFormatTag,
 302                                        HINSTANCE hinstModule)
 303 {
 304     PWINE_ACMDRIVERID padid;
 305
 306     TRACE("('%s', '%x', 0x%08x)\n", pszFileName, wFormatTag, hinstModule);
 307
 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 }
 329
 330
 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     if (p->pszFileName)
 342         free(p->pszFileName);
 343
 344     if (p == MSACM_pFirstACMDriverID)
 345         MSACM_pFirstACMDriverID = p->pNextACMDriverID;
 346     if (p == MSACM_pLastACMDriverID)
 347         MSACM_pLastACMDriverID = p->pPrevACMDriverID;
 348
 349     if (p->pPrevACMDriverID)
 350         p->pPrevACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
 351     if (p->pNextACMDriverID)
 352         p->pNextACMDriverID->pPrevACMDriverID = p->pPrevACMDriverID;
 353
 354     pNextACMDriverID = p->pNextACMDriverID;
 355
 356     HeapFree(MSACM_hHeap, 0, p);
 357
 358     return pNextACMDriverID;
 359 }
 360
 361 /***********************************************************************
 362  *           MSACM_UnregisterAllDrivers32()
 363  * FIXME
 364  *   Where should this function be called?
 365  */
 366 void MSACM_UnregisterAllDrivers(void)
 367 {
 368     PWINE_ACMDRIVERID p;
 369
 370     for (p = MSACM_pFirstACMDriverID; p; p = MSACM_UnregisterDriver(p));
 371 }
 372
 373 /***********************************************************************
 374  *           MSACM_GetDriverID32()
 375  */
 376 PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID)
 377 {
 378     return (PWINE_ACMDRIVERID)hDriverID;
 379 }
 380
 381 /***********************************************************************
 382  *           MSACM_GetDriver32()
 383  */
 384 PWINE_ACMDRIVER MSACM_GetDriver(HACMDRIVER hDriver)
 385 {
 386     return (PWINE_ACMDRIVER)hDriver;
 387 }
 388
 389 /***********************************************************************
 390  *           MSACM_GetObj32()
 391  */
 392 PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj)
 393 {
 394     return (PWINE_ACMOBJ)hObj;
 395 }
 396
 397
 398
 399 /***********************************************************************
 400  *           acmStreamOpen (MSACM32.40)
 401  */
 402 MMRESULT WINAPI acmStreamOpen(PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
 403                               PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
 404                               DWORD dwInstance, DWORD fdwOpen)
 405 {
 406     PWINE_ACMSTREAM     was;
 407     PWINE_ACMDRIVER     wad;
 408     MMRESULT            ret;
 409     int                 wfxSrcSize;
 410     int                 wfxDstSize;
 411
 412     TRACE("(%p, 0x%08x, %p, %p, %p, %ld, %ld, %ld)\n",
 413           phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
 414
 415     TRACE("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
 416           pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec,
 417           pwfxSrc->nBlockAlign, pwfxSrc->wBitsPerSample, pwfxSrc->cbSize);
 418
 419     TRACE("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
 420           pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec,
 421           pwfxDst->nBlockAlign, pwfxDst->wBitsPerSample, pwfxDst->cbSize);
 422
 423 #define SIZEOF_WFX(wfx) (sizeof(WAVEFORMATEX) + ((wfx->wFormatTag == WAVE_FORMAT_PCM) ? 0 : wfx->cbSize))
 424     wfxSrcSize = SIZEOF_WFX(pwfxSrc);
 425     wfxDstSize = SIZEOF_WFX(pwfxDst);
 426 #undef SIZEOF_WFX
 427
 428     was = (PWINE_ACMSTREAM) HeapAlloc(MSACM_hHeap, 0, sizeof(*was) + wfxSrcSize + wfxDstSize + ((pwfltr) ? sizeof(WAVEFILTER) : 0));
 429     if (was == NULL)
 430         return MMSYSERR_NOMEM;
 431     was->drvInst.cbStruct = sizeof(was->drvInst);
 432     was->drvInst.pwfxSrc = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was));
 433     memcpy(was->drvInst.pwfxSrc, pwfxSrc, wfxSrcSize);
 434     // LHACM is checking for 0x1
 435     // but if this will not help
 436     // was->drvInst.pwfxSrc->wFormatTag = 1;
 437     was->drvInst.pwfxDst = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was) + wfxSrcSize);
 438     memcpy(was->drvInst.pwfxDst, pwfxDst, wfxDstSize);
 439     if (pwfltr) {
 440         was->drvInst.pwfltr = (PWAVEFILTER)((LPSTR)was + sizeof(*was) + wfxSrcSize + wfxDstSize);
 441         memcpy(was->drvInst.pwfltr, pwfltr, sizeof(WAVEFILTER));
 442     } else {
 443         was->drvInst.pwfltr = NULL;
 444     }
 445     was->drvInst.dwCallback = dwCallback;
 446     was->drvInst.dwInstance = dwInstance;
 447     was->drvInst.fdwOpen = fdwOpen;
 448     was->drvInst.fdwDriver = 0L;
 449     was->drvInst.dwDriver = 0L;
 450     was->drvInst.has = (HACMSTREAM)was;
 451
 452     if (had) {
 453         if (!(wad = MSACM_GetDriver(had))) {
 454             ret = MMSYSERR_INVALPARAM;
 455             goto errCleanUp;
 456         }
 457
 458         was->obj.pACMDriverID = wad->obj.pACMDriverID;
 459         was->pDrv = wad;
 460         was->hAcmDriver = 0; /* not to close it in acmStreamClose */
 461
 462         ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
 463         if (ret != MMSYSERR_NOERROR)
 464             goto errCleanUp;
 465     } else {
 466         PWINE_ACMDRIVERID wadi;
 467         short drv_tag;
 468         ret = ACMERR_NOTPOSSIBLE;
 469 /*      if(pwfxSrc->wFormatTag==1)//compression
 470             drv_tag=pwfxDst->wFormatTag;
 471             else
 472             if(pwfxDst->wFormatTag==1)//decompression
 473                 drv_tag=pwfxSrc->wFormatTag;
 474                 else
 475                 goto errCleanUp;
 476
 477             ret=acmDriverOpen2(drv_tag);
 478             if (ret == MMSYSERR_NOERROR) {
 479                 if ((wad = MSACM_GetDriver(had)) != 0) {
 480                     was->obj.pACMDriverID = wad->obj.pACMDriverID;
 481                     was->pDrv = wad;
 482                     was->hAcmDriver = had;
 483
 484                     ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
 485                     if (ret == MMSYSERR_NOERROR) {
 486                         if (fdwOpen & ACM_STREAMOPENF_QUERY) {
 487                             acmDriverClose(had, 0L);
 488                         }
 489                         break;
 490                     }
 491                 }
 492                 acmDriverClose(had, 0L);*/
 493         //if(MSACM_pFirstACMDriverID==NULL)
 494         //    MSACM_RegisterAllDrivers();
 495
 496         for (wadi = MSACM_pFirstACMDriverID; wadi; wadi = wadi->pNextACMDriverID)
 497         {
 498             /* Check Format */
 499             if ((int)wadi->wFormatTag != (int)pwfxSrc->wFormatTag) continue;
 500
 501             ret = acmDriverOpen(&had, (HACMDRIVERID)wadi, 0L);
 502             if (ret == MMSYSERR_NOERROR) {
 503                 if ((wad = MSACM_GetDriver(had)) != 0) {
 504                     was->obj.pACMDriverID = wad->obj.pACMDriverID;
 505                     was->pDrv = wad;
 506                     was->hAcmDriver = had;
 507
 508                     ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
 509                     //lhacm - crash printf("RETOPEN %d\n", ret);
 510                     //ret = 0;
 511                     if (ret == MMSYSERR_NOERROR) {
 512                         if (fdwOpen & ACM_STREAMOPENF_QUERY) {
 513                             acmDriverClose(had, 0L);
 514                         }
 515                         break;
 516                     }
 517                 }
 518                 // no match, close this acm driver and try next one
 519                 acmDriverClose(had, 0L);
 520             }
 521         }
 522         if (ret != MMSYSERR_NOERROR) {
 523             ret = ACMERR_NOTPOSSIBLE;
 524             goto errCleanUp;
 525         }
 526     }
 527     ret = MMSYSERR_NOERROR;
 528     if (!(fdwOpen & ACM_STREAMOPENF_QUERY)) {
 529         if (phas)
 530             *phas = (HACMSTREAM)was;
 531         TRACE("=> (%d)\n", ret);
 532 #ifdef WIN32_LOADER
 533         CodecAlloc();
 534 #endif
 535         return ret;
 536     }
 537 errCleanUp:
 538     if (phas)
 539         *phas = (HACMSTREAM)0;
 540     HeapFree(MSACM_hHeap, 0, was);
 541     TRACE("=> (%d)\n", ret);
 542     return ret;
 543 }
 544
 545
 546 MMRESULT WINAPI acmStreamClose(HACMSTREAM has, DWORD fdwClose)
 547 {
 548     PWINE_ACMSTREAM     was;
 549     MMRESULT            ret;
 550
 551     TRACE("(0x%08x, %ld)\n", has, fdwClose);
 552
 553     if ((was = ACM_GetStream(has)) == NULL) {
 554         return MMSYSERR_INVALHANDLE;
 555     }
 556     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_CLOSE, (DWORD)&was->drvInst, 0);
 557     if (ret == MMSYSERR_NOERROR) {
 558         if (was->hAcmDriver)
 559             acmDriverClose(was->hAcmDriver, 0L);
 560         HeapFree(MSACM_hHeap, 0, was);
 561 #ifdef WIN32_LOADER
 562         CodecRelease();
 563 #endif
 564     }
 565     TRACE("=> (%d)\n", ret);
 566     return ret;
 567 }
 568
 569 /***********************************************************************
 570  *           acmStreamConvert (MSACM32.38)
 571  */
 572 MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash,
 573                                  DWORD fdwConvert)
 574 {
 575     PWINE_ACMSTREAM     was;
 576     MMRESULT            ret = MMSYSERR_NOERROR;
 577     PACMDRVSTREAMHEADER padsh;
 578
 579     TRACE("(0x%08x, %p, %ld)\n", has, pash, fdwConvert);
 580
 581     if ((was = ACM_GetStream(has)) == NULL)
 582         return MMSYSERR_INVALHANDLE;
 583     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER))
 584         return MMSYSERR_INVALPARAM;
 585
 586     if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED))
 587         return ACMERR_UNPREPARED;
 588
 589     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
 590      * size. some fields are private to msacm internals, and are exposed
 591      * in ACMSTREAMHEADER in the dwReservedDriver array
 592      */
 593     padsh = (PACMDRVSTREAMHEADER)pash;
 594
 595     /* check that pointers have not been modified */
 596     if (padsh->pbPreparedSrc != padsh->pbSrc ||
 597         padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
 598         padsh->pbPreparedDst != padsh->pbDst ||
 599         padsh->cbPreparedDstLength < padsh->cbDstLength) {
 600         return MMSYSERR_INVALPARAM;
 601     }
 602
 603     padsh->fdwConvert = fdwConvert;
 604
 605     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_CONVERT, (DWORD)&was->drvInst, (DWORD)padsh);
 606     if (ret == MMSYSERR_NOERROR) {
 607         padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_DONE;
 608     }
 609     TRACE("=> (%d)\n", ret);
 610     return ret;
 611 }
 612
 613
 614 /***********************************************************************
 615  *           acmStreamPrepareHeader (MSACM32.41)
 616  */
 617 MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
 618                                        DWORD fdwPrepare)
 619 {
 620     PWINE_ACMSTREAM     was;
 621     MMRESULT            ret = MMSYSERR_NOERROR;
 622     PACMDRVSTREAMHEADER padsh;
 623
 624     TRACE("(0x%08x, %p, %ld)\n", has, pash, fdwPrepare);
 625
 626     if ((was = ACM_GetStream(has)) == NULL)
 627         return MMSYSERR_INVALHANDLE;
 628     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER))
 629         return MMSYSERR_INVALPARAM;
 630     if (fdwPrepare)
 631         ret = MMSYSERR_INVALFLAG;
 632
 633     if (pash->fdwStatus & ACMSTREAMHEADER_STATUSF_DONE)
 634         return MMSYSERR_NOERROR;
 635
 636     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
 637      * size. some fields are private to msacm internals, and are exposed
 638      * in ACMSTREAMHEADER in the dwReservedDriver array
 639      */
 640     padsh = (PACMDRVSTREAMHEADER)pash;
 641
 642     padsh->fdwConvert = fdwPrepare;
 643     padsh->padshNext = NULL;
 644     padsh->fdwDriver = padsh->dwDriver = 0L;
 645
 646     padsh->fdwPrepared = 0;
 647     padsh->dwPrepared = 0;
 648     padsh->pbPreparedSrc = 0;
 649     padsh->cbPreparedSrcLength = 0;
 650     padsh->pbPreparedDst = 0;
 651     padsh->cbPreparedDstLength = 0;
 652
 653     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_PREPARE, (DWORD)&was->drvInst, (DWORD)padsh);
 654     if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
 655         ret = MMSYSERR_NOERROR;
 656         padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE);
 657         padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_PREPARED;
 658         padsh->fdwPrepared = padsh->fdwStatus;
 659         padsh->dwPrepared = 0;
 660         padsh->pbPreparedSrc = padsh->pbSrc;
 661         padsh->cbPreparedSrcLength = padsh->cbSrcLength;
 662         padsh->pbPreparedDst = padsh->pbDst;
 663         padsh->cbPreparedDstLength = padsh->cbDstLength;
 664     } else {
 665         padsh->fdwPrepared = 0;
 666         padsh->dwPrepared = 0;
 667         padsh->pbPreparedSrc = 0;
 668         padsh->cbPreparedSrcLength = 0;
 669         padsh->pbPreparedDst = 0;
 670         padsh->cbPreparedDstLength = 0;
 671     }
 672     TRACE("=> (%d)\n", ret);
 673     return ret;
 674 }
 675
 676 /***********************************************************************
 677  *           acmStreamReset (MSACM32.42)
 678  */
 679 MMRESULT WINAPI acmStreamReset(HACMSTREAM has, DWORD fdwReset)
 680 {
 681     PWINE_ACMSTREAM     was;
 682     MMRESULT            ret = MMSYSERR_NOERROR;
 683
 684     TRACE("(0x%08x, %ld)\n", has, fdwReset);
 685
 686     if (fdwReset) {
 687         ret = MMSYSERR_INVALFLAG;
 688     } else if ((was = ACM_GetStream(has)) == NULL) {
 689         return MMSYSERR_INVALHANDLE;
 690     } else if (was->drvInst.fdwOpen & ACM_STREAMOPENF_ASYNC) {
 691         ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_RESET, (DWORD)&was->drvInst, 0);
 692     }
 693     TRACE("=> (%d)\n", ret);
 694     return ret;
 695 }
 696
 697 /***********************************************************************
 698  *           acmStreamSize (MSACM32.43)
 699  */
 700 MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput,
 701                               LPDWORD pdwOutputBytes, DWORD fdwSize)
 702 {
 703     PWINE_ACMSTREAM     was;
 704     ACMDRVSTREAMSIZE    adss;
 705     MMRESULT            ret;
 706
 707     TRACE("(0x%08x, %ld, %p, %ld)\n", has, cbInput, pdwOutputBytes, fdwSize);
 708
 709     if ((was = ACM_GetStream(has)) == NULL) {
 710         return MMSYSERR_INVALHANDLE;
 711     }
 712     if ((fdwSize & ~ACM_STREAMSIZEF_QUERYMASK) != 0) {
 713         return MMSYSERR_INVALFLAG;
 714     }
 715
 716     *pdwOutputBytes = 0L;
 717
 718     switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
 719     case ACM_STREAMSIZEF_DESTINATION:
 720         adss.cbDstLength = cbInput;
 721         adss.cbSrcLength = 0;
 722         break;
 723     case ACM_STREAMSIZEF_SOURCE:
 724         adss.cbSrcLength = cbInput;
 725         adss.cbDstLength = 0;
 726         break;
 727     default:
 728         return MMSYSERR_INVALFLAG;
 729     }
 730
 731     adss.cbStruct = sizeof(adss);
 732     adss.fdwSize = fdwSize;
 733     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_SIZE,
 734                             (DWORD)&was->drvInst, (DWORD)&adss);
 735     if (ret == MMSYSERR_NOERROR) {
 736         switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
 737         case ACM_STREAMSIZEF_DESTINATION:
 738             *pdwOutputBytes = adss.cbSrcLength;
 739             break;
 740         case ACM_STREAMSIZEF_SOURCE:
 741             *pdwOutputBytes = adss.cbDstLength;
 742             break;
 743         }
 744     }
 745     TRACE("=> (%d) [%lu]\n", ret, *pdwOutputBytes);
 746     return ret;
 747 }
 748
 749 /***********************************************************************
 750  *           acmStreamUnprepareHeader (MSACM32.44)
 751  */
 752 MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
 753                                          DWORD fdwUnprepare)
 754 {
 755     PWINE_ACMSTREAM     was;
 756     MMRESULT            ret = MMSYSERR_NOERROR;
 757     PACMDRVSTREAMHEADER padsh;
 758
 759     TRACE("(0x%08x, %p, %ld)\n", has, pash, fdwUnprepare);
 760
 761     if ((was = ACM_GetStream(has)) == NULL)
 762         return MMSYSERR_INVALHANDLE;
 763     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER))
 764         return MMSYSERR_INVALPARAM;
 765
 766     if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED))
 767         return ACMERR_UNPREPARED;
 768
 769     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
 770      * size. some fields are private to msacm internals, and are exposed
 771      * in ACMSTREAMHEADER in the dwReservedDriver array
 772      */
 773     padsh = (PACMDRVSTREAMHEADER)pash;
 774
 775     /* check that pointers have not been modified */
 776     if (padsh->pbPreparedSrc != padsh->pbSrc ||
 777         padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
 778         padsh->pbPreparedDst != padsh->pbDst ||
 779         padsh->cbPreparedDstLength < padsh->cbDstLength) {
 780         return MMSYSERR_INVALPARAM;
 781     }
 782
 783     padsh->fdwConvert = fdwUnprepare;
 784
 785     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_UNPREPARE, (DWORD)&was->drvInst, (DWORD)padsh);
 786     if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
 787         ret = MMSYSERR_NOERROR;
 788         padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE|ACMSTREAMHEADER_STATUSF_PREPARED);
 789     }
 790     TRACE("=> (%d)\n", ret);
 791     return ret;
 792 }