format.c File Reference

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

Include dependency graph for format.c:

Go to the source code of this file.

Classes
struct	MSACM_FillFormatData
struct	MSACM_FormatEnumWtoA_Instance
struct	MSACM_FormatTagEnumWtoA_Instance

Macros
#define	WINE_ACMFF_TAG   0
#define	WINE_ACMFF_FORMAT   1
#define	WINE_ACMFF_WFX   2

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msacm)
static BOOL CALLBACK	MSACM_FillFormatTagsCB (HACMDRIVERID hadid, PACMFORMATTAGDETAILSW paftd, DWORD_PTR dwInstance, DWORD fdwSupport)
static BOOL	MSACM_FillFormatTags (HWND hWnd, PACMFORMATCHOOSEW afc)
static BOOL	MSACM_FillFormat (HWND hWnd, PACMFORMATCHOOSEW afc)
static MMRESULT	MSACM_GetWFX (HWND hWnd, PACMFORMATCHOOSEW afc)
static INT_PTR CALLBACK	FormatChooseDlgProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
MMRESULT WINAPI	acmFormatChooseA (PACMFORMATCHOOSEA pafmtc)
MMRESULT WINAPI	acmFormatChooseW (PACMFORMATCHOOSEW pafmtc)
MMRESULT WINAPI	acmFormatDetailsA (HACMDRIVER had, PACMFORMATDETAILSA pafd, DWORD fdwDetails)
MMRESULT WINAPI	acmFormatDetailsW (HACMDRIVER had, PACMFORMATDETAILSW pafd, DWORD fdwDetails)
static BOOL CALLBACK	MSACM_FormatEnumCallbackWtoA (HACMDRIVERID hadid, PACMFORMATDETAILSW pafdw, DWORD_PTR dwInstance, DWORD fdwSupport)
MMRESULT WINAPI	acmFormatEnumA (HACMDRIVER had, PACMFORMATDETAILSA pafda, ACMFORMATENUMCBA fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum)
static BOOL	MSACM_FormatEnumHelper (PWINE_ACMDRIVERID padid, HACMDRIVER had, PACMFORMATDETAILSW pafd, PWAVEFORMATEX pwfxRef, ACMFORMATENUMCBW fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum)
MMRESULT WINAPI	acmFormatEnumW (HACMDRIVER had, PACMFORMATDETAILSW pafd, ACMFORMATENUMCBW fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum)
MMRESULT WINAPI	acmFormatSuggest (HACMDRIVER had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest)
MMRESULT WINAPI	acmFormatTagDetailsA (HACMDRIVER had, PACMFORMATTAGDETAILSA paftda, DWORD fdwDetails)
MMRESULT WINAPI	acmFormatTagDetailsW (HACMDRIVER had, PACMFORMATTAGDETAILSW paftd, DWORD fdwDetails)
static BOOL CALLBACK	MSACM_FormatTagEnumCallbackWtoA (HACMDRIVERID hadid, PACMFORMATTAGDETAILSW paftdw, DWORD_PTR dwInstance, DWORD fdwSupport)
MMRESULT WINAPI	acmFormatTagEnumA (HACMDRIVER had, PACMFORMATTAGDETAILSA paftda, ACMFORMATTAGENUMCBA fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum)
MMRESULT WINAPI	acmFormatTagEnumW (HACMDRIVER had, PACMFORMATTAGDETAILSW paftd, ACMFORMATTAGENUMCBW fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum)

Variables
static const WCHAR	fmt_prop [] = {'a','c','m','p','r','o','p','\0'}

Macro Definition Documentation

WINE_ACMFF_FORMAT

#define WINE_ACMFF_FORMAT   1

Definition at line 42 of file format.c.

WINE_ACMFF_TAG

#define WINE_ACMFF_TAG   0

Definition at line 41 of file format.c.

WINE_ACMFF_WFX

#define WINE_ACMFF_WFX   2

Definition at line 43 of file format.c.

Function Documentation

acmFormatChooseA()

MMRESULT WINAPI acmFormatChooseA

(

PACMFORMATCHOOSEA

pafmtc

)

Definition at line 297 of file format.c.

