vmr7.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 "d3d9.h"
#include "videoacc.h"
#include "vmr9.h"
#include "wine/debug.h"

Include dependency graph for vmr7.c:

Go to the source code of this file.

Classes
struct	vmr7
struct	get_available_monitors_args

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (quartz)
static const BITMAPINFOHEADER *	get_bitmap_header (const AM_MEDIA_TYPE *mt)
static const BITMAPINFOHEADER *	get_filter_bitmap_header (const struct vmr7 *filter)
static struct vmr7 *	impl_from_video_window (struct video_window *iface)
static struct vmr7 *	impl_from_IAMCertifiedOutputProtection (IAMCertifiedOutputProtection *iface)
static struct vmr7 *	impl_from_IAMFilterMiscFlags (IAMFilterMiscFlags *iface)
static struct vmr7 *	impl_from_IVMRFilterConfig (IVMRFilterConfig *iface)
static struct vmr7 *	impl_from_IVMRMonitorConfig (IVMRMonitorConfig *iface)
static struct vmr7 *	impl_from_IVMRSurfaceAllocatorNotify (IVMRSurfaceAllocatorNotify *iface)
static struct vmr7 *	impl_from_IVMRWindowlessControl (IVMRWindowlessControl *iface)
static struct vmr7 *	impl_from_IBaseFilter (IBaseFilter *iface)
static void	copy_plane (BYTE **dstp, unsigned int dst_pitch, unsigned int dst_height, const BYTE **srcp, unsigned int src_pitch, int src_height)
static HRESULT	vmr_render (struct strmbase_renderer *iface, IMediaSample *sample)
static HRESULT	vmr_query_accept (struct strmbase_renderer *iface, const AM_MEDIA_TYPE *mt)
static HRESULT	initialize_device (struct vmr7 *filter, VMRALLOCATIONINFO *info, DWORD count)
static HRESULT	allocate_surfaces (struct vmr7 *filter, const AM_MEDIA_TYPE *mt)
static void	vmr_init_stream (struct strmbase_renderer *iface)
static void	vmr_start_stream (struct strmbase_renderer *iface)
static void	vmr_stop_stream (struct strmbase_renderer *iface)
static HRESULT	vmr_connect (struct strmbase_renderer *iface, const AM_MEDIA_TYPE *mt)
static void	deallocate_surfaces (struct vmr7 *filter)
static void	vmr_disconnect (struct strmbase_renderer *iface)
static void	vmr_destroy (struct strmbase_renderer *iface)
static HRESULT	vmr_query_interface (struct strmbase_renderer *iface, REFIID iid, void **out)
static HRESULT	vmr_pin_query_interface (struct strmbase_renderer *iface, REFIID iid, void **out)
static void	vmr_get_default_rect (struct video_window *iface, RECT *rect)
static HRESULT	vmr_get_current_image (struct video_window *iface, LONG *size, LONG *image)
static HRESULT WINAPI	certified_output_protection_QueryInterface (IAMCertifiedOutputProtection *iface, REFIID iid, void **out)
static ULONG WINAPI	certified_output_protection_AddRef (IAMCertifiedOutputProtection *iface)
static ULONG WINAPI	certified_output_protection_Release (IAMCertifiedOutputProtection *iface)
static HRESULT WINAPI	certified_output_protection_KeyExchange (IAMCertifiedOutputProtection *iface, GUID *random, BYTE **certificate, DWORD *size)
static HRESULT WINAPI	certified_output_protection_SessionSequenceStart (IAMCertifiedOutputProtection *iface, AMCOPPSignature *signature)
static HRESULT WINAPI	certified_output_protection_ProtectionCommand (IAMCertifiedOutputProtection *iface, const AMCOPPCommand *cmd)
static HRESULT WINAPI	certified_output_protection_ProtectionStatus (IAMCertifiedOutputProtection *iface, const AMCOPPStatusInput *input, AMCOPPStatusOutput *output)
static HRESULT WINAPI	misc_flags_QueryInterface (IAMFilterMiscFlags *iface, REFIID iid, void **out)
static ULONG WINAPI	misc_flags_AddRef (IAMFilterMiscFlags *iface)
static ULONG WINAPI	misc_flags_Release (IAMFilterMiscFlags *iface)
static ULONG WINAPI	misc_flags_GetMiscFlags (IAMFilterMiscFlags *iface)
static HRESULT WINAPI	filter_config_QueryInterface (IVMRFilterConfig *iface, REFIID iid, void **out)
static ULONG WINAPI	filter_config_AddRef (IVMRFilterConfig *iface)
static ULONG WINAPI	filter_config_Release (IVMRFilterConfig *iface)
static HRESULT WINAPI	filter_config_SetImageCompositor (IVMRFilterConfig *iface, IVMRImageCompositor *compositor)
static HRESULT WINAPI	filter_config_SetNumberOfStreams (IVMRFilterConfig *iface, DWORD count)
static HRESULT WINAPI	filter_config_GetNumberOfStreams (IVMRFilterConfig *iface, DWORD *count)
static HRESULT WINAPI	filter_config_SetRenderingPrefs (IVMRFilterConfig *iface, DWORD flags)
static HRESULT WINAPI	filter_config_GetRenderingPrefs (IVMRFilterConfig *iface, DWORD *flags)
static HRESULT WINAPI	filter_config_SetRenderingMode (IVMRFilterConfig *iface, DWORD mode)
static HRESULT WINAPI	filter_config_GetRenderingMode (IVMRFilterConfig *iface, DWORD *mode)
static BOOL CALLBACK	get_available_monitors_proc (HMONITOR monitor, HDC dc, RECT *rect, LPARAM ctx)
static HRESULT WINAPI	monitor_config_QueryInterface (IVMRMonitorConfig *iface, REFIID iid, void **out)
static ULONG WINAPI	monitor_config_AddRef (IVMRMonitorConfig *iface)
static ULONG WINAPI	monitor_config_Release (IVMRMonitorConfig *iface)
static HRESULT WINAPI	monitor_config_SetMonitor (IVMRMonitorConfig *iface, const VMRGUID *guid)
static HRESULT WINAPI	monitor_config_GetMonitor (IVMRMonitorConfig *iface, VMRGUID *guid)
static HRESULT WINAPI	monitor_config_SetDefaultMonitor (IVMRMonitorConfig *iface, const VMRGUID *guid)
static HRESULT WINAPI	monitor_config_GetDefaultMonitor (IVMRMonitorConfig *iface, VMRGUID *guid)
static HRESULT WINAPI	monitor_config_GetAvailableMonitors (IVMRMonitorConfig *iface, VMRMONITORINFO *info, DWORD capacity, DWORD *count)
static HRESULT WINAPI	windowless_control_QueryInterface (IVMRWindowlessControl *iface, REFIID iid, void **out)
static ULONG WINAPI	windowless_control_AddRef (IVMRWindowlessControl *iface)
static ULONG WINAPI	windowless_control_Release (IVMRWindowlessControl *iface)
static HRESULT WINAPI	windowless_control_GetNativeVideoSize (IVMRWindowlessControl *iface, LONG *width, LONG *height, LONG *aspect_width, LONG *aspect_height)
static HRESULT WINAPI	windowless_control_GetMinIdealVideoSize (IVMRWindowlessControl *iface, LONG *width, LONG *height)
static HRESULT WINAPI	windowless_control_GetMaxIdealVideoSize (IVMRWindowlessControl *iface, LONG *width, LONG *height)
static HRESULT WINAPI	windowless_control_SetVideoPosition (IVMRWindowlessControl *iface, const RECT *source, const RECT *dest)
static HRESULT WINAPI	windowless_control_GetVideoPosition (IVMRWindowlessControl *iface, RECT *source, RECT *dest)
static HRESULT WINAPI	windowless_control_GetAspectRatioMode (IVMRWindowlessControl *iface, DWORD *mode)
static HRESULT WINAPI	windowless_control_SetAspectRatioMode (IVMRWindowlessControl *iface, DWORD mode)
static HRESULT WINAPI	windowless_control_SetVideoClippingWindow (IVMRWindowlessControl *iface, HWND window)
static HRESULT WINAPI	windowless_control_RepaintVideo (IVMRWindowlessControl *iface, HWND window, HDC dc)
static HRESULT WINAPI	windowless_control_DisplayModeChanged (IVMRWindowlessControl *iface)
static HRESULT WINAPI	windowless_control_GetCurrentImage (IVMRWindowlessControl *iface, BYTE **image)
static HRESULT WINAPI	windowless_control_SetBorderColor (IVMRWindowlessControl *iface, COLORREF color)
static HRESULT WINAPI	windowless_control_GetBorderColor (IVMRWindowlessControl *iface, COLORREF *color)
static HRESULT WINAPI	windowless_control_SetColorKey (IVMRWindowlessControl *iface, COLORREF color)
static HRESULT WINAPI	windowless_control_GetColorKey (IVMRWindowlessControl *iface, COLORREF *color)
static HRESULT WINAPI	surface_allocator_notify_QueryInterface (IVMRSurfaceAllocatorNotify *iface, REFIID iid, void **out)
static ULONG WINAPI	surface_allocator_notify_AddRef (IVMRSurfaceAllocatorNotify *iface)
static ULONG WINAPI	surface_allocator_notify_Release (IVMRSurfaceAllocatorNotify *iface)
static HRESULT WINAPI	surface_allocator_notify_AdviseSurfaceAllocator (IVMRSurfaceAllocatorNotify *iface, DWORD_PTR cookie, IVMRSurfaceAllocator *allocator)
static HRESULT WINAPI	surface_allocator_notify_SetDDrawDevice (IVMRSurfaceAllocatorNotify *iface, IDirectDraw7 *device, HMONITOR monitor)
static HRESULT WINAPI	surface_allocator_notify_ChangeDDrawDevice (IVMRSurfaceAllocatorNotify *iface, IDirectDraw7 *device, HMONITOR monitor)
static HRESULT WINAPI	surface_allocator_notify_RestoreDDrawSurfaces (IVMRSurfaceAllocatorNotify *iface)
static HRESULT WINAPI	surface_allocator_notify_NotifyEvent (IVMRSurfaceAllocatorNotify *iface, LONG code, LONG_PTR param1, LONG_PTR param2)
static HRESULT WINAPI	surface_allocator_notify_SetBorderColor (IVMRSurfaceAllocatorNotify *iface, COLORREF color)
static struct vmr7 *	impl_from_IAMVideoAccelerator (IAMVideoAccelerator *iface)
static HRESULT WINAPI	video_accelerator_QueryInterface (IAMVideoAccelerator *iface, REFIID iid, void **out)
static ULONG WINAPI	video_accelerator_AddRef (IAMVideoAccelerator *iface)
static ULONG WINAPI	video_accelerator_Release (IAMVideoAccelerator *iface)
static HRESULT WINAPI	video_accelerator_GetVideoAcceleratorGUIDs (IAMVideoAccelerator *iface, DWORD *count, GUID *accelerators)
static HRESULT WINAPI	video_accelerator_GetUncompFormatsSupported (IAMVideoAccelerator *iface, const GUID *accelerator, DWORD *count, DDPIXELFORMAT *formats)
static HRESULT WINAPI	video_accelerator_GetInternalMemInfo (IAMVideoAccelerator *iface, const GUID *accelerator, const AMVAUncompDataInfo *format_info, AMVAInternalMemInfo *mem_info)
static HRESULT WINAPI	video_accelerator_GetCompBufferInfo (IAMVideoAccelerator *iface, const GUID *accelerator, const AMVAUncompDataInfo *uncompressed_info, DWORD *compressed_info_count, AMVACompBufferInfo *compressed_infos)
static HRESULT WINAPI	video_accelerator_GetInternalCompBufferInfo (IAMVideoAccelerator *iface, DWORD *count, AMVACompBufferInfo *infos)
static HRESULT WINAPI	video_accelerator_BeginFrame (IAMVideoAccelerator *iface, const AMVABeginFrameInfo *info)
static HRESULT WINAPI	video_accelerator_EndFrame (IAMVideoAccelerator *iface, const AMVAEndFrameInfo *info)
static HRESULT WINAPI	video_accelerator_GetBuffer (IAMVideoAccelerator *iface, DWORD type_index, DWORD buffer_index, BOOL read_only, void **buffer, LONG *stride)
static HRESULT WINAPI	video_accelerator_ReleaseBuffer (IAMVideoAccelerator *iface, DWORD type_index, DWORD buffer_index)
static HRESULT WINAPI	video_accelerator_Execute (IAMVideoAccelerator *iface, DWORD function, void *in_data, DWORD in_size, void *out_data, DWORD out_size, DWORD buffer_count, const AMVABUFFERINFO *buffers)
static HRESULT WINAPI	video_accelerator_QueryRenderStatus (IAMVideoAccelerator *iface, DWORD type_index, DWORD buffer_index, DWORD flags)
static HRESULT WINAPI	video_accelerator_DisplayFrame (IAMVideoAccelerator *iface, DWORD index, IMediaSample *sample)
static struct vmr7 *	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	vmr7_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 IAMCertifiedOutputProtectionVtbl	certified_output_protection_vtbl
static const IAMFilterMiscFlagsVtbl	misc_flags_vtbl
static const IVMRFilterConfigVtbl	filter_config_vtbl
static const IVMRMonitorConfigVtbl	monitor_config_vtbl
static const IVMRWindowlessControlVtbl	windowless_control_vtbl
static const IVMRSurfaceAllocatorNotifyVtbl	surface_allocator_notify_vtbl
static const IAMVideoAcceleratorVtbl	video_accelerator_vtbl
static const IOverlayVtbl	overlay_vtbl

