?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added memicmpW.
[wine.git] / dlls / avifil32 / editstream.c
blob12581634fffbe9e334e8db4681904125bc170fec
1 /*
2 * Copyright 2003 Michael Günnewig
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19 #define COM_NO_WINDOWS_H
20 #include <assert.h>
21 #include <stdarg.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winuser.h"
26 #include "wingdi.h"
27 #include "winnls.h"
28 #include "winerror.h"
29 #include "windowsx.h"
30 #include "mmsystem.h"
31 #include "vfw.h"
32
33 #include "avifile_private.h"
34 #include "extrachunk.h"
35
36 #include "wine/debug.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(avifile);
39
40 /***********************************************************************/
41
42 /* internal interface to get access to table of stream in an editable stream */
43 typedef struct IEditStreamInternal IEditStreamInternal;
44
45 typedef struct _EditStreamTable {
46 PAVISTREAM pStream; /* stream which contains the data */
47 DWORD dwStart; /* where starts the part which is also our */
48 DWORD dwLength; /* how many is also in this stream */
49 } EditStreamTable;
50
51 #define INTERFACE IEditStreamInternal
52 #define IEditStreamInternal_METHODS \
53 IUnknown_METHODS \
54 STDMETHOD(GetEditStreamImpl)(THIS_ LPVOID*) PURE;
55 ICOM_DEFINE(IEditStreamInternal, IUnknown)
56 #undef INTERFACE
57
58 #define EditStreamEnd(This,streamNr) ((This)->pStreams[streamNr].dwStart + \
59 (This)->pStreams[streamNr].dwLength)
60
61 /***********************************************************************/
62
63 static HRESULT WINAPI IAVIEditStream_fnQueryInterface(IAVIEditStream*iface,REFIID refiid,LPVOID *obj);
64 static ULONG WINAPI IAVIEditStream_fnAddRef(IAVIEditStream*iface);
65 static ULONG WINAPI IAVIEditStream_fnRelease(IAVIEditStream*iface);
66 static HRESULT WINAPI IAVIEditStream_fnCut(IAVIEditStream*iface,LONG*plStart,
67 LONG*plLength,PAVISTREAM*ppResult);
68 static HRESULT WINAPI IAVIEditStream_fnCopy(IAVIEditStream*iface,LONG*plStart,
69 LONG*plLength,PAVISTREAM*ppResult);
70 static HRESULT WINAPI IAVIEditStream_fnPaste(IAVIEditStream*iface,LONG*plStart,
71 LONG*plLength,PAVISTREAM pSource,
72 LONG lStart,LONG lEnd);
73 static HRESULT WINAPI IAVIEditStream_fnClone(IAVIEditStream*iface,
74 PAVISTREAM*ppResult);
75 static HRESULT WINAPI IAVIEditStream_fnSetInfo(IAVIEditStream*iface,
76 LPAVISTREAMINFOW asi,LONG size);
77
78 struct ICOM_VTABLE(IAVIEditStream) ieditstream = {
79 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
80 IAVIEditStream_fnQueryInterface,
81 IAVIEditStream_fnAddRef,
82 IAVIEditStream_fnRelease,
83 IAVIEditStream_fnCut,
84 IAVIEditStream_fnCopy,
85 IAVIEditStream_fnPaste,
86 IAVIEditStream_fnClone,
87 IAVIEditStream_fnSetInfo
88 };
89
90 static HRESULT WINAPI IEditAVIStream_fnQueryInterface(IAVIStream*iface,REFIID refiid,LPVOID*obj);
91 static ULONG WINAPI IEditAVIStream_fnAddRef(IAVIStream*iface);
92 static ULONG WINAPI IEditAVIStream_fnRelease(IAVIStream*iface);
93 static HRESULT WINAPI IEditAVIStream_fnCreate(IAVIStream*iface,LPARAM lParam1,LPARAM lParam2);
94 static HRESULT WINAPI IEditAVIStream_fnInfo(IAVIStream*iface,AVISTREAMINFOW *psi,LONG size);
95 static LONG WINAPI IEditAVIStream_fnFindSample(IAVIStream*iface,LONG pos,
96 LONG flags);
97 static HRESULT WINAPI IEditAVIStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG*formatsize);
98 static HRESULT WINAPI IEditAVIStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG formatsize);
99 static HRESULT WINAPI IEditAVIStream_fnRead(IAVIStream*iface,LONG start,
100 LONG samples,LPVOID buffer,
101 LONG buffersize,LONG*bytesread,
102 LONG*samplesread);
103 static HRESULT WINAPI IEditAVIStream_fnWrite(IAVIStream*iface,LONG start,
104 LONG samples,LPVOID buffer,
105 LONG buffersize,DWORD flags,
106 LONG*sampwritten,LONG*byteswritten);
107 static HRESULT WINAPI IEditAVIStream_fnDelete(IAVIStream*iface,LONG start,LONG samples);
108 static HRESULT WINAPI IEditAVIStream_fnReadData(IAVIStream*iface,DWORD fcc,
109 LPVOID lp,LONG *lpread);
110 static HRESULT WINAPI IEditAVIStream_fnWriteData(IAVIStream*iface,DWORD fcc,
111 LPVOID lp,LONG size);
112 static HRESULT WINAPI IEditAVIStream_fnSetInfo(IAVIStream*iface,AVISTREAMINFOW*info,LONG infolen);
113
114 struct ICOM_VTABLE(IAVIStream) ieditstast = {
115 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
116 IEditAVIStream_fnQueryInterface,
117 IEditAVIStream_fnAddRef,
118 IEditAVIStream_fnRelease,
119 IEditAVIStream_fnCreate,
120 IEditAVIStream_fnInfo,
121 IEditAVIStream_fnFindSample,
122 IEditAVIStream_fnReadFormat,
123 IEditAVIStream_fnSetFormat,
124 IEditAVIStream_fnRead,
125 IEditAVIStream_fnWrite,
126 IEditAVIStream_fnDelete,
127 IEditAVIStream_fnReadData,
128 IEditAVIStream_fnWriteData,
129 IEditAVIStream_fnSetInfo
130 };
131
132 static HRESULT WINAPI IEditStreamInternal_fnQueryInterface(IEditStreamInternal*iface,REFIID refiid,LPVOID*obj);
133 static ULONG WINAPI IEditStreamInternal_fnAddRef(IEditStreamInternal*iface);
134 static ULONG WINAPI IEditStreamInternal_fnRelease(IEditStreamInternal*iface);
135 static HRESULT WINAPI IEditStreamInternal_fnGetEditStreamImpl(IEditStreamInternal*iface,LPVOID*ppimpl);
136
137 struct ICOM_VTABLE(IEditStreamInternal) ieditstreaminternal = {
138 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
139 IEditStreamInternal_fnQueryInterface,
140 IEditStreamInternal_fnAddRef,
141 IEditStreamInternal_fnRelease,
142 IEditStreamInternal_fnGetEditStreamImpl
143 };
144
145 typedef struct _IAVIEditStreamImpl IAVIEditStreamImpl;
146
147 typedef struct _IEditAVIStreamImpl {
148 /* IUnknown stuff */
149 ICOM_VFIELD(IAVIStream);
150
151 /* IAVIStream stuff */
152 IAVIEditStreamImpl *pae;
153 } IEditAVIStreamImpl;
154
155 typedef struct _IEditStreamInternalImpl {
156 /* IUnknown stuff */
157 ICOM_VFIELD(IEditStreamInternal);
158
159 /* IEditStreamInternal stuff */
160 IAVIEditStreamImpl *pae;
161 } IEditStreamInternalImpl;
162
163 struct _IAVIEditStreamImpl {
164 /* IUnknown stuff */
165 ICOM_VFIELD(IAVIEditStream);
166 DWORD ref;
167
168 /* IAVIEditStream stuff */
169 IEditAVIStreamImpl iAVIStream;
170 IEditStreamInternalImpl iEditStreamInternal;
171
172 AVISTREAMINFOW sInfo;
173
174 EditStreamTable *pStreams;
175 DWORD nStreams; /* current fill level of pStreams table */
176 DWORD nTableSize; /* size of pStreams table */
177
178 BOOL bDecompress;
179 PAVISTREAM pCurStream;
180 PGETFRAME pg; /* IGetFrame for pCurStream */
181 LPBITMAPINFOHEADER lpFrame; /* frame of pCurStream */
182 };
183
184 /***********************************************************************/
185
186 PAVIEDITSTREAM AVIFILE_CreateEditStream(PAVISTREAM pstream)
187 {
188 IAVIEditStreamImpl *pedit = NULL;
189
190 pedit = (IAVIEditStreamImpl*)LocalAlloc(LPTR,sizeof(IAVIEditStreamImpl));
191 if (pedit == NULL)
192 return NULL;
193
194 pedit->lpVtbl = &ieditstream;
195 pedit->iAVIStream.lpVtbl = &ieditstast;
196 pedit->iAVIStream.pae = pedit;
197 pedit->iEditStreamInternal.lpVtbl = &ieditstreaminternal;
198 pedit->iEditStreamInternal.pae = pedit;
199 pedit->ref = 1;
200
201 IAVIStream_Create((PAVISTREAM)&pedit->iAVIStream,(LPARAM)pstream,0);
202
203 return (PAVIEDITSTREAM)pedit;
204 }
205
206 static HRESULT AVIFILE_FindStreamInTable(IAVIEditStreamImpl* const This,
207 DWORD pos,PAVISTREAM *ppStream,
208 DWORD* streamPos,
209 DWORD* streamNr,BOOL bFindSample)
210 {
211 DWORD n;
212
213 TRACE("(%p,%lu,%p,%p,%p,%d)\n",This,pos,ppStream,streamPos,
214 streamNr,bFindSample);
215
216 if (pos < This->sInfo.dwStart)
217 return AVIERR_BADPARAM;
218
219 pos -= This->sInfo.dwStart;
220 for (n = 0; n < This->nStreams; n++) {
221 if (pos < This->pStreams[n].dwLength) {
222 *ppStream = This->pStreams[n].pStream;
223 *streamPos = This->pStreams[n].dwStart + pos;
224 if (streamNr != NULL)
225 *streamNr = n;
226
227 return AVIERR_OK;
228 }
229 pos -= This->pStreams[n].dwLength;
230 }
231 if (pos == 0 && bFindSample) {
232 *ppStream = This->pStreams[--n].pStream;
233 *streamPos = EditStreamEnd(This, n);
234 if (streamNr != NULL)
235 *streamNr = n;
236
237 TRACE(" -- pos=0 && b=1 -> (%p,%lu,%lu)\n",*ppStream, *streamPos, n);
238 return AVIERR_OK;
239 } else {
240 *ppStream = NULL;
241 *streamPos = 0;
242 if (streamNr != NULL)
243 *streamNr = 0;
244
245 TRACE(" -> ERROR (NULL,0,0)\n");
246 return AVIERR_BADPARAM;
247 }
248 }
249
250 static LPVOID AVIFILE_ReadFrame(IAVIEditStreamImpl* const This,
251 PAVISTREAM pstream, LONG pos)
252 {
253 PGETFRAME pg;
254
255 TRACE("(%p,%p,%ld)\n",This,pstream,pos);
256
257 if (pstream == NULL)
258 return NULL;
259
260 /* if stream changes make sure that only palette changes */
261 if (This->pCurStream != pstream) {
262 pg = AVIStreamGetFrameOpen(pstream, NULL);
263 if (pg == NULL)
264 return NULL;
265 if (This->pg != NULL) {
266 if (IGetFrame_SetFormat(pg, This->lpFrame, NULL, 0, 0, -1, -1)) {
267 AVIStreamGetFrameClose(pg);
268 ERR(": IGetFrame_SetFormat failed\n");
269 return NULL;
270 }
271 AVIStreamGetFrameClose(This->pg);
272 }
273 This->pg = pg;
274 This->pCurStream = pstream;
275 }
276
277 /* now get the decompressed frame */
278 This->lpFrame = AVIStreamGetFrame(This->pg, pos);
279 if (This->lpFrame != NULL)
280 This->sInfo.dwSuggestedBufferSize = This->lpFrame->biSizeImage;
281
282 return This->lpFrame;
283 }
284
285 static HRESULT AVIFILE_RemoveStream(IAVIEditStreamImpl* const This, DWORD nr)
286 {
287 assert(This != NULL);
288 assert(nr < This->nStreams);
289
290 /* remove part nr */
291 IAVIStream_Release(This->pStreams[nr].pStream);
292 This->nStreams--;
293 if (This->nStreams - nr > 0) {
294 memmove(This->pStreams + nr, This->pStreams + nr + 1,
295 (This->nStreams - nr) * sizeof(EditStreamTable));
296 }
297 This->pStreams[This->nStreams].pStream = NULL;
298 This->pStreams[This->nStreams].dwStart = 0;
299 This->pStreams[This->nStreams].dwLength = 0;
300
301 /* try to merge the part before the deleted one and the one after it */
302 if (0 < nr && 0 < This->nStreams &&
303 This->pStreams[nr - 1].pStream == This->pStreams[nr].pStream) {
304 if (EditStreamEnd(This, nr - 1) == This->pStreams[nr].dwStart) {
305 This->pStreams[nr - 1].dwLength += This->pStreams[nr].dwLength;
306 return AVIFILE_RemoveStream(This, nr);
307 }
308 }
309
310 return AVIERR_OK;
311 }
312
313 static BOOL AVIFILE_FormatsEqual(PAVISTREAM avi1, PAVISTREAM avi2)
314 {
315 LPVOID fmt1 = NULL, fmt2 = NULL;
316 LONG size1, size2, start1, start2;
317 BOOL status = FALSE;
318
319 assert(avi1 != NULL && avi2 != NULL);
320
321 /* get stream starts and check format sizes */
322 start1 = AVIStreamStart(avi1);
323 start2 = AVIStreamStart(avi2);
324 if (FAILED(AVIStreamFormatSize(avi1, start1, &size1)))
325 return FALSE;
326 if (FAILED(AVIStreamFormatSize(avi2, start2, &size2)))
327 return FALSE;
328 if (size1 != size2)
329 return FALSE;
330
331 /* sizes match, now get formats and compare them */
332 fmt1 = GlobalAllocPtr(GHND, size1);
333 if (fmt1 == NULL)
334 return FALSE;
335 if (SUCCEEDED(AVIStreamReadFormat(avi1, start1, fmt1, &size1))) {
336 fmt2 = GlobalAllocPtr(GHND, size1);
337 if (fmt2 != NULL) {
338 if (SUCCEEDED(AVIStreamReadFormat(avi2, start2, fmt2, &size1)))
339 status = (memcmp(fmt1, fmt2, size1) == 0);
340 }
341 }
342
343 if (fmt2 != NULL)
344 GlobalFreePtr(fmt2);
345 GlobalFreePtr(fmt1);
346
347 return status;
348 }
349
350 /***********************************************************************/
351
352 static HRESULT WINAPI IAVIEditStream_fnQueryInterface(IAVIEditStream*iface,REFIID refiid,LPVOID *obj)
353 {
354 ICOM_THIS(IAVIEditStreamImpl,iface);
355
356 TRACE("(%p,%s,%p)\n", This, debugstr_guid(refiid), obj);
357
358 if (IsEqualGUID(&IID_IUnknown, refiid) ||
359 IsEqualGUID(&IID_IAVIEditStream, refiid)) {
360 *obj = iface;
361 IAVIEditStream_AddRef(iface);
362
363 return S_OK;
364 } else if (IsEqualGUID(&IID_IAVIStream, refiid)) {
365 *obj = &This->iAVIStream;
366 IAVIEditStream_AddRef(iface);
367
368 return S_OK;
369 } else if (IsEqualGUID(&IID_IEditStreamInternal, refiid)) {
370 *obj = &This->iEditStreamInternal;
371 IAVIEditStream_AddRef(iface);
372
373 return S_OK;
374 }
375
376 return OLE_E_ENUM_NOMORE;
377 }
378
379 static ULONG WINAPI IAVIEditStream_fnAddRef(IAVIEditStream*iface)
380 {
381 ICOM_THIS(IAVIEditStreamImpl,iface);
382
383 TRACE("(%p) -> %ld\n", iface, This->ref + 1);
384 return ++(This->ref);
385 }
386
387 static ULONG WINAPI IAVIEditStream_fnRelease(IAVIEditStream*iface)
388 {
389 ICOM_THIS(IAVIEditStreamImpl,iface);
390 DWORD i;
391
392 TRACE("(%p) -> %ld\n", iface, This->ref - 1);
393
394 if (!--(This->ref)) {
395 /* releaase memory */
396 if (This->pg != NULL)
397 AVIStreamGetFrameClose(This->pg);
398 if (This->pStreams != NULL) {
399 for (i = 0; i < This->nStreams; i++) {
400 if (This->pStreams[i].pStream != NULL)
401 IAVIStream_Release(This->pStreams[i].pStream);
402 }
403 GlobalFreePtr(This->pStreams);
404 }
405
406 LocalFree((HLOCAL)This);
407 return 0;
408 }
409 return This->ref;
410 }
411
412 static HRESULT WINAPI IAVIEditStream_fnCut(IAVIEditStream*iface,LONG*plStart,
413 LONG*plLength,PAVISTREAM*ppResult)
414 {
415 ICOM_THIS(IAVIEditStreamImpl,iface);
416 PAVISTREAM stream;
417 DWORD start, len, streamPos, streamNr;
418 HRESULT hr;
419
420 TRACE("(%p,%p,%p,%p)\n",iface,plStart,plLength,ppResult);
421
422 if (ppResult != NULL)
423 *ppResult = NULL;
424 if (plStart == NULL || plLength == NULL || *plStart < 0)
425 return AVIERR_BADPARAM;
426
427 /* if asked for cutted part copy it before deleting */
428 if (ppResult != NULL) {
429 hr = IAVIEditStream_Copy(iface, plStart, plLength, ppResult);
430 if (FAILED(hr))
431 return hr;
432 }
433
434 start = *plStart;
435 len = *plLength;
436
437 /* now delete the requested part */
438 while (len > 0) {
439 hr = AVIFILE_FindStreamInTable(This, start, &stream,
440 &streamPos, &streamNr, FALSE);
441 if (FAILED(hr))
442 return hr;
443 if (This->pStreams[streamNr].dwStart == streamPos) {
444 /* deleting from start of part */
445 if (len < This->pStreams[streamNr].dwLength) {
446 start += len;
447 This->pStreams[streamNr].dwStart += len;
448 This->pStreams[streamNr].dwLength -= len;
449 This->sInfo.dwLength -= len;
450 len = 0;
451
452 /* we must return decompressed data now */
453 This->bDecompress = TRUE;
454 } else {
455 /* deleting hole part */
456 len -= This->pStreams[streamNr].dwLength;
457 AVIFILE_RemoveStream(This,streamNr);
458 }
459 } else if (EditStreamEnd(This, streamNr) <= streamPos + len) {
460 /* deleting at end of a part */
461 DWORD count = EditStreamEnd(This, streamNr) - streamPos;
462 This->sInfo.dwLength -= count;
463 len -= count;
464 This->pStreams[streamNr].dwLength =
465 streamPos - This->pStreams[streamNr].dwStart;
466 } else {
467 /* splitting */
468 if (This->nStreams + 1 >= This->nTableSize) {
469 This->pStreams =
470 GlobalReAllocPtr(This->pStreams, (This->nTableSize + 32) * sizeof(EditStreamTable), GMEM_SHARE|GHND);
471 if (This->pStreams == NULL)
472 return AVIERR_MEMORY;
473 This->nTableSize += 32;
474 }
475 memmove(This->pStreams + streamNr + 1, This->pStreams + streamNr,
476 (This->nStreams - streamNr) * sizeof(EditStreamTable));
477 This->nStreams++;
478
479 IAVIStream_AddRef(This->pStreams[streamNr + 1].pStream);
480 This->pStreams[streamNr + 1].dwStart = streamPos + len;
481 This->pStreams[streamNr + 1].dwLength =
482 EditStreamEnd(This, streamNr) - This->pStreams[streamNr + 1].dwStart;
483
484 This->pStreams[streamNr].dwLength =
485 streamPos - This->pStreams[streamNr].dwStart;
486 This->sInfo.dwLength -= len;
487 len = 0;
488 }
489 }
490
491 This->sInfo.dwEditCount++;
492
493 return AVIERR_OK;
494 }
495
496 static HRESULT WINAPI IAVIEditStream_fnCopy(IAVIEditStream*iface,LONG*plStart,
497 LONG*plLength,PAVISTREAM*ppResult)
498 {
499 ICOM_THIS(IAVIEditStreamImpl,iface);
500 IAVIEditStreamImpl* pEdit;
501 HRESULT hr;
502 LONG start = 0;
503
504 TRACE("(%p,%p,%p,%p)\n",iface,plStart,plLength,ppResult);
505
506 if (ppResult == NULL)
507 return AVIERR_BADPARAM;
508 *ppResult = NULL;
509 if (plStart == NULL || plLength == NULL || *plStart < 0 || *plLength < 0)
510 return AVIERR_BADPARAM;
511
512 /* check bounds */
513 if (*(LPDWORD)plLength > This->sInfo.dwLength)
514 *(LPDWORD)plLength = This->sInfo.dwLength;
515 if (*(LPDWORD)plStart < This->sInfo.dwStart) {
516 *(LPDWORD)plLength -= This->sInfo.dwStart - *(LPDWORD)plStart;
517 *(LPDWORD)plStart = This->sInfo.dwStart;
518 if (*plLength < 0)
519 return AVIERR_BADPARAM;
520 }
521 if (*(LPDWORD)plStart + *(LPDWORD)plLength > This->sInfo.dwStart + This->sInfo.dwLength)
522 *(LPDWORD)plLength = This->sInfo.dwStart + This->sInfo.dwLength -
523 *(LPDWORD)plStart;
524
525 pEdit = (IAVIEditStreamImpl*)AVIFILE_CreateEditStream(NULL);
526 if (pEdit == NULL)
527 return AVIERR_MEMORY;
528
529 hr = IAVIEditStream_Paste((PAVIEDITSTREAM)pEdit,&start,plLength,
530 (PAVISTREAM)&This->iAVIStream,*plStart,
531 *plStart + *plLength);
532 *plStart = start;
533 if (FAILED(hr))
534 IAVIEditStream_Release((PAVIEDITSTREAM)pEdit);
535 else
536 *ppResult = (PAVISTREAM)&pEdit->iAVIStream;
537
538 return hr;
539 }
540
541 static HRESULT WINAPI IAVIEditStream_fnPaste(IAVIEditStream*iface,LONG*plStart,
542 LONG*plLength,PAVISTREAM pSource,
543 LONG lStart,LONG lLength)
544 {
545 ICOM_THIS(IAVIEditStreamImpl,iface);
546 AVISTREAMINFOW srcInfo;
547 IEditStreamInternal*pInternal = NULL;
548 IAVIEditStreamImpl *pEdit = NULL;
549 PAVISTREAM pStream;
550 DWORD startPos, endPos, streamNr, n, nStreams;
551
552 TRACE("(%p,%p,%p,%p,%ld,%ld)\n",iface,plStart,plLength,
553 pSource,lStart,lLength);
554
555 if (pSource == NULL)
556 return AVIERR_BADHANDLE;
557 if (plStart == NULL || *plStart < 0)
558 return AVIERR_BADPARAM;
559 if (This->sInfo.dwStart + This->sInfo.dwLength < *plStart)
560 return AVIERR_BADPARAM; /* Can't paste with holes */
561 if (FAILED(IAVIStream_Info(pSource, &srcInfo, sizeof(srcInfo))))
562 return AVIERR_ERROR;
563 if (lStart < srcInfo.dwStart || lStart >= srcInfo.dwStart + srcInfo.dwLength)
564 return AVIERR_BADPARAM;
565 if (This->sInfo.fccType == 0) {
566 /* This stream is empty */
567 IAVIStream_Info(pSource, &This->sInfo, sizeof(This->sInfo));
568 This->sInfo.dwStart = *plStart;
569 This->sInfo.dwLength = 0;
570 }
571 if (This->sInfo.fccType != srcInfo.fccType)
572 return AVIERR_UNSUPPORTED; /* different stream types */
573 if (lLength == -1) /* Copy the hole stream */
574 lLength = srcInfo.dwLength;
575 if (lStart + lLength > srcInfo.dwStart + srcInfo.dwLength)
576 lLength = srcInfo.dwStart + srcInfo.dwLength - lStart;
577 if (lLength + *plStart >= 0x80000000)
578 return AVIERR_MEMORY;
579
580 /* streamtype specific tests */
581 if (srcInfo.fccType == streamtypeVIDEO) {
582 DWORD size;
583
584 size = srcInfo.rcFrame.right - srcInfo.rcFrame.left;
585 if (size != This->sInfo.rcFrame.right - This->sInfo.rcFrame.left)
586 return AVIERR_UNSUPPORTED; /* FIXME: Can't GetFrame convert it? */
587 size = srcInfo.rcFrame.bottom - srcInfo.rcFrame.top;
588 if (size != This->sInfo.rcFrame.bottom - This->sInfo.rcFrame.top)
589 return AVIERR_UNSUPPORTED; /* FIXME: Can't GetFrame convert it? */
590 } else if (srcInfo.fccType == streamtypeAUDIO) {
591 if (! AVIFILE_FormatsEqual((PAVISTREAM)&This->iAVIStream, pSource))
592 return AVIERR_UNSUPPORTED;
593 } else {
594 /* FIXME: streamtypeMIDI and streamtypeTEXT */
595 return AVIERR_UNSUPPORTED;
596 }
597
598 /* try to get an IEditStreamInternal interface */
599 if (SUCCEEDED(IAVIStream_QueryInterface(pSource, &IID_IEditStreamInternal,
600 (LPVOID*)&pInternal))) {
601 pInternal->lpVtbl->GetEditStreamImpl(pInternal, (LPVOID*)&pEdit);
602 pInternal->lpVtbl->Release(pInternal);
603 }
604
605 /* for video must check for change of format */
606 if (This->sInfo.fccType == streamtypeVIDEO) {
607 if (! This->bDecompress) {
608 /* Need to decompress if any of the following conditions matches:
609 * - pSource is an editable stream which decompresses
610 * - the nearest keyframe of pSource isn't lStart
611 * - the nearest keyframe of this stream isn't *plStart
612 * - the format of pSource doesn't match this one
613 */
614 if ((pEdit != NULL && pEdit->bDecompress) ||
615 AVIStreamNearestKeyFrame(pSource, lStart) != lStart ||
616 AVIStreamNearestKeyFrame((PAVISTREAM)&This->iAVIStream, *plStart) != *plStart ||
617 (This->nStreams > 0 && !AVIFILE_FormatsEqual((PAVISTREAM)&This->iAVIStream, pSource))) {
618 /* Use first stream part to get format to convert everything to */
619 AVIFILE_ReadFrame(This, This->pStreams[0].pStream,
620 This->pStreams[0].dwStart);
621
622 /* Check if we could convert the source streams to the disired format... */
623 if (pEdit != NULL) {
624 if (FAILED(AVIFILE_FindStreamInTable(pEdit, lStart, &pStream,
625 &startPos, &streamNr, TRUE)))
626 return AVIERR_INTERNAL;
627 for (n = lStart; n < lStart + lLength; streamNr++) {
628 if (AVIFILE_ReadFrame(This, pEdit->pStreams[streamNr].pStream, startPos) == NULL)
629 return AVIERR_BADFORMAT;
630 startPos = pEdit->pStreams[streamNr].dwStart;
631 n += pEdit->pStreams[streamNr].dwLength;
632 }
633 } else if (AVIFILE_ReadFrame(This, pSource, lStart) == NULL)
634 return AVIERR_BADFORMAT;
635
636 This->bDecompress = TRUE;
637 This->sInfo.fccHandler = 0;
638 }
639 } else if (AVIFILE_ReadFrame(This, pSource, lStart) == NULL)
640 return AVIERR_BADFORMAT; /* Can't convert source to own format */
641 } /* FIXME: something special for the other formats? */
642
643 /* Make sure we have enough memory for parts */
644 if (pEdit != NULL) {
645 DWORD nLastStream;
646
647 AVIFILE_FindStreamInTable(pEdit, lStart + lLength, &pStream,
648 &endPos, &nLastStream, TRUE);
649 AVIFILE_FindStreamInTable(pEdit, lStart, &pStream,
650 &startPos, &streamNr, FALSE);
651 if (nLastStream == streamNr)
652 nLastStream++;
653
654 nStreams = nLastStream - streamNr;
655 } else
656 nStreams = 1;
657 if (This->nStreams + nStreams + 1 > This->nTableSize) {
658 n = This->nStreams + nStreams + 33;
659
660 This->pStreams =
661 GlobalReAllocPtr(This->pStreams, n * sizeof(EditStreamTable), GMEM_SHARE|GHND);
662 if (This->pStreams == NULL)
663 return AVIERR_MEMORY;
664 This->nTableSize = n;
665 }
666
667 if (plLength != NULL)
668 *plLength = lLength;
669
670 /* now do the real work */
671 if (This->sInfo.dwStart + This->sInfo.dwLength > *plStart) {
672 AVIFILE_FindStreamInTable(This, *plStart, &pStream,
673 &startPos, &streamNr, FALSE);
674 if (startPos != This->pStreams[streamNr].dwStart) {
675 /* split stream streamNr at startPos */
676 memmove(This->pStreams + streamNr + nStreams + 1,
677 This->pStreams + streamNr,
678 (This->nStreams + nStreams - streamNr + 1) * sizeof(EditStreamTable));
679
680 This->pStreams[streamNr + 2].dwLength =
681 EditStreamEnd(This, streamNr + 2) - startPos;
682 This->pStreams[streamNr + 2].dwStart = startPos;
683 This->pStreams[streamNr].dwLength =
684 startPos - This->pStreams[streamNr].dwStart;
685 IAVIStream_AddRef(This->pStreams[streamNr].pStream);
686 streamNr++;
687 } else {
688 /* insert before stream at streamNr */
689 memmove(This->pStreams + streamNr + nStreams, This->pStreams + streamNr,
690 (This->nStreams + nStreams - streamNr) * sizeof(EditStreamTable));
691 }
692 } else /* append the streams */
693 streamNr = This->nStreams;
694
695 if (pEdit != NULL) {
696 /* insert the parts of the editable stream instead of itself */
697 AVIFILE_FindStreamInTable(pEdit, lStart + lLength, &pStream,
698 &endPos, NULL, FALSE);
699 AVIFILE_FindStreamInTable(pEdit, lStart, &pStream, &startPos, &n, FALSE);
700
701 memcpy(This->pStreams + streamNr, pEdit->pStreams + n,
702 nStreams * sizeof(EditStreamTable));
703 if (This->pStreams[streamNr].dwStart < startPos) {
704 This->pStreams[streamNr].dwLength =
705 EditStreamEnd(This, streamNr) - startPos;
706 This->pStreams[streamNr].dwStart = startPos;
707 }
708 if (endPos < EditStreamEnd(This, streamNr + nStreams))
709 This->pStreams[streamNr + nStreams].dwLength =
710 endPos - This->pStreams[streamNr + nStreams].dwStart;
711 } else {
712 /* a simple stream */
713 This->pStreams[streamNr].pStream = pSource;
714 This->pStreams[streamNr].dwStart = lStart;
715 This->pStreams[streamNr].dwLength = lLength;
716 }
717
718 for (n = 0; n < nStreams; n++) {
719 IAVIStream_AddRef(This->pStreams[streamNr + n].pStream);
720 if (0 < streamNr + n &&
721 This->pStreams[streamNr + n - 1].pStream != This->pStreams[streamNr + n].pStream) {
722 This->sInfo.dwFlags |= AVISTREAMINFO_FORMATCHANGES;
723 This->sInfo.dwFormatChangeCount++;
724 }
725 }
726 This->sInfo.dwEditCount++;
727 This->sInfo.dwLength += lLength;
728 This->nStreams += nStreams;
729
730 return AVIERR_OK;
731 }
732
733 static HRESULT WINAPI IAVIEditStream_fnClone(IAVIEditStream*iface,
734 PAVISTREAM*ppResult)
735 {
736 ICOM_THIS(IAVIEditStreamImpl,iface);
737 IAVIEditStreamImpl* pEdit;
738 DWORD i;
739
740 TRACE("(%p,%p)\n",iface,ppResult);
741
742 if (ppResult == NULL)
743 return AVIERR_BADPARAM;
744 *ppResult = NULL;
745
746 pEdit = (IAVIEditStreamImpl*)AVIFILE_CreateEditStream(NULL);
747 if (pEdit == NULL)
748 return AVIERR_MEMORY;
749 if (This->nStreams > pEdit->nTableSize) {
750 pEdit->pStreams = GlobalReAllocPtr(pEdit->pStreams, This->nStreams * sizeof(EditStreamTable),GMEM_SHARE|GHND);
751 if (pEdit->pStreams == NULL)
752 return AVIERR_MEMORY;
753 pEdit->nTableSize = This->nStreams;
754 }
755 pEdit->nStreams = This->nStreams;
756 memcpy(pEdit->pStreams, This->pStreams,
757 This->nStreams * sizeof(EditStreamTable));
758 memcpy(&pEdit->sInfo,&This->sInfo,sizeof(This->sInfo));
759 for (i = 0; i < This->nStreams; i++) {
760 if (pEdit->pStreams[i].pStream != NULL)
761 IAVIStream_AddRef(pEdit->pStreams[i].pStream);
762 }
763
764 *ppResult = (PAVISTREAM)&pEdit->iAVIStream;
765
766 return AVIERR_OK;
767 }
768
769 static HRESULT WINAPI IAVIEditStream_fnSetInfo(IAVIEditStream*iface,
770 LPAVISTREAMINFOW asi,LONG size)
771 {
772 ICOM_THIS(IAVIEditStreamImpl,iface);
773
774 TRACE("(%p,%p,%ld)\n",iface,asi,size);
775
776 /* check parameters */
777 if (asi == NULL)
778 return AVIERR_BADPARAM;
779 if (size != sizeof(AVISTREAMINFOW))
780 return AVIERR_BADSIZE;
781 if (asi->dwScale == 0 || asi->dwRate == 0 || (LONG)asi->dwQuality < -1 ||
782 asi->dwQuality > ICQUALITY_HIGH)
783 return AVIERR_ERROR;
784
785 This->sInfo.wLanguage = asi->wLanguage;
786 This->sInfo.wPriority = asi->wPriority;
787 This->sInfo.dwStart = asi->dwStart;
788 if (asi->dwRate != 0)
789 This->sInfo.dwRate = asi->dwRate;
790 if (asi->dwScale != 0)
791 This->sInfo.dwScale = asi->dwScale;
792 if (asi->dwQuality <= ICQUALITY_HIGH)
793 This->sInfo.dwQuality = ICQUALITY_HIGH;
794 CopyRect(&This->sInfo.rcFrame, &asi->rcFrame);
795 memcpy(&This->sInfo.szName, &asi->szName, sizeof(asi->szName));
796 This->sInfo.dwEditCount++;
797
798 return AVIERR_OK;
799 }
800
801 static HRESULT WINAPI IEditAVIStream_fnQueryInterface(IAVIStream*iface,
802 REFIID refiid,LPVOID*obj)
803 {
804 ICOM_THIS(IEditAVIStreamImpl,iface);
805
806 assert(This->pae != NULL);
807
808 return IAVIEditStream_QueryInterface((IAVIEditStream*)This->pae,refiid,obj);
809 }
810
811 static ULONG WINAPI IEditAVIStream_fnAddRef(IAVIStream*iface)
812 {
813 ICOM_THIS(IEditAVIStreamImpl,iface);
814
815 assert(This->pae != NULL);
816
817 return IAVIEditStream_AddRef((IAVIEditStream*)This->pae);
818 }
819
820 static ULONG WINAPI IEditAVIStream_fnRelease(IAVIStream*iface)
821 {
822 ICOM_THIS(IEditAVIStreamImpl,iface);
823
824 assert(This->pae != NULL);
825
826 return IAVIEditStream_Release((IAVIEditStream*)This->pae);
827 }
828
829 static HRESULT WINAPI IEditAVIStream_fnCreate(IAVIStream*iface,
830 LPARAM lParam1,LPARAM lParam2)
831 {
832 IAVIEditStreamImpl *This = ((IEditAVIStreamImpl*)iface)->pae;
833
834 if (lParam2 != 0)
835 return AVIERR_ERROR;
836
837 if (This->pStreams == NULL) {
838 This->pStreams =
839 GlobalAllocPtr(GMEM_SHARE|GHND, 256 * sizeof(EditStreamTable));
840 if (This->pStreams == NULL)
841 return AVIERR_MEMORY;
842 This->nTableSize = 256;
843 }
844
845 if (lParam1 != 0) {
846 IAVIStream_Info((PAVISTREAM)lParam1, &This->sInfo, sizeof(This->sInfo));
847 IAVIStream_AddRef((PAVISTREAM)lParam1);
848 This->pStreams[0].pStream = (PAVISTREAM)lParam1;
849 This->pStreams[0].dwStart = This->sInfo.dwStart;
850 This->pStreams[0].dwLength = This->sInfo.dwLength;
851 This->nStreams = 1;
852 }
853 return AVIERR_OK;
854 }
855
856 static HRESULT WINAPI IEditAVIStream_fnInfo(IAVIStream*iface,
857 AVISTREAMINFOW *psi,LONG size)
858 {
859 ICOM_THIS(IEditAVIStreamImpl,iface);
860
861 TRACE("(%p,%p,%ld)\n",iface,psi,size);
862
863 assert(This->pae != NULL);
864
865 if (psi == NULL)
866 return AVIERR_BADPARAM;
867 if (size < 0)
868 return AVIERR_BADSIZE;
869
870 if (This->pae->bDecompress)
871 This->pae->sInfo.fccHandler = 0;
872
873 memcpy(psi, &This->pae->sInfo, min((DWORD)size, sizeof(This->pae->sInfo)));
874
875 if ((DWORD)size < sizeof(This->pae->sInfo))
876 return AVIERR_BUFFERTOOSMALL;
877 return AVIERR_OK;
878 }
879
880 static LONG WINAPI IEditAVIStream_fnFindSample(IAVIStream*iface,LONG pos,
881 LONG flags)
882 {
883 IAVIEditStreamImpl* const This = ((IEditAVIStreamImpl* const)iface)->pae;
884 PAVISTREAM stream;
885 DWORD streamPos, streamNr;
886
887 TRACE("(%p,%ld,0x%08lX)\n",iface,pos,flags);
888
889 if (flags & FIND_FROM_START)
890 pos = (LONG)This->sInfo.dwStart;
891
892 /* outside of stream? */
893 if (pos < (LONG)This->sInfo.dwStart ||
894 (LONG)This->sInfo.dwStart + (LONG)This->sInfo.dwLength <= pos)
895 return -1;
896
897 /* map our position to a stream and position in it */
898 if (AVIFILE_FindStreamInTable(This, pos, &stream, &streamPos,
899 &streamNr, TRUE))
900 return -1; /* doesn't exist */
901
902 if (This->bDecompress) {
903 /* only one stream -- format changes only at start */
904 if (flags & FIND_FORMAT)
905 return (flags & FIND_NEXT ? -1 : 0);
906
907 /* FIXME: map positions back to us */
908 return IAVIStream_FindSample(stream, streamPos, flags);
909 } else {
910 /* assume change of format every frame */
911 return pos;
912 }
913 }
914
915 static HRESULT WINAPI IEditAVIStream_fnReadFormat(IAVIStream*iface,LONG pos,
916 LPVOID format,LONG*fmtsize)
917 {
918 IAVIEditStreamImpl* const This = ((IEditAVIStreamImpl* const)iface)->pae;
919 LPBITMAPINFOHEADER lp;
920 PAVISTREAM stream;
921 DWORD n;
922 HRESULT hr;
923
924 TRACE("(%p,%ld,%p,%p)\n",iface,pos,format,fmtsize);
925
926 if (fmtsize == NULL || pos < This->sInfo.dwStart ||
927 This->sInfo.dwStart + This->sInfo.dwLength <= pos)
928 return AVIERR_BADPARAM;
929
930 /* find stream corresponding to position */
931 hr = AVIFILE_FindStreamInTable(This, pos, &stream, &n, NULL, FALSE);
932 if (FAILED(hr))
933 return hr;
934
935 if (! This->bDecompress)
936 return IAVIStream_ReadFormat(stream, n, format, fmtsize);
937
938 lp = (LPBITMAPINFOHEADER)AVIFILE_ReadFrame(This, stream, n);
939 if (lp == NULL)
940 return AVIERR_ERROR;
941 if (lp->biBitCount <= 8) {
942 n = (lp->biClrUsed > 0 ? lp->biClrUsed : 1 << lp->biBitCount);
943 n *= sizeof(RGBQUAD);
944 } else
945 n = 0;
946 n += lp->biSize;
947
948 memcpy(format, lp, min((LONG)n, *fmtsize));
949 hr = ((LONG)n > *fmtsize ? AVIERR_BUFFERTOOSMALL : AVIERR_OK);
950 *fmtsize = n;
951
952 return hr;
953 }
954
955 static HRESULT WINAPI IEditAVIStream_fnSetFormat(IAVIStream*iface,LONG pos,
956 LPVOID format,LONG formatsize)
957 {
958 TRACE("(%p,%ld,%p,%ld)\n",iface,pos,format,formatsize);
959
960 return AVIERR_UNSUPPORTED;
961 }
962
963 static HRESULT WINAPI IEditAVIStream_fnRead(IAVIStream*iface,LONG start,
964 LONG samples,LPVOID buffer,
965 LONG buffersize,LONG*bytesread,
966 LONG*samplesread)
967 {
968 IAVIEditStreamImpl* const This = ((IEditAVIStreamImpl* const)iface)->pae;
969 PAVISTREAM stream;
970 DWORD streamPos, streamNr;
971 LONG readBytes, readSamples, count;
972 HRESULT hr;
973
974 TRACE("(%p,%ld,%ld,%p,%ld,%p,%p) -- 0x%08lX\n",iface,start,samples,
975 buffer,buffersize,bytesread,samplesread,This->sInfo.fccType);
976
977 /* check parameters */
978 if (bytesread != NULL)
979 *bytesread = 0;
980 if (samplesread != NULL)
981 *samplesread = 0;
982 if (buffersize < 0)
983 return AVIERR_BADSIZE;
984 if ((DWORD)start < This->sInfo.dwStart ||
985 This->sInfo.dwStart + This->sInfo.dwLength < (DWORD)start)
986 return AVIERR_BADPARAM;
987
988 if (! This->bDecompress) {
989 /* audio like data -- sample-based */
990 do {
991 if (samples == 0)
992 return AVIERR_OK; /* nothing at all or already done */
993
994 if (FAILED(AVIFILE_FindStreamInTable(This, start, &stream,
995 &streamPos, &streamNr, FALSE)))
996 return AVIERR_ERROR;
997
998 /* limit to end of the stream */
999 count = samples;
1000 if (streamPos + count > EditStreamEnd(This, streamNr))
1001 count = EditStreamEnd(This, streamNr) - streamPos;
1002
1003 hr = IAVIStream_Read(stream, streamPos, count, buffer, buffersize,
1004 &readBytes, &readSamples);
1005 if (FAILED(hr))
1006 return hr;
1007 if (readBytes == 0 && readSamples == 0 && count != 0)
1008 return AVIERR_FILEREAD; /* for bad stream implementations */
1009
1010 if (samplesread != NULL)
1011 *samplesread += readSamples;
1012 if (bytesread != NULL)
1013 *bytesread += readBytes;
1014 if (buffer != NULL) {
1015 (LPBYTE)buffer += readBytes;
1016 buffersize -= readBytes;
1017 }
1018 start += count;
1019 samples -= count;
1020 } while (This->sInfo.dwStart + This->sInfo.dwLength > start);
1021 } else {
1022 /* video like data -- frame-based */
1023 LPBITMAPINFOHEADER lp;
1024
1025 if (samples == 0)
1026 return AVIERR_OK;
1027
1028 if (FAILED(AVIFILE_FindStreamInTable(This, start, &stream,
1029 &streamPos, &streamNr, FALSE)))
1030 return AVIERR_ERROR;
1031
1032 lp = AVIFILE_ReadFrame(This, stream, streamPos);
1033 if (lp == NULL)
1034 return AVIERR_ERROR;
1035
1036 if (buffer != NULL) {
1037 /* need size of format to skip */
1038 if (lp->biBitCount <= 8) {
1039 count = lp->biClrUsed > 0 ? lp->biClrUsed : 1 << lp->biBitCount;
1040 count *= sizeof(RGBQUAD);
1041 } else
1042 count = 0;
1043 count += lp->biSize;
1044
1045 if (buffersize < lp->biSizeImage)
1046 return AVIERR_BUFFERTOOSMALL;
1047 memcpy(buffer, (LPBYTE)lp + count, lp->biSizeImage);
1048 }
1049
1050 if (bytesread != NULL)
1051 *bytesread = lp->biSizeImage;
1052 if (samplesread != NULL)
1053 *samplesread = 1;
1054 }
1055
1056 return AVIERR_OK;
1057 }
1058
1059 static HRESULT WINAPI IEditAVIStream_fnWrite(IAVIStream*iface,LONG start,
1060 LONG samples,LPVOID buffer,
1061 LONG buffersize,DWORD flags,
1062 LONG*sampwritten,LONG*byteswritten)
1063 {
1064 TRACE("(%p,%ld,%ld,%p,%ld,0x%08lX,%p,%p)\n",iface,start,samples,buffer,
1065 buffersize,flags,sampwritten,byteswritten);
1066
1067 /* be sure return parameters have correct values */
1068 if (sampwritten != NULL)
1069 *sampwritten = 0;
1070 if (byteswritten != NULL)
1071 *byteswritten = 0;
1072
1073 return AVIERR_UNSUPPORTED;
1074 }
1075
1076 static HRESULT WINAPI IEditAVIStream_fnDelete(IAVIStream*iface,LONG start,
1077 LONG samples)
1078 {
1079 ICOM_THIS(IEditAVIStreamImpl,iface);
1080
1081 TRACE("(%p,%ld,%ld)\n",iface,start,samples);
1082
1083 return IAVIEditStream_Cut((IAVIEditStream*)This->pae,&start,&samples,NULL);
1084 }
1085
1086 static HRESULT WINAPI IEditAVIStream_fnReadData(IAVIStream*iface,DWORD fcc,
1087 LPVOID lp,LONG *lpread)
1088 {
1089 IAVIEditStreamImpl* const This = ((IEditAVIStreamImpl* const)iface)->pae;
1090 DWORD n;
1091
1092 TRACE("(%p,0x%08lX,%p,%p)\n",iface,fcc,lp,lpread);
1093
1094 /* check parameters */
1095 if (lp == NULL || lpread == NULL)
1096 return AVIERR_BADPARAM;
1097
1098 /* simply ask every stream and return the first block found */
1099 for (n = 0; n < This->nStreams; n++) {
1100 HRESULT hr = IAVIStream_ReadData(This->pStreams[n].pStream,fcc,lp,lpread);
1101
1102 if (SUCCEEDED(hr))
1103 return hr;
1104 }
1105
1106 *lpread = 0;
1107 return AVIERR_NODATA;
1108 }
1109
1110 static HRESULT WINAPI IEditAVIStream_fnWriteData(IAVIStream*iface,DWORD fcc,
1111 LPVOID lp,LONG size)
1112 {
1113 TRACE("(%p,0x%08lX,%p,%ld)\n",iface,fcc,lp,size);
1114
1115 return AVIERR_UNSUPPORTED;
1116 }
1117
1118 static HRESULT WINAPI IEditAVIStream_fnSetInfo(IAVIStream*iface,
1119 AVISTREAMINFOW*info,LONG len)
1120 {
1121 ICOM_THIS(IEditAVIStreamImpl,iface);
1122
1123 TRACE("(%p,%p,%ld)\n",iface,info,len);
1124
1125 return IAVIEditStream_SetInfo((IAVIEditStream*)This->pae,info,len);
1126 }
1127
1128 static HRESULT WINAPI IEditStreamInternal_fnQueryInterface(IEditStreamInternal*iface,REFIID refiid,LPVOID*obj)
1129 {
1130 ICOM_THIS(IEditStreamInternalImpl,iface);
1131
1132 assert(This->pae != NULL);
1133
1134 return IAVIEditStream_QueryInterface((IAVIEditStream*)This->pae, refiid, obj);
1135 }
1136
1137 static ULONG WINAPI IEditStreamInternal_fnAddRef(IEditStreamInternal*iface)
1138 {
1139 ICOM_THIS(IEditStreamInternalImpl,iface);
1140
1141 assert(This->pae != NULL);
1142
1143 return IAVIEditStream_AddRef((IAVIEditStream*)This->pae);
1144 }
1145
1146 static ULONG WINAPI IEditStreamInternal_fnRelease(IEditStreamInternal*iface)
1147 {
1148 ICOM_THIS(IEditStreamInternalImpl,iface);
1149
1150 assert(This->pae != NULL);
1151
1152 return IAVIEditStream_Release((IAVIEditStream*)This->pae);
1153 }
1154
1155 static HRESULT WINAPI IEditStreamInternal_fnGetEditStreamImpl(IEditStreamInternal*iface,LPVOID*ppimpl)
1156 {
1157 ICOM_THIS(IEditStreamInternalImpl,iface);
1158
1159 TRACE("(%p,%p) -> %p\n", iface, ppimpl, This->pae);
1160
1161 assert(This->pae != NULL);
1162 assert(ppimpl != NULL);
1163
1164 *ppimpl = This->pae;
1165 return AVIERR_OK;
1166 }
Windows API implementation