#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/debug.h"

Include dependency graph for msg711.c:

Classes
struct	tagAcmG711Data

struct	Format

Macros
#define	SIGN_BIT (0x80) /* Sign bit for an A-law byte. */

#define	QUANT_MASK (0xf) /* Quantization field mask. */

#define	NSEGS (8) /* Number of A-law segments. */

#define	SEG_SHIFT (4) /* Left shift for segment number. */

#define	SEG_MASK (0x70) /* Segment field mask. */

#define	BIAS (0x84) /* Bias for linear code. */

#define	CLIP 8159

Typedefs
typedef struct tagAcmG711Data	AcmG711Data

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (g711)

static LRESULT	G711_drvOpen (LPCSTR str)

static LRESULT	G711_drvClose (DWORD_PTR dwDevID)

static DWORD	G711_GetFormatIndex (const WAVEFORMATEX *wfx)

static short	R16 (const unsigned char *src)

static void	W16 (unsigned char *dst, short s)

static short	search (int val, const short *table, int size)

static unsigned char	linear2alaw (int pcm_val)

static int	alaw2linear (unsigned char a_val)

static unsigned char	linear2ulaw (short pcm_val)

static short	ulaw2linear (unsigned char u_val)

static unsigned char	alaw2ulaw (unsigned char aval)

static unsigned char	ulaw2alaw (unsigned char uval)

static void	cvtXXalaw16K (PACMDRVSTREAMINSTANCE adsi, const unsigned char src, LPDWORD srcsize, unsigned char dst, LPDWORD dstsize)

static void	cvtXX16alawK (PACMDRVSTREAMINSTANCE adsi, const unsigned char src, LPDWORD srcsize, unsigned char dst, LPDWORD dstsize)

static void	cvtXXulaw16K (PACMDRVSTREAMINSTANCE adsi, const unsigned char src, LPDWORD srcsize, unsigned char dst, LPDWORD dstsize)

static void	cvtXX16ulawK (PACMDRVSTREAMINSTANCE adsi, const unsigned char src, LPDWORD srcsize, unsigned char dst, LPDWORD dstsize)

static void	cvtXXalawulawK (PACMDRVSTREAMINSTANCE adsi, const unsigned char src, LPDWORD srcsize, unsigned char dst, LPDWORD dstsize)

static void	cvtXXulawalawK (PACMDRVSTREAMINSTANCE adsi, const unsigned char src, LPDWORD srcsize, unsigned char dst, LPDWORD dstsize)

static LRESULT	G711_DriverDetails (PACMDRIVERDETAILSW add)

static LRESULT	G711_FormatTagDetails (PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)

static LRESULT	G711_FormatDetails (PACMFORMATDETAILSW afd, DWORD dwQuery)

static LRESULT	G711_FormatSuggest (PACMDRVFORMATSUGGEST adfs)

static void	G711_Reset (PACMDRVSTREAMINSTANCE adsi, AcmG711Data *aad)

static LRESULT	G711_StreamOpen (PACMDRVSTREAMINSTANCE adsi)

static LRESULT	G711_StreamClose (PACMDRVSTREAMINSTANCE adsi)

static LRESULT	G711_StreamSize (const ACMDRVSTREAMINSTANCE *adsi, PACMDRVSTREAMSIZE adss)

static LRESULT	G711_StreamConvert (PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMHEADER adsh)

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

Variables
static const Format	PCM_Formats []

static const Format	ALaw_Formats []

static const Format	ULaw_Formats []

static const short	seg_aend [8] = {0x1F, 0x3F, 0x7F, 0x0FF, 0x1FF, 0x3FF, 0x7FF, 0x0FFF}

static const short	seg_uend [8] = {0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF}

static const unsigned char	_u2a [128]

static const unsigned char	_a2u [128]

static const unsigned short	_a2l []

static const unsigned short	_u2l []

Macro Definition Documentation

◆ BIAS

#define BIAS (0x84) /* Bias for linear code. */

Definition at line 395 of file msg711.c.

◆ CLIP

#define CLIP 8159

Definition at line 396 of file msg711.c.

◆ NSEGS

#define NSEGS (8) /* Number of A-law segments. */

Definition at line 203 of file msg711.c.

◆ QUANT_MASK

#define QUANT_MASK (0xf) /* Quantization field mask. */

Definition at line 202 of file msg711.c.

◆ SEG_MASK

#define SEG_MASK (0x70) /* Segment field mask. */

Definition at line 205 of file msg711.c.

◆ SEG_SHIFT

#define SEG_SHIFT (4) /* Left shift for segment number. */

Definition at line 204 of file msg711.c.

◆ SIGN_BIT

