stream.c

Go to the documentation of this file.

/* -*- tab-width: 8; c-basic-offset: 4 -*- */
 
/*
 *      MSACM32 library
 *
 *      Copyright 1998  Patrik Stridvall
 *        1999  Eric Pouech
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
/* TODO
 *  + asynchronous conversion is not implemented
 *  + callback/notification
 *  * acmStreamMessage
 *  + properly close ACM streams
 */
 
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "wine/debug.h"
#include "mmsystem.h"
#define NOBITMAP
#include "mmreg.h"
#include "msacm.h"
#include "msacmdrv.h"
#include "wineacm.h"
 
WINE_DEFAULT_DEBUG_CHANNEL(msacm);
 
static PWINE_ACMSTREAM  ACM_GetStream(HACMSTREAM has)
{
    TRACE("(%p)\n", has);
 
    return (PWINE_ACMSTREAM)has;
}
 
static BOOL ACM_ValidatePointers(PACMDRVSTREAMHEADER padsh)
{
    /* check that pointers have not been modified */
    return !(padsh->pbPreparedSrc != padsh->pbSrc ||
             padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
             padsh->pbPreparedDst != padsh->pbDst ||
             padsh->cbPreparedDstLength < padsh->cbDstLength);
}
 
/***********************************************************************
 *           acmStreamClose (MSACM32.@)
 */
MMRESULT WINAPI acmStreamClose(HACMSTREAM has, DWORD fdwClose)
{
    PWINE_ACMSTREAM was;
    MMRESULT        ret;
 
    TRACE("(%p, %d)\n", has, fdwClose);
 
    if ((was = ACM_GetStream(has)) == NULL) {
        WARN("invalid handle\n");
    return MMSYSERR_INVALHANDLE;
    }
    ret = MSACM_Message((HACMDRIVER)was->pDrv, ACMDM_STREAM_CLOSE, (LPARAM)&was->drvInst, 0);
    if (ret == MMSYSERR_NOERROR) {
    if (was->hAcmDriver)
        acmDriverClose(was->hAcmDriver, 0L);
    HeapFree(MSACM_hHeap, 0, was);
    }
    TRACE("=> (%d)\n", ret);
    return ret;
}
 
/***********************************************************************
 *           acmStreamConvert (MSACM32.@)
 */
MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash,
                 DWORD fdwConvert)
{
    PWINE_ACMSTREAM was;
    MMRESULT        ret = MMSYSERR_NOERROR;
    PACMDRVSTREAMHEADER padsh;
 
    TRACE("(%p, %p, %d)\n", has, pash, fdwConvert);
 
    if ((was = ACM_GetStream(has)) == NULL) {
        WARN("invalid handle\n");
    return MMSYSERR_INVALHANDLE;
    }
    if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER)) {
        WARN("invalid parameter\n");
    return MMSYSERR_INVALPARAM;
    }
    if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED)) {
        WARN("unprepared header\n");
    return ACMERR_UNPREPARED;
    }
 
    pash->cbSrcLengthUsed = 0;
    pash->cbDstLengthUsed = 0;
 
    /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
     * size. some fields are private to msacm internals, and are exposed
     * in ACMSTREAMHEADER in the dwReservedDriver array
     */
    padsh = (PACMDRVSTREAMHEADER)pash;
 
    if (!ACM_ValidatePointers(padsh)) {
        WARN("invalid parameter\n");
        return MMSYSERR_INVALPARAM;
    }
 
    padsh->fdwConvert = fdwConvert;
 
    ret = MSACM_Message((HACMDRIVER)was->pDrv, ACMDM_STREAM_CONVERT, (LPARAM)&was->drvInst, (LPARAM)padsh);
    if (ret == MMSYSERR_NOERROR) {
    padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_DONE;
    }
    TRACE("=> (%d)\n", ret);
    return ret;
}
 
/***********************************************************************
 *           acmStreamMessage (MSACM32.@)
 */
MMRESULT WINAPI acmStreamMessage(HACMSTREAM has, UINT uMsg, LPARAM lParam1,
                 LPARAM lParam2)
{
    FIXME("(%p, %u, %ld, %ld): stub\n", has, uMsg, lParam1, lParam2);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return MMSYSERR_ERROR;
}
 
/***********************************************************************
 *           acmStreamOpen (MSACM32.@)
 */
