videorenderer.c File Reference

#include "quartz_private.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/debug.h"

Include dependency graph for videorenderer.c:

Go to the source code of this file.

Classes
struct	video_renderer

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (quartz)
static struct video_renderer *	impl_from_video_window (struct video_window *iface)
static struct video_renderer *	impl_from_strmbase_renderer (struct strmbase_renderer *iface)
static struct video_renderer *	impl_from_IVideoWindow (IVideoWindow *iface)
static const BITMAPINFOHEADER *	get_bitmap_header (const AM_MEDIA_TYPE *mt)
static void	VideoRenderer_AutoShowWindow (struct video_renderer *This)
static HRESULT	video_renderer_render (struct strmbase_renderer *iface, IMediaSample *pSample)
static HRESULT	video_renderer_query_accept (struct strmbase_renderer *iface, const AM_MEDIA_TYPE *mt)
static void	video_renderer_destroy (struct strmbase_renderer *iface)
static HRESULT	video_renderer_query_interface (struct strmbase_renderer *iface, REFIID iid, void **out)
static HRESULT	video_renderer_pin_query_interface (struct strmbase_renderer *iface, REFIID iid, void **out)
static void	video_renderer_stop_stream (struct strmbase_renderer *iface)
static void	video_renderer_init_stream (struct strmbase_renderer *iface)
static HRESULT	video_renderer_connect (struct strmbase_renderer *iface, const AM_MEDIA_TYPE *mt)
static void	video_renderer_get_default_rect (struct video_window *iface, RECT *rect)
static HRESULT	video_renderer_get_current_image (struct video_window *iface, LONG *size, LONG *image)
static HRESULT WINAPI	VideoWindow_get_FullScreenMode (IVideoWindow *iface, LONG *FullScreenMode)
static HRESULT WINAPI	VideoWindow_put_FullScreenMode (IVideoWindow *iface, LONG fullscreen)
static struct video_renderer *	impl_from_IOverlay (IOverlay *iface)
static HRESULT WINAPI	overlay_QueryInterface (IOverlay *iface, REFIID iid, void **out)
static ULONG WINAPI	overlay_AddRef (IOverlay *iface)
static ULONG WINAPI	overlay_Release (IOverlay *iface)
static HRESULT WINAPI	overlay_GetPalette (IOverlay *iface, DWORD *count, PALETTEENTRY **palette)
static HRESULT WINAPI	overlay_SetPalette (IOverlay *iface, DWORD count, PALETTEENTRY *palette)
static HRESULT WINAPI	overlay_GetDefaultColorKey (IOverlay *iface, COLORKEY *key)
static HRESULT WINAPI	overlay_GetColorKey (IOverlay *iface, COLORKEY *key)
static HRESULT WINAPI	overlay_SetColorKey (IOverlay *iface, COLORKEY *key)
static HRESULT WINAPI	overlay_GetWindowHandle (IOverlay *iface, HWND *window)
static HRESULT WINAPI	overlay_GetClipList (IOverlay *iface, RECT *source, RECT *dest, RGNDATA **region)
static HRESULT WINAPI	overlay_GetVideoPosition (IOverlay *iface, RECT *source, RECT *dest)
static HRESULT WINAPI	overlay_Advise (IOverlay *iface, IOverlayNotify *sink, DWORD flags)
static HRESULT WINAPI	overlay_Unadvise (IOverlay *iface)
HRESULT	video_renderer_create (IUnknown *outer, IUnknown **out)
HRESULT	video_renderer_default_create (IUnknown *outer, IUnknown **out)

Variables
static const struct strmbase_renderer_ops	renderer_ops
static const struct video_window_ops	window_ops
static const IVideoWindowVtbl	IVideoWindow_VTable
static const IOverlayVtbl	overlay_vtbl

Function Documentation

get_bitmap_header()

static const BITMAPINFOHEADER * get_bitmap_header ( const AM_MEDIA_TYPE *  mt )

static

Definition at line 68 of file videorenderer.c.

{
    if (IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo))
        return &((VIDEOINFOHEADER *)mt->pbFormat)->bmiHeader;
    else
        return &((VIDEOINFOHEADER2 *)mt->pbFormat)->bmiHeader;
}

Referenced by video_renderer_connect(), video_renderer_get_current_image(), and video_renderer_render().

impl_from_IOverlay()

static struct video_renderer * impl_from_IOverlay ( IOverlay *  iface )

inlinestatic

