dlls/amstream/ddrawstream.c

   1 /*
   2  * Primary DirectDraw video stream
   3  *
   4  * Copyright 2005, 2008, 2012 Christian Costa
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22 #include "amstream_private.h"
  23 #include "wine/debug.h"
  24 #include "wine/list.h"
  25 #include "wine/strmbase.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  28
  29 static const WCHAR sink_id[] = L"I{A35FF56A-9FDA-11D0-8FDF-00C04FD9189D}";
  30
  31 struct format
  32 {
  33     DWORD flags;
  34     DWORD width;
  35     DWORD height;
  36     DDPIXELFORMAT pf;
  37 };
  38
  39 struct ddraw_stream
  40 {
  41     IAMMediaStream IAMMediaStream_iface;
  42     IDirectDrawMediaStream IDirectDrawMediaStream_iface;
  43     IMemInputPin IMemInputPin_iface;
  44     IPin IPin_iface;
  45     LONG ref;
  46     LONG sample_refs;
  47
  48     IMultiMediaStream* parent;
  49     MSPID purpose_id;
  50     STREAM_TYPE stream_type;
  51     IDirectDraw *ddraw;
  52     CRITICAL_SECTION cs;
  53     IMediaStreamFilter *filter;
  54     IFilterGraph *graph;
  55
  56     IPin *peer;
  57     IMemAllocator *allocator;
  58     AM_MEDIA_TYPE mt;
  59     struct format format;
  60     FILTER_STATE state;
  61     REFERENCE_TIME segment_start;
  62     BOOL eos;
  63     BOOL flushing;
  64     CONDITION_VARIABLE update_queued_cv;
  65     struct list update_queue;
  66 };
  67
  68 struct ddraw_sample
  69 {
  70     IDirectDrawStreamSample IDirectDrawStreamSample_iface;
  71     LONG ref;
  72     struct ddraw_stream *parent;
  73     IMultiMediaStream *mmstream;
  74     IDirectDrawSurface *surface;
  75     RECT rect;
  76     STREAM_TIME start_time;
  77     STREAM_TIME end_time;
  78     BOOL continuous_update;
  79     CONDITION_VARIABLE update_cv;
  80     HANDLE external_event;
  81
  82     struct list entry;
  83     HRESULT update_hr;
  84     BOOL busy;
  85 };
  86
  87 static HRESULT ddrawstreamsample_create(struct ddraw_stream *parent, IDirectDrawSurface *surface,
  88     const RECT *rect, IDirectDrawStreamSample **ddraw_stream_sample);
  89
  90 static void remove_queued_update(struct ddraw_sample *sample)
  91 {
  92     sample->busy = FALSE;
  93     list_remove(&sample->entry);
  94     WakeConditionVariable(&sample->update_cv);
  95     if (sample->external_event)
  96         SetEvent(sample->external_event);
  97 }
  98
  99 static void flush_update_queue(struct ddraw_stream *stream, HRESULT update_hr)
 100 {
 101     struct list *entry;
 102     while ((entry = list_head(&stream->update_queue)))
 103     {
 104         struct ddraw_sample *sample = LIST_ENTRY(entry, struct ddraw_sample, entry);
 105         sample->update_hr = update_hr;
 106         remove_queued_update(sample);
 107     }
 108 }
 109
 110 static HRESULT process_update(struct ddraw_sample *sample, int stride, BYTE *pointer,
 111         STREAM_TIME start_time, STREAM_TIME end_time)
 112 {
 113     DDSURFACEDESC desc;
 114     DWORD row_size;
 115     const BYTE *src_row;
 116     BYTE *dst_row;
 117     DWORD row;
 118     HRESULT hr;
 119
 120     desc.dwSize = sizeof(desc);
 121     hr = IDirectDrawSurface_Lock(sample->surface, &sample->rect, &desc, DDLOCK_WAIT, NULL);
 122     if (FAILED(hr))
 123         return hr;
 124
 125     row_size = (sample->rect.right - sample->rect.left) * desc.ddpfPixelFormat.dwRGBBitCount / 8;
 126     src_row = pointer;
 127     dst_row = desc.lpSurface;
 128     for (row = sample->rect.top; row < sample->rect.bottom; ++row)
 129     {
 130         memcpy(dst_row, src_row, row_size);
 131         src_row += stride;
 132         dst_row += desc.lPitch;
 133     }
 134
 135     hr = IDirectDrawSurface_Unlock(sample->surface, desc.lpSurface);
 136     if (FAILED(hr))
 137         return hr;
 138
 139     sample->start_time = start_time;
 140     sample->end_time = end_time;
 141
 142     return S_OK;
 143 }
 144
 145 static BOOL is_format_compatible(struct ddraw_stream *stream,
 146         DWORD width, DWORD height, const DDPIXELFORMAT *connection_pf)
 147 {
 148     if (stream->format.flags & DDSD_HEIGHT)
 149     {
 150         if (stream->format.width != width || stream->format.height != height)
 151             return FALSE;
 152     }
 153     if (stream->format.flags & DDSD_PIXELFORMAT)
 154     {
 155         if (stream->format.pf.dwFlags & DDPF_FOURCC)
 156             return FALSE;
 157         if (stream->format.pf.dwRGBBitCount != connection_pf->dwRGBBitCount)
 158             return FALSE;
 159         if (stream->format.pf.dwRGBBitCount == 16 && stream->format.pf.dwGBitMask != connection_pf->dwGBitMask)
 160             return FALSE;
 161     }
 162     return TRUE;
 163 }
 164
 165 static inline struct ddraw_stream *impl_from_IAMMediaStream(IAMMediaStream *iface)
 166 {
 167     return CONTAINING_RECORD(iface, struct ddraw_stream, IAMMediaStream_iface);
 168 }
 169
 170 /*** IUnknown methods ***/
 171 static HRESULT WINAPI ddraw_IAMMediaStream_QueryInterface(IAMMediaStream *iface,
 172         REFIID riid, void **ret_iface)
 173 {
 174     struct ddraw_stream *This = impl_from_IAMMediaStream(iface);
 175
 176     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ret_iface);
 177
 178     if (IsEqualGUID(riid, &IID_IUnknown) ||
 179         IsEqualGUID(riid, &IID_IMediaStream) ||
 180         IsEqualGUID(riid, &IID_IAMMediaStream))
 181     {
 182         IAMMediaStream_AddRef(iface);
 183         *ret_iface = iface;
 184         return S_OK;
 185     }
 186     else if (IsEqualGUID(riid, &IID_IDirectDrawMediaStream))
 187     {
 188         IAMMediaStream_AddRef(iface);
 189         *ret_iface = &This->IDirectDrawMediaStream_iface;
 190         return S_OK;
 191     }
 192     else if (IsEqualGUID(riid, &IID_IPin))
 193     {
 194         IAMMediaStream_AddRef(iface);
 195         *ret_iface = &This->IPin_iface;
 196         return S_OK;
 197     }
 198     else if (IsEqualGUID(riid, &IID_IMemInputPin))
 199     {
 200         IAMMediaStream_AddRef(iface);
 201         *ret_iface = &This->IMemInputPin_iface;
 202         return S_OK;
 203     }
 204
 205     ERR("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ret_iface);
 206     return E_NOINTERFACE;
 207 }
 208
 209 static ULONG WINAPI ddraw_IAMMediaStream_AddRef(IAMMediaStream *iface)
 210 {
 211     struct ddraw_stream *This = impl_from_IAMMediaStream(iface);
 212     ULONG ref = InterlockedIncrement(&This->ref);
 213
 214     TRACE("(%p/%p)->(): new ref = %lu\n", iface, This, ref);
 215
 216     return ref;
 217 }
 218
 219 static ULONG WINAPI ddraw_IAMMediaStream_Release(IAMMediaStream *iface)
 220 {
 221     struct ddraw_stream *stream = impl_from_IAMMediaStream(iface);
 222     ULONG ref = InterlockedDecrement(&stream->ref);
 223
 224     TRACE("%p decreasing refcount to %lu.\n", stream, ref);
 225
 226     if (!ref)
 227     {
 228         DeleteCriticalSection(&stream->cs);
 229         if (stream->ddraw)
 230             IDirectDraw_Release(stream->ddraw);
 231         free(stream);
 232     }
 233
 234     return ref;
 235 }
 236
 237 /*** IMediaStream methods ***/
 238 static HRESULT WINAPI ddraw_IAMMediaStream_GetMultiMediaStream(IAMMediaStream *iface,
 239         IMultiMediaStream **mmstream)
 240 {
 241     struct ddraw_stream *stream = impl_from_IAMMediaStream(iface);
 242
 243     TRACE("stream %p, mmstream %p.\n", stream, mmstream);
 244
 245     if (!mmstream)
 246         return E_POINTER;
 247
 248     if (stream->parent)
 249         IMultiMediaStream_AddRef(stream->parent);
 250     *mmstream = stream->parent;
 251     return S_OK;
 252 }
 253
 254 static HRESULT WINAPI ddraw_IAMMediaStream_GetInformation(IAMMediaStream *iface,
 255         MSPID *purpose_id, STREAM_TYPE *type)
 256 {
 257     struct ddraw_stream *This = impl_from_IAMMediaStream(iface);
 258
 259     TRACE("(%p/%p)->(%p,%p)\n", This, iface, purpose_id, type);
 260
 261     if (purpose_id)
 262         *purpose_id = This->purpose_id;
 263     if (type)
 264         *type = This->stream_type;
 265
 266     return S_OK;
 267 }
 268
 269 static HRESULT WINAPI ddraw_IAMMediaStream_SetSameFormat(IAMMediaStream *iface,
 270         IMediaStream *pStreamThatHasDesiredFormat, DWORD flags)
 271 {
 272     struct ddraw_stream *This = impl_from_IAMMediaStream(iface);
 273
 274     FIXME("(%p/%p)->(%p,%lx) stub!\n", This, iface, pStreamThatHasDesiredFormat, flags);
 275
 276     return S_FALSE;
 277 }
 278
 279 static HRESULT WINAPI ddraw_IAMMediaStream_AllocateSample(IAMMediaStream *iface,
 280         DWORD flags, IStreamSample **sample)
 281 {
 282     struct ddraw_stream *This = impl_from_IAMMediaStream(iface);
 283
 284     FIXME("(%p/%p)->(%lx,%p) stub!\n", This, iface, flags, sample);
 285
 286     return S_FALSE;
 287 }
 288
 289 static HRESULT WINAPI ddraw_IAMMediaStream_CreateSharedSample(IAMMediaStream *iface,
 290         IStreamSample *existing_sample, DWORD flags, IStreamSample **sample)
 291 {
 292     struct ddraw_stream *This = impl_from_IAMMediaStream(iface);
 293
 294     FIXME("(%p/%p)->(%p,%lx,%p) stub!\n", This, iface, existing_sample, flags, sample);
 295
 296     return S_FALSE;
 297 }
 298
 299 static HRESULT WINAPI ddraw_IAMMediaStream_SendEndOfStream(IAMMediaStream *iface, DWORD flags)
 300 {
 301     struct ddraw_stream *This = impl_from_IAMMediaStream(iface);
 302
 303     FIXME("(%p/%p)->(%lx) stub!\n", This, iface, flags);
 304
 305     return S_FALSE;
 306 }
 307
 308 /*** IAMMediaStream methods ***/
 309 static HRESULT WINAPI ddraw_IAMMediaStream_Initialize(IAMMediaStream *iface, IUnknown *source_object, DWORD flags,
 310                                                     REFMSPID purpose_id, const STREAM_TYPE stream_type)
 311 {
 312     struct ddraw_stream *stream = impl_from_IAMMediaStream(iface);
 313     HRESULT hr;
 314
 315     TRACE("stream %p, source_object %p, flags %lx, purpose_id %s, stream_type %u.\n", stream, source_object, flags,
 316             debugstr_guid(purpose_id), stream_type);
 317
 318     if (!purpose_id)
 319         return E_POINTER;
 320
 321     if (flags & AMMSF_CREATEPEER)
 322         FIXME("AMMSF_CREATEPEER is not yet supported.\n");
 323
 324     stream->purpose_id = *purpose_id;
 325     stream->stream_type = stream_type;
 326
 327     if (stream->ddraw)
 328         IDirectDraw_Release(stream->ddraw);
 329     stream->ddraw = NULL;
 330
 331     if (source_object
 332             && FAILED(hr = IUnknown_QueryInterface(source_object, &IID_IDirectDraw, (void **)&stream->ddraw)))
 333         FIXME("Stream object doesn't implement IDirectDraw interface, hr %#lx.\n", hr);
 334
 335     if (!source_object)
 336     {
 337         if (FAILED(hr = DirectDrawCreate(NULL, &stream->ddraw, NULL)))
 338             return hr;
 339         IDirectDraw_SetCooperativeLevel(stream->ddraw, NULL, DDSCL_NORMAL);
 340     }
 341
 342     return S_OK;
 343 }
 344
 345 static HRESULT WINAPI ddraw_IAMMediaStream_SetState(IAMMediaStream *iface, FILTER_STATE state)
 346 {
 347     struct ddraw_stream *stream = impl_from_IAMMediaStream(iface);
 348
 349     TRACE("stream %p, state %u.\n", stream, state);
 350
 351     EnterCriticalSection(&stream->cs);
 352
 353     if (state == State_Stopped)
 354         WakeConditionVariable(&stream->update_queued_cv);
 355     if (stream->state == State_Stopped)
 356         stream->eos = FALSE;
 357
 358     stream->state = state;
 359
 360     LeaveCriticalSection(&stream->cs);
 361
 362     return S_OK;
 363 }
 364
 365 static HRESULT WINAPI ddraw_IAMMediaStream_JoinAMMultiMediaStream(IAMMediaStream *iface, IAMMultiMediaStream *mmstream)
 366 {
 367     struct ddraw_stream *stream = impl_from_IAMMediaStream(iface);
 368
 369     TRACE("stream %p, mmstream %p.\n", stream, mmstream);
 370
 371     stream->parent = (IMultiMediaStream *)mmstream;
 372
 373     return S_OK;
 374 }
 375
 376 static HRESULT WINAPI ddraw_IAMMediaStream_JoinFilter(IAMMediaStream *iface, IMediaStreamFilter *filter)
 377 {
 378     struct ddraw_stream *stream = impl_from_IAMMediaStream(iface);
 379
 380     TRACE("iface %p, filter %p.\n", iface, filter);
 381
 382     stream->filter = filter;
 383
 384     return S_OK;
 385 }
 386
 387 static HRESULT WINAPI ddraw_IAMMediaStream_JoinFilterGraph(IAMMediaStream *iface, IFilterGraph *filtergraph)
 388 {
 389     struct ddraw_stream *stream = impl_from_IAMMediaStream(iface);
 390
 391     TRACE("stream %p, filtergraph %p.\n", stream, filtergraph);
 392
 393     stream->graph = filtergraph;
 394
 395     return S_OK;
 396 }
 397
 398 static const struct IAMMediaStreamVtbl ddraw_IAMMediaStream_vtbl =
 399 {
 400     /*** IUnknown methods ***/
 401     ddraw_IAMMediaStream_QueryInterface,
 402     ddraw_IAMMediaStream_AddRef,
 403     ddraw_IAMMediaStream_Release,
 404     /*** IMediaStream methods ***/
 405     ddraw_IAMMediaStream_GetMultiMediaStream,
 406     ddraw_IAMMediaStream_GetInformation,
 407     ddraw_IAMMediaStream_SetSameFormat,
 408     ddraw_IAMMediaStream_AllocateSample,
 409     ddraw_IAMMediaStream_CreateSharedSample,
 410     ddraw_IAMMediaStream_SendEndOfStream,
 411     /*** IAMMediaStream methods ***/
 412     ddraw_IAMMediaStream_Initialize,
 413     ddraw_IAMMediaStream_SetState,
 414     ddraw_IAMMediaStream_JoinAMMultiMediaStream,
 415     ddraw_IAMMediaStream_JoinFilter,
 416     ddraw_IAMMediaStream_JoinFilterGraph
 417 };
 418
 419 static inline struct ddraw_stream *impl_from_IDirectDrawMediaStream(IDirectDrawMediaStream *iface)
 420 {
 421     return CONTAINING_RECORD(iface, struct ddraw_stream, IDirectDrawMediaStream_iface);
 422 }
 423
 424 /*** IUnknown methods ***/
 425 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_QueryInterface(IDirectDrawMediaStream *iface,
 426         REFIID riid, void **ret_iface)
 427 {
 428     struct ddraw_stream *This = impl_from_IDirectDrawMediaStream(iface);
 429     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ret_iface);
 430     return IAMMediaStream_QueryInterface(&This->IAMMediaStream_iface, riid, ret_iface);
 431 }
 432
 433 static ULONG WINAPI ddraw_IDirectDrawMediaStream_AddRef(IDirectDrawMediaStream *iface)
 434 {
 435     struct ddraw_stream *This = impl_from_IDirectDrawMediaStream(iface);
 436     TRACE("(%p/%p)\n", iface, This);
 437     return IAMMediaStream_AddRef(&This->IAMMediaStream_iface);
 438 }
 439
 440 static ULONG WINAPI ddraw_IDirectDrawMediaStream_Release(IDirectDrawMediaStream *iface)
 441 {
 442     struct ddraw_stream *This = impl_from_IDirectDrawMediaStream(iface);
 443     TRACE("(%p/%p)\n", iface, This);
 444     return IAMMediaStream_Release(&This->IAMMediaStream_iface);
 445 }
 446
 447 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_GetMultiMediaStream(IDirectDrawMediaStream *iface,
 448         IMultiMediaStream **mmstream)
 449 {
 450     struct ddraw_stream *stream = impl_from_IDirectDrawMediaStream(iface);
 451     return IAMMediaStream_GetMultiMediaStream(&stream->IAMMediaStream_iface, mmstream);
 452 }
 453
 454 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_GetInformation(IDirectDrawMediaStream *iface,
 455         MSPID *purpose_id, STREAM_TYPE *type)
 456 {
 457     struct ddraw_stream *stream = impl_from_IDirectDrawMediaStream(iface);
 458     return IAMMediaStream_GetInformation(&stream->IAMMediaStream_iface, purpose_id, type);
 459 }
 460
 461 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_SetSameFormat(IDirectDrawMediaStream *iface,
 462         IMediaStream *other, DWORD flags)
 463 {
 464     struct ddraw_stream *stream = impl_from_IDirectDrawMediaStream(iface);
 465     return IAMMediaStream_SetSameFormat(&stream->IAMMediaStream_iface, other, flags);
 466 }
 467
 468 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_AllocateSample(IDirectDrawMediaStream *iface,
 469         DWORD flags, IStreamSample **sample)
 470 {
 471     struct ddraw_stream *stream = impl_from_IDirectDrawMediaStream(iface);
 472     return IAMMediaStream_AllocateSample(&stream->IAMMediaStream_iface, flags, sample);
 473 }
 474
 475 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_CreateSharedSample(IDirectDrawMediaStream *iface,
 476         IStreamSample *existing_sample, DWORD flags, IStreamSample **sample)
 477 {
 478     struct ddraw_stream *stream = impl_from_IDirectDrawMediaStream(iface);
 479     return IAMMediaStream_CreateSharedSample(&stream->IAMMediaStream_iface, existing_sample, flags, sample);
 480 }
 481
 482 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_SendEndOfStream(IDirectDrawMediaStream *iface, DWORD flags)
 483 {
 484     struct ddraw_stream *stream = impl_from_IDirectDrawMediaStream(iface);
 485     return IAMMediaStream_SendEndOfStream(&stream->IAMMediaStream_iface, flags);
 486 }
 487
 488 /*** IDirectDrawMediaStream methods ***/
 489 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_GetFormat(IDirectDrawMediaStream *iface,
 490         DDSURFACEDESC *current_format, IDirectDrawPalette **palette,
 491         DDSURFACEDESC *desired_format, DWORD *flags)
 492 {
 493     struct ddraw_stream *stream = impl_from_IDirectDrawMediaStream(iface);
 494
 495     TRACE("stream %p, current_format %p, palette %p, desired_format %p, flags %p.\n", stream, current_format, palette,
 496             desired_format, flags);
 497
 498     EnterCriticalSection(&stream->cs);
 499
 500     if (!stream->peer)
 501     {
 502         LeaveCriticalSection(&stream->cs);
 503         return MS_E_NOSTREAM;
 504     }
 505
 506     if (current_format)
 507     {
 508         current_format->dwFlags = stream->format.flags | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
 509         current_format->dwWidth = stream->format.width;
 510         current_format->dwHeight = stream->format.height;
 511         current_format->ddpfPixelFormat = stream->format.pf;
 512         current_format->ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_OFFSCREENPLAIN;
 513     }
 514
 515     if (palette)
 516         *palette = NULL;
 517
 518     if (desired_format)
 519     {
 520         desired_format->dwFlags = DDSD_WIDTH | DDSD_HEIGHT;
 521         desired_format->dwWidth = stream->format.width;
 522         desired_format->dwHeight = stream->format.height;
 523         desired_format->ddpfPixelFormat = stream->format.pf;
 524         desired_format->ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_OFFSCREENPLAIN;
 525     }
 526
 527     if (flags)
 528         *flags = 0;
 529
 530     LeaveCriticalSection(&stream->cs);
 531
 532     return S_OK;
 533 }
 534
 535 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_SetFormat(IDirectDrawMediaStream *iface,
 536         const DDSURFACEDESC *format, IDirectDrawPalette *palette)
 537 {
 538     struct ddraw_stream *stream = impl_from_IDirectDrawMediaStream(iface);
 539     AM_MEDIA_TYPE old_media_type;
 540     struct format old_format;
 541     IPin *old_peer;
 542     HRESULT hr;
 543
 544     TRACE("stream %p, format %p, palette %p.\n", stream, format, palette);
 545
 546     if (palette)
 547         FIXME("Setting palette is not yet supported.\n");
 548
 549     if (!format)
 550         return E_POINTER;
 551
 552     if (format->dwSize != sizeof(DDSURFACEDESC))
 553         return E_INVALIDARG;
 554
 555     TRACE("flags %#lx, pixel format flags %#lx, bit count %lu, size %lux%lu.\n",
 556             format->dwFlags, format->ddpfPixelFormat.dwFlags,
 557             format->ddpfPixelFormat.dwRGBBitCount, format->dwWidth, format->dwHeight);
 558
 559     if (format->dwFlags & DDSD_PIXELFORMAT)
 560     {
 561         if (format->ddpfPixelFormat.dwSize != sizeof(DDPIXELFORMAT))
 562             return DDERR_INVALIDSURFACETYPE;
 563
 564         if (format->ddpfPixelFormat.dwFlags & DDPF_FOURCC)
 565         {
 566             if (!format->ddpfPixelFormat.dwRGBBitCount)
 567                 return E_INVALIDARG;
 568         }
 569         else
 570         {
 571             if (format->ddpfPixelFormat.dwFlags & (DDPF_YUV | DDPF_PALETTEINDEXED1 |
 572                     DDPF_PALETTEINDEXED2 | DDPF_PALETTEINDEXED4 | DDPF_PALETTEINDEXEDTO8))
 573                 return DDERR_INVALIDSURFACETYPE;
 574
 575             if (!(format->ddpfPixelFormat.dwFlags & DDPF_RGB))
 576                 return DDERR_INVALIDSURFACETYPE;
 577
 578             switch (format->ddpfPixelFormat.dwRGBBitCount)
 579             {
 580             case 8:
 581                 if (!(format->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8))
 582                     return DDERR_INVALIDSURFACETYPE;
 583                 break;
 584             case 16:
 585                 if (format->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8)
 586                     return DDERR_INVALIDSURFACETYPE;
 587                 if ((format->ddpfPixelFormat.dwRBitMask != 0x7c00 ||
 588                     format->ddpfPixelFormat.dwGBitMask != 0x03e0 ||
 589                     format->ddpfPixelFormat.dwBBitMask != 0x001f) &&
 590                     (format->ddpfPixelFormat.dwRBitMask != 0xf800 ||
 591                     format->ddpfPixelFormat.dwGBitMask != 0x07e0 ||
 592                     format->ddpfPixelFormat.dwBBitMask != 0x001f))
 593                     return DDERR_INVALIDSURFACETYPE;
 594                 break;
 595             case 24:
 596             case 32:
 597                 if (format->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8)
 598                     return DDERR_INVALIDSURFACETYPE;
 599                 if (format->ddpfPixelFormat.dwRBitMask != 0xff0000 ||
 600                     format->ddpfPixelFormat.dwGBitMask != 0x00ff00 ||
 601                     format->ddpfPixelFormat.dwBBitMask != 0x0000ff)
 602                     return DDERR_INVALIDSURFACETYPE;
 603                 break;
 604             default:
 605                 return DDERR_INVALIDSURFACETYPE;
 606             }
 607         }
 608     }
 609
 610     EnterCriticalSection(&stream->cs);
 611
 612     old_format = stream->format;
 613     stream->format.flags = format->dwFlags & (DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT);
 614     if (format->dwFlags & (DDSD_WIDTH | DDSD_HEIGHT))
 615     {
 616         stream->format.width = format->dwWidth;
 617         stream->format.height = format->dwHeight;
 618     }
 619     if (format->dwFlags & DDSD_PIXELFORMAT)
 620         stream->format.pf = format->ddpfPixelFormat;
 621
 622     if (stream->peer && !is_format_compatible(stream, old_format.width, old_format.height, &old_format.pf))
 623     {
 624         hr = CopyMediaType(&old_media_type, &stream->mt);
 625         if (FAILED(hr))
 626         {
 627             stream->format = old_format;
 628             LeaveCriticalSection(&stream->cs);
 629             return hr;
 630         }
 631         old_peer = stream->peer;
 632         IPin_AddRef(old_peer);
 633
 634         IFilterGraph_Disconnect(stream->graph, stream->peer);
 635         IFilterGraph_Disconnect(stream->graph, &stream->IPin_iface);
 636         hr = IFilterGraph_ConnectDirect(stream->graph, old_peer, &stream->IPin_iface, NULL);
 637         if (FAILED(hr))
 638         {
 639             stream->format = old_format;
 640             IFilterGraph_ConnectDirect(stream->graph, old_peer, &stream->IPin_iface, &old_media_type);
 641             IPin_Release(old_peer);
 642             FreeMediaType(&old_media_type);
 643             LeaveCriticalSection(&stream->cs);
 644             return DDERR_INVALIDSURFACETYPE;
 645         }
 646
 647         IPin_Release(old_peer);
 648         FreeMediaType(&old_media_type);
 649     }
 650
 651     LeaveCriticalSection(&stream->cs);
 652
 653     return S_OK;
 654 }
 655
 656 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_GetDirectDraw(IDirectDrawMediaStream *iface,
 657         IDirectDraw **ddraw)
 658 {
 659     struct ddraw_stream *stream = impl_from_IDirectDrawMediaStream(iface);
 660
 661     TRACE("stream %p, ddraw %p.\n", stream, ddraw);
 662
 663     if (!ddraw)
 664         return E_POINTER;
 665
 666     if (!stream->ddraw)
 667     {
 668         *ddraw = NULL;
 669         return S_OK;
 670     }
 671
 672     IDirectDraw_AddRef(stream->ddraw);
 673     *ddraw = stream->ddraw;
 674
 675     return S_OK;
 676 }
 677
 678 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_SetDirectDraw(IDirectDrawMediaStream *iface,
 679         IDirectDraw *ddraw)
 680 {
 681     struct ddraw_stream *stream = impl_from_IDirectDrawMediaStream(iface);
 682
 683     TRACE("stream %p, ddraw %p.\n", stream, ddraw);
 684
 685     EnterCriticalSection(&stream->cs);
 686
 687     if (stream->sample_refs)
 688     {
 689         HRESULT hr = (stream->ddraw == ddraw) ? S_OK : MS_E_SAMPLEALLOC;
 690         LeaveCriticalSection(&stream->cs);
 691         return hr;
 692     }
 693
 694     if (stream->ddraw)
 695         IDirectDraw_Release(stream->ddraw);
 696
 697     if (ddraw)
 698     {
 699         IDirectDraw_AddRef(ddraw);
 700         stream->ddraw = ddraw;
 701     }
 702     else
 703         stream->ddraw = NULL;
 704
 705     LeaveCriticalSection(&stream->cs);
 706
 707     return S_OK;
 708 }
 709
 710 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_CreateSample(IDirectDrawMediaStream *iface,
 711         IDirectDrawSurface *surface, const RECT *rect, DWORD flags,
 712         IDirectDrawStreamSample **sample)
 713 {
 714     struct ddraw_stream *stream = impl_from_IDirectDrawMediaStream(iface);
 715     HRESULT hr;
 716
 717     TRACE("stream %p, surface %p, rect %s, flags %#lx, sample %p.\n",
 718             stream, surface, wine_dbgstr_rect(rect), flags, sample);
 719
 720     if (!surface && rect)
 721         return E_INVALIDARG;
 722
 723     EnterCriticalSection(&stream->cs);
 724     hr = ddrawstreamsample_create(stream, surface, rect, sample);
 725     LeaveCriticalSection(&stream->cs);
 726
 727     return hr;
 728 }
 729
 730 static HRESULT WINAPI ddraw_IDirectDrawMediaStream_GetTimePerFrame(IDirectDrawMediaStream *iface,
 731         STREAM_TIME *frame_time)
 732 {
 733     struct ddraw_stream *stream = impl_from_IDirectDrawMediaStream(iface);
 734
 735     TRACE("stream %p, frame_time %p.\n", stream, frame_time);
 736
 737     if (!frame_time)
 738         return E_POINTER;
 739
 740     EnterCriticalSection(&stream->cs);
 741
 742     if (!stream->peer)
 743     {
 744         LeaveCriticalSection(&stream->cs);
 745         return MS_E_NOSTREAM;
 746     }
 747
 748     *frame_time = ((VIDEOINFO *)stream->mt.pbFormat)->AvgTimePerFrame;
 749
 750     LeaveCriticalSection(&stream->cs);
 751
 752     return S_OK;
 753 }
 754
 755 static const struct IDirectDrawMediaStreamVtbl ddraw_IDirectDrawMediaStream_Vtbl =
 756 {
 757     /*** IUnknown methods ***/
 758     ddraw_IDirectDrawMediaStream_QueryInterface,
 759     ddraw_IDirectDrawMediaStream_AddRef,
 760     ddraw_IDirectDrawMediaStream_Release,
 761     /*** IMediaStream methods ***/
 762     ddraw_IDirectDrawMediaStream_GetMultiMediaStream,
 763     ddraw_IDirectDrawMediaStream_GetInformation,
 764     ddraw_IDirectDrawMediaStream_SetSameFormat,
 765     ddraw_IDirectDrawMediaStream_AllocateSample,
 766     ddraw_IDirectDrawMediaStream_CreateSharedSample,
 767     ddraw_IDirectDrawMediaStream_SendEndOfStream,
 768     /*** IDirectDrawMediaStream methods ***/
 769     ddraw_IDirectDrawMediaStream_GetFormat,
 770     ddraw_IDirectDrawMediaStream_SetFormat,
 771     ddraw_IDirectDrawMediaStream_GetDirectDraw,
 772     ddraw_IDirectDrawMediaStream_SetDirectDraw,
 773     ddraw_IDirectDrawMediaStream_CreateSample,
 774     ddraw_IDirectDrawMediaStream_GetTimePerFrame
 775 };
 776
 777 struct enum_media_types
 778 {
 779     IEnumMediaTypes IEnumMediaTypes_iface;
 780     LONG refcount;
 781     unsigned int index;
 782 };
 783
 784 static const IEnumMediaTypesVtbl enum_media_types_vtbl;
 785
 786 static struct enum_media_types *impl_from_IEnumMediaTypes(IEnumMediaTypes *iface)
 787 {
 788     return CONTAINING_RECORD(iface, struct enum_media_types, IEnumMediaTypes_iface);
 789 }
 790
 791 static HRESULT WINAPI enum_media_types_QueryInterface(IEnumMediaTypes *iface, REFIID iid, void **out)
 792 {
 793     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 794
 795     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IEnumMediaTypes))
 796     {
 797         IEnumMediaTypes_AddRef(iface);
 798         *out = iface;
 799         return S_OK;
 800     }
 801
 802     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 803     *out = NULL;
 804     return E_NOINTERFACE;
 805 }
 806
 807 static ULONG WINAPI enum_media_types_AddRef(IEnumMediaTypes *iface)
 808 {
 809     struct enum_media_types *enum_media_types = impl_from_IEnumMediaTypes(iface);
 810     ULONG refcount = InterlockedIncrement(&enum_media_types->refcount);
 811     TRACE("%p increasing refcount to %lu.\n", enum_media_types, refcount);
 812     return refcount;
 813 }
 814
 815 static ULONG WINAPI enum_media_types_Release(IEnumMediaTypes *iface)
 816 {
 817     struct enum_media_types *enum_media_types = impl_from_IEnumMediaTypes(iface);
 818     ULONG refcount = InterlockedDecrement(&enum_media_types->refcount);
 819     TRACE("%p decreasing refcount to %lu.\n", enum_media_types, refcount);
 820     if (!refcount)
 821         free(enum_media_types);
 822     return refcount;
 823 }
 824
 825 static HRESULT WINAPI enum_media_types_Next(IEnumMediaTypes *iface, ULONG count, AM_MEDIA_TYPE **mts, ULONG *ret_count)
 826 {
 827     struct enum_media_types *enum_media_types = impl_from_IEnumMediaTypes(iface);
 828
 829     TRACE("iface %p, count %lu, mts %p, ret_count %p.\n", iface, count, mts, ret_count);
 830
 831     if (!ret_count)
 832         return E_POINTER;
 833
 834     if (count && !enum_media_types->index)
 835     {
 836         mts[0] = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
 837         memset(mts[0], 0, sizeof(AM_MEDIA_TYPE));
 838         mts[0]->majortype = MEDIATYPE_Video;
 839         mts[0]->subtype = MEDIASUBTYPE_RGB8;
 840         mts[0]->bFixedSizeSamples = TRUE;
 841         mts[0]->lSampleSize = 10000;
 842         ++enum_media_types->index;
 843         *ret_count = 1;
 844         return count == 1 ? S_OK : S_FALSE;
 845     }
 846
 847     *ret_count = 0;
 848     return count ? S_FALSE : S_OK;
 849 }
 850
 851 static HRESULT WINAPI enum_media_types_Skip(IEnumMediaTypes *iface, ULONG count)
 852 {
 853     struct enum_media_types *enum_media_types = impl_from_IEnumMediaTypes(iface);
 854
 855     TRACE("iface %p, count %lu.\n", iface, count);
 856
 857     enum_media_types->index += count;
 858
 859     return S_OK;
 860 }
 861
 862 static HRESULT WINAPI enum_media_types_Reset(IEnumMediaTypes *iface)
 863 {
 864     struct enum_media_types *enum_media_types = impl_from_IEnumMediaTypes(iface);
 865
 866     TRACE("iface %p.\n", iface);
 867
 868     enum_media_types->index = 0;
 869     return S_OK;
 870 }
 871
 872 static HRESULT WINAPI enum_media_types_Clone(IEnumMediaTypes *iface, IEnumMediaTypes **out)
 873 {
 874     struct enum_media_types *enum_media_types = impl_from_IEnumMediaTypes(iface);
 875     struct enum_media_types *object;
 876
 877     TRACE("iface %p, out %p.\n", iface, out);
 878
 879     if (!(object = calloc(1, sizeof(*object))))
 880         return E_OUTOFMEMORY;
 881
 882     object->IEnumMediaTypes_iface.lpVtbl = &enum_media_types_vtbl;
 883     object->refcount = 1;
 884     object->index = enum_media_types->index;
 885
 886     *out = &object->IEnumMediaTypes_iface;
 887     return S_OK;
 888 }
 889
 890 static const IEnumMediaTypesVtbl enum_media_types_vtbl =
 891 {
 892     enum_media_types_QueryInterface,
 893     enum_media_types_AddRef,
 894     enum_media_types_Release,
 895     enum_media_types_Next,
 896     enum_media_types_Skip,
 897     enum_media_types_Reset,
 898     enum_media_types_Clone,
 899 };
 900
 901 static inline struct ddraw_stream *impl_from_IPin(IPin *iface)
 902 {
 903     return CONTAINING_RECORD(iface, struct ddraw_stream, IPin_iface);
 904 }
 905
 906 static HRESULT WINAPI ddraw_sink_QueryInterface(IPin *iface, REFIID iid, void **out)
 907 {
 908     struct ddraw_stream *stream = impl_from_IPin(iface);
 909     return IAMMediaStream_QueryInterface(&stream->IAMMediaStream_iface, iid, out);
 910 }
 911
 912 static ULONG WINAPI ddraw_sink_AddRef(IPin *iface)
 913 {
 914     struct ddraw_stream *stream = impl_from_IPin(iface);
 915     return IAMMediaStream_AddRef(&stream->IAMMediaStream_iface);
 916 }
 917
 918 static ULONG WINAPI ddraw_sink_Release(IPin *iface)
 919 {
 920     struct ddraw_stream *stream = impl_from_IPin(iface);
 921     return IAMMediaStream_Release(&stream->IAMMediaStream_iface);
 922 }
 923
 924 static HRESULT WINAPI ddraw_sink_Connect(IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
 925 {
 926     WARN("iface %p, peer %p, mt %p, unexpected call!\n", iface, peer, mt);
 927     return E_UNEXPECTED;
 928 }
 929
 930 static HRESULT WINAPI ddraw_sink_ReceiveConnection(IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
 931 {
 932     struct ddraw_stream *stream = impl_from_IPin(iface);
 933     const VIDEOINFOHEADER *video_info;
 934     PIN_DIRECTION dir;
 935     DWORD width;
 936     DWORD height;
 937     DDPIXELFORMAT pf = {sizeof(DDPIXELFORMAT)};
 938
 939     TRACE("stream %p, peer %p, mt %p.\n", stream, peer, mt);
 940
 941     EnterCriticalSection(&stream->cs);
 942
 943     if (stream->peer)
 944     {
 945         LeaveCriticalSection(&stream->cs);
 946         return VFW_E_ALREADY_CONNECTED;
 947     }
 948
 949     if (!IsEqualGUID(&mt->majortype, &MEDIATYPE_Video)
 950             || !IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo))
 951     {
 952         LeaveCriticalSection(&stream->cs);
 953         return VFW_E_TYPE_NOT_ACCEPTED;
 954     }
 955
 956     video_info = (const VIDEOINFOHEADER *)mt->pbFormat;
 957
 958     width = video_info->bmiHeader.biWidth;
 959     height = abs(video_info->bmiHeader.biHeight);
 960     pf.dwFlags = DDPF_RGB;
 961     if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB8))
 962     {
 963         pf.dwFlags |= DDPF_PALETTEINDEXED8;
 964         pf.dwRGBBitCount = 8;
 965     }
 966     else if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB555))
 967     {
 968         pf.dwRGBBitCount = 16;
 969         pf.dwRBitMask = 0x7c00;
 970         pf.dwGBitMask = 0x03e0;
 971         pf.dwBBitMask = 0x001f;
 972     }
 973     else if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB565))
 974     {
 975         pf.dwRGBBitCount = 16;
 976         pf.dwRBitMask = 0xf800;
 977         pf.dwGBitMask = 0x07e0;
 978         pf.dwBBitMask = 0x001f;
 979     }
 980     else if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB24))
 981     {
 982         pf.dwRGBBitCount = 24;
 983         pf.dwRBitMask = 0xff0000;
 984         pf.dwGBitMask = 0x00ff00;
 985         pf.dwBBitMask = 0x0000ff;
 986     }
 987     else if (IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB32))
 988     {
 989         pf.dwRGBBitCount = 32;
 990         pf.dwRBitMask = 0xff0000;
 991         pf.dwGBitMask = 0x00ff00;
 992         pf.dwBBitMask = 0x0000ff;
 993     }
 994     else
 995     {
 996         LeaveCriticalSection(&stream->cs);
 997         return VFW_E_TYPE_NOT_ACCEPTED;
 998     }
 999