#define SIGN_BIT (0x80) /* Sign bit for an A-law byte. */

Definition at line 201 of file msg711.c.

Typedef Documentation

◆ AcmG711Data

typedef struct tagAcmG711Data AcmG711Data

Function Documentation

◆ alaw2linear()

static int alaw2linear ( unsigned char a_val )

inlinestatic

Definition at line 389 of file msg711.c.

{
    return (short)_a2l[a_val];
}

Referenced by cvtXXalaw16K().

◆ alaw2ulaw()

static unsigned char alaw2ulaw ( unsigned char aval )

inlinestatic

Definition at line 533 of file msg711.c.

{
    aval &= 0xff;
    return (unsigned char) ((aval & 0x80) ? (0xFF ^ _a2u[aval ^ 0xD5]) :
                            (0x7F ^ _a2u[aval ^ 0x55]));
}

Referenced by cvtXXalawulawK().

◆ cvtXX16alawK()

static void cvtXX16alawK	(	PACMDRVSTREAMINSTANCE	adsi,
		const unsigned char *	src,
		LPDWORD	srcsize,
		unsigned char *	dst,
		LPDWORD	dstsize
	)

static

Definition at line 567 of file msg711.c.

{
    DWORD       len = min(*srcsize / 2, *dstsize);
    DWORD       i;
 
    *srcsize = len * 2;
    *dstsize = len;
    for (i = 0; i < len; i++)
    {
        *dst++ = linear2alaw(R16(src)); src += 2;
    }
}

Referenced by G711_StreamOpen().

◆ cvtXX16ulawK()

static void cvtXX16ulawK	(	PACMDRVSTREAMINSTANCE	adsi,
		const unsigned char *	src,
		LPDWORD	srcsize,
		unsigned char *	dst,
		LPDWORD	dstsize
	)

static

Definition at line 599 of file msg711.c.

{
    DWORD       len = min(*srcsize / 2, *dstsize);
    DWORD       i;
 
    *srcsize = len * 2;
    *dstsize = len;
    for (i = 0; i < len; i++)
    {
        *dst++ = linear2ulaw(R16(src)); src += 2;
    }
}

Referenced by G711_StreamOpen().

◆ cvtXXalaw16K()

static void cvtXXalaw16K	(	PACMDRVSTREAMINSTANCE	adsi,
		const unsigned char *	src,
		LPDWORD	srcsize,
		unsigned char *	dst,
		LPDWORD	dstsize
	)

static

Definition at line 550 of file msg711.c.

{
    DWORD       len = min(*srcsize, *dstsize / 2);
    DWORD       i;
    short       w;
 
    *srcsize = len;
    *dstsize = len * 2;
    for (i = 0; i < len; i++)
    {
        w = alaw2linear(*src++);
        W16(dst, w);    dst += 2;
    }
}

Referenced by G711_StreamOpen().

◆ cvtXXalawulawK()

static void cvtXXalawulawK	(	PACMDRVSTREAMINSTANCE	adsi,
		const unsigned char *	src,
		LPDWORD	srcsize,
		unsigned char *	dst,
		LPDWORD	dstsize
	)

static

Definition at line 614 of file msg711.c.

{
    DWORD       len = min(*srcsize, *dstsize);
    DWORD       i;
 
    *srcsize = len;
    *dstsize = len;
 
    for (i = 0; i < len; i++)
        *dst++ = alaw2ulaw(*src++);
}

Referenced by G711_StreamOpen().

◆ cvtXXulaw16K()

static void cvtXXulaw16K	(	PACMDRVSTREAMINSTANCE	adsi,
		const unsigned char *	src,
		LPDWORD	srcsize,
		unsigned char *	dst,
		LPDWORD	dstsize
	)

static

Definition at line 582 of file msg711.c.

{
    DWORD       len = min(*srcsize, *dstsize / 2);
    DWORD       i;
    short       w;
 
    *srcsize = len;
    *dstsize = len * 2;
    for (i = 0; i < len; i++)
    {
        w = ulaw2linear(*src++);
        W16(dst, w);    dst += 2;
    }
}

Referenced by G711_StreamOpen().

◆ cvtXXulawalawK()

static void cvtXXulawalawK	(	PACMDRVSTREAMINSTANCE	adsi,
		const unsigned char *	src,
		LPDWORD	srcsize,
		unsigned char *	dst,
		LPDWORD	dstsize
	)

static

Definition at line 629 of file msg711.c.

{
    DWORD       len = min(*srcsize, *dstsize);
    DWORD       i;
 
    *srcsize = len;
    *dstsize = len;
 
    for (i = 0; i < len; i++)
        *dst++ = ulaw2alaw(*src++);
}

