| /* |
| * Video Renderer (Fullscreen and Windowed using Direct Draw) |
| * |
| * Copyright 2004 Christian Costa |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include "config.h" |
| |
| #define NONAMELESSSTRUCT |
| #define NONAMELESSUNION |
| #include "quartz_private.h" |
| #include "control_private.h" |
| #include "pin.h" |
| |
| #include "uuids.h" |
| #include "vfwmsgs.h" |
| #include "amvideo.h" |
| #include "windef.h" |
| #include "winbase.h" |
| #include "dshow.h" |
| #include "evcode.h" |
| #include "strmif.h" |
| #include "ddraw.h" |
| #include "dvdmedia.h" |
| |
| #include <assert.h> |
| #include "wine/unicode.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(quartz); |
| |
| static BOOL wnd_class_registered = FALSE; |
| |
| static const WCHAR wcsInputPinName[] = {'i','n','p','u','t',' ','p','i','n',0}; |
| |
| static const IBaseFilterVtbl VideoRenderer_Vtbl; |
| static const IUnknownVtbl IInner_VTable; |
| static const IBasicVideoVtbl IBasicVideo_VTable; |
| static const IVideoWindowVtbl IVideoWindow_VTable; |
| static const IPinVtbl VideoRenderer_InputPin_Vtbl; |
| static const IAMFilterMiscFlagsVtbl IAMFilterMiscFlags_Vtbl; |
| static const IQualityControlVtbl VideoRenderer_QualityControl_Vtbl = { |
| QualityControlImpl_QueryInterface, |
| QualityControlImpl_AddRef, |
| QualityControlImpl_Release, |
| QualityControlImpl_Notify, |
| QualityControlImpl_SetSink |
| }; |
| |
| typedef struct VideoRendererImpl |
| { |
| BaseFilter filter; |
| const IBasicVideoVtbl * IBasicVideo_vtbl; |
| const IVideoWindowVtbl * IVideoWindow_vtbl; |
| const IUnknownVtbl * IInner_vtbl; |
| const IAMFilterMiscFlagsVtbl *IAMFilterMiscFlags_vtbl; |
| IUnknown *seekthru_unk; |
| QualityControlImpl qcimpl; |
| |
| BaseInputPin *pInputPin; |
| |
| BOOL init; |
| HANDLE hThread; |
| HANDLE blocked; |
| |
| DWORD ThreadID; |
| HANDLE hEvent; |
| BOOL ThreadResult; |
| HWND hWnd; |
| HWND hWndMsgDrain; |
| HWND hWndOwner; |
| BOOL AutoShow; |
| RECT SourceRect; |
| RECT DestRect; |
| RECT WindowPos; |
| LONG VideoWidth; |
| LONG VideoHeight; |
| IUnknown * pUnkOuter; |
| BOOL bUnkOuterValid; |
| BOOL bAggregatable; |
| LONG WindowStyle; |
| |
| /* During pause we can hold a single sample, for use in GetCurrentImage */ |
| IMediaSample *sample_held; |
| } VideoRendererImpl; |
| |
| static LRESULT CALLBACK VideoWndProcW(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) |
| { |
| VideoRendererImpl* pVideoRenderer = (VideoRendererImpl*)GetWindowLongPtrW(hwnd, 0); |
| LPRECT lprect = (LPRECT)lParam; |
| |
| if (pVideoRenderer && pVideoRenderer->hWndMsgDrain) |
| { |
| switch(uMsg) |
| { |
| case WM_KEYDOWN: |
| case WM_KEYUP: |
| case WM_LBUTTONDBLCLK: |
| case WM_LBUTTONDOWN: |
| case WM_LBUTTONUP: |
| case WM_MBUTTONDBLCLK: |
| case WM_MBUTTONDOWN: |
| case WM_MBUTTONUP: |
| case WM_MOUSEACTIVATE: |
| case WM_MOUSEMOVE: |
| case WM_NCLBUTTONDBLCLK: |
| case WM_NCLBUTTONDOWN: |
| case WM_NCLBUTTONUP: |
| case WM_NCMBUTTONDBLCLK: |
| case WM_NCMBUTTONDOWN: |
| case WM_NCMBUTTONUP: |
| case WM_NCMOUSEMOVE: |
| case WM_NCRBUTTONDBLCLK: |
| case WM_NCRBUTTONDOWN: |
| case WM_NCRBUTTONUP: |
| case WM_RBUTTONDBLCLK: |
| case WM_RBUTTONDOWN: |
| case WM_RBUTTONUP: |
| PostMessageW(pVideoRenderer->hWndMsgDrain, uMsg, wParam, lParam); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| switch(uMsg) |
| { |
| case WM_SIZING: |
| /* TRACE("WM_SIZING %d %d %d %d\n", lprect->left, lprect->top, lprect->right, lprect->bottom); */ |
| SetWindowPos(hwnd, NULL, lprect->left, lprect->top, lprect->right - lprect->left, lprect->bottom - lprect->top, SWP_NOZORDER); |
| GetClientRect(hwnd, &pVideoRenderer->DestRect); |
| TRACE("WM_SIZING: DestRect=(%d,%d),(%d,%d)\n", |
| pVideoRenderer->DestRect.left, |
| pVideoRenderer->DestRect.top, |
| pVideoRenderer->DestRect.right - pVideoRenderer->DestRect.left, |
| pVideoRenderer->DestRect.bottom - pVideoRenderer->DestRect.top); |
| return TRUE; |
| case WM_SIZE: |
| TRACE("WM_SIZE %d %d\n", LOWORD(lParam), HIWORD(lParam)); |
| GetClientRect(hwnd, &pVideoRenderer->DestRect); |
| TRACE("WM_SIZING: DestRect=(%d,%d),(%d,%d)\n", |
| pVideoRenderer->DestRect.left, |
| pVideoRenderer->DestRect.top, |
| pVideoRenderer->DestRect.right - pVideoRenderer->DestRect.left, |
| pVideoRenderer->DestRect.bottom - pVideoRenderer->DestRect.top); |
| return TRUE; |
| default: |
| return DefWindowProcW(hwnd, uMsg, wParam, lParam); |
| } |
| return 0; |
| } |
| |
| static const WCHAR classnameW[] = { 'W','i','n','e',' ','A','c','t','i','v','e','M','o','v','i','e',' ','C','l','a','s','s',0 }; |
| static const WCHAR windownameW[] = { 'A','c','t','i','v','e','M','o','v','i','e',' ','W','i','n','d','o','w',0 }; |
| |
| static BOOL video_register_windowclass(void) { |
| WNDCLASSW winclass; |
| if (wnd_class_registered) |
| return 1; |
| |
| winclass.style = 0; |
| winclass.lpfnWndProc = VideoWndProcW; |
| winclass.cbClsExtra = 0; |
| winclass.cbWndExtra = sizeof(VideoRendererImpl*); |
| winclass.hInstance = NULL; |
| winclass.hIcon = NULL; |
| winclass.hCursor = NULL; |
| winclass.hbrBackground = GetStockObject(BLACK_BRUSH); |
| winclass.lpszMenuName = NULL; |
| winclass.lpszClassName = classnameW; |
| if (!RegisterClassW(&winclass)) |
| { |
| ERR("Unable to register window class: %u\n", GetLastError()); |
| return FALSE; |
| } |
| wnd_class_registered = 1; |
| return 1; |
| } |
| |
| void video_unregister_windowclass(void) { |
| if (!wnd_class_registered) |
| return; |
| UnregisterClassW(classnameW, NULL); |
| } |
| |
| static BOOL CreateRenderingWindow(VideoRendererImpl* This) |
| { |
| TRACE("(%p)->()\n", This); |
| if (!video_register_windowclass()) |
| return FALSE; |
| This->hWnd = CreateWindowExW(0, classnameW, windownameW, WS_SIZEBOX, |
| CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, |
| NULL, NULL, NULL); |
| |
| if (!This->hWnd) |
| { |
| ERR("Unable to create window\n"); |
| return FALSE; |
| } |
| |
| SetWindowLongPtrW(This->hWnd, 0, (LONG_PTR)This); |
| |
| return TRUE; |
| } |
| |
| static DWORD WINAPI MessageLoop(LPVOID lpParameter) |
| { |
| VideoRendererImpl* This = lpParameter; |
| MSG msg; |
| BOOL fGotMessage; |
| |
| TRACE("Starting message loop\n"); |
| |
| if (!CreateRenderingWindow(This)) |
| { |
| This->ThreadResult = FALSE; |
| SetEvent(This->hEvent); |
| return 0; |
| } |
| |
| This->ThreadResult = TRUE; |
| SetEvent(This->hEvent); |
| |
| while ((fGotMessage = GetMessageW(&msg, NULL, 0, 0)) != 0 && fGotMessage != -1) |
| { |
| TranslateMessage(&msg); |
| DispatchMessageW(&msg); |
| } |
| |
| TRACE("End of message loop\n"); |
| |
| return msg.wParam; |
| } |
| |
| static BOOL CreateRenderingSubsystem(VideoRendererImpl* This) |
| { |
| This->hEvent = CreateEventW(NULL, TRUE, FALSE, NULL); |
| if (!This->hEvent) |
| return FALSE; |
| |
| This->hThread = CreateThread(NULL, 0, MessageLoop, This, 0, &This->ThreadID); |
| if (!This->hThread) |
| { |
| CloseHandle(This->hEvent); |
| return FALSE; |
| } |
| |
| WaitForSingleObject(This->hEvent, INFINITE); |
| |
| if (!This->ThreadResult) |
| { |
| CloseHandle(This->hEvent); |
| CloseHandle(This->hThread); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| static void VideoRenderer_AutoShowWindow(VideoRendererImpl *This) { |
| if (!This->init && (!This->WindowPos.right || !This->WindowPos.top)) |
| { |
| DWORD style = GetWindowLongW(This->hWnd, GWL_STYLE); |
| DWORD style_ex = GetWindowLongW(This->hWnd, GWL_EXSTYLE); |
| |
| if (!This->WindowPos.right) |
| { |
| This->WindowPos.left = This->SourceRect.left; |
| This->WindowPos.right = This->SourceRect.right; |
| } |
| if (!This->WindowPos.bottom) |
| { |
| This->WindowPos.top = This->SourceRect.top; |
| This->WindowPos.bottom = This->SourceRect.bottom; |
| } |
| |
| AdjustWindowRectEx(&This->WindowPos, style, TRUE, style_ex); |
| |
| TRACE("WindowPos: %d %d %d %d\n", This->WindowPos.left, This->WindowPos.top, This->WindowPos.right, This->WindowPos.bottom); |
| SetWindowPos(This->hWnd, NULL, |
| This->WindowPos.left, |
| This->WindowPos.top, |
| This->WindowPos.right - This->WindowPos.left, |
| This->WindowPos.bottom - This->WindowPos.top, |
| SWP_NOZORDER|SWP_NOMOVE|SWP_DEFERERASE); |
| |
| GetClientRect(This->hWnd, &This->DestRect); |
| } |
| else if (!This->init) |
| This->DestRect = This->WindowPos; |
| This->init = TRUE; |
| if (This->AutoShow) |
| ShowWindow(This->hWnd, SW_SHOW); |
| } |
| |
| static DWORD VideoRenderer_SendSampleData(VideoRendererImpl* This, LPBYTE data, DWORD size) |
| { |
| AM_MEDIA_TYPE amt; |
| HRESULT hr = S_OK; |
| DDSURFACEDESC sdesc; |
| HDC hDC; |
| BITMAPINFOHEADER *bmiHeader; |
| |
| TRACE("(%p)->(%p, %d)\n", This, data, size); |
| |
| sdesc.dwSize = sizeof(sdesc); |
| hr = IPin_ConnectionMediaType((IPin *)This->pInputPin, &amt); |
| if (FAILED(hr)) { |
| ERR("Unable to retrieve media type\n"); |
| return hr; |
| } |
| |
| if (IsEqualIID(&amt.formattype, &FORMAT_VideoInfo)) |
| { |
| bmiHeader = &((VIDEOINFOHEADER *)amt.pbFormat)->bmiHeader; |
| } |
| else if (IsEqualIID(&amt.formattype, &FORMAT_VideoInfo2)) |
| { |
| bmiHeader = &((VIDEOINFOHEADER2 *)amt.pbFormat)->bmiHeader; |
| } |
| else |
| { |
| FIXME("Unknown type %s\n", debugstr_guid(&amt.subtype)); |
| return VFW_E_RUNTIME_ERROR; |
| } |
| |
| TRACE("biSize = %d\n", bmiHeader->biSize); |
| TRACE("biWidth = %d\n", bmiHeader->biWidth); |
| TRACE("biHeight = %d\n", bmiHeader->biHeight); |
| TRACE("biPlanes = %d\n", bmiHeader->biPlanes); |
| TRACE("biBitCount = %d\n", bmiHeader->biBitCount); |
| TRACE("biCompression = %s\n", debugstr_an((LPSTR)&(bmiHeader->biCompression), 4)); |
| TRACE("biSizeImage = %d\n", bmiHeader->biSizeImage); |
| |
| hDC = GetDC(This->hWnd); |
| |
| if (!hDC) { |
| ERR("Cannot get DC from window!\n"); |
| return E_FAIL; |
| } |
| |
| TRACE("Src Rect: %d %d %d %d\n", This->SourceRect.left, This->SourceRect.top, This->SourceRect.right, This->SourceRect.bottom); |
| TRACE("Dst Rect: %d %d %d %d\n", This->DestRect.left, This->DestRect.top, This->DestRect.right, This->DestRect.bottom); |
| |
| StretchDIBits(hDC, This->DestRect.left, This->DestRect.top, This->DestRect.right -This->DestRect.left, |
| This->DestRect.bottom - This->DestRect.top, This->SourceRect.left, This->SourceRect.top, |
| This->SourceRect.right - This->SourceRect.left, This->SourceRect.bottom - This->SourceRect.top, |
| data, (BITMAPINFO *)bmiHeader, DIB_RGB_COLORS, SRCCOPY); |
| |
| ReleaseDC(This->hWnd, hDC); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI VideoRenderer_Receive(BaseInputPin* pin, IMediaSample * pSample) |
| { |
| VideoRendererImpl *This = (VideoRendererImpl *)pin->pin.pinInfo.pFilter; |
| LPBYTE pbSrcStream = NULL; |
| LONG cbSrcStream = 0; |
| REFERENCE_TIME tStart, tStop; |
| HRESULT hr; |
| |
| TRACE("(%p)->(%p)\n", pin, pSample); |
| |
| EnterCriticalSection(&This->filter.csFilter); |
| |
| if (This->pInputPin->flushing || This->pInputPin->end_of_stream) |
| { |
| LeaveCriticalSection(&This->filter.csFilter); |
| return S_FALSE; |
| } |
| |
| if (This->filter.state == State_Stopped) |
| { |
| LeaveCriticalSection(&This->filter.csFilter); |
| return VFW_E_WRONG_STATE; |
| } |
| |
| if (IMediaSample_GetMediaTime(pSample, &tStart, &tStop) == S_OK) |
| MediaSeekingPassThru_RegisterMediaTime(This->seekthru_unk, tStart); |
| |
| /* Preroll means the sample isn't shown, this is used for key frames and things like that */ |
| if (IMediaSample_IsPreroll(pSample) == S_OK) { |
| LeaveCriticalSection(&This->filter.csFilter); |
| return S_OK; |
| } |
| |
| hr = IMediaSample_GetPointer(pSample, &pbSrcStream); |
| if (FAILED(hr)) |
| { |
| ERR("Cannot get pointer to sample data (%x)\n", hr); |
| LeaveCriticalSection(&This->filter.csFilter); |
| return hr; |
| } |
| |
| cbSrcStream = IMediaSample_GetActualDataLength(pSample); |
| |
| TRACE("val %p %d\n", pbSrcStream, cbSrcStream); |
| |
| #if 0 /* For debugging purpose */ |
| { |
| int i; |
| for(i = 0; i < cbSrcStream; i++) |
| { |
| if ((i!=0) && !(i%16)) |
| TRACE("\n"); |
| TRACE("%02x ", pbSrcStream[i]); |
| } |
| TRACE("\n"); |
| } |
| #endif |
| |
| SetEvent(This->hEvent); |
| if (This->filter.state == State_Paused) |
| { |
| VideoRenderer_SendSampleData(This, pbSrcStream, cbSrcStream); |
| This->sample_held = pSample; |
| LeaveCriticalSection(&This->filter.csFilter); |
| WaitForSingleObject(This->blocked, INFINITE); |
| EnterCriticalSection(&This->filter.csFilter); |
| SetEvent(This->hEvent); |
| This->sample_held = NULL; |
| if (This->filter.state == State_Paused) |
| { |
| /* Flushing */ |
| LeaveCriticalSection(&This->filter.csFilter); |
| return S_OK; |
| } |
| if (This->filter.state == State_Stopped) |
| { |
| LeaveCriticalSection(&This->filter.csFilter); |
| return VFW_E_WRONG_STATE; |
| } |
| } else { |
| hr = QualityControlRender_WaitFor(&This->qcimpl, pSample, This->blocked); |
| if (hr == S_OK) { |
| QualityControlRender_BeginRender(&This->qcimpl); |
| VideoRenderer_SendSampleData(This, pbSrcStream, cbSrcStream); |
| QualityControlRender_EndRender(&This->qcimpl); |
| } |
| QualityControlRender_DoQOS(&This->qcimpl); |
| } |
| LeaveCriticalSection(&This->filter.csFilter); |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI VideoRenderer_CheckMediaType(BasePin *iface, const AM_MEDIA_TYPE * pmt) |
| { |
| BaseInputPin* pin = (BaseInputPin*)iface; |
| VideoRendererImpl *This = (VideoRendererImpl *)pin->pin.pinInfo.pFilter; |
| |
| if (!IsEqualIID(&pmt->majortype, &MEDIATYPE_Video)) |
| return S_FALSE; |
| |
| if (IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_RGB32) || |
| IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_RGB24) || |
| IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_RGB565) || |
| IsEqualIID(&pmt->subtype, &MEDIASUBTYPE_RGB8)) |
| { |
| LONG height; |
| |
| if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo)) |
| { |
| VIDEOINFOHEADER *format = (VIDEOINFOHEADER *)pmt->pbFormat; |
| This->SourceRect.left = 0; |
| This->SourceRect.top = 0; |
| This->SourceRect.right = This->VideoWidth = format->bmiHeader.biWidth; |
| height = format->bmiHeader.biHeight; |
| if (height < 0) |
| This->SourceRect.bottom = This->VideoHeight = -height; |
| else |
| This->SourceRect.bottom = This->VideoHeight = height; |
| } |
| else if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo2)) |
| { |
| VIDEOINFOHEADER2 *format2 = (VIDEOINFOHEADER2 *)pmt->pbFormat; |
| |
| This->SourceRect.left = 0; |
| This->SourceRect.top = 0; |
| This->SourceRect.right = This->VideoWidth = format2->bmiHeader.biWidth; |
| height = format2->bmiHeader.biHeight; |
| if (height < 0) |
| This->SourceRect.bottom = This->VideoHeight = -height; |
| else |
| This->SourceRect.bottom = This->VideoHeight = height; |
| } |
| else |
| { |
| WARN("Format type %s not supported\n", debugstr_guid(&pmt->formattype)); |
| return S_FALSE; |
| } |
| return S_OK; |
| } |
| return S_FALSE; |
| } |
| |
| static IPin* WINAPI VideoRenderer_GetPin(BaseFilter *iface, int pos) |
| { |
| VideoRendererImpl *This = (VideoRendererImpl *)iface; |
| |
| if (pos >= 1 || pos < 0) |
| return NULL; |
| |
| IPin_AddRef((IPin *)This->pInputPin); |
| return (IPin *)This->pInputPin; |
| } |
| |
| static LONG WINAPI VideoRenderer_GetPinCount(BaseFilter *iface) |
| { |
| return 1; |
| } |
| |
| static const BaseFilterFuncTable BaseFuncTable = { |
| VideoRenderer_GetPin, |
| VideoRenderer_GetPinCount |
| }; |
| |
| static const BasePinFuncTable input_BaseFuncTable = { |
| VideoRenderer_CheckMediaType, |
| NULL, |
| BasePinImpl_GetMediaTypeVersion, |
| BasePinImpl_GetMediaType |
| }; |
| |
| static const BaseInputPinFuncTable input_BaseInputFuncTable = { |
| VideoRenderer_Receive |
| }; |
| |
| HRESULT VideoRenderer_create(IUnknown * pUnkOuter, LPVOID * ppv) |
| { |
| HRESULT hr; |
| PIN_INFO piInput; |
| VideoRendererImpl * pVideoRenderer; |
| ISeekingPassThru *passthru; |
| |
| TRACE("(%p, %p)\n", pUnkOuter, ppv); |
| |
| *ppv = NULL; |
| |
| pVideoRenderer = CoTaskMemAlloc(sizeof(VideoRendererImpl)); |
| pVideoRenderer->pUnkOuter = pUnkOuter; |
| pVideoRenderer->bUnkOuterValid = FALSE; |
| pVideoRenderer->bAggregatable = FALSE; |
| pVideoRenderer->IInner_vtbl = &IInner_VTable; |
| pVideoRenderer->IAMFilterMiscFlags_vtbl = &IAMFilterMiscFlags_Vtbl; |
| |
| BaseFilter_Init(&pVideoRenderer->filter, &VideoRenderer_Vtbl, &CLSID_VideoRenderer, (DWORD_PTR)(__FILE__ ": VideoRendererImpl.csFilter"), &BaseFuncTable); |
| |
| pVideoRenderer->IBasicVideo_vtbl = &IBasicVideo_VTable; |
| pVideoRenderer->IVideoWindow_vtbl = &IVideoWindow_VTable; |
| |
| pVideoRenderer->init = 0; |
| pVideoRenderer->AutoShow = 1; |
| ZeroMemory(&pVideoRenderer->SourceRect, sizeof(RECT)); |
| ZeroMemory(&pVideoRenderer->DestRect, sizeof(RECT)); |
| ZeroMemory(&pVideoRenderer->WindowPos, sizeof(RECT)); |
| pVideoRenderer->hWndMsgDrain = pVideoRenderer->hWndOwner = NULL; |
| pVideoRenderer->WindowStyle = WS_OVERLAPPED; |
| |
| /* construct input pin */ |
| piInput.dir = PINDIR_INPUT; |
| piInput.pFilter = (IBaseFilter *)pVideoRenderer; |
| lstrcpynW(piInput.achName, wcsInputPinName, sizeof(piInput.achName) / sizeof(piInput.achName[0])); |
| |
| hr = BaseInputPin_Construct(&VideoRenderer_InputPin_Vtbl, &piInput, &input_BaseFuncTable, &input_BaseInputFuncTable, &pVideoRenderer->filter.csFilter, NULL, (IPin **)&pVideoRenderer->pInputPin); |
| |
| if (SUCCEEDED(hr)) |
| { |
| hr = CoCreateInstance(&CLSID_SeekingPassThru, pUnkOuter ? pUnkOuter : (IUnknown*)&pVideoRenderer->IInner_vtbl, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&pVideoRenderer->seekthru_unk); |
| if (FAILED(hr)) { |
| IPin_Release((IPin*)pVideoRenderer->pInputPin); |
| goto fail; |
| } |
| IUnknown_QueryInterface(pVideoRenderer->seekthru_unk, &IID_ISeekingPassThru, (void**)&passthru); |
| ISeekingPassThru_Init(passthru, TRUE, (IPin*)pVideoRenderer->pInputPin); |
| ISeekingPassThru_Release(passthru); |
| pVideoRenderer->sample_held = NULL; |
| *ppv = pVideoRenderer; |
| } |
| if (FAILED(hr)) |
| goto fail; |
| |
| QualityControlImpl_init(&pVideoRenderer->qcimpl, (IPin*)pVideoRenderer->pInputPin, (IBaseFilter*)pVideoRenderer); |
| pVideoRenderer->qcimpl.lpVtbl = &VideoRenderer_QualityControl_Vtbl; |
| |
| if (!CreateRenderingSubsystem(pVideoRenderer)) |
| return E_FAIL; |
| |
| pVideoRenderer->blocked = CreateEventW(NULL, FALSE, FALSE, NULL); |
| if (!pVideoRenderer->blocked) |
| { |
| hr = HRESULT_FROM_WIN32(GetLastError()); |
| IUnknown_Release((IUnknown *)pVideoRenderer); |
| } |
| |
| return hr; |
| fail: |
| BaseFilterImpl_Release((IBaseFilter*)pVideoRenderer); |
| CoTaskMemFree(pVideoRenderer); |
| return hr; |
| } |
| |
| HRESULT VideoRendererDefault_create(IUnknown * pUnkOuter, LPVOID * ppv) |
| { |
| /* TODO: Attempt to use the VMR-7 renderer instead when possible */ |
| return VideoRenderer_create(pUnkOuter, ppv); |
| } |
| |
| static HRESULT WINAPI VideoRendererInner_QueryInterface(IUnknown * iface, REFIID riid, LPVOID * ppv) |
| { |
| ICOM_THIS_MULTI(VideoRendererImpl, IInner_vtbl, iface); |
| TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv); |
| |
| if (This->bAggregatable) |
| This->bUnkOuterValid = TRUE; |
| |
| *ppv = NULL; |
| |
| if (IsEqualIID(riid, &IID_IUnknown)) |
| *ppv = &This->IInner_vtbl; |
| else if (IsEqualIID(riid, &IID_IPersist)) |
| *ppv = This; |
| else if (IsEqualIID(riid, &IID_IMediaFilter)) |
| *ppv = This; |
| else if (IsEqualIID(riid, &IID_IBaseFilter)) |
| *ppv = This; |
| else if (IsEqualIID(riid, &IID_IBasicVideo)) |
| *ppv = &This->IBasicVideo_vtbl; |
| else if (IsEqualIID(riid, &IID_IVideoWindow)) |
| *ppv = &This->IVideoWindow_vtbl; |
| else if (IsEqualIID(riid, &IID_IMediaSeeking)) |
| return IUnknown_QueryInterface(This->seekthru_unk, riid, ppv); |
| else if (IsEqualIID(riid, &IID_IAMFilterMiscFlags)) |
| *ppv = &This->IAMFilterMiscFlags_vtbl; |
| else if (IsEqualIID(riid, &IID_IQualityControl)) |
| *ppv = &This->qcimpl; |
| |
| if (*ppv) |
| { |
| IUnknown_AddRef((IUnknown *)(*ppv)); |
| return S_OK; |
| } |
| |
| if (!IsEqualIID(riid, &IID_IPin)) |
| FIXME("No interface for %s!\n", qzdebugstr_guid(riid)); |
| |
| return E_NOINTERFACE; |
| } |
| |
| static ULONG WINAPI VideoRendererInner_AddRef(IUnknown * iface) |
| { |
| ICOM_THIS_MULTI(VideoRendererImpl, IInner_vtbl, iface); |
| ULONG refCount = InterlockedIncrement(&This->filter.refCount); |
| |
| TRACE("(%p/%p)->() AddRef from %d\n", This, iface, refCount - 1); |
| |
| return refCount; |
| } |
| |
| static ULONG WINAPI VideoRendererInner_Release(IUnknown * iface) |
| { |
| ICOM_THIS_MULTI(VideoRendererImpl, IInner_vtbl, iface); |
| ULONG refCount = InterlockedDecrement(&This->filter.refCount); |
| |
| TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1); |
| |
| if (!refCount) |
| { |
| IPin *pConnectedTo; |
| |
| if (This->hWnd) |
| SendMessageW(This->hWnd, WM_CLOSE, 0, 0); |
| PostThreadMessageW(This->ThreadID, WM_QUIT, 0, 0); |
| WaitForSingleObject(This->hThread, INFINITE); |
| CloseHandle(This->hThread); |
| CloseHandle(This->hEvent); |
| |
| if (SUCCEEDED(IPin_ConnectedTo((IPin *)This->pInputPin, &pConnectedTo))) |
| { |
| IPin_Disconnect(pConnectedTo); |
| IPin_Release(pConnectedTo); |
| } |
| IPin_Disconnect((IPin *)This->pInputPin); |
| |
| IPin_Release((IPin *)This->pInputPin); |
| |
| This->filter.lpVtbl = NULL; |
| IUnknown_Release(This->seekthru_unk); |
| This->filter.csFilter.DebugInfo->Spare[0] = 0; |
| DeleteCriticalSection(&This->filter.csFilter); |
| |
| TRACE("Destroying Video Renderer\n"); |
| CoTaskMemFree(This); |
| |
| return 0; |
| } |
| else |
| return refCount; |
| } |
| |
| static const IUnknownVtbl IInner_VTable = |
| { |
| VideoRendererInner_QueryInterface, |
| VideoRendererInner_AddRef, |
| VideoRendererInner_Release |
| }; |
| |
| static HRESULT WINAPI VideoRenderer_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv) |
| { |
| VideoRendererImpl *This = (VideoRendererImpl *)iface; |
| |
| if (This->bAggregatable) |
| This->bUnkOuterValid = TRUE; |
| |
| if (This->pUnkOuter) |
| { |
| if (This->bAggregatable) |
| return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv); |
| |
| if (IsEqualIID(riid, &IID_IUnknown)) |
| { |
| HRESULT hr; |
| |
| IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl)); |
| hr = IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv); |
| IUnknown_Release((IUnknown *)&(This->IInner_vtbl)); |
| This->bAggregatable = TRUE; |
| return hr; |
| } |
| |
| *ppv = NULL; |
| return E_NOINTERFACE; |
| } |
| |
| return IUnknown_QueryInterface((IUnknown *)&(This->IInner_vtbl), riid, ppv); |
| } |
| |
| static ULONG WINAPI VideoRenderer_AddRef(IBaseFilter * iface) |
| { |
| VideoRendererImpl *This = (VideoRendererImpl *)iface; |
| |
| if (This->pUnkOuter && This->bUnkOuterValid) |
| return IUnknown_AddRef(This->pUnkOuter); |
| return IUnknown_AddRef((IUnknown *)&(This->IInner_vtbl)); |
| } |
| |
| static ULONG WINAPI VideoRenderer_Release(IBaseFilter * iface) |
| { |
| VideoRendererImpl *This = (VideoRendererImpl *)iface; |
| |
| if (This->pUnkOuter && This->bUnkOuterValid) |
| return IUnknown_Release(This->pUnkOuter); |
| return IUnknown_Release((IUnknown *)&(This->IInner_vtbl)); |
| } |
| |
| /** IMediaFilter methods **/ |
| |
| static HRESULT WINAPI VideoRenderer_Stop(IBaseFilter * iface) |
| { |
| VideoRendererImpl *This = (VideoRendererImpl *)iface; |
| |
| TRACE("(%p/%p)->()\n", This, iface); |
| |
| EnterCriticalSection(&This->filter.csFilter); |
| { |
| This->filter.state = State_Stopped; |
| SetEvent(This->hEvent); |
| SetEvent(This->blocked); |
| MediaSeekingPassThru_ResetMediaTime(This->seekthru_unk); |
| if (This->AutoShow) |
| /* Black it out */ |
| RedrawWindow(This->hWnd, NULL, NULL, RDW_INVALIDATE|RDW_ERASE); |
| } |
| LeaveCriticalSection(&This->filter.csFilter); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI VideoRenderer_Pause(IBaseFilter * iface) |
| { |
| VideoRendererImpl *This = (VideoRendererImpl *)iface; |
| |
| TRACE("(%p/%p)->()\n", This, iface); |
| |
| EnterCriticalSection(&This->filter.csFilter); |
| if (This->filter.state != State_Paused) |
| { |
| if (This->filter.state == State_Stopped) |
| { |
| This->pInputPin->end_of_stream = 0; |
| ResetEvent(This->hEvent); |
| VideoRenderer_AutoShowWindow(This); |
| } |
| |
| This->filter.state = State_Paused; |
| ResetEvent(This->blocked); |
| } |
| LeaveCriticalSection(&This->filter.csFilter); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI VideoRenderer_SetSyncSource(IBaseFilter *iface, IReferenceClock *clock) { |
| VideoRendererImpl *This = (VideoRendererImpl *)iface; |
| HRESULT hr; |
| |
| EnterCriticalSection(&This->filter.csFilter); |
| QualityControlRender_SetClock(&This->qcimpl, clock); |
| hr = BaseFilterImpl_SetSyncSource(iface, clock); |
| LeaveCriticalSection(&This->filter.csFilter); |
| return hr; |
| } |
| |
| static HRESULT WINAPI VideoRenderer_Run(IBaseFilter * iface, REFERENCE_TIME tStart) |
| { |
| HRESULT hr = S_OK; |
| VideoRendererImpl *This = (VideoRendererImpl *)iface; |
| |
| TRACE("(%p/%p)->(%s)\n", This, iface, wine_dbgstr_longlong(tStart)); |
| |
| EnterCriticalSection(&This->filter.csFilter); |
| This->filter.rtStreamStart = tStart; |
| if (This->filter.state == State_Running) |
| goto out; |
| QualityControlRender_Start(&This->qcimpl, tStart); |
| if (This->pInputPin->pin.pConnectedTo && (This->filter.state == State_Stopped || !This->pInputPin->end_of_stream)) |
| { |
| if (This->filter.state == State_Stopped) |
| { |
| ResetEvent(This->hEvent); |
| VideoRenderer_AutoShowWindow(This); |
| This->pInputPin->end_of_stream = 0; |
| } |
| SetEvent(This->blocked); |
| } else if (This->filter.filterInfo.pGraph) { |
| IMediaEventSink *pEventSink; |
| hr = IFilterGraph_QueryInterface(This->filter.filterInfo.pGraph, &IID_IMediaEventSink, (LPVOID*)&pEventSink); |
| if (SUCCEEDED(hr)) |
| { |
| hr = IMediaEventSink_Notify(pEventSink, EC_COMPLETE, S_OK, (LONG_PTR)This); |
| IMediaEventSink_Release(pEventSink); |
| } |
| hr = S_OK; |
| } |
| if (SUCCEEDED(hr)) |
| This->filter.state = State_Running; |
| out: |
| LeaveCriticalSection(&This->filter.csFilter); |
| |
| return hr; |
| } |
| |
| static HRESULT WINAPI VideoRenderer_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState) |
| { |
| VideoRendererImpl *This = (VideoRendererImpl *)iface; |
| HRESULT hr; |
| |
| TRACE("(%p/%p)->(%d, %p)\n", This, iface, dwMilliSecsTimeout, pState); |
| |
| if (WaitForSingleObject(This->hEvent, dwMilliSecsTimeout) == WAIT_TIMEOUT) |
| hr = VFW_S_STATE_INTERMEDIATE; |
| else |
| hr = S_OK; |
| |
| BaseFilterImpl_GetState(iface, dwMilliSecsTimeout, pState); |
| |
| return hr; |
| } |
| |
| /** IBaseFilter implementation **/ |
| |
| static HRESULT WINAPI VideoRenderer_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin) |
| { |
| VideoRendererImpl *This = (VideoRendererImpl *)iface; |
| |
| FIXME("(%p/%p)->(%p,%p): stub !!!\n", This, iface, debugstr_w(Id), ppPin); |
| |
| /* FIXME: critical section */ |
| |
| return E_NOTIMPL; |
| } |
| |
| static const IBaseFilterVtbl VideoRenderer_Vtbl = |
| { |
| VideoRenderer_QueryInterface, |
| VideoRenderer_AddRef, |
| VideoRenderer_Release, |
| BaseFilterImpl_GetClassID, |
| VideoRenderer_Stop, |
| VideoRenderer_Pause, |
| VideoRenderer_Run, |
| VideoRenderer_GetState, |
| VideoRenderer_SetSyncSource, |
| BaseFilterImpl_GetSyncSource, |
| BaseFilterImpl_EnumPins, |
| VideoRenderer_FindPin, |
| BaseFilterImpl_QueryFilterInfo, |
| BaseFilterImpl_JoinFilterGraph, |
| BaseFilterImpl_QueryVendorInfo |
| }; |
| |
| static HRESULT WINAPI VideoRenderer_InputPin_EndOfStream(IPin * iface) |
| { |
| BaseInputPin* This = (BaseInputPin*)iface; |
| VideoRendererImpl *pFilter; |
| IMediaEventSink* pEventSink; |
| HRESULT hr = S_OK; |
| |
| TRACE("(%p/%p)->()\n", This, iface); |
| |
| EnterCriticalSection(This->pin.pCritSec); |
| pFilter = (VideoRendererImpl*)This->pin.pinInfo.pFilter; |
| if (This->flushing || This->end_of_stream) |
| goto out; |
| hr = IFilterGraph_QueryInterface(pFilter->filter.filterInfo.pGraph, &IID_IMediaEventSink, (LPVOID*)&pEventSink); |
| if (SUCCEEDED(hr)) |
| { |
| hr = IMediaEventSink_Notify(pEventSink, EC_COMPLETE, S_OK, (LONG_PTR)pFilter); |
| IMediaEventSink_Release(pEventSink); |
| } |
| MediaSeekingPassThru_EOS(pFilter->seekthru_unk); |
| This->end_of_stream = 1; |
| out: |
| LeaveCriticalSection(This->pin.pCritSec); |
| |
| return hr; |
| } |
| |
| static HRESULT WINAPI VideoRenderer_InputPin_BeginFlush(IPin * iface) |
| { |
| BaseInputPin* This = (BaseInputPin*)iface; |
| VideoRendererImpl *pVideoRenderer = (VideoRendererImpl *)This->pin.pinInfo.pFilter; |
| |
| TRACE("(%p/%p)->()\n", This, iface); |
| |
| SetEvent(pVideoRenderer->blocked); |
| return BaseInputPinImpl_BeginFlush(iface); |
| } |
| |
| static HRESULT WINAPI VideoRenderer_InputPin_EndFlush(IPin * iface) |
| { |
| BaseInputPin* This = (BaseInputPin*)iface; |
| VideoRendererImpl *pVideoRenderer = (VideoRendererImpl *)This->pin.pinInfo.pFilter; |
| HRESULT hr; |
| |
| TRACE("(%p/%p)->()\n", This, iface); |
| |
| EnterCriticalSection(This->pin.pCritSec); |
| |
| if (pVideoRenderer->sample_held) { |
| SetEvent(pVideoRenderer->blocked); |
| ResetEvent(pVideoRenderer->hEvent); |
| LeaveCriticalSection(This->pin.pCritSec); |
| WaitForSingleObject(pVideoRenderer->hEvent, INFINITE); |
| EnterCriticalSection(This->pin.pCritSec); |
| ResetEvent(pVideoRenderer->blocked); |
| } |
| if (pVideoRenderer->filter.state == State_Paused) { |
| ResetEvent(pVideoRenderer->blocked); |
| ResetEvent(pVideoRenderer->hEvent); |
| } |
| |
| QualityControlRender_Start(&pVideoRenderer->qcimpl, pVideoRenderer->filter.rtStreamStart); |
| hr = BaseInputPinImpl_EndFlush(iface); |
| LeaveCriticalSection(This->pin.pCritSec); |
| MediaSeekingPassThru_ResetMediaTime(pVideoRenderer->seekthru_unk); |
| |
| return hr; |
| } |
| |
| static const IPinVtbl VideoRenderer_InputPin_Vtbl = |
| { |
| BaseInputPinImpl_QueryInterface, |
| BasePinImpl_AddRef, |
| BaseInputPinImpl_Release, |
| BaseInputPinImpl_Connect, |
| BaseInputPinImpl_ReceiveConnection, |
| BasePinImpl_Disconnect, |
| BasePinImpl_ConnectedTo, |
| BasePinImpl_ConnectionMediaType, |
| BasePinImpl_QueryPinInfo, |
| BasePinImpl_QueryDirection, |
| BasePinImpl_QueryId, |
| BaseInputPinImpl_QueryAccept, |
| BasePinImpl_EnumMediaTypes, |
| BasePinImpl_QueryInternalConnections, |
| VideoRenderer_InputPin_EndOfStream, |
| VideoRenderer_InputPin_BeginFlush, |
| VideoRenderer_InputPin_EndFlush, |
| BaseInputPinImpl_NewSegment |
| }; |
| |
| /*** IUnknown methods ***/ |
| static HRESULT WINAPI Basicvideo_QueryInterface(IBasicVideo *iface, |
| REFIID riid, |
| LPVOID*ppvObj) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj); |
| |
| return VideoRenderer_QueryInterface((IBaseFilter*)This, riid, ppvObj); |
| } |
| |
| static ULONG WINAPI Basicvideo_AddRef(IBasicVideo *iface) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->()\n", This, iface); |
| |
| return VideoRenderer_AddRef((IBaseFilter*)This); |
| } |
| |
| static ULONG WINAPI Basicvideo_Release(IBasicVideo *iface) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->()\n", This, iface); |
| |
| return VideoRenderer_Release((IBaseFilter*)This); |
| } |
| |
| /*** IDispatch methods ***/ |
| static HRESULT WINAPI Basicvideo_GetTypeInfoCount(IBasicVideo *iface, |
| UINT*pctinfo) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_GetTypeInfo(IBasicVideo *iface, |
| UINT iTInfo, |
| LCID lcid, |
| ITypeInfo**ppTInfo) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_GetIDsOfNames(IBasicVideo *iface, |
| REFIID riid, |
| LPOLESTR*rgszNames, |
| UINT cNames, |
| LCID lcid, |
| DISPID*rgDispId) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_Invoke(IBasicVideo *iface, |
| DISPID dispIdMember, |
| REFIID riid, |
| LCID lcid, |
| WORD wFlags, |
| DISPPARAMS*pDispParams, |
| VARIANT*pVarResult, |
| EXCEPINFO*pExepInfo, |
| UINT*puArgErr) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%d, %s (%p), %d, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr); |
| |
| return S_OK; |
| } |
| |
| /*** IBasicVideo methods ***/ |
| static HRESULT WINAPI Basicvideo_get_AvgTimePerFrame(IBasicVideo *iface, |
| REFTIME *pAvgTimePerFrame) { |
| AM_MEDIA_TYPE *pmt; |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| if (!This->pInputPin->pin.pConnectedTo) |
| return VFW_E_NOT_CONNECTED; |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pAvgTimePerFrame); |
| |
| pmt = &This->pInputPin->pin.mtCurrent; |
| if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo)) { |
| VIDEOINFOHEADER *vih = (VIDEOINFOHEADER*)pmt->pbFormat; |
| *pAvgTimePerFrame = vih->AvgTimePerFrame; |
| } else if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo2)) { |
| VIDEOINFOHEADER2 *vih = (VIDEOINFOHEADER2*)pmt->pbFormat; |
| *pAvgTimePerFrame = vih->AvgTimePerFrame; |
| } else { |
| ERR("Unknown format type %s\n", qzdebugstr_guid(&pmt->formattype)); |
| *pAvgTimePerFrame = 0; |
| } |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_get_BitRate(IBasicVideo *iface, |
| LONG *pBitRate) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBitRate); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_get_BitErrorRate(IBasicVideo *iface, |
| LONG *pBitErrorRate) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBitErrorRate); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_get_VideoWidth(IBasicVideo *iface, |
| LONG *pVideoWidth) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pVideoWidth); |
| |
| *pVideoWidth = This->VideoWidth; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_get_VideoHeight(IBasicVideo *iface, |
| LONG *pVideoHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pVideoHeight); |
| |
| *pVideoHeight = This->VideoHeight; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_put_SourceLeft(IBasicVideo *iface, |
| LONG SourceLeft) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, SourceLeft); |
| |
| This->SourceRect.left = SourceLeft; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_get_SourceLeft(IBasicVideo *iface, |
| LONG *pSourceLeft) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pSourceLeft); |
| |
| *pSourceLeft = This->SourceRect.left; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_put_SourceWidth(IBasicVideo *iface, |
| LONG SourceWidth) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, SourceWidth); |
| |
| This->SourceRect.right = This->SourceRect.left + SourceWidth; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_get_SourceWidth(IBasicVideo *iface, |
| LONG *pSourceWidth) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pSourceWidth); |
| |
| *pSourceWidth = This->SourceRect.right - This->SourceRect.left; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_put_SourceTop(IBasicVideo *iface, |
| LONG SourceTop) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, SourceTop); |
| |
| This->SourceRect.top = SourceTop; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_get_SourceTop(IBasicVideo *iface, |
| LONG *pSourceTop) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pSourceTop); |
| |
| *pSourceTop = This->SourceRect.top; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_put_SourceHeight(IBasicVideo *iface, |
| LONG SourceHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, SourceHeight); |
| |
| This->SourceRect.bottom = This->SourceRect.top + SourceHeight; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_get_SourceHeight(IBasicVideo *iface, |
| LONG *pSourceHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pSourceHeight); |
| |
| *pSourceHeight = This->SourceRect.bottom - This->SourceRect.top; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_put_DestinationLeft(IBasicVideo *iface, |
| LONG DestinationLeft) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, DestinationLeft); |
| |
| This->DestRect.left = DestinationLeft; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_get_DestinationLeft(IBasicVideo *iface, |
| LONG *pDestinationLeft) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationLeft); |
| |
| *pDestinationLeft = This->DestRect.left; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_put_DestinationWidth(IBasicVideo *iface, |
| LONG DestinationWidth) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, DestinationWidth); |
| |
| This->DestRect.right = This->DestRect.left + DestinationWidth; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_get_DestinationWidth(IBasicVideo *iface, |
| LONG *pDestinationWidth) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationWidth); |
| |
| *pDestinationWidth = This->DestRect.right - This->DestRect.left; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_put_DestinationTop(IBasicVideo *iface, |
| LONG DestinationTop) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, DestinationTop); |
| |
| This->DestRect.top = DestinationTop; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_get_DestinationTop(IBasicVideo *iface, |
| LONG *pDestinationTop) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationTop); |
| |
| *pDestinationTop = This->DestRect.top; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_put_DestinationHeight(IBasicVideo *iface, |
| LONG DestinationHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, DestinationHeight); |
| |
| This->DestRect.right = This->DestRect.left + DestinationHeight; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_get_DestinationHeight(IBasicVideo *iface, |
| LONG *pDestinationHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationHeight); |
| |
| *pDestinationHeight = This->DestRect.right - This->DestRect.left; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_SetSourcePosition(IBasicVideo *iface, |
| LONG Left, |
| LONG Top, |
| LONG Width, |
| LONG Height) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height); |
| |
| This->SourceRect.left = Left; |
| This->SourceRect.top = Top; |
| This->SourceRect.right = Left + Width; |
| This->SourceRect.bottom = Top + Height; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_GetSourcePosition(IBasicVideo *iface, |
| LONG *pLeft, |
| LONG *pTop, |
| LONG *pWidth, |
| LONG *pHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight); |
| |
| *pLeft = This->SourceRect.left; |
| *pTop = This->SourceRect.top; |
| *pWidth = This->SourceRect.right - This->SourceRect.left; |
| *pHeight = This->SourceRect.bottom - This->SourceRect.top; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_SetDefaultSourcePosition(IBasicVideo *iface) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->()\n", This, iface); |
| |
| This->SourceRect.left = 0; |
| This->SourceRect.top = 0; |
| This->SourceRect.right = This->VideoWidth; |
| This->SourceRect.bottom = This->VideoHeight; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_SetDestinationPosition(IBasicVideo *iface, |
| LONG Left, |
| LONG Top, |
| LONG Width, |
| LONG Height) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height); |
| |
| This->DestRect.left = Left; |
| This->DestRect.top = Top; |
| This->DestRect.right = Left + Width; |
| This->DestRect.bottom = Top + Height; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_GetDestinationPosition(IBasicVideo *iface, |
| LONG *pLeft, |
| LONG *pTop, |
| LONG *pWidth, |
| LONG *pHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight); |
| |
| *pLeft = This->DestRect.left; |
| *pTop = This->DestRect.top; |
| *pWidth = This->DestRect.right - This->DestRect.left; |
| *pHeight = This->DestRect.bottom - This->DestRect.top; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_SetDefaultDestinationPosition(IBasicVideo *iface) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| RECT rect; |
| |
| TRACE("(%p/%p)->()\n", This, iface); |
| |
| if (!GetClientRect(This->hWnd, &rect)) |
| return E_FAIL; |
| |
| This->SourceRect.left = 0; |
| This->SourceRect.top = 0; |
| This->SourceRect.right = rect.right; |
| This->SourceRect.bottom = rect.bottom; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_GetVideoSize(IBasicVideo *iface, |
| LONG *pWidth, |
| LONG *pHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight); |
| |
| *pWidth = This->VideoWidth; |
| *pHeight = This->VideoHeight; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_GetVideoPaletteEntries(IBasicVideo *iface, |
| LONG StartIndex, |
| LONG Entries, |
| LONG *pRetrieved, |
| LONG *pPalette) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d, %d, %p, %p)\n", This, iface, StartIndex, Entries, pRetrieved, pPalette); |
| |
| if (pRetrieved) |
| *pRetrieved = 0; |
| return VFW_E_NO_PALETTE_AVAILABLE; |
| } |
| |
| static HRESULT WINAPI Basicvideo_GetCurrentImage(IBasicVideo *iface, |
| LONG *pBufferSize, |
| LONG *pDIBImage) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| BITMAPINFOHEADER *bmiHeader; |
| LONG needed_size; |
| AM_MEDIA_TYPE *amt = &This->pInputPin->pin.mtCurrent; |
| char *ptr; |
| |
| FIXME("(%p/%p)->(%p, %p): partial stub\n", This, iface, pBufferSize, pDIBImage); |
| |
| EnterCriticalSection(&This->filter.csFilter); |
| |
| if (!This->sample_held) |
| { |
| LeaveCriticalSection(&This->filter.csFilter); |
| return (This->filter.state == State_Paused ? E_UNEXPECTED : VFW_E_NOT_PAUSED); |
| } |
| |
| if (IsEqualIID(&amt->formattype, &FORMAT_VideoInfo)) |
| { |
| bmiHeader = &((VIDEOINFOHEADER *)amt->pbFormat)->bmiHeader; |
| } |
| else if (IsEqualIID(&amt->formattype, &FORMAT_VideoInfo2)) |
| { |
| bmiHeader = &((VIDEOINFOHEADER2 *)amt->pbFormat)->bmiHeader; |
| } |
| else |
| { |
| FIXME("Unknown type %s\n", debugstr_guid(&amt->subtype)); |
| LeaveCriticalSection(&This->filter.csFilter); |
| return VFW_E_RUNTIME_ERROR; |
| } |
| |
| needed_size = bmiHeader->biSize; |
| needed_size += IMediaSample_GetActualDataLength(This->sample_held); |
| |
| if (!pDIBImage) |
| { |
| *pBufferSize = needed_size; |
| LeaveCriticalSection(&This->filter.csFilter); |
| return S_OK; |
| } |
| |
| if (needed_size < *pBufferSize) |
| { |
| ERR("Buffer too small %u/%u\n", needed_size, *pBufferSize); |
| LeaveCriticalSection(&This->filter.csFilter); |
| return E_FAIL; |
| } |
| *pBufferSize = needed_size; |
| |
| memcpy(pDIBImage, bmiHeader, bmiHeader->biSize); |
| IMediaSample_GetPointer(This->sample_held, (BYTE **)&ptr); |
| memcpy((char *)pDIBImage + bmiHeader->biSize, ptr, IMediaSample_GetActualDataLength(This->sample_held)); |
| |
| LeaveCriticalSection(&This->filter.csFilter); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_IsUsingDefaultSource(IBasicVideo *iface) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| FIXME("(%p/%p)->(): stub !!!\n", This, iface); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Basicvideo_IsUsingDefaultDestination(IBasicVideo *iface) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IBasicVideo_vtbl, iface); |
| |
| FIXME("(%p/%p)->(): stub !!!\n", This, iface); |
| |
| return S_OK; |
| } |
| |
| |
| static const IBasicVideoVtbl IBasicVideo_VTable = |
| { |
| Basicvideo_QueryInterface, |
| Basicvideo_AddRef, |
| Basicvideo_Release, |
| Basicvideo_GetTypeInfoCount, |
| Basicvideo_GetTypeInfo, |
| Basicvideo_GetIDsOfNames, |
| Basicvideo_Invoke, |
| Basicvideo_get_AvgTimePerFrame, |
| Basicvideo_get_BitRate, |
| Basicvideo_get_BitErrorRate, |
| Basicvideo_get_VideoWidth, |
| Basicvideo_get_VideoHeight, |
| Basicvideo_put_SourceLeft, |
| Basicvideo_get_SourceLeft, |
| Basicvideo_put_SourceWidth, |
| Basicvideo_get_SourceWidth, |
| Basicvideo_put_SourceTop, |
| Basicvideo_get_SourceTop, |
| Basicvideo_put_SourceHeight, |
| Basicvideo_get_SourceHeight, |
| Basicvideo_put_DestinationLeft, |
| Basicvideo_get_DestinationLeft, |
| Basicvideo_put_DestinationWidth, |
| Basicvideo_get_DestinationWidth, |
| Basicvideo_put_DestinationTop, |
| Basicvideo_get_DestinationTop, |
| Basicvideo_put_DestinationHeight, |
| Basicvideo_get_DestinationHeight, |
| Basicvideo_SetSourcePosition, |
| Basicvideo_GetSourcePosition, |
| Basicvideo_SetDefaultSourcePosition, |
| Basicvideo_SetDestinationPosition, |
| Basicvideo_GetDestinationPosition, |
| Basicvideo_SetDefaultDestinationPosition, |
| Basicvideo_GetVideoSize, |
| Basicvideo_GetVideoPaletteEntries, |
| Basicvideo_GetCurrentImage, |
| Basicvideo_IsUsingDefaultSource, |
| Basicvideo_IsUsingDefaultDestination |
| }; |
| |
| |
| /*** IUnknown methods ***/ |
| static HRESULT WINAPI Videowindow_QueryInterface(IVideoWindow *iface, |
| REFIID riid, |
| LPVOID*ppvObj) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj); |
| |
| return VideoRenderer_QueryInterface((IBaseFilter*)This, riid, ppvObj); |
| } |
| |
| static ULONG WINAPI Videowindow_AddRef(IVideoWindow *iface) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->()\n", This, iface); |
| |
| return VideoRenderer_AddRef((IBaseFilter*)This); |
| } |
| |
| static ULONG WINAPI Videowindow_Release(IVideoWindow *iface) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->()\n", This, iface); |
| |
| return VideoRenderer_Release((IBaseFilter*)This); |
| } |
| |
| /*** IDispatch methods ***/ |
| static HRESULT WINAPI Videowindow_GetTypeInfoCount(IVideoWindow *iface, |
| UINT*pctinfo) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_GetTypeInfo(IVideoWindow *iface, |
| UINT iTInfo, |
| LCID lcid, |
| ITypeInfo**ppTInfo) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%d, %d, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_GetIDsOfNames(IVideoWindow *iface, |
| REFIID riid, |
| LPOLESTR*rgszNames, |
| UINT cNames, |
| LCID lcid, |
| DISPID*rgDispId) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%s (%p), %p, %d, %d, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_Invoke(IVideoWindow *iface, |
| DISPID dispIdMember, |
| REFIID riid, |
| LCID lcid, |
| WORD wFlags, |
| DISPPARAMS*pDispParams, |
| VARIANT*pVarResult, |
| EXCEPINFO*pExepInfo, |
| UINT*puArgErr) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%d, %s (%p), %d, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr); |
| |
| return S_OK; |
| } |
| |
| /*** IVideoWindow methods ***/ |
| static HRESULT WINAPI Videowindow_put_Caption(IVideoWindow *iface, |
| BSTR strCaption) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strCaption), strCaption); |
| |
| if (!SetWindowTextW(This->hWnd, strCaption)) |
| return E_FAIL; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_Caption(IVideoWindow *iface, |
| BSTR *strCaption) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, strCaption); |
| |
| GetWindowTextW(This->hWnd, (LPWSTR)strCaption, 100); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_WindowStyle(IVideoWindow *iface, |
| LONG WindowStyle) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| LONG old; |
| |
| old = GetWindowLongW(This->hWnd, GWL_STYLE); |
| |
| TRACE("(%p/%p)->(%x -> %x)\n", This, iface, old, WindowStyle); |
| |
| if (WindowStyle & (WS_DISABLED|WS_HSCROLL|WS_ICONIC|WS_MAXIMIZE|WS_MINIMIZE|WS_VSCROLL)) |
| return E_INVALIDARG; |
| |
| SetWindowLongW(This->hWnd, GWL_STYLE, WindowStyle); |
| SetWindowPos(This->hWnd,0,0,0,0,0,SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOZORDER); |
| This->WindowStyle = WindowStyle; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_WindowStyle(IVideoWindow *iface, |
| LONG *WindowStyle) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyle); |
| |
| *WindowStyle = This->WindowStyle; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_WindowStyleEx(IVideoWindow *iface, |
| LONG WindowStyleEx) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, WindowStyleEx); |
| |
| if (!SetWindowLongW(This->hWnd, GWL_EXSTYLE, WindowStyleEx)) |
| return E_FAIL; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_WindowStyleEx(IVideoWindow *iface, |
| LONG *WindowStyleEx) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyleEx); |
| |
| *WindowStyleEx = GetWindowLongW(This->hWnd, GWL_EXSTYLE); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_AutoShow(IVideoWindow *iface, |
| LONG AutoShow) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, AutoShow); |
| |
| This->AutoShow = AutoShow; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_AutoShow(IVideoWindow *iface, |
| LONG *AutoShow) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, AutoShow); |
| |
| *AutoShow = This->AutoShow; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_WindowState(IVideoWindow *iface, |
| LONG WindowState) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, WindowState); |
| ShowWindow(This->hWnd, WindowState); |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_WindowState(IVideoWindow *iface, |
| LONG *WindowState) { |
| WINDOWPLACEMENT place; |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| place.length = sizeof(place); |
| GetWindowPlacement(This->hWnd, &place); |
| TRACE("(%p/%p)->(%p)\n", This, iface, WindowState); |
| *WindowState = place.showCmd; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_BackgroundPalette(IVideoWindow *iface, |
| LONG BackgroundPalette) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, BackgroundPalette); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_BackgroundPalette(IVideoWindow *iface, |
| LONG *pBackgroundPalette) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pBackgroundPalette); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_Visible(IVideoWindow *iface, |
| LONG Visible) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, Visible); |
| |
| ShowWindow(This->hWnd, Visible ? SW_SHOW : SW_HIDE); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_Visible(IVideoWindow *iface, |
| LONG *pVisible) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pVisible); |
| |
| *pVisible = IsWindowVisible(This->hWnd); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_Left(IVideoWindow *iface, |
| LONG Left) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, Left); |
| |
| if (!SetWindowPos(This->hWnd, NULL, Left, This->WindowPos.top, 0, 0, SWP_NOZORDER|SWP_NOSIZE)) |
| return E_FAIL; |
| |
| This->WindowPos.left = Left; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_Left(IVideoWindow *iface, |
| LONG *pLeft) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pLeft); |
| |
| *pLeft = This->WindowPos.left; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_Width(IVideoWindow *iface, |
| LONG Width) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, Width); |
| |
| if (!SetWindowPos(This->hWnd, NULL, 0, 0, Width, This->WindowPos.bottom-This->WindowPos.top, SWP_NOZORDER|SWP_NOMOVE)) |
| return E_FAIL; |
| |
| This->WindowPos.right = This->WindowPos.left + Width; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_Width(IVideoWindow *iface, |
| LONG *pWidth) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pWidth); |
| |
| *pWidth = This->WindowPos.right - This->WindowPos.left; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_Top(IVideoWindow *iface, |
| LONG Top) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, Top); |
| |
| if (!SetWindowPos(This->hWnd, NULL, This->WindowPos.left, Top, 0, 0, SWP_NOZORDER|SWP_NOSIZE)) |
| return E_FAIL; |
| |
| This->WindowPos.top = Top; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_Top(IVideoWindow *iface, |
| LONG *pTop) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pTop); |
| |
| *pTop = This->WindowPos.top; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_Height(IVideoWindow *iface, |
| LONG Height) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, Height); |
| |
| if (!SetWindowPos(This->hWnd, NULL, 0, 0, This->WindowPos.right-This->WindowPos.left, Height, SWP_NOZORDER|SWP_NOMOVE)) |
| return E_FAIL; |
| |
| This->WindowPos.bottom = This->WindowPos.top + Height; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_Height(IVideoWindow *iface, |
| LONG *pHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, pHeight); |
| |
| *pHeight = This->WindowPos.bottom - This->WindowPos.top; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_Owner(IVideoWindow *iface, |
| OAHWND Owner) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Owner); |
| |
| This->hWndOwner = (HWND)Owner; |
| SetParent(This->hWnd, This->hWndOwner); |
| if (This->WindowStyle & WS_CHILD) |
| { |
| LONG old = GetWindowLongW(This->hWnd, GWL_STYLE); |
| if (old != This->WindowStyle) |
| { |
| SetWindowLongW(This->hWnd, GWL_STYLE, This->WindowStyle); |
| SetWindowPos(This->hWnd,0,0,0,0,0,SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOZORDER); |
| } |
| } |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_Owner(IVideoWindow *iface, |
| OAHWND *Owner) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, Owner); |
| |
| *(HWND*)Owner = This->hWndOwner; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_MessageDrain(IVideoWindow *iface, |
| OAHWND Drain) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%08x)\n", This, iface, (DWORD) Drain); |
| |
| This->hWndMsgDrain = (HWND)Drain; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_MessageDrain(IVideoWindow *iface, |
| OAHWND *Drain) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p)\n", This, iface, Drain); |
| |
| *Drain = (OAHWND)This->hWndMsgDrain; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_BorderColor(IVideoWindow *iface, |
| LONG *Color) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, Color); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_BorderColor(IVideoWindow *iface, |
| LONG Color) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, Color); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_get_FullScreenMode(IVideoWindow *iface, |
| LONG *FullScreenMode) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, FullScreenMode); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_put_FullScreenMode(IVideoWindow *iface, |
| LONG FullScreenMode) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, FullScreenMode); |
| |
| if (FullScreenMode) { |
| ShowWindow(This->hWnd, SW_HIDE); |
| SetParent(This->hWnd, 0); |
| SetWindowLongW(This->hWnd, GWL_STYLE, WS_POPUP); |
| SetWindowPos(This->hWnd,HWND_TOP,0,0,GetSystemMetrics(SM_CXSCREEN),GetSystemMetrics(SM_CYSCREEN),SWP_SHOWWINDOW); |
| GetWindowRect(This->hWnd, &This->DestRect); |
| This->WindowPos = This->DestRect; |
| } else { |
| ShowWindow(This->hWnd, SW_HIDE); |
| SetParent(This->hWnd, This->hWndOwner); |
| SetWindowLongW(This->hWnd, GWL_STYLE, This->WindowStyle); |
| GetClientRect(This->hWnd, &This->DestRect); |
| SetWindowPos(This->hWnd,0,This->DestRect.left,This->DestRect.top,This->DestRect.right,This->DestRect.bottom,SWP_NOZORDER|SWP_SHOWWINDOW); |
| This->WindowPos = This->DestRect; |
| } |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_SetWindowForeground(IVideoWindow *iface, |
| LONG Focus) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| BOOL ret; |
| IPin* pPin; |
| HRESULT hr; |
| |
| TRACE("(%p/%p)->(%d)\n", This, iface, Focus); |
| |
| if ((Focus != FALSE) && (Focus != TRUE)) |
| return E_INVALIDARG; |
| |
| hr = IPin_ConnectedTo((IPin *)This->pInputPin, &pPin); |
| if ((hr != S_OK) || !pPin) |
| return VFW_E_NOT_CONNECTED; |
| |
| if (Focus) |
| ret = SetForegroundWindow(This->hWnd); |
| else |
| ret = SetWindowPos(This->hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE); |
| |
| if (!ret) |
| return E_FAIL; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_NotifyOwnerMessage(IVideoWindow *iface, |
| OAHWND hwnd, |
| LONG uMsg, |
| LONG_PTR wParam, |
| LONG_PTR lParam) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%08lx, %d, %08lx, %08lx)\n", This, iface, hwnd, uMsg, wParam, lParam); |
| |
| if (!PostMessageW(This->hWnd, uMsg, wParam, lParam)) |
| return E_FAIL; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_SetWindowPosition(IVideoWindow *iface, |
| LONG Left, |
| LONG Top, |
| LONG Width, |
| LONG Height) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height); |
| |
| if (!SetWindowPos(This->hWnd, NULL, Left, Top, Width, Height, SWP_NOZORDER)) |
| return E_FAIL; |
| |
| This->WindowPos.left = Left; |
| This->WindowPos.top = Top; |
| This->WindowPos.right = Left + Width; |
| This->WindowPos.bottom = Top + Height; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_GetWindowPosition(IVideoWindow *iface, |
| LONG *pLeft, |
| LONG *pTop, |
| LONG *pWidth, |
| LONG *pHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight); |
| |
| *pLeft = This->WindowPos.left; |
| *pTop = This->WindowPos.top; |
| *pWidth = This->WindowPos.right - This->WindowPos.left; |
| *pHeight = This->WindowPos.bottom - This->WindowPos.top; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_GetMinIdealImageSize(IVideoWindow *iface, |
| LONG *pWidth, |
| LONG *pHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%p, %p): semi stub !!!\n", This, iface, pWidth, pHeight); |
| |
| *pWidth = This->VideoWidth; |
| *pHeight = This->VideoHeight; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_GetMaxIdealImageSize(IVideoWindow *iface, |
| LONG *pWidth, |
| LONG *pHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%p, %p): semi stub !!!\n", This, iface, pWidth, pHeight); |
| |
| *pWidth = This->VideoWidth; |
| *pHeight = This->VideoHeight; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_GetRestorePosition(IVideoWindow *iface, |
| LONG *pLeft, |
| LONG *pTop, |
| LONG *pWidth, |
| LONG *pHeight) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_HideCursor(IVideoWindow *iface, |
| LONG HideCursor) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%d): stub !!!\n", This, iface, HideCursor); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI Videowindow_IsCursorHidden(IVideoWindow *iface, |
| LONG *CursorHidden) { |
| ICOM_THIS_MULTI(VideoRendererImpl, IVideoWindow_vtbl, iface); |
| |
| FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, CursorHidden); |
| |
| return S_OK; |
| } |
| |
| static const IVideoWindowVtbl IVideoWindow_VTable = |
| { |
| Videowindow_QueryInterface, |
| Videowindow_AddRef, |
| Videowindow_Release, |
| Videowindow_GetTypeInfoCount, |
| Videowindow_GetTypeInfo, |
| Videowindow_GetIDsOfNames, |
| Videowindow_Invoke, |
| Videowindow_put_Caption, |
| Videowindow_get_Caption, |
| Videowindow_put_WindowStyle, |
| Videowindow_get_WindowStyle, |
| Videowindow_put_WindowStyleEx, |
| Videowindow_get_WindowStyleEx, |
| Videowindow_put_AutoShow, |
| Videowindow_get_AutoShow, |
| Videowindow_put_WindowState, |
| Videowindow_get_WindowState, |
| Videowindow_put_BackgroundPalette, |
| Videowindow_get_BackgroundPalette, |
| Videowindow_put_Visible, |
| Videowindow_get_Visible, |
| Videowindow_put_Left, |
| Videowindow_get_Left, |
| Videowindow_put_Width, |
| Videowindow_get_Width, |
| Videowindow_put_Top, |
| Videowindow_get_Top, |
| Videowindow_put_Height, |
| Videowindow_get_Height, |
| Videowindow_put_Owner, |
| Videowindow_get_Owner, |
| Videowindow_put_MessageDrain, |
| Videowindow_get_MessageDrain, |
| Videowindow_get_BorderColor, |
| Videowindow_put_BorderColor, |
| Videowindow_get_FullScreenMode, |
| Videowindow_put_FullScreenMode, |
| Videowindow_SetWindowForeground, |
| Videowindow_NotifyOwnerMessage, |
| Videowindow_SetWindowPosition, |
| Videowindow_GetWindowPosition, |
| Videowindow_GetMinIdealImageSize, |
| Videowindow_GetMaxIdealImageSize, |
| Videowindow_GetRestorePosition, |
| Videowindow_HideCursor, |
| Videowindow_IsCursorHidden |
| }; |
| |
| static VideoRendererImpl *from_IAMFilterMiscFlags(IAMFilterMiscFlags *iface) { |
| return (VideoRendererImpl*)((char*)iface - offsetof(VideoRendererImpl, IAMFilterMiscFlags_vtbl)); |
| } |
| |
| static HRESULT WINAPI AMFilterMiscFlags_QueryInterface(IAMFilterMiscFlags *iface, REFIID riid, void **ppv) { |
| VideoRendererImpl *This = from_IAMFilterMiscFlags(iface); |
| return IUnknown_QueryInterface((IUnknown*)This, riid, ppv); |
| } |
| |
| static ULONG WINAPI AMFilterMiscFlags_AddRef(IAMFilterMiscFlags *iface) { |
| VideoRendererImpl *This = from_IAMFilterMiscFlags(iface); |
| return IUnknown_AddRef((IUnknown*)This); |
| } |
| |
| static ULONG WINAPI AMFilterMiscFlags_Release(IAMFilterMiscFlags *iface) { |
| VideoRendererImpl *This = from_IAMFilterMiscFlags(iface); |
| return IUnknown_Release((IUnknown*)This); |
| } |
| |
| static ULONG WINAPI AMFilterMiscFlags_GetMiscFlags(IAMFilterMiscFlags *iface) { |
| return AM_FILTER_MISC_FLAGS_IS_RENDERER; |
| } |
| |
| static const IAMFilterMiscFlagsVtbl IAMFilterMiscFlags_Vtbl = { |
| AMFilterMiscFlags_QueryInterface, |
| AMFilterMiscFlags_AddRef, |
| AMFilterMiscFlags_Release, |
| AMFilterMiscFlags_GetMiscFlags |
| }; |
