#include "precomp.h"
#include "dtmf.h"


HRESULT
SendAudioStream::Initialize( DataPump *pDP)
{
	HRESULT hr = DPR_OUT_OF_MEMORY;
	DWORD dwFlags =  DP_FLAG_FULL_DUPLEX | DP_FLAG_AUTO_SWITCH ;
	MEDIACTRLINIT mcInit;
	FX_ENTRY ("SendAudioStream::Initialize")

	dwFlags |= DP_FLAG_ACM | DP_FLAG_MMSYSTEM | DP_FLAG_AUTO_SILENCE_DETECT;

	// store the platform flags
	// enable Send and Recv by default
	m_DPFlags = (dwFlags & DP_MASK_PLATFORM) | DPFLAG_ENABLE_SEND;
	// store a back pointer to the datapump container
	m_pDP = pDP;

	m_Net = NULL; // this object (RTPSession) no longer used;
	m_pRTPSend = NULL;  // replaced with this object (RTPSend)

	// Initialize data (should be in constructor)
	m_CaptureDevice = (UINT) -1;	// use VIDEO_MAPPER



	// Create and Transmit audio streams
	
    DBG_SAVE_FILE_LINE
	m_SendStream = new TxStream();
	if ( !m_SendStream)
	{
		DEBUGMSG (ZONE_DP, ("%s: TxStream new failed\r\n", _fx_));
 		goto StreamAllocError;
	}


	// Create Input and Output audio filters
    DBG_SAVE_FILE_LINE
	m_pAudioFilter = new AcmFilter();  // audio filter will replace m_SendFilter
	if (!m_pAudioFilter)
	{
		DEBUGMSG (ZONE_DP, ("%s: FilterManager new failed\r\n", _fx_));
		goto FilterAllocError;
	}
	
	//Create MultiMedia device control objects
    DBG_SAVE_FILE_LINE
	m_InMedia = new WaveInControl();
	if (!m_InMedia )
	{
		DEBUGMSG (ZONE_DP, ("%s: MediaControl new failed\r\n", _fx_));
		goto MediaAllocError;
	}

	// Initialize the send-stream media control object
	mcInit.dwFlags = dwFlags | DP_FLAG_SEND;
	hr = m_InMedia->Initialize(&mcInit);
	if (hr != DPR_SUCCESS)
	{
		DEBUGMSG (ZONE_DP, ("%s: IMedia->Init failed, hr=0x%lX\r\n", _fx_, hr));
		goto MediaAllocError;
	}

    DBG_SAVE_FILE_LINE
	m_pDTMF = new DTMFQueue;
	if (!m_pDTMF)
	{
		return DPR_OUT_OF_MEMORY;
	}



	// determine if the wave devices are available
	if (waveInGetNumDevs()) m_DPFlags |= DP_FLAG_RECORD_CAP;
	
	// set media to half duplex mode by default
	m_InMedia->SetProp(MC_PROP_DUPLEX_TYPE, DP_FLAG_HALF_DUPLEX);

	m_SavedTickCount = timeGetTime();	//so we start with low timestamps
	m_DPFlags |= DPFLAG_INITIALIZED;

	m_bAutoMix = FALSE; // where else do you initialize this ?

	return DPR_SUCCESS;


MediaAllocError:
	if (m_InMedia) delete m_InMedia;
FilterAllocError:
	if (m_pAudioFilter) delete m_pAudioFilter;
StreamAllocError:
	if (m_SendStream) delete m_SendStream;

	ERRORMESSAGE( ("%s: exit, hr=0x%lX\r\n", _fx_, hr));

	return hr;
}


SendAudioStream::~SendAudioStream()
{

	if (m_DPFlags & DPFLAG_INITIALIZED) {
		m_DPFlags &= ~DPFLAG_INITIALIZED;
	
		if (m_DPFlags & DPFLAG_CONFIGURED_SEND )
			UnConfigure();

		if (m_pRTPSend)
		{
			m_pRTPSend->Release();
			m_pRTPSend = NULL;
		}

		if (m_pDTMF)
		{
			delete m_pDTMF;
			m_pDTMF = NULL;
		}

		// Close the receive and transmit streams
		if (m_SendStream) delete m_SendStream;

		// Close the wave devices
		if (m_InMedia) { delete m_InMedia;}


		if (m_pAudioFilter)
			delete m_pAudioFilter;

		m_pDP->RemoveMediaChannel(MCF_SEND|MCF_AUDIO, (IMediaChannel*)(SendMediaStream*)this);
	}
}


