windows-server-2003/termsrv/rdpclip/sndchan.cpp

/////////////////////////////////////////////////////////////////////
//
//      Module:     sndchan.c
//
//      Purpose:    Server-side audio redirection communication
//                  module
//
//      Copyright(C) Microsoft Corporation 2000
//
//      History:    4-10-2000  vladimis [created]
//
/////////////////////////////////////////////////////////////////////

#include    <windef.h>
#include    <winsta.h>
#include    <wtsapi32.h>
#include    <pchannel.h>
#include    <malloc.h>
#include    <stdio.h>
#include    <stdlib.h>
#include    <winsock2.h>

#include    <mmsystem.h>
#include    <mmreg.h>
#include    <msacm.h>
#include    <aclapi.h>
#include    <sha.h>
#include    <rc4.h>

#include    <rdpstrm.h>
//
// Include security headers for RNG functions
//
#define NO_INCLUDE_LICENSING 1
#include    <tssec.h>
#include    "sndchan.h"
#include    "sndknown.h"

#define TSSND_REG_MAXBANDWIDTH_KEY  L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Drivers32\\Terminal Server\\RDP"

#define TSSND_REG_MAXBANDWIDTH_VAL  L"MaxBandwidth"
#define TSSND_REG_MINBANDWIDTH_VAL  L"MinBandwidth"
#define TSSND_REG_DISABLEDGRAM_VAL  L"DisableDGram"
#define TSSND_REG_ENABLEMP3_VAL     L"EnableMP3Codec"
#define TSSND_REG_ALLOWCODECS       L"AllowCodecs"
#define TSSND_REG_MAXDGRAM          L"MaxDGram"

#define DEFAULT_RESPONSE_TIMEOUT    5000

#define TSSND_TRAINING_BLOCKSIZE    1024

//
//      --- READ THIS IF YOU ARE ADDING FEATURES ---
//  right now the encryption works only from server to client
//  there's no data send from server to client
//  if you read this in the future and you are planning to add
//  data stream from client to server, PLEASE ENCRYPT IT !!! 
//  use SL_Encrypt function for that
//
#define MIN_ENCRYPT_LEVEL           2

#define STAT_COUNT                  32
#define STAT_COUNT_INIT             (STAT_COUNT - 8)

#define READ_EVENT              0
#define DISCONNECT_EVENT        1
#define RECONNECT_EVENT         2
#define DATAREADY_EVENT         3
#define DGRAM_EVENT             4
#define POWERWAKEUP_EVENT       5
#define POWERSUSPEND_EVENT      6
#define TOTAL_EVENTS            7

#define NEW_CODEC_COVER         90  // minimum percentage a new codec has to cover
                                    // i.e if we are at 7kbps and the new meassurement is
                                    // for 10kbps we are not switching to codec which
                                    // does have more than NEW_CODEC_COVER * 10k / 100 bandwith
                                    // requirement

//
//  Data for enabling private codecs
//  BUGBUG 
//  Legal issue ?!
//
#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

#define _RDPSNDWNDCLASS             L"RDPSound window"

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

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;

#define WAVE_FORMAT_WMAUDIO2    0x161

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

typedef struct {
    SNDPROLOG   Prolog;
    UINT        uiPrologReceived;
    PVOID       pBody;
    UINT        uiBodyAllocated;
    UINT        uiBodyReceived;
} SNDMESSAGE, *PSNDMESSAGE;


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

typedef VOID (*PFNCONVERTER)( INT16 *, DWORD, DWORD * );

static HANDLE      g_hVC               = NULL;  // virtual channel handle

BYTE        g_Buffer[CHANNEL_CHUNK_LENGTH];     // receive buffer
UINT        g_uiBytesInBuffer   = 0;            //
UINT        g_uiBufferOffset    = 0;
OVERLAPPED  g_OverlappedRead;                   // overlapped structure

HANDLE      g_hDataReadyEvent   = NULL;         // set by the client apps
HANDLE      g_hStreamIsEmptyEvent = NULL;       // set by this code
HANDLE      g_hStreamMutex      = NULL;         // guard the stream data
HANDLE      g_hStream           = NULL;         // stream handle
HANDLE      g_hDisconnectEvent  = NULL;         // set for this VC
PSNDSTREAM  g_Stream;                           // stream data pointer

BOOL        g_bRunning          = TRUE;         // TRUE if running
BOOL        g_bDeviceOpened     = FALSE;        // TRUE if device opened
BOOL        g_bDisconnected     = FALSE;        // TRUE if disconnected
DWORD       g_dwLineBandwidth   = 0;            // current bandwidth
DWORD       g_dwCodecChangeThreshold = 10;      // how mach the bandwith has to change in order
                                                // to change the codec ( in percents )
                                                // this number changes up to 50%
PSNDFORMATITEM  *g_ppNegotiatedFormats = NULL;  // list of formats
DWORD           g_dwNegotiatedFormats  = 0;     // number of formats
DWORD           g_dwCurrentFormat      = 0;     // current format Id
HACMDRIVERID    g_hacmDriverId  = NULL;         // codec handles
HACMDRIVER      g_hacmDriver    = NULL;
HACMSTREAM      g_hacmStream    = NULL;

PFNCONVERTER    g_pfnConverter  = NULL;         // intermidiate converter

DWORD       g_dwDataRemain = 0;
BYTE        g_pCnvPrevData[ TSSND_BLOCKSIZE ];

PVCSNDFORMATLIST g_pAllCodecsFormatList = NULL; // all available codecs
DWORD            g_dwAllCodecsNumber = 0;

DWORD   g_dwMaxBandwidth        = (DWORD) -1;   // options
DWORD   g_dwMinBandwidth        = 0;
DWORD   g_dwDisableDGram        = 0;
DWORD   g_dwEnableMP3Codec      = 0;

DWORD   *g_AllowCodecs    = NULL;
DWORD   g_AllowCodecsSize = 0;

DWORD   g_dwStatPing            = 0;            // statistics
DWORD   g_dwStatLatency         = 0;
DWORD   g_dwBlocksOnTheNet      = TSSND_BLOCKSONTHENET;
DWORD   g_dwStatCount           = STAT_COUNT_INIT;
DWORD   g_dwPacketSize          = 0;


HANDLE      g_hPowerWakeUpEvent = NULL;         // power events
HANDLE      g_hPowerSuspendEvent = NULL;
BOOL        g_bSuspended        = FALSE;
BOOL        g_bDeviceFailed     = FALSE;

//
//  datagram control
//
SOCKET  g_hDGramSocket = INVALID_SOCKET;
DWORD   g_dwDGramPort = 0;
DWORD   g_dwDGramSize = 1460;   // number good which is ok for LAN
u_long  g_ulDGramAddress = 0;
DWORD   g_EncryptionLevel = 3;
DWORD   g_wClientVersion = 0;
DWORD   g_HiBlockNo = 0;
BYTE    g_EncryptKey[RANDOM_KEY_LENGTH + 4];

WSABUF  g_wsabuf;
BYTE    g_pDGramRecvData[128];

WSAOVERLAPPED g_WSAOverlapped;

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 - ";

static  HANDLE      g_hThread = NULL;

//
//  internal functions
//

BOOL
ChannelBlockWrite(
    PVOID   pBlock,
    ULONG   ulBlockSize
    );

BOOL
VCSndAcquireStream(
    VOID
    );

BOOL
VCSndReleaseStream(
    VOID
    );

BOOL
_VCSndOpenConverter(
    VOID
    );

VOID
_VCSndCloseConverter(
    VOID
    );

VOID
_VCSndOrderFormatList(
    PVCSNDFORMATLIST    *ppFormatList,
    DWORD               *pdwNum
    );

DWORD
_VCSndChooseProperFormat(
    DWORD   dwBandwidth
    );

BOOL
_VCSndGetACMDriverId( 
    PSNDFORMATITEM pSndFmt 
    );

VOID
DGramRead(
    HANDLE hDGramEvent,
    PVOID  *ppBuff,
    DWORD  *pdwRecvd
    );

VOID
DGramReadComplete(
    PVOID  *ppBuff,
    DWORD  *pdwRecvd
    );

#if !( TSSND_NATIVE_SAMPLERATE - 22050 )
//
// converters
// convert to the native format
//
#define CONVERTFROMNATIVETOMONO(_speed_) \
VOID \
_Convert##_speed_##Mono( \
    INT16  *pSrc, \
    DWORD dwSrcSize, \
    DWORD *pdwDstSize ) \
{ \
    DWORD dwDstSize; \
    DWORD i; \
    DWORD dwLeap; \
    INT16 *pDest = pSrc; \
\
    ASSERT( TSSND_NATIVE_SAMPLERATE >= _speed_ ); \
    ASSERT( TSSND_NATIVE_CHANNELS  == 2 ); \
\
    dwDstSize = dwSrcSize * _speed_ / \
                ( TSSND_NATIVE_BLOCKALIGN * TSSND_NATIVE_SAMPLERATE ); \
\
    for (i = 0, dwLeap = 0; \
         i < dwDstSize; \
         i ++) \
    { \
        INT sum; \
\
        sum = pSrc[0] + pSrc[1]; \
\
        if (sum > 0x7FFF) \
            sum = 0x7FFF; \
        if (sum < -0x8000) \
            sum = -0x8000; \
\
        pDest[0] = (INT16)sum; \
        pDest ++; \
\
        dwLeap += 2 * TSSND_NATIVE_SAMPLERATE; \
        pSrc += dwLeap / _speed_; \
        dwLeap %= _speed_; \
    } \
\
    *pdwDstSize = dwDstSize * 2; \
}

#define CONVERTFROMNATIVETOSTEREO(_speed_) \
VOID \
_Convert##_speed_##Stereo( \
    INT16 *pSrc, \
    DWORD dwSrcSize, \
    DWORD *pdwDstSize ) \
{ \
    DWORD dwDstSize; \
    DWORD i; \
    DWORD dwLeap; \
    INT16  *pDest = pSrc; \
\
    ASSERT( TSSND_NATIVE_SAMPLERATE >= _speed_ ); \
\
    dwDstSize = dwSrcSize * _speed_ / \
                ( TSSND_NATIVE_BLOCKALIGN * TSSND_NATIVE_SAMPLERATE ); \
    for (i = 0, dwLeap = 0; \
         i < dwDstSize; \
         i ++) \
    { \
        INT sum; \
\
        pDest[0] = pSrc[0]; \
        pDest ++; \
        pDest[0] = pSrc[1]; \
        pDest ++; \
\
        dwLeap += 2 * TSSND_NATIVE_SAMPLERATE; \
        pSrc += dwLeap / _speed_; \
        dwLeap %= _speed_; \
    } \
\
    *pdwDstSize = dwDstSize * 4; \
}

VOID
_Convert11025Mono( 
    INT16 *pSrc, 
    DWORD dwSrcSize, 
    DWORD *pdwDstSize )
{
    DWORD dwDstSize;
    INT16  *pDest = pSrc;

    ASSERT( TSSND_NATIVE_SAMPLERATE >= 11025 );

    dwDstSize = dwSrcSize / ( TSSND_NATIVE_BLOCKALIGN * 2 );

    *pdwDstSize = 2 * dwDstSize;

    for (; dwDstSize; dwDstSize --)
    {
        INT sum = pSrc[0] + pSrc[1];

        if (sum > 0x7FFF)
            sum = 0x7FFF;
        if (sum < -0x8000)
            sum = -0x8000;

        pDest[0] = (INT16)sum;
        pDest ++;

        pSrc += 4;
    }
}

VOID
_Convert22050Mono( 
    INT16 *pSrc, 
    DWORD dwSrcSize, 
    DWORD *pdwDstSize )
{
    DWORD dwDstSize;
    INT16  *pDest = pSrc;

    ASSERT( TSSND_NATIVE_SAMPLERATE >= 22050 );

    dwDstSize = dwSrcSize / ( TSSND_NATIVE_BLOCKALIGN );

    *pdwDstSize = 2 * dwDstSize;

    for (; dwDstSize; dwDstSize --)
    {
        INT sum = pSrc[0] + pSrc[1];

        if (sum > 0x7FFF)
            sum = 0x7FFF;
        if (sum < -0x8000)
            sum = -0x8000;

        pDest[0] = (INT16)sum;
        pDest ++;

        pSrc += 2;
    }
}

VOID
_Convert11025Stereo( 
    INT16 *pSrc, 
    DWORD dwSrcSize, 
    DWORD *pdwDstSize )
{
    DWORD dwDstSize;
    INT16  *pDest = pSrc;

    ASSERT( TSSND_NATIVE_SAMPLERATE >= 22050 );

    dwDstSize = dwSrcSize / ( TSSND_NATIVE_BLOCKALIGN * 2 );

    *pdwDstSize = 4 * dwDstSize;

    for (; dwDstSize; dwDstSize --)
    {
        pDest[0] = pSrc[0];
        pSrc  ++;
        pDest ++;
        pDest[0] = pSrc[0];
        pDest ++;
        pSrc  ++;

        pSrc += 2;
    }

}

//
// Make the actual code
//
CONVERTFROMNATIVETOMONO( 8000 )
CONVERTFROMNATIVETOMONO( 12000 )
CONVERTFROMNATIVETOMONO( 16000 )

CONVERTFROMNATIVETOSTEREO( 8000 )
CONVERTFROMNATIVETOSTEREO( 12000 )
CONVERTFROMNATIVETOSTEREO( 16000 )

#else
#pragma error
#endif

u_long
inet_addrW(
    LPCWSTR     szAddressW
    ) 
{

    CHAR szAddressA[32];

    *szAddressA = 0;
    WideCharToMultiByte(
        CP_ACP,
        0,
        szAddressW,
        -1,
        szAddressA,
        sizeof(szAddressA),
        NULL, NULL);

    return inet_addr(szAddressA);
}

/*
 *  create signature bits
 */
VOID
SL_Signature(
    PBYTE pSig,
    DWORD dwBlockNo
    )
{
    BYTE  ShaBits[A_SHA_DIGEST_LEN];
    A_SHA_CTX SHACtx;

    ASSERT( A_SHA_DIGEST_LEN > RDPSND_SIGNATURE_SIZE );

    A_SHAInit(&SHACtx);
    *((DWORD *)(g_EncryptKey + RANDOM_KEY_LENGTH)) = dwBlockNo;
    A_SHAUpdate(&SHACtx, (PBYTE)g_EncryptKey, sizeof(g_EncryptKey));
    A_SHAFinal(&SHACtx, ShaBits);
    memcpy( pSig, ShaBits, RDPSND_SIGNATURE_SIZE );
}

/*
 *  signature which verifies the audio bits
 */
VOID
SL_AudioSignature(
    PBYTE pSig,
    DWORD dwBlockNo,
    PBYTE pData,
    DWORD dwDataSize
    )
{
    BYTE ShaBits[A_SHA_DIGEST_LEN];
    A_SHA_CTX SHACtx;

    A_SHAInit(&SHACtx);
    *((DWORD *)(g_EncryptKey + RANDOM_KEY_LENGTH)) = dwBlockNo;
    A_SHAUpdate(&SHACtx, (PBYTE)g_EncryptKey, sizeof(g_EncryptKey));
    A_SHAUpdate(&SHACtx, pData, dwDataSize );
    A_SHAFinal(&SHACtx, ShaBits);
    memcpy( pSig, ShaBits, RDPSND_SIGNATURE_SIZE );
}

/*
 *  encrypt/decrypt a block of data
 *
 */
BOOL
SL_Encrypt( PBYTE pBits, DWORD BlockNo, DWORD dwBitsLen )
{
    BYTE  ShaBits[A_SHA_DIGEST_LEN];
    RC4_KEYSTRUCT rc4key;
    DWORD i;
    PBYTE pbBuffer;
    A_SHA_CTX SHACtx;
    DWORD   dw;
    DWORD_PTR   *pdwBits;

    A_SHAInit(&SHACtx);

    // SHA the bits
    *((DWORD *)(g_EncryptKey + RANDOM_KEY_LENGTH)) = BlockNo;
    A_SHAUpdate(&SHACtx, (PBYTE)g_EncryptKey, sizeof(g_EncryptKey));

    A_SHAFinal(&SHACtx, ShaBits);

    rc4_key(&rc4key, A_SHA_DIGEST_LEN, ShaBits);
    rc4(&rc4key, dwBitsLen, pBits);

    return TRUE;
}

BOOL
SL_SendKey( VOID )
{
    SNDCRYPTKEY Key;

    Key.Prolog.Type = SNDC_CRYPTKEY;
    Key.Prolog.BodySize = sizeof( Key ) - sizeof( Key.Prolog );
    Key.Reserved = 0;
    memcpy( Key.Seed, g_EncryptKey, sizeof( Key.Seed ));
    return ChannelBlockWrite( &Key, sizeof( Key ));
}

/*
 *  Function:
 *      _StatsCollect
 *
 *  Description:
 *      Collects statistics for the line quality
 *
 */
VOID
_StatsCollect(
    DWORD   dwTimeStamp
    )
{
    DWORD dwTimeDiff;

#if _DBG_STATS
    TRC(INF, "_StatsCollect: time now=%x, stamp=%x\n",
                GetTickCount() & 0xffff, 
                dwTimeStamp);
#endif

    dwTimeDiff = (( GetTickCount() & 0xffff ) - dwTimeStamp ) & 0xffff;
    
    //  it is possible to receive time stamp 
    // with time before the packet was sent,
    // this is because the client does adjusments to the time stamp
    // i.e. subtracts the time when the packet was played
    // catch and ignore this case
    //
    if ( dwTimeDiff > 0xf000 )
    {
        dwTimeDiff = 1;
    }

    if ( 0 == dwTimeDiff )
        dwTimeDiff = 1;

    if ( 0 == g_dwStatLatency )
        g_dwStatLatency = dwTimeDiff;
    else {
        //
        //  increase by 30%
        //
        g_dwStatLatency = (( 7 * g_dwStatLatency ) + ( 3 * dwTimeDiff )) / 10;
    }

    g_dwStatCount ++;
}

/*
 *  Function:
 *      _StatsSendPing
 *
 *  Description:
 *      Sends a ping packet to the client
 *
 */
VOID
_StatSendPing(
    VOID
    )
{
//
// send a ping request
//
    SNDTRAINING SndTraining;

    SndTraining.Prolog.Type = SNDC_TRAINING;
    SndTraining.Prolog.BodySize    = sizeof( SndTraining ) - 
                                        sizeof( SndTraining.Prolog );
    SndTraining.wTimeStamp   = (UINT16)GetTickCount();
    SndTraining.wPackSize    = 0;

    if ( INVALID_SOCKET != g_hDGramSocket &&
         0 != g_dwDGramPort &&
         0 != g_ulDGramAddress
        )
    {
        struct sockaddr_in sin;
        INT rc;

        sin.sin_family = PF_INET;
        sin.sin_port  = (u_short)g_dwDGramPort;
        sin.sin_addr.s_addr = g_ulDGramAddress;

        rc = sendto(
                g_hDGramSocket,
                (LPSTR)&SndTraining,
                sizeof( SndTraining ),
                0,
                (struct sockaddr *)&sin,           // to address
                sizeof(sin)
            );

        if (SOCKET_ERROR == rc)
        {
            TRC(ERR, "_StatsSendPing: sendto failed: %d\n",
                    WSAGetLastError());
        }
    } else {
        BOOL bSuccess;

        bSuccess = ChannelBlockWrite( &SndTraining, sizeof( SndTraining ));
        if (!bSuccess)
        {
            TRC(ERR, "_StatSendPing: ChannelBlockWrite failed: %d\n",
                GetLastError());
        }
    }
}

