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