Referenced by G711_StreamOpen().

◆ G711_DriverDetails()

static LRESULT G711_DriverDetails ( PACMDRIVERDETAILSW add )

static

Definition at line 647 of file msg711.c.

{
    add->fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
    add->fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
    add->wMid = MM_MICROSOFT;
    add->wPid = MM_MSFT_ACM_G711;
    add->vdwACM = 0x01000000;
    add->vdwDriver = 0x01000000;
    add->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
    add->cFormatTags = 3; /* PCM, G711 A-LAW & MU-LAW */
    add->cFilterTags = 0;
    add->hicon = NULL;
    MultiByteToWideChar( CP_ACP, 0, "Microsoft CCITT G.711", -1,
                         add->szShortName, ARRAY_SIZE( add->szShortName ));
    MultiByteToWideChar( CP_ACP, 0, "Wine G711 converter", -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 G711_DriverProc().

◆ G711_DriverProc()

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

Definition at line 1074 of file msg711.c.

{
    TRACE("(%08Ix %p %04x %08Ix %08Ix);\n",
          dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 
    switch (wMsg)
    {
    case DRV_LOAD:      return 1;
    case DRV_FREE:      return 1;
    case DRV_OPEN:      return G711_drvOpen((LPSTR)dwParam1);
    case DRV_CLOSE:     return G711_drvClose(dwDevID);
    case DRV_ENABLE:        return 1;
    case DRV_DISABLE:       return 1;
    case DRV_QUERYCONFIGURE:    return 1;
    case DRV_CONFIGURE:     MessageBoxA(0, "MS G711 (a-Law & mu-Law) filter !", "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 G711_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
 
    case ACMDM_FORMATTAG_DETAILS:
    return G711_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
 
    case ACMDM_FORMAT_DETAILS:
    return G711_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
 
    case ACMDM_FORMAT_SUGGEST:
    return G711_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
 
    case ACMDM_STREAM_OPEN:
    return G711_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
 
    case ACMDM_STREAM_CLOSE:
    return G711_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
 
    case ACMDM_STREAM_SIZE:
    return G711_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
 
    case ACMDM_STREAM_CONVERT:
    return G711_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
 
    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);
    }
}

◆ G711_drvClose()

static LRESULT G711_drvClose ( DWORD_PTR dwDevID )

static

Definition at line 49 of file msg711.c.

{
    return 1;
}

Referenced by G711_DriverProc().

◆ G711_drvOpen()

static LRESULT G711_drvOpen ( LPCSTR str )

static

Definition at line 41 of file msg711.c.

{
    return 1;
}

Referenced by G711_DriverProc().

◆ G711_FormatDetails()

static LRESULT G711_FormatDetails	(	PACMFORMATDETAILSW	afd,
		DWORD	dwQuery
	)

static

Definition at line 733 of file msg711.c.

{
    switch (dwQuery)
    {
    case ACM_FORMATDETAILSF_FORMAT:
    if (G711_GetFormatIndex(afd->pwfx) == 0xFFFFFFFF) 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(PCM_Formats)) return ACMERR_NOTPOSSIBLE;
        afd->pwfx->nChannels = PCM_Formats[afd->dwFormatIndex].nChannels;
        afd->pwfx->nSamplesPerSec = PCM_Formats[afd->dwFormatIndex].rate;
        afd->pwfx->wBitsPerSample = PCM_Formats[afd->dwFormatIndex].nBits;
        afd->pwfx->nBlockAlign = afd->pwfx->nChannels * 2;
        afd->pwfx->nAvgBytesPerSec = afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
        break;
    case WAVE_FORMAT_ALAW:
        if (afd->dwFormatIndex >= ARRAY_SIZE(ALaw_Formats)) return ACMERR_NOTPOSSIBLE;
        afd->pwfx->nChannels = ALaw_Formats[afd->dwFormatIndex].nChannels;
        afd->pwfx->nSamplesPerSec = ALaw_Formats[afd->dwFormatIndex].rate;
        afd->pwfx->wBitsPerSample = ALaw_Formats[afd->dwFormatIndex].nBits;
        afd->pwfx->nBlockAlign = ALaw_Formats[afd->dwFormatIndex].nChannels;
        afd->pwfx->nAvgBytesPerSec = afd->pwfx->nSamplesPerSec * afd->pwfx->nChannels;
            afd->pwfx->cbSize = 0;
        break;
    case WAVE_FORMAT_MULAW:
        if (afd->dwFormatIndex >= ARRAY_SIZE(ULaw_Formats)) return ACMERR_NOTPOSSIBLE;
        afd->pwfx->nChannels = ULaw_Formats[afd->dwFormatIndex].nChannels;
        afd->pwfx->nSamplesPerSec = ULaw_Formats[afd->dwFormatIndex].rate;
        afd->pwfx->wBitsPerSample = ULaw_Formats[afd->dwFormatIndex].nBits;
        afd->pwfx->nBlockAlign = ULaw_Formats[afd->dwFormatIndex].nChannels;
        afd->pwfx->nAvgBytesPerSec = afd->pwfx->nSamplesPerSec * afd->pwfx->nChannels;
            afd->pwfx->cbSize = 0;
        break;
    default:
            WARN("Unsupported tag %08lx\n", afd->dwFormatTag);
        return MMSYSERR_INVALPARAM;
    }
    break;
    default:
    WARN("Unsupported query %08lx\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 G711_DriverProc().

◆ G711_FormatSuggest()

static LRESULT G711_FormatSuggest ( PACMDRVFORMATSUGGEST adfs )

static

Definition at line 789 of file msg711.c.

{
    /* some tests ... */
    if (adfs->cbwfxSrc < sizeof(PCMWAVEFORMAT) ||
    adfs->cbwfxDst < sizeof(PCMWAVEFORMAT) ||
    G711_GetFormatIndex(adfs->pwfxSrc) == 0xFFFFFFFF) 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 = 8;
        else
            adfs->pwfxDst->wBitsPerSample = 16;
    }
    if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG))
    {
    switch (adfs->pwfxSrc->wFormatTag)
        {
        case WAVE_FORMAT_PCM:   adfs->pwfxDst->wFormatTag = WAVE_FORMAT_ALAW; break;
        case WAVE_FORMAT_ALAW:  adfs->pwfxDst->wFormatTag = WAVE_FORMAT_PCM; break;
        case WAVE_FORMAT_MULAW: adfs->pwfxDst->wFormatTag = WAVE_FORMAT_PCM; break;
        }
    }
    /* check if result is ok */
    if (G711_GetFormatIndex(adfs->pwfxDst) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
 
    /* recompute other values */
    switch (adfs->pwfxDst->wFormatTag)
    {
    case WAVE_FORMAT_PCM:
        adfs->pwfxDst->nBlockAlign = adfs->pwfxDst->nChannels * 2;
        adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * adfs->pwfxDst->nBlockAlign;
        break;
    case WAVE_FORMAT_ALAW:
        adfs->pwfxDst->nBlockAlign = adfs->pwfxDst->nChannels;
        adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * adfs->pwfxSrc->nChannels;
        break;
    case WAVE_FORMAT_MULAW:
        adfs->pwfxDst->nBlockAlign = adfs->pwfxDst->nChannels;
        adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * adfs->pwfxSrc->nChannels;
        break;
    }
 
    return MMSYSERR_NOERROR;
}

Referenced by G711_DriverProc().

◆ G711_FormatTagDetails()

static LRESULT G711_FormatTagDetails	(	PACMFORMATTAGDETAILSW	aftd,
		DWORD	dwQuery
	)

static

Definition at line 676 of file msg711.c.

{
    switch (dwQuery)
    {
    case ACM_FORMATTAGDETAILSF_INDEX:
    if (aftd->dwFormatTagIndex >= 3) 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_ALAW:  aftd->dwFormatTagIndex = 1; break;
    case WAVE_FORMAT_MULAW: aftd->dwFormatTagIndex = 2; break;
    default:        return ACMERR_NOTPOSSIBLE;
    }
    break;
    default:
    WARN("Unsupported query %08lx\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(PCM_Formats);
        lstrcpyW(aftd->szFormatTag, L"PCM");
        break;
    case 1:
    aftd->dwFormatTag = WAVE_FORMAT_ALAW;
    aftd->cbFormatSize = sizeof(WAVEFORMATEX);
    aftd->cStandardFormats = ARRAY_SIZE(ALaw_Formats);
        lstrcpyW(aftd->szFormatTag, L"A-Law");
    break;
    case 2:
    aftd->dwFormatTag = WAVE_FORMAT_MULAW;
    aftd->cbFormatSize = sizeof(WAVEFORMATEX);
    aftd->cStandardFormats = ARRAY_SIZE(ULaw_Formats);
        lstrcpyW(aftd->szFormatTag, L"U-Law");
    break;
    }
    return MMSYSERR_NOERROR;
}

Referenced by G711_DriverProc().

◆ G711_GetFormatIndex()

static DWORD G711_GetFormatIndex ( const WAVEFORMATEX * wfx )

static

Definition at line 93 of file msg711.c.

{
    int             i, hi;
    const Format*   fmts;
 
    switch (wfx->wFormatTag)
    {
    case WAVE_FORMAT_PCM:
    hi = ARRAY_SIZE(PCM_Formats);
    fmts = PCM_Formats;
    break;
    case WAVE_FORMAT_ALAW:
    hi = ARRAY_SIZE(ALaw_Formats);
    fmts = ALaw_Formats;
    break;
    case WAVE_FORMAT_MULAW:
    hi = ARRAY_SIZE(ULaw_Formats);
    fmts = ULaw_Formats;
    break;
    default:
    return 0xFFFFFFFF;
    }
 
    for (i = 0; i < hi; i++)
    {
    if (wfx->nChannels == fmts[i].nChannels &&
        wfx->nSamplesPerSec == fmts[i].rate &&
        wfx->wBitsPerSample == fmts[i].nBits)
        return i;
    }
 
    return 0xFFFFFFFF;
}

Referenced by G711_FormatDetails(), G711_FormatSuggest(), and G711_StreamOpen().

◆ G711_Reset()

static void G711_Reset	(	PACMDRVSTREAMINSTANCE	adsi,
		AcmG711Data *	aad
	)

static

Definition at line 846 of file msg711.c.

847{

848}

Referenced by G711_StreamConvert(), and G711_StreamOpen().

◆ G711_StreamClose()

static LRESULT G711_StreamClose ( PACMDRVSTREAMINSTANCE adsi )

static

Definition at line 964 of file msg711.c.

{
    HeapFree(GetProcessHeap(), 0, (void*)adsi->dwDriver);
    return MMSYSERR_NOERROR;
}

Referenced by G711_DriverProc().

◆ G711_StreamConvert()

static LRESULT G711_StreamConvert	(	PACMDRVSTREAMINSTANCE	adsi,
		PACMDRVSTREAMHEADER	adsh
	)

static

Definition at line 1041 of file msg711.c.

{
    AcmG711Data*    aad = (AcmG711Data*)adsi->dwDriver;
    DWORD       nsrc = adsh->cbSrcLength;
    DWORD       ndst = adsh->cbDstLength;
 
    if (adsh->fdwConvert &
    ~(ACM_STREAMCONVERTF_BLOCKALIGN|
      ACM_STREAMCONVERTF_END|
      ACM_STREAMCONVERTF_START))
    {
    FIXME("Unsupported fdwConvert (%08lx), ignoring it\n", adsh->fdwConvert);
    }
    /* ACM_STREAMCONVERTF_BLOCKALIGN
     *  currently all conversions are block aligned, so do nothing for this flag
     * ACM_STREAMCONVERTF_END
     *  no pending data, so do nothing for this flag
     */
    if ((adsh->fdwConvert & ACM_STREAMCONVERTF_START))
    {
    G711_Reset(adsi, aad);
    }
 
    aad->convert(adsi, adsh->pbSrc, &nsrc, adsh->pbDst, &ndst);
    adsh->cbSrcLengthUsed = nsrc;
    adsh->cbDstLengthUsed = ndst;
 
    return MMSYSERR_NOERROR;
}

Referenced by G711_DriverProc().

◆ G711_StreamOpen()

static LRESULT G711_StreamOpen ( PACMDRVSTREAMINSTANCE adsi )

static

Definition at line 854 of file msg711.c.

{
    AcmG711Data*    aad;
 
    assert(!(adsi->fdwOpen & ACM_STREAMOPENF_ASYNC));
 
    if (G711_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF ||
    G711_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
    return ACMERR_NOTPOSSIBLE;
 
    aad = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmG711Data));
    if (aad == 0) return MMSYSERR_NOMEM;
 
    adsi->dwDriver = (DWORD_PTR)aad;
 
    if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
    adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
    {
    goto theEnd;
    }
    else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW &&
             adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
    {
    /* resampling or mono <=> stereo not available
         * G711 algo only define 16 bit per sample output
         */
    if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
        adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels ||
            adsi->pwfxDst->wBitsPerSample != 16)
        goto theEnd;
 
    /* g711 A-Law decoding... */
    if (adsi->pwfxDst->wBitsPerSample == 16)
        aad->convert = cvtXXalaw16K;
    }
    else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
             adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW)
    {
    if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
        adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels ||
            adsi->pwfxSrc->wBitsPerSample != 16)
        goto theEnd;
 
    /* g711 coding... */
    if (adsi->pwfxSrc->wBitsPerSample == 16)
        aad->convert = cvtXX16alawK;
    }
    else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW &&
             adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
    {
    /* resampling or mono <=> stereo not available
         * G711 algo only define 16 bit per sample output
         */
    if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
        adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels ||
            adsi->pwfxDst->wBitsPerSample != 16)
        goto theEnd;
 
    /* g711 MU-Law decoding... */
    if (adsi->pwfxDst->wBitsPerSample == 16)
        aad->convert = cvtXXulaw16K;
    }
    else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
             adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW)
    {
    if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
        adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels ||
            adsi->pwfxSrc->wBitsPerSample != 16)
        goto theEnd;
 
    /* g711 coding... */
    if (adsi->pwfxSrc->wBitsPerSample == 16)
        aad->convert = cvtXX16ulawK;
    }
    else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW &&
             adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW)
    {
    if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
        adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels)
        goto theEnd;
 
    /* MU-Law => A-Law... */
        aad->convert = cvtXXulawalawK;
    }
    else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW &&
             adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW)
    {
    if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
        adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels)
        goto theEnd;
 
    /* A-Law => MU-Law... */
        aad->convert = cvtXXalawulawK;
    }
    else goto theEnd;
 
    G711_Reset(adsi, aad);
 
    return MMSYSERR_NOERROR;
 
 theEnd:
    HeapFree(GetProcessHeap(), 0, aad);
    adsi->dwDriver = 0L;
    return MMSYSERR_NOTSUPPORTED;
}