Function Documentation

allocate_surfaces()

static HRESULT allocate_surfaces ( struct vmr7 *  filter, const AM_MEDIA_TYPE *  mt  )

static

Definition at line 342 of file vmr7.c.

{
    BITMAPINFOHEADER bitmap_header = *get_bitmap_header(mt);
    VMRALLOCATIONINFO info = {0};
    HRESULT hr = E_FAIL;
    DWORD count = 1;
 
    TRACE("Initializing in mode %u, our window %p, clipping window %p.\n",
            filter->mode, filter->window.hwnd, filter->clipping_window);
 
    if (filter->mode == VMRMode_Windowless && !filter->clipping_window)
        return S_OK;
 
    info.dwFlags = AMAP_DIRECTED_FLIP | AMAP_ALLOW_SYSMEM;
    info.lpHdr = &bitmap_header;
    info.dwMinBuffers = info.dwMaxBuffers = count;
    info.szAspectRatio.cx = info.szNativeSize.cx = bitmap_header.biWidth;
    info.szAspectRatio.cy = info.szNativeSize.cy = bitmap_header.biHeight;
 
    if (FAILED(hr = initialize_device(filter, &info, count)))
        free(filter->surfaces);
    return hr;
}

Referenced by vmr_connect().

certified_output_protection_AddRef()

static ULONG WINAPI certified_output_protection_AddRef ( IAMCertifiedOutputProtection *  iface )

static

Definition at line 588 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IAMCertifiedOutputProtection(iface);
 
    return IUnknown_AddRef(filter->renderer.filter.outer_unk);
}

certified_output_protection_KeyExchange()

static HRESULT WINAPI certified_output_protection_KeyExchange ( IAMCertifiedOutputProtection *  iface, GUID *  random, BYTE **  certificate, DWORD *  size  )

static

Definition at line 602 of file vmr7.c.

{
    FIXME("iface %p, random %p, certificate %p, size %p, stub!\n", iface, random, certificate, size);
    return VFW_E_NO_COPP_HW;
}

certified_output_protection_ProtectionCommand()

static HRESULT WINAPI certified_output_protection_ProtectionCommand ( IAMCertifiedOutputProtection *  iface, const AMCOPPCommand *  cmd  )

static

Definition at line 616 of file vmr7.c.

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

certified_output_protection_ProtectionStatus()

static HRESULT WINAPI certified_output_protection_ProtectionStatus ( IAMCertifiedOutputProtection *  iface, const AMCOPPStatusInput *  input, AMCOPPStatusOutput *  output  )

static

Definition at line 623 of file vmr7.c.

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

certified_output_protection_QueryInterface()

static HRESULT WINAPI certified_output_protection_QueryInterface ( IAMCertifiedOutputProtection *  iface, REFIID  iid, void **  out  )

static

Definition at line 580 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IAMCertifiedOutputProtection(iface);
 
    return IUnknown_QueryInterface(filter->renderer.filter.outer_unk, iid, out);
}

certified_output_protection_Release()

static ULONG WINAPI certified_output_protection_Release ( IAMCertifiedOutputProtection *  iface )

static

Definition at line 595 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IAMCertifiedOutputProtection(iface);
 
    return IUnknown_Release(filter->renderer.filter.outer_unk);
}

certified_output_protection_SessionSequenceStart()

static HRESULT WINAPI certified_output_protection_SessionSequenceStart ( IAMCertifiedOutputProtection *  iface, AMCOPPSignature *  signature  )

static

Definition at line 609 of file vmr7.c.

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

copy_plane()

static void copy_plane ( BYTE **  dstp, unsigned int  dst_pitch, unsigned int  dst_height, const BYTE **  srcp, unsigned int  src_pitch, int  src_height  )

static

Definition at line 128 of file vmr7.c.

{
    size_t copy_size = min(src_pitch, dst_pitch);
    const BYTE *src = *srcp;
    BYTE *dst = *dstp;
    unsigned int i;
 
    if (src_height < 0)
    {
        TRACE("Inverting image.\n");
 
        src_height = -src_height;
        src += src_height * src_pitch;
 
        for (i = 0; i < src_height; ++i)
        {
            src -= src_pitch;
            memcpy(dst, src, copy_size);
            dst += dst_pitch;
        }
    }
    else
    {
        for (i = 0; i < src_height; ++i)
        {
            memcpy(dst, src, copy_size);
            dst += dst_pitch;
            src += src_pitch;
        }
    }
 
    *srcp += src_pitch * src_height;
    *dstp += dst_pitch * dst_height;
}