{
    ACMFORMATCHOOSEW    afcw;
    MMRESULT            ret;
    LPWSTR              title = NULL;
    LPWSTR              name = NULL;
    LPWSTR              templ = NULL;
    DWORD               sz;
 
    if (pafmtc->cbStruct < sizeof(ACMFORMATCHOOSEA))
        return MMSYSERR_INVALPARAM;
 
    afcw.cbStruct  = sizeof(afcw);
    afcw.fdwStyle  = pafmtc->fdwStyle;
    afcw.hwndOwner = pafmtc->hwndOwner;
    afcw.pwfx      = pafmtc->pwfx;
    afcw.cbwfx     = pafmtc->cbwfx;
    if (pafmtc->pszTitle)
    {
        sz = MultiByteToWideChar(CP_ACP, 0, pafmtc->pszTitle, -1, NULL, 0);
        if (!(title = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
        {
            ret = MMSYSERR_NOMEM;
            goto done;
        }
        MultiByteToWideChar(CP_ACP, 0, pafmtc->pszTitle, -1, title, sz);
    }
    afcw.pszTitle  = title;
    if (pafmtc->pszName)
    {
        sz = MultiByteToWideChar(CP_ACP, 0, pafmtc->pszName, -1, NULL, 0);
        if (!(name = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
        {
            ret = MMSYSERR_NOMEM;
            goto done;
        }
        MultiByteToWideChar(CP_ACP, 0, pafmtc->pszName, -1, name, sz);
    }
    afcw.pszName   = name;
    afcw.cchName   = pafmtc->cchName;
    afcw.fdwEnum   = pafmtc->fdwEnum;
    afcw.pwfxEnum  = pafmtc->pwfxEnum;
    afcw.hInstance = pafmtc->hInstance;
    if (pafmtc->pszTemplateName)
    {
        sz = MultiByteToWideChar(CP_ACP, 0, pafmtc->pszTemplateName, -1, NULL, 0);
        if (!(templ = HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR))))
        {
            ret = MMSYSERR_NOMEM;
            goto done;
        }
        MultiByteToWideChar(CP_ACP, 0, pafmtc->pszTemplateName, -1, templ, sz);
    }
    afcw.pszTemplateName = templ;
    /* FIXME: hook procs not supported yet */
    if (pafmtc->pfnHook)
    {
        FIXME("Unsupported hook procs\n");
        ret = MMSYSERR_NOTSUPPORTED;
        goto done;
    }
    ret = acmFormatChooseW(&afcw);
    if (ret == MMSYSERR_NOERROR)
    {
        WideCharToMultiByte(CP_ACP, 0, afcw.szFormatTag, -1, pafmtc->szFormatTag, sizeof(pafmtc->szFormatTag),
                            NULL, NULL);
        WideCharToMultiByte(CP_ACP, 0, afcw.szFormat, -1, pafmtc->szFormat, sizeof(pafmtc->szFormat),
                            NULL, NULL);
        if (pafmtc->pszName)
            WideCharToMultiByte(CP_ACP, 0, afcw.pszName, -1, pafmtc->pszName, pafmtc->cchName, NULL, NULL);
    }
done:
    HeapFree(GetProcessHeap(), 0, title);
    HeapFree(GetProcessHeap(), 0, name);
    HeapFree(GetProcessHeap(), 0, templ);
    return ret;
}

acmFormatChooseW()

MMRESULT WINAPI acmFormatChooseW

(

PACMFORMATCHOOSEW

pafmtc

)

Definition at line 378 of file format.c.

{
    if (pafmtc->cbStruct < sizeof(ACMFORMATCHOOSEW))
        return MMSYSERR_INVALPARAM;
 
    if (!pafmtc->pwfx)
        return MMSYSERR_INVALPARAM;
 
    if (pafmtc->fdwStyle & ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE)
        return DialogBoxIndirectParamW(MSACM_hInstance32, (LPCDLGTEMPLATEW)pafmtc->hInstance,
                                       pafmtc->hwndOwner, FormatChooseDlgProc, (LPARAM)pafmtc);
 
    if (pafmtc->fdwStyle & ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE)
        return DialogBoxParamW(pafmtc->hInstance, pafmtc->pszTemplateName,
                               pafmtc->hwndOwner, FormatChooseDlgProc, (LPARAM)pafmtc);
 
    return DialogBoxParamW(MSACM_hInstance32, MAKEINTRESOURCEW(DLG_ACMFORMATCHOOSE_ID),
                           pafmtc->hwndOwner, FormatChooseDlgProc, (LPARAM)pafmtc);
}

Referenced by acmFormatChooseA(), AVISaveOptionsFmtChoose(), and test_acmFormatChoose().

acmFormatDetailsA()

MMRESULT WINAPI acmFormatDetailsA	(	HACMDRIVER	had,
		PACMFORMATDETAILSA	pafd,
		DWORD	fdwDetails
	)

Definition at line 401 of file format.c.

{
    ACMFORMATDETAILSW   afdw;
    MMRESULT        mmr;
 
    if (!pafd)
        return MMSYSERR_INVALPARAM;
 
    memset(&afdw, 0, sizeof(afdw));
    afdw.cbStruct = sizeof(afdw);
    afdw.dwFormatIndex = pafd->dwFormatIndex;
    afdw.dwFormatTag = pafd->dwFormatTag;
    afdw.fdwSupport = pafd->fdwSupport;
    afdw.pwfx = pafd->pwfx;
    afdw.cbwfx = pafd->cbwfx;
 
    mmr = acmFormatDetailsW(had, &afdw, fdwDetails);
    if (mmr == MMSYSERR_NOERROR) {
    pafd->dwFormatTag = afdw.dwFormatTag;
    pafd->fdwSupport = afdw.fdwSupport;
        WideCharToMultiByte( CP_ACP, 0, afdw.szFormat, -1,
                             pafd->szFormat, sizeof(pafd->szFormat), NULL, NULL );
    }
    return mmr;
}

Referenced by DriverEnumProc(), and FormatTagEnumProc().

acmFormatDetailsW()

MMRESULT WINAPI acmFormatDetailsW	(	HACMDRIVER	had,
		PACMFORMATDETAILSW	pafd,
		DWORD	fdwDetails
	)

Definition at line 431 of file format.c.

{
    MMRESULT            mmr;
    static const WCHAR      fmt1[] = {'%','d',' ','H','z',0};
    static const WCHAR      fmt2[] = {';',' ','%','d',' ','b','i','t','s',0};
    ACMFORMATTAGDETAILSW    aftd = {0};
 
    TRACE("(%p, %p, %d)\n", had, pafd, fdwDetails);
 
    if (!pafd)
        return MMSYSERR_INVALPARAM;
 
    if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
 
    if (!pafd->pwfx)
        return MMSYSERR_INVALPARAM;
 
    if (pafd->cbwfx < sizeof(PCMWAVEFORMAT))
        return MMSYSERR_INVALPARAM;
 
    if (pafd->fdwSupport)
        return MMSYSERR_INVALPARAM;
 
    if (pafd->dwFormatTag == WAVE_FORMAT_UNKNOWN)
        return MMSYSERR_INVALPARAM;
 
    switch (fdwDetails) {
    case ACM_FORMATDETAILSF_FORMAT:
    if (pafd->dwFormatTag != pafd->pwfx->wFormatTag) {
        mmr = MMSYSERR_INVALPARAM;
        break;
    }
    if (had == NULL) {
        PWINE_ACMDRIVERID       padid;
 
        mmr = ACMERR_NOTPOSSIBLE;
        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
        /* should check for codec only */
        if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
            mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS, (LPARAM)pafd, fdwDetails);
            acmDriverClose(had, 0);
            if (mmr == MMSYSERR_NOERROR) break;
        }
        }
    } else {
        mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS, (LPARAM)pafd, fdwDetails);
    }
    break;
    case ACM_FORMATDETAILSF_INDEX:
        aftd.cbStruct = sizeof(aftd);
        aftd.dwFormatTag = pafd->dwFormatTag;
        mmr = acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_FORMATTAG);
        if (mmr != MMSYSERR_NOERROR)
            break;
        if (pafd->dwFormatIndex >= aftd.cStandardFormats)
        {
            mmr = MMSYSERR_INVALPARAM;
            break;
        }
    mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS, (LPARAM)pafd, fdwDetails);
    break;
    default:
    WARN("Unknown fdwDetails %08x\n", fdwDetails);
    mmr = MMSYSERR_INVALFLAG;
    break;
    }
 
    if (mmr == MMSYSERR_NOERROR && pafd->szFormat[0] == 0) {
    wsprintfW(pafd->szFormat, fmt1, pafd->pwfx->nSamplesPerSec);
    if (pafd->pwfx->wBitsPerSample) {
        wsprintfW(pafd->szFormat + lstrlenW(pafd->szFormat), fmt2,
              pafd->pwfx->wBitsPerSample);
    }
        MultiByteToWideChar(CP_ACP, 0, (pafd->pwfx->nChannels == 1) ? "; Mono" : "; Stereo", -1,
                            pafd->szFormat + lstrlenW(pafd->szFormat),
                            ARRAY_SIZE(pafd->szFormat) - lstrlenW(pafd->szFormat));
    }
 
    TRACE("=> %d\n", mmr);
    return mmr;
}