/*
 *  Function:
 *      _StatsCheckResample
 *
 *  Description:
 *      Looks in the statistics and eventually changes the current
 *      codec
 */
BOOL
_StatsCheckResample(
    VOID
    )
{
    BOOL  rv = FALSE;
    DWORD dwNewFmt;
    DWORD dwNewLatency;
    DWORD dwNewBandwidth;
    DWORD dwLatDiff;
    DWORD dwMsPerBlock;
    DWORD dwBlocksOnTheNet;
    DWORD dwCurrBandwith;

    if (( g_dwStatCount % STAT_COUNT ) == STAT_COUNT / 2 )
        _StatSendPing();

    if ( g_dwStatCount < STAT_COUNT )
        goto exitpt;

    if ( g_dwStatPing >= g_dwStatLatency )
        g_dwStatPing = g_dwStatLatency - 1;

    dwNewLatency = ( g_dwStatLatency - g_dwStatPing / 2 );

    if ( 0 == g_dwPacketSize )
    {
        TRC(INF, "_StatsCheckResample: invalid packet size\n");
        goto resetpt;
    }

    dwNewBandwidth = g_dwPacketSize * 1000 / dwNewLatency;

    if ( 0 == dwNewBandwidth )
    {
        TRC(INF, "_StatsCheckResample: invalid bandwidth\n");
        goto resetpt;
    }

    TRC(INF, "_StatsCheckResample: latency=%d, bandwidth=%d\n",
            dwNewLatency, dwNewBandwidth );
    //
    //  g_dwBlocksOnTheNet is the latency in number of blocks
    //
    dwMsPerBlock = TSSND_BLOCKSIZE * 1000 / TSSND_NATIVE_AVGBYTESPERSEC;
    dwBlocksOnTheNet = ((g_dwStatLatency + dwMsPerBlock / 2) / dwMsPerBlock + 2);
    if ( dwBlocksOnTheNet > TSSND_BLOCKSONTHENET )
    {
        g_dwBlocksOnTheNet = TSSND_BLOCKSONTHENET;
    } else {
        g_dwBlocksOnTheNet = dwBlocksOnTheNet;
    }
    TRC( INF, "BlocksOnTheNet=%d\n", g_dwBlocksOnTheNet );

    //
    //  check for at least 10% difference in the bandwidth
    //
    if ( dwNewBandwidth > g_dwMaxBandwidth )
        dwNewBandwidth = g_dwMaxBandwidth;

    if ( dwNewBandwidth < g_dwMinBandwidth )
        dwNewBandwidth = g_dwMinBandwidth;

    dwCurrBandwith = ( NULL != g_ppNegotiatedFormats[ g_dwCurrentFormat ] )?
                        g_ppNegotiatedFormats[ g_dwCurrentFormat ]->nAvgBytesPerSec:
                        g_dwLineBandwidth;

    if ( dwCurrBandwith > dwNewBandwidth )
        dwLatDiff = dwCurrBandwith - dwNewBandwidth;
    else
        dwLatDiff = dwNewBandwidth - dwCurrBandwith;

    if ( dwLatDiff < g_dwCodecChangeThreshold * dwCurrBandwith / 100 )
        goto resetpt;

    //
    //  increment the threshold up to 50%
    //
    if ( g_dwCodecChangeThreshold < 50 )
    {
        g_dwCodecChangeThreshold += 5;
    }
    //
    //  try to choose another format
    //
    dwNewFmt = _VCSndChooseProperFormat( dwNewBandwidth );

    if ( (DWORD)-1 != dwNewFmt &&
         dwNewFmt  != g_dwCurrentFormat )
    {
        INT   step;
        DWORD dwNextFmt;
        //
        //  don't jump directly to the new format, just move
        //  towards it
        //
        step = ( dwNewFmt > g_dwCurrentFormat )?1:-1;
        dwNextFmt = g_dwCurrentFormat + step;
        while( dwNextFmt != dwNewFmt &&
               NULL == g_ppNegotiatedFormats[dwNextFmt] )
        {
            dwNextFmt += step;
        }
        dwNewFmt = dwNextFmt;
    }

    if ( dwNewFmt == (DWORD)-1 ||
         dwNewFmt == g_dwCurrentFormat )
        goto resetpt;

    TRC(INF, "_StatsCheckResample: new bandwidth=%d resampling\n",
            dwNewBandwidth);

    //
    //  resample, NOW
    //
    _VCSndCloseConverter();

    if ( _VCSndGetACMDriverId( g_ppNegotiatedFormats[dwNewFmt] ))
    {

        g_dwLineBandwidth = dwNewBandwidth;
        g_dwCurrentFormat = dwNewFmt;

        g_dwDataRemain = 0;
    }
    _VCSndOpenConverter();

    rv = TRUE;

resetpt:
    g_dwStatLatency  = 0;
    g_dwStatCount    = 0;

exitpt:
    return rv;
}

/*
 *  Function:
 *      _StatReset
 *
 *  Description:
 *      Resets the statistics
 *
 */
VOID
_StatReset(
    VOID
    )
{
    g_dwStatLatency = 0;
    g_dwStatPing    = 0;
    g_dwStatCount   = STAT_COUNT_INIT;
}

/*
 *  Function:
 *      ChannelOpen
 *
 *  Description:
 *      Opens the virtual channel
 *
 *
 */
BOOL
ChannelOpen(
    VOID
    )
{
    BOOL    rv = FALSE;

    
    if (!g_hVC)
        g_hVC = WinStationVirtualOpen(
                    NULL,
                    LOGONID_CURRENT,
                    _SNDVC_NAME
                );

    rv = (g_hVC != NULL);

    return rv;

}

/*
 *  Function:
 *      ChannelClose
 *
 *  Description:
 *      Closes the virtual channel
 */
VOID
ChannelClose(
    VOID
    )
{

    if (g_hVC)
    {
        CloseHandle(g_hVC);
        g_hVC = NULL;
    }

    g_uiBytesInBuffer   = 0;
    g_uiBufferOffset    = 0;
}

/*
 *  Function:
 *      ChannelBlockWrite
 *
 *  Description:
 *      Writes a block thru the virtual channel
 *
 */
BOOL
ChannelBlockWrite(
    PVOID   pBlock,
    ULONG   ulBlockSize
    )
{
    BOOL    bSuccess = TRUE;
    PCHAR   pData = (PCHAR) pBlock;
    ULONG   ulBytesWritten;
    ULONG   ulBytesToWrite = ulBlockSize;
    HANDLE  hVC;

    hVC = g_hVC;
    if (!hVC)
    {
        TRC(ERR, "ChannelBlockWrite: vc handle is NULL\n");
        bSuccess = FALSE;
        goto exitpt;
    }

    while (bSuccess && ulBytesToWrite)
    {
        OVERLAPPED  Overlapped;

        Overlapped.hEvent = NULL;
        Overlapped.Offset = 0;
        Overlapped.OffsetHigh = 0;

        bSuccess = WriteFile(
                        hVC,
                        pData,
                        ulBytesToWrite,
                        &ulBytesWritten,
                        &Overlapped
                    );

        if (!bSuccess && ERROR_IO_PENDING == GetLastError())
            bSuccess = GetOverlappedResult(
                                    hVC,
                                    &Overlapped,
                                    &ulBytesWritten,
                                    TRUE);

        if (bSuccess)
        {
            TRC(ALV, "VirtualChannelWrite: Wrote %d bytes\n",
                     ulBytesWritten);
            ulBytesToWrite -= ulBytesWritten;
            pData       += ulBytesWritten;
        } else {
            TRC(ERR, "VirtualChannelWrite failed, GetLastError=%d\n",
                     GetLastError());
        }
    }

exitpt:

    return bSuccess;
}

/*
 *  Function:
 *      ChannelMessageWrite
 *
 *  Description:
 *      Writes a two pieces message as a single one (uses ChannelBlockWrite)
 *
 */
BOOL
ChannelMessageWrite(
    PVOID   pProlog,
    ULONG   ulPrologSize,
    PVOID   pBody,
    ULONG   ulBodySize
    )
{
    BOOL rv = FALSE;

    if ( 0 != ulBodySize )
    {
        //
        //  create a new prolog message
        //  in which a UINT32 word is added at the end
        //  this word is the same as the first word of the prolog
        //  the client is aware of this and will reconstruct
        //  to the correct messages
        //
        PVOID pNewProlog;


        __try {
            pNewProlog = alloca( ulPrologSize + sizeof(UINT32) );
        } __except((EXCEPTION_STACK_OVERFLOW == GetExceptionCode()) ?
                    EXCEPTION_EXECUTE_HANDLER :
                    EXCEPTION_CONTINUE_SEARCH)

        {
            _resetstkoflw();
            pNewProlog = NULL;
        }

        if ( NULL == pNewProlog )
        {
            TRC(ERR, "ChannelMessageWrite: alloca failed for %d bytes\n",
                ulPrologSize + sizeof(UINT32) );
            goto exitpt;
        }

        memcpy(pNewProlog, pProlog, ulPrologSize);

        // replace the word, put SNDC_NONE in the body
        //
        ASSERT( ulBodySize >= sizeof(UINT32));

        *(DWORD *)(((LPSTR)pNewProlog) + ulPrologSize) =
                *(DWORD *)pBody;
        *(DWORD *)pBody = SNDC_NONE;

        pProlog = pNewProlog;
        ulPrologSize += sizeof(UINT32);
    }

    rv = ChannelBlockWrite(
            pProlog,
            ulPrologSize
        );
    
    if (!rv)
    {
        TRC(ERR, "ChannelMessageWrite: failed while sending the prolog\n");
        goto exitpt;
    }

    rv = ChannelBlockWrite(
            pBody,
            ulBodySize
        );

    if (!rv)
    {
        TRC(ERR, "ChannelMessageWrite: failed while sending the body\n");
    }
exitpt:

    return rv;
}

/*
 *  Function:
 *      ChannelBlockRead
 *
 *  Description:
 *      Read a block, as much as possible
 *
 */
BOOL
ChannelBlockRead(
    PVOID   pBlock,
    ULONG   ulBlockSize,
    ULONG   *pulBytesRead,
    ULONG   ulTimeout,
    HANDLE  hEvent
    )
{
    BOOL    bSuccess = FALSE;
    PCHAR   pData = (PCHAR) pBlock;
    ULONG   ulBytesRead = 0;
    HANDLE  hVC;

    hVC = g_hVC;

    if (NULL == hVC)
    {
        TRC(ERR, "ChannelBlockRead: vc handle is invalid(NULL)\n");
        goto exitpt;
    }

    if (NULL == pulBytesRead)
    {
        TRC(ERR, "ChannelBlockRead: pulBytesRead is NULL\n");
        goto exitpt;
    }

    if (!g_uiBytesInBuffer)
    {

        g_OverlappedRead.hEvent = hEvent;
        g_OverlappedRead.Offset = 0;
        g_OverlappedRead.OffsetHigh = 0;

        bSuccess = ReadFile(
                        hVC,
                        g_Buffer,
                        sizeof(g_Buffer),
                        (LPDWORD) &g_uiBytesInBuffer,
                        &g_OverlappedRead
                    );
                        
        if (ERROR_IO_PENDING == GetLastError())
        {
            bSuccess = FALSE;
            goto exitpt;
        }

        if (!bSuccess)
        {

            TRC(ERR, "VirtualChannelRead failed, "
                     "GetLastError=%d\n", 
                     GetLastError());
            g_uiBytesInBuffer = 0;
        } else {

            TRC(ALV, "VirtualChannelRead: read %d bytes\n", 
                     g_uiBytesInBuffer);


            SetLastError(ERROR_SUCCESS);
        }
    }

    if (g_uiBytesInBuffer)
    {
        ulBytesRead = (g_uiBytesInBuffer < ulBlockSize)
                        ?   g_uiBytesInBuffer :   ulBlockSize;

        memcpy(pData, g_Buffer + g_uiBufferOffset, ulBytesRead);
        g_uiBufferOffset += ulBytesRead;
        g_uiBytesInBuffer -= ulBytesRead;

        bSuccess = TRUE;
    }

    // if the buffer is completed, zero the offset
    //
    if (0 == g_uiBytesInBuffer)
        g_uiBufferOffset = 0;

    TRC(ALV, "ChannelBlockRead: block size %d was read\n", ulBlockSize);

exitpt:
    if (NULL != pulBytesRead)
        *pulBytesRead = ulBytesRead;

    return bSuccess;
}

/*
 *  Function:
 *      ChannelBlockReadComplete
 *
 *  Description:
 *      Read completion
 *
 */
BOOL
ChannelBlockReadComplete(
    VOID
    )
{
    BOOL bSuccess = FALSE;

    if (!g_hVC)
    {
        TRC(ERR, "ChannelBlockReadComplete: vc handle is invalid(NULL)\n");
        goto exitpt;
    }

    
    bSuccess = GetOverlappedResult(
            g_hVC, 
            &g_OverlappedRead, 
            (LPDWORD) &g_uiBytesInBuffer,
            FALSE
    );

    if (bSuccess)
    {
        TRC(ALV, "VirtualChannelRead: read %d bytes\n",
            g_uiBytesInBuffer);
        ;
    } else {
        TRC(ERR, "GetOverlappedResult failed, "
            "GetLastError=%d\n",
            GetLastError());
    }

exitpt:
    return bSuccess;
}

/*
 *  Function:
 *      ChannelCancelIo
 *
 *  Description:
 *      Cancel the current IO
 *
 */
BOOL
ChannelCancelIo(
    VOID
    )
{
    BOOL rv = FALSE;

    if (!g_hVC)
    {
        TRC(ERR, "ChannelCancelIo: vc handle is invalid(NULL)\n");
        goto exitpt;
    }

    rv = CancelIo(g_hVC);
    if (rv)
        SetLastError(ERROR_IO_INCOMPLETE);

exitpt:
    return rv;
}

/*
 *  Function:
 *      ChannelReceiveMessage
 *
 *  Description:
 *      Attempts to read two piece message,
 *      returns TRUE if the whole message is received
 *
 */
BOOL
ChannelReceiveMessage(
    PSNDMESSAGE pSndMessage, 
    HANDLE hReadEvent
    )
{
    BOOL    rv = FALSE;
    HANDLE  hVC = g_hVC;
    UINT    uiBytesReceived = 0;

    ASSERT( NULL != pSndMessage );
    ASSERT( NULL != hReadEvent );

    if (NULL == hVC)
    {
        TRC(ERR, "ChannelReceiveMessage: VC is NULL\n");
        goto exitpt;
    }

    //
    //  loop until PENDING or message is received
    //
    do {
        if (pSndMessage->uiPrologReceived < sizeof(pSndMessage->Prolog))
        {
            if (ChannelBlockRead(
                    ((LPSTR)(&pSndMessage->Prolog)) + 
                        pSndMessage->uiPrologReceived,
                    sizeof(pSndMessage->Prolog) - 
                        pSndMessage->uiPrologReceived,
                    (ULONG*) &uiBytesReceived,
                    DEFAULT_VC_TIMEOUT,
                    hReadEvent
                    ))
            {
                pSndMessage->uiPrologReceived += uiBytesReceived;
            }
            else
            {
                if (ERROR_IO_PENDING != GetLastError())
                {
            //  Perform cleanup
            //
                   pSndMessage->uiPrologReceived = 0;
                }
                goto exitpt;
            }
        }

        //  Reallocate a new body if needed
        //
        if (pSndMessage->uiBodyAllocated < pSndMessage->Prolog.BodySize)
        {
            PVOID pBody;

            pBody = (NULL == pSndMessage->pBody)?
                    TSMALLOC(pSndMessage->Prolog.BodySize):
                    TSREALLOC(pSndMessage->pBody, 
                              pSndMessage->Prolog.BodySize);

            if ( NULL == pBody  && NULL != pSndMessage->pBody )
            {
                TSFREE( pSndMessage->pBody );
            }
            pSndMessage->pBody = pBody;

            if (!pSndMessage->pBody)
            {
                TRC(ERR, "ChannelMessageRead: can't allocate %d bytes\n",
                        pSndMessage->Prolog.BodySize);
                pSndMessage->uiBodyAllocated = 0;
                goto exitpt;
            } else
                pSndMessage->uiBodyAllocated = pSndMessage->Prolog.BodySize;
        }

        //  Receive the body
        //
        if (pSndMessage->uiBodyReceived < pSndMessage->Prolog.BodySize)
        {
            if (ChannelBlockRead(
                ((LPSTR)(pSndMessage->pBody)) + pSndMessage->uiBodyReceived,
                pSndMessage->Prolog.BodySize - pSndMessage->uiBodyReceived,
                (ULONG*) &uiBytesReceived,
                DEFAULT_VC_TIMEOUT,
                hReadEvent
                ))
            {
                pSndMessage->uiBodyReceived += uiBytesReceived;
            }
            else
            {
                if (ERROR_IO_PENDING != GetLastError())
                {
                //  Perform cleanup
                //
                    pSndMessage->uiPrologReceived = 0;
                    pSndMessage->uiBodyReceived = 0;
                }
                goto exitpt;
            }
        }

        // check if the message is received
        //
    } while (pSndMessage->uiBodyReceived != pSndMessage->Prolog.BodySize);

    rv = TRUE;

exitpt:
    return rv;
}

/*
 *  Function:
 *      VCSndDataArrived
 *
 *  Description:
 *      Arrived message demultiplexer
 *
 */
