git.oblomov.eu Git - wine/blob - include/vmr9.idl

   1 /*
   2  * Copyright 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 import "unknwn.idl";
  20
  21 cpp_quote("#if 0")
  22 interface IDirect3DSurface9;
  23 interface IDirect3DDevice9;
  24 typedef LONGLONG REFERENCE_TIME;
  25 typedef DWORD D3DFORMAT;
  26 typedef DWORD D3DPOOL;
  27 typedef HANDLE HMONITOR;
  28 typedef struct { char dummy; } AM_MEDIA_TYPE;
  29 typedef struct { char dummy; } D3DCOLOR;
  30 cpp_quote("#endif")
  31
  32 interface IVMRSurface9;
  33 interface IVMRSurfaceAllocator9;
  34 interface IVMRSurfaceAllocatorEx9;
  35 interface IVMRSurfaceAllocatorNotify9;
  36 interface IVMRImagePresenter9;
  37 interface IVMRImagePresenterConfig9;
  38 interface IVMRMonitorConfig9;
  39 interface IVMRWindowlessControl9;
  40 interface IVMRMixerControl9;
  41 interface IVMRImageCompositor9;
  42 interface IVMRMixerBitmap9;
  43 interface IVMRFilterConfig9;
  44 interface IVMRAspectRatioControl9;
  45 interface IVMRVideoStreamControl9;
  46
  47 typedef enum _VMR9PresentationFlags
  48 {
  49     VMR9Sample_SyncPoint = 0x1,
  50     VMR9Sample_Preroll = 0x2,
  51     VMR9Sample_Discontinuity = 0x4,
  52     VMR9Sample_TimeValid = 0x8,
  53     VMR9Sample_SrcDstRectsValid = 0x10
  54 } VMR9PresentationFlags;
  55
  56 typedef struct _VMR9PresentationInfo
  57 {
  58     DWORD dwFlags; /* Flags defined above */
  59     IDirect3DSurface9 *lpSurf;
  60     REFERENCE_TIME rtStart;
  61     REFERENCE_TIME rtEnd;
  62     SIZE szAspectRatio;
  63     RECT rcSrc;
  64     RECT rcDst;
  65     DWORD dwReserved1;
  66     DWORD dwReserved2;
  67 } VMR9PresentationInfo;
  68
  69 [
  70     local,
  71     object,
  72     uuid(69188c61-12a3-40f0-8ffc-342e7b433fd7),
  73     helpstring("IVMRImagePresenter9 interface"),
  74     pointer_default(unique)
  75 ]
  76 interface IVMRImagePresenter9 : IUnknown
  77 {
  78     HRESULT StartPresenting([in] DWORD_PTR id);
  79     HRESULT StopPresenting([in] DWORD_PTR id);
  80     HRESULT PresentImage([in] DWORD_PTR id, [in] VMR9PresentationInfo *info);
  81 };
  82
  83 typedef enum _VMR9SurfaceAllocationFlags
  84 {
  85     VMR9AllocFlag_3DRenderTarget = 0x1,
  86     VMR9AllocFlag_DXVATarget = 0x2,
  87     VMR9AllocFlag_TextureSurface = 0x4,
  88     VMR9AllocFlag_OffscreenSurface = 0x8,
  89     VMR9AllocFlag_RGBDynamicSwitch = 0x10,
  90     VMR9AllocFlag_UsageReserved = 0xe0,
  91     VMR9AllocFlag_UsageMask = 0xff,
  92 } VMR9SurfaceAllocationFlags;
  93
  94 typedef struct _VMR9AllocationInfo
  95 {
  96     DWORD dwFlags; /* Flags defined above */
  97     DWORD dwWidth;
  98     DWORD dwHeight;
  99     D3DFORMAT Format;
 100     D3DPOOL Pool;
 101     DWORD MinBuffers;
 102     SIZE szAspectRatio;
 103     SIZE szNativeSize;
 104 } VMR9AllocationInfo;
 105
 106 [
 107     local,
 108     object,
 109     uuid(8d5148ea-3f5d-46cf-9df1-d1b896eedb1f),
 110     helpstring("IVMRSurfaceAllocator9 interface"),
 111     pointer_default(unique)
 112 ]
 113 interface IVMRSurfaceAllocator9 : IUnknown
 114 {
 115     HRESULT InitializeDevice([in] DWORD_PTR id, [in] VMR9AllocationInfo *allocinfo, [in, out] DWORD *numbuffers);
 116     HRESULT TerminateDevice([in] DWORD_PTR id);
 117     HRESULT GetSurface([in] DWORD_PTR id, [in] DWORD surfaceindex, [in] DWORD flags, [out] IDirect3DSurface9 **surface);
 118     HRESULT AdviseNotify([in] IVMRSurfaceAllocatorNotify9 *allocnotify);
 119 };
 120
 121 [
 122     local,
 123     object,
 124     uuid(6de9a68a-a928-4522-bf57-655ae3866456),
 125     helpstring("IVMRSurfaceAllocatorEx9 interface"),
 126     pointer_default(unique)
 127 ]
 128 interface IVMRSurfaceAllocatorEx9 : IVMRSurfaceAllocator9
 129 {
 130     HRESULT GetSurfaceEx([in] DWORD_PTR id, [in] DWORD surfaceindex, [in] DWORD flags, [out] IDirect3DSurface9 **surface, [out] RECT *dest);
 131 };
 132
 133 [
 134     local,
 135     object,
 136     uuid(dca3f5df-bb3a-4d03-bd81-84614bfbfa0c),
 137     helpstring("IVMRSurfaceAllocatorNotify9 interface"),
 138     pointer_default(unique)
 139 ]
 140 interface IVMRSurfaceAllocatorNotify9 : IUnknown
 141 {
 142     HRESULT AdviseSurfaceAllocator([in] DWORD_PTR id, [in] IVMRSurfaceAllocator9 *alloc);
 143     HRESULT SetD3DDevice([in] IDirect3DDevice9 *device, [in] HMONITOR monitor);
 144     HRESULT ChangeD3DDevice([in] IDirect3DDevice9 *device, [in] HMONITOR monitor);
 145     HRESULT AllocateSurfaceHelper([in] VMR9AllocationInfo *allocinfo, [in, out] DWORD *numbuffers, [out] IDirect3DSurface9 **surface);
 146     HRESULT NotifyEvent([in] LONG code, [in] LONG_PTR param1, [in] LONG_PTR param2);
 147 };
 148
 149 typedef enum _VMR9AspectRatioMode
 150 {
 151     VMR9ARMode_None,
 152     VMR9ARMode_LetterBox
 153 } VMR9AspectRatioMode;
 154
 155 [
 156     local,
 157     object,
 158     uuid(8f537d09-f85e-4414-b23b-502e54c79927),
 159     helpstring("IVMRWindowlessControl interface"),
 160     pointer_default(unique)
 161 ]
 162 interface IVMRWindowlessControl9 : IUnknown
 163 {
 164     HRESULT GetNativeVideoSize([out] LONG *width, [out] LONG *height, [out] LONG *arwidth, [out] LONG *arheight);
 165     HRESULT GetMinIdealVideoSize([out] LONG *width, [out] LONG *height);
 166     HRESULT GetMaxIdealVideoSize([out] LONG *width, [out] LONG *height);
 167     HRESULT SetVideoPosition([in] const RECT *source, [in] const RECT *dest);
 168     HRESULT GetVideoPosition([out] RECT *source, [out] RECT *dest);
 169     HRESULT GetAspectRatioMode([out] DWORD *mode);
 170     HRESULT SetAspectRatioMode([in] DWORD mode);
 171     HRESULT SetVideoClippingWindow([in] HWND hwnd);
 172     HRESULT RepaintVideo([in] HWND hwnd, [in] HDC hdc);
 173     HRESULT DisplayModeChanged();
 174     HRESULT GetCurrentImage([out] BYTE **dib);
 175     HRESULT SetBorderColor([in] COLORREF color);
 176     HRESULT GetBorderColor([out] COLORREF *color);
 177 };
 178
 179 typedef enum _VMR9MixerPrefs
 180 {
 181     /* Decimation */
 182     MixerPref9_NoDecimation = 0x1,
 183     MixerPref9_DecimateOutput = 0x2,
 184     MixerPref9_ARAdjustXorY = 0x4,
 185     MixerPref9_NonSquareMixing = 0x8,
 186     MixerPref9_DecimateMask = 0xf,
 187
 188     /* Filtering */
 189     MixerPref9_BiLinearFiltering = 0x10,
 190     MixerPref9_PointFiltering = 0x20,
 191     MixerPref9_AnisotropicFiltering = 0x40,
 192     MixerPref9_PyramidalQuadFiltering = 0x80,
 193     MixerPref9_GaussianQuadFiltering = 0x100,
 194     MixerPref9_FilteringReserved = 0xe00,
 195     MixerPref9_FilteringMask = 0xff0,
 196
 197     /* Render target */
 198     MixerPref9_RenderTargetRGB = 0x1000,
 199     MixerPref9_RenderTargetYUV = 0x2000,
 200     MixerPref9_RenderTargetReserved = 0xfc000,
 201
 202     MixerPref9_DynamicSwitchToBOB = 0x100000,
 203     MixerPref9_DynamicDecimateBy2 = 0x200000,
 204     MixerPref9_DynamicReserved = 0xc00000,
 205     MixerPref9_DynamicMask = 0xf00000,
 206 } VMR9MixerPrefs;
 207
 208 typedef struct _VMR9NormalizedRect
 209 {
 210     FLOAT left;
 211     FLOAT top;
 212     FLOAT right;
 213     FLOAT bottom;
 214 } VMR9NormalizedRect;
 215
 216 typedef enum _VMR9ProcAmpControlFlags
 217 {
 218     ProcAmpControl9_Brightness = 0x1,
 219     ProcAmpControl9_Contrast = 0x2,
 220     ProcAmpControl9_Hue = 0x4,
 221     ProcAmpControl9_Saturation = 0x8,
 222     ProcAmpControl9_Mask = 0xf
 223 } VMR9ProcAmpControlFlags;
 224
 225 typedef struct _VMR9ProcAmpControl
 226 {
 227     DWORD dwSize;
 228     DWORD dwFlags;
 229     FLOAT Brightness;
 230     FLOAT Contrast;
 231     FLOAT Hue;
 232     FLOAT Saturation;
 233 } VMR9ProcAmpControl;
 234
 235 typedef struct _VMR9ProcAmpControlRange
 236 {
 237     DWORD dwSize;
 238     VMR9ProcAmpControlFlags dwProperty;
 239     FLOAT MinValue;
 240     FLOAT MaxValue;
 241     FLOAT DefaultValue;
 242     FLOAT StepSize;
 243 } VMR9ProcAmpControlRange;
 244
 245 [
 246     local,
 247     object,
 248     uuid(1a777eaa-47c8-4930-b2c9-8fee1c1b0f3b),
 249     helpstring("IVMRMixerControl9 interface"),
 250     pointer_default(unique)
 251 ]
 252 interface IVMRMixerControl9 : IUnknown
 253 {
 254     HRESULT SetAlpha([in] DWORD streamid, [in] FLOAT alpha);
 255     HRESULT GetAlpha([in] DWORD streamid, [out] FLOAT *alpha);
 256     HRESULT SetZOrder([in] DWORD streamid, [in] DWORD zorder);
 257     HRESULT GetZOrder([in] DWORD streamid, [out] DWORD *zorder);
 258     HRESULT SetOutputRect([in] DWORD streamid, [in] const VMR9NormalizedRect *rect);
 259     HRESULT GetOutputRect([in] DWORD streamid, [out] VMR9NormalizedRect *rect);
 260     HRESULT SetBackgroundClr([in] COLORREF back);
 261     HRESULT GetBackgroundClr([out] COLORREF *back);
 262     HRESULT SetMixingPrefs([in] DWORD mixingprefs);
 263     HRESULT GetMixingPrefs([out] DWORD *mixingprefs);
 264     HRESULT SetProcAmpControl([in] DWORD streamid, [in] VMR9ProcAmpControl *control);
 265     HRESULT GetProcAmpControl([in] DWORD streamid, [in, out] VMR9ProcAmpControl *control);
 266     HRESULT GetProcAmpControlRange([in] DWORD streamid, [in, out] VMR9ProcAmpControlRange *controlrange);
 267 };
 268
 269 typedef struct _VMR9AlphaBitmap
 270 {
 271     DWORD dwFlags;
 272     HDC hdc;
 273     IDirect3DSurface9 *pDDS;
 274     RECT rSrc;
 275     VMR9NormalizedRect *rDest;
 276     FLOAT fAlpha;
 277     COLORREF clrSrcKey;
 278     DWORD dwFilterMode;
 279 } VMR9AlphaBitmap;
 280
 281 typedef enum _VMR9AlphaBitmapFlags
 282 {
 283     VMR9AlphaBitmap_Disable = 0x1,
 284     VMR9AlphaBitmap_hDC = 0x2,
 285     VMR9AlphaBitmap_EntireDDS = 0x4,
 286     VMR9AlphaBitmap_SrcColorKey = 0x8,
 287     VMR9AlphaBitmap_SrcRect = 0x10,
 288     VMR9AlphaBitmap_FilterMode = 0x20
 289 } VMR9AlphaBitmapFlags;
 290
 291 [
 292     local,
 293     object,
 294     uuid(ced175e5-1935-4820-81bd-ff6ad00c9108),
 295     helpstring("IVMRMixerBitmap interface"),
 296     pointer_default(unique)
 297 ]
 298 interface IVMRMixerBitmap9 : IUnknown
 299 {
 300     HRESULT SetAlphaBitmap([in] const VMR9AlphaBitmap *bitmap);
 301     HRESULT UpdateAlphaBitmapParameters([in] const VMR9AlphaBitmap *bitmap);
 302     HRESULT GetAlphaBitmapParameters([out] VMR9AlphaBitmap *bitmap);
 303 };
 304
 305 [
 306     local,
 307     object,
 308     uuid(dfc581a1-6e1f-4c3a-8d0a-5e9792ea2afc),
 309     helpstring("IVMRSurface interface"),
 310     pointer_default(unique)
 311 ]
 312 interface IVMRSurface9 : IUnknown
 313 {
 314     HRESULT IsSurfaceLocked();
 315     HRESULT LockSurface([out] BYTE **surface);
 316     HRESULT UnlockSurface();
 317     HRESULT GetSurface([out] IDirect3DSurface9 **surface);
 318 };
 319
 320 typedef enum _VMR9RenderPrefs
 321 {
 322    RenderPrefs9_DoNotRenderBorder = 0x1,
 323    RenderPrefs9_Mask = 0x1
 324 } VMR9RenderPrefs;
 325
 326 [
 327     local,
 328     object,
 329     uuid(45c15cab-6e22-420a-8043-ae1f0ac02c7d),
 330     helpstring("IVMRImagePresenterConfig9 interface"),
 331     pointer_default(unique)
 332 ]
 333 interface IVMRImagePresenterConfig9 : IUnknown
 334 {
 335     HRESULT SetRenderingPrefs([in] DWORD renderflags);
 336     HRESULT GetRenderingPrefs([out] DWORD *renderflags);
 337 };
 338
 339 [
 340     local,
 341     object,
 342     uuid(d0cfe38b-93e7-4772-8957-0400c49a4485),
 343     helpstring("IVMRMixerStreamConfig interface"),
 344     pointer_default(unique)
 345 ]
 346 interface IVMRVideoStreamControl9: IUnknown
 347 {
 348     HRESULT SetStreamActiveState([in] BOOL active);
 349     HRESULT GetStreamActiveState([out] BOOL *active);
 350 };
 351
 352 typedef enum _VMR9Mode
 353 {
 354     VMR9Mode_Windowed = 0x1,
 355     VMR9Mode_Windowless = 0x2,
 356     VMR9Mode_Renderless = 0x4,
 357     VMR9Mode_Mask = 0x7
 358 } VMR9Mode;
 359
 360 [
 361     local,
 362     object,
 363     uuid(5a804648-4f66-4867-9c43-4f5c822cf1b8),
 364     helpstring("IVMRFilterConfig9 interface"),
 365     pointer_default(unique)
 366 ]
 367 interface IVMRFilterConfig9 : IUnknown
 368 {
 369     HRESULT SetImageCompositor([in] IVMRImageCompositor9 *compositor);
 370     HRESULT SetNumberOfStreams([in] DWORD max);
 371     HRESULT GetNumberOfStreams([out] DWORD *max);
 372     HRESULT SetRenderingPrefs([in] DWORD renderflags);
 373     HRESULT GetRenderingPrefs([out] DWORD *renderflags);
 374     HRESULT SetRenderingMode([in] DWORD mode);
 375     HRESULT GetRenderingMode([out] DWORD *mode);
 376 };
 377
 378 [
 379     local,
 380     object,
 381     uuid(00d96c29-bbde-4efc-9901-bb5036392146),
 382     helpstring("IVMRAspectRatioControl9 interface"),
 383     pointer_default(unique)
 384 ]
 385 interface IVMRAspectRatioControl9 : IUnknown
 386 {
 387     HRESULT GetAspectRatioMode([out] DWORD *mode);
 388     HRESULT SetAspectRatioMode([in] DWORD mode);
 389 }
 390
 391 #define VMR9DEVICENAMELEN 32
 392 #define VMR9DEVICEDESCRIPTIONLEN 512
 393
 394 typedef struct _VMR9MonitorInfo
 395 {
 396     UINT uDevID;
 397     RECT rcMonitor;
 398     HMONITOR hMon;
 399     DWORD dwFlags;
 400     WCHAR szDevice[VMR9DEVICENAMELEN];
 401     WCHAR szDescription[VMR9DEVICEDESCRIPTIONLEN];
 402     LARGE_INTEGER liDriverVersion;
 403     DWORD dwVendorId;
 404     DWORD dwDeviceId;
 405     DWORD dwSubSysId;
 406     DWORD dwRevision;
 407 } VMR9MonitorInfo;
 408
 409 [
 410     local,
 411     object,
 412     uuid(46c2e457-8ba0-4eef-b80b-0680f0978749),
 413     helpstring("IVMRMonitorConfig9 interface"),
 414     pointer_default(unique)
 415 ]
 416 interface IVMRMonitorConfig9 : IUnknown
 417 {
 418     HRESULT SetMonitor([in] UINT uDev);
 419     HRESULT GetMonitor([out] UINT *uDev);
 420     HRESULT SetDefaultMonitor([in] UINT uDev);
 421     HRESULT GetDefaultMonitor([out] UINT *uDev);
 422     HRESULT GetAvailableMonitors([out, size_is(arraysize)] VMR9MonitorInfo *info, [in] DWORD arraysize, [out] DWORD *numdev);
 423 };
 424
 425 typedef enum _VMR9DeinterlacePrefs
 426 {
 427     DeinterlacePref9_NextBest = 0x1,
 428     DeinterlacePref9_BOB = 0x2,
 429     DeinterlacePref9_Weave = 0x4,
 430     DeinterlacePref9_Mask = 0x7
 431 } VMR9DeinterlacePrefs;
 432
 433 typedef enum _VMR9DeinterlaceTech
 434 {
 435     DeinterlaceTech9_Unknown = 0,
 436     DeinterlaceTech9_BOBLineReplicate = 0x1,
 437     DeinterlaceTech9_BOBVerticalStretch = 0x2,
 438     DeinterlaceTech9_MedianFiltering = 0x4,
 439     DeinterlaceTech9_EdgeFiltering = 0x10,
 440     DeinterlaceTech9_FieldAdaptive = 0x20,
 441     DeinterlaceTech9_PixelAdaptive = 0x40,
 442     DeinterlaceTech9_MotionVectorSteered = 0x80
 443 } VMR9DeinterlaceTech;
 444
 445 typedef struct _VMR9Frequency
 446 {
 447     DWORD dwNumerator;
 448     DWORD dwDenominator;
 449 } VMR9Frequency;
 450
 451 typedef enum _VMR9_SampleFormat
 452 {
 453     VMR9_SampleReserved = 1,
 454     VMR9_SampleProgressiveFrame = 2,
 455     VMR9_SampleFieldInterleavedEvenFirst = 3,
 456     VMR9_SampleFieldInterleavedOddFirst = 4,
 457     VMR9_SampleFieldSingleEven = 5,
 458     VMR9_SampleFieldSingleOdd = 6,
 459 } VMR9_SampleFormat;
 460
 461 typedef struct _VMR9VideoDesc
 462 {
 463     DWORD dwSize;
 464     DWORD dwSampleWidth;
 465     DWORD dwSampleHeight;
 466     VMR9_SampleFormat SampleFormat;
 467     DWORD dwFourCC;
 468     VMR9Frequency InputSampleFreq;
 469     VMR9Frequency OutputFrameFreq;
 470 } VMR9VideoDesc;
 471
 472 typedef struct _VMR9DeinterlaceCaps {
 473     DWORD dwSize;
 474     DWORD dwNumPreviousOutputFrames;
 475     DWORD dwNumForwardRefSamples;
 476     DWORD dwNumBackwardRefSamples;
 477     VMR9DeinterlaceTech DeinterlaceTechnology;
 478 } VMR9DeinterlaceCaps;
 479
 480 [
 481     local,
 482     object,
 483     uuid(a215fb8d-13c2-4f7f-993c-003d6271a459),
 484     helpstring("IVMRDeinterlaceControl9 interface"),
 485     pointer_default(unique)
 486 ]
 487 interface IVMRDeinterlaceControl9 : IUnknown
 488 {
 489     HRESULT GetNumberOfDeinterlaceModes([in] VMR9VideoDesc *desc, [in, out] DWORD *nummodes, [out] GUID *modes);
 490     HRESULT GetDeinterlaceModeCaps([in] GUID *mode, [in] VMR9VideoDesc *desc, [out] VMR9DeinterlaceCaps *caps);
 491     HRESULT GetDeinterlaceMode([in] DWORD streamid, [out] GUID *mode);
 492     HRESULT SetDeinterlaceMode([in] DWORD streamid, [in] GUID *mode);
 493     HRESULT GetDeinterlacePrefs([out] DWORD *prefs);
 494     HRESULT SetDeinterlacePrefs([in] DWORD prefs);
 495     HRESULT GetActualDeinterlaceMode([in] DWORD streamid, [out] GUID *mode);
 496 };
 497
 498 typedef struct _VMR9VideoStreamInfo {
 499     IDirect3DSurface9 *pddsVideoSurface;
 500     DWORD dwWidth;
 501     DWORD dwHeight;
 502     DWORD dwStrmID;
 503     FLOAT fAlpha;
 504     VMR9NormalizedRect rNormal;
 505     REFERENCE_TIME rtStart;
 506     REFERENCE_TIME rtEnd;
 507     VMR9_SampleFormat SampleFormat;
 508 } VMR9VideoStreamInfo;
 509
 510 [
 511     local,
 512     object,
 513     uuid(4a5c89eb-df51-4654-ac2a-e48e02bbabf6),
 514     helpstring("IVMRImageCompositor9 interface"),
 515     pointer_default(unique)
 516 ]
 517 interface IVMRImageCompositor9 : IUnknown
 518 {
 519     HRESULT InitCompositionDevice([in] IUnknown *d3ddev);
 520     HRESULT TermCompositionDevice([in] IUnknown *d3ddev);
 521     HRESULT CompositeImage([in] IUnknown *d3ddev, [in] IDirect3DSurface9 *d3dtarget, [in] AM_MEDIA_TYPE *mttarget,
 522                            [in] REFERENCE_TIME start, [in] REFERENCE_TIME stop, D3DCOLOR back,
 523                            [in] VMR9VideoStreamInfo *info, [in] UINT streams);
 524 };