HRESULT STDMETHODCALLTYPE SendAudioStream::QueryInterface(REFIID iid, void **ppVoid)
{
	// resolve duplicate inheritance to the SendMediaStream;

	extern IID IID_IProperty;

	if (iid == IID_IUnknown)
	{
		*ppVoid = (IUnknown*)((SendMediaStream*)this);
	}
	else if (iid == IID_IMediaChannel)
	{
		*ppVoid = (IMediaChannel*)((SendMediaStream *)this);
	}
	else if (iid == IID_IAudioChannel)
	{
		*ppVoid = (IAudioChannel*)this;
	}
	else if (iid == IID_IDTMFSend)
	{
		*ppVoid = (IDTMFSend*)this;
	}
	else if (iid == IID_IProperty)
	{
		*ppVoid = NULL;
		ERROR_OUT(("Don't QueryInterface for IID_IProperty, use IMediaChannel"));
		return E_NOINTERFACE;
	}
	else
	{
		*ppVoid = NULL;
		return E_NOINTERFACE;
	}
	AddRef();

	return S_OK;

}

ULONG STDMETHODCALLTYPE SendAudioStream::AddRef(void)
{
	return InterlockedIncrement(&m_lRefCount);
}

ULONG STDMETHODCALLTYPE SendAudioStream::Release(void)
{
	LONG lRet;

	lRet = InterlockedDecrement(&m_lRefCount);

	if (lRet == 0)
	{
		delete this;
		return 0;
	}

	else
		return lRet;

}



	
HRESULT STDMETHODCALLTYPE SendAudioStream::Configure(
	BYTE *pFormat,
	UINT cbFormat,
	BYTE *pChannelParams,
	UINT cbParams,
	IUnknown *pUnknown)
{
	HRESULT hr;
	BOOL fRet;
	MEDIAPACKETINIT apInit;
	MEDIACTRLCONFIG mcConfig;
	MediaPacket **ppAudPckt;
	ULONG cAudPckt;
	DWORD_PTR dwPropVal;
    DWORD dwSourceSize, dwDestSize;
	UINT ringSize = MAX_RXRING_SIZE;
	WAVEFORMATEX *pwfSend;
	DWORD dwPacketDuration, dwPacketSize;
	AUDIO_CHANNEL_PARAMETERS audChannelParams;
	audChannelParams.RTP_Payload = 0;
	MMRESULT mmr;
	int nIndex;
	
	FX_ENTRY ("SendAudioStream::Configure")

	// basic parameter checking
	if (! (m_DPFlags & DPFLAG_INITIALIZED))
		return DPR_OUT_OF_MEMORY;		//BUGBUG: return proper error;

	// Not a good idea to change anything while in mid-stream
	if (m_DPFlags & DPFLAG_STARTED_SEND)
	{
		return DPR_IO_PENDING; // anything better to return
	}

	if (m_DPFlags & DPFLAG_CONFIGURED_SEND)
	{
		DEBUGMSG(ZONE_DP, ("Stream Re-Configuration - calling UnConfigure"));
		UnConfigure();
	}


	if ((NULL == pFormat) || (NULL == pChannelParams) ||
		(cbParams < sizeof(AUDIO_CHANNEL_PARAMETERS)) ||
		(cbFormat < sizeof(WAVEFORMATEX)))
	{
		return DPR_INVALID_PARAMETER;
	}

	audChannelParams = *(AUDIO_CHANNEL_PARAMETERS *)pChannelParams;
	pwfSend = (WAVEFORMATEX *)pFormat;
	m_wfCompressed = *pwfSend;
	m_wfCompressed.cbSize = 0;

	mmr = AcmFilter::SuggestDecodeFormat(pwfSend, &m_fDevSend);

	UPDATE_REPORT_ENTRY(g_prptCallParameters, pwfSend->wFormatTag, REP_SEND_AUDIO_FORMAT);
	UPDATE_REPORT_ENTRY(g_prptCallParameters, pwfSend->nSamplesPerSec, REP_SEND_AUDIO_SAMPLING);
	UPDATE_REPORT_ENTRY(g_prptCallParameters, pwfSend->nAvgBytesPerSec * 8, REP_SEND_AUDIO_BITRATE);
	RETAILMSG(("NAC: Audio Send Format: %s", (pwfSend->wFormatTag == 66) ? "G723.1" : (pwfSend->wFormatTag == 112) ? "LHCELP" : (pwfSend->wFormatTag == 113) ? "LHSB08" : (pwfSend->wFormatTag == 114) ? "LHSB12" : (pwfSend->wFormatTag == 115) ? "LHSB16" : (pwfSend->wFormatTag == 6) ? "MSALAW" : (pwfSend->wFormatTag == 7) ? "MSULAW" : (pwfSend->wFormatTag == 130) ? "MSRT24" : "??????"));
	RETAILMSG(("NAC: Audio Send Sampling Rate (Hz): %ld", pwfSend->nSamplesPerSec));
	RETAILMSG(("NAC: Audio Send Bitrate (w/o network overhead - bps): %ld", pwfSend->nAvgBytesPerSec*8));

// Initialize the send-stream media control object
	mcConfig.uDuration = MC_USING_DEFAULT;	// set duration by samples per pkt
	mcConfig.pDevFmt = &m_fDevSend;
	mcConfig.hStrm = (DPHANDLE) m_SendStream;
	mcConfig.uDevId = m_CaptureDevice;
	mcConfig.cbSamplesPerPkt = audChannelParams.ns_params.wFrameSize
		*audChannelParams.ns_params.wFramesPerPkt;

	UPDATE_REPORT_ENTRY(g_prptCallParameters, mcConfig.cbSamplesPerPkt, REP_SEND_AUDIO_PACKET);
	RETAILMSG(("NAC: Audio Send Packetization (ms/packet): %ld", pwfSend->nSamplesPerSec ? mcConfig.cbSamplesPerPkt * 1000UL / pwfSend->nSamplesPerSec : 0));
	INIT_COUNTER_MAX(g_pctrAudioSendBytes, (pwfSend->nAvgBytesPerSec + pwfSend->nSamplesPerSec * (sizeof(RTP_HDR) + IP_HEADER_SIZE + UDP_HEADER_SIZE) / mcConfig.cbSamplesPerPkt) << 3);

	hr = m_InMedia->Configure(&mcConfig);
	if (hr != DPR_SUCCESS)
	{
		DEBUGMSG (ZONE_DP, ("%s: IMedia->Config failed, hr=0x%lX\r\n", _fx_, hr));
		goto IMediaInitError;
	}

	
	// initialize the ACM filter
	mmr = m_pAudioFilter->Open(&m_fDevSend, pwfSend);
	if (mmr != 0)
	{
		DEBUGMSG (ZONE_DP, ("%s: AcmFilter->Open failed, mmr=%d\r\n", _fx_, mmr));
		hr = DPR_CANT_OPEN_CODEC;
		goto SendFilterInitError;
	}


	// Initialize the send stream and the packets
	ZeroMemory (&apInit, sizeof (apInit));

	apInit.dwFlags = DP_FLAG_SEND | DP_FLAG_ACM | DP_FLAG_MMSYSTEM;
	m_InMedia->FillMediaPacketInit (&apInit);

	m_InMedia->GetProp (MC_PROP_SIZE, &dwPropVal);
    dwSourceSize = (DWORD)dwPropVal;

	m_pAudioFilter->SuggestDstSize(dwSourceSize, &dwDestSize);

	apInit.cbSizeRawData = dwSourceSize;
	apInit.cbOffsetRawData = 0;
	apInit.cbSizeNetData = dwDestSize;
	dwPacketSize = dwDestSize;

	apInit.pStrmConvSrcFmt = &m_fDevSend;
	apInit.pStrmConvDstFmt = &m_wfCompressed;


	m_InMedia->GetProp (MC_PROP_DURATION, &dwPropVal);
    dwPacketDuration = (DWORD)dwPropVal;

	apInit.cbOffsetNetData = sizeof (RTP_HDR);
	apInit.payload = audChannelParams.RTP_Payload;
	fRet = m_SendStream->Initialize (DP_FLAG_MMSYSTEM, MAX_TXRING_SIZE, m_pDP, &apInit);
	if (! fRet)
	{
		DEBUGMSG (ZONE_DP, ("%s: TxStream->Init failed, fRet=0%u\r\n", _fx_, fRet));
		hr = DPR_CANT_INIT_TX_STREAM;
		goto TxStreamInitError;
	}

	// prepare headers for TxStream
	m_SendStream->GetRing (&ppAudPckt, &cAudPckt);
	m_InMedia->RegisterData (ppAudPckt, cAudPckt);
	m_InMedia->PrepareHeaders ();

	m_pAudioFilter->PrepareAudioPackets((AudioPacket**)ppAudPckt, cAudPckt, AP_ENCODE);

	// Open the play from wav file
	OpenSrcFile();


	// Initialize DTMF support
	m_pDTMF->Initialize(&m_fDevSend);
	m_pDTMF->ClearQueue();


	// WS2Qos will be called in Start to communicate stream reservations to the
	// remote endpoint using a RESV message
	//
	// We use a peak-rate allocation approach based on our target bitrates
	// Note that for the token bucket size and the maximum SDU size, we now
	// account for IP header overhead, and use the max frame fragment size
	// instead of the maximum compressed image size returned by the codec
	//
	// Some of the parameters are left unspecified because they are set
	// in the sender Tspec.


	InitAudioFlowspec(&m_flowspec, pwfSend, dwPacketSize);

	if (m_pDP->m_pIQoS)
	{
		// Initialize our requests. One for CPU usage, one for bandwidth usage.
		m_aRRq.cResourceRequests = 2;
		m_aRRq.aResourceRequest[0].resourceID = RESOURCE_OUTGOING_BANDWIDTH;
		if (dwPacketDuration)
			m_aRRq.aResourceRequest[0].nUnitsMin = (DWORD)(dwPacketSize + sizeof(RTP_HDR) + IP_HEADER_SIZE + UDP_HEADER_SIZE) * 8000 / dwPacketDuration;
		else
			m_aRRq.aResourceRequest[0].nUnitsMin = 0;
		m_aRRq.aResourceRequest[1].resourceID = RESOURCE_CPU_CYCLES;
		m_aRRq.aResourceRequest[1].nUnitsMin = 800;

/*
        BUGBUG. This is, in theory the correct calculation, but until we do more investigation, go with a known value

		m_aRRq.aResourceRequest[1].nUnitsMin = (audDetails.wCPUUtilizationEncode+audDetails.wCPUUtilizationDecode)*10;

*/
		// Initialize QoS structure
		ZeroMemory(&m_Stats, sizeof(m_Stats));

		// Initialize oldest QoS callback timestamp
		// Register with the QoS module. Even if this call fails, that's Ok, we'll do without the QoS support
		m_pDP->m_pIQoS->RequestResources((GUID *)&MEDIA_TYPE_H323AUDIO, (LPRESOURCEREQUESTLIST)&m_aRRq, QosNotifyAudioCB, (DWORD_PTR)this);
	}

	m_DPFlags |= DPFLAG_CONFIGURED_SEND;


	return DPR_SUCCESS;

TxStreamInitError:
SendFilterInitError:
	m_InMedia->Close();
	m_pAudioFilter->Close();
IMediaInitError:
	ERRORMESSAGE(("%s:  failed, hr=0%u\r\n", _fx_, hr));
	return hr;
}




