dlls/amstream/mediastream.c

   1 /*
   2  * Implementation of IMediaStream Interfaces
   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 NONAMELESSSTRUCT
  23 #define COBJMACROS
  24
  25 #include <stdarg.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "dshow.h"
  30
  31 #include "wine/strmbase.h"
  32
  33 #include "amstream_private.h"
  34
  35 #include "ddstream.h"
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(amstream);
  39
  40 static HRESULT ddrawstreamsample_create(IDirectDrawMediaStream *parent, IDirectDrawSurface *surface,
  41     const RECT *rect, IDirectDrawStreamSample **ddraw_stream_sample);
  42 static HRESULT audiostreamsample_create(IAudioMediaStream *parent, IAudioData *audio_data, IAudioStreamSample **audio_stream_sample);
  43
  44 struct DirectDrawMediaStreamImpl;
  45
  46 typedef struct {
  47     BaseInputPin pin;
  48     struct DirectDrawMediaStreamImpl *parent;
  49 } DirectDrawMediaStreamInputPin;
  50
  51 typedef struct DirectDrawMediaStreamImpl {
  52     IAMMediaStream IAMMediaStream_iface;
  53     IDirectDrawMediaStream IDirectDrawMediaStream_iface;
  54     LONG ref;
  55     IMultiMediaStream* parent;
  56     MSPID purpose_id;
  57     STREAM_TYPE stream_type;
  58     IDirectDraw7 *ddraw;
  59     DirectDrawMediaStreamInputPin *input_pin;
  60     CRITICAL_SECTION critical_section;
  61 } DirectDrawMediaStreamImpl;
  62
  63 static inline DirectDrawMediaStreamImpl *impl_from_DirectDrawMediaStream_IAMMediaStream(IAMMediaStream *iface)
  64 {
  65     return CONTAINING_RECORD(iface, DirectDrawMediaStreamImpl, IAMMediaStream_iface);
  66 }
  67
  68 /*** IUnknown methods ***/
  69 static HRESULT WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_QueryInterface(IAMMediaStream *iface,
  70                                                         REFIID riid, void **ret_iface)
  71 {
  72     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
  73
  74     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ret_iface);
  75
  76     if (IsEqualGUID(riid, &IID_IUnknown) ||
  77         IsEqualGUID(riid, &IID_IMediaStream) ||
  78         IsEqualGUID(riid, &IID_IAMMediaStream))
  79     {
  80         IAMMediaStream_AddRef(iface);
  81         *ret_iface = iface;
  82         return S_OK;
  83     }
  84     else if (IsEqualGUID(riid, &IID_IDirectDrawMediaStream))
  85     {
  86         IAMMediaStream_AddRef(iface);
  87         *ret_iface = &This->IDirectDrawMediaStream_iface;
  88         return S_OK;
  89     }
  90     else if (IsEqualGUID(riid, &IID_IPin))
  91     {
  92         IAMMediaStream_AddRef(iface);
  93         *ret_iface = &This->input_pin->pin.pin.IPin_iface;
  94         return S_OK;
  95     }
  96     else if (IsEqualGUID(riid, &IID_IMemInputPin))
  97     {
  98         IAMMediaStream_AddRef(iface);
  99         *ret_iface = &This->input_pin->pin.IMemInputPin_iface;
 100         return S_OK;
 101     }
 102
 103     ERR("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ret_iface);
 104     return E_NOINTERFACE;
 105 }
 106
 107 static ULONG WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_AddRef(IAMMediaStream *iface)
 108 {
 109     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 110     ULONG ref = InterlockedIncrement(&This->ref);
 111
 112     TRACE("(%p/%p)->(): new ref = %u\n", iface, This, ref);
 113
 114     return ref;
 115 }
 116
 117 static ULONG WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_Release(IAMMediaStream *iface)
 118 {
 119     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 120     ULONG ref = InterlockedDecrement(&This->ref);
 121
 122     TRACE("(%p/%p)->(): new ref = %u\n", iface, This, ref);
 123
 124     if (!ref)
 125     {
 126         BaseInputPin_Destroy((BaseInputPin *)This->input_pin);
 127         DeleteCriticalSection(&This->critical_section);
 128         if (This->ddraw)
 129             IDirectDraw7_Release(This->ddraw);
 130         HeapFree(GetProcessHeap(), 0, This);
 131     }
 132
 133     return ref;
 134 }
 135
 136 /*** IMediaStream methods ***/
 137 static HRESULT WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_GetMultiMediaStream(IAMMediaStream *iface,
 138         IMultiMediaStream** multi_media_stream)
 139 {
 140     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 141
 142     TRACE("(%p/%p)->(%p)\n", This, iface, multi_media_stream);
 143
 144     if (!multi_media_stream)
 145         return E_POINTER;
 146
 147     IMultiMediaStream_AddRef(This->parent);
 148     *multi_media_stream = This->parent;
 149
 150     return S_OK;
 151 }
 152
 153 static HRESULT WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_GetInformation(IAMMediaStream *iface,
 154         MSPID *purpose_id, STREAM_TYPE *type)
 155 {
 156     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 157
 158     TRACE("(%p/%p)->(%p,%p)\n", This, iface, purpose_id, type);
 159
 160     if (purpose_id)
 161         *purpose_id = This->purpose_id;
 162     if (type)
 163         *type = This->stream_type;
 164
 165     return S_OK;
 166 }
 167
 168 static HRESULT WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_SetSameFormat(IAMMediaStream *iface,
 169         IMediaStream *pStreamThatHasDesiredFormat, DWORD flags)
 170 {
 171     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 172
 173     FIXME("(%p/%p)->(%p,%x) stub!\n", This, iface, pStreamThatHasDesiredFormat, flags);
 174
 175     return S_FALSE;
 176 }
 177
 178 static HRESULT WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_AllocateSample(IAMMediaStream *iface,
 179         DWORD flags, IStreamSample **sample)
 180 {
 181     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 182
 183     FIXME("(%p/%p)->(%x,%p) stub!\n", This, iface, flags, sample);
 184
 185     return S_FALSE;
 186 }
 187
 188 static HRESULT WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_CreateSharedSample(IAMMediaStream *iface,
 189         IStreamSample *existing_sample, DWORD flags, IStreamSample **sample)
 190 {
 191     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 192
 193     FIXME("(%p/%p)->(%p,%x,%p) stub!\n", This, iface, existing_sample, flags, sample);
 194
 195     return S_FALSE;
 196 }
 197
 198 static HRESULT WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_SendEndOfStream(IAMMediaStream *iface, DWORD flags)
 199 {
 200     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 201
 202     FIXME("(%p/%p)->(%x) stub!\n", This, iface, flags);
 203
 204     return S_FALSE;
 205 }
 206
 207 /*** IAMMediaStream methods ***/
 208 static HRESULT WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_Initialize(IAMMediaStream *iface, IUnknown *source_object, DWORD flags,
 209                                                     REFMSPID purpose_id, const STREAM_TYPE stream_type)
 210 {
 211     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 212
 213     FIXME("(%p/%p)->(%p,%x,%p,%u) stub!\n", This, iface, source_object, flags, purpose_id, stream_type);
 214
 215     return S_FALSE;
 216 }
 217
 218 static HRESULT WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_SetState(IAMMediaStream *iface, FILTER_STATE state)
 219 {
 220     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 221
 222     FIXME("(%p/%p)->(%u) stub!\n", This, iface, state);
 223
 224     return S_FALSE;
 225 }
 226
 227 static HRESULT WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_JoinAMMultiMediaStream(IAMMediaStream *iface, IAMMultiMediaStream *am_multi_media_stream)
 228 {
 229     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 230
 231     FIXME("(%p/%p)->(%p) stub!\n", This, iface, am_multi_media_stream);
 232
 233     return S_FALSE;
 234 }
 235
 236 static HRESULT WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_JoinFilter(IAMMediaStream *iface, IMediaStreamFilter *media_stream_filter)
 237 {
 238     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 239
 240     TRACE("(%p/%p)->(%p)\n", This, iface, media_stream_filter);
 241
 242     This->input_pin->pin.pin.pinInfo.pFilter = (IBaseFilter *)media_stream_filter;
 243
 244     return S_OK;
 245 }
 246
 247 static HRESULT WINAPI DirectDrawMediaStreamImpl_IAMMediaStream_JoinFilterGraph(IAMMediaStream *iface, IFilterGraph *filtergraph)
 248 {
 249     DirectDrawMediaStreamImpl *This = impl_from_DirectDrawMediaStream_IAMMediaStream(iface);
 250
 251     FIXME("(%p/%p)->(%p) stub!\n", This, iface, filtergraph);
 252
 253     return S_FALSE;
 254 }
 255
 256 static const struct IAMMediaStreamVtbl DirectDrawMediaStreamImpl_IAMMediaStream_Vtbl =
 257 {
 258     /*** IUnknown methods ***/
 259     DirectDrawMediaStreamImpl_IAMMediaStream_QueryInterface,
 260     DirectDrawMediaStreamImpl_IAMMediaStream_AddRef,
 261     DirectDrawMediaStreamImpl_IAMMediaStream_Release,
 262     /*** IMediaStream methods ***/
 263     DirectDrawMediaStreamImpl_IAMMediaStream_GetMultiMediaStream,
 264     DirectDrawMediaStreamImpl_IAMMediaStream_GetInformation,
 265     DirectDrawMediaStreamImpl_IAMMediaStream_SetSameFormat,
 266     DirectDrawMediaStreamImpl_IAMMediaStream_AllocateSample,
 267     DirectDrawMediaStreamImpl_IAMMediaStream_CreateSharedSample,
 268     DirectDrawMediaStreamImpl_IAMMediaStream_SendEndOfStream,
 269     /*** IAMMediaStream methods ***/
 270     DirectDrawMediaStreamImpl_IAMMediaStream_Initialize,
 271     DirectDrawMediaStreamImpl_IAMMediaStream_SetState,
 272     DirectDrawMediaStreamImpl_IAMMediaStream_JoinAMMultiMediaStream,
 273     DirectDrawMediaStreamImpl_IAMMediaStream_JoinFilter,
 274     DirectDrawMediaStreamImpl_IAMMediaStream_JoinFilterGraph
 275 };
 276
 277 static inline DirectDrawMediaStreamImpl *impl_from_IDirectDrawMediaStream(IDirectDrawMediaStream *iface)
 278 {
 279     return CONTAINING_RECORD(iface, DirectDrawMediaStreamImpl, IDirectDrawMediaStream_iface);
 280 }
 281
 282 /*** IUnknown methods ***/
 283 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_QueryInterface(IDirectDrawMediaStream *iface,
 284         REFIID riid, void **ret_iface)
 285 {
 286     DirectDrawMediaStreamImpl *This = impl_from_IDirectDrawMediaStream(iface);
 287     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ret_iface);
 288     return IAMMediaStream_QueryInterface(&This->IAMMediaStream_iface, riid, ret_iface);
 289 }
 290
 291 static ULONG WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_AddRef(IDirectDrawMediaStream *iface)
 292 {
 293     DirectDrawMediaStreamImpl *This = impl_from_IDirectDrawMediaStream(iface);
 294     TRACE("(%p/%p)\n", iface, This);
 295     return IAMMediaStream_AddRef(&This->IAMMediaStream_iface);
 296 }
 297
 298 static ULONG WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_Release(IDirectDrawMediaStream *iface)
 299 {
 300     DirectDrawMediaStreamImpl *This = impl_from_IDirectDrawMediaStream(iface);
 301     TRACE("(%p/%p)\n", iface, This);
 302     return IAMMediaStream_Release(&This->IAMMediaStream_iface);
 303 }
 304
 305 /*** IMediaStream methods ***/
 306 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_GetMultiMediaStream(IDirectDrawMediaStream *iface,
 307         IMultiMediaStream **multi_media_stream)
 308 {
 309     DirectDrawMediaStreamImpl *This = impl_from_IDirectDrawMediaStream(iface);
 310
 311     TRACE("(%p/%p)->(%p)\n", This, iface, multi_media_stream);
 312
 313     if (!multi_media_stream)
 314         return E_POINTER;
 315
 316     IMultiMediaStream_AddRef(This->parent);
 317     *multi_media_stream = This->parent;
 318
 319     return S_OK;
 320 }
 321
 322 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_GetInformation(IDirectDrawMediaStream *iface,
 323         MSPID *purpose_id, STREAM_TYPE *type)
 324 {
 325     DirectDrawMediaStreamImpl *This = impl_from_IDirectDrawMediaStream(iface);
 326
 327     TRACE("(%p/%p)->(%p,%p)\n", This, iface, purpose_id, type);
 328
 329     if (purpose_id)
 330         *purpose_id = This->purpose_id;
 331     if (type)
 332         *type = This->stream_type;
 333
 334     return S_OK;
 335 }
 336
 337 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_SetSameFormat(IDirectDrawMediaStream *iface,
 338         IMediaStream *pStreamThatHasDesiredFormat, DWORD dwFlags)
 339 {
 340     DirectDrawMediaStreamImpl *This = impl_from_IDirectDrawMediaStream(iface);
 341
 342     FIXME("(%p/%p)->(%p,%x) stub!\n", This, iface, pStreamThatHasDesiredFormat, dwFlags);
 343
 344     return S_FALSE;
 345 }
 346
 347 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_AllocateSample(IDirectDrawMediaStream *iface,
 348         DWORD dwFlags, IStreamSample **ppSample)
 349 {
 350     DirectDrawMediaStreamImpl *This = impl_from_IDirectDrawMediaStream(iface);
 351
 352     FIXME("(%p/%p)->(%x,%p) stub!\n", This, iface, dwFlags, ppSample);
 353
 354     return S_FALSE;
 355 }
 356
 357 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_CreateSharedSample(IDirectDrawMediaStream *iface,
 358         IStreamSample *pExistingSample, DWORD dwFlags, IStreamSample **ppSample)
 359 {
 360     DirectDrawMediaStreamImpl *This = impl_from_IDirectDrawMediaStream(iface);
 361
 362     FIXME("(%p/%p)->(%p,%x,%p) stub!\n", This, iface, pExistingSample, dwFlags, ppSample);
 363
 364     return S_FALSE;
 365 }
 366
 367 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_SendEndOfStream(IDirectDrawMediaStream *iface,
 368         DWORD dwFlags)
 369 {
 370     DirectDrawMediaStreamImpl *This = impl_from_IDirectDrawMediaStream(iface);
 371
 372     FIXME("(%p/%p)->(%x) stub!\n", This, iface, dwFlags);
 373
 374     return S_FALSE;
 375 }
 376
 377 /*** IDirectDrawMediaStream methods ***/
 378 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_GetFormat(IDirectDrawMediaStream *iface,
 379         DDSURFACEDESC *current_format, IDirectDrawPalette **palette,
 380         DDSURFACEDESC *desired_format, DWORD *flags)
 381 {
 382     FIXME("(%p)->(%p,%p,%p,%p) stub!\n", iface, current_format, palette, desired_format,
 383             flags);
 384
 385     return MS_E_NOSTREAM;
 386
 387 }
 388
 389 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_SetFormat(IDirectDrawMediaStream *iface,
 390         const DDSURFACEDESC *pDDSurfaceDesc, IDirectDrawPalette *pDirectDrawPalette)
 391 {
 392     FIXME("(%p)->(%p,%p) stub!\n", iface, pDDSurfaceDesc, pDirectDrawPalette);
 393
 394     return E_NOTIMPL;
 395 }
 396
 397 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_GetDirectDraw(IDirectDrawMediaStream *iface,
 398         IDirectDraw **ddraw)
 399 {
 400     DirectDrawMediaStreamImpl *This = impl_from_IDirectDrawMediaStream(iface);
 401
 402     TRACE("(%p)->(%p)\n", iface, ddraw);
 403
 404     *ddraw = NULL;
 405     if (!This->ddraw)
 406     {
 407         HRESULT hr = DirectDrawCreateEx(NULL, (void**)&This->ddraw, &IID_IDirectDraw7, NULL);
 408         if (FAILED(hr))
 409             return hr;
 410         IDirectDraw7_SetCooperativeLevel(This->ddraw, NULL, DDSCL_NORMAL);
 411     }
 412
 413     return IDirectDraw7_QueryInterface(This->ddraw, &IID_IDirectDraw, (void**)ddraw);
 414 }
 415
 416 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_SetDirectDraw(IDirectDrawMediaStream *iface,
 417         IDirectDraw *pDirectDraw)
 418 {
 419     FIXME("(%p)->(%p) stub!\n", iface, pDirectDraw);
 420
 421     return E_NOTIMPL;
 422 }
 423
 424 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_CreateSample(IDirectDrawMediaStream *iface,
 425         IDirectDrawSurface *surface, const RECT *rect, DWORD dwFlags,
 426         IDirectDrawStreamSample **ppSample)
 427 {
 428     TRACE("(%p)->(%p,%s,%x,%p)\n", iface, surface, wine_dbgstr_rect(rect), dwFlags, ppSample);
 429
 430     return ddrawstreamsample_create(iface, surface, rect, ppSample);
 431 }
 432
 433 static HRESULT WINAPI DirectDrawMediaStreamImpl_IDirectDrawMediaStream_GetTimePerFrame(IDirectDrawMediaStream *iface,
 434         STREAM_TIME *pFrameTime)
 435 {
 436     FIXME("(%p)->(%p) stub!\n", iface, pFrameTime);
 437
 438     return E_NOTIMPL;
 439 }
 440
 441 static const struct IDirectDrawMediaStreamVtbl DirectDrawMediaStreamImpl_IDirectDrawMediaStream_Vtbl =
 442 {
 443     /*** IUnknown methods ***/
 444     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_QueryInterface,
 445     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_AddRef,
 446     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_Release,
 447     /*** IMediaStream methods ***/
 448     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_GetMultiMediaStream,
 449     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_GetInformation,
 450     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_SetSameFormat,
 451     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_AllocateSample,
 452     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_CreateSharedSample,
 453     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_SendEndOfStream,
 454     /*** IDirectDrawMediaStream methods ***/
 455     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_GetFormat,
 456     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_SetFormat,
 457     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_GetDirectDraw,
 458     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_SetDirectDraw,
 459     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_CreateSample,
 460     DirectDrawMediaStreamImpl_IDirectDrawMediaStream_GetTimePerFrame
 461 };
 462
 463 static inline DirectDrawMediaStreamInputPin *impl_from_DirectDrawMediaStreamInputPin_IPin(IPin *iface)
 464 {
 465     return CONTAINING_RECORD(iface, DirectDrawMediaStreamInputPin, pin.pin.IPin_iface);
 466 }
 467
 468 /*** IUnknown methods ***/
 469 static HRESULT WINAPI DirectDrawMediaStreamInputPin_IPin_QueryInterface(IPin *iface, REFIID riid, void **ret_iface)
 470 {
 471     DirectDrawMediaStreamInputPin *This = impl_from_DirectDrawMediaStreamInputPin_IPin(iface);
 472
 473     return IAMMediaStream_QueryInterface(&This->parent->IAMMediaStream_iface, riid, ret_iface);
 474 }
 475
 476 static ULONG WINAPI DirectDrawMediaStreamInputPin_IPin_AddRef(IPin *iface)
 477 {
 478     DirectDrawMediaStreamInputPin *This = impl_from_DirectDrawMediaStreamInputPin_IPin(iface);
 479
 480     return IAMMediaStream_AddRef(&This->parent->IAMMediaStream_iface);
 481 }
 482
 483 static ULONG WINAPI DirectDrawMediaStreamInputPin_IPin_Release(IPin *iface)
 484 {
 485     DirectDrawMediaStreamInputPin *This = impl_from_DirectDrawMediaStreamInputPin_IPin(iface);
 486
 487     return IAMMediaStream_Release(&This->parent->IAMMediaStream_iface);
 488 }
 489
 490 static const IPinVtbl DirectDrawMediaStreamInputPin_IPin_Vtbl =
 491 {
 492     DirectDrawMediaStreamInputPin_IPin_QueryInterface,
 493     DirectDrawMediaStreamInputPin_IPin_AddRef,
 494     DirectDrawMediaStreamInputPin_IPin_Release,
 495     BaseInputPinImpl_Connect,
 496     BaseInputPinImpl_ReceiveConnection,
 497     BasePinImpl_Disconnect,
 498     BasePinImpl_ConnectedTo,
 499     BasePinImpl_ConnectionMediaType,
 500     BasePinImpl_QueryPinInfo,
 501     BasePinImpl_QueryDirection,
 502     BasePinImpl_QueryId,
 503     BaseInputPinImpl_QueryAccept,
 504     BasePinImpl_EnumMediaTypes,
 505     BasePinImpl_QueryInternalConnections,
 506     BaseInputPinImpl_EndOfStream,
 507     BaseInputPinImpl_BeginFlush,
 508     BaseInputPinImpl_EndFlush,
 509     BaseInputPinImpl_NewSegment,
 510 };
 511
 512 static HRESULT WINAPI DirectDrawMediaStreamInputPin_CheckMediaType(BasePin *base, const AM_MEDIA_TYPE *media_type)
 513 {
 514     DirectDrawMediaStreamInputPin *This = impl_from_DirectDrawMediaStreamInputPin_IPin(&base->IPin_iface);
 515
 516     TRACE("(%p)->(%p)\n", This, media_type);
 517
 518     if (IsEqualGUID(&media_type->majortype, &MEDIATYPE_Video))
 519     {
 520         if (IsEqualGUID(&media_type->subtype, &MEDIASUBTYPE_RGB1) ||
 521             IsEqualGUID(&media_type->subtype, &MEDIASUBTYPE_RGB4) ||
 522             IsEqualGUID(&media_type->subtype, &MEDIASUBTYPE_RGB8)  ||
 523             IsEqualGUID(&media_type->subtype, &MEDIASUBTYPE_RGB565) ||
 524             IsEqualGUID(&media_type->subtype, &MEDIASUBTYPE_RGB555) ||
 525             IsEqualGUID(&media_type->subtype, &MEDIASUBTYPE_RGB24) ||
 526             IsEqualGUID(&media_type->subtype, &MEDIASUBTYPE_RGB32))
 527         {
 528             TRACE("Video sub-type %s matches\n", debugstr_guid(&media_type->subtype));
 529             return S_OK;
 530         }
 531     }
 532
 533     return S_FALSE;
 534 }
 535
 536 static LONG WINAPI DirectDrawMediaStreamInputPin_GetMediaTypeVersion(BasePin *base)
 537 {
 538     return 0;
 539 }
 540
 541 static HRESULT WINAPI DirectDrawMediaStreamInputPin_GetMediaType(BasePin *base, int index, AM_MEDIA_TYPE *media_type)
 542 {
 543     DirectDrawMediaStreamInputPin *This = impl_from_DirectDrawMediaStreamInputPin_IPin(&base->IPin_iface);
 544
 545     TRACE("(%p)->(%d,%p)\n", This, index, media_type);
 546
 547     /* FIXME: Reset structure as we only fill majortype and minortype for now */
 548     ZeroMemory(media_type, sizeof(*media_type));
 549
 550     media_type->majortype = MEDIATYPE_Video;
 551
 552     switch (index)
 553     {
 554         case 0:
 555             media_type->subtype = MEDIASUBTYPE_RGB1;
 556             break;
 557         case 1:
 558             media_type->subtype = MEDIASUBTYPE_RGB4;
 559             break;
 560         case 2:
 561             media_type->subtype = MEDIASUBTYPE_RGB8;
 562             break;
 563         case 3:
 564             media_type->subtype = MEDIASUBTYPE_RGB565;
 565             break;
 566         case 4:
 567             media_type->subtype = MEDIASUBTYPE_RGB555;
 568             break;
 569         case 5:
 570             media_type->subtype = MEDIASUBTYPE_RGB24;
 571             break;
 572         case 6:
 573             media_type->subtype = MEDIASUBTYPE_RGB32;
 574             break;
 575         default:
 576             return S_FALSE;
 577     }
 578
 579     return S_OK;
 580 }
 581
 582 static HRESULT WINAPI DirectDrawMediaStreamInputPin_Receive(BaseInputPin *base, IMediaSample *sample)
 583 {
 584     DirectDrawMediaStreamInputPin *This = impl_from_DirectDrawMediaStreamInputPin_IPin(&base->pin.IPin_iface);
 585
 586     FIXME("(%p)->(%p) stub!\n", This, sample);
 587
 588     return E_NOTIMPL;
 589 }
 590
 591 static const BaseInputPinFuncTable DirectDrawMediaStreamInputPin_FuncTable =
 592 {
 593     {
 594         DirectDrawMediaStreamInputPin_CheckMediaType,
 595         NULL,
 596         DirectDrawMediaStreamInputPin_GetMediaTypeVersion,
 597         DirectDrawMediaStreamInputPin_GetMediaType,
 598     },
 599     DirectDrawMediaStreamInputPin_Receive,
 600 };
 601
 602 HRESULT ddrawmediastream_create(IMultiMediaStream *parent, const MSPID *purpose_id,
 603         STREAM_TYPE stream_type, IAMMediaStream **media_stream)
 604 {
 605     DirectDrawMediaStreamImpl *object;
 606     PIN_INFO pin_info;
 607     HRESULT hr;
 608
 609     TRACE("(%p,%s,%p)\n", parent, debugstr_guid(purpose_id), media_stream);
 610
 611     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DirectDrawMediaStreamImpl));
 612     if (!object)
 613         return E_OUTOFMEMORY;
 614
 615     object->IAMMediaStream_iface.lpVtbl = &DirectDrawMediaStreamImpl_IAMMediaStream_Vtbl;
 616     object->IDirectDrawMediaStream_iface.lpVtbl = &DirectDrawMediaStreamImpl_IDirectDrawMediaStream_Vtbl;
 617     object->ref = 1;
 618
 619     InitializeCriticalSection(&object->critical_section);
 620
 621     pin_info.pFilter = NULL;
 622     pin_info.dir = PINDIR_INPUT;
 623     pin_info.achName[0] = 'I';
 624     StringFromGUID2(purpose_id, pin_info.achName + 1, MAX_PIN_NAME - 1);
 625     hr = BaseInputPin_Construct(&DirectDrawMediaStreamInputPin_IPin_Vtbl,
 626         sizeof(DirectDrawMediaStreamInputPin), &pin_info, &DirectDrawMediaStreamInputPin_FuncTable,
 627         &object->critical_section, NULL, (IPin **)&object->input_pin);
 628     if (FAILED(hr))
 629         goto out_object;
 630
 631     object->input_pin->parent = object;
 632
 633     object->parent = parent;
 634     object->purpose_id = *purpose_id;
 635     object->stream_type = stream_type;
 636
 637     *media_stream = &object->IAMMediaStream_iface;
 638
 639     return S_OK;
 640
 641 out_object:
 642     HeapFree(GetProcessHeap(), 0, object);
 643
 644     return hr;
 645 }
 646
 647 struct AudioMediaStreamImpl;
 648
 649 typedef struct {
 650     BaseInputPin pin;
 651     struct AudioMediaStreamImpl *parent;
 652 } AudioMediaStreamInputPin;
 653
 654 typedef struct AudioMediaStreamImpl {
 655     IAMMediaStream IAMMediaStream_iface;
 656     IAudioMediaStream IAudioMediaStream_iface;
 657     LONG ref;
 658     IMultiMediaStream* parent;
 659     MSPID purpose_id;
 660     STREAM_TYPE stream_type;
 661     AudioMediaStreamInputPin *input_pin;
 662     CRITICAL_SECTION critical_section;
 663 } AudioMediaStreamImpl;
 664
 665 static inline AudioMediaStreamImpl *impl_from_AudioMediaStream_IAMMediaStream(IAMMediaStream *iface)
 666 {
 667     return CONTAINING_RECORD(iface, AudioMediaStreamImpl, IAMMediaStream_iface);
 668 }
 669
 670 /*** IUnknown methods ***/
 671 static HRESULT WINAPI AudioMediaStreamImpl_IAMMediaStream_QueryInterface(IAMMediaStream *iface,
 672                                                         REFIID riid, void **ret_iface)
 673 {
 674     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 675
 676     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ret_iface);
 677
 678     if (IsEqualGUID(riid, &IID_IUnknown) ||
 679         IsEqualGUID(riid, &IID_IMediaStream) ||
 680         IsEqualGUID(riid, &IID_IAMMediaStream))
 681     {
 682         IAMMediaStream_AddRef(iface);
 683         *ret_iface = iface;
 684         return S_OK;
 685     }
 686     else if (IsEqualGUID(riid, &IID_IAudioMediaStream))
 687     {
 688         IAMMediaStream_AddRef(iface);
 689         *ret_iface = &This->IAudioMediaStream_iface;
 690         return S_OK;
 691     }
 692     else if (IsEqualGUID(riid, &IID_IPin))
 693     {
 694         IAMMediaStream_AddRef(iface);
 695         *ret_iface = &This->input_pin->pin.pin.IPin_iface;
 696         return S_OK;
 697     }
 698     else if (IsEqualGUID(riid, &IID_IMemInputPin))
 699     {
 700         IAMMediaStream_AddRef(iface);
 701         *ret_iface = &This->input_pin->pin.IMemInputPin_iface;
 702         return S_OK;
 703     }
 704
 705     ERR("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ret_iface);
 706     return E_NOINTERFACE;
 707 }
 708
 709 static ULONG WINAPI AudioMediaStreamImpl_IAMMediaStream_AddRef(IAMMediaStream *iface)
 710 {
 711     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 712     ULONG ref = InterlockedIncrement(&This->ref);
 713
 714     TRACE("(%p/%p)->(): new ref = %u\n", iface, This, ref);
 715
 716     return ref;
 717 }
 718
 719 static ULONG WINAPI AudioMediaStreamImpl_IAMMediaStream_Release(IAMMediaStream *iface)
 720 {
 721     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 722     ULONG ref = InterlockedDecrement(&This->ref);
 723
 724     TRACE("(%p/%p)->(): new ref = %u\n", iface, This, ref);
 725
 726     if (!ref)
 727     {
 728         BaseInputPin_Destroy((BaseInputPin *)This->input_pin);
 729         DeleteCriticalSection(&This->critical_section);
 730         HeapFree(GetProcessHeap(), 0, This);
 731     }
 732
 733     return ref;
 734 }
 735
 736 /*** IMediaStream methods ***/
 737 static HRESULT WINAPI AudioMediaStreamImpl_IAMMediaStream_GetMultiMediaStream(IAMMediaStream *iface,
 738         IMultiMediaStream** multi_media_stream)
 739 {
 740     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 741
 742     TRACE("(%p/%p)->(%p)\n", This, iface, multi_media_stream);
 743
 744     if (!multi_media_stream)
 745         return E_POINTER;
 746
 747     IMultiMediaStream_AddRef(This->parent);
 748     *multi_media_stream = This->parent;
 749
 750     return S_OK;
 751 }
 752
 753 static HRESULT WINAPI AudioMediaStreamImpl_IAMMediaStream_GetInformation(IAMMediaStream *iface,
 754         MSPID *purpose_id, STREAM_TYPE *type)
 755 {
 756     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 757
 758     TRACE("(%p/%p)->(%p,%p)\n", This, iface, purpose_id, type);
 759
 760     if (purpose_id)
 761         *purpose_id = This->purpose_id;
 762     if (type)
 763         *type = This->stream_type;
 764
 765     return S_OK;
 766 }
 767
 768 static HRESULT WINAPI AudioMediaStreamImpl_IAMMediaStream_SetSameFormat(IAMMediaStream *iface,
 769         IMediaStream *pStreamThatHasDesiredFormat, DWORD flags)
 770 {
 771     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 772
 773     FIXME("(%p/%p)->(%p,%x) stub!\n", This, iface, pStreamThatHasDesiredFormat, flags);
 774
 775     return S_FALSE;
 776 }
 777
 778 static HRESULT WINAPI AudioMediaStreamImpl_IAMMediaStream_AllocateSample(IAMMediaStream *iface,
 779         DWORD flags, IStreamSample **sample)
 780 {
 781     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 782
 783     FIXME("(%p/%p)->(%x,%p) stub!\n", This, iface, flags, sample);
 784
 785     return S_FALSE;
 786 }
 787
 788 static HRESULT WINAPI AudioMediaStreamImpl_IAMMediaStream_CreateSharedSample(IAMMediaStream *iface,
 789         IStreamSample *existing_sample, DWORD flags, IStreamSample **sample)
 790 {
 791     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 792
 793     FIXME("(%p/%p)->(%p,%x,%p) stub!\n", This, iface, existing_sample, flags, sample);
 794
 795     return S_FALSE;
 796 }
 797
 798 static HRESULT WINAPI AudioMediaStreamImpl_IAMMediaStream_SendEndOfStream(IAMMediaStream *iface, DWORD flags)
 799 {
 800     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 801
 802     FIXME("(%p/%p)->(%x) stub!\n", This, iface, flags);
 803
 804     return S_FALSE;
 805 }
 806
 807 /*** IAMMediaStream methods ***/
 808 static HRESULT WINAPI AudioMediaStreamImpl_IAMMediaStream_Initialize(IAMMediaStream *iface, IUnknown *source_object, DWORD flags,
 809                                                     REFMSPID purpose_id, const STREAM_TYPE stream_type)
 810 {
 811     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 812
 813     FIXME("(%p/%p)->(%p,%x,%p,%u) stub!\n", This, iface, source_object, flags, purpose_id, stream_type);
 814
 815     return S_FALSE;
 816 }
 817
 818 static HRESULT WINAPI AudioMediaStreamImpl_IAMMediaStream_SetState(IAMMediaStream *iface, FILTER_STATE state)
 819 {
 820     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 821
 822     FIXME("(%p/%p)->(%u) stub!\n", This, iface, state);
 823
 824     return S_FALSE;
 825 }
 826
 827 static HRESULT WINAPI AudioMediaStreamImpl_IAMMediaStream_JoinAMMultiMediaStream(IAMMediaStream *iface, IAMMultiMediaStream *am_multi_media_stream)
 828 {
 829     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 830
 831     FIXME("(%p/%p)->(%p) stub!\n", This, iface, am_multi_media_stream);
 832
 833     return S_FALSE;
 834 }
 835
 836 static HRESULT WINAPI AudioMediaStreamImpl_IAMMediaStream_JoinFilter(IAMMediaStream *iface, IMediaStreamFilter *media_stream_filter)
 837 {
 838     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 839
 840     FIXME("(%p/%p)->(%p) stub!\n", This, iface, media_stream_filter);
 841
 842     return S_FALSE;
 843 }
 844
 845 static HRESULT WINAPI AudioMediaStreamImpl_IAMMediaStream_JoinFilterGraph(IAMMediaStream *iface, IFilterGraph *filtergraph)
 846 {
 847     AudioMediaStreamImpl *This = impl_from_AudioMediaStream_IAMMediaStream(iface);
 848
 849     FIXME("(%p/%p)->(%p) stub!\n", This, iface, filtergraph);
 850
 851     return S_FALSE;
 852 }
 853
 854 static const struct IAMMediaStreamVtbl AudioMediaStreamImpl_IAMMediaStream_Vtbl =
 855 {
 856     /*** IUnknown methods ***/
 857     AudioMediaStreamImpl_IAMMediaStream_QueryInterface,
 858     AudioMediaStreamImpl_IAMMediaStream_AddRef,
 859     AudioMediaStreamImpl_IAMMediaStream_Release,
 860     /*** IMediaStream methods ***/
 861     AudioMediaStreamImpl_IAMMediaStream_GetMultiMediaStream,
 862     AudioMediaStreamImpl_IAMMediaStream_GetInformation,
 863     AudioMediaStreamImpl_IAMMediaStream_SetSameFormat,
 864     AudioMediaStreamImpl_IAMMediaStream_AllocateSample,
 865     AudioMediaStreamImpl_IAMMediaStream_CreateSharedSample,
 866     AudioMediaStreamImpl_IAMMediaStream_SendEndOfStream,
 867     /*** IAMMediaStream methods ***/
 868     AudioMediaStreamImpl_IAMMediaStream_Initialize,
 869     AudioMediaStreamImpl_IAMMediaStream_SetState,
 870     AudioMediaStreamImpl_IAMMediaStream_JoinAMMultiMediaStream,
 871     AudioMediaStreamImpl_IAMMediaStream_JoinFilter,
 872     AudioMediaStreamImpl_IAMMediaStream_JoinFilterGraph
 873 };
 874
 875 static inline AudioMediaStreamImpl *impl_from_IAudioMediaStream(IAudioMediaStream *iface)
 876 {
 877     return CONTAINING_RECORD(iface, AudioMediaStreamImpl, IAudioMediaStream_iface);
 878 }
 879
 880 /*** IUnknown methods ***/
 881 static HRESULT WINAPI AudioMediaStreamImpl_IAudioMediaStream_QueryInterface(IAudioMediaStream *iface,
 882         REFIID riid, void **ret_iface)
 883 {
 884     AudioMediaStreamImpl *This = impl_from_IAudioMediaStream(iface);
 885     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ret_iface);
 886     return IAMMediaStream_QueryInterface(&This->IAMMediaStream_iface, riid, ret_iface);
 887 }
 888
 889 static ULONG WINAPI AudioMediaStreamImpl_IAudioMediaStream_AddRef(IAudioMediaStream *iface)
 890 {
 891     AudioMediaStreamImpl *This = impl_from_IAudioMediaStream(iface);
 892     TRACE("(%p/%p)\n", iface, This);
 893     return IAMMediaStream_AddRef(&This->IAMMediaStream_iface);
 894 }
 895
 896 static ULONG WINAPI AudioMediaStreamImpl_IAudioMediaStream_Release(IAudioMediaStream *iface)
 897 {
 898     AudioMediaStreamImpl *This = impl_from_IAudioMediaStream(iface);
 899     TRACE("(%p/%p)\n", iface, This);
 900     return IAMMediaStream_Release(&This->IAMMediaStream_iface);
 901 }
 902
 903 /*** IMediaStream methods ***/
 904 static HRESULT WINAPI AudioMediaStreamImpl_IAudioMediaStream_GetMultiMediaStream(IAudioMediaStream *iface,
 905         IMultiMediaStream **multi_media_stream)
 906 {
 907     AudioMediaStreamImpl *This = impl_from_IAudioMediaStream(iface);
 908
 909     TRACE("(%p/%p)->(%p)\n", iface, This, multi_media_stream);
 910
 911     if (!multi_media_stream)
 912         return E_POINTER;
 913
 914     IMultiMediaStream_AddRef(This->parent);
 915     *multi_media_stream = This->parent;
 916
 917     return S_OK;
 918 }
 919
 920 static HRESULT WINAPI AudioMediaStreamImpl_IAudioMediaStream_GetInformation(IAudioMediaStream *iface,
 921         MSPID *purpose_id, STREAM_TYPE *type)
 922 {
 923     AudioMediaStreamImpl *This = impl_from_IAudioMediaStream(iface);
 924
 925     TRACE("(%p/%p)->(%p,%p)\n", iface, This, purpose_id, type);
 926
 927     if (purpose_id)
 928         *purpose_id = This->purpose_id;
 929     if (type)
 930         *type = This->stream_type;
 931
 932     return S_OK;
 933 }
 934
 935 static HRESULT WINAPI AudioMediaStreamImpl_IAudioMediaStream_SetSameFormat(IAudioMediaStream *iface,
 936         IMediaStream *stream_format, DWORD flags)
 937 {
 938     AudioMediaStreamImpl *This = impl_from_IAudioMediaStream(iface);
 939
 940     FIXME("(%p/%p)->(%p,%x) stub!\n", iface, This, stream_format, flags);
 941
 942     return S_FALSE;
 943 }
 944
 945 static HRESULT WINAPI AudioMediaStreamImpl_IAudioMediaStream_AllocateSample(IAudioMediaStream *iface,
 946         DWORD flags, IStreamSample **sample)
 947 {
 948     AudioMediaStreamImpl *This = impl_from_IAudioMediaStream(iface);
 949
 950     FIXME("(%p/%p)->(%x,%p) stub!\n", iface, This, flags, sample);
 951
 952     return S_FALSE;
 953 }
 954
 955 static HRESULT WINAPI AudioMediaStreamImpl_IAudioMediaStream_CreateSharedSample(IAudioMediaStream *iface,
 956         IStreamSample *existing_sample, DWORD flags, IStreamSample **sample)
 957 {
 958     AudioMediaStreamImpl *This = impl_from_IAudioMediaStream(iface);
 959
 960     FIXME("(%p/%p)->(%p,%x,%p) stub!\n", iface, This, existing_sample, flags, sample);
 961
 962     return S_FALSE;
 963 }
 964
 965 static HRESULT WINAPI AudioMediaStreamImpl_IAudioMediaStream_SendEndOfStream(IAudioMediaStream *iface,
 966         DWORD flags)
 967 {
 968     AudioMediaStreamImpl *This = impl_from_IAudioMediaStream(iface);
 969
 970     FIXME("(%p/%p)->(%x) stub!\n", iface, This, flags);
 971
 972     return S_FALSE;
 973 }
 974
 975 /*** IAudioMediaStream methods ***/
 976 static HRESULT WINAPI AudioMediaStreamImpl_IAudioMediaStream_GetFormat(IAudioMediaStream *iface, WAVEFORMATEX *wave_format_current)
 977 {
 978     AudioMediaStreamImpl *This = impl_from_IAudioMediaStream(iface);
 979
 980     FIXME("(%p/%p)->(%p) stub!\n", iface, This, wave_format_current);
 981
 982     if (!wave_format_current)
 983         return E_POINTER;
 984
 985     return MS_E_NOSTREAM;
 986
 987 }
 988
 989 static HRESULT WINAPI AudioMediaStreamImpl_IAudioMediaStream_SetFormat(IAudioMediaStream *iface, const WAVEFORMATEX *wave_format)
 990 {
 991     AudioMediaStreamImpl *This = impl_from_IAudioMediaStream(iface);
 992
 993     FIXME("(%p/%p)->(%p) stub!\n", iface, This, wave_format);
 994
 995     return E_NOTIMPL;
 996 }
 997
 998 static HRESULT WINAPI AudioMediaStreamImpl_IAudioMediaStream_CreateSample(IAudioMediaStream *iface, IAudioData *audio_data,
 999                                                          DWORD flags, IAudioStreamSample **sample)
