#include    <windows.h>
#include    <stdlib.h>
#include    <mmsystem.h>
#include    <mmreg.h>
#include    <msacm.h>

#include    <stdlib.h>
#include    <stdio.h>

#define TSSND_NATIVE_BITSPERSAMPLE  16
#define TSSND_NATIVE_CHANNELS       2
#define TSSND_NATIVE_SAMPLERATE     22050
#define TSSND_NATIVE_BLOCKALIGN     ((TSSND_NATIVE_BITSPERSAMPLE * \
                                    TSSND_NATIVE_CHANNELS) / 8)
#define TSSND_NATIVE_AVGBYTESPERSEC (TSSND_NATIVE_BLOCKALIGN * \
                                    TSSND_NATIVE_SAMPLERATE)

#define TSSND_SAMPLESPERBLOCK       8192
//
//  Defines
//
#undef  ASSERT
#ifdef  DBG
#define TRC     _DebugMessage
#define ASSERT(_x_)     if (!(_x_)) \
                        {  TRC(FATAL, "ASSERT failed, line %d, file %s\n", \
                        __LINE__, __FILE__); DebugBreak(); }
#else   // !DBG
#define TRC
#define ASSERT
#endif  // !DBG

#define TSMALLOC( _x_ ) malloc( _x_ )
#define TSFREE( _x_ )   free( _x_ )

#ifndef G723MAGICWORD1
#define G723MAGICWORD1 0xf7329ace
#endif

#ifndef G723MAGICWORD2
#define G723MAGICWORD2 0xacdeaea2
#endif

#ifndef VOXWARE_KEY
#define VOXWARE_KEY "35243410-F7340C0668-CD78867B74DAD857-AC71429AD8CAFCB5-E4E1A99E7FFD-371"
#endif

#ifndef WMAUDIO_KEY
#define WMAUDIO_KEY "F6DC9830-BC79-11d2-A9D0-006097926036"
#endif

#ifndef WMAUDIO_DEC_KEY
#define WMAUDIO_DEC_KEY "1A0F78F0-EC8A-11d2-BBBE-006008320064"
#endif

#define WAVE_FORMAT_WMAUDIO2    0x161

const CHAR  *ALV =   "TSSNDD::ALV - ";
const CHAR  *INF =   "TSSNDD::INF - ";
const CHAR  *WRN =   "TSSNDD::WRN - ";
const CHAR  *ERR =   "TSSNDD::ERR - ";
const CHAR  *FATAL = "TSSNDD::FATAL - ";

typedef struct _VCSNDFORMATLIST {
    struct  _VCSNDFORMATLIST    *pNext;
    HACMDRIVERID    hacmDriverId;
    WAVEFORMATEX    Format;
//  additional data for the format
} VCSNDFORMATLIST, *PVCSNDFORMATLIST;

#ifdef _WIN32
#include <pshpack1.h>
#else
#ifndef RC_INVOKED
#pragma pack(1)
#endif
#endif

typedef struct wmaudio2waveformat_tag {
    WAVEFORMATEX wfx;
    DWORD        dwSamplesPerBlock; // only counting "new" samples "= half of what will be used due to overlapping
    WORD         wEncodeOptions;
    DWORD        dwSuperBlockAlign; // the big size...  should be multiples of wfx.nBlockAlign.
} WMAUDIO2WAVEFORMAT;

typedef struct msg723waveformat_tag {
    WAVEFORMATEX wfx;
    WORD         wConfigWord;
    DWORD        dwCodeword1;
    DWORD        dwCodeword2;
} MSG723WAVEFORMAT;

typedef struct intelg723waveformat_tag {
    WAVEFORMATEX wfx;
    WORD         wConfigWord;
    DWORD        dwCodeword1;
    DWORD        dwCodeword2;
} INTELG723WAVEFORMAT;

typedef struct tagVOXACM_WAVEFORMATEX 
{
    WAVEFORMATEX    wfx;
    DWORD           dwCodecId;
    DWORD           dwMode;
    char            szKey[72];
} VOXACM_WAVEFORMATEX, *PVOXACM_WAVEFORMATEX, FAR *LPVOXACM_WAVEFORMATEX;

