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(&basePin->IPin_iface);
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(&This->basePin->IPin_iface);
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 };
308
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.