stream.c File Reference

#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "wine/debug.h"
#include "mmsystem.h"
#include "mmreg.h"
#include "msacm.h"
#include "msacmdrv.h"
#include "wineacm.h"

Include dependency graph for stream.c:

Go to the source code of this file.

Macros
#define	NOBITMAP

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msacm)
static PWINE_ACMSTREAM	ACM_GetStream (HACMSTREAM has)
static BOOL	ACM_ValidatePointers (PACMDRVSTREAMHEADER padsh)
MMRESULT WINAPI	acmStreamClose (HACMSTREAM has, DWORD fdwClose)
MMRESULT WINAPI	acmStreamConvert (HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwConvert)
MMRESULT WINAPI	acmStreamMessage (HACMSTREAM has, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
MMRESULT WINAPI	acmStreamOpen (PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
MMRESULT WINAPI	acmStreamPrepareHeader (HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwPrepare)
MMRESULT WINAPI	acmStreamReset (HACMSTREAM has, DWORD fdwReset)
MMRESULT WINAPI	acmStreamSize (HACMSTREAM has, DWORD cbInput, LPDWORD pdwOutputBytes, DWORD fdwSize)
MMRESULT WINAPI	acmStreamUnprepareHeader (HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwUnprepare)

Macro Definition Documentation

NOBITMAP

#define NOBITMAP

Definition at line 38 of file stream.c.

Function Documentation

ACM_GetStream()

static PWINE_ACMSTREAM ACM_GetStream ( HACMSTREAM  has )

static

Definition at line 46 of file stream.c.

{
    TRACE("(%p)\n", has);
 
    return (PWINE_ACMSTREAM)has;
}

Referenced by acmStreamClose(), acmStreamConvert(), acmStreamPrepareHeader(), acmStreamReset(), acmStreamSize(), and acmStreamUnprepareHeader().

ACM_ValidatePointers()

static BOOL ACM_ValidatePointers ( PACMDRVSTREAMHEADER  padsh )

static

Definition at line 53 of file stream.c.

{
    /* check that pointers have not been modified */
    return !(padsh->pbPreparedSrc != padsh->pbSrc ||
             padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
             padsh->pbPreparedDst != padsh->pbDst ||
             padsh->cbPreparedDstLength < padsh->cbDstLength);
}

Referenced by acmStreamConvert(), and acmStreamUnprepareHeader().

acmStreamClose()

MMRESULT WINAPI acmStreamClose	(	HACMSTREAM	has,
		DWORD	fdwClose
	)

Definition at line 65 of file stream.c.

{
    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;
}

Referenced by ACMStream_fnRelease(), ACMWrapper_BreakConnect(), AVIFILE_SaveFile(), audio_resampler_acm::close(), test_convert(), test_mp3(), test_prepareheader(), widClose(), widOpenHelper(), wodClose(), and wodOpenHelper().

acmStreamConvert()

MMRESULT WINAPI acmStreamConvert	(	HACMSTREAM	has,
		PACMSTREAMHEADER	pash,
		DWORD	fdwConvert
	)

Definition at line 89 of file stream.c.

{
    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;
}

Referenced by ACMStream_fnRead(), ACMStream_fnWrite(), ACMWrapper_Receive(), audio_resampler_acm::audio_receive(), test_convert(), test_prepareheader(), widCallback(), and wodWrite().

acmStreamMessage()

MMRESULT WINAPI acmStreamMessage	(	HACMSTREAM	has,
		UINT	uMsg,
		LPARAM	lParam1,
		LPARAM	lParam2
	)

Definition at line 138 of file stream.c.

{
    FIXME("(%p, %u, %ld, %ld): stub\n", has, uMsg, lParam1, lParam2);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return MMSYSERR_ERROR;
}

acmStreamOpen()

MMRESULT WINAPI acmStreamOpen	(	PHACMSTREAM	phas,
		HACMDRIVER	had,
		PWAVEFORMATEX	pwfxSrc,
		PWAVEFORMATEX	pwfxDst,
		PWAVEFILTER	pwfltr,
		DWORD_PTR	dwCallback,
		DWORD_PTR	dwInstance,
		DWORD	fdwOpen
	)

Definition at line 149 of file stream.c.

{
    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;
}

Referenced by ACMWrapper_CompleteConnect(), ACMWrapper_SetMediaType(), AVIFILE_OpenCompressor(), AVIFILE_SaveFile(), audio_resampler_acm::open(), test_convert(), test_mp3(), test_prepareheader(), widOpenHelper(), and wodOpenHelper().

acmStreamPrepareHeader()

MMRESULT WINAPI acmStreamPrepareHeader	(	HACMSTREAM	has,
		PACMSTREAMHEADER	pash,
		DWORD	fdwPrepare
	)

Definition at line 299 of file stream.c.

{
    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;
}

Referenced by ACMStream_fnRead(), ACMStream_fnWrite(), ACMWrapper_Receive(), audio_resampler_acm::open(), test_convert(), test_prepareheader(), widPrepare(), and wodPrepare().

acmStreamReset()

MMRESULT WINAPI acmStreamReset	(	HACMSTREAM	has,
		DWORD	fdwReset
	)

Definition at line 371 of file stream.c.

{
    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()

MMRESULT WINAPI acmStreamSize	(	HACMSTREAM	has,
		DWORD	cbInput,
		LPDWORD	pdwOutputBytes,
		DWORD	fdwSize
	)

Definition at line 394 of file stream.c.

{
    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;
}

Referenced by AVIFILE_SaveFile(), audio_resampler_acm::open(), test_mp3(), widPrepare(), and wodPrepare().

acmStreamUnprepareHeader()

MMRESULT WINAPI acmStreamUnprepareHeader	(	HACMSTREAM	has,
		PACMSTREAMHEADER	pash,
		DWORD	fdwUnprepare
	)

Definition at line 449 of file stream.c.

{
    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;
}

Referenced by ACMStream_fnRelease(), ACMWrapper_Receive(), audio_resampler_acm::close(), test_convert(), test_prepareheader(), widUnprepare(), and wodUnprepare().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msacm

)