msgsm32.c File Reference

#include "config.h"
#include <wine/port.h>
#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "mmsystem.h"
#include "mmreg.h"
#include "msacm.h"
#include "msacmdrv.h"
#include "wine/library.h"
#include "wine/debug.h"

Include dependency graph for msgsm32.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (gsm)
static LRESULT	GSM_drvFree (void)
static LRESULT	GSM_DriverDetails (PACMDRIVERDETAILSW add)
static BOOL	GSM_FormatValidate (const WAVEFORMATEX *wfx)
static LRESULT	GSM_FormatTagDetails (PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
static LRESULT	GSM_FormatDetails (PACMFORMATDETAILSW afd, DWORD dwQuery)
static LRESULT	GSM_FormatSuggest (PACMDRVFORMATSUGGEST adfs)
LRESULT CALLBACK	GSM_DriverProc (DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg, LPARAM dwParam1, LPARAM dwParam2)

Variables
static const DWORD	gsm_rates [] = { 8000, 11025, 22050, 44100, 48000, 96000 }

Function Documentation

GSM_DriverDetails()

static LRESULT GSM_DriverDetails ( PACMDRIVERDETAILSW  add )

static

Definition at line 114 of file msgsm32.c.

{
    add->fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
    add->fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
    /* Details found from probing native msgsm32.acm */
    add->wMid = MM_MICROSOFT;
    add->wPid = MM_MSFT_ACM_GSM610;
    add->vdwACM = 0x3320000;
    add->vdwDriver = 0x4000000;
    add->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
    add->cFormatTags = 2;
    add->cFilterTags = 0;
    add->hicon = NULL;
    MultiByteToWideChar( CP_ACP, 0, "Microsoft GSM 6.10", -1,
                         add->szShortName, ARRAY_SIZE( add->szShortName ));
    MultiByteToWideChar( CP_ACP, 0, "Wine GSM 6.10 libgsm codec", -1,
                         add->szLongName, ARRAY_SIZE( add->szLongName ));
    MultiByteToWideChar( CP_ACP, 0, "Brought to you by the Wine team...", -1,
                         add->szCopyright, ARRAY_SIZE( add->szCopyright ));
    MultiByteToWideChar( CP_ACP, 0, "Refer to LICENSE file", -1,
                         add->szLicensing, ARRAY_SIZE( add->szLicensing ));
    add->szFeatures[0] = 0;
    return MMSYSERR_NOERROR;
}

Referenced by GSM_DriverProc().

GSM_DriverProc()

LRESULT CALLBACK GSM_DriverProc	(	DWORD_PTR	dwDevID,
		HDRVR	hDriv,
		UINT	wMsg,
		LPARAM	dwParam1,
		LPARAM	dwParam2
	)

Definition at line 572 of file msgsm32.c.

{
    TRACE("(%08lx %p %04x %08lx %08lx);\n",
          dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 
    switch (wMsg)
    {
    case DRV_LOAD:      return 1;
    case DRV_FREE:      return GSM_drvFree();
    case DRV_OPEN:      return 1;
    case DRV_CLOSE:     return 1;
    case DRV_ENABLE:        return 1;
    case DRV_DISABLE:       return 1;
    case DRV_QUERYCONFIGURE:    return 1;
    case DRV_CONFIGURE:     MessageBoxA(0, "GSM 06.10 codec", "Wine Driver", MB_OK); return 1;
    case DRV_INSTALL:       return DRVCNF_RESTART;
    case DRV_REMOVE:        return DRVCNF_RESTART;
 
    case ACMDM_DRIVER_NOTIFY:
    /* no caching from other ACM drivers is done so far */
    return MMSYSERR_NOERROR;
 
    case ACMDM_DRIVER_DETAILS:
    return GSM_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
 
    case ACMDM_FORMATTAG_DETAILS:
    return GSM_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
 
    case ACMDM_FORMAT_DETAILS:
    return GSM_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
 
    case ACMDM_FORMAT_SUGGEST:
    return GSM_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
 
#ifdef SONAME_LIBGSM
    case ACMDM_STREAM_OPEN:
    return GSM_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
 
    case ACMDM_STREAM_CLOSE:
    return GSM_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
 
    case ACMDM_STREAM_SIZE:
    return GSM_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
 
    case ACMDM_STREAM_CONVERT:
    return GSM_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
#else
    case ACMDM_STREAM_OPEN: WARN("libgsm support not compiled in!\n");
    case ACMDM_STREAM_CLOSE:
    case ACMDM_STREAM_SIZE:
    case ACMDM_STREAM_CONVERT:
        return MMSYSERR_NOTSUPPORTED;
#endif
 
    case ACMDM_HARDWARE_WAVE_CAPS_INPUT:
    case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT:
    /* this converter is not a hardware driver */
    case ACMDM_FILTERTAG_DETAILS:
    case ACMDM_FILTER_DETAILS:
    /* this converter is not a filter */
    case ACMDM_STREAM_RESET:
    /* only needed for asynchronous driver... we aren't, so just say it */
    return MMSYSERR_NOTSUPPORTED;
    case ACMDM_STREAM_PREPARE:
    case ACMDM_STREAM_UNPREPARE:
    /* nothing special to do here... so don't do anything */
    return MMSYSERR_NOERROR;
 
    default:
    return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
    }
}

GSM_drvFree()

static LRESULT GSM_drvFree ( void  )

static

Definition at line 103 of file msgsm32.c.

{
    return 1;
}

Referenced by GSM_DriverProc().

GSM_FormatDetails()

static LRESULT GSM_FormatDetails ( PACMFORMATDETAILSW  afd, DWORD  dwQuery  )

static

Definition at line 260 of file msgsm32.c.

{
    switch (dwQuery)
    {
    case ACM_FORMATDETAILSF_FORMAT:
    if (!GSM_FormatValidate(afd->pwfx)) return ACMERR_NOTPOSSIBLE;
    break;
    case ACM_FORMATDETAILSF_INDEX:
    afd->pwfx->wFormatTag = afd->dwFormatTag;
    switch (afd->dwFormatTag)
        {
    case WAVE_FORMAT_PCM:
        if (afd->dwFormatIndex >= ARRAY_SIZE(gsm_rates)) return ACMERR_NOTPOSSIBLE;
        afd->pwfx->nChannels = 1;
        afd->pwfx->nSamplesPerSec = gsm_rates[afd->dwFormatIndex];
        afd->pwfx->wBitsPerSample = 16;
        afd->pwfx->nBlockAlign = 2;
        afd->pwfx->nAvgBytesPerSec = afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
        break;
    case WAVE_FORMAT_GSM610:
        if (afd->dwFormatIndex >= ARRAY_SIZE(gsm_rates)) return ACMERR_NOTPOSSIBLE;
        afd->pwfx->nChannels = 1;
        afd->pwfx->nSamplesPerSec = gsm_rates[afd->dwFormatIndex];
        afd->pwfx->wBitsPerSample = 0;
        afd->pwfx->nBlockAlign = 65;
            afd->pwfx->nAvgBytesPerSec = afd->pwfx->nSamplesPerSec * 65 / 320;
            afd->pwfx->cbSize = sizeof(WORD);
            ((GSM610WAVEFORMAT*)afd->pwfx)->wSamplesPerBlock = 320;
        break;
    default:
            WARN("Unsupported tag %08x\n", afd->dwFormatTag);
        return MMSYSERR_INVALPARAM;
    }
    break;
    default:
    WARN("Unsupported query %08x\n", dwQuery);
    return MMSYSERR_NOTSUPPORTED;
    }
    afd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
    afd->szFormat[0] = 0; /* let MSACM format this for us... */
 
    return MMSYSERR_NOERROR;
}

Referenced by GSM_DriverProc().

GSM_FormatSuggest()

static LRESULT GSM_FormatSuggest ( PACMDRVFORMATSUGGEST  adfs )

static

Definition at line 308 of file msgsm32.c.

{
    /* some tests ... */
    if (adfs->cbwfxSrc < sizeof(PCMWAVEFORMAT) ||
    adfs->cbwfxDst < sizeof(PCMWAVEFORMAT) ||
    !GSM_FormatValidate(adfs->pwfxSrc)) return ACMERR_NOTPOSSIBLE;
    /* FIXME: should do those tests against the real size (according to format tag */
 
    /* If no suggestion for destination, then copy source value */
    if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NCHANNELS))
    adfs->pwfxDst->nChannels = adfs->pwfxSrc->nChannels;
    if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NSAMPLESPERSEC))
        adfs->pwfxDst->nSamplesPerSec = adfs->pwfxSrc->nSamplesPerSec;
 
    if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WBITSPERSAMPLE))
    {
    if (adfs->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM)
            adfs->pwfxDst->wBitsPerSample = 0;
        else
            adfs->pwfxDst->wBitsPerSample = 16;
    }
    if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG))
    {
    switch (adfs->pwfxSrc->wFormatTag)
        {
        case WAVE_FORMAT_PCM: adfs->pwfxDst->wFormatTag = WAVE_FORMAT_GSM610; break;
        case WAVE_FORMAT_GSM610: adfs->pwfxDst->wFormatTag = WAVE_FORMAT_PCM; break;
        }
    }
 
    /* recompute other values */
    switch (adfs->pwfxDst->wFormatTag)
    {
    case WAVE_FORMAT_PCM:
        adfs->pwfxDst->nBlockAlign = 2;
        adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * 2;
        break;
    case WAVE_FORMAT_GSM610:
        if (adfs->pwfxDst->cbSize < sizeof(WORD))
            return ACMERR_NOTPOSSIBLE;
        adfs->pwfxDst->nBlockAlign = 65;
        adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * 65 / 320;
        ((GSM610WAVEFORMAT*)adfs->pwfxDst)->wSamplesPerBlock = 320;
        break;
    default:
        return ACMERR_NOTPOSSIBLE;
    }
 
    /* check if result is ok */
    if (!GSM_FormatValidate(adfs->pwfxDst)) return ACMERR_NOTPOSSIBLE;
    return MMSYSERR_NOERROR;
}