Referenced by vmr_render().

deallocate_surfaces()

static void deallocate_surfaces ( struct vmr7 *  filter )

static

Definition at line 413 of file vmr7.c.

{
    if (filter->mode && filter->allocator && filter->presenter)
    {
        for (DWORD i = 0; i < filter->surface_count; ++i)
            IDirectDrawSurface7_Release(filter->surfaces[i]);
        free(filter->surfaces);
 
        IVMRSurfaceAllocator_FreeSurface(filter->allocator, filter->cookie);
        filter->surface_count = 0;
    }
}

Referenced by vmr_disconnect().

filter_config_AddRef()

static ULONG WINAPI filter_config_AddRef ( IVMRFilterConfig *  iface )

static

Definition at line 682 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRFilterConfig(iface);
 
    return IUnknown_AddRef(filter->renderer.filter.outer_unk);
}

filter_config_GetNumberOfStreams()

static HRESULT WINAPI filter_config_GetNumberOfStreams ( IVMRFilterConfig *  iface, DWORD *  count  )

static

Definition at line 730 of file vmr7.c.

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

filter_config_GetRenderingMode()

static HRESULT WINAPI filter_config_GetRenderingMode ( IVMRFilterConfig *  iface, DWORD *  mode  )

static

Definition at line 796 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRFilterConfig(iface);
 
    TRACE("filter %p, mode %p.\n", filter, mode);
 
    if (!mode)
        return E_POINTER;
 
    if (filter->mode)
        *mode = filter->mode;
    else
        *mode = VMRMode_Windowed;
 
    return S_OK;
}

filter_config_GetRenderingPrefs()

static HRESULT WINAPI filter_config_GetRenderingPrefs ( IVMRFilterConfig *  iface, DWORD *  flags  )

static

Definition at line 742 of file vmr7.c.

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

filter_config_QueryInterface()

static HRESULT WINAPI filter_config_QueryInterface ( IVMRFilterConfig *  iface, REFIID  iid, void **  out  )

static

Definition at line 675 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRFilterConfig(iface);
 
    return IUnknown_QueryInterface(filter->renderer.filter.outer_unk, iid, out);
}

filter_config_Release()

static ULONG WINAPI filter_config_Release ( IVMRFilterConfig *  iface )

static

Definition at line 689 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRFilterConfig(iface);
 
    return IUnknown_Release(filter->renderer.filter.outer_unk);
}

filter_config_SetImageCompositor()

static HRESULT WINAPI filter_config_SetImageCompositor ( IVMRFilterConfig *  iface, IVMRImageCompositor *  compositor  )

static

Definition at line 696 of file vmr7.c.

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

filter_config_SetNumberOfStreams()

static HRESULT WINAPI filter_config_SetNumberOfStreams ( IVMRFilterConfig *  iface, DWORD  count  )

static

Definition at line 703 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRFilterConfig(iface);
 
    FIXME("iface %p, count %lu, stub!\n", iface, count);
 
    if (!count)
    {
        WARN("Application requested zero streams; returning E_INVALIDARG.\n");
        return E_INVALIDARG;
    }
 
    EnterCriticalSection(&filter->renderer.filter.filter_cs);
 
    if (filter->stream_count)
    {
        LeaveCriticalSection(&filter->renderer.filter.filter_cs);
        WARN("Stream count is already set; returning VFW_E_WRONG_STATE.\n");
        return VFW_E_WRONG_STATE;
    }
 
    filter->stream_count = count;
 
    LeaveCriticalSection(&filter->renderer.filter.filter_cs);
    return S_OK;
}

filter_config_SetRenderingMode()

static HRESULT WINAPI filter_config_SetRenderingMode ( IVMRFilterConfig *  iface, DWORD  mode  )

static

Definition at line 748 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRFilterConfig(iface);
    IUnknown *default_presenter;
    HRESULT hr = S_OK;
 
    TRACE("filter %p, mode %lu.\n", filter, mode);
 
    EnterCriticalSection(&filter->renderer.filter.filter_cs);
 
    if (filter->mode)
    {
        LeaveCriticalSection(&filter->renderer.filter.filter_cs);
        return VFW_E_WRONG_STATE;
    }
 
    switch (mode)
    {
        case VMRMode_Windowed:
        case VMRMode_Windowless:
            if (FAILED(hr = vmr7_presenter_create(NULL, &default_presenter)))
            {
                ERR("Failed to create default presenter, hr %#lx.\n", hr);
                LeaveCriticalSection(&filter->renderer.filter.filter_cs);
                return hr;
            }
            IUnknown_QueryInterface(default_presenter, &IID_IVMRSurfaceAllocator, (void **)&filter->allocator);
            IUnknown_QueryInterface(default_presenter, &IID_IVMRImagePresenter, (void **)&filter->presenter);
            IUnknown_Release(default_presenter);
            break;
 
        case VMRMode_Renderless:
            break;
 
        default:
            LeaveCriticalSection(&filter->renderer.filter.filter_cs);
            return E_INVALIDARG;
    }
 
    if (mode != VMRMode_Windowed)
        video_window_cleanup(&filter->window);
 
    filter->mode = mode;
 
    LeaveCriticalSection(&filter->renderer.filter.filter_cs);
    return hr;
}

filter_config_SetRenderingPrefs()

static HRESULT WINAPI filter_config_SetRenderingPrefs ( IVMRFilterConfig *  iface, DWORD  flags  )

static

Definition at line 736 of file vmr7.c.

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

get_available_monitors_proc()

static BOOL CALLBACK get_available_monitors_proc ( HMONITOR  monitor, HDC  dc, RECT *  rect, LPARAM  ctx  )

static

Definition at line 835 of file vmr7.c.

{
    struct get_available_monitors_args *args = (struct get_available_monitors_args *)ctx;
    MONITORINFOEXW mi;
 
    if (args->info7 || args->info9)
    {
 
        if (!args->capacity)
            return FALSE;
 
        mi.cbSize = sizeof(mi);
        if (!GetMonitorInfoW(monitor, (MONITORINFO*)&mi))
            return TRUE;
 
        /* fill VMRMONITORINFO struct */
        if (args->info7)
        {
            VMRMONITORINFO *info = args->info7++;
            memset(info, 0, sizeof(*info));
 
            if (args->count > 0)
            {
                info->guid.pGUID = &info->guid.GUID;
                info->guid.GUID.Data4[7] = args->count;
            }
            else
                info->guid.pGUID = NULL;
 
            info->rcMonitor     = mi.rcMonitor;
            info->hMon          = monitor;
            info->dwFlags       = mi.dwFlags;
 
            lstrcpynW(info->szDevice, mi.szDevice, ARRAY_SIZE(info->szDevice));
 
            /* FIXME: how to get these values? */
            info->szDescription[0] = 0;
        }
 
        /* fill VMR9MonitorInfo struct */
        if (args->info9)
        {
            VMR9MonitorInfo *info = args->info9++;
            memset(info, 0, sizeof(*info));
 
            info->uDevID        = 0; /* FIXME */
            info->rcMonitor     = mi.rcMonitor;
            info->hMon          = monitor;
            info->dwFlags       = mi.dwFlags;
 
            lstrcpynW(info->szDevice, mi.szDevice, ARRAY_SIZE(info->szDevice));
 
            /* FIXME: how to get these values? */
            info->szDescription[0] = 0;
            info->dwVendorId    = 0;
            info->dwDeviceId    = 0;
            info->dwSubSysId    = 0;
            info->dwRevision    = 0;
        }
 
        args->capacity--;
    }
 
    args->count++;
    return TRUE;
}

Referenced by monitor_config_GetAvailableMonitors().

get_bitmap_header()

static const BITMAPINFOHEADER * get_bitmap_header ( const AM_MEDIA_TYPE *  mt )

static

Definition at line 43 of file vmr7.c.

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

Referenced by allocate_surfaces(), get_filter_bitmap_header(), and vmr_connect().

get_filter_bitmap_header()

static const BITMAPINFOHEADER * get_filter_bitmap_header ( const struct vmr7 *  filter )

static

Definition at line 83 of file vmr7.c.

{
    return get_bitmap_header(&filter->renderer.sink.pin.mt);
}

Referenced by vmr_get_default_rect(), vmr_render(), and windowless_control_GetNativeVideoSize().

impl_from_IAMCertifiedOutputProtection()

static struct vmr7 * impl_from_IAMCertifiedOutputProtection ( IAMCertifiedOutputProtection *  iface )

static

Definition at line 93 of file vmr7.c.

{
    return CONTAINING_RECORD(iface, struct vmr7, IAMCertifiedOutputProtection_iface);
}