#ifdef _WIN32
#include <poppack.h>
#else
#ifndef RC_INVOKED
#pragma pack()
#endif
#endif

/////////////////////////////////////////////////////////////////////
//
//  Tracing
//
/////////////////////////////////////////////////////////////////////

VOID
_cdecl
_DebugMessage(
    LPCSTR  szLevel,
    LPCSTR  szFormat,
    ...
    )
{
    CHAR szBuffer[256];
    va_list     arglist;

    if (szLevel == ALV)
        return;

    va_start (arglist, szFormat);
    _vsnprintf (szBuffer, sizeof(szBuffer), szFormat, arglist);
    va_end (arglist);

//    printf( "%s:%s", szLevel, szBuffer );
    OutputDebugStringA(szLevel);
    OutputDebugStringA(szBuffer);
}

/*
 *  Function:
 *      _VCSmdFindSuggestedConverter
 *
 *  Description:
 *      Searches for intermidiate converter
 *
 */
BOOL
_VCSndFindSuggestedConverter(
    HACMDRIVERID    hadid,
    LPWAVEFORMATEX  pDestFormat,
    LPWAVEFORMATEX  pInterrimFmt
    )
{
    BOOL            rv = FALSE;
    MMRESULT        mmres;
    HACMDRIVER      hacmDriver = NULL;
    HACMSTREAM      hacmStream = NULL;

    ASSERT( NULL != pDestFormat );
    ASSERT( NULL != hadid );
    ASSERT( NULL != pInterrimFmt );

    //
    //  first, open the destination acm driver
    //
    mmres = acmDriverOpen(&hacmDriver, hadid, 0);
    if ( MMSYSERR_NOERROR != mmres )
    {
        TRC(ERR, "_VCSndFindSuggestedConverter: can't "
                 "open the acm driver: %d\n",
                mmres);
        goto exitpt;
    }

    //
    //  first probe with the native format
    //  if it passes, we don't need intermidiate
    //  format converter
    //

    pInterrimFmt->wFormatTag         = WAVE_FORMAT_PCM;
    pInterrimFmt->nChannels          = TSSND_NATIVE_CHANNELS;
    pInterrimFmt->nSamplesPerSec     = TSSND_NATIVE_SAMPLERATE;
    pInterrimFmt->nAvgBytesPerSec    = TSSND_NATIVE_AVGBYTESPERSEC;
    pInterrimFmt->nBlockAlign        = TSSND_NATIVE_BLOCKALIGN;
    pInterrimFmt->wBitsPerSample     = TSSND_NATIVE_BITSPERSAMPLE;
    pInterrimFmt->cbSize             = 0;

    mmres = acmStreamOpen(
                &hacmStream,
                hacmDriver,
                pInterrimFmt,
                pDestFormat,
                NULL,           // filter
                0,              // callback
                0,              // dwinstance
                ACM_STREAMOPENF_NONREALTIME
            );

    if ( MMSYSERR_NOERROR == mmres )
    {
    //
    // format is supported
    //
        rv = TRUE;
        goto exitpt;
    } else {
        TRC(ALV, "_VCSndFindSuggestedConverter: format is not supported\n");
    }

    //
    //  find a suggested intermidiate PCM format
    //
    mmres = acmFormatSuggest(
                    hacmDriver,
                    pDestFormat,
                    pInterrimFmt,
                    sizeof( *pInterrimFmt ),
                    ACM_FORMATSUGGESTF_WFORMATTAG 
            );

    if ( MMSYSERR_NOERROR != mmres )
    {
        TRC(ALV, "_VCSndFindSuggestedConverter: can't find "
                 "interrim format: %d\n",
            mmres);
        goto exitpt;
    }

    if ( 16 != pInterrimFmt->wBitsPerSample ||
         ( 1 != pInterrimFmt->nChannels &&
           2 != pInterrimFmt->nChannels) ||
         ( 8000 != pInterrimFmt->nSamplesPerSec &&
           11025 != pInterrimFmt->nSamplesPerSec &&
           12000 != pInterrimFmt->nSamplesPerSec &&
           16000 != pInterrimFmt->nSamplesPerSec &&
           22050 != pInterrimFmt->nSamplesPerSec)
        )
    {
        TRC(ALV, "_VCSndFindSuggestedConverter: not supported "
                 "interrim format. Details:\n");
        TRC(ALV, "Channels - %d\n",         pInterrimFmt->nChannels);
        TRC(ALV, "SamplesPerSec - %d\n",    pInterrimFmt->nSamplesPerSec);
        TRC(ALV, "AvgBytesPerSec - %d\n",   pInterrimFmt->nAvgBytesPerSec);
        TRC(ALV, "BlockAlign - %d\n",       pInterrimFmt->nBlockAlign);
        TRC(ALV, "BitsPerSample - %d\n",    pInterrimFmt->wBitsPerSample);
        goto exitpt;
    }

    if ( 1 == pInterrimFmt->nChannels )
    {
        switch ( pInterrimFmt->nSamplesPerSec )
        {
        case  8000: 
        case 11025: 
        case 12000: 
        case 16000: 
        case 22050: 
            break;
        default:
            ASSERT( 0 );
        }
    } else {
        switch ( pInterrimFmt->nSamplesPerSec )
        {
        case  8000: 
        case 11025: 
        case 12000: 
        case 16000: 
        case 22050: 
            break;
        default:
            ASSERT( 0 );
        }
    }

    //
    //  probe with this format
    //
    mmres = acmStreamOpen(
                &hacmStream,
                hacmDriver,
                pInterrimFmt,
                pDestFormat,
                NULL,           // filter
                0,              // callback
                0,              // dwinstance
                ACM_STREAMOPENF_NONREALTIME
            );

    if ( MMSYSERR_NOERROR != mmres )
    {
        TRC(ALV, "_VCSndFindSuggestedConverter: probing the suggested "
                 "format failed: %d\n",
            mmres);
        goto exitpt;
    }

    TRC(ALV, "_VCSndFindSuggestedConverter: found intermidiate PCM format\n");
    TRC(ALV, "Channels - %d\n",         pInterrimFmt->nChannels);
    TRC(ALV, "SamplesPerSec - %d\n",    pInterrimFmt->nSamplesPerSec);
    TRC(ALV, "AvgBytesPerSec - %d\n",   pInterrimFmt->nAvgBytesPerSec);
    TRC(ALV, "BlockAlign - %d\n",       pInterrimFmt->nBlockAlign);
    TRC(ALV, "BitsPerSample - %d\n",    pInterrimFmt->wBitsPerSample);

    rv = TRUE;

exitpt:
    if ( NULL != hacmStream )
        acmStreamClose( hacmStream, 0 );

    if ( NULL != hacmDriver )
        acmDriverClose( hacmDriver, 0 );

    return rv;
}

/*
 *  Function:
 *      _VCSndOrderFormatList
 *
 *  Description:
 *      Order all formats in descendant order
 *
 */
VOID
_VCSndOrderFormatList(
    PVCSNDFORMATLIST    *ppFormatList,
    DWORD               *pdwNum
    )
{
    PVCSNDFORMATLIST    pFormatList;
    PVCSNDFORMATLIST    pLessThan;
    PVCSNDFORMATLIST    pPrev;
    PVCSNDFORMATLIST    pNext;
    PVCSNDFORMATLIST    pIter;
    PVCSNDFORMATLIST    pIter2;
    DWORD               dwNum = 0;

    ASSERT ( NULL != ppFormatList );

    pFormatList = *ppFormatList;
    pLessThan   = NULL;

    //
    //  fill both lists
    //
    pIter = pFormatList;
    while ( NULL != pIter )
    {
        pNext = pIter->pNext;
        pIter->pNext = NULL;

        //
        //  descending order
        //
        pIter2 = pLessThan;
        pPrev  = NULL;
        while ( NULL != pIter2 &&
                pIter2->Format.nAvgBytesPerSec >
                    pIter->Format.nAvgBytesPerSec )
        {
            pPrev  = pIter2;
            pIter2 = pIter2->pNext;
        }

        pIter->pNext = pIter2;
        if ( NULL == pPrev )
            pLessThan = pIter;
        else
            pPrev->pNext = pIter;

        pIter = pNext;
        dwNum ++;
    }

    *ppFormatList = pLessThan;

    if ( NULL != pdwNum )
        *pdwNum = dwNum;
}

