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