VirtualBox

source: vbox/trunk/src/VBox/Devices/Graphics/shaderlib/wine/include/vmrender.idl

Last change on this file was 53206, checked in by vboxsync, 10 years ago

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