//
//  puts code licensing codes into the header
//
BOOL
_VCSndFixHeader(
    PWAVEFORMATEX   pFmt,
    PWAVEFORMATEX   *ppNewFmt
    )
{
    BOOL rv = FALSE;

    *ppNewFmt = NULL;
    switch (pFmt->wFormatTag)
    {
        case WAVE_FORMAT_MSG723:
            ASSERT(pFmt->cbSize == 10);
            ((MSG723WAVEFORMAT *) pFmt)->dwCodeword1 = G723MAGICWORD1;
            ((MSG723WAVEFORMAT *) pFmt)->dwCodeword2 = G723MAGICWORD2;

            rv = TRUE;
            break;

        case WAVE_FORMAT_MSRT24:
            //
            // assume call control will take care of the other
            // params ?
            //
            ASSERT(pFmt->cbSize == 80);
            strncpy(((VOXACM_WAVEFORMATEX *) pFmt)->szKey, VOXWARE_KEY, 80);

            rv = TRUE;
            break;

        case WAVE_FORMAT_WMAUDIO2:
            if ( ((WMAUDIO2WAVEFORMAT *)pFmt)->dwSamplesPerBlock > TSSND_SAMPLESPERBLOCK )
            {
                //
                // block is too big, too high latency
                //
                break;
            }
            ASSERT( pFmt->cbSize == sizeof( WMAUDIO2WAVEFORMAT ) - sizeof( WAVEFORMATEX ));
            *ppNewFmt = TSMALLOC( sizeof( WMAUDIO2WAVEFORMAT ) + sizeof( WMAUDIO_KEY ));
            if ( NULL == *ppNewFmt )
            {
                break;
            }
            memcpy( *ppNewFmt, pFmt, sizeof( WMAUDIO2WAVEFORMAT ));
            strncpy((CHAR *)(((WMAUDIO2WAVEFORMAT *) *ppNewFmt) + 1), WMAUDIO_KEY, sizeof( WMAUDIO_KEY ));
            (*ppNewFmt)->cbSize += sizeof( WMAUDIO_KEY );
            rv = TRUE;
        break;
        default:
            rv = TRUE;
    }

    return rv;

}


/*
 *  Function:
 *      acmFormatEnumCallback
 *
 *  Description:
 *      All formats enumerator
 *
 */