Referenced by GSM_DriverProc().

GSM_FormatTagDetails()

static LRESULT GSM_FormatTagDetails ( PACMFORMATTAGDETAILSW  aftd, DWORD  dwQuery  )

static

Definition at line 207 of file msgsm32.c.

{
    static const WCHAR szPcm[]={'P','C','M',0};
    static const WCHAR szGsm[]={'G','S','M',' ','6','.','1','0',0};
 
    switch (dwQuery)
    {
    case ACM_FORMATTAGDETAILSF_INDEX:
    if (aftd->dwFormatTagIndex > 1) return ACMERR_NOTPOSSIBLE;
    break;
    case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
    if (aftd->dwFormatTag == WAVE_FORMAT_UNKNOWN)
        {
            aftd->dwFormatTagIndex = 1;
        break;
    }
    /* fall through */
    case ACM_FORMATTAGDETAILSF_FORMATTAG:
    switch (aftd->dwFormatTag)
        {
    case WAVE_FORMAT_PCM: aftd->dwFormatTagIndex = 0; break;
    case WAVE_FORMAT_GSM610: aftd->dwFormatTagIndex = 1; break;
    default: return ACMERR_NOTPOSSIBLE;
    }
    break;
    default:
    WARN("Unsupported query %08x\n", dwQuery);
    return MMSYSERR_NOTSUPPORTED;
    }
 
    aftd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
    switch (aftd->dwFormatTagIndex)
    {
    case 0:
    aftd->dwFormatTag = WAVE_FORMAT_PCM;
    aftd->cbFormatSize = sizeof(PCMWAVEFORMAT);
    aftd->cStandardFormats = ARRAY_SIZE(gsm_rates);
        lstrcpyW(aftd->szFormatTag, szPcm);
        break;
    case 1:
    aftd->dwFormatTag = WAVE_FORMAT_GSM610;
    aftd->cbFormatSize = sizeof(GSM610WAVEFORMAT);
    aftd->cStandardFormats = ARRAY_SIZE(gsm_rates);
        lstrcpyW(aftd->szFormatTag, szGsm);
    break;
    }
    return MMSYSERR_NOERROR;
}

