wined3d: Don't crash during initialization if the adapter doesn't have full GL info.
[wine] / 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 };