BOOL
CALLBACK
acmFormatEnumCallback(
    HACMDRIVERID        hadid,       
    LPACMFORMATDETAILS  pAcmFormatDetails,  
    DWORD_PTR           dwInstance,         
    DWORD               fdwSupport          
    )
{
    PVCSNDFORMATLIST    *ppFormatList;
    PWAVEFORMATEX       pEntry, pFixedEntry = NULL;

    ASSERT(0 != dwInstance);
    ASSERT(NULL != pAcmFormatDetails);
    ASSERT(NULL != pAcmFormatDetails->pwfx);

    if ( 0 == dwInstance ||
         NULL == pAcmFormatDetails ||
         NULL == pAcmFormatDetails->pwfx )
    {

        TRC( ERR, "acmFormatEnumCallback: Invalid parameters\n" );
        goto exitpt;
    }

    ppFormatList = (PVCSNDFORMATLIST *)dwInstance;

    if (( 0 != ( fdwSupport & ACMDRIVERDETAILS_SUPPORTF_CODEC ) ||
          0 != ( fdwSupport & ACMDRIVERDETAILS_SUPPORTF_CONVERTER )) && 
         pAcmFormatDetails->pwfx->nAvgBytesPerSec < TSSND_NATIVE_AVGBYTESPERSEC
        )
    {
    //
    //  this codec should be good, save it in the list
    //  keep the list sorted in descended order
    //
        PVCSNDFORMATLIST    pIter;
        PVCSNDFORMATLIST    pPrev;
        PVCSNDFORMATLIST    pNewEntry;
        WAVEFORMATEX        WaveFormat;     // dummy parameter
        DWORD               itemsize;

        if (
            WAVE_FORMAT_PCM == pAcmFormatDetails->pwfx->wFormatTag ||
            !_VCSndFixHeader(pAcmFormatDetails->pwfx, &pFixedEntry )
            )
        {
            TRC(ALV, "acmFormatEnumCallback: unsupported format, "
                     "don't use it\n");
            goto exitpt;
        }

        pEntry = ( NULL == pFixedEntry )?pAcmFormatDetails->pwfx:pFixedEntry;

        if (!_VCSndFindSuggestedConverter(
                hadid,
                pEntry,
                &WaveFormat
            ))
        {
            TRC(ALV, "acmFormatEnumCallback: unsupported format, "
                     "don't use it\n");
            goto exitpt;
        }

        TRC(ALV, "acmFormatEnumCallback: codec found %S (%d b/s)\n",
                pAcmFormatDetails->szFormat,
                pEntry->nAvgBytesPerSec);

        itemsize = sizeof( *pNewEntry ) + pEntry->cbSize;
        pNewEntry = (PVCSNDFORMATLIST) TSMALLOC( itemsize );

        if (NULL == pNewEntry)
        {
            TRC(ERR, "acmFormatEnumCallback: can't allocate %d bytes\n",
                    itemsize);
            goto exitpt;
        }

        memcpy( &pNewEntry->Format, pEntry, 
                sizeof (pNewEntry->Format) + pEntry->cbSize );
        pNewEntry->hacmDriverId = hadid;

        pNewEntry->pNext = *ppFormatList;
        *ppFormatList = pNewEntry;

    }

exitpt:

    if ( NULL != pFixedEntry )
    {
        TSFREE( pFixedEntry );
    }

    return TRUE;
}


//
//  returns true if this codec is shipped with windows
//  because we are testing only the these
//
BOOL
AllowThisCodec( 
    HACMDRIVERID hadid 
    )
{
    ACMDRIVERDETAILS Details;
    BOOL rv = FALSE;

    static DWORD AllowedCodecs[][2] = 
                              { MM_INTEL,     503,
                                MM_MICROSOFT, MM_MSFT_ACM_IMAADPCM,
                                MM_FRAUNHOFER_IIS, 12,
                                MM_MICROSOFT, 90,
                                MM_MICROSOFT, MM_MSFT_ACM_MSADPCM,
                                MM_MICROSOFT, 39,
                                MM_MICROSOFT, MM_MSFT_ACM_G711,
                                MM_MICROSOFT, 82,
                                MM_MICROSOFT, MM_MSFT_ACM_GSM610,
                                MM_SIPROLAB,  1,
                                MM_DSP_GROUP, 1,
                                MM_MICROSOFT, MM_MSFT_ACM_PCM };


    RtlZeroMemory( &Details, sizeof( Details ));
    Details.cbStruct = sizeof( Details );

    if ( MMSYSERR_NOERROR == 
         acmDriverDetails( hadid, &Details, 0 ))
    {
        //
        //  Is this one known
        //
        DWORD count;

        for ( count = 0; count < sizeof( AllowedCodecs ) / (2 * sizeof( DWORD )); count ++ )
        {
            if ( Details.wMid == AllowedCodecs[count][0] &&
                 Details.wPid == AllowedCodecs[count][1] )
            {
                rv = TRUE;
                goto exitpt;
            }
        }
    }

exitpt:
    if ( rv )
        TRC( ALV, "ACMDRV: +++++++++++++++++++++ CODEC ALLOWED +++++++++++++++++++++++\n" );
    else
        TRC( ALV, "ACMDRV: ------------------- CODEC DISALLOWED ----------------------\n" );

    TRC( ALV, "ACMDRV: Mid: %d\n", Details.wMid );
    TRC( ALV, "ACMDRV: Pid: %d\n", Details.wPid );
    TRC( ALV, "ACMDRV: ShortName: %S\n", Details.szShortName );
    TRC( ALV, "ACMDRV: LongName: %S\n", Details.szLongName );
    TRC( ALV, "ACMDRV: Copyright: %S\n", Details.szLicensing );
    TRC( ALV, "ACMDRV: Features: %S\n", Details.szFeatures );

    return rv;
}
/*
 *  Function:
 *      acmDriverEnumCallback
 *
 *  Description:
 *      All drivers enumerator
 *
 */