Definition at line 371 of file videorenderer.c.

{
    return CONTAINING_RECORD(iface, struct video_renderer, IOverlay_iface);
}

Referenced by overlay_AddRef(), overlay_GetWindowHandle(), overlay_QueryInterface(), and overlay_Release().

impl_from_IVideoWindow()

static struct video_renderer * impl_from_IVideoWindow ( IVideoWindow *  iface )

inlinestatic

Definition at line 63 of file videorenderer.c.

{
    return CONTAINING_RECORD(iface, struct video_renderer, window.IVideoWindow_iface);
}

Referenced by VideoWindow_get_FullScreenMode(), and VideoWindow_put_FullScreenMode().

impl_from_strmbase_renderer()

static struct video_renderer * impl_from_strmbase_renderer ( struct strmbase_renderer *  iface )

inlinestatic

Definition at line 58 of file videorenderer.c.

{
    return CONTAINING_RECORD(iface, struct video_renderer, renderer);
}

Referenced by video_renderer_connect(), video_renderer_destroy(), video_renderer_init_stream(), video_renderer_pin_query_interface(), video_renderer_query_interface(), video_renderer_render(), and video_renderer_stop_stream().

impl_from_video_window()

static struct video_renderer * impl_from_video_window ( struct video_window *  iface )

inlinestatic

Definition at line 53 of file videorenderer.c.

{
    return CONTAINING_RECORD(iface, struct video_renderer, window);
}

Referenced by video_renderer_get_current_image(), and video_renderer_get_default_rect().

overlay_AddRef()

static ULONG WINAPI overlay_AddRef ( IOverlay *  iface )

static

Definition at line 382 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_IOverlay(iface);
    return IPin_AddRef(&filter->renderer.sink.pin.IPin_iface);
}

overlay_Advise()

static HRESULT WINAPI overlay_Advise ( IOverlay *  iface, IOverlayNotify *  sink, DWORD  flags  )

static

Definition at line 446 of file videorenderer.c.

{
    FIXME("iface %p, sink %p, flags %#lx, stub!\n", iface, sink, flags);
    return E_NOTIMPL;
}

overlay_GetClipList()

static HRESULT WINAPI overlay_GetClipList ( IOverlay *  iface, RECT *  source, RECT *  dest, RGNDATA **  region  )

static

Definition at line 434 of file videorenderer.c.

{
    FIXME("iface %p, source %p, dest %p, region %p, stub!\n", iface, source, dest, region);
    return E_NOTIMPL;
}

overlay_GetColorKey()

static HRESULT WINAPI overlay_GetColorKey ( IOverlay *  iface, COLORKEY *  key  )

static

Definition at line 412 of file videorenderer.c.

{
    FIXME("iface %p, key %p, stub!\n", iface, key);
    return E_NOTIMPL;
}

overlay_GetDefaultColorKey()

static HRESULT WINAPI overlay_GetDefaultColorKey ( IOverlay *  iface, COLORKEY *  key  )

static

Definition at line 406 of file videorenderer.c.

{
    FIXME("iface %p, key %p, stub!\n", iface, key);
    return E_NOTIMPL;
}

overlay_GetPalette()

static HRESULT WINAPI overlay_GetPalette ( IOverlay *  iface, DWORD *  count, PALETTEENTRY **  palette  )

static

Definition at line 394 of file videorenderer.c.

{
    FIXME("iface %p, count %p, palette %p, stub!\n", iface, count, palette);
    return E_NOTIMPL;
}

overlay_GetVideoPosition()

static HRESULT WINAPI overlay_GetVideoPosition ( IOverlay *  iface, RECT *  source, RECT *  dest  )

static

Definition at line 440 of file videorenderer.c.

{
    FIXME("iface %p, source %p, dest %p, stub!\n", iface, source, dest);
    return E_NOTIMPL;
}

overlay_GetWindowHandle()

static HRESULT WINAPI overlay_GetWindowHandle ( IOverlay *  iface, HWND *  window  )

static

Definition at line 424 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_IOverlay(iface);
 
    TRACE("filter %p, window %p.\n", filter, window);
 
    *window = filter->window.hwnd;
    return S_OK;
}

overlay_QueryInterface()

static HRESULT WINAPI overlay_QueryInterface ( IOverlay *  iface, REFIID  iid, void **  out  )

static

Definition at line 376 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_IOverlay(iface);
    return IPin_QueryInterface(&filter->renderer.sink.pin.IPin_iface, iid, out);
}