Referenced by G711_DriverProc().

◆ G711_StreamSize()

static LRESULT G711_StreamSize	(	const ACMDRVSTREAMINSTANCE *	adsi,
		PACMDRVSTREAMSIZE	adss
	)

static

Definition at line 974 of file msg711.c.

{
    switch (adss->fdwSize)
    {
    case ACM_STREAMSIZEF_DESTINATION:
    /* cbDstLength => cbSrcLength */
    if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
        (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW ||
             adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW))
        {
        adss->cbSrcLength = adss->cbDstLength * 2;
    }
        else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW ||
                  adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW) &&
                 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
        {
        adss->cbSrcLength = adss->cbDstLength / 2;
    }
        else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW ||
                  adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW) &&
                 (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW ||
                  adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW))
        {
        adss->cbSrcLength = adss->cbDstLength;
        }
        else
        {
        return MMSYSERR_NOTSUPPORTED;
    }
    break;
    case ACM_STREAMSIZEF_SOURCE:
    /* cbSrcLength => cbDstLength */
    if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
        (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW ||
             adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW))
        {
        adss->cbDstLength = adss->cbSrcLength / 2;
    }
        else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW ||
                  adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW) &&
                 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
        {
        adss->cbDstLength = adss->cbSrcLength * 2;
    }
        else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_ALAW ||
                  adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MULAW) &&
                 (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_ALAW ||
                  adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MULAW))
        {
        adss->cbDstLength = adss->cbSrcLength;
        }
        else
        {
        return MMSYSERR_NOTSUPPORTED;
    }
    break;
    default:
    WARN("Unsupported query %08lx\n", adss->fdwSize);
    return MMSYSERR_NOTSUPPORTED;
    }
    return MMSYSERR_NOERROR;
}