Referenced by acmFormatDetailsA(), acmFormatSuggest(), AVISaveOptionsUpdate(), MSACM_FillFormatTagsCB(), and MSACM_FormatEnumHelper().

acmFormatEnumA()

MMRESULT WINAPI acmFormatEnumA	(	HACMDRIVER	had,
		PACMFORMATDETAILSA	pafda,
		ACMFORMATENUMCBA	fnCallback,
		DWORD_PTR	dwInstance,
		DWORD	fdwEnum
	)

Definition at line 542 of file format.c.

{
    ACMFORMATDETAILSW       afdw;
    struct MSACM_FormatEnumWtoA_Instance afei;
 
    if (!pafda)
        return MMSYSERR_INVALPARAM;
 
    if (!fnCallback)
        return MMSYSERR_INVALPARAM;
 
    if (pafda->cbStruct < sizeof(*pafda))
        return MMSYSERR_INVALPARAM;
 
    memset(&afdw, 0, sizeof(afdw));
    afdw.cbStruct = sizeof(afdw);
    afdw.dwFormatIndex = pafda->dwFormatIndex;
    afdw.dwFormatTag = pafda->dwFormatTag;
    afdw.fdwSupport = pafda->fdwSupport;
    afdw.pwfx = pafda->pwfx;
    afdw.cbwfx = pafda->cbwfx;
 
    afei.pafda = pafda;
    afei.dwInstance = dwInstance;
    afei.fnCallback = fnCallback;
 
    return acmFormatEnumW(had, &afdw, MSACM_FormatEnumCallbackWtoA,
                          (DWORD_PTR)&afei, fdwEnum);
}

Referenced by DriverEnumProc().

acmFormatEnumW()

MMRESULT WINAPI acmFormatEnumW	(	HACMDRIVER	had,
		PACMFORMATDETAILSW	pafd,
		ACMFORMATENUMCBW	fnCallback,
		DWORD_PTR	dwInstance,
		DWORD	fdwEnum
	)

Definition at line 671 of file format.c.

{
    PWINE_ACMDRIVERID       padid;
    WAVEFORMATEX        wfxRef;
    BOOL            ret;
    DWORD           cbwfxMax;
    MMRESULT            mmr;
 
    TRACE("(%p, %p, %p, %ld, %d)\n",
      had, pafd, fnCallback, dwInstance, fdwEnum);
 
    if (!pafd)
        return MMSYSERR_INVALPARAM;
 
    if (!fnCallback)
        return MMSYSERR_INVALPARAM;
 
    if (pafd->cbStruct < sizeof(*pafd))
        return MMSYSERR_INVALPARAM;
 
    if (pafd->fdwSupport)
        return MMSYSERR_INVALPARAM;
 
    if (!pafd->pwfx)
        return MMSYSERR_INVALPARAM;
 
    if (fdwEnum & (ACM_FORMATENUMF_WFORMATTAG|ACM_FORMATENUMF_NCHANNELS|
           ACM_FORMATENUMF_NSAMPLESPERSEC|ACM_FORMATENUMF_WBITSPERSAMPLE|
           ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_SUGGEST))
        wfxRef = *pafd->pwfx;
 
    if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
    !(fdwEnum & (ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT)))
    return MMSYSERR_INVALPARAM;
 
    if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) &&
    (pafd->dwFormatTag != pafd->pwfx->wFormatTag))
    return MMSYSERR_INVALPARAM;
 
    if (fdwEnum & (ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT))
    FIXME("Unsupported fdwEnum values %08x\n", fdwEnum);
 
    mmr = acmMetrics((HACMOBJ)had, ACM_METRIC_MAX_SIZE_FORMAT, &cbwfxMax);
    if (mmr != MMSYSERR_NOERROR)
        return mmr;
    if (pafd->cbwfx < cbwfxMax)
        return MMSYSERR_INVALPARAM;
 
    if (had) {
    HACMDRIVERID    hadid;
 
    if (acmDriverID((HACMOBJ)had, &hadid, 0) != MMSYSERR_NOERROR)
        return MMSYSERR_INVALHANDLE;
    MSACM_FormatEnumHelper(MSACM_GetDriverID(hadid), had, pafd, &wfxRef,
                   fnCallback, dwInstance, fdwEnum);
    return MMSYSERR_NOERROR;
    }
    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
        /* should check for codec only */
        if ((padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ||
        acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
        continue;
        ret = MSACM_FormatEnumHelper(padid, had, pafd, &wfxRef,
                     fnCallback, dwInstance, fdwEnum);
        acmDriverClose(had, 0);
        if (!ret) break;
    }
    return MMSYSERR_NOERROR;
}

Referenced by acmFormatEnumA().

