dlls/msacm/stream.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  *      MSACM32 library
   5  *
   6  *      Copyright 1998  Patrik Stridvall
   7  *                1999  Eric Pouech
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 /* TODO
  25  *      + asynchronous conversion is not implemented
  26  *      + callback/notification
  27  *      * acmStreamMessage
  28  *      + properly close ACM streams
  29  */
  30
  31 #include <stdarg.h>
  32 #include <string.h>
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winerror.h"
  36 #include "wine/debug.h"
  37 #include "mmsystem.h"
  38 #define NOBITMAP
  39 #include "mmreg.h"
  40 #include "msacm.h"
  41 #include "msacmdrv.h"
  42 #include "wineacm.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(msacm);
  45
  46 static PWINE_ACMSTREAM  ACM_GetStream(HACMSTREAM has)
  47 {
  48     TRACE("(%p)\n", has);
  49
  50     return (PWINE_ACMSTREAM)has;
  51 }
  52
  53 /***********************************************************************
  54  *           acmStreamClose (MSACM32.@)
  55  */
  56 MMRESULT WINAPI acmStreamClose(HACMSTREAM has, DWORD fdwClose)
  57 {
  58     PWINE_ACMSTREAM     was;
  59     MMRESULT            ret;
  60
  61     TRACE("(%p, %ld)\n", has, fdwClose);
  62
  63     if ((was = ACM_GetStream(has)) == NULL) {
  64         WARN("invalid handle\n");
  65         return MMSYSERR_INVALHANDLE;
  66     }
  67     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_CLOSE, (DWORD)&was->drvInst, 0);
  68     if (ret == MMSYSERR_NOERROR) {
  69         if (was->hAcmDriver)
  70             acmDriverClose(was->hAcmDriver, 0L);
  71         HeapFree(MSACM_hHeap, 0, was);
  72     }
  73     TRACE("=> (%d)\n", ret);
  74     return ret;
  75 }
  76
  77 /***********************************************************************
  78  *           acmStreamConvert (MSACM32.@)
  79  */
  80 MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash,
  81                                  DWORD fdwConvert)
  82 {
  83     PWINE_ACMSTREAM     was;
  84     MMRESULT            ret = MMSYSERR_NOERROR;
  85     PACMDRVSTREAMHEADER padsh;
  86
  87     TRACE("(%p, %p, %ld)\n", has, pash, fdwConvert);
  88
  89     if ((was = ACM_GetStream(has)) == NULL) {
  90         WARN("invalid handle\n");
  91         return MMSYSERR_INVALHANDLE;
  92     }
  93     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER)) {
  94         WARN("invalid parameter\n");
  95         return MMSYSERR_INVALPARAM;
  96     }
  97     if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED)) {
  98         WARN("unprepared header\n");
  99         return ACMERR_UNPREPARED;
 100     }
 101
 102     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
 103      * size. some fields are private to msacm internals, and are exposed
 104      * in ACMSTREAMHEADER in the dwReservedDriver array
 105      */
 106     padsh = (PACMDRVSTREAMHEADER)pash;
 107
 108     /* check that pointers have not been modified */
 109     if (padsh->pbPreparedSrc != padsh->pbSrc ||
 110         padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
 111         padsh->pbPreparedDst != padsh->pbDst ||
 112         padsh->cbPreparedDstLength < padsh->cbDstLength) {
 113         WARN("invalid parameter\n");
 114         return MMSYSERR_INVALPARAM;
 115     }
 116
 117     padsh->fdwConvert = fdwConvert;
 118
 119     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_CONVERT, (DWORD)&was->drvInst, (DWORD)padsh);
 120     if (ret == MMSYSERR_NOERROR) {
 121         padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_DONE;
 122     }
 123     TRACE("=> (%d)\n", ret);
 124     return ret;
 125 }
 126
 127 /***********************************************************************
 128  *           acmStreamMessage (MSACM32.@)
 129  */
 130 MMRESULT WINAPI acmStreamMessage(HACMSTREAM has, UINT uMsg, LPARAM lParam1,
 131                                  LPARAM lParam2)
 132 {
 133     FIXME("(%p, %u, %ld, %ld): stub\n", has, uMsg, lParam1, lParam2);
 134     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 135     return MMSYSERR_ERROR;
 136 }
 137
 138 /***********************************************************************
 139  *           acmStreamOpen (MSACM32.@)
 140  */
 141 MMRESULT WINAPI acmStreamOpen(PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
 142                               PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
 143                               DWORD dwInstance, DWORD fdwOpen)
 144 {
 145     PWINE_ACMSTREAM     was;
 146     PWINE_ACMDRIVER     wad;
 147     MMRESULT            ret;
 148     int                 wfxSrcSize;
 149     int                 wfxDstSize;
 150     WAVEFORMATEX        wfxSrc, wfxDst;
 151
 152     TRACE("(%p, %p, %p, %p, %p, %ld, %ld, %ld)\n",
 153           phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
 154
 155     /* NOTE: pwfxSrc and/or pwfxDst can point to a structure smaller than
 156      * WAVEFORMATEX so don't use them directly when not sure */
 157     if (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) {
 158         memcpy(&wfxSrc, pwfxSrc, sizeof(PCMWAVEFORMAT));
 159         wfxSrc.wBitsPerSample = pwfxSrc->wBitsPerSample;
 160         wfxSrc.cbSize = 0;
 161         pwfxSrc = &wfxSrc;
 162     }
 163
 164     if (pwfxDst->wFormatTag == WAVE_FORMAT_PCM) {
 165         memcpy(&wfxDst, pwfxDst, sizeof(PCMWAVEFORMAT));
 166         wfxDst.wBitsPerSample = pwfxDst->wBitsPerSample;
 167         wfxDst.cbSize = 0;
 168         pwfxDst = &wfxDst;
 169     }
 170
 171     TRACE("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
 172           pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec,
 173           pwfxSrc->nBlockAlign, pwfxSrc->wBitsPerSample, pwfxSrc->cbSize);
 174
 175     TRACE("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
 176           pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec,
 177           pwfxDst->nBlockAlign, pwfxDst->wBitsPerSample, pwfxDst->cbSize);
 178
 179     /* (WS) In query mode, phas should be NULL. If it is not, then instead
 180      * of returning an error we are making sure it is NULL, preventing some
 181      * applications that pass garbage for phas from crashing.
 182      */
 183     if (fdwOpen & ACM_STREAMOPENF_QUERY) phas = NULL;
 184
 185     if (pwfltr && (pwfxSrc->wFormatTag != pwfxDst->wFormatTag)) {
 186         WARN("invalid parameter\n");
 187         return MMSYSERR_INVALPARAM;
 188     }
 189
 190     wfxSrcSize = wfxDstSize = sizeof(WAVEFORMATEX);
 191     if (pwfxSrc->wFormatTag != WAVE_FORMAT_PCM) wfxSrcSize += pwfxSrc->cbSize;
 192     if (pwfxDst->wFormatTag != WAVE_FORMAT_PCM) wfxDstSize += pwfxDst->cbSize;
 193
 194     was = HeapAlloc(MSACM_hHeap, 0, sizeof(*was) + wfxSrcSize + wfxDstSize +
 195                     ((pwfltr) ? sizeof(WAVEFILTER) : 0));
 196     if (was == NULL) {
 197         WARN("no memory\n");
 198         return MMSYSERR_NOMEM;
 199     }
 200
 201     was->drvInst.cbStruct = sizeof(was->drvInst);
 202     was->drvInst.pwfxSrc = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was));
 203     memcpy(was->drvInst.pwfxSrc, pwfxSrc, wfxSrcSize);
 204     was->drvInst.pwfxDst = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was) + wfxSrcSize);
 205     memcpy(was->drvInst.pwfxDst, pwfxDst, wfxDstSize);
 206     if (pwfltr) {
 207         was->drvInst.pwfltr = (PWAVEFILTER)((LPSTR)was + sizeof(*was) + wfxSrcSize + wfxDstSize);
 208         memcpy(was->drvInst.pwfltr, pwfltr, sizeof(WAVEFILTER));
 209     } else {
 210         was->drvInst.pwfltr = NULL;
 211     }
 212     was->drvInst.dwCallback = dwCallback;
 213     was->drvInst.dwInstance = dwInstance;
 214     was->drvInst.fdwOpen = fdwOpen;
 215     was->drvInst.fdwDriver = 0L;
 216     was->drvInst.dwDriver = 0L;
 217     /* real value will be stored once ACMDM_STREAM_OPEN succeeds */
 218     was->drvInst.has = 0L;
 219
 220     if (had) {
 221         if (!(wad = MSACM_GetDriver(had))) {
 222             ret = MMSYSERR_INVALPARAM;
 223             goto errCleanUp;
 224         }
 225
 226         was->obj.dwType = WINE_ACMOBJ_STREAM;
 227         was->obj.pACMDriverID = wad->obj.pACMDriverID;
 228         was->pDrv = wad;
 229         was->hAcmDriver = 0; /* not to close it in acmStreamClose */
 230
 231         ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
 232         if (ret != MMSYSERR_NOERROR)
 233             goto errCleanUp;
 234     } else {
 235         PWINE_ACMDRIVERID wadi;
 236
 237         ret = ACMERR_NOTPOSSIBLE;
 238         for (wadi = MSACM_pFirstACMDriverID; wadi; wadi = wadi->pNextACMDriverID) {
 239             if ((wadi->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ||
 240                 !MSACM_FindFormatTagInCache(wadi, pwfxSrc->wFormatTag, NULL) ||
 241                 !MSACM_FindFormatTagInCache(wadi, pwfxDst->wFormatTag, NULL))
 242                 continue;
 243             ret = acmDriverOpen(&had, (HACMDRIVERID)wadi, 0L);
 244             if (ret != MMSYSERR_NOERROR)
 245                 continue;
 246             if ((wad = MSACM_GetDriver(had)) != 0) {
 247                 was->obj.dwType = WINE_ACMOBJ_STREAM;
 248                 was->obj.pACMDriverID = wad->obj.pACMDriverID;
 249                 was->pDrv = wad;
 250                 was->hAcmDriver = had;
 251
 252                 ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
 253                 TRACE("%s => %08x\n", debugstr_w(wadi->pszDriverAlias), ret);
 254                 if (ret == MMSYSERR_NOERROR) {
 255                     if (fdwOpen & ACM_STREAMOPENF_QUERY) {
 256                         acmDriverClose(had, 0L);
 257                     }
 258                     break;
 259                 }
 260             }
 261             /* no match, close this acm driver and try next one */
 262             acmDriverClose(had, 0L);
 263         }
 264         if (ret != MMSYSERR_NOERROR) {
 265             ret = ACMERR_NOTPOSSIBLE;
 266             goto errCleanUp;
 267         }
 268     }
 269     ret = MMSYSERR_NOERROR;
 270     was->drvInst.has = (HACMSTREAM)was;
 271     if (!(fdwOpen & ACM_STREAMOPENF_QUERY)) {
 272         if (phas)
 273             *phas = (HACMSTREAM)was;
 274         TRACE("=> (%d)\n", ret);
 275         return ret;
 276     }
 277 errCleanUp:
 278     if (phas)
 279         *phas = NULL;
 280     HeapFree(MSACM_hHeap, 0, was);
 281     TRACE("=> (%d)\n", ret);
 282     return ret;
 283 }
 284
 285
 286 /***********************************************************************
 287  *           acmStreamPrepareHeader (MSACM32.@)
 288  */
 289 MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
 290                                        DWORD fdwPrepare)
 291 {
 292     PWINE_ACMSTREAM     was;
 293     MMRESULT            ret = MMSYSERR_NOERROR;
 294     PACMDRVSTREAMHEADER padsh;
 295
 296     TRACE("(%p, %p, %ld)\n", has, pash, fdwPrepare);
 297
 298     if ((was = ACM_GetStream(has)) == NULL) {
 299         WARN("invalid handle\n");
 300         return MMSYSERR_INVALHANDLE;
 301     }
 302     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER)) {
 303         WARN("invalid parameter\n");
 304         return MMSYSERR_INVALPARAM;
 305     }
 306     if (fdwPrepare)
 307         ret = MMSYSERR_INVALFLAG;
 308
 309     if (pash->fdwStatus & ACMSTREAMHEADER_STATUSF_DONE)
 310         return MMSYSERR_NOERROR;
 311
 312     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
 313      * size. some fields are private to msacm internals, and are exposed
 314      * in ACMSTREAMHEADER in the dwReservedDriver array
 315      */
 316     padsh = (PACMDRVSTREAMHEADER)pash;
 317
 318     padsh->fdwConvert = fdwPrepare;
 319     padsh->padshNext = NULL;
 320     padsh->fdwDriver = padsh->dwDriver = 0L;
 321
 322     padsh->fdwPrepared = 0;
 323     padsh->dwPrepared = 0;
 324     padsh->pbPreparedSrc = 0;
 325     padsh->cbPreparedSrcLength = 0;
 326     padsh->pbPreparedDst = 0;
 327     padsh->cbPreparedDstLength = 0;
 328
 329     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_PREPARE, (DWORD)&was->drvInst, (DWORD)padsh);
 330     if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
 331         ret = MMSYSERR_NOERROR;
 332         padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE);
 333         padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_PREPARED;
 334         padsh->fdwPrepared = padsh->fdwStatus;
 335         padsh->dwPrepared = 0;
 336         padsh->pbPreparedSrc = padsh->pbSrc;
 337         padsh->cbPreparedSrcLength = padsh->cbSrcLength;
 338         padsh->pbPreparedDst = padsh->pbDst;
 339         padsh->cbPreparedDstLength = padsh->cbDstLength;
 340     } else {
 341         padsh->fdwPrepared = 0;
 342         padsh->dwPrepared = 0;
 343         padsh->pbPreparedSrc = 0;
 344         padsh->cbPreparedSrcLength = 0;
 345         padsh->pbPreparedDst = 0;
 346         padsh->cbPreparedDstLength = 0;
 347     }
 348     TRACE("=> (%d)\n", ret);
 349     return ret;
 350 }
 351
 352 /***********************************************************************
 353  *           acmStreamReset (MSACM32.@)
 354  */
 355 MMRESULT WINAPI acmStreamReset(HACMSTREAM has, DWORD fdwReset)
 356 {
 357     PWINE_ACMSTREAM     was;
 358     MMRESULT            ret = MMSYSERR_NOERROR;
 359
 360     TRACE("(%p, %ld)\n", has, fdwReset);
 361
 362     if (fdwReset) {
 363         WARN("invalid flag\n");
 364         ret = MMSYSERR_INVALFLAG;
 365     } else if ((was = ACM_GetStream(has)) == NULL) {
 366         WARN("invalid handle\n");
 367         return MMSYSERR_INVALHANDLE;
 368     } else if (was->drvInst.fdwOpen & ACM_STREAMOPENF_ASYNC) {
 369         ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_RESET, (DWORD)&was->drvInst, 0);
 370     }
 371     TRACE("=> (%d)\n", ret);
 372     return ret;
 373 }
 374
 375 /***********************************************************************
 376  *           acmStreamSize (MSACM32.@)
 377  */
 378 MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput,
 379                               LPDWORD pdwOutputBytes, DWORD fdwSize)
 380 {
 381     PWINE_ACMSTREAM     was;
 382     ACMDRVSTREAMSIZE    adss;
 383     MMRESULT            ret;
 384
 385     TRACE("(%p, %ld, %p, %ld)\n", has, cbInput, pdwOutputBytes, fdwSize);
 386
 387     if ((was = ACM_GetStream(has)) == NULL) {
 388         WARN("invalid handle\n");
 389         return MMSYSERR_INVALHANDLE;
 390     }
 391     if ((fdwSize & ~ACM_STREAMSIZEF_QUERYMASK) != 0) {
 392         WARN("invalid flag\n");
 393         return MMSYSERR_INVALFLAG;
 394     }
 395
 396     *pdwOutputBytes = 0L;
 397
 398     switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
 399     case ACM_STREAMSIZEF_DESTINATION:
 400         adss.cbDstLength = cbInput;
 401         adss.cbSrcLength = 0;
 402         break;
 403     case ACM_STREAMSIZEF_SOURCE:
 404         adss.cbSrcLength = cbInput;
 405         adss.cbDstLength = 0;
 406         break;
 407     default:
 408         WARN("invalid flag\n");
 409         return MMSYSERR_INVALFLAG;
 410     }
 411
 412     adss.cbStruct = sizeof(adss);
 413     adss.fdwSize = fdwSize;
 414     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_SIZE,
 415                             (DWORD)&was->drvInst, (DWORD)&adss);
 416     if (ret == MMSYSERR_NOERROR) {
 417         switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
 418         case ACM_STREAMSIZEF_DESTINATION:
 419             *pdwOutputBytes = adss.cbSrcLength;
 420             break;
 421         case ACM_STREAMSIZEF_SOURCE:
 422             *pdwOutputBytes = adss.cbDstLength;
 423             break;
 424         }
 425     }
 426     TRACE("=> (%d) [%lu]\n", ret, *pdwOutputBytes);
 427     return ret;
 428 }
 429
 430 /***********************************************************************
 431  *           acmStreamUnprepareHeader (MSACM32.@)
 432  */
 433 MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
 434                                          DWORD fdwUnprepare)
 435 {
 436     PWINE_ACMSTREAM     was;
 437     MMRESULT            ret = MMSYSERR_NOERROR;
 438     PACMDRVSTREAMHEADER padsh;
 439
 440     TRACE("(%p, %p, %ld)\n", has, pash, fdwUnprepare);
 441
 442     if ((was = ACM_GetStream(has)) == NULL) {
 443         WARN("invalid handle\n");
 444         return MMSYSERR_INVALHANDLE;
 445     }
 446     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER)) {
 447         WARN("invalid parameter\n");
 448         return MMSYSERR_INVALPARAM;
 449     }
 450     if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED)) {
 451         WARN("unprepared header\n");
 452         return ACMERR_UNPREPARED;
 453     }
 454
 455     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
 456      * size. some fields are private to msacm internals, and are exposed
 457      * in ACMSTREAMHEADER in the dwReservedDriver array
 458      */
 459     padsh = (PACMDRVSTREAMHEADER)pash;
 460
 461     /* check that pointers have not been modified */
 462     if (padsh->pbPreparedSrc != padsh->pbSrc ||
 463         padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
 464         padsh->pbPreparedDst != padsh->pbDst ||
 465         padsh->cbPreparedDstLength < padsh->cbDstLength) {
 466         WARN("invalid parameter\n");
 467         return MMSYSERR_INVALPARAM;
 468     }
 469
 470     padsh->fdwConvert = fdwUnprepare;
 471
 472     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_UNPREPARE, (DWORD)&was->drvInst, (DWORD)padsh);
 473     if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
 474         ret = MMSYSERR_NOERROR;
 475         padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE|ACMSTREAMHEADER_STATUSF_PREPARED);
 476     }
 477     TRACE("=> (%d)\n", ret);
 478     return ret;
 479 }