dlls/quartz/enummedia.c

   1 /*
   2  * Implementation of IEnumMediaTypes Interface
   3  *
   4  * Copyright 2003 Robert Shearman
   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 "quartz_private.h"
  22
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  26
  27 BOOL CompareMediaTypes(const AM_MEDIA_TYPE * pmt1, const AM_MEDIA_TYPE * pmt2, BOOL bWildcards)
  28 {
  29     TRACE("pmt1: ");
  30     dump_AM_MEDIA_TYPE(pmt1);
  31     TRACE("pmt2: ");
  32     dump_AM_MEDIA_TYPE(pmt2);
  33     return (((bWildcards && (IsEqualGUID(&pmt1->majortype, &GUID_NULL) || IsEqualGUID(&pmt2->majortype, &GUID_NULL))) || IsEqualGUID(&pmt1->majortype, &pmt2->majortype)) &&
  34             ((bWildcards && (IsEqualGUID(&pmt1->subtype, &GUID_NULL)   || IsEqualGUID(&pmt2->subtype, &GUID_NULL)))   || IsEqualGUID(&pmt1->subtype, &pmt2->subtype)));
  35 }
  36
  37 void dump_AM_MEDIA_TYPE(const AM_MEDIA_TYPE * pmt)
  38 {
  39     if (!pmt)
  40         return;
  41     TRACE("\t%s\n\t%s\n\t...\n\t%s\n", qzdebugstr_guid(&pmt->majortype), qzdebugstr_guid(&pmt->subtype), qzdebugstr_guid(&pmt->formattype));
  42 }
  43
  44 typedef struct IEnumMediaTypesImpl
  45 {
  46     const IEnumMediaTypesVtbl * lpVtbl;
  47     LONG refCount;
  48     ENUMMEDIADETAILS enumMediaDetails;
  49     ULONG uIndex;
  50 } IEnumMediaTypesImpl;
  51
  52 static const struct IEnumMediaTypesVtbl IEnumMediaTypesImpl_Vtbl;
  53
  54 HRESULT IEnumMediaTypesImpl_Construct(const ENUMMEDIADETAILS * pDetails, IEnumMediaTypes ** ppEnum)
  55 {
  56     ULONG i;
  57     IEnumMediaTypesImpl * pEnumMediaTypes = CoTaskMemAlloc(sizeof(IEnumMediaTypesImpl));
  58
  59     if (!pEnumMediaTypes)
  60     {
  61         *ppEnum = NULL;
  62         return E_OUTOFMEMORY;
  63     }
  64     pEnumMediaTypes->lpVtbl = &IEnumMediaTypesImpl_Vtbl;
  65     pEnumMediaTypes->refCount = 1;
  66     pEnumMediaTypes->uIndex = 0;
  67     pEnumMediaTypes->enumMediaDetails.cMediaTypes = pDetails->cMediaTypes;
  68     pEnumMediaTypes->enumMediaDetails.pMediaTypes = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE) * pDetails->cMediaTypes);
  69     for (i = 0; i < pDetails->cMediaTypes; i++)
  70         if (FAILED(CopyMediaType(&pEnumMediaTypes->enumMediaDetails.pMediaTypes[i], &pDetails->pMediaTypes[i])))
  71         {
  72            while (i--)
  73               CoTaskMemFree(pEnumMediaTypes->enumMediaDetails.pMediaTypes[i].pbFormat);
  74            CoTaskMemFree(pEnumMediaTypes->enumMediaDetails.pMediaTypes);
  75            return E_OUTOFMEMORY;
  76         }
  77     *ppEnum = (IEnumMediaTypes *)(&pEnumMediaTypes->lpVtbl);
  78     return S_OK;
  79 }
  80
  81 static HRESULT WINAPI IEnumMediaTypesImpl_QueryInterface(IEnumMediaTypes * iface, REFIID riid, LPVOID * ppv)
  82 {
  83     TRACE("(%s, %p)\n", qzdebugstr_guid(riid), ppv);
  84
  85     *ppv = NULL;
  86
  87     if (IsEqualIID(riid, &IID_IUnknown))
  88         *ppv = iface;
  89     else if (IsEqualIID(riid, &IID_IEnumMediaTypes))
  90         *ppv = iface;
  91
  92     if (*ppv)
  93     {
  94         IUnknown_AddRef((IUnknown *)(*ppv));
  95         return S_OK;
  96     }
  97
  98     FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
  99
 100     return E_NOINTERFACE;
 101 }
 102
 103 static ULONG WINAPI IEnumMediaTypesImpl_AddRef(IEnumMediaTypes * iface)
 104 {
 105     IEnumMediaTypesImpl *This = (IEnumMediaTypesImpl *)iface;
 106     ULONG refCount = InterlockedIncrement(&This->refCount);
 107
 108     TRACE("(%p)->() AddRef from %d\n", iface, refCount - 1);
 109
 110     return refCount;
 111 }
 112
 113 static ULONG WINAPI IEnumMediaTypesImpl_Release(IEnumMediaTypes * iface)
 114 {
 115     IEnumMediaTypesImpl *This = (IEnumMediaTypesImpl *)iface;
 116     ULONG refCount = InterlockedDecrement(&This->refCount);
 117
 118     TRACE("(%p)->() Release from %d\n", iface, refCount + 1);
 119
 120     if (!refCount)
 121     {
 122         ULONG i;
 123         for (i = 0; i < This->enumMediaDetails.cMediaTypes; i++)
 124             if (This->enumMediaDetails.pMediaTypes[i].pbFormat)
 125                 CoTaskMemFree(This->enumMediaDetails.pMediaTypes[i].pbFormat);
 126         CoTaskMemFree(This->enumMediaDetails.pMediaTypes);
 127         CoTaskMemFree(This);
 128     }
 129     return refCount;
 130 }
 131
 132 static HRESULT WINAPI IEnumMediaTypesImpl_Next(IEnumMediaTypes * iface, ULONG cMediaTypes, AM_MEDIA_TYPE ** ppMediaTypes, ULONG * pcFetched)
 133 {
 134     ULONG cFetched;
 135     IEnumMediaTypesImpl *This = (IEnumMediaTypesImpl *)iface;
 136
 137     cFetched = min(This->enumMediaDetails.cMediaTypes, This->uIndex + cMediaTypes) - This->uIndex;
 138
 139     TRACE("(%u, %p, %p)\n", cMediaTypes, ppMediaTypes, pcFetched);
 140     TRACE("Next uIndex: %u, cFetched: %u\n", This->uIndex, cFetched);
 141
 142     if (cFetched > 0)
 143     {
 144         ULONG i;
 145         for (i = 0; i < cFetched; i++)
 146             if (!(ppMediaTypes[i] = CreateMediaType(&This->enumMediaDetails.pMediaTypes[This->uIndex + i])))
 147             {
 148                 while (i--)
 149                     DeleteMediaType(ppMediaTypes[i]);
 150                 *pcFetched = 0;
 151                 return E_OUTOFMEMORY;
 152             }
 153     }
 154
 155     if ((cMediaTypes != 1) || pcFetched)
 156         *pcFetched = cFetched;
 157
 158     This->uIndex += cFetched;
 159
 160     if (cFetched != cMediaTypes)
 161         return S_FALSE;
 162     return S_OK;
 163 }
 164
 165 static HRESULT WINAPI IEnumMediaTypesImpl_Skip(IEnumMediaTypes * iface, ULONG cMediaTypes)
 166 {
 167     IEnumMediaTypesImpl *This = (IEnumMediaTypesImpl *)iface;
 168
 169     TRACE("(%u)\n", cMediaTypes);
 170
 171     if (This->uIndex + cMediaTypes < This->enumMediaDetails.cMediaTypes)
 172     {
 173         This->uIndex += cMediaTypes;
 174         return S_OK;
 175     }
 176     return S_FALSE;
 177 }
 178
 179 static HRESULT WINAPI IEnumMediaTypesImpl_Reset(IEnumMediaTypes * iface)
 180 {
 181     IEnumMediaTypesImpl *This = (IEnumMediaTypesImpl *)iface;
 182
 183     TRACE("()\n");
 184
 185     This->uIndex = 0;
 186     return S_OK;
 187 }
 188
 189 static HRESULT WINAPI IEnumMediaTypesImpl_Clone(IEnumMediaTypes * iface, IEnumMediaTypes ** ppEnum)
 190 {
 191     HRESULT hr;
 192     IEnumMediaTypesImpl *This = (IEnumMediaTypesImpl *)iface;
 193
 194     TRACE("(%p)\n", ppEnum);
 195
 196     hr = IEnumMediaTypesImpl_Construct(&This->enumMediaDetails, ppEnum);
 197     if (FAILED(hr))
 198         return hr;
 199     return IEnumMediaTypes_Skip(*ppEnum, This->uIndex);
 200 }
 201
 202 static const IEnumMediaTypesVtbl IEnumMediaTypesImpl_Vtbl =
 203 {
 204     IEnumMediaTypesImpl_QueryInterface,
 205     IEnumMediaTypesImpl_AddRef,
 206     IEnumMediaTypesImpl_Release,
 207     IEnumMediaTypesImpl_Next,
 208     IEnumMediaTypesImpl_Skip,
 209     IEnumMediaTypesImpl_Reset,
 210     IEnumMediaTypesImpl_Clone
 211 };