acmFormatSuggest()

MMRESULT WINAPI acmFormatSuggest	(	HACMDRIVER	had,
		PWAVEFORMATEX	pwfxSrc,
		PWAVEFORMATEX	pwfxDst,
		DWORD	cbwfxDst,
		DWORD	fdwSuggest
	)

Definition at line 746 of file format.c.

{
    ACMFORMATTAGDETAILSW aftd = {0};
    ACMDRVFORMATSUGGEST adfg;
    MMRESULT        mmr;
 
    TRACE("(%p, %p, %p, %d, %d)\n",
      had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest);
 
    if (!pwfxSrc || !pwfxDst)
        return MMSYSERR_INVALPARAM;
 
    if (fdwSuggest & ~(ACM_FORMATSUGGESTF_NCHANNELS|ACM_FORMATSUGGESTF_NSAMPLESPERSEC|
               ACM_FORMATSUGGESTF_WBITSPERSAMPLE|ACM_FORMATSUGGESTF_WFORMATTAG))
    return MMSYSERR_INVALFLAG;
 
    /* if we were given PCM, try to convert to PCM */
    if (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM && !had &&
        !(fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG))
    {
        ACMFORMATDETAILSW afd = {0};
        afd.cbStruct = sizeof(afd);
        afd.dwFormatTag = WAVE_FORMAT_PCM;
        afd.pwfx = pwfxSrc;
        afd.cbwfx = sizeof(PCMWAVEFORMAT);
        if (!acmFormatDetailsW(had, &afd, ACM_FORMATDETAILSF_FORMAT))
        {
            memcpy(pwfxDst, pwfxSrc, sizeof(PCMWAVEFORMAT));
            return MMSYSERR_NOERROR;
        }
    }
 
    aftd.cbStruct = sizeof(aftd);
    if (fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG)
        aftd.dwFormatTag = pwfxDst->wFormatTag;
    mmr = acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
    if ((fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG) && mmr == ACMERR_NOTPOSSIBLE)
        return ACMERR_NOTPOSSIBLE;
 
    if (cbwfxDst < aftd.cbFormatSize)
        return MMSYSERR_INVALPARAM;
 
    adfg.cbStruct = sizeof(adfg);
    adfg.fdwSuggest = fdwSuggest;
    adfg.pwfxSrc = pwfxSrc;
    adfg.cbwfxSrc = (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) ?
    sizeof(WAVEFORMATEX) : (sizeof(WAVEFORMATEX) + pwfxSrc->cbSize);
    adfg.pwfxDst = pwfxDst;
    adfg.cbwfxDst = cbwfxDst;
 
    if (had == NULL) {
    PWINE_ACMDRIVERID   padid;
 
    /* MS doc says: ACM finds the best suggestion.
     * Well, first found will be the "best"
     */
    mmr = ACMERR_NOTPOSSIBLE;
    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
        /* should check for codec only */
        if ((padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ||
        acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
        continue;
 
        if (MSACM_Message(had, ACMDM_FORMAT_SUGGEST, (LPARAM)&adfg, 0L) == MMSYSERR_NOERROR) {
        mmr = MMSYSERR_NOERROR;
        break;
        }
        acmDriverClose(had, 0);
    }
    } else {
    mmr = MSACM_Message(had, ACMDM_FORMAT_SUGGEST, (LPARAM)&adfg, 0L);
    }
    return mmr;
}

Referenced by AVIFILE_OpenCompressor(), AVIFILE_SaveFile(), FormatEnumProc(), FormatTagEnumProc(), and test_acmFormatSuggest().

acmFormatTagDetailsA()

MMRESULT WINAPI acmFormatTagDetailsA	(	HACMDRIVER	had,
		PACMFORMATTAGDETAILSA	paftda,
		DWORD	fdwDetails
	)

Definition at line 825 of file format.c.

{
    ACMFORMATTAGDETAILSW    aftdw;
    MMRESULT            mmr;
 
    memset(&aftdw, 0, sizeof(aftdw));
    aftdw.cbStruct = sizeof(aftdw);
    aftdw.dwFormatTagIndex = paftda->dwFormatTagIndex;
    aftdw.dwFormatTag = paftda->dwFormatTag;
 
    mmr = acmFormatTagDetailsW(had, &aftdw, fdwDetails);
    if (mmr == MMSYSERR_NOERROR) {
    paftda->dwFormatTag = aftdw.dwFormatTag;
    paftda->dwFormatTagIndex = aftdw.dwFormatTagIndex;
    paftda->cbFormatSize = aftdw.cbFormatSize;
    paftda->fdwSupport = aftdw.fdwSupport;
    paftda->cStandardFormats = aftdw.cStandardFormats;
        WideCharToMultiByte( CP_ACP, 0, aftdw.szFormatTag, -1, paftda->szFormatTag,
                             sizeof(paftda->szFormatTag), NULL, NULL );
    }
    return mmr;
}

Referenced by FormatTagEnumProc().

acmFormatTagDetailsW()

MMRESULT WINAPI acmFormatTagDetailsW	(	HACMDRIVER	had,
		PACMFORMATTAGDETAILSW	paftd,
		DWORD	fdwDetails
	)

Definition at line 852 of file format.c.

{
    PWINE_ACMDRIVERID   padid;
    MMRESULT        mmr = ACMERR_NOTPOSSIBLE;
 
    TRACE("(%p, %p, %d)\n", had, paftd, fdwDetails);
 
    if (fdwDetails & ~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_INDEX|
               ACM_FORMATTAGDETAILSF_LARGESTSIZE))
    return MMSYSERR_INVALFLAG;
 
    switch (fdwDetails) {
    case ACM_FORMATTAGDETAILSF_FORMATTAG:
    if (had == NULL) {
        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
        /* should check for codec only */
        if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
            MSACM_FindFormatTagInCache(padid, paftd->dwFormatTag, NULL) &&
            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
            mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
            acmDriverClose(had, 0);
            if (mmr == MMSYSERR_NOERROR) break;
        }
        }
    } else {
        PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
 
        if (pad && MSACM_FindFormatTagInCache(pad->obj.pACMDriverID, paftd->dwFormatTag, NULL))
        mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
    }
    break;
 
    case ACM_FORMATTAGDETAILSF_INDEX:
    if (had != NULL) {
        PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
 
        if (pad && paftd->dwFormatTagIndex < pad->obj.pACMDriverID->cFormatTags)
        mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
    }
    break;
 
    case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
    if (had == NULL) {
        ACMFORMATTAGDETAILSW    tmp;
        DWORD           ft = paftd->dwFormatTag;
 
        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
        /* should check for codec only */
        if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
 
            memset(&tmp, 0, sizeof(tmp));
            tmp.cbStruct = sizeof(tmp);
            tmp.dwFormatTag = ft;
 
            if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
                      (LPARAM)&tmp, fdwDetails) == MMSYSERR_NOERROR) {
            if (mmr == ACMERR_NOTPOSSIBLE ||
                paftd->cbFormatSize < tmp.cbFormatSize) {
                *paftd = tmp;
                mmr = MMSYSERR_NOERROR;
            }
            }
            acmDriverClose(had, 0);
        }
        }
    } else {
        mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS, (LPARAM)paftd, fdwDetails);
    }
    break;
 
    default:
    WARN("Unsupported fdwDetails=%08x\n", fdwDetails);
    mmr = MMSYSERR_ERROR;
    }
 
    if (mmr == MMSYSERR_NOERROR &&
    paftd->dwFormatTag == WAVE_FORMAT_PCM && paftd->szFormatTag[0] == 0)
        MultiByteToWideChar(CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
                            ARRAY_SIZE(paftd->szFormatTag));
 
    return mmr;
}

