dlls/amstream/amstream.c

   1 /*
   2  * Implementation of IAMMultiMediaStream Interface
   3  *
   4  * Copyright 2004, 2012 Christian Costa
   5  * Copyright 2006 Ivan Leo Puoti
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "wine/debug.h"
  23
  24 #define COBJMACROS
  25
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28
  29 #include "amstream_private.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(amstream);
  32
  33 typedef struct {
  34     IAMMultiMediaStream IAMMultiMediaStream_iface;
  35     LONG ref;
  36     IGraphBuilder* pFilterGraph;
  37     IMediaSeeking* media_seeking;
  38     IMediaControl* media_control;
  39     IMediaStreamFilter *media_stream_filter;
  40     IPin* ipin;
  41     ULONG nbStreams;
  42     IAMMediaStream **pStreams;
  43     STREAM_TYPE StreamType;
  44     OAEVENT event;
  45 } IAMMultiMediaStreamImpl;
  46
  47 static inline IAMMultiMediaStreamImpl *impl_from_IAMMultiMediaStream(IAMMultiMediaStream *iface)
  48 {
  49     return CONTAINING_RECORD(iface, IAMMultiMediaStreamImpl, IAMMultiMediaStream_iface);
  50 }
  51
  52 static const struct IAMMultiMediaStreamVtbl AM_Vtbl;
  53
  54 HRESULT AM_create(IUnknown *pUnkOuter, LPVOID *ppObj)
  55 {
  56     IAMMultiMediaStreamImpl* object;
  57
  58     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
  59
  60     if( pUnkOuter )
  61         return CLASS_E_NOAGGREGATION;
  62
  63     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAMMultiMediaStreamImpl));
  64     if (!object)
  65         return E_OUTOFMEMORY;
  66
  67     object->IAMMultiMediaStream_iface.lpVtbl = &AM_Vtbl;
  68     object->ref = 1;
  69
  70     *ppObj = &object->IAMMultiMediaStream_iface;
  71
  72     return S_OK;
  73 }
  74
  75 /*** IUnknown methods ***/
  76 static HRESULT WINAPI IAMMultiMediaStreamImpl_QueryInterface(IAMMultiMediaStream* iface, REFIID riid, void** ppvObject)
  77 {
  78     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
  79
  80     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
  81
  82     if (IsEqualGUID(riid, &IID_IUnknown) ||
  83         IsEqualGUID(riid, &IID_IMultiMediaStream) ||
  84         IsEqualGUID(riid, &IID_IAMMultiMediaStream))
  85     {
  86         IAMMultiMediaStream_AddRef(iface);
  87         *ppvObject = iface;
  88         return S_OK;
  89     }
  90
  91     ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
  92
  93     return E_NOINTERFACE;
  94 }
  95
  96 static ULONG WINAPI IAMMultiMediaStreamImpl_AddRef(IAMMultiMediaStream* iface)
  97 {
  98     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
  99
 100     TRACE("(%p/%p)\n", iface, This);
 101
 102     return InterlockedIncrement(&This->ref);
 103 }
 104
 105 static ULONG WINAPI IAMMultiMediaStreamImpl_Release(IAMMultiMediaStream* iface)
 106 {
 107     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 108     ULONG ref = InterlockedDecrement(&This->ref);
 109     ULONG i;
 110
 111     TRACE("(%p/%p)\n", iface, This);
 112
 113     if (!ref)
 114     {
 115         for(i = 0; i < This->nbStreams; i++)
 116             IAMMediaStream_Release(This->pStreams[i]);
 117         CoTaskMemFree(This->pStreams);
 118         if (This->ipin)
 119             IPin_Release(This->ipin);
 120         if (This->media_stream_filter)
 121             IMediaStreamFilter_Release(This->media_stream_filter);
 122         if (This->media_seeking)
 123             IMediaSeeking_Release(This->media_seeking);
 124         if (This->media_control)
 125             IMediaControl_Release(This->media_control);
 126         if (This->pFilterGraph)
 127             IGraphBuilder_Release(This->pFilterGraph);
 128         HeapFree(GetProcessHeap(), 0, This);
 129     }
 130
 131     return ref;
 132 }
 133
 134 /*** IMultiMediaStream methods ***/
 135 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetInformation(IAMMultiMediaStream* iface, DWORD* pdwFlags, STREAM_TYPE* pStreamType)
 136 {
 137     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 138
 139     FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pdwFlags, pStreamType);
 140
 141     return E_NOTIMPL;
 142 }
 143
 144 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetMediaStream(IAMMultiMediaStream* iface, REFMSPID idPurpose, IMediaStream** ppMediaStream)
 145 {
 146     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 147     MSPID PurposeId;
 148     unsigned int i;
 149
 150     TRACE("(%p/%p)->(%s,%p)\n", This, iface, debugstr_guid(idPurpose), ppMediaStream);
 151
 152     for (i = 0; i < This->nbStreams; i++)
 153     {
 154         IAMMediaStream_GetInformation(This->pStreams[i], &PurposeId, NULL);
 155         if (IsEqualIID(&PurposeId, idPurpose))
 156         {
 157             *ppMediaStream = (IMediaStream*)This->pStreams[i];
 158             IMediaStream_AddRef(*ppMediaStream);
 159             return S_OK;
 160         }
 161     }
 162
 163     return MS_E_NOSTREAM;
 164 }
 165
 166 static HRESULT WINAPI IAMMultiMediaStreamImpl_EnumMediaStreams(IAMMultiMediaStream* iface, LONG Index, IMediaStream** ppMediaStream)
 167 {
 168     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 169
 170     FIXME("(%p/%p)->(%d,%p) stub!\n", This, iface, Index, ppMediaStream);
 171
 172     return E_NOTIMPL;
 173 }
 174
 175 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetState(IAMMultiMediaStream* iface, STREAM_STATE* pCurrentState)
 176 {
 177     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 178
 179     FIXME("(%p/%p)->(%p) stub!\n", This, iface, pCurrentState);
 180
 181     return E_NOTIMPL;
 182 }
 183
 184 static HRESULT WINAPI IAMMultiMediaStreamImpl_SetState(IAMMultiMediaStream* iface, STREAM_STATE new_state)
 185 {
 186     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 187     HRESULT hr = E_INVALIDARG;
 188
 189     TRACE("(%p/%p)->(%u)\n", This, iface, new_state);
 190
 191     if (new_state == STREAMSTATE_RUN)
 192         hr = IMediaControl_Run(This->media_control);
 193     else if (new_state == STREAMSTATE_STOP)
 194         hr = IMediaControl_Stop(This->media_control);
 195
 196     return hr;
 197 }
 198
 199 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetTime(IAMMultiMediaStream* iface, STREAM_TIME* pCurrentTime)
 200 {
 201     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 202
 203     FIXME("(%p/%p)->(%p) stub!\n", This, iface, pCurrentTime);
 204
 205     return E_NOTIMPL;
 206 }
 207
 208 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetDuration(IAMMultiMediaStream* iface, STREAM_TIME* pDuration)
 209 {
 210     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 211
 212     FIXME("(%p/%p)->(%p) stub!\n", This, iface, pDuration);
 213
 214     return E_NOTIMPL;
 215 }
 216
 217 static HRESULT WINAPI IAMMultiMediaStreamImpl_Seek(IAMMultiMediaStream* iface, STREAM_TIME seek_time)
 218 {
 219     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 220
 221     TRACE("(%p/%p)->(%s)\n", This, iface, wine_dbgstr_longlong(seek_time));
 222
 223     return IMediaSeeking_SetPositions(This->media_seeking, &seek_time, AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
 224 }
 225
 226 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetEndOfStream(IAMMultiMediaStream* iface, HANDLE* phEOS)
 227 {
 228     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 229
 230     FIXME("(%p/%p)->(%p) stub!\n", This, iface, phEOS);
 231
 232     return E_NOTIMPL;
 233 }
 234
 235 /*** IAMMultiMediaStream methods ***/
 236 static HRESULT WINAPI IAMMultiMediaStreamImpl_Initialize(IAMMultiMediaStream* iface, STREAM_TYPE StreamType, DWORD dwFlags, IGraphBuilder* pFilterGraph)
 237 {
 238     static const WCHAR filternameW[] = {'M','e','d','i','a','S','t','r','e','a','m','F','i','l','t','e','r',0};
 239     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 240     HRESULT hr = S_OK;
 241
 242     TRACE("(%p/%p)->(%x,%x,%p)\n", This, iface, (DWORD)StreamType, dwFlags, pFilterGraph);
 243
 244     if (pFilterGraph)
 245     {
 246         This->pFilterGraph = pFilterGraph;
 247         IGraphBuilder_AddRef(This->pFilterGraph);
 248     }
 249     else
 250     {
 251         hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, (LPVOID*)&This->pFilterGraph);
 252     }
 253
 254     if (SUCCEEDED(hr))
 255     {
 256         This->StreamType = StreamType;
 257         hr = IGraphBuilder_QueryInterface(This->pFilterGraph, &IID_IMediaSeeking, (void**)&This->media_seeking);
 258         if (SUCCEEDED(hr))
 259             hr = IGraphBuilder_QueryInterface(This->pFilterGraph, &IID_IMediaControl, (void**)&This->media_control);
 260         if (SUCCEEDED(hr))
 261             hr = CoCreateInstance(&CLSID_MediaStreamFilter, NULL, CLSCTX_INPROC_SERVER, &IID_IMediaStreamFilter, (void**)&This->media_stream_filter);
 262         if (SUCCEEDED(hr))
 263             hr = IGraphBuilder_AddFilter(This->pFilterGraph, (IBaseFilter*)This->media_stream_filter, filternameW);
 264         if (SUCCEEDED(hr))
 265         {
 266             IMediaEventEx* media_event = NULL;
 267             hr = IGraphBuilder_QueryInterface(This->pFilterGraph, &IID_IMediaEventEx, (void**)&media_event);
 268             if (SUCCEEDED(hr))
 269                 hr = IMediaEventEx_GetEventHandle(media_event, &This->event);
 270             if (SUCCEEDED(hr))
 271                 hr = IMediaEventEx_SetNotifyFlags(media_event, AM_MEDIAEVENT_NONOTIFY);
 272             if (media_event)
 273                 IMediaEventEx_Release(media_event);
 274         }
 275     }
 276
 277     if (FAILED(hr))
 278     {
 279         if (This->media_stream_filter)
 280             IMediaStreamFilter_Release(This->media_stream_filter);
 281         This->media_stream_filter = NULL;
 282         if (This->media_seeking)
 283             IMediaSeeking_Release(This->media_seeking);
 284         This->media_seeking = NULL;
 285         if (This->media_control)
 286             IMediaControl_Release(This->media_control);
 287         This->media_control = NULL;
 288         if (This->pFilterGraph)
 289             IGraphBuilder_Release(This->pFilterGraph);
 290         This->pFilterGraph = NULL;
 291     }
 292
 293     return hr;
 294 }
 295
 296 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetFilterGraph(IAMMultiMediaStream* iface, IGraphBuilder** ppGraphBuilder)
 297 {
 298     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 299
 300     TRACE("(%p/%p)->(%p)\n", This, iface, ppGraphBuilder);
 301
 302     if (!ppGraphBuilder)
 303         return E_POINTER;
 304
 305     if (This->pFilterGraph)
 306         return IGraphBuilder_QueryInterface(This->pFilterGraph, &IID_IGraphBuilder, (void**)ppGraphBuilder);
 307     else
 308         *ppGraphBuilder = NULL;
 309
 310     return S_OK;
 311 }
 312
 313 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetFilter(IAMMultiMediaStream* iface, IMediaStreamFilter** ppFilter)
 314 {
 315     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 316
 317     TRACE("(%p/%p)->(%p)\n", This, iface, ppFilter);
 318
 319     if (!ppFilter)
 320         return E_POINTER;
 321
 322     *ppFilter = This->media_stream_filter;
 323     if (*ppFilter)
 324         IMediaStreamFilter_AddRef(*ppFilter);
 325
 326     return S_OK;
 327 }
 328
 329 static HRESULT WINAPI IAMMultiMediaStreamImpl_AddMediaStream(IAMMultiMediaStream* iface, IUnknown* stream_object, const MSPID* PurposeId,
 330                                           DWORD dwFlags, IMediaStream** ppNewStream)
 331 {
 332     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 333     HRESULT hr;
 334     IAMMediaStream* pStream;
 335     IAMMediaStream** pNewStreams;
 336
 337     TRACE("(%p/%p)->(%p,%s,%x,%p)\n", This, iface, stream_object, debugstr_guid(PurposeId), dwFlags, ppNewStream);
 338
 339     if (!IsEqualGUID(PurposeId, &MSPID_PrimaryVideo) && !IsEqualGUID(PurposeId, &MSPID_PrimaryAudio))
 340         return MS_E_PURPOSEID;
 341
 342     if (dwFlags & AMMSF_ADDDEFAULTRENDERER)
 343     {
 344         if (IsEqualGUID(PurposeId, &MSPID_PrimaryVideo))
 345         {
 346             /* Default renderer not supported by video stream */
 347             return MS_E_PURPOSEID;
 348         }
 349         else
 350         {
 351             IBaseFilter* dsoundrender_filter;
 352
 353             /* Create the default renderer for audio */
 354             hr = CoCreateInstance(&CLSID_DSoundRender, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&dsoundrender_filter);
 355             if (SUCCEEDED(hr))
 356             {
 357                  hr = IGraphBuilder_AddFilter(This->pFilterGraph, dsoundrender_filter, NULL);
 358                  IBaseFilter_Release(dsoundrender_filter);
 359             }
 360
 361             /* No media stream created when the default renderer is used */
 362             return hr;
 363         }
 364     }
 365
 366     if (IsEqualGUID(PurposeId, &MSPID_PrimaryVideo))
 367         hr = ddrawmediastream_create((IMultiMediaStream*)iface, PurposeId, stream_object, This->StreamType, &pStream);
 368     else
 369         hr = audiomediastream_create((IMultiMediaStream*)iface, PurposeId, stream_object, This->StreamType, &pStream);
 370     if (SUCCEEDED(hr))
 371     {
 372         pNewStreams = CoTaskMemRealloc(This->pStreams, (This->nbStreams+1) * sizeof(IAMMediaStream*));
 373         if (!pNewStreams)
 374         {
 375             IAMMediaStream_Release(pStream);
 376             return E_OUTOFMEMORY;
 377         }
 378         This->pStreams = pNewStreams;
 379         This->pStreams[This->nbStreams] = pStream;
 380         This->nbStreams++;
 381
 382         if (ppNewStream)
 383             *ppNewStream = (IMediaStream*)pStream;
 384     }
 385
 386     if (SUCCEEDED(hr))
 387     {
 388         /* Add stream to the media stream filter */
 389         IMediaStreamFilter_AddMediaStream(This->media_stream_filter, pStream);
 390     }
 391
 392     return hr;
 393 }
 394
 395 static HRESULT WINAPI IAMMultiMediaStreamImpl_OpenFile(IAMMultiMediaStream* iface, LPCWSTR filename, DWORD flags)
 396 {
 397     static const WCHAR sourceW[] = {'S','o','u','r','c','e',0};
 398     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 399     HRESULT ret = S_OK;
 400     IBaseFilter *BaseFilter = NULL;
 401     IEnumPins *EnumPins = NULL;
 402     IPin *ipin;
 403     PIN_DIRECTION pin_direction;
 404
 405     TRACE("(%p/%p)->(%s,%x)\n", This, iface, debugstr_w(filename), flags);
 406
 407     if (!filename)
 408         return E_POINTER;
 409
 410     /* If Initialize was not called before, we do it here */
 411     if (!This->pFilterGraph)
 412         ret = IAMMultiMediaStream_Initialize(iface, STREAMTYPE_READ, 0, NULL);
 413
 414     if (SUCCEEDED(ret))
 415         ret = IGraphBuilder_AddSourceFilter(This->pFilterGraph, filename, sourceW, &BaseFilter);
 416
 417     if (SUCCEEDED(ret))
 418         ret = IBaseFilter_EnumPins(BaseFilter, &EnumPins);
 419
 420     if (SUCCEEDED(ret))
 421         ret = IEnumPins_Next(EnumPins, 1, &ipin, NULL);
 422
 423     if (SUCCEEDED(ret))
 424     {
 425         ret = IPin_QueryDirection(ipin, &pin_direction);
 426         if (ret == S_OK && pin_direction == PINDIR_OUTPUT)
 427             This->ipin = ipin;
 428     }
 429
 430     if (SUCCEEDED(ret) && !(flags & AMMSF_NORENDER))
 431         ret = IGraphBuilder_Render(This->pFilterGraph, This->ipin);
 432
 433     if (EnumPins)
 434         IEnumPins_Release(EnumPins);
 435     if (BaseFilter)
 436         IBaseFilter_Release(BaseFilter);
 437     return ret;
 438 }
 439
 440 static HRESULT WINAPI IAMMultiMediaStreamImpl_OpenMoniker(IAMMultiMediaStream* iface, IBindCtx* pCtx, IMoniker* pMoniker, DWORD dwFlags)
 441 {
 442     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 443
 444     FIXME("(%p/%p)->(%p,%p,%x) stub!\n", This, iface, pCtx, pMoniker, dwFlags);
 445
 446     return E_NOTIMPL;
 447 }
 448
 449 static HRESULT WINAPI IAMMultiMediaStreamImpl_Render(IAMMultiMediaStream* iface, DWORD dwFlags)
 450 {
 451     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 452
 453     FIXME("(%p/%p)->(%x) partial stub!\n", This, iface, dwFlags);
 454
 455     if(dwFlags != AMMSF_NOCLOCK)
 456         return E_INVALIDARG;
 457
 458     return IGraphBuilder_Render(This->pFilterGraph, This->ipin);
 459 }
 460
 461 static const IAMMultiMediaStreamVtbl AM_Vtbl =
 462 {
 463     IAMMultiMediaStreamImpl_QueryInterface,
 464     IAMMultiMediaStreamImpl_AddRef,
 465     IAMMultiMediaStreamImpl_Release,
 466     IAMMultiMediaStreamImpl_GetInformation,
 467     IAMMultiMediaStreamImpl_GetMediaStream,
 468     IAMMultiMediaStreamImpl_EnumMediaStreams,
 469     IAMMultiMediaStreamImpl_GetState,
 470     IAMMultiMediaStreamImpl_SetState,
 471     IAMMultiMediaStreamImpl_GetTime,
 472     IAMMultiMediaStreamImpl_GetDuration,
 473     IAMMultiMediaStreamImpl_Seek,
 474     IAMMultiMediaStreamImpl_GetEndOfStream,
 475     IAMMultiMediaStreamImpl_Initialize,
 476     IAMMultiMediaStreamImpl_GetFilterGraph,
 477     IAMMultiMediaStreamImpl_GetFilter,
 478     IAMMultiMediaStreamImpl_AddMediaStream,
 479     IAMMultiMediaStreamImpl_OpenFile,
 480     IAMMultiMediaStreamImpl_OpenMoniker,
 481     IAMMultiMediaStreamImpl_Render
 482 };