overlay_Release()

static ULONG WINAPI overlay_Release ( IOverlay *  iface )

static

Definition at line 388 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_IOverlay(iface);
    return IPin_Release(&filter->renderer.sink.pin.IPin_iface);
}

overlay_SetColorKey()

static HRESULT WINAPI overlay_SetColorKey ( IOverlay *  iface, COLORKEY *  key  )

static

Definition at line 418 of file videorenderer.c.

{
    FIXME("iface %p, key %p, stub!\n", iface, key);
    return E_NOTIMPL;
}

overlay_SetPalette()

static HRESULT WINAPI overlay_SetPalette ( IOverlay *  iface, DWORD  count, PALETTEENTRY *  palette  )

static

Definition at line 400 of file videorenderer.c.

{
    FIXME("iface %p, count %lu, palette %p, stub!\n", iface, count, palette);
    return E_NOTIMPL;
}

overlay_Unadvise()

static HRESULT WINAPI overlay_Unadvise ( IOverlay *  iface )

static

Definition at line 452 of file videorenderer.c.

{
    FIXME("iface %p, stub!\n", iface);
    return E_NOTIMPL;
}

video_renderer_connect()

static HRESULT video_renderer_connect ( struct strmbase_renderer *  iface, const AM_MEDIA_TYPE *  mt  )

static

Definition at line 181 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_strmbase_renderer(iface);
    const BITMAPINFOHEADER *bitmap_header = get_bitmap_header(mt);
    HWND window = filter->window.hwnd;
    RECT rect;
 
    filter->VideoWidth = bitmap_header->biWidth;
    filter->VideoHeight = abs(bitmap_header->biHeight);
    SetRect(&rect, 0, 0, filter->VideoWidth, filter->VideoHeight);
    filter->window.src = rect;
 
    AdjustWindowRectEx(&rect, GetWindowLongW(window, GWL_STYLE), FALSE,
            GetWindowLongW(window, GWL_EXSTYLE));
    SetWindowPos(window, NULL, 0, 0, rect.right - rect.left, rect.bottom - rect.top,
            SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
    GetClientRect(window, &filter->window.dst);
 
    return S_OK;
}

video_renderer_create()

HRESULT video_renderer_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 475 of file videorenderer.c.

{
    struct video_renderer *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    strmbase_renderer_init(&object->renderer, outer, &CLSID_VideoRenderer, L"In", &renderer_ops);
    wcscpy(object->renderer.sink.pin.name, L"Input");
 
    object->IOverlay_iface.lpVtbl = &overlay_vtbl;
 
    video_window_init(&object->window, &IVideoWindow_VTable,
            &object->renderer.filter, &object->renderer.sink.pin, &window_ops);
 
    if (FAILED(hr = video_window_create_window(&object->window)))
    {
        video_window_cleanup(&object->window);
        strmbase_renderer_cleanup(&object->renderer);
        free(object);
        return hr;
    }
 
    TRACE("Created video renderer %p.\n", object);
    *out = &object->renderer.filter.IUnknown_inner;
    return S_OK;
}

Referenced by video_renderer_default_create().

video_renderer_default_create()

HRESULT video_renderer_default_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 504 of file videorenderer.c.

{
    HRESULT hr;
 
    if (SUCCEEDED(hr = vmr7_create(outer, out)))
        return hr;
 
    return video_renderer_create(outer, out);
}

video_renderer_destroy()

static void video_renderer_destroy ( struct strmbase_renderer *  iface )

static

Definition at line 126 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_strmbase_renderer(iface);
 
    video_window_cleanup(&filter->window);
    strmbase_renderer_cleanup(&filter->renderer);
    free(filter);
}

video_renderer_get_current_image()

static HRESULT video_renderer_get_current_image ( struct video_window *  iface, LONG *  size, LONG *  image  )

static