VOID
VCSndDataArrived(
    PSNDMESSAGE pSndMessage
    )
{
    if (pSndMessage->Prolog.BodySize &&
        NULL == pSndMessage->pBody)
    {
        TRC(ERR, "_VCSndDataArrived: pBody is NULL\n");
        goto exitpt;
    }

    // first, get the stream
    //
    if (!VCSndAcquireStream())
        {
            TRC(FATAL, "VCSndDataArrived: somebody is holding the "
                       "Stream mutext for too long\n");
            ASSERT(0);
            goto exitpt;
        }

    switch (pSndMessage->Prolog.Type)
    {

    case SNDC_WAVECONFIRM:
    {
        PSNDWAVECONFIRM pSndConfirm;

        if ( pSndMessage->Prolog.BodySize <
             sizeof( *pSndConfirm ) - sizeof( SNDPROLOG ))
        {
            TRC( ERR, "VCSndDataArrived: Invalid confirmation received\n" );
            break;
        }

        pSndConfirm = (PSNDWAVECONFIRM)
                        (((LPSTR)pSndMessage->pBody) - 
                            sizeof(pSndMessage->Prolog));

        _StatsCollect( pSndConfirm->wTimeStamp );

        TRC(ALV, "VCSndDataArrived: SNDC_WAVECONFIRM, block no %d\n",
                pSndConfirm->cConfirmedBlockNo);

        if ( (BYTE)(g_Stream->cLastBlockSent -
                pSndConfirm->cConfirmedBlockNo) > TSSND_BLOCKSONTHENET )
        {
            TRC(WRN, "VCSndDataArrived: confirmation for block #%d "
                     "which wasn't sent. Last sent=%d. DROPPING !!!\n",
                    pSndConfirm->cConfirmedBlockNo,
                    g_Stream->cLastBlockSent);
            break;
        }

        if ( (BYTE)(pSndConfirm->cConfirmedBlockNo -
                g_Stream->cLastBlockConfirmed) < TSSND_BLOCKSONTHENET )
        {

            // move the mark
            //
            g_Stream->cLastBlockConfirmed = pSndConfirm->cConfirmedBlockNo + 1;
        } else {
            TRC(WRN, "VCSndDataArrived: difference in confirmed blocks "
                    "last=%d, this one=%d\n",
                    g_Stream->cLastBlockConfirmed,
                    pSndConfirm->cConfirmedBlockNo
                    );
        }

        PulseEvent(g_hStreamIsEmptyEvent);
    }
    break;

    case SNDC_TRAINING:
    {
        PSNDTRAINING pSndTraining;
        DWORD        dwLatency;

        if ( pSndMessage->Prolog.BodySize < 
                sizeof ( *pSndTraining ) - sizeof ( pSndTraining->Prolog ))
        {
            TRC(ERR, "VCSndDataArrived: SNDC_TRAINING invalid length "
                     "for the body=%d\n",
                    pSndMessage->Prolog.BodySize );
            break;
        }

        pSndTraining = (PSNDTRAINING)
                        (((LPSTR)pSndMessage->pBody) -
                            sizeof(pSndMessage->Prolog));

        if ( 0 != pSndTraining->wPackSize )
        {
            TRC(INF, "VCSndDataArrived: SNDC_TRAINING received (ignoring)\n");
            //
            //  these type of messages are handled
            //  in _VCSndLineVCTraining(), bail out
            //
            break;
        }
        dwLatency = (GetTickCount() & 0xffff) - pSndTraining->wTimeStamp;

        TRC(INF, "VCSndDataArrived: SNDC_TRAINING Latency=%d\n",
            dwLatency );

        //
        //  increase by 30%
        //
        if ( 0 == g_dwStatPing )
            g_dwStatPing = dwLatency;
        else
            g_dwStatPing = (( 7 * g_dwStatPing ) + ( 3 * dwLatency )) / 10;
    }
    break;

    case SNDC_FORMATS:
        //
        //  this is handled in VCSndNegotiateWaveFormat()
        //
        TRC(INF, "VCSndDataArrived: SNDC_FORMATS reveived (ignoring)\n");
    break;

    default:
        {
            TRC(ERR, "_VCSndDataArrived: unknow message received: %d\n",
                pSndMessage->Prolog.Type);
            ASSERT(0);
        }
    }

    VCSndReleaseStream();

exitpt:
    ;
}

/*
 *  Function:
 *      VCSndAcquireStream
 *
 *  Description:
 *      Locks the stream
 *
 */
BOOL
VCSndAcquireStream(
    VOID
    )
{
    BOOL    rv = FALSE;
    DWORD   dwres;

    if (NULL == g_hStream ||
        NULL == g_Stream)
    {
        TRC(FATAL, "VCSndAcquireStream: the stream handle is NULL\n");
        goto exitpt;
    }

    if (NULL == g_hStreamMutex)
    {
        TRC(FATAL, "VCSndAcquireStream: the stream mutex is NULL\n");
        goto exitpt;
    }

    dwres = WaitForSingleObject(g_hStreamMutex, DEFAULT_VC_TIMEOUT);
    if (WAIT_TIMEOUT == dwres ||
         WAIT_ABANDONED == dwres )
    {
        TRC(ERR, "VCSndAcquireStream: "
                 "timed out waiting for the stream mutex or owner crashed=%d\n", dwres );
        //
        // possible app crash
        //
        ASSERT(0);
        goto exitpt;
    }

    rv = TRUE;

exitpt:
    return rv;
}

/*
 *  Function:
 *      VCSndReleaseStream
 *
 *  Description:
 *      Release the stream data
 *
 */
BOOL
VCSndReleaseStream(
    VOID
    )
{
    BOOL rv = TRUE;

    ASSERT(NULL != g_hStream);
    ASSERT(NULL != g_Stream);
    ASSERT(NULL != g_hStreamMutex);

    if (!ReleaseMutex(g_hStreamMutex))
        rv = FALSE;

    return rv;
}

/*
 *  Function:
 *      _DGramOpen
 *
 *  Description:
 *      Opens a datagram socket
 *
 */
VOID
_DGramOpen(
    VOID
    )
{
    // create a datagram socket if needed
    //
    if (INVALID_SOCKET == g_hDGramSocket)
    {
        g_hDGramSocket = socket(AF_INET, SOCK_DGRAM, 0);

        if (INVALID_SOCKET == g_hDGramSocket)
            TRC(ERR, "_DGramOpen: failed to crate dgram socket: %d\n",
                WSAGetLastError());
        else
            TRC(ALV, "_DGramOpen: datagram socket created\n");
    }

    // get the max datagram size
    //
    if (INVALID_SOCKET != g_hDGramSocket)
    {
        UINT optval = 0;
        UINT optlen = sizeof(optval);

        getsockopt(g_hDGramSocket, 
                   SOL_SOCKET,
                   SO_MAX_MSG_SIZE,
                   (LPSTR)(&optval),
                   (int *) &optlen);

        TRC(ALV, "_DGramOpen: max allowed datagram: %d\n",
                optval);

        optval = (optval < TSSND_BLOCKSIZE)?optval:TSSND_BLOCKSIZE;

        // align the dgram to DWORD
        //
        optval /= sizeof(DWORD);
        optval *= sizeof(DWORD);

        if ( optval < RDPSND_MIN_FRAG_SIZE )
        {
            g_dwDGramSize = 0;
        } else if ( optval < g_dwDGramSize )
        {
            g_dwDGramSize = optval;
            TRC( INF, "DGram size downgraded to %d\n", g_dwDGramSize );
        }

        TRC(ALV, "_DGramOpen: max datagram size: %d\n",
                optval);

        // get client's ip address
        //
        {
            WINSTATIONCLIENT ClientData;
            ULONG            ulReturnLength;
            BOOL             rc;
            u_long           ulDGramClientAddress;

            rc = WinStationQueryInformation(
                        SERVERNAME_CURRENT,
                        LOGONID_CURRENT,
                        WinStationClient,
                        &ClientData,
                        sizeof(ClientData),
                        &ulReturnLength);
            if (rc)
            {
                g_EncryptionLevel = ClientData.EncryptionLevel;
                if (PF_INET == ClientData.ClientAddressFamily)
                {
                    TRC(ALV, "_VCSndSendOpenDevice: client address is: %S\n",
                            ClientData.ClientAddress);

                    ulDGramClientAddress = inet_addrW(ClientData.ClientAddress);
                    if (INADDR_NONE != ulDGramClientAddress)
                        g_ulDGramAddress = ulDGramClientAddress;
                    else
                        TRC(ERR, "_VCSndSendOpenDevice: client address is NONE\n");
                }
                else
                    TRC(ERR, "_VCSndSendOpenDevice: "
                             "Invalid address family: %d\n",
                                ClientData.ClientAddressFamily);

            } else
                TRC(ERR, "_VCSndSendOpenDevice: "
                         "WinStationQueryInformation failed. %d\n",
                        GetLastError());
        }
    }

}

VOID
_FillWithGarbage(
    PVOID   pBuff,
    DWORD   dwSize
    )
{
    PBYTE pbBuff = (PBYTE)pBuff;

    for ( ; dwSize; pbBuff++, dwSize-- )
    {
        pbBuff[0] = (BYTE)rand();
    }
}

/*
 *  Function:
 *      _VCSndReadRegistry
 *
 *  Description:
 *      Reads current options
 */
VOID
_VCSndReadRegistry(
    VOID
    )
{
    DWORD rv = (DWORD) -1;
    DWORD sysrc;
    HKEY  hkey = NULL;
    DWORD dwKeyType;
    DWORD dwKeyLen;
    WINSTATIONCONFIG config;
    ULONG Length = 0;
    DWORD dw;

    sysrc = RegOpenKeyEx(  HKEY_LOCAL_MACHINE,
                           TSSND_REG_MAXBANDWIDTH_KEY,
                           0,       // reserved
                           KEY_READ,
                           &hkey);

    if ( ERROR_SUCCESS != sysrc )
    {
        TRC(WRN, "_VCSndReadRegistry: "
                 "RegOpenKeyEx failed: %d\n", 
                sysrc );
        goto exitpt;
    }

    dwKeyType = REG_DWORD;
    dwKeyLen  = sizeof( rv );
    sysrc = RegQueryValueEx( hkey,
                             TSSND_REG_MAXBANDWIDTH_VAL,
                             NULL,      // reserved
                             &dwKeyType,
                             (LPBYTE)&rv,
                             &dwKeyLen);

    if ( ERROR_SUCCESS != sysrc )
    {
        TRC(WRN, "_VCSndReadRegistry: "
                 "RegQueryValueEx failed: %d\n",
                    sysrc );
    } else {
        g_dwMaxBandwidth = rv;
    }

    sysrc = RegQueryValueEx( hkey,
                             TSSND_REG_MINBANDWIDTH_VAL,
                             NULL,      // reserved
                             &dwKeyType,
                             (LPBYTE)&rv,
                             &dwKeyLen);

    if ( ERROR_SUCCESS != sysrc )
    {
        TRC(ALV, "_VCSndReadRegistry: "
                 "RegQueryValueEx failed: %d\n",
                    sysrc );
    } else {
        g_dwMinBandwidth = rv;
    }

    sysrc = RegQueryValueEx( hkey,
                             TSSND_REG_DISABLEDGRAM_VAL,
                             NULL,      // reserved
                             &dwKeyType,
                             (LPBYTE)&rv,
                             &dwKeyLen);

    if ( ERROR_SUCCESS != sysrc )
    {
        TRC(ALV, "_VCSndReadRegistry: "
                 "RegQueryValueEx failed: %d\n",
                    sysrc );
    } else {
        g_dwDisableDGram = rv;
    }

    sysrc = RegQueryValueEx( hkey,
                             TSSND_REG_ENABLEMP3_VAL,
                             NULL,      // reserved
                             &dwKeyType,
                             (LPBYTE)&rv,
                             &dwKeyLen);

    if ( ERROR_SUCCESS != sysrc )
    {
        TRC(WRN, "_VCSndReadRegistry: "
                 "RegQueryValueEx failed: %d\n",
                    sysrc );
    } else {
        g_dwEnableMP3Codec = rv;
    }

    sysrc = RegQueryValueEx( hkey,
                             TSSND_REG_MAXDGRAM,
                             NULL,
                             &dwKeyType,
                             (LPBYTE)&rv,
                             &dwKeyLen );
    if ( ERROR_SUCCESS != sysrc )
    {
        TRC( WRN, "_VCSndReadRegistry: "
                  "RegQueryValueEx failed for \"%s\": %d\n",
                    TSSND_REG_MAXDGRAM, sysrc );
    } else {
        if ( rv < g_dwDGramSize && rv >= RDPSND_MIN_FRAG_SIZE )
        {
            g_dwDGramSize = rv;
            TRC( INF, "DGram size forced to %d\n", g_dwDGramSize );
        }
    }

    dwKeyLen  = 0;
    sysrc = RegQueryValueEx( hkey,
                             TSSND_REG_ALLOWCODECS,
                             NULL,
                             &dwKeyType,
                             NULL,
                             &dwKeyLen );
    if ( ERROR_MORE_DATA != sysrc || REG_BINARY != dwKeyType )
    {
        TRC( ALV, "_VCSndReadRegistry: "
                  "RegQueryValueEx failed for AllowCodecs: %d\n",
                  sysrc );
    } else {
        if ( NULL != g_AllowCodecs )
            TSFREE( g_AllowCodecs );
        g_AllowCodecs = (DWORD *)TSMALLOC( dwKeyLen );
        if ( NULL == g_AllowCodecs )
        {
            TRC( WRN, "_VCSndReadRegistry: "
                      "malloc failed for %d bytes\n",
                      dwKeyLen );
        } else {
            sysrc = RegQueryValueEx( hkey,
                                     TSSND_REG_ALLOWCODECS,
                                     NULL,
                                     &dwKeyType,
                                     (LPBYTE)g_AllowCodecs,
                                     &dwKeyLen );
            if ( ERROR_SUCCESS != sysrc )
            {
                TRC( WRN, "_VCSndReadRegistry: "
                          "RegQueryValueEx failed: %d\n",
                          sysrc );
                TSFREE( g_AllowCodecs );
                g_AllowCodecs = NULL;
                g_AllowCodecsSize = 0;
            } else {
                g_AllowCodecsSize = dwKeyLen;
            }
        }
    }

exitpt:
    if ( NULL != hkey )
        RegCloseKey( hkey );

}

/*
 *  Function:
 *      _VCSndLineVCTraining
 *
 *  Description:
 *      Meassures the line speed thru the virtual channel
 *
 */
DWORD
_VCSndLineVCTraining(
    HANDLE  hReadEvent
    )
{
    PSNDTRAINING        pSndTraining;
    SNDMESSAGE          SndMessage;
    DWORD               dwSuggestedBaudRate;
    DWORD               dwLatency;
    PSNDTRAINING        pSndTrainingResp;


    memset(&SndMessage, 0, sizeof(SndMessage));

    dwLatency = 0;

    if (NULL == hReadEvent)
    {
        TRC(ERR, "_VCSndLineVCTraining: hReadEvent is NULL\n");
        goto exitpt;
    }

    __try
    {
        pSndTraining = (PSNDTRAINING) alloca( TSSND_TRAINING_BLOCKSIZE );
    } __except((EXCEPTION_STACK_OVERFLOW == GetExceptionCode()) ?
                    EXCEPTION_EXECUTE_HANDLER :
                    EXCEPTION_CONTINUE_SEARCH)
    {
        _resetstkoflw();
        pSndTraining = NULL;
    }

    if (NULL == pSndTraining)
    {
        TRC(ERR, "_VCSndLineVCTraining: can't alloca %d bytes\n",
            TSSND_TRAINING_BLOCKSIZE);
        goto exitpt;
    }

    _FillWithGarbage( pSndTraining, TSSND_TRAINING_BLOCKSIZE);
    pSndTraining->Prolog.Type = SNDC_TRAINING;
    pSndTraining->Prolog.BodySize = TSSND_TRAINING_BLOCKSIZE -
                                    sizeof (pSndTraining->Prolog);

    pSndTraining->wTimeStamp = (UINT16)GetTickCount();
    pSndTraining->wPackSize  = (UINT16)TSSND_TRAINING_BLOCKSIZE;

    //
    //  send the packet
    //
    if (!ChannelBlockWrite(pSndTraining, TSSND_TRAINING_BLOCKSIZE))
    {
        TRC(ERR, "_VCSndLineVCTraining: failed to send a block: %d\n",
                GetLastError());
        goto exitpt;
    }

    //
    // wait for response to arrive
    //
    do {
        SndMessage.uiPrologReceived = 0;
        SndMessage.uiBodyReceived = 0;

        while(!ChannelReceiveMessage(&SndMessage, hReadEvent))
        {
            if (ERROR_IO_PENDING == GetLastError())
            {
                DWORD dwres;
                HANDLE ahEvents[2];

                ahEvents[0] = hReadEvent;
                ahEvents[1] = g_hDisconnectEvent;
                dwres = WaitForMultipleObjects( 
                            sizeof(ahEvents)/sizeof(ahEvents[0]), // count
                            ahEvents,                             // events
                            FALSE,                                // wait all
                            DEFAULT_RESPONSE_TIMEOUT);

                if (WAIT_TIMEOUT == dwres ||
                    WAIT_OBJECT_0 + 1 == dwres)
                {
                    TRC(WRN, "_VCSndLineVCTraining: timeout "
                             "waiting for response\n");
                    ChannelCancelIo();
                    ResetEvent(hReadEvent);
                    goto exitpt;
                }

                ChannelBlockReadComplete();
                ResetEvent(hReadEvent);
            } else
            if (ERROR_SUCCESS != GetLastError())
            {
                TRC(ERR, "_VCSndLineVCTraining: "
                         "ChannelReceiveMessage failed: %d\n",
                    GetLastError());
                goto exitpt;
            }
        }
    } while ( SNDC_TRAINING != SndMessage.Prolog.Type ||
              sizeof(SNDTRAINING) - sizeof(SNDPROLOG) <
              SndMessage.Prolog.BodySize);

    TRC(ALV, "_VCSndLineVCTraining: response received\n");

    pSndTrainingResp = (PSNDTRAINING)
                    (((LPSTR)SndMessage.pBody) -
                        sizeof(SndMessage.Prolog));

    //
    // calculate latency (nonzero)
    //
    dwLatency = ((WORD)GetTickCount()) - pSndTrainingResp->wTimeStamp + 1;

exitpt:

    TRC(INF, "_VCSndLineVCTraining: dwLatency = %d\n",
                dwLatency);

    if (0 != dwLatency)
    {
        //
        // the latency is in miliseconds, so compute it bytes per seconds
        // and get nonzero result
        //
        dwSuggestedBaudRate = 1 + (1000 * ( pSndTrainingResp->wPackSize +
                                        sizeof( *pSndTraining ))
                                  / dwLatency);
    }
    else
        dwSuggestedBaudRate = 0;

    TRC(INF, "_VCSndLineVCTraining: dwSuggestedBaudRate = %d\n",
                dwSuggestedBaudRate);

    if (NULL != SndMessage.pBody)
        TSFREE(SndMessage.pBody);

    return dwSuggestedBaudRate;
}

/*
 *  Function:
 *      _VCSndLineDGramTraining
 *
 *  Description:
 *      Meassures the line speed thru UDP channel
 *
 */
DWORD
_VCSndLineDGramTraining(
    HANDLE  hDGramEvent
    )
{
    PSNDTRAINING        pSndTraining;
    PSNDTRAINING        pSndTrainingResp;
    struct sockaddr_in  sin;
    DWORD               dwRetries;
    DWORD               dwSuggestedBaudRate;
    DWORD               dwDGramLatency = 0;
    INT                 sendres;
    DWORD               dwPackSize;
    DWORD               dwRespSize;

    dwDGramLatency = 0;

    if (NULL == hDGramEvent)
    {
        TRC(ERR, "_VCSndLineDGramTraining: hDGramEvent is NULL\n");
        goto exitpt;
    }

    if (INVALID_SOCKET == g_hDGramSocket ||
        0 == g_dwDGramPort ||
        g_dwDGramSize < sizeof(*pSndTraining) ||
        0 == g_ulDGramAddress)
    {
        TRC(ERR, "_VCSndLineDGramTraining: no dgram support. Can't train the line\n");
        goto exitpt;
    }

    dwPackSize = ( g_dwDGramSize < TSSND_TRAINING_BLOCKSIZE )?
                    g_dwDGramSize:
                    TSSND_TRAINING_BLOCKSIZE;
    __try 
    {
        pSndTraining = (PSNDTRAINING) alloca( dwPackSize );
    } __except((EXCEPTION_STACK_OVERFLOW == GetExceptionCode()) ?
                    EXCEPTION_EXECUTE_HANDLER :
                    EXCEPTION_CONTINUE_SEARCH)
    {
        _resetstkoflw();
        pSndTraining = NULL;
    }

    if (NULL == pSndTraining)
    {
        TRC(ERR, "_VCSndLineDGramTraining: can't alloca %d bytes\n",
            dwPackSize);
        goto exitpt;
    }

    _FillWithGarbage( pSndTraining, dwPackSize );

    //
    //  send a block and measure the time when it will arrive
    //

    // prepare the to address
    //
    sin.sin_family = PF_INET;
    sin.sin_port = (u_short)g_dwDGramPort;
    sin.sin_addr.s_addr = g_ulDGramAddress;

    pSndTraining->Prolog.Type = SNDC_TRAINING;
    pSndTraining->Prolog.BodySize = (UINT16)( dwPackSize -
                                        sizeof (pSndTraining->Prolog));
    pSndTraining->wPackSize  = (UINT16)TSSND_TRAINING_BLOCKSIZE;

    dwRetries = 2 * DEFAULT_RESPONSE_TIMEOUT / 1000;
    do {

        pSndTraining->wTimeStamp = (WORD)GetTickCount();

        //
        //  send the datagram
        //  the type is SNDC_WAVE but the structure is of SNDWAVE
        //  wTimeStamp contains the sending time
        //
        sendres = sendto(
                     g_hDGramSocket,
                     (LPSTR)pSndTraining,
                     dwPackSize,
                     0,                                 // flags
                     (struct sockaddr *)&sin,           // to address
                     sizeof(sin)
                );

        if (SOCKET_ERROR == sendres)
        {
            TRC(ERR, "_VCSndLineDGramTraining: sendto failed: %d\n",
                    WSAGetLastError());
            goto exitpt;
        }

        //
        //  wait for a response
        //
        do {
            pSndTrainingResp = NULL;
            dwRespSize       = 0;

            DGramRead( hDGramEvent, (PVOID*) &pSndTrainingResp, &dwRespSize );

            if ( NULL == pSndTrainingResp )
            {
                DWORD dwres;
                HANDLE ahEvents[2];

                ahEvents[0] = hDGramEvent;
                ahEvents[1] = g_hDisconnectEvent;
                dwres = WaitForMultipleObjects(
                        sizeof(ahEvents)/sizeof(ahEvents[0]), // count
                        ahEvents,                             // events
                        FALSE,                                // wait all
                        1000);


                if ( WAIT_OBJECT_0 + 1 == dwres )
                {
                    TRC(WRN, "_VCSndLineDGramTraining: disconnected\n");
                    goto exitpt;
                }

                if (WAIT_TIMEOUT == dwres)
                {
                    TRC(WRN, "_VCSndLineDGramTraining: timeout "
                             "waiting for response\n");
                    goto try_again;
                }

                DGramReadComplete( (PVOID*) &pSndTrainingResp, &dwRespSize );
            }

        } while ( NULL == pSndTrainingResp ||
                  sizeof( *pSndTrainingResp ) != dwRespSize ||
                  SNDC_TRAINING != pSndTrainingResp->Prolog.Type ||
                  sizeof(SNDTRAINING) - sizeof(SNDPROLOG) <
                  pSndTrainingResp->Prolog.BodySize );

        TRC(ALV, "_VCSndLineDGramTraining: response received\n");
        break;

try_again:
        dwRetries --;
    } while (0 != dwRetries);

    if (0 != dwRetries)
    {
        //
        // calculate latency (nonzero)
        //
        dwDGramLatency = ((WORD)GetTickCount()) - 
                        pSndTrainingResp->wTimeStamp + 1;
    }

exitpt:
    TRC(INF, "_VCSndLineDGramTraining: dwDGramLatency = %d\n",
                dwDGramLatency);

    if (0 != dwDGramLatency)
    {
        //
        // the latency is in miliseconds, so compute it bytes per seconds
        // and get nonzero result
        //
        dwSuggestedBaudRate = 1 + (1000 * ( pSndTrainingResp->wPackSize +
                                    sizeof( *pSndTrainingResp ))
                                  / dwDGramLatency);
    }
    else
        dwSuggestedBaudRate = 0;

    TRC(INF, "_VCSndLineDGramTraining: dwSuggestedBaudRate = %d\n",
                dwSuggestedBaudRate);


    return dwSuggestedBaudRate;
}

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

    switch (pFmt->wFormatTag)
    {
        case WAVE_FORMAT_MSG723:
            ASSERT(pFmt->cbSize == 10);
            if ( 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 == sizeof( VOXACM_WAVEFORMATEX ) - sizeof( WAVEFORMATEX ) );
            if ( sizeof( VOXACM_WAVEFORMATEX ) - sizeof( WAVEFORMATEX ) == pFmt->cbSize )
            {
                VOXACM_WAVEFORMATEX *pVOX = (VOXACM_WAVEFORMATEX *)pFmt;

                ASSERT( strlen( VOXWARE_KEY ) + 1 == sizeof( pVOX->szKey ));
                strncpy( pVOX->szKey, VOXWARE_KEY, sizeof( pVOX->szKey ));

                rv = TRUE;
            }
            break;

        // this format eats too much from the CPU
        //
        case WAVE_FORMAT_MPEGLAYER3:
            if ( g_dwEnableMP3Codec )
                rv = TRUE;
            break;

        case WAVE_FORMAT_WMAUDIO2:
            if ( g_dwEnableMP3Codec )
            {
                rv = TRUE;
            }
            break;

        default:
            rv = TRUE;
    }

    return rv;
}

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

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

    *ppfnConverter = NULL;
    //
    //  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: pfnConverter = _Convert8000Mono; break;
        case 11025: pfnConverter = _Convert11025Mono; break;
        case 12000: pfnConverter = _Convert12000Mono; break;
        case 16000: pfnConverter = _Convert16000Mono; break;
        case 22050: pfnConverter = _Convert22050Mono; break;
        default:
            ASSERT( 0 );
        }
    } else {
        switch ( pInterrimFmt->nSamplesPerSec )
        {
        case  8000: pfnConverter = _Convert8000Stereo;  break;
        case 11025: pfnConverter = _Convert11025Stereo; break;
        case 12000: pfnConverter = _Convert12000Stereo; break;
        case 16000: pfnConverter = _Convert16000Stereo; break;
        case 22050: pfnConverter = NULL;                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 );

    *ppfnConverter = pfnConverter;

    return rv;
}

/*
 *  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;
    UINT             count, codecsize;

    ASSERT( ppFormatList );
    ASSERT( pdwNumberOfFormats );

    *ppFormatList = NULL;

    //
    //  convert the known format list to a linked list
    //
    for ( count = 0, codecsize = 0; count < sizeof( KnownFormats ); count += codecsize )
    {
        PWAVEFORMATEX pSndFmt = (PWAVEFORMATEX)(KnownFormats + count);
        codecsize = sizeof( WAVEFORMATEX ) + pSndFmt->cbSize;

        //
        //  skip mp3s if disabled
        //
        if (( WAVE_FORMAT_MPEGLAYER3 == pSndFmt->wFormatTag ||
              WAVE_FORMAT_WMAUDIO2 == pSndFmt->wFormatTag ) &&
             !g_dwEnableMP3Codec )
        {
            continue;
        }

        UINT entrysize = sizeof( VCSNDFORMATLIST ) + pSndFmt->cbSize;
        PVCSNDFORMATLIST pNewEntry;

        pNewEntry = (PVCSNDFORMATLIST) TSMALLOC( entrysize );
        if ( NULL != pNewEntry )
        {
            memcpy( &pNewEntry->Format, pSndFmt, codecsize );
            pNewEntry->hacmDriverId = NULL;
            pNewEntry->pNext = *ppFormatList;
            *ppFormatList = pNewEntry;
        }
    }

    //
    //  additional codecs
    //  these are codecs not included initially, it reads them from the registry
    //  see AllowCodecs initialization
    //
    for ( count = 0, codecsize = 0; count < g_AllowCodecsSize ; count += codecsize )
    {
        PWAVEFORMATEX pSndFmt = (PWAVEFORMATEX)(((PBYTE)g_AllowCodecs) + count);
        codecsize = sizeof( WAVEFORMATEX ) + pSndFmt->cbSize;

        if ( codecsize + count > g_AllowCodecsSize )
        {
            TRC( ERR, "Invalid size of additional codec\n" );
            break;
        }

        //
        //  skip mp3s if disabled
        //
        if (( WAVE_FORMAT_MPEGLAYER3 == pSndFmt->wFormatTag ||
              WAVE_FORMAT_WMAUDIO2 == pSndFmt->wFormatTag ) &&
             !g_dwEnableMP3Codec )
        {
            continue;
        }

        UINT entrysize = sizeof( VCSNDFORMATLIST ) + pSndFmt->cbSize;
        PVCSNDFORMATLIST pNewEntry;

        pNewEntry = (PVCSNDFORMATLIST) TSMALLOC( entrysize );
        if ( NULL != pNewEntry )
        {
            memcpy( &pNewEntry->Format, pSndFmt, codecsize );
            pNewEntry->hacmDriverId = NULL;
            pNewEntry->pNext = *ppFormatList;
            *ppFormatList = pNewEntry;
        }
    }

    //
    //  add the native format
    //
    pIter = (PVCSNDFORMATLIST) TSMALLOC( sizeof( *pIter ) );
    if ( NULL != pIter )
    {
        pIter->Format.wFormatTag        = WAVE_FORMAT_PCM;
        pIter->Format.nChannels         = TSSND_NATIVE_CHANNELS;
        pIter->Format.nSamplesPerSec    = TSSND_NATIVE_SAMPLERATE;
        pIter->Format.nAvgBytesPerSec   = TSSND_NATIVE_AVGBYTESPERSEC;
        pIter->Format.nBlockAlign       = TSSND_NATIVE_BLOCKALIGN;
        pIter->Format.wBitsPerSample    = TSSND_NATIVE_BITSPERSAMPLE;
        pIter->Format.cbSize            = 0;
        pIter->hacmDriverId             = NULL;

        pIter->pNext = *ppFormatList;
        *ppFormatList = pIter;
    }

    if (NULL == *ppFormatList)
    {
        TRC(WRN, "VCSndEnumAllCodecFormats: failed to add formats\n");

        goto exitpt;
    }


    _VCSndOrderFormatList( ppFormatList, &dwNum );

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

        pIter = *ppFormatList;
        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;
}

BOOL
CALLBACK
acmDriverEnumCallbackGetACM(
    HACMDRIVERID    hadid,
    DWORD_PTR       dwInstance,
    DWORD           fdwSupport
    )
{
    BOOL                rv = TRUE;
    MMRESULT            mmres;

    ASSERT(dwInstance);

    ASSERT( NULL != hadid );

    if ( (0 != ( fdwSupport & ACMDRIVERDETAILS_SUPPORTF_CODEC ) ||
          0 != ( fdwSupport & ACMDRIVERDETAILS_SUPPORTF_CONVERTER )))
    {
    //
    //  a codec found
    //
        ACMFORMATTAGDETAILS fdwDetails;
        PVCSNDFORMATLIST pFmt = (PVCSNDFORMATLIST)dwInstance;

        fdwDetails.cbStruct = sizeof( fdwDetails );
        fdwDetails.fdwSupport = 0;
        fdwDetails.dwFormatTag = pFmt->Format.wFormatTag;

        mmres = acmFormatTagDetails( (HACMDRIVER)hadid, &fdwDetails, ACM_FORMATTAGDETAILSF_FORMATTAG );
        if ( MMSYSERR_NOERROR == mmres )
        {

            WAVEFORMATEX        WaveFormat;     // dummy parameter
            PFNCONVERTER        pfnConverter;   // dummy parameter

            if ( _VCSndFindSuggestedConverter(
                (HACMDRIVERID)hadid,
                &(pFmt->Format),
                &WaveFormat,
                &pfnConverter ))
            {
                pFmt->hacmDriverId = hadid;
                rv = FALSE;
            }
        }
    }

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

BOOL
_VCSndGetACMDriverId( PSNDFORMATITEM pSndFmt )
{
    DWORD   rv = FALSE;
    PVCSNDFORMATLIST pIter;
    //
    //  Find the acm format id
    //
    for( pIter = g_pAllCodecsFormatList; NULL != pIter; pIter = pIter->pNext )
    {
        if (pIter->Format.wFormatTag == pSndFmt->wFormatTag &&
            pIter->Format.nChannels  == pSndFmt->nChannels &&
            pIter->Format.nSamplesPerSec == pSndFmt->nSamplesPerSec &&
            pIter->Format.nAvgBytesPerSec == pSndFmt->nAvgBytesPerSec &&
            pIter->Format.nBlockAlign == pSndFmt->nBlockAlign &&
            pIter->Format.wBitsPerSample == pSndFmt->wBitsPerSample &&
            pIter->Format.cbSize == pSndFmt->cbSize &&
            0 == memcmp((&pIter->Format) + 1, pSndFmt + 1, pIter->Format.cbSize))
        {
            //
            //  format is found
            //
            DWORD_PTR dwp = (DWORD_PTR)pIter;
            MMRESULT mmres;

            if ( NULL != pIter->hacmDriverId )
            {
                //  found already
                rv = TRUE;
                break;
            }

            mmres = acmDriverEnum(
                acmDriverEnumCallbackGetACM,
                (DWORD_PTR)dwp,
                0
            );

            if ( MMSYSERR_NOERROR == mmres )
            {
                if ( NULL != pIter->hacmDriverId )
                {

                rv = TRUE;
                } else {
                    ASSERT( 0 );
                }
            }
            break;
        }
    }

    return rv;
}

/*
 *  Function:
 *      _VCSndChooseProperFormat
 *
 *  Description:
 *      Chooses the closest format to a given bandwidth
 *
 */
DWORD
_VCSndChooseProperFormat(
    DWORD dwBandwidth
    )
{
    // choose a format from the list
    // closest to the measured bandwidth
    //
    DWORD           i;
    DWORD           fmt = (DWORD)-1;
    DWORD           lastgood = (DWORD)-1;

    if ( NULL == g_ppNegotiatedFormats )
    {
        TRC(ERR, "_VCSndChooseProperFormat: no negotiated formats\n");
        goto exitpt;
    }

    for( i = 0; i < g_dwNegotiatedFormats; i++ )
    {
        if ( NULL == g_ppNegotiatedFormats[i] )
        {
            continue;
        }
        lastgood = i;
        if ( dwBandwidth != g_dwLineBandwidth )
        {
            //
            //  we are looking for new codec here, make sure we cover at least 90%
            //  of the requested bandwith
            //
            if ( g_ppNegotiatedFormats[i]->nAvgBytesPerSec <= dwBandwidth * NEW_CODEC_COVER / 100 )
            {
                fmt = i;
                break;
            }
        } else if ( g_ppNegotiatedFormats[i]->nAvgBytesPerSec <= dwBandwidth )
        {
            fmt = i;
            break;
        }
    }

    //
    //  get the last format inc case that all format are not
    //  suitable for our bandwidth
    //
    if ( (DWORD)-1 == fmt && 0 != g_dwNegotiatedFormats )
    {
        fmt = lastgood;
    }

    ASSERT( fmt != (DWORD)-1 );

exitpt:
    return fmt;
}

/*
 *  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;
}

/*
 *  Function:
 *      _VCSndLineTraining
 *
 *  Description:
 *      Meassures the line bandwidth
 *
 */
BOOL
_VCSndLineTraining(
    HANDLE  hReadEvent,
    HANDLE  hDGramEvent
    )
{
    BOOL rv = FALSE;
    DWORD   dwLineBandwidth = 0;

    _DGramOpen();

    //
    //  test this line while it's hot
    //
    if ( !g_dwDisableDGram )
    {
        dwLineBandwidth = _VCSndLineDGramTraining( hDGramEvent );
    }

    if (0 == dwLineBandwidth || g_dwDisableDGram)
    {
        TRC(WRN, "_VCSndLineTraining: no bandwidth trough UDP\n");
        g_ulDGramAddress = 0;
        g_dwDGramPort    = 0;

        g_EncryptionLevel = 0;
        dwLineBandwidth = _VCSndLineVCTraining( hReadEvent );

        if (0 == dwLineBandwidth)
        {
            TRC(WRN, "_VCSndLineTraining: no bandwidth "
                     "trough VC either. GIVING up\n");
            goto exitpt;
        }
    } else {
        if ( g_wClientVersion == 1 )
             g_EncryptionLevel = 0;
    }

    //
    //  check for encryption
    //
    if ( g_EncryptionLevel >= MIN_ENCRYPT_LEVEL )
    {
        TRC( INF, "Encryption enabled\n" );
        if ( TSRNG_GenerateRandomBits( g_EncryptKey, RANDOM_KEY_LENGTH))
        {
            SL_SendKey();
        } else {
            TRC( ERR, "_VCSndLineTraining: failing to generate random numbers. GIVING up\n" );
            goto exitpt;
        }
    }

    //
    //  check for limitations
    //
    if ((DWORD)-1 != g_dwMaxBandwidth && 
        dwLineBandwidth > g_dwMaxBandwidth )
    {
        dwLineBandwidth = g_dwMaxBandwidth;

        TRC(INF, "Bandwidth limited up to %d\n",
            dwLineBandwidth );
    }

    if ( dwLineBandwidth < g_dwMinBandwidth )
    {
        dwLineBandwidth = g_dwMinBandwidth;
        TRC(INF, "Bandwidth limited to at least %d\n",
            dwLineBandwidth );
    }

    rv = TRUE;

exitpt:

    g_dwLineBandwidth = dwLineBandwidth;

    return rv;
}

/*
 *  Function:
 *      VCSndNegotiateWaveFormat
 *
 *  Description:
 *      Requests the client for a list of supported formats
 *
 */