MMRESULT WINAPI acmStreamOpen(PHACMSTREAM phas, HACMDRIVER had,
                              PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst,
                              PWAVEFILTER pwfltr, DWORD_PTR dwCallback,
                              DWORD_PTR dwInstance, DWORD fdwOpen)
{
    PWINE_ACMSTREAM was;
    PWINE_ACMDRIVER wad;
    MMRESULT        ret;
    int         wfxSrcSize;
    int         wfxDstSize;
    WAVEFORMATEX    wfxSrc, wfxDst;
 
    TRACE("(%p, %p, %p, %p, %p, %ld, %ld, %d)\n",
      phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
 
    /* NOTE: pwfxSrc and/or pwfxDst can point to a structure smaller than
     * WAVEFORMATEX so don't use them directly when not sure */
    if (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) {
        memcpy(&wfxSrc, pwfxSrc, sizeof(PCMWAVEFORMAT));
        wfxSrc.wBitsPerSample = pwfxSrc->wBitsPerSample;
        wfxSrc.cbSize = 0;
        pwfxSrc = &wfxSrc;
    }
 
    if (pwfxDst->wFormatTag == WAVE_FORMAT_PCM) {
        memcpy(&wfxDst, pwfxDst, sizeof(PCMWAVEFORMAT));
        wfxDst.wBitsPerSample = pwfxDst->wBitsPerSample;
        wfxDst.cbSize = 0;
        pwfxDst = &wfxDst;
    }
 
    TRACE("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%u, nAvgBytesPerSec=%u, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
      pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec,
      pwfxSrc->nBlockAlign, pwfxSrc->wBitsPerSample, pwfxSrc->cbSize);
 
    TRACE("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%u, nAvgBytesPerSec=%u, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
      pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec,
      pwfxDst->nBlockAlign, pwfxDst->wBitsPerSample, pwfxDst->cbSize);
 
    /* (WS) In query mode, phas should be NULL. If it is not, then instead
     * of returning an error we are making sure it is NULL, preventing some
     * applications that pass garbage for phas from crashing.
     */
    if (fdwOpen & ACM_STREAMOPENF_QUERY) phas = NULL;
 
    if (pwfltr && (pwfxSrc->wFormatTag != pwfxDst->wFormatTag)) {
        WARN("invalid parameter\n");
        return MMSYSERR_INVALPARAM;
    }
 
    wfxSrcSize = wfxDstSize = sizeof(WAVEFORMATEX);
    if (pwfxSrc->wFormatTag != WAVE_FORMAT_PCM) wfxSrcSize += pwfxSrc->cbSize;
    if (pwfxDst->wFormatTag != WAVE_FORMAT_PCM) wfxDstSize += pwfxDst->cbSize;
 
    was = HeapAlloc(MSACM_hHeap, 0, sizeof(*was) + wfxSrcSize + wfxDstSize +
            ((pwfltr) ? sizeof(WAVEFILTER) : 0));
    if (was == NULL) {
        WARN("no memory\n");
    return MMSYSERR_NOMEM;
    }
 
    was->drvInst.cbStruct = sizeof(was->drvInst);
    was->drvInst.pwfxSrc = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was));
    memcpy(was->drvInst.pwfxSrc, pwfxSrc, wfxSrcSize);
    was->drvInst.pwfxDst = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was) + wfxSrcSize);
    memcpy(was->drvInst.pwfxDst, pwfxDst, wfxDstSize);
    if (pwfltr) {
    was->drvInst.pwfltr = (PWAVEFILTER)((LPSTR)was + sizeof(*was) + wfxSrcSize + wfxDstSize);
    memcpy(was->drvInst.pwfltr, pwfltr, sizeof(WAVEFILTER));
    } else {
    was->drvInst.pwfltr = NULL;
    }
    was->drvInst.dwCallback = dwCallback;
    was->drvInst.dwInstance = dwInstance;
    was->drvInst.fdwOpen = fdwOpen;
    was->drvInst.fdwDriver = 0L;
    was->drvInst.dwDriver = 0L;
    /* real value will be stored once ACMDM_STREAM_OPEN succeeds */
    was->drvInst.has = 0L;
 
    if (had) {
    if (!(wad = MSACM_GetDriver(had))) {
        ret = MMSYSERR_INVALPARAM;
        goto errCleanUp;
    }
 
    was->obj.dwType = WINE_ACMOBJ_STREAM;
    was->obj.pACMDriverID = wad->obj.pACMDriverID;
    was->pDrv = wad;
    was->hAcmDriver = 0; /* not to close it in acmStreamClose */
 
    ret = MSACM_Message((HACMDRIVER)wad, ACMDM_STREAM_OPEN, (LPARAM)&was->drvInst, 0L);
    if (ret != MMSYSERR_NOERROR)
        goto errCleanUp;
    } else {
    PWINE_ACMDRIVERID wadi;
 
    ret = ACMERR_NOTPOSSIBLE;
    for (wadi = MSACM_pFirstACMDriverID; wadi; wadi = wadi->pNextACMDriverID) {
        if ((wadi->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ||
        !MSACM_FindFormatTagInCache(wadi, pwfxSrc->wFormatTag, NULL) ||
        !MSACM_FindFormatTagInCache(wadi, pwfxDst->wFormatTag, NULL))
        continue;
        ret = acmDriverOpen(&had, (HACMDRIVERID)wadi, 0L);
        if (ret != MMSYSERR_NOERROR)
        continue;
        if ((wad = MSACM_GetDriver(had)) != 0) {
        was->obj.dwType = WINE_ACMOBJ_STREAM;
        was->obj.pACMDriverID = wad->obj.pACMDriverID;
        was->pDrv = wad;
        was->hAcmDriver = had;
 
        ret = MSACM_Message((HACMDRIVER)wad, ACMDM_STREAM_OPEN, (LPARAM)&was->drvInst, 0L);
        TRACE("%s => %08x\n", debugstr_w(wadi->pszDriverAlias), ret);
        if (ret == MMSYSERR_NOERROR) {
            if (fdwOpen & ACM_STREAMOPENF_QUERY) {
            MSACM_Message((HACMDRIVER)wad, ACMDM_STREAM_CLOSE, (LPARAM)&was->drvInst, 0);
            acmDriverClose(had, 0L);
            }
            break;
        }
        }
        /* no match, close this acm driver and try next one */
        acmDriverClose(had, 0L);
    }
    if (ret != MMSYSERR_NOERROR) {
        ret = ACMERR_NOTPOSSIBLE;
        goto errCleanUp;
    }
    }
    ret = MMSYSERR_NOERROR;
    was->drvInst.has = (HACMSTREAM)was;
    if (!(fdwOpen & ACM_STREAMOPENF_QUERY)) {
    if (phas)
        *phas = (HACMSTREAM)was;
    TRACE("=> (%d)\n", ret);
    return ret;
    }
errCleanUp:
    if (phas)
    *phas = NULL;
    HeapFree(MSACM_hHeap, 0, was);
    TRACE("=> (%d)\n", ret);
    return ret;
}
 
 
/***********************************************************************
 *           acmStreamPrepareHeader (MSACM32.@)
 */
MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
                       DWORD fdwPrepare)
{
    PWINE_ACMSTREAM was;
    MMRESULT        ret = MMSYSERR_NOERROR;
    PACMDRVSTREAMHEADER padsh;
 
    TRACE("(%p, %p, %d)\n", has, pash, fdwPrepare);
 
    if ((was = ACM_GetStream(has)) == NULL) {
        WARN("invalid handle\n");
        return MMSYSERR_INVALHANDLE;
    }
    if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER)) {
        WARN("invalid parameter\n");
        return MMSYSERR_INVALPARAM;
    }
    if (fdwPrepare) {
        WARN("invalid use of reserved parameter\n");
        return MMSYSERR_INVALFLAG;
    }
    if ((was->drvInst.pwfxSrc->wFormatTag == WAVE_FORMAT_ADPCM ||
         was->drvInst.pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) &&
        pash->cbSrcLength < was->drvInst.pwfxSrc->nBlockAlign) {
        WARN("source smaller than block align (%d < %d)\n",
             pash->cbSrcLength, was->drvInst.pwfxSrc->nBlockAlign);
        return pash->cbSrcLength ? ACMERR_NOTPOSSIBLE : MMSYSERR_INVALPARAM;
    }
 
    /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
     * size. some fields are private to msacm internals, and are exposed
     * in ACMSTREAMHEADER in the dwReservedDriver array
     */
    padsh = (PACMDRVSTREAMHEADER)pash;
 
    padsh->fdwConvert = fdwPrepare;
    padsh->padshNext = NULL;
    padsh->fdwDriver = padsh->dwDriver = 0L;
 
    padsh->fdwPrepared = 0;
    padsh->dwPrepared = 0;
    padsh->pbPreparedSrc = 0;
    padsh->cbPreparedSrcLength = 0;
    padsh->pbPreparedDst = 0;
    padsh->cbPreparedDstLength = 0;
 
    ret = MSACM_Message((HACMDRIVER)was->pDrv, ACMDM_STREAM_PREPARE, (LPARAM)&was->drvInst, (LPARAM)padsh);
    if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
    ret = MMSYSERR_NOERROR;
    padsh->fdwStatus &= ~ACMSTREAMHEADER_STATUSF_INQUEUE;
    padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_PREPARED;
    padsh->fdwPrepared = padsh->fdwStatus;
    padsh->dwPrepared = 0;
    padsh->pbPreparedSrc = padsh->pbSrc;
    padsh->cbPreparedSrcLength = padsh->cbSrcLength;
    padsh->pbPreparedDst = padsh->pbDst;
    padsh->cbPreparedDstLength = padsh->cbDstLength;
    } else {
    padsh->fdwPrepared = 0;
    padsh->dwPrepared = 0;
    padsh->pbPreparedSrc = 0;
    padsh->cbPreparedSrcLength = 0;
    padsh->pbPreparedDst = 0;
    padsh->cbPreparedDstLength = 0;
    }
    TRACE("=> (%d)\n", ret);
    return ret;
}
 