void SendAudioStream::UnConfigure()
{
	AudioPacket **ppAudPckt;
	ULONG uPackets;


	if ((m_DPFlags & DPFLAG_CONFIGURED_SEND)) {
	
		if (m_hCapturingThread) {
			Stop();
		}
		
		// Close the wave devices
		m_InMedia->Reset();
		m_InMedia->UnprepareHeaders();
		m_InMedia->Close();
		// Close the play from wav file
		CloseSrcFile();

		// Close the filters
		m_SendStream->GetRing ((MediaPacket***)&ppAudPckt, &uPackets);
		m_pAudioFilter->UnPrepareAudioPackets(ppAudPckt, uPackets, AP_ENCODE);
		m_pAudioFilter->Close();

		// Close the transmit streams
		m_SendStream->Destroy();
		m_DPFlags &= ~DPFLAG_CONFIGURED_SEND;
		m_ThreadFlags = 0;  // invalidate previous call to SetMaxBitrate


		// Release the QoS Resources
		// If the associated RequestResources had failed, the ReleaseResources can be
		// still called... it will just come back without having freed anything.
		if (m_pDP->m_pIQoS)
		{
			m_pDP->m_pIQoS->ReleaseResources((GUID *)&MEDIA_TYPE_H323AUDIO, (LPRESOURCEREQUESTLIST)&m_aRRq);
		}
	}
}