BOOL
VCSndNegotiateWaveFormat(
    HANDLE  hReadEvent,
    HANDLE  hDGramEvent
    )
{
    BOOL                rv = FALSE;
    PVCSNDFORMATLIST    pIter;
    BOOL                bSuccess;
    PSNDFORMATMSG       pSndFormats;
    PSNDFORMATMSG       pSndResp;
    PSNDFORMATITEM      pSndFmt;
    SNDMESSAGE          SndMessage;
    DWORD               msgsize;
    DWORD               maxsize;
    DWORD               i;
    DWORD               dwNewFmt;
    DWORD               dwSoundCaps = 0;
    DWORD               dwVolume;
    DWORD               dwPitch;
    DWORD               BestChannels;
    DWORD               BestSamplesPerSec;
    DWORD               BestBitsPerSample;
    DWORD               dwPacketSize;
    BOOL                bWMADetected = FALSE;

    //
    // clean the previously negotiated format
    //
    if (NULL != g_ppNegotiatedFormats)
    {
        DWORD i;

        for ( i = 0; i < g_dwNegotiatedFormats; i++ )
        {
            if ( NULL != g_ppNegotiatedFormats[i] )
                TSFREE( g_ppNegotiatedFormats[i] );
        }
        TSFREE( g_ppNegotiatedFormats );
        g_ppNegotiatedFormats = NULL;
        g_dwNegotiatedFormats = 0;
        g_hacmDriverId        = NULL;

    }

    memset( &SndMessage, 0, sizeof( SndMessage ));

    //
    //  get the list of all codec formats
    //
    if ( NULL == g_pAllCodecsFormatList )
    {
        bSuccess = VCSndEnumAllCodecFormats( 
                    &g_pAllCodecsFormatList, 
                    &g_dwAllCodecsNumber 
                    );
        if (!bSuccess)
            goto exitpt;
    }

    //
    //  create a packet huge enough to hold all formats
    //
    msgsize = sizeof( *pSndFormats ) +
              sizeof( SNDFORMATITEM ) * g_dwAllCodecsNumber;
    //
    //  calculate the extra data needed by all format
    //
    for( maxsize = 0, pIter = g_pAllCodecsFormatList; 
         NULL != pIter; 
         pIter = pIter->pNext )
    {
        msgsize += pIter->Format.cbSize;
        if (maxsize < pIter->Format.cbSize)
            maxsize = pIter->Format.cbSize;
    }

    __try {

        pSndFormats = (PSNDFORMATMSG) alloca( msgsize );

    } __except((EXCEPTION_STACK_OVERFLOW == GetExceptionCode()) ?
                    EXCEPTION_EXECUTE_HANDLER :
                    EXCEPTION_CONTINUE_SEARCH)
    {
        _resetstkoflw();
        pSndFormats = NULL;

    }

    if ( NULL == pSndFormats )
    {
        TRC(ERR, "VCSndNegotiateWaveFormat: alloca failed for %d bytes\n",
                    msgsize);
        goto exitpt;                
    }

    pSndFormats->Prolog.Type        = SNDC_FORMATS;
    pSndFormats->Prolog.BodySize    = (UINT16)( msgsize - sizeof( pSndFormats->Prolog ));
    pSndFormats->wNumberOfFormats   = (UINT16)g_dwAllCodecsNumber;
    pSndFormats->cLastBlockConfirmed = g_Stream->cLastBlockConfirmed;
    pSndFormats->wVersion           = RDPSND_PROTOCOL_VERSION;

    for ( i = 0, pSndFmt = (PSNDFORMATITEM) (pSndFormats + 1), 
                pIter = g_pAllCodecsFormatList;
          i < g_dwAllCodecsNumber; 
          i++, 
                pSndFmt = (PSNDFORMATITEM)
                    (((LPSTR)pSndFmt) + 
                    sizeof( *pSndFmt ) + pSndFmt->cbSize), 
                pIter = pIter->pNext )
    {
        ASSERT(NULL != pIter);

        pSndFmt->wFormatTag         = pIter->Format.wFormatTag;
        pSndFmt->nChannels          = pIter->Format.nChannels;
        pSndFmt->nSamplesPerSec     = pIter->Format.nSamplesPerSec;
        pSndFmt->nAvgBytesPerSec    = pIter->Format.nAvgBytesPerSec;
        pSndFmt->nBlockAlign        = pIter->Format.nBlockAlign;
        pSndFmt->wBitsPerSample     = pIter->Format.wBitsPerSample;
        pSndFmt->cbSize             = pIter->Format.cbSize;
        //
        //  copy the rest of the format data
        //
        memcpy( pSndFmt + 1, (&pIter->Format) + 1, pSndFmt->cbSize );
    }

    bSuccess = ChannelBlockWrite( pSndFormats, msgsize );
    if (!bSuccess)
    {
        TRC(ERR, "VCSndNegotiateWaveFormat: ChannelBlockWrite failed: %d\n",
                GetLastError());
        goto exitpt;
    }

    do {
    //
    //  Wait for response with a valid message
    //
        SndMessage.uiPrologReceived = 0;
        SndMessage.uiBodyReceived = 0;

        while(!ChannelReceiveMessage(&SndMessage, hReadEvent))
        {

            if (ERROR_IO_PENDING == GetLastError())
            {
                DWORD dwres;
                HANDLE ahEvents[2];

                ahEvents[0] = hReadEvent;
                ahEvents[1] = g_hDisconnectEvent;
                dwres = WaitForMultipleObjects(
                            sizeof(ahEvents)/sizeof(ahEvents[0]), // count
                            ahEvents,                             // events
                            FALSE,                                // wait all
                            DEFAULT_VC_TIMEOUT);

                if (WAIT_TIMEOUT == dwres ||
                    WAIT_OBJECT_0 + 1 == dwres)
                {
                    TRC(WRN, "VCSndNegotiateWaveFormat: timeout "
                             "waiting for response\n");
                    ChannelCancelIo();
                    ResetEvent(hReadEvent);
                    goto exitpt;
                }

                ChannelBlockReadComplete();
                ResetEvent(hReadEvent);
            } else 
            if (ERROR_SUCCESS != GetLastError())
            {
                TRC(ERR, "VCSndNegotiateWaveFormat: "
                         "ChannelReceiveMessage failed: %d\n",
                    GetLastError());
                goto exitpt;
            }
        }

    } while (SNDC_FORMATS != SndMessage.Prolog.Type);

    if (SndMessage.Prolog.BodySize <
        sizeof( SNDFORMATMSG ) - sizeof( SNDPROLOG ))
    {
        TRC(ERR, "VCSndNegotiateWaveFormat: SNDC_FORMAT message "
                "invalid body size: %d\n",
                SndMessage.Prolog.BodySize );
    }

    pSndResp = (PSNDFORMATMSG)
                (((LPSTR)SndMessage.pBody) - sizeof( SNDPROLOG ));
    //  save the capabilities
    //
    dwSoundCaps = pSndResp->dwFlags;
    dwVolume    = pSndResp->dwVolume;
    dwPitch     = pSndResp->dwPitch;
    g_dwDGramPort = pSndResp->wDGramPort;
    g_wClientVersion = pSndResp->wVersion;

    //
    //  Expect at least one format returned
    //
    if (SndMessage.Prolog.BodySize <
        sizeof( SNDFORMATITEM ) + 
        sizeof( SNDFORMATMSG ) - sizeof( SNDPROLOG ))
    {
        TRC(ERR, "VCSndNegotiateWaveFormat: SNDC_FORMAT message "
                 "w/ invalid size (%d). No supported formats\n",
                SndMessage.Prolog.BodySize );
        goto exitpt;
    }

    //
    //  train this line
    //
    if ( 0 != ( dwSoundCaps & TSSNDCAPS_ALIVE ))
    {
        if (!_VCSndLineTraining( hReadEvent, hDGramEvent ))
        {
            TRC( WRN, "VCSndIo: can't talk to the client, go silent\n" );
            dwSoundCaps = 0;
        }
    }

    //
    //  allocate a new list
    //
    g_dwNegotiatedFormats = pSndResp->wNumberOfFormats;

    g_ppNegotiatedFormats = (PSNDFORMATITEM*) TSMALLOC( sizeof( g_ppNegotiatedFormats[0] ) *
                                        g_dwNegotiatedFormats );
    memset( g_ppNegotiatedFormats, 0,
            sizeof( g_ppNegotiatedFormats[0] ) * g_dwNegotiatedFormats );

    if ( NULL == g_ppNegotiatedFormats )
    {
        TRC(ERR, "VCSndNegotiateWaveFormat: can't allocate %d bytes\n",
                sizeof( g_ppNegotiatedFormats[0] ) * g_dwNegotiatedFormats);
        goto exitpt;
    }

    //
    //  allocate space for each entry in the list
    //
    for ( i = 0; i < g_dwNegotiatedFormats; i ++ )
    {
        g_ppNegotiatedFormats[i] = (PSNDFORMATITEM) TSMALLOC( sizeof( **g_ppNegotiatedFormats ) +
                                        maxsize);

        if ( NULL == g_ppNegotiatedFormats[i] )
        {
            TRC(ERR, "VCSndNegotiateWaveFormat: can't allocate %d bytes\n",
                    sizeof( **g_ppNegotiatedFormats ) + maxsize );
            goto exitpt;
        }
    }

    //
    //  Fill in the global list
    //
    pSndFmt = (PSNDFORMATITEM)(pSndResp + 1);
    dwPacketSize = sizeof( SNDPROLOG ) + SndMessage.Prolog.BodySize - sizeof( *pSndResp );

    for( i = 0; i < g_dwNegotiatedFormats; i++)
    {
        DWORD adv = sizeof( *pSndFmt ) + pSndFmt->cbSize;

        if ( adv > dwPacketSize )
        {
            TRC( ERR, "VCSndNegotiateWaveFormat: invalid response packet size\n" );
            ASSERT( 0 );
            goto exitpt;
        }

        if ( pSndFmt->cbSize > maxsize )
        {
            TRC(ERR, "VCSndNegotiateWaveFormat: invalid format size\n" );
            ASSERT( 0 );
            goto exitpt;
        }

        memcpy( g_ppNegotiatedFormats[i], 
                pSndFmt,
                sizeof( *g_ppNegotiatedFormats[0] ) + pSndFmt->cbSize );

        //
        //  advance to the next format
        //
        pSndFmt = (PSNDFORMATITEM)(((LPSTR)pSndFmt) + adv);
        dwPacketSize -= adv;
    }
    ASSERT( 0 == dwPacketSize );

    //
    //  prune the formats
    //  ie, don't allow 8khZ mono codec to be between
    //  22kHz and 11kHz stereo
    //  This is the order of imporatnce: frquency, channels, bits, bytes/s
    //
#if DBG
    TRC( INF, "======== Pruning formats =========. num=%d\n\n", g_dwNegotiatedFormats );
#endif
    BestSamplesPerSec = 0;
    BestChannels      = 0;
    BestBitsPerSample = 0;
    for( i = g_dwNegotiatedFormats; i > 0; i-- )
    {
        PSNDFORMATITEM pDest = g_ppNegotiatedFormats[i - 1];

        if ( WAVE_FORMAT_MPEGLAYER3 == pDest->wFormatTag && bWMADetected )
        {
            goto bad_codec;
        }
        if ( WAVE_FORMAT_WMAUDIO2 == pDest->wFormatTag )
        {
            bWMADetected = TRUE;
        }

        //
        //  a complex check for the order
        //
        if ( BestSamplesPerSec > pDest->nSamplesPerSec )
        {
            goto bad_codec;
        } else if ( BestSamplesPerSec == pDest->nSamplesPerSec )
        {
            if ( BestChannels > pDest->nChannels )
            {
                goto bad_codec;
#if 0
            } else if ( BestChannels == pDest->nChannels )
            {
                if ( BestBitsPerSample > pDest->wBitsPerSample )
                {
                    goto bad_codec;
                }
#endif
            }
        }


        //
        //  good codec, keep it
        //
        BestChannels = pDest->nChannels;
        BestBitsPerSample = pDest->wBitsPerSample;
        BestSamplesPerSec = pDest->nSamplesPerSec;
#if 0
        TRC(INF, "GOOD ag=%d chans=%d rate=%d, bps=%d, bpsamp=%d\n",
            pDest->wFormatTag, pDest->nChannels, pDest->nSamplesPerSec, pDest->nAvgBytesPerSec, pDest->wBitsPerSample
        );
#endif
        continue;

bad_codec:
        //
        //  bad codec, delete
        //
#if 0
        TRC(INF, "BAD ag=%d chans=%d rate=%d, bps=%d, bpsamp=%d\n",
            pDest->wFormatTag, pDest->nChannels, pDest->nSamplesPerSec, pDest->nAvgBytesPerSec, pDest->wBitsPerSample
        );
#endif
        TSFREE( pDest );
        g_ppNegotiatedFormats[i - 1] = NULL;

    }

    //
    //  choose the first format as a default
    //
    dwNewFmt = _VCSndChooseProperFormat( g_dwLineBandwidth );
    if (dwNewFmt != (DWORD) -1)
    {
        //
        //  get a valid driver id
        //
        _VCSndGetACMDriverId( g_ppNegotiatedFormats[ dwNewFmt ] );

        g_dwCurrentFormat = dwNewFmt;
        //
        //  correct the new bandwidth
        //
        g_dwLineBandwidth = g_ppNegotiatedFormats[ dwNewFmt ]->nAvgBytesPerSec;
    }

    //
    //  remember the stream settings
    //
    if ( 0 != dwSoundCaps )
    {
        //
        // set the remote sound caps
        //
        if (VCSndAcquireStream())
        {

            g_Stream->dwSoundCaps = dwSoundCaps;
            g_Stream->dwVolume    = dwVolume;
            g_Stream->dwPitch     = dwPitch;

            VCSndReleaseStream();
        }
    }

    rv = TRUE;

exitpt:

    //  don't forget to free the body of the eventually received message
    //
    if ( NULL != SndMessage.pBody )
        TSFREE( SndMessage.pBody );

    //
    //  in case of error cleanup the negotiated format
    //
    if ( !rv && NULL != g_ppNegotiatedFormats )
    {
        for ( i = 0; i < g_dwNegotiatedFormats; i++ )
        {
            if ( NULL != g_ppNegotiatedFormats[i] )
                TSFREE( g_ppNegotiatedFormats[i] );
        }
        TSFREE( g_ppNegotiatedFormats );
        g_ppNegotiatedFormats = NULL;
        g_dwNegotiatedFormats = 0;
        g_hacmDriverId        = NULL;
    }

    return rv;
}

/*
 *  Function:
 *      _VCSndFindNativeFormat
 *
 *  Description:
 *      returns the ID of the native format ( no codecs available )
 *
 */
DWORD
_VCSndFindNativeFormat(
    VOID
    )
{
    PSNDFORMATITEM pIter;
    DWORD          rv = 0;

    if ( NULL == g_ppNegotiatedFormats )
    {
        TRC(ERR, "_VCSndFindNativeFormat: no format cache\n");
        goto exitpt;
    }

    for( rv  = 0; rv < g_dwNegotiatedFormats; rv++ )
    {
        pIter = g_ppNegotiatedFormats[ rv ];
        if (pIter->wFormatTag == WAVE_FORMAT_PCM &&
            pIter->nChannels  == TSSND_NATIVE_CHANNELS &&
            pIter->nSamplesPerSec == TSSND_NATIVE_SAMPLERATE &&
            pIter->nAvgBytesPerSec == TSSND_NATIVE_AVGBYTESPERSEC &&
            pIter->nBlockAlign == TSSND_NATIVE_BLOCKALIGN &&
            pIter->wBitsPerSample == TSSND_NATIVE_BITSPERSAMPLE &&
            pIter->cbSize == 0)
            //
            //  format is found
            //
            break;
    }

    ASSERT( rv < g_dwNegotiatedFormats );

exitpt:

    return rv;
}

/*
 *  Function:
 *      _VCSndOpenConverter
 *
 *  Description:
 *      Opens a codec
 *
 */
BOOL
_VCSndOpenConverter(
    VOID
    )
{
    BOOL            rv = FALSE;
    MMRESULT        mmres;
    WAVEFORMATEX    NativeFormat;
    PSNDFORMATITEM  pSndFmt;
    PVCSNDFORMATLIST  pIter;
    BOOL            bSucc;

    //
    //  assert that these wasn't opened before
    //
    ASSERT(NULL == g_hacmDriver);
    ASSERT(NULL == g_hacmStream);

    if ( NULL == g_ppNegotiatedFormats )
    {
        TRC(INF, "_VCSndOpenConverter: no acm format specified\n");
        goto exitpt;
    }

    //
    //  Find the acm format id
    //
    pSndFmt = g_ppNegotiatedFormats[ g_dwCurrentFormat ];
    for( pIter = g_pAllCodecsFormatList; NULL != pIter; pIter = pIter->pNext )
    {
        if (pIter->Format.wFormatTag == pSndFmt->wFormatTag &&
            pIter->Format.nChannels  == pSndFmt->nChannels &&
            pIter->Format.nSamplesPerSec == pSndFmt->nSamplesPerSec &&
            pIter->Format.nAvgBytesPerSec == pSndFmt->nAvgBytesPerSec &&
            pIter->Format.nBlockAlign == pSndFmt->nBlockAlign &&
            pIter->Format.wBitsPerSample == pSndFmt->wBitsPerSample &&
            pIter->Format.cbSize == pSndFmt->cbSize &&
            0 == memcmp((&pIter->Format) + 1, pSndFmt + 1, pIter->Format.cbSize)
)
        {
            //
            //  format is found
            //
            g_hacmDriverId = pIter->hacmDriverId;
            break;
        }
    }

    if (NULL == g_hacmDriverId)
    {
        TRC(ERR, "_VCSndOpenConverter: acm driver id was not found\n");
        goto exitpt;
    }

    TRC(INF, "_VCSndOpenConverter: format received is:\n");
    TRC(INF, "FormatTag - %d\n",        pSndFmt->wFormatTag);
    TRC(INF, "Channels - %d\n",         pSndFmt->nChannels);
    TRC(INF, "SamplesPerSec - %d\n",    pSndFmt->nSamplesPerSec);
    TRC(INF, "AvgBytesPerSec - %d\n",   pSndFmt->nAvgBytesPerSec);
    TRC(INF, "BlockAlign - %d\n",       pSndFmt->nBlockAlign);
    TRC(INF, "BitsPerSample - %d\n",    pSndFmt->wBitsPerSample);
    TRC(INF, "cbSize        - %d\n",    pSndFmt->cbSize);
    TRC(INF, "acmFormatId   - %p\n",    g_hacmDriverId);

    mmres = acmDriverOpen(
                    &g_hacmDriver,
                    g_hacmDriverId,
                    0
                );

    if (MMSYSERR_NOERROR != mmres)
    {
        TRC(ERR, "_VCSndOpenConverter: unable to open acm driver: %d\n",
                mmres);
        goto exitpt;
    }

    TRC(ALV, "_VCSndOpenConverter: Driver is open, DriverId = %p\n",
            g_hacmDriverId);

    //
    //  first, find a suggested format for this converter
    //
    pSndFmt = g_ppNegotiatedFormats[ g_dwCurrentFormat ];

    if ( WAVE_FORMAT_PCM == pSndFmt->wFormatTag &&
         TSSND_NATIVE_CHANNELS == pSndFmt->nChannels &&
         TSSND_NATIVE_SAMPLERATE == pSndFmt->nSamplesPerSec &&
         TSSND_NATIVE_AVGBYTESPERSEC == pSndFmt->nAvgBytesPerSec &&
         TSSND_NATIVE_BLOCKALIGN == pSndFmt->nBlockAlign &&
         TSSND_NATIVE_BITSPERSAMPLE == pSndFmt->wBitsPerSample &&
         0 == pSndFmt->cbSize )
    {
        TRC(INF, "_VCSndOpenConverter: opening native format, no converter\n");
        goto exitpt;
    }

    bSucc = _VCSndFindSuggestedConverter(
            g_hacmDriverId,
            (LPWAVEFORMATEX)pSndFmt,
            &NativeFormat,
            &g_pfnConverter);

    if (!bSucc)
    {
        TRC(FATAL, "_VCSndOpenConverter: can't find a suggested format\n");
        goto exitpt;
    }

    TRC(ALV, "_VCSndOpenConverter: SOURCE format is:\n");
    TRC(ALV, "FormatTag - %d\n",        NativeFormat.wFormatTag);
    TRC(ALV, "Channels - %d\n",         NativeFormat.nChannels);
    TRC(ALV, "SamplesPerSec - %d\n",    NativeFormat.nSamplesPerSec);
    TRC(ALV, "AvgBytesPerSec - %d\n",   NativeFormat.nAvgBytesPerSec);
    TRC(ALV, "BlockAlign - %d\n",       NativeFormat.nBlockAlign);
    TRC(ALV, "BitsPerSample - %d\n",    NativeFormat.wBitsPerSample);
    TRC(ALV, "cbSize        - %d\n",    NativeFormat.cbSize);

    TRC(ALV, "_VCSndOpenConverter: DESTINATION format is:\n");
    TRC(ALV, "FormatTag - %d\n",        pSndFmt->wFormatTag);
    TRC(ALV, "Channels - %d\n",         pSndFmt->nChannels);
    TRC(ALV, "SamplesPerSec - %d\n",    pSndFmt->nSamplesPerSec);
    TRC(ALV, "AvgBytesPerSec - %d\n",   pSndFmt->nAvgBytesPerSec);
    TRC(ALV, "BlockAlign - %d\n",       pSndFmt->nBlockAlign);
    TRC(ALV, "BitsPerSample - %d\n",    pSndFmt->wBitsPerSample);
    TRC(ALV, "cbSize        - %d\n",    pSndFmt->cbSize);

    mmres = acmStreamOpen(
                &g_hacmStream,
                g_hacmDriver,
                &NativeFormat,
                (LPWAVEFORMATEX)pSndFmt,
                NULL,       // no filter
                0,          // no callback
                0,          // no callback instance
                ACM_STREAMOPENF_NONREALTIME
            );

    if (MMSYSERR_NOERROR != mmres)
    {
        TRC(ERR, "_VCSndOpenConverter: unable to open acm stream: %d\n",
                mmres);
        goto exitpt;
    }

    g_dwDataRemain = 0;

    rv = TRUE;

exitpt:
    if (!rv)
    {
        _VCSndCloseConverter();
        g_dwCurrentFormat = _VCSndFindNativeFormat();
    }

    return rv;
}

