git.oblomov.eu Git - wine/blob - 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 #include "amstream.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(amstream);
  33
  34 typedef struct {
  35     IAMMultiMediaStream IAMMultiMediaStream_iface;
  36     LONG ref;
  37     IGraphBuilder* pFilterGraph;
  38     IMediaSeeking* media_seeking;
  39     IMediaControl* media_control;
  40     IBaseFilter* media_stream_filter;
  41     IPin* ipin;
  42     ULONG nbStreams;
  43     IMediaStream** pStreams;
  44     STREAM_TYPE StreamType;
  45     OAEVENT event;
  46 } IAMMultiMediaStreamImpl;
  47
  48 static inline IAMMultiMediaStreamImpl *impl_from_IAMMultiMediaStream(IAMMultiMediaStream *iface)
  49 {
  50     return CONTAINING_RECORD(iface, IAMMultiMediaStreamImpl, IAMMultiMediaStream_iface);
  51 }
  52
  53 static const struct IAMMultiMediaStreamVtbl AM_Vtbl;
  54
  55 HRESULT AM_create(IUnknown *pUnkOuter, LPVOID *ppObj)
  56 {
  57     IAMMultiMediaStreamImpl* object;
  58
  59     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
  60
  61     if( pUnkOuter )
  62         return CLASS_E_NOAGGREGATION;
  63
  64     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAMMultiMediaStreamImpl));
  65     if (!object)
  66     {
  67         ERR("Out of memory\n");
  68         return E_OUTOFMEMORY;
  69     }
  70
  71     object->IAMMultiMediaStream_iface.lpVtbl = &AM_Vtbl;
  72     object->ref = 1;
  73
  74     *ppObj = object;
  75
  76     return S_OK;
  77 }
  78
  79 /*** IUnknown methods ***/
  80 static HRESULT WINAPI IAMMultiMediaStreamImpl_QueryInterface(IAMMultiMediaStream* iface, REFIID riid, void** ppvObject)
  81 {
  82     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
  83
  84     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
  85
  86     if (IsEqualGUID(riid, &IID_IUnknown) ||
  87         IsEqualGUID(riid, &IID_IMultiMediaStream) ||
  88         IsEqualGUID(riid, &IID_IAMMultiMediaStream))
  89     {
  90         IUnknown_AddRef(iface);
  91         *ppvObject = This;
  92         return S_OK;
  93     }
  94
  95     ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
  96
  97     return E_NOINTERFACE;
  98 }
  99
 100 static ULONG WINAPI IAMMultiMediaStreamImpl_AddRef(IAMMultiMediaStream* iface)
 101 {
 102     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 103
 104     TRACE("(%p/%p)\n", iface, This);
 105
 106     return InterlockedIncrement(&This->ref);
 107 }
 108
 109 static ULONG WINAPI IAMMultiMediaStreamImpl_Release(IAMMultiMediaStream* iface)
 110 {
 111     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 112     ULONG ref = InterlockedDecrement(&This->ref);
 113     ULONG i;
 114
 115     TRACE("(%p/%p)\n", iface, This);
 116
 117     if (!ref)
 118     {
 119         for(i = 0; i < This->nbStreams; i++)
 120             IMediaStream_Release(This->pStreams[i]);
 121         if (This->ipin)
 122             IPin_Release(This->ipin);
 123         if (This->media_stream_filter)
 124             IBaseFilter_Release(This->media_stream_filter);
 125         if (This->media_seeking)
 126             IMediaSeeking_Release(This->media_seeking);
 127         if (This->media_control)
 128             IMediaControl_Release(This->media_control);
 129         if (This->pFilterGraph)
 130             IGraphBuilder_Release(This->pFilterGraph);
 131         HeapFree(GetProcessHeap(), 0, This);
 132     }
 133
 134     return ref;
 135 }
 136
 137 /*** IMultiMediaStream methods ***/
 138 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetInformation(IAMMultiMediaStream* iface, DWORD* pdwFlags, STREAM_TYPE* pStreamType)
 139 {
 140     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 141
 142     FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pdwFlags, pStreamType);
 143
 144     return E_NOTIMPL;
 145 }
 146
 147 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetMediaStream(IAMMultiMediaStream* iface, REFMSPID idPurpose, IMediaStream** ppMediaStream)
 148 {
 149     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 150     MSPID PurposeId;
 151     unsigned int i;
 152
 153     TRACE("(%p/%p)->(%s,%p)\n", This, iface, debugstr_guid(idPurpose), ppMediaStream);
 154
 155     for (i = 0; i < This->nbStreams; i++)
 156     {
 157         IMediaStream_GetInformation(This->pStreams[i], &PurposeId, NULL);
 158         if (IsEqualIID(&PurposeId, idPurpose))
 159         {
 160             *ppMediaStream = This->pStreams[i];
 161             IMediaStream_AddRef(*ppMediaStream);
 162             return S_OK;
 163         }
 164     }
 165
 166     return MS_E_NOSTREAM;
 167 }
 168
 169 static HRESULT WINAPI IAMMultiMediaStreamImpl_EnumMediaStreams(IAMMultiMediaStream* iface, LONG Index, IMediaStream** ppMediaStream)
 170 {
 171     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 172
 173     FIXME("(%p/%p)->(%d,%p) stub!\n", This, iface, Index, ppMediaStream);
 174
 175     return E_NOTIMPL;
 176 }
 177
 178 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetState(IAMMultiMediaStream* iface, STREAM_STATE* pCurrentState)
 179 {
 180     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 181
 182     FIXME("(%p/%p)->(%p) stub!\n", This, iface, pCurrentState);
 183
 184     return E_NOTIMPL;
 185 }
 186
 187 static HRESULT WINAPI IAMMultiMediaStreamImpl_SetState(IAMMultiMediaStream* iface, STREAM_STATE NewState)
 188 {
 189     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 190
 191     FIXME("(%p/%p)->() stub!\n", This, iface);
 192
 193     return E_NOTIMPL;
 194 }
 195
 196 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetTime(IAMMultiMediaStream* iface, STREAM_TIME* pCurrentTime)
 197 {
 198     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 199
 200     FIXME("(%p/%p)->(%p) stub!\n", This, iface, pCurrentTime);
 201
 202     return E_NOTIMPL;
 203 }
 204
 205 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetDuration(IAMMultiMediaStream* iface, STREAM_TIME* pDuration)
 206 {
 207     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 208
 209     FIXME("(%p/%p)->(%p) stub!\n", This, iface, pDuration);
 210
 211     return E_NOTIMPL;
 212 }
 213
 214 static HRESULT WINAPI IAMMultiMediaStreamImpl_Seek(IAMMultiMediaStream* iface, STREAM_TIME SeekTime)
 215 {
 216     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 217
 218     FIXME("(%p/%p)->() stub!\n", This, iface);
 219
 220     return E_NOTIMPL;
 221 }
 222
 223 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetEndOfStream(IAMMultiMediaStream* iface, HANDLE* phEOS)
 224 {
 225     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 226
 227     FIXME("(%p/%p)->(%p) stub!\n", This, iface, phEOS);
 228
 229     return E_NOTIMPL;
 230 }
 231
 232 /*** IAMMultiMediaStream methods ***/
 233 static HRESULT WINAPI IAMMultiMediaStreamImpl_Initialize(IAMMultiMediaStream* iface, STREAM_TYPE StreamType, DWORD dwFlags, IGraphBuilder* pFilterGraph)
 234 {
 235     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 236     HRESULT hr = S_OK;
 237     const WCHAR filternameW[] = {'M','e','d','i','a','S','t','r','e','a','m','F','i','l','t','e','r',0};
 238
 239     TRACE("(%p/%p)->(%x,%x,%p)\n", This, iface, (DWORD)StreamType, dwFlags, pFilterGraph);
 240
 241     if (pFilterGraph)
 242     {
 243         This->pFilterGraph = pFilterGraph;
 244         IGraphBuilder_AddRef(This->pFilterGraph);
 245     }
 246     else
 247     {
 248         hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, (LPVOID*)&This->pFilterGraph);
 249     }
 250
 251     if (SUCCEEDED(hr))
 252     {
 253         This->StreamType = StreamType;
 254         hr = IGraphBuilder_QueryInterface(This->pFilterGraph, &IID_IMediaSeeking, (void**)&This->media_seeking);
 255         if (SUCCEEDED(hr))
 256             IGraphBuilder_QueryInterface(This->pFilterGraph, &IID_IMediaControl, (void**)&This->media_control);
 257         if (SUCCEEDED(hr))
 258             hr = CoCreateInstance(&CLSID_MediaStreamFilter, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&This->media_stream_filter);
 259         if (SUCCEEDED(hr))
 260             IGraphBuilder_AddFilter(This->pFilterGraph, This->media_stream_filter, filternameW);
 261         if (SUCCEEDED(hr))
 262         {
 263             IMediaEventEx* media_event = NULL;
 264             hr = IGraphBuilder_QueryInterface(This->pFilterGraph, &IID_IMediaEventEx, (void**)&media_event);
 265             if (SUCCEEDED(hr))
 266                 hr = IMediaEventEx_GetEventHandle(media_event, &This->event);
 267             if (SUCCEEDED(hr))
 268                 hr = IMediaEventEx_SetNotifyFlags(media_event, AM_MEDIAEVENT_NONOTIFY);
 269             if (media_event)
 270                 IMediaEventEx_Release(media_event);
 271         }
 272     }
 273
 274     if (FAILED(hr))
 275     {
 276         if (This->media_stream_filter)
 277             IBaseFilter_Release(This->media_stream_filter);
 278         This->media_stream_filter = NULL;
 279         if (This->media_seeking)
 280             IMediaSeeking_Release(This->media_seeking);
 281         This->media_seeking = NULL;
 282         if (This->media_control)
 283             IMediaControl_Release(This->media_control);
 284         This->media_control = NULL;
 285         if (This->pFilterGraph)
 286             IGraphBuilder_Release(This->pFilterGraph);
 287         This->pFilterGraph = NULL;
 288     }
 289
 290     return hr;
 291 }
 292
 293 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetFilterGraph(IAMMultiMediaStream* iface, IGraphBuilder** ppGraphBuilder)
 294 {
 295     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 296
 297     TRACE("(%p/%p)->(%p)\n", This, iface, ppGraphBuilder);
 298
 299     if (!ppGraphBuilder)
 300         return E_POINTER;
 301
 302     if (This->pFilterGraph)
 303         return IFilterGraph_QueryInterface(This->pFilterGraph, &IID_IGraphBuilder, (void**)ppGraphBuilder);
 304     else
 305         *ppGraphBuilder = NULL;
 306
 307     return S_OK;
 308 }
 309
 310 static HRESULT WINAPI IAMMultiMediaStreamImpl_GetFilter(IAMMultiMediaStream* iface, IMediaStreamFilter** ppFilter)
 311 {
 312     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 313     HRESULT hr = S_OK;
 314
 315     TRACE("(%p/%p)->(%p)\n", This, iface, ppFilter);
 316
 317     if (!ppFilter)
 318         return E_POINTER;
 319
 320     *ppFilter = NULL;
 321
 322     if (This->media_stream_filter)
 323         hr = IBaseFilter_QueryInterface(This->media_stream_filter, &IID_IMediaStreamFilter, (LPVOID*)ppFilter);
 324
 325     return hr;
 326 }
 327
 328 static HRESULT WINAPI IAMMultiMediaStreamImpl_AddMediaStream(IAMMultiMediaStream* iface, IUnknown* pStreamObject, const MSPID* PurposeId,
 329                                           DWORD dwFlags, IMediaStream** ppNewStream)
 330 {
 331     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 332     HRESULT hr;
 333     IMediaStream* pStream;
 334     IMediaStream** pNewStreams;
 335
 336     FIXME("(%p/%p)->(%p,%s,%x,%p) partial stub!\n", This, iface, pStreamObject, debugstr_guid(PurposeId), dwFlags, ppNewStream);
 337
 338     if (!IsEqualGUID(PurposeId, &MSPID_PrimaryVideo) && !IsEqualGUID(PurposeId, &MSPID_PrimaryAudio))
 339         return MS_E_PURPOSEID;
 340
 341     if (dwFlags & AMMSF_ADDDEFAULTRENDERER)
 342     {
 343         if (IsEqualGUID(PurposeId, &MSPID_PrimaryVideo))
 344         {
 345             /* Default renderer not supported by video stream */
 346             return MS_E_PURPOSEID;
 347         }
 348         else
 349         {
 350             IBaseFilter* dsoundrender_filter;
 351
 352             /* Create the default renderer for audio */
 353             hr = CoCreateInstance(&CLSID_DSoundRender, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&dsoundrender_filter);
 354             if (SUCCEEDED(hr))
 355             {
 356                  hr = IGraphBuilder_AddFilter(This->pFilterGraph, dsoundrender_filter, NULL);
 357                  IBaseFilter_Release(dsoundrender_filter);
 358             }
 359
 360             /* No media stream created when the default renderer is used */
 361             return hr;
 362         }
 363     }
 364
 365     hr = mediastream_create((IMultiMediaStream*)iface, PurposeId, This->StreamType, &pStream);
 366     if (SUCCEEDED(hr))
 367     {
 368         pNewStreams = CoTaskMemRealloc(This->pStreams, (This->nbStreams+1) * sizeof(IMediaStream*));
 369         if (!pNewStreams)
 370         {
 371             IMediaStream_Release(pStream);
 372             return E_OUTOFMEMORY;
 373         }
 374         This->pStreams = pNewStreams;
 375         This->pStreams[This->nbStreams] = pStream;
 376         This->nbStreams++;
 377
 378         if (ppNewStream)
 379             *ppNewStream = pStream;
 380     }
 381
 382     return hr;
 383 }
 384
 385 static HRESULT WINAPI IAMMultiMediaStreamImpl_OpenFile(IAMMultiMediaStream* iface, LPCWSTR pszFileName, DWORD dwFlags)
 386 {
 387     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 388     HRESULT ret = S_OK;
 389     IBaseFilter *BaseFilter = NULL;
 390     IEnumPins *EnumPins = NULL;
 391     IPin *ipin;
 392     PIN_DIRECTION pin_direction;
 393     const WCHAR sourceW[] = {'S','o','u','r','c','e',0};
 394
 395     TRACE("(%p/%p)->(%s,%x)\n", This, iface, debugstr_w(pszFileName), dwFlags);
 396
 397     /* If Initialize was not called before, we do it here */
 398     if (!This->pFilterGraph)
 399         ret = IAMMultiMediaStream_Initialize(iface, STREAMTYPE_READ, 0, NULL);
 400
 401     if (SUCCEEDED(ret))
 402         ret = IGraphBuilder_AddSourceFilter(This->pFilterGraph, pszFileName, sourceW, &BaseFilter);
 403
 404     if (SUCCEEDED(ret))
 405         ret = IBaseFilter_EnumPins(BaseFilter, &EnumPins);
 406
 407     if (SUCCEEDED(ret))
 408         ret = IEnumPins_Next(EnumPins, 1, &ipin, NULL);
 409
 410     if (SUCCEEDED(ret))
 411     {
 412         ret = IPin_QueryDirection(ipin, &pin_direction);
 413         if (ret == S_OK && pin_direction == PINDIR_OUTPUT)
 414             This->ipin = ipin;
 415     }
 416
 417     if (EnumPins)
 418         IEnumPins_Release(EnumPins);
 419     if (BaseFilter)
 420         IBaseFilter_Release(BaseFilter);
 421     return ret;
 422 }
 423
 424 static HRESULT WINAPI IAMMultiMediaStreamImpl_OpenMoniker(IAMMultiMediaStream* iface, IBindCtx* pCtx, IMoniker* pMoniker, DWORD dwFlags)
 425 {
 426     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 427
 428     FIXME("(%p/%p)->(%p,%p,%x) stub!\n", This, iface, pCtx, pMoniker, dwFlags);
 429
 430     return E_NOTIMPL;
 431 }
 432
 433 static HRESULT WINAPI IAMMultiMediaStreamImpl_Render(IAMMultiMediaStream* iface, DWORD dwFlags)
 434 {
 435     IAMMultiMediaStreamImpl *This = impl_from_IAMMultiMediaStream(iface);
 436
 437     FIXME("(%p/%p)->(%x) partial stub!\n", This, iface, dwFlags);
 438
 439     if(dwFlags != AMMSF_NOCLOCK)
 440         return E_INVALIDARG;
 441
 442     return IGraphBuilder_Render(This->pFilterGraph, This->ipin);
 443 }
 444
 445 static const IAMMultiMediaStreamVtbl AM_Vtbl =
 446 {
 447     IAMMultiMediaStreamImpl_QueryInterface,
 448     IAMMultiMediaStreamImpl_AddRef,
 449     IAMMultiMediaStreamImpl_Release,
 450     IAMMultiMediaStreamImpl_GetInformation,
 451     IAMMultiMediaStreamImpl_GetMediaStream,
 452     IAMMultiMediaStreamImpl_EnumMediaStreams,
 453     IAMMultiMediaStreamImpl_GetState,
 454     IAMMultiMediaStreamImpl_SetState,
 455     IAMMultiMediaStreamImpl_GetTime,
 456     IAMMultiMediaStreamImpl_GetDuration,
 457     IAMMultiMediaStreamImpl_Seek,
 458     IAMMultiMediaStreamImpl_GetEndOfStream,
 459     IAMMultiMediaStreamImpl_Initialize,
 460     IAMMultiMediaStreamImpl_GetFilterGraph,
 461     IAMMultiMediaStreamImpl_GetFilter,
 462     IAMMultiMediaStreamImpl_AddMediaStream,
 463     IAMMultiMediaStreamImpl_OpenFile,
 464     IAMMultiMediaStreamImpl_OpenMoniker,
 465     IAMMultiMediaStreamImpl_Render
 466 };