Referenced by G711_DriverProc().

◆ linear2alaw()

static unsigned char linear2alaw ( int pcm_val )

inlinestatic

Definition at line 289 of file msg711.c.

{
    int     mask;   /* changed from "short" *drago* */
    int     seg;    /* changed from "short" *drago* */
    unsigned char   aval;
 
    pcm_val = pcm_val >> 3;
 
    if (pcm_val >= 0) {
        mask = 0xD5;        /* sign (7th) bit = 1 */
    } else {
        mask = 0x55;        /* sign bit = 0 */
        pcm_val = -pcm_val - 1;
    }
 
    /* Convert the scaled magnitude to segment number. */
    seg = search(pcm_val, seg_aend, 8);
 
    /* Combine the sign, segment, and quantization bits. */
 
    if (seg >= 8)       /* out of range, return maximum value. */
        return (unsigned char) (0x7F ^ mask);
    else {
        aval = (unsigned char) seg << SEG_SHIFT;
        if (seg < 2)
            aval |= (pcm_val >> 1) & QUANT_MASK;
        else
            aval |= (pcm_val >> seg) & QUANT_MASK;
        return (aval ^ mask);
    }
}

Referenced by cvtXX16alawK().

◆ linear2ulaw()

static unsigned char linear2ulaw ( short pcm_val )

