msg711.c File Reference

#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:

Go to the source code of this file.

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 1078 of file msg711.c.

{
    TRACE("(%08lx %p %04x %08lx %08lx);\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 737 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 %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 G711_DriverProc().

G711_FormatSuggest()

static LRESULT G711_FormatSuggest ( PACMDRVFORMATSUGGEST  adfs )

static

Definition at line 793 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.

{
    static const WCHAR szPcm[]={'P','C','M',0};
    static const WCHAR szALaw[]={'A','-','L','a','w',0};
    static const WCHAR szULaw[]={'U','-','L','a','w',0};
 
    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 %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(PCM_Formats);
        lstrcpyW(aftd->szFormatTag, szPcm);
        break;
    case 1:
    aftd->dwFormatTag = WAVE_FORMAT_ALAW;
    aftd->cbFormatSize = sizeof(WAVEFORMATEX);
    aftd->cStandardFormats = ARRAY_SIZE(ALaw_Formats);
        lstrcpyW(aftd->szFormatTag, szALaw);
    break;
    case 2:
    aftd->dwFormatTag = WAVE_FORMAT_MULAW;
    aftd->cbFormatSize = sizeof(WAVEFORMATEX);
    aftd->cStandardFormats = ARRAY_SIZE(ULaw_Formats);
        lstrcpyW(aftd->szFormatTag, szULaw);
    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 850 of file msg711.c.

{
}

Referenced by G711_StreamConvert(), and G711_StreamOpen().

G711_StreamClose()

static LRESULT G711_StreamClose ( PACMDRVSTREAMINSTANCE  adsi )

static

Definition at line 968 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 1045 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 (%08x), 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 858 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 978 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 %08x\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(), 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(), main(), MSVCRT_locale_to_LCID(), MyFileExists(), BtrfsContextMenu::reflink_copy(), SearchTest::search0(), SearchTest::search1(), SearchTest::search2(), search_builtin_pe(), 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().