Referenced by certified_output_protection_AddRef(), certified_output_protection_QueryInterface(), and certified_output_protection_Release().

impl_from_IAMFilterMiscFlags()

static struct vmr7 * impl_from_IAMFilterMiscFlags ( IAMFilterMiscFlags *  iface )

static

Definition at line 98 of file vmr7.c.

{
    return CONTAINING_RECORD(iface, struct vmr7, IAMFilterMiscFlags_iface);
}

Referenced by misc_flags_AddRef(), misc_flags_QueryInterface(), and misc_flags_Release().

impl_from_IAMVideoAccelerator()

static struct vmr7 * impl_from_IAMVideoAccelerator ( IAMVideoAccelerator *  iface )

static

Definition at line 1307 of file vmr7.c.

{
    return CONTAINING_RECORD(iface, struct vmr7, IAMVideoAccelerator_iface);
}

Referenced by video_accelerator_AddRef(), video_accelerator_QueryInterface(), and video_accelerator_Release().

impl_from_IBaseFilter()

static struct vmr7 * impl_from_IBaseFilter ( IBaseFilter *  iface )

static

Definition at line 123 of file vmr7.c.

{
    return CONTAINING_RECORD(iface, struct vmr7, renderer.filter.IBaseFilter_iface);
}

Referenced by vmr_connect(), vmr_destroy(), vmr_disconnect(), vmr_init_stream(), vmr_pin_query_interface(), vmr_query_interface(), vmr_render(), vmr_start_stream(), and vmr_stop_stream().

impl_from_IOverlay()

static struct vmr7 * impl_from_IOverlay ( IOverlay *  iface )

static

Definition at line 1443 of file vmr7.c.

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

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

impl_from_IVMRFilterConfig()

static struct vmr7 * impl_from_IVMRFilterConfig ( IVMRFilterConfig *  iface )

static

Definition at line 103 of file vmr7.c.

{
    return CONTAINING_RECORD(iface, struct vmr7, IVMRFilterConfig_iface);
}

Referenced by filter_config_AddRef(), filter_config_GetRenderingMode(), filter_config_QueryInterface(), filter_config_Release(), filter_config_SetNumberOfStreams(), and filter_config_SetRenderingMode().

impl_from_IVMRMonitorConfig()

static struct vmr7 * impl_from_IVMRMonitorConfig ( IVMRMonitorConfig *  iface )

static

Definition at line 108 of file vmr7.c.

{
    return CONTAINING_RECORD(iface, struct vmr7, IVMRMonitorConfig_iface);
}

Referenced by monitor_config_AddRef(), monitor_config_GetAvailableMonitors(), monitor_config_QueryInterface(), and monitor_config_Release().

impl_from_IVMRSurfaceAllocatorNotify()

static struct vmr7 * impl_from_IVMRSurfaceAllocatorNotify ( IVMRSurfaceAllocatorNotify *  iface )

static

Definition at line 113 of file vmr7.c.

{
    return CONTAINING_RECORD(iface, struct vmr7, IVMRSurfaceAllocatorNotify_iface);
}

Referenced by surface_allocator_notify_AddRef(), surface_allocator_notify_AdviseSurfaceAllocator(), surface_allocator_notify_QueryInterface(), and surface_allocator_notify_Release().

impl_from_IVMRWindowlessControl()

static struct vmr7 * impl_from_IVMRWindowlessControl ( IVMRWindowlessControl *  iface )

static

Definition at line 118 of file vmr7.c.

{
    return CONTAINING_RECORD(iface, struct vmr7, IVMRWindowlessControl_iface);
}

Referenced by windowless_control_AddRef(), windowless_control_GetNativeVideoSize(), windowless_control_GetVideoPosition(), windowless_control_QueryInterface(), windowless_control_Release(), windowless_control_SetVideoClippingWindow(), and windowless_control_SetVideoPosition().

impl_from_video_window()

static struct vmr7 * impl_from_video_window ( struct video_window *  iface )

static

Definition at line 88 of file vmr7.c.

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

Referenced by vmr_get_default_rect().

initialize_device()

static HRESULT initialize_device ( struct vmr7 *  filter, VMRALLOCATIONINFO *  info, DWORD  count  )

static

Definition at line 298 of file vmr7.c.

{
    IDirectDrawSurface7 *frontbuffer, *prev;
    IVMRWindowlessControl *control;
    HRESULT hr;
 
    if (FAILED(hr = IVMRSurfaceAllocator_AllocateSurface(filter->allocator,
            filter->cookie, info, &count, &frontbuffer)))
    {
        WARN("Failed to allocate surface, hr %#lx.\n", hr);
        return hr;
    }
 
    if (filter->mode != VMRMode_Renderless)
    {
        IVMRSurfaceAllocator_QueryInterface(filter->allocator, &IID_IVMRWindowlessControl, (void **)&control);
        IVMRWindowlessControl_SetVideoClippingWindow(control,
                filter->mode == VMRMode_Windowed ? filter->window.hwnd : filter->clipping_window);
        IVMRWindowlessControl_Release(control);
    }
 
    if (!(filter->surfaces = calloc(count, sizeof(IDirectDrawSurface7 *))))
        return E_OUTOFMEMORY;
    filter->surface_count = count;
    filter->surface_index = 0;
 
    prev = frontbuffer;
    for (DWORD i = 0; i < count; ++i)
    {
        DDSCAPS2 caps = {.dwCaps = DDSCAPS_FLIP};
 
        if (FAILED(hr = IDirectDrawSurface7_GetAttachedSurface(prev, &caps, &filter->surfaces[i])))
        {
            ERR("Failed to get surface %lu, hr %#lx.\n", i, hr);
            while (i--)
                IDirectDrawSurface7_Release(filter->surfaces[i]);
            IVMRSurfaceAllocator_FreeSurface(filter->allocator, filter->cookie);
            return hr;
        }
    }
 
    return hr;
}

Referenced by allocate_surfaces().

misc_flags_AddRef()

static ULONG WINAPI misc_flags_AddRef ( IAMFilterMiscFlags *  iface )

static

Definition at line 648 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IAMFilterMiscFlags(iface);
 
    return IUnknown_AddRef(filter->renderer.filter.outer_unk);
}

misc_flags_GetMiscFlags()

static ULONG WINAPI misc_flags_GetMiscFlags ( IAMFilterMiscFlags *  iface )

static

Definition at line 662 of file vmr7.c.

{
    return AM_FILTER_MISC_FLAGS_IS_RENDERER;
}

misc_flags_QueryInterface()

static HRESULT WINAPI misc_flags_QueryInterface ( IAMFilterMiscFlags *  iface, REFIID  iid, void **  out  )

static

Definition at line 641 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IAMFilterMiscFlags(iface);
 
    return IUnknown_QueryInterface(filter->renderer.filter.outer_unk, iid, out);
}

misc_flags_Release()

static ULONG WINAPI misc_flags_Release ( IAMFilterMiscFlags *  iface )

static

Definition at line 655 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IAMFilterMiscFlags(iface);
 
    return IUnknown_Release(filter->renderer.filter.outer_unk);
}

monitor_config_AddRef()

static ULONG WINAPI monitor_config_AddRef ( IVMRMonitorConfig *  iface )

static

Definition at line 909 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRMonitorConfig(iface);
 
    return IUnknown_AddRef(filter->renderer.filter.outer_unk);
}

monitor_config_GetAvailableMonitors()

static HRESULT WINAPI monitor_config_GetAvailableMonitors ( IVMRMonitorConfig *  iface, VMRMONITORINFO *  info, DWORD  capacity, DWORD *  count  )

static

Definition at line 965 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRMonitorConfig(iface);
    struct get_available_monitors_args args;
 
    TRACE("filter %p, info %p, capacity %lu, count %p.\n", filter, info, capacity, count);
 
    if (!count)
        return E_POINTER;
 
    if (info && !capacity)
        return E_INVALIDARG;
 
    args.info7 = info;
    args.info9 = NULL;
    args.capacity = capacity;
    args.count = 0;
    EnumDisplayMonitors(NULL, NULL, get_available_monitors_proc, (LPARAM)&args);
 
    *count = args.count;
    return S_OK;
}

monitor_config_GetDefaultMonitor()

static HRESULT WINAPI monitor_config_GetDefaultMonitor ( IVMRMonitorConfig *  iface, VMRGUID *  guid  )

static

Definition at line 954 of file vmr7.c.

{
    FIXME("iface %p, guid %p, stub!\n", iface, guid);
 
    if (!guid)
        return E_POINTER;
 
    guid->pGUID = NULL; /* default DirectDraw device */
    return S_OK;
}

monitor_config_GetMonitor()

static HRESULT WINAPI monitor_config_GetMonitor ( IVMRMonitorConfig *  iface, VMRGUID *  guid  )

static

Definition at line 933 of file vmr7.c.