Referenced by acmFormatDetailsW(), acmFormatSuggest(), acmFormatTagDetailsA(), AVISaveOptionsUpdate(), MSACM_FormatEnumHelper(), and test_acmFormatTagDetails().

acmFormatTagEnumA()

MMRESULT WINAPI acmFormatTagEnumA	(	HACMDRIVER	had,
		PACMFORMATTAGDETAILSA	paftda,
		ACMFORMATTAGENUMCBA	fnCallback,
		DWORD_PTR	dwInstance,
		DWORD	fdwEnum
	)

Definition at line 967 of file format.c.

{
    ACMFORMATTAGDETAILSW    aftdw;
    struct MSACM_FormatTagEnumWtoA_Instance aftei;
 
    if (!paftda)
        return MMSYSERR_INVALPARAM;
 
    if (paftda->cbStruct < sizeof(*paftda))
        return MMSYSERR_INVALPARAM;
 
    if (fdwEnum != 0)
        return MMSYSERR_INVALFLAG;
 
    memset(&aftdw, 0, sizeof(aftdw));
    aftdw.cbStruct = sizeof(aftdw);
    aftdw.dwFormatTagIndex = paftda->dwFormatTagIndex;
    aftdw.dwFormatTag = paftda->dwFormatTag;
 
    aftei.paftda = paftda;
    aftei.dwInstance = dwInstance;
    aftei.fnCallback = fnCallback;
 
    return acmFormatTagEnumW(had, &aftdw, MSACM_FormatTagEnumCallbackWtoA,
                             (DWORD_PTR)&aftei, fdwEnum);
}

Referenced by DriverEnumProc().

acmFormatTagEnumW()

MMRESULT WINAPI acmFormatTagEnumW	(	HACMDRIVER	had,
		PACMFORMATTAGDETAILSW	paftd,
		ACMFORMATTAGENUMCBW	fnCallback,
		DWORD_PTR	dwInstance,
		DWORD	fdwEnum
	)

Definition at line 999 of file format.c.

{
    PWINE_ACMDRIVERID   padid;
    unsigned int        i;
    BOOL                bPcmDone = FALSE;
 
    TRACE("(%p, %p, %p, %ld, %d)\n",
          had, paftd, fnCallback, dwInstance, fdwEnum);
 
    if (!paftd)
        return MMSYSERR_INVALPARAM;
 
    if (paftd->cbStruct < sizeof(*paftd))
        return MMSYSERR_INVALPARAM;
 
    if (fdwEnum != 0)
        return MMSYSERR_INVALFLAG;
 
    /* (WS) MSDN info page says that if had != 0, then we should find
     * the specific driver to get its tags from. Therefore I'm removing
     * the FIXME call and adding a search block below. It also seems
     * that the lack of this functionality was the responsible for 
     * codecs to be multiply and incorrectly listed. 
     */
 
    /* if (had) FIXME("had != NULL, not supported\n"); */
 
    if (had) {
        if (acmDriverID((HACMOBJ)had, (HACMDRIVERID *)&padid, 0) != MMSYSERR_NOERROR)
        return MMSYSERR_INVALHANDLE;
 
        for (i = 0; i < padid->cFormatTags; i++) {
            paftd->dwFormatTagIndex = i;
            if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
                (LPARAM)paftd, ACM_FORMATTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
                if (paftd->dwFormatTag == WAVE_FORMAT_PCM) {
                    if (paftd->szFormatTag[0] == 0)
                        MultiByteToWideChar(CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
                                            ARRAY_SIZE(paftd->szFormatTag));
                    /* (WS) I'm preserving this PCM hack since it seems to be
                     * correct. Please notice this block was borrowed from
                     * below.
                     */
                    if (bPcmDone) continue;
                    bPcmDone = TRUE;
                }
                if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance, padid->fdwSupport))
                    return MMSYSERR_NOERROR;
            }
        }
    }
    /* if had==0 then search for the first suitable driver */
    else {
        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
            /* should check for codec only */
            if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
                acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
                for (i = 0; i < padid->cFormatTags; i++) {
                    paftd->dwFormatTagIndex = i;
                    if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
                        (LPARAM)paftd, ACM_FORMATTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
                        if (paftd->dwFormatTag == WAVE_FORMAT_PCM) {
                            if (paftd->szFormatTag[0] == 0)
                                MultiByteToWideChar(CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
                                                    ARRAY_SIZE(paftd->szFormatTag));
                            /* FIXME (EPP): I'm not sure this is the correct
                             * algorithm (should make more sense to apply the same
                             * for all already loaded formats, but this will do
                             * for now
                             */
                            if (bPcmDone) continue;
                            bPcmDone = TRUE;
                        }
                        if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance, padid->fdwSupport)) {
                            acmDriverClose(had, 0);
                            return MMSYSERR_NOERROR;
                        }
                    }
                }
                acmDriverClose(had, 0);
            }
        }
    }
    return MMSYSERR_NOERROR;
}