Definition at line 221 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_video_window(iface);
    const BITMAPINFOHEADER *bih;
    size_t image_size;
    BYTE *sample_data;
 
    EnterCriticalSection(&filter->renderer.filter.stream_cs);
 
    bih = get_bitmap_header(&filter->renderer.sink.pin.mt);
    image_size = bih->biWidth * bih->biHeight * bih->biBitCount / 8;
 
    if (!image)
    {
        LeaveCriticalSection(&filter->renderer.filter.stream_cs);
        *size = sizeof(BITMAPINFOHEADER) + image_size;
        return S_OK;
    }
 
    if (filter->renderer.filter.state != State_Paused)
    {
        LeaveCriticalSection(&filter->renderer.filter.stream_cs);
        return VFW_E_NOT_PAUSED;
    }
 
    if (!filter->renderer.current_sample)
    {
        LeaveCriticalSection(&filter->renderer.filter.stream_cs);
        return E_UNEXPECTED;
    }
 
    if (*size < sizeof(BITMAPINFOHEADER) + image_size)
    {
        LeaveCriticalSection(&filter->renderer.filter.stream_cs);
        return E_OUTOFMEMORY;
    }
 
    memcpy(image, bih, sizeof(BITMAPINFOHEADER));
    IMediaSample_GetPointer(filter->renderer.current_sample, &sample_data);
    memcpy((char *)image + sizeof(BITMAPINFOHEADER), sample_data, image_size);
 
    LeaveCriticalSection(&filter->renderer.filter.stream_cs);
    return S_OK;
}

video_renderer_get_default_rect()

static void video_renderer_get_default_rect ( struct video_window *  iface, RECT *  rect  )

static

Definition at line 202 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_video_window(iface);
 
    SetRect(rect, 0, 0, filter->VideoWidth, filter->VideoHeight);
}

video_renderer_init_stream()

static void video_renderer_init_stream ( struct strmbase_renderer *  iface )

static

Definition at line 174 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_strmbase_renderer(iface);
 
    VideoRenderer_AutoShowWindow(filter);
}

video_renderer_pin_query_interface()

static HRESULT video_renderer_pin_query_interface ( struct strmbase_renderer *  iface, REFIID  iid, void **  out  )

static

Definition at line 150 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_strmbase_renderer(iface);
 
    if (IsEqualGUID(iid, &IID_IOverlay))
        *out = &filter->IOverlay_iface;
    else
        return E_NOINTERFACE;
 
    IUnknown_AddRef((IUnknown *)*out);
    return S_OK;
}

video_renderer_query_accept()

static HRESULT video_renderer_query_accept ( struct strmbase_renderer *  iface, const AM_MEDIA_TYPE *  mt  )

static

Definition at line 108 of file videorenderer.c.

{
    if (!IsEqualGUID(&mt->majortype, &MEDIATYPE_Video))
        return S_FALSE;
 
    if (!IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB32)
            && !IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB24)
            && !IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB565)
            && !IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB8))
        return S_FALSE;
 
    if (!IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo)
            && !IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo2))
        return S_FALSE;
 
    return S_OK;
}

video_renderer_query_interface()

static HRESULT video_renderer_query_interface ( struct strmbase_renderer *  iface, REFIID  iid, void **  out  )

static

Definition at line 135 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_strmbase_renderer(iface);
 
    if (IsEqualGUID(iid, &IID_IBasicVideo))
        *out = &filter->window.IBasicVideo_iface;
    else if (IsEqualGUID(iid, &IID_IVideoWindow))
        *out = &filter->window.IVideoWindow_iface;
    else
        return E_NOINTERFACE;
 
    IUnknown_AddRef((IUnknown *)*out);
    return S_OK;
}

video_renderer_render()

static HRESULT video_renderer_render ( struct strmbase_renderer *  iface, IMediaSample *  pSample  )

static

Definition at line 82 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_strmbase_renderer(iface);
    RECT src = filter->window.src, dst = filter->window.dst;
    LPBYTE pbSrcStream = NULL;
    HRESULT hr;
    HDC dc;
 
    TRACE("filter %p, sample %p.\n", filter, pSample);
 
    hr = IMediaSample_GetPointer(pSample, &pbSrcStream);
    if (FAILED(hr))
    {
        ERR("Failed to get buffer pointer, hr %#lx.\n", hr);
        return hr;
    }
 
    dc = GetDC(filter->window.hwnd);
    StretchDIBits(dc, dst.left, dst.top, dst.right - dst.left, dst.bottom - dst.top,
            src.left, src.top, src.right - src.left, src.bottom - src.top, pbSrcStream,
            (BITMAPINFO *)get_bitmap_header(&filter->renderer.sink.pin.mt), DIB_RGB_COLORS, SRCCOPY);
    ReleaseDC(filter->window.hwnd, dc);
 
    return S_OK;
}

video_renderer_stop_stream()

static void video_renderer_stop_stream ( struct strmbase_renderer *  iface )

static

Definition at line 163 of file videorenderer.c.

