|
|
#include "precomp.h"
#ifndef SIZEOF_VIDEOFORMATEX
#define SIZEOF_VIDEOFORMATEX(pwfx) (sizeof(VIDEOFORMATEX))
#endif
// #define LOGSTATISTICS_ON 1
// Used to translate between frame sizes and the FRAME_* bit flags
#define NON_STANDARD 0x80000000
#define SIZE_TO_FLAG(s) (s == Small ? FRAME_SQCIF : s == Medium ? FRAME_QCIF: s == Large ? FRAME_CIF : NON_STANDARD)
const int VID_AVG_PACKET_SIZE = 450; // avg from NetMon stats
// maps temporal spatial tradeoff to a target frame rate
// assume the MAX frame rate for QCIF and SQCIF is 10 on modem
// let the "best quality" be 2 frames/sec
int g_TSTable_Modem_QCIF[] ={ 200, 225, 250, 275, // best quality
300, 325, 350, 375, 400, 425, 450, 475, 500, 525, 550, 575, 600, 625, 650, 675, 700, 725, 750, 775, 800, 825, 850, 875, 900, 925, 950, 1000 // fast frames
};
// max frame rate for CIF be 2.5 frames/sec on modem
// best quality will be .6 frame/sec
int g_TSTable_Modem_CIF[] ={ 60, 66, 72, 78, 84, 90, 96, 102, 108, 114, 120, 126, 132, 140, 146, 152, 158, 164, 170, 174, 180, 186, 192, 198, 208, 216, 222, 228, 232, 238, 244, 250};
#ifdef USE_NON_LINEAR_FPS_ADJUSTMENT
// this table and related code anc be used for non-linear adjustment of our frame rate based
// on QOS information in QosNotifyVideoCB
int g_QoSMagic[19][19] ={ {-90,-90,-90,-90,-90,-90,-90,-90,-90,-90,-90,-90,-90,-90,-90,-90,-90,-90,-90}, {-90,-80,-80,-80,-80,-80,-80,-80,-80,-80,-80,-80,-80,-80,-80,-80,-80,-80,-80}, {-90,-80,-70,-70,-70,-70,-70,-70,-70,-70,-70,-70,-70,-70,-70,-70,-70,-70,-70}, {-90,-80,-70,-60,-60,-60,-60,-60,-60,-60,-60,-60,-60,-60,-60,-60,-60,-60,-60}, {-90,-80,-70,-60,-50,-50,-50,-50,-50,-50,-50,-50,-50,-50,-50,-50,-50,-50,-50}, {-90,-80,-70,-60,-50,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40,-40}, {-90,-80,-70,-60,-50,-40,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30,-30}, {-90,-80,-70,-60,-50,-40,-30,-20,-20,-20,-20,-20,-20,-20,-20,-20,-20,-20,-20}, {-90,-80,-70,-60,-50,-40,-30,-20,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10,-10}, {-90,-80,-70,-60,-50,-40,-30,-20,-10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {-90,-80,-70,-60,-50,-40,-30,-20,-10, 0, 10, 10, 10, 10, 10, 10, 10, 10, 10}, {-90,-80,-70,-60,-50,-40,-30,-20,-10, 0, 10, 20, 20, 20, 20, 20, 20, 20, 20}, {-90,-80,-70,-60,-50,-40,-30,-20,-10, 0, 10, 20, 30, 30, 30, 30, 30, 30, 30}, {-90,-80,-70,-60,-50,-40,-30,-20,-10, 0, 10, 20, 30, 40, 40, 40, 40, 40, 40}, {-90,-80,-70,-60,-50,-40,-30,-20,-10, 0, 10, 20, 30, 40, 50, 50, 50, 50, 50}, {-90,-80,-70,-60,-50,-40,-30,-20,-10, 0, 10, 20, 30, 40, 50, 60, 60, 60, 60}, {-90,-80,-70,-60,-50,-40,-30,-20,-10, 0, 10, 20, 30, 40, 50, 60, 70, 70, 70}, {-90,-80,-70,-60,-50,-40,-30,-20,-10, 0, 10, 20, 30, 40, 50, 60, 70, 80, 80}, {-90,-80,-70,-60,-50,-40,-30,-20,-10, 0, 10, 20, 30, 40, 50, 60, 70, 80, 90},};#endif
BOOL SortOrder(IAppVidCap *pavc, BASIC_VIDCAP_INFO* pvidcaps, DWORD dwcFormats, DWORD dwFlags, WORD wDesiredSortOrder, int nNumFormats);
UINT ChoosePacketSize(VIDEOFORMATEX *pvf){ // set default samples per pkt to 1
UINT spp, sblk; spp = 1; // calculate samples per block ( aka frame)
sblk = pvf->nBlockAlign* pvf->nSamplesPerSec/ pvf->nAvgBytesPerSec; if (sblk <= spp) { spp = (spp/sblk)*sblk; } else spp = sblk; return spp;}
HRESULT STDMETHODCALLTYPE SendVideoStream::QueryInterface(REFIID iid, void **ppVoid){ // resolve duplicate inheritance to the SendMediaStream;
extern IID IID_IProperty;
if (iid == IID_IUnknown) { *ppVoid = (IUnknown*)((RecvMediaStream*)this); } else if (iid == IID_IMediaChannel) { *ppVoid = (IMediaChannel*)((RecvMediaStream *)this); } else if (iid == IID_IVideoChannel) { *ppVoid = (IVideoChannel*)this; } else if (iid == IID_IProperty) { *ppVoid = NULL; ERROR_OUT(("Don't QueryInterface for IID_IProperty, use IMediaChannel")); return E_NOINTERFACE; }
else if (iid == IID_IVideoRender)// satisfy symmetric property of QI
{ *ppVoid = (IVideoRender *)this; }
else { *ppVoid = NULL; return E_NOINTERFACE; }
AddRef();
return S_OK;
}
ULONG STDMETHODCALLTYPE SendVideoStream::AddRef(void){ return InterlockedIncrement(&m_lRefCount);}
ULONG STDMETHODCALLTYPE SendVideoStream::Release(void){ LONG lRet;
lRet = InterlockedDecrement(&m_lRefCount);
if (lRet == 0) { delete this; return 0; }
else return lRet;
}
DWORD CALLBACK SendVideoStream::StartCaptureThread(LPVOID pVoid){ SendVideoStream *pThisStream = (SendVideoStream*)pVoid; return pThisStream->CapturingThread();}
HRESULTSendVideoStream::Initialize(DataPump *pDP){ HRESULT hr = DPR_OUT_OF_MEMORY; DWORD dwFlags = DP_FLAG_FULL_DUPLEX | DP_FLAG_AUTO_SWITCH ; MEDIACTRLINIT mcInit; FX_ENTRY ("DP::InitChannel") FINDCAPTUREDEVICE fcd;
m_pIUnknown = (IUnknown *)NULL;
InitializeCriticalSection(&m_crsVidQoS); InitializeCriticalSection(&m_crs); dwFlags |= DP_FLAG_VCM | DP_FLAG_VIDEO ;
m_maxfps = 2997; // max of 29.97 fps
m_frametime = 1000 / 30; // default of 30 fps (time in ms) QOS will slow us, if
// need be
// Modem connections will use a frame rate control table
// to implement TS-Tradeoff
m_pTSTable = NULL; m_dwCurrentTSSetting = VCM_DEFAULT_IMAGE_QUALITY;
// 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_pRTPSend = NULL; // m_PrevFormatId = INVALID_MEDIA_FORMAT;
ZeroMemory(&m_fCodecOutput, sizeof(VIDEOFORMATEX));
// Initialize data (should be in constructor)
m_CaptureDevice = (UINT) -1; // use VIDEO_MAPPER
m_PreviousCaptureDevice = (UINT) -1;
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 video filters
DBG_SAVE_FILE_LINE m_pVideoFilter = new VcmFilter(); m_dwDstSize = 0; if (m_pVideoFilter==NULL) { DEBUGMSG (ZONE_DP, ("%s: VcmFilter new failed\r\n", _fx_)); goto FilterAllocError; }
//Create Video MultiMedia device control objects
DBG_SAVE_FILE_LINE m_InMedia = new VideoInControl(); 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; }
// determine if the video devices are available
fcd.dwSize = sizeof (FINDCAPTUREDEVICE); if (FindFirstCaptureDevice(&fcd, NULL)) { DEBUGMSG (ZONE_DP, ("%s: OMedia->have capture cap\r\n", _fx_)); 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;
return DPR_SUCCESS;
MediaAllocError: if (m_InMedia) delete m_InMedia;FilterAllocError: if (m_pVideoFilter) delete m_pVideoFilter;StreamAllocError: if (m_SendStream) delete m_SendStream;
ERRORMESSAGE( ("SendVideoStream::Initialize: exit, hr=0x%lX\r\n", hr));
return hr;}
// LOOK: identical to SendAudioStream version.
SendVideoStream::~SendVideoStream(){
if (m_DPFlags & DPFLAG_INITIALIZED) { m_DPFlags &= ~DPFLAG_INITIALIZED;
// TEMP:Make sure preview stops
m_DPFlags &= ~DPFLAG_ENABLE_PREVIEW; if (m_DPFlags & DPFLAG_CONFIGURED_SEND ) { UnConfigure(); }
if (m_pRTPSend) { m_pRTPSend->Release(); m_pRTPSend = NULL; }
// Close the receive and transmit streams
if (m_SendStream) delete m_SendStream;
// Close the wave devices
if (m_InMedia) { delete m_InMedia;} // Close the filters
if (m_pVideoFilter) { delete m_pVideoFilter; } m_pDP->RemoveMediaChannel(MCF_SEND| MCF_VIDEO, (IMediaChannel*)(RecvMediaStream *)this);
} DeleteCriticalSection(&m_crs); DeleteCriticalSection(&m_crsVidQoS);}
HRESULT STDMETHODCALLTYPE SendVideoStream::Configure( BYTE *pFormat, UINT cbFormat, BYTE *pChannelParams, UINT cbParams, IUnknown *pUnknown){ HRESULT hr; BOOL fRet; MEDIAPACKETINIT pcktInit; MEDIACTRLCONFIG mcConfig; MediaPacket **ppPckt; ULONG cPckt, uIndex; DWORD_PTR dwPropVal; VIDEOFORMATEX *pfSend = (VIDEOFORMATEX*)pFormat; DWORD maxBitRate=0; DWORD i, dwSrcSize, dwMaxFragSize=0; int iXOffset, iYOffset; VIDEO_CHANNEL_PARAMETERS vidChannelParams; struct { int cResources; RESOURCE aResources[1]; } m_aLocalRs; vidChannelParams.RTP_Payload = 0; int optval = 0 ; CCaptureChain *pChain; HCAPDEV hCapDev=NULL; LPBITMAPINFOHEADER lpcap, lpsend; BOOL fNewDeviceSettings = TRUE; BOOL fNewDevice = TRUE; BOOL fLive = FALSE, fReconfiguring; MMRESULT mmr; DWORD dwStreamingMode = STREAMING_PREFER_FRAME_GRAB;
FX_ENTRY ("SendVideoStream::Configure")
if (pfSend) { // for now, don't allow SendVideoStream to be re-configured
// if we are already streaming.
if (m_DPFlags & DPFLAG_STARTED_SEND) { return DPR_IO_PENDING; } } else { ASSERT(!pChannelParams); }
if(NULL != pChannelParams) { // get channel parameters
if (cbParams != sizeof(vidChannelParams)) { hr = DPR_INVALID_PARAMETER; goto IMediaInitError; }
vidChannelParams = *(VIDEO_CHANNEL_PARAMETERS *)pChannelParams; fLive = TRUE; } else { //
// else this is configuring for preview or is unconfiguring. There are
// no channel parameters
//
} if (m_DPFlags & DPFLAG_CONFIGURED_SEND) { if (pfSend) { if (m_CaptureDevice == m_PreviousCaptureDevice) fNewDevice = FALSE; if (IsSimilarVidFormat(&m_fCodecOutput, pfSend)) fNewDeviceSettings = FALSE; }
// When using a different capture device, we systematically configure everyting
// although it would probably be possible to optimize the configuration
// of the filters and transmit stream
EndSend(); UnConfigureSendVideo(fNewDeviceSettings, fNewDevice); }
if (!pfSend) { return DPR_SUCCESS; }
if (fLive) m_DPFlags |= DPFLAG_REAL_THING;
// m_Net = pNet;
if (! (m_DPFlags & DPFLAG_INITIALIZED)) return DPR_OUT_OF_MEMORY; //BUGBUG: return proper error;
if (fNewDeviceSettings || fNewDevice) { m_ThreadFlags |= DPTFLAG_PAUSE_CAPTURE;
mcConfig.uDuration = MC_USING_DEFAULT; // set duration by samples per pkt
// force an unknown device to be profiled by fetching
// it's streaming capabilites BEFORE opening it
mmr = vcmGetDevCapsStreamingMode(m_CaptureDevice, &dwStreamingMode); if (mmr != MMSYSERR_NOERROR) { dwStreamingMode = STREAMING_PREFER_FRAME_GRAB; }
m_InMedia->GetProp (MC_PROP_MEDIA_DEV_HANDLE, &dwPropVal);
if (!dwPropVal) { // if capture device isn't already open, then open it
m_InMedia->SetProp(MC_PROP_MEDIA_DEV_ID, (DWORD)m_CaptureDevice); if (fNewDevice) { hr = m_InMedia->Open(); if (hr != DPR_SUCCESS) { DEBUGMSG (ZONE_DP, ("%s: m_InMedia->Open failed to open capture, hr=0x%lX\r\n", _fx_, hr)); goto IMediaInitError; } } m_InMedia->GetProp (MC_PROP_MEDIA_DEV_HANDLE, &dwPropVal); if (!dwPropVal) { DEBUGMSG (ZONE_DP, ("%s: capture device not open (0x%lX)\r\n", _fx_)); goto IMediaInitError; } } hCapDev = (HCAPDEV)dwPropVal;
if (m_pCaptureChain) { delete m_pCaptureChain; m_pCaptureChain = NULL; }
i = 0; // assume no colortable
// m_fDevSend is the uncompressed format
// pfSend is the compressed format
mmr = VcmFilter::SuggestEncodeFormat(m_CaptureDevice, &m_fDevSend, pfSend);
if (mmr == MMSYSERR_NOERROR) { i = m_fDevSend.bih.biClrUsed; // non-zero, if vcmstrm gave us a colortable
SetCaptureDeviceFormat(hCapDev, &m_fDevSend.bih, 0, 0); }
dwPropVal = GetCaptureDeviceFormatHeaderSize(hCapDev); while (1) { if (lpcap = (LPBITMAPINFOHEADER)MemAlloc((UINT)dwPropVal)) { lpcap->biSize = (DWORD)dwPropVal; if (!GetCaptureDeviceFormat(hCapDev, lpcap)) { MemFree(lpcap); DEBUGMSG (ZONE_DP, ("%s: failed to set/get capture format\r\n", _fx_)); goto IMediaInitError; } UPDATE_REPORT_ENTRY(g_prptSystemSettings, (lpcap->biWidth << 22) | (lpcap->biHeight << 12) | ((lpcap->biCompression == VIDEO_FORMAT_UYVY) ? VIDEO_FORMAT_NUM_COLORS_UYVY : (lpcap->biCompression == VIDEO_FORMAT_YUY2) ? VIDEO_FORMAT_NUM_COLORS_YUY2 : (lpcap->biCompression == VIDEO_FORMAT_IYUV) ? VIDEO_FORMAT_NUM_COLORS_IYUV : (lpcap->biCompression == VIDEO_FORMAT_I420) ? VIDEO_FORMAT_NUM_COLORS_I420 : (lpcap->biCompression == VIDEO_FORMAT_YVU9) ? VIDEO_FORMAT_NUM_COLORS_YVU9 : (lpcap->biCompression == 0) ? ((lpcap->biBitCount == 24) ? VIDEO_FORMAT_NUM_COLORS_16777216 : (lpcap->biBitCount == 16) ? VIDEO_FORMAT_NUM_COLORS_65536 : (lpcap->biBitCount == 8) ? VIDEO_FORMAT_NUM_COLORS_256 : (lpcap->biBitCount == 4) ? VIDEO_FORMAT_NUM_COLORS_16 : 0x00000800) : 0x00000800), REP_DEVICE_IMAGE_SIZE); if (lpcap->biBitCount > 8) break; else if (dwPropVal > 256 * sizeof(RGBQUAD)) { if (i) { // vcmstrm gave us a colortable in m_fDevSend, so use it
CopyMemory(((BYTE*)lpcap) + lpcap->biSize, (BYTE*)&m_fDevSend.bih + m_fDevSend.bih.biSize, 256 * sizeof(RGBQUAD)); } else { CAPTUREPALETTE pal; LPRGBQUAD lprgb;
GetCaptureDevicePalette(hCapDev, &pal); lprgb = (LPRGBQUAD)(((BYTE*)lpcap) + lpcap->biSize); for (i = 0; i < 256; i++) { lprgb->rgbRed = pal.pe[i].peRed; lprgb->rgbGreen = pal.pe[i].peGreen; lprgb->rgbBlue = pal.pe[i].peBlue; lprgb++; } } break; }
dwPropVal += 256 * sizeof(RGBQUAD); MemFree(lpcap); // free this lpcap, and alloc a new with room for palette
} else { DEBUGMSG (ZONE_DP, ("%s: failed to set/get capture format\r\n", _fx_)); goto IMediaInitError; } }
DBG_SAVE_FILE_LINE if (pChain = new CCaptureChain) { VIDEOFORMATEX *capfmt;
// if pfSend is 128x96, but capture is greater, then InitCaptureChain with a larger size so
// that the codec will just crop to 128x96
iXOffset = pfSend->bih.biWidth; iYOffset = pfSend->bih.biHeight; if ((iXOffset == 128) && (iYOffset == 96)) { if (lpcap->biWidth == 160) { iXOffset = lpcap->biWidth; iYOffset = lpcap->biHeight; } else if (lpcap->biWidth == 320) { iXOffset = lpcap->biWidth / 2; iYOffset = lpcap->biHeight / 2; } } if ((hr = pChain->InitCaptureChain(hCapDev, (dwStreamingMode==STREAMING_PREFER_STREAMING), lpcap, iXOffset, iYOffset, 0, &lpsend)) != NO_ERROR) { DEBUGMSG (ZONE_DP, ("%s: failed to init capture chain\r\n", _fx_)); MemFree(lpcap); delete pChain; goto IMediaInitError; } } else { DEBUGMSG (ZONE_DP, ("%s: failed allocate capture chain\r\n", _fx_)); MemFree((HANDLE)lpcap); hr = DPR_OUT_OF_MEMORY; goto IMediaInitError; } MemFree((HANDLE)lpcap);
m_pCaptureChain = pChain;
// build m_fDevSend format as format that will be input to codec
CopyMemory(&m_fDevSend, pfSend, sizeof(VIDEOFORMATEX)-sizeof(BITMAPINFOHEADER)-BMIH_SLOP_BYTES);
// m_fDevSend.bih is the output format of the CaptureChain
CopyMemory(&m_fDevSend.bih, lpsend, lpsend->biSize); //LOOKLOOK RP - need to get colortable too?
m_fDevSend.dwFormatSize = sizeof(VIDEOFORMATEX); m_fDevSend.dwFormatTag = lpsend->biCompression; m_fDevSend.nAvgBytesPerSec = m_fDevSend.nMinBytesPerSec = m_fDevSend.nMaxBytesPerSec = m_fDevSend.nSamplesPerSec * lpsend->biSizeImage; m_fDevSend.nBlockAlign = lpsend->biSizeImage; m_fDevSend.wBitsPerSample = lpsend->biBitCount; LocalFree((HANDLE)lpsend);
mcConfig.pDevFmt = &m_fDevSend; UPDATE_REPORT_ENTRY(g_prptCallParameters, pfSend->dwFormatTag, REP_SEND_VIDEO_FORMAT); RETAILMSG(("NAC: Video Send Format: %.4s", (LPSTR)&pfSend->dwFormatTag));
// Initialize the send-stream media control object
mcConfig.hStrm = (DPHANDLE) m_SendStream; m_InMedia->GetProp(MC_PROP_MEDIA_DEV_ID, &dwPropVal); mcConfig.uDevId = (DWORD)dwPropVal;
mcConfig.cbSamplesPerPkt = ChoosePacketSize(pfSend);
hr = m_InMedia->Configure(&mcConfig); if (hr != DPR_SUCCESS) { DEBUGMSG (ZONE_DP, ("%s: IVMedia->Config failed, hr=0x%lX\r\n", _fx_, hr)); goto IMediaInitError; }
// initialize m_cliprect
iXOffset = 0; iYOffset = 0; if (m_fDevSend.bih.biWidth > pfSend->bih.biWidth) iXOffset = (m_fDevSend.bih.biWidth - pfSend->bih.biWidth) >> 1; if (m_fDevSend.bih.biHeight > pfSend->bih.biHeight) iYOffset = (m_fDevSend.bih.biHeight - pfSend->bih.biHeight) >> 1; SetRect(&m_cliprect, iXOffset, iYOffset, pfSend->bih.biWidth + iXOffset, pfSend->bih.biHeight + iYOffset);
dwMaxFragSize = 512; // default video packet size
CopyMemory (&m_fCodecOutput, pfSend, sizeof(VIDEOFORMATEX)); m_InMedia->GetProp (MC_PROP_SIZE, &dwPropVal); dwSrcSize = (DWORD)dwPropVal;
mmr = m_pVideoFilter->Open(&m_fDevSend, &m_fCodecOutput, dwMaxFragSize);
if (mmr != MMSYSERR_NOERROR) { DEBUGMSG (ZONE_DP, ("%s: VcmFilter->Open failed, mmr=%d\r\n", _fx_, mmr)); hr = DPR_CANT_OPEN_CODEC; goto SendFilterInitError; }
// Initialize the send queue
ZeroMemory (&pcktInit, sizeof (pcktInit));
pcktInit.dwFlags = DP_FLAG_SEND | DP_FLAG_VCM | DP_FLAG_VIDEO; pcktInit.pStrmConvSrcFmt = &m_fDevSend; pcktInit.pStrmConvDstFmt = &m_fCodecOutput; pcktInit.cbSizeRawData = dwSrcSize; pcktInit.cbOffsetRawData = 0;
m_InMedia->FillMediaPacketInit (&pcktInit); m_InMedia->GetProp (MC_PROP_SIZE, &dwPropVal);
m_pVideoFilter->SuggestDstSize(dwSrcSize, &m_dwDstSize); pcktInit.cbSizeNetData = m_dwDstSize; m_pVideoFilter->GetProperty(FM_PROP_PAYLOAD_HEADER_SIZE, &pcktInit.cbPayloadHeaderSize);
pcktInit.cbOffsetNetData = sizeof (RTP_HDR); pcktInit.payload = vidChannelParams.RTP_Payload;
fRet = m_SendStream->Initialize (DP_FLAG_VIDEO, MAX_TXVRING_SIZE, m_pDP, &pcktInit); if (!fRet) { DEBUGMSG (ZONE_DP, ("%s: TxvStream->Init failed, fRet=0%u\r\n", _fx_, fRet)); hr = DPR_CANT_INIT_TXV_STREAM; goto TxStreamInitError; }
// Prepare headers for TxvStream
m_SendStream->GetRing (&ppPckt, &cPckt); m_InMedia->RegisterData (ppPckt, cPckt); m_InMedia->PrepareHeaders (); } else { // The following fields may change with the capabilities of the other end point
dwMaxFragSize = 512; // default video packet size
if (pChannelParams) { m_pVideoFilter->GetProperty(FM_PROP_PAYLOAD_HEADER_SIZE, &pcktInit.cbPayloadHeaderSize);
pcktInit.cbOffsetNetData = sizeof (RTP_HDR); } } if(pChannelParams) { // Update the bitrate
maxBitRate = vidChannelParams.ns_params.maxBitRate*100; if (maxBitRate < BW_144KBS_BITS) maxBitRate = BW_144KBS_BITS;
// set the max. fragment size
DEBUGMSG(ZONE_DP,("%s: Video Send: maxBitRate=%d, maxBPP=%d, MPI=%d\r\n", _fx_,maxBitRate, vidChannelParams.ns_params.maxBPP*1024, vidChannelParams.ns_params.MPI*33));
// Initialize the max frame rate with the negociated max
if ((vidChannelParams.ns_params.MPI > 0UL) && (vidChannelParams.ns_params.MPI < 33UL)) { dwPropVal = 2997UL / vidChannelParams.ns_params.MPI; m_maxfps = (DWORD)dwPropVal; INIT_COUNTER_MAX(g_pctrVideoSend, (m_maxfps + 50) / 100); UPDATE_REPORT_ENTRY(g_prptCallParameters, (m_maxfps + 50) / 100, REP_SEND_VIDEO_MAXFPS); RETAILMSG(("NAC: Video Send Max Frame Rate (negotiated - fps): %ld", (m_maxfps + 50) / 100)); DEBUGMSG(1,("%s: Video Send: Negociated max fps = %d.%d\r\n", _fx_, m_maxfps/100, m_maxfps - m_maxfps / 100 * 100)); }
UPDATE_REPORT_ENTRY(g_prptCallParameters, maxBitRate, REP_SEND_VIDEO_BITRATE); RETAILMSG(("NAC: Video Send Max Bitrate (negotiated - bps): %ld", maxBitRate)); INIT_COUNTER_MAX(g_pctrVideoSendBytes, maxBitRate * 75 / 100);
// At this point we actually know what is the minimum bitrate chosen
// by the sender and the receiver. Let's reset the resources reserved
// by the QoS with those more meaningfull values.
if (m_pDP->m_pIQoS) { // Fill in the resource list
m_aLocalRs.cResources = 1; m_aLocalRs.aResources[0].resourceID = RESOURCE_OUTGOING_BANDWIDTH;
// Do a sanity check on the minimal bit rate
m_aLocalRs.aResources[0].nUnits = maxBitRate; m_aLocalRs.aResources[0].ulResourceFlags = m_aLocalRs.aResources[0].reserved = 0;
DEBUGMSG(1,("%s: Video Send: Negociated max bps = %d\r\n", _fx_, maxBitRate));
// Set the resources on the QoS object
hr = m_pDP->m_pIQoS->SetResources((LPRESOURCELIST)&m_aLocalRs); }
// if we're sending on the LAN, fragment video frames into Ethernet packet sized chunks
// On slower links use smaller packets for better bandwidth sharing
// NOTE: codec packetizer can occasionally exceed the fragment size limit
if (maxBitRate > BW_ISDN_BITS) dwMaxFragSize = 1350;
m_pVideoFilter->SetProperty(FM_PROP_VIDEO_MAX_PACKET_SIZE, dwMaxFragSize);
// To correctly initialize the flow spec structure we need to get the values that
// our QoS module will be effectively using. Typically, we only use 70% of the max
// advertized. On top of that, some system administrator may have significantly
// reduced the maximum bitrate on this machine.
if (m_pDP->m_pIQoS) { LPRESOURCELIST pResourceList = NULL;
// Get a list of all resources from QoS
hr = m_pDP->m_pIQoS->GetResources(&pResourceList); if (SUCCEEDED(hr) && pResourceList) { // Find the BW resource
for (i=0; i < pResourceList->cResources; i++) { if (pResourceList->aResources[i].resourceID == RESOURCE_OUTGOING_BANDWIDTH) { maxBitRate = min(maxBitRate, (DWORD)pResourceList->aResources[i].nUnits); break; } }
// Release memory
m_pDP->m_pIQoS->FreeBuffer(pResourceList); } }
// WS2Qos will be called in Start to communicate stream information to the
// remote endpoint using a PATH 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
ASSERT(maxBitRate > 0);
InitVideoFlowspec(&m_flowspec, maxBitRate, dwMaxFragSize, VID_AVG_PACKET_SIZE);
// Update RTCP send address and payload type. It should be known now
// We have to explicitly set the payload again because the preview
// channel configuration has already set it to zero.
m_RTPPayload = vidChannelParams.RTP_Payload; m_SendStream->GetRing (&ppPckt, &cPckt); for (uIndex = 0; uIndex < cPckt; uIndex++) { ppPckt[uIndex]->SetPayload(m_RTPPayload); }
// Keep a weak reference to the IUnknown interface
// We will use it to query a Stream Signal interface pointer in Start()
m_pIUnknown = pUnknown; }
if (m_DPFlags & DPFLAG_REAL_THING) { 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; m_aRRq.aResourceRequest[0].nUnitsMin = 0; m_aRRq.aResourceRequest[1].resourceID = RESOURCE_CPU_CYCLES; m_aRRq.aResourceRequest[1].nUnitsMin = 0;
// Initialize QoS structure
ZeroMemory(&m_Stats, sizeof(m_Stats));
// Start collecting CPU performance data from the registry
StartCPUUsageCollection();
// Register with the QoS module. This call should NEVER fail. If it does, we'll do without the QoS
m_pDP->m_pIQoS->RequestResources((GUID *)&MEDIA_TYPE_H323VIDEO, (LPRESOURCEREQUESTLIST)&m_aRRq, QosNotifyVideoCB, (DWORD_PTR)this); } }
// reset the temporal spatial tradeoff to best quality
// it's expected that the UI will re-specify the TS setting
// sometime after the stream is started
m_pVideoFilter->SetProperty(FM_PROP_VIDEO_RESET_IMAGE_QUALITY ,VCM_RESET_IMAGE_QUALITY); m_pTSTable = NULL; m_dwCurrentTSSetting = VCM_MAX_IMAGE_QUALITY;
//Before we start, reset the frame frame rate to the channel max.
//If the previous call had been slower than possible, resume
//previewing at the desired FPS.
if (pChannelParams && (m_DPFlags & DPFLAG_REAL_THING)) { int iSlowStartFrameRate;
// us a frame-rate table for temporal spatial tradeoff settings
// if the bandwidth is a modem setting
if (maxBitRate <= BW_288KBS_BITS) { if (pfSend->bih.biWidth >= CIF_WIDTH) { m_pTSTable = g_TSTable_Modem_CIF; } else { m_pTSTable = g_TSTable_Modem_QCIF; } }
// Let's do a slow start and then catch up with the negociated max
if (m_pTSTable == NULL) { iSlowStartFrameRate = m_maxfps >> 1; } else { iSlowStartFrameRate = m_pTSTable[VCM_MAX_IMAGE_QUALITY]; }
SetProperty(PROP_VIDEO_FRAME_RATE, &iSlowStartFrameRate, sizeof(int));
// Initialize the codec with the new target bitrates and frame rates
// PhilF-: This assumes that we start with a silent audio channel...
SetTargetRates(iSlowStartFrameRate, maxBitRate);
} else { INIT_COUNTER_MAX(g_pctrVideoSend, 30); SetProperty(PROP_VIDEO_FRAME_RATE, &m_maxfps, sizeof(int)); }
m_ThreadFlags &= ~DPTFLAG_PAUSE_CAPTURE; m_DPFlags |= DPFLAG_CONFIGURED_SEND; m_PreviousCaptureDevice = m_CaptureDevice;// m_PrevFormatId = SendVidFmt;
return DPR_SUCCESS;
TxStreamInitError: m_pVideoFilter->Close();SendFilterInitError:IMediaInitError: if (m_pCaptureChain) { delete m_pCaptureChain; m_pCaptureChain = NULL; } // We need to close the video controller object on failure to open the capture device,
// otherwise we get a pure virtual function call on NM shutdown!
if (m_InMedia) m_InMedia->Close(); ERRORMESSAGE(("%s: failed, hr=0%u\r\n", _fx_, hr)); return hr;}
void SendVideoStream::UnConfigure(){ // By default, unconfigure all resources
UnConfigureSendVideo(TRUE, TRUE);}
void SendVideoStream::UnConfigureSendVideo(BOOL fNewDeviceSettings, BOOL fNewDevice){
#ifdef TEST
DWORD dwTicks;
dwTicks = GetTickCount();#endif
if (m_DPFlags & DPFLAG_CONFIGURED_SEND) { if (m_hCapturingThread) Stop();
if (fNewDeviceSettings || fNewDevice) {// m_PrevFormatId = INVALID_MEDIA_FORMAT;
ZeroMemory(&m_fCodecOutput, sizeof(VIDEOFORMATEX));
m_Net = NULL;
if (m_pCaptureChain) { delete m_pCaptureChain; m_pCaptureChain = NULL; }
// Close the devices
m_InMedia->Reset(); m_InMedia->UnprepareHeaders(); if (fNewDevice) { m_PreviousCaptureDevice = -1L; // VIDEO_MAPPER
m_InMedia->Close(); }
// Close the filters
m_pVideoFilter->Close();
// Close the transmit streams
m_SendStream->Destroy(); }
m_DPFlags &= ~DPFLAG_CONFIGURED_SEND;
// 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) { if (m_DPFlags & DPFLAG_REAL_THING) { m_pDP->m_pIQoS->ReleaseResources((GUID *)&MEDIA_TYPE_H323VIDEO, (LPRESOURCEREQUESTLIST)&m_aRRq);
// Terminate CPU usage data collection
StopCPUUsageCollection();
} m_DPFlags &= ~DPFLAG_REAL_THING; } }
#ifdef TEST
LOG((LOGMSG_TIME_SEND_VIDEO_UNCONFIGURE,GetTickCount() - dwTicks));#endif
}
HRESULTSendVideoStream::Start(){ int nRet= IFRAMES_CAPS_UNKNOWN;
FX_ENTRY ("SendVideoStream::Start")
if (m_DPFlags & DPFLAG_STARTED_SEND) return DPR_SUCCESS; if (!(m_DPFlags & DPFLAG_CONFIGURED_SEND)) return DPR_NOT_CONFIGURED;
// to fix: if we optimize SetNetworkInterface to allow
// us to transition from preview->sending without having
// to call stop/start, we need to make sure the flowspec/QOS
// stuff get's called there.
SetFlowSpec(); ASSERT(!m_hCapturingThread); m_ThreadFlags &= ~(DPTFLAG_STOP_RECORD|DPTFLAG_STOP_SEND); // Start recording thread
if (!(m_ThreadFlags & DPTFLAG_STOP_RECORD)) m_hCapturingThread = CreateThread(NULL,0, SendVideoStream::StartCaptureThread,this,0,&m_CaptureThId);
// ------------------------------------------------------------------------
// Decide whether or not we need to send periodic I-Frames during this call
// Who are we talking to?
if ((m_pIUnknown) && (m_DPFlags & DPFLAG_REAL_THING)) { HRESULT hr; IStreamSignal *pIStreamSignal=NULL;
hr = m_pIUnknown->QueryInterface(IID_IStreamSignal, (void **)&pIStreamSignal); if (HR_SUCCEEDED(hr)) { nRet = GetIFrameCaps(pIStreamSignal); pIStreamSignal->Release(); } }
// only disable sending of I Frames if and only if we know the remote party
// can handle it. In this case, NetMeeting 3.0 or TAPI 3.1
if (nRet == IFRAMES_CAPS_NM3) { m_pVideoFilter->SetProperty(FM_PROP_PERIODIC_IFRAMES, FALSE); } else { m_pVideoFilter->SetProperty(FM_PROP_PERIODIC_IFRAMES, TRUE); }// ------------------------------------------------------------------------
m_DPFlags |= DPFLAG_STARTED_SEND;
DEBUGMSG (ZONE_DP, ("%s: Record threadid=%x,\r\n", _fx_, m_CaptureThId)); return DPR_SUCCESS;}
// LOOK: identical to SendAudioStream version.
HRESULTSendVideoStream::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(); m_SendStream->Reset(); } /*
* 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: dwWait =%d\r\n", dwWait)); ASSERT(dwWait != WAIT_FAILED);
CloseHandle(m_hCapturingThread); m_hCapturingThread = NULL; }
m_DPFlags &= ~DPFLAG_STARTED_SEND; return DPR_SUCCESS;}
HRESULT STDMETHODCALLTYPE SendVideoStream::SetMaxBitrate(UINT uMaxBitrate){ DWORD dwFrameRate=0; UINT uSize=sizeof(DWORD); BOOL bRet; HRESULT hr;
hr = GetProperty(PROP_VIDEO_FRAME_RATE, &dwFrameRate, &uSize);
if (SUCCEEDED(hr)) { bRet = SetTargetRates(dwFrameRate, (DWORD)uMaxBitrate); if (bRet) hr = S_OK; else hr = E_FAIL; }
return hr;}
// IProperty::GetProperty / SetProperty
// (DataPump::MediaChannel::GetProperty)
// Properties of the MediaStream.
STDMETHODIMPSendVideoStream::GetProperty( DWORD prop, PVOID pBuf, LPUINT pcbBuf ){ HRESULT hr = DPR_SUCCESS; DWORD dwValue; DWORD_PTR dwPropVal; UINT len = sizeof(DWORD); // most props are DWORDs
if (!pBuf || *pcbBuf < len) { *pcbBuf = len; return DPR_INVALID_PARAMETER; }
switch (prop) {#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_RECORD_ON: *(DWORD *)pBuf = ((m_DPFlags & DPFLAG_ENABLE_SEND) !=0); break; case PROP_CAPTURE_DEVICE: *(UINT *)pBuf = m_CaptureDevice; break;
case PROP_VIDEO_FRAME_RATE: *((DWORD *)pBuf) = 100000 / m_frametime; break;
case PROP_VIDEO_IMAGE_QUALITY: hr = GetTemporalSpatialTradeOff((DWORD *)pBuf); break;
case PROP_VIDEO_CAPTURE_AVAILABLE: *(DWORD *)pBuf = (m_DPFlags & DP_FLAG_RECORD_CAP) != 0; break;
case PROP_VIDEO_CAPTURE_DIALOGS_AVAILABLE: hr = m_InMedia->GetProp(MC_PROP_VFW_DIALOGS, &dwPropVal); *(DWORD *)pBuf = (DWORD)dwPropVal; break;
case PROP_VIDEO_PREVIEW_ON: *(DWORD *)pBuf = ((m_DPFlags & DPFLAG_ENABLE_PREVIEW) != 0); break;
case PROP_PAUSE_SEND: *(DWORD *)pBuf = ((m_ThreadFlags & DPTFLAG_PAUSE_SEND) != 0); break; default: hr = DPR_INVALID_PROP_ID; break; } return hr;}
STDMETHODIMPSendVideoStream::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_CAPTURE_DEVICE: if (m_DPFlags & DPFLAG_ENABLE_PREVIEW) { return DPR_INVALID_PARAMETER; } else { m_CaptureDevice = *(UINT*)pBuf; m_InMedia->SetProp(MC_PROP_MEDIA_DEV_ID, (DWORD)m_CaptureDevice); }
break;
case PROP_VIDEO_FRAME_RATE: if (*(DWORD*)pBuf <= m_maxfps) { DEBUGMSG(ZONE_VERBOSE, ("DP: setting fps = %d \n", *(DWORD*)pBuf)); // set frame rate here
m_frametime = 100000 / *(DWORD*)pBuf; } break;
case PROP_VIDEO_IMAGE_QUALITY: hr = SetTemporalSpatialTradeOff(*(DWORD*)pBuf); break;
case PROP_VIDEO_RESET_IMAGE_QUALITY: hr = m_pVideoFilter->SetProperty(FM_PROP_VIDEO_IMAGE_QUALITY, VCM_DEFAULT_IMAGE_QUALITY); break;
case PROP_VIDEO_CAPTURE_DIALOG: hr = ((VideoInControl *)m_InMedia)->DisplayDriverDialog(GetActiveWindow(), *(DWORD *)pBuf); break;
case PROP_VIDEO_SIZE: ASSERT(0); break;
case PROP_VIDEO_PREVIEW_ON: ASSERT(0); break; case PROP_VIDEO_AUDIO_SYNC: if (*(DWORD *)pBuf) m_DPFlags |= DPFLAG_AV_SYNC; else m_DPFlags &= ~DPFLAG_AV_SYNC; break;
case PROP_PAUSE_SEND: if (*(DWORD *)pBuf) m_ThreadFlags |= DPTFLAG_PAUSE_SEND; else m_ThreadFlags &= ~DPTFLAG_PAUSE_SEND; break; default: return DPR_INVALID_PROP_ID; break; } return hr;}
//---------------------------------------------------------------------
// IVideoRender implementation and support functions
// IVideoRender::Init
// (DataPump::Init)
STDMETHODIMPSendVideoStream::Init( DWORD_PTR dwUser, LPFNFRAMEREADY pfCallback ){ // Save the event away. Note that we DO allow both send and receive to
// share an event
m_hRenderEvent = (HANDLE) dwUser; // if pfCallback is NULL then dwUser is an event handle
m_pfFrameReadyCallback = pfCallback; return DPR_SUCCESS;}
// IVideoRender::Done
// (DataPump::Done)
STDMETHODIMPSendVideoStream::Done( ){ m_hRenderEvent = NULL; m_pfFrameReadyCallback = NULL; return DPR_SUCCESS;}
// IVideoRender::GetFrame
// (DataPump::GetFrame)
STDMETHODIMPSendVideoStream::GetFrame( FRAMECONTEXT* pfc ){ HRESULT hr; PVOID pData = NULL; UINT cbData = 0;
// Validate parameters
if (!pfc ) return DPR_INVALID_PARAMETER;
// Don't arbitrarily call out while holding this crs or you may deadlock...
EnterCriticalSection(&m_crs);
if ((m_DPFlags & DPFLAG_CONFIGURED_SEND) && m_pNextPacketToRender && !m_pNextPacketToRender->m_fRendering) { m_pNextPacketToRender->m_fRendering = TRUE; m_pNextPacketToRender->GetDevData(&pData,&cbData); pfc->lpData = (PUCHAR) pData; pfc->dwReserved = (DWORD_PTR) m_pNextPacketToRender; // set bmi length?
pfc->lpbmi = (PBITMAPINFO)&m_fDevSend.bih; pfc->lpClipRect = &m_cliprect; m_cRendering++; hr = S_OK; LOG((LOGMSG_GET_SEND_FRAME,m_pNextPacketToRender->GetIndex())); } else hr = S_FALSE; // nothing ready to render
LeaveCriticalSection(&m_crs);
return hr; }
// IVideoRender::ReleaseFrame
// (DataPump::ReleaseFrame)
STDMETHODIMPSendVideoStream::ReleaseFrame( FRAMECONTEXT* pfc ){ HRESULT hr; MediaPacket *pPacket;
// Validate parameters
if (!pfc) return DPR_INVALID_PARAMETER;
// Handle a send frame
{ EnterCriticalSection(&m_crs);
// Don't arbitrarily call out while holding this crs or you may deadlock...
if ((m_DPFlags & DPFLAG_CONFIGURED_SEND) && (pPacket = (MediaPacket *)pfc->dwReserved) && pPacket->m_fRendering) { LOG((LOGMSG_RELEASE_SEND_FRAME,pPacket->GetIndex())); pPacket->m_fRendering = FALSE; pfc->dwReserved = 0; // if its not the current frame
if (m_pNextPacketToRender != pPacket) { pPacket->Recycle(); m_SendStream->Release(pPacket); } m_cRendering--; hr = S_OK; } else hr = DPR_INVALID_PARAMETER;
LeaveCriticalSection(&m_crs); } return hr;}
HRESULT __stdcall SendVideoStream::SendKeyFrame(void){ MMRESULT mmr; HVCMSTREAM hvs;
ASSERT(m_pVideoFilter);
if ((mmr = m_pVideoFilter->RequestIFrame()) != MMSYSERR_NOERROR) { return S_FALSE; } return S_OK;
}
// IVideoChannel
HRESULT __stdcall SendVideoStream::SetTemporalSpatialTradeOff(DWORD dwVal){ HRESULT hr=DPR_NOT_CONFIGURED;
ASSERT(m_pVideoFilter);
if (m_pVideoFilter) { if (m_pTSTable == NULL) { hr = m_pVideoFilter->SetProperty(FM_PROP_VIDEO_IMAGE_QUALITY, dwVal); } m_dwCurrentTSSetting = dwVal; return S_OK; }
return hr;}
HRESULT __stdcall SendVideoStream::GetTemporalSpatialTradeOff(DWORD *pdwVal){ HRESULT hr=DPR_NOT_CONFIGURED;
ASSERT(m_pVideoFilter);
if (m_pVideoFilter) { if (m_pTSTable == NULL) { *pdwVal = m_dwCurrentTSSetting; hr = S_OK; } else { hr = m_pVideoFilter->GetProperty(FM_PROP_VIDEO_IMAGE_QUALITY, pdwVal); } } return hr;}
HRESULT STDMETHODCALLTYPE RecvVideoStream::QueryInterface(REFIID iid, void **ppVoid){ // resolve duplicate inheritance to the SendMediaStream;
extern IID IID_IProperty;
if (iid == IID_IUnknown) { *ppVoid = (IUnknown*)((RecvMediaStream*)this); } else if (iid == IID_IMediaChannel) { *ppVoid = (IMediaChannel*)((RecvMediaStream *)this); }// else if (iid == IID_IVideoChannel)
// {
// *ppVoid = (IVideoChannel*)this;
// }
else if (iid == IID_IProperty) { *ppVoid = NULL; ERROR_OUT(("Don't QueryInterface for IID_IProperty, use IMediaChannel")); return E_NOINTERFACE; }
else if (iid == IID_IVideoRender)// satisfy symmetric property of QI
{ *ppVoid = (IVideoRender *)this; }
else { *ppVoid = NULL; return E_NOINTERFACE; }
AddRef();
return S_OK;
}
ULONG STDMETHODCALLTYPE RecvVideoStream::AddRef(void){ return InterlockedIncrement(&m_lRefCount);}
ULONG STDMETHODCALLTYPE RecvVideoStream::Release(void){ LONG lRet;
lRet = InterlockedDecrement(&m_lRefCount);
if (lRet == 0) { delete this; return 0; }
else return lRet;}
DWORD CALLBACK RecvVideoStream::StartRenderingThread(PVOID pVoid){ RecvVideoStream *pThisStream = (RecvVideoStream*)pVoid; return pThisStream->RenderingThread();}
HRESULTRecvVideoStream::Initialize(DataPump *pDP){ HRESULT hr = DPR_OUT_OF_MEMORY; DWORD dwFlags = DP_FLAG_FULL_DUPLEX | DP_FLAG_AUTO_SWITCH ; MEDIACTRLINIT mcInit; FX_ENTRY ("DP::RecvVideoStream")
m_pIUnknown = (IUnknown *)NULL;
InitializeCriticalSection(&m_crs); InitializeCriticalSection(&m_crsVidQoS); InitializeCriticalSection(&m_crsIStreamSignal);
dwFlags |= DP_FLAG_VCM | DP_FLAG_VIDEO ;
// store the platform flags
// enable Send and Recv by default
m_DPFlags = (dwFlags & DP_MASK_PLATFORM) | DPFLAG_ENABLE_RECV; // store a back pointer to the datapump container
m_pDP = pDP; m_Net = NULL; m_pIRTPRecv = NULL;
// Initialize data (should be in constructor)
m_RenderingDevice = (UINT) -1; // use VIDEO_MAPPER
// Create Receive and Transmit video streams
DBG_SAVE_FILE_LINE m_RecvStream = new RVStream(MAX_RXVRING_SIZE); if (!m_RecvStream ) { DEBUGMSG (ZONE_DP, ("%s: RxStream new failed\r\n", _fx_)); goto StreamAllocError; }
// Create Input and Output video filters
DBG_SAVE_FILE_LINE m_pVideoFilter = new VcmFilter(); m_dwSrcSize = 0; if (m_pVideoFilter == NULL) { DEBUGMSG (ZONE_DP, ("%s: VcmFilter new failed\r\n", _fx_)); goto FilterAllocError; }
//Create Video MultiMedia device control objects
DBG_SAVE_FILE_LINE m_OutMedia = new VideoOutControl(); if ( !m_OutMedia) { DEBUGMSG (ZONE_DP, ("%s: MediaControl new failed\r\n", _fx_)); goto MediaAllocError; }
// Initialize the recv-stream media control object
mcInit.dwFlags = dwFlags | DP_FLAG_RECV; hr = m_OutMedia->Initialize(&mcInit); if (hr != DPR_SUCCESS) { DEBUGMSG (ZONE_DP, ("%s: OMedia->Init failed, hr=0x%lX\r\n", _fx_, hr)); goto MediaAllocError; }
m_DPFlags |= DP_FLAG_RECORD_CAP ; // set media to half duplex mode by default
m_OutMedia->SetProp(MC_PROP_DUPLEX_TYPE, DP_FLAG_HALF_DUPLEX); m_DPFlags |= DPFLAG_INITIALIZED;
return DPR_SUCCESS;
MediaAllocError: if (m_OutMedia) delete m_OutMedia;FilterAllocError: if (m_pVideoFilter) delete m_pVideoFilter;StreamAllocError: if (m_RecvStream) delete m_RecvStream;
ERRORMESSAGE( ("%s: exit, hr=0x%lX\r\n", _fx_, hr));
return hr;}
// LOOK: identical to RecvAudioStream version.
RecvVideoStream::~RecvVideoStream(){
if (m_DPFlags & DPFLAG_INITIALIZED) { m_DPFlags &= ~DPFLAG_INITIALIZED; if (m_DPFlags & DPFLAG_CONFIGURED_RECV) UnConfigure();
// Close the receive and transmit streams
if (m_RecvStream) delete m_RecvStream;
// Close the wave devices
if (m_OutMedia) { delete m_OutMedia;} // Close the filters
if (m_pVideoFilter) delete m_pVideoFilter;
m_pDP->RemoveMediaChannel(MCF_RECV| MCF_VIDEO, this);
} DeleteCriticalSection(&m_crs); DeleteCriticalSection(&m_crsVidQoS); DeleteCriticalSection(&m_crsIStreamSignal);}
HRESULTRecvVideoStream::Configure( BYTE __RPC_FAR *pFormat, UINT cbFormat, BYTE __RPC_FAR *pChannelParams, UINT cbParams, IUnknown *pUnknown){ MMRESULT mmr; DWORD dwSrcSize; HRESULT hr; BOOL fRet; MEDIAPACKETINIT pcktInit; MEDIACTRLCONFIG mcConfig; MediaPacket **ppPckt; ULONG cPckt; DWORD_PTR dwPropVal; UINT ringSize = MAX_RXVRING_SIZE; DWORD dwFlags, dwSizeDst, dwMaxFrag, dwMaxBitRate = 0;
VIDEOFORMATEX *pfRecv = (VIDEOFORMATEX*)pFormat; VIDEO_CHANNEL_PARAMETERS vidChannelParams; int optval=8192*4; // Use max SQCIF, QCIF I frame size
#ifdef TEST
DWORD dwTicks;#endif
FX_ENTRY ("RecvVideoStream::Configure")
#ifdef TEST
dwTicks = GetTickCount();#endif
// m_Net = pNet;
// get format details
if ((NULL == pFormat) || (NULL == pChannelParams) || (cbParams != sizeof(vidChannelParams))) { return DPR_INVALID_PARAMETER; }
vidChannelParams = *(VIDEO_CHANNEL_PARAMETERS *)pChannelParams; if (! (m_DPFlags & DPFLAG_INITIALIZED)) return DPR_OUT_OF_MEMORY; //BUGBUG: return proper error;
// if (m_Net)
// {
// hr = m_Net->QueryInterface(IID_IRTPRecv, (void **)&m_pIRTPRecv);
// if (!SUCCEEDED(hr))
// return hr;
// }
mmr = VcmFilter::SuggestDecodeFormat(pfRecv, &m_fDevRecv);
// initialize m_cliprect
SetRect(&m_cliprect, 0, 0, m_fDevRecv.bih.biWidth, m_fDevRecv.bih.biHeight);
// Initialize the recv-stream media control object
mcConfig.uDuration = MC_USING_DEFAULT; // set duration by samples per pkt
mcConfig.pDevFmt = &m_fDevRecv; UPDATE_REPORT_ENTRY(g_prptCallParameters, pfRecv->dwFormatTag, REP_RECV_VIDEO_FORMAT); RETAILMSG(("NAC: Video Recv Format: %.4s", (LPSTR)&pfRecv->dwFormatTag));
mcConfig.hStrm = (DPHANDLE) m_RecvStream; mcConfig.uDevId = m_RenderingDevice; mcConfig.cbSamplesPerPkt = ChoosePacketSize(pfRecv); hr = m_OutMedia->Configure(&mcConfig); m_OutMedia->GetProp (MC_PROP_SIZE, &dwPropVal); dwSizeDst = (DWORD)dwPropVal;
// BUGBUG - HARDCODED platform flags. The right way to do this is to
// have a smart filter object create() that creates a platform-aware
// instance of the object
dwFlags = DP_FLAG_RECV | DP_FLAG_VCM | DP_FLAG_VIDEO;
mmr = m_pVideoFilter->Open(pfRecv, &m_fDevRecv, 0); // maxfragsize == 0
if (hr != DPR_SUCCESS) { DEBUGMSG (ZONE_DP, ("%s: RecvVideoFilter->Init failed, hr=0x%lX\r\n", _fx_, hr)); hr = DPR_CANT_OPEN_CODEC; goto RecvFilterInitError; } // set the max. fragment size
DEBUGMSG(ZONE_DP,("%s: Video Recv: maxBitRate=%d, maxBPP=%d, MPI=%d\r\n", _fx_ ,vidChannelParams.ns_params.maxBitRate*100, vidChannelParams.ns_params.maxBPP*1024, vidChannelParams.ns_params.MPI ? 30 / vidChannelParams.ns_params.MPI : 30)); UPDATE_REPORT_ENTRY(g_prptCallParameters, vidChannelParams.ns_params.MPI ? 30 / vidChannelParams.ns_params.MPI : 30, REP_RECV_VIDEO_MAXFPS); UPDATE_REPORT_ENTRY(g_prptCallParameters, vidChannelParams.ns_params.maxBitRate*100, REP_RECV_VIDEO_BITRATE); RETAILMSG(("NAC: Video Recv Max Frame Rate (negotiated - fps): %ld", vidChannelParams.ns_params.MPI ? 30 / vidChannelParams.ns_params.MPI : 30)); RETAILMSG(("NAC: Video Recv Max Bitrate (negotiated - bps): %ld", vidChannelParams.ns_params.maxBitRate*100)); INIT_COUNTER_MAX(g_pctrVideoReceive, vidChannelParams.ns_params.MPI ? 30 / vidChannelParams.ns_params.MPI : 30); INIT_COUNTER_MAX(g_pctrVideoReceiveBytes, vidChannelParams.ns_params.maxBitRate*100);
// Initialize the recv stream
ZeroMemory (&pcktInit, sizeof (pcktInit));
pcktInit.pStrmConvSrcFmt = pfRecv; pcktInit.pStrmConvDstFmt = &m_fDevRecv; pcktInit.dwFlags = dwFlags; pcktInit.cbOffsetRawData = 0; pcktInit.cbSizeRawData = dwSizeDst;
m_OutMedia->FillMediaPacketInit (&pcktInit);
m_pVideoFilter->SuggestSrcSize(dwSizeDst, &m_dwSrcSize);
pcktInit.cbSizeNetData = m_dwSrcSize;
pcktInit.cbOffsetNetData = sizeof (RTP_HDR);
m_OutMedia->GetProp (MC_PROP_SPP, &dwPropVal); ringSize = 8; // reserve space for 8 video frames
// may need to increase the number if a/v sync is enabled.
fRet = ((RVStream*)m_RecvStream)->Initialize (DP_FLAG_VIDEO, ringSize, NULL, &pcktInit, (DWORD)dwPropVal, pfRecv->nSamplesPerSec, m_pVideoFilter); if (! fRet) { DEBUGMSG (ZONE_DP, ("%s: RxvStream->Init failed, fRet=0%u\r\n", _fx_, fRet)); hr = DPR_CANT_INIT_RXV_STREAM; goto RxStreamInitError; }
// 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.
// Computer of actual bandwidth 70 % (but it's already been divided by 100)
dwMaxBitRate = vidChannelParams.ns_params.maxBitRate*70; if (dwMaxBitRate > BW_ISDN_BITS) { dwMaxFrag = 1350; } else { dwMaxFrag = 512; }
InitVideoFlowspec(&m_flowspec, dwMaxBitRate, dwMaxFrag, VID_AVG_PACKET_SIZE);
/*
// assume no more than 32 fragments for CIF and
// 20 fragments for SQCIF, QCIF
//BLOAT WARNING: this could be quite a bit of memory
// need to fix this to use a heap instead of fixed size buffers.
*/
// prepare headers for RxvStream
m_RecvStream->GetRing (&ppPckt, &cPckt); m_OutMedia->RegisterData (ppPckt, cPckt); m_OutMedia->PrepareHeaders ();
// Keep a weak reference to the IUnknown interface
// We will use it to query a Stream Signal interface pointer in Start()
m_pIUnknown = pUnknown;
m_DPFlags |= DPFLAG_CONFIGURED_RECV;
#ifdef TEST
LOG((LOGMSG_TIME_RECV_VIDEO_CONFIGURE,GetTickCount() - dwTicks));#endif
return DPR_SUCCESS;
RxStreamInitError: m_pVideoFilter->Close();RecvFilterInitError: m_OutMedia->Close(); if (m_pIRTPRecv) { m_pIRTPRecv->Release(); m_pIRTPRecv = NULL; } DEBUGMSG (1, ("%s: failed, hr=0%u\r\n", _fx_, hr)); return hr;}
void RecvVideoStream::UnConfigure(){
#ifdef TEST
DWORD dwTicks;
dwTicks = GetTickCount();#endif
if ( (m_DPFlags & DPFLAG_CONFIGURED_RECV)) { Stop();
// Close the RTP state if its open
//m_Net->Close(); We should be able to do this in Disconnect()
m_Net = NULL; if (m_pIRTPRecv) { m_pIRTPRecv->Release(); m_pIRTPRecv = NULL; } m_OutMedia->Reset(); m_OutMedia->UnprepareHeaders(); m_OutMedia->Close();
// Close the filter
m_pVideoFilter->Close();
// Close the receive stream
m_RecvStream->Destroy();
m_DPFlags &= ~(DPFLAG_CONFIGURED_RECV); }
#ifdef TEST
LOG((LOGMSG_TIME_RECV_VIDEO_UNCONFIGURE,GetTickCount() - dwTicks));#endif
}
// NOTE: Identical to RecvAudioStream. Move up?
HRESULTRecvVideoStream::Start(){ int nRet=IFRAMES_CAPS_UNKNOWN; FX_ENTRY ("RecvVideoStream::Start");
if (m_DPFlags & DPFLAG_STARTED_RECV) return DPR_SUCCESS;
if ((!(m_DPFlags & DPFLAG_CONFIGURED_RECV)) || (m_pIRTPRecv==NULL)) return DPR_NOT_CONFIGURED; ASSERT(!m_hRenderingThread);
m_ThreadFlags &= ~(DPTFLAG_STOP_PLAY|DPTFLAG_STOP_RECV);
m_RecvStream->SetRTP(m_pIRTPRecv);
SetFlowSpec();
// --------------------------------------------------------------------------
// Decide whether or not we will be making I-Frame requests for lost packets
// This should be done for all scenarios except when we are calling
// NetMeeting 2.x. NM 2.x will send us periodic I-Frames.
m_fDiscontinuity = FALSE; m_dwLastIFrameRequest = 0UL; m_ulLastSeq = UINT_MAX;
if (m_pIUnknown) { HRESULT hr;
if (!m_pIStreamSignal) { hr = m_pIUnknown->QueryInterface(IID_IStreamSignal, (void **)&m_pIStreamSignal); if (!HR_SUCCEEDED(hr)) { m_pIStreamSignal = (IStreamSignal *)NULL; m_pIUnknown = (IUnknown *)NULL; } }
if (m_pIStreamSignal) { nRet = GetIFrameCaps(m_pIStreamSignal);
if (nRet == IFRAMES_CAPS_NM2) { m_pIStreamSignal->Release(); m_pIStreamSignal = NULL; m_pIUnknown = NULL; } } }// --------------------------------------------------------------------------
// Start playback thread
if (!(m_ThreadFlags & DPTFLAG_STOP_PLAY)) m_hRenderingThread = CreateThread(NULL,0,RecvVideoStream::StartRenderingThread,this,0,&m_RenderingThId); // Start receive thread
#if 0
if (!m_pDP->m_hRecvThread) { m_pDP->m_hRecvThread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)&StartDPRecvThread,m_pDP,0,&m_pDP->m_RecvThId); //Tell the recv Thread we've turned on
if (m_pDP->m_hRecvThreadChangeEvent) SetEvent (m_pDP->m_hRecvThreadChangeEvent); } m_pDP->m_nReceivers++; #else
m_pDP->StartReceiving(this); #endif
m_DPFlags |= DPFLAG_STARTED_RECV; DEBUGMSG (ZONE_DP, ("%s: Rendering ThId =%x\r\n",_fx_, m_RenderingThId)); return DPR_SUCCESS;}
// LOOK: Identical to RecvAudioStream version.
HRESULTRecvVideoStream::Stop(){ DWORD dwWait; FX_ENTRY ("RecvVideoStream::Stop");
if(!(m_DPFlags & DPFLAG_STARTED_RECV)) { return DPR_SUCCESS; }
m_ThreadFlags = m_ThreadFlags | DPTFLAG_STOP_RECV | DPTFLAG_STOP_PLAY ;
m_pDP->StopReceiving(this); DEBUGMSG (ZONE_VERBOSE, ("%s: m_hRenderingThread =%x\r\n",_fx_, m_hRenderingThread));
/*
* we want to wait for all the threads to exit, but we need to handle windows * messages (mostly from winsock) while waiting. * we made several attempts at that. When we wait for messages in addition * to the thread exit events, we crash in rrcm.dll, possibly because we * process a winsock message to a thread that is terminating. * * needs more investigation before putting in code that handles messages */
if(m_hRenderingThread) { dwWait = WaitForSingleObject (m_hRenderingThread, INFINITE);
DEBUGMSG (ZONE_VERBOSE, ("%s: dwWait =%d\r\n", _fx_, dwWait)); ASSERT(dwWait != WAIT_FAILED);
CloseHandle(m_hRenderingThread); m_hRenderingThread = NULL; }
// Access to the stream signal interface needs to be serialized. We could crash
// if we release the interface here and we are still using that interface in the
// RTP callback.
if (m_pIStreamSignal) { EnterCriticalSection(&m_crsIStreamSignal); m_pIStreamSignal->Release(); m_pIStreamSignal = (IStreamSignal *)NULL; LeaveCriticalSection(&m_crsIStreamSignal); }
//This is per channel, but the variable is "DPFlags"
m_DPFlags &= ~DPFLAG_STARTED_RECV;
return DPR_SUCCESS;}
// IProperty::GetProperty / SetProperty
// Properties of the MediaChannel.
STDMETHODIMPRecvVideoStream::GetProperty( DWORD prop, PVOID pBuf, LPUINT pcbBuf ){ HRESULT hr = DPR_SUCCESS; RTP_STATS RTPStats; DWORD dwValue; DWORD_PTR dwPropVal; UINT len = sizeof(DWORD); // most props are DWORDs
if (!pBuf || *pcbBuf < len) { *pcbBuf = len; return DPR_INVALID_PARAMETER; }
switch (prop) { #ifdef OLDSTUFF
case PROP_NET_RECV_STATS: if (m_Net && *pcbBuf >= sizeof(RTP_STATS)) { m_Net->GetRecvStats((RTP_STATS *)pBuf); *pcbBuf = sizeof(RTP_STATS); } else hr = DPR_INVALID_PROP_VAL; break;
#endif
case PROP_DURATION: hr = m_OutMedia->GetProp(MC_PROP_DURATION, &dwPropVal); *(DWORD *)pBuf = (DWORD)dwPropVal; break;
case PROP_PLAY_ON: *(DWORD *)pBuf = ((m_ThreadFlags & DPFLAG_ENABLE_RECV)!=0); break;
case PROP_PLAYBACK_DEVICE: *(DWORD *)pBuf = m_RenderingDevice; break;
case PROP_VIDEO_BRIGHTNESS: hr = m_pVideoFilter->GetProperty(FM_PROP_VIDEO_BRIGHTNESS, (DWORD *)pBuf); break;
case PROP_VIDEO_CONTRAST: hr = m_pVideoFilter->GetProperty(FM_PROP_VIDEO_CONTRAST, (DWORD *)pBuf); break;
case PROP_VIDEO_SATURATION: hr = m_pVideoFilter->GetProperty(FM_PROP_VIDEO_SATURATION, (DWORD *)pBuf); break;
case PROP_VIDEO_AUDIO_SYNC: *(DWORD *)pBuf = ((m_DPFlags & DPFLAG_AV_SYNC) != 0); break;
case PROP_PAUSE_RECV: *(DWORD *)pBuf = ((m_ThreadFlags & DPTFLAG_PAUSE_RECV) != 0); break; default: hr = DPR_INVALID_PROP_ID; break; }
return hr;}
STDMETHODIMPRecvVideoStream::SetProperty( DWORD prop, PVOID pBuf, UINT cbBuf ){ DWORD dw; HRESULT hr = S_OK; if (cbBuf < sizeof (DWORD)) return DPR_INVALID_PARAMETER;
switch (prop) {
#if 0
case PROP_PLAY_ON: { DWORD flag = (DPFLAG_ENABLE_RECV); 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")); //hr = EnableStream( *(DWORD*)pBuf);
break; } #endif
case PROP_PLAYBACK_DEVICE: m_RenderingDevice = *(DWORD*)pBuf; // RETAILMSG(("NAC: Setting default playback device to %d", m_RenderingDevice));
break;
case PROP_VIDEO_BRIGHTNESS: hr = m_pVideoFilter->SetProperty(FM_PROP_VIDEO_BRIGHTNESS, *(DWORD*)pBuf); break;
case PROP_VIDEO_CONTRAST: hr = m_pVideoFilter->SetProperty(FM_PROP_VIDEO_CONTRAST, *(DWORD*)pBuf); break;
case PROP_VIDEO_SATURATION: hr = m_pVideoFilter->SetProperty(FM_PROP_VIDEO_SATURATION, *(DWORD*)pBuf); break;
case PROP_VIDEO_RESET_BRIGHTNESS: hr = m_pVideoFilter->SetProperty(FM_PROP_VIDEO_BRIGHTNESS, VCM_DEFAULT_BRIGHTNESS); break;
case PROP_VIDEO_RESET_CONTRAST: hr = m_pVideoFilter->SetProperty(FM_PROP_VIDEO_CONTRAST, VCM_DEFAULT_CONTRAST); break;
case PROP_VIDEO_RESET_SATURATION: hr = m_pVideoFilter->SetProperty(FM_PROP_VIDEO_SATURATION, VCM_DEFAULT_SATURATION); break;
case PROP_VIDEO_SIZE: // For now, do not change anything if we already are connected
ASSERT(0); //return SetVideoSize(m_pDP->m_pNac, *(DWORD*)pBuf);
case PROP_VIDEO_AUDIO_SYNC: if (*(DWORD *)pBuf) m_DPFlags |= DPFLAG_AV_SYNC; else m_DPFlags &= ~DPFLAG_AV_SYNC; break; case PROP_PAUSE_RECV: if (*(DWORD *)pBuf) m_ThreadFlags |= DPTFLAG_PAUSE_RECV; else m_ThreadFlags &= ~DPTFLAG_PAUSE_RECV; break;
default: return DPR_INVALID_PROP_ID; break; } return hr;}//---------------------------------------------------------------------
// IVideoRender implementation and support functions
// IVideoRender::Init
// (DataPump::Init)
// identical to SendVideoStream::Init
STDMETHODIMPRecvVideoStream::Init( DWORD_PTR dwUser, LPFNFRAMEREADY pfCallback ){ // Save the event away. Note that we DO allow both send and receive to
// share an event
m_hRenderEvent = (HANDLE)dwUser; // if pfCallback is NULL then dwUser is an event handle
m_pfFrameReadyCallback = pfCallback; return DPR_SUCCESS;}
// IVideoRender::Done
// idnentical to SendVideoStream::Done
STDMETHODIMPRecvVideoStream::Done( ){ m_hRenderEvent = NULL; m_pfFrameReadyCallback = NULL; return DPR_SUCCESS;}
// IVideoRender::GetFrame
// (RecvVideoStream::GetFrame)
// NOTE: subtly different from SendVideoStream implementation!
STDMETHODIMPRecvVideoStream::GetFrame( FRAMECONTEXT* pfc ){ HRESULT hr; PVOID pData = NULL; UINT cbData = 0;
// Validate parameters
if (!pfc ) return DPR_INVALID_PARAMETER;
// Don't arbitrarily call out while holding this crs or you may deadlock...
EnterCriticalSection(&m_crs);
if ((m_DPFlags & DPFLAG_CONFIGURED_RECV) && m_pNextPacketToRender && !m_pNextPacketToRender->m_fRendering) { m_pNextPacketToRender->m_fRendering = TRUE; m_pNextPacketToRender->GetDevData(&pData,&cbData); pfc->lpData = (PUCHAR) pData; pfc->dwReserved = (DWORD_PTR) m_pNextPacketToRender; // set bmi length?
pfc->lpbmi = (PBITMAPINFO)&m_fDevRecv.bih; pfc->lpClipRect = &m_cliprect; m_cRendering++; hr = S_OK; LOG((LOGMSG_GET_RECV_FRAME,m_pNextPacketToRender->GetIndex())); } else hr = S_FALSE; // nothing ready to render
LeaveCriticalSection(&m_crs);
return hr; }
// IVideoRender::ReleaseFrame
// NOTE: subtly different from SendVideoStream implementation!
STDMETHODIMPRecvVideoStream::ReleaseFrame( FRAMECONTEXT* pfc ){ HRESULT hr; MediaPacket *pPacket;
// Validate parameters
if (!pfc) return DPR_INVALID_PARAMETER;
// Handle a send frame
{ EnterCriticalSection(&m_crs);
// Don't arbitrarily call out while holding this crs or you may deadlock...
if ((m_DPFlags & DPFLAG_CONFIGURED_RECV) && (pPacket = (MediaPacket *)pfc->dwReserved) && pPacket->m_fRendering) { LOG((LOGMSG_RELEASE_SEND_FRAME,pPacket->GetIndex())); pPacket->m_fRendering = FALSE; pfc->dwReserved = 0; // if its not the current frame
if (m_pNextPacketToRender != pPacket) { pPacket->Recycle(); m_RecvStream->Release(pPacket); } m_cRendering--; hr = S_OK; } else hr = DPR_INVALID_PARAMETER;
LeaveCriticalSection(&m_crs); } return hr;}
HRESULT CALLBACK SendVideoStream::QosNotifyVideoCB(LPRESOURCEREQUESTLIST lpResourceRequestList, DWORD_PTR dwThis){ HRESULT hr=NOERROR; LPRESOURCEREQUESTLIST prrl=lpResourceRequestList; int i; int iMaxBWUsage, iMaxCPUUsage; DWORD dwCPUUsage, dwBWUsage; int iCPUUsageId, iBWUsageId; int iCPUDelta, iBWDelta, deltascale; int iFrameRate, iMaxFrameRate, iOldFrameRate; UINT dwSize = sizeof(int); DWORD dwOverallCPUUsage;#ifdef LOGSTATISTICS_ON
char szDebug[256]; HANDLE hDebugFile; DWORD d;#endif
DWORD dwEpoch; SendVideoStream *pThis = (SendVideoStream *)dwThis;
FX_ENTRY("QosNotifyVideoCB");
// Get the max for the resources.
iMaxCPUUsage = -1L; iMaxBWUsage = -1L; 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;
// Enter critical section to allow QoS thread to read the statistics while capturing
EnterCriticalSection(&(pThis->m_crsVidQoS));
// 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)) {
// Measure the epoch
dwEpoch = pThis->m_Stats.dwNewestTs - pThis->m_Stats.dwOldestTs;
#ifdef LOGSTATISTICS_ON
wsprintf(szDebug, " Epoch = %ld\r\n", dwEpoch); OutputDebugString(szDebug);#endif
// Compute the current average frame rate
iOldFrameRate = pThis->m_Stats.dwCount * 100000 / dwEpoch;
if (iCPUUsageId != -1L) iMaxCPUUsage = lpResourceRequestList->aRequests[iCPUUsageId].nUnitsMin; if (iBWUsageId != -1L) iMaxBWUsage = lpResourceRequestList->aRequests[iBWUsageId].nUnitsMin;
// Get general BW usage
dwBWUsage = pThis->m_Stats.dwBits * 1000UL / dwEpoch;
// Get general CPU usage. In order to reduce oscillations, apply low-pass filtering operation
// We will use our own CPU usage number ONLY if the call to GetCPUUsage() fails.
if (pThis->GetCPUUsage(&dwOverallCPUUsage)) { if (pThis->m_Stats.dwSmoothedCPUUsage) dwCPUUsage = (pThis->m_Stats.dwSmoothedCPUUsage + dwOverallCPUUsage) >> 1; else dwCPUUsage = dwOverallCPUUsage; } else dwCPUUsage = (pThis->m_Stats.dwMsCap + pThis->m_Stats.dwMsComp) * 1000UL / dwEpoch;
// Record current CPU usage
pThis->m_Stats.dwSmoothedCPUUsage = dwCPUUsage;
#ifdef LOGSTATISTICS_ON
hDebugFile = CreateFile("C:\\QoS.txt", GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL); SetFilePointer(hDebugFile, 0, NULL, FILE_END); wsprintf(szDebug, " Overall CPU usage = %ld\r\n", dwOverallCPUUsage); WriteFile(hDebugFile, szDebug, strlen(szDebug), &d, NULL); OutputDebugString(szDebug); CloseHandle(hDebugFile);
wsprintf(szDebug, " Number of frames dwCount = %ld\r\n", pThis->m_Stats.dwCount); OutputDebugString(szDebug);#endif
// For this first implementation, the only output variable is the frame rate of the
// video capture
#ifdef USE_NON_LINEAR_FPS_ADJUSTMENT
if (iCPUUsageId != -1L) { if (dwCPUUsage) { iCPUDelta = (iMaxCPUUsage - (int)dwCPUUsage) * 10 / (int)dwCPUUsage; if (iCPUDelta >= 10) iCPUDelta = 9; else if (iCPUDelta <= -1) iCPUDelta = -9; } else iCPUDelta = 9; } else iCPUDelta = 0;
if (iBWUsageId != -1L) { if (dwBWUsage) { iBWDelta = (iMaxBWUsage - (int)dwBWUsage) * 10 / (int)dwBWUsage; if (iBWDelta >= 10) iBWDelta = 9; else if (iBWDelta <= -1) iBWDelta = -9; } else iBWDelta = 9; } else iBWDelta = 0;#else
if (iCPUUsageId != -1L) { if (dwCPUUsage) iCPUDelta = (iMaxCPUUsage - (int)dwCPUUsage) * 100 / (int)dwCPUUsage; else iCPUDelta = 90; } else iCPUDelta = 0;
if (iBWUsageId != -1L) { if (dwBWUsage) iBWDelta = (iMaxBWUsage - (int)dwBWUsage) * 100 / (int)dwBWUsage; else iBWDelta = 90; } else iBWDelta = 0;#endif
UPDATE_COUNTER(g_pctrVideoCPUuse, iCPUDelta); UPDATE_COUNTER(g_pctrVideoBWuse, iBWDelta);
#ifdef USE_NON_LINEAR_FPS_ADJUSTMENT
iFrameRate = iOldFrameRate + iOldFrameRate * g_QoSMagic[iCPUDelta + 9][iBWDelta + 9] / 100;#else
deltascale = iCPUDelta; if (deltascale > iBWDelta) deltascale = iBWDelta; if (deltascale > 90) deltascale = 90; if (deltascale < -90) deltascale = -90; iFrameRate = iOldFrameRate + (iOldFrameRate * deltascale) / 100;#endif
// Initialize QoS structure. Only the four first fields should be zeroed.
// The handle to the CPU performance key should not be cleared.
ZeroMemory(&(pThis->m_Stats), 4UL * sizeof(DWORD));
// The video should reduce its CPU and bandwidth usage quickly, but probably shouldn't
// be allowed to increase its CPU and bandwidth usage as fast. Let's increase the
// frame rate at half the speed it would be decreased when we are above 5fps.
if ((iFrameRate > iOldFrameRate) && (iFrameRate > 500)) iFrameRate -= (iFrameRate - iOldFrameRate) >> 1;
// We should keep our requirements between a minimum that will allow us to catch up
// quickly and the current max frame rate
iMaxFrameRate = pThis->m_maxfps; // max negotiated for call
// if using a modem, then the frame rate is determined by the
// temporal spatial tradeoff
if (pThis->m_pTSTable) { iMaxFrameRate = min(iMaxFrameRate, pThis->m_pTSTable[pThis->m_dwCurrentTSSetting]); }
if (iFrameRate > iMaxFrameRate) iFrameRate = iMaxFrameRate; if (iFrameRate < 50) // make sure framerate is > 0 (this does not mean 50 fps; it is .50 fps)
iFrameRate = 50; // Update the frame rate
if (iFrameRate != iOldFrameRate) pThis->SetProperty(PROP_VIDEO_FRAME_RATE, &iFrameRate, sizeof(int));
// Record the time of this call for the next callback call
pThis->m_Stats.dwOldestTs = pThis->m_Stats.dwNewestTs;
// 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_pctrVideoSendLost && SUCCEEDED(pThis->m_pRTPSend->GetSendStats(&pThis->m_RTPStats))) UPDATE_COUNTER(g_pctrVideoSendLost, pThis->m_RTPStats.packetsLost-lastPacketsLost); }
// Leave critical section
LeaveCriticalSection(&(pThis->m_crsVidQoS));
DEBUGMSG(ZONE_QOS, ("%s: Over the last %ld.%lds, video used %ld%% of the CPU (max allowed %ld%%) and %ld bps (max allowed %ld bps)\r\n", _fx_, dwEpoch / 1000UL, dwEpoch - (dwEpoch / 1000UL) * 1000UL, dwCPUUsage / 10UL, iMaxCPUUsage / 10UL, dwBWUsage, iMaxBWUsage)); DEBUGMSG(ZONE_QOS, ("%s: Ajusting target frame rate from %ld.%ld fps to %ld.%ld fps\r\n", _fx_, iOldFrameRate / 100UL, iOldFrameRate - (iOldFrameRate / 100UL) * 100UL, iFrameRate / 100UL, iFrameRate - (iFrameRate / 100UL) * 100UL));
// Set the target bitrates and frame rates on the codec
pThis->SetTargetRates(iFrameRate, iMaxBWUsage);
#ifdef LOGSTATISTICS_ON
// How are we doing?
if (iCPUUsageId != -1L) { if (iCPUDelta > 0) wsprintf(szDebug, "Max CPU Usage: %ld, Current CPU Usage: %ld, Increase CPU Usage by: %li, Old Frame Rate: %ld, New Frame Rate: %ld\r\n", lpResourceRequestList->aRequests[iCPUUsageId].nUnitsMin, dwCPUUsage, iCPUDelta, iOldFrameRate, iFrameRate); else wsprintf(szDebug, "Max CPU Usage: %ld, Current CPU Usage: %ld, Decrese CPU Usage by: %li, Old Frame Rate: %ld, New Frame Rate: %ld\r\n", lpResourceRequestList->aRequests[iCPUUsageId].nUnitsMin, dwCPUUsage, iCPUDelta, iOldFrameRate, iFrameRate); hDebugFile = CreateFile("C:\\QoS.txt", GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL); SetFilePointer(hDebugFile, 0, NULL, FILE_END); WriteFile(hDebugFile, szDebug, strlen(szDebug), &d, NULL); CloseHandle(hDebugFile); OutputDebugString(szDebug); }
if (iBWUsageId != -1L) { if (iBWDelta > 0) wsprintf(szDebug, "Max BW Usage: %ld, Current BW Usage: %ld, Increase BW Usage by: %li\r\n", lpResourceRequestList->aRequests[iBWUsageId].nUnitsMin, dwBWUsage, iBWDelta); else wsprintf(szDebug, "Max BW Usage: %ld, Current BW Usage: %ld, Decrease BW Usage by: %li\r\n", lpResourceRequestList->aRequests[iBWUsageId].nUnitsMin, dwBWUsage, iBWDelta); hDebugFile = CreateFile("C:\\QoS.txt", GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL); SetFilePointer(hDebugFile, 0, NULL, FILE_END); WriteFile(hDebugFile, szDebug, strlen(szDebug), &d, NULL); CloseHandle(hDebugFile); OutputDebugString(szDebug); }#endif
} else { // Leave critical section
LeaveCriticalSection(&(pThis->m_crsVidQoS));
#ifdef LOGSTATISTICS_ON
hDebugFile = CreateFile("C:\\QoS.txt", GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL); SetFilePointer(hDebugFile, 0, NULL, FILE_END); wsprintf(szDebug, "Not enough data captured -> Leave without any change\r\n"); WriteFile(hDebugFile, szDebug, strlen(szDebug), &d, NULL); CloseHandle(hDebugFile); OutputDebugString(szDebug);#endif
}
return hr;}
// SortOrder
// Helper function to search for the specific format type and set its sort
// order to the desired number
BOOLSortOrder( IAppVidCap *pavc, BASIC_VIDCAP_INFO* pvidcaps, DWORD dwcFormats, DWORD dwFlags, WORD wDesiredSortOrder, int nNumFormats ){ int i, j; int nNumSizes = 0; int *aFrameSizes = (int *)NULL; int *aMinFrameSizes = (int *)NULL; int iMaxPos; WORD wTempPos, wMaxSortIndex;
// Scale sort value
wDesiredSortOrder *= (WORD)nNumFormats;
// Local buffer of sizes that match dwFlags
if (!(aFrameSizes = (int *)MEMALLOC(nNumFormats * sizeof (int)))) goto out;
// Look through all the formats until we find the ones we want
// Save the position of these entries
for (i=0; i<(int)dwcFormats; i++) if (SIZE_TO_FLAG(pvidcaps[i].enumVideoSize) == dwFlags) aFrameSizes[nNumSizes++] = i;
// Now order those entries from highest to lowest sort index
for (i=0; i<nNumSizes; i++) { for (iMaxPos = -1L, wMaxSortIndex=0UL, j=i; j<nNumSizes; j++) { if (pvidcaps[aFrameSizes[j]].wSortIndex > wMaxSortIndex) { wMaxSortIndex = pvidcaps[aFrameSizes[j]].wSortIndex; iMaxPos = j; } } if (iMaxPos != -1L) { wTempPos = (WORD)aFrameSizes[i]; aFrameSizes[i] = aFrameSizes[iMaxPos]; aFrameSizes[iMaxPos] = wTempPos; } }
// Change the sort index of the sorted entries
for (; nNumSizes--;) pvidcaps[aFrameSizes[nNumSizes]].wSortIndex = wDesiredSortOrder++;
// Release memory
MEMFREE(aFrameSizes);
return TRUE;
out: return FALSE;}
// LOOK: this is identical to the RecvAudioStream implementation
HRESULTRecvVideoStream::GetCurrentPlayNTPTime(NTP_TS *pNtpTime){ DWORD rtpTime;#ifdef OLDSTUFF
if ((m_DPFlags & DPFLAG_STARTED_RECV) && m_fReceiving) { if (m_Net->RTPtoNTP(m_PlaybackTimestamp,pNtpTime)) return S_OK; }#endif
return 0xff; // return proper error
}
BOOL RecvVideoStream::IsEmpty() { return m_RecvStream->IsEmpty();}
/*
Called by the recv thread to setup the stream for receiving. Call RTP object to post the initial recv buffer(s).*/// NOTE: identical to audio version except for choice of number of packet buffers
HRESULTRecvVideoStream::StartRecv(HWND hWnd){ HRESULT hr = S_OK; DWORD dwPropVal = 0; UINT numPackets; if ((!(m_ThreadFlags & DPTFLAG_STOP_RECV) ) && (m_DPFlags & DPFLAG_CONFIGURED_RECV)) { numPackets = m_dwSrcSize > 10000 ? MAX_VIDEO_FRAGMENTS : MAX_QCIF_VIDEO_FRAGMENTS;
hr = m_pIRTPRecv->SetRecvNotification(&RTPRecvCallback, (DWORD_PTR)this, numPackets); } return hr;}
// NOTE: identical to audio version
HRESULTRecvVideoStream::StopRecv(){ // Free any RTP buffers that we're holding on to
m_RecvStream->ReleaseNetBuffers(); // dont recv on this stream
m_pIRTPRecv->CancelRecvNotification();
return S_OK; }
HRESULT RecvVideoStream::RTPCallback(WSABUF *pWsaBuf, DWORD timestamp, UINT seq, UINT fMark){ HRESULT hr; DWORD_PTR dwPropVal; BOOL fSkippedAFrame; BOOL fReceivedKeyframe;
FX_ENTRY("RecvVideoStream::RTPCallback");
// if we are paused, reject the packet
if (m_ThreadFlags & DPTFLAG_PAUSE_RECV) { return E_FAIL; }
// PutNextNetIn will return DPR_SUCESS to indicate a new frame
// S_FALSE if success, but no new frame
// error otherwise
// It always takes care of freeing the RTP buffers
hr = m_RecvStream->PutNextNetIn(pWsaBuf, timestamp, seq, fMark, &fSkippedAFrame, &fReceivedKeyframe);
if (m_pIUnknown) { // Check out the sequence number
// If there is a gap between the new sequence number and the last
// one, a frame got lost. Generate an I-Frame request then, but no more
// often than one every 15 seconds. How should we go about NM2.0? Other
// clients that don't support I-Frame requests.
//
// Is there a discontinuity in sequence numbers that was detected
// in the past but not handled because an I-Frame request had alreay
// been sent less than 15s ago? Is there a new discontinuity?
if (FAILED(hr) || fSkippedAFrame || m_fDiscontinuity || ((seq > 0) && (m_ulLastSeq != UINT_MAX) && ((seq - 1) > m_ulLastSeq))) { DWORD dwNow = GetTickCount();
// Was the last time we issued an I-Frame request more than 15s ago?
if ((dwNow > m_dwLastIFrameRequest) && ((dwNow - m_dwLastIFrameRequest) > MIN_IFRAME_REQUEST_INTERVAL)) { DEBUGMSG (ZONE_IFRAME, ("%s: Loss detected - Sending I-Frame request...\r\n", _fx_));
m_dwLastIFrameRequest = dwNow; m_fDiscontinuity = FALSE;
// Access to the stream signal interface needs to be serialized. We could crash
// if we used the interface here while Stop() is releasing it.
EnterCriticalSection(&m_crsIStreamSignal); if (m_pIStreamSignal) m_pIStreamSignal->PictureUpdateRequest(); LeaveCriticalSection(&m_crsIStreamSignal); } else { if (!fReceivedKeyframe) { DEBUGMSG (ZONE_IFRAME, ("%s: Loss detected but too soon to send I-Frame request. Wait %ld ms.\r\n", _fx_, MIN_IFRAME_REQUEST_INTERVAL - (dwNow - m_dwLastIFrameRequest))); m_fDiscontinuity = TRUE; } else { DEBUGMSG (ZONE_IFRAME, ("%s: Received a keyframe - resetting packet loss detector\r\n", _fx_)); m_fDiscontinuity = FALSE; } } }
m_ulLastSeq = seq; }
if (hr == DPR_SUCCESS) { m_OutMedia->GetProp (MC_PROP_EVENT_HANDLE, &dwPropVal); if (dwPropVal) { SetEvent( (HANDLE) dwPropVal); } } else if (FAILED(hr)) { DEBUGMSG(ZONE_DP,("RVStream::PutNextNetIn (ts=%d,seq=%d,fMark=%d) failed with 0x%lX\r\n",timestamp,seq,fMark,hr)); }
return S_OK;}
#define TOTAL_BYTES 8192
#define BYTE_INCREMENT 1024
/****************************************************************************
* @doc EXTERNAL QOSFUNC * * @func void | StartCPUUsageCollection | This function does all necessary * initialization for CPU usage data collection. * * @rdesc Although this function doesn't ever fail, m_Stats.hPerfKey is set to a * valid HKEY value if initialization occured correctly, and NULL otherwise. * * @comm This functions executes two different code paths: one for NT and one * for Win95-98. * * @devnote MSDN references: * Microsoft Knowledge Base, Article ID Q174631 * "HOWTO: Access the Performance Registry Under Windows 95" * * Microsoft Knowledge Base, Article ID Q107728 * "Retrieving Counter Data from the Registry" * * Microsoft Knowledge Base, Article ID Q178887 * "INFO: Troubleshooting Performance Registry Access Violations" * * Also, used section "Platform SDK\Windows Base Services\Windows NT Features\Performance Data Helper" ***************************************************************************/void SendVideoStream::StartCPUUsageCollection(void){ PPERF_DATA_BLOCK pPerfDataBlock; PPERF_OBJECT_TYPE pPerfObjectType; PPERF_COUNTER_DEFINITION pPerfCounterDefinition; PPERF_INSTANCE_DEFINITION pPerfInstanceDefinition; PPERF_COUNTER_BLOCK pPerfCounterBlock; OSVERSIONINFO osvInfo = {0}; DWORD cbCounterData; DWORD cbTryCounterData; DWORD dwType; HANDLE hPerfData; char *pszData; char *pszIndex; char szProcessorIndex[16]; long lRet;
FX_ENTRY("SendVideoStream::StartCPUUsageCollection");
// Are we on NT or Win95/98 ?
osvInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); GetVersionEx(&osvInfo);
if (m_Stats.fWinNT = (BOOL)(osvInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)) { // Enable the collection of CPU performance data on Win NT
// Open the registry key that contains the performance counter indices and names.
// 009 is the U.S. English language id. In a non-English version of Windows NT,
// performance counters are stored both in the native language of the system and
// in English.
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Perflib\\009", NULL, KEY_READ, &m_Stats.hPerfKey) != ERROR_SUCCESS) goto MyError0; else { // Get all the counter indices and names.
// Read the performance data from the registry. The size of that data may change
// between each call to the registry. We first get the current size of the buffer,
// allocate it, and try to read from the registry into it. If there already isn't
// enough room in the buffer, we realloc() it until we manage to read all the data.
if (RegQueryValueEx(m_Stats.hPerfKey, "Counters", NULL, &dwType, NULL, &cbCounterData) != ERROR_SUCCESS) cbCounterData = TOTAL_BYTES;
// Allocate buffer for counter indices and names
if (!(m_Stats.NtCPUUsage.hPerfData = (PBYTE)LocalAlloc (LMEM_MOVEABLE, cbCounterData))) { m_Stats.NtCPUUsage.pbyPerfData = (PBYTE)NULL; RegCloseKey(m_Stats.hPerfKey); goto MyError0; } else { m_Stats.NtCPUUsage.pbyPerfData = (PBYTE)LocalLock(m_Stats.NtCPUUsage.hPerfData);
cbTryCounterData = cbCounterData; while((lRet = RegQueryValueEx(m_Stats.hPerfKey, "Counters", NULL, NULL, m_Stats.NtCPUUsage.pbyPerfData, &cbTryCounterData)) == ERROR_MORE_DATA) { cbCounterData += BYTE_INCREMENT; LocalUnlock(m_Stats.NtCPUUsage.hPerfData); hPerfData = LocalReAlloc(m_Stats.NtCPUUsage.hPerfData, cbCounterData, LMEM_MOVEABLE); if (!hPerfData) goto MyError1; m_Stats.NtCPUUsage.hPerfData = hPerfData; m_Stats.NtCPUUsage.pbyPerfData = (PBYTE)LocalLock(hPerfData); cbTryCounterData = cbCounterData; }
// We don't need that key anymore
RegCloseKey(m_Stats.hPerfKey);
if (lRet != ERROR_SUCCESS) goto MyError1; else { // The data is stored as MULTI_SZ strings. This data type consists
// of a list of strings, each terminated with NULL. The last string
// is followed by an additional NULL. The strings are listed in
// pairs. The first string of each pair is the string of the index,
// and the second string is the actual name of the index. The Counter
// data uses only even-numbered indexes. For example, the Counter
// data contains the following object and counter name strings.
// Examples:
// 2 System
// 4 Memory
// 6 % Processor Time
//
// Look for the "% Processor Time" counter
pszData = (char *)m_Stats.NtCPUUsage.pbyPerfData; pszIndex = (char *)m_Stats.NtCPUUsage.pbyPerfData;
while (*pszData && lstrcmpi(pszData, "% Processor Time")) { pszIndex = pszData; pszData += lstrlen(pszData) + 1; }
if (!pszData) { // Couldn't find "% Processor Time" counter!!!
goto MyError1; } else { m_Stats.NtCPUUsage.dwPercentProcessorIndex = atol(pszIndex);
// Look for the "Processor" object
pszIndex = pszData = (char *)m_Stats.NtCPUUsage.pbyPerfData;
while (*pszData && lstrcmpi(pszData, "Processor")) { pszIndex = pszData; pszData += lstrlen(pszData) + 1; }
if (!pszData) { // Couldn't find "Processor" counter!!!
goto MyError1; } else { m_Stats.NtCPUUsage.dwProcessorIndex = atol(pszIndex); CopyMemory(szProcessorIndex, pszIndex, lstrlen(pszIndex));
// Read the PERF_DATA_BLOCK header structure. It describes the system
// and the performance data. The PERF_DATA_BLOCK structure is followed
// by a list of object information blocks (one per object). We use the
// counter index to retrieve object information.
// Under some cicumstances (cf. Q178887 for details) the RegQueryValueEx
// function may cause an Access Violation because of a buggy performance
// extension DLL such as SQL's.
__try { m_Stats.NtCPUUsage.cbPerfData = cbCounterData; while((lRet = RegQueryValueEx(HKEY_PERFORMANCE_DATA, szProcessorIndex, NULL, NULL, m_Stats.NtCPUUsage.pbyPerfData, &cbCounterData)) == ERROR_MORE_DATA) { m_Stats.NtCPUUsage.cbPerfData += BYTE_INCREMENT; LocalUnlock(m_Stats.NtCPUUsage.hPerfData); hPerfData = LocalReAlloc(m_Stats.NtCPUUsage.hPerfData, m_Stats.NtCPUUsage.cbPerfData, LMEM_MOVEABLE); if (!hPerfData) goto MyError1; m_Stats.NtCPUUsage.hPerfData = hPerfData; m_Stats.NtCPUUsage.pbyPerfData = (PBYTE)LocalLock(hPerfData); cbCounterData = m_Stats.NtCPUUsage.cbPerfData; } } __except(EXCEPTION_EXECUTE_HANDLER) { ERRORMESSAGE(("%s: Performance Registry Access Violation -> don't use perf counters for CPU measurements\r\n", _fx_)); goto MyError1; }
if (lRet != ERROR_SUCCESS) goto MyError1; else { // Each object information block contains a PERF_OBJECT_TYPE structure,
// which describes the performance data for the object. Look for the one
// that applies to CPU usage based on its index value.
pPerfDataBlock = (PPERF_DATA_BLOCK)m_Stats.NtCPUUsage.pbyPerfData; pPerfObjectType = (PPERF_OBJECT_TYPE)(m_Stats.NtCPUUsage.pbyPerfData + pPerfDataBlock->HeaderLength); for (int i = 0; i < (int)pPerfDataBlock->NumObjectTypes; i++) { if (pPerfObjectType->ObjectNameTitleIndex == m_Stats.NtCPUUsage.dwProcessorIndex) { // The PERF_OBJECT_TYPE structure is followed by a list of PERF_COUNTER_DEFINITION
// structures, one for each counter defined for the object. The list of PERF_COUNTER_DEFINITION
// structures is followed by a list of instance information blocks (one for each instance).
//
// Each instance information block contains a PERF_INSTANCE_DEFINITION structure and
// a PERF_COUNTER_BLOCK structure, followed by the data for each counter.
//
// Look for the counter defined for % processor time.
pPerfCounterDefinition = (PPERF_COUNTER_DEFINITION)((PBYTE)pPerfObjectType + pPerfObjectType->HeaderLength); for (int j = 0; j < (int)pPerfObjectType->NumCounters; j++) { if (pPerfCounterDefinition->CounterNameTitleIndex == m_Stats.NtCPUUsage.dwPercentProcessorIndex) { // Note: looking at the CounterType filed of the PERF_COUNTER_DEFINITION
// structure shows that the '% Processor Time' counter has the following properties:
// The counter data is a large integer (PERF_SIZE_LARGE set)
// The counter data is an increasing numeric value (PERF_TYPE_COUNTER set)
// The counter value should be divided by the elapsed time (PERF_COUNTER_RATE set)
// The time base units of the 100-nanosecond timer should be used as the base (PERF_TIMER_100NS set)
// The difference between the previous counter value and the current counter value is computed before proceeding (PERF_DELTA_BASE set)
// The display suffix is '%' (PERF_DISPLAY_PERCENT set)
// Save the number of object instances for the CPU counter, as well as the
// starting time.
m_Stats.NtCPUUsage.dwNumProcessors = pPerfObjectType->NumInstances; if (!(m_Stats.NtCPUUsage.pllCounterValue = (PLONGLONG)LocalAlloc(LMEM_FIXED, m_Stats.NtCPUUsage.dwNumProcessors * sizeof(LONGLONG)))) goto MyError1; m_Stats.NtCPUUsage.llPerfTime100nSec = *(PLONGLONG)&pPerfDataBlock->PerfTime100nSec;
pPerfInstanceDefinition = (PPERF_INSTANCE_DEFINITION)((PBYTE)pPerfObjectType + pPerfObjectType->DefinitionLength); for (int k = 0; k < pPerfObjectType->NumInstances; k++) { // Get a pointer to the PERF_COUNTER_BLOCK
pPerfCounterBlock = (PPERF_COUNTER_BLOCK)((PBYTE)pPerfInstanceDefinition + pPerfInstanceDefinition->ByteLength);
// This last offset steps us over any other counters to the one we need
m_Stats.NtCPUUsage.pllCounterValue[k] = *(PLONGLONG)((PBYTE)pPerfInstanceDefinition + pPerfInstanceDefinition->ByteLength + pPerfCounterDefinition->CounterOffset);
// Get to the next instance information block
pPerfInstanceDefinition = (PPERF_INSTANCE_DEFINITION)((PBYTE)pPerfInstanceDefinition + pPerfInstanceDefinition->ByteLength + pPerfCounterBlock->ByteLength); }
// We're done!
return; } else pPerfCounterDefinition = (PPERF_COUNTER_DEFINITION)((PBYTE)pPerfCounterDefinition + pPerfCounterDefinition->ByteLength); } break; } else pPerfObjectType = (PPERF_OBJECT_TYPE)((PBYTE)pPerfObjectType + pPerfObjectType->TotalByteLength); }
// If we get here, we haven't found the counters we were looking for
goto MyError2; } } } } } } } else { // Enable the collection of CPU performance data on Win 95-98 by starting the kernel stat server
if (RegOpenKeyEx(HKEY_DYN_DATA, "PerfStats\\StartSrv", NULL, KEY_READ, &m_Stats.hPerfKey) != ERROR_SUCCESS) m_Stats.hPerfKey = (HKEY)NULL; else { DWORD cbData = sizeof(DWORD); DWORD dwType; DWORD dwData;
if (RegQueryValueEx(m_Stats.hPerfKey, "KERNEL", NULL, &dwType, (LPBYTE)&dwData, &cbData) != ERROR_SUCCESS) { RegCloseKey(m_Stats.hPerfKey); m_Stats.hPerfKey = (HKEY)NULL; } else { RegCloseKey(m_Stats.hPerfKey);
// The kernel stat server is now started. Now start the CPUUsage data collection on the kernel stat server.
if (RegOpenKeyEx(HKEY_DYN_DATA, "PerfStats\\StartStat", NULL, KEY_READ, &m_Stats.hPerfKey) != ERROR_SUCCESS) m_Stats.hPerfKey = (HKEY)NULL; else { if (RegQueryValueEx(m_Stats.hPerfKey, "KERNEL\\CPUUsage", NULL, &dwType, (LPBYTE)&dwData, &cbData) != ERROR_SUCCESS) { RegCloseKey(m_Stats.hPerfKey); m_Stats.hPerfKey = (HKEY)NULL; } else { RegCloseKey(m_Stats.hPerfKey);
// The data and stat servers are now started. Let's get ready to collect actual data.
if (RegOpenKeyEx(HKEY_DYN_DATA, "PerfStats\\StatData", NULL, KEY_READ, &m_Stats.hPerfKey) != ERROR_SUCCESS) m_Stats.hPerfKey = (HKEY)NULL; } } } } }
return;
MyError2: if (m_Stats.NtCPUUsage.pllCounterValue) LocalFree(m_Stats.NtCPUUsage.pllCounterValue); m_Stats.NtCPUUsage.pllCounterValue = (PLONGLONG)NULL;MyError1: if (m_Stats.NtCPUUsage.hPerfData) { LocalUnlock(m_Stats.NtCPUUsage.hPerfData); LocalFree(m_Stats.NtCPUUsage.hPerfData); } m_Stats.NtCPUUsage.hPerfData = (HANDLE)NULL; m_Stats.NtCPUUsage.pbyPerfData = (PBYTE)NULL;MyError0: m_Stats.hPerfKey = (HKEY)NULL; }
/****************************************************************************
* @doc EXTERNAL QOSFUNC * * @func void | StopCPUUsageCollection | This function does all necessary * CPU usage data collection cleanup. * * @comm This function executes two different code paths: one for NT and one * for Win95-98. * * @devnote MSDN references: * Microsoft Knowledge Base, Article ID Q174631 * "HOWTO: Access the Performance Registry Under Windows 95" * * Microsoft Knowledge Base, Article ID Q107728 * "Retrieving Counter Data from the Registry" * * Also, used section "Platform SDK\Windows Base Services\Windows NT Features\Performance Data Helper" ***************************************************************************/void SendVideoStream::StopCPUUsageCollection(void){ DWORD dwType; DWORD cbData;
if (m_Stats.fWinNT) { if (m_Stats.NtCPUUsage.hPerfData) { LocalUnlock(m_Stats.NtCPUUsage.hPerfData); LocalFree(m_Stats.NtCPUUsage.hPerfData); } m_Stats.NtCPUUsage.hPerfData = (HANDLE)NULL; m_Stats.NtCPUUsage.pbyPerfData = (PBYTE)NULL; if (m_Stats.NtCPUUsage.pllCounterValue) LocalFree(m_Stats.NtCPUUsage.pllCounterValue); m_Stats.NtCPUUsage.pllCounterValue = (PLONGLONG)NULL; } else { if (m_Stats.hPerfKey) { // Close the data collection key
RegCloseKey(m_Stats.hPerfKey);
// Stop the CPUUsage data collection on the kernel stat server
if (RegOpenKeyEx(HKEY_DYN_DATA, "PerfStats\\StopStat", 0, KEY_READ, &m_Stats.hPerfKey) == ERROR_SUCCESS) { RegQueryValueEx(m_Stats.hPerfKey, "KERNEL\\CPUUsage", NULL, &dwType, NULL, &cbData); RegCloseKey(m_Stats.hPerfKey); }
// Stop the kernel stat server
if (RegOpenKeyEx(HKEY_DYN_DATA, "PerfStats\\StopSrv", 0, KEY_READ, &m_Stats.hPerfKey) == ERROR_SUCCESS) { RegQueryValueEx(m_Stats.hPerfKey, "KERNEL", NULL, &dwType, NULL, &cbData); RegCloseKey(m_Stats.hPerfKey); }
m_Stats.hPerfKey = (HKEY)NULL; } }}
/****************************************************************************
* @doc EXTERNAL QOSFUNC * * @func void | GetCPUUsage | This function does all necessary * initialization for CPU usage data collection. * * @parm PDWORD | [OUT] pdwOverallCPUUsage | Specifies a pointer to a DWORD to * receive the current CPU usage. * * @rdesc Returns TRUE on success, and FALSE otherwise. * * @comm This functions executes two different code paths: one for NT and one * for Win95-98. Note that we collect data on all CPUs on NT MP machines. * * @devnote MSDN references: * Microsoft Knowledge Base, Article ID Q174631 * "HOWTO: Access the Performance Registry Under Windows 95" * * Microsoft Knowledge Base, Article ID Q107728 * "Retrieving Counter Data from the Registry" * * Also, used section "Platform SDK\Windows Base Services\Windows NT Features\Performance Data Helper" ***************************************************************************/BOOL SendVideoStream::GetCPUUsage(PDWORD pdwOverallCPUUsage){
PPERF_DATA_BLOCK pPerfDataBlock; PPERF_OBJECT_TYPE pPerfObjectType; PPERF_COUNTER_DEFINITION pPerfCounterDefinition; PPERF_INSTANCE_DEFINITION pPerfInstanceDefinition; PPERF_COUNTER_BLOCK pPerfCounterBlock; DWORD dwType; DWORD cbData = sizeof(DWORD); DWORD cbTryCounterData; HANDLE hPerfData; LONGLONG llDeltaPerfTime100nSec; LONGLONG llDeltaCPUUsage = (LONGLONG)NULL; char szProcessorIndex[16]; long lRet;
FX_ENTRY("SendVideoStream::GetCPUUsage");
// We use the handle to the perf key as a way to figure out if we have been initialized correctly
if (m_Stats.hPerfKey && pdwOverallCPUUsage) { // Initialize result value
*pdwOverallCPUUsage = 0UL;
if (m_Stats.fWinNT && m_Stats.NtCPUUsage.pbyPerfData) { // Make a string out of the processor object index.
_ltoa(m_Stats.NtCPUUsage.dwProcessorIndex, szProcessorIndex, 10);
// Under some cicumstances (cf. Q178887 for details) the RegQueryValueEx
// function may cause an Access Violation because of a buggy performance
// extension DLL such as SQL's.
__try { // Read the performance data. Its size may change between each 'registry' access.
cbTryCounterData = m_Stats.NtCPUUsage.cbPerfData; while((lRet = RegQueryValueEx(HKEY_PERFORMANCE_DATA, szProcessorIndex, NULL, &dwType, m_Stats.NtCPUUsage.pbyPerfData, &cbTryCounterData)) == ERROR_MORE_DATA) { m_Stats.NtCPUUsage.cbPerfData += BYTE_INCREMENT; LocalUnlock(m_Stats.NtCPUUsage.hPerfData); hPerfData = LocalReAlloc(m_Stats.NtCPUUsage.hPerfData, m_Stats.NtCPUUsage.cbPerfData, LMEM_MOVEABLE); if (!hPerfData) goto MyError; m_Stats.NtCPUUsage.hPerfData = hPerfData; m_Stats.NtCPUUsage.pbyPerfData = (PBYTE)LocalLock(hPerfData); cbTryCounterData = m_Stats.NtCPUUsage.cbPerfData; } } __except(EXCEPTION_EXECUTE_HANDLER) { ERRORMESSAGE(("%s: Performance Registry Access Violation -> don't use perf counters for CPU measurements\r\n", _fx_)); goto MyError; }
if (lRet != ERROR_SUCCESS) goto MyError; else { // Read the PERF_DATA_BLOCK header structure. It describes the system
// and the performance data. The PERF_DATA_BLOCK structure is followed
// by a list of object information blocks (one per object). We use the
// counter index to retrieve object information.
//
// Each object information block contains a PERF_OBJECT_TYPE structure,
// which describes the performance data for the object. Look for the one
// that applies to CPU usage based on its index value.
pPerfDataBlock = (PPERF_DATA_BLOCK)m_Stats.NtCPUUsage.pbyPerfData; pPerfObjectType = (PPERF_OBJECT_TYPE)(m_Stats.NtCPUUsage.pbyPerfData + pPerfDataBlock->HeaderLength); for (int i = 0; i < (int)pPerfDataBlock->NumObjectTypes; i++) { if (pPerfObjectType->ObjectNameTitleIndex == m_Stats.NtCPUUsage.dwProcessorIndex) { // The PERF_OBJECT_TYPE structure is followed by a list of PERF_COUNTER_DEFINITION
// structures, one for each counter defined for the object. The list of PERF_COUNTER_DEFINITION
// structures is followed by a list of instance information blocks (one for each instance).
//
// Each instance information block contains a PERF_INSTANCE_DEFINITION structure and
// a PERF_COUNTER_BLOCK structure, followed by the data for each counter.
//
// Look for the counter defined for % processor time.
pPerfCounterDefinition = (PPERF_COUNTER_DEFINITION)((PBYTE)pPerfObjectType + pPerfObjectType->HeaderLength); for (int j = 0; j < (int)pPerfObjectType->NumCounters; j++) { if (pPerfCounterDefinition->CounterNameTitleIndex == m_Stats.NtCPUUsage.dwPercentProcessorIndex) { // Measure elapsed time
llDeltaPerfTime100nSec = *(PLONGLONG)&pPerfDataBlock->PerfTime100nSec - m_Stats.NtCPUUsage.llPerfTime100nSec;
// Save the timestamp for the next round
m_Stats.NtCPUUsage.llPerfTime100nSec = *(PLONGLONG)&pPerfDataBlock->PerfTime100nSec;
pPerfInstanceDefinition = (PPERF_INSTANCE_DEFINITION)((PBYTE)pPerfObjectType + pPerfObjectType->DefinitionLength); for (int k = 0; k < (int)pPerfObjectType->NumInstances && k < (int)m_Stats.NtCPUUsage.dwNumProcessors; k++) { // Get a pointer to the PERF_COUNTER_BLOCK
pPerfCounterBlock = (PPERF_COUNTER_BLOCK)((PBYTE)pPerfInstanceDefinition + pPerfInstanceDefinition->ByteLength);
// Get the CPU usage
llDeltaCPUUsage += *(PLONGLONG)((PBYTE)pPerfInstanceDefinition + pPerfInstanceDefinition->ByteLength + pPerfCounterDefinition->CounterOffset) - m_Stats.NtCPUUsage.pllCounterValue[k];
// Save the value for the next round
m_Stats.NtCPUUsage.pllCounterValue[k] = *(PLONGLONG)((PBYTE)pPerfInstanceDefinition + pPerfInstanceDefinition->ByteLength + pPerfCounterDefinition->CounterOffset);
// Go to the next instance information block
pPerfInstanceDefinition = (PPERF_INSTANCE_DEFINITION)((PBYTE)pPerfInstanceDefinition + pPerfInstanceDefinition->ByteLength + pPerfCounterBlock->ByteLength); }
// Do a bit of checking on the return value and change its unit to match QoS unit
if ((llDeltaPerfTime100nSec != (LONGLONG)0) && pPerfObjectType->NumInstances) if ((*pdwOverallCPUUsage = (DWORD)((LONGLONG)1000 - (LONGLONG)1000 * llDeltaCPUUsage / llDeltaPerfTime100nSec / (LONGLONG)pPerfObjectType->NumInstances)) > 1000UL) { *pdwOverallCPUUsage = 0UL; return FALSE; }
// We're done!
return TRUE; } else pPerfCounterDefinition = (PPERF_COUNTER_DEFINITION)((PBYTE)pPerfCounterDefinition + pPerfCounterDefinition->ByteLength); } break; } else pPerfObjectType = (PPERF_OBJECT_TYPE)((PBYTE)pPerfObjectType + pPerfObjectType->TotalByteLength); }
// If we get here, we haven't found the counters we were looking for
goto MyError; } } else { // Do a bit of checking on the return value and change its unit to match QoS unit.
if ((RegQueryValueEx(m_Stats.hPerfKey, "KERNEL\\CPUUsage", NULL, &dwType, (LPBYTE)pdwOverallCPUUsage, &cbData) == ERROR_SUCCESS) && (*pdwOverallCPUUsage > 0) && (*pdwOverallCPUUsage <= 100)) { *pdwOverallCPUUsage *= 10UL; return TRUE; } else { *pdwOverallCPUUsage = 0UL; return FALSE; } } } return FALSE;
MyError: if (m_Stats.NtCPUUsage.pllCounterValue) LocalFree(m_Stats.NtCPUUsage.pllCounterValue); m_Stats.NtCPUUsage.pllCounterValue = (PLONGLONG)NULL; if (m_Stats.NtCPUUsage.hPerfData) { LocalUnlock(m_Stats.NtCPUUsage.hPerfData); LocalFree(m_Stats.NtCPUUsage.hPerfData); } m_Stats.NtCPUUsage.hPerfData = (HANDLE)NULL; m_Stats.NtCPUUsage.pbyPerfData = (PBYTE)NULL; m_Stats.hPerfKey = (HKEY)NULL;
return FALSE;}
BOOL SendVideoStream::SetTargetRates(DWORD dwTargetFrameRate, DWORD dwTargetBitrate){ MMRESULT mmr; ASSERT(m_pVideoFilter);
mmr = m_pVideoFilter->SetTargetRates(dwTargetFrameRate, dwTargetBitrate >> 3); return (mmr == MMSYSERR_NOERROR);}
// dwFlags must be one of the following:
// CAPTURE_DIALOG_FORMAT
// CAPTURE_DIALOG_SOURCE
HRESULT __stdcall SendVideoStream::ShowDeviceDialog(DWORD dwFlags){ DWORD dwQueryFlags = 0; DWORD_PTR dwPropVal; HRESULT hr=DPR_INVALID_PARAMETER;
// the device must be "open" for us to display the dialog box
if (!(m_DPFlags & DPFLAG_CONFIGURED_SEND)) return DPR_NOT_CONFIGURED;
((VideoInControl*)m_InMedia)->GetProp(MC_PROP_VFW_DIALOGS, &dwPropVal); dwQueryFlags = (DWORD)dwPropVal;
if ((dwQueryFlags & CAPTURE_DIALOG_SOURCE) && (dwFlags & CAPTURE_DIALOG_SOURCE)) { hr = ((VideoInControl *)m_InMedia)->DisplayDriverDialog(GetActiveWindow(), CAPTURE_DIALOG_SOURCE); } else if ((dwQueryFlags & CAPTURE_DIALOG_FORMAT) && (dwFlags & CAPTURE_DIALOG_FORMAT)) { hr = ((VideoInControl *)m_InMedia)->DisplayDriverDialog(GetActiveWindow(), CAPTURE_DIALOG_FORMAT); }
return hr;
}
// will set dwFlags to one or more of the following bits
// CAPTURE_DIALOG_FORMAT
// CAPTURE_DIALOG_SOURCE
HRESULT __stdcall SendVideoStream::GetDeviceDialog(DWORD *pdwFlags){ HRESULT hr; DWORD_PTR dwPropVal;
hr = ((VideoInControl*)m_InMedia)->GetProp(MC_PROP_VFW_DIALOGS, &dwPropVal); *pdwFlags = (DWORD)dwPropVal; return hr;}
|