inlinestatic

Definition at line 428 of file msg711.c.

{
    short       mask;
    short       seg;
    unsigned char   uval;
 
    /* Get the sign and the magnitude of the value. */
    pcm_val = pcm_val >> 2;
    if (pcm_val < 0) {
        pcm_val = -pcm_val;
        mask = 0x7F;
    } else {
        mask = 0xFF;
    }
    if ( pcm_val > CLIP ) pcm_val = CLIP;       /* clip the magnitude */
    pcm_val += (BIAS >> 2);
 
    /* Convert the scaled magnitude to segment number. */
    seg = search(pcm_val, seg_uend, 8);
 
    /*
     * Combine the sign, segment, quantization bits;
     * and complement the code word.
     */
    if (seg >= 8)       /* out of range, return maximum value. */
        return (unsigned char) (0x7F ^ mask);
    else {
        uval = (unsigned char) (seg << 4) | ((pcm_val >> (seg + 1)) & 0xF);
        return (uval ^ mask);
    }
}

Referenced by cvtXX16ulawK().

◆ R16()

static short R16 ( const unsigned char * src )

inlinestatic

Definition at line 132 of file msg711.c.

{
    return (short)((unsigned short)src[0] | ((unsigned short)src[1] << 8));
}

Referenced by cvtXX16alawK(), and cvtXX16ulawK().

