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