DWORD CALLBACK SendAudioStream::StartRecordingThread (LPVOID pVoid)
{
	SendAudioStream *pThisStream = (SendAudioStream*)pVoid;
	return pThisStream->RecordingThread();
}




// LOOK: identical to SendVideoStream version.
HRESULT
SendAudioStream::Start()
{
	FX_ENTRY ("SendAudioStream::Start")
	if (m_DPFlags & DPFLAG_STARTED_SEND)
		return DPR_SUCCESS;
	// TODO: remove this check once audio UI calls the IComChan PAUSE_ prop
	if (!(m_DPFlags & DPFLAG_ENABLE_SEND))
		return DPR_SUCCESS;
	if ((!(m_DPFlags & DPFLAG_CONFIGURED_SEND)) || (m_pRTPSend==NULL))
		return DPR_NOT_CONFIGURED;
	ASSERT(!m_hCapturingThread);
	m_ThreadFlags &= ~(DPTFLAG_STOP_RECORD|DPTFLAG_STOP_SEND);

	SetFlowSpec();

	// Start recording thread
	if (!(m_ThreadFlags & DPTFLAG_STOP_RECORD))
		m_hCapturingThread = CreateThread(NULL,0, SendAudioStream::StartRecordingThread,(LPVOID)this,0,&m_CaptureThId);

	m_DPFlags |= DPFLAG_STARTED_SEND;

	DEBUGMSG (ZONE_DP, ("%s: Record threadid=%x,\r\n", _fx_, m_CaptureThId));
	return DPR_SUCCESS;
}

// LOOK: identical to SendVideoStream version.
HRESULT
SendAudioStream::Stop()
{											
	DWORD dwWait;

	if(!(m_DPFlags & DPFLAG_STARTED_SEND))
	{
		return DPR_SUCCESS;
	}
	
	m_ThreadFlags = m_ThreadFlags  |
		DPTFLAG_STOP_SEND |  DPTFLAG_STOP_RECORD ;

	if(m_SendStream)
		m_SendStream->Stop();
	
DEBUGMSG (ZONE_VERBOSE, ("STOP1: Waiting for record thread to exit\r\n"));

	/*
	 *	we want to wait for all the threads to exit, but we need to handle windows
	 *	messages (mostly from winsock) while waiting.
	 */

	if(m_hCapturingThread)
	{
		dwWait = WaitForSingleObject (m_hCapturingThread, INFINITE);

		DEBUGMSG (ZONE_VERBOSE, ("STOP2: Recording thread exited\r\n"));
		ASSERT(dwWait != WAIT_FAILED);
	
		CloseHandle(m_hCapturingThread);
		m_hCapturingThread = NULL;
	}
	m_DPFlags &= ~DPFLAG_STARTED_SEND;
	
	return DPR_SUCCESS;
}