Referenced by acmFormatTagEnumA(), MSACM_FillFormat(), MSACM_FillFormatTags(), and MSACM_GetWFX().

FormatChooseDlgProc()

static INT_PTR CALLBACK FormatChooseDlgProc ( HWND  hWnd, UINT  msg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 218 of file format.c.

{
    PACMFORMATCHOOSEW   afc = (PACMFORMATCHOOSEW)GetPropW(hWnd, fmt_prop);
 
    TRACE("hwnd=%p msg=%i 0x%08lx 0x%08lx\n", hWnd, msg, wParam, lParam);
 
    switch (msg) {
    case WM_INITDIALOG:
    afc = (PACMFORMATCHOOSEW)lParam;
    SetPropW(hWnd, fmt_prop, (HANDLE)afc);
    MSACM_FillFormatTags(hWnd, afc);
    MSACM_FillFormat(hWnd, afc);
    if ((afc->fdwStyle & ~(ACMFORMATCHOOSE_STYLEF_CONTEXTHELP|
                   ACMFORMATCHOOSE_STYLEF_SHOWHELP|
                               ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT|
                               ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE|
                               ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE)) != 0)
            FIXME("Unsupported style %08x\n", afc->fdwStyle);
    if (!(afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP))
        ShowWindow(GetDlgItem(hWnd, IDD_ACMFORMATCHOOSE_BTN_HELP), SW_HIDE);
    return TRUE;
 
    case WM_COMMAND:
    switch (LOWORD(wParam)) {
    case IDOK:
        EndDialog(hWnd, MSACM_GetWFX(hWnd, afc));
        return TRUE;
    case IDCANCEL:
        EndDialog(hWnd, ACMERR_CANCELED);
        return TRUE;
    case IDD_ACMFORMATCHOOSE_CMB_FORMATTAG:
        switch (HIWORD(wParam)) {
        case CBN_SELCHANGE:
        MSACM_FillFormat(hWnd, afc);
        break;
        default:
        TRACE("Dropped dlgNotif (fmtTag): 0x%08x 0x%08lx\n",
              HIWORD(wParam), lParam);
        break;
        }
        break;
    case IDD_ACMFORMATCHOOSE_BTN_HELP:
        if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP)
        SendMessageW(afc->hwndOwner,
                 RegisterWindowMessageW(ACMHELPMSGSTRINGW), 0L, 0L);
        break;
 
    default:
        TRACE("Dropped dlgCmd: ctl=%d ntf=0x%04x 0x%08lx\n",
          LOWORD(wParam), HIWORD(wParam), lParam);
        break;
    }
    break;
    case WM_CONTEXTMENU:
    if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
        SendMessageW(afc->hwndOwner,
             RegisterWindowMessageW(ACMHELPMSGCONTEXTMENUW),
             wParam, lParam);
    break;
#if defined(WM_CONTEXTHELP)
    case WM_CONTEXTHELP:
    if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
        SendMessageW(afc->hwndOwner,
             RegisterWindowMessageW(ACMHELPMSGCONTEXTHELPW),
             wParam, lParam);
    break;
#endif
    default:
    TRACE("Dropped dlgMsg: hwnd=%p msg=%i 0x%08lx 0x%08lx\n",
          hWnd,  msg, wParam, lParam );
    break;
    }
    return FALSE;
}

Referenced by acmFormatChooseW().

MSACM_FillFormat()

static BOOL MSACM_FillFormat ( HWND  hWnd, PACMFORMATCHOOSEW  afc  )

static

Definition at line 169 of file format.c.

{
    ACMFORMATTAGDETAILSW    aftd;
    struct MSACM_FillFormatData affd;
 
    SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_RESETCONTENT, 0, 0);
 
    memset(&aftd, 0, sizeof(aftd));
    aftd.cbStruct = sizeof(aftd);
 
    affd.hWnd = hWnd;
    affd.mode = WINE_ACMFF_FORMAT;
    affd.afc = afc;
    SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
            CB_GETLBTEXT,
            SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
                        CB_GETCURSEL, 0, 0),
                        (LPARAM)affd.szFormatTag);
 
    acmFormatTagEnumW(NULL, &aftd, MSACM_FillFormatTagsCB, (DWORD_PTR)&affd, 0);
    if (SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_GETCURSEL, 0, 0) == CB_ERR)
        SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_SETCURSEL, 0, 0);
    return TRUE;
}

Referenced by FormatChooseDlgProc().

MSACM_FillFormatTags()

static BOOL MSACM_FillFormatTags ( HWND  hWnd, PACMFORMATCHOOSEW  afc  )

static

Definition at line 151 of file format.c.

{
    ACMFORMATTAGDETAILSW    aftd;
    struct MSACM_FillFormatData affd;
 
    memset(&aftd, 0, sizeof(aftd));
    aftd.cbStruct = sizeof(aftd);
 
    affd.hWnd = hWnd;
    affd.mode = WINE_ACMFF_TAG;
    affd.afc = afc;
 
    acmFormatTagEnumW(NULL, &aftd, MSACM_FillFormatTagsCB, (DWORD_PTR)&affd, 0);
    if (SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, CB_GETCURSEL, 0, 0) == CB_ERR)
        SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, CB_SETCURSEL, 0, 0);
    return TRUE;
}

Referenced by FormatChooseDlgProc().

MSACM_FillFormatTagsCB()

static BOOL CALLBACK MSACM_FillFormatTagsCB ( HACMDRIVERID  hadid, PACMFORMATTAGDETAILSW  paftd, DWORD_PTR  dwInstance, DWORD  fdwSupport  )