Referenced by GSM_DriverProc().

GSM_FormatValidate()

static BOOL GSM_FormatValidate ( const WAVEFORMATEX *  wfx )

static

Definition at line 140 of file msgsm32.c.

{
    if (wfx->nChannels != 1)
        return FALSE;
 
    switch (wfx->wFormatTag)
    {
    case WAVE_FORMAT_PCM:
        if (wfx->wBitsPerSample != 16)
        {
            WARN("PCM wBitsPerSample %u\n", wfx->wBitsPerSample);
            return FALSE;
        }
        if (wfx->nBlockAlign != 2)
        {
            WARN("PCM nBlockAlign %u\n", wfx->nBlockAlign);
            return FALSE;
        }
        if (wfx->nAvgBytesPerSec != wfx->nBlockAlign * wfx->nSamplesPerSec)
        {
            WARN("PCM nAvgBytesPerSec %u/%u\n",
                 wfx->nAvgBytesPerSec,
                 wfx->nBlockAlign * wfx->nSamplesPerSec);
            return FALSE;
        }
        return TRUE;
    case WAVE_FORMAT_GSM610:
        if (wfx->cbSize < sizeof(WORD))
        {
            WARN("GSM cbSize %u\n", wfx->cbSize);
            return FALSE;
        }
        if (wfx->wBitsPerSample != 0)
        {
            WARN("GSM wBitsPerSample %u\n", wfx->wBitsPerSample);
            return FALSE;
        }
        if (wfx->nBlockAlign != 65)
        {
            WARN("GSM nBlockAlign %u\n", wfx->nBlockAlign);
            return FALSE;
        }
        if (((const GSM610WAVEFORMAT*)wfx)->wSamplesPerBlock != 320)
        {
            WARN("GSM wSamplesPerBlock %u\n",
                 ((const GSM610WAVEFORMAT*)wfx)->wSamplesPerBlock);
            return FALSE;
        }
        if (wfx->nAvgBytesPerSec != wfx->nSamplesPerSec * 65 / 320)
        {
            WARN("GSM nAvgBytesPerSec %d / %d\n",
                 wfx->nAvgBytesPerSec, wfx->nSamplesPerSec * 65 / 320);
            return FALSE;
        }
        return TRUE;
    default:
        return FALSE;
    }
    return FALSE;
}

Referenced by GSM_FormatDetails(), and GSM_FormatSuggest().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

gsm

)

Variable Documentation

gsm_rates

const DWORD gsm_rates[] = { 8000, 11025, 22050, 44100, 48000, 96000 }

static

Definition at line 201 of file msgsm32.c.

Referenced by GSM_FormatDetails(), and GSM_FormatTagDetails().