1000 {
1001     AudioMediaStreamImpl *This = impl_from_IAudioMediaStream(iface);
1002
1003     TRACE("(%p/%p)->(%p,%u,%p)\n", iface, This, audio_data, flags, sample);
1004
1005     if (!audio_data)
1006         return E_POINTER;
1007
1008     return audiostreamsample_create(iface, audio_data, sample);
1009 }
1010
1011 static const struct IAudioMediaStreamVtbl AudioMediaStreamImpl_IAudioMediaStream_Vtbl =
1012 {
1013     /*** IUnknown methods ***/
1014     AudioMediaStreamImpl_IAudioMediaStream_QueryInterface,
1015     AudioMediaStreamImpl_IAudioMediaStream_AddRef,
1016     AudioMediaStreamImpl_IAudioMediaStream_Release,
1017     /*** IMediaStream methods ***/
1018     AudioMediaStreamImpl_IAudioMediaStream_GetMultiMediaStream,
1019     AudioMediaStreamImpl_IAudioMediaStream_GetInformation,
1020     AudioMediaStreamImpl_IAudioMediaStream_SetSameFormat,
1021     AudioMediaStreamImpl_IAudioMediaStream_AllocateSample,
1022     AudioMediaStreamImpl_IAudioMediaStream_CreateSharedSample,
1023     AudioMediaStreamImpl_IAudioMediaStream_SendEndOfStream,
1024     /*** IAudioMediaStream methods ***/
1025     AudioMediaStreamImpl_IAudioMediaStream_GetFormat,
1026     AudioMediaStreamImpl_IAudioMediaStream_SetFormat,
1027     AudioMediaStreamImpl_IAudioMediaStream_CreateSample
1028 };
1029
1030 static inline AudioMediaStreamInputPin *impl_from_AudioMediaStreamInputPin_IPin(IPin *iface)
1031 {
1032     return CONTAINING_RECORD(iface, AudioMediaStreamInputPin, pin.pin.IPin_iface);
1033 }
1034
1035 /*** IUnknown methods ***/
1036 static HRESULT WINAPI AudioMediaStreamInputPin_IPin_QueryInterface(IPin *iface, REFIID riid, void **ret_iface)
1037 {
1038     AudioMediaStreamInputPin *This = impl_from_AudioMediaStreamInputPin_IPin(iface);
1039
1040     return IAMMediaStream_QueryInterface(&This->parent->IAMMediaStream_iface, riid, ret_iface);
1041 }
1042
1043 static ULONG WINAPI AudioMediaStreamInputPin_IPin_AddRef(IPin *iface)
1044 {
1045     AudioMediaStreamInputPin *This = impl_from_AudioMediaStreamInputPin_IPin(iface);
1046
1047     return IAMMediaStream_AddRef(&This->parent->IAMMediaStream_iface);
1048 }
1049
1050 static ULONG WINAPI AudioMediaStreamInputPin_IPin_Release(IPin *iface)
1051 {
1052     AudioMediaStreamInputPin *This = impl_from_AudioMediaStreamInputPin_IPin(iface);
1053
1054     return IAMMediaStream_Release(&This->parent->IAMMediaStream_iface);
1055 }
1056
1057 static const IPinVtbl AudioMediaStreamInputPin_IPin_Vtbl =
1058 {
1059     AudioMediaStreamInputPin_IPin_QueryInterface,
1060     AudioMediaStreamInputPin_IPin_AddRef,
1061     AudioMediaStreamInputPin_IPin_Release,
1062     BaseInputPinImpl_Connect,
1063     BaseInputPinImpl_ReceiveConnection,
1064     BasePinImpl_Disconnect,
1065     BasePinImpl_ConnectedTo,
1066     BasePinImpl_ConnectionMediaType,
1067     BasePinImpl_QueryPinInfo,
1068     BasePinImpl_QueryDirection,
1069     BasePinImpl_QueryId,
1070     BaseInputPinImpl_QueryAccept,
1071     BasePinImpl_EnumMediaTypes,
1072     BasePinImpl_QueryInternalConnections,
1073     BaseInputPinImpl_EndOfStream,
1074     BaseInputPinImpl_BeginFlush,
1075     BaseInputPinImpl_EndFlush,
1076     BaseInputPinImpl_NewSegment,
1077 };
1078
1079 static HRESULT WINAPI AudioMediaStreamInputPin_CheckMediaType(BasePin *base, const AM_MEDIA_TYPE *media_type)
1080 {
1081     AudioMediaStreamInputPin *This = impl_from_AudioMediaStreamInputPin_IPin(&base->IPin_iface);
1082
1083     FIXME("(%p)->(%p) stub!\n", This, media_type);
1084
1085     return E_NOTIMPL;
1086 }
1087
1088 static LONG WINAPI AudioMediaStreamInputPin_GetMediaTypeVersion(BasePin *base)
1089 {
1090     return 0;
1091 }
1092
1093 static HRESULT WINAPI AudioMediaStreamInputPin_GetMediaType(BasePin *base, int index, AM_MEDIA_TYPE *media_type)
1094 {
1095     AudioMediaStreamInputPin *This = impl_from_AudioMediaStreamInputPin_IPin(&base->IPin_iface);
1096
1097     FIXME("(%p)->(%d,%p) stub!\n", This, index, media_type);
1098
1099     return E_NOTIMPL;
1100 }
1101
1102 static HRESULT WINAPI AudioMediaStreamInputPin_Receive(BaseInputPin *base, IMediaSample *sample)
1103 {
1104     AudioMediaStreamInputPin *This = impl_from_AudioMediaStreamInputPin_IPin(&base->pin.IPin_iface);
1105
1106     FIXME("(%p)->(%p) stub!\n", This, sample);
1107
1108     return E_NOTIMPL;
1109 }
1110
1111 static const BaseInputPinFuncTable AudioMediaStreamInputPin_FuncTable =
1112 {
1113     {
1114         AudioMediaStreamInputPin_CheckMediaType,
1115         NULL,
1116         AudioMediaStreamInputPin_GetMediaTypeVersion,
1117         AudioMediaStreamInputPin_GetMediaType,
1118     },
1119     AudioMediaStreamInputPin_Receive,
1120 };
1121
1122 HRESULT audiomediastream_create(IMultiMediaStream *parent, const MSPID *purpose_id,
1123         STREAM_TYPE stream_type, IAMMediaStream **media_stream)
1124 {
1125     AudioMediaStreamImpl *object;
1126     PIN_INFO pin_info;
1127     HRESULT hr;
1128
1129     TRACE("(%p,%s,%p)\n", parent, debugstr_guid(purpose_id), media_stream);
1130
1131     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(AudioMediaStreamImpl));
1132     if (!object)
1133         return E_OUTOFMEMORY;
1134
1135     object->IAMMediaStream_iface.lpVtbl = &AudioMediaStreamImpl_IAMMediaStream_Vtbl;
1136     object->IAudioMediaStream_iface.lpVtbl = &AudioMediaStreamImpl_IAudioMediaStream_Vtbl;
1137     object->ref = 1;
1138
1139     InitializeCriticalSection(&object->critical_section);
1140
1141     pin_info.pFilter = NULL;
1142     pin_info.dir = PINDIR_INPUT;
1143     pin_info.achName[0] = 'I';
1144     StringFromGUID2(purpose_id, pin_info.achName + 1, MAX_PIN_NAME - 1);
1145     hr = BaseInputPin_Construct(&AudioMediaStreamInputPin_IPin_Vtbl,
1146         sizeof(AudioMediaStreamInputPin), &pin_info, &AudioMediaStreamInputPin_FuncTable,
1147         &object->critical_section, NULL, (IPin **)&object->input_pin);
1148     if (FAILED(hr))
1149         goto out_object;
1150
1151     object->input_pin->parent = object;
1152
1153     object->parent = parent;
1154     object->purpose_id = *purpose_id;
1155     object->stream_type = stream_type;
1156
1157     *media_stream = &object->IAMMediaStream_iface;
1158
1159     return S_OK;
1160
1161 out_object:
1162     HeapFree(GetProcessHeap(), 0, object);
1163
1164     return hr;
1165 }
1166
1167 typedef struct {
1168     IDirectDrawStreamSample IDirectDrawStreamSample_iface;
1169     LONG ref;
1170     IMediaStream *parent;
1171     IDirectDrawSurface *surface;
1172     RECT rect;
1173 } IDirectDrawStreamSampleImpl;
1174
1175 static inline IDirectDrawStreamSampleImpl *impl_from_IDirectDrawStreamSample(IDirectDrawStreamSample *iface)
1176 {
1177     return CONTAINING_RECORD(iface, IDirectDrawStreamSampleImpl, IDirectDrawStreamSample_iface);
1178 }
1179
1180 /*** IUnknown methods ***/
1181 static HRESULT WINAPI IDirectDrawStreamSampleImpl_QueryInterface(IDirectDrawStreamSample *iface,
1182         REFIID riid, void **ret_iface)
1183 {
1184     TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(riid), ret_iface);
1185
1186     if (IsEqualGUID(riid, &IID_IUnknown) ||
1187         IsEqualGUID(riid, &IID_IStreamSample) ||
1188         IsEqualGUID(riid, &IID_IDirectDrawStreamSample))
1189     {
1190         IDirectDrawStreamSample_AddRef(iface);
1191         *ret_iface = iface;
1192         return S_OK;
1193     }
1194
1195     *ret_iface = NULL;
1196
1197     ERR("(%p)->(%s,%p),not found\n", iface, debugstr_guid(riid), ret_iface);
1198     return E_NOINTERFACE;
1199 }
1200
1201 static ULONG WINAPI IDirectDrawStreamSampleImpl_AddRef(IDirectDrawStreamSample *iface)
1202 {
1203     IDirectDrawStreamSampleImpl *This = impl_from_IDirectDrawStreamSample(iface);
1204     ULONG ref = InterlockedIncrement(&This->ref);
1205
1206     TRACE("(%p)->(): new ref = %u\n", iface, ref);
1207
1208     return ref;
1209 }
1210
1211 static ULONG WINAPI IDirectDrawStreamSampleImpl_Release(IDirectDrawStreamSample *iface)
1212 {
1213     IDirectDrawStreamSampleImpl *This = impl_from_IDirectDrawStreamSample(iface);
1214     ULONG ref = InterlockedDecrement(&This->ref);
1215
1216     TRACE("(%p)->(): new ref = %u\n", iface, ref);
1217
1218     if (!ref)
1219     {
1220         if (This->surface)
1221             IDirectDrawSurface_Release(This->surface);
1222         IMediaStream_Release(This->parent);
1223         HeapFree(GetProcessHeap(), 0, This);
1224     }
1225
1226     return ref;
1227 }
1228
1229 /*** IStreamSample methods ***/
1230 static HRESULT WINAPI IDirectDrawStreamSampleImpl_GetMediaStream(IDirectDrawStreamSample *iface, IMediaStream **media_stream)
1231 {
1232     FIXME("(%p)->(%p): stub\n", iface, media_stream);
1233
1234     return E_NOTIMPL;
1235 }
1236
1237 static HRESULT WINAPI IDirectDrawStreamSampleImpl_GetSampleTimes(IDirectDrawStreamSample *iface, STREAM_TIME *start_time,
1238                                                                  STREAM_TIME *end_time, STREAM_TIME *current_time)
1239 {
1240     FIXME("(%p)->(%p,%p,%p): stub\n", iface, start_time, end_time, current_time);
1241
1242     return E_NOTIMPL;
1243 }
1244
1245 static HRESULT WINAPI IDirectDrawStreamSampleImpl_SetSampleTimes(IDirectDrawStreamSample *iface, const STREAM_TIME *start_time,
1246                                                                  const STREAM_TIME *end_time)
1247 {
1248     FIXME("(%p)->(%p,%p): stub\n", iface, start_time, end_time);
1249
1250     return E_NOTIMPL;
1251 }
1252
1253 static HRESULT WINAPI IDirectDrawStreamSampleImpl_Update(IDirectDrawStreamSample *iface, DWORD flags, HANDLE event,
1254                                                          PAPCFUNC func_APC, DWORD APC_data)
1255 {
1256     FIXME("(%p)->(%x,%p,%p,%u): stub\n", iface, flags, event, func_APC, APC_data);
1257
1258     return S_OK;
1259 }
1260
1261 static HRESULT WINAPI IDirectDrawStreamSampleImpl_CompletionStatus(IDirectDrawStreamSample *iface, DWORD flags, DWORD milliseconds)
1262 {
1263     FIXME("(%p)->(%x,%u): stub\n", iface, flags, milliseconds);
1264
1265     return E_NOTIMPL;
1266 }
1267
1268 /*** IDirectDrawStreamSample methods ***/
1269 static HRESULT WINAPI IDirectDrawStreamSampleImpl_GetSurface(IDirectDrawStreamSample *iface, IDirectDrawSurface **ddraw_surface,
1270                                                              RECT *rect)
1271 {
1272     IDirectDrawStreamSampleImpl *This = impl_from_IDirectDrawStreamSample(iface);
1273
1274     TRACE("(%p)->(%p,%p)\n", iface, ddraw_surface, rect);
1275
1276     if (ddraw_surface)
1277     {
1278         *ddraw_surface = This->surface;
1279         if (*ddraw_surface)
1280             IDirectDrawSurface_AddRef(*ddraw_surface);
1281     }
1282
1283     if (rect)
1284         *rect = This->rect;
1285
1286     return S_OK;
1287 }
1288
1289 static HRESULT WINAPI IDirectDrawStreamSampleImpl_SetRect(IDirectDrawStreamSample *iface, const RECT *rect)
1290 {
1291     FIXME("(%p)->(%p): stub\n", iface, rect);
1292
1293     return E_NOTIMPL;
1294 }
1295
1296 static const struct IDirectDrawStreamSampleVtbl DirectDrawStreamSample_Vtbl =
1297 {
1298     /*** IUnknown methods ***/
1299     IDirectDrawStreamSampleImpl_QueryInterface,
1300     IDirectDrawStreamSampleImpl_AddRef,
1301     IDirectDrawStreamSampleImpl_Release,
1302     /*** IStreamSample methods ***/
1303     IDirectDrawStreamSampleImpl_GetMediaStream,
1304     IDirectDrawStreamSampleImpl_GetSampleTimes,
1305     IDirectDrawStreamSampleImpl_SetSampleTimes,
1306     IDirectDrawStreamSampleImpl_Update,
1307     IDirectDrawStreamSampleImpl_CompletionStatus,
1308     /*** IDirectDrawStreamSample methods ***/
1309     IDirectDrawStreamSampleImpl_GetSurface,
1310     IDirectDrawStreamSampleImpl_SetRect
1311 };
1312
1313 static HRESULT ddrawstreamsample_create(IDirectDrawMediaStream *parent, IDirectDrawSurface *surface,
1314     const RECT *rect, IDirectDrawStreamSample **ddraw_stream_sample)
1315 {
1316     IDirectDrawStreamSampleImpl *object;
1317     HRESULT hr;
1318
1319     TRACE("(%p)\n", ddraw_stream_sample);
1320
1321     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1322     if (!object)
1323         return E_OUTOFMEMORY;
1324
1325     object->IDirectDrawStreamSample_iface.lpVtbl = &DirectDrawStreamSample_Vtbl;
1326     object->ref = 1;
1327     object->parent = (IMediaStream*)parent;
1328     IMediaStream_AddRef(object->parent);
1329
1330     if (surface)
1331     {
1332         object->surface = surface;
1333         IDirectDrawSurface_AddRef(surface);
1334     }
1335     else
1336     {
1337         DDSURFACEDESC desc;
1338         IDirectDraw *ddraw;
1339
1340         hr = IDirectDrawMediaStream_GetDirectDraw(parent, &ddraw);
1341         if (FAILED(hr))
1342         {
1343             IDirectDrawStreamSample_Release(&object->IDirectDrawStreamSample_iface);
1344             return hr;
1345         }
1346
1347         desc.dwSize = sizeof(desc);
1348         desc.dwFlags = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;
1349         desc.dwHeight = 100;
1350         desc.dwWidth = 100;
1351         desc.ddpfPixelFormat.dwSize = sizeof(desc.ddpfPixelFormat);
1352         desc.ddpfPixelFormat.dwFlags = DDPF_RGB;
1353         desc.ddpfPixelFormat.u1.dwRGBBitCount = 32;
1354         desc.ddpfPixelFormat.u2.dwRBitMask = 0xff0000;
1355         desc.ddpfPixelFormat.u3.dwGBitMask = 0x00ff00;
1356         desc.ddpfPixelFormat.u4.dwBBitMask = 0x0000ff;
1357         desc.ddpfPixelFormat.u5.dwRGBAlphaBitMask = 0;
1358         desc.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY|DDSCAPS_OFFSCREENPLAIN;
1359         desc.lpSurface = NULL;
1360
1361         hr = IDirectDraw_CreateSurface(ddraw, &desc, &object->surface, NULL);
1362         IDirectDraw_Release(ddraw);
1363         if (FAILED(hr))
1364         {
1365             ERR("failed to create surface, 0x%08x\n", hr);
1366             IDirectDrawStreamSample_Release(&object->IDirectDrawStreamSample_iface);
1367             return hr;
1368         }
1369     }
1370
1371     if (rect)
1372         object->rect = *rect;
1373     else if (object->surface)
1374     {
1375         DDSURFACEDESC desc = { sizeof(desc) };
1376         hr = IDirectDrawSurface_GetSurfaceDesc(object->surface, &desc);
1377         if (hr == S_OK)
1378             SetRect(&object->rect, 0, 0, desc.dwWidth, desc.dwHeight);
1379     }
1380
1381     *ddraw_stream_sample = &object->IDirectDrawStreamSample_iface;
1382
1383     return S_OK;
1384 }
1385
1386 typedef struct {
1387     IAudioStreamSample IAudioStreamSample_iface;
1388     LONG ref;
1389     IMediaStream *parent;
1390     IAudioData *audio_data;
1391 } IAudioStreamSampleImpl;
1392
1393 static inline IAudioStreamSampleImpl *impl_from_IAudioStreamSample(IAudioStreamSample *iface)
1394 {
1395     return CONTAINING_RECORD(iface, IAudioStreamSampleImpl, IAudioStreamSample_iface);
1396 }
1397
1398 /*** IUnknown methods ***/
1399 static HRESULT WINAPI IAudioStreamSampleImpl_QueryInterface(IAudioStreamSample *iface,
1400         REFIID riid, void **ret_iface)
1401 {
1402     TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(riid), ret_iface);
1403
1404     if (IsEqualGUID(riid, &IID_IUnknown) ||
1405         IsEqualGUID(riid, &IID_IStreamSample) ||
1406         IsEqualGUID(riid, &IID_IAudioStreamSample))
1407     {
1408         IAudioStreamSample_AddRef(iface);
1409         *ret_iface = iface;
1410         return S_OK;
1411     }
1412
1413     *ret_iface = NULL;
1414
1415     ERR("(%p)->(%s,%p),not found\n", iface, debugstr_guid(riid), ret_iface);
1416     return E_NOINTERFACE;
1417 }
1418
1419 static ULONG WINAPI IAudioStreamSampleImpl_AddRef(IAudioStreamSample *iface)
1420 {
1421     IAudioStreamSampleImpl *This = impl_from_IAudioStreamSample(iface);
1422     ULONG ref = InterlockedIncrement(&This->ref);
1423
1424     TRACE("(%p)->(): new ref = %u\n", iface, ref);
1425
1426     return ref;
1427 }
1428
1429 static ULONG WINAPI IAudioStreamSampleImpl_Release(IAudioStreamSample *iface)
1430 {
1431     IAudioStreamSampleImpl *This = impl_from_IAudioStreamSample(iface);
1432     ULONG ref = InterlockedDecrement(&This->ref);
1433
1434     TRACE("(%p)->(): new ref = %u\n", iface, ref);
1435
1436     if (!ref)
1437         HeapFree(GetProcessHeap(), 0, This);
1438
1439     return ref;
1440 }
1441
1442 /*** IStreamSample methods ***/
1443 static HRESULT WINAPI IAudioStreamSampleImpl_GetMediaStream(IAudioStreamSample *iface, IMediaStream **media_stream)
1444 {
1445     FIXME("(%p)->(%p): stub\n", iface, media_stream);
1446
1447     return E_NOTIMPL;
1448 }
1449
1450 static HRESULT WINAPI IAudioStreamSampleImpl_GetSampleTimes(IAudioStreamSample *iface, STREAM_TIME *start_time,
1451                                                                  STREAM_TIME *end_time, STREAM_TIME *current_time)
1452 {
1453     FIXME("(%p)->(%p,%p,%p): stub\n", iface, start_time, end_time, current_time);
1454
1455     return E_NOTIMPL;
1456 }
1457
1458 static HRESULT WINAPI IAudioStreamSampleImpl_SetSampleTimes(IAudioStreamSample *iface, const STREAM_TIME *start_time,
1459                                                                  const STREAM_TIME *end_time)
1460 {
1461     FIXME("(%p)->(%p,%p): stub\n", iface, start_time, end_time);
1462
1463     return E_NOTIMPL;
1464 }
1465
1466 static HRESULT WINAPI IAudioStreamSampleImpl_Update(IAudioStreamSample *iface, DWORD flags, HANDLE event,
1467                                                          PAPCFUNC func_APC, DWORD APC_data)
1468 {
1469     FIXME("(%p)->(%x,%p,%p,%u): stub\n", iface, flags, event, func_APC, APC_data);
1470
1471     return E_NOTIMPL;
1472 }
1473
1474 static HRESULT WINAPI IAudioStreamSampleImpl_CompletionStatus(IAudioStreamSample *iface, DWORD flags, DWORD milliseconds)
1475 {
1476     FIXME("(%p)->(%x,%u): stub\n", iface, flags, milliseconds);
1477
1478     return E_NOTIMPL;
1479 }
1480
1481 /*** IAudioStreamSample methods ***/
1482 static HRESULT WINAPI IAudioStreamSampleImpl_GetAudioData(IAudioStreamSample *iface, IAudioData **audio_data)
1483 {
1484     FIXME("(%p)->(%p): stub\n", iface, audio_data);
1485
1486     return E_NOTIMPL;
1487 }
1488
1489 static const struct IAudioStreamSampleVtbl AudioStreamSample_Vtbl =
1490 {
1491     /*** IUnknown methods ***/
1492     IAudioStreamSampleImpl_QueryInterface,
1493     IAudioStreamSampleImpl_AddRef,
1494     IAudioStreamSampleImpl_Release,
1495     /*** IStreamSample methods ***/
1496     IAudioStreamSampleImpl_GetMediaStream,
1497     IAudioStreamSampleImpl_GetSampleTimes,
1498     IAudioStreamSampleImpl_SetSampleTimes,
1499     IAudioStreamSampleImpl_Update,
1500     IAudioStreamSampleImpl_CompletionStatus,
1501     /*** IAudioStreamSample methods ***/
1502     IAudioStreamSampleImpl_GetAudioData
1503 };
1504
1505 static HRESULT audiostreamsample_create(IAudioMediaStream *parent, IAudioData *audio_data, IAudioStreamSample **audio_stream_sample)
1506 {
1507     IAudioStreamSampleImpl *object;
1508
1509     TRACE("(%p)\n", audio_stream_sample);
1510
1511     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAudioStreamSampleImpl));
1512     if (!object)
1513         return E_OUTOFMEMORY;
1514
1515     object->IAudioStreamSample_iface.lpVtbl = &AudioStreamSample_Vtbl;
1516     object->ref = 1;
1517     object->parent = (IMediaStream*)parent;
1518     object->audio_data = audio_data;
1519
1520     *audio_stream_sample = (IAudioStreamSample*)&object->IAudioStreamSample_iface;
1521
1522     return S_OK;
1523 }