// low order word is the signal strength
// high order work contains bits to indicate status
// (0x01 - transmitting)
// (0x02 - audio device is jammed)
STDMETHODIMP SendAudioStream::GetSignalLevel(UINT *pSignalStrength)
{
	UINT uLevel;
	DWORD dwJammed;
    DWORD_PTR dwPropVal;

	if(!(m_DPFlags & DPFLAG_STARTED_SEND))
	{
		uLevel = 0;
	}
	else
	{
		uLevel = m_AudioMonitor.GetSignalStrength();

		m_InMedia->GetProp(MC_PROP_AUDIO_JAMMED, &dwPropVal);
        dwJammed = (DWORD)dwPropVal;

		if (dwJammed)
		{
			uLevel = (2 << 16);  // 0x0200
		}
		else if (m_fSending)
		{
			uLevel |= (1 << 16); // 0x0100 + uLevel
		}
	}

	*pSignalStrength = uLevel;
	return S_OK;
};



// this interface method is primarily for H.245 flow control messages
// it will pause the stream if uMaxBitrate is less than the codec
// output bitrate.  Only valid on a Configure'd stream.
HRESULT STDMETHODCALLTYPE SendAudioStream::SetMaxBitrate(UINT uMaxBitrate)
{
	UINT uMinBitrate;
	
	if (!(m_DPFlags & DPFLAG_CONFIGURED_SEND))
	{
		return DPR_NOT_CONFIGURED;
	}

	uMinBitrate = 8 * m_wfCompressed.nAvgBytesPerSec;

	if (uMaxBitrate < uMinBitrate)
	{
		DEBUGMSG(1, ("SendAudioStream::SetMaxBitrate - PAUSING"));
		m_ThreadFlags |= DPTFLAG_PAUSE_SEND;
	}
	else
	{
		DEBUGMSG(1, ("SendAudioStream::SetMaxBitrate - UnPausing"));
		m_ThreadFlags = m_ThreadFlags & ~(DPTFLAG_PAUSE_SEND);
	}

	return S_OK;
}

//  IProperty::GetProperty / SetProperty
//  (DataPump::MediaChannel::GetProperty)
//      Properties of the MediaChannel. Supports properties for both audio
//      and video channels.

STDMETHODIMP
SendAudioStream::GetProperty(
	DWORD prop,
	PVOID pBuf,
	LPUINT pcbBuf
    )
{
	HRESULT hr = DPR_SUCCESS;
	RTP_STATS RTPStats;
	DWORD_PTR dwPropVal;
	UINT len = sizeof(DWORD);	// most props are DWORDs

	if (!pBuf || *pcbBuf < len)
    {
		*pcbBuf = len;
		return DPR_INVALID_PARAMETER;
	}

	switch (prop)
    {
	case PROP_AUDIO_STRENGTH:
		return GetSignalLevel((UINT *)pBuf);

	case PROP_AUDIO_JAMMED:
		hr = m_InMedia->GetProp(MC_PROP_AUDIO_JAMMED, &dwPropVal);
        *(DWORD *)pBuf = (DWORD)dwPropVal;
		break;

#ifdef OLDSTUFF
	case PROP_NET_SEND_STATS:
		if (m_Net && *pcbBuf >= sizeof(RTP_STATS))
        {
			m_Net->GetSendStats((RTP_STATS *)pBuf);
			*pcbBuf = sizeof(RTP_STATS);
		} else
			hr = DPR_INVALID_PROP_VAL;
			
		break;
#endif

	case PROP_DURATION:
		hr = m_InMedia->GetProp(MC_PROP_DURATION, &dwPropVal);
        *(DWORD *)pBuf = (DWORD)dwPropVal;
		break;

	case PROP_SILENCE_LEVEL:
		*(DWORD *)pBuf = m_AudioMonitor.GetSilenceLevel();
		break;

	case PROP_SILENCE_DURATION:
		hr = m_InMedia->GetProp(MC_PROP_SILENCE_DURATION, &dwPropVal);
        *(DWORD *)pBuf = (DWORD)dwPropVal;
		break;

	case PROP_DUPLEX_TYPE:
		hr = m_InMedia->GetProp(MC_PROP_DUPLEX_TYPE, &dwPropVal);
		if(HR_SUCCEEDED(hr))
		{
			if(dwPropVal & DP_FLAG_FULL_DUPLEX)
				*(DWORD *)pBuf = DUPLEX_TYPE_FULL;
			else
				*(DWORD *)pBuf = DUPLEX_TYPE_HALF;
		}
		break;

	case PROP_AUDIO_SPP:
		hr = m_InMedia->GetProp(MC_PROP_SPP, &dwPropVal);
        *(DWORD *)pBuf = (DWORD)dwPropVal;
		break;

	case PROP_AUDIO_SPS:
		hr = m_InMedia->GetProp(MC_PROP_SPS, &dwPropVal);
        *(DWORD *)pBuf = (DWORD)dwPropVal;
		break;

	case PROP_WAVE_DEVICE_TYPE:
		*(DWORD *)pBuf = m_DPFlags & DP_MASK_WAVE_DEVICE;
		break;

	case PROP_RECORD_ON:
		*(DWORD *)pBuf = (m_DPFlags & DPFLAG_ENABLE_SEND) !=0;
		break;

	case PROP_AUDIO_AUTOMIX:
		*(DWORD *)pBuf = m_bAutoMix;
		break;

	case PROP_RECORD_DEVICE:
		*(DWORD *)pBuf = m_CaptureDevice;
		break;

	default:
		hr = DPR_INVALID_PROP_ID;
		break;
	}

	return hr;
}