{
    FIXME("iface %p, guid %p, stub!\n", iface, guid);
 
    if (!guid)
        return E_POINTER;
 
    guid->pGUID = NULL; /* default DirectDraw device */
    return S_OK;
}

monitor_config_QueryInterface()

static HRESULT WINAPI monitor_config_QueryInterface ( IVMRMonitorConfig *  iface, REFIID  iid, void **  out  )

static

Definition at line 902 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRMonitorConfig(iface);
 
    return IUnknown_QueryInterface(filter->renderer.filter.outer_unk, iid, out);
}

monitor_config_Release()

static ULONG WINAPI monitor_config_Release ( IVMRMonitorConfig *  iface )

static

Definition at line 916 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRMonitorConfig(iface);
 
    return IUnknown_Release(filter->renderer.filter.outer_unk);
}

monitor_config_SetDefaultMonitor()

static HRESULT WINAPI monitor_config_SetDefaultMonitor ( IVMRMonitorConfig *  iface, const VMRGUID *  guid  )

static

Definition at line 944 of file vmr7.c.

{
    FIXME("iface %p, guid %p, stub!\n", iface, guid);
 
    if (!guid)
        return E_POINTER;
 
    return S_OK;
}

monitor_config_SetMonitor()

static HRESULT WINAPI monitor_config_SetMonitor ( IVMRMonitorConfig *  iface, const VMRGUID *  guid  )

static

Definition at line 923 of file vmr7.c.

{
    FIXME("iface %p, guid %p, stub!\n", iface, guid);
 
    if (!guid)
        return E_POINTER;
 
    return S_OK;
}

overlay_AddRef()

static ULONG WINAPI overlay_AddRef ( IOverlay *  iface )

static

Definition at line 1455 of file vmr7.c.

{
    struct vmr7 *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 1524 of file vmr7.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 1512 of file vmr7.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 1487 of file vmr7.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 1481 of file vmr7.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 1469 of file vmr7.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 1518 of file vmr7.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 1499 of file vmr7.c.

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

overlay_QueryInterface()

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

static

Definition at line 1448 of file vmr7.c.

{
    struct vmr7 *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 1462 of file vmr7.c.

{
    struct vmr7 *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 1493 of file vmr7.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 1475 of file vmr7.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 1530 of file vmr7.c.

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

surface_allocator_notify_AddRef()

static ULONG WINAPI surface_allocator_notify_AddRef ( IVMRSurfaceAllocatorNotify *  iface )

static

Definition at line 1208 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRSurfaceAllocatorNotify(iface);
 
    return IUnknown_AddRef(filter->renderer.filter.outer_unk);
}

surface_allocator_notify_AdviseSurfaceAllocator()

static HRESULT WINAPI surface_allocator_notify_AdviseSurfaceAllocator ( IVMRSurfaceAllocatorNotify *  iface, DWORD_PTR  cookie, IVMRSurfaceAllocator *  allocator  )

static

Definition at line 1222 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRSurfaceAllocatorNotify(iface);
    IVMRImagePresenter *presenter;
 
    TRACE("filter %p, cookie %#Ix, allocator %p.\n", filter, cookie, allocator);
 
    EnterCriticalSection(&filter->renderer.filter.filter_cs);
 
    filter->cookie = cookie;
 
    if (filter->renderer.sink.pin.peer)
    {
        LeaveCriticalSection(&filter->renderer.filter.filter_cs);
        WARN("Attempt to set allocator while connected; returning VFW_E_WRONG_STATE.\n");
        return VFW_E_WRONG_STATE;
    }
 
    if (FAILED(IVMRSurfaceAllocator_QueryInterface(allocator, &IID_IVMRImagePresenter, (void **)&presenter)))
    {
        LeaveCriticalSection(&filter->renderer.filter.filter_cs);
        return E_NOINTERFACE;
    }
 
    if (filter->allocator)
    {
        IVMRImagePresenter_Release(filter->presenter);
        IVMRSurfaceAllocator_Release(filter->allocator);
    }
    filter->allocator = allocator;
    filter->presenter = presenter;
    IVMRSurfaceAllocator_AddRef(allocator);
 
    LeaveCriticalSection(&filter->renderer.filter.filter_cs);
    return S_OK;
}

surface_allocator_notify_ChangeDDrawDevice()

static HRESULT WINAPI surface_allocator_notify_ChangeDDrawDevice ( IVMRSurfaceAllocatorNotify *  iface, IDirectDraw7 *  device, HMONITOR  monitor  )

static

Definition at line 1267 of file vmr7.c.

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

surface_allocator_notify_NotifyEvent()

static HRESULT WINAPI surface_allocator_notify_NotifyEvent ( IVMRSurfaceAllocatorNotify *  iface, LONG  code, LONG_PTR  param1, LONG_PTR  param2  )

static

Definition at line 1280 of file vmr7.c.

{
    FIXME("iface %p, code %#lx, param1 %#Ix, param2 %#Ix, stub!\n", iface, code, param1, param2);
    return E_NOTIMPL;
}

surface_allocator_notify_QueryInterface()

static HRESULT WINAPI surface_allocator_notify_QueryInterface ( IVMRSurfaceAllocatorNotify *  iface, REFIID  iid, void **  out  )

static

Definition at line 1200 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRSurfaceAllocatorNotify(iface);
 
    return IUnknown_QueryInterface(filter->renderer.filter.outer_unk, iid, out);
}

surface_allocator_notify_Release()

static ULONG WINAPI surface_allocator_notify_Release ( IVMRSurfaceAllocatorNotify *  iface )

static

Definition at line 1215 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRSurfaceAllocatorNotify(iface);
 
    return IUnknown_Release(filter->renderer.filter.outer_unk);
}

surface_allocator_notify_RestoreDDrawSurfaces()

static HRESULT WINAPI surface_allocator_notify_RestoreDDrawSurfaces ( IVMRSurfaceAllocatorNotify *  iface )

static

Definition at line 1274 of file vmr7.c.

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

surface_allocator_notify_SetBorderColor()

static HRESULT WINAPI surface_allocator_notify_SetBorderColor ( IVMRSurfaceAllocatorNotify *  iface, COLORREF  color  )

static

Definition at line 1287 of file vmr7.c.

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

surface_allocator_notify_SetDDrawDevice()

static HRESULT WINAPI surface_allocator_notify_SetDDrawDevice ( IVMRSurfaceAllocatorNotify *  iface, IDirectDraw7 *  device, HMONITOR  monitor  )

static

Definition at line 1260 of file vmr7.c.

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

video_accelerator_AddRef()

static ULONG WINAPI video_accelerator_AddRef ( IAMVideoAccelerator *  iface )

static

Definition at line 1319 of file vmr7.c.

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

video_accelerator_BeginFrame()

static HRESULT WINAPI video_accelerator_BeginFrame ( IAMVideoAccelerator *  iface, const AMVABeginFrameInfo *  info  )

static

Definition at line 1372 of file vmr7.c.

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

video_accelerator_DisplayFrame()

static HRESULT WINAPI video_accelerator_DisplayFrame ( IAMVideoAccelerator *  iface, DWORD  index, IMediaSample *  sample  )

static

Definition at line 1417 of file vmr7.c.

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

video_accelerator_EndFrame()

static HRESULT WINAPI video_accelerator_EndFrame ( IAMVideoAccelerator *  iface, const AMVAEndFrameInfo *  info  )

static

Definition at line 1378 of file vmr7.c.

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

video_accelerator_Execute()

static HRESULT WINAPI video_accelerator_Execute ( IAMVideoAccelerator *  iface, DWORD  function, void *  in_data, DWORD  in_size, void *  out_data, DWORD  out_size, DWORD  buffer_count, const AMVABUFFERINFO *  buffers  )

static

Definition at line 1399 of file vmr7.c.

{
    FIXME("iface %p, function %#lx, in_data %p, in_size %lu,"
            " out_data %p, out_size %lu, buffer_count %lu, buffers %p, stub!\n",
            iface, function, in_data, in_size, out_data, out_size, buffer_count, buffers);
    return E_NOTIMPL;
}

video_accelerator_GetBuffer()

static HRESULT WINAPI video_accelerator_GetBuffer ( IAMVideoAccelerator *  iface, DWORD  type_index, DWORD  buffer_index, BOOL  read_only, void **  buffer, LONG *  stride  )

static

Definition at line 1384 of file vmr7.c.

{
    FIXME("iface %p, type_index %lu, buffer_index %lu, read_only %d, buffer %p, stride %p, stub!\n",
            iface, type_index, buffer_index, read_only, buffer, stride);
    return E_NOTIMPL;
}

video_accelerator_GetCompBufferInfo()

static HRESULT WINAPI video_accelerator_GetCompBufferInfo ( IAMVideoAccelerator *  iface, const GUID *  accelerator, const AMVAUncompDataInfo *  uncompressed_info, DWORD *  compressed_info_count, AMVACompBufferInfo *  compressed_infos  )

static

Definition at line 1356 of file vmr7.c.