1000     if (!is_format_compatible(stream, width, height, &pf))
1001     {
1002         LeaveCriticalSection(&stream->cs);
1003         return VFW_E_TYPE_NOT_ACCEPTED;
1004     }
1005
1006     IPin_QueryDirection(peer, &dir);
1007     if (dir != PINDIR_OUTPUT)
1008     {
1009         WARN("Rejecting connection from input pin.\n");
1010         LeaveCriticalSection(&stream->cs);
1011         return VFW_E_INVALID_DIRECTION;
1012     }
1013
1014     CopyMediaType(&stream->mt, mt);
1015     IPin_AddRef(stream->peer = peer);
1016
1017     stream->format.width = width;
1018     stream->format.height = height;
1019     if (!(stream->format.flags & DDSD_PIXELFORMAT))
1020         stream->format.pf = pf;
1021
1022     LeaveCriticalSection(&stream->cs);
1023
1024     return S_OK;
1025 }
1026
1027 static HRESULT WINAPI ddraw_sink_Disconnect(IPin *iface)
1028 {
1029     struct ddraw_stream *stream = impl_from_IPin(iface);
1030
1031     TRACE("stream %p.\n", stream);
1032
1033     EnterCriticalSection(&stream->cs);
1034
1035     if (!stream->peer)
1036     {
1037         LeaveCriticalSection(&stream->cs);
1038         return S_FALSE;
1039     }
1040
1041     IPin_Release(stream->peer);
1042     stream->peer = NULL;
1043     FreeMediaType(&stream->mt);
1044     memset(&stream->mt, 0, sizeof(AM_MEDIA_TYPE));
1045
1046     LeaveCriticalSection(&stream->cs);
1047
1048     return S_OK;
1049 }
1050
1051 static HRESULT WINAPI ddraw_sink_ConnectedTo(IPin *iface, IPin **peer)
1052 {
1053     struct ddraw_stream *stream = impl_from_IPin(iface);
1054     HRESULT hr;
1055
1056     TRACE("stream %p, peer %p.\n", stream, peer);
1057
1058     EnterCriticalSection(&stream->cs);
1059
1060     if (stream->peer)
1061     {
1062         IPin_AddRef(*peer = stream->peer);
1063         hr = S_OK;
1064     }
1065     else
1066     {
1067         *peer = NULL;
1068         hr = VFW_E_NOT_CONNECTED;
1069     }
1070
1071     LeaveCriticalSection(&stream->cs);
1072
1073     return hr;
1074 }
1075
1076 static HRESULT WINAPI ddraw_sink_ConnectionMediaType(IPin *iface, AM_MEDIA_TYPE *mt)
1077 {
1078     struct ddraw_stream *stream = impl_from_IPin(iface);
1079     HRESULT hr;
1080
1081     TRACE("stream %p, mt %p.\n", stream, mt);
1082
1083     EnterCriticalSection(&stream->cs);
1084
1085     if (stream->peer)
1086     {
1087         CopyMediaType(mt, &stream->mt);
1088         hr = S_OK;
1089     }
1090     else
1091     {
1092         memset(mt, 0, sizeof(AM_MEDIA_TYPE));
1093         hr = VFW_E_NOT_CONNECTED;
1094     }
1095
1096     LeaveCriticalSection(&stream->cs);
1097
1098     return hr;
1099 }
1100
1101 static HRESULT WINAPI ddraw_sink_QueryPinInfo(IPin *iface, PIN_INFO *info)
1102 {
1103     struct ddraw_stream *stream = impl_from_IPin(iface);
1104
1105     TRACE("stream %p, info %p.\n", stream, info);
1106
1107     IBaseFilter_AddRef(info->pFilter = (IBaseFilter *)stream->filter);
1108     info->dir = PINDIR_INPUT;
1109     wcscpy(info->achName, sink_id);
1110
1111     return S_OK;
1112 }
1113
1114 static HRESULT WINAPI ddraw_sink_QueryDirection(IPin *iface, PIN_DIRECTION *dir)
1115 {
1116     TRACE("iface %p, dir %p.\n", iface, dir);
1117     *dir = PINDIR_INPUT;
1118     return S_OK;
1119 }
1120
1121 static HRESULT WINAPI ddraw_sink_QueryId(IPin *iface, WCHAR **id)
1122 {
1123     TRACE("iface %p, id %p.\n", iface, id);
1124
1125     if (!(*id = CoTaskMemAlloc(sizeof(sink_id))))
1126         return E_OUTOFMEMORY;
1127
1128     wcscpy(*id, sink_id);
1129
1130     return S_OK;
1131 }
1132
1133 static HRESULT WINAPI ddraw_sink_QueryAccept(IPin *iface, const AM_MEDIA_TYPE *mt)
1134 {
1135     TRACE("iface %p, mt %p.\n", iface, mt);
1136
1137     if (IsEqualGUID(&mt->majortype, &MEDIATYPE_Video)
1138             && IsEqualGUID(&mt->subtype, &MEDIASUBTYPE_RGB8)
1139             && IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo))
1140         return S_OK;
1141
1142     return VFW_E_TYPE_NOT_ACCEPTED;
1143 }
1144
1145 static HRESULT WINAPI ddraw_sink_EnumMediaTypes(IPin *iface, IEnumMediaTypes **enum_media_types)
1146 {
1147     struct enum_media_types *object;
1148
1149     TRACE("iface %p, enum_media_types %p.\n", iface, enum_media_types);
1150
1151     if (!enum_media_types)
1152         return E_POINTER;
1153
1154     if (!(object = calloc(1, sizeof(*object))))
1155         return E_OUTOFMEMORY;
1156
1157     object->IEnumMediaTypes_iface.lpVtbl = &enum_media_types_vtbl;
1158     object->refcount = 1;
1159     object->index = 0;
1160
1161     *enum_media_types = &object->IEnumMediaTypes_iface;
1162     return S_OK;
1163 }
1164
1165 static HRESULT WINAPI ddraw_sink_QueryInternalConnections(IPin *iface, IPin **pins, ULONG *count)
1166 {
1167     TRACE("iface %p, pins %p, count %p.\n", iface, pins, count);
1168     return E_NOTIMPL;
1169 }
1170
1171 static HRESULT WINAPI ddraw_sink_EndOfStream(IPin *iface)
1172 {
1173     struct ddraw_stream *stream = impl_from_IPin(iface);
1174
1175     TRACE("stream %p.\n", stream);
1176
1177     EnterCriticalSection(&stream->cs);
1178
1179     if (stream->eos || stream->flushing)
1180     {
1181         LeaveCriticalSection(&stream->cs);
1182         return E_FAIL;
1183     }
1184
1185     stream->eos = TRUE;
1186
1187     flush_update_queue(stream, MS_S_ENDOFSTREAM);
1188
1189     LeaveCriticalSection(&stream->cs);
1190
1191     /* Calling IMediaStreamFilter::EndOfStream() inside the critical section
1192      * would invert the locking order, so we must leave it first to avoid
1193      * the streaming thread deadlocking on the filter's critical section. */
1194     IMediaStreamFilter_EndOfStream(stream->filter);
1195
1196     return S_OK;
1197 }
1198
1199 static HRESULT WINAPI ddraw_sink_BeginFlush(IPin *iface)
1200 {
1201     struct ddraw_stream *stream = impl_from_IPin(iface);
1202     BOOL cancel_eos;
1203
1204     TRACE("stream %p.\n", stream);
1205
1206     EnterCriticalSection(&stream->cs);
1207
1208     cancel_eos = stream->eos;
1209
1210     stream->flushing = TRUE;
1211     stream->eos = FALSE;
1212     WakeConditionVariable(&stream->update_queued_cv);
1213
1214     LeaveCriticalSection(&stream->cs);
1215
1216     /* Calling IMediaStreamFilter::Flush() inside the critical section would
1217      * invert the locking order, so we must leave it first to avoid the
1218      * application thread deadlocking on the filter's critical section. */
1219     IMediaStreamFilter_Flush(stream->filter, cancel_eos);
1220
1221     return S_OK;
1222 }
1223
1224 static HRESULT WINAPI ddraw_sink_EndFlush(IPin *iface)
1225 {
1226     struct ddraw_stream *stream = impl_from_IPin(iface);
1227
1228     TRACE("stream %p.\n", stream);
1229
1230     EnterCriticalSection(&stream->cs);
1231
1232     stream->flushing = FALSE;
1233
1234     LeaveCriticalSection(&stream->cs);
1235
1236     return S_OK;
1237 }
1238
1239 static HRESULT WINAPI ddraw_sink_NewSegment(IPin *iface, REFERENCE_TIME start, REFERENCE_TIME stop, double rate)
1240 {
1241     struct ddraw_stream *stream = impl_from_IPin(iface);
1242
1243     TRACE("stream %p, start %s, stop %s, rate %0.16e\n",
1244             stream, wine_dbgstr_longlong(start), wine_dbgstr_longlong(stop), rate);
1245
1246     EnterCriticalSection(&stream->cs);
1247
1248     stream->segment_start = start;
1249
1250     LeaveCriticalSection(&stream->cs);
1251
1252     return S_OK;
1253 }
1254
1255 static const IPinVtbl ddraw_sink_vtbl =
1256 {
1257     ddraw_sink_QueryInterface,
1258     ddraw_sink_AddRef,
1259     ddraw_sink_Release,
1260     ddraw_sink_Connect,
1261     ddraw_sink_ReceiveConnection,
1262     ddraw_sink_Disconnect,
1263     ddraw_sink_ConnectedTo,
1264     ddraw_sink_ConnectionMediaType,
1265     ddraw_sink_QueryPinInfo,
1266     ddraw_sink_QueryDirection,
1267     ddraw_sink_QueryId,
1268     ddraw_sink_QueryAccept,
1269     ddraw_sink_EnumMediaTypes,
1270     ddraw_sink_QueryInternalConnections,
1271     ddraw_sink_EndOfStream,
1272     ddraw_sink_BeginFlush,
1273     ddraw_sink_EndFlush,
1274     ddraw_sink_NewSegment,
1275 };
1276
1277 static inline struct ddraw_stream *impl_from_IMemInputPin(IMemInputPin *iface)
1278 {
1279     return CONTAINING_RECORD(iface, struct ddraw_stream, IMemInputPin_iface);
1280 }
1281
1282 static HRESULT WINAPI ddraw_meminput_QueryInterface(IMemInputPin *iface, REFIID iid, void **out)
1283 {
1284     struct ddraw_stream *stream = impl_from_IMemInputPin(iface);
1285     return IAMMediaStream_QueryInterface(&stream->IAMMediaStream_iface, iid, out);
1286 }
1287
1288 static ULONG WINAPI ddraw_meminput_AddRef(IMemInputPin *iface)
1289 {
1290     struct ddraw_stream *stream = impl_from_IMemInputPin(iface);
1291     return IAMMediaStream_AddRef(&stream->IAMMediaStream_iface);
1292 }
1293
1294 static ULONG WINAPI ddraw_meminput_Release(IMemInputPin *iface)
1295 {
1296     struct ddraw_stream *stream = impl_from_IMemInputPin(iface);
1297     return IAMMediaStream_Release(&stream->IAMMediaStream_iface);
1298 }
1299
1300 static HRESULT WINAPI ddraw_meminput_GetAllocator(IMemInputPin *iface, IMemAllocator **allocator)
1301 {
1302     struct ddraw_stream *stream = impl_from_IMemInputPin(iface);
1303
1304     TRACE("stream %p, allocator %p.\n", stream, allocator);
1305
1306     if (stream->allocator)
1307     {
1308         IMemAllocator_AddRef(*allocator = stream->allocator);
1309         return S_OK;
1310     }
1311
1312     *allocator = NULL;
1313     return VFW_E_NO_ALLOCATOR;
1314 }
1315
1316 static HRESULT WINAPI ddraw_meminput_NotifyAllocator(IMemInputPin *iface, IMemAllocator *allocator, BOOL readonly)
1317 {
1318     struct ddraw_stream *stream = impl_from_IMemInputPin(iface);
1319
1320     TRACE("stream %p, allocator %p, readonly %d.\n", stream, allocator, readonly);
1321
1322     if (!allocator)
1323         return E_POINTER;
1324
1325     if (allocator)
1326         IMemAllocator_AddRef(allocator);
1327     if (stream->allocator)
1328         IMemAllocator_Release(stream->allocator);
1329     stream->allocator = allocator;
1330
1331     return S_OK;
1332 }
1333
1334 static HRESULT WINAPI ddraw_meminput_GetAllocatorRequirements(IMemInputPin *iface, ALLOCATOR_PROPERTIES *props)
1335 {
1336     TRACE("iface %p, props %p.\n", iface, props);
1337     return E_NOTIMPL;
1338 }
1339
1340 static HRESULT WINAPI ddraw_meminput_Receive(IMemInputPin *iface, IMediaSample *sample)
1341 {
1342     struct ddraw_stream *stream = impl_from_IMemInputPin(iface);
1343     BITMAPINFOHEADER *bitmap_info;
1344     REFERENCE_TIME start_time = 0;
1345     REFERENCE_TIME end_time = 0;
1346     STREAM_TIME start_stream_time;
1347     STREAM_TIME end_stream_time;
1348     IMediaStreamFilter *filter;
1349     STREAM_TIME current_time;
1350     BYTE *top_down_pointer;
1351     int top_down_stride;
1352     BYTE *pointer;
1353     BOOL top_down;
1354     int stride;
1355     HRESULT hr;
1356
1357     TRACE("stream %p, sample %p.\n", stream, sample);
1358
1359     hr = IMediaSample_GetPointer(sample, &pointer);
1360     if (FAILED(hr))
1361         return hr;
1362
1363     IMediaSample_GetTime(sample, &start_time, &end_time);
1364
1365     EnterCriticalSection(&stream->cs);
1366
1367     if (stream->state == State_Stopped)
1368     {
1369         LeaveCriticalSection(&stream->cs);
1370         return S_OK;
1371     }
1372     if (stream->flushing)
1373     {
1374         LeaveCriticalSection(&stream->cs);
1375         return S_FALSE;
1376     }
1377
1378     bitmap_info = &((VIDEOINFOHEADER *)stream->mt.pbFormat)->bmiHeader;
1379
1380     stride = ((bitmap_info->biWidth * bitmap_info->biBitCount + 31) & ~31) / 8;
1381     top_down = (bitmap_info->biHeight < 0);
1382
1383     top_down_stride = top_down ? stride : -stride;
1384     top_down_pointer = top_down ? pointer : pointer + stride * (bitmap_info->biHeight - 1);
1385
1386     start_stream_time = start_time + stream->segment_start;
1387     end_stream_time = end_time + stream->segment_start;
1388
1389     filter = stream->filter;
1390
1391     LeaveCriticalSection(&stream->cs);
1392     if (S_OK == IMediaStreamFilter_GetCurrentStreamTime(filter, &current_time)
1393             && start_time >= current_time + 10000)
1394         IMediaStreamFilter_WaitUntil(filter, start_time);
1395     EnterCriticalSection(&stream->cs);
1396
1397     for (;;)
1398     {
1399         if (stream->state == State_Stopped)
1400         {
1401             LeaveCriticalSection(&stream->cs);
1402             return S_OK;
1403         }
1404         if (stream->flushing)
1405         {
1406             LeaveCriticalSection(&stream->cs);
1407             return S_FALSE;
1408         }
1409         if (!list_empty(&stream->update_queue))
1410         {
1411             struct ddraw_sample *sample = LIST_ENTRY(list_head(&stream->update_queue), struct ddraw_sample, entry);
1412
1413             sample->update_hr = process_update(sample, top_down_stride, top_down_pointer,
1414                     start_stream_time, end_stream_time);
1415
1416             if (sample->continuous_update && SUCCEEDED(sample->update_hr))
1417             {
1418                 list_remove(&sample->entry);
1419                 list_add_tail(&sample->parent->update_queue, &sample->entry);
1420             }
1421             else
1422             {
1423                 remove_queued_update(sample);
1424             }
1425             LeaveCriticalSection(&stream->cs);
1426             return S_OK;
1427         }
1428
1429         SleepConditionVariableCS(&stream->update_queued_cv, &stream->cs, INFINITE);
1430     }
1431 }
1432
1433 static HRESULT WINAPI ddraw_meminput_ReceiveMultiple(IMemInputPin *iface,
1434         IMediaSample **samples, LONG count, LONG *processed)
1435 {
1436     FIXME("iface %p, samples %p, count %lu, processed %p, stub!\n", iface, samples, count, processed);
1437     return E_NOTIMPL;
1438 }
1439
1440 static HRESULT WINAPI ddraw_meminput_ReceiveCanBlock(IMemInputPin *iface)
1441 {
1442     TRACE("iface %p.\n", iface);
1443     return S_OK;
1444 }
1445
1446 static const IMemInputPinVtbl ddraw_meminput_vtbl =
1447 {
1448     ddraw_meminput_QueryInterface,
1449     ddraw_meminput_AddRef,
1450     ddraw_meminput_Release,
1451     ddraw_meminput_GetAllocator,
1452     ddraw_meminput_NotifyAllocator,
1453     ddraw_meminput_GetAllocatorRequirements,
1454     ddraw_meminput_Receive,
1455     ddraw_meminput_ReceiveMultiple,
1456     ddraw_meminput_ReceiveCanBlock,
1457 };
1458
1459 HRESULT ddraw_stream_create(IUnknown *outer, void **out)
1460 {
1461     struct ddraw_stream *object;
1462
1463     if (outer)
1464         return CLASS_E_NOAGGREGATION;
1465
1466     if (!(object = calloc(1, sizeof(*object))))
1467         return E_OUTOFMEMORY;
1468
1469     object->IAMMediaStream_iface.lpVtbl = &ddraw_IAMMediaStream_vtbl;
1470     object->IDirectDrawMediaStream_iface.lpVtbl = &ddraw_IDirectDrawMediaStream_Vtbl;
1471     object->IMemInputPin_iface.lpVtbl = &ddraw_meminput_vtbl;
1472     object->IPin_iface.lpVtbl = &ddraw_sink_vtbl;
1473     object->ref = 1;
1474
1475     object->format.width = 100;
1476     object->format.height = 100;
1477
1478     InitializeCriticalSection(&object->cs);
1479     InitializeConditionVariable(&object->update_queued_cv);
1480     list_init(&object->update_queue);
1481
1482     TRACE("Created ddraw stream %p.\n", object);
1483
1484     *out = &object->IAMMediaStream_iface;
1485
1486     return S_OK;
1487 }
1488
1489 static inline struct ddraw_sample *impl_from_IDirectDrawStreamSample(IDirectDrawStreamSample *iface)
1490 {
1491     return CONTAINING_RECORD(iface, struct ddraw_sample, IDirectDrawStreamSample_iface);
1492 }
1493
1494 /*** IUnknown methods ***/
1495 static HRESULT WINAPI ddraw_sample_QueryInterface(IDirectDrawStreamSample *iface,
1496         REFIID riid, void **ret_iface)
1497 {
1498     TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(riid), ret_iface);
1499
1500     if (IsEqualGUID(riid, &IID_IUnknown) ||
1501         IsEqualGUID(riid, &IID_IStreamSample) ||
1502         IsEqualGUID(riid, &IID_IDirectDrawStreamSample))
1503     {
1504         IDirectDrawStreamSample_AddRef(iface);
1505         *ret_iface = iface;
1506         return S_OK;
1507     }
1508
1509     *ret_iface = NULL;
1510
1511     ERR("(%p)->(%s,%p),not found\n", iface, debugstr_guid(riid), ret_iface);
1512     return E_NOINTERFACE;
1513 }
1514
1515 static ULONG WINAPI ddraw_sample_AddRef(IDirectDrawStreamSample *iface)
1516 {
1517     struct ddraw_sample *sample = impl_from_IDirectDrawStreamSample(iface);
1518     ULONG ref = InterlockedIncrement(&sample->ref);
1519
1520     TRACE("(%p)->(): new ref = %lu\n", iface, ref);
1521
1522     return ref;
1523 }
1524
1525 static ULONG WINAPI ddraw_sample_Release(IDirectDrawStreamSample *iface)
1526 {
1527     struct ddraw_sample *sample = impl_from_IDirectDrawStreamSample(iface);
1528     ULONG ref = InterlockedDecrement(&sample->ref);
1529
1530     TRACE("(%p)->(): new ref = %lu\n", iface, ref);
1531
1532     if (!ref)
1533     {
1534         EnterCriticalSection(&sample->parent->cs);
1535         --sample->parent->sample_refs;
1536         LeaveCriticalSection(&sample->parent->cs);
1537
1538         if (sample->mmstream)
1539             IMultiMediaStream_Release(sample->mmstream);
1540         IAMMediaStream_Release(&sample->parent->IAMMediaStream_iface);
1541
1542         if (sample->surface)
1543             IDirectDrawSurface_Release(sample->surface);
1544         free(sample);
1545     }
1546
1547     return ref;
1548 }
1549
1550 /*** IStreamSample methods ***/
1551 static HRESULT WINAPI ddraw_sample_GetMediaStream(IDirectDrawStreamSample *iface, IMediaStream **media_stream)
1552 {
1553     struct ddraw_sample *sample = impl_from_IDirectDrawStreamSample(iface);
1554
1555     TRACE("sample %p, media_stream %p.\n", sample, media_stream);
1556
1557     if (!media_stream)
1558         return E_POINTER;
1559
1560     IAMMediaStream_AddRef(&sample->parent->IAMMediaStream_iface);
1561     *media_stream = (IMediaStream *)&sample->parent->IAMMediaStream_iface;
1562
1563     return S_OK;
1564 }
1565
1566 static HRESULT WINAPI ddraw_sample_GetSampleTimes(IDirectDrawStreamSample *iface, STREAM_TIME *start_time,
1567                                                                  STREAM_TIME *end_time, STREAM_TIME *current_time)
1568 {
1569     struct ddraw_sample *sample = impl_from_IDirectDrawStreamSample(iface);
1570
1571     TRACE("sample %p, start_time %p, end_time %p, current_time %p.\n", sample, start_time, end_time, current_time);
1572
1573     if (current_time)
1574         IMediaStreamFilter_GetCurrentStreamTime(sample->parent->filter, current_time);
1575
1576     if (start_time)
1577         *start_time = sample->start_time;
1578     if (end_time)
1579         *end_time = sample->end_time;
1580
1581     return S_OK;
1582 }
1583
1584 static HRESULT WINAPI ddraw_sample_SetSampleTimes(IDirectDrawStreamSample *iface, const STREAM_TIME *start_time,
1585                                                                  const STREAM_TIME *end_time)
1586 {
1587     FIXME("(%p)->(%p,%p): stub\n", iface, start_time, end_time);
1588
1589     return E_NOTIMPL;
1590 }
1591
1592 static HRESULT WINAPI ddraw_sample_Update(IDirectDrawStreamSample *iface,
1593         DWORD flags, HANDLE event, PAPCFUNC apc_func, DWORD apc_data)
1594 {
1595     struct ddraw_sample *sample = impl_from_IDirectDrawStreamSample(iface);
1596
1597     TRACE("sample %p, flags %#lx, event %p, apc_func %p, apc_data %#lx.\n",
1598             sample, flags, event, apc_func, apc_data);
1599
1600     if (event && apc_func)
1601         return E_INVALIDARG;
1602
1603     if (apc_func)
1604     {
1605         FIXME("APC support is not implemented!\n");
1606         return E_NOTIMPL;
1607     }
1608
1609     EnterCriticalSection(&sample->parent->cs);
1610
1611     if (sample->parent->state != State_Running)
1612     {
1613         LeaveCriticalSection(&sample->parent->cs);
1614         return MS_E_NOTRUNNING;
1615     }
1616     if (!sample->parent->peer || sample->parent->eos)
1617     {
1618         sample->update_hr = MS_S_ENDOFSTREAM;
1619         LeaveCriticalSection(&sample->parent->cs);
1620         return MS_S_ENDOFSTREAM;
1621     }
1622     if (sample->busy)
1623     {
1624         LeaveCriticalSection(&sample->parent->cs);
1625         return MS_E_BUSY;
1626     }
1627
1628     sample->continuous_update = (flags & SSUPDATE_ASYNC) && (flags & SSUPDATE_CONTINUOUS);
1629
1630     sample->update_hr = MS_S_NOUPDATE;
1631     sample->busy = TRUE;
1632     sample->external_event = event;
1633     list_add_tail(&sample->parent->update_queue, &sample->entry);
1634     WakeConditionVariable(&sample->parent->update_queued_cv);
1635
1636     if ((flags & SSUPDATE_ASYNC) || event)
1637     {
1638         LeaveCriticalSection(&sample->parent->cs);
1639         return MS_S_PENDING;
1640     }
1641
1642     while (sample->busy)
1643         SleepConditionVariableCS(&sample->update_cv, &sample->parent->cs, INFINITE);
1644
1645     LeaveCriticalSection(&sample->parent->cs);
1646
1647     return sample->update_hr;
1648 }
1649
1650 static HRESULT WINAPI ddraw_sample_CompletionStatus(IDirectDrawStreamSample *iface, DWORD flags, DWORD milliseconds)
1651 {
1652     struct ddraw_sample *sample = impl_from_IDirectDrawStreamSample(iface);
1653     HRESULT hr;
1654
1655     TRACE("sample %p, flags %#lx, milliseconds %lu.\n", sample, flags, milliseconds);
1656
1657     EnterCriticalSection(&sample->parent->cs);
1658
1659     if (sample->busy)
1660     {
1661         if (flags & (COMPSTAT_NOUPDATEOK | COMPSTAT_ABORT))
1662         {
1663             remove_queued_update(sample);
1664         }
1665         else if (flags & COMPSTAT_WAIT)
1666         {
1667             DWORD start_time = GetTickCount();
1668             DWORD elapsed = 0;
1669             sample->continuous_update = FALSE;
1670             while (sample->busy && elapsed < milliseconds)
1671             {
1672                 DWORD sleep_time = milliseconds - elapsed;
1673                 if (!SleepConditionVariableCS(&sample->update_cv, &sample->parent->cs, sleep_time))
1674                     break;
1675                 elapsed = GetTickCount() - start_time;
1676             }
1677         }
1678     }
1679
1680     hr = sample->busy ? MS_S_PENDING : sample->update_hr;
1681
1682     LeaveCriticalSection(&sample->parent->cs);
1683
1684     return hr;
1685 }
1686
1687 /*** IDirectDrawStreamSample methods ***/
1688 static HRESULT WINAPI ddraw_sample_GetSurface(IDirectDrawStreamSample *iface, IDirectDrawSurface **ddraw_surface,
1689                                                              RECT *rect)
1690 {
1691     struct ddraw_sample *sample = impl_from_IDirectDrawStreamSample(iface);
1692
1693     TRACE("(%p)->(%p,%p)\n", iface, ddraw_surface, rect);
1694
1695     if (ddraw_surface)
1696     {
1697         *ddraw_surface = sample->surface;
1698         if (*ddraw_surface)
1699             IDirectDrawSurface_AddRef(*ddraw_surface);
1700     }
1701
1702     if (rect)
1703         *rect = sample->rect;
1704
1705     return S_OK;
1706 }
1707
1708 static HRESULT WINAPI ddraw_sample_SetRect(IDirectDrawStreamSample *iface, const RECT *rect)
1709 {
1710     FIXME("(%p)->(%p): stub\n", iface, rect);
1711
1712     return E_NOTIMPL;
1713 }
1714
1715 static const struct IDirectDrawStreamSampleVtbl DirectDrawStreamSample_Vtbl =
1716 {
1717     /*** IUnknown methods ***/
1718     ddraw_sample_QueryInterface,
1719     ddraw_sample_AddRef,
1720     ddraw_sample_Release,
1721     /*** IStreamSample methods ***/
1722     ddraw_sample_GetMediaStream,
1723     ddraw_sample_GetSampleTimes,
1724     ddraw_sample_SetSampleTimes,
1725     ddraw_sample_Update,
1726     ddraw_sample_CompletionStatus,
1727     /*** IDirectDrawStreamSample methods ***/
1728     ddraw_sample_GetSurface,
1729     ddraw_sample_SetRect
1730 };
1731
1732 static HRESULT ddrawstreamsample_create(struct ddraw_stream *parent, IDirectDrawSurface *surface,
1733     const RECT *rect, IDirectDrawStreamSample **ddraw_stream_sample)
1734 {
1735     struct ddraw_sample *object;
1736     DDSURFACEDESC desc;
1737     HRESULT hr;
1738
1739     TRACE("(%p)\n", ddraw_stream_sample);
1740
1741     if (!(object = calloc(1, sizeof(*object))))
1742         return E_OUTOFMEMORY;
1743
1744     object->IDirectDrawStreamSample_iface.lpVtbl = &DirectDrawStreamSample_Vtbl;
1745     object->ref = 1;
1746     object->parent = parent;
1747     object->mmstream = parent->parent;
1748     InitializeConditionVariable(&object->update_cv);
1749     IAMMediaStream_AddRef(&parent->IAMMediaStream_iface);
1750     if (object->mmstream)
1751         IMultiMediaStream_AddRef(object->mmstream);
1752     ++parent->sample_refs;
1753
1754     if (surface)
1755     {
1756         object->surface = surface;
1757         IDirectDrawSurface_AddRef(surface);
1758     }
1759     else
1760     {
1761         IDirectDraw *ddraw;
1762
1763         hr = IDirectDrawMediaStream_GetDirectDraw(&parent->IDirectDrawMediaStream_iface, &ddraw);
1764         if (FAILED(hr))
1765         {
1766             IDirectDrawStreamSample_Release(&object->IDirectDrawStreamSample_iface);
1767             return hr;
1768         }
1769
1770         desc.dwSize = sizeof(desc);
1771         desc.dwFlags = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;
1772         desc.dwHeight = parent->format.height;
1773         desc.dwWidth = parent->format.width;
1774         if (parent->format.flags & DDSD_PIXELFORMAT)
1775         {
1776             desc.ddpfPixelFormat = parent->format.pf;
1777         }
1778         else
1779         {
1780             desc.ddpfPixelFormat.dwSize = sizeof(desc.ddpfPixelFormat);
1781             desc.ddpfPixelFormat.dwFlags = DDPF_RGB;
1782             desc.ddpfPixelFormat.dwRGBBitCount = 32;
1783             desc.ddpfPixelFormat.dwRBitMask = 0xff0000;
1784             desc.ddpfPixelFormat.dwGBitMask = 0x00ff00;
1785             desc.ddpfPixelFormat.dwBBitMask = 0x0000ff;
1786             desc.ddpfPixelFormat.dwRGBAlphaBitMask = 0;
1787         }
1788         desc.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY|DDSCAPS_OFFSCREENPLAIN;
1789         desc.lpSurface = NULL;
1790
1791         hr = IDirectDraw_CreateSurface(ddraw, &desc, &object->surface, NULL);
1792         IDirectDraw_Release(ddraw);
1793         if (FAILED(hr))
1794         {
1795             ERR("failed to create surface, 0x%08lx\n", hr);
1796             IDirectDrawStreamSample_Release(&object->IDirectDrawStreamSample_iface);
1797             return hr;
1798         }
1799     }
1800
1801     desc.dwSize = sizeof(desc);
1802     hr = IDirectDrawSurface_GetSurfaceDesc(object->surface, &desc);
1803     if (FAILED(hr))
1804     {
1805         IDirectDrawStreamSample_Release(&object->IDirectDrawStreamSample_iface);
1806         return hr;
1807     }
1808
1809     if (rect)
1810     {
1811         object->rect = *rect;
1812         desc.dwWidth = rect->right - rect->left;
1813         desc.dwHeight = rect->bottom - rect->top;
1814     }
1815     else
1816     {
1817         SetRect(&object->rect, 0, 0, desc.dwWidth, desc.dwHeight);
1818     }
1819
1820     hr = IDirectDrawMediaStream_SetFormat(&parent->IDirectDrawMediaStream_iface, &desc, NULL);
1821     if (FAILED(hr))
1822     {
1823         IDirectDrawStreamSample_Release(&object->IDirectDrawStreamSample_iface);
1824         return hr;
1825     }
1826
1827     *ddraw_stream_sample = &object->IDirectDrawStreamSample_iface;
1828
1829     return S_OK;
1830 }