/***********************************************************************
 *           acmStreamReset (MSACM32.@)
 */
MMRESULT WINAPI acmStreamReset(HACMSTREAM has, DWORD fdwReset)
{
    PWINE_ACMSTREAM was;
    MMRESULT        ret = MMSYSERR_NOERROR;
 
    TRACE("(%p, %d)\n", has, fdwReset);
 
    if (fdwReset) {
        WARN("invalid flag\n");
    ret = MMSYSERR_INVALFLAG;
    } else if ((was = ACM_GetStream(has)) == NULL) {
        WARN("invalid handle\n");
    return MMSYSERR_INVALHANDLE;
    } else if (was->drvInst.fdwOpen & ACM_STREAMOPENF_ASYNC) {
    ret = MSACM_Message((HACMDRIVER)was->pDrv, ACMDM_STREAM_RESET, (LPARAM)&was->drvInst, 0);
    }
    TRACE("=> (%d)\n", ret);
    return ret;
}
 
/***********************************************************************
 *           acmStreamSize (MSACM32.@)
 */
MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput,
                  LPDWORD pdwOutputBytes, DWORD fdwSize)
{
    PWINE_ACMSTREAM was;
    ACMDRVSTREAMSIZE    adss;
    MMRESULT        ret;
 
    TRACE("(%p, %d, %p, %d)\n", has, cbInput, pdwOutputBytes, fdwSize);
 
    if ((was = ACM_GetStream(has)) == NULL) {
        WARN("invalid handle\n");
    return MMSYSERR_INVALHANDLE;
    }
    if ((fdwSize & ~ACM_STREAMSIZEF_QUERYMASK) != 0) {
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    *pdwOutputBytes = 0L;
 
    switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
    case ACM_STREAMSIZEF_DESTINATION:
    adss.cbDstLength = cbInput;
    adss.cbSrcLength = 0;
    break;
    case ACM_STREAMSIZEF_SOURCE:
    adss.cbSrcLength = cbInput;
    adss.cbDstLength = 0;
    break;
    default:
        WARN("invalid flag\n");
    return MMSYSERR_INVALFLAG;
    }
 
    adss.cbStruct = sizeof(adss);
    adss.fdwSize = fdwSize;
    ret = MSACM_Message((HACMDRIVER)was->pDrv, ACMDM_STREAM_SIZE,
                            (LPARAM)&was->drvInst, (LPARAM)&adss);
    if (ret == MMSYSERR_NOERROR) {
    switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
    case ACM_STREAMSIZEF_DESTINATION:
        *pdwOutputBytes = adss.cbSrcLength;
        break;
    case ACM_STREAMSIZEF_SOURCE:
        *pdwOutputBytes = adss.cbDstLength;
        break;
    }
    }
    TRACE("=> (%d) [%u]\n", ret, *pdwOutputBytes);
    return ret;
}
 
/***********************************************************************
 *           acmStreamUnprepareHeader (MSACM32.@)
 */
MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
                     DWORD fdwUnprepare)
{
    PWINE_ACMSTREAM was;
    MMRESULT        ret = MMSYSERR_NOERROR;
    PACMDRVSTREAMHEADER padsh;
 
    TRACE("(%p, %p, %d)\n", has, pash, fdwUnprepare);
 
    if ((was = ACM_GetStream(has)) == NULL) {
        WARN("invalid handle\n");
    return MMSYSERR_INVALHANDLE;
    }
    if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER)) {
        WARN("invalid parameter\n");
    return MMSYSERR_INVALPARAM;
    }
    if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED)) {
        WARN("unprepared header\n");
    return ACMERR_UNPREPARED;
    }
 
    /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
     * size. some fields are private to msacm internals, and are exposed
     * in ACMSTREAMHEADER in the dwReservedDriver array
     */
    padsh = (PACMDRVSTREAMHEADER)pash;
 
    if (!ACM_ValidatePointers(padsh)) {
        WARN("invalid parameter\n");
        return MMSYSERR_INVALPARAM;
    }
 
    padsh->fdwConvert = fdwUnprepare;
 
    ret = MSACM_Message((HACMDRIVER)was->pDrv, ACMDM_STREAM_UNPREPARE, (LPARAM)&was->drvInst, (LPARAM)padsh);
    if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
    ret = MMSYSERR_NOERROR;
    padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_INQUEUE|ACMSTREAMHEADER_STATUSF_PREPARED);
    }
    TRACE("=> (%d)\n", ret);
    return ret;
}