/*
 *  Function:
 *      _VCSndCloseConverter
 *
 *  Description:
 *      Closes the codec
 *
 */
VOID
_VCSndCloseConverter(
    VOID
    )
{
    if (g_hacmStream)
    {
        acmStreamClose( g_hacmStream, 0 );
        g_hacmStream = NULL;
    }

    if (g_hacmDriver)
    {
        acmDriverClose( g_hacmDriver, 0 );
        g_hacmDriver = NULL;
    }
}

/*
 *  Function:
 *      _VCSndConvert
 *
 *  Description:
 *      Convert a block
 *
 */
BOOL
_VCSndConvert( 
    PBYTE   pSrc, 
    DWORD   dwSrcSize, 
    PBYTE   pDest, 
    DWORD   *pdwDestSize )
{
    BOOL            rv = FALSE;
    ACMSTREAMHEADER acmStreamHdr;
    MMRESULT        mmres, mmres2;
    DWORD           dwDestSize = 0;
    DWORD           dwSrcBlockAlign = 0;
    DWORD           dwNewDestSize = 0;

    PBYTE           pbRemDst;
    DWORD           dwRemDstLength;

    ASSERT( NULL != g_hacmStream );
    ASSERT( NULL != pdwDestSize );

    //
    // check if we have interrim converter
    // use it, if so
    //
    if ( NULL != g_pfnConverter )
    {
        DWORD   dwInterrimSize;
        g_pfnConverter( (INT16 *)pSrc, 
                        dwSrcSize, 
                        &dwInterrimSize );
        dwSrcSize = dwInterrimSize;
    }

    //
    //  compute the destination size
    //
    mmres = acmStreamSize(
                g_hacmStream,
                dwSrcSize,
                &dwNewDestSize,
                ACM_STREAMSIZEF_SOURCE
            );
    if ( MMSYSERR_NOERROR != mmres )
    {
        TRC(ERR, "_VCSndConvert: acmStreamSize failed: %d\n",
                    mmres);
        g_dwDataRemain = 0;
        goto go_convert;
    }

    //
    //  align the source to a block of the destination
    //  the remainder put in a buffer for consequentive use
    //
    mmres = acmStreamSize(
                g_hacmStream,
                g_ppNegotiatedFormats[ g_dwCurrentFormat ]->nBlockAlign,
                &dwSrcBlockAlign,
                ACM_STREAMSIZEF_DESTINATION
            );

    if ( MMSYSERR_NOERROR != mmres )
    {

        TRC(ALV, "_VCSndConvert: acmStreamSize failed for dst len: %d\n",
                    mmres);
        g_dwDataRemain = 0;
        goto go_convert;
    }

    dwNewDestSize += g_ppNegotiatedFormats[ g_dwCurrentFormat ]->nBlockAlign;
    if ( dwNewDestSize > *pdwDestSize )
    {
        TRC( FATAL, "_VCSndConvert: dest size(%d) "
                    "bigger than passed buffer(%d)\n",
            dwNewDestSize,
            *pdwDestSize);
        goto exitpt;
    }
    *pdwDestSize = dwNewDestSize;

    if ( dwSrcBlockAlign <= g_dwDataRemain )
        g_dwDataRemain = 0;

go_convert:
    //
    //  prepare the acm stream header
    //
    memset( &acmStreamHdr, 0, sizeof( acmStreamHdr ));
    acmStreamHdr.cbStruct       = sizeof( acmStreamHdr );
    acmStreamHdr.pbDst          = pDest;
    acmStreamHdr.cbDstLength    = *pdwDestSize;

    //
    //  first convert the remainding data from the previous call
    //  add the data needed to complete one block
    //
    if ( 0 != g_dwDataRemain)
    {
        DWORD dwDataToCopy = dwSrcBlockAlign - g_dwDataRemain;

        memcpy( g_pCnvPrevData + g_dwDataRemain, 
                pSrc,
                dwDataToCopy);

        pSrc += dwDataToCopy;

        ASSERT( dwSrcSize > dwDataToCopy );
        dwSrcSize -= dwDataToCopy;

        acmStreamHdr.pbSrc          = g_pCnvPrevData;
        acmStreamHdr.cbSrcLength    = dwSrcBlockAlign;

        mmres = acmStreamPrepareHeader(
                g_hacmStream,
                &acmStreamHdr,
                0
            );
        if ( MMSYSERR_NOERROR != mmres )
        {
            TRC(ERR, "_VCSndConvert: acmStreamPrepareHeader failed: %d\n",
                    mmres);
            goto exitpt;
        }

        mmres = acmStreamConvert(
                g_hacmStream,
                &acmStreamHdr,
                ACM_STREAMCONVERTF_BLOCKALIGN
            );

        mmres2 = acmStreamUnprepareHeader(
                    g_hacmStream,
                    &acmStreamHdr,
                    0
                );

        ASSERT( mmres == MMSYSERR_NOERROR );

        if ( MMSYSERR_NOERROR != mmres )
        {
            TRC(ERR, "_VCSndConvert: acmStreamConvert failed: %d\n",
                    mmres );
        } else {
            dwDestSize += acmStreamHdr.cbDstLengthUsed;

            acmStreamHdr.cbSrcLengthUsed= 0;
            acmStreamHdr.pbDst          += acmStreamHdr.cbDstLengthUsed;
            acmStreamHdr.cbDstLength    -= acmStreamHdr.cbDstLengthUsed;
            acmStreamHdr.cbDstLengthUsed= 0;
        }

    }

    //
    //  if we don't have fully aligned block
    //  skip this conversion, but don't forget to save
    //  this block
    //
    if (dwSrcSize < dwSrcBlockAlign)
    {
        g_dwDataRemain = dwSrcSize;
        memcpy( g_pCnvPrevData, pSrc, g_dwDataRemain );
        rv = TRUE;
        goto exitpt;
    }

    pbRemDst                    = acmStreamHdr.pbDst;
    dwRemDstLength              = acmStreamHdr.cbDstLength;

    acmStreamHdr.pbSrc          = pSrc;
    acmStreamHdr.cbSrcLength    = dwSrcSize;
    acmStreamHdr.fdwStatus      = 0;

    mmres = acmStreamPrepareHeader(
                g_hacmStream,
                &acmStreamHdr,
                0
            );
    if ( MMSYSERR_NOERROR != mmres )
    {
        TRC(ERR, "_VCSndConvert: can't prepare header: %d\n",
                mmres);
        goto exitpt;
    }

    while (acmStreamHdr.cbSrcLength > dwSrcBlockAlign)
    {
        mmres = acmStreamConvert(
                    g_hacmStream,
                    &acmStreamHdr,
                    ACM_STREAMCONVERTF_BLOCKALIGN
                );

        if ( MMSYSERR_NOERROR != mmres )
        {
            TRC(ERR, "_VCSndConvert: acmStreamConvert failed: %d\n",
                    mmres);
            goto exitpt;
        }

        //
        //  advance the buffer positions
        //
        acmStreamHdr.pbSrc          += acmStreamHdr.cbSrcLengthUsed;
        acmStreamHdr.pbDst          += acmStreamHdr.cbDstLengthUsed;
        acmStreamHdr.cbSrcLength    -= acmStreamHdr.cbSrcLengthUsed;
        acmStreamHdr.cbDstLength    -= acmStreamHdr.cbDstLengthUsed;

        dwDestSize += acmStreamHdr.cbDstLengthUsed;

        acmStreamHdr.cbSrcLengthUsed= 0;
        acmStreamHdr.cbDstLengthUsed= 0;

    }

    rv = TRUE;

    //
    //  save the unaligned data
    //
    if ( 0 != dwSrcBlockAlign )
    {
        g_dwDataRemain = acmStreamHdr.cbSrcLength;
        memcpy( g_pCnvPrevData, acmStreamHdr.pbSrc, g_dwDataRemain );
    }

    //
    // restore the header and unprepare
    //
    acmStreamHdr.pbSrc          = pSrc;
    acmStreamHdr.pbDst          = pbRemDst;
    acmStreamHdr.cbSrcLength    = dwSrcSize;
    acmStreamHdr.cbSrcLengthUsed= 0;
    acmStreamHdr.cbDstLength    = dwRemDstLength;
    acmStreamHdr.cbDstLengthUsed= 0;

    mmres = acmStreamUnprepareHeader(
                g_hacmStream,
                &acmStreamHdr,
                0
            );

    ASSERT( mmres == MMSYSERR_NOERROR );

exitpt:

    *pdwDestSize = dwDestSize;

    return rv;    
}

/*
 *  Function:
 *      _VCSndCheckDevice
 *
 *  Description:
 *      Initializes capabilities negotiations with the client
 *
 */
VOID
_VCSndCheckDevice(
    HANDLE  hReadEvent,
    HANDLE  hDGramEvent
    )
{
    SNDPROLOG       Prolog;
    BOOL            bSuccess;

    //
    //  no sound caps yet
    //
    g_Stream->dwSoundCaps = 0;

    //
    //  find the best compression for this audio line
    //
    if ( !VCSndNegotiateWaveFormat( hReadEvent, hDGramEvent ))
    {
        ChannelClose();
    }

}

/*
 *  Function:
 *      _VCSndCloseDevice
 *
 *  Description:
 *      Closes the remote device
 *
 */
VOID
_VCSndCloseDevice(
    VOID
    )
{
    if (!VCSndAcquireStream())
    {
        TRC(FATAL, "_VCSndCloseDevice: Can't acquire stream mutex. exit\n");
        goto exitpt;
    }

    //  disable the local audio
    //
    g_Stream->dwSoundCaps = 0;
    g_bDeviceOpened = FALSE;
    g_dwLineBandwidth = 0;

    VCSndReleaseStream();

exitpt:
    ;
}

/*
 *  Function:
 *      _VCSndSendWave
 *
 *  Description:
 *      Sends a wave data to the client using UDP
 *
 */
BOOL
_VCSndSendWaveDGram(
    BYTE  cBlockNo,
    PVOID pData,
    DWORD dwDataSize
    ) 
{
    BOOL    bSucc = FALSE;
    struct sockaddr_in  sin;
    INT                 sendres;
    PSNDWAVE            pSndWave;


    //
    //  encrypt the packet if necessary
    //
    if ( g_EncryptionLevel >= MIN_ENCRYPT_LEVEL )
         if ( !SL_Encrypt( (PBYTE)pData, ( g_HiBlockNo << 8 ) + cBlockNo, dwDataSize ))
            goto exitpt;

    __try {
        pSndWave = (PSNDWAVE) alloca(g_dwDGramSize);
    } __except((EXCEPTION_STACK_OVERFLOW == GetExceptionCode()) ?
                    EXCEPTION_EXECUTE_HANDLER :
                    EXCEPTION_CONTINUE_SEARCH)
    {
        _resetstkoflw();
        pSndWave = NULL;
        TRC(ERR, "_VCSndSendWaveDGram: alloca generate exception: %d\n",
                GetExceptionCode());
    }

    if (NULL == pSndWave)
        goto exitpt;

    pSndWave->Prolog.Type = (g_EncryptionLevel >= MIN_ENCRYPT_LEVEL)?SNDC_WAVEENCRYPT:SNDC_WAVE;
    pSndWave->wFormatNo   = (UINT16)g_dwCurrentFormat;
    pSndWave->wTimeStamp  = (UINT16)GetTickCount();
    pSndWave->dwBlockNo   = (g_HiBlockNo << 8) + cBlockNo;

    // prepare the to address
    //
    sin.sin_family = PF_INET;
    sin.sin_port = (u_short)g_dwDGramPort;
    sin.sin_addr.s_addr = g_ulDGramAddress;

    //  Send the block in chunks of dwDGramSize
    //
    while (dwDataSize)
    {
        DWORD dwWaveDataLen;

        dwWaveDataLen = (dwDataSize + sizeof(*pSndWave)
                            < g_dwDGramSize)
                        ?
                        dwDataSize:
                        g_dwDGramSize - sizeof(*pSndWave);

        pSndWave->Prolog.BodySize = (UINT16)
                                    ( sizeof(*pSndWave) - 
                                    sizeof(pSndWave->Prolog) +
                                    dwWaveDataLen );

        memcpy(pSndWave + 1, pData, dwWaveDataLen);

        sendres = sendto(g_hDGramSocket,
                         (LPSTR)pSndWave,
                         sizeof(*pSndWave) + dwWaveDataLen,
                         0,                                 // flags
                         (struct sockaddr *)&sin,           // to address
                         sizeof(sin));

        if (SOCKET_ERROR == sendres)
        {
            TRC(ERR, "_VCSndSendWaveDGram: sendto failed: %d\n",
                WSAGetLastError());
            goto exitpt;
        }

        g_dwPacketSize = sizeof(*pSndWave) + dwWaveDataLen;

        dwDataSize -= dwWaveDataLen;
        pData = ((LPSTR)(pData)) + dwWaveDataLen;
    }

    bSucc = TRUE;

exitpt:
    return bSucc;
}

BOOL
_VCSndSendWaveDGramInFrags(
    BYTE  cBlockNo,
    PVOID pData,
    DWORD dwDataSize
    )
{
    BOOL    bSucc = FALSE;
    struct sockaddr_in  sin;
    INT     sendres;
    PSNDUDPWAVE pWave;
    PSNDUDPWAVELAST pLast;
    PBYTE   pSource;
    PBYTE   pEnd;
    DWORD   dwFragSize;
    DWORD   dwNumFrags;
    DWORD   count;
    DWORD   dwSize;
    PVOID   pBuffer;
    UINT16  wStartTime;

    ASSERT( CanUDPFragment( g_wClientVersion ) && dwDataSize <= 0x8000 + RDPSND_SIGNATURE_SIZE );

    __try {
        pBuffer = _alloca( g_dwDGramSize );
    } __except((EXCEPTION_STACK_OVERFLOW == GetExceptionCode()) ?
                    EXCEPTION_EXECUTE_HANDLER :
                    EXCEPTION_CONTINUE_SEARCH)
    {
        _resetstkoflw();
        pBuffer = 0;
    }
    if ( NULL == pBuffer )
    {
        goto exitpt;
    }
    //
    //  calculate number of frags etc
    //
    dwFragSize = g_dwDGramSize - sizeof( *pLast );
    dwNumFrags = dwDataSize / dwFragSize;
    pSource = (PBYTE)pData;
    pEnd = pSource + dwDataSize;
    wStartTime = (UINT16)GetTickCount();

    // prepare the to address
    //
    sin.sin_family = PF_INET;
    sin.sin_port = (u_short)g_dwDGramPort;
    sin.sin_addr.s_addr = g_ulDGramAddress;

    //
    //  make sure we can fit all the frag counters
    //
    ASSERT( dwNumFrags < 0x7fff );

    if ( 0 != dwNumFrags )
    {
        pWave = (PSNDUDPWAVE)pBuffer;
        pWave->Type = SNDC_UDPWAVE;
        pWave->cBlockNo = cBlockNo;
        for( count = 0; count < dwNumFrags; count++ )
        {
            PBYTE pDest = (PBYTE)(&pWave->cFragNo);
            dwSize = sizeof( *pWave ) + dwFragSize;

            if ( count >= RDPSND_FRAGNO_EXT )
            {
                *pDest = (BYTE)(((count >> 8) & (~RDPSND_FRAGNO_EXT)) | RDPSND_FRAGNO_EXT);
                pDest++;
                *pDest = (BYTE)(count & 0xff);
                dwSize++;
            } else {
                *pDest = (BYTE)count;
            }
            pDest++;
            memcpy( pDest, pSource, dwFragSize );

            sendres = sendto(
                    g_hDGramSocket,
                    (LPSTR)pWave,
                    dwSize,
                    0,                                 // flags
                    (struct sockaddr *)&sin,           // to address
                    sizeof(sin));

            if (SOCKET_ERROR == sendres)
            {
                TRC(ERR, "_VCSndSendWaveDGramInFrags: sendto failed: %d\n",
                    WSAGetLastError());
                goto exitpt;
            }
            pSource += dwFragSize;
        }
    }

    ASSERT( pSource <= pEnd );
    //
    //  send the last fragment with all the extra info
    //
    pLast = (PSNDUDPWAVELAST)pBuffer;
    pLast->Type = SNDC_UDPWAVELAST;
    pLast->wTotalSize   = (UINT16)dwDataSize;
    pLast->wTimeStamp   = wStartTime;
    pLast->wFormatNo    = (UINT16)g_dwCurrentFormat;
    pLast->dwBlockNo    = (g_HiBlockNo << 8) + cBlockNo;
    dwSize = PtrToLong( (PVOID)( pEnd - pSource ));
    memcpy( pLast + 1, pSource, dwSize );
    sendres = sendto(
                g_hDGramSocket,
                (LPSTR)pLast,
                dwSize + sizeof( *pLast ),
                0,
                (struct sockaddr *)&sin,
                sizeof(sin)
            );

    if (SOCKET_ERROR == sendres)
    {
        TRC(ERR, "_VCSndSendWaveDGramInFrags: sendto failed: %d\n",
            WSAGetLastError());
        goto exitpt;
    }
    g_dwPacketSize = dwNumFrags * sizeof( *pWave ) + sizeof( *pLast ) + dwDataSize;

    bSucc = TRUE;

exitpt:
    return bSucc;
}