{
    FIXME("iface %p, accelerator %s, uncompressed_info %p, compressed_info_count %p, compressed_infos %p, stub!\n",
            iface, debugstr_guid(accelerator), uncompressed_info, compressed_info_count, compressed_infos);
    return E_NOTIMPL;
}

video_accelerator_GetInternalCompBufferInfo()

static HRESULT WINAPI video_accelerator_GetInternalCompBufferInfo ( IAMVideoAccelerator *  iface, DWORD *  count, AMVACompBufferInfo *  infos  )

static

Definition at line 1365 of file vmr7.c.

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

video_accelerator_GetInternalMemInfo()

static HRESULT WINAPI video_accelerator_GetInternalMemInfo ( IAMVideoAccelerator *  iface, const GUID *  accelerator, const AMVAUncompDataInfo *  format_info, AMVAInternalMemInfo *  mem_info  )

static

Definition at line 1348 of file vmr7.c.

{
    FIXME("iface %p, accelerator %s, format_info %p, mem_info %p, stub!\n",
            iface, debugstr_guid(accelerator), format_info, mem_info);
    return E_NOTIMPL;
}

video_accelerator_GetUncompFormatsSupported()

static HRESULT WINAPI video_accelerator_GetUncompFormatsSupported ( IAMVideoAccelerator *  iface, const GUID *  accelerator, DWORD *  count, DDPIXELFORMAT *  formats  )

static

Definition at line 1340 of file vmr7.c.

{
    FIXME("iface %p, accelerator %s, count %p, formats %p, stub!\n",
            iface, debugstr_guid(accelerator), count, formats);
    return E_NOTIMPL;
}

video_accelerator_GetVideoAcceleratorGUIDs()

static HRESULT WINAPI video_accelerator_GetVideoAcceleratorGUIDs ( IAMVideoAccelerator *  iface, DWORD *  count, GUID *  accelerators  )

static

Definition at line 1333 of file vmr7.c.

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

video_accelerator_QueryInterface()

static HRESULT WINAPI video_accelerator_QueryInterface ( IAMVideoAccelerator *  iface, REFIID  iid, void **  out  )

static

Definition at line 1312 of file vmr7.c.

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

video_accelerator_QueryRenderStatus()

static HRESULT WINAPI video_accelerator_QueryRenderStatus ( IAMVideoAccelerator *  iface, DWORD  type_index, DWORD  buffer_index, DWORD  flags  )

static

Definition at line 1409 of file vmr7.c.

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

video_accelerator_Release()

static ULONG WINAPI video_accelerator_Release ( IAMVideoAccelerator *  iface )

static

Definition at line 1326 of file vmr7.c.

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

video_accelerator_ReleaseBuffer()

static HRESULT WINAPI video_accelerator_ReleaseBuffer ( IAMVideoAccelerator *  iface, DWORD  type_index, DWORD  buffer_index  )

static

Definition at line 1392 of file vmr7.c.

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

vmr7_create()

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

Definition at line 1553 of file vmr7.c.

{
    struct vmr7 *object;
    HRESULT hr;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    strmbase_renderer_init(&object->renderer, outer, &CLSID_VideoMixingRenderer, L"VMR Input0", &renderer_ops);
    object->IAMCertifiedOutputProtection_iface.lpVtbl = &certified_output_protection_vtbl;
    object->IAMFilterMiscFlags_iface.lpVtbl = &misc_flags_vtbl;
    object->IVMRFilterConfig_iface.lpVtbl = &filter_config_vtbl;
    object->IVMRMonitorConfig_iface.lpVtbl = &monitor_config_vtbl;
    object->IVMRSurfaceAllocatorNotify_iface.lpVtbl = &surface_allocator_notify_vtbl;
    object->IVMRWindowlessControl_iface.lpVtbl = &windowless_control_vtbl;
 
    object->IAMVideoAccelerator_iface.lpVtbl = &video_accelerator_vtbl;
    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;
    }
 
    object->mixing_prefs = MixerPref9_NoDecimation | MixerPref9_ARAdjustXorY
            | MixerPref9_BiLinearFiltering | MixerPref9_RenderTargetRGB;
 
    TRACE("Created VMR %p.\n", object);
    *out = &object->renderer.filter.IUnknown_inner;
    return S_OK;
}

Referenced by video_renderer_default_create().

vmr_connect()

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

static

Definition at line 389 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
    const BITMAPINFOHEADER *bitmap_header = get_bitmap_header(mt);
    HWND window = filter->window.hwnd;
    HRESULT hr;
    RECT rect;
 
    SetRect(&rect, 0, 0, bitmap_header->biWidth, bitmap_header->biHeight);
    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);
 
    if (filter->mode
            || SUCCEEDED(hr = IVMRFilterConfig_SetRenderingMode(&filter->IVMRFilterConfig_iface, VMRMode_Windowed)))
        hr = allocate_surfaces(filter, mt);
 
    return hr;
}

vmr_destroy()

static void vmr_destroy ( struct strmbase_renderer *  iface )

static

Definition at line 433 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
 
    video_window_cleanup(&filter->window);
 
    if (filter->allocator)
    {
        if (filter->surface_count)
            IVMRSurfaceAllocator_FreeSurface(filter->allocator, filter->cookie);
        IVMRSurfaceAllocator_Release(filter->allocator);
    }
    if (filter->presenter)
        IVMRImagePresenter_Release(filter->presenter);
 
    filter->surface_count = 0;
 
    strmbase_renderer_cleanup(&filter->renderer);
    free(filter);
}

vmr_disconnect()

static void vmr_disconnect ( struct strmbase_renderer *  iface )

static

Definition at line 426 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
 
    deallocate_surfaces(filter);
}

vmr_get_current_image()

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

static

Definition at line 518 of file vmr7.c.

{
    FIXME("stub!\n");
    return E_NOTIMPL;
}

vmr_get_default_rect()

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

static

Definition at line 510 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_video_window(iface);
    const BITMAPINFOHEADER *bitmap_header = get_filter_bitmap_header(filter);
 
    SetRect(rect, 0, 0, bitmap_header->biWidth, bitmap_header->biHeight);
}

vmr_init_stream()

static void vmr_init_stream ( struct strmbase_renderer *  iface )

static

Definition at line 366 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
 
    if (filter->window.hwnd && filter->window.AutoShow)
        ShowWindow(filter->window.hwnd, SW_SHOW);
}

vmr_pin_query_interface()

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

static

Definition at line 481 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
 
    if (IsEqualGUID(iid, &IID_IAMVideoAccelerator))
        *out = &filter->IAMVideoAccelerator_iface;
    else if (IsEqualGUID(iid, &IID_IOverlay))
        *out = &filter->IOverlay_iface;
    else
        return E_NOINTERFACE;
 
    IUnknown_AddRef((IUnknown *)*out);
    return S_OK;
}

vmr_query_accept()

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

static

Definition at line 286 of file vmr7.c.

{
    if (!IsEqualIID(&mt->majortype, &MEDIATYPE_Video) || !mt->pbFormat)
        return S_FALSE;
 
    if (!IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo)
            && !IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo2))
        return S_FALSE;
 
    return S_OK;
}

vmr_query_interface()

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

static

Definition at line 454 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
 
    if (IsEqualGUID(iid, &IID_IVideoWindow))
        *out = &filter->window.IVideoWindow_iface;
    else if (IsEqualGUID(iid, &IID_IBasicVideo))
        *out = &filter->window.IBasicVideo_iface;
    else if (IsEqualGUID(iid, &IID_IAMCertifiedOutputProtection))
        *out = &filter->IAMCertifiedOutputProtection_iface;
    else if (IsEqualGUID(iid, &IID_IAMFilterMiscFlags))
        *out = &filter->IAMFilterMiscFlags_iface;
    else if (IsEqualGUID(iid, &IID_IVMRFilterConfig))
        *out = &filter->IVMRFilterConfig_iface;
    else if (IsEqualGUID(iid, &IID_IVMRMonitorConfig))
        *out = &filter->IVMRMonitorConfig_iface;
    else if (IsEqualGUID(iid, &IID_IVMRSurfaceAllocatorNotify) && filter->mode == VMRMode_Renderless)
        *out = &filter->IVMRSurfaceAllocatorNotify_iface;
    else if (IsEqualGUID(iid, &IID_IVMRWindowlessControl) && filter->mode == VMRMode_Windowless)
        *out = &filter->IVMRWindowlessControl_iface;
    else
        return E_NOINTERFACE;
 
    IUnknown_AddRef((IUnknown *)*out);
    return S_OK;
}

vmr_render()

static HRESULT vmr_render ( struct strmbase_renderer *  iface, IMediaSample *  sample  )

static

