include/vmrender.idl

   1 /*
   2  * Copyright (C) 2008 Maarten Lankhorst
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 cpp_quote("#if 0")
  20 typedef DWORD IDirectDrawSurface7;
  21 typedef DWORD IDirectDraw7;
  22 typedef DWORD *LPBITMAPINFOHEADER;
  23 typedef DWORD *LPDDPIXELFORMAT;
  24 typedef struct { DWORD dw1, dw2; } DDCOLORKEY;
  25 cpp_quote("#endif")
  26 cpp_quote("#include <ddraw.h>")
  27
  28 interface IVMRSurface;
  29 interface IVMRSurfaceAllocator;
  30 interface IVMRSurfaceAllocatorNotify;
  31 interface IVMRImagePresenter;
  32 interface IVMRImagePresenterNotify;
  33 interface IVMRWindowlessControl;
  34 interface IVMRMixerControl;
  35 interface IVMRMixerBitmap;
  36 interface IVMRFilterConfig;
  37 interface IVMRAspectRatioControl;
  38 interface IVMRDeinterlaceControl;
  39 interface IVMRMonitorConfig;
  40 interface IVMRImageCompositor;
  41 interface IVMRVideoStreamControl;
  42
  43 typedef enum _VMRPresentationFlags
  44 {
  45     VMRSample_SyncPoint = 0x01,
  46     VMRSample_Preroll = 0x02,
  47     VMRSample_Discontinuity = 0x04,
  48     VMRSample_TimeValid = 0x08,
  49     VMRSample_SrcDstRectsValid = 0x10
  50 } VMRPresentationFlags;
  51
  52 typedef struct tagVMRPRESENTATIONINFO
  53 {
  54     DWORD dwFlags;
  55     IDirectDrawSurface7 *lpSurf;
  56     REFERENCE_TIME rtStart, rtEnd;
  57     SIZE szAspectRatio;
  58     RECT rcSrc, rcDst;
  59     DWORD dwTypeSpecificFlags;
  60     DWORD dwInterlaceFlags;
  61 } VMRPRESENTATIONINFO;
  62
  63 [
  64     local,
  65     object,
  66     uuid(ce704fe7-e71e-41fb-baa2-c4403e1182f5),
  67     helpstring("IVMRImagePresenter interface"),
  68     pointer_default(unique)
  69 ]
  70 interface IVMRImagePresenter : IUnknown
  71 {
  72     HRESULT StartPresenting([in] DWORD_PTR id);
  73     HRESULT StopPresenting([in] DWORD_PTR id);
  74     HRESULT PresentImage([in] DWORD_PTR id, [in] VMRPRESENTATIONINFO *info);
  75 };
  76
  77 typedef enum _VMRSurfaceAllocationFlags
  78 {
  79     AMAP_PIXELFORMAT_VALID = 0x01,
  80     AMAP_3D_TARGET = 0x02,
  81     AMAP_ALLOW_SYSMEM = 0x04,
  82     AMAP_FORCE_SYSMEM = 0x08,
  83     AMAP_DIRECTED_FLIP = 0x10,
  84     AMAP_DXVA_TARGET = 0x20
  85 } VMRSurfaceAllocationFlags;
  86
  87 typedef struct tagVMRALLOCATIONINFO
  88 {
  89     DWORD dwFlags;
  90     LPBITMAPINFOHEADER lpHdr;
  91     LPDDPIXELFORMAT lpPixFmt;
  92     SIZE szAspectRatio;
  93     DWORD dwMinBuffers;
  94     DWORD dwMaxBuffers;
  95     DWORD dwInterlaceFlags;
  96     SIZE szNativeSize;
  97 } VMRALLOCATIONINFO;
  98
  99 [
 100     local,
 101     object,
 102     uuid(31ce832e-4484-458b-8cca-f4d7e3db0b52),
 103     helpstring("IVMRSurfaceAllocator interface"),
 104     pointer_default(unique)
 105 ]
 106 interface IVMRSurfaceAllocator : IUnknown
 107 {
 108     HRESULT AllocateSurface([in] DWORD_PTR id, [in] VMRALLOCATIONINFO *allocinfo, [in, out] DWORD *buffers, IDirectDrawSurface7 **surface);
 109     HRESULT FreeSurface([in] DWORD_PTR id);
 110     HRESULT PrepareSurface([in] DWORD_PTR id, [in] IDirectDrawSurface7 *surface, [in] DWORD dwSurfaceFlags);
 111     HRESULT AdviseNotify([in] IVMRSurfaceAllocatorNotify *notify);
 112 };
 113
 114 [
 115     local,
 116     object,
 117     uuid(aada05a8-5a4e-4729-af0b-cea27aed51e2),
 118     helpstring("IVMRSurfaceAllocatorNotify interface"),
 119     pointer_default(unique)
 120 ]
 121 interface IVMRSurfaceAllocatorNotify : IUnknown
 122 {
 123     HRESULT AdviseSurfaceAllocator([in] DWORD_PTR id, [in] IVMRSurfaceAllocator *allocator);
 124     HRESULT SetDDrawDevice([in] IDirectDraw7 *device, [in] HMONITOR monitor);
 125     HRESULT ChangeDDrawDevice([in] IDirectDraw7 *device, [in] HMONITOR monitor);
 126     HRESULT RestoreDDrawSurfaces();
 127     HRESULT NotifyEvent([in] LONG EventCode, [in] LONG_PTR p1, [in] LONG_PTR p2);
 128     HRESULT SetBorderColor([in] COLORREF border);
 129 };
 130
 131 typedef enum _VMR_ASPECT_RATIO_MODE
 132 {
 133     VMR_ARMODE_NONE,
 134     VMR_ARMODE_LETTER_BOX
 135 } VMR_ASPECT_RATIO_MODE;
 136
 137 [
 138     local,
 139     object,
 140     uuid(0eb1088c-4dcd-46f0-878f-39dae86a51b7),
 141     helpstring("IVMRWindowlessControl interface"),
 142     pointer_default(unique)
 143 ]
 144 interface IVMRWindowlessControl : IUnknown
 145 {
 146     HRESULT GetNativeVideoSize([out] LONG *width, [out] LONG *height, [out] LONG *ar_width, [out] LONG *ar_height);
 147     HRESULT GetMinIdealVideoSize([out] LONG *width, [out] LONG *height);
 148     HRESULT GetMaxIdealVideoSize([out] LONG *width, [out] LONG *height);
 149     HRESULT SetVideoPosition([in] const RECT *src_rect, [in] const RECT *dst_rect);
 150     HRESULT GetVideoPosition([out] RECT *src_rect, [out] RECT *dst_rect);
 151     HRESULT GetAspectRatioMode([out] DWORD *mode);
 152     HRESULT SetAspectRatioMode([in] DWORD mode);
 153     HRESULT SetVideoClippingWindow([in] HWND hwnd);
 154     HRESULT RepaintVideo([in] HWND hwnd, [in] HDC hdc);
 155     HRESULT DisplayModeChanged();
 156     HRESULT GetCurrentImage([out] BYTE **data);
 157     HRESULT SetBorderColor([in] COLORREF border);
 158     HRESULT GetBorderColor([out] COLORREF *border);
 159     HRESULT SetColorKey([in] COLORREF key);
 160     HRESULT GetColorKey([out] COLORREF *key);
 161 };
 162
 163 typedef enum _VMRMixerPrefs
 164 {
 165     MixerPref_NoDecimation = 0x0001,
 166     MixerPref_DecimateOutput = 0x0002,
 167     MixerPref_ARAdjustXorY = 0x0004,
 168     MixerPref_DecimationReserved = 0x0008,
 169     MixerPref_DecimateMask = 0x000f,
 170
 171     MixerPref_BiLinearFiltering = 0x0010,
 172     MixerPref_PointFiltering = 0x0020,
 173     MixerPref_FinteringMask = 0x00f0,
 174
 175     MixerPref_RenderTargetRGB = 0x0100,
 176     MixerPref_RenderTargetYUV = 0x1000,
 177     MixerPref_RenderTargetYUV420 = 0x0200,
 178     MixerPref_RenderTargetYUV422 = 0x0400,
 179     MixerPref_RenderTargetYUV444 = 0x0800,
 180     MixerPref_RenderTargetReserved = 0xe000,
 181     MixerPref_RenderTargetMask = 0xff00,
 182
 183     MixerPref_DynamicSwitchToBOB = 0x10000,
 184     MixerPref_DynamicDecimateBy2 = 0x20000,
 185     MixerPref_DynamicReserved = 0xc0000,
 186     MixerPref_DynamicMask = 0xf0000
 187 } VMRMixerPrefs;
 188
 189 typedef struct _NORMALIZEDRECT
 190 {
 191     FLOAT left, top, right, bottom;
 192 } NORMALIZEDRECT;
 193
 194 [
 195     local,
 196     object,
 197     uuid(1c1a17b0-bed0-415d-974b-dc6696131599),
 198     helpstring("IVMRMixerControl interface"),
 199     pointer_default(unique)
 200 ]
 201 interface IVMRMixerControl : IUnknown
 202 {
 203     HRESULT SetAlpha([in] DWORD id, [in] FLOAT alpha);
 204     HRESULT GetAlpha([in] DWORD id, [out] FLOAT *alpha);
 205     HRESULT SetZOrder([in] DWORD id, [in] DWORD z);
 206     HRESULT GetZOrder([in] DWORD id, [out] DWORD *z);
 207     HRESULT SetOutputRect([in] DWORD id, [in] const NORMALIZEDRECT *rect);
 208     HRESULT SetBackgroundClr([in] COLORREF background);
 209     HRESULT GetBackgroundClr([out] COLORREF *background);
 210     HRESULT SetMixingPrefs([in] DWORD prefs);
 211     HRESULT GetMixingPrefs([out] DWORD *prefs);
 212 };
 213
 214 typedef struct tagVMRGUID
 215 {
 216     GUID *pGUID, GUID;
 217 } VMRGUID;
 218
 219 #define VMRDEVICENAMELEN 32
 220 #define VMRDEVICEDESCRIPTIONLEN 256
 221
 222 typedef struct tagVMRMONITORINFO
 223 {
 224     VMRGUID guid;
 225     RECT rcMonitor;
 226     HMONITOR hMon;
 227     DWORD dwFlags;
 228     WCHAR szDevice[VMRDEVICENAMELEN];
 229     WCHAR szDescription[VMRDEVICEDESCRIPTIONLEN];
 230     LARGE_INTEGER liDriverVersion;
 231     DWORD dwVendorId;
 232     DWORD dwDeviceId;
 233     DWORD dwSubSysId;
 234     DWORD dwRevision;
 235 } VMRMONITORINFO;
 236
 237 [
 238     local,
 239     object,
 240     uuid(9cf0b1b6-fbaa-4b7f-88cf-cf1f130a0dce),
 241     helpstring("IVMRMonitorConfig interface"),
 242     pointer_default(unique)
 243 ]
 244 interface IVMRMonitorConfig : IUnknown
 245 {
 246     HRESULT SetMonitor([in] const VMRGUID *vmrguid);
 247     HRESULT GetMonitor([out] VMRGUID *vmrguid);
 248     HRESULT SetDefaultMonitor([in] const VMRGUID *vmrguid);
 249     HRESULT GetDefaultMonitor([out] VMRGUID *vmrguid);
 250     HRESULT GetAvailableMonitors([out, size_is(array_size)] VMRMONITORINFO *info, [in] DWORD array_size, [out] DWORD *retrieved);
 251 }
 252
 253 typedef enum _VMRRenderPrefs
 254 {
 255     RenderPrefs_RestrictToInitialMonitor = 0x00,
 256     RenderPrefs_ForceOffScreen = 0x01,
 257     RenderPrefs_ForceOverlays = 0x02,
 258     RenderPrefs_AllowOverlays = 0x00,
 259     RenderPrefs_AllowOffscreen = 0x00,
 260     RenderPrefs_DoNotRenderColorKeyAndBorder = 0x08,
 261     RenderPrefs_Reserved = 0x10,
 262     RenderPrefs_PreferAGPMemWhenMixing = 0x20,
 263     RenderPrefs_Mask = 0x3f
 264 } VMRRenderPrefs;
 265
 266 typedef enum _VMRMode
 267 {
 268     VMRMode_Windowed = 0x1,
 269     VMRMode_Windowless = 0x2,
 270     VMRMode_Renderless = 0x4,
 271     VMRMode_Mask = 0x7
 272 } VMRMode;
 273
 274 enum { MAX_NUMBER_OF_STREAMS = 16 };
 275
 276 [
 277     local,
 278     object,
 279     uuid(9e5530c5-7034-48b4-bb46-0b8a6efc8e36),
 280     helpstring("IVMRFilterConfig interface"),
 281     pointer_default(unique)
 282 ]
 283 interface IVMRFilterConfig : IUnknown
 284 {
 285     HRESULT SetImageCompositor([in] IVMRImageCompositor *compositor);
 286     HRESULT SetNumberOfStreams([in] DWORD streams);
 287     HRESULT GetNumberOfStreams([out] DWORD *streams);
 288     HRESULT SetRenderingPrefs([in] DWORD prefs);
 289     HRESULT GetRenderingPrefs([out] DWORD *prefs);
 290     HRESULT SetRenderingMode([in] DWORD mode);
 291     HRESULT GetRenderingMode([out] DWORD *mode);
 292 };
 293
 294 [
 295     local,
 296     object,
 297     uuid(ede80b5c-bad6-4623-b537-65586c9f8dfd),
 298     helpstring("IVMRAspectRatioControl interface"),
 299     pointer_default(unique)
 300 ]
 301 interface IVMRAspectRatioControl : IUnknown
 302 {
 303     HRESULT GetAspectRatioMode([out] DWORD *armode);
 304     HRESULT SetAspectRatioMode([in] DWORD armode);
 305 };
 306
 307 typedef enum _VMRDeinterlacePrefs
 308 {
 309     DeinterlacePref_NextBest = 0x1,
 310     DeinterlacePref_BOB = 0x2,
 311     DeinterlacePref_Weave = 0x4,
 312     DeinterlacePref_Mask = 0x7
 313 } VMRDeinterlacePrefs;
 314
 315 typedef enum _VMRDeinterlaceTech
 316 {
 317     DeinterlaceTech_Unknown = 0x00,
 318     DeinterlaceTech_BOBLineReplicate = 0x01,
 319     DeinterlaceTech_BOBVerticalStretch = 0x02,
 320     DeinterlaceTech_MedianFiltering = 0x04,
 321     DeinterlaceTech_EdgeFiltering = 0x08,
 322     DeinterlaceTech_FieldAdaptive = 0x10,
 323     DeinterlaceTech_PixelAdaptive = 0x20,
 324     DeinterlaceTech_MotionVectorSteered = 0x80
 325 } VMRDeinterlaceTech;
 326
 327 typedef struct _VMRFrequency
 328 {
 329     DWORD dwNumerator, dwDenominator;
 330 } VMRFrequency;
 331
 332 typedef struct _VMRVideoDesc
 333 {
 334     DWORD dwSize;
 335     DWORD dwSampleWidth;
 336     DWORD dwSampleHeight;
 337     BOOL SingleFieldPerSample;
 338     DWORD dwFourCC;
 339     VMRFrequency InputSampleFreq;
 340     VMRFrequency OutputFrameFreq;
 341 } VMRVideoDesc;
 342
 343 typedef struct _VMRDeinterlaceCaps
 344 {
 345     DWORD dwSize;
 346     DWORD dwNumPreviousOutputFrames;
 347     DWORD dwNumForwardRefSamples;
 348     DWORD dwNumBackwardRefSamples;
 349     VMRDeinterlaceTech DeinterlaceTechnology;
 350 } VMRDeinterlaceCaps;
 351
 352 [
 353     local,
 354     object,
 355     uuid(bb057577-0db8-4e6a-87a7-1a8c9a505a0f),
 356     helpstring("IVMRDeinterlaceControl interface"),
 357     pointer_default(unique)
 358 ]
 359 interface IVMRDeinterlaceControl : IUnknown
 360 {
 361     HRESULT GetNumberOfDeinterlaceModes([in] VMRVideoDesc *desc, [in, out] DWORD *num_modes, [out] GUID *modes);
 362     HRESULT GetDeinterlaceModeCaps([in] GUID *mode, [in] VMRVideoDesc *desc, [in, out] VMRDeinterlaceCaps *caps);
 363     HRESULT GetDeinterlaceMode([in] DWORD id, [out] GUID *mode);
 364     HRESULT SetDeinterlaceMode([in] DWORD id, [in] GUID *mode);
 365     HRESULT GetDeinterlacePrefs([out] DWORD *prefs);
 366     HRESULT SetDeinterlacePrefs([in] DWORD prefs);
 367     HRESULT GetActualDeinterlaceMode([in] DWORD id, [out] GUID *mode);
 368 };
 369
 370 typedef struct _VMRALPHABITMAP
 371 {
 372     DWORD dwFlags;
 373     HDC hdc;
 374     IDirectDrawSurface7 *pDDS;
 375     RECT rSrc;
 376     RECT rDest;
 377     FLOAT fAlpha;
 378     COLORREF clrSrcKey;
 379 } VMRALPHABITMAP, *PVMRALPHABITMAP;
 380
 381 cpp_quote("#define VMRBITMAP_DISABLE (0x01)")
 382 cpp_quote("#define VMRBITMAP_HDC (0x02)")
 383 cpp_quote("#define VMRBITMAP_ENTIREDDS (0x04)")
 384 cpp_quote("#define VMRBITMAP_SRCCOLORKEY (0x08)")
 385 cpp_quote("#define VMRBITMAP_SRCRECT (0x10)")
 386
 387 [
 388     local,
 389     object,
 390     uuid(1e673275-0257-40aa-af20-7c608d4a0428),
 391     helpstring("IVMRMixerBitmap interface"),
 392     pointer_default(unique)
 393 ]
 394 interface IVMRMixerBitmap : IUnknown
 395 {
 396     HRESULT SetAlphaBitmap([in] const VMRALPHABITMAP *params);
 397     HRESULT UpdateAlphaBitmapParameters([in] VMRALPHABITMAP *params);
 398     HRESULT GetAlphaBitmapParameters([out] VMRALPHABITMAP *params);
 399 };
 400
 401 typedef struct _VMRVIDEOSTREAMINFO
 402 {
 403     IDirectDrawSurface7 *pddsVideoSurface;
 404     DWORD dwWidth;
 405     DWORD dwHeight;
 406     DWORD dwStrmID;
 407     FLOAT fAlpha;
 408     DDCOLORKEY ddClrKey;
 409     NORMALIZEDRECT rNormal;
 410 } VMRVIDEOSTREAMINFO;
 411
 412 [
 413     local,
 414     object,
 415     uuid(7a4fb5af-479f-4074-bb40-ce6722e43c82),
 416     helpstring("IVMRImageCompositor interface"),
 417     pointer_default(unique)
 418 ]
 419 interface IVMRImageCompositor : IUnknown
 420 {
 421     HRESULT InitCompositionTarget([in] IUnknown *d3ddev, [in] IDirectDrawSurface7 *rendertarget);
 422     HRESULT TermCompositionTarget([in] IUnknown *d3ddev, [in] IDirectDrawSurface7 *rendertarget);
 423     HRESULT SetStreamMediaType([in] DWORD id, [in] AM_MEDIA_TYPE *pmt, [in] BOOL texture);
 424     HRESULT CompositeImage([in] IUnknown *d3ddev, [in] IDirectDrawSurface7 *rendertarget,
 425                            [in] AM_MEDIA_TYPE *pmt, [in] REFERENCE_TIME start, [in] REFERENCE_TIME stop,
 426                            [in] DWORD backgrnd, [in] VMRVIDEOSTREAMINFO *info, [in] UINT streams);
 427 };
 428
 429 [
 430     local,
 431     object,
 432     uuid(058d1f11-2a54-4bef-bd54-df706626b727),
 433     helpstring("IVMRVideoStreamControl interface"),
 434     pointer_default(unique)
 435 ]
 436 interface IVMRVideoStreamControl : IUnknown
 437 {
 438     HRESULT SetColorKey([in] DDCOLORKEY *key);
 439     HRESULT GetColorKey([out] DDCOLORKEY *key);
 440     HRESULT SetStreamActiveState([in] BOOL active);
 441     HRESULT GetStreamActiveState([out] BOOL *active);
 442 };
 443
 444 [
 445     local,
 446     object,
 447     uuid(9f3a1c85-8555-49ba-935f-be5b5b29d178),
 448     helpstring("IVMRImagePresenterConfig interface"),
 449     pointer_default(unique)
 450 ]
 451 interface IVMRImagePresenterConfig : IUnknown
 452 {
 453     HRESULT SetRenderingPrefs([in] DWORD prefs);
 454     HRESULT GetRenderingPrefs([out] DWORD *prefs);
 455 };
 456
 457 [
 458     local,
 459     object,
 460     uuid(e6f7ce40-4673-44f1-8f77-5499d68cb4ea),
 461     helpstring("IVMRImagePresenterExclModeConfig interface"),
 462     pointer_default(unique)
 463 ]
 464 interface IVMRImagePresenterExclModeConfig : IVMRImagePresenterConfig
 465 {
 466     HRESULT SetXlcModeDDObjAndPrimarySurface([in] IDirectDraw7 *dddev, [in] IDirectDrawSurface7 *ddsurface);
 467     HRESULT GetXlcModeDDObjAndPrimarySurface([out] IDirectDraw7 **dddev, [out] IDirectDrawSurface7 **ddsurface);
 468 };
 469
 470 [
 471     local,
 472     object,
 473     uuid(aac18c18-e186-46d2-825d-a1f8dc8e395a),
 474     helpstring("IVPManager interface"),
 475     pointer_default(unique)
 476 ]
 477 interface IVPManager : IUnknown
 478 {
 479     HRESULT SetVideoPortIndex([in] DWORD index);
 480     HRESULT GetVideoPortIndex([out] DWORD *index);
 481 };