git.oblomov.eu Git - wine/blob - dlls/amstream/mediastreamfilter.c

   1 /*
   2  * Implementation of MediaStream Filter
   3  *
   4  * Copyright 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 #include "wine/debug.h"
  22
  23 #define COBJMACROS
  24
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "dshow.h"
  28
  29 #include "wine/strmbase.h"
  30
  31 #include "amstream_private.h"
  32 #include "amstream.h"
  33
  34 #include "ddstream.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(amstream);
  37
  38 typedef struct MediaStreamFilter_InputPin
  39 {
  40     BaseInputPin pin;
  41 } MediaStreamFilter_InputPin;
  42
  43 static const IPinVtbl MediaStreamFilter_InputPin_Vtbl =
  44 {
  45     BaseInputPinImpl_QueryInterface,
  46     BasePinImpl_AddRef,
  47     BaseInputPinImpl_Release,
  48     BaseInputPinImpl_Connect,
  49     BaseInputPinImpl_ReceiveConnection,
  50     BasePinImpl_Disconnect,
  51     BasePinImpl_ConnectedTo,
  52     BasePinImpl_ConnectionMediaType,
  53     BasePinImpl_QueryPinInfo,
  54     BasePinImpl_QueryDirection,
  55     BasePinImpl_QueryId,
  56     BasePinImpl_QueryAccept,
  57     BasePinImpl_EnumMediaTypes,
  58     BasePinImpl_QueryInternalConnections,
  59     BaseInputPinImpl_EndOfStream,
  60     BaseInputPinImpl_BeginFlush,
  61     BaseInputPinImpl_EndFlush,
  62     BasePinImpl_NewSegment
  63 };
  64
  65 typedef struct {
  66     BaseFilter filter;
  67     ULONG nb_streams;
  68     IMediaStream** streams;
  69     IPin** pins;
  70 } IMediaStreamFilterImpl;
  71
  72 static inline IMediaStreamFilterImpl *impl_from_IMediaStreamFilter(IMediaStreamFilter *iface)
  73 {
  74     return CONTAINING_RECORD(iface, IMediaStreamFilterImpl, filter);
  75 }
  76
  77 static HRESULT WINAPI BasePinImpl_CheckMediaType(BasePin *This, const AM_MEDIA_TYPE *pmt)
  78 {
  79     return S_FALSE;
  80 }
  81
  82 static LONG WINAPI BasePinImp_GetMediaTypeVersion(BasePin *This)
  83 {
  84     return 0;
  85 }
  86
  87 static HRESULT WINAPI BasePinImp_GetMediaType(BasePin *This, int iPosition, AM_MEDIA_TYPE *amt)
  88 {
  89     return S_FALSE;
  90 }
  91
  92 static const  BasePinFuncTable input_BaseFuncTable = {
  93     BasePinImpl_CheckMediaType,
  94     NULL,
  95     BasePinImp_GetMediaTypeVersion,
  96     BasePinImp_GetMediaType
  97 };
  98
  99 static const BaseInputPinFuncTable input_BaseInputFuncTable = {
 100     NULL
 101 };
 102
 103 /*** IUnknown methods ***/
 104
 105 static HRESULT WINAPI MediaStreamFilterImpl_QueryInterface(IMediaStreamFilter *iface, REFIID riid,
 106         void **ppv)
 107 {
 108     IMediaStreamFilterImpl *This = impl_from_IMediaStreamFilter(iface);
 109
 110     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 111
 112     *ppv = NULL;
 113
 114     if (IsEqualIID(riid, &IID_IUnknown))
 115         *ppv = This;
 116     else if (IsEqualIID(riid, &IID_IPersist))
 117         *ppv = This;
 118     else if (IsEqualIID(riid, &IID_IMediaFilter))
 119         *ppv = This;
 120     else if (IsEqualIID(riid, &IID_IBaseFilter))
 121         *ppv = This;
 122     else if (IsEqualIID(riid, &IID_IMediaStreamFilter))
 123         *ppv = This;
 124
 125     if (*ppv)
 126     {
 127         IUnknown_AddRef((IUnknown *)(*ppv));
 128         return S_OK;
 129     }
 130
 131     return E_NOINTERFACE;
 132 }
 133
 134 static ULONG WINAPI MediaStreamFilterImpl_AddRef(IMediaStreamFilter *iface)
 135 {
 136     IMediaStreamFilterImpl *This = impl_from_IMediaStreamFilter(iface);
 137     ULONG ref = BaseFilterImpl_AddRef(&This->filter.IBaseFilter_iface);
 138
 139     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 140
 141     return ref;
 142 }
 143
 144 static ULONG WINAPI MediaStreamFilterImpl_Release(IMediaStreamFilter *iface)
 145 {
 146     IMediaStreamFilterImpl *This = impl_from_IMediaStreamFilter(iface);
 147     ULONG ref = BaseFilterImpl_Release(&This->filter.IBaseFilter_iface);
 148
 149     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 150
 151     if (!ref)
 152     {
 153         int i;
 154         for (i = 0; i < This->nb_streams; i++)
 155         {
 156             IMediaStream_Release(This->streams[i]);
 157             IPin_Release(This->pins[i]);
 158         }
 159         HeapFree(GetProcessHeap(), 0, This);
 160     }
 161
 162     return ref;
 163 }
 164
 165 /*** IPersist methods ***/
 166
 167 static HRESULT WINAPI MediaStreamFilterImpl_GetClassID(IMediaStreamFilter * iface, CLSID * pClsid)
 168 {
 169     return BaseFilterImpl_GetClassID((IBaseFilter*)iface, pClsid);
 170 }
 171
 172 /*** IBaseFilter methods ***/
 173
 174 static HRESULT WINAPI MediaStreamFilterImpl_Stop(IMediaStreamFilter * iface)
 175 {
 176     FIXME("(%p)->(): Stub!\n", iface);
 177
 178     return E_NOTIMPL;
 179 }
 180
 181 static HRESULT WINAPI MediaStreamFilterImpl_Pause(IMediaStreamFilter * iface)
 182 {
 183     FIXME("(%p)->(): Stub!\n", iface);
 184
 185     return E_NOTIMPL;
 186 }
 187
 188 static HRESULT WINAPI MediaStreamFilterImpl_Run(IMediaStreamFilter * iface, REFERENCE_TIME tStart)
 189 {
 190     FIXME("(%p)->(%s): Stub!\n", iface, wine_dbgstr_longlong(tStart));
 191
 192     return E_NOTIMPL;
 193 }
 194
 195 static HRESULT WINAPI MediaStreamFilterImpl_GetState(IMediaStreamFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
 196 {
 197     return BaseFilterImpl_GetState((IBaseFilter*)iface, dwMilliSecsTimeout, pState);
 198 }
 199
 200 static HRESULT WINAPI MediaStreamFilterImpl_SetSyncSource(IMediaStreamFilter * iface, IReferenceClock *pClock)
 201 {
 202     return BaseFilterImpl_SetSyncSource((IBaseFilter*)iface, pClock);
 203 }
 204
 205 static HRESULT WINAPI MediaStreamFilterImpl_GetSyncSource(IMediaStreamFilter * iface, IReferenceClock **ppClock)
 206 {
 207     return BaseFilterImpl_GetSyncSource((IBaseFilter*)iface, ppClock);
 208 }
 209
 210 static HRESULT WINAPI MediaStreamFilterImpl_EnumPins(IMediaStreamFilter * iface, IEnumPins **ppEnum)
 211 {
 212     return BaseFilterImpl_EnumPins((IBaseFilter*)iface, ppEnum);
 213 }
 214
 215 static HRESULT WINAPI MediaStreamFilterImpl_FindPin(IMediaStreamFilter * iface, LPCWSTR Id, IPin **ppPin)
 216 {
 217     FIXME("(%p)->(%s,%p): Stub!\n", iface, debugstr_w(Id), ppPin);
 218
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI MediaStreamFilterImpl_QueryFilterInfo(IMediaStreamFilter * iface, FILTER_INFO *pInfo)
 223 {
 224     return BaseFilterImpl_QueryFilterInfo((IBaseFilter*)iface, pInfo);
 225 }
 226
 227 static HRESULT WINAPI MediaStreamFilterImpl_JoinFilterGraph(IMediaStreamFilter * iface, IFilterGraph *pGraph, LPCWSTR pName)
 228 {
 229     return BaseFilterImpl_JoinFilterGraph((IBaseFilter*)iface, pGraph, pName);
 230 }
 231
 232 static HRESULT WINAPI MediaStreamFilterImpl_QueryVendorInfo(IMediaStreamFilter * iface, LPWSTR *pVendorInfo)
 233 {
 234     return BaseFilterImpl_QueryVendorInfo((IBaseFilter*)iface, pVendorInfo);
 235 }
 236
 237 /*** IMediaStreamFilter methods ***/
 238
 239 static HRESULT WINAPI MediaStreamFilterImpl_AddMediaStream(IMediaStreamFilter* iface, IAMMediaStream *pAMMediaStream)
 240 {
 241     IMediaStreamFilterImpl *This = impl_from_IMediaStreamFilter(iface);
 242     IMediaStream** streams;
 243     IPin** pins;
 244     MediaStreamFilter_InputPin* pin;
 245     HRESULT hr;
 246     PIN_INFO info;
 247     MSPID purpose_id;
 248
 249     TRACE("(%p)->(%p)\n", iface, pAMMediaStream);
 250
 251     streams = CoTaskMemRealloc(This->streams, (This->nb_streams + 1) * sizeof(IMediaStream*));
 252     if (!streams)
 253         return E_OUTOFMEMORY;
 254     This->streams = streams;
 255     pins = CoTaskMemRealloc(This->pins, (This->nb_streams + 1) * sizeof(IPin*));
 256     if (!pins)
 257         return E_OUTOFMEMORY;
 258     This->pins = pins;
 259     info.pFilter = (IBaseFilter*)&This->filter;
 260     info.dir = PINDIR_INPUT;
 261     hr = IAMMediaStream_GetInformation(pAMMediaStream, &purpose_id, NULL);
 262     if (FAILED(hr))
 263         return hr;
 264     /* Pin name is "I{guid MSPID_PrimaryVideo or MSPID_PrimaryAudio}" */
 265     info.achName[0] = 'I';
 266     StringFromGUID2(&purpose_id, info.achName + 1, 40);
 267     hr = BaseInputPin_Construct(&MediaStreamFilter_InputPin_Vtbl, &info, &input_BaseFuncTable, &input_BaseInputFuncTable, &This->filter.csFilter, NULL, &This->pins[This->nb_streams]);
 268     if (FAILED(hr))
 269         return hr;
 270
 271     pin = (MediaStreamFilter_InputPin*)This->pins[This->nb_streams];
 272     pin->pin.pin.pinInfo.pFilter = (LPVOID)This;
 273     This->streams[This->nb_streams] = (IMediaStream*)pAMMediaStream;
 274     This->nb_streams++;
 275
 276     IMediaStream_AddRef((IMediaStream*)pAMMediaStream);
 277
 278     return S_OK;
 279 }
 280
 281 static HRESULT WINAPI MediaStreamFilterImpl_GetMediaStream(IMediaStreamFilter* iface, REFMSPID idPurpose, IMediaStream **ppMediaStream)
 282 {
 283     IMediaStreamFilterImpl *This = impl_from_IMediaStreamFilter(iface);
 284     MSPID purpose_id;
 285     unsigned int i;
 286
 287     TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(idPurpose), ppMediaStream);
 288
 289     for (i = 0; i < This->nb_streams; i++)
 290     {
 291         IMediaStream_GetInformation(This->streams[i], &purpose_id, NULL);
 292         if (IsEqualIID(&purpose_id, idPurpose))
 293         {
 294             *ppMediaStream = This->streams[i];
 295             IMediaStream_AddRef(*ppMediaStream);
 296             return S_OK;
 297         }
 298     }
 299
 300     return MS_E_NOSTREAM;
 301 }
 302
 303 static HRESULT WINAPI MediaStreamFilterImpl_EnumMediaStreams(IMediaStreamFilter* iface, LONG Index, IMediaStream **ppMediaStream)
 304 {
 305     FIXME("(%p)->(%d,%p): Stub!\n", iface, Index, ppMediaStream);
 306
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI MediaStreamFilterImpl_SupportSeeking(IMediaStreamFilter* iface, BOOL bRenderer)
 311 {
 312     FIXME("(%p)->(%d): Stub!\n", iface, bRenderer);
 313
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI MediaStreamFilterImpl_ReferenceTimeToStreamTime(IMediaStreamFilter* iface, REFERENCE_TIME *pTime)
 318 {
 319     FIXME("(%p)->(%p): Stub!\n", iface, pTime);
 320
 321     return E_NOTIMPL;
 322 }
 323
 324 static HRESULT WINAPI MediaStreamFilterImpl_GetCurrentStreamTime(IMediaStreamFilter* iface, REFERENCE_TIME *pCurrentStreamTime)
 325 {
 326     FIXME("(%p)->(%p): Stub!\n", iface, pCurrentStreamTime);
 327
 328     return E_NOTIMPL;
 329 }
 330
 331 static HRESULT WINAPI MediaStreamFilterImpl_WaitUntil(IMediaStreamFilter* iface, REFERENCE_TIME WaitStreamTime)
 332 {
 333     FIXME("(%p)->(%s): Stub!\n", iface, wine_dbgstr_longlong(WaitStreamTime));
 334
 335     return E_NOTIMPL;
 336 }
 337
 338 static HRESULT WINAPI MediaStreamFilterImpl_Flush(IMediaStreamFilter* iface, BOOL bCancelEOS)
 339 {
 340     FIXME("(%p)->(%d): Stub!\n", iface, bCancelEOS);
 341
 342     return E_NOTIMPL;
 343 }
 344
 345 static HRESULT WINAPI MediaStreamFilterImpl_EndOfStream(IMediaStreamFilter* iface)
 346 {
 347     FIXME("(%p)->(): Stub!\n",  iface);
 348
 349     return E_NOTIMPL;
 350 }
 351
 352 static const IMediaStreamFilterVtbl MediaStreamFilter_Vtbl =
 353 {
 354     MediaStreamFilterImpl_QueryInterface,
 355     MediaStreamFilterImpl_AddRef,
 356     MediaStreamFilterImpl_Release,
 357     MediaStreamFilterImpl_GetClassID,
 358     MediaStreamFilterImpl_Stop,
 359     MediaStreamFilterImpl_Pause,
 360     MediaStreamFilterImpl_Run,
 361     MediaStreamFilterImpl_GetState,
 362     MediaStreamFilterImpl_SetSyncSource,
 363     MediaStreamFilterImpl_GetSyncSource,
 364     MediaStreamFilterImpl_EnumPins,
 365     MediaStreamFilterImpl_FindPin,
 366     MediaStreamFilterImpl_QueryFilterInfo,
 367     MediaStreamFilterImpl_JoinFilterGraph,
 368     MediaStreamFilterImpl_QueryVendorInfo,
 369     MediaStreamFilterImpl_AddMediaStream,
 370     MediaStreamFilterImpl_GetMediaStream,
 371     MediaStreamFilterImpl_EnumMediaStreams,
 372     MediaStreamFilterImpl_SupportSeeking,
 373     MediaStreamFilterImpl_ReferenceTimeToStreamTime,
 374     MediaStreamFilterImpl_GetCurrentStreamTime,
 375     MediaStreamFilterImpl_WaitUntil,
 376     MediaStreamFilterImpl_Flush,
 377     MediaStreamFilterImpl_EndOfStream
 378 };
 379
 380 static IPin* WINAPI MediaStreamFilterImpl_GetPin(BaseFilter *iface, int pos)
 381 {
 382     IMediaStreamFilterImpl* This = (IMediaStreamFilterImpl*)iface;
 383
 384     if (pos < This->nb_streams)
 385     {
 386         IPin_AddRef(This->pins[pos]);
 387         return This->pins[pos];
 388     }
 389
 390     return NULL;
 391 }
 392
 393 static LONG WINAPI MediaStreamFilterImpl_GetPinCount(BaseFilter *iface)
 394 {
 395     IMediaStreamFilterImpl* This = (IMediaStreamFilterImpl*)iface;
 396
 397     return This->nb_streams;
 398 }
 399
 400 static const BaseFilterFuncTable BaseFuncTable = {
 401     MediaStreamFilterImpl_GetPin,
 402     MediaStreamFilterImpl_GetPinCount
 403 };
 404
 405 HRESULT MediaStreamFilter_create(IUnknown *pUnkOuter, void **ppObj)
 406 {
 407     IMediaStreamFilterImpl* object;
 408
 409     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 410
 411     if( pUnkOuter )
 412         return CLASS_E_NOAGGREGATION;
 413
 414     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IMediaStreamFilterImpl));
 415     if (!object)
 416     {
 417         ERR("Out of memory\n");
 418         return E_OUTOFMEMORY;
 419     }
 420
 421     BaseFilter_Init(&object->filter, (IBaseFilterVtbl*)&MediaStreamFilter_Vtbl, &CLSID_MediaStreamFilter, (DWORD_PTR)(__FILE__ ": MediaStreamFilterImpl.csFilter"), &BaseFuncTable);
 422
 423     *ppObj = object;
 424
 425     return S_OK;
 426 }