Definition at line 164 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
    unsigned int data_size, width, depth, src_pitch;
    const BITMAPINFOHEADER *bitmap_header;
    REFERENCE_TIME start_time, end_time;
    VMRPRESENTATIONINFO info = {0};
    DDSURFACEDESC2 surface_desc;
    BYTE *data = NULL;
    HRESULT hr;
    int height;
 
    TRACE("filter %p, sample %p.\n", filter, sample);
 
    if (!filter->allocator || !filter->presenter)
    {
        ERR("No presenter.\n");
        return S_FALSE;
    }
 
    info.dwFlags = VMR9Sample_SrcDstRectsValid;
 
    if (SUCCEEDED(hr = IMediaSample_GetTime(sample, &start_time, &end_time)))
        info.dwFlags |= VMR9Sample_TimeValid;
 
    if (IMediaSample_IsDiscontinuity(sample) == S_OK)
        info.dwFlags |= VMR9Sample_Discontinuity;
 
    if (IMediaSample_IsPreroll(sample) == S_OK)
        info.dwFlags |= VMR9Sample_Preroll;
 
    if (IMediaSample_IsSyncPoint(sample) == S_OK)
        info.dwFlags |= VMR9Sample_SyncPoint;
 
    if (FAILED(hr = IMediaSample_GetPointer(sample, &data)))
    {
        ERR("Failed to get pointer to sample data, hr %#lx.\n", hr);
        return hr;
    }
    data_size = IMediaSample_GetActualDataLength(sample);
    TRACE("Sample size %u.\n", data_size);
 
    bitmap_header = get_filter_bitmap_header(filter);
    width = bitmap_header->biWidth;
    height = bitmap_header->biHeight;
    depth = bitmap_header->biBitCount;
    if (bitmap_header->biCompression == mmioFOURCC('N','V','1','2')
            || bitmap_header->biCompression == mmioFOURCC('Y','V','1','2'))
        src_pitch = (width + 3) & ~3;
    else /* packed YUV (UYVY or YUY2) or RGB */
        src_pitch = ((width * depth / 8) + 3) & ~3;
 
    info.dwFlags = VMRSample_TimeValid;
    info.rtStart = start_time;
    info.rtEnd = end_time;
    info.szAspectRatio.cx = width;
    info.szAspectRatio.cy = height;
    info.lpSurf = filter->surfaces[(--filter->surface_index) % filter->surface_count];
 
    hr = IVMRSurfaceAllocator_PrepareSurface(filter->allocator, filter->cookie, info.lpSurf, 0);
    if (hr != S_OK)
        ERR("PrepareSurface() returned %#lx.\n", hr);
 
    surface_desc.dwSize = sizeof(surface_desc);
    if (FAILED(hr = IDirectDrawSurface7_Lock(info.lpSurf, NULL,
            &surface_desc, DDLOCK_DISCARDCONTENTS | DDLOCK_WAIT, NULL)))
    {
        ERR("Failed to lock surface, hr %#lx.\n", hr);
        return hr;
    }
 
    if (width > surface_desc.dwWidth || abs(height)  > surface_desc.dwHeight)
    {
        FIXME("src surface (%ux%u) larger than rendering surface (%lux%lu).\n", width, height,
                surface_desc.dwWidth, surface_desc.dwHeight);
    }
 
    if (bitmap_header->biCompression == mmioFOURCC('N','V','1','2'))
    {
        BYTE *dst = surface_desc.lpSurface;
        const BYTE *src = data;
 
        copy_plane(&dst, surface_desc.lPitch, surface_desc.dwHeight, &src, src_pitch, height);
        copy_plane(&dst, surface_desc.lPitch, surface_desc.dwHeight / 2, &src, src_pitch, height / 2);
    }
    else if (bitmap_header->biCompression == mmioFOURCC('Y','V','1','2'))
    {
        BYTE *dst = surface_desc.lpSurface;
        const BYTE *src = data;
 
        copy_plane(&dst, surface_desc.lPitch, surface_desc.dwHeight, &src, src_pitch, height);
        copy_plane(&dst, surface_desc.lPitch / 2, surface_desc.dwHeight / 2, &src, src_pitch / 2, height / 2);
        copy_plane(&dst, surface_desc.lPitch / 2, surface_desc.dwHeight / 2, &src, src_pitch / 2, height / 2);
    }
    else if (height > 0 && bitmap_header->biCompression == BI_RGB)
    {
        BYTE *dst = surface_desc.lpSurface;
        const BYTE *src = data;
 
        copy_plane(&dst, surface_desc.lPitch, surface_desc.dwHeight, &src, src_pitch, -height);
    }
    else if (surface_desc.lPitch != src_pitch)
    {
        BYTE *dst = surface_desc.lpSurface;
        const BYTE *src = data;
 
        TRACE("Source pitch %u does not match dest pitch %lu; copying manually.\n",
                src_pitch, surface_desc.lPitch);
 
        height = abs(height);
        copy_plane(&dst, surface_desc.lPitch, surface_desc.dwHeight, &src, src_pitch, height);
    }
    else
    {
        memcpy(surface_desc.lpSurface, data, data_size);
    }
 
    IDirectDrawSurface7_Unlock(info.lpSurf, NULL);
 
    return IVMRImagePresenter_PresentImage(filter->presenter, filter->cookie, &info);
}

vmr_start_stream()

static void vmr_start_stream ( struct strmbase_renderer *  iface )

static

Definition at line 374 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
 
    IVMRImagePresenter_StartPresenting(filter->presenter, filter->cookie);
}

vmr_stop_stream()

static void vmr_stop_stream ( struct strmbase_renderer *  iface )

static

Definition at line 381 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
 
    if (filter->renderer.filter.state == State_Running)
        IVMRImagePresenter_StopPresenting(filter->presenter, filter->cookie);
}

windowless_control_AddRef()

static ULONG WINAPI windowless_control_AddRef ( IVMRWindowlessControl *  iface )

static

Definition at line 1008 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRWindowlessControl(iface);
 
    return IUnknown_AddRef(filter->renderer.filter.outer_unk);
}

windowless_control_DisplayModeChanged()

static HRESULT WINAPI windowless_control_DisplayModeChanged ( IVMRWindowlessControl *  iface )

static

Definition at line 1142 of file vmr7.c.

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

windowless_control_GetAspectRatioMode()

static HRESULT WINAPI windowless_control_GetAspectRatioMode ( IVMRWindowlessControl *  iface, DWORD *  mode  )

static

Definition at line 1093 of file vmr7.c.

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

windowless_control_GetBorderColor()

static HRESULT WINAPI windowless_control_GetBorderColor ( IVMRWindowlessControl *  iface, COLORREF *  color  )

static

Definition at line 1160 of file vmr7.c.

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

windowless_control_GetColorKey()

static HRESULT WINAPI windowless_control_GetColorKey ( IVMRWindowlessControl *  iface, COLORREF *  color  )

static

Definition at line 1172 of file vmr7.c.

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

windowless_control_GetCurrentImage()

static HRESULT WINAPI windowless_control_GetCurrentImage ( IVMRWindowlessControl *  iface, BYTE **  image  )

static

Definition at line 1148 of file vmr7.c.

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

windowless_control_GetMaxIdealVideoSize()

static HRESULT WINAPI windowless_control_GetMaxIdealVideoSize ( IVMRWindowlessControl *  iface, LONG *  width, LONG *  height  )

static

Definition at line 1051 of file vmr7.c.

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

windowless_control_GetMinIdealVideoSize()

static HRESULT WINAPI windowless_control_GetMinIdealVideoSize ( IVMRWindowlessControl *  iface, LONG *  width, LONG *  height  )

static

Definition at line 1044 of file vmr7.c.

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

windowless_control_GetNativeVideoSize()

static HRESULT WINAPI windowless_control_GetNativeVideoSize ( IVMRWindowlessControl *  iface, LONG *  width, LONG *  height, LONG *  aspect_width, LONG *  aspect_height  )

static

Definition at line 1022 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRWindowlessControl(iface);
    const BITMAPINFOHEADER *bitmap_header = get_filter_bitmap_header(filter);
 
    TRACE("filter %p, width %p, height %p, aspect_width %p, aspect_height %p.\n",
            filter, width, height, aspect_width, aspect_height);
 
    if (!width || !height)
        return E_POINTER;
 
    *width = bitmap_header->biWidth;
    *height = bitmap_header->biHeight;
    if (aspect_width)
        *aspect_width = bitmap_header->biWidth;
    if (aspect_height)
        *aspect_height = bitmap_header->biHeight;
 
    return S_OK;
}

windowless_control_GetVideoPosition()

static HRESULT WINAPI windowless_control_GetVideoPosition ( IVMRWindowlessControl *  iface, RECT *  source, RECT *  dest  )

static

Definition at line 1077 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRWindowlessControl(iface);
 
    TRACE("filter %p, source %p, dest %p.\n", filter, source, dest);
 
    if (source)
        *source = filter->window.src;
 
    if (dest)
        *dest = filter->window.dst;
 
    return S_OK;
}

windowless_control_QueryInterface()

static HRESULT WINAPI windowless_control_QueryInterface ( IVMRWindowlessControl *  iface, REFIID  iid, void **  out  )

static