STDMETHODIMP
SendAudioStream::SetProperty(
	DWORD prop,
	PVOID pBuf,
	UINT cbBuf
    )
{
	DWORD dw;
	HRESULT hr = S_OK;
	
	if (cbBuf < sizeof (DWORD))
		return DPR_INVALID_PARAMETER;

	switch (prop)
    {
	case PROP_SILENCE_LEVEL:
		m_AudioMonitor.SetSilenceLevel(*(DWORD *)pBuf);
		RETAILMSG(("NAC: Silence Level set to %d / 1000",*(DWORD*)pBuf));
		break;

	case PROP_DUPLEX_TYPE:
		ASSERT(0);
		break;


	case DP_PROP_DUPLEX_TYPE:
		dw = *(DWORD*)pBuf;
		if (dw)
		{
			dw = DP_FLAG_FULL_DUPLEX;
		}
		else
		{
			dw = DP_FLAG_HALF_DUPLEX;
		}

		m_InMedia->SetProp(MC_PROP_DUPLEX_TYPE, dw);
		break;

	case PROP_VOICE_SWITCH:
		// set duplex type of both input and output
		dw = *(DWORD*)pBuf;
		switch(dw)
		{
			case VOICE_SWITCH_MIC_ON:
				dw = DP_FLAG_MIC_ON;
			break;
			case VOICE_SWITCH_MIC_OFF:
				dw = DP_FLAG_MIC_OFF;
			break;
			default:
			case VOICE_SWITCH_AUTO:
				dw = DP_FLAG_AUTO_SWITCH;
			break;
		}
	
		hr = m_InMedia->SetProp(MC_PROP_VOICE_SWITCH, dw);
		RETAILMSG(("NAC: Setting voice switch to %s", (DP_FLAG_AUTO_SWITCH & dw) ? "Auto" : ((DP_FLAG_MIC_ON & dw)? "MicOn":"MicOff")));
		break;

	case PROP_SILENCE_DURATION:
		hr = m_InMedia->SetProp(MC_PROP_SILENCE_DURATION, *(DWORD*)pBuf);
		RETAILMSG(("NAC: setting silence duration to %d ms",*(DWORD*)pBuf));
		break;
// TODO: remove this property once UI calls IComChan version
	case PROP_RECORD_ON:
	{
		DWORD flag =  DPFLAG_ENABLE_SEND ;
		if (*(DWORD *)pBuf) {
			m_DPFlags |= flag; // set the flag
			Start();
		}
		else
		{
			m_DPFlags &= ~flag; // clear the flag
			Stop();
		}
		RETAILMSG(("NAC: %s", *(DWORD*)pBuf ? "Enabling":"Disabling"));
		break;
	}	

	case PROP_AUDIO_AUTOMIX:
		m_bAutoMix = *(DWORD*)pBuf;
		break;


	case PROP_RECORD_DEVICE:
		m_CaptureDevice = *(DWORD*)pBuf;
		RETAILMSG(("NAC: Setting default record device to %d", m_CaptureDevice));
		break;

	default:
		return DPR_INVALID_PROP_ID;
		break;
	}
	return hr;
}

void SendAudioStream::EndSend()
{
}








/*************************************************************************

  Function: SendAudioStream::OpenSrcFile(void)

  Purpose : Opens wav file to read audio data from.

  Returns : HRESULT.

  Params  : None

  Comments: * Registry keys:
            \\HKEY_LOCAL_MACHINE\Software\Microsoft\Internet Audio\PlayFromFile\fPlayFromFile
              If set to zero, data will not be read from wav file.
              If set to a non null value <= INT_MAX, data will be read from wav file.
            \\HKEY_LOCAL_MACHINE\Software\Microsoft\Internet Audio\PlayFromFile\szInputFileName
              Name of the wav file to read audio data from.
            \\HKEY_LOCAL_MACHINE\Software\Microsoft\Internet Audio\PlayFromFile\fLoop
              If set to zero, the file will only be read once.
              If set to a non null value <= INT_MAX, the file will be read circularly.
            \\HKEY_LOCAL_MACHINE\Software\Microsoft\Internet Audio\PlayFromFile\cchIOBuffer
              If set to zero, size of the MM IO buffer is set to its default value (8Kbytes).
              If set to one, size of the MM IO buffer is set to match maximum size of the wav file.
              If set a non null value between 2 and INT_MAX, size of the MM IO buffer is set to cchIOBuffer bytes.

  History : Date      Reason
            06/02/96  Created - PhilF

*************************************************************************/
HRESULT SendAudioStream::OpenSrcFile (void)
{
	return AudioFile::OpenSourceFile(&m_mmioSrc, &m_fDevSend);
}