BOOL
_VCSndSendWaveVC(
    BYTE  cBlockNo,
    PVOID pData,
    DWORD dwDataSize
    )
{
    BOOL    bSucc = FALSE;
    SNDWAVE Wave;
    //
    // send this block through the virtual channel
    //
    TRC(ALV, "_VCSndSendWave: sending through VC\n");

    Wave.Prolog.Type = SNDC_WAVE;
    Wave.cBlockNo    = cBlockNo;
    Wave.wFormatNo   = (UINT16)g_dwCurrentFormat;
    Wave.wTimeStamp  = (UINT16)GetTickCount();
    Wave.Prolog.BodySize = (UINT16)( sizeof(Wave) - sizeof(Wave.Prolog) +
                            dwDataSize );

    bSucc = ChannelMessageWrite(
                &Wave,
                sizeof(Wave),
                pData,
                dwDataSize
    );

    g_dwPacketSize = sizeof(Wave) + Wave.Prolog.BodySize;

    if (!bSucc)
    {
        TRC(ERR, "_VCSndSendWave: failed to send wave: %d\n",
            GetLastError());
    }

    return bSucc;
}

/*
 *  Function:
 *      _VCSndSendWave
 *
 *  Description:
 *      Sends a wave data to the client
 *
 */
BOOL
_VCSndSendWave(
    BYTE  cBlockNo,
    PVOID pData,
    DWORD dwDataSize
    ) 
{
    BOOL    bSucc = FALSE;
    static BYTE    s_pDest[ TSSND_BLOCKSIZE + RDPSND_SIGNATURE_SIZE ];
    PBYTE   pDest = s_pDest + RDPSND_SIGNATURE_SIZE;

#if _SIM_RESAMPLE
    //
    //  resample randomly
    //
    if ( NULL != g_ppNegotiatedFormats && 0 == (cBlockNo % 32) )
    {
        _VCSndCloseConverter();

        g_dwCurrentFormat = rand() % g_dwNegotiatedFormats;
        g_dwDataRemain = 0;

        _VCSndOpenConverter();
    }
#endif
    _StatsCheckResample();

    if ( NULL != g_hacmStream )
    {
        DWORD dwDestSize = TSSND_BLOCKSIZE;
        if (!_VCSndConvert( (PBYTE) pData, dwDataSize, pDest, &dwDestSize ))
        {
            TRC(ERR, "_VCSndSendWave: conversion failed\n");
            goto exitpt;
        } else {
            pData = pDest;
            dwDataSize = dwDestSize;
        }
    } else {
        //
        // no conversion
        // use the data as it is
        // copy it in the s_pDest buffer
        //
        ASSERT( dwDataSize <= TSSND_BLOCKSIZE );
        memcpy( pDest, pData, dwDataSize );
    }

    if (
        INVALID_SOCKET != g_hDGramSocket &&
        0 != g_dwDGramPort &&
        0 != g_dwDGramSize &&
        0 != g_ulDGramAddress &&
        0 != g_dwLineBandwidth         // if this is 0, we don't have UDP
        )
    {
    //  Send a datagram
    //
        if ( !CanUDPFragment( g_wClientVersion ) &&
             dwDataSize + sizeof( SNDWAVE ) + RDPSND_SIGNATURE_SIZE > g_dwDGramSize )
        {
        //
        //  if the wave doesn't fit in the UDP packet use VCs
        //
            bSucc = _VCSndSendWaveVC( cBlockNo, pData, dwDataSize );
        } else {
            //
            //  add signature if necessary
            //
            if ( IsDGramWaveSigned( g_wClientVersion ))
            {
                if ( !IsDGramWaveAudioSigned( g_wClientVersion ))
                {
                    SL_Signature( s_pDest, (g_HiBlockNo << 8) + cBlockNo );
                } else {
                    SL_AudioSignature( s_pDest, (g_HiBlockNo << 8) + cBlockNo, 
                                       (PBYTE)pData, dwDataSize );
                }
                pData = s_pDest;
                dwDataSize += RDPSND_SIGNATURE_SIZE;
            }

            if ( CanUDPFragment( g_wClientVersion ) &&
                 dwDataSize + sizeof( SNDWAVE ) > g_dwDGramSize )
            {
                bSucc = _VCSndSendWaveDGramInFrags( cBlockNo, pData, dwDataSize );
            } else {
                bSucc = _VCSndSendWaveDGram( cBlockNo, pData, dwDataSize );
            }
        }
    } else {
        bSucc = _VCSndSendWaveVC( cBlockNo, pData, dwDataSize );
    }

    TRC(ALV, "_VCSndSendWave: BlockNo: %d sent\n", cBlockNo);

exitpt:

    return bSucc;
}


INT
WSInit(
    VOID
    )
{
    WORD    versionRequested;
    WSADATA wsaData;
    int     intRC;

    versionRequested = MAKEWORD(1, 1);

    intRC = WSAStartup(versionRequested, &wsaData);

    if (intRC != 0)
    {
        TRC(ERR, "Failed to initialize WinSock rc:%d\n", intRC);
    }
    return intRC;
}

/*
 *  Function:
 *      DGramRead
 *
 *  Description:
 *      Reads an UDP message (datagram)
 *
 */
VOID
DGramRead(
    HANDLE hDGramEvent,
    PVOID  *ppBuff,
    DWORD  *pdwSize
    )
{
    DWORD   dwRecvd;
    DWORD   dwFlags;
    INT     rc;

    if ( INVALID_SOCKET == g_hDGramSocket )
        goto exitpt;

    ASSERT( NULL != hDGramEvent );

    do {
        memset(&g_WSAOverlapped, 0, sizeof(g_WSAOverlapped));
        g_WSAOverlapped.hEvent = hDGramEvent;

        dwRecvd = 0;
        dwFlags = 0;

        g_wsabuf.len = sizeof( g_pDGramRecvData );
        g_wsabuf.buf = (char *) g_pDGramRecvData;

        rc = WSARecvFrom(
                g_hDGramSocket,
                &g_wsabuf,
                1,
                &dwRecvd,
                &dwFlags,
                NULL,       // no from address
                NULL,
                &g_WSAOverlapped,
                NULL);      // no completion routine

        if ( 0 == rc )
        {
        //
        //  data received
        //
            SNDMESSAGE SndMsg;

            if ( NULL != ppBuff && NULL != pdwSize )
            {
            //
            //  pass the data to the caller
            //
                *ppBuff  = g_pDGramRecvData;
                *pdwSize = dwRecvd;
                goto exitpt;
            }


            if ( dwRecvd < sizeof( SNDPROLOG ))
            {
                TRC(WRN, "DGramRead: invalid message received: len=%d\n",
                    dwRecvd );
                continue;
            }
            
            memcpy( &SndMsg.Prolog, g_pDGramRecvData, sizeof( SNDPROLOG ));
            SndMsg.pBody = g_pDGramRecvData + sizeof( SNDPROLOG );

            TRC(ALV, "DGramRead: data received\n");

            //  parse this packet
            //
                VCSndDataArrived( &SndMsg );
        }
    }
    while ( SOCKET_ERROR != rc );

exitpt:
    ;
}

/*
 *  Function:
 *      DGramReadCompletion
 *
 *  Description:
 *      Datagram read completion
 *
 */
VOID
DGramReadComplete(
    PVOID  *ppBuff,
    DWORD  *pdwSize
    )
{
    BOOL        rc;
    SNDMESSAGE  SndMsg;
    DWORD       dwFlags = 0;
    DWORD       dwRecvd = 0;

    ASSERT( INVALID_SOCKET != g_hDGramSocket );

    rc = WSAGetOverlappedResult(
            g_hDGramSocket,
            &g_WSAOverlapped,
            &dwRecvd,
            FALSE,
            &dwFlags
        );

    if ( !rc )
    {
        TRC(ERR, "DGramReadComplete: WSAGetOverlappedResult failed=%d\n",
                WSAGetLastError());
        goto exitpt;
    }

    //
    //  data received
    //

    if ( dwRecvd < sizeof( SNDPROLOG ))
    {
        TRC(WRN, "DGramReadComplete: invalid message received: len=%d\n",
            dwRecvd );
        goto exitpt;
    }

    if ( NULL != ppBuff && NULL != pdwSize )
    {
    //
    //  pass the data to the caller
    //
        *ppBuff  = g_pDGramRecvData;
        *pdwSize = dwRecvd;
        goto exitpt;
    }

    memcpy( &SndMsg.Prolog, g_pDGramRecvData, sizeof( SNDPROLOG ));
    SndMsg.pBody = g_pDGramRecvData + sizeof( SNDPROLOG );

    TRC(ALV, "DGramReadComplete: data received\n");

    //  parse this packet
    //
    VCSndDataArrived( &SndMsg );

exitpt:
    ;
}

/*
 *  Add an ACE to object security descriptor
 */
DWORD 
AddAceToObjectsSecurityDescriptor (
    HANDLE hObject,             // handle to object
    SE_OBJECT_TYPE ObjectType,  // type of object
    LPTSTR pszTrustee,          // trustee for new ACE
    TRUSTEE_FORM TrusteeForm,   // format of TRUSTEE structure
    DWORD dwAccessRights,       // access mask for new ACE
    ACCESS_MODE AccessMode,     // type of ACE
    DWORD dwInheritance         // inheritance flags for new ACE
) 
{
    DWORD dwRes;
    PACL pOldDACL = NULL, pNewDACL = NULL;
    PSECURITY_DESCRIPTOR pSD = NULL;
    EXPLICIT_ACCESS ea;

    if (NULL == hObject) 
        return ERROR_INVALID_PARAMETER;

    // Get a pointer to the existing DACL.

    dwRes = GetSecurityInfo(hObject, ObjectType, 
          DACL_SECURITY_INFORMATION,
          NULL, NULL, &pOldDACL, NULL, &pSD);

    if (ERROR_SUCCESS != dwRes) 
    {
        TRC( ERR, "GetSecurityInfo Error %u\n", dwRes );
        goto exitpt; 
    }  

    // Initialize an EXPLICIT_ACCESS structure for the new ACE. 

    ZeroMemory(&ea, sizeof(EXPLICIT_ACCESS));
    ea.grfAccessPermissions = dwAccessRights;
    ea.grfAccessMode = AccessMode;
    ea.grfInheritance= dwInheritance;
    ea.Trustee.TrusteeForm = TrusteeForm;
    ea.Trustee.ptstrName = pszTrustee;

    // Create a new ACL that merges the new ACE
    // into the existing DACL.

    dwRes = SetEntriesInAcl(1, &ea, pOldDACL, &pNewDACL);
    if (ERROR_SUCCESS != dwRes)  
    {
        TRC( ERR, "SetEntriesInAcl Error %u\n", dwRes );
        goto exitpt; 
    }  

    // Attach the new ACL as the object's DACL.

    dwRes = SetSecurityInfo(hObject, ObjectType, 
          DACL_SECURITY_INFORMATION,
          NULL, NULL, pNewDACL, NULL);

    if (ERROR_SUCCESS != dwRes)  
    {
        TRC( ERR, "SetSecurityInfo Error %u\n", dwRes );
        goto exitpt; 
    }  

exitpt:

    if(pSD != NULL) 
        LocalFree((HLOCAL) pSD); 
    if(pNewDACL != NULL) 
        LocalFree((HLOCAL) pNewDACL); 

    return dwRes;
}

/*
 *  Add "system" account with full control over this handle
 *
 */
BOOL
_ObjectAllowSystem(
    HANDLE h
    )
{
    BOOL rv = FALSE;
    PSID pSidSystem;
    SID_IDENTIFIER_AUTHORITY AuthorityNt = SECURITY_NT_AUTHORITY;
    DWORD dw;

    if (!AllocateAndInitializeSid(&AuthorityNt, 1, SECURITY_LOCAL_SYSTEM_RID, 0, 0, 0, 0, 0, 0, 0, &pSidSystem))
    {
        TRC( ERR, "AllocateAndInitializeSid failed: %d\n",
                  GetLastError() );
        goto exitpt;
    }

    ASSERT(IsValidSid(pSidSystem));

    dw = AddAceToObjectsSecurityDescriptor (
        h,                           // handle to object
        SE_KERNEL_OBJECT,            // type of object
        (LPTSTR)pSidSystem,          // trustee for new ACE
        TRUSTEE_IS_SID,              // format of TRUSTEE structure
        GENERIC_ALL,                 // access mask for new ACE
        GRANT_ACCESS,                // type of ACE
        0                            // inheritance flags for new ACE
    );

    if ( ERROR_SUCCESS != dw )
    {

        TRC( ERR, "AddAceToObjectsSecurityDescriptor failed=%d\n", dw );
        goto exitpt;
    }

    rv = TRUE;
exitpt:

    return rv;
}

VOID
_SignalInitializeDone(
    VOID
    )
{
    HANDLE hInitEvent = OpenEvent( EVENT_MODIFY_STATE,
                                   FALSE,
                                   TSSND_WAITTOINIT );

    g_Stream->dwSoundCaps |= TSSNDCAPS_INITIALIZED;

    if ( NULL != hInitEvent )
    {
        PulseEvent( hInitEvent );
        CloseHandle( hInitEvent );
    }

    TRC( INF, "Audio host is ready!\n" );
}

/*
 *  Function:
 *      VCSndIoThread
 *
 *  Description:
 *      Main entry pint for this thread
 *
 */
INT
WINAPI
VCSndIoThread(
    PVOID pParam
    )
{
    HANDLE          ahEvents[TOTAL_EVENTS];
    HANDLE          hReadEvent = NULL;
    HANDLE          hDGramEvent = NULL;
    SNDMESSAGE      SndMessage;
    DWORD           dwres;
    ULONG           logonId;
    HANDLE          hReconnectEvent = NULL;
    WCHAR           szEvName[64];
    BYTE            i;

    _VCSndReadRegistry();

    memset (&SndMessage, 0, sizeof(SndMessage));

    WSInit();


    // create the global/local events
    //
    g_hDataReadyEvent = CreateEvent(NULL,
                                    FALSE, 
                                    FALSE, 
                                    TSSND_DATAREADYEVENT);
    g_hStreamIsEmptyEvent = CreateEvent(NULL, 
                                        FALSE, 
                                        TRUE, 
                                        TSSND_STREAMISEMPTYEVENT);

    g_hStreamMutex = CreateMutex(NULL, FALSE, TSSND_STREAMMUTEX);

    hReadEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    hDGramEvent = WSACreateEvent();

    if (NULL == g_hDataReadyEvent ||
        NULL == g_hStreamIsEmptyEvent ||
        NULL == g_hStreamMutex ||
        NULL == hReadEvent ||
        NULL == hDGramEvent)
    {
        TRC(FATAL, "VCSndIoThread: no events\n");
        goto exitpt;
    }

    //  adjust privileges on the events
    //
    if (!_ObjectAllowSystem( g_hDataReadyEvent ))
        goto exitpt;
    if (!_ObjectAllowSystem( g_hStreamIsEmptyEvent ))
        goto exitpt;
    if (!_ObjectAllowSystem( g_hStreamMutex ))
        goto exitpt;

    //  create the stream
    //
    g_hStream = CreateFileMapping(
                    INVALID_HANDLE_VALUE,   //PG.SYS
                    NULL,                    // security
                    PAGE_READWRITE,
                    0,                      // Size high
                    sizeof(*g_Stream),      // Size low
                    TSSND_STREAMNAME        // mapping name
                    );

    if (NULL == g_hStream)
    {
        TRC(FATAL, "DllInstanceInit: failed to create mapping: %d\n",
                    GetLastError());
        goto exitpt;
    }

    if (!_ObjectAllowSystem( g_hStream ))
        goto exitpt;

    g_Stream = (PSNDSTREAM) MapViewOfFile(
                    g_hStream,
                    FILE_MAP_ALL_ACCESS,
                    0, 0,       // offset
                    sizeof(*g_Stream)
                    );

    if (NULL == g_Stream)
    {
        TRC(ERR, "VCSndIoThread: "
                 "can't map the stream view: %d\n",
                 GetLastError());
        goto exitpt;
    }

    //  Initialize the stream
    //
    if (VCSndAcquireStream())
    {
        memset(g_Stream, 0, sizeof(*g_Stream) - sizeof(g_Stream->pSndData));
        memset(g_Stream->pSndData, 0x00000000, sizeof(g_Stream->pSndData));
        g_Stream->cLastBlockConfirmed   = g_Stream->cLastBlockSent - 1;

        //
        // no socket created, so far
        //
        g_hDGramSocket = INVALID_SOCKET;

        VCSndReleaseStream();

    } else {
    
        TRC(FATAL, "VCSndIoThread, can't map the stream: %d, aborting\n",
                   GetLastError());
        goto exitpt;
    }

    if (!ProcessIdToSessionId(GetCurrentProcessId(), &logonId))
    {
        TRC(FATAL, "VCSndIoThread: failed to het session Id. %d\n",
            GetLastError());
        goto exitpt;
    }

    //  create disconnect/reconnect events
    //
    wcsncpy(szEvName, L"RDPSound-Disconnect", sizeof(szEvName)/sizeof(szEvName[0]));

    g_hDisconnectEvent = CreateEvent(NULL, FALSE, FALSE, szEvName);
    if (NULL == g_hDisconnectEvent)
    {
        TRC(FATAL, "VCSndIoThread: can't create disconnect event. %d\n",
            GetLastError());
        goto exitpt;
    }

    wcsncpy(szEvName, L"RDPSound-Reconnect", sizeof(szEvName)/sizeof(szEvName[0]));

    hReconnectEvent = CreateEvent(NULL, FALSE, FALSE, szEvName);
    if (NULL == hReconnectEvent)
    {
        TRC(FATAL, "VCSndIoThread: can't create reconnect event. %d\n",
            GetLastError());
        goto exitpt;
    }

    if (!ChannelOpen())
    {
        TRC(FATAL, "VCSndIoThread: unable to open virtual channel\n");
        goto exitpt;
    }

    ahEvents[READ_EVENT]         = hReadEvent;
    ahEvents[DISCONNECT_EVENT]   = g_hDisconnectEvent;
    ahEvents[RECONNECT_EVENT]    = hReconnectEvent;
    ahEvents[DATAREADY_EVENT]    = g_hDataReadyEvent;
    ahEvents[DGRAM_EVENT]        = hDGramEvent;
    ahEvents[POWERWAKEUP_EVENT]  = g_hPowerWakeUpEvent;
    ahEvents[POWERSUSPEND_EVENT] = g_hPowerSuspendEvent;

    _VCSndCheckDevice( hReadEvent, hDGramEvent );

    //  Check the channel for data
    //
    while (ChannelReceiveMessage(&SndMessage, hReadEvent))
    {
        VCSndDataArrived(&SndMessage);
        SndMessage.uiPrologReceived = 0;
        SndMessage.uiBodyReceived = 0;
    }

    DGramRead( hDGramEvent, NULL, NULL );

    //
    //  signal all workers waiting for initialize
    //
    _SignalInitializeDone();

    // main loop
    //
    while (g_bRunning)
    {
        DWORD dwNumEvents = sizeof(ahEvents)/sizeof(ahEvents[0]);

        dwres = WaitForMultipleObjectsEx(
                              dwNumEvents,                  // count
                              ahEvents,                     // events
                              FALSE,                        // wait all
                              DEFAULT_RESPONSE_TIMEOUT,
                              FALSE                         // non alertable
                            );

        if (!g_bRunning)
            TRC(ALV, "VCSndIoThread: time to exit\n");

        if (WAIT_TIMEOUT != dwres)
            TRC(ALV, "VCSndIoThread: an event was fired\n");

        if (READ_EVENT == dwres)
        //
        //  data is ready to read
        //
        {
            ChannelBlockReadComplete();
            ResetEvent(ahEvents[0]);

            //  Check the channel for data
            //
            while (ChannelReceiveMessage(&SndMessage, hReadEvent))
            {
                VCSndDataArrived(&SndMessage);
                SndMessage.uiPrologReceived = 0;
                SndMessage.uiBodyReceived = 0;
            }

        } else if (( DISCONNECT_EVENT == dwres ) ||    // disconnect event
                   ( POWERSUSPEND_EVENT == dwres ))         // suspend event
        {
        //  disconnect event
        //
            TRC(INF, "VCSndIoThread: DISCONNECTED\n");
            _VCSndCloseDevice();
            _VCSndCloseConverter();
            ChannelClose();
            _StatReset();
            if ( DISCONNECT_EVENT == dwres )
            {
                g_bDisconnected = TRUE;
            } else {
                g_bSuspended = TRUE;
            }
            continue;

        } else if (( RECONNECT_EVENT == dwres ) ||     // reconnect event
                   ( POWERWAKEUP_EVENT == dwres )) 
        {
        //  reconnect event
        //
            if ( POWERWAKEUP_EVENT == dwres )
            {
            // power wakeup event
            // here, we may have not received suspend event, but in that case we
            // had failed to send, so check the g_bDeviceFailed flag and act only if it is on
                if ( g_bDisconnected )
                {
                // no reason to process power wake up if we are not remote
                //
                    g_bSuspended = FALSE;
                    continue;
                }
                if ( !g_bSuspended && !g_bDeviceFailed )
                {
                // if neither of these happend
                // then we don't care
                    continue;
                }
            }

            TRC(INF, "VCSndIoThread: RECONNECTED\n");
            if (!ChannelOpen())
            {
                TRC(FATAL, "VCSndIoThread: unable to open virtual channel\n");
            } else {
                _VCSndCheckDevice( hReadEvent, hDGramEvent );
                //
                //  start the receive loop again
                //
                if (ChannelReceiveMessage(&SndMessage, hReadEvent))
                {
                    VCSndDataArrived(&SndMessage);
                    SndMessage.uiPrologReceived = 0;
                    SndMessage.uiBodyReceived = 0;
                }

                if ( RECONNECT_EVENT == dwres )
                {
                    g_bDisconnected = FALSE;
                } else {
                    g_bSuspended = FALSE;
                }
                g_bDeviceFailed = FALSE;

                // kick the player
                //
                PulseEvent( g_hStreamIsEmptyEvent );
                _SignalInitializeDone();
            }
        } else if ( DGRAM_EVENT == dwres )
        {
        //
        //  DGram ready  
        //
            DGramReadComplete( NULL, NULL );
            //
            //  atttempt more read
            //
            DGramRead( hDGramEvent, NULL, NULL );
        }

        //  Check for data available from the apps
        //
        if (!VCSndAcquireStream())
        {
            TRC(FATAL, "VCSndIoThread: somebody is holding the "
                       "Stream mutext for too long\n");
            continue;
        }

        //  if this was a reconnect
        //  roll back to the last block sent
        //
        if ( RECONNECT_EVENT == dwres)
        {
            //
            // clean this chunk for the next mix
            //
            memset( g_Stream->pSndData, 0, TSSND_MAX_BLOCKS * TSSND_BLOCKSIZE );

            g_Stream->cLastBlockConfirmed = g_Stream->cLastBlockSent;
        }

        //
        //  if we have not received confirmation
        //  for the packets sent, just give up and continue
        //
        if (WAIT_TIMEOUT == dwres &&
            g_bDeviceOpened &&
            g_Stream->cLastBlockSent != g_Stream->cLastBlockConfirmed)
        {
            BYTE cCounter;

            TRC(WRN, "VCSndIoThread: not received confirmation for blocks "
                     "between %d and %d\n",
                      g_Stream->cLastBlockConfirmed,
                      g_Stream->cLastBlockSent);

            for ( cCounter = g_Stream->cLastBlockConfirmed;
                 cCounter != (BYTE)(g_Stream->cLastBlockSent + 1);
                 cCounter++)
            {
                _StatsCollect(( GetTickCount() - DEFAULT_RESPONSE_TIMEOUT ) &
                                0xffff );
            }
            //
            // end of the loop
            //
            g_Stream->cLastBlockConfirmed = g_Stream->cLastBlockSent;
            //
            //  kick the player
            //
            PulseEvent(g_hStreamIsEmptyEvent);
        }

        // Check for control commands
        //
        // Volume
        //
        if ( g_bDeviceOpened && g_Stream->bNewVolume &&
            0 != (g_Stream->dwSoundCaps & TSSNDCAPS_VOLUME))
        {
            SNDSETVOLUME SetVolume;

            TRC(ALV, "VCSndIoThread: new volume\n");

            SetVolume.Prolog.Type = SNDC_SETVOLUME;
            SetVolume.Prolog.BodySize = sizeof(SetVolume) - sizeof(SetVolume.Prolog);
            SetVolume.dwVolume = g_Stream->dwVolume;

            ChannelBlockWrite(
                    &SetVolume,
                    sizeof(SetVolume)
                );

            g_Stream->bNewVolume = FALSE;
        }

        //  Pitch
        //
        if ( g_bDeviceOpened && g_Stream->bNewPitch &&
            0 != (g_Stream->dwSoundCaps & TSSNDCAPS_PITCH))
        {
            SNDSETPITCH SetPitch;

            TRC(ALV, "VCSndIoThread: new pitch\n");

            SetPitch.Prolog.Type = SNDC_SETPITCH;
            SetPitch.Prolog.BodySize = sizeof(SetPitch) - sizeof(SetPitch.Prolog);
            SetPitch.dwPitch = g_Stream->dwPitch;

            ChannelBlockWrite(
                    &SetPitch,
                    sizeof(SetPitch)
                );

            g_Stream->bNewPitch = FALSE;
        }

        //  Check for data available from the apps
        //
        if (g_Stream->cLastBlockSent != g_Stream->cLastBlockQueued &&
            (BYTE)(g_Stream->cLastBlockSent - g_Stream->cLastBlockConfirmed) <
                g_dwBlocksOnTheNet
            )
        {
        //  Aha, here's some data to send
        //

            TRC(ALV, "VCSndIoThread: will send some data\n");

            if (g_bDisconnected || g_bSuspended || g_bDeviceFailed)
            {
                TRC(ALV, "Device is disconnected. ignore the packets\n");
                g_Stream->cLastBlockSent = g_Stream->cLastBlockQueued;
                g_Stream->cLastBlockConfirmed = g_Stream->cLastBlockSent - 1;

                PulseEvent( g_hStreamIsEmptyEvent );
            } else
            if (!g_bDeviceOpened)
            {
            // send an "open device" command
            //
                SNDPROLOG Prolog;

                    //
                    //  first, try to open the acm converter
                    //
                    _VCSndOpenConverter();
                    //
                    // if we failed width the converter will
                    // send in native format
                    //
                    g_bDeviceOpened = TRUE;
            }

            for (i = g_Stream->cLastBlockSent; 
                 i != g_Stream->cLastBlockQueued &&
                    (BYTE)(g_Stream->cLastBlockSent - 
                        g_Stream->cLastBlockConfirmed) <
                    g_dwBlocksOnTheNet;
                 i++)
            {
                BOOL bSucc;

//                TRC( INF, "Sending block # %d, last conf=%d, last queued=%d\n", i, g_Stream->cLastBlockConfirmed, g_Stream->cLastBlockSent );
                bSucc = _VCSndSendWave(
                            i,              // block no
                            ((LPSTR)g_Stream->pSndData) +
                                ((i % TSSND_MAX_BLOCKS) * TSSND_BLOCKSIZE),
                            TSSND_BLOCKSIZE
                );

                //
                // clean this chunk for the next mix
                //
                memset(g_Stream->pSndData +
                        (i % TSSND_MAX_BLOCKS) *
                        TSSND_BLOCKSIZE,
                        0x00000000,
                        TSSND_BLOCKSIZE);

                if ( 0xff == i )
                    g_HiBlockNo++;

                if (bSucc)
                {
                    g_Stream->cLastBlockSent = i + 1;
                }
                else
                {
                    TRC(WRN, "VCSndIoThread: failed to send, "
                             "disabling the device\n");
                    //
                    //  act the same way as DISCONNECT
                    //
                    _VCSndCloseDevice();
                    _VCSndCloseConverter();
                    ChannelClose();

                    g_Stream->cLastBlockConfirmed =
                        g_Stream->cLastBlockSent = g_Stream->cLastBlockQueued;
                    _StatReset();

                    g_bDeviceFailed = TRUE;
                    //
                    //  Break this loop
                    //
                    break;
                }
            }
        }

        //  Check if there's no more data
        //  if so, close the remote device
        //
        if (g_bDeviceOpened &&
            g_Stream->cLastBlockQueued == g_Stream->cLastBlockSent &&
            g_Stream->cLastBlockSent == g_Stream->cLastBlockConfirmed)
        {
            SNDPROLOG Prolog;

            TRC(ALV, "VCSndIoThread: no more data, closing the device\n");

            _VCSndCloseConverter();

            Prolog.Type = SNDC_CLOSE;
            Prolog.BodySize = 0;

            ChannelBlockWrite(&Prolog, sizeof(Prolog));

            g_bDeviceOpened = FALSE;
            
        }

        VCSndReleaseStream();

    }

exitpt:
    ChannelClose();
    if (NULL != hReadEvent)
        CloseHandle(hReadEvent);

    if (NULL != hDGramEvent)
        WSACloseEvent( hDGramEvent );

    if (SndMessage.pBody)
        TSFREE(SndMessage.pBody);

    if (NULL != hReconnectEvent)
        CloseHandle(hReconnectEvent);

    if (NULL != g_hDisconnectEvent)
        CloseHandle(g_hDisconnectEvent);

    if (NULL != g_hStreamIsEmptyEvent)
        CloseHandle(g_hStreamIsEmptyEvent);

    if (VCSndAcquireStream())
    {
        //
        //  mark the device dead
        //
        g_Stream->dwSoundCaps = TSSNDCAPS_TERMINATED;

        VCSndReleaseStream();

        _SignalInitializeDone();
    }

    if (NULL != g_Stream)
    {
        if (INVALID_SOCKET != g_hDGramSocket)
            closesocket(g_hDGramSocket);

        UnmapViewOfFile(g_Stream);
    }

    if (NULL != g_hStream)
        CloseHandle(g_hStream);

    if (NULL != g_hStreamMutex)
        CloseHandle(g_hStreamMutex);

    // clean the previously negotiated format
    //
    if (NULL != g_ppNegotiatedFormats)
    {
        DWORD i;
        for ( i = 0; i < g_dwNegotiatedFormats; i++ )
        {
            if ( NULL != g_ppNegotiatedFormats[i] )
                TSFREE( g_ppNegotiatedFormats[i] );
        }
        TSFREE( g_ppNegotiatedFormats );

    }

    //
    //  cleanup the format list
    //
    if ( NULL != g_pAllCodecsFormatList )
    {
        PVCSNDFORMATLIST pIter;

        pIter = g_pAllCodecsFormatList;
        while( NULL != pIter )
        {
            PVCSNDFORMATLIST pNext = pIter->pNext;

            TSFREE( pIter );

            pIter = pNext;
        }
    }

    if ( NULL != g_AllowCodecs )
    {
        TSFREE( g_AllowCodecs );
        g_AllowCodecs = NULL;
        g_AllowCodecsSize = 0;
    }

    WSACleanup();

    TRC(INF, "VCSndIoThread: EXIT !\n");

    return 0;
}

/////////////////////////////////////////////////////////////////////
//
//  Startup code
//
/////////////////////////////////////////////////////////////////////


VOID
TSSNDD_Term(
    VOID
    )
{

    if ( NULL == g_hThread )
        return;

    g_bRunning = FALSE;
    //
    //  kick the io thread
    //
    if (NULL != g_hDataReadyEvent)
        SetEvent(g_hDataReadyEvent);

    if ( NULL != g_hThread )
    {
        WaitForSingleObject(g_hThread, DEFAULT_VC_TIMEOUT);
        CloseHandle(g_hThread);
        g_hThread = NULL;
    }

    if (NULL != g_hDataReadyEvent)
    {
        CloseHandle(g_hDataReadyEvent);
        g_hDataReadyEvent = NULL;
    }

    if ( NULL != g_hPowerWakeUpEvent )
    {
        CloseHandle( g_hPowerWakeUpEvent );
        g_hPowerWakeUpEvent = NULL;
    }
    if ( NULL != g_hPowerSuspendEvent )
    {
        CloseHandle( g_hPowerSuspendEvent );
        g_hPowerSuspendEvent = NULL;
    }
}

LRESULT
TSSNDD_PowerMessage(
    WPARAM wParam,
    LPARAM lParam
    )
{
    switch( wParam )
    {
    case PBT_APMSUSPEND:
        //
        //  signal only if connected
        //
        if ( NULL != g_hPowerSuspendEvent )
        {
            SetEvent( g_hPowerSuspendEvent );
        }
    break;
    case PBT_APMRESUMEAUTOMATIC:
    case PBT_APMRESUMECRITICAL:
    case PBT_APMRESUMESUSPEND:
        //
        //  signal only if not connected
        //
        if ( NULL != g_hPowerWakeUpEvent )
        {
            SetEvent( g_hPowerWakeUpEvent );
        }
    break;
    }

    return TRUE;
}

LRESULT
CALLBACK
_VCSndWndProc(
    HWND hwnd,
    UINT uiMessage,
    WPARAM wParam,
    LPARAM lParam
    )
{
    LRESULT rv = 0;

    switch( uiMessage )
    {
    case WM_CREATE:
    break;

    case WM_CLOSE:
        DestroyWindow(hwnd);
    break;

    case WM_DESTROY:
        PostQuitMessage(0);
    break;

    case WM_ENDSESSION:
        TSSNDD_Term();
    break;

    case WM_POWERBROADCAST:
        rv = TSSNDD_PowerMessage( wParam, lParam );
    break;

    default:
        rv = DefWindowProc(hwnd, uiMessage, wParam, lParam);
    }

    return rv;
}

BOOL
TSSNDD_Loop(
    HINSTANCE   hInstance 
    )
{
    BOOL        rv = FALSE;
    WNDCLASS    wc;
    DWORD       dwLastErr;
    HWND        hWnd = NULL;
    MSG         msg;

    memset(&wc, 0, sizeof(wc));

    wc.lpfnWndProc      = _VCSndWndProc;
    wc.hInstance        = hInstance;
    wc.hbrBackground    = (HBRUSH)GetStockObject(HOLLOW_BRUSH);
    wc.lpszClassName    = _RDPSNDWNDCLASS;

    if (!RegisterClass (&wc) &&
        (dwLastErr = GetLastError()) &&
         dwLastErr != ERROR_CLASS_ALREADY_EXISTS)
    {
        TRC(ERR,
              "TSSNDD_Loop: Can't register class. GetLastError=%d\n",
              GetLastError());
        goto exitpt;
    }


    hWnd = CreateWindow(
                       _RDPSNDWNDCLASS,
                       _RDPSNDWNDCLASS,         // Window name
                       WS_OVERLAPPEDWINDOW,     // dwStyle
                       0,            // x
                       0,            // y
                       100,          // nWidth
                       100,          // nHeight
                       NULL,         // hWndParent
                       NULL,         // hMenu
                       hInstance,
                       NULL);        // lpParam

    if (!hWnd)
    {
        TRC(ERR, "TSSNDD_Loop: Failed to create message window: %d\n",
                GetLastError());
        goto exitpt;
    }

    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    rv = TRUE;

exitpt:
    return rv;
}

BOOL
TSSNDD_Init(
    )
{
    BOOL    rv = FALSE;

    DWORD   dwThreadId;

    g_bRunning = TRUE;

    if ( NULL == g_hPowerWakeUpEvent )
    {
        g_hPowerWakeUpEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
        if ( NULL == g_hPowerWakeUpEvent )
        {
            TRC( FATAL, "TSSNDD_Init: failed to create power wakeup notification message: %d\n", GetLastError() );
            goto exitpt;
        }
    }
    if ( NULL == g_hPowerSuspendEvent )
    {
        g_hPowerSuspendEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
        if ( NULL == g_hPowerSuspendEvent )
        {
            TRC( FATAL, "TSSNDD_Init: failed to create power suspend notification message: %d\n", GetLastError() );
            goto exitpt;
        }
    }

    g_hThread = CreateThread(
                        NULL,
                        0,
                        (LPTHREAD_START_ROUTINE)VCSndIoThread,
                        NULL,
                        0,
                        &dwThreadId
                        );

    if (NULL == g_hThread)
    {
        TRC(FATAL, "WinMain: can't create thread: %d. Aborting\n",
            GetLastError());
        goto exitpt;
    }

    rv = TRUE;

exitpt:
    return rv;
}

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

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

    if (szLevel == ALV)
        return;

    va_start (arglist, szFormat);
    _vsnprintf (szBuffer, RTL_NUMBER_OF(szBuffer), szFormat, arglist);
    va_end (arglist);
    szBuffer[ RTL_NUMBER_OF( szBuffer ) - 1 ] = 0;

    OutputDebugStringA(szLevel);
    OutputDebugStringA(szBuffer);
}