◆ search()

static short search	(	int	val,
		const short *	table,
		int	size
	)

static

Definition at line 255 of file msg711.c.

{
    int     i;  /* changed from "short" *drago* */
 
    for (i = 0; i < size; i++) {
        if (val <= *table++)
            return (i);
    }
    return (size);
}

Referenced by _test_anchor_put_search(), _test_anchor_search(), add_favs_to_menu(), adns__consistency(), alloc_inf_info(), Array_indexOf(), Array_lastIndexOf(), bidi_compute_isolating_runs_set(), computeIsolatingRunsSet(), CredReadW(), FileQueryFiles(), finish_seh_function(), get_seh_function(), ldap_get_next_page(), ldap_get_next_page_s(), ldap_get_paged_count(), ldap_search_abandon_page(), linear2alaw(), linear2ulaw(), locale_to_sname(), main(), MyFileExists(), BtrfsContextMenu::reflink_copy(), SearchTest::search0(), SearchTest::search1(), SearchTest::search2(), search_builtin_pe(), StrRStrIA(), StrRStrIW(), strspn(), StrStrA(), StrStrIA(), StrStrIW(), StrStrNIW(), StrStrNW(), StrStrW(), test_EnumContexts(), test_EnumDocumentMgr(), test_StrStrA(), test_StrStrIA(), test_StrStrIW(), test_StrStrNIW(), test_StrStrNW(), and test_StrStrW().

◆ ulaw2alaw()

static unsigned char ulaw2alaw ( unsigned char uval )

inlinestatic

Definition at line 542 of file msg711.c.

{
    uval &= 0xff;
    return (uval & 0x80) ? (0xD5 ^ (_u2a[0xFF ^ uval] - 1)) : (0x55 ^ (_u2a[0x7F ^ uval] - 1));
}

Referenced by cvtXXulawalawK().

◆ ulaw2linear()

static short ulaw2linear ( unsigned char u_val )

inlinestatic

Definition at line 525 of file msg711.c.

{
    return (short)_u2l[u_val];
}

Referenced by cvtXXulaw16K().

◆ W16()

static void W16	(	unsigned char *	dst,
		short	s
	)

inlinestatic

Definition at line 142 of file msg711.c.

{
    dst[0] = LOBYTE(s);
    dst[1] = HIBYTE(s);
}

Referenced by cvtXXalaw16K(), and cvtXXulaw16K().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( g711 )

Variable Documentation

◆ _a2l

const unsigned short _a2l[]

static

Definition at line 354 of file msg711.c.

Referenced by alaw2linear().

◆ _a2u

const unsigned char _a2u[128]

static

Initial value:

= {     
    1,  3,  5,  7,  9,  11, 13, 15,
    16, 17, 18, 19, 20, 21, 22, 23,
    24, 25, 26, 27, 28, 29, 30, 31,
    32, 32, 33, 33, 34, 34, 35, 35,
    36, 37, 38, 39, 40, 41, 42, 43,
    44, 45, 46, 47, 48, 48, 49, 49,
    50, 51, 52, 53, 54, 55, 56, 57,
    58, 59, 60, 61, 62, 63, 64, 64,
    65, 66, 67, 68, 69, 70, 71, 72,
 
    73, 74, 75, 76, 77, 78, 79, 80,
 
    80, 81, 82, 83, 84, 85, 86, 87,
    88, 89, 90, 91, 92, 93, 94, 95,
    96, 97, 98, 99, 100,    101,    102,    103,
    104,    105,    106,    107,    108,    109,    110,    111,
    112,    113,    114,    115,    116,    117,    118,    119,
    120,    121,    122,    123,    124,    125,    126,    127}