BOOL
CALLBACK
acmDriverEnumCallback(
    HACMDRIVERID    hadid,  
    DWORD_PTR       dwInstance,    
    DWORD           fdwSupport     
    )
{
    PVCSNDFORMATLIST    *ppFormatList;
    MMRESULT            mmres;

    ASSERT(dwInstance);

    ppFormatList = (PVCSNDFORMATLIST *)dwInstance;

    if ( (0 != ( fdwSupport & ACMDRIVERDETAILS_SUPPORTF_CODEC ) ||
          0 != ( fdwSupport & ACMDRIVERDETAILS_SUPPORTF_CONVERTER )) &&
          AllowThisCodec(hadid) )
    {
    //
    //  a codec found
    //
        HACMDRIVER had;

        mmres = acmDriverOpen(&had, hadid, 0);
        if (MMSYSERR_NOERROR == mmres)
        {
            PWAVEFORMATEX       pWaveFormat;
            ACMFORMATDETAILS    AcmFormatDetails;
            DWORD               dwMaxFormatSize;

            //
            //  first find the max size for the format
            //
            mmres = acmMetrics( (HACMOBJ)had, 
                                ACM_METRIC_MAX_SIZE_FORMAT, 
                                (LPVOID)&dwMaxFormatSize);

            if (MMSYSERR_NOERROR != mmres ||
                dwMaxFormatSize < sizeof( *pWaveFormat ))

                dwMaxFormatSize = sizeof( *pWaveFormat );

            //
            //  Allocate the format structure
            //
            __try {
                pWaveFormat = (PWAVEFORMATEX) _alloca ( dwMaxFormatSize );
            } __except ( EXCEPTION_EXECUTE_HANDLER )
            {
                pWaveFormat = NULL;
            }

            if ( NULL == pWaveFormat )
            {
                TRC(ERR, "acmDriverEnumCallback: alloca failed for %d bytes\n",
                    dwMaxFormatSize);
                goto close_acm_driver;
            }

            //  
            //  clear the extra format data
            //
            memset( pWaveFormat + 1, 0, dwMaxFormatSize - sizeof( *pWaveFormat ));
            //
            //  create the format to convert from
            //
            pWaveFormat->wFormatTag         = WAVE_FORMAT_PCM;
            pWaveFormat->nChannels          = TSSND_NATIVE_CHANNELS;
            pWaveFormat->nSamplesPerSec     = TSSND_NATIVE_SAMPLERATE;
            pWaveFormat->nAvgBytesPerSec    = TSSND_NATIVE_AVGBYTESPERSEC;
            pWaveFormat->nBlockAlign        = TSSND_NATIVE_BLOCKALIGN;
            pWaveFormat->wBitsPerSample     = TSSND_NATIVE_BITSPERSAMPLE;
            pWaveFormat->cbSize             = 0;

            AcmFormatDetails.cbStruct     = sizeof( AcmFormatDetails );
            AcmFormatDetails.dwFormatIndex= 0;
            AcmFormatDetails.dwFormatTag  = WAVE_FORMAT_PCM;
            AcmFormatDetails.fdwSupport   = 0;
            AcmFormatDetails.pwfx         = pWaveFormat;
            AcmFormatDetails.cbwfx        = dwMaxFormatSize;

            //
            //  enum all formats supported by this driver
            //
            mmres = acmFormatEnum(
                        had,
                        &AcmFormatDetails,
                        acmFormatEnumCallback,
                        (DWORD_PTR)ppFormatList,
                        0   //ACM_FORMATENUMF_CONVERT
                        );

            if (MMSYSERR_NOERROR != mmres)
            {
                TRC(ERR, "acmDriverEnumCallback: acmFormatEnum failed %d\n",
                    mmres);
            }

close_acm_driver:
            acmDriverClose(had, 0);
        } else
            TRC(ALV, "acmDriverEnumCallback: acmDriverOpen failed: %d\n",
                        mmres);
    }

    //
    //  continue to the next driver
    //
    return TRUE;
}