Definition at line 1001 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRWindowlessControl(iface);
 
    return IUnknown_QueryInterface(filter->renderer.filter.outer_unk, iid, out);
}

windowless_control_Release()

static ULONG WINAPI windowless_control_Release ( IVMRWindowlessControl *  iface )

static

Definition at line 1015 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRWindowlessControl(iface);
 
    return IUnknown_Release(filter->renderer.filter.outer_unk);
}

windowless_control_RepaintVideo()

static HRESULT WINAPI windowless_control_RepaintVideo ( IVMRWindowlessControl *  iface, HWND  window, HDC  dc  )

static

Definition at line 1135 of file vmr7.c.

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

windowless_control_SetAspectRatioMode()

static HRESULT WINAPI windowless_control_SetAspectRatioMode ( IVMRWindowlessControl *  iface, DWORD  mode  )

static

Definition at line 1099 of file vmr7.c.

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

windowless_control_SetBorderColor()

static HRESULT WINAPI windowless_control_SetBorderColor ( IVMRWindowlessControl *  iface, COLORREF  color  )

static

Definition at line 1154 of file vmr7.c.

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

windowless_control_SetColorKey()

static HRESULT WINAPI windowless_control_SetColorKey ( IVMRWindowlessControl *  iface, COLORREF  color  )

static

Definition at line 1166 of file vmr7.c.

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

windowless_control_SetVideoClippingWindow()

static HRESULT WINAPI windowless_control_SetVideoClippingWindow ( IVMRWindowlessControl *  iface, HWND  window  )

static

Definition at line 1105 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRWindowlessControl(iface);
    HRESULT hr;
 
    TRACE("filter %p, window %p.\n", filter, window);
 
    if (!IsWindow(window))
    {
        WARN("Invalid window %p, returning E_INVALIDARG.\n", window);
        return E_INVALIDARG;
    }
 
    EnterCriticalSection(&filter->renderer.filter.filter_cs);
 
    if (filter->renderer.sink.pin.peer)
    {
        LeaveCriticalSection(&filter->renderer.filter.filter_cs);
        WARN("Attempt to set the clipping window while connected; returning VFW_E_WRONG_STATE.\n");
        return VFW_E_WRONG_STATE;
    }
 
    filter->clipping_window = window;
 
    hr = IVMRFilterConfig_SetNumberOfStreams(&filter->IVMRFilterConfig_iface, 4);
 
    LeaveCriticalSection(&filter->renderer.filter.filter_cs);
    return hr;
}

windowless_control_SetVideoPosition()

static HRESULT WINAPI windowless_control_SetVideoPosition ( IVMRWindowlessControl *  iface, const RECT *  source, const RECT *  dest  )

static

Definition at line 1058 of file vmr7.c.

{
    struct vmr7 *filter = impl_from_IVMRWindowlessControl(iface);
 
    TRACE("filter %p, source %s, dest %s.\n", filter, wine_dbgstr_rect(source), wine_dbgstr_rect(dest));
 
    EnterCriticalSection(&filter->renderer.filter.filter_cs);
 
    if (source)
        filter->window.src = *source;
    if (dest)
        filter->window.dst = *dest;
 
    LeaveCriticalSection(&filter->renderer.filter.filter_cs);
 
    return S_OK;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

quartz

)

Variable Documentation

certified_output_protection_vtbl

const IAMCertifiedOutputProtectionVtbl certified_output_protection_vtbl

static

Initial value:

=
{
    certified_output_protection_QueryInterface,
    certified_output_protection_AddRef,
    certified_output_protection_Release,
    certified_output_protection_KeyExchange,
    certified_output_protection_SessionSequenceStart,
    certified_output_protection_ProtectionCommand,
    certified_output_protection_ProtectionStatus,
}

Definition at line 630 of file vmr7.c.

Referenced by vmr7_create().

filter_config_vtbl

const IVMRFilterConfigVtbl filter_config_vtbl

static

Initial value:

=
{
    filter_config_QueryInterface,
    filter_config_AddRef,
    filter_config_Release,
    filter_config_SetImageCompositor,
    filter_config_SetNumberOfStreams,
    filter_config_GetNumberOfStreams,
    filter_config_SetRenderingPrefs,
    filter_config_GetRenderingPrefs,
    filter_config_SetRenderingMode,
    filter_config_GetRenderingMode,
}

Definition at line 813 of file vmr7.c.

Referenced by vmr7_create().

IVideoWindow_VTable

const IVideoWindowVtbl IVideoWindow_VTable

static

Definition at line 530 of file vmr7.c.

Referenced by vmr7_create().

misc_flags_vtbl

const IAMFilterMiscFlagsVtbl misc_flags_vtbl

static

Initial value:

=
{
    misc_flags_QueryInterface,
    misc_flags_AddRef,
    misc_flags_Release,
    misc_flags_GetMiscFlags,
}

Definition at line 667 of file vmr7.c.

Referenced by vmr7_create().

monitor_config_vtbl

const IVMRMonitorConfigVtbl monitor_config_vtbl

static

Initial value:

=
{
    monitor_config_QueryInterface,
    monitor_config_AddRef,
    monitor_config_Release,
    monitor_config_SetMonitor,
    monitor_config_GetMonitor,
    monitor_config_SetDefaultMonitor,
    monitor_config_GetDefaultMonitor,
    monitor_config_GetAvailableMonitors,
}

Definition at line 989 of file vmr7.c.

Referenced by vmr7_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 1536 of file vmr7.c.

Referenced by vmr7_create().

renderer_ops

const struct strmbase_renderer_ops renderer_ops

static

Initial value:

=
{
    .renderer_query_accept = vmr_query_accept,
    .renderer_render = vmr_render,
    .renderer_init_stream = vmr_init_stream,
    .renderer_start_stream = vmr_start_stream,
    .renderer_stop_stream = vmr_stop_stream,
    .renderer_connect = vmr_connect,
    .renderer_disconnect = vmr_disconnect,
    .renderer_destroy = vmr_destroy,
    .renderer_query_interface = vmr_query_interface,
    .renderer_pin_query_interface = vmr_pin_query_interface,
}

Definition at line 496 of file vmr7.c.

Referenced by vmr7_create().

surface_allocator_notify_vtbl

const IVMRSurfaceAllocatorNotifyVtbl surface_allocator_notify_vtbl

static

Initial value:

=
{
    surface_allocator_notify_QueryInterface,
    surface_allocator_notify_AddRef,
    surface_allocator_notify_Release,
    surface_allocator_notify_AdviseSurfaceAllocator,
    surface_allocator_notify_SetDDrawDevice,
    surface_allocator_notify_ChangeDDrawDevice,
    surface_allocator_notify_RestoreDDrawSurfaces,
    surface_allocator_notify_NotifyEvent,
    surface_allocator_notify_SetBorderColor,
}

Definition at line 1294 of file vmr7.c.

Referenced by vmr7_create().

video_accelerator_vtbl

const IAMVideoAcceleratorVtbl video_accelerator_vtbl

static

Initial value:

=
{
    video_accelerator_QueryInterface,
    video_accelerator_AddRef,
    video_accelerator_Release,
    video_accelerator_GetVideoAcceleratorGUIDs,
    video_accelerator_GetUncompFormatsSupported,
    video_accelerator_GetInternalMemInfo,
    video_accelerator_GetCompBufferInfo,
    video_accelerator_GetInternalCompBufferInfo,
    video_accelerator_BeginFrame,
    video_accelerator_EndFrame,
    video_accelerator_GetBuffer,
    video_accelerator_ReleaseBuffer,
    video_accelerator_Execute,
    video_accelerator_QueryRenderStatus,
    video_accelerator_DisplayFrame,
}

Definition at line 1424 of file vmr7.c.

Referenced by vmr7_create().

window_ops

const struct video_window_ops window_ops

static

Initial value:

=
{
    .get_default_rect = vmr_get_default_rect,
    .get_current_image = vmr_get_current_image,
}

Definition at line 524 of file vmr7.c.

Referenced by vmr7_create().

windowless_control_vtbl

const IVMRWindowlessControlVtbl windowless_control_vtbl

static

Initial value:

=
{
    windowless_control_QueryInterface,
    windowless_control_AddRef,
    windowless_control_Release,
    windowless_control_GetNativeVideoSize,
    windowless_control_GetMinIdealVideoSize,
    windowless_control_GetMaxIdealVideoSize,
    windowless_control_SetVideoPosition,
    windowless_control_GetVideoPosition,
    windowless_control_GetAspectRatioMode,
    windowless_control_SetAspectRatioMode,
    windowless_control_SetVideoClippingWindow,
    windowless_control_RepaintVideo,
    windowless_control_DisplayModeChanged,
    windowless_control_GetCurrentImage,
    windowless_control_SetBorderColor,
    windowless_control_GetBorderColor,
    windowless_control_SetColorKey,
    windowless_control_GetColorKey,
}

Definition at line 1178 of file vmr7.c.

Referenced by vmr7_create().