Definition at line 232 of file msg711.c.

Referenced by alaw2ulaw().

◆ _u2a

const unsigned char _u2a[128]

static

Initial value:

= {     
    1,  1,  2,  2,  3,  3,  4,  4,
    5,  5,  6,  6,  7,  7,  8,  8,
    9,  10, 11, 12, 13, 14, 15, 16,
    17, 18, 19, 20, 21, 22, 23, 24,
    25, 27, 29, 31, 33, 34, 35, 36,
    37, 38, 39, 40, 41, 42, 43, 44,
    46, 48, 49, 50, 51, 52, 53, 54,
    55, 56, 57, 58, 59, 60, 61, 62,
    64, 65, 66, 67, 68, 69, 70, 71,
    72, 73, 74, 75, 76, 77, 78, 79,
 
    80, 82, 83, 84, 85, 86, 87, 88,
    89, 90, 91, 92, 93, 94, 95, 96,
    97, 98, 99, 100,    101,    102,    103,    104,
    105,    106,    107,    108,    109,    110,    111,    112,
    113,    114,    115,    116,    117,    118,    119,    120,
    121,    122,    123,    124,    125,    126,    127,    128}

Definition at line 211 of file msg711.c.

Referenced by ulaw2alaw().

◆ _u2l

const unsigned short _u2l[]

static

Definition at line 491 of file msg711.c.

Referenced by ulaw2linear().

◆ ALaw_Formats

const Format ALaw_Formats[]

static

Initial value:

=
{
    {1,  8,  8000}, {2, 8,  8000},  {1,  8, 11025}, {2,  8, 11025},
    {1,  8, 22050}, {2, 8, 22050},  {1,  8, 44100}, {2,  8, 44100},
}

Definition at line 78 of file msg711.c.

Referenced by G711_FormatDetails(), G711_FormatTagDetails(), and G711_GetFormatIndex().

◆ PCM_Formats

const Format PCM_Formats[]

static

Initial value:

=
{
    {1, 16,  8000}, {2, 16,  8000},
    {1, 16, 11025}, {2, 16, 11025},
    {1, 16, 22050}, {2, 16, 22050},
    {1, 16, 44100}, {2, 16, 44100},
}

Definition at line 70 of file msg711.c.

Referenced by G711_FormatDetails(), G711_FormatTagDetails(), and G711_GetFormatIndex().

◆ seg_aend

const short seg_aend[8] = {0x1F, 0x3F, 0x7F, 0x0FF, 0x1FF, 0x3FF, 0x7FF, 0x0FFF}

static

Definition at line 207 of file msg711.c.

Referenced by linear2alaw().

◆ seg_uend

const short seg_uend[8] = {0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF}

static

Definition at line 208 of file msg711.c.

Referenced by linear2ulaw().

◆ ULaw_Formats

const Format ULaw_Formats[]

static

Initial value:

=
{
    {1,  8,  8000}, {2, 8,  8000},  {1,  8, 11025}, {2,  8, 11025},
    {1,  8, 22050}, {2, 8, 22050},  {1,  8, 44100}, {2,  8, 44100},
}

Definition at line 84 of file msg711.c.

Referenced by G711_FormatDetails(), G711_FormatTagDetails(), and G711_GetFormatIndex().

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ BIAS

◆ CLIP

◆ NSEGS

◆ QUANT_MASK

◆ SEG_MASK

◆ SEG_SHIFT

◆ SIGN_BIT

Typedef Documentation

◆ AcmG711Data

Function Documentation

◆ alaw2linear()

◆ alaw2ulaw()

◆ cvtXX16alawK()

◆ cvtXX16ulawK()

◆ cvtXXalaw16K()

◆ cvtXXalawulawK()

◆ cvtXXulaw16K()

◆ cvtXXulawalawK()

◆ G711_DriverDetails()

◆ G711_DriverProc()

◆ G711_drvClose()

◆ G711_drvOpen()

◆ G711_FormatDetails()

◆ G711_FormatSuggest()

◆ G711_FormatTagDetails()

◆ G711_GetFormatIndex()

◆ G711_Reset()

◆ G711_StreamClose()

◆ G711_StreamConvert()

◆ G711_StreamOpen()

◆ G711_StreamSize()

◆ linear2alaw()

◆ linear2ulaw()

◆ R16()

◆ search()

◆ ulaw2alaw()

◆ ulaw2linear()

◆ W16()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

Variable Documentation

◆ _a2l

◆ _a2u

◆ _u2a

◆ _u2l

◆ ALaw_Formats

◆ PCM_Formats

◆ seg_aend

◆ seg_uend

◆ ULaw_Formats