/*************************************************************************

  Function: DataPump::CloseSrcFile(void)

  Purpose : Close wav file used to read audio data from.

  Returns : HRESULT.

  Params  : None

  Comments:

  History : Date      Reason
            06/02/96  Created - PhilF

*************************************************************************/
HRESULT SendAudioStream::CloseSrcFile (void)
{
	return AudioFile::CloseSourceFile(&m_mmioSrc);
}


HRESULT CALLBACK SendAudioStream::QosNotifyAudioCB(LPRESOURCEREQUESTLIST lpResourceRequestList, DWORD_PTR dwThis)
{
	HRESULT hr=NOERROR;
	LPRESOURCEREQUESTLIST prrl=lpResourceRequestList;
	int i;
#ifdef LOGSTATISTICS_ON
	int iMaxBWUsage, iMaxCPUUsage;
	char szDebug[256];
#endif
	DWORD dwCPUUsage, dwBWUsage;
	int iCPUUsageId, iBWUsageId;
	UINT dwSize = sizeof(int);
	SendMediaStream *pThis = (SendMediaStream *)dwThis;

	// Enter critical section to allow QoS thread to read the statistics while recording
	EnterCriticalSection(&(pThis->m_crsQos));

	// Record the time of this callback call
	pThis->m_Stats.dwNewestTs = timeGetTime();

	// Only do anything if we have at least captured a frame in the previous epoch
	if ((pThis->m_Stats.dwCount) && (pThis->m_Stats.dwNewestTs > pThis->m_Stats.dwOldestTs))
	{
#ifdef LOGSTATISTICS_ON
		wsprintf(szDebug, "    Epoch = %ld\r\n", pThis->m_Stats.dwNewestTs - pThis->m_Stats.dwOldestTs);
		OutputDebugString(szDebug);
#endif
		// Read the stats
		dwCPUUsage = pThis->m_Stats.dwMsComp * 1000UL / (pThis->m_Stats.dwNewestTs - pThis->m_Stats.dwOldestTs);
		dwBWUsage = pThis->m_Stats.dwBits * 1000UL / (pThis->m_Stats.dwNewestTs - pThis->m_Stats.dwOldestTs);

		// Initialize QoS structure. Only the four first fields should be zeroed.
		ZeroMemory(&(pThis->m_Stats), 4UL * sizeof(DWORD));

		// Record the time of this call for the next callback call
		pThis->m_Stats.dwOldestTs = pThis->m_Stats.dwNewestTs;
	}
	else
		dwBWUsage = dwCPUUsage = 0UL;

	// Get the latest RTCP stats and update the counters.
	// we do this here because it is called periodically.
	if (pThis->m_pRTPSend)
	{
		UINT lastPacketsLost = pThis->m_RTPStats.packetsLost;
		if (g_pctrAudioSendLost &&  SUCCEEDED(pThis->m_pRTPSend->GetSendStats(&pThis->m_RTPStats)))
			UPDATE_COUNTER(g_pctrAudioSendLost, pThis->m_RTPStats.packetsLost-lastPacketsLost);
	}
		
	// Leave critical section
	LeaveCriticalSection(&(pThis->m_crsQos));


	// Get the max for the resources.
#ifdef LOGSTATISTICS_ON
	iMaxCPUUsage = -1L; iMaxBWUsage = -1L;
#endif
	for (i=0, iCPUUsageId = -1L, iBWUsageId = -1L; i<(int)lpResourceRequestList->cRequests; i++)
		if (lpResourceRequestList->aRequests[i].resourceID == RESOURCE_OUTGOING_BANDWIDTH)
			iBWUsageId = i;
		else if (lpResourceRequestList->aRequests[i].resourceID == RESOURCE_CPU_CYCLES)
			iCPUUsageId = i;

#ifdef LOGSTATISTICS_ON
	if (iBWUsageId != -1L)
		iMaxBWUsage = lpResourceRequestList->aRequests[iBWUsageId].nUnitsMin;
	if (iCPUUsageId != -1L)
		iMaxCPUUsage = lpResourceRequestList->aRequests[iCPUUsageId].nUnitsMin;
#endif

	// Update the QoS resources (only if you need less than what's available)
	if (iCPUUsageId != -1L)
	{
		if ((int)dwCPUUsage < lpResourceRequestList->aRequests[iCPUUsageId].nUnitsMin)
			lpResourceRequestList->aRequests[iCPUUsageId].nUnitsMin = dwCPUUsage;
	}
	
	if (iBWUsageId != -1L)
	{
		if ((int)dwBWUsage < lpResourceRequestList->aRequests[iBWUsageId].nUnitsMin)
			lpResourceRequestList->aRequests[iBWUsageId].nUnitsMin = dwBWUsage;
	}

#ifdef LOGSTATISTICS_ON
	// How are we doing?
	if (iCPUUsageId != -1L)
	{
		wsprintf(szDebug, " A: Max CPU Usage: %ld, Current CPU Usage: %ld\r\n", iMaxCPUUsage, dwCPUUsage);
		OutputDebugString(szDebug);
	}
	if (iBWUsageId != -1L)
	{
		wsprintf(szDebug, " A: Max BW Usage: %ld, Current BW Usage: %ld\r\n", iMaxBWUsage, dwBWUsage);
		OutputDebugString(szDebug);
	}
#endif

	return hr;
}



