system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-11-05 18:01:34 +00:00
Code Issues Projects Releases Packages Wiki Activity
wine/dlls/quartz/videorenderer.c
Marcus Meissner 82cd229cc2 quartz: Removed const from const REFIID (Coverity).
2011-03-14 19:31:29 +01:00

2229 lines
70 KiB
C
Raw Blame History

/*
* 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
};
Reference in a new issue View git blame Copy permalink