dlls/strmbase/mediatype.c

   1 /*
   2  * Implementation of MedaType utility functions
   3  *
   4  * Copyright 2003 Robert Shearman
   5  * Copyright 2010 Aric Stewart, CodeWeavers
   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 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24 #include "dshow.h"
  25
  26 #include "wine/strmbase.h"
  27 #include "wine/debug.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(strmbase);
  30
  31 HRESULT WINAPI CopyMediaType(AM_MEDIA_TYPE *dest, const AM_MEDIA_TYPE *src)
  32 {
  33     *dest = *src;
  34     if (src->pbFormat)
  35     {
  36         dest->pbFormat = CoTaskMemAlloc(src->cbFormat);
  37         if (!dest->pbFormat)
  38             return E_OUTOFMEMORY;
  39         memcpy(dest->pbFormat, src->pbFormat, src->cbFormat);
  40     }
  41     if (dest->pUnk)
  42         IUnknown_AddRef(dest->pUnk);
  43     return S_OK;
  44 }
  45
  46 void WINAPI FreeMediaType(AM_MEDIA_TYPE * pMediaType)
  47 {
  48     if (pMediaType->pbFormat)
  49     {
  50         CoTaskMemFree(pMediaType->pbFormat);
  51         pMediaType->pbFormat = NULL;
  52     }
  53     if (pMediaType->pUnk)
  54     {
  55         IUnknown_Release(pMediaType->pUnk);
  56         pMediaType->pUnk = NULL;
  57     }
  58 }
  59
  60 AM_MEDIA_TYPE * WINAPI CreateMediaType(AM_MEDIA_TYPE const * pSrc)
  61 {
  62     AM_MEDIA_TYPE * pDest;
  63
  64     pDest = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
  65     if (!pDest)
  66         return NULL;
  67
  68     if (FAILED(CopyMediaType(pDest, pSrc)))
  69     {
  70         CoTaskMemFree(pDest);
  71         return NULL;
  72     }
  73
  74     return pDest;
  75 }
  76
  77 void WINAPI DeleteMediaType(AM_MEDIA_TYPE * pMediaType)
  78 {
  79     FreeMediaType(pMediaType);
  80     CoTaskMemFree(pMediaType);
  81 }
  82
  83 typedef struct tagENUMEDIADETAILS
  84 {
  85     ULONG cMediaTypes;
  86     AM_MEDIA_TYPE * pMediaTypes;
  87 } ENUMMEDIADETAILS;
  88
  89 typedef struct IEnumMediaTypesImpl
  90 {
  91     IEnumMediaTypes IEnumMediaTypes_iface;
  92     LONG refCount;
  93     BasePin *basePin;
  94     BasePin_GetMediaType enumMediaFunction;
  95     BasePin_GetMediaTypeVersion mediaVersionFunction;
  96     LONG currentVersion;
  97     ENUMMEDIADETAILS enumMediaDetails;
  98     ULONG uIndex;
  99 } IEnumMediaTypesImpl;
 100
 101 static inline IEnumMediaTypesImpl *impl_from_IEnumMediaTypes(IEnumMediaTypes *iface)
 102 {
 103     return CONTAINING_RECORD(iface, IEnumMediaTypesImpl, IEnumMediaTypes_iface);
 104 }
 105
 106 static const struct IEnumMediaTypesVtbl IEnumMediaTypesImpl_Vtbl;
 107
 108 HRESULT WINAPI EnumMediaTypes_Construct(BasePin *basePin, BasePin_GetMediaType enumFunc, BasePin_GetMediaTypeVersion versionFunc, IEnumMediaTypes ** ppEnum)
 109 {
 110     ULONG i;
 111     IEnumMediaTypesImpl * pEnumMediaTypes = CoTaskMemAlloc(sizeof(IEnumMediaTypesImpl));
 112     AM_MEDIA_TYPE amt;
 113
 114     *ppEnum = NULL;
 115
 116     if (!pEnumMediaTypes)
 117         return E_OUTOFMEMORY;
 118
 119     pEnumMediaTypes->IEnumMediaTypes_iface.lpVtbl = &IEnumMediaTypesImpl_Vtbl;
 120     pEnumMediaTypes->refCount = 1;
 121     pEnumMediaTypes->uIndex = 0;
 122     pEnumMediaTypes->enumMediaFunction = enumFunc;
 123     pEnumMediaTypes->mediaVersionFunction = versionFunc;
 124     IPin_AddRef(&basePin->IPin_iface);
 125     pEnumMediaTypes->basePin = basePin;
 126
 127     i = 0;
 128     while (enumFunc(basePin, i, &amt) == S_OK)
 129     {
 130         FreeMediaType(&amt);
 131         i++;
 132     }
 133
 134     pEnumMediaTypes->enumMediaDetails.cMediaTypes = i;
 135     pEnumMediaTypes->enumMediaDetails.pMediaTypes = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE) * i);
 136     memset(pEnumMediaTypes->enumMediaDetails.pMediaTypes, 0, sizeof(AM_MEDIA_TYPE) * i);
 137     for (i = 0; i < pEnumMediaTypes->enumMediaDetails.cMediaTypes; i++)
 138     {
 139         HRESULT hr;
 140
 141         if (FAILED(hr = enumFunc(basePin, i, &pEnumMediaTypes->enumMediaDetails.pMediaTypes[i])))
 142         {
 143             IEnumMediaTypes_Release(&pEnumMediaTypes->IEnumMediaTypes_iface);
 144             return hr;
 145         }
 146     }
 147     *ppEnum = &pEnumMediaTypes->IEnumMediaTypes_iface;
 148     pEnumMediaTypes->currentVersion = versionFunc(basePin);
 149     return S_OK;
 150 }
 151
 152 static HRESULT WINAPI IEnumMediaTypesImpl_QueryInterface(IEnumMediaTypes * iface, REFIID riid, void ** ret_iface)
 153 {
 154     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ret_iface);
 155
 156     if (IsEqualIID(riid, &IID_IUnknown) ||
 157         IsEqualIID(riid, &IID_IEnumMediaTypes))
 158     {
 159         IEnumMediaTypes_AddRef(iface);
 160         *ret_iface = iface;
 161         return S_OK;
 162     }
 163
 164     *ret_iface = NULL;
 165
 166     WARN("No interface for %s\n", debugstr_guid(riid));
 167
 168     return E_NOINTERFACE;
 169 }
 170
 171 static ULONG WINAPI IEnumMediaTypesImpl_AddRef(IEnumMediaTypes * iface)
 172 {
 173     IEnumMediaTypesImpl *This = impl_from_IEnumMediaTypes(iface);
 174     ULONG ref = InterlockedIncrement(&This->refCount);
 175
 176     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 177
 178     return ref;
 179 }
 180
 181 static ULONG WINAPI IEnumMediaTypesImpl_Release(IEnumMediaTypes * iface)
 182 {
 183     IEnumMediaTypesImpl *This = impl_from_IEnumMediaTypes(iface);
 184     ULONG ref = InterlockedDecrement(&This->refCount);
 185
 186     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 187
 188     if (!ref)
 189     {
 190         ULONG i;
 191         for (i = 0; i < This->enumMediaDetails.cMediaTypes; i++)
 192             FreeMediaType(&This->enumMediaDetails.pMediaTypes[i]);
 193         CoTaskMemFree(This->enumMediaDetails.pMediaTypes);
 194         IPin_Release(&This->basePin->IPin_iface);
 195         CoTaskMemFree(This);
 196     }
 197     return ref;
 198 }
 199
 200 static HRESULT WINAPI IEnumMediaTypesImpl_Next(IEnumMediaTypes * iface, ULONG cMediaTypes, AM_MEDIA_TYPE ** ppMediaTypes, ULONG * pcFetched)
 201 {
 202     ULONG cFetched;
 203     IEnumMediaTypesImpl *This = impl_from_IEnumMediaTypes(iface);
 204
 205     TRACE("(%p)->(%u, %p, %p)\n", iface, cMediaTypes, ppMediaTypes, pcFetched);
 206
 207     cFetched = min(This->enumMediaDetails.cMediaTypes, This->uIndex + cMediaTypes) - This->uIndex;
 208
 209     if (This->currentVersion != This->mediaVersionFunction(This->basePin))
 210         return VFW_E_ENUM_OUT_OF_SYNC;
 211
 212     TRACE("Next uIndex: %u, cFetched: %u\n", This->uIndex, cFetched);
 213
 214     if (cFetched > 0)
 215     {
 216         ULONG i;
 217         for (i = 0; i < cFetched; i++)
 218             if (!(ppMediaTypes[i] = CreateMediaType(&This->enumMediaDetails.pMediaTypes[This->uIndex + i])))
 219             {
 220                 while (i--)
 221                     DeleteMediaType(ppMediaTypes[i]);
 222                 *pcFetched = 0;
 223                 return E_OUTOFMEMORY;
 224             }
 225     }
 226
 227     if ((cMediaTypes != 1) || pcFetched)
 228         *pcFetched = cFetched;
 229
 230     This->uIndex += cFetched;
 231
 232     if (cFetched != cMediaTypes)
 233         return S_FALSE;
 234     return S_OK;
 235 }
 236
 237 static HRESULT WINAPI IEnumMediaTypesImpl_Skip(IEnumMediaTypes * iface, ULONG cMediaTypes)
 238 {
 239     IEnumMediaTypesImpl *This = impl_from_IEnumMediaTypes(iface);
 240
 241     TRACE("(%p)->(%u)\n", iface, cMediaTypes);
 242
 243     if (This->currentVersion != This->mediaVersionFunction(This->basePin))
 244         return VFW_E_ENUM_OUT_OF_SYNC;
 245
 246     if (This->uIndex + cMediaTypes < This->enumMediaDetails.cMediaTypes)
 247     {
 248         This->uIndex += cMediaTypes;
 249         return S_OK;
 250     }
 251     return S_FALSE;
 252 }
 253
 254 static HRESULT WINAPI IEnumMediaTypesImpl_Reset(IEnumMediaTypes * iface)
 255 {
 256     ULONG i;
 257     AM_MEDIA_TYPE amt;
 258     IEnumMediaTypesImpl *This = impl_from_IEnumMediaTypes(iface);
 259
 260     TRACE("(%p)->()\n", iface);
 261
 262     for (i = 0; i < This->enumMediaDetails.cMediaTypes; i++)
 263         FreeMediaType(&This->enumMediaDetails.pMediaTypes[i]);
 264     CoTaskMemFree(This->enumMediaDetails.pMediaTypes);
 265
 266     i = 0;
 267     while (This->enumMediaFunction(This->basePin, i, &amt) == S_OK) i++;
 268
 269     This->enumMediaDetails.cMediaTypes = i;
 270     This->enumMediaDetails.pMediaTypes = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE) * i);
 271     for (i = 0; i < This->enumMediaDetails.cMediaTypes; i++)
 272     {
 273         This->enumMediaFunction(This->basePin, i,&amt);
 274         if (FAILED(CopyMediaType(&This->enumMediaDetails.pMediaTypes[i], &amt)))
 275         {
 276             while (i--)
 277                 FreeMediaType(&This->enumMediaDetails.pMediaTypes[i]);
 278             CoTaskMemFree(This->enumMediaDetails.pMediaTypes);
 279             return E_OUTOFMEMORY;
 280         }
 281     }
 282
 283     This->currentVersion = This->mediaVersionFunction(This->basePin);
 284     This->uIndex = 0;
 285
 286     return S_OK;
 287 }
 288
 289 static HRESULT WINAPI IEnumMediaTypesImpl_Clone(IEnumMediaTypes * iface, IEnumMediaTypes ** ppEnum)
 290 {
 291     HRESULT hr;
 292     IEnumMediaTypesImpl *This = impl_from_IEnumMediaTypes(iface);
 293
 294     TRACE("(%p)->(%p)\n", iface, ppEnum);
 295
 296     hr = EnumMediaTypes_Construct(This->basePin, This->enumMediaFunction, This->mediaVersionFunction, ppEnum);
 297     if (FAILED(hr))
 298         return hr;
 299     return IEnumMediaTypes_Skip(*ppEnum, This->uIndex);
 300 }
 301
 302 static const IEnumMediaTypesVtbl IEnumMediaTypesImpl_Vtbl =
 303 {
 304     IEnumMediaTypesImpl_QueryInterface,
 305     IEnumMediaTypesImpl_AddRef,
 306     IEnumMediaTypesImpl_Release,
 307     IEnumMediaTypesImpl_Next,
 308     IEnumMediaTypesImpl_Skip,
 309     IEnumMediaTypesImpl_Reset,
 310     IEnumMediaTypesImpl_Clone
 311 };