void video_set_window_region(int id, long x, long y, long w, long h) {
get_video(videoStruct, id);
IVideoWindow *pVidWin = NULL;
videoStruct->pGraph->QueryInterface(IID_IVideoWindow, (void **)&pVidWin);
pVidWin->SetWindowPosition(x, y, w, h);
}
HRESULT
recChannel_t::unmap(void)
{
__CONTEXT("recChannel_t::unmap");
IBaseFilter * pFilter = NULL;
int hr =0;
hr = pGraph->FindFilterByName(L"Video Renderer",&pFilter);
if (!hr)
{
IVideoWindow *pWindowInfo = NULL;
hr = pFilter->QueryInterface(IID_IVideoWindow, (void **)&pWindowInfo);
errorCheck(hr);
pWindowInfo->put_Visible(OAFALSE);
pWindowInfo->put_AutoShow(OAFALSE);
pWindowInfo->Release();
}
pControl->StopWhenReady();
#ifdef _WINDOWS
if (fControl)
{
fControl->CWnd::ShowWindow(SW_HIDE);
}
#endif
mapping = false;
return 0;
}
HRESULT CMpcAudioRenderer::InitCoopLevel()
{
HRESULT hr = S_OK;
IVideoWindow* pVideoWindow = nullptr;
HWND hWnd = nullptr;
hr = m_pGraph->QueryInterface(IID_PPV_ARGS(&pVideoWindow));
if (SUCCEEDED(hr)) {
pVideoWindow->get_Owner((OAHWND*)&hWnd);
SAFE_RELEASE(pVideoWindow);
}
if (!hWnd) {
hWnd = GetTopWindow(nullptr);
}
ASSERT(hWnd != nullptr);
if (!m_useWASAPI) {
hr = m_pDS->SetCooperativeLevel(hWnd, DSSCL_PRIORITY);
} else if (hTask == nullptr) {
// Ask MMCSS to temporarily boost the thread priority
// to reduce glitches while the low-latency stream plays.
DWORD taskIndex = 0;
if (pfAvSetMmThreadCharacteristicsW) {
hTask = pfAvSetMmThreadCharacteristicsW(_T("Pro Audio"), &taskIndex);
TRACE(_T("CMpcAudioRenderer::InitCoopLevel Putting thread in higher priority for WASAPI mode (lowest latency)\n"));
hr = GetLastError();
if (hTask == nullptr) {
return hr;
}
}
}
return hr;
}
HRESULT CMpcAudioRenderer::InitCoopLevel()
{
HRESULT hr = S_OK;
IVideoWindow* pVideoWindow = NULL;
HWND hWnd = NULL;
CComBSTR bstrCaption;
hr = m_pGraph->QueryInterface (__uuidof(IVideoWindow), (void**) &pVideoWindow);
if (SUCCEEDED (hr))
{
pVideoWindow->get_Owner((long*)&hWnd);
SAFE_RELEASE (pVideoWindow);
}
if (!hWnd)
{
hWnd = GetTopWindow(NULL);
}
ATLASSERT(hWnd != NULL);
if (!useWASAPI)
hr = m_pDS->SetCooperativeLevel(hWnd, DSSCL_PRIORITY);
else if (hTask == NULL)
{
// Ask MMCSS to temporarily boost the thread priority
// to reduce glitches while the low-latency stream plays.
DWORD taskIndex = 0;
hTask = AvSetMmThreadCharacteristics(TEXT("Pro Audio"), &taskIndex);
hr=GetLastError();
if (hTask == NULL)
return hr;
}
return hr;
}
void video_set_fullscreen(int id, bool fullscreen) {
get_video(videoStruct, id);
IVideoWindow *pVidWin = NULL;
videoStruct->pGraph->QueryInterface(IID_IVideoWindow, (void **)&pVidWin);
pVidWin->put_FullScreenMode(-fullscreen);
}
void video_set_scale(int id, bool scale) {
get_video(videoStruct, id);
IVideoWindow *pVidWin = NULL;
videoStruct->pGraph->QueryInterface(IID_IVideoWindow, (void **)&pVidWin);
RECT rc;
if (scale) {
GetClientRect(enigma::hWnd, &rc);
} else {
//TODO: Finish me
}
pVidWin->SetWindowPosition(0, 0, rc.right, rc.bottom);
}
HRESULT
recChannel_t::set_window_title(char * newTitle)
{
__CONTEXT("recChannel_t::set_window_title");
int hr = 0;
memset(title,0,100);
strcpy(title,newTitle);
IVideoWindow * pWindow = NULL;
pGraph->QueryInterface(IID_IVideoWindow,(void **) &pWindow);
wchar_t wtext[100];
lText(wtext,title);
pWindow->put_Caption(wtext);
pWindow->Release();
return hr;
}
void play_movie( HWND hwnd )
{
IGraphBuilder *pGraph;
IMediaControl *pMediaControl;
IMediaEvent *pEvent;
IBasicVideo *pBasic;
IVideoWindow *pVidWin = NULL;
RECT grc;
long width, height;
CoInitialize(NULL);
// Create the filter graph manager and query for interfaces.
CoCreateInstance(
CLSID_FilterGraph,
NULL,
CLSCTX_INPROC_SERVER,
IID_IGraphBuilder,
(void **)&pGraph);
pGraph->QueryInterface(IID_IVideoWindow, (void **)&pVidWin);
pGraph->QueryInterface(IID_IMediaControl, (void **)&pMediaControl);
pGraph->QueryInterface(IID_IMediaEvent, (void **)&pEvent);
pGraph->QueryInterface(IID_IBasicVideo, (void**)&pBasic );
// Build the graph. IMPORTANT: Change string to a file on your system.
pGraph->RenderFile(L"e:\\alpha\\running.avi", NULL);
pBasic->GetVideoSize( &width, &height );
printf( "video frames are %d x %d\n", width, height );
pVidWin->put_Owner((OAHWND)hwnd);
pVidWin->put_WindowStyle(WS_CHILD | WS_CLIPSIBLINGS);
GetClientRect( hwnd, &grc );
pVidWin->SetWindowPosition(10, 10, width, height);
printf( "window is %d x %d\n", grc.right, grc.bottom );
// Run the graph.
pMediaControl->Run();
// Wait for completion.
long evCode;
pEvent->WaitForCompletion(INFINITE, &evCode);
pVidWin->put_Visible(OAFALSE);
pVidWin->put_Owner(NULL);
// Clean up.
pBasic->Release();
pVidWin->Release();
pMediaControl->Release();
pEvent->Release();
pGraph->Release();
CoUninitialize();
}
void CHogVideo::Cleanup()
{
this->UnHog();
if (m_pEvent)
{
IMediaEvent *pEvent = (IMediaEvent*)m_pEvent;
pEvent->Release();
m_pEvent = NULL;
}
if (m_pVideoWindow)
{
IVideoWindow *pVideoWindow = (IVideoWindow*)m_pVideoWindow;
pVideoWindow->Release();
m_pVideoWindow = NULL;
}
if (m_pMediaControl)
{
IMediaControl *pMediaControl = (IMediaControl*)m_pMediaControl;
pMediaControl->Release();
m_pMediaControl = NULL;
}
if (m_pGraph)
{
IGraphBuilder *pGraph = (IGraphBuilder*)m_pGraph;
pGraph->Release();
m_pGraph = NULL;
}
if (m_bCOMInitialized)
{
CoUninitialize();
m_bCOMInitialized = false;
}
}
int video_add(string fname) {
enigma::VideoStruct* videoStruct = new enigma::VideoStruct();
IGraphBuilder *pGraph = NULL;
// Initialize the COM library.
HRESULT hr = CoInitialize(NULL);
if (FAILED(hr))
{
MessageBox(NULL, "Failed to initialize COM library.", "ERROR", MB_ICONERROR | MB_OK);
return -1;
}
// Create the filter graph manager and query for interfaces.
hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
IID_IGraphBuilder, (void **)&pGraph);
if (FAILED(hr))
{
MessageBox(NULL, "Failed to create the Filter Graph Manager.", "ERROR", MB_ICONERROR | MB_OK);
return -1;
}
// Build the graph.
hr = pGraph->RenderFile(std::wstring(fname.begin(), fname.end()).c_str(), NULL);
IVideoWindow *pVidWin = NULL;
pGraph->QueryInterface(IID_IVideoWindow, (void **)&pVidWin);
pVidWin->put_Owner((OAHWND)enigma::hWnd);
pVidWin->put_WindowStyle(WS_CHILD | WS_CLIPSIBLINGS);
videoStruct->pGraph = pGraph;
enigma::videoStructs.push_back(videoStruct);
return enigma::videoStructs.size() - 1;
}
bool CHogVideo::Hog()
{
if (!m_pGraph && !m_pMediaControl && !m_pVideoWindow)
return false;
this->UnHog();
HRESULT hr = NULL;
IGraphBuilder *pGraph = (IGraphBuilder*) m_pGraph;
IMediaControl *pMediaControl = (IMediaControl*) m_pMediaControl;
IVideoWindow *pVideoWindow = (IVideoWindow*) m_pVideoWindow;
// Build the graph. IMPORTANT: Change string to a file on your system.
hr = pGraph->RenderFile(m_wszFilename, NULL);
if (SUCCEEDED(hr))
{
// Run the graph.
hr = pMediaControl->Run();
// Hide the window
pVideoWindow->put_WindowState(SW_HIDE);
pVideoWindow->put_AutoShow(OAFALSE);
pVideoWindow->put_Visible(OAFALSE);
pVideoWindow->put_Top(-100);
pVideoWindow->put_Left(-100);
pVideoWindow->put_Width(0);
pVideoWindow->put_Height(0);
if (SUCCEEDED(hr))
{
// Hog the resource.
pMediaControl->Pause();
return true;
}
else
return false;
}
else
return false;
}
/*
* Class: sage_DShowMediaPlayer
* Method: setVideoHWND0
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sage_DShowMediaPlayer_setVideoHWND0
(JNIEnv *env, jobject jo, jlong dataPtr, jlong vhwnd)
{
CPlayerData* playData = (CPlayerData*) dataPtr;
IGraphBuilder* pGraph = playData->GetGraph();
IVideoWindow* pVW = NULL;
HRESULT hr = pGraph->QueryInterface(IID_IVideoWindow, (void**)&pVW);
if (SUCCEEDED(hr))
{
slog((env, "DShowPlayer setVideoHWND(%d)\r\n", (int) vhwnd));
pVW->put_AutoShow(OAFALSE);
pVW->put_Owner((OAHWND)vhwnd);
pVW->put_MessageDrain((OAHWND)vhwnd);
pVW->put_WindowStyle(WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
pVW->put_Visible(OATRUE);
// We do all of our own aspect ratio control, so don't let DShow do any for us
// by setting the aspect ratio mode on the video rendering filter's pin
IEnumFilters *pEnum = NULL;
hr = pGraph->EnumFilters(&pEnum);
if (SUCCEEDED(hr))
{
IBaseFilter *currFilt = NULL;
while (pEnum->Next(1, &currFilt, NULL) == S_OK)
{
IPin *overlayPin = NULL;
hr = currFilt->FindPin(L"Input0", &overlayPin);
if (SUCCEEDED(hr))
{
// Right pin name, let's see if it's overlay
IMixerPinConfig *pOverlayMix = NULL;
hr = overlayPin->QueryInterface(IID_IMixerPinConfig, (void**)&pOverlayMix);
if (SUCCEEDED(hr))
{
pOverlayMix->SetAspectRatioMode(AM_ARMODE_STRETCHED);
SAFE_RELEASE(pOverlayMix);
}
SAFE_RELEASE(overlayPin);
}
SAFE_RELEASE(currFilt);
}
SAFE_RELEASE(pEnum);
hr = S_OK;
}
SAFE_RELEASE(pVW);
}
HTESTPRINT(hr);
}
void Video::PlayMovie(string path)
{
IGraphBuilder *pGraph = NULL;
IMediaControl *pControl = NULL;
IMediaEvent *pEvent = NULL;
IVideoWindow *pVideo = NULL;
// Initialize the COM library.
CoInitialize(NULL);
// Create the filter graph manager and query for interfaces.
CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, IID_IGraphBuilder, (void **)&pGraph);
// Build the graph
int len;
int slength = (int)path.length() + 1;
len = MultiByteToWideChar(CP_ACP, 0, path.c_str(), slength, 0, 0);
wchar_t* buf = new wchar_t[len];
MultiByteToWideChar(CP_ACP, 0, path.c_str(), slength, buf, len);
std::wstring r(buf);
delete[] buf;
pGraph->RenderFile(LPCWSTR(r.c_str()), NULL);
// set the owner window
pGraph->QueryInterface(IID_IVideoWindow, (void **) &pVideo);
pVideo->put_Owner((OAHWND)window);
pVideo->put_WindowStyle( WS_CHILD );
pVideo->put_Left(0);
pVideo->put_Top(0);
pGraph->QueryInterface(IID_IMediaControl, (void **)&pControl);
pGraph->QueryInterface(IID_IMediaEvent, (void **)&pEvent);
pControl->Run();
long evCode;
pEvent->WaitForCompletion(-1, &evCode);
// release controls
pControl->Release();
pEvent->Release();
pGraph->Release();
pVideo->Release();
CoUninitialize();
}
void
recChannel_t::refresh_channel(bool all)
{
__CONTEXT("recChannel_t::refresh_channel");
pControl->Stop();
#ifdef _WINDOWS
if (fControl)
{
fControl->CWnd::ShowWindow(SW_HIDE);
}
#endif
if (pSource!=NULL)
{
pGraph->RemoveFilter(pSource);
camInfo->setFree(true);
}
// Enumerate the filters in the graph.
IEnumFilters *pEnum = NULL;
int hr = pGraph->EnumFilters(&pEnum);
if (SUCCEEDED(hr))
{
IBaseFilter *pFilter = NULL;
while (S_OK == pEnum->Next(1, &pFilter, NULL))
{
CLSID filterId;
pFilter->GetClassID(&filterId);
if(filterId == CLSID_VideoRenderer ||
filterId == CLSID_VideoMixingRenderer)
{
IVideoWindow *pWindowInfo = NULL;
pFilter->QueryInterface(IID_IVideoWindow, (void **)&pWindowInfo);
pWindowInfo->get_Height(&windowInfo.heigth);
pWindowInfo->get_Left(&windowInfo.left);
pWindowInfo->get_Top(&windowInfo.top);
pWindowInfo->get_Width(&windowInfo.width);
pWindowInfo->put_AutoShow(OAFALSE);
pWindowInfo->put_Visible(OAFALSE);
if (all)
{
pGraph->RemoveFilter(pFilter);
pFilter->Release();
pEnum->Reset();
pWindowInfo->Release();
}
}else{
pGraph->RemoveFilter(pFilter);
pFilter->Release();
pEnum->Reset();
}
}
pEnum->Release();
}
if (all)
{
pGraph->Release();
hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
IID_IGraphBuilder, (void **)&pGraph);
errorCheck(hr);
}
hr = pGraph->QueryInterface(IID_IMediaControl, (void **)&pControl);
errorCheck(hr);
}
HRESULT
OnTapiEvent(
TAPI_EVENT TapiEvent,
IDispatch * pEvent
)
{
HRESULT hr;
switch ( TapiEvent )
{
case TE_CALLNOTIFICATION:
{
//
// TE_CALLNOTIFICATION means that the application is being notified
// of a new call.
//
// Note that we don't answer to call at this point. The application
// should wait for a CS_OFFERING CallState message before answering
// the call.
//
ITCallNotificationEvent * pNotify;
hr = pEvent->QueryInterface( IID_ITCallNotificationEvent, (void **)&pNotify );
if (S_OK != hr)
{
DoMessage( L"Incoming call, but failed to get the interface");
}
else
{
CALL_PRIVILEGE cp;
ITCallInfo * pCall;
//
// get the call
//
hr = pNotify->get_Call( &pCall );
pNotify->Release();
if ( SUCCEEDED(hr) )
{
//
// check to see if we own the call
//
hr = pCall->get_Privilege( &cp );
if ( FAILED(hr) || (CP_OWNER != cp) )
{
//
// just ignore it if we don't own it
//
pCall->Release();
pEvent->Release(); // we addrefed it CTAPIEventNotification::Event()
return S_OK;
}
//
// Get the ITBasicCallControl interface
//
//
// If we're already in a call, disconnect the new call. Otherwise,
// save it in our global variable.
//
ITBasicCallControl * pCallControl;
hr = pCall->QueryInterface( IID_ITBasicCallControl,
(void**)&pCallControl );
pCall->Release();
if ( SUCCEEDED(hr) )
{
if (gpCall == NULL)
{
gpCall = pCallControl;
//
// update UI
//
EnableButton( IDC_ANSWER );
DisableButton( IDC_DISCONNECT );
SetStatusMessage(L"Incoming Owner Call");
}
else
{
//
// Reject this call since we're already in a call
//
hr = pCallControl->Disconnect(DC_REJECTED);
pCallControl->Release();
if (FAILED(hr))
{
break;
}
}
}
}
}
break;
}
case TE_CALLSTATE:
{
// TE_CALLSTATE is a call state event. pEvent is
// an ITCallStateEvent
CALL_STATE cs;
ITCallStateEvent * pCallStateEvent;
ITCallInfo * pCall;
ITBasicCallControl * pCallControl;
// Get the interface
hr = pEvent->QueryInterface( IID_ITCallStateEvent, (void **)&pCallStateEvent );
if ( FAILED(hr) )
{
break;
}
// get the CallInfo interface
hr = pCallStateEvent->get_Call( &pCall );
if ( FAILED(hr) )
{
pCallStateEvent->Release();
break;
}
//get the ITBasicCallControl interface and compare it to our existing call
hr = pCall->QueryInterface( IID_ITBasicCallControl,(void**)&pCallControl );
pCall->Release();
if (FAILED(hr))
{
pCallStateEvent->Release();
break;
}
//ignore call state events for other calls
if (pCallControl != gpCall)
{
pCallControl->Release();
pCallStateEvent->Release();
break;
}
pCallControl->Release();
//
// This is a call state event for our call
//
// get the CallState that we are being notified of.
hr = pCallStateEvent->get_State( &cs );
// Release the interface
pCallStateEvent->Release();
if ( FAILED(hr) )
{
break;
}
// if it's offering, update our UI
if (CS_OFFERING == cs)
{
if (gfAutoAnswer)
{
PostMessage(ghDlg, WM_COMMAND, IDC_ANSWER, 0);
}
else
{
SetStatusMessage(L"Click the Answer button");
}
}
else if (CS_DISCONNECTED == cs)
{
PostMessage(ghDlg, WM_COMMAND, IDC_DISCONNECTED, 0);
}
else if (CS_CONNECTED == cs)
{
// nothing to do -- we handle connection synchronously
}
break;
}
case TE_CALLMEDIA:
{
// TE_CALLMEDIA is a media event. pEvent is
// an ITCallMediaEvent
CALL_MEDIA_EVENT cme;
ITCallMediaEvent * pCallMediaEvent;
// Get the interface
hr = pEvent->QueryInterface( IID_ITCallMediaEvent, (void **)&pCallMediaEvent );
if ( FAILED(hr) )
{
break;
}
// get the CALL_MEDIA_EVENT that we are being notified of.
hr = pCallMediaEvent->get_Event( &cme );
if ( SUCCEEDED(hr) )
{
switch ( cme )
{
case CME_STREAM_NOT_USED:
case CME_STREAM_INACTIVE:
case CME_NEW_STREAM:
break;
case CME_STREAM_FAIL:
DoMessage( L"Call media event: stream failed");
break;
case CME_TERMINAL_FAIL:
DoMessage( L"Call media event: terminal failed");
break;
case CME_STREAM_ACTIVE:
{
//
// Find out if this stream has a video render terminal. If not,
// we don't need to do anything with this stream. Also note
// if this is the video capture stream or the video render
// stream.
//
ITTerminal * pTerminal;
BOOL fRenderStream;
hr = GetVideoRenderTerminalFromStreamEvent(
pCallMediaEvent,
&pTerminal,
&fRenderStream
);
if ( SUCCEEDED(hr) )
{
// Get the video window interface for the terminal
IVideoWindow *pVideoWindow = NULL;
hr = pTerminal->QueryInterface( IID_IVideoWindow, (void**)&pVideoWindow );
pTerminal->Release();
if ( SUCCEEDED(hr) )
{
// Put this window in our dialog
HostWindow(pVideoWindow, fRenderStream);
pVideoWindow->Release();
}
}
break;
}
default:
break;
}
}
// We no longer need this interface.
pCallMediaEvent->Release();
break;
}
default:
break;
}
pEvent->Release(); // we addrefed it CTAPIEventNotification::Event()
return S_OK;
}
void Video::play( char *fileName, DWORD )
{
WCHAR wPath[100];
HRESULT hr;
IMediaControl *pMC;
if(!init_success)
return;
MultiByteToWideChar( CP_ACP, 0, fileName, -1, wPath, 100 );
if( (hr = pGraph->RenderFile(wPath, NULL)) == 0)
{
// use full screen video interface
// try to change display mode
IVideoWindow *iVideoWindow = NULL;
if( (hr = pGraph->QueryInterface(IID_IVideoWindow, (void **) &iVideoWindow)) == 0)
{
#ifdef CREATE_DUMMY_WINDOW
if(hwnd)
{
HRESULT hr2 = iVideoWindow->put_MessageDrain((OAHWND) hwnd);
hr2 = 0;
}
#endif
#ifdef FULL_SCREEN_VIDEO
IFilter *iFilter;
if( pGraph->FindFilterByName(L"Video Renderer", &iFilter) == 0)
{
IBasicVideo *iBasicVideo;
if( iFilter->QueryInterface(IID_IBasicVideo, (void **)&iBasicVideo) == 0)
{
IFullScreenVideo *iFullScreenVideo;
IDirectDrawVideo *iDirectDrawVideo;
if( iFilter->QueryInterface(IID_IFullScreenVideo, (void **)&iFullScreenVideo) == 0)
{
iFullScreenVideo->Release();
}
else if( iFilter->QueryInterface(IID_IDirectDrawVideo, (void **)&iDirectDrawVideo) == 0)
{
HRESULT hr2;
hr2 = iDirectDrawVideo->UseWhenFullScreen(OATRUE);
iDirectDrawVideo->Release();
}
iBasicVideo->Release();
}
iFilter->Release();
}
hr=iVideoWindow->put_FullScreenMode(OATRUE);
#endif
/* // code to find all filter in the filter graph
{
IEnumFilters *iEnumFilters;
pGraph->EnumFilters(&iEnumFilters);
ULONG filterCount = 16;
IFilter *iFilters[16];
iEnumFilters->Next(filterCount, iFilters, &filterCount);
for( ULONG j = 0; j < filterCount; ++j )
{
FILTER_INFO filterInfo;
iFilters[j]->QueryFilterInfo(&filterInfo);
filterInfo.pGraph->Release();
iFilters[j]->Release();
}
iEnumFilters->Release();
}*/
iVideoWindow->HideCursor(OATRUE);
iVideoWindow->put_Visible( OAFALSE );
iVideoWindow->put_AutoShow( OAFALSE );
LONG windowStyle;
iVideoWindow->get_WindowStyle( &windowStyle);
windowStyle &= ~WS_BORDER & ~WS_CAPTION & ~WS_SIZEBOX & ~WS_THICKFRAME &
~WS_HSCROLL & ~WS_VSCROLL & ~WS_VISIBLE;
iVideoWindow->put_WindowStyle( windowStyle);
}
else
iVideoWindow = NULL;
if( (hr = pGraph->QueryInterface(IID_IMediaControl, (void **) &pMC)) == 0)
{
pMC->Run(); // sometimes it returns 1, but still ok
state = PLAYING;
pMC->Release();
}
if( iVideoWindow )
{
iVideoWindow->put_Visible( OAFALSE );
LONG windowStyle;
iVideoWindow->get_WindowStyle( &windowStyle);
windowStyle &= ~WS_BORDER & ~WS_CAPTION & ~WS_SIZEBOX & ~WS_THICKFRAME &
~WS_HSCROLL & ~WS_VSCROLL & ~WS_VISIBLE;
iVideoWindow->put_WindowStyle( windowStyle);
LONG maxWidth;
LONG maxHeight;
hr=iVideoWindow->GetMaxIdealImageSize( &maxWidth, &maxHeight);
#ifdef FULL_SCREEN_VIDEO
#else
iVideoWindow->put_BorderColor( RGB(0,0,0) );
iVideoWindow->put_WindowState(SW_MAXIMIZE);
IBaseFilter *iFilter;
if( pGraph->FindFilterByName((const WCHAR *)L"Video Renderer", &iFilter) == 0)
{
IBasicVideo *iBasicVideo;
if( iFilter->QueryInterface(IID_IBasicVideo, (void **)&iBasicVideo) == 0)
{
LONG screenWidth;
LONG screenHeight;
LONG videoWidth;
LONG videoHeight;
if( iVideoWindow->get_Width(&screenWidth) == 0 &&
iVideoWindow->get_Height(&screenHeight) == 0 &&
iBasicVideo->GetVideoSize(&videoWidth, &videoHeight) == 0)
{
// zoom in by 2 if possible
if( screenWidth >= videoWidth * 2 &&
screenHeight >= videoHeight * 2)
{
videoWidth *= 2;
videoHeight *= 2;
}
// center the video client area
iBasicVideo->SetDestinationPosition(
(screenWidth-videoWidth)/2, (screenHeight-videoHeight)/2,
videoWidth, videoHeight);
}
iBasicVideo->Release();
}
iFilter->Release();
}
#endif
iVideoWindow->HideCursor(OATRUE);
iVideoWindow->SetWindowForeground(OATRUE);
}
if(iVideoWindow)
{
iVideoWindow->Release();
iVideoWindow = NULL;
}
}
if( hr && !skip_on_fail_flag)
err.run("video.play error %d", hr );
}
virtual HRESULT SetVideoPosition(RECT *pSrc, RECT *pDst, BOOL hideMouse)
{
if (!m_pGraph) return E_FAIL;
if (m_pVmrAllocator && pSrc && pDst)
{
// Update our VMR9 window positioning for mouse events to work (this may only
// work on XP, I think it will still fail on 2K)
m_pVmrAllocator->UpdateVideoPosition(pSrc, pDst);
return S_OK;
}
IBasicVideo* pBV = NULL;
HRESULT hr = m_pGraph->QueryInterface(IID_IBasicVideo, (void**)&pBV);
if (SUCCEEDED(hr))
{
/* long nativeWidth;
hr = pBV->get_VideoWidth(&nativeWidth);
if (FAILED(hr))
{
SAFE_RELEASE(pBV);
// no video is present
return;
}
*/
long srcTop, srcLeft, srcWidth, srcHeight;
pBV->GetSourcePosition(&srcLeft, &srcTop, &srcWidth, &srcHeight);
pBV->GetDestinationPosition(&srcLeft, &srcTop, &srcWidth, &srcHeight);
if (pSrc)
{
pBV->SetSourcePosition(pSrc->left, pSrc->top, pSrc->right - pSrc->left, pSrc->bottom - pSrc->top);
}
else
{
pBV->SetDefaultSourcePosition();
}
if (pDst)
{
pBV->SetDestinationPosition(pDst->left, pDst->top, pDst->right - pDst->left, pDst->bottom - pDst->top);
}
else
{
pBV->SetDefaultDestinationPosition();
}
SAFE_RELEASE(pBV);
IVideoWindow* pVW = NULL;
hr = m_pGraph->QueryInterface(IID_IVideoWindow, (void**)&pVW);
if (SUCCEEDED(hr))
{
OAHWND vidWinHWND;
hr = pVW->get_Owner(&vidWinHWND);
if (SUCCEEDED(hr))
{
RECT grc;
GetClientRect((HWND)vidWinHWND, &grc);
pVW->SetWindowPosition(0, 0, grc.right, grc.bottom);
}
pVW->HideCursor(hideMouse == JNI_TRUE ? OATRUE : OAFALSE);
SAFE_RELEASE(pVW);
}
}
return S_OK;
}
HRESULT CRTCAVSession::ShowVideo(RTC_VIDEO_DEVICE enDevice, BOOL fShow)
{
IVideoWindow * pVid = NULL;
IRTCClient * pClient = NULL;
long lMediaCaps = 0;
HWND hWnd = NULL;
HRESULT hr;
hr = m_pSession->get_Client(&pClient);
if (FAILED(hr))
{
// get_Client failed
return hr;
}
// Get the media capabilities
hr = pClient->get_MediaCapabilities(&lMediaCaps);
if (FAILED(hr))
{
// get_MediaCapabilities failed
SAFE_RELEASE(pClient);
return hr;
}
hr = pClient->get_IVideoWindow(
enDevice, &pVid);
SAFE_RELEASE(pClient);
if (FAILED(hr))
{
// get_IVideoWindow failed
return hr;
}
if (enDevice == RTCVD_PREVIEW)
{
// Determine whether to show the preview video
fShow = fShow && (lMediaCaps & RTCMT_VIDEO_SEND);
m_fShowPrev = fShow;
hWnd = m_hPrevVideoParent;
// Show or hide the preview video preview parent window
ShowWindow(m_hPrevVideoParent, fShow ? SW_SHOW : SW_HIDE);
// Set window region for receive video parent window
HRGN hRegion;
if (fShow)
{
// Set the receive video region to make room for the preview
// video picture-in-picture
POINT rgPoints[6] =
{ 0, 0,
0, m_lRecvHeight,
m_lRecvWidth - m_lPrevWidth, m_lRecvHeight,
m_lRecvWidth - m_lPrevWidth, m_lRecvHeight - m_lPrevHeight,
m_lRecvWidth, m_lRecvHeight - m_lPrevHeight,
m_lRecvWidth, 0
};
hRegion = CreatePolygonRgn(rgPoints, 6, ALTERNATE);
}
else
{
// Set the receive video region to be rectangular
hRegion = CreateRectRgn(0, 0, m_lRecvWidth, m_lRecvHeight);
}
SetWindowRgn(m_hRecvVideoParent, hRegion, TRUE);
}
else
{
// Determine whether to show the receive video
fShow = fShow && (lMediaCaps & RTCMT_VIDEO_RECEIVE);
m_fShowRecv = fShow;
hWnd = m_hRecvVideoParent;
// Always show the video receive parent window
ShowWindow(m_hRecvVideoParent, SW_SHOW);
}
if ( fShow == TRUE )
{
// Set the video window style
pVid->put_WindowStyle( WS_CHILD |
WS_CLIPCHILDREN |
WS_CLIPSIBLINGS );
// Set the parent window for the video window
pVid->put_Owner( (OAHWND)hWnd );
RECT rc;
GetClientRect(hWnd, &rc );
// Position the video window
pVid->SetWindowPosition(
rc.left,
rc.top,
rc.right,
rc.bottom
);
// Make the video window visible
pVid->put_Visible(-1);
}
SAFE_RELEASE(pVid);
return S_OK;
}
