VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/include/vmr9.idl@ 33252

Last change on this file since 33252 was 19678, checked in by vboxsync, 16 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette