2977 lines
74 KiB
C++
2977 lines
74 KiB
C++
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Module: rdpsndc.c
|
|
//
|
|
// Purpose: Client-side audio redirection
|
|
//
|
|
// Copyright(C) Microsoft Corporation 2000
|
|
//
|
|
// History: 4-10-2000 vladimis [created]
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
#include "precom.h"
|
|
#include <sha.h>
|
|
#include <rc4.h>
|
|
#include "rdpsndc.h"
|
|
|
|
#undef ASSERT
|
|
#ifdef DBG
|
|
#undef TRC
|
|
#define TRC _DbgPrintMessage
|
|
#define ASSERT(Cond) if (!(Cond)) \
|
|
{ \
|
|
::_DbgPrintMessage( \
|
|
FATAL, \
|
|
_T("ASSERT in file: %s, line %d\n"), \
|
|
_T(__FILE__), \
|
|
__LINE__); \
|
|
DebugBreak(); \
|
|
}
|
|
#else // !DBG
|
|
#define TRC
|
|
#define ASSERT
|
|
#endif // !DBG
|
|
|
|
|
|
#ifdef UNICODE
|
|
#define _NAMEOFCLAS L"RDPSoundWnd"
|
|
#else // !UNICODE
|
|
#define _NAMEOFCLAS "RDPSoundWnd"
|
|
#endif
|
|
|
|
|
|
#define WM_WSOCK WM_USER
|
|
#define WM_RESAMPLE (WM_USER + 1)
|
|
|
|
#define WAVE_CLOSE_TIMEOUT 3000
|
|
|
|
//
|
|
// WMA codec description
|
|
//
|
|
#define WMAUDIO_DEC_KEY "1A0F78F0-EC8A-11d2-BBBE-006008320064"
|
|
#define WAVE_FORMAT_WMAUDIO2 0x161
|
|
#ifdef _WIN32
|
|
#include <pshpack1.h>
|
|
#else
|
|
#ifndef RC_INVOKED
|
|
#pragma pack(1)
|
|
#endif
|
|
#endif
|
|
typedef struct wmaudio2waveformat_tag {
|
|
WAVEFORMATEX wfx;
|
|
DWORD dwSamplesPerBlock;
|
|
WORD wEncodeOptions;
|
|
DWORD dwSuperBlockAlign;
|
|
} WMAUDIO2WAVEFORMAT;
|
|
#ifdef _WIN32
|
|
#include <poppack.h>
|
|
#else
|
|
#ifndef RC_INVOKED
|
|
#pragma pack()
|
|
#endif
|
|
#endif
|
|
|
|
// Trace levels
|
|
//
|
|
const TCHAR *ALV = _T("TSSNDC - ALV:");
|
|
const TCHAR *INF = _T("TSSNDC - INF:");
|
|
const TCHAR *WRN = _T("TSSNDC - WRN:");
|
|
const TCHAR *ERR = _T("TSSNDC - ERR:");
|
|
const TCHAR *FATAL = _T("TSSNDC - !FATAL!:");
|
|
|
|
/*
|
|
* Function declarations
|
|
*
|
|
*/
|
|
|
|
VOID
|
|
VCAPITYPE
|
|
OpenEventFnEx(
|
|
IN PVOID lpUserParam,
|
|
IN DWORD OpenHandle,
|
|
IN UINT event,
|
|
IN PVOID pData,
|
|
IN UINT32 dataLength,
|
|
IN UINT32 totalLength,
|
|
IN UINT32 dataFlags
|
|
);
|
|
|
|
INT
|
|
WSInit(
|
|
VOID
|
|
);
|
|
|
|
LRESULT
|
|
CALLBACK
|
|
MsgWndProc(
|
|
HWND hwnd,
|
|
UINT uiMessage,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
);
|
|
|
|
VOID
|
|
_cdecl
|
|
_DbgPrintMessage(
|
|
LPCTSTR level,
|
|
LPCTSTR format,
|
|
...
|
|
);
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
* Function:
|
|
* OpenEventFn
|
|
*
|
|
* Description:
|
|
* Called by the TS client on channel read/write ready
|
|
*
|
|
* Parameters:
|
|
* lpUserParam - parameter passed from VirtualChannelEntryEx
|
|
* OpenaHandle - Channel handle, returned by VirtualChanneOpen
|
|
* event - event type
|
|
* pData - meaning depends on event type
|
|
* dataLength - size of pData
|
|
* dataFlags - information about the received data
|
|
*
|
|
*/
|
|
VOID
|
|
VCAPITYPE
|
|
OpenEventFnEx(
|
|
IN PVOID lpUserParam,
|
|
IN DWORD OpenHandle,
|
|
IN UINT event,
|
|
IN PVOID pData,
|
|
IN UINT32 dataLength,
|
|
IN UINT32 totalLength,
|
|
IN UINT32 dataFlags
|
|
)
|
|
{
|
|
CRDPSound *pSnd;
|
|
|
|
ASSERT( NULL != lpUserParam );
|
|
|
|
if ( NULL != lpUserParam )
|
|
{
|
|
pSnd = ((VCManager*)lpUserParam)->GetSound();
|
|
ASSERT( NULL != pSnd );
|
|
|
|
if ( NULL != pSnd )
|
|
pSnd->OpenEventFn(
|
|
OpenHandle,
|
|
event,
|
|
pData,
|
|
dataLength,
|
|
totalLength,
|
|
dataFlags
|
|
);
|
|
}
|
|
}
|
|
|
|
LRESULT
|
|
CALLBACK
|
|
MsgWndProc(
|
|
HWND hwnd,
|
|
UINT uiMessage,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
LRESULT rv = 0;
|
|
CRDPSound *pSnd;
|
|
|
|
pSnd = (CRDPSound *)
|
|
#ifndef OS_WINCE
|
|
GetWindowLongPtr( hwnd, GWLP_USERDATA );
|
|
#else // OS_WINCE
|
|
GetWindowLong( hwnd, GWL_USERDATA );
|
|
#endif
|
|
|
|
switch (uiMessage)
|
|
{
|
|
case MM_WOM_OPEN:
|
|
ASSERT( NULL != pSnd );
|
|
if ( NULL != pSnd )
|
|
pSnd->vcwaveCallback( (HWAVEOUT)wParam, WOM_OPEN, NULL );
|
|
break;
|
|
case MM_WOM_CLOSE:
|
|
ASSERT( NULL != pSnd );
|
|
if ( NULL != pSnd )
|
|
pSnd->vcwaveCallback( (HWAVEOUT)wParam, WOM_CLOSE, NULL );
|
|
break;
|
|
|
|
case MM_WOM_DONE:
|
|
ASSERT( NULL != pSnd );
|
|
if ( NULL != pSnd )
|
|
pSnd->vcwaveCallback((HWAVEOUT)wParam, WOM_DONE, (LPWAVEHDR)lParam);
|
|
break;
|
|
|
|
case WM_RESAMPLE:
|
|
ASSERT( NULL != pSnd );
|
|
if ( NULL != pSnd )
|
|
pSnd->vcwaveResample();
|
|
break;
|
|
case WM_WSOCK:
|
|
ASSERT( NULL != pSnd );
|
|
pSnd->DGramSocketMessage(wParam, lParam);
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
PostQuitMessage(0);
|
|
break;
|
|
|
|
default:
|
|
rv = DefWindowProc(hwnd, uiMessage, wParam, lParam);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* InitEventFn
|
|
*
|
|
* Description:
|
|
* Called by InitEventFn
|
|
*
|
|
* Parameters:
|
|
* pInitHandle - connection handle
|
|
* event - Event id
|
|
* pData - Data, meaning depends on event id
|
|
* dataLength - Length of data
|
|
* (see MSDN: VirtualChannelInitEvent)
|
|
*
|
|
*/
|
|
VOID
|
|
CRDPSound::InitEventFn(
|
|
PVOID pInitHandle,
|
|
UINT event,
|
|
PVOID pData,
|
|
UINT dataLength
|
|
)
|
|
{
|
|
UINT rc;
|
|
UNREFERENCED_PARAMETER(dataLength);
|
|
|
|
ASSERT( pInitHandle == m_pInitHandle );
|
|
switch(event)
|
|
{
|
|
case CHANNEL_EVENT_INITIALIZED:
|
|
TRC(ALV, _T("InitEventFnEx: CHANNEL_EVENT_INITILIZED\n"));
|
|
::WSInit();
|
|
/*
|
|
#ifdef OS_WINCE
|
|
#error create single instance
|
|
::WSAStartAsyncThread();
|
|
#endif // OS_WINCE
|
|
*/
|
|
CreateMsgWindow(m_hInst);
|
|
break;
|
|
case CHANNEL_EVENT_CONNECTED:
|
|
TRC(ALV, _T("InitEventFnEx: CHANNEL_EVENT_CONNECTED to %s\n"), pData);
|
|
ASSERT(m_ChannelEntries.pVirtualChannelOpenEx);
|
|
|
|
rc = (m_ChannelEntries.pVirtualChannelOpenEx)(
|
|
pInitHandle,
|
|
&m_dwChannel,
|
|
_SNDVC_NAME,
|
|
OpenEventFnEx
|
|
);
|
|
|
|
if (rc != CHANNEL_RC_OK)
|
|
{
|
|
TRC(WRN, _T("InitEventFnEx: VirtualChannelOpen returned %d\n"), rc);
|
|
m_dwChannel = INVALID_CHANNELID;
|
|
} else {
|
|
// All's OK, check the channel handle
|
|
//
|
|
ASSERT(m_dwChannel != INVALID_CHANNELID);
|
|
}
|
|
|
|
// Prepare for connectionless data
|
|
//
|
|
DGramInit();
|
|
|
|
break;
|
|
case CHANNEL_EVENT_DISCONNECTED:
|
|
TRC(ALV, _T("InitEventFnEx: CHANNEL_EVENT_DISCONNECTED\n"));
|
|
ASSERT(m_ChannelEntries.pVirtualChannelCloseEx);
|
|
|
|
if (m_dwChannel != INVALID_CHANNELID)
|
|
{
|
|
rc = m_ChannelEntries.pVirtualChannelCloseEx(
|
|
m_pInitHandle,
|
|
m_dwChannel
|
|
);
|
|
if (rc != CHANNEL_RC_OK)
|
|
{
|
|
TRC(WRN, _T("InitEventFnEx: VirtualChannelClose returned %d\n"), rc);
|
|
}
|
|
m_dwChannel = INVALID_CHANNELID;
|
|
|
|
if (NULL != m_hWave)
|
|
{
|
|
waveOutReset(m_hWave);
|
|
vcwaveClose();
|
|
}
|
|
}
|
|
|
|
// destroy the UDP socket
|
|
//
|
|
DGramDone();
|
|
|
|
m_bPrologReceived = FALSE;
|
|
m_dwBytesInProlog = 0;
|
|
m_dwBytesInBody = 0;
|
|
|
|
//
|
|
// dispose the cache format
|
|
//
|
|
vcwaveCleanSoundFormats();
|
|
|
|
vcwaveFreeAllWaves();
|
|
_FragSlotFreeAll();
|
|
break;
|
|
case CHANNEL_EVENT_V1_CONNECTED:
|
|
TRC(ALV, _T("InitEventFnEx: CHANNEL_EVENT_V1_CONNECTED\n"));
|
|
break;
|
|
case CHANNEL_EVENT_TERMINATED:
|
|
TRC(ALV, _T("InitEventFnEx: CHANNEL_EVENT_TERMINATED\n"));
|
|
WSACleanup();
|
|
if (NULL != m_hWave)
|
|
{
|
|
waveOutReset(m_hWave);
|
|
vcwaveClose();
|
|
}
|
|
|
|
DGramDone();
|
|
/*
|
|
#ifdef OS_WINCE
|
|
#error see previous error
|
|
::WSACloseAsyncThread();
|
|
#endif // OS_WINCE
|
|
*/
|
|
if ( NULL != m_pProlog )
|
|
{
|
|
free( m_pProlog );
|
|
m_pProlog = NULL;
|
|
}
|
|
|
|
if ( NULL != m_pMsgBody )
|
|
{
|
|
free( m_pMsgBody );
|
|
m_pMsgBody = NULL;
|
|
}
|
|
|
|
vcwaveCleanSoundFormats();
|
|
vcwaveFreeAllWaves();
|
|
_FragSlotFreeAll();
|
|
|
|
DestroyMsgWindow();
|
|
|
|
break;
|
|
default:
|
|
TRC(ALV, _T("Unhandled event in InitEventFnEx: %d\n"), event);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* OpenEventFn
|
|
*
|
|
* Description:
|
|
* Called by OpenEventFnEx
|
|
*
|
|
* Parameters:
|
|
* OpenaHandle - Channel handle, returned by VirtualChanneOpen
|
|
* event - event type
|
|
* pData - meaning depends on event type
|
|
* dataLength - size of pData
|
|
* dataFlags - information about the received data
|
|
*
|
|
*/
|
|
VOID
|
|
CRDPSound::OpenEventFn(
|
|
DWORD OpenHandle,
|
|
UINT event,
|
|
PVOID pData,
|
|
UINT32 dataLength,
|
|
UINT32 totalLength,
|
|
UINT32 dataFlags
|
|
)
|
|
{
|
|
UNREFERENCED_PARAMETER(OpenHandle);
|
|
|
|
switch (event)
|
|
{
|
|
case CHANNEL_EVENT_DATA_RECEIVED:
|
|
#if _IO_DBG
|
|
TRC(ALV,
|
|
"OpenEventFn: CHANNEL_EVENT_DATA_RECEIVED, dataSize=0x%x, total=0x%x\n",
|
|
dataLength,
|
|
totalLength);
|
|
#endif
|
|
|
|
//
|
|
// save the data in global buffers
|
|
//
|
|
if (!m_bPrologReceived)
|
|
{
|
|
//
|
|
// receive the prolog (1st message)
|
|
//
|
|
|
|
if ( 0 != ( dataFlags & CHANNEL_FLAG_FIRST ))
|
|
m_dwBytesInProlog = 0;
|
|
|
|
if ( NULL == m_pProlog )
|
|
{
|
|
ASSERT( 0 != ( dataFlags & CHANNEL_FLAG_FIRST ));
|
|
|
|
m_pProlog = malloc( totalLength );
|
|
|
|
if ( NULL == m_pProlog )
|
|
{
|
|
TRC( FATAL, _T("OpenEventFn: failed to allocate %d bytes\n"),
|
|
totalLength);
|
|
break;
|
|
}
|
|
|
|
m_dwPrologAllocated = totalLength;
|
|
}
|
|
|
|
if ( totalLength > m_dwPrologAllocated )
|
|
{
|
|
PVOID pNewProlog;
|
|
|
|
ASSERT( 0 != ( dataFlags & CHANNEL_FLAG_FIRST ));
|
|
|
|
pNewProlog = realloc( m_pProlog, totalLength );
|
|
|
|
if ( NULL == pNewProlog )
|
|
{
|
|
TRC( FATAL, _T("OpenEventFn: failed to allocate %d bytes\n"),
|
|
totalLength);
|
|
free ( m_pProlog );
|
|
m_pProlog = NULL;
|
|
m_dwPrologAllocated = 0;
|
|
break;
|
|
|
|
}
|
|
m_pProlog = pNewProlog;
|
|
m_dwPrologAllocated = totalLength;
|
|
}
|
|
|
|
if ( m_dwBytesInProlog + dataLength > m_dwPrologAllocated )
|
|
{
|
|
TRC( ERR, _T("An invalid VC packet received. Ignoring\n" ));
|
|
break;
|
|
}
|
|
|
|
memcpy( ((LPSTR)m_pProlog) + m_dwBytesInProlog, pData, dataLength );
|
|
m_dwBytesInProlog += dataLength;
|
|
|
|
ASSERT( m_dwBytesInProlog <= totalLength );
|
|
|
|
if ( 0 != ( dataFlags & CHANNEL_FLAG_LAST ))
|
|
{
|
|
m_bPrologReceived = TRUE;
|
|
|
|
ASSERT( sizeof(SNDPROLOG) <= m_dwBytesInProlog );
|
|
|
|
//
|
|
// check if we expect a body
|
|
//
|
|
ASSERT( m_dwBytesInProlog - sizeof(SNDPROLOG) <=
|
|
((PSNDPROLOG)m_pProlog)->BodySize);
|
|
|
|
if ( m_dwBytesInProlog - sizeof(SNDPROLOG) ==
|
|
((PSNDPROLOG)m_pProlog)->BodySize )
|
|
{
|
|
// no, proceed the message
|
|
//
|
|
DataArrived(
|
|
(PSNDPROLOG)m_pProlog,
|
|
((PSNDPROLOG)m_pProlog) + 1
|
|
);
|
|
|
|
m_bPrologReceived = FALSE;
|
|
m_dwBytesInProlog = 0;
|
|
m_dwBytesInBody = 0;
|
|
}
|
|
}
|
|
} else {
|
|
//
|
|
// receive the body (2nd message)
|
|
//
|
|
|
|
if ( 0 != ( dataFlags & CHANNEL_FLAG_FIRST ))
|
|
m_dwBytesInBody = 0;
|
|
|
|
if ( NULL == m_pMsgBody )
|
|
{
|
|
ASSERT( 0 != ( dataFlags & CHANNEL_FLAG_FIRST ));
|
|
|
|
m_pMsgBody = malloc( totalLength );
|
|
|
|
if ( NULL == m_pMsgBody )
|
|
{
|
|
TRC( FATAL, _T("OpenEventFn: failed to allocate %d bytes\n"),
|
|
totalLength);
|
|
break;
|
|
}
|
|
|
|
m_dwBodyAllocated = totalLength;
|
|
}
|
|
|
|
if ( totalLength > m_dwBodyAllocated )
|
|
{
|
|
PVOID pNewBody;
|
|
|
|
ASSERT( 0 != ( dataFlags & CHANNEL_FLAG_FIRST ));
|
|
|
|
pNewBody = realloc( m_pMsgBody, totalLength );
|
|
|
|
if ( NULL == pNewBody )
|
|
{
|
|
TRC( FATAL, _T("OpenEventFn: failed to allocate %d bytes\n"),
|
|
totalLength);
|
|
free ( m_pMsgBody );
|
|
m_pMsgBody = NULL;
|
|
m_dwBodyAllocated = 0;
|
|
break;
|
|
|
|
}
|
|
m_pMsgBody = pNewBody;
|
|
m_dwBodyAllocated = totalLength;
|
|
}
|
|
|
|
if ( m_dwBytesInBody + dataLength > m_dwBodyAllocated )
|
|
{
|
|
TRC( ERR, _T("An invalid VC packet received. Ignoring\n" ));
|
|
break;
|
|
}
|
|
|
|
memcpy( ((LPSTR)m_pMsgBody) + m_dwBytesInBody, pData, dataLength );
|
|
m_dwBytesInBody += dataLength;
|
|
|
|
ASSERT( m_dwBytesInBody <= totalLength );
|
|
|
|
if ( 0 != ( dataFlags & CHANNEL_FLAG_LAST ))
|
|
{
|
|
UINT32 *pdw;
|
|
|
|
//
|
|
// here comes the magic
|
|
// the server sends two packets, but it is possible
|
|
// in case of switching between sessions (or shadowing ?!)
|
|
// that the client can receive first packet from one session
|
|
// and the second from another
|
|
// that's why we have a valid message type for each packet
|
|
// by replacing the first word of the second message
|
|
// this word is kept in the end of the first message
|
|
//
|
|
if ( NULL != m_pMsgBody &&
|
|
SNDC_NONE != *((UINT32 *)m_pMsgBody) )
|
|
{
|
|
LPVOID pSwap;
|
|
DWORD dwSwap;
|
|
|
|
TRC(ERR, _T("OpenEventFn: messages not synchronized. ")
|
|
_T("Trying to fix it\n"));
|
|
|
|
pSwap = m_pProlog;
|
|
m_pProlog = m_pMsgBody;
|
|
m_pMsgBody = pSwap;
|
|
|
|
dwSwap = m_dwPrologAllocated;
|
|
m_dwPrologAllocated = m_dwBodyAllocated;
|
|
m_dwBodyAllocated = dwSwap;
|
|
|
|
m_dwBytesInProlog = m_dwBytesInBody;
|
|
m_dwBytesInBody = 0;
|
|
|
|
// we swapped the body and the prolog
|
|
// now, wait for the actual body
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
// from the end of the prolog message, remove
|
|
// UINT32 word and place it at the begining of the body
|
|
//
|
|
|
|
ASSERT( sizeof(SNDPROLOG) + sizeof(UINT32) <= m_dwBytesInProlog);
|
|
if ( sizeof(SNDPROLOG) + sizeof(UINT32) > m_dwBytesInProlog )
|
|
{
|
|
TRC( ERR, _T("An invalid VC packet received. Ignoring\n" ));
|
|
break;
|
|
}
|
|
|
|
pdw = (UINT32 *)(((LPSTR)m_pProlog) +
|
|
m_dwBytesInProlog - sizeof(UINT32));
|
|
*((UINT32 *)m_pMsgBody) = *pdw;
|
|
|
|
//
|
|
// cut the prolog length by UINT32 size
|
|
//
|
|
m_dwBytesInProlog -= sizeof(UINT32);
|
|
|
|
DataArrived(
|
|
(PSNDPROLOG)m_pProlog,
|
|
m_pMsgBody
|
|
);
|
|
|
|
m_bPrologReceived = FALSE;
|
|
m_dwBytesInProlog = 0;
|
|
m_dwBytesInBody = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CHANNEL_EVENT_WRITE_COMPLETE:
|
|
{
|
|
TRC(ALV, _T("OpenEventFn: CHANNEL_EVENT_WRITE_COMPLETE, ptr=0x%p\n"),
|
|
pData);
|
|
|
|
free(pData);
|
|
|
|
}
|
|
break;
|
|
case CHANNEL_EVENT_WRITE_CANCELLED:
|
|
{
|
|
TRC(WRN, _T("OpenEventFn: CHANNEL_EVENT_WRITE_CANCELED. Cleaning up\n"));
|
|
free(pData);
|
|
}
|
|
break;
|
|
default:
|
|
TRC(ALV, _T("Unhandled event in OpenEventFn: %d\n"), event);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* ChannelWriteNCopy
|
|
*
|
|
* Description:
|
|
* Allocates a chunk of memory and sends it using ChannelWrite
|
|
* Allows the caller to free or reuse the buffer
|
|
*
|
|
* Parameters:
|
|
* pBuffer - Chunk pointer
|
|
* uiSize - Chunk size
|
|
*
|
|
* Returns:
|
|
* TRUE on success
|
|
*
|
|
*/
|
|
BOOL
|
|
CRDPSound::ChannelWriteNCopy(
|
|
LPVOID pBuffer,
|
|
UINT32 uiSize
|
|
)
|
|
{
|
|
BOOL rv = FALSE;
|
|
LPVOID pSendBuffer = NULL;
|
|
|
|
if ( INVALID_CHANNELID == m_dwChannel )
|
|
{
|
|
TRC(ERR, _T("ChannelWriteNCopy: invalid handle\n"));
|
|
goto exitpt;
|
|
}
|
|
|
|
if (NULL == pBuffer)
|
|
{
|
|
TRC(ERR, _T("ChannelWriteNCopy: buffer is NULL\n"));
|
|
goto exitpt;
|
|
}
|
|
|
|
pSendBuffer = malloc(uiSize);
|
|
|
|
if (pSendBuffer)
|
|
{
|
|
memcpy(pSendBuffer, pBuffer, uiSize);
|
|
rv = ChannelWrite( pSendBuffer, uiSize );
|
|
}
|
|
|
|
exitpt:
|
|
if (!rv)
|
|
{
|
|
if (pSendBuffer)
|
|
free(pSendBuffer);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* DataArrived
|
|
*
|
|
* Description:
|
|
* Processes a message arrived from the channel
|
|
*
|
|
* Parameters:
|
|
* pProlog - the message prolog, type and body size
|
|
* pBody - pointer to the message body
|
|
*
|
|
*/
|
|
VOID
|
|
CRDPSound::DataArrived(
|
|
PSNDPROLOG pProlog,
|
|
LPVOID pBody
|
|
)
|
|
{
|
|
ASSERT(pProlog);
|
|
ASSERT(pBody);
|
|
switch(pProlog->Type)
|
|
{
|
|
case SNDC_CLOSE:
|
|
|
|
TRC(ALV, _T("DataArrived: SNDC_CLOSE\n"));
|
|
|
|
if (m_hWave)
|
|
{
|
|
vcwaveClose();
|
|
}
|
|
break;
|
|
|
|
case SNDC_SETVOLUME:
|
|
{
|
|
PSNDSETVOLUME pSetVolume;
|
|
|
|
TRC(ALV, _T("DataArrived: SNDC_SETVOLUME\n"));
|
|
|
|
if ( pProlog->BodySize < sizeof( *pSetVolume ) - sizeof( *pProlog ))
|
|
{
|
|
TRC( ERR, _T("DataArrived: Invalid SNDC_SETVOLUME message\n" ));
|
|
break;
|
|
}
|
|
|
|
pSetVolume = (PSNDSETVOLUME)
|
|
(((LPSTR)pBody) - sizeof(*pProlog));
|
|
|
|
ASSERT(pProlog->BodySize == sizeof(*pSetVolume) - sizeof(*pProlog));
|
|
|
|
if (m_hWave)
|
|
waveOutSetVolume(m_hWave, pSetVolume->dwVolume);
|
|
}
|
|
break;
|
|
|
|
case SNDC_WAVE:
|
|
{
|
|
PSNDWAVE pWave;
|
|
|
|
//
|
|
// disable dgram response
|
|
//
|
|
m_dwRemoteDGramPort = 0;
|
|
m_ulRemoteDGramAddress = 0;
|
|
|
|
pWave = (PSNDWAVE)pProlog;
|
|
|
|
TRC(ALV, _T("DataArrived: SNDC_WAVE, block no: %d\n"),
|
|
pWave->cBlockNo);
|
|
|
|
if ( pProlog->BodySize < sizeof( *pWave ) - sizeof( *pProlog ))
|
|
{
|
|
TRC( ERR, _T("DataArrived: Invalid SNDC_WAVE message\n" ));
|
|
break;
|
|
}
|
|
|
|
vcwaveWrite(pWave->cBlockNo,
|
|
pWave->wFormatNo,
|
|
pWave->wTimeStamp,
|
|
pWave->Prolog.BodySize - sizeof(SNDWAVE) + sizeof(SNDPROLOG),
|
|
pBody);
|
|
|
|
}
|
|
break;
|
|
|
|
case SNDC_TRAINING:
|
|
{
|
|
SNDTRAINING SndTraining;
|
|
PSNDTRAINING pRecvTraining;
|
|
|
|
if ( pProlog->BodySize < sizeof( *pRecvTraining ) - sizeof( *pProlog ))
|
|
{
|
|
TRC( ERR, _T("DataArrived: Invalid SNDC_TRAINING message\n" ));
|
|
break;
|
|
}
|
|
|
|
//
|
|
// disable dgram response
|
|
//
|
|
m_dwRemoteDGramPort = 0;
|
|
m_ulRemoteDGramAddress = 0;
|
|
|
|
pRecvTraining = (PSNDTRAINING)
|
|
(((LPSTR)pBody) - sizeof(*pProlog));
|
|
|
|
TRC(ALV, _T("DataArrived: training, sending a response\n"));
|
|
SndTraining.Prolog.Type = SNDC_TRAINING;
|
|
SndTraining.Prolog.BodySize = sizeof(SndTraining) -
|
|
sizeof(SndTraining.Prolog);
|
|
SndTraining.wTimeStamp = pRecvTraining->wTimeStamp;
|
|
SndTraining.wPackSize = pRecvTraining->wPackSize;
|
|
|
|
//
|
|
// send the response immediatly
|
|
//
|
|
ChannelWriteNCopy( &SndTraining, sizeof(SndTraining) );
|
|
|
|
}
|
|
break;
|
|
|
|
case SNDC_FORMATS:
|
|
{
|
|
PSNDFORMATMSG pSndFormats;
|
|
PSNDFORMATMSG pSndFormatsResp;
|
|
PSNDFORMATITEM pSndSuppFormats = NULL;
|
|
DWORD dwRespSize;
|
|
DWORD dwListSize;
|
|
DWORD dwNumFormats;
|
|
BOOL bSuccess;
|
|
DWORD dwPacketSize;
|
|
DWORD count;
|
|
PSNDFORMATITEM pFmt;
|
|
|
|
pSndFormats = (PSNDFORMATMSG)
|
|
(((LPSTR)pBody) - sizeof(*pProlog));
|
|
|
|
TRC(ALV, _T("DataArrived: SNDC_FORMATS, number of formats: %d\n"),
|
|
pSndFormats->wNumberOfFormats);
|
|
|
|
if ( pProlog->BodySize < sizeof( *pSndFormats ) - sizeof( *pProlog ))
|
|
{
|
|
TRC( ERR, _T("DataArrived: Invalid SNDC_FORMATS message\n" ));
|
|
break;
|
|
}
|
|
|
|
//
|
|
// validate the packet length
|
|
//
|
|
dwPacketSize = pProlog->BodySize - sizeof( *pSndFormats ) + sizeof( *pProlog );
|
|
pFmt = (PSNDFORMATITEM) (pSndFormats + 1);
|
|
for( count = 0; count < pSndFormats->wNumberOfFormats; count ++ )
|
|
{
|
|
DWORD adv = sizeof( *pFmt ) + pFmt->cbSize;
|
|
if ( adv > dwPacketSize )
|
|
{
|
|
TRC( ERR, _T("DataArrived: Invalid SNDC_FORMATS, invalid format list\n" ));
|
|
goto break_sndformat;
|
|
}
|
|
pFmt = (PSNDFORMATITEM)((LPSTR)pFmt + adv);
|
|
dwPacketSize -= adv;
|
|
}
|
|
ASSERT( 0 == dwPacketSize );
|
|
|
|
|
|
m_cLastReceivedBlock = pSndFormats->cLastBlockConfirmed;
|
|
vcwaveCleanSoundFormats();
|
|
|
|
bSuccess = vcwaveChooseSoundFormat(
|
|
pSndFormats->wNumberOfFormats,
|
|
(PSNDFORMATITEM) (pSndFormats + 1),
|
|
&pSndSuppFormats,
|
|
&dwListSize,
|
|
&dwNumFormats
|
|
);
|
|
|
|
if (bSuccess)
|
|
{
|
|
ASSERT( NULL != pSndSuppFormats );
|
|
ASSERT( 0 != dwListSize );
|
|
ASSERT( 0 != dwNumFormats );
|
|
|
|
bSuccess = vcwaveSaveSoundFormats(
|
|
pSndSuppFormats,
|
|
dwNumFormats);
|
|
if (!bSuccess)
|
|
{
|
|
free(pSndSuppFormats);
|
|
pSndSuppFormats = NULL;
|
|
dwNumFormats = 0;
|
|
dwListSize = 0;
|
|
}
|
|
} else {
|
|
ASSERT( NULL == pSndSuppFormats );
|
|
ASSERT( 0 == dwListSize );
|
|
ASSERT( 0 == dwNumFormats );
|
|
}
|
|
|
|
dwRespSize = sizeof( *pSndFormatsResp ) + dwListSize;
|
|
|
|
__try {
|
|
pSndFormatsResp = (PSNDFORMATMSG)alloca( dwRespSize );
|
|
}
|
|
__except((EXCEPTION_STACK_OVERFLOW == GetExceptionCode()) ?
|
|
EXCEPTION_EXECUTE_HANDLER :
|
|
EXCEPTION_CONTINUE_SEARCH)
|
|
{
|
|
_resetstkoflw();
|
|
pSndFormatsResp = NULL;
|
|
TRC(ERR, _T("alloca threw exception: 0x%x\n"),
|
|
GetExceptionCode());
|
|
}
|
|
if ( NULL == pSndFormatsResp )
|
|
goto break_sndformat;
|
|
|
|
pSndFormatsResp->Prolog.Type = SNDC_FORMATS;
|
|
pSndFormatsResp->Prolog.BodySize = (UINT16)(
|
|
dwRespSize -
|
|
sizeof( pSndFormatsResp->Prolog ));
|
|
pSndFormatsResp->wNumberOfFormats = (WORD)dwNumFormats;
|
|
vcwaveGetDevCaps( pSndFormatsResp );
|
|
|
|
//
|
|
// Beta 1 compatability, fake we are version 1 if the server is version 1
|
|
//
|
|
m_wServerVersion = pSndFormats->wVersion;
|
|
if ( 1 == pSndFormats->wVersion )
|
|
pSndFormatsResp->wVersion = 1;
|
|
else
|
|
pSndFormatsResp->wVersion = RDPSND_PROTOCOL_VERSION;
|
|
|
|
//
|
|
// copy the format list
|
|
//
|
|
memcpy( (PSNDFORMATITEM) ( pSndFormatsResp + 1 ),
|
|
pSndSuppFormats,
|
|
dwListSize );
|
|
|
|
ChannelWriteNCopy( pSndFormatsResp, dwRespSize );
|
|
break_sndformat:
|
|
if ( NULL != pSndSuppFormats )
|
|
free ( pSndSuppFormats );
|
|
}
|
|
break;
|
|
|
|
case SNDC_CRYPTKEY:
|
|
{
|
|
PSNDCRYPTKEY pKey = (PSNDCRYPTKEY)(((LPSTR)pBody) - sizeof(*pProlog));
|
|
|
|
if ( pProlog->BodySize < sizeof( *pKey ) - sizeof( *pProlog ))
|
|
{
|
|
TRC( ERR, _T("DataArrived: Invalid SNDC_CRYPTKEY message\n"));
|
|
break;
|
|
}
|
|
memcpy( m_EncryptKey, pKey->Seed, RANDOM_KEY_LENGTH );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
TRC(ERR, _T("DataArrived: Invalid message type received: %d\n"), pProlog->Type);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* vcwaveResample
|
|
*
|
|
* Description:
|
|
* Reopens the device with new codec
|
|
*
|
|
*/
|
|
VOID
|
|
CRDPSound::vcwaveResample(
|
|
VOID
|
|
)
|
|
{
|
|
if ( 0 != m_dwWavesPlaying || NULL == m_pFirstWave )
|
|
goto exitpt;
|
|
|
|
if ( NULL == m_hWave ||
|
|
m_dwCurrentFormat != (DWORD)PtrToLong((PVOID)m_pFirstWave->reserved))
|
|
{
|
|
TRC(INF, _T("vcwaveResample: Resampling\n"));
|
|
m_dwCurrentFormat = (DWORD)PtrToLong((PVOID)m_pFirstWave->reserved);
|
|
|
|
if ( m_dwCurrentFormat >= m_dwNumFormats )
|
|
{
|
|
TRC(ERR, _T("vcwaveResample: invalid format no\n"));
|
|
vcwaveFreeAllWaves();
|
|
|
|
goto exitpt;
|
|
}
|
|
|
|
vcwaveOpen( (LPWAVEFORMATEX)m_ppFormats[ m_dwCurrentFormat ] );
|
|
}
|
|
|
|
//
|
|
// stuff all pending blocks
|
|
//
|
|
while ( NULL != m_pFirstWave &&
|
|
m_dwCurrentFormat == (DWORD)PtrToLong( (PVOID)m_pFirstWave->reserved ))
|
|
{
|
|
LPWAVEHDR lpNext = m_pFirstWave->lpNext;
|
|
MMRESULT mmres;
|
|
|
|
mmres = vcwaveOutWrite( m_pFirstWave );
|
|
if ( MMSYSERR_NOERROR != mmres )
|
|
{
|
|
vcwaveFreeAllWaves();
|
|
} else {
|
|
|
|
m_pFirstWave = lpNext;
|
|
|
|
if ( NULL == m_pFirstWave )
|
|
m_pLastWave = NULL;
|
|
}
|
|
}
|
|
|
|
exitpt:
|
|
;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* DGramSocketMessage
|
|
*
|
|
* Description:
|
|
* Callback from UDP
|
|
*
|
|
*/
|
|
VOID
|
|
CRDPSound::DGramSocketMessage(
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
if (WSAGETSELECTERROR(lParam))
|
|
{
|
|
TRC(ERR, _T("WM_WSOCK: Winsock error: %d\n"),
|
|
WSAGETSELECTERROR(lParam));
|
|
goto exitpt;
|
|
}
|
|
|
|
if (m_hDGramSocket != (SOCKET)wParam)
|
|
{
|
|
TRC(WRN, _T("WM_WSOCK: message for unknown socket\n"));
|
|
goto exitpt;
|
|
}
|
|
|
|
if (WSAGETSELECTEVENT(lParam) == FD_CLOSE)
|
|
{
|
|
TRC(ERR, _T("WM_WSOCK: socket closed\n"));
|
|
DGramDone();
|
|
|
|
goto exitpt;
|
|
}
|
|
|
|
if (WSAGETSELECTEVENT(lParam) != FD_READ)
|
|
{
|
|
TRC(WRN, _T("WM_WSOCK: unknown event received\n"));
|
|
|
|
goto exitpt;
|
|
}
|
|
|
|
TRC(ALV, _T("WM_WSOCK: data available\n"));
|
|
{
|
|
BOOL bSuccess;
|
|
PSNDWAVE pSndWave;
|
|
UINT structsize;
|
|
|
|
structsize = sizeof(*pSndWave) + TSSND_BLOCKSIZE + RDPSND_SIGNATURE_SIZE;
|
|
|
|
__try
|
|
{
|
|
pSndWave = (PSNDWAVE)alloca(structsize);
|
|
}
|
|
__except((EXCEPTION_STACK_OVERFLOW == GetExceptionCode()) ?
|
|
EXCEPTION_EXECUTE_HANDLER :
|
|
EXCEPTION_CONTINUE_SEARCH)
|
|
{
|
|
_resetstkoflw();
|
|
pSndWave = NULL;
|
|
TRC(ERR, _T("WM_SOCK: alloca threw exception: 0x%x\n"),
|
|
GetExceptionCode());
|
|
}
|
|
|
|
if (NULL == pSndWave)
|
|
goto exitpt;
|
|
|
|
bSuccess = DGramRecvWave(
|
|
pSndWave,
|
|
structsize
|
|
);
|
|
|
|
if (bSuccess)
|
|
{
|
|
PBYTE pWave = (PBYTE)(pSndWave+1);
|
|
UINT uiWaveSize = pSndWave->Prolog.BodySize -
|
|
sizeof(SNDWAVE) + sizeof(SNDPROLOG);
|
|
|
|
if ( IsDGramWaveSigned( m_wServerVersion ))
|
|
{
|
|
DWORD dw;
|
|
BYTE Signature[ RDPSND_SIGNATURE_SIZE ];
|
|
|
|
//
|
|
// wave starts with signature
|
|
//
|
|
if ( uiWaveSize < RDPSND_SIGNATURE_SIZE )
|
|
{
|
|
TRC( ERR, _T("Insufficient data for signature\n" ));
|
|
goto exitpt;
|
|
}
|
|
|
|
if ( !IsDGramWaveAudioSigned( m_wServerVersion ))
|
|
{
|
|
SL_Signature( Signature, pSndWave->dwBlockNo );
|
|
} else {
|
|
SL_AudioSignature( Signature,
|
|
pSndWave->dwBlockNo,
|
|
pWave + RDPSND_SIGNATURE_SIZE,
|
|
uiWaveSize - RDPSND_SIGNATURE_SIZE );
|
|
}
|
|
dw = memcmp( pWave, Signature, RDPSND_SIGNATURE_SIZE );
|
|
if ( 0 != dw )
|
|
{
|
|
TRC( ERR, _T("Invalid signature\n" ));
|
|
goto exitpt;
|
|
}
|
|
pWave += RDPSND_SIGNATURE_SIZE;
|
|
uiWaveSize -= RDPSND_SIGNATURE_SIZE;
|
|
}
|
|
vcwaveWrite(pSndWave->cBlockNo,
|
|
pSndWave->wFormatNo,
|
|
pSndWave->wTimeStamp,
|
|
uiWaveSize,
|
|
pWave);
|
|
}
|
|
}
|
|
|
|
exitpt:
|
|
;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* CreateMsgWindow
|
|
*
|
|
* Description:
|
|
* Creates a window
|
|
*
|
|
*/
|
|
BOOL
|
|
CRDPSound::CreateMsgWindow(
|
|
HINSTANCE hInstance
|
|
)
|
|
{
|
|
WNDCLASS wc;
|
|
BOOL rv = FALSE;
|
|
DWORD dwLastErr;
|
|
LONG_PTR dwUser;
|
|
|
|
memset(&wc, 0, sizeof(wc));
|
|
|
|
wc.lpfnWndProc = MsgWndProc;
|
|
wc.hInstance = hInstance;
|
|
wc.lpszClassName = _NAMEOFCLAS;
|
|
|
|
if (!RegisterClass (&wc))
|
|
{
|
|
dwLastErr = GetLastError();
|
|
if(dwLastErr != ERROR_CLASS_ALREADY_EXISTS)
|
|
{
|
|
TRC(ERR,
|
|
_T("CreateMsgWindow: Can't register class. GetLastError=%d\n"),
|
|
GetLastError());
|
|
goto exitpt;
|
|
}
|
|
}
|
|
|
|
|
|
m_hMsgWindow = CreateWindow(
|
|
_NAMEOFCLAS,
|
|
NULL, // Window name
|
|
0, // dwStyle
|
|
0, // x
|
|
0, // y
|
|
0, // nWidth
|
|
0, // nHeight
|
|
NULL, // hWndParent
|
|
NULL, // hMenu
|
|
hInstance,
|
|
NULL); // lpParam
|
|
|
|
if (!m_hMsgWindow)
|
|
{
|
|
TRC(ERR, _T("CreateMsgWindow: Failed to create message window. GetLastError=%d\n"),
|
|
GetLastError());
|
|
goto exitpt;
|
|
}
|
|
|
|
//
|
|
// safe the class pointer in the window structure
|
|
//
|
|
#ifndef OS_WINCE
|
|
dwUser = SetWindowLongPtr(
|
|
m_hMsgWindow,
|
|
GWLP_USERDATA,
|
|
(LONG_PTR)this
|
|
);
|
|
#else
|
|
dwUser = SetWindowLong(
|
|
m_hMsgWindow,
|
|
GWL_USERDATA,
|
|
(LONG)this
|
|
);
|
|
#endif
|
|
|
|
ASSERT( 0 == dwUser );
|
|
|
|
rv = TRUE;
|
|
exitpt:
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* DestroyMsgWindow
|
|
*
|
|
* Description:
|
|
* Destroy our window
|
|
*
|
|
*/
|
|
VOID
|
|
CRDPSound::DestroyMsgWindow(
|
|
VOID
|
|
)
|
|
{
|
|
if (NULL != m_hMsgWindow)
|
|
DestroyWindow(m_hMsgWindow);
|
|
|
|
UnregisterClass(_NAMEOFCLAS, m_hInst);
|
|
}
|
|
|
|
|
|
/*
|
|
* Function:
|
|
* ChannelWrite
|
|
*
|
|
* Description:
|
|
* Sends or queues a chunk of data to the virtual channel
|
|
*
|
|
* Parameters:
|
|
* hGlobMem - handle to a HGLOBAL
|
|
* uiBlockSize - size of the chunk
|
|
*
|
|
* Returns:
|
|
* TRUE on success
|
|
*
|
|
*/
|
|
BOOL
|
|
CRDPSound::ChannelWrite(
|
|
LPVOID pData,
|
|
UINT32 uiBlockSize
|
|
)
|
|
{
|
|
BOOL rv = FALSE;
|
|
DWORD Handle = m_dwChannel;
|
|
UINT rc;
|
|
|
|
ASSERT(Handle != INVALID_CHANNELID);
|
|
ASSERT(m_ChannelEntries.pVirtualChannelWriteEx);
|
|
|
|
// parameters check
|
|
//
|
|
if (INVALID_CHANNELID == Handle)
|
|
{
|
|
TRC(ERR, _T("ChannelWrite: invalid handle\n"));
|
|
goto exitpt;
|
|
}
|
|
|
|
TRC(ALV, _T("Sending ptr=%p, Size=%d\n"), pData, uiBlockSize);
|
|
|
|
rc = m_ChannelEntries.pVirtualChannelWriteEx(
|
|
m_pInitHandle,
|
|
Handle,
|
|
pData,
|
|
uiBlockSize,
|
|
pData);
|
|
|
|
if (rc != CHANNEL_RC_OK)
|
|
{
|
|
TRC(INF, _T("VirtualChannelWrite failed rv=%d"), rc);
|
|
goto exitpt;
|
|
}
|
|
|
|
rv = TRUE;
|
|
|
|
exitpt:
|
|
|
|
if (!rv)
|
|
{
|
|
TRC(ERR, _T("ChannelWrite: Failed to send data\n"));
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* vcwaveCallbacl
|
|
*
|
|
* Description:
|
|
* WaveOut callbacks
|
|
*
|
|
*/
|
|
VOID
|
|
CRDPSound::vcwaveCallback(
|
|
HWAVEOUT hWave,
|
|
UINT uMsg,
|
|
LPWAVEHDR lpWaveHdr
|
|
)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case WOM_OPEN:
|
|
TRC(ALV, _T("vcwaveCallback: WOM_OPEN\n"));
|
|
break;
|
|
case WOM_CLOSE:
|
|
TRC(ALV, _T("vcwaveCallback: WOM_CLOSE\n"));
|
|
break;
|
|
|
|
case WOM_DONE:
|
|
{
|
|
SNDWAVECONFIRM WaveConfirm;
|
|
|
|
ASSERT( 0 != ( lpWaveHdr->dwFlags & WHDR_PREPARED ));
|
|
|
|
if ( 0 == ( lpWaveHdr->dwFlags & WHDR_PREPARED ))
|
|
{
|
|
TRC( ERR, _T("vcwaveCallback: buffer already unprepared\n") );
|
|
} else if ( m_hWave != hWave )
|
|
{
|
|
TRC( ERR, _T("vcwaveCallback: can't unprepare header, beacuse ")
|
|
_T("the stream is already closed\n"));
|
|
} else {
|
|
MMRESULT mmres;
|
|
|
|
mmres = waveOutUnprepareHeader(
|
|
hWave,
|
|
lpWaveHdr,
|
|
sizeof(*lpWaveHdr)
|
|
);
|
|
|
|
ASSERT( mmres == MMSYSERR_NOERROR );
|
|
#if DBG
|
|
m_lPrepdBlocks --;
|
|
#endif // DBG
|
|
|
|
}
|
|
|
|
if (lpWaveHdr)
|
|
{
|
|
DWORD dw = PtrToLong((PVOID)lpWaveHdr->dwUser);
|
|
|
|
WaveConfirm.cConfirmedBlockNo = (BYTE)(dw >> 16);
|
|
//
|
|
// adjust completly the time stamp
|
|
// see vcwaveWrite
|
|
//
|
|
WaveConfirm.wTimeStamp = (WORD)
|
|
((dw & 0xffff) + GetTickCount());
|
|
#if _STAT_DBG
|
|
TRC(INF, _T("blockno=%d, adjusted time stamp=%x\n"),
|
|
WaveConfirm.cConfirmedBlockNo, WaveConfirm.wTimeStamp);
|
|
#endif
|
|
|
|
TRC(ALV, _T("vcwaveCallback: WOM_DONE, block no %d\n"),
|
|
WaveConfirm.cConfirmedBlockNo);
|
|
|
|
if (lpWaveHdr->lpData)
|
|
{
|
|
#ifdef OS_WINCE
|
|
lpWaveHdr->lpData = (char *)UnMapPtr(lpWaveHdr->lpData);
|
|
if (lpWaveHdr->lpData)
|
|
#endif
|
|
free(lpWaveHdr->lpData);
|
|
}
|
|
else
|
|
TRC(ERR, _T("vcwaveCallback: WOM_DONE: lpWaveHdr->lpData is NULL\n"));
|
|
|
|
free(lpWaveHdr);
|
|
} else
|
|
TRC(ERR, _T("vcwaveCallback: WOM_DONE: lpWaveHdr is NULL\n"));
|
|
|
|
// Send the confirmation
|
|
//
|
|
WaveConfirm.Prolog.Type = SNDC_WAVECONFIRM;
|
|
WaveConfirm.Prolog.BodySize = sizeof(WaveConfirm) -
|
|
sizeof(WaveConfirm.Prolog);
|
|
|
|
if ( 0 != m_ulRemoteDGramAddress )
|
|
DGramSend( &WaveConfirm, sizeof(WaveConfirm));
|
|
else
|
|
ChannelWriteNCopy( &WaveConfirm, sizeof( WaveConfirm ));
|
|
|
|
m_dwWavesPlaying --;
|
|
ASSERT( -1 != m_dwWavesPlaying );
|
|
|
|
if ( 0 == m_dwWavesPlaying && NULL != m_pFirstWave )
|
|
{
|
|
TRC(INF, _T("vcwaveCallback: WOM_DONE: attempt to resample\n"));
|
|
PostMessage( m_hMsgWindow, WM_RESAMPLE, 0, 0 );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* vcwaveGetDevCaps
|
|
*
|
|
* Description:
|
|
* Queries for device capabilities
|
|
*
|
|
*/
|
|
VOID
|
|
CRDPSound::vcwaveGetDevCaps(
|
|
PSNDFORMATMSG pFmtMsg
|
|
)
|
|
{
|
|
WAVEFORMATEX Format;
|
|
MMRESULT mmres;
|
|
DWORD dw;
|
|
|
|
ASSERT( NULL != pFmtMsg );
|
|
|
|
pFmtMsg->dwFlags = 0;
|
|
pFmtMsg->dwVolume = 0;
|
|
pFmtMsg->dwPitch = 0;
|
|
pFmtMsg->wDGramPort = 0;
|
|
|
|
Format.wFormatTag = WAVE_FORMAT_PCM;
|
|
Format.nChannels = TSSND_NATIVE_CHANNELS;
|
|
Format.nSamplesPerSec = TSSND_NATIVE_SAMPLERATE;
|
|
Format.nAvgBytesPerSec = TSSND_NATIVE_AVGBYTESPERSEC;
|
|
Format.nBlockAlign = TSSND_NATIVE_BLOCKALIGN;
|
|
Format.wBitsPerSample = TSSND_NATIVE_BITSPERSAMPLE;
|
|
Format.cbSize = 0;
|
|
|
|
if (!vcwaveOpen(&Format))
|
|
{
|
|
TRC(ERR, _T("vcwaveGetDevCaps: can't open device\n"));
|
|
goto exitpt;
|
|
}
|
|
ASSERT( NULL != m_hWave );
|
|
|
|
pFmtMsg->dwFlags = TSSNDCAPS_ALIVE;
|
|
pFmtMsg->wDGramPort = DGramGetLocalPort();
|
|
|
|
mmres = waveOutGetVolume(m_hWave, &dw);
|
|
if (MMSYSERR_NOERROR == mmres)
|
|
{
|
|
pFmtMsg->dwFlags |= TSSNDCAPS_VOLUME;
|
|
pFmtMsg->dwVolume = dw;
|
|
}
|
|
else
|
|
TRC(ERR, _T("vcwaveGetDevCaps: device doesn't support volume control\n"));
|
|
|
|
mmres = waveOutGetPitch(m_hWave, &dw);
|
|
if (MMSYSERR_NOERROR == mmres)
|
|
{
|
|
pFmtMsg->dwFlags |= TSSNDCAPS_PITCH;
|
|
pFmtMsg->dwPitch = dw;
|
|
}
|
|
else
|
|
TRC(INF, _T("vcwaveGetDevCaps: device doesn't support pitch control\n"));
|
|
|
|
vcwaveClose();
|
|
|
|
exitpt:
|
|
;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* vcwaveChooseSoundFormat
|
|
*
|
|
* Description:
|
|
* Queries the local device for different formats
|
|
*
|
|
*/
|
|
BOOL
|
|
CRDPSound::vcwaveChooseSoundFormat(
|
|
DWORD dwNumberOfFormats,
|
|
PSNDFORMATITEM pSndFormats,
|
|
PSNDFORMATITEM *ppSndFormatFound,
|
|
DWORD *pdwListSize,
|
|
DWORD *pdwNumFormats
|
|
)
|
|
{
|
|
PSNDFORMATITEM pSndFormat;
|
|
|
|
//
|
|
// query the waveout device with different wave formats
|
|
// returns the list of successfull formats in pSndFormatFound
|
|
// FALSE in any other case
|
|
// the caller takes responsibility for freeing the data in
|
|
// *ppSndFormatFound
|
|
//
|
|
BOOL rv = FALSE;
|
|
DWORD i;
|
|
PSNDFORMATITEM pSndFormatFound = NULL;
|
|
LPSTR pFmtCopy;
|
|
DWORD dwListSize = 0;
|
|
DWORD dwNumFormats = 0;
|
|
|
|
ASSERT( NULL != pSndFormats );
|
|
ASSERT( NULL != ppSndFormatFound );
|
|
ASSERT( NULL != pdwListSize );
|
|
ASSERT( NULL != pdwNumFormats );
|
|
|
|
for ( i = 0, pSndFormat = pSndFormats;
|
|
i < dwNumberOfFormats;
|
|
i++, pSndFormat = (PSNDFORMATITEM)
|
|
(((LPSTR)pSndFormat) + sizeof( *pSndFormat ) + pSndFormat->cbSize)
|
|
)
|
|
{
|
|
MMRESULT mmres;
|
|
PSNDFORMATITEM pFmtToOpen = pSndFormat;
|
|
PSNDFORMATITEM pFixedFormat = NULL;
|
|
|
|
//
|
|
// fix the format for WMA audio
|
|
// copy and modify it in another structure, so we don't disrupt
|
|
// the original
|
|
//
|
|
if ( WAVE_FORMAT_WMAUDIO2 == pSndFormat->wFormatTag )
|
|
{
|
|
DWORD dwTotalSize = sizeof( WMAUDIO2WAVEFORMAT ) -
|
|
sizeof( WAVEFORMATEX ) + sizeof( WMAUDIO_DEC_KEY );
|
|
|
|
ASSERT( pSndFormat->cbSize == dwTotalSize );
|
|
if ( pSndFormat->cbSize == dwTotalSize )
|
|
{
|
|
pFixedFormat = (PSNDFORMATITEM)malloc( sizeof( WMAUDIO2WAVEFORMAT ) +
|
|
sizeof( WMAUDIO_DEC_KEY ));
|
|
if ( NULL != pFixedFormat )
|
|
{
|
|
memcpy( pFixedFormat, pSndFormat, sizeof( pSndFormat ) + pSndFormat->cbSize );
|
|
strncpy((CHAR *)(((WMAUDIO2WAVEFORMAT *) pFixedFormat) + 1),
|
|
WMAUDIO_DEC_KEY, sizeof( WMAUDIO_DEC_KEY ));
|
|
pFmtToOpen = pFixedFormat;
|
|
}
|
|
}
|
|
}
|
|
|
|
mmres = waveOutOpen(
|
|
NULL,
|
|
WAVE_MAPPER,
|
|
(LPWAVEFORMATEX)pFmtToOpen,
|
|
0,
|
|
0,
|
|
WAVE_FORMAT_QUERY
|
|
);
|
|
|
|
if ( NULL != pFixedFormat )
|
|
{
|
|
free( pFixedFormat );
|
|
}
|
|
|
|
TRC(ALV, _T("FormatTag - %d\n"), pSndFormat->wFormatTag);
|
|
TRC(ALV, _T("Channels - %d\n"), pSndFormat->nChannels);
|
|
TRC(ALV, _T("SamplesPerSec - %d\n"), pSndFormat->nSamplesPerSec);
|
|
TRC(ALV, _T("AvgBytesPerSec - %d\n"), pSndFormat->nAvgBytesPerSec);
|
|
TRC(ALV, _T("BlockAlign - %d\n"), pSndFormat->nBlockAlign);
|
|
TRC(ALV, _T("BitsPerSample - %d\n"), pSndFormat->wBitsPerSample);
|
|
TRC(ALV, _T("cbSize - %d\n"), pSndFormat->cbSize);
|
|
|
|
if ( MMSYSERR_NOERROR == mmres )
|
|
{
|
|
//
|
|
// this format is supported
|
|
//
|
|
|
|
TRC(ALV, _T("vcwaveChooseSoundFormat: format found\n"));
|
|
|
|
dwListSize += sizeof( *pSndFormat ) + pSndFormat->cbSize;
|
|
dwNumFormats ++;
|
|
} else {
|
|
//
|
|
// if not supported,
|
|
// zero it's AvgBytesPerSec member
|
|
//
|
|
TRC(INF, _T("vcwaveChooseSoundFormat: format not supported\n"));
|
|
pSndFormat->nAvgBytesPerSec = 0;
|
|
}
|
|
|
|
}
|
|
|
|
if ( 0 == dwListSize )
|
|
{
|
|
TRC(WRN, _T("vcwaveChooseSoundFormat: no formats found\n"));
|
|
goto exitpt;
|
|
}
|
|
|
|
pSndFormatFound = (PSNDFORMATITEM)malloc( dwListSize );
|
|
if ( NULL == pSndFormatFound )
|
|
{
|
|
TRC( ERR, _T("vcwaveChooseSoundFormat: can't allocate %d bytes\n"),
|
|
dwListSize );
|
|
|
|
dwListSize = 0;
|
|
dwNumFormats = 0;
|
|
goto exitpt;
|
|
}
|
|
|
|
//
|
|
// copy the list of supported formats
|
|
//
|
|
for ( i = 0, pSndFormat = pSndFormats, pFmtCopy = (LPSTR)pSndFormatFound;
|
|
i < dwNumberOfFormats;
|
|
i++, pSndFormat = (PSNDFORMATITEM)
|
|
(((LPSTR)pSndFormat) + sizeof( *pSndFormat ) + pSndFormat->cbSize)
|
|
)
|
|
{
|
|
if ( 0 != pSndFormat->nAvgBytesPerSec )
|
|
{
|
|
memcpy( pFmtCopy,
|
|
pSndFormat,
|
|
sizeof( *pSndFormat ) + pSndFormat->cbSize);
|
|
pFmtCopy += sizeof( *pSndFormat ) + pSndFormat->cbSize;
|
|
}
|
|
}
|
|
|
|
rv = TRUE;
|
|
|
|
exitpt:
|
|
*ppSndFormatFound = pSndFormatFound;
|
|
*pdwListSize = dwListSize;
|
|
*pdwNumFormats = dwNumFormats;
|
|
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* vcwaveCleanSoundForamt
|
|
*
|
|
* Description:
|
|
* Cleans the list of negotiated formats
|
|
*
|
|
*/
|
|
VOID
|
|
CRDPSound::vcwaveCleanSoundFormats(
|
|
VOID
|
|
)
|
|
{
|
|
DWORD i;
|
|
|
|
if ( NULL == m_ppFormats )
|
|
goto exitpt;
|
|
//
|
|
// dispose the allocated structures
|
|
//
|
|
for (i = 0; i < m_dwNumFormats; i++)
|
|
{
|
|
if ( NULL != m_ppFormats[i] )
|
|
free( m_ppFormats[i] );
|
|
}
|
|
free( m_ppFormats );
|
|
m_ppFormats = NULL;
|
|
m_dwNumFormats = 0;
|
|
exitpt:
|
|
;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* vcwaveSafeSoundFormats
|
|
*
|
|
* Description:
|
|
* Saves the list of negotiated formats
|
|
*
|
|
*/
|
|
BOOL
|
|
CRDPSound::vcwaveSaveSoundFormats(
|
|
PSNDFORMATITEM pSndFormats,
|
|
DWORD dwNumFormats
|
|
)
|
|
{
|
|
BOOL rv = FALSE;
|
|
DWORD i;
|
|
DWORD dwAllocSize;
|
|
LPSTR p;
|
|
|
|
ASSERT( NULL != pSndFormats );
|
|
ASSERT( 0 != dwNumFormats );
|
|
|
|
if ( NULL != m_ppFormats )
|
|
{
|
|
vcwaveCleanSoundFormats();
|
|
}
|
|
|
|
ASSERT( NULL == m_ppFormats );
|
|
ASSERT( 0 == m_dwNumFormats );
|
|
|
|
dwAllocSize = sizeof( PSNDFORMATITEM ) * dwNumFormats;
|
|
m_ppFormats = (PSNDFORMATITEM *)malloc( dwAllocSize );
|
|
if ( NULL == m_ppFormats )
|
|
{
|
|
TRC(ERR, _T("Failed to allocate %d bytes\n"),
|
|
dwAllocSize );
|
|
goto exitpt;
|
|
}
|
|
|
|
memset( m_ppFormats, 0, dwAllocSize );
|
|
|
|
for (i = 0, p = (LPSTR)pSndFormats;
|
|
i < dwNumFormats;
|
|
i++, p += sizeof(SNDFORMATITEM) + ((PSNDFORMATITEM)p)->cbSize)
|
|
{
|
|
PSNDFORMATITEM pFmt;
|
|
|
|
pFmt = (PSNDFORMATITEM) p;
|
|
dwAllocSize = sizeof(SNDFORMATITEM) + pFmt->cbSize;
|
|
m_ppFormats[i] = (PSNDFORMATITEM)malloc( dwAllocSize );
|
|
|
|
if ( NULL == (PVOID)m_ppFormats[i] )
|
|
{
|
|
TRC(ERR, _T("Failed to allocate %d bytes\n"),
|
|
dwAllocSize );
|
|
goto exitpt;
|
|
}
|
|
|
|
//
|
|
// copy the format
|
|
//
|
|
memcpy( m_ppFormats[i], pFmt, dwAllocSize );
|
|
}
|
|
|
|
m_dwNumFormats = dwNumFormats;
|
|
|
|
rv = TRUE;
|
|
|
|
exitpt:
|
|
|
|
if (!rv && NULL != m_ppFormats)
|
|
{
|
|
// dispose the allocated structures
|
|
//
|
|
for (i = 0; i < dwNumFormats; i++)
|
|
{
|
|
if ( NULL != m_ppFormats[i] )
|
|
free( m_ppFormats[i] );
|
|
}
|
|
free( m_ppFormats );
|
|
m_ppFormats = NULL;
|
|
m_dwNumFormats = 0;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* vcwaveClose
|
|
*
|
|
* Description:
|
|
* Closes the local device
|
|
*
|
|
*/
|
|
VOID
|
|
CRDPSound::vcwaveClose(
|
|
VOID
|
|
)
|
|
{
|
|
MSG msg;
|
|
UINT_PTR idTimer;
|
|
|
|
if ( NULL == m_hWave )
|
|
goto exitpt;
|
|
|
|
//
|
|
// process all MM_WOM_DONE messages
|
|
//
|
|
ASSERT( NULL != m_hMsgWindow );
|
|
|
|
//
|
|
// start a timeout timer
|
|
//
|
|
idTimer = SetTimer( m_hMsgWindow, 1, WAVE_CLOSE_TIMEOUT, NULL );
|
|
|
|
while( 0 != m_dwWavesPlaying &&
|
|
GetMessage( &msg, m_hMsgWindow, 0, 0 ))
|
|
{
|
|
if ( WM_TIMER == msg.message && msg.wParam == idTimer )
|
|
{
|
|
//
|
|
// cancel outstanding io
|
|
//
|
|
TRC( WRN, _T("TIMEDOUT waiting for the playing to complete. Resetting\n" ));
|
|
waveOutReset( m_hWave );
|
|
}
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
if ( 0 != idTimer )
|
|
{
|
|
KillTimer( m_hMsgWindow, idTimer );
|
|
}
|
|
|
|
waveOutClose(m_hWave);
|
|
|
|
#ifdef DBG
|
|
if ( 0 != InterlockedDecrement(&m_lTimesWaveOutOpened))
|
|
{
|
|
TRC(FATAL, _T("Device was closed too many times\n"));
|
|
ASSERT(0);
|
|
}
|
|
|
|
ASSERT( 0 == m_dwWavesPlaying );
|
|
ASSERT( 0 == m_lPrepdBlocks );
|
|
#endif
|
|
m_hWave = NULL;
|
|
|
|
exitpt:
|
|
;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* vcwaveOpen
|
|
*
|
|
* Description:
|
|
* Opens the device in given format
|
|
*
|
|
*/
|
|
BOOL
|
|
CRDPSound::vcwaveOpen(
|
|
LPWAVEFORMATEX pFormat
|
|
)
|
|
{
|
|
BOOL rv = FALSE;
|
|
MMRESULT mmres;
|
|
|
|
|
|
if (m_hWave)
|
|
{
|
|
TRC(WRN, _T("vcwaveOpen: device is already opened. Reopening\n"));
|
|
|
|
waveOutReset(m_hWave);
|
|
vcwaveClose();
|
|
}
|
|
|
|
if (INVALID_SOCKET == m_hDGramSocket)
|
|
{
|
|
TRC(ERR, _T("vcwaveOpen: no datagram connection, falling to VC\n"));
|
|
}
|
|
|
|
// 11.025 kHz, 8 bit, mono
|
|
|
|
if (NULL == m_hMsgWindow && !CreateMsgWindow(m_hInst))
|
|
goto exitpt;
|
|
|
|
//
|
|
// fix the format for WMA audio
|
|
//
|
|
if ( WAVE_FORMAT_WMAUDIO2 == pFormat->wFormatTag )
|
|
{
|
|
DWORD dwTotalSize = sizeof( WMAUDIO2WAVEFORMAT ) -
|
|
sizeof( WAVEFORMATEX ) + sizeof( WMAUDIO_DEC_KEY );
|
|
|
|
ASSERT( pFormat->cbSize == dwTotalSize );
|
|
if ( pFormat->cbSize == dwTotalSize )
|
|
{
|
|
strncpy((CHAR *)(((WMAUDIO2WAVEFORMAT *) pFormat) + 1),
|
|
WMAUDIO_DEC_KEY, sizeof( WMAUDIO_DEC_KEY ));
|
|
}
|
|
}
|
|
mmres = waveOutOpen(
|
|
&m_hWave,
|
|
WAVE_MAPPER,
|
|
pFormat,
|
|
(DWORD_PTR)m_hMsgWindow,
|
|
0, // CallbackInstance
|
|
CALLBACK_WINDOW
|
|
);
|
|
|
|
if (MMSYSERR_NOERROR != mmres)
|
|
{
|
|
TRC(WRN, _T("vcwaveOpen: failed to open WaveOut device: MMRESULT=%d\n"),
|
|
mmres);
|
|
goto exitpt;
|
|
}
|
|
|
|
#ifdef OS_WINCE
|
|
TRC(ALV, _T("waveOutOpen succeeded with following format %d\n"), pFormat->wFormatTag);
|
|
TRC(ALV, _T("FormatTag - %d\n"), pFormat->wFormatTag);
|
|
TRC(ALV, _T("Channels - %d\n"), pFormat->nChannels);
|
|
TRC(ALV, _T("SamplesPerSec - %d\n"), pFormat->nSamplesPerSec);
|
|
TRC(ALV, _T("AvgBytesPerSec - %d\n"), pFormat->nAvgBytesPerSec);
|
|
TRC(ALV, _T("BlockAlign - %d\n"), pFormat->nBlockAlign);
|
|
TRC(ALV, _T("BitsPerSample - %d\n"), pFormat->wBitsPerSample);
|
|
TRC(ALV, _T("cbSize - %d\n"), pFormat->cbSize);
|
|
#endif
|
|
|
|
#ifdef DBG
|
|
// Win95 InterlockedIncrement() difference.
|
|
InterlockedIncrement(&m_lTimesWaveOutOpened);
|
|
|
|
if ( 1 != m_lTimesWaveOutOpened )
|
|
{
|
|
TRC(FATAL, _T("Device was opened %d times\n"),
|
|
m_lTimesWaveOutOpened);
|
|
ASSERT(0);
|
|
}
|
|
#endif
|
|
|
|
rv = TRUE;
|
|
|
|
exitpt:
|
|
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* vcwaveFreeAllWaves
|
|
*
|
|
* Description:
|
|
* Frees all queued data
|
|
*
|
|
*/
|
|
VOID
|
|
CRDPSound::vcwaveFreeAllWaves(
|
|
VOID
|
|
)
|
|
{
|
|
while ( NULL != m_pFirstWave )
|
|
{
|
|
LPWAVEHDR lpNext = m_pFirstWave->lpNext;
|
|
|
|
free( m_pFirstWave->lpData );
|
|
free( m_pFirstWave );
|
|
|
|
m_pFirstWave = lpNext;
|
|
}
|
|
|
|
m_pFirstWave = m_pLastWave = NULL;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* vcwaveOutWrite
|
|
*
|
|
* Description:
|
|
* Writes a data to the output sound device
|
|
*
|
|
*/
|
|
MMRESULT
|
|
CRDPSound::vcwaveOutWrite(
|
|
LPWAVEHDR lpWaveHdr
|
|
)
|
|
{
|
|
MMRESULT mmres;
|
|
|
|
mmres = waveOutPrepareHeader(
|
|
m_hWave,
|
|
lpWaveHdr,
|
|
sizeof(*lpWaveHdr)
|
|
);
|
|
|
|
if (MMSYSERR_NOERROR != mmres)
|
|
{
|
|
TRC(WRN, _T("vcwaveOpen: failed to prepare buffer: MMRESULT=%d\n"),
|
|
mmres);
|
|
goto exitpt;
|
|
}
|
|
|
|
m_dwWavesPlaying++;
|
|
#if DBG
|
|
m_lPrepdBlocks ++;
|
|
#endif
|
|
|
|
mmres = waveOutWrite(
|
|
m_hWave,
|
|
lpWaveHdr,
|
|
sizeof(*lpWaveHdr)
|
|
);
|
|
|
|
if (MMSYSERR_NOERROR != mmres)
|
|
{
|
|
TRC(WRN, _T("vcwaveOpen: failed to write in WaveOut device: MMRESULT=%d\n"),
|
|
mmres);
|
|
|
|
waveOutUnprepareHeader(
|
|
m_hWave,
|
|
lpWaveHdr,
|
|
sizeof(*lpWaveHdr)
|
|
);
|
|
|
|
m_dwWavesPlaying --;
|
|
#if DBG
|
|
m_lPrepdBlocks --;
|
|
#endif
|
|
|
|
goto exitpt;
|
|
}
|
|
|
|
exitpt:
|
|
return mmres;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* vcwaveWrite
|
|
*
|
|
* Description:
|
|
* If the format id is not changes calls vcwaveOutWrite
|
|
* otherwise queues the data for later
|
|
*
|
|
*/
|
|
BOOL
|
|
CRDPSound::vcwaveWrite(
|
|
BYTE cBlockNo,
|
|
DWORD dwFormatNo,
|
|
DWORD dwTimeStamp,
|
|
DWORD dwWaveDataLen,
|
|
LPVOID pData
|
|
)
|
|
{
|
|
BOOL rv = FALSE;
|
|
LPVOID lpWaveData = NULL;
|
|
LPWAVEHDR lpWaveHdr = NULL;
|
|
MMRESULT mmres;
|
|
BOOL bDontPlay = FALSE;
|
|
|
|
//
|
|
// put the stamp here to remove the delay of opening the device
|
|
//
|
|
DWORD dwStartStamp = GetTickCount() & 0xffff;
|
|
|
|
if ( NULL != m_hWave &&
|
|
m_dwCurrentFormat != dwFormatNo )
|
|
{
|
|
bDontPlay = TRUE;
|
|
}
|
|
|
|
if (NULL == m_hWave)
|
|
{
|
|
TRC(ALV, _T("wcwaveWrite: attempting to open the device\n"));
|
|
if (dwFormatNo >= m_dwNumFormats)
|
|
{
|
|
TRC(FATAL, _T("Invalid format no: %d\n"),
|
|
dwFormatNo);
|
|
goto exitpt;
|
|
}
|
|
if ( NULL == m_ppFormats )
|
|
{
|
|
TRC(FATAL, _T("No formats available(NULL)\n"));
|
|
goto exitpt;
|
|
}
|
|
if ( !vcwaveOpen( (LPWAVEFORMATEX)m_ppFormats[dwFormatNo] ))
|
|
TRC(ERR, _T("Can't open the device\n"));
|
|
|
|
m_dwCurrentFormat = dwFormatNo;
|
|
}
|
|
|
|
if ((BYTE)( m_cLastReceivedBlock - cBlockNo ) < TSSND_BLOCKSONTHENET)
|
|
{
|
|
TRC(WRN, _T("wcwaveWrite: received old block, ")
|
|
_T("the last one is %d, this one is %d. Discarding\n"),
|
|
m_cLastReceivedBlock,
|
|
cBlockNo);
|
|
goto exitpt;
|
|
} else
|
|
m_cLastReceivedBlock = cBlockNo;
|
|
|
|
lpWaveData = malloc(dwWaveDataLen);
|
|
if (!lpWaveData)
|
|
{
|
|
TRC(ERR, _T("vcwaveWrite: malloc failed to allocate %d bytes\n"),
|
|
dwWaveDataLen);
|
|
goto exitpt;
|
|
}
|
|
|
|
lpWaveHdr = (LPWAVEHDR)malloc(sizeof(*lpWaveHdr));
|
|
if (!lpWaveHdr)
|
|
{
|
|
TRC(ERR, _T("vcwaveWrite: malloc failed for %d bytes\n"),
|
|
sizeof(*lpWaveHdr));
|
|
goto exitpt;
|
|
}
|
|
|
|
memset(lpWaveHdr, 0, sizeof(*lpWaveHdr));
|
|
|
|
memcpy(lpWaveData, pData, dwWaveDataLen);
|
|
|
|
lpWaveHdr->lpData = (LPSTR)lpWaveData;
|
|
lpWaveHdr->dwBufferLength = dwWaveDataLen;
|
|
lpWaveHdr->dwFlags = 0;
|
|
lpWaveHdr->dwLoops = 0;
|
|
|
|
//
|
|
// here, we'll do a little magic with the time stamp
|
|
// in order to exclude the time when time packet is in the wave queue
|
|
// we'll subtract the current time now and add the time when
|
|
// confirmation is to be send
|
|
//
|
|
#if _STAT_DBG
|
|
TRC(INF, _T("blockno=%d, time stamp=%x\n"),
|
|
cBlockNo, dwTimeStamp );
|
|
#endif
|
|
|
|
lpWaveHdr->dwUser = (cBlockNo << 16) +
|
|
((dwTimeStamp - dwStartStamp ) & 0xffff);
|
|
|
|
if ( bDontPlay )
|
|
{
|
|
//
|
|
// format change
|
|
// add this wave to the list
|
|
//
|
|
lpWaveHdr->reserved = dwFormatNo;
|
|
lpWaveHdr->lpNext = NULL;
|
|
|
|
if ( NULL != m_pLastWave )
|
|
m_pLastWave->lpNext = lpWaveHdr;
|
|
else
|
|
m_pFirstWave = lpWaveHdr;
|
|
|
|
m_pLastWave = lpWaveHdr;
|
|
|
|
ASSERT( NULL != lpWaveHdr->lpData );
|
|
|
|
TRC(INF, _T("vcwaveWrite: posting WM_RESAMPLE\n"));
|
|
PostMessage( m_hMsgWindow, WM_RESAMPLE, 0, 0 );
|
|
|
|
goto leavept;
|
|
}
|
|
|
|
mmres = vcwaveOutWrite( lpWaveHdr );
|
|
|
|
if (MMSYSERR_NOERROR != mmres)
|
|
{
|
|
TRC(WRN, _T("vcwaveOpen: failed to play a buffer: MMRESULT=%d\n"),
|
|
mmres);
|
|
goto exitpt;
|
|
}
|
|
|
|
leavept:
|
|
|
|
rv = TRUE;
|
|
|
|
exitpt:
|
|
|
|
if (!rv)
|
|
{
|
|
if (lpWaveData)
|
|
free(lpWaveData);
|
|
|
|
if (lpWaveHdr)
|
|
free(lpWaveHdr);
|
|
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* DGramInit
|
|
*
|
|
* Description:
|
|
* Init our UDP socket
|
|
*
|
|
*/
|
|
BOOL
|
|
CRDPSound::DGramInit(
|
|
VOID
|
|
)
|
|
{
|
|
BOOL rv = FALSE;
|
|
#ifndef OS_WINCE
|
|
INT optval;
|
|
#endif
|
|
INT rc;
|
|
struct sockaddr_in sin;
|
|
|
|
ASSERT(INVALID_SOCKET == m_hDGramSocket);
|
|
|
|
m_hDGramSocket = socket(AF_INET, SOCK_DGRAM, 0);
|
|
if (INVALID_SOCKET == m_hDGramSocket)
|
|
{
|
|
TRC(ERR, _T("DGramInit: can't create dgram socket: %d\n"),
|
|
WSAGetLastError());
|
|
goto exitpt;
|
|
}
|
|
|
|
// bind the socket to any port/address
|
|
//
|
|
sin.sin_family = PF_INET;
|
|
sin.sin_port = htons(0); // any port between 1024 and 50000
|
|
sin.sin_addr.s_addr = INADDR_ANY;
|
|
|
|
rc = bind(m_hDGramSocket, (struct sockaddr *)(&sin), sizeof(sin));
|
|
if (SOCKET_ERROR == rc)
|
|
{
|
|
TRC(ERR, _T("DGramInit: can't bind the socket: %d\n"),
|
|
WSAGetLastError());
|
|
goto exitpt;
|
|
}
|
|
|
|
#ifndef OS_WINCE
|
|
//
|
|
// assign an appropriate buffer length
|
|
//
|
|
optval = TSSND_BLOCKSONTHENET * (sizeof(SNDWAVE) + TSSND_BLOCKSIZE);
|
|
rc = setsockopt(m_hDGramSocket,
|
|
SOL_SOCKET,
|
|
SO_RCVBUF,
|
|
(LPSTR)&optval,
|
|
sizeof(optval));
|
|
|
|
if (SOCKET_ERROR == rc)
|
|
{
|
|
TRC(ERR, _T("DGramInit: setsockopt failed: %d\n"),
|
|
WSAGetLastError());
|
|
goto exitpt;
|
|
}
|
|
#endif
|
|
|
|
// select the socket on the message window
|
|
//
|
|
if (NULL != m_hMsgWindow &&
|
|
SOCKET_ERROR ==
|
|
WSAAsyncSelect(m_hDGramSocket, m_hMsgWindow,
|
|
WM_WSOCK, FD_READ))
|
|
{
|
|
TRC(ERR, _T("DGramInit: WSAAsyncSelect failed: %d\n"),
|
|
WSAGetLastError());
|
|
goto exitpt;
|
|
}
|
|
|
|
rv = TRUE;
|
|
|
|
exitpt:
|
|
if (!rv && INVALID_SOCKET != m_hDGramSocket)
|
|
{
|
|
closesocket(m_hDGramSocket);
|
|
m_hDGramSocket = INVALID_SOCKET;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* DGramDone
|
|
*
|
|
* Description:
|
|
* Destroy our UDP socket
|
|
*
|
|
*/
|
|
VOID
|
|
CRDPSound::DGramDone(
|
|
VOID
|
|
)
|
|
{
|
|
if (INVALID_SOCKET != m_hDGramSocket)
|
|
{
|
|
closesocket(m_hDGramSocket);
|
|
m_hDGramSocket = INVALID_SOCKET;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* DGramGetLocalPort
|
|
*
|
|
* Description:
|
|
* Retreives the local UDP port
|
|
*
|
|
*/
|
|
u_short
|
|
CRDPSound::DGramGetLocalPort(
|
|
VOID
|
|
)
|
|
{
|
|
u_short rv = 0;
|
|
struct sockaddr_in sin;
|
|
INT rc;
|
|
INT nSinSize;
|
|
|
|
if (INVALID_SOCKET == m_hDGramSocket)
|
|
{
|
|
TRC(ERR, _T("DGramGetLocalPort: invalid socket\n"));
|
|
goto exitpt;
|
|
}
|
|
|
|
nSinSize = sizeof(sin);
|
|
rc = getsockname(m_hDGramSocket,
|
|
(struct sockaddr *)&sin,
|
|
&nSinSize);
|
|
|
|
if (SOCKET_ERROR == rc)
|
|
{
|
|
TRC(ERR, _T("DGramGetLocalPort: getsockname failed: %d\n"),
|
|
WSAGetLastError());
|
|
goto exitpt;
|
|
}
|
|
|
|
ASSERT(PF_INET == sin.sin_family);
|
|
|
|
rv = sin.sin_port;
|
|
exitpt:
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* DGramSend
|
|
*
|
|
* Description:
|
|
* Send an UDP packet
|
|
*
|
|
*/
|
|
BOOL
|
|
CRDPSound::DGramSend(
|
|
LPVOID pData,
|
|
DWORD dwSize
|
|
)
|
|
{
|
|
INT rc = SOCKET_ERROR;
|
|
struct sockaddr_in sin;
|
|
|
|
ASSERT( 0 != m_dwRemoteDGramPort );
|
|
ASSERT( 0 != m_ulRemoteDGramAddress );
|
|
|
|
if ( INVALID_SOCKET == m_hDGramSocket )
|
|
{
|
|
TRC(ERR, _T("DGramSend: invalid socket handle\n"));
|
|
goto exitpt;
|
|
}
|
|
|
|
sin.sin_family = PF_INET;
|
|
sin.sin_port = (u_short)m_dwRemoteDGramPort;
|
|
sin.sin_addr.s_addr = m_ulRemoteDGramAddress;
|
|
rc = sendto(
|
|
m_hDGramSocket,
|
|
(LPSTR)pData,
|
|
dwSize,
|
|
0,
|
|
(struct sockaddr *)&sin,
|
|
sizeof( sin )
|
|
);
|
|
|
|
if ( SOCKET_ERROR == rc )
|
|
{
|
|
TRC(WRN, _T("DGramSend: sendto failed=%d\n"),
|
|
WSAGetLastError());
|
|
}
|
|
|
|
exitpt:
|
|
return ( rc != SOCKET_ERROR );
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* DGramRecvWave
|
|
*
|
|
* Description:
|
|
* Recieve data from UDP
|
|
*
|
|
*/
|
|
BOOL
|
|
CRDPSound::DGramRecvWave(
|
|
PSNDWAVE pSndWave,
|
|
DWORD dwSize
|
|
)
|
|
{
|
|
BOOL rv = FALSE;
|
|
INT recvd;
|
|
struct sockaddr_in sin_from;
|
|
INT nSinFrom;
|
|
|
|
// parameters check
|
|
//
|
|
if (NULL == pSndWave)
|
|
{
|
|
TRC(ERR, _T("DGramRecvWave: pSndWave is NULL\n"));
|
|
goto exitpt;
|
|
}
|
|
|
|
if (dwSize <= sizeof(*pSndWave))
|
|
{
|
|
TRC(ERR, _T("DGramRecvWave: no enough space to get the wave\n"));
|
|
goto exitpt;
|
|
}
|
|
|
|
// receive the message
|
|
//
|
|
nSinFrom = sizeof( sin_from );
|
|
recvd = recvfrom(
|
|
m_hDGramSocket,
|
|
(LPSTR)pSndWave,
|
|
dwSize,
|
|
0,
|
|
(struct sockaddr *)&sin_from,
|
|
&nSinFrom
|
|
);
|
|
|
|
if (recvd < sizeof(pSndWave->Prolog) || ((DWORD)recvd) > dwSize)
|
|
{
|
|
if (SOCKET_ERROR == recvd)
|
|
TRC(ERR, _T("WM_WSOCK: recvfrom failed: %d\n"),
|
|
WSAGetLastError());
|
|
else
|
|
TRC(WRN,
|
|
_T("WM_WSOCK: received %d bytes instead %d. Discarding\n"),
|
|
recvd, sizeof(pSndWave->Prolog));
|
|
goto exitpt;
|
|
}
|
|
|
|
ASSERT( PF_INET == sin_from.sin_family );
|
|
if ( PF_INET != sin_from.sin_family )
|
|
{
|
|
TRC(WRN, _T("WM_WSOCK: message from invalid protocol( %x )\n"),
|
|
sin_from.sin_family );
|
|
goto exitpt;
|
|
}
|
|
if ( sizeof( sin_from ) > nSinFrom )
|
|
{
|
|
TRC(WRN, _T("WM_WSOCK: from address invalid, len=%d\n"),
|
|
nSinFrom );
|
|
goto exitpt;
|
|
}
|
|
|
|
m_dwRemoteDGramPort = sin_from.sin_port;
|
|
m_ulRemoteDGramAddress = sin_from.sin_addr.s_addr;
|
|
|
|
//
|
|
// Check for line-training request
|
|
//
|
|
if (SNDC_TRAINING == pSndWave->Prolog.Type)
|
|
{
|
|
SNDTRAINING SndTraining;
|
|
PSNDTRAINING pRecvTraining;
|
|
|
|
TRC(ALV, _T("DGramRecvWave: training, sending a response\n"));
|
|
|
|
pRecvTraining = (PSNDTRAINING)pSndWave;
|
|
|
|
SndTraining.Prolog.Type = SNDC_TRAINING;
|
|
SndTraining.Prolog.BodySize = sizeof(SndTraining) -
|
|
sizeof(SndTraining.Prolog);
|
|
SndTraining.wTimeStamp = pRecvTraining->wTimeStamp;
|
|
SndTraining.wPackSize = pRecvTraining->wPackSize;
|
|
|
|
//
|
|
// send the response immediatly
|
|
//
|
|
DGramSend( &SndTraining, sizeof(SndTraining) );
|
|
|
|
goto exitpt;
|
|
}
|
|
|
|
if ( SNDC_UDPWAVE == pSndWave->Prolog.Type)
|
|
{
|
|
rv = ConstructFromDGramFrags(
|
|
(PSNDUDPWAVE)pSndWave,
|
|
recvd,
|
|
pSndWave,
|
|
dwSize
|
|
);
|
|
goto exitpt;
|
|
|
|
} else if ( SNDC_UDPWAVELAST == pSndWave->Prolog.Type)
|
|
{
|
|
rv = ConstructFromDGramLastFrag(
|
|
(PSNDUDPWAVELAST)pSndWave,
|
|
recvd,
|
|
pSndWave,
|
|
dwSize
|
|
);
|
|
goto exitpt;
|
|
}
|
|
|
|
if (SNDC_WAVEENCRYPT == pSndWave->Prolog.Type)
|
|
{
|
|
|
|
if ( !SL_Encrypt(
|
|
(PBYTE)(pSndWave + 1),
|
|
pSndWave->dwBlockNo,
|
|
pSndWave->Prolog.BodySize - sizeof(SNDWAVE) + sizeof(SNDPROLOG) ))
|
|
goto exitpt;
|
|
|
|
}
|
|
else if (SNDC_WAVE != pSndWave->Prolog.Type)
|
|
{
|
|
TRC(ERR, _T("DGramRecvWave: invalid message type: %d\n"),
|
|
pSndWave->Prolog.Type);
|
|
goto exitpt;
|
|
}
|
|
|
|
if ( recvd < sizeof(SNDPROLOG) ||
|
|
pSndWave->Prolog.BodySize + sizeof(SNDPROLOG) != (DWORD)recvd)
|
|
{
|
|
TRC(WRN,
|
|
_T("WM_WSOCK: received %d bytes instead %d. Discarding\n"),
|
|
recvd, pSndWave->Prolog.BodySize + sizeof(SNDPROLOG) );
|
|
goto exitpt;
|
|
}
|
|
|
|
TRC(ALV, _T("DGramRecvWave: block no: %d\n"),
|
|
pSndWave->cBlockNo);
|
|
|
|
rv = TRUE;
|
|
|
|
exitpt:
|
|
return rv;
|
|
}
|
|
|
|
BOOL
|
|
CRDPSound::ConstructFromDGramFrags(
|
|
PSNDUDPWAVE pWave,
|
|
DWORD dwSize,
|
|
PSNDWAVE pReady,
|
|
DWORD dwReadySize
|
|
)
|
|
{
|
|
BOOL rv = FALSE;
|
|
PBYTE pRecvdData;
|
|
DWORD dwFragNo;
|
|
DWORD dwEstimatedSize;
|
|
DWORD dwDataSize;
|
|
PFRAGSLOT pSlot;
|
|
|
|
if ( dwSize <= sizeof( *pWave ))
|
|
{
|
|
TRC( ERR, _T("ConstructFromDGramFrags: packet too small %d\n"),
|
|
dwSize );
|
|
goto exitpt;
|
|
}
|
|
|
|
pRecvdData = (PBYTE)(pWave + 1);
|
|
dwFragNo = pWave->cFragNo & (~RDPSND_FRAGNO_EXT);
|
|
dwDataSize = dwSize - sizeof( *pWave );
|
|
|
|
if ( pWave->cFragNo & RDPSND_FRAGNO_EXT )
|
|
{
|
|
dwFragNo <<= 8;
|
|
dwFragNo += *pRecvdData;
|
|
pRecvdData++;
|
|
dwDataSize--;
|
|
}
|
|
dwEstimatedSize = ( dwFragNo + 1 ) * dwDataSize;
|
|
if ( dwEstimatedSize >= MAX_UDP_SIZE )
|
|
{
|
|
TRC( ERR, _T("ConstructFromDGramFrags: estimated size >=64K (0x%x)\n"),
|
|
dwEstimatedSize );
|
|
goto exitpt;
|
|
}
|
|
|
|
if (!_FragSlotFind( &pSlot, pWave->cBlockNo, dwEstimatedSize ))
|
|
{
|
|
goto exitpt;
|
|
}
|
|
|
|
if ( 0 != pSlot->dwFragSize && pSlot->dwFragSize != dwDataSize )
|
|
{
|
|
TRC( ERR, _T("ConstructFromDGramFrags: received frag with different size: %d, expect %d\n"),
|
|
dwDataSize, pSlot->dwFragSize );
|
|
_FragSlotClear( pSlot );
|
|
goto exitpt;
|
|
}
|
|
memcpy( pSlot->pData + dwFragNo * dwDataSize, pRecvdData, dwDataSize );
|
|
pSlot->dwFragSize = dwDataSize;
|
|
pSlot->dwTotalSize += dwDataSize;
|
|
|
|
// TRC( INF, _T("Fragment received: block#=0x%x, frag#=0x%x, total=0x%x\n"),
|
|
// pWave->cBlockNo, dwFragNo, pSlot->dwTotalSize );
|
|
if ( pSlot->dwTotalSize != pSlot->dwExpectedTotalSize )
|
|
{
|
|
goto exitpt;
|
|
}
|
|
//
|
|
// wave is ready, convert
|
|
//
|
|
if (!_FragSlotToWave( pSlot, pReady, dwReadySize ))
|
|
{
|
|
goto exitpt;
|
|
}
|
|
rv = TRUE;
|
|
|
|
exitpt:
|
|
|
|
return rv;
|
|
}
|
|
|
|
BOOL
|
|
CRDPSound::ConstructFromDGramLastFrag(
|
|
PSNDUDPWAVELAST pLast,
|
|
DWORD dwSize,
|
|
PSNDWAVE pReady,
|
|
DWORD dwReadySize
|
|
)
|
|
{
|
|
BOOL rv = FALSE;
|
|
DWORD dwDataSize;
|
|
PFRAGSLOT pSlot;
|
|
|
|
if ( dwSize < sizeof( *pLast ))
|
|
{
|
|
TRC( ERR, _T("ConstructFromDGramLastFrag: too small packet (%d)\n"), dwSize );
|
|
}
|
|
|
|
if (!_FragSlotFind( &pSlot, pLast->cBlockNo, pLast->wTotalSize ))
|
|
{
|
|
TRC( WRN, _T("ConstructFromDGramLastFrag: Failed to find a slot for last fragment\n" ));
|
|
goto exitpt;
|
|
}
|
|
|
|
pSlot->dwExpectedTotalSize = pLast->wTotalSize;
|
|
pSlot->wTimeStamp = pLast->wTimeStamp;
|
|
pSlot->wFormatNo = pLast->wFormatNo;
|
|
pSlot->dwBlockNo = pLast->dwBlockNo;
|
|
dwDataSize = dwSize - sizeof( *pLast );
|
|
memcpy( pSlot->pData + pSlot->dwExpectedTotalSize - dwDataSize, pLast + 1, dwDataSize );
|
|
|
|
pSlot->dwTotalSize += dwDataSize;
|
|
|
|
// TRC( INF, _T("Fragment LAST block#=0x%x, total=0x%x\n"),
|
|
// pLast->cBlockNo, pSlot->dwTotalSize );
|
|
if ( pSlot->dwTotalSize != pSlot->dwExpectedTotalSize )
|
|
{
|
|
goto exitpt;
|
|
}
|
|
//
|
|
// ready, set, go
|
|
//
|
|
if (!_FragSlotToWave( pSlot, pReady, dwReadySize ))
|
|
{
|
|
goto exitpt;
|
|
}
|
|
rv = TRUE;
|
|
|
|
exitpt:
|
|
return rv;
|
|
}
|
|
|
|
BOOL
|
|
CRDPSound::_FragSlotFind(
|
|
PFRAGSLOT *ppFragSlot,
|
|
BYTE cBlockNo,
|
|
DWORD dwEstimatedSize
|
|
)
|
|
{
|
|
BOOL rv = FALSE;
|
|
PFRAGSLOT pIter = m_pFragSlots;
|
|
PFRAGSLOT pLastFree = NULL;
|
|
PFRAGSLOT pFound = NULL;
|
|
DWORD dwNewSize;
|
|
|
|
while( pIter )
|
|
{
|
|
//
|
|
// check if the slot hasn't been used for a while
|
|
//
|
|
if ( pIter->bUsed &&
|
|
(BYTE)( m_cLastReceivedBlock - pIter->cBlockNo ) < TSSND_BLOCKSONTHENET)
|
|
{
|
|
TRC( WRN, _T("Old frag found id %d, last id %d\n"),
|
|
pIter->cBlockNo, m_cLastReceivedBlock );
|
|
_FragSlotClear( pIter );
|
|
}
|
|
|
|
if ( !pIter->bUsed && NULL == pLastFree )
|
|
{
|
|
pLastFree = pIter;
|
|
|
|
}
|
|
if ( pIter->bUsed && pIter->cBlockNo == cBlockNo )
|
|
{
|
|
// found a block with same number
|
|
pFound = pIter;
|
|
break;
|
|
}
|
|
pIter = pIter->pNext;
|
|
}
|
|
|
|
if ( NULL == pFound && NULL != pLastFree )
|
|
{
|
|
//
|
|
// found a free block
|
|
//
|
|
pLastFree->bUsed = TRUE;
|
|
pLastFree->cBlockNo = cBlockNo;
|
|
pFound = pLastFree;
|
|
}
|
|
|
|
if ( NULL != pFound &&
|
|
pFound->dwAllocatedSize < dwEstimatedSize )
|
|
{
|
|
dwNewSize = dwEstimatedSize * 2;
|
|
|
|
PBYTE pNewData = (PBYTE)malloc( dwEstimatedSize * 2 );
|
|
if ( NULL == pNewData )
|
|
{
|
|
//
|
|
// we can't use this slot anymore
|
|
//
|
|
_FragSlotClear( pFound );
|
|
pFound = NULL;
|
|
goto exitpt;
|
|
}
|
|
memcpy( pNewData, pFound->pData, pFound->dwAllocatedSize );
|
|
pFound->dwAllocatedSize = dwNewSize;
|
|
free( pFound->pData );
|
|
pFound->pData = pNewData;
|
|
|
|
}
|
|
if ( NULL == pFound )
|
|
{
|
|
// allocate a new block
|
|
//
|
|
pFound = (PFRAGSLOT)malloc( sizeof( *pFound ));
|
|
if ( NULL == pFound )
|
|
{
|
|
goto exitpt;
|
|
}
|
|
|
|
dwNewSize = ( dwEstimatedSize > TSSND_BLOCKSIZE + RDPSND_SIGNATURE_SIZE )
|
|
? dwEstimatedSize : TSSND_BLOCKSIZE + RDPSND_SIGNATURE_SIZE;
|
|
|
|
pFound->pData = (PBYTE)malloc( dwNewSize );
|
|
if ( NULL == pFound->pData )
|
|
{
|
|
free( pFound );
|
|
goto exitpt;
|
|
}
|
|
|
|
pFound->dwAllocatedSize = dwNewSize;
|
|
_FragSlotClear( pFound );
|
|
pFound->bUsed = TRUE;
|
|
pFound->cBlockNo = cBlockNo;
|
|
|
|
//
|
|
// add it to the list
|
|
//
|
|
pFound->pNext = m_pFragSlots;
|
|
m_pFragSlots = pFound;
|
|
}
|
|
|
|
*ppFragSlot = pFound;
|
|
|
|
rv = TRUE;
|
|
|
|
exitpt:
|
|
|
|
return rv;
|
|
}
|
|
|
|
VOID
|
|
CRDPSound::_FragSlotClear(
|
|
PFRAGSLOT pSlot
|
|
)
|
|
{
|
|
DWORD dwAllocated = pSlot->dwAllocatedSize;
|
|
PBYTE pData = pSlot->pData;
|
|
PFRAGSLOT pNext = pSlot->pNext;
|
|
|
|
memset( pSlot, 0, sizeof( *pSlot ));
|
|
pSlot->dwAllocatedSize = dwAllocated;
|
|
pSlot->pData = pData;
|
|
pSlot->pNext = pNext;
|
|
}
|
|
|
|
VOID
|
|
CRDPSound::_FragSlotFreeAll(
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// free the fragment slots too
|
|
//
|
|
while( NULL != m_pFragSlots )
|
|
{
|
|
PFRAGSLOT pNext = m_pFragSlots->pNext;
|
|
|
|
free( m_pFragSlots->pData );
|
|
free( m_pFragSlots );
|
|
|
|
m_pFragSlots = pNext;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
CRDPSound::_FragSlotToWave(
|
|
PFRAGSLOT pSlot,
|
|
PSNDWAVE pWave,
|
|
DWORD dwWaveSize
|
|
)
|
|
{
|
|
BOOL rv = FALSE;
|
|
DWORD dwAvailDataSize;
|
|
DWORD dwBodySize;
|
|
|
|
ASSERT( pSlot->dwExpectedTotalSize == pSlot->dwTotalSize );
|
|
|
|
dwAvailDataSize = dwWaveSize - sizeof( *pWave );
|
|
if ( dwAvailDataSize < pSlot->dwTotalSize )
|
|
{
|
|
TRC( ERR, _T("_FragSlotToWave insufficient size to move the wave")
|
|
_T(" need %d, available %d\n"),
|
|
pSlot->dwTotalSize, dwAvailDataSize );
|
|
goto exitpt;
|
|
}
|
|
|
|
//
|
|
// when we support fragments, packets are encrypted
|
|
//
|
|
pWave->Prolog.Type = SNDC_WAVEENCRYPT;
|
|
dwBodySize = pSlot->dwTotalSize + sizeof( *pWave ) -
|
|
sizeof( pWave->Prolog );
|
|
ASSERT( dwBodySize < MAX_UDP_SIZE - sizeof( *pWave ));
|
|
pWave->Prolog.BodySize = (UINT16)dwBodySize;
|
|
pWave->wTimeStamp = pSlot->wTimeStamp;
|
|
pWave->wFormatNo = pSlot->wFormatNo;
|
|
pWave->dwBlockNo = pSlot->dwBlockNo;
|
|
memcpy( pWave + 1, pSlot->pData, pSlot->dwTotalSize );
|
|
|
|
//
|
|
// release the slot
|
|
//
|
|
_FragSlotClear( pSlot );
|
|
|
|
rv = TRUE;
|
|
|
|
exitpt:
|
|
return rv;
|
|
}
|
|
|
|
INT
|
|
WSInit(
|
|
VOID
|
|
)
|
|
{
|
|
WORD versionRequested;
|
|
WSADATA wsaData;
|
|
int intRC;
|
|
|
|
versionRequested = MAKEWORD(1, 1);
|
|
|
|
intRC = WSAStartup(versionRequested, &wsaData);
|
|
|
|
if (intRC != 0)
|
|
{
|
|
TRC(ERR, _T("Failed to initialize WinSock rc:%d\n"), intRC);
|
|
}
|
|
return intRC;
|
|
}
|
|
|
|
/*
|
|
* create signature bits
|
|
*/
|
|
VOID
|
|
CRDPSound::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 *)(m_EncryptKey + RANDOM_KEY_LENGTH)) = dwBlockNo;
|
|
A_SHAUpdate(&SHACtx, (PBYTE)m_EncryptKey, sizeof(m_EncryptKey));
|
|
A_SHAFinal(&SHACtx, ShaBits);
|
|
memcpy( pSig, ShaBits, RDPSND_SIGNATURE_SIZE );
|
|
}
|
|
|
|
/*
|
|
* signature which verifies the audio bits
|
|
*/
|
|
VOID
|
|
CRDPSound::SL_AudioSignature(
|
|
PBYTE pSig,
|
|
DWORD dwBlockNo,
|
|
PBYTE pData,
|
|
DWORD dwDataSize
|
|
)
|
|
{
|
|
BYTE ShaBits[A_SHA_DIGEST_LEN];
|
|
A_SHA_CTX SHACtx;
|
|
|
|
A_SHAInit(&SHACtx);
|
|
*((DWORD *)(m_EncryptKey + RANDOM_KEY_LENGTH)) = dwBlockNo;
|
|
A_SHAUpdate(&SHACtx, (PBYTE)m_EncryptKey, sizeof(m_EncryptKey));
|
|
A_SHAUpdate(&SHACtx, pData, dwDataSize );
|
|
A_SHAFinal(&SHACtx, ShaBits);
|
|
memcpy( pSig, ShaBits, RDPSND_SIGNATURE_SIZE );
|
|
}
|
|
|
|
/*
|
|
* encrypt/decrypt a block of data
|
|
*
|
|
*/
|
|
BOOL
|
|
CRDPSound::SL_Encrypt( PBYTE pBits, DWORD BlockNo, DWORD dwBitsLen )
|
|
{
|
|
BYTE ShaBits[A_SHA_DIGEST_LEN];
|
|
RC4_KEYSTRUCT rc4key;
|
|
#ifndef OS_WINCE
|
|
DWORD i;
|
|
#endif
|
|
PBYTE pbBuffer;
|
|
A_SHA_CTX SHACtx;
|
|
DWORD dw;
|
|
DWORD_PTR *pdwBits;
|
|
|
|
A_SHAInit(&SHACtx);
|
|
|
|
// SHA the static bits
|
|
*((DWORD *)(m_EncryptKey + RANDOM_KEY_LENGTH)) = BlockNo;
|
|
A_SHAUpdate(&SHACtx, (PBYTE)m_EncryptKey, sizeof(m_EncryptKey));
|
|
|
|
A_SHAFinal(&SHACtx, ShaBits);
|
|
|
|
rc4_key(&rc4key, A_SHA_DIGEST_LEN, ShaBits);
|
|
rc4(&rc4key, dwBitsLen, pBits);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Function:
|
|
* _DbgPrintMessage
|
|
*
|
|
* Description:
|
|
* A tracing function
|
|
*
|
|
* Parameters:
|
|
* level - current message trace level
|
|
* format - message format
|
|
* ... - parameters
|
|
*
|
|
*/
|
|
VOID
|
|
_cdecl
|
|
_DbgPrintMessage(LPCTSTR level, LPCTSTR format, ...)
|
|
{
|
|
TCHAR szBuffer[256];
|
|
va_list arglist;
|
|
|
|
if (ALV == level)
|
|
return;
|
|
|
|
va_start (arglist, format);
|
|
StringCchVPrintf(szBuffer, SIZE_TCHARS(szBuffer), format, arglist);
|
|
va_end (arglist);
|
|
|
|
#ifndef OS_WINCE
|
|
OutputDebugString(level);
|
|
OutputDebugString(szBuffer);
|
|
#endif // !OS_WINCE
|
|
}
|