static

Definition at line 50 of file format.c.

{
    struct MSACM_FillFormatData*    affd = (struct MSACM_FillFormatData*)dwInstance;
 
    switch (affd->mode) {
    case WINE_ACMFF_TAG:
        if (paftd->cStandardFormats > 0)
        {
            if (SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
                                    CB_FINDSTRINGEXACT, -1,
                                    (LPARAM)paftd->szFormatTag) == CB_ERR)
            {
                int index = SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
                                    CB_ADDSTRING, 0, (LPARAM)paftd->szFormatTag);
                if (((affd->afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT) &&
             (paftd->dwFormatTag == affd->afc->pwfx->wFormatTag)) ||
            (!(affd->afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT) &&
             (paftd->dwFormatTag == WAVE_FORMAT_PCM)))
                    SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
                                        CB_SETCURSEL, index, 0);
            }
        }
    break;
    case WINE_ACMFF_FORMAT:
    if (lstrcmpW(affd->szFormatTag, paftd->szFormatTag) == 0) {
        HACMDRIVER      had;
 
        if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
        ACMFORMATDETAILSW   afd = {0};
                unsigned int            i, len;
        MMRESULT        mmr;
        WCHAR           buffer[ACMFORMATDETAILS_FORMAT_CHARS+16];
 
        afd.cbStruct = sizeof(afd);
        afd.dwFormatTag = paftd->dwFormatTag;
        afd.pwfx = HeapAlloc(MSACM_hHeap, 0, paftd->cbFormatSize);
        if (!afd.pwfx) return FALSE;
        afd.pwfx->wFormatTag = paftd->dwFormatTag;
        if (paftd->dwFormatTag != WAVE_FORMAT_PCM)
            afd.pwfx->cbSize = paftd->cbFormatSize - sizeof(WAVEFORMATEX);
        afd.cbwfx = paftd->cbFormatSize;
 
        for (i = 0; i < paftd->cStandardFormats; i++) {
                    static const WCHAR fmtW[] = {'%','d',' ','K','o','/','s','\0'};
                    int j, index;
 
            afd.dwFormatIndex = i;
            afd.fdwSupport = 0;
            mmr = acmFormatDetailsW(had, &afd, ACM_FORMATDETAILSF_INDEX);
            if (mmr == MMSYSERR_NOERROR) {
                       lstrcpynW(buffer, afd.szFormat, ACMFORMATTAGDETAILS_FORMATTAG_CHARS + 1);
                       len = lstrlenW(buffer);
                       for (j = len; j < ACMFORMATTAGDETAILS_FORMATTAG_CHARS; j++)
                           buffer[j] = ' ';
                       wsprintfW(buffer + ACMFORMATTAGDETAILS_FORMATTAG_CHARS,
                                 fmtW, (afd.pwfx->nAvgBytesPerSec + 512) / 1024);
                       index = SendDlgItemMessageW(affd->hWnd,
                                           IDD_ACMFORMATCHOOSE_CMB_FORMAT,
                                           CB_ADDSTRING, 0, (LPARAM)buffer);
                       if ((affd->afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT) &&
                           affd->afc->cbwfx >= paftd->cbFormatSize &&
                           !memcmp(afd.pwfx, affd->afc->pwfx, paftd->cbFormatSize))
                           SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT,
                                               CB_SETCURSEL, index, 0);
            }
        }
        acmDriverClose(had, 0);
        HeapFree(MSACM_hHeap, 0, afd.pwfx);
        }
    }
    break;
    case WINE_ACMFF_WFX:
    if (lstrcmpW(affd->szFormatTag, paftd->szFormatTag) == 0) {
        HACMDRIVER      had;
 
        if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
        ACMFORMATDETAILSW   afd = {0};
 
        afd.cbStruct = sizeof(afd);
        afd.dwFormatTag = paftd->dwFormatTag;
        afd.pwfx = affd->afc->pwfx;
        afd.cbwfx = affd->afc->cbwfx;
 
        afd.dwFormatIndex = SendDlgItemMessageW(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT,
                            CB_GETCURSEL, 0, 0);
        affd->ret = acmFormatDetailsW(had, &afd, ACM_FORMATDETAILSF_INDEX);
        acmDriverClose(had, 0);
        return TRUE;
        }
    }
    break;
    default:
    FIXME("Unknown mode (%d)\n", affd->mode);
    break;
    }
    return TRUE;
}

Referenced by MSACM_FillFormat(), MSACM_FillFormatTags(), and MSACM_GetWFX().

MSACM_FormatEnumCallbackWtoA()

static BOOL CALLBACK MSACM_FormatEnumCallbackWtoA ( HACMDRIVERID  hadid, PACMFORMATDETAILSW  pafdw, DWORD_PTR  dwInstance, DWORD  fdwSupport  )

static

Definition at line 520 of file format.c.

{
    struct MSACM_FormatEnumWtoA_Instance* pafei;
 
    pafei = (struct MSACM_FormatEnumWtoA_Instance*)dwInstance;
 
    pafei->pafda->dwFormatIndex = pafdw->dwFormatIndex;
    pafei->pafda->dwFormatTag = pafdw->dwFormatTag;
    pafei->pafda->fdwSupport = pafdw->fdwSupport;
    WideCharToMultiByte( CP_ACP, 0, pafdw->szFormat, -1,
                         pafei->pafda->szFormat, sizeof(pafei->pafda->szFormat), NULL, NULL );
 
    return (pafei->fnCallback)(hadid, pafei->pafda,
                   pafei->dwInstance, fdwSupport);
}

Referenced by acmFormatEnumA().

MSACM_FormatEnumHelper()

static BOOL MSACM_FormatEnumHelper ( PWINE_ACMDRIVERID  padid, HACMDRIVER  had, PACMFORMATDETAILSW  pafd, PWAVEFORMATEX  pwfxRef, ACMFORMATENUMCBW  fnCallback, DWORD_PTR  dwInstance, DWORD  fdwEnum  )