HRESULT __stdcall SendAudioStream::AddDigit(int nDigit)
{
	IMediaChannel *pIMC = NULL;
	RecvMediaStream *pRecv = NULL;
	BOOL bIsStarted;

	if ((!(m_DPFlags & DPFLAG_CONFIGURED_SEND)) || (m_pRTPSend==NULL))
	{
		return DPR_NOT_CONFIGURED;
	}

	bIsStarted = (m_DPFlags & DPFLAG_STARTED_SEND);

	if (bIsStarted)
	{
		Stop();
	}

	m_pDTMF->AddDigitToQueue(nDigit);
	SendDTMF();



	m_pDP->GetMediaChannelInterface(MCF_RECV | MCF_AUDIO, &pIMC);
	if (pIMC)
	{
		pRecv = static_cast<RecvMediaStream *> (pIMC);
		pRecv->DTMFBeep();
		pIMC->Release();
	}

	if (bIsStarted)
	{
		Start();
	}

	return S_OK;
}


HRESULT __stdcall SendAudioStream::SendDTMF()
{
	HRESULT hr;
	MediaPacket **ppAudPckt, *pPacket;
	ULONG uCount;
	UINT uBufferSize, uBytesSent;
	void *pBuffer;
	bool bMark = true;
	DWORD dwSamplesPerPkt;
	MMRESULT mmr;
	DWORD dwSamplesPerSec;
	DWORD dwPacketTimeMS;
    DWORD_PTR dwPropVal;
	UINT uTimerID;
	HANDLE hEvent = m_pDTMF->GetEvent();
	
	
	m_InMedia->GetProp (MC_PROP_SPP, &dwPropVal);
    dwSamplesPerPkt = (DWORD)dwPropVal;

	m_InMedia->GetProp (MC_PROP_SPS, &dwPropVal);
    dwSamplesPerSec = (DWORD)dwPropVal;

	dwPacketTimeMS = (dwSamplesPerPkt * 1000) / dwSamplesPerSec;

	timeBeginPeriod(5);
	ResetEvent(hEvent);
	uTimerID = timeSetEvent(dwPacketTimeMS-1, 5, (LPTIMECALLBACK)hEvent, 0, TIME_CALLBACK_EVENT_SET|TIME_PERIODIC);

	// since the stream is stopped, just grab any packet
	// from the TxStream

	m_SendStream->GetRing(&ppAudPckt, &uCount);
	pPacket = ppAudPckt[0];
	pPacket->GetDevData(&pBuffer, &uBufferSize);

	hr = m_pDTMF->ReadFromQueue((BYTE*)pBuffer, uBufferSize);

	while (SUCCEEDED(hr))
	{

		// there should be only 1 tone in the queue (it can handle more)
		// so assume we only need to set the mark bit on the first packet


		pPacket->m_fMark = bMark;
		bMark = false;

		pPacket->SetProp(MP_PROP_TIMESTAMP, m_SendTimestamp);
		m_SendTimestamp += dwSamplesPerPkt;

		pPacket->SetState (MP_STATE_RECORDED);

		// compress
		mmr = m_pAudioFilter->Convert((AudioPacket*)pPacket, AP_ENCODE);
		if (mmr == MMSYSERR_NOERROR)
		{
			pPacket->SetState(MP_STATE_ENCODED);
			SendPacket((AudioPacket*)pPacket, &uBytesSent);
			pPacket->m_fMark=false;
			pPacket->SetState(MP_STATE_RESET);
		}

		hr = m_pDTMF->ReadFromQueue((BYTE*)pBuffer, uBufferSize);

		// so that we don't overload the receive jitter buffer on the remote
		// side, sleep a few milliseconds between sending packets
		if (SUCCEEDED(hr))
		{
			WaitForSingleObject(hEvent, dwPacketTimeMS);
			ResetEvent(hEvent);
		}
	}

	timeKillEvent(uTimerID);
	timeEndPeriod(5);
	return S_OK;
}


HRESULT __stdcall SendAudioStream::ResetDTMF()
{
	if(!(m_DPFlags & DPFLAG_STARTED_SEND))
	{
		return S_OK;
	}

	return m_pDTMF->ClearQueue();
}