?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d2d1: Implement ID2D1DeviceContext::CreateImageBrush().
[wine.git] / dlls / quartz / vmr9.c
blob2330f8fc0c9232b02a75088f162dad9157c5b691
1 /*
2 * Video Mixing Renderer for dx9
3 *
4 * Copyright 2004 Christian Costa
5 * Copyright 2008 Maarten Lankhorst
6 * Copyright 2012 Aric Stewart
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "quartz_private.h"
24
25 #include "uuids.h"
26 #include "vfwmsgs.h"
27 #include "amvideo.h"
28 #include "windef.h"
29 #include "winbase.h"
30 #include "dshow.h"
31 #include "evcode.h"
32 #include "strmif.h"
33 #include "ddraw.h"
34 #include "dvdmedia.h"
35 #include "d3d9.h"
36 #include "videoacc.h"
37 #include "vmr9.h"
38
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
42
43 static inline const char *debugstr_normalized_rect(const VMR9NormalizedRect *rect)
44 {
45 if (!rect) return "(null)";
46 return wine_dbg_sprintf("(%.8e,%.8e)-(%.8e,%.8e)", rect->left, rect->top, rect->right, rect->bottom);
47 }
48
49 static const BITMAPINFOHEADER *get_bitmap_header(const AM_MEDIA_TYPE *mt)
50 {
51 if (IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo))
52 return &((VIDEOINFOHEADER *)mt->pbFormat)->bmiHeader;
53 else
54 return &((VIDEOINFOHEADER2 *)mt->pbFormat)->bmiHeader;
55 }
56
57 struct quartz_vmr
58 {
59 struct strmbase_renderer renderer;
60 struct video_window window;
61
62 IAMCertifiedOutputProtection IAMCertifiedOutputProtection_iface;
63 IAMFilterMiscFlags IAMFilterMiscFlags_iface;
64 IVMRAspectRatioControl9 IVMRAspectRatioControl9_iface;
65 IVMRFilterConfig IVMRFilterConfig_iface;
66 IVMRFilterConfig9 IVMRFilterConfig9_iface;
67 IVMRMixerBitmap9 IVMRMixerBitmap9_iface;
68 IVMRMixerControl9 IVMRMixerControl9_iface;
69 IVMRMonitorConfig IVMRMonitorConfig_iface;
70 IVMRMonitorConfig9 IVMRMonitorConfig9_iface;
71 IVMRSurfaceAllocatorNotify IVMRSurfaceAllocatorNotify_iface;
72 IVMRSurfaceAllocatorNotify9 IVMRSurfaceAllocatorNotify9_iface;
73 IVMRWindowlessControl IVMRWindowlessControl_iface;
74 IVMRWindowlessControl9 IVMRWindowlessControl9_iface;
75
76 /* Devil May Cry 3 releases the last IBaseFilter reference while still
77 * holding an IVMRSurfaceAllocatorNotify9 reference, and depends on
78 * IVMRSurfaceAllocator9::TerminateDevice() being called as a result.
79 * Native uses a separate reference count for IVMRSurfaceAllocatorNotify9. */
80 LONG IVMRSurfaceAllocatorNotify9_refcount;
81
82 IAMVideoAccelerator IAMVideoAccelerator_iface;
83 IOverlay IOverlay_iface;
84
85 IVMRSurfaceAllocator9 *allocator;
86 IVMRImagePresenter9 *presenter;
87
88 DWORD stream_count;
89 DWORD mixing_prefs;
90
91 /*
92 * The Video Mixing Renderer supports 3 modes, renderless, windowless and windowed
93 * What I do is implement windowless as a special case of renderless, and then
94 * windowed also as a special case of windowless. This is probably the easiest way.
95 */
96 VMR9Mode mode;
97 BITMAPINFOHEADER bmiheader;
98
99 HMODULE hD3d9;
100
101 /* Presentation related members */
102 IDirect3DDevice9 *allocator_d3d9_dev;
103 IDirect3DSurface9 **surfaces;
104 DWORD num_surfaces;
105 DWORD cur_surface;
106 DWORD_PTR cookie;
107
108 HWND clipping_window;
109
110 LONG VideoWidth;
111 LONG VideoHeight;
112 VMR9AspectRatioMode aspect_mode;
113 };
114
115 static inline BOOL is_vmr9(const struct quartz_vmr *filter)
116 {
117 return IsEqualGUID(&filter->renderer.filter.clsid, &CLSID_VideoMixingRenderer9);
118 }
119
120 static inline struct quartz_vmr *impl_from_video_window(struct video_window *iface)
121 {
122 return CONTAINING_RECORD(iface, struct quartz_vmr, window);
123 }
124
125 static inline struct quartz_vmr *impl_from_IAMCertifiedOutputProtection(IAMCertifiedOutputProtection *iface)
126 {
127 return CONTAINING_RECORD(iface, struct quartz_vmr, IAMCertifiedOutputProtection_iface);
128 }
129
130 static inline struct quartz_vmr *impl_from_IAMFilterMiscFlags(IAMFilterMiscFlags *iface)
131 {
132 return CONTAINING_RECORD(iface, struct quartz_vmr, IAMFilterMiscFlags_iface);
133 }
134
135 static inline struct quartz_vmr *impl_from_IVMRFilterConfig(IVMRFilterConfig *iface)
136 {
137 return CONTAINING_RECORD(iface, struct quartz_vmr, IVMRFilterConfig_iface);
138 }
139
140 static inline struct quartz_vmr *impl_from_IVMRFilterConfig9(IVMRFilterConfig9 *iface)
141 {
142 return CONTAINING_RECORD(iface, struct quartz_vmr, IVMRFilterConfig9_iface);
143 }
144
145 static inline struct quartz_vmr *impl_from_IVMRMonitorConfig(IVMRMonitorConfig *iface)
146 {
147 return CONTAINING_RECORD(iface, struct quartz_vmr, IVMRMonitorConfig_iface);
148 }
149
150 static inline struct quartz_vmr *impl_from_IVMRMonitorConfig9(IVMRMonitorConfig9 *iface)
151 {
152 return CONTAINING_RECORD(iface, struct quartz_vmr, IVMRMonitorConfig9_iface);
153 }
154
155 static inline struct quartz_vmr *impl_from_IVMRSurfaceAllocatorNotify(IVMRSurfaceAllocatorNotify *iface)
156 {
157 return CONTAINING_RECORD(iface, struct quartz_vmr, IVMRSurfaceAllocatorNotify_iface);
158 }
159
160 static inline struct quartz_vmr *impl_from_IVMRSurfaceAllocatorNotify9(IVMRSurfaceAllocatorNotify9 *iface)
161 {
162 return CONTAINING_RECORD(iface, struct quartz_vmr, IVMRSurfaceAllocatorNotify9_iface);
163 }
164
165 static inline struct quartz_vmr *impl_from_IVMRWindowlessControl(IVMRWindowlessControl *iface)
166 {
167 return CONTAINING_RECORD(iface, struct quartz_vmr, IVMRWindowlessControl_iface);
168 }
169
170 static inline struct quartz_vmr *impl_from_IVMRWindowlessControl9(IVMRWindowlessControl9 *iface)
171 {
172 return CONTAINING_RECORD(iface, struct quartz_vmr, IVMRWindowlessControl9_iface);
173 }
174
175 struct default_presenter
176 {
177 IVMRImagePresenter9 IVMRImagePresenter9_iface;
178 IVMRSurfaceAllocator9 IVMRSurfaceAllocator9_iface;
179
180 LONG refCount;
181
182 IDirect3DDevice9 *d3d9_dev;
183 IDirect3D9 *d3d9_ptr;
184 IDirect3DSurface9 **d3d9_surfaces;
185 HMONITOR hMon;
186 DWORD num_surfaces;
187
188 VMR9AllocationInfo info;
189
190 struct quartz_vmr* pVMR9;
191 IVMRSurfaceAllocatorNotify9 *SurfaceAllocatorNotify;
192 };
193
194 static inline struct default_presenter *impl_from_IVMRImagePresenter9(IVMRImagePresenter9 *iface)
195 {
196 return CONTAINING_RECORD(iface, struct default_presenter, IVMRImagePresenter9_iface);
197 }
198
199 static inline struct default_presenter *impl_from_IVMRSurfaceAllocator9(IVMRSurfaceAllocator9 *iface)
200 {
201 return CONTAINING_RECORD(iface, struct default_presenter, IVMRSurfaceAllocator9_iface);
202 }
203
204 static HRESULT VMR9DefaultAllocatorPresenterImpl_create(struct quartz_vmr *parent, LPVOID * ppv);
205
206 static inline struct quartz_vmr *impl_from_IBaseFilter(IBaseFilter *iface)
207 {
208 return CONTAINING_RECORD(iface, struct quartz_vmr, renderer.filter.IBaseFilter_iface);
209 }
210
211 static HRESULT vmr_render(struct strmbase_renderer *iface, IMediaSample *sample)
212 {
213 struct quartz_vmr *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
214 unsigned int data_size, width, depth, src_pitch;
215 const BITMAPINFOHEADER *bitmap_header;
216 REFERENCE_TIME start_time, end_time;
217 VMR9PresentationInfo info = {};
218 D3DLOCKED_RECT locked_rect;
219 BYTE *data = NULL;
220 HRESULT hr;
221 int height;
222
223 TRACE("filter %p, sample %p.\n", filter, sample);
224
225 /* It is possible that there is no device at this point */
226
227 if (!filter->allocator || !filter->presenter)
228 {
229 ERR("NO PRESENTER!!\n");
230 return S_FALSE;
231 }
232
233 info.dwFlags = VMR9Sample_SrcDstRectsValid;
234
235 if (SUCCEEDED(hr = IMediaSample_GetTime(sample, &start_time, &end_time)))
236 info.dwFlags |= VMR9Sample_TimeValid;
237
238 if (IMediaSample_IsDiscontinuity(sample) == S_OK)
239 info.dwFlags |= VMR9Sample_Discontinuity;
240
241 if (IMediaSample_IsPreroll(sample) == S_OK)
242 info.dwFlags |= VMR9Sample_Preroll;
243
244 if (IMediaSample_IsSyncPoint(sample) == S_OK)
245 info.dwFlags |= VMR9Sample_SyncPoint;
246
247 if (FAILED(hr = IMediaSample_GetPointer(sample, &data)))
248 {
249 ERR("Failed to get pointer to sample data, hr %#lx.\n", hr);
250 return hr;
251 }
252 data_size = IMediaSample_GetActualDataLength(sample);
253
254 bitmap_header = get_bitmap_header(&filter->renderer.sink.pin.mt);
255 width = bitmap_header->biWidth;
256 height = bitmap_header->biHeight;
257 depth = bitmap_header->biBitCount;
258 if (bitmap_header->biCompression == mmioFOURCC('N','V','1','2')
259 || bitmap_header->biCompression == mmioFOURCC('Y','V','1','2'))
260 src_pitch = width;
261 else /* packed YUV (UYVY or YUY2) or RGB */
262 src_pitch = ((width * depth / 8) + 3) & ~3;
263
264 info.rtStart = start_time;
265 info.rtEnd = end_time;
266 info.szAspectRatio.cx = width;
267 info.szAspectRatio.cy = height;
268 info.lpSurf = filter->surfaces[(++filter->cur_surface) % filter->num_surfaces];
269
270 if (FAILED(hr = IDirect3DSurface9_LockRect(info.lpSurf, &locked_rect, NULL, D3DLOCK_DISCARD)))
271 {
272 ERR("Failed to lock surface, hr %#lx.\n", hr);
273 return hr;
274 }
275
276 if (height > 0 && bitmap_header->biCompression == BI_RGB)
277 {
278 BYTE *dst = (BYTE *)locked_rect.pBits + (height * locked_rect.Pitch);
279 const BYTE *src = data;
280
281 TRACE("Inverting image.\n");
282
283 while (height--)
284 {
285 dst -= locked_rect.Pitch;
286 memcpy(dst, src, width * depth / 8);
287 src += src_pitch;
288 }
289 }
290 else if (locked_rect.Pitch != src_pitch)
291 {
292 BYTE *dst = locked_rect.pBits;
293 const BYTE *src = data;
294
295 height = abs(height);
296
297 TRACE("Source pitch %u does not match dest pitch %u; copying manually.\n",
298 src_pitch, locked_rect.Pitch);
299
300 while (height--)
301 {
302 memcpy(dst, src, width * depth / 8);
303 src += src_pitch;
304 dst += locked_rect.Pitch;
305 }
306 }
307 else
308 {
309 memcpy(locked_rect.pBits, data, data_size);
310 }
311
312 IDirect3DSurface9_UnlockRect(info.lpSurf);
313
314 return IVMRImagePresenter9_PresentImage(filter->presenter, filter->cookie, &info);
315 }
316
317 static HRESULT vmr_query_accept(struct strmbase_renderer *iface, const AM_MEDIA_TYPE *mt)
318 {
319 if (!IsEqualIID(&mt->majortype, &MEDIATYPE_Video) || !mt->pbFormat)
320 return S_FALSE;
321
322 if (!IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo)
323 && !IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo2))
324 return S_FALSE;
325
326 return S_OK;
327 }
328
329 static HRESULT initialize_device(struct quartz_vmr *filter, VMR9AllocationInfo *info, DWORD count)
330 {
331 HRESULT hr;
332 DWORD i;
333
334 if (FAILED(hr = IVMRSurfaceAllocator9_InitializeDevice(filter->allocator,
335 filter->cookie, info, &count)))
336 {
337 WARN("Failed to initialize device (flags %#lx), hr %#lx.\n", info->dwFlags, hr);
338 return hr;
339 }
340
341 for (i = 0; i < count; ++i)
342 {
343 if (FAILED(hr = IVMRSurfaceAllocator9_GetSurface(filter->allocator,
344 filter->cookie, i, 0, &filter->surfaces[i])))
345 {
346 ERR("Failed to get surface %lu, hr %#lx.\n", i, hr);
347 while (i--)
348 IDirect3DSurface9_Release(filter->surfaces[i]);
349 IVMRSurfaceAllocator9_TerminateDevice(filter->allocator, filter->cookie);
350 return hr;
351 }
352 }
353
354 return hr;
355 }
356
357 static HRESULT allocate_surfaces(struct quartz_vmr *filter, const AM_MEDIA_TYPE *mt)
358 {
359 VMR9AllocationInfo info = {};
360 HRESULT hr = E_FAIL;
361 DWORD count = 1;
362 unsigned int i;
363
364 static const struct
365 {
366 const GUID *subtype;
367 D3DFORMAT format;
368 DWORD flags;
369 }
370 formats[] =
371 {
372 {&MEDIASUBTYPE_ARGB1555, D3DFMT_A1R5G5B5, VMR9AllocFlag_TextureSurface},
373 {&MEDIASUBTYPE_ARGB32, D3DFMT_A8R8G8B8, VMR9AllocFlag_TextureSurface},
374 {&MEDIASUBTYPE_ARGB4444, D3DFMT_A4R4G4B4, VMR9AllocFlag_TextureSurface},
375
376 {&MEDIASUBTYPE_RGB24, D3DFMT_R8G8B8, VMR9AllocFlag_TextureSurface | VMR9AllocFlag_OffscreenSurface},
377 {&MEDIASUBTYPE_RGB32, D3DFMT_X8R8G8B8, VMR9AllocFlag_TextureSurface | VMR9AllocFlag_OffscreenSurface},
378 {&MEDIASUBTYPE_RGB555, D3DFMT_X1R5G5B5, VMR9AllocFlag_TextureSurface | VMR9AllocFlag_OffscreenSurface},
379 {&MEDIASUBTYPE_RGB565, D3DFMT_R5G6B5, VMR9AllocFlag_TextureSurface | VMR9AllocFlag_OffscreenSurface},
380
381 {&MEDIASUBTYPE_NV12, MAKEFOURCC('N','V','1','2'), VMR9AllocFlag_OffscreenSurface},
382 {&MEDIASUBTYPE_UYVY, D3DFMT_UYVY, VMR9AllocFlag_OffscreenSurface},
383 {&MEDIASUBTYPE_YUY2, D3DFMT_YUY2, VMR9AllocFlag_OffscreenSurface},
384 {&MEDIASUBTYPE_YV12, MAKEFOURCC('Y','V','1','2'), VMR9AllocFlag_OffscreenSurface},
385 };
386
387 TRACE("Initializing in mode %u, our window %p, clipping window %p.\n",
388 filter->mode, filter->window.hwnd, filter->clipping_window);
389
390 if (filter->mode == VMR9Mode_Windowless && !filter->clipping_window)
391 return S_OK;
392
393 info.Pool = D3DPOOL_DEFAULT;
394 info.MinBuffers = count;
395 info.dwWidth = info.szAspectRatio.cx = info.szNativeSize.cx = filter->bmiheader.biWidth;
396 info.dwHeight = info.szAspectRatio.cy = info.szNativeSize.cy = filter->bmiheader.biHeight;
397
398 if (!(filter->surfaces = calloc(count, sizeof(IDirect3DSurface9 *))))
399 return E_OUTOFMEMORY;
400 filter->num_surfaces = count;
401 filter->cur_surface = 0;
402
403 if (!is_vmr9(filter))
404 {
405 switch (filter->bmiheader.biCompression)
406 {
407 case BI_RGB:
408 switch (filter->bmiheader.biBitCount)
409 {
410 case 24: info.Format = D3DFMT_R8G8B8; break;
411 case 32: info.Format = D3DFMT_X8R8G8B8; break;
412 default:
413 FIXME("Unhandled bit depth %u.\n", filter->bmiheader.biBitCount);
414 free(filter->surfaces);
415 return VFW_E_TYPE_NOT_ACCEPTED;
416 }
417
418 info.dwFlags = VMR9AllocFlag_TextureSurface;
419 break;
420
421 case mmioFOURCC('N','V','1','2'):
422 case mmioFOURCC('U','Y','V','Y'):
423 case mmioFOURCC('Y','U','Y','2'):
424 case mmioFOURCC('Y','V','1','2'):
425 info.Format = filter->bmiheader.biCompression;
426 info.dwFlags = VMR9AllocFlag_OffscreenSurface;
427 break;
428
429 default:
430 WARN("Unhandled video compression %#lx.\n", filter->bmiheader.biCompression);
431 free(filter->surfaces);
432 return VFW_E_TYPE_NOT_ACCEPTED;
433 }
434 if (FAILED(hr = initialize_device(filter, &info, count)))
435 free(filter->surfaces);
436 return hr;
437 }
438
439 for (i = 0; i < ARRAY_SIZE(formats); ++i)
440 {
441 if (IsEqualGUID(&mt->subtype, formats[i].subtype))
442 {
443 info.Format = formats[i].format;
444
445 if (formats[i].flags & VMR9AllocFlag_TextureSurface)
446 {
447 info.dwFlags = VMR9AllocFlag_TextureSurface;
448 if (SUCCEEDED(hr = initialize_device(filter, &info, count)))
449 return hr;
450 }
451
452 if (formats[i].flags & VMR9AllocFlag_OffscreenSurface)
453 {
454 info.dwFlags = VMR9AllocFlag_OffscreenSurface;
455 if (SUCCEEDED(hr = initialize_device(filter, &info, count)))
456 return hr;
457 }
458 }
459 }
460
461 free(filter->surfaces);
462 return VFW_E_TYPE_NOT_ACCEPTED;
463 }
464
465 static void vmr_init_stream(struct strmbase_renderer *iface)
466 {
467 struct quartz_vmr *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
468
469 if (filter->window.hwnd && filter->window.AutoShow)
470 ShowWindow(filter->window.hwnd, SW_SHOW);
471 }
472
473 static void vmr_start_stream(struct strmbase_renderer *iface)
474 {
475 struct quartz_vmr *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
476
477 IVMRImagePresenter9_StartPresenting(filter->presenter, filter->cookie);
478 }
479
480 static void vmr_stop_stream(struct strmbase_renderer *iface)
481 {
482 struct quartz_vmr *This = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
483
484 TRACE("(%p)\n", This);
485
486 if (This->renderer.filter.state == State_Running)
487 IVMRImagePresenter9_StopPresenting(This->presenter, This->cookie);
488 }
489
490 static HRESULT vmr_connect(struct strmbase_renderer *iface, const AM_MEDIA_TYPE *mt)
491 {
492 struct quartz_vmr *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
493 const BITMAPINFOHEADER *bitmap_header = get_bitmap_header(mt);
494 HWND window = filter->window.hwnd;
495 HRESULT hr;
496 RECT rect;
497
498 filter->bmiheader = *bitmap_header;
499 filter->VideoWidth = bitmap_header->biWidth;
500 filter->VideoHeight = bitmap_header->biHeight;
501 SetRect(&rect, 0, 0, filter->VideoWidth, filter->VideoHeight);
502 filter->window.src = rect;
503
504 AdjustWindowRectEx(&rect, GetWindowLongW(window, GWL_STYLE), FALSE,
505 GetWindowLongW(window, GWL_EXSTYLE));
506 SetWindowPos(window, NULL, 0, 0, rect.right - rect.left, rect.bottom - rect.top,
507 SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
508 GetClientRect(window, &filter->window.dst);
509
510 if (filter->mode
511 || SUCCEEDED(hr = IVMRFilterConfig9_SetRenderingMode(&filter->IVMRFilterConfig9_iface, VMR9Mode_Windowed)))
512 hr = allocate_surfaces(filter, mt);
513
514 return hr;
515 }
516
517 static void vmr_disconnect(struct strmbase_renderer *This)
518 {
519 struct quartz_vmr *filter = impl_from_IBaseFilter(&This->filter.IBaseFilter_iface);
520 DWORD i;
521
522 if (filter->mode && filter->allocator && filter->presenter)
523 {
524 for (i = 0; i < filter->num_surfaces; ++i)
525 IDirect3DSurface9_Release(filter->surfaces[i]);
526 free(filter->surfaces);
527
528 IVMRSurfaceAllocator9_TerminateDevice(filter->allocator, filter->cookie);
529 filter->num_surfaces = 0;
530 }
531 }
532
533 static void vmr_destroy(struct strmbase_renderer *iface)
534 {
535 struct quartz_vmr *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
536
537 video_window_cleanup(&filter->window);
538
539 /* Devil May Cry 3 releases the IVMRSurfaceAllocatorNotify9 interface from
540 * TerminateDevice(). Artificially increase the reference count so that we
541 * don't free the filter yet. */
542 InterlockedIncrement(&filter->renderer.filter.refcount);
543
544 if (filter->allocator)
545 {
546 IVMRSurfaceAllocator9_TerminateDevice(filter->allocator, filter->cookie);
547 IVMRSurfaceAllocator9_Release(filter->allocator);
548 }
549 if (filter->presenter)
550 IVMRImagePresenter9_Release(filter->presenter);
551
552 filter->num_surfaces = 0;
553 if (filter->allocator_d3d9_dev)
554 {
555 IDirect3DDevice9_Release(filter->allocator_d3d9_dev);
556 filter->allocator_d3d9_dev = NULL;
557 }
558
559 FreeLibrary(filter->hD3d9);
560 strmbase_renderer_cleanup(&filter->renderer);
561 if (!filter->IVMRSurfaceAllocatorNotify9_refcount)
562 free(filter);
563 }
564
565 static HRESULT vmr_query_interface(struct strmbase_renderer *iface, REFIID iid, void **out)
566 {
567 struct quartz_vmr *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
568
569 if (IsEqualGUID(iid, &IID_IVideoWindow))
570 *out = &filter->window.IVideoWindow_iface;
571 else if (IsEqualGUID(iid, &IID_IBasicVideo))
572 *out = &filter->window.IBasicVideo_iface;
573 else if (IsEqualGUID(iid, &IID_IAMCertifiedOutputProtection))
574 *out = &filter->IAMCertifiedOutputProtection_iface;
575 else if (IsEqualGUID(iid, &IID_IAMFilterMiscFlags))
576 *out = &filter->IAMFilterMiscFlags_iface;
577 else if (IsEqualGUID(iid, &IID_IVMRAspectRatioControl9) && is_vmr9(filter))
578 *out = &filter->IVMRAspectRatioControl9_iface;
579 else if (IsEqualGUID(iid, &IID_IVMRFilterConfig) && !is_vmr9(filter))
580 *out = &filter->IVMRFilterConfig_iface;
581 else if (IsEqualGUID(iid, &IID_IVMRFilterConfig9) && is_vmr9(filter))
582 *out = &filter->IVMRFilterConfig9_iface;
583 else if (IsEqualGUID(iid, &IID_IVMRMixerBitmap9) && is_vmr9(filter))
584 *out = &filter->IVMRMixerBitmap9_iface;
585 else if (IsEqualGUID(iid, &IID_IVMRMixerControl9) && is_vmr9(filter) && filter->stream_count)
586 *out = &filter->IVMRMixerControl9_iface;
587 else if (IsEqualGUID(iid, &IID_IVMRMonitorConfig) && !is_vmr9(filter))
588 *out = &filter->IVMRMonitorConfig_iface;
589 else if (IsEqualGUID(iid, &IID_IVMRMonitorConfig9)
590 && filter->mode != VMR9Mode_Renderless && is_vmr9(filter))
591 *out = &filter->IVMRMonitorConfig9_iface;
592 else if (IsEqualGUID(iid, &IID_IVMRSurfaceAllocatorNotify)
593 && filter->mode == (VMR9Mode)VMRMode_Renderless && !is_vmr9(filter))
594 *out = &filter->IVMRSurfaceAllocatorNotify_iface;
595 else if (IsEqualGUID(iid, &IID_IVMRSurfaceAllocatorNotify9)
596 && filter->mode == VMR9Mode_Renderless && is_vmr9(filter))
597 *out = &filter->IVMRSurfaceAllocatorNotify9_iface;
598 else if (IsEqualGUID(iid, &IID_IVMRWindowlessControl)
599 && filter->mode == (VMR9Mode)VMRMode_Windowless && !is_vmr9(filter))
600 *out = &filter->IVMRWindowlessControl_iface;
601 else if (IsEqualGUID(iid, &IID_IVMRWindowlessControl9)
602 && filter->mode == VMR9Mode_Windowless && is_vmr9(filter))
603 *out = &filter->IVMRWindowlessControl9_iface;
604 else
605 return E_NOINTERFACE;
606
607 IUnknown_AddRef((IUnknown *)*out);
608 return S_OK;
609 }
610
611 static HRESULT vmr_pin_query_interface(struct strmbase_renderer *iface, REFIID iid, void **out)
612 {
613 struct quartz_vmr *filter = impl_from_IBaseFilter(&iface->filter.IBaseFilter_iface);
614
615 if (IsEqualGUID(iid, &IID_IAMVideoAccelerator))
616 *out = &filter->IAMVideoAccelerator_iface;
617 else if (IsEqualGUID(iid, &IID_IOverlay))
618 *out = &filter->IOverlay_iface;
619 else
620 return E_NOINTERFACE;
621
622 IUnknown_AddRef((IUnknown *)*out);
623 return S_OK;
624 }
625
626 static const struct strmbase_renderer_ops renderer_ops =
627 {
628 .renderer_query_accept = vmr_query_accept,
629 .renderer_render = vmr_render,
630 .renderer_init_stream = vmr_init_stream,
631 .renderer_start_stream = vmr_start_stream,
632 .renderer_stop_stream = vmr_stop_stream,
633 .renderer_connect = vmr_connect,
634 .renderer_disconnect = vmr_disconnect,
635 .renderer_destroy = vmr_destroy,
636 .renderer_query_interface = vmr_query_interface,
637 .renderer_pin_query_interface = vmr_pin_query_interface,
638 };
639
640 static RECT vmr_get_default_rect(struct video_window *This)
641 {
642 struct quartz_vmr *pVMR9 = impl_from_video_window(This);
643 static RECT defRect;
644
645 SetRect(&defRect, 0, 0, pVMR9->VideoWidth, pVMR9->VideoHeight);
646
647 return defRect;
648 }
649
650 static HRESULT vmr_get_current_image(struct video_window *iface, LONG *size, LONG *image)
651 {
652 struct quartz_vmr *filter = impl_from_video_window(iface);
653 IDirect3DSurface9 *rt = NULL, *surface = NULL;
654 D3DLOCKED_RECT locked_rect;
655 IDirect3DDevice9 *device;
656 unsigned int row_size;
657 BITMAPINFOHEADER bih;
658 LONG i, size_left;
659 char *dst;
660 HRESULT hr;
661
662 EnterCriticalSection(&filter->renderer.filter.stream_cs);
663 device = filter->allocator_d3d9_dev;
664
665 bih = *get_bitmap_header(&filter->renderer.sink.pin.mt);
666 bih.biSizeImage = bih.biWidth * bih.biHeight * bih.biBitCount / 8;
667
668 if (!image)
669 {
670 *size = sizeof(BITMAPINFOHEADER) + bih.biSizeImage;
671 LeaveCriticalSection(&filter->renderer.filter.stream_cs);
672 return S_OK;
673 }
674
675 if (FAILED(hr = IDirect3DDevice9_GetRenderTarget(device, 0, &rt)))
676 goto out;
677
678 if (FAILED(hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, bih.biWidth,
679 bih.biHeight, D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM, &surface, NULL)))
680 goto out;
681
682 if (FAILED(hr = IDirect3DDevice9_GetRenderTargetData(device, rt, surface)))
683 goto out;
684
685 if (FAILED(hr = IDirect3DSurface9_LockRect(surface, &locked_rect, NULL, D3DLOCK_READONLY)))
686 goto out;
687
688 size_left = *size;
689 memcpy(image, &bih, min(size_left, sizeof(BITMAPINFOHEADER)));
690 size_left -= sizeof(BITMAPINFOHEADER);
691
692 dst = (char *)image + sizeof(BITMAPINFOHEADER);
693 row_size = bih.biWidth * bih.biBitCount / 8;
694
695 for (i = 0; i < bih.biHeight && size_left > 0; ++i)
696 {
697 memcpy(dst, (char *)locked_rect.pBits + (i * locked_rect.Pitch), min(row_size, size_left));
698 dst += row_size;
699 size_left -= row_size;
700 }
701
702 IDirect3DSurface9_UnlockRect(surface);
703
704 out:
705 if (surface) IDirect3DSurface9_Release(surface);
706 if (rt) IDirect3DSurface9_Release(rt);
707 LeaveCriticalSection(&filter->renderer.filter.stream_cs);
708 return hr;
709 }
710
711 static const struct video_window_ops window_ops =
712 {
713 .get_default_rect = vmr_get_default_rect,
714 .get_current_image = vmr_get_current_image,
715 };
716
717 static const IVideoWindowVtbl IVideoWindow_VTable =
718 {
719 BaseControlWindowImpl_QueryInterface,
720 BaseControlWindowImpl_AddRef,
721 BaseControlWindowImpl_Release,
722 BaseControlWindowImpl_GetTypeInfoCount,
723 BaseControlWindowImpl_GetTypeInfo,
724 BaseControlWindowImpl_GetIDsOfNames,
725 BaseControlWindowImpl_Invoke,
726 BaseControlWindowImpl_put_Caption,
727 BaseControlWindowImpl_get_Caption,
728 BaseControlWindowImpl_put_WindowStyle,
729 BaseControlWindowImpl_get_WindowStyle,
730 BaseControlWindowImpl_put_WindowStyleEx,
731 BaseControlWindowImpl_get_WindowStyleEx,
732 BaseControlWindowImpl_put_AutoShow,
733 BaseControlWindowImpl_get_AutoShow,
734 BaseControlWindowImpl_put_WindowState,
735 BaseControlWindowImpl_get_WindowState,
736 BaseControlWindowImpl_put_BackgroundPalette,
737 BaseControlWindowImpl_get_BackgroundPalette,
738 BaseControlWindowImpl_put_Visible,
739 BaseControlWindowImpl_get_Visible,
740 BaseControlWindowImpl_put_Left,
741 BaseControlWindowImpl_get_Left,
742 BaseControlWindowImpl_put_Width,
743 BaseControlWindowImpl_get_Width,
744 BaseControlWindowImpl_put_Top,
745 BaseControlWindowImpl_get_Top,
746 BaseControlWindowImpl_put_Height,
747 BaseControlWindowImpl_get_Height,
748 BaseControlWindowImpl_put_Owner,
749 BaseControlWindowImpl_get_Owner,
750 BaseControlWindowImpl_put_MessageDrain,
751 BaseControlWindowImpl_get_MessageDrain,
752 BaseControlWindowImpl_get_BorderColor,
753 BaseControlWindowImpl_put_BorderColor,
754 BaseControlWindowImpl_get_FullScreenMode,
755 BaseControlWindowImpl_put_FullScreenMode,
756 BaseControlWindowImpl_SetWindowForeground,
757 BaseControlWindowImpl_NotifyOwnerMessage,
758 BaseControlWindowImpl_SetWindowPosition,
759 BaseControlWindowImpl_GetWindowPosition,
760 BaseControlWindowImpl_GetMinIdealImageSize,
761 BaseControlWindowImpl_GetMaxIdealImageSize,
762 BaseControlWindowImpl_GetRestorePosition,
763 BaseControlWindowImpl_HideCursor,
764 BaseControlWindowImpl_IsCursorHidden
765 };
766
767 static HRESULT WINAPI AMCertifiedOutputProtection_QueryInterface(IAMCertifiedOutputProtection *iface,
768 REFIID riid, void **ppv)
769 {
770 struct quartz_vmr *This = impl_from_IAMCertifiedOutputProtection(iface);
771 return IUnknown_QueryInterface(This->renderer.filter.outer_unk, riid, ppv);
772 }
773
774 static ULONG WINAPI AMCertifiedOutputProtection_AddRef(IAMCertifiedOutputProtection *iface)
775 {
776 struct quartz_vmr *This = impl_from_IAMCertifiedOutputProtection(iface);
777 return IUnknown_AddRef(This->renderer.filter.outer_unk);
778 }
779
780 static ULONG WINAPI AMCertifiedOutputProtection_Release(IAMCertifiedOutputProtection *iface)
781 {
782 struct quartz_vmr *This = impl_from_IAMCertifiedOutputProtection(iface);
783 return IUnknown_Release(This->renderer.filter.outer_unk);
784 }
785
786 static HRESULT WINAPI AMCertifiedOutputProtection_KeyExchange(IAMCertifiedOutputProtection *iface,
787 GUID* pRandom, BYTE** VarLenCertGH,
788 DWORD* pdwLengthCertGH)
789 {
790 struct quartz_vmr *This = impl_from_IAMCertifiedOutputProtection(iface);
791
792 FIXME("(%p/%p)->(%p, %p, %p) stub\n", iface, This, pRandom, VarLenCertGH, pdwLengthCertGH);
793 return VFW_E_NO_COPP_HW;
794 }
795
796 static HRESULT WINAPI AMCertifiedOutputProtection_SessionSequenceStart(IAMCertifiedOutputProtection *iface,
797 AMCOPPSignature* pSig)
798 {
799 struct quartz_vmr *This = impl_from_IAMCertifiedOutputProtection(iface);
800
801 FIXME("(%p/%p)->(%p) stub\n", iface, This, pSig);
802 return VFW_E_NO_COPP_HW;
803 }
804
805 static HRESULT WINAPI AMCertifiedOutputProtection_ProtectionCommand(IAMCertifiedOutputProtection *iface,
806 const AMCOPPCommand* cmd)
807 {
808 struct quartz_vmr *This = impl_from_IAMCertifiedOutputProtection(iface);
809
810 FIXME("(%p/%p)->(%p) stub\n", iface, This, cmd);
811 return VFW_E_NO_COPP_HW;
812 }
813
814 static HRESULT WINAPI AMCertifiedOutputProtection_ProtectionStatus(IAMCertifiedOutputProtection *iface,
815 const AMCOPPStatusInput* pStatusInput,
816 AMCOPPStatusOutput* pStatusOutput)
817 {
818 struct quartz_vmr *This = impl_from_IAMCertifiedOutputProtection(iface);
819
820 FIXME("(%p/%p)->(%p, %p) stub\n", iface, This, pStatusInput, pStatusOutput);
821 return VFW_E_NO_COPP_HW;
822 }
823
824 static const IAMCertifiedOutputProtectionVtbl IAMCertifiedOutputProtection_Vtbl =
825 {
826 AMCertifiedOutputProtection_QueryInterface,
827 AMCertifiedOutputProtection_AddRef,
828 AMCertifiedOutputProtection_Release,
829 AMCertifiedOutputProtection_KeyExchange,
830 AMCertifiedOutputProtection_SessionSequenceStart,
831 AMCertifiedOutputProtection_ProtectionCommand,
832 AMCertifiedOutputProtection_ProtectionStatus
833 };
834
835 static HRESULT WINAPI AMFilterMiscFlags_QueryInterface(IAMFilterMiscFlags *iface, REFIID riid, void **ppv) {
836 struct quartz_vmr *This = impl_from_IAMFilterMiscFlags(iface);
837 return IUnknown_QueryInterface(This->renderer.filter.outer_unk, riid, ppv);
838 }
839
840 static ULONG WINAPI AMFilterMiscFlags_AddRef(IAMFilterMiscFlags *iface) {
841 struct quartz_vmr *This = impl_from_IAMFilterMiscFlags(iface);
842 return IUnknown_AddRef(This->renderer.filter.outer_unk);
843 }
844
845 static ULONG WINAPI AMFilterMiscFlags_Release(IAMFilterMiscFlags *iface) {
846 struct quartz_vmr *This = impl_from_IAMFilterMiscFlags(iface);
847 return IUnknown_Release(This->renderer.filter.outer_unk);
848 }
849
850 static ULONG WINAPI AMFilterMiscFlags_GetMiscFlags(IAMFilterMiscFlags *iface) {
851 return AM_FILTER_MISC_FLAGS_IS_RENDERER;
852 }
853
854 static const IAMFilterMiscFlagsVtbl IAMFilterMiscFlags_Vtbl = {
855 AMFilterMiscFlags_QueryInterface,
856 AMFilterMiscFlags_AddRef,
857 AMFilterMiscFlags_Release,
858 AMFilterMiscFlags_GetMiscFlags
859 };
860
861 static HRESULT WINAPI VMR7FilterConfig_QueryInterface(IVMRFilterConfig *iface, REFIID riid,
862 void** ppv)
863 {
864 struct quartz_vmr *This = impl_from_IVMRFilterConfig(iface);
865 return IUnknown_QueryInterface(This->renderer.filter.outer_unk, riid, ppv);
866 }
867
868 static ULONG WINAPI VMR7FilterConfig_AddRef(IVMRFilterConfig *iface)
869 {
870 struct quartz_vmr *This = impl_from_IVMRFilterConfig(iface);
871 return IUnknown_AddRef(This->renderer.filter.outer_unk);
872 }
873
874 static ULONG WINAPI VMR7FilterConfig_Release(IVMRFilterConfig *iface)
875 {
876 struct quartz_vmr *This = impl_from_IVMRFilterConfig(iface);
877 return IUnknown_Release(This->renderer.filter.outer_unk);
878 }
879
880 static HRESULT WINAPI VMR7FilterConfig_SetImageCompositor(IVMRFilterConfig *iface,
881 IVMRImageCompositor *compositor)
882 {
883 struct quartz_vmr *This = impl_from_IVMRFilterConfig(iface);
884
885 FIXME("(%p/%p)->(%p) stub\n", iface, This, compositor);
886 return E_NOTIMPL;
887 }
888
889 static HRESULT WINAPI VMR7FilterConfig_SetNumberOfStreams(IVMRFilterConfig *iface, DWORD count)
890 {
891 struct quartz_vmr *filter = impl_from_IVMRFilterConfig(iface);
892
893 FIXME("filter %p, count %lu, stub!\n", filter, count);
894
895 return E_NOTIMPL;
896 }
897
898 static HRESULT WINAPI VMR7FilterConfig_GetNumberOfStreams(IVMRFilterConfig *iface, DWORD *max)
899 {
900 struct quartz_vmr *This = impl_from_IVMRFilterConfig(iface);
901
902 FIXME("(%p/%p)->(%p) stub\n", iface, This, max);
903 return E_NOTIMPL;
904 }
905
906 static HRESULT WINAPI VMR7FilterConfig_SetRenderingPrefs(IVMRFilterConfig *iface, DWORD flags)
907 {
908 struct quartz_vmr *filter = impl_from_IVMRFilterConfig(iface);
909
910 FIXME("filter %p, flags %#lx, stub!\n", filter, flags);
911
912 return E_NOTIMPL;
913 }
914
915 static HRESULT WINAPI VMR7FilterConfig_GetRenderingPrefs(IVMRFilterConfig *iface, DWORD *renderflags)
916 {
917 struct quartz_vmr *This = impl_from_IVMRFilterConfig(iface);
918
919 FIXME("(%p/%p)->(%p) stub\n", iface, This, renderflags);
920 return E_NOTIMPL;
921 }
922
923 static HRESULT WINAPI VMR7FilterConfig_SetRenderingMode(IVMRFilterConfig *iface, DWORD mode)
924 {
925 struct quartz_vmr *filter = impl_from_IVMRFilterConfig(iface);
926
927 TRACE("iface %p, mode %#lx.\n", iface, mode);
928
929 return IVMRFilterConfig9_SetRenderingMode(&filter->IVMRFilterConfig9_iface, mode);
930 }
931
932 static HRESULT WINAPI VMR7FilterConfig_GetRenderingMode(IVMRFilterConfig *iface, DWORD *mode)
933 {
934 struct quartz_vmr *This = impl_from_IVMRFilterConfig(iface);
935
936 TRACE("(%p/%p)->(%p)\n", iface, This, mode);
937 if (!mode) return E_POINTER;
938
939 if (This->mode)
940 *mode = This->mode;
941 else
942 *mode = VMRMode_Windowed;
943
944 return S_OK;
945 }
946
947 static const IVMRFilterConfigVtbl VMR7_FilterConfig_Vtbl =
948 {
949 VMR7FilterConfig_QueryInterface,
950 VMR7FilterConfig_AddRef,
951 VMR7FilterConfig_Release,
952 VMR7FilterConfig_SetImageCompositor,
953 VMR7FilterConfig_SetNumberOfStreams,
954 VMR7FilterConfig_GetNumberOfStreams,
955 VMR7FilterConfig_SetRenderingPrefs,
956 VMR7FilterConfig_GetRenderingPrefs,
957 VMR7FilterConfig_SetRenderingMode,
958 VMR7FilterConfig_GetRenderingMode
959 };
960
961 struct get_available_monitors_args
962 {
963 VMRMONITORINFO *info7;
964 VMR9MonitorInfo *info9;
965 DWORD arraysize;
966 DWORD numdev;
967 };
968
969 static BOOL CALLBACK get_available_monitors_proc(HMONITOR hmon, HDC hdc, LPRECT lprc, LPARAM lparam)
970 {
971 struct get_available_monitors_args *args = (struct get_available_monitors_args *)lparam;
972 MONITORINFOEXW mi;
973
974 if (args->info7 || args->info9)
975 {
976
977 if (!args->arraysize)
978 return FALSE;
979
980 mi.cbSize = sizeof(mi);
981 if (!GetMonitorInfoW(hmon, (MONITORINFO*)&mi))
982 return TRUE;
983
984 /* fill VMRMONITORINFO struct */
985 if (args->info7)
986 {
987 VMRMONITORINFO *info = args->info7++;
988 memset(info, 0, sizeof(*info));
989
990 if (args->numdev > 0)
991 {
992 info->guid.pGUID = &info->guid.GUID;
993 info->guid.GUID.Data4[7] = args->numdev;
994 }
995 else
996 info->guid.pGUID = NULL;
997
998 info->rcMonitor = mi.rcMonitor;
999 info->hMon = hmon;
1000 info->dwFlags = mi.dwFlags;
1001
1002 lstrcpynW(info->szDevice, mi.szDevice, ARRAY_SIZE(info->szDevice));
1003
1004 /* FIXME: how to get these values? */
1005 info->szDescription[0] = 0;
1006 }
1007
1008 /* fill VMR9MonitorInfo struct */
1009 if (args->info9)
1010 {
1011 VMR9MonitorInfo *info = args->info9++;
1012 memset(info, 0, sizeof(*info));
1013
1014 info->uDevID = 0; /* FIXME */
1015 info->rcMonitor = mi.rcMonitor;
1016 info->hMon = hmon;
1017 info->dwFlags = mi.dwFlags;
1018
1019 lstrcpynW(info->szDevice, mi.szDevice, ARRAY_SIZE(info->szDevice));
1020
1021 /* FIXME: how to get these values? */
1022 info->szDescription[0] = 0;
1023 info->dwVendorId = 0;
1024 info->dwDeviceId = 0;
1025 info->dwSubSysId = 0;
1026 info->dwRevision = 0;
1027 }
1028
1029 args->arraysize--;
1030 }
1031
1032 args->numdev++;
1033 return TRUE;
1034 }
1035
1036 static HRESULT WINAPI VMR7MonitorConfig_QueryInterface(IVMRMonitorConfig *iface, REFIID riid,
1037 LPVOID * ppv)
1038 {
1039 struct quartz_vmr *This = impl_from_IVMRMonitorConfig(iface);
1040 return IUnknown_QueryInterface(This->renderer.filter.outer_unk, riid, ppv);
1041 }
1042
1043 static ULONG WINAPI VMR7MonitorConfig_AddRef(IVMRMonitorConfig *iface)
1044 {
1045 struct quartz_vmr *This = impl_from_IVMRMonitorConfig(iface);
1046 return IUnknown_AddRef(This->renderer.filter.outer_unk);
1047 }
1048
1049 static ULONG WINAPI VMR7MonitorConfig_Release(IVMRMonitorConfig *iface)
1050 {
1051 struct quartz_vmr *This = impl_from_IVMRMonitorConfig(iface);
1052 return IUnknown_Release(This->renderer.filter.outer_unk);
1053 }
1054
1055 static HRESULT WINAPI VMR7MonitorConfig_SetMonitor(IVMRMonitorConfig *iface, const VMRGUID *pGUID)
1056 {
1057 struct quartz_vmr *This = impl_from_IVMRMonitorConfig(iface);
1058
1059 FIXME("(%p/%p)->(%p) stub\n", iface, This, pGUID);
1060
1061 if (!pGUID)
1062 return E_POINTER;
1063
1064 return S_OK;
1065 }
1066
1067 static HRESULT WINAPI VMR7MonitorConfig_GetMonitor(IVMRMonitorConfig *iface, VMRGUID *pGUID)
1068 {
1069 struct quartz_vmr *This = impl_from_IVMRMonitorConfig(iface);
1070
1071 FIXME("(%p/%p)->(%p) stub\n", iface, This, pGUID);
1072
1073 if (!pGUID)
1074 return E_POINTER;
1075
1076 pGUID->pGUID = NULL; /* default DirectDraw device */
1077 return S_OK;
1078 }
1079
1080 static HRESULT WINAPI VMR7MonitorConfig_SetDefaultMonitor(IVMRMonitorConfig *iface,
1081 const VMRGUID *pGUID)
1082 {
1083 struct quartz_vmr *This = impl_from_IVMRMonitorConfig(iface);
1084
1085 FIXME("(%p/%p)->(%p) stub\n", iface, This, pGUID);
1086
1087 if (!pGUID)
1088 return E_POINTER;
1089
1090 return S_OK;
1091 }
1092
1093 static HRESULT WINAPI VMR7MonitorConfig_GetDefaultMonitor(IVMRMonitorConfig *iface, VMRGUID *pGUID)
1094 {
1095 struct quartz_vmr *This = impl_from_IVMRMonitorConfig(iface);
1096
1097 FIXME("(%p/%p)->(%p) stub\n", iface, This, pGUID);
1098
1099 if (!pGUID)
1100 return E_POINTER;
1101
1102 pGUID->pGUID = NULL; /* default DirectDraw device */
1103 return S_OK;
1104 }
1105
1106 static HRESULT WINAPI VMR7MonitorConfig_GetAvailableMonitors(IVMRMonitorConfig *iface,
1107 VMRMONITORINFO *info, DWORD arraysize,
1108 DWORD *numdev)
1109 {
1110 struct quartz_vmr *This = impl_from_IVMRMonitorConfig(iface);
1111 struct get_available_monitors_args args;
1112
1113 TRACE("filter %p, info %p, arraysize %lu, numdev %p.\n", This, info, arraysize, numdev);
1114
1115 if (!numdev)
1116 return E_POINTER;
1117
1118 if (info && arraysize == 0)
1119 return E_INVALIDARG;
1120
1121 args.info7 = info;
1122 args.info9 = NULL;
1123 args.arraysize = arraysize;
1124 args.numdev = 0;
1125 EnumDisplayMonitors(NULL, NULL, get_available_monitors_proc, (LPARAM)&args);
1126
1127 *numdev = args.numdev;
1128 return S_OK;
1129 }
1130
1131 static const IVMRMonitorConfigVtbl VMR7_MonitorConfig_Vtbl =
1132 {
1133 VMR7MonitorConfig_QueryInterface,
1134 VMR7MonitorConfig_AddRef,
1135 VMR7MonitorConfig_Release,
1136 VMR7MonitorConfig_SetMonitor,
1137 VMR7MonitorConfig_GetMonitor,
1138 VMR7MonitorConfig_SetDefaultMonitor,
1139 VMR7MonitorConfig_GetDefaultMonitor,
1140 VMR7MonitorConfig_GetAvailableMonitors
1141 };
1142
1143 static HRESULT WINAPI VMR9MonitorConfig_QueryInterface(IVMRMonitorConfig9 *iface, REFIID riid,
1144 LPVOID * ppv)
1145 {
1146 struct quartz_vmr *This = impl_from_IVMRMonitorConfig9(iface);
1147 return IUnknown_QueryInterface(This->renderer.filter.outer_unk, riid, ppv);
1148 }
1149
1150 static ULONG WINAPI VMR9MonitorConfig_AddRef(IVMRMonitorConfig9 *iface)
1151 {
1152 struct quartz_vmr *This = impl_from_IVMRMonitorConfig9(iface);
1153 return IUnknown_AddRef(This->renderer.filter.outer_unk);
1154 }
1155
1156 static ULONG WINAPI VMR9MonitorConfig_Release(IVMRMonitorConfig9 *iface)
1157 {
1158 struct quartz_vmr *This = impl_from_IVMRMonitorConfig9(iface);
1159 return IUnknown_Release(This->renderer.filter.outer_unk);
1160 }
1161
1162 static HRESULT WINAPI VMR9MonitorConfig_SetMonitor(IVMRMonitorConfig9 *iface, UINT uDev)
1163 {
1164 struct quartz_vmr *This = impl_from_IVMRMonitorConfig9(iface);
1165
1166 FIXME("(%p/%p)->(%u) stub\n", iface, This, uDev);
1167
1168 return S_OK;
1169 }
1170
1171 static HRESULT WINAPI VMR9MonitorConfig_GetMonitor(IVMRMonitorConfig9 *iface, UINT *uDev)
1172 {
1173 struct quartz_vmr *This = impl_from_IVMRMonitorConfig9(iface);
1174
1175 FIXME("(%p/%p)->(%p) stub\n", iface, This, uDev);
1176
1177 if (!uDev)
1178 return E_POINTER;
1179
1180 *uDev = 0;
1181 return S_OK;
1182 }
1183
1184 static HRESULT WINAPI VMR9MonitorConfig_SetDefaultMonitor(IVMRMonitorConfig9 *iface, UINT uDev)
1185 {
1186 struct quartz_vmr *This = impl_from_IVMRMonitorConfig9(iface);
1187
1188 FIXME("(%p/%p)->(%u) stub\n", iface, This, uDev);
1189
1190 return S_OK;
1191 }
1192
1193 static HRESULT WINAPI VMR9MonitorConfig_GetDefaultMonitor(IVMRMonitorConfig9 *iface, UINT *uDev)
1194 {
1195 struct quartz_vmr *This = impl_from_IVMRMonitorConfig9(iface);
1196
1197 FIXME("(%p/%p)->(%p) stub\n", iface, This, uDev);
1198
1199 if (!uDev)
1200 return E_POINTER;
1201
1202 *uDev = 0;
1203 return S_OK;
1204 }
1205
1206 static HRESULT WINAPI VMR9MonitorConfig_GetAvailableMonitors(IVMRMonitorConfig9 *iface,
1207 VMR9MonitorInfo *info, DWORD arraysize,
1208 DWORD *numdev)
1209 {
1210 struct quartz_vmr *This = impl_from_IVMRMonitorConfig9(iface);
1211 struct get_available_monitors_args args;
1212
1213 TRACE("filter %p, info %p, arraysize %lu, numdev %p.\n", This, info, arraysize, numdev);
1214
1215 if (!numdev)
1216 return E_POINTER;
1217
1218 if (info && arraysize == 0)
1219 return E_INVALIDARG;
1220
1221 args.info7 = NULL;
1222 args.info9 = info;
1223 args.arraysize = arraysize;
1224 args.numdev = 0;
1225 EnumDisplayMonitors(NULL, NULL, get_available_monitors_proc, (LPARAM)&args);
1226
1227 *numdev = args.numdev;
1228 return S_OK;
1229 }
1230
1231 static const IVMRMonitorConfig9Vtbl VMR9_MonitorConfig_Vtbl =
1232 {
1233 VMR9MonitorConfig_QueryInterface,
1234 VMR9MonitorConfig_AddRef,
1235 VMR9MonitorConfig_Release,
1236 VMR9MonitorConfig_SetMonitor,
1237 VMR9MonitorConfig_GetMonitor,
1238 VMR9MonitorConfig_SetDefaultMonitor,
1239 VMR9MonitorConfig_GetDefaultMonitor,
1240 VMR9MonitorConfig_GetAvailableMonitors
1241 };
1242
1243 static HRESULT WINAPI VMR9FilterConfig_QueryInterface(IVMRFilterConfig9 *iface, REFIID riid, LPVOID * ppv)
1244 {
1245 struct quartz_vmr *This = impl_from_IVMRFilterConfig9(iface);
1246 return IUnknown_QueryInterface(This->renderer.filter.outer_unk, riid, ppv);
1247 }
1248
1249 static ULONG WINAPI VMR9FilterConfig_AddRef(IVMRFilterConfig9 *iface)
1250 {
1251 struct quartz_vmr *This = impl_from_IVMRFilterConfig9(iface);
1252 return IUnknown_AddRef(This->renderer.filter.outer_unk);
1253 }
1254
1255 static ULONG WINAPI VMR9FilterConfig_Release(IVMRFilterConfig9 *iface)
1256 {
1257 struct quartz_vmr *This = impl_from_IVMRFilterConfig9(iface);
1258 return IUnknown_Release(This->renderer.filter.outer_unk);
1259 }
1260
1261 static HRESULT WINAPI VMR9FilterConfig_SetImageCompositor(IVMRFilterConfig9 *iface, IVMRImageCompositor9 *compositor)
1262 {
1263 struct quartz_vmr *This = impl_from_IVMRFilterConfig9(iface);
1264
1265 FIXME("(%p/%p)->(%p) stub\n", iface, This, compositor);
1266 return E_NOTIMPL;
1267 }
1268
1269 static HRESULT WINAPI VMR9FilterConfig_SetNumberOfStreams(IVMRFilterConfig9 *iface, DWORD count)
1270 {
1271 struct quartz_vmr *filter = impl_from_IVMRFilterConfig9(iface);
1272
1273 FIXME("iface %p, count %lu, stub!\n", iface, count);
1274
1275 if (!count)
1276 {
1277 WARN("Application requested zero streams; returning E_INVALIDARG.\n");
1278 return E_INVALIDARG;
1279 }
1280
1281 EnterCriticalSection(&filter->renderer.filter.filter_cs);
1282
1283 if (filter->stream_count)
1284 {
1285 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
1286 WARN("Stream count is already set; returning VFW_E_WRONG_STATE.\n");
1287 return VFW_E_WRONG_STATE;
1288 }
1289
1290 filter->stream_count = count;
1291
1292 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
1293 return S_OK;
1294 }
1295
1296 static HRESULT WINAPI VMR9FilterConfig_GetNumberOfStreams(IVMRFilterConfig9 *iface, DWORD *count)
1297 {
1298 struct quartz_vmr *filter = impl_from_IVMRFilterConfig9(iface);
1299
1300 TRACE("filter %p, count %p.\n", filter, count);
1301
1302 EnterCriticalSection(&filter->renderer.filter.filter_cs);
1303
1304 if (!filter->stream_count)
1305 {
1306 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
1307 return VFW_E_VMR_NOT_IN_MIXER_MODE;
1308 }
1309
1310 *count = filter->stream_count;
1311
1312 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
1313 return S_OK;
1314 }
1315
1316 static HRESULT WINAPI VMR9FilterConfig_SetRenderingPrefs(IVMRFilterConfig9 *iface, DWORD flags)
1317 {
1318 struct quartz_vmr *filter = impl_from_IVMRFilterConfig9(iface);
1319
1320 TRACE("filter %p, flags %#lx.\n", filter, flags);
1321
1322 return E_NOTIMPL;
1323 }
1324
1325 static HRESULT WINAPI VMR9FilterConfig_GetRenderingPrefs(IVMRFilterConfig9 *iface, DWORD *renderflags)
1326 {
1327 struct quartz_vmr *This = impl_from_IVMRFilterConfig9(iface);
1328
1329 FIXME("(%p/%p)->(%p) stub\n", iface, This, renderflags);
1330 return E_NOTIMPL;
1331 }
1332
1333 static HRESULT WINAPI VMR9FilterConfig_SetRenderingMode(IVMRFilterConfig9 *iface, DWORD mode)
1334 {
1335 HRESULT hr = S_OK;
1336 struct quartz_vmr *This = impl_from_IVMRFilterConfig9(iface);
1337
1338 TRACE("filter %p, mode %lu.\n", This, mode);
1339
1340 EnterCriticalSection(&This->renderer.filter.filter_cs);
1341 if (This->mode)
1342 {
1343 LeaveCriticalSection(&This->renderer.filter.filter_cs);
1344 return VFW_E_WRONG_STATE;
1345 }
1346
1347 if (This->allocator)
1348 IVMRSurfaceAllocator9_Release(This->allocator);
1349 if (This->presenter)
1350 IVMRImagePresenter9_Release(This->presenter);
1351
1352 This->allocator = NULL;
1353 This->presenter = NULL;
1354
1355 switch (mode)
1356 {
1357 case VMR9Mode_Windowed:
1358 case VMR9Mode_Windowless:
1359 This->cookie = ~0;
1360
1361 if (FAILED(hr = VMR9DefaultAllocatorPresenterImpl_create(This, (void **)&This->presenter)))
1362 {
1363 ERR("Failed to create default presenter, hr %#lx.\n", hr);
1364 break;
1365 }
1366
1367 if (FAILED(hr = IVMRImagePresenter9_QueryInterface(This->presenter,
1368 &IID_IVMRSurfaceAllocator9, (void **)&This->allocator)))
1369 {
1370 ERR("Failed to query for IVMRSurfaceAllocator9, hr %#lx.\n", hr);
1371 IVMRImagePresenter9_Release(This->presenter);
1372 This->allocator = NULL;
1373 This->presenter = NULL;
1374 break;
1375 }
1376
1377 hr = IVMRSurfaceAllocator9_AdviseNotify(This->allocator, &This->IVMRSurfaceAllocatorNotify9_iface);
1378 break;
1379 case VMR9Mode_Renderless:
1380 break;
1381 default:
1382 LeaveCriticalSection(&This->renderer.filter.filter_cs);
1383 return E_INVALIDARG;
1384 }
1385
1386 if (mode != VMR9Mode_Windowed)
1387 video_window_cleanup(&This->window);
1388
1389 This->mode = mode;
1390 LeaveCriticalSection(&This->renderer.filter.filter_cs);
1391 return hr;
1392 }
1393
1394 static HRESULT WINAPI VMR9FilterConfig_GetRenderingMode(IVMRFilterConfig9 *iface, DWORD *mode)
1395 {
1396 struct quartz_vmr *This = impl_from_IVMRFilterConfig9(iface);
1397
1398 TRACE("(%p/%p)->(%p)\n", iface, This, mode);
1399 if (!mode)
1400 return E_POINTER;
1401
1402 if (This->mode)
1403 *mode = This->mode;
1404 else
1405 *mode = VMR9Mode_Windowed;
1406
1407 return S_OK;
1408 }
1409
1410 static const IVMRFilterConfig9Vtbl VMR9_FilterConfig_Vtbl =
1411 {
1412 VMR9FilterConfig_QueryInterface,
1413 VMR9FilterConfig_AddRef,
1414 VMR9FilterConfig_Release,
1415 VMR9FilterConfig_SetImageCompositor,
1416 VMR9FilterConfig_SetNumberOfStreams,
1417 VMR9FilterConfig_GetNumberOfStreams,
1418 VMR9FilterConfig_SetRenderingPrefs,
1419 VMR9FilterConfig_GetRenderingPrefs,
1420 VMR9FilterConfig_SetRenderingMode,
1421 VMR9FilterConfig_GetRenderingMode
1422 };
1423
1424 static HRESULT WINAPI VMR7WindowlessControl_QueryInterface(IVMRWindowlessControl *iface, REFIID riid,
1425 LPVOID * ppv)
1426 {
1427 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1428 return IUnknown_QueryInterface(This->renderer.filter.outer_unk, riid, ppv);
1429 }
1430
1431 static ULONG WINAPI VMR7WindowlessControl_AddRef(IVMRWindowlessControl *iface)
1432 {
1433 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1434 return IUnknown_AddRef(This->renderer.filter.outer_unk);
1435 }
1436
1437 static ULONG WINAPI VMR7WindowlessControl_Release(IVMRWindowlessControl *iface)
1438 {
1439 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1440 return IUnknown_Release(This->renderer.filter.outer_unk);
1441 }
1442
1443 static HRESULT WINAPI VMR7WindowlessControl_GetNativeVideoSize(IVMRWindowlessControl *iface,
1444 LONG *width, LONG *height, LONG *aspect_width, LONG *aspect_height)
1445 {
1446 struct quartz_vmr *filter = impl_from_IVMRWindowlessControl(iface);
1447
1448 TRACE("filter %p, width %p, height %p, aspect_width %p, aspect_height %p.\n",
1449 filter, width, height, aspect_width, aspect_height);
1450
1451 if (!width || !height)
1452 return E_POINTER;
1453
1454 *width = filter->bmiheader.biWidth;
1455 *height = filter->bmiheader.biHeight;
1456 if (aspect_width)
1457 *aspect_width = filter->bmiheader.biWidth;
1458 if (aspect_height)
1459 *aspect_height = filter->bmiheader.biHeight;
1460
1461 return S_OK;
1462 }
1463
1464 static HRESULT WINAPI VMR7WindowlessControl_GetMinIdealVideoSize(IVMRWindowlessControl *iface,
1465 LONG *width, LONG *height)
1466 {
1467 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1468
1469 FIXME("(%p/%p)->(...) stub\n", iface, This);
1470 return E_NOTIMPL;
1471 }
1472
1473 static HRESULT WINAPI VMR7WindowlessControl_GetMaxIdealVideoSize(IVMRWindowlessControl *iface,
1474 LONG *width, LONG *height)
1475 {
1476 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1477
1478 FIXME("(%p/%p)->(...) stub\n", iface, This);
1479 return E_NOTIMPL;
1480 }
1481
1482 static HRESULT WINAPI VMR7WindowlessControl_SetVideoPosition(IVMRWindowlessControl *iface,
1483 const RECT *source, const RECT *dest)
1484 {
1485 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1486
1487 TRACE("(%p/%p)->(%p, %p)\n", iface, This, source, dest);
1488
1489 EnterCriticalSection(&This->renderer.filter.filter_cs);
1490
1491 if (source)
1492 This->window.src = *source;
1493 if (dest)
1494 This->window.dst = *dest;
1495
1496 LeaveCriticalSection(&This->renderer.filter.filter_cs);
1497
1498 return S_OK;
1499 }
1500
1501 static HRESULT WINAPI VMR7WindowlessControl_GetVideoPosition(IVMRWindowlessControl *iface,
1502 RECT *source, RECT *dest)
1503 {
1504 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1505
1506 if (source)
1507 *source = This->window.src;
1508
1509 if (dest)
1510 *dest = This->window.dst;
1511
1512 FIXME("(%p/%p)->(%p/%p) stub\n", iface, This, source, dest);
1513 return S_OK;
1514 }
1515
1516 static HRESULT WINAPI VMR7WindowlessControl_GetAspectRatioMode(IVMRWindowlessControl *iface,
1517 DWORD *mode)
1518 {
1519 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1520
1521 FIXME("(%p/%p)->(...) stub\n", iface, This);
1522 return E_NOTIMPL;
1523 }
1524
1525 static HRESULT WINAPI VMR7WindowlessControl_SetAspectRatioMode(IVMRWindowlessControl *iface,
1526 DWORD mode)
1527 {
1528 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1529
1530 FIXME("(%p/%p)->(...) stub\n", iface, This);
1531 return E_NOTIMPL;
1532 }
1533
1534 static HRESULT WINAPI VMR7WindowlessControl_SetVideoClippingWindow(IVMRWindowlessControl *iface, HWND window)
1535 {
1536 struct quartz_vmr *filter = impl_from_IVMRWindowlessControl(iface);
1537
1538 TRACE("iface %p, window %p.\n", iface, window);
1539
1540 return IVMRWindowlessControl9_SetVideoClippingWindow(&filter->IVMRWindowlessControl9_iface, window);
1541 }
1542
1543 static HRESULT WINAPI VMR7WindowlessControl_RepaintVideo(IVMRWindowlessControl *iface,
1544 HWND hwnd, HDC hdc)
1545 {
1546 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1547
1548 FIXME("(%p/%p)->(...) stub\n", iface, This);
1549 return E_NOTIMPL;
1550 }
1551
1552 static HRESULT WINAPI VMR7WindowlessControl_DisplayModeChanged(IVMRWindowlessControl *iface)
1553 {
1554 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1555
1556 FIXME("(%p/%p)->(...) stub\n", iface, This);
1557 return E_NOTIMPL;
1558 }
1559
1560 static HRESULT WINAPI VMR7WindowlessControl_GetCurrentImage(IVMRWindowlessControl *iface,
1561 BYTE **dib)
1562 {
1563 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1564
1565 FIXME("(%p/%p)->(...) stub\n", iface, This);
1566 return E_NOTIMPL;
1567 }
1568
1569 static HRESULT WINAPI VMR7WindowlessControl_SetBorderColor(IVMRWindowlessControl *iface,
1570 COLORREF color)
1571 {
1572 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1573
1574 FIXME("(%p/%p)->(...) stub\n", iface, This);
1575 return E_NOTIMPL;
1576 }
1577
1578 static HRESULT WINAPI VMR7WindowlessControl_GetBorderColor(IVMRWindowlessControl *iface,
1579 COLORREF *color)
1580 {
1581 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1582
1583 FIXME("(%p/%p)->(...) stub\n", iface, This);
1584 return E_NOTIMPL;
1585 }
1586
1587 static HRESULT WINAPI VMR7WindowlessControl_SetColorKey(IVMRWindowlessControl *iface, COLORREF color)
1588 {
1589 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1590
1591 FIXME("(%p/%p)->(...) stub\n", iface, This);
1592 return E_NOTIMPL;
1593 }
1594
1595 static HRESULT WINAPI VMR7WindowlessControl_GetColorKey(IVMRWindowlessControl *iface, COLORREF *color)
1596 {
1597 struct quartz_vmr *This = impl_from_IVMRWindowlessControl(iface);
1598
1599 FIXME("(%p/%p)->(...) stub\n", iface, This);
1600 return E_NOTIMPL;
1601 }
1602
1603 static const IVMRWindowlessControlVtbl VMR7_WindowlessControl_Vtbl =
1604 {
1605 VMR7WindowlessControl_QueryInterface,
1606 VMR7WindowlessControl_AddRef,
1607 VMR7WindowlessControl_Release,
1608 VMR7WindowlessControl_GetNativeVideoSize,
1609 VMR7WindowlessControl_GetMinIdealVideoSize,
1610 VMR7WindowlessControl_GetMaxIdealVideoSize,
1611 VMR7WindowlessControl_SetVideoPosition,
1612 VMR7WindowlessControl_GetVideoPosition,
1613 VMR7WindowlessControl_GetAspectRatioMode,
1614 VMR7WindowlessControl_SetAspectRatioMode,
1615 VMR7WindowlessControl_SetVideoClippingWindow,
1616 VMR7WindowlessControl_RepaintVideo,
1617 VMR7WindowlessControl_DisplayModeChanged,
1618 VMR7WindowlessControl_GetCurrentImage,
1619 VMR7WindowlessControl_SetBorderColor,
1620 VMR7WindowlessControl_GetBorderColor,
1621 VMR7WindowlessControl_SetColorKey,
1622 VMR7WindowlessControl_GetColorKey
1623 };
1624
1625 static HRESULT WINAPI VMR9WindowlessControl_QueryInterface(IVMRWindowlessControl9 *iface, REFIID riid, LPVOID * ppv)
1626 {
1627 struct quartz_vmr *This = impl_from_IVMRWindowlessControl9(iface);
1628 return IUnknown_QueryInterface(This->renderer.filter.outer_unk, riid, ppv);
1629 }
1630
1631 static ULONG WINAPI VMR9WindowlessControl_AddRef(IVMRWindowlessControl9 *iface)
1632 {
1633 struct quartz_vmr *This = impl_from_IVMRWindowlessControl9(iface);
1634 return IUnknown_AddRef(This->renderer.filter.outer_unk);
1635 }
1636
1637 static ULONG WINAPI VMR9WindowlessControl_Release(IVMRWindowlessControl9 *iface)
1638 {
1639 struct quartz_vmr *This = impl_from_IVMRWindowlessControl9(iface);
1640 return IUnknown_Release(This->renderer.filter.outer_unk);
1641 }
1642
1643 static HRESULT WINAPI VMR9WindowlessControl_GetNativeVideoSize(IVMRWindowlessControl9 *iface,
1644 LONG *width, LONG *height, LONG *aspect_width, LONG *aspect_height)
1645 {
1646 struct quartz_vmr *filter = impl_from_IVMRWindowlessControl9(iface);
1647
1648 TRACE("filter %p, width %p, height %p, aspect_width %p, aspect_height %p.\n",
1649 filter, width, height, aspect_width, aspect_height);
1650
1651 if (!width || !height)
1652 return E_POINTER;
1653
1654 *width = filter->bmiheader.biWidth;
1655 *height = filter->bmiheader.biHeight;
1656 if (aspect_width)
1657 *aspect_width = filter->bmiheader.biWidth;
1658 if (aspect_height)
1659 *aspect_height = filter->bmiheader.biHeight;
1660
1661 return S_OK;
1662 }
1663
1664 static HRESULT WINAPI VMR9WindowlessControl_GetMinIdealVideoSize(IVMRWindowlessControl9 *iface, LONG *width, LONG *height)
1665 {
1666 struct quartz_vmr *This = impl_from_IVMRWindowlessControl9(iface);
1667
1668 FIXME("(%p/%p)->(...) stub\n", iface, This);
1669 return E_NOTIMPL;
1670 }
1671
1672 static HRESULT WINAPI VMR9WindowlessControl_GetMaxIdealVideoSize(IVMRWindowlessControl9 *iface, LONG *width, LONG *height)
1673 {
1674 struct quartz_vmr *This = impl_from_IVMRWindowlessControl9(iface);
1675
1676 FIXME("(%p/%p)->(...) stub\n", iface, This);
1677 return E_NOTIMPL;
1678 }
1679
1680 static HRESULT WINAPI VMR9WindowlessControl_SetVideoPosition(IVMRWindowlessControl9 *iface,
1681 const RECT *src, const RECT *dst)
1682 {
1683 struct quartz_vmr *filter = impl_from_IVMRWindowlessControl9(iface);
1684
1685 TRACE("filter %p, src %s, dst %s.\n", filter, wine_dbgstr_rect(src), wine_dbgstr_rect(dst));
1686
1687 EnterCriticalSection(&filter->renderer.filter.filter_cs);
1688
1689 if (src)
1690 filter->window.src = *src;
1691 if (dst)
1692 filter->window.dst = *dst;
1693
1694 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
1695
1696 return S_OK;
1697 }
1698
1699 static HRESULT WINAPI VMR9WindowlessControl_GetVideoPosition(IVMRWindowlessControl9 *iface, RECT *src, RECT *dst)
1700 {
1701 struct quartz_vmr *filter = impl_from_IVMRWindowlessControl9(iface);
1702
1703 TRACE("filter %p, src %p, dst %p.\n", filter, src, dst);
1704
1705 if (src)
1706 *src = filter->window.src;
1707
1708 if (dst)
1709 *dst = filter->window.dst;
1710
1711 return S_OK;
1712 }
1713
1714 static HRESULT WINAPI VMR9WindowlessControl_GetAspectRatioMode(IVMRWindowlessControl9 *iface, DWORD *mode)
1715 {
1716 struct quartz_vmr *filter = impl_from_IVMRWindowlessControl9(iface);
1717
1718 TRACE("filter %p, mode %p.\n", filter, mode);
1719
1720 EnterCriticalSection(&filter->renderer.filter.filter_cs);
1721 *mode = filter->aspect_mode;
1722 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
1723 return S_OK;
1724 }
1725
1726 static HRESULT WINAPI VMR9WindowlessControl_SetAspectRatioMode(IVMRWindowlessControl9 *iface, DWORD mode)
1727 {
1728 struct quartz_vmr *filter = impl_from_IVMRWindowlessControl9(iface);
1729
1730 TRACE("filter %p, mode %lu.\n", filter, mode);
1731
1732 EnterCriticalSection(&filter->renderer.filter.filter_cs);
1733 filter->aspect_mode = mode;
1734 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
1735 return S_OK;
1736 }
1737
1738 static HRESULT WINAPI VMR9WindowlessControl_SetVideoClippingWindow(IVMRWindowlessControl9 *iface, HWND window)
1739 {
1740 struct quartz_vmr *filter = impl_from_IVMRWindowlessControl9(iface);
1741 HRESULT hr;
1742
1743 TRACE("filter %p, window %p.\n", filter, window);
1744
1745 if (!IsWindow(window))
1746 {
1747 WARN("Invalid window %p, returning E_INVALIDARG.\n", window);
1748 return E_INVALIDARG;
1749 }
1750
1751 EnterCriticalSection(&filter->renderer.filter.filter_cs);
1752
1753 if (filter->renderer.sink.pin.peer)
1754 {
1755 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
1756 WARN("Attempt to set the clipping window while connected; returning VFW_E_WRONG_STATE.\n");
1757 return VFW_E_WRONG_STATE;
1758 }
1759
1760 filter->clipping_window = window;
1761
1762 hr = IVMRFilterConfig9_SetNumberOfStreams(&filter->IVMRFilterConfig9_iface, 4);
1763
1764 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
1765 return hr;
1766 }
1767
1768 static HRESULT WINAPI VMR9WindowlessControl_RepaintVideo(IVMRWindowlessControl9 *iface, HWND hwnd, HDC hdc)
1769 {
1770 struct quartz_vmr *This = impl_from_IVMRWindowlessControl9(iface);
1771 HRESULT hr;
1772
1773 FIXME("(%p/%p)->(...) semi-stub\n", iface, This);
1774
1775 EnterCriticalSection(&This->renderer.filter.filter_cs);
1776 if (hwnd != This->clipping_window)
1777 {
1778 ERR("Not handling changing windows yet!!!\n");
1779 LeaveCriticalSection(&This->renderer.filter.filter_cs);
1780 return S_OK;
1781 }
1782
1783 if (!This->allocator_d3d9_dev)
1784 {
1785 ERR("No d3d9 device!\n");
1786 LeaveCriticalSection(&This->renderer.filter.filter_cs);
1787 return VFW_E_WRONG_STATE;
1788 }
1789
1790 /* Windowless extension */
1791 hr = IDirect3DDevice9_Present(This->allocator_d3d9_dev, NULL, NULL, NULL, NULL);
1792 LeaveCriticalSection(&This->renderer.filter.filter_cs);
1793
1794 return hr;
1795 }
1796
1797 static HRESULT WINAPI VMR9WindowlessControl_DisplayModeChanged(IVMRWindowlessControl9 *iface)
1798 {
1799 struct quartz_vmr *This = impl_from_IVMRWindowlessControl9(iface);
1800
1801 FIXME("(%p/%p)->(...) stub\n", iface, This);
1802 return E_NOTIMPL;
1803 }
1804
1805 static HRESULT WINAPI VMR9WindowlessControl_GetCurrentImage(IVMRWindowlessControl9 *iface, BYTE **dib)
1806 {
1807 struct quartz_vmr *This = impl_from_IVMRWindowlessControl9(iface);
1808
1809 FIXME("(%p/%p)->(...) stub\n", iface, This);
1810 return E_NOTIMPL;
1811 }
1812
1813 static HRESULT WINAPI VMR9WindowlessControl_SetBorderColor(IVMRWindowlessControl9 *iface, COLORREF color)
1814 {
1815 struct quartz_vmr *This = impl_from_IVMRWindowlessControl9(iface);
1816
1817 FIXME("(%p/%p)->(...) stub\n", iface, This);
1818 return E_NOTIMPL;
1819 }
1820
1821 static HRESULT WINAPI VMR9WindowlessControl_GetBorderColor(IVMRWindowlessControl9 *iface, COLORREF *color)
1822 {
1823 struct quartz_vmr *This = impl_from_IVMRWindowlessControl9(iface);
1824
1825 FIXME("(%p/%p)->(...) stub\n", iface, This);
1826 return E_NOTIMPL;
1827 }
1828
1829 static const IVMRWindowlessControl9Vtbl VMR9_WindowlessControl_Vtbl =
1830 {
1831 VMR9WindowlessControl_QueryInterface,
1832 VMR9WindowlessControl_AddRef,
1833 VMR9WindowlessControl_Release,
1834 VMR9WindowlessControl_GetNativeVideoSize,
1835 VMR9WindowlessControl_GetMinIdealVideoSize,
1836 VMR9WindowlessControl_GetMaxIdealVideoSize,
1837 VMR9WindowlessControl_SetVideoPosition,
1838 VMR9WindowlessControl_GetVideoPosition,
1839 VMR9WindowlessControl_GetAspectRatioMode,
1840 VMR9WindowlessControl_SetAspectRatioMode,
1841 VMR9WindowlessControl_SetVideoClippingWindow,
1842 VMR9WindowlessControl_RepaintVideo,
1843 VMR9WindowlessControl_DisplayModeChanged,
1844 VMR9WindowlessControl_GetCurrentImage,
1845 VMR9WindowlessControl_SetBorderColor,
1846 VMR9WindowlessControl_GetBorderColor
1847 };
1848
1849 static HRESULT WINAPI VMR7SurfaceAllocatorNotify_QueryInterface(IVMRSurfaceAllocatorNotify *iface,
1850 REFIID riid, LPVOID * ppv)
1851 {
1852 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify(iface);
1853 return IUnknown_QueryInterface(This->renderer.filter.outer_unk, riid, ppv);
1854 }
1855
1856 static ULONG WINAPI VMR7SurfaceAllocatorNotify_AddRef(IVMRSurfaceAllocatorNotify *iface)
1857 {
1858 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify(iface);
1859 return IUnknown_AddRef(This->renderer.filter.outer_unk);
1860 }
1861
1862 static ULONG WINAPI VMR7SurfaceAllocatorNotify_Release(IVMRSurfaceAllocatorNotify *iface)
1863 {
1864 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify(iface);
1865 return IUnknown_Release(This->renderer.filter.outer_unk);
1866 }
1867
1868 static HRESULT WINAPI VMR7SurfaceAllocatorNotify_AdviseSurfaceAllocator(IVMRSurfaceAllocatorNotify *iface,
1869 DWORD_PTR id,
1870 IVMRSurfaceAllocator *alloc)
1871 {
1872 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify(iface);
1873
1874 FIXME("(%p/%p)->(...) stub\n", iface, This);
1875 return E_NOTIMPL;
1876 }
1877
1878 static HRESULT WINAPI VMR7SurfaceAllocatorNotify_SetDDrawDevice(IVMRSurfaceAllocatorNotify *iface,
1879 IDirectDraw7 *device, HMONITOR monitor)
1880 {
1881 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify(iface);
1882
1883 FIXME("(%p/%p)->(...) stub\n", iface, This);
1884 return E_NOTIMPL;
1885 }
1886
1887 static HRESULT WINAPI VMR7SurfaceAllocatorNotify_ChangeDDrawDevice(IVMRSurfaceAllocatorNotify *iface,
1888 IDirectDraw7 *device, HMONITOR monitor)
1889 {
1890 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify(iface);
1891
1892 FIXME("(%p/%p)->(...) stub\n", iface, This);
1893 return E_NOTIMPL;
1894 }
1895
1896 static HRESULT WINAPI VMR7SurfaceAllocatorNotify_RestoreDDrawSurfaces(IVMRSurfaceAllocatorNotify *iface)
1897 {
1898 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify(iface);
1899
1900 FIXME("(%p/%p)->(...) stub\n", iface, This);
1901 return E_NOTIMPL;
1902 }
1903
1904 static HRESULT WINAPI VMR7SurfaceAllocatorNotify_NotifyEvent(IVMRSurfaceAllocatorNotify *iface, LONG code,
1905 LONG_PTR param1, LONG_PTR param2)
1906 {
1907 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify(iface);
1908
1909 FIXME("(%p/%p)->(...) stub\n", iface, This);
1910 return E_NOTIMPL;
1911 }
1912
1913 static HRESULT WINAPI VMR7SurfaceAllocatorNotify_SetBorderColor(IVMRSurfaceAllocatorNotify *iface,
1914 COLORREF clrBorder)
1915 {
1916 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify(iface);
1917
1918 FIXME("(%p/%p)->(...) stub\n", iface, This);
1919 return E_NOTIMPL;
1920 }
1921
1922 static const IVMRSurfaceAllocatorNotifyVtbl VMR7_SurfaceAllocatorNotify_Vtbl =
1923 {
1924 VMR7SurfaceAllocatorNotify_QueryInterface,
1925 VMR7SurfaceAllocatorNotify_AddRef,
1926 VMR7SurfaceAllocatorNotify_Release,
1927 VMR7SurfaceAllocatorNotify_AdviseSurfaceAllocator,
1928 VMR7SurfaceAllocatorNotify_SetDDrawDevice,
1929 VMR7SurfaceAllocatorNotify_ChangeDDrawDevice,
1930 VMR7SurfaceAllocatorNotify_RestoreDDrawSurfaces,
1931 VMR7SurfaceAllocatorNotify_NotifyEvent,
1932 VMR7SurfaceAllocatorNotify_SetBorderColor
1933 };
1934
1935 static HRESULT WINAPI VMR9SurfaceAllocatorNotify_QueryInterface(IVMRSurfaceAllocatorNotify9 *iface, REFIID riid, LPVOID * ppv)
1936 {
1937 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify9(iface);
1938 return IUnknown_QueryInterface(This->renderer.filter.outer_unk, riid, ppv);
1939 }
1940
1941 static ULONG WINAPI VMR9SurfaceAllocatorNotify_AddRef(IVMRSurfaceAllocatorNotify9 *iface)
1942 {
1943 struct quartz_vmr *filter = impl_from_IVMRSurfaceAllocatorNotify9(iface);
1944 ULONG refcount = InterlockedIncrement(&filter->IVMRSurfaceAllocatorNotify9_refcount);
1945
1946 TRACE("%p increasing refcount to %lu.\n", iface, refcount);
1947
1948 return refcount;
1949 }
1950
1951 static ULONG WINAPI VMR9SurfaceAllocatorNotify_Release(IVMRSurfaceAllocatorNotify9 *iface)
1952 {
1953 struct quartz_vmr *filter = impl_from_IVMRSurfaceAllocatorNotify9(iface);
1954 ULONG refcount = InterlockedDecrement(&filter->IVMRSurfaceAllocatorNotify9_refcount);
1955
1956 TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
1957
1958 if (!refcount && !filter->renderer.filter.refcount)
1959 free(filter);
1960
1961 return refcount;
1962 }
1963
1964 static HRESULT WINAPI VMR9SurfaceAllocatorNotify_AdviseSurfaceAllocator(
1965 IVMRSurfaceAllocatorNotify9 *iface, DWORD_PTR cookie, IVMRSurfaceAllocator9 *allocator)
1966 {
1967 struct quartz_vmr *filter = impl_from_IVMRSurfaceAllocatorNotify9(iface);
1968 IVMRImagePresenter9 *presenter;
1969
1970 TRACE("filter %p, cookie %#Ix, allocator %p.\n", filter, cookie, allocator);
1971
1972 EnterCriticalSection(&filter->renderer.filter.filter_cs);
1973
1974 filter->cookie = cookie;
1975
1976 if (filter->renderer.sink.pin.peer)
1977 {
1978 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
1979 WARN("Attempt to set allocator while connected; returning VFW_E_WRONG_STATE.\n");
1980 return VFW_E_WRONG_STATE;
1981 }
1982
1983 if (FAILED(IVMRSurfaceAllocator9_QueryInterface(allocator, &IID_IVMRImagePresenter9, (void **)&presenter)))
1984 {
1985 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
1986 return E_NOINTERFACE;
1987 }
1988
1989 if (filter->allocator)
1990 {
1991 IVMRImagePresenter9_Release(filter->presenter);
1992 IVMRSurfaceAllocator9_Release(filter->allocator);
1993 }
1994 filter->allocator = allocator;
1995 filter->presenter = presenter;
1996 IVMRSurfaceAllocator9_AddRef(allocator);
1997
1998 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
1999 return S_OK;
2000 }
2001
2002 static HRESULT WINAPI VMR9SurfaceAllocatorNotify_SetD3DDevice(IVMRSurfaceAllocatorNotify9 *iface,
2003 IDirect3DDevice9 *device, HMONITOR monitor)
2004 {
2005 struct quartz_vmr *filter = impl_from_IVMRSurfaceAllocatorNotify9(iface);
2006
2007 TRACE("filter %p, device %p, monitor %p.\n", filter, device, monitor);
2008
2009 if (filter->allocator_d3d9_dev)
2010 IDirect3DDevice9_Release(filter->allocator_d3d9_dev);
2011 filter->allocator_d3d9_dev = device;
2012 IDirect3DDevice9_AddRef(device);
2013
2014 return S_OK;
2015 }
2016
2017 static HRESULT WINAPI VMR9SurfaceAllocatorNotify_ChangeD3DDevice(IVMRSurfaceAllocatorNotify9 *iface, IDirect3DDevice9 *device, HMONITOR monitor)
2018 {
2019 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify9(iface);
2020
2021 FIXME("(%p/%p)->(...) semi-stub\n", iface, This);
2022 if (This->allocator_d3d9_dev)
2023 IDirect3DDevice9_Release(This->allocator_d3d9_dev);
2024 This->allocator_d3d9_dev = device;
2025 IDirect3DDevice9_AddRef(This->allocator_d3d9_dev);
2026
2027 return S_OK;
2028 }
2029
2030 static HRESULT WINAPI VMR9SurfaceAllocatorNotify_AllocateSurfaceHelper(IVMRSurfaceAllocatorNotify9 *iface, VMR9AllocationInfo *allocinfo, DWORD *numbuffers, IDirect3DSurface9 **surface)
2031 {
2032 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify9(iface);
2033 DWORD i;
2034 HRESULT hr = S_OK;
2035
2036 TRACE("filter %p, allocinfo %p, numbuffers %p, surface %p.\n", This, numbuffers, allocinfo, surface);
2037
2038 if (!allocinfo || !numbuffers || !surface)
2039 return E_POINTER;
2040
2041 TRACE("Flags %#lx, size %lux%lu, format %u (%#x), pool %u, minimum buffers %lu.\n",
2042 allocinfo->dwFlags, allocinfo->dwWidth, allocinfo->dwHeight,
2043 allocinfo->Format, allocinfo->Format, allocinfo->Pool, allocinfo->MinBuffers);
2044
2045 if ((allocinfo->dwFlags & VMR9AllocFlag_TextureSurface)
2046 && (allocinfo->dwFlags & VMR9AllocFlag_OffscreenSurface))
2047 {
2048 WARN("Invalid flags specified; returning E_INVALIDARG.\n");
2049 return E_INVALIDARG;
2050 }
2051
2052 if (!allocinfo->Format)
2053 {
2054 IDirect3DSurface9 *backbuffer;
2055 D3DSURFACE_DESC desc;
2056
2057 IDirect3DDevice9_GetBackBuffer(This->allocator_d3d9_dev, 0, 0,
2058 D3DBACKBUFFER_TYPE_MONO, &backbuffer);
2059 IDirect3DSurface9_GetDesc(backbuffer, &desc);
2060 IDirect3DSurface9_Release(backbuffer);
2061 allocinfo->Format = desc.Format;
2062 }
2063
2064 if (!*numbuffers || *numbuffers < allocinfo->MinBuffers)
2065 {
2066 WARN("%lu surfaces requested (minimum %lu); returning E_INVALIDARG.\n",
2067 *numbuffers, allocinfo->MinBuffers);
2068 return E_INVALIDARG;
2069 }
2070
2071 if (!This->allocator_d3d9_dev)
2072 {
2073 WARN("No Direct3D device; returning VFW_E_WRONG_STATE.\n");
2074 return VFW_E_WRONG_STATE;
2075 }
2076
2077 if (allocinfo->dwFlags == VMR9AllocFlag_OffscreenSurface)
2078 {
2079 for (i = 0; i < *numbuffers; ++i)
2080 {
2081 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(This->allocator_d3d9_dev, allocinfo->dwWidth, allocinfo->dwHeight,
2082 allocinfo->Format, allocinfo->Pool, &surface[i], NULL);
2083 if (FAILED(hr))
2084 break;
2085 }
2086 }
2087 else if (allocinfo->dwFlags == VMR9AllocFlag_TextureSurface)
2088 {
2089 for (i = 0; i < *numbuffers; ++i)
2090 {
2091 IDirect3DTexture9 *texture;
2092
2093 hr = IDirect3DDevice9_CreateTexture(This->allocator_d3d9_dev, allocinfo->dwWidth, allocinfo->dwHeight, 1, D3DUSAGE_DYNAMIC,
2094 allocinfo->Format, allocinfo->Pool, &texture, NULL);
2095 if (FAILED(hr))
2096 break;
2097 IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface[i]);
2098 IDirect3DTexture9_Release(texture);
2099 }
2100 }
2101 else if (allocinfo->dwFlags == VMR9AllocFlag_3DRenderTarget)
2102 {
2103 for (i = 0; i < *numbuffers; ++i)
2104 {
2105 if (FAILED(hr = IDirect3DDevice9_CreateRenderTarget(This->allocator_d3d9_dev,
2106 allocinfo->dwWidth, allocinfo->dwHeight, allocinfo->Format,
2107 D3DMULTISAMPLE_NONE, 0, FALSE, &surface[i], NULL)))
2108 break;
2109 }
2110 }
2111 else
2112 {
2113 FIXME("Unhandled flags %#lx.\n", allocinfo->dwFlags);
2114 return E_NOTIMPL;
2115 }
2116
2117 if (FAILED(hr))
2118 WARN("%lu/%lu surfaces allocated, hr %#lx.\n", i, *numbuffers, hr);
2119
2120 if (i >= allocinfo->MinBuffers)
2121 {
2122 hr = S_OK;
2123 *numbuffers = i;
2124 }
2125 else
2126 {
2127 for ( ; i > 0; --i) IDirect3DSurface9_Release(surface[i - 1]);
2128 *numbuffers = 0;
2129 }
2130 return hr;
2131 }
2132
2133 static HRESULT WINAPI VMR9SurfaceAllocatorNotify_NotifyEvent(IVMRSurfaceAllocatorNotify9 *iface, LONG code, LONG_PTR param1, LONG_PTR param2)
2134 {
2135 struct quartz_vmr *This = impl_from_IVMRSurfaceAllocatorNotify9(iface);
2136
2137 FIXME("(%p/%p)->(...) stub\n", iface, This);
2138 return E_NOTIMPL;
2139 }
2140
2141 static const IVMRSurfaceAllocatorNotify9Vtbl VMR9_SurfaceAllocatorNotify_Vtbl =
2142 {
2143 VMR9SurfaceAllocatorNotify_QueryInterface,
2144 VMR9SurfaceAllocatorNotify_AddRef,
2145 VMR9SurfaceAllocatorNotify_Release,
2146 VMR9SurfaceAllocatorNotify_AdviseSurfaceAllocator,
2147 VMR9SurfaceAllocatorNotify_SetD3DDevice,
2148 VMR9SurfaceAllocatorNotify_ChangeD3DDevice,
2149 VMR9SurfaceAllocatorNotify_AllocateSurfaceHelper,
2150 VMR9SurfaceAllocatorNotify_NotifyEvent
2151 };
2152
2153 static inline struct quartz_vmr *impl_from_IVMRMixerControl9(IVMRMixerControl9 *iface)
2154 {
2155 return CONTAINING_RECORD(iface, struct quartz_vmr, IVMRMixerControl9_iface);
2156 }
2157
2158 static HRESULT WINAPI mixer_control9_QueryInterface(IVMRMixerControl9 *iface, REFIID iid, void **out)
2159 {
2160 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2161 return IUnknown_QueryInterface(filter->renderer.filter.outer_unk, iid, out);
2162 }
2163
2164 static ULONG WINAPI mixer_control9_AddRef(IVMRMixerControl9 *iface)
2165 {
2166 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2167 return IUnknown_AddRef(filter->renderer.filter.outer_unk);
2168 }
2169
2170 static ULONG WINAPI mixer_control9_Release(IVMRMixerControl9 *iface)
2171 {
2172 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2173 return IUnknown_Release(filter->renderer.filter.outer_unk);
2174 }
2175
2176 static HRESULT WINAPI mixer_control9_SetAlpha(IVMRMixerControl9 *iface, DWORD stream, float alpha)
2177 {
2178 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2179
2180 FIXME("filter %p, stream %lu, alpha %.8e, stub!\n", filter, stream, alpha);
2181
2182 return E_NOTIMPL;
2183 }
2184
2185 static HRESULT WINAPI mixer_control9_GetAlpha(IVMRMixerControl9 *iface, DWORD stream, float *alpha)
2186 {
2187 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2188
2189 FIXME("filter %p, stream %lu, alpha %p, stub!\n", filter, stream, alpha);
2190
2191 return E_NOTIMPL;
2192 }
2193
2194 static HRESULT WINAPI mixer_control9_SetZOrder(IVMRMixerControl9 *iface, DWORD stream, DWORD z)
2195 {
2196 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2197
2198 FIXME("filter %p, stream %lu, z %lu, stub!\n", filter, stream, z);
2199
2200 return E_NOTIMPL;
2201 }
2202
2203 static HRESULT WINAPI mixer_control9_GetZOrder(IVMRMixerControl9 *iface, DWORD stream, DWORD *z)
2204 {
2205 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2206
2207 FIXME("filter %p, stream %lu, z %p, stub!\n", filter, stream, z);
2208
2209 return E_NOTIMPL;
2210 }
2211
2212 static HRESULT WINAPI mixer_control9_SetOutputRect(IVMRMixerControl9 *iface,
2213 DWORD stream, const VMR9NormalizedRect *rect)
2214 {
2215 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2216
2217 FIXME("filter %p, stream %lu, rect %s, stub!\n", filter, stream, debugstr_normalized_rect(rect));
2218
2219 return E_NOTIMPL;
2220 }
2221
2222 static HRESULT WINAPI mixer_control9_GetOutputRect(IVMRMixerControl9 *iface,
2223 DWORD stream, VMR9NormalizedRect *rect)
2224 {
2225 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2226
2227 FIXME("filter %p, stream %lu, rect %p, stub!\n", filter, stream, rect);
2228
2229 return E_NOTIMPL;
2230 }
2231
2232 static HRESULT WINAPI mixer_control9_SetBackgroundClr(IVMRMixerControl9 *iface, COLORREF color)
2233 {
2234 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2235
2236 FIXME("filter %p, color #%06lx, stub!\n", filter, color);
2237
2238 return E_NOTIMPL;
2239 }
2240
2241 static HRESULT WINAPI mixer_control9_GetBackgroundClr(IVMRMixerControl9 *iface, COLORREF *color)
2242 {
2243 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2244
2245 FIXME("filter %p, color %p, stub!\n", filter, color);
2246
2247 return E_NOTIMPL;
2248 }
2249
2250 static HRESULT WINAPI mixer_control9_SetMixingPrefs(IVMRMixerControl9 *iface, DWORD flags)
2251 {
2252 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2253
2254 FIXME("filter %p, flags %#lx, stub!\n", filter, flags);
2255
2256 EnterCriticalSection(&filter->renderer.filter.filter_cs);
2257 filter->mixing_prefs = flags;
2258 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
2259 return S_OK;
2260 }
2261
2262 static HRESULT WINAPI mixer_control9_GetMixingPrefs(IVMRMixerControl9 *iface, DWORD *flags)
2263 {
2264 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2265
2266 FIXME("filter %p, flags %p, stub!\n", filter, flags);
2267
2268 EnterCriticalSection(&filter->renderer.filter.filter_cs);
2269 *flags = filter->mixing_prefs;
2270 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
2271 return S_OK;
2272 }
2273
2274 static HRESULT WINAPI mixer_control9_SetProcAmpControl(IVMRMixerControl9 *iface,
2275 DWORD stream, VMR9ProcAmpControl *settings)
2276 {
2277 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2278
2279 FIXME("filter %p, settings %p, stub!\n", filter, settings);
2280
2281 return E_NOTIMPL;
2282 }
2283
2284 static HRESULT WINAPI mixer_control9_GetProcAmpControl(IVMRMixerControl9 *iface,
2285 DWORD stream, VMR9ProcAmpControl *settings)
2286 {
2287 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2288
2289 FIXME("filter %p, settings %p, stub!\n", filter, settings);
2290
2291 return E_NOTIMPL;
2292 }
2293
2294 static HRESULT WINAPI mixer_control9_GetProcAmpControlRange(IVMRMixerControl9 *iface,
2295 DWORD stream, VMR9ProcAmpControlRange *settings)
2296 {
2297 struct quartz_vmr *filter = impl_from_IVMRMixerControl9(iface);
2298
2299 FIXME("filter %p, settings %p, stub!\n", filter, settings);
2300
2301 return E_NOTIMPL;
2302 }
2303
2304 static const IVMRMixerControl9Vtbl mixer_control9_vtbl =
2305 {
2306 mixer_control9_QueryInterface,
2307 mixer_control9_AddRef,
2308 mixer_control9_Release,
2309 mixer_control9_SetAlpha,
2310 mixer_control9_GetAlpha,
2311 mixer_control9_SetZOrder,
2312 mixer_control9_GetZOrder,
2313 mixer_control9_SetOutputRect,
2314 mixer_control9_GetOutputRect,
2315 mixer_control9_SetBackgroundClr,
2316 mixer_control9_GetBackgroundClr,
2317 mixer_control9_SetMixingPrefs,
2318 mixer_control9_GetMixingPrefs,
2319 mixer_control9_SetProcAmpControl,
2320 mixer_control9_GetProcAmpControl,
2321 mixer_control9_GetProcAmpControlRange,
2322 };
2323
2324 static inline struct quartz_vmr *impl_from_IVMRMixerBitmap9(IVMRMixerBitmap9 *iface)
2325 {
2326 return CONTAINING_RECORD(iface, struct quartz_vmr, IVMRMixerBitmap9_iface);
2327 }
2328
2329 static HRESULT WINAPI mixer_bitmap9_QueryInterface(IVMRMixerBitmap9 *iface, REFIID iid, void **out)
2330 {
2331 struct quartz_vmr *filter = impl_from_IVMRMixerBitmap9(iface);
2332 return IUnknown_QueryInterface(filter->renderer.filter.outer_unk, iid, out);
2333 }
2334
2335 static ULONG WINAPI mixer_bitmap9_AddRef(IVMRMixerBitmap9 *iface)
2336 {
2337 struct quartz_vmr *filter = impl_from_IVMRMixerBitmap9(iface);
2338 return IUnknown_AddRef(filter->renderer.filter.outer_unk);
2339 }
2340
2341 static ULONG WINAPI mixer_bitmap9_Release(IVMRMixerBitmap9 *iface)
2342 {
2343 struct quartz_vmr *filter = impl_from_IVMRMixerBitmap9(iface);
2344 return IUnknown_Release(filter->renderer.filter.outer_unk);
2345 }
2346
2347 static HRESULT WINAPI mixer_bitmap9_SetAlphaBitmap(IVMRMixerBitmap9 *iface,
2348 const VMR9AlphaBitmap *bitmap)
2349 {
2350 FIXME("iface %p, bitmap %p, stub!\n", iface, bitmap);
2351 TRACE("dwFlags %#lx, hdc %p, pDDS %p, rSrc %s, rDest %s, fAlpha %.8e, clrSrcKey #%06lx, dwFilterMode %#lx.\n",
2352 bitmap->dwFlags, bitmap->hdc, bitmap->pDDS, wine_dbgstr_rect(&bitmap->rSrc),
2353 debugstr_normalized_rect(&bitmap->rDest), bitmap->fAlpha, bitmap->clrSrcKey, bitmap->dwFilterMode);
2354 return E_NOTIMPL;
2355 }
2356
2357 static HRESULT WINAPI mixer_bitmap9_UpdateAlphaBitmapParameters(IVMRMixerBitmap9 *iface,
2358 const VMR9AlphaBitmap *bitmap)
2359 {
2360 FIXME("iface %p, bitmap %p, stub!\n", iface, bitmap);
2361 return E_NOTIMPL;
2362 }
2363
2364 static HRESULT WINAPI mixer_bitmap9_GetAlphaBitmapParameters(IVMRMixerBitmap9 *iface,
2365 VMR9AlphaBitmap *bitmap)
2366 {
2367 FIXME("iface %p, bitmap %p, stub!\n", iface, bitmap);
2368 return E_NOTIMPL;
2369 }
2370
2371 static const IVMRMixerBitmap9Vtbl mixer_bitmap9_vtbl =
2372 {
2373 mixer_bitmap9_QueryInterface,
2374 mixer_bitmap9_AddRef,
2375 mixer_bitmap9_Release,
2376 mixer_bitmap9_SetAlphaBitmap,
2377 mixer_bitmap9_UpdateAlphaBitmapParameters,
2378 mixer_bitmap9_GetAlphaBitmapParameters,
2379 };
2380
2381 static inline struct quartz_vmr *impl_from_IVMRAspectRatioControl9(IVMRAspectRatioControl9 *iface)
2382 {
2383 return CONTAINING_RECORD(iface, struct quartz_vmr, IVMRAspectRatioControl9_iface);
2384 }
2385
2386 static HRESULT WINAPI aspect_ratio_control9_QueryInterface(IVMRAspectRatioControl9 *iface, REFIID iid, void **out)
2387 {
2388 struct quartz_vmr *filter = impl_from_IVMRAspectRatioControl9(iface);
2389 return IUnknown_QueryInterface(filter->renderer.filter.outer_unk, iid, out);
2390 }
2391
2392 static ULONG WINAPI aspect_ratio_control9_AddRef(IVMRAspectRatioControl9 *iface)
2393 {
2394 struct quartz_vmr *filter = impl_from_IVMRAspectRatioControl9(iface);
2395 return IUnknown_AddRef(filter->renderer.filter.outer_unk);
2396 }
2397
2398 static ULONG WINAPI aspect_ratio_control9_Release(IVMRAspectRatioControl9 *iface)
2399 {
2400 struct quartz_vmr *filter = impl_from_IVMRAspectRatioControl9(iface);
2401 return IUnknown_Release(filter->renderer.filter.outer_unk);
2402 }
2403
2404 static HRESULT WINAPI aspect_ratio_control9_GetAspectRatioMode(IVMRAspectRatioControl9 *iface, DWORD *mode)
2405 {
2406 struct quartz_vmr *filter = impl_from_IVMRAspectRatioControl9(iface);
2407
2408 TRACE("filter %p, mode %p.\n", filter, mode);
2409
2410 EnterCriticalSection(&filter->renderer.filter.filter_cs);
2411 *mode = filter->aspect_mode;
2412 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
2413 return S_OK;
2414 }
2415
2416 static HRESULT WINAPI aspect_ratio_control9_SetAspectRatioMode(IVMRAspectRatioControl9 *iface, DWORD mode)
2417 {
2418 struct quartz_vmr *filter = impl_from_IVMRAspectRatioControl9(iface);
2419
2420 TRACE("filter %p, mode %lu.\n", filter, mode);
2421
2422 EnterCriticalSection(&filter->renderer.filter.filter_cs);
2423 filter->aspect_mode = mode;
2424 LeaveCriticalSection(&filter->renderer.filter.filter_cs);
2425 return S_OK;
2426 }
2427
2428 static const IVMRAspectRatioControl9Vtbl aspect_ratio_control9_vtbl =
2429 {
2430 aspect_ratio_control9_QueryInterface,
2431 aspect_ratio_control9_AddRef,
2432 aspect_ratio_control9_Release,
2433 aspect_ratio_control9_GetAspectRatioMode,
2434 aspect_ratio_control9_SetAspectRatioMode,
2435 };
2436
2437 static struct quartz_vmr *impl_from_IAMVideoAccelerator(IAMVideoAccelerator *iface)
2438 {
2439 return CONTAINING_RECORD(iface, struct quartz_vmr, IAMVideoAccelerator_iface);
2440 }
2441
2442 static HRESULT WINAPI video_accelerator_QueryInterface(IAMVideoAccelerator *iface, REFIID iid, void **out)
2443 {
2444 struct quartz_vmr *filter = impl_from_IAMVideoAccelerator(iface);
2445 return IPin_QueryInterface(&filter->renderer.sink.pin.IPin_iface, iid, out);
2446 }
2447
2448 static ULONG WINAPI video_accelerator_AddRef(IAMVideoAccelerator *iface)
2449 {
2450 struct quartz_vmr *filter = impl_from_IAMVideoAccelerator(iface);
2451 return IPin_AddRef(&filter->renderer.sink.pin.IPin_iface);
2452 }
2453
2454 static ULONG WINAPI video_accelerator_Release(IAMVideoAccelerator *iface)
2455 {
2456 struct quartz_vmr *filter = impl_from_IAMVideoAccelerator(iface);
2457 return IPin_Release(&filter->renderer.sink.pin.IPin_iface);
2458 }
2459
2460 static HRESULT WINAPI video_accelerator_GetVideoAcceleratorGUIDs(
2461 IAMVideoAccelerator *iface, DWORD *count, GUID *accelerators)
2462 {
2463 FIXME("iface %p, count %p, accelerators %p, stub!\n", iface, count, accelerators);
2464 return E_NOTIMPL;
2465 }
2466
2467 static HRESULT WINAPI video_accelerator_GetUncompFormatsSupported(IAMVideoAccelerator *iface,
2468 const GUID *accelerator, DWORD *count, DDPIXELFORMAT *formats)
2469 {
2470 FIXME("iface %p, accelerator %s, count %p, formats %p, stub!\n",
2471 iface, debugstr_guid(accelerator), count, formats);
2472 return E_NOTIMPL;
2473 }
2474
2475 static HRESULT WINAPI video_accelerator_GetInternalMemInfo(IAMVideoAccelerator *iface,
2476 const GUID *accelerator, const AMVAUncompDataInfo *format_info, AMVAInternalMemInfo *mem_info)
2477 {
2478 FIXME("iface %p, accelerator %s, format_info %p, mem_info %p, stub!\n",
2479 iface, debugstr_guid(accelerator), format_info, mem_info);
2480 return E_NOTIMPL;
2481 }
2482
2483 static HRESULT WINAPI video_accelerator_GetCompBufferInfo(IAMVideoAccelerator *iface,
2484 const GUID *accelerator, const AMVAUncompDataInfo *uncompressed_info,
2485 DWORD *compressed_info_count, AMVACompBufferInfo *compressed_infos)
2486 {
2487 FIXME("iface %p, accelerator %s, uncompressed_info %p, compressed_info_count %p, compressed_infos %p, stub!\n",
2488 iface, debugstr_guid(accelerator), uncompressed_info, compressed_info_count, compressed_infos);
2489 return E_NOTIMPL;
2490 }
2491
2492 static HRESULT WINAPI video_accelerator_GetInternalCompBufferInfo(
2493 IAMVideoAccelerator *iface, DWORD *count, AMVACompBufferInfo *infos)
2494 {
2495 FIXME("iface %p, count %p, infos %p, stub!\n", iface, count, infos);
2496 return E_NOTIMPL;
2497 }
2498
2499 static HRESULT WINAPI video_accelerator_BeginFrame(IAMVideoAccelerator *iface, const AMVABeginFrameInfo *info)
2500 {
2501 FIXME("iface %p, info %p, stub!\n", iface, info);
2502 return E_NOTIMPL;
2503 }
2504
2505 static HRESULT WINAPI video_accelerator_EndFrame(IAMVideoAccelerator *iface, const AMVAEndFrameInfo *info)
2506 {
2507 FIXME("iface %p, info %p, stub!\n", iface, info);
2508 return E_NOTIMPL;
2509 }
2510
2511 static HRESULT WINAPI video_accelerator_GetBuffer(IAMVideoAccelerator *iface,
2512 DWORD type_index, DWORD buffer_index, BOOL read_only, void **buffer, LONG *stride)
2513 {
2514 FIXME("iface %p, type_index %lu, buffer_index %lu, read_only %d, buffer %p, stride %p, stub!\n",
2515 iface, type_index, buffer_index, read_only, buffer, stride);
2516 return E_NOTIMPL;
2517 }
2518
2519 static HRESULT WINAPI video_accelerator_ReleaseBuffer(
2520 IAMVideoAccelerator *iface, DWORD type_index, DWORD buffer_index)
2521 {
2522 FIXME("iface %p, type_index %lu, buffer_index %lu, stub!\n", iface, type_index, buffer_index);
2523 return E_NOTIMPL;
2524 }
2525
2526 static HRESULT WINAPI video_accelerator_Execute(IAMVideoAccelerator *iface,
2527 DWORD function, void *in_data, DWORD in_size, void *out_data,
2528 DWORD out_size, DWORD buffer_count, const AMVABUFFERINFO *buffers)
2529 {
2530 FIXME("iface %p, function %#lx, in_data %p, in_size %lu,"
2531 " out_data %p, out_size %lu, buffer_count %lu, buffers %p, stub!\n",
2532 iface, function, in_data, in_size, out_data, out_size, buffer_count, buffers);
2533 return E_NOTIMPL;
2534 }
2535
2536 static HRESULT WINAPI video_accelerator_QueryRenderStatus(IAMVideoAccelerator *iface,
2537 DWORD type_index, DWORD buffer_index, DWORD flags)
2538 {
2539 FIXME("iface %p, type_index %lu, buffer_index %lu, flags %#lx, stub!\n",
2540 iface, type_index, buffer_index, flags);
2541 return E_NOTIMPL;
2542 }
2543
2544 static HRESULT WINAPI video_accelerator_DisplayFrame(
2545 IAMVideoAccelerator *iface, DWORD index, IMediaSample *sample)
2546 {
2547 FIXME("iface %p, index %lu, sample %p, stub!\n", iface, index, sample);
2548 return E_NOTIMPL;
2549 }
2550
2551 static const IAMVideoAcceleratorVtbl video_accelerator_vtbl =
2552 {
2553 video_accelerator_QueryInterface,
2554 video_accelerator_AddRef,
2555 video_accelerator_Release,
2556 video_accelerator_GetVideoAcceleratorGUIDs,
2557 video_accelerator_GetUncompFormatsSupported,
2558 video_accelerator_GetInternalMemInfo,
2559 video_accelerator_GetCompBufferInfo,
2560 video_accelerator_GetInternalCompBufferInfo,
2561 video_accelerator_BeginFrame,
2562 video_accelerator_EndFrame,
2563 video_accelerator_GetBuffer,
2564 video_accelerator_ReleaseBuffer,
2565 video_accelerator_Execute,
2566 video_accelerator_QueryRenderStatus,
2567 video_accelerator_DisplayFrame,
2568 };
2569
2570 static inline struct quartz_vmr *impl_from_IOverlay(IOverlay *iface)
2571 {
2572 return CONTAINING_RECORD(iface, struct quartz_vmr, IOverlay_iface);
2573 }
2574
2575 static HRESULT WINAPI overlay_QueryInterface(IOverlay *iface, REFIID iid, void **out)
2576 {
2577 struct quartz_vmr *filter = impl_from_IOverlay(iface);
2578 return IPin_QueryInterface(&filter->renderer.sink.pin.IPin_iface, iid, out);
2579 }
2580
2581 static ULONG WINAPI overlay_AddRef(IOverlay *iface)
2582 {
2583 struct quartz_vmr *filter = impl_from_IOverlay(iface);
2584 return IPin_AddRef(&filter->renderer.sink.pin.IPin_iface);
2585 }
2586
2587 static ULONG WINAPI overlay_Release(IOverlay *iface)
2588 {
2589 struct quartz_vmr *filter = impl_from_IOverlay(iface);
2590 return IPin_Release(&filter->renderer.sink.pin.IPin_iface);
2591 }
2592
2593 static HRESULT WINAPI overlay_GetPalette(IOverlay *iface, DWORD *count, PALETTEENTRY **palette)
2594 {
2595 FIXME("iface %p, count %p, palette %p, stub!\n", iface, count, palette);
2596 return E_NOTIMPL;
2597 }
2598
2599 static HRESULT WINAPI overlay_SetPalette(IOverlay *iface, DWORD count, PALETTEENTRY *palette)
2600 {
2601 FIXME("iface %p, count %lu, palette %p, stub!\n", iface, count, palette);
2602 return E_NOTIMPL;
2603 }
2604
2605 static HRESULT WINAPI overlay_GetDefaultColorKey(IOverlay *iface, COLORKEY *key)
2606 {
2607 FIXME("iface %p, key %p, stub!\n", iface, key);
2608 return E_NOTIMPL;
2609 }
2610
2611 static HRESULT WINAPI overlay_GetColorKey(IOverlay *iface, COLORKEY *key)
2612 {
2613 FIXME("iface %p, key %p, stub!\n", iface, key);
2614 return E_NOTIMPL;
2615 }
2616
2617 static HRESULT WINAPI overlay_SetColorKey(IOverlay *iface, COLORKEY *key)
2618 {
2619 FIXME("iface %p, key %p, stub!\n", iface, key);
2620 return E_NOTIMPL;
2621 }
2622
2623 static HRESULT WINAPI overlay_GetWindowHandle(IOverlay *iface, HWND *window)
2624 {
2625 struct quartz_vmr *filter = impl_from_IOverlay(iface);
2626
2627 TRACE("filter %p, window %p.\n", filter, window);
2628
2629 if (!filter->window.hwnd)
2630 return VFW_E_WRONG_STATE;
2631
2632 *window = filter->window.hwnd;
2633 return S_OK;
2634 }
2635
2636 static HRESULT WINAPI overlay_GetClipList(IOverlay *iface, RECT *source, RECT *dest, RGNDATA **region)
2637 {
2638 FIXME("iface %p, source %p, dest %p, region %p, stub!\n", iface, source, dest, region);
2639 return E_NOTIMPL;
2640 }
2641
2642 static HRESULT WINAPI overlay_GetVideoPosition(IOverlay *iface, RECT *source, RECT *dest)
2643 {
2644 FIXME("iface %p, source %p, dest %p, stub!\n", iface, source, dest);
2645 return E_NOTIMPL;
2646 }
2647
2648 static HRESULT WINAPI overlay_Advise(IOverlay *iface, IOverlayNotify *sink, DWORD flags)
2649 {
2650 FIXME("iface %p, sink %p, flags %#lx, stub!\n", iface, sink, flags);
2651 return E_NOTIMPL;
2652 }
2653
2654 static HRESULT WINAPI overlay_Unadvise(IOverlay *iface)
2655 {
2656 FIXME("iface %p, stub!\n", iface);
2657 return E_NOTIMPL;
2658 }
2659
2660 static const IOverlayVtbl overlay_vtbl =
2661 {
2662 overlay_QueryInterface,
2663 overlay_AddRef,
2664 overlay_Release,
2665 overlay_GetPalette,
2666 overlay_SetPalette,
2667 overlay_GetDefaultColorKey,
2668 overlay_GetColorKey,
2669 overlay_SetColorKey,
2670 overlay_GetWindowHandle,
2671 overlay_GetClipList,
2672 overlay_GetVideoPosition,
2673 overlay_Advise,
2674 overlay_Unadvise,
2675 };
2676
2677 static HRESULT vmr_create(IUnknown *outer, IUnknown **out, const CLSID *clsid)
2678 {
2679 struct quartz_vmr *object;
2680 HRESULT hr;
2681
2682 if (!(object = calloc(1, sizeof(*object))))
2683 return E_OUTOFMEMORY;
2684
2685 object->hD3d9 = LoadLibraryA("d3d9.dll");
2686 if (!object->hD3d9)
2687 {
2688 WARN("Could not load d3d9.dll\n");
2689 free(object);
2690 return VFW_E_DDRAW_CAPS_NOT_SUITABLE;
2691 }
2692
2693 strmbase_renderer_init(&object->renderer, outer, clsid, L"VMR Input0", &renderer_ops);
2694 object->IAMCertifiedOutputProtection_iface.lpVtbl = &IAMCertifiedOutputProtection_Vtbl;
2695 object->IAMFilterMiscFlags_iface.lpVtbl = &IAMFilterMiscFlags_Vtbl;
2696 object->IVMRAspectRatioControl9_iface.lpVtbl = &aspect_ratio_control9_vtbl;
2697 object->IVMRFilterConfig_iface.lpVtbl = &VMR7_FilterConfig_Vtbl;
2698 object->IVMRFilterConfig9_iface.lpVtbl = &VMR9_FilterConfig_Vtbl;
2699 object->IVMRMixerBitmap9_iface.lpVtbl = &mixer_bitmap9_vtbl;
2700 object->IVMRMixerControl9_iface.lpVtbl = &mixer_control9_vtbl;
2701 object->IVMRMonitorConfig_iface.lpVtbl = &VMR7_MonitorConfig_Vtbl;
2702 object->IVMRMonitorConfig9_iface.lpVtbl = &VMR9_MonitorConfig_Vtbl;
2703 object->IVMRSurfaceAllocatorNotify_iface.lpVtbl = &VMR7_SurfaceAllocatorNotify_Vtbl;
2704 object->IVMRSurfaceAllocatorNotify9_iface.lpVtbl = &VMR9_SurfaceAllocatorNotify_Vtbl;
2705 object->IVMRWindowlessControl_iface.lpVtbl = &VMR7_WindowlessControl_Vtbl;
2706 object->IVMRWindowlessControl9_iface.lpVtbl = &VMR9_WindowlessControl_Vtbl;
2707
2708 object->IAMVideoAccelerator_iface.lpVtbl = &video_accelerator_vtbl;
2709 object->IOverlay_iface.lpVtbl = &overlay_vtbl;
2710
2711 video_window_init(&object->window, &IVideoWindow_VTable,
2712 &object->renderer.filter, &object->renderer.sink.pin, &window_ops);
2713
2714 if (FAILED(hr = video_window_create_window(&object->window)))
2715 {
2716 video_window_cleanup(&object->window);
2717 strmbase_renderer_cleanup(&object->renderer);
2718 FreeLibrary(object->hD3d9);
2719 free(object);
2720 return hr;
2721 }
2722
2723 object->mixing_prefs = MixerPref9_NoDecimation | MixerPref9_ARAdjustXorY
2724 | MixerPref9_BiLinearFiltering | MixerPref9_RenderTargetRGB;
2725
2726 TRACE("Created VMR %p.\n", object);
2727 *out = &object->renderer.filter.IUnknown_inner;
2728 return S_OK;
2729 }
2730
2731 HRESULT vmr7_create(IUnknown *outer, IUnknown **out)
2732 {
2733 return vmr_create(outer, out, &CLSID_VideoMixingRenderer);
2734 }
2735
2736 HRESULT vmr9_create(IUnknown *outer, IUnknown **out)
2737 {
2738 return vmr_create(outer, out, &CLSID_VideoMixingRenderer9);
2739 }
2740
2741
2742 static HRESULT WINAPI VMR9_ImagePresenter_QueryInterface(IVMRImagePresenter9 *iface, REFIID riid, void **ppv)
2743 {
2744 struct default_presenter *This = impl_from_IVMRImagePresenter9(iface);
2745
2746 TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
2747
2748 *ppv = NULL;
2749
2750 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IVMRImagePresenter9))
2751 *ppv = &This->IVMRImagePresenter9_iface;
2752 else if (IsEqualIID(riid, &IID_IVMRSurfaceAllocator9))
2753 *ppv = &This->IVMRSurfaceAllocator9_iface;
2754
2755 if (*ppv)
2756 {
2757 IUnknown_AddRef((IUnknown *)(*ppv));
2758 return S_OK;
2759 }
2760
2761 FIXME("No interface for %s\n", debugstr_guid(riid));
2762
2763 return E_NOINTERFACE;
2764 }
2765
2766 static ULONG WINAPI VMR9_ImagePresenter_AddRef(IVMRImagePresenter9 *iface)
2767 {
2768 struct default_presenter *presenter = impl_from_IVMRImagePresenter9(iface);
2769 ULONG refcount = InterlockedIncrement(&presenter->refCount);
2770
2771 TRACE("%p increasing refcount to %lu.\n", presenter, refcount);
2772
2773 return refcount;
2774 }
2775
2776 static ULONG WINAPI VMR9_ImagePresenter_Release(IVMRImagePresenter9 *iface)
2777 {
2778 struct default_presenter *This = impl_from_IVMRImagePresenter9(iface);
2779 ULONG refcount = InterlockedDecrement(&This->refCount);
2780
2781 TRACE("%p decreasing refcount to %lu.\n", This, refcount);
2782
2783 if (!refcount)
2784 {
2785 DWORD i;
2786
2787 IDirect3D9_Release(This->d3d9_ptr);
2788
2789 for (i = 0; i < This->num_surfaces; ++i)
2790 {
2791 IDirect3DSurface9 *surface = This->d3d9_surfaces[i];
2792 if (surface)
2793 IDirect3DSurface9_Release(surface);
2794 }
2795
2796 if (This->d3d9_dev)
2797 IDirect3DDevice9_Release(This->d3d9_dev);
2798 free(This->d3d9_surfaces);
2799 This->d3d9_surfaces = NULL;
2800 This->num_surfaces = 0;
2801 free(This);
2802 return 0;
2803 }
2804 return refcount;
2805 }
2806
2807 static HRESULT WINAPI VMR9_ImagePresenter_StartPresenting(IVMRImagePresenter9 *iface, DWORD_PTR cookie)
2808 {
2809 struct default_presenter *presenter = impl_from_IVMRImagePresenter9(iface);
2810
2811 TRACE("presenter %p, cookie %#Ix.\n", presenter, cookie);
2812
2813 return S_OK;
2814 }
2815
2816 static HRESULT WINAPI VMR9_ImagePresenter_StopPresenting(IVMRImagePresenter9 *iface, DWORD_PTR cookie)
2817 {
2818 struct default_presenter *presenter = impl_from_IVMRImagePresenter9(iface);
2819
2820 TRACE("presenter %p, cookie %#Ix.\n", presenter, cookie);
2821
2822 return S_OK;
2823 }
2824
2825 static HRESULT WINAPI VMR9_ImagePresenter_PresentImage(IVMRImagePresenter9 *iface,
2826 DWORD_PTR cookie, VMR9PresentationInfo *info)
2827 {
2828 struct default_presenter *presenter = impl_from_IVMRImagePresenter9(iface);
2829 const struct quartz_vmr *filter = presenter->pVMR9;
2830 IDirect3DDevice9 *device = presenter->d3d9_dev;
2831 const RECT src = filter->window.src;
2832 IDirect3DSurface9 *backbuffer;
2833 RECT dst = filter->window.dst;
2834 HRESULT hr;
2835
2836 TRACE("presenter %p, cookie %#Ix, info %p.\n", presenter, cookie, info);
2837
2838 /* This might happen if we don't have active focus (eg on a different virtual desktop) */
2839 if (!device)
2840 return S_OK;
2841
2842 if (FAILED(hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET,
2843 D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0)))
2844 ERR("Failed to clear, hr %#lx.\n", hr);
2845
2846 if (FAILED(hr = IDirect3DDevice9_BeginScene(device)))
2847 ERR("Failed to begin scene, hr %#lx.\n", hr);
2848
2849 if (FAILED(hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer)))
2850 {
2851 ERR("Failed to get backbuffer, hr %#lx.\n", hr);
2852 return hr;
2853 }
2854
2855 if (FAILED(hr = IDirect3DDevice9_StretchRect(device, info->lpSurf, NULL, backbuffer, NULL, D3DTEXF_POINT)))
2856 ERR("Failed to blit image, hr %#lx.\n", hr);
2857 IDirect3DSurface9_Release(backbuffer);
2858
2859 if (FAILED(hr = IDirect3DDevice9_EndScene(device)))
2860 ERR("Failed to end scene, hr %#lx.\n", hr);
2861
2862 if (filter->aspect_mode == VMR9ARMode_LetterBox)
2863 {
2864 unsigned int src_width = src.right - src.left, src_height = src.bottom - src.top;
2865 unsigned int dst_width = dst.right - dst.left, dst_height = dst.bottom - dst.top;
2866
2867 if (src_width * dst_height > dst_width * src_height)
2868 {
2869 /* src is "wider" than dst. */
2870 unsigned int dst_center = (dst.top + dst.bottom) / 2;
2871 unsigned int scaled_height = src_height * dst_width / src_width;
2872
2873 dst.top = dst_center - scaled_height / 2;
2874 dst.bottom = dst.top + scaled_height;
2875 }
2876 else if (src_width * dst_height < dst_width * src_height)
2877 {
2878 /* src is "taller" than dst. */
2879 unsigned int dst_center = (dst.left + dst.right) / 2;
2880 unsigned int scaled_width = src_width * dst_height / src_height;
2881
2882 dst.left = dst_center - scaled_width / 2;
2883 dst.right = dst.left + scaled_width;
2884 }
2885 }
2886
2887 if (FAILED(hr = IDirect3DDevice9_Present(device, &src, &dst, NULL, NULL)))
2888 ERR("Failed to present, hr %#lx.\n", hr);
2889
2890 return S_OK;
2891 }
2892
2893 static const IVMRImagePresenter9Vtbl VMR9_ImagePresenter =
2894 {
2895 VMR9_ImagePresenter_QueryInterface,
2896 VMR9_ImagePresenter_AddRef,
2897 VMR9_ImagePresenter_Release,
2898 VMR9_ImagePresenter_StartPresenting,
2899 VMR9_ImagePresenter_StopPresenting,
2900 VMR9_ImagePresenter_PresentImage
2901 };
2902
2903 static HRESULT WINAPI VMR9_SurfaceAllocator_QueryInterface(IVMRSurfaceAllocator9 *iface, REFIID iid, void **out)
2904 {
2905 struct default_presenter *presenter = impl_from_IVMRSurfaceAllocator9(iface);
2906 return IVMRImagePresenter9_QueryInterface(&presenter->IVMRImagePresenter9_iface, iid, out);
2907 }
2908
2909 static ULONG WINAPI VMR9_SurfaceAllocator_AddRef(IVMRSurfaceAllocator9 *iface)
2910 {
2911 struct default_presenter *presenter = impl_from_IVMRSurfaceAllocator9(iface);
2912 return IVMRImagePresenter9_AddRef(&presenter->IVMRImagePresenter9_iface);
2913 }
2914
2915 static ULONG WINAPI VMR9_SurfaceAllocator_Release(IVMRSurfaceAllocator9 *iface)
2916 {
2917 struct default_presenter *presenter = impl_from_IVMRSurfaceAllocator9(iface);
2918 return IVMRImagePresenter9_Release(&presenter->IVMRImagePresenter9_iface);
2919 }
2920
2921 static void adjust_surface_size(const D3DCAPS9 *caps, VMR9AllocationInfo *allocinfo)
2922 {
2923 UINT width, height;
2924
2925 /* There are no restrictions on the size of offscreen surfaces. */
2926 if (!(allocinfo->dwFlags & VMR9AllocFlag_TextureSurface))
2927 return;
2928
2929 if (!(caps->TextureCaps & D3DPTEXTURECAPS_POW2) || (caps->TextureCaps & D3DPTEXTURECAPS_SQUAREONLY))
2930 {
2931 width = allocinfo->dwWidth;
2932 height = allocinfo->dwHeight;
2933 }
2934 else
2935 {
2936 width = height = 1;
2937 while (width < allocinfo->dwWidth)
2938 width *= 2;
2939
2940 while (height < allocinfo->dwHeight)
2941 height *= 2;
2942 FIXME("NPOW2 support missing, not using proper surfaces!\n");
2943 }
2944
2945 if (caps->TextureCaps & D3DPTEXTURECAPS_SQUAREONLY)
2946 {
2947 if (height > width)
2948 width = height;
2949 else
2950 height = width;
2951 FIXME("Square texture support required..\n");
2952 }
2953
2954 allocinfo->dwHeight = height;
2955 allocinfo->dwWidth = width;
2956 }
2957
2958 static UINT d3d9_adapter_from_hwnd(IDirect3D9 *d3d9, HWND hwnd, HMONITOR *mon_out)
2959 {
2960 UINT d3d9_adapter;
2961 HMONITOR mon;
2962
2963 mon = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONULL);
2964 if (!mon)
2965 d3d9_adapter = 0;
2966 else
2967 {
2968 for (d3d9_adapter = 0; d3d9_adapter < IDirect3D9_GetAdapterCount(d3d9); ++d3d9_adapter)
2969 {
2970 if (mon == IDirect3D9_GetAdapterMonitor(d3d9, d3d9_adapter))
2971 break;
2972 }
2973 if (d3d9_adapter >= IDirect3D9_GetAdapterCount(d3d9))
2974 d3d9_adapter = 0;
2975 }
2976 if (mon_out)
2977 *mon_out = mon;
2978 return d3d9_adapter;
2979 }
2980
2981 static HRESULT WINAPI VMR9_SurfaceAllocator_InitializeDevice(IVMRSurfaceAllocator9 *iface,
2982 DWORD_PTR cookie, VMR9AllocationInfo *info, DWORD *numbuffers)
2983 {
2984 struct default_presenter *This = impl_from_IVMRSurfaceAllocator9(iface);
2985 D3DPRESENT_PARAMETERS d3dpp;
2986 IDirect3DDevice9 *device;
2987 DWORD d3d9_adapter;
2988 D3DCAPS9 caps;
2989 HWND window;
2990 HRESULT hr;
2991
2992 TRACE("presenter %p, cookie %#Ix, info %p, numbuffers %p.\n", This, cookie, info, numbuffers);
2993
2994 This->info = *info;
2995
2996 if (This->pVMR9->mode == VMR9Mode_Windowed)
2997 window = This->pVMR9->window.hwnd;
2998 else
2999 window = This->pVMR9->clipping_window;
3000
3001 /* Obtain a monitor and d3d9 device */
3002 d3d9_adapter = d3d9_adapter_from_hwnd(This->d3d9_ptr, window, &This->hMon);
3003
3004 /* Now try to create the d3d9 device */
3005 ZeroMemory(&d3dpp, sizeof(d3dpp));
3006 d3dpp.Windowed = TRUE;
3007 d3dpp.hDeviceWindow = window;
3008 d3dpp.SwapEffect = D3DSWAPEFFECT_COPY;
3009 d3dpp.BackBufferWidth = info->dwWidth;
3010 d3dpp.BackBufferHeight = info->dwHeight;
3011
3012 hr = IDirect3D9_CreateDevice(This->d3d9_ptr, d3d9_adapter, D3DDEVTYPE_HAL,
3013 NULL, D3DCREATE_MIXED_VERTEXPROCESSING, &d3dpp, &device);
3014 if (FAILED(hr))
3015 {
3016 ERR("Failed to create device, hr %#lx.\n", hr);
3017 return hr;
3018 }
3019
3020 IDirect3DDevice9_GetDeviceCaps(device, &caps);
3021 if (!(caps.DevCaps2 & D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES))
3022 {
3023 WARN("Device does not support blitting from textures.\n");
3024 IDirect3DDevice9_Release(device);
3025 return VFW_E_DDRAW_CAPS_NOT_SUITABLE;
3026 }
3027
3028 This->d3d9_dev = device;
3029 IVMRSurfaceAllocatorNotify9_SetD3DDevice(This->SurfaceAllocatorNotify, This->d3d9_dev, This->hMon);
3030
3031 if (!(This->d3d9_surfaces = calloc(*numbuffers, sizeof(IDirect3DSurface9 *))))
3032 return E_OUTOFMEMORY;
3033
3034 adjust_surface_size(&caps, info);
3035
3036 hr = IVMRSurfaceAllocatorNotify9_AllocateSurfaceHelper(This->SurfaceAllocatorNotify,
3037 info, numbuffers, This->d3d9_surfaces);
3038 if (FAILED(hr))
3039 {
3040 ERR("Failed to allocate surfaces, hr %#lx.\n", hr);
3041 IVMRSurfaceAllocator9_TerminateDevice(This->pVMR9->allocator, This->pVMR9->cookie);
3042 return hr;
3043 }
3044
3045 This->num_surfaces = *numbuffers;
3046
3047 return S_OK;
3048 }
3049
3050 static HRESULT WINAPI VMR9_SurfaceAllocator_TerminateDevice(IVMRSurfaceAllocator9 *iface, DWORD_PTR cookie)
3051 {
3052 TRACE("iface %p, cookie %#Ix.\n", iface, cookie);
3053
3054 return S_OK;
3055 }
3056
3057 static HRESULT WINAPI VMR9_SurfaceAllocator_GetSurface(IVMRSurfaceAllocator9 *iface,
3058 DWORD_PTR cookie, DWORD surfaceindex, DWORD flags, IDirect3DSurface9 **surface)
3059 {
3060 struct default_presenter *This = impl_from_IVMRSurfaceAllocator9(iface);
3061
3062 /* Update everything first, this is needed because the surface might be destroyed in the reset */
3063 if (!This->d3d9_dev)
3064 {
3065 TRACE("Device has left me!\n");
3066 return E_FAIL;
3067 }
3068
3069 if (surfaceindex >= This->num_surfaces)
3070 {
3071 ERR("surfaceindex is greater than num_surfaces\n");
3072 return E_FAIL;
3073 }
3074 *surface = This->d3d9_surfaces[surfaceindex];
3075 IDirect3DSurface9_AddRef(*surface);
3076
3077 return S_OK;
3078 }
3079
3080 static HRESULT WINAPI VMR9_SurfaceAllocator_AdviseNotify(IVMRSurfaceAllocator9 *iface,
3081 IVMRSurfaceAllocatorNotify9 *notify)
3082 {
3083 struct default_presenter *presenter = impl_from_IVMRSurfaceAllocator9(iface);
3084
3085 TRACE("presenter %p, notify %p.\n", presenter, notify);
3086
3087 /* No AddRef taken here or the base VMR9 filter would never be destroyed */
3088 presenter->SurfaceAllocatorNotify = notify;
3089 return S_OK;
3090 }
3091
3092 static const IVMRSurfaceAllocator9Vtbl VMR9_SurfaceAllocator =
3093 {
3094 VMR9_SurfaceAllocator_QueryInterface,
3095 VMR9_SurfaceAllocator_AddRef,
3096 VMR9_SurfaceAllocator_Release,
3097 VMR9_SurfaceAllocator_InitializeDevice,
3098 VMR9_SurfaceAllocator_TerminateDevice,
3099 VMR9_SurfaceAllocator_GetSurface,
3100 VMR9_SurfaceAllocator_AdviseNotify,
3101 };
3102
3103 static IDirect3D9 *init_d3d9(HMODULE d3d9_handle)
3104 {
3105 IDirect3D9 * (__stdcall * d3d9_create)(UINT SDKVersion);
3106
3107 d3d9_create = (void *)GetProcAddress(d3d9_handle, "Direct3DCreate9");
3108 if (!d3d9_create) return NULL;
3109
3110 return d3d9_create(D3D_SDK_VERSION);
3111 }
3112
3113 static HRESULT VMR9DefaultAllocatorPresenterImpl_create(struct quartz_vmr *parent, LPVOID * ppv)
3114 {
3115 struct default_presenter *object;
3116
3117 if (!(object = calloc(1, sizeof(*object))))
3118 return E_OUTOFMEMORY;
3119
3120 object->d3d9_ptr = init_d3d9(parent->hD3d9);
3121 if (!object->d3d9_ptr)
3122 {
3123 WARN("Could not initialize d3d9.dll\n");
3124 free(object);
3125 return VFW_E_DDRAW_CAPS_NOT_SUITABLE;
3126 }
3127
3128 object->IVMRImagePresenter9_iface.lpVtbl = &VMR9_ImagePresenter;
3129 object->IVMRSurfaceAllocator9_iface.lpVtbl = &VMR9_SurfaceAllocator;
3130
3131 object->refCount = 1;
3132 object->pVMR9 = parent;
3133
3134 TRACE("Created default presenter %p.\n", object);
3135 *ppv = &object->IVMRImagePresenter9_iface;
3136 return S_OK;
3137 }
Windows API implementation