/*
 *  Function:
 *      VCSndEnumAllCodecFormats
 *
 *  Description:
 *      Creates a list of all codecs/formats
 *
 */
BOOL
VCSndEnumAllCodecFormats(
    PVCSNDFORMATLIST *ppFormatList,
    DWORD            *pdwNumberOfFormats
    )
{
    BOOL             rv = FALSE;
    PVCSNDFORMATLIST pIter;
    PVCSNDFORMATLIST pPrev;
    PVCSNDFORMATLIST pNext;
    MMRESULT         mmres;
    DWORD            dwNum = 0;

    ASSERT( ppFormatList );
    ASSERT( pdwNumberOfFormats );

    *ppFormatList = NULL;

    mmres = acmDriverEnum(
        acmDriverEnumCallback,
        (DWORD_PTR)ppFormatList,
        0
        );

    if (NULL == *ppFormatList)
    {
        TRC(WRN, "VCSndEnumAllCodecFormats: acmDriverEnum failed: %d\n",
                    mmres);

        goto exitpt;
    }

    _VCSndOrderFormatList( ppFormatList, &dwNum );

    pIter = *ppFormatList;
    //
    //  number of formats is passed as UINT16, delete all after those
    //
    if ( dwNum > 0xffff )
    {
        DWORD dwLimit = 0xfffe;

        while ( 0 != dwLimit )
        {
            pIter = pIter->pNext;
            dwLimit --;
        }

        pNext = pIter->pNext;
        pIter->pNext = NULL;
        pIter = pNext;
        while( NULL != pIter )
        {
            pNext = pIter->pNext;
            TSFREE( pNext );
            pIter = pNext;
        }

        dwNum = 0xffff;
    }

    rv = TRUE;

exitpt:
    if (!rv)
    {
        //
        //  in case of error free the allocated list of formats
        //
        pIter = *ppFormatList;
        while( NULL != pIter )
        {
            PVCSNDFORMATLIST pNext = pIter->pNext;

            TSFREE( pIter );

            pIter = pNext;
        }

        *ppFormatList = NULL;

    }

    *pdwNumberOfFormats = dwNum;

    return rv;
}


int
_cdecl
wmain( void )
{
    PVCSNDFORMATLIST pFormatList = NULL;
    DWORD            dwNumberOfFormats = 0;

    printf( "// use dumpcod.c to generate this table\n" );
    printf( "//\n" );
    printf( "// FormatTag |   Channels | SamplesPerSec | AvgBytesPerSec | BlockAlign | BitsPerSamepl | ExtraInfo\n" );
    printf( "// ================================================================================================\n" );
    printf( "//\n" );
    printf( "BYTE KnownFormats[] = {\n" );

    VCSndEnumAllCodecFormats( &pFormatList, &dwNumberOfFormats );
    for ( ;pFormatList != NULL; pFormatList = pFormatList->pNext )
    {
        PWAVEFORMATEX pSndFmt = &(pFormatList->Format);
        UINT i;


        printf( "// %.3d, %.2d, %.5d, %.5d, %.3d, %.2d\n",
                    pSndFmt->wFormatTag,
                    pSndFmt->nChannels,
                    pSndFmt->nSamplesPerSec,
                    pSndFmt->nAvgBytesPerSec,
                    pSndFmt->nBlockAlign,
                    pSndFmt->wBitsPerSample);

        for ( i = 0; i < sizeof( WAVEFORMATEX ); i ++ )
        {
            printf( "0x%02x", ((PBYTE)pSndFmt)[i]);
            if ( i + 1 < sizeof( WAVEFORMATEX ) || pSndFmt->cbSize )
            {
                printf( ", " );
            }
        }
        for ( i = 0; i < pSndFmt->cbSize; i++ )
        {
            printf( "0x%02x", (((PBYTE)pSndFmt) + sizeof( WAVEFORMATEX ))[i]);
            if ( i + 1 < pSndFmt->cbSize )
            {
                printf( ", " );
            }
        }
        if ( NULL != pFormatList->pNext )
        {
            printf ( ",\n" );
        } else {
            printf( " };\n" );
        }
    }

    return 0;

}