static

Definition at line 577 of file format.c.

{
    ACMFORMATTAGDETAILSW    aftd;
    unsigned int            i, j;
 
    if (fdwEnum & ACM_FORMATENUMF_SUGGEST) {
        HDRVR hdrvr;
        ACMDRVFORMATSUGGEST adfs;
        pafd->dwFormatIndex = 0;
        memset(&aftd, 0, sizeof(aftd));
        aftd.cbStruct = sizeof(aftd);
        memset(&adfs, 0, sizeof(adfs));
        adfs.cbStruct = sizeof(adfs);
 
        for (i = 0; i < padid->cFormatTags; i++) {
            aftd.dwFormatTag = i;
            pafd->dwFormatTag = aftd.dwFormatTag;
            pafd->pwfx->wFormatTag = pafd->dwFormatTag;
 
            if (acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
                continue;
 
            adfs.cbwfxSrc = aftd.cbFormatSize;
            adfs.cbwfxDst = aftd.cbFormatSize;
            adfs.pwfxSrc = pwfxRef;
            adfs.pwfxDst = pafd->pwfx;
            pafd->fdwSupport = padid->fdwSupport;
 
            if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) &&
                aftd.dwFormatTag != pwfxRef->wFormatTag)
                continue;
 
            if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
                !(pafd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_HARDWARE))
                continue;
 
            hdrvr = OpenDriver(padid->pszFileName,0,0);
            SendDriverMessage(hdrvr,ACMDM_FORMAT_SUGGEST,(LPARAM)&adfs,(fdwEnum & 0x000000FFL));
 
            if (acmFormatDetailsW(had, pafd, ACM_FORMATDETAILSF_FORMAT) != MMSYSERR_NOERROR)
                continue;
 
            pafd->cbwfx = sizeof(*(pafd->pwfx));
 
            if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, padid->fdwSupport))
                return FALSE;
        }
    } else {
        for (i = 0; i < padid->cFormatTags; i++) {
            memset(&aftd, 0, sizeof(aftd));
            aftd.cbStruct = sizeof(aftd);
            aftd.dwFormatTagIndex = i;
            if (acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
                continue;
 
            if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) && aftd.dwFormatTag != pwfxRef->wFormatTag)
                continue;
 
            for (j = 0; j < aftd.cStandardFormats; j++) {
                pafd->dwFormatIndex = j;
                pafd->dwFormatTag = aftd.dwFormatTag;
                pafd->fdwSupport = 0;
                if (acmFormatDetailsW(had, pafd, ACM_FORMATDETAILSF_INDEX) != MMSYSERR_NOERROR)
                    continue;
 
                if ((fdwEnum & ACM_FORMATENUMF_NCHANNELS) &&
                    pafd->pwfx->nChannels != pwfxRef->nChannels)
                    continue;
                if ((fdwEnum & ACM_FORMATENUMF_NSAMPLESPERSEC) &&
                    pafd->pwfx->nSamplesPerSec != pwfxRef->nSamplesPerSec)
                    continue;
                if ((fdwEnum & ACM_FORMATENUMF_WBITSPERSAMPLE) &&
                    pafd->pwfx->wBitsPerSample != pwfxRef->wBitsPerSample)
                    continue;
                if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
                    !(pafd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_HARDWARE))
                    continue;
 
            /* more checks to be done on fdwEnum */
 
                if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, padid->fdwSupport))
                    return FALSE;
            }
        /* the "formats" used by the filters are also reported */
        }
    }
    return TRUE;
}

Referenced by acmFormatEnumW().

MSACM_FormatTagEnumCallbackWtoA()

static BOOL CALLBACK MSACM_FormatTagEnumCallbackWtoA ( HACMDRIVERID  hadid, PACMFORMATTAGDETAILSW  paftdw, DWORD_PTR  dwInstance, DWORD  fdwSupport  )

static

Definition at line 943 of file format.c.

{
    struct MSACM_FormatTagEnumWtoA_Instance* paftei;
 
    paftei = (struct MSACM_FormatTagEnumWtoA_Instance*)dwInstance;
 
    paftei->paftda->dwFormatTagIndex = paftdw->dwFormatTagIndex;
    paftei->paftda->dwFormatTag = paftdw->dwFormatTag;
    paftei->paftda->cbFormatSize = paftdw->cbFormatSize;
    paftei->paftda->fdwSupport = paftdw->fdwSupport;
    paftei->paftda->cStandardFormats = paftdw->cStandardFormats;
    WideCharToMultiByte( CP_ACP, 0, paftdw->szFormatTag, -1, paftei->paftda->szFormatTag,
                         sizeof(paftei->paftda->szFormatTag), NULL, NULL );
 
    return (paftei->fnCallback)(hadid, paftei->paftda,
                paftei->dwInstance, fdwSupport);
}

Referenced by acmFormatTagEnumA().

MSACM_GetWFX()

static MMRESULT MSACM_GetWFX ( HWND  hWnd, PACMFORMATCHOOSEW  afc  )

static

Definition at line 194 of file format.c.

{
    ACMFORMATTAGDETAILSW    aftd;
    struct MSACM_FillFormatData affd;
 
    memset(&aftd, 0, sizeof(aftd));
    aftd.cbStruct = sizeof(aftd);
 
    affd.hWnd = hWnd;
    affd.mode = WINE_ACMFF_WFX;
    affd.afc = afc;
    affd.ret = MMSYSERR_NOERROR;
    SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
            CB_GETLBTEXT,
            SendDlgItemMessageW(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
                        CB_GETCURSEL, 0, 0),
                        (LPARAM)affd.szFormatTag);
 
    acmFormatTagEnumW(NULL, &aftd, MSACM_FillFormatTagsCB, (DWORD_PTR)&affd, 0);
    return affd.ret;
}

Referenced by FormatChooseDlgProc().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msacm

)

Variable Documentation

fmt_prop

const WCHAR fmt_prop[] = {'a','c','m','p','r','o','p','\0'}

static

Definition at line 216 of file format.c.

Referenced by FormatChooseDlgProc().