{
    struct video_renderer *This = impl_from_strmbase_renderer(iface);
 
    TRACE("(%p)->()\n", This);
 
    if (This->window.AutoShow)
        /* Black it out */
        RedrawWindow(This->window.hwnd, NULL, NULL, RDW_INVALIDATE | RDW_ERASE);
}

VideoRenderer_AutoShowWindow()

static void VideoRenderer_AutoShowWindow ( struct video_renderer *  This )

static

Definition at line 76 of file videorenderer.c.

{
    if (This->window.AutoShow)
        ShowWindow(This->window.hwnd, SW_SHOW);
}

Referenced by video_renderer_init_stream().

VideoWindow_get_FullScreenMode()

static HRESULT WINAPI VideoWindow_get_FullScreenMode ( IVideoWindow *  iface, LONG *  FullScreenMode  )

static

Definition at line 272 of file videorenderer.c.

{
    struct video_renderer *This = impl_from_IVideoWindow(iface);
 
    TRACE("window %p, fullscreen %p.\n", This, FullScreenMode);
 
    if (!FullScreenMode)
        return E_POINTER;
 
    *FullScreenMode = This->FullScreenMode;
 
    return S_OK;
}

VideoWindow_put_FullScreenMode()

static HRESULT WINAPI VideoWindow_put_FullScreenMode ( IVideoWindow *  iface, LONG  fullscreen  )

static

Definition at line 287 of file videorenderer.c.

{
    struct video_renderer *filter = impl_from_IVideoWindow(iface);
    HWND window = filter->window.hwnd;
 
    FIXME("filter %p, fullscreen %ld.\n", filter, fullscreen);
 
    if (fullscreen == filter->FullScreenMode)
        return S_FALSE;
 
    if (fullscreen)
    {
        filter->saved_style = GetWindowLongW(window, GWL_STYLE);
        ShowWindow(window, SW_HIDE);
        SetParent(window, NULL);
        SetWindowLongW(window, GWL_STYLE, WS_POPUP);
        SetWindowPos(window, HWND_TOP, 0, 0,
                GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), SWP_SHOWWINDOW);
        GetWindowRect(window, &filter->window.dst);
    }
    else
    {
        ShowWindow(window, SW_HIDE);
        SetParent(window, filter->window.hwndOwner);
        SetWindowLongW(window, GWL_STYLE, filter->saved_style);
        GetClientRect(window, &filter->window.dst);
        SetWindowPos(window, 0, filter->window.dst.left, filter->window.dst.top,
                filter->window.dst.right, filter->window.dst.bottom, SWP_NOZORDER | SWP_SHOWWINDOW);
    }
    filter->FullScreenMode = fullscreen;
 
    return S_OK;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

quartz

)

Variable Documentation

IVideoWindow_VTable

const IVideoWindowVtbl IVideoWindow_VTable

static

Definition at line 321 of file videorenderer.c.

Referenced by video_renderer_create().

overlay_vtbl

const IOverlayVtbl overlay_vtbl

static

Initial value:

=
{
    overlay_QueryInterface,
    overlay_AddRef,
    overlay_Release,
    overlay_GetPalette,
    overlay_SetPalette,
    overlay_GetDefaultColorKey,
    overlay_GetColorKey,
    overlay_SetColorKey,
    overlay_GetWindowHandle,
    overlay_GetClipList,
    overlay_GetVideoPosition,
    overlay_Advise,
    overlay_Unadvise,
}

Definition at line 458 of file videorenderer.c.

Referenced by video_renderer_create().

renderer_ops

const struct strmbase_renderer_ops renderer_ops

static

Initial value:

=
{
    .renderer_query_accept = video_renderer_query_accept,
    .renderer_render = video_renderer_render,
    .renderer_init_stream = video_renderer_init_stream,
    .renderer_stop_stream = video_renderer_stop_stream,
    .renderer_destroy = video_renderer_destroy,
    .renderer_query_interface = video_renderer_query_interface,
    .renderer_pin_query_interface = video_renderer_pin_query_interface,
    .renderer_connect = video_renderer_connect,
}

Definition at line 209 of file videorenderer.c.

Referenced by video_renderer_create().

window_ops

const struct video_window_ops window_ops

static

Initial value:

=
{
    .get_default_rect = video_renderer_get_default_rect,
    .get_current_image = video_renderer_get_current_image,
}

Definition at line 266 of file videorenderer.c.

Referenced by video_renderer_create().