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