dinput/tests: Skip acquire tests when not running in the foreground.
[wine] / dlls / avifil32 / icmstream.c
1 /*
2  * Copyright 2002 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include <assert.h>
20 #include <stdarg.h>
21
22 #include "windef.h"
23 #include "winbase.h"
24 #include "wingdi.h"
25 #include "winuser.h"
26 #include "winerror.h"
27 #include "mmsystem.h"
28 #include "vfw.h"
29
30 #include "avifile_private.h"
31
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(avifile);
35
36 #define MAX_FRAMESIZE       (16 * 1024 * 1024)
37 #define MAX_FRAMESIZE_DIFF  512
38
39 /***********************************************************************/
40
41 typedef struct _IAVIStreamImpl {
42   /* IUnknown stuff */
43   IAVIStream         IAVIStream_iface;
44   LONG               ref;
45
46   /* IAVIStream stuff */
47   PAVISTREAM         pStream;
48   AVISTREAMINFOW     sInfo;
49
50   PGETFRAME          pg;
51   HIC                hic;
52   DWORD              dwICMFlags;
53
54   LONG               lCurrent;
55   LONG               lLastKey;
56   LONG               lKeyFrameEvery;
57   DWORD              dwLastQuality;
58   DWORD              dwBytesPerFrame;
59   DWORD              dwUnusedBytes;
60
61   LPBITMAPINFOHEADER lpbiCur;  /* current frame */
62   LPVOID             lpCur;
63   LPBITMAPINFOHEADER lpbiPrev; /* previous frame */
64   LPVOID             lpPrev;
65
66   LPBITMAPINFOHEADER lpbiOutput; /* output format of codec */
67   LONG               cbOutput;
68   LPBITMAPINFOHEADER lpbiInput;  /* input format for codec */
69   LONG               cbInput;
70 } IAVIStreamImpl;
71
72 /***********************************************************************/
73
74 static HRESULT AVIFILE_EncodeFrame(IAVIStreamImpl *This,
75                                    LPBITMAPINFOHEADER lpbi, LPVOID lpBits);
76 static HRESULT AVIFILE_OpenGetFrame(IAVIStreamImpl *This);
77
78 static inline IAVIStreamImpl *impl_from_IAVIStream(IAVIStream *iface)
79 {
80   return CONTAINING_RECORD(iface, IAVIStreamImpl, IAVIStream_iface);
81 }
82
83 static inline void AVIFILE_Reset(IAVIStreamImpl *This)
84 {
85   This->lCurrent      = -1;
86   This->lLastKey      = 0;
87   This->dwLastQuality = ICQUALITY_HIGH;
88   This->dwUnusedBytes = 0;
89 }
90
91 static HRESULT WINAPI ICMStream_fnQueryInterface(IAVIStream *iface,
92                                                   REFIID refiid, LPVOID *obj)
93 {
94   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
95
96   TRACE("(%p,%s,%p)\n", iface, debugstr_guid(refiid), obj);
97
98   if (IsEqualGUID(&IID_IUnknown, refiid) ||
99       IsEqualGUID(&IID_IAVIStream, refiid)) {
100     *obj = This;
101     IAVIStream_AddRef(iface);
102
103     return S_OK;
104   }
105
106   return OLE_E_ENUM_NOMORE;
107 }
108
109 static ULONG WINAPI ICMStream_fnAddRef(IAVIStream *iface)
110 {
111   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
112   ULONG ref = InterlockedIncrement(&This->ref);
113
114   TRACE("(%p) -> %d\n", iface, ref);
115
116   /* also add reference to the nested stream */
117   if (This->pStream != NULL)
118     IAVIStream_AddRef(This->pStream);
119
120   return ref;
121 }
122
123 static ULONG WINAPI ICMStream_fnRelease(IAVIStream* iface)
124 {
125   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
126   ULONG ref = InterlockedDecrement(&This->ref);
127
128   TRACE("(%p) -> %d\n", iface, ref);
129
130   if (ref == 0) {
131     /* destruct */
132     if (This->pg != NULL) {
133       AVIStreamGetFrameClose(This->pg);
134       This->pg = NULL;
135     }
136     if (This->pStream != NULL) {
137       IAVIStream_Release(This->pStream);
138       This->pStream = NULL;
139     }
140     if (This->hic != NULL) {
141       if (This->lpbiPrev != NULL) {
142         ICDecompressEnd(This->hic);
143         HeapFree(GetProcessHeap(), 0, This->lpbiPrev);
144         This->lpbiPrev = NULL;
145         This->lpPrev   = NULL;
146       }
147       ICCompressEnd(This->hic);
148       This->hic = NULL;
149     }
150     if (This->lpbiCur != NULL) {
151       HeapFree(GetProcessHeap(), 0, This->lpbiCur);
152       This->lpbiCur = NULL;
153       This->lpCur   = NULL;
154     }
155     if (This->lpbiOutput != NULL) {
156       HeapFree(GetProcessHeap(), 0, This->lpbiOutput);
157       This->lpbiOutput = NULL;
158       This->cbOutput   = 0;
159     }
160     if (This->lpbiInput != NULL) {
161       HeapFree(GetProcessHeap(), 0, This->lpbiInput);
162       This->lpbiInput = NULL;
163       This->cbInput   = 0;
164     }
165
166     HeapFree(GetProcessHeap(), 0, This);
167
168     return 0;
169   }
170
171   /* also release reference to the nested stream */
172   if (This->pStream != NULL)
173     IAVIStream_Release(This->pStream);
174
175   return ref;
176 }
177
178 /* lParam1: PAVISTREAM
179  * lParam2: LPAVICOMPRESSOPTIONS
180  */
181 static HRESULT WINAPI ICMStream_fnCreate(IAVIStream *iface, LPARAM lParam1,
182                                           LPARAM lParam2)
183 {
184   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
185
186   ICINFO               icinfo;
187   ICCOMPRESSFRAMES     icFrames;
188   LPAVICOMPRESSOPTIONS pco = (LPAVICOMPRESSOPTIONS)lParam2;
189
190   TRACE("(%p,0x%08lX,0x%08lX)\n", iface, lParam1, lParam2);
191
192   /* check parameter */
193   if ((LPVOID)lParam1 == NULL)
194     return AVIERR_BADPARAM;
195
196   /* get infos from stream */
197   IAVIStream_Info((PAVISTREAM)lParam1, &This->sInfo, sizeof(This->sInfo));
198   if (This->sInfo.fccType != streamtypeVIDEO)
199     return AVIERR_ERROR; /* error in registry or AVIMakeCompressedStream */
200
201   /* add reference to the stream */
202   This->pStream = (PAVISTREAM)lParam1;
203   IAVIStream_AddRef(This->pStream);
204
205   AVIFILE_Reset(This);
206
207   if (pco != NULL && pco->fccHandler != comptypeDIB) {
208     /* we should compress */
209     This->sInfo.fccHandler = pco->fccHandler;
210
211     This->hic = ICOpen(ICTYPE_VIDEO, pco->fccHandler, ICMODE_COMPRESS);
212     if (This->hic == NULL)
213       return AVIERR_NOCOMPRESSOR;
214
215     /* restore saved state of codec */
216     if (pco->cbParms > 0 && pco->lpParms != NULL) {
217       ICSetState(This->hic, pco->lpParms, pco->cbParms);
218     }
219
220     /* set quality -- resolve default quality */
221     This->sInfo.dwQuality = pco->dwQuality;
222     if (pco->dwQuality == ICQUALITY_DEFAULT)
223       This->sInfo.dwQuality = ICGetDefaultQuality(This->hic);
224
225     /* get capabilities of codec */
226     ICGetInfo(This->hic, &icinfo, sizeof(icinfo));
227     This->dwICMFlags = icinfo.dwFlags;
228
229     /* use keyframes? */
230     if ((pco->dwFlags & AVICOMPRESSF_KEYFRAMES) &&
231         (icinfo.dwFlags & (VIDCF_TEMPORAL|VIDCF_FASTTEMPORALC))) {
232       This->lKeyFrameEvery = pco->dwKeyFrameEvery;
233     } else
234       This->lKeyFrameEvery = 1;
235
236     /* use datarate? */
237     if ((pco->dwFlags & AVICOMPRESSF_DATARATE)) {
238       /* Do we have a chance to reduce size to desired one? */
239       if ((icinfo.dwFlags & (VIDCF_CRUNCH|VIDCF_QUALITY)) == 0)
240         return AVIERR_NOCOMPRESSOR;
241
242       assert(This->sInfo.dwRate != 0);
243
244       This->dwBytesPerFrame = MulDiv(pco->dwBytesPerSecond,
245                                      This->sInfo.dwScale, This->sInfo.dwRate);
246     } else {
247       pco->dwBytesPerSecond = 0;
248       This->dwBytesPerFrame = 0;
249     }
250
251     if (icinfo.dwFlags & VIDCF_COMPRESSFRAMES) {
252       memset(&icFrames, 0, sizeof(icFrames));
253       icFrames.lpbiOutput  = This->lpbiOutput;
254       icFrames.lpbiInput   = This->lpbiInput;
255       icFrames.lFrameCount = This->sInfo.dwLength;
256       icFrames.lQuality    = This->sInfo.dwQuality;
257       icFrames.lDataRate   = pco->dwBytesPerSecond;
258       icFrames.lKeyRate    = This->lKeyFrameEvery;
259       icFrames.dwRate      = This->sInfo.dwRate;
260       icFrames.dwScale     = This->sInfo.dwScale;
261       ICSendMessage(This->hic, ICM_COMPRESS_FRAMES_INFO,
262                     (LPARAM)&icFrames, (LPARAM)sizeof(icFrames));
263     }
264   } else
265     This->sInfo.fccHandler = comptypeDIB;
266
267   return AVIERR_OK;
268 }
269
270 static HRESULT WINAPI ICMStream_fnInfo(IAVIStream *iface,LPAVISTREAMINFOW psi,
271                                         LONG size)
272 {
273   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
274
275   TRACE("(%p,%p,%d)\n", iface, psi, size);
276
277   if (psi == NULL)
278     return AVIERR_BADPARAM;
279   if (size < 0)
280     return AVIERR_BADSIZE;
281
282   memcpy(psi, &This->sInfo, min((DWORD)size, sizeof(This->sInfo)));
283
284   if ((DWORD)size < sizeof(This->sInfo))
285     return AVIERR_BUFFERTOOSMALL;
286   return AVIERR_OK;
287 }
288
289 static LONG WINAPI ICMStream_fnFindSample(IAVIStream *iface, LONG pos,
290                                            LONG flags)
291 {
292   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
293
294   TRACE("(%p,%d,0x%08X)\n",iface,pos,flags);
295
296   if (flags & FIND_FROM_START) {
297     pos = This->sInfo.dwStart;
298     flags &= ~(FIND_FROM_START|FIND_PREV);
299     flags |= FIND_NEXT;
300   }
301
302   if (flags & FIND_RET)
303     WARN(": FIND_RET flags will be ignored!\n");
304
305   if (flags & FIND_KEY) {
306     if (This->hic == NULL)
307       return pos; /* we decompress so every frame is a keyframe */
308
309     if (flags & FIND_PREV) {
310       /* need to read old or new frames? */
311       if (This->lLastKey <= pos || pos < This->lCurrent)
312         IAVIStream_Read(iface, pos, 1, NULL, 0, NULL, NULL);
313
314       return This->lLastKey;
315     }
316   } else if (flags & FIND_ANY) {
317     return pos; /* We really don't know, reread is to expensive, so guess. */
318   } else if (flags & FIND_FORMAT) {
319     if (flags & FIND_PREV)
320       return 0;
321   }
322
323   return -1;
324 }
325
326 static HRESULT WINAPI ICMStream_fnReadFormat(IAVIStream *iface, LONG pos,
327                                               LPVOID format, LONG *formatsize)
328 {
329   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
330
331   LPBITMAPINFOHEADER lpbi;
332   HRESULT            hr;
333
334   TRACE("(%p,%d,%p,%p)\n", iface, pos, format, formatsize);
335
336   if (formatsize == NULL)
337     return AVIERR_BADPARAM;
338
339   if (This->pg == NULL) {
340     hr = AVIFILE_OpenGetFrame(This);
341
342     if (FAILED(hr))
343       return hr;
344   }
345
346   lpbi = AVIStreamGetFrame(This->pg, pos);
347   if (lpbi == NULL)
348     return AVIERR_MEMORY;
349
350   if (This->hic == NULL) {
351     LONG size = lpbi->biSize + lpbi->biClrUsed * sizeof(RGBQUAD);
352
353     if (size > 0) {
354       if (This->sInfo.dwSuggestedBufferSize < lpbi->biSizeImage)
355         This->sInfo.dwSuggestedBufferSize = lpbi->biSizeImage;
356
357       This->cbOutput = size;
358       if (format != NULL) {
359         if (This->lpbiOutput != NULL)
360           memcpy(format, This->lpbiOutput, min(*formatsize, This->cbOutput));
361         else
362           memcpy(format, lpbi, min(*formatsize, size));
363       }
364     }
365   } else if (format != NULL)
366     memcpy(format, This->lpbiOutput, min(*formatsize, This->cbOutput));
367
368   if (*formatsize < This->cbOutput)
369     hr = AVIERR_BUFFERTOOSMALL;
370   else
371     hr = AVIERR_OK;
372
373   *formatsize = This->cbOutput;
374   return hr;
375 }
376
377 static HRESULT WINAPI ICMStream_fnSetFormat(IAVIStream *iface, LONG pos,
378                                              LPVOID format, LONG formatsize)
379 {
380   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
381
382   TRACE("(%p,%d,%p,%d)\n", iface, pos, format, formatsize);
383
384   /* check parameters */
385   if (format == NULL || formatsize <= 0)
386     return AVIERR_BADPARAM;
387
388   /* We can only accept RGB data for writing */
389   if (((LPBITMAPINFOHEADER)format)->biCompression != BI_RGB) {
390     WARN(": need RGB data as input\n");
391     return AVIERR_UNSUPPORTED;
392   }
393
394   /* Input format already known?
395    * Changing of palette is supported, but be quiet if it's the same */
396   if (This->lpbiInput != NULL) {
397     if (This->cbInput != formatsize)
398       return AVIERR_UNSUPPORTED;
399
400     if (memcmp(format, This->lpbiInput, formatsize) == 0)
401       return AVIERR_OK;
402   }
403
404   /* Does the nested stream support writing? */
405   if ((This->sInfo.dwCaps & AVIFILECAPS_CANWRITE) == 0)
406     return AVIERR_READONLY;
407
408   /* check if frame is already written */
409   if (This->sInfo.dwLength + This->sInfo.dwStart > pos)
410     return AVIERR_UNSUPPORTED;
411
412   /* check if we should compress */
413   if (This->sInfo.fccHandler == 0 ||
414       This->sInfo.fccHandler == mmioFOURCC('N','O','N','E'))
415     This->sInfo.fccHandler = comptypeDIB;
416
417   /* only pass through? */
418   if (This->sInfo.fccHandler == comptypeDIB)
419     return IAVIStream_SetFormat(This->pStream, pos, format, formatsize);
420
421   /* initial format setting? */
422   if (This->lpbiInput == NULL) {
423     ULONG size;
424
425     assert(This->hic != NULL);
426
427     /* get memory for input format */
428     This->lpbiInput = HeapAlloc(GetProcessHeap(), 0, formatsize);
429     if (This->lpbiInput == NULL)
430       return AVIERR_MEMORY;
431     This->cbInput = formatsize;
432     memcpy(This->lpbiInput, format, formatsize);
433
434     /* get output format */
435     size = ICCompressGetFormatSize(This->hic, This->lpbiInput);
436     if (size < sizeof(BITMAPINFOHEADER))
437       return AVIERR_COMPRESSOR;
438     This->lpbiOutput = HeapAlloc(GetProcessHeap(), 0, size);
439     if (This->lpbiOutput == NULL)
440       return AVIERR_MEMORY;
441     This->cbOutput = size;
442     if (ICCompressGetFormat(This->hic,This->lpbiInput,This->lpbiOutput) < S_OK)
443       return AVIERR_COMPRESSOR;
444
445     /* update AVISTREAMINFO structure */
446     This->sInfo.rcFrame.right  =
447       This->sInfo.rcFrame.left + This->lpbiOutput->biWidth;
448     This->sInfo.rcFrame.bottom =
449       This->sInfo.rcFrame.top  + This->lpbiOutput->biHeight;
450
451     /* prepare codec for compression */
452     if (ICCompressBegin(This->hic, This->lpbiInput, This->lpbiOutput) != S_OK)
453       return AVIERR_COMPRESSOR;
454
455     /* allocate memory for compressed frame */
456     size = ICCompressGetSize(This->hic, This->lpbiInput, This->lpbiOutput);
457     This->lpbiCur = HeapAlloc(GetProcessHeap(), 0, This->cbOutput + size);
458     if (This->lpbiCur == NULL)
459       return AVIERR_MEMORY;
460     memcpy(This->lpbiCur, This->lpbiOutput, This->cbOutput);
461     This->lpCur = DIBPTR(This->lpbiCur);
462
463     /* allocate memory for last frame if needed */
464     if (This->lKeyFrameEvery != 1 &&
465         (This->dwICMFlags & VIDCF_FASTTEMPORALC) == 0) {
466       size = ICDecompressGetFormatSize(This->hic, This->lpbiOutput);
467       This->lpbiPrev = HeapAlloc(GetProcessHeap(), 0, size);
468       if (This->lpbiPrev == NULL)
469         return AVIERR_MEMORY;
470       if (ICDecompressGetFormat(This->hic, This->lpbiOutput, This->lpbiPrev) < S_OK)
471         return AVIERR_COMPRESSOR;
472
473       if (This->lpbiPrev->biSizeImage == 0) {
474         This->lpbiPrev->biSizeImage =
475           DIBWIDTHBYTES(*This->lpbiPrev) * This->lpbiPrev->biHeight;
476       }
477
478       /* get memory for format and picture */
479       size += This->lpbiPrev->biSizeImage;
480       This->lpbiPrev = HeapReAlloc(GetProcessHeap(), 0, This->lpbiPrev, size);
481       if (This->lpbiPrev == NULL)
482         return AVIERR_MEMORY;
483       This->lpPrev = DIBPTR(This->lpbiPrev);
484
485       /* prepare codec also for decompression */
486       if (ICDecompressBegin(This->hic,This->lpbiOutput,This->lpbiPrev) != S_OK)
487         return AVIERR_COMPRESSOR;
488     }
489   } else {
490     /* format change -- check that's only the palette */
491     LPBITMAPINFOHEADER lpbi = format;
492
493     if (lpbi->biSize != This->lpbiInput->biSize ||
494         lpbi->biWidth != This->lpbiInput->biWidth ||
495         lpbi->biHeight != This->lpbiInput->biHeight ||
496         lpbi->biBitCount != This->lpbiInput->biBitCount ||
497         lpbi->biPlanes != This->lpbiInput->biPlanes ||
498         lpbi->biCompression != This->lpbiInput->biCompression ||
499         lpbi->biClrUsed != This->lpbiInput->biClrUsed)
500       return AVIERR_UNSUPPORTED;
501
502     /* get new output format */
503     if (ICCompressGetFormat(This->hic, lpbi, This->lpbiOutput) < S_OK)
504       return AVIERR_BADFORMAT;
505
506     /* restart compression */
507     ICCompressEnd(This->hic);
508     if (ICCompressBegin(This->hic, lpbi, This->lpbiOutput) != S_OK)
509       return AVIERR_COMPRESSOR;
510
511     /* check if we need to restart decompression also */
512     if (This->lKeyFrameEvery != 1 &&
513         (This->dwICMFlags & VIDCF_FASTTEMPORALC) == 0) {
514       ICDecompressEnd(This->hic);
515       if (ICDecompressGetFormat(This->hic,This->lpbiOutput,This->lpbiPrev) < S_OK)
516         return AVIERR_COMPRESSOR;
517       if (ICDecompressBegin(This->hic,This->lpbiOutput,This->lpbiPrev) != S_OK)
518         return AVIERR_COMPRESSOR;
519     }
520   }
521
522   /* tell nested stream the new format */
523   return IAVIStream_SetFormat(This->pStream, pos,
524                               This->lpbiOutput, This->cbOutput);
525 }
526
527 static HRESULT WINAPI ICMStream_fnRead(IAVIStream *iface, LONG start,
528                                         LONG samples, LPVOID buffer,
529                                         LONG buffersize, LPLONG bytesread,
530                                         LPLONG samplesread)
531 {
532   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
533
534   LPBITMAPINFOHEADER lpbi;
535
536   TRACE("(%p,%d,%d,%p,%d,%p,%p)\n", iface, start, samples, buffer,
537         buffersize, bytesread, samplesread);
538
539   /* clear return parameters if given */
540   if (bytesread != NULL)
541     *bytesread = 0;
542   if (samplesread != NULL)
543     *samplesread = 0;
544
545   if (samples == 0)
546     return AVIERR_OK;
547
548   /* check parameters */
549   if (samples != 1 && (bytesread == NULL && samplesread == NULL))
550     return AVIERR_BADPARAM;
551   if (samples == -1) /* read as much as we could */
552     samples = 1;
553
554   if (This->pg == NULL) {
555     HRESULT hr = AVIFILE_OpenGetFrame(This);
556
557     if (FAILED(hr))
558       return hr;
559   }
560
561   /* compress or decompress? */
562   if (This->hic == NULL) {
563     /* decompress */
564     lpbi = AVIStreamGetFrame(This->pg, start);
565     if (lpbi == NULL)
566       return AVIERR_MEMORY;
567
568     if (buffer != NULL && buffersize > 0) {
569       /* check buffersize */
570       if (buffersize < lpbi->biSizeImage)
571         return AVIERR_BUFFERTOOSMALL;
572
573       memcpy(buffer, DIBPTR(lpbi), lpbi->biSizeImage);
574     }
575
576     /* fill out return parameters if given */
577     if (bytesread != NULL)
578       *bytesread = lpbi->biSizeImage;
579   } else {
580     /* compress */
581     if (This->lCurrent > start)
582       AVIFILE_Reset(This);
583
584     while (start > This->lCurrent) {
585       HRESULT hr;
586
587       lpbi = AVIStreamGetFrame(This->pg, ++This->lCurrent);
588       if (lpbi == NULL) {
589         AVIFILE_Reset(This);
590         return AVIERR_MEMORY;
591       }
592
593       hr = AVIFILE_EncodeFrame(This, lpbi, DIBPTR(lpbi));
594       if (FAILED(hr)) {
595         AVIFILE_Reset(This);
596         return hr;
597       }
598     }
599
600     if (buffer != NULL && buffersize > 0) {
601       /* check buffersize */
602       if (This->lpbiCur->biSizeImage > buffersize)
603         return AVIERR_BUFFERTOOSMALL;
604
605       memcpy(buffer, This->lpCur, This->lpbiCur->biSizeImage);
606     }
607
608     /* fill out return parameters if given */
609     if (bytesread != NULL)
610       *bytesread = This->lpbiCur->biSizeImage;
611   }
612
613   /* fill out return parameters if given */
614   if (samplesread != NULL)
615     *samplesread = 1;
616
617   return AVIERR_OK;
618 }
619
620 static HRESULT WINAPI ICMStream_fnWrite(IAVIStream *iface, LONG start,
621                                          LONG samples, LPVOID buffer,
622                                          LONG buffersize, DWORD flags,
623                                          LPLONG sampwritten,
624                                          LPLONG byteswritten)
625 {
626   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
627
628   HRESULT hr;
629
630   TRACE("(%p,%d,%d,%p,%d,0x%08X,%p,%p)\n", iface, start, samples,
631         buffer, buffersize, flags, sampwritten, byteswritten);
632
633   /* clear return parameters if given */
634   if (sampwritten != NULL)
635     *sampwritten = 0;
636   if (byteswritten != NULL)
637     *byteswritten = 0;
638
639   /* check parameters */
640   if (buffer == NULL && (buffersize > 0 || samples > 0))
641     return AVIERR_BADPARAM;
642
643   if (This->sInfo.fccHandler == comptypeDIB) {
644     /* only pass through */
645     flags |= AVIIF_KEYFRAME;
646
647     return IAVIStream_Write(This->pStream, start, samples, buffer, buffersize,
648                             flags, sampwritten, byteswritten);
649   } else {
650     /* compress data before writing to pStream */
651     if (samples != 1 && (sampwritten == NULL && byteswritten == NULL))
652       return AVIERR_UNSUPPORTED;
653
654     This->lCurrent = start;
655     hr = AVIFILE_EncodeFrame(This, This->lpbiInput, buffer);
656     if (FAILED(hr))
657       return hr;
658
659     if (This->lLastKey == start)
660       flags |= AVIIF_KEYFRAME;
661
662     return IAVIStream_Write(This->pStream, start, samples, This->lpCur,
663                             This->lpbiCur->biSizeImage, flags, byteswritten,
664                             sampwritten);
665   }
666 }
667
668 static HRESULT WINAPI ICMStream_fnDelete(IAVIStream *iface, LONG start,
669                                           LONG samples)
670 {
671   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
672
673   TRACE("(%p,%d,%d)\n", iface, start, samples);
674
675   return IAVIStream_Delete(This->pStream, start, samples);
676 }
677
678 static HRESULT WINAPI ICMStream_fnReadData(IAVIStream *iface, DWORD fcc,
679                                             LPVOID lp, LPLONG lpread)
680 {
681   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
682
683   TRACE("(%p,0x%08X,%p,%p)\n", iface, fcc, lp, lpread);
684
685   assert(This->pStream != NULL);
686
687   return IAVIStream_ReadData(This->pStream, fcc, lp, lpread);
688 }
689
690 static HRESULT WINAPI ICMStream_fnWriteData(IAVIStream *iface, DWORD fcc,
691                                              LPVOID lp, LONG size)
692 {
693   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
694
695   TRACE("(%p,0x%08x,%p,%d)\n", iface, fcc, lp, size);
696
697   assert(This->pStream != NULL);
698
699   return IAVIStream_WriteData(This->pStream, fcc, lp, size);
700 }
701
702 static HRESULT WINAPI ICMStream_fnSetInfo(IAVIStream *iface,
703                                            LPAVISTREAMINFOW info, LONG infolen)
704 {
705   FIXME("(%p,%p,%d): stub\n", iface, info, infolen);
706
707   return E_FAIL;
708 }
709
710 static const struct IAVIStreamVtbl iicmst = {
711   ICMStream_fnQueryInterface,
712   ICMStream_fnAddRef,
713   ICMStream_fnRelease,
714   ICMStream_fnCreate,
715   ICMStream_fnInfo,
716   ICMStream_fnFindSample,
717   ICMStream_fnReadFormat,
718   ICMStream_fnSetFormat,
719   ICMStream_fnRead,
720   ICMStream_fnWrite,
721   ICMStream_fnDelete,
722   ICMStream_fnReadData,
723   ICMStream_fnWriteData,
724   ICMStream_fnSetInfo
725 };
726
727 HRESULT AVIFILE_CreateICMStream(REFIID riid, LPVOID *ppv)
728 {
729   IAVIStreamImpl *pstream;
730   HRESULT         hr;
731
732   assert(riid != NULL && ppv != NULL);
733
734   *ppv = NULL;
735
736   pstream = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAVIStreamImpl));
737   if (pstream == NULL)
738     return AVIERR_MEMORY;
739
740   pstream->IAVIStream_iface.lpVtbl = &iicmst;
741   AVIFILE_Reset(pstream);
742
743   hr = IAVIStream_QueryInterface(&pstream->IAVIStream_iface, riid, ppv);
744   if (FAILED(hr))
745     HeapFree(GetProcessHeap(), 0, pstream);
746
747   return hr;
748 }
749
750 /***********************************************************************/
751
752 static HRESULT AVIFILE_EncodeFrame(IAVIStreamImpl *This,
753                                    LPBITMAPINFOHEADER lpbi, LPVOID lpBits)
754 {
755   DWORD dwMinQual, dwMaxQual, dwCurQual;
756   DWORD dwRequest;
757   DWORD icmFlags = 0;
758   DWORD idxFlags = 0;
759   BOOL  bDecreasedQual = FALSE;
760   BOOL  doSizeCheck;
761   BOOL  noPrev;
762
763   /* make lKeyFrameEvery and at start a keyframe */
764   if ((This->lKeyFrameEvery != 0 &&
765        (This->lCurrent - This->lLastKey) >= This->lKeyFrameEvery) ||
766       This->lCurrent == This->sInfo.dwStart) {
767     idxFlags = AVIIF_KEYFRAME;
768     icmFlags = ICCOMPRESS_KEYFRAME;
769   }
770
771   if (This->lKeyFrameEvery != 0) {
772     if (This->lCurrent == This->sInfo.dwStart) {
773       if (idxFlags & AVIIF_KEYFRAME) {
774         /* for keyframes allow to consume all unused bytes */
775         dwRequest = This->dwBytesPerFrame + This->dwUnusedBytes;
776         This->dwUnusedBytes = 0;
777       } else {
778         /* for non-keyframes only allow something of the unused bytes to be consumed */
779         DWORD tmp1 = 0;
780         DWORD tmp2;
781
782         if (This->dwBytesPerFrame >= This->dwUnusedBytes)
783           tmp1 = This->dwBytesPerFrame / This->lKeyFrameEvery;
784         tmp2 = (This->dwUnusedBytes + tmp1) / This->lKeyFrameEvery;
785
786         dwRequest = This->dwBytesPerFrame - tmp1 + tmp2;
787         This->dwUnusedBytes -= tmp2;
788       }
789     } else
790       dwRequest = MAX_FRAMESIZE;
791   } else {
792     /* only one keyframe at start desired */
793     if (This->lCurrent == This->sInfo.dwStart) {
794       dwRequest = This->dwBytesPerFrame + This->dwUnusedBytes;
795       This->dwUnusedBytes = 0;
796     } else
797       dwRequest = MAX_FRAMESIZE;
798   }
799
800   /* must we check for framesize to gain requested
801    * datarate or could we trust codec? */
802   doSizeCheck = (dwRequest != 0 && ((This->dwICMFlags & (VIDCF_CRUNCH|VIDCF_QUALITY)) == 0));
803
804   dwMaxQual = dwCurQual = This->sInfo.dwQuality;
805   dwMinQual = ICQUALITY_LOW;
806
807   noPrev = TRUE;
808   if ((icmFlags & ICCOMPRESS_KEYFRAME) == 0 && 
809       (This->dwICMFlags & VIDCF_FASTTEMPORALC) == 0)
810     noPrev = FALSE;
811
812   do {
813     DWORD   idxCkid = 0;
814     DWORD   res;
815
816     res = ICCompress(This->hic,icmFlags,This->lpbiCur,This->lpCur,lpbi,lpBits,
817                      &idxCkid, &idxFlags, This->lCurrent, dwRequest, dwCurQual,
818                      noPrev ? NULL:This->lpbiPrev, noPrev ? NULL:This->lpPrev);
819     if (res == ICERR_NEWPALETTE) {
820       FIXME(": codec has changed palette -- unhandled!\n");
821     } else if (res != ICERR_OK)
822       return AVIERR_COMPRESSOR;
823
824     /* need to check for framesize */
825     if (! doSizeCheck)
826       break;
827
828     if (dwRequest >= This->lpbiCur->biSizeImage) {
829       /* frame is smaller -- try to maximize quality */
830       if (dwMaxQual - dwCurQual > 10) {
831         DWORD tmp = dwRequest / 8;
832
833         if (tmp < MAX_FRAMESIZE_DIFF)
834           tmp = MAX_FRAMESIZE_DIFF;
835
836         if (tmp < dwRequest - This->lpbiCur->biSizeImage && bDecreasedQual) {
837           tmp = dwCurQual;
838           dwCurQual = (dwMinQual + dwMaxQual) / 2;
839           dwMinQual = tmp;
840           continue;
841         }
842       } else
843         break;
844     } else if (dwMaxQual - dwMinQual <= 1) {
845       break;
846     } else {
847       dwMaxQual = dwCurQual;
848
849       if (bDecreasedQual || dwCurQual == This->dwLastQuality)
850         dwCurQual = (dwMinQual + dwMaxQual) / 2;
851       else
852         FIXME(": no new quality computed min=%u cur=%u max=%u last=%u\n",
853               dwMinQual, dwCurQual, dwMaxQual, This->dwLastQuality);
854
855       bDecreasedQual = TRUE;
856     }
857   } while (TRUE);
858
859   /* remember some values */
860   This->dwLastQuality = dwCurQual;
861   This->dwUnusedBytes = dwRequest - This->lpbiCur->biSizeImage;
862   if (icmFlags & ICCOMPRESS_KEYFRAME)
863     This->lLastKey = This->lCurrent;
864
865   /* Does we manage previous frame? */
866   if (This->lpPrev != NULL && This->lKeyFrameEvery != 1)
867     ICDecompress(This->hic, 0, This->lpbiCur, This->lpCur,
868                  This->lpbiPrev, This->lpPrev);
869
870   return AVIERR_OK;
871 }
872
873 static HRESULT AVIFILE_OpenGetFrame(IAVIStreamImpl *This)
874 {
875   LPBITMAPINFOHEADER lpbi;
876   DWORD              size;
877
878   /* pre-conditions */
879   assert(This != NULL);
880   assert(This->pStream != NULL);
881   assert(This->pg == NULL);
882
883   This->pg = AVIStreamGetFrameOpen(This->pStream, NULL);
884   if (This->pg == NULL)
885     return AVIERR_ERROR;
886
887   /* When we only decompress this is enough */
888   if (This->sInfo.fccHandler == comptypeDIB)
889     return AVIERR_OK;
890
891   assert(This->hic != NULL);
892   assert(This->lpbiOutput == NULL);
893
894   /* get input format */
895   lpbi = AVIStreamGetFrame(This->pg, This->sInfo.dwStart);
896   if (lpbi == NULL)
897     return AVIERR_MEMORY;
898
899   /* get memory for output format */
900   size = ICCompressGetFormatSize(This->hic, lpbi);
901   if ((LONG)size < (LONG)sizeof(BITMAPINFOHEADER))
902     return AVIERR_COMPRESSOR;
903   This->lpbiOutput = HeapAlloc(GetProcessHeap(), 0, size);
904   if (This->lpbiOutput == NULL)
905     return AVIERR_MEMORY;
906   This->cbOutput = size;
907
908   if (ICCompressGetFormat(This->hic, lpbi, This->lpbiOutput) < S_OK)
909     return AVIERR_BADFORMAT;
910
911   /* update AVISTREAMINFO structure */
912   This->sInfo.rcFrame.right  =
913     This->sInfo.rcFrame.left + This->lpbiOutput->biWidth;
914   This->sInfo.rcFrame.bottom =
915     This->sInfo.rcFrame.top  + This->lpbiOutput->biHeight;
916   This->sInfo.dwSuggestedBufferSize =
917     ICCompressGetSize(This->hic, lpbi, This->lpbiOutput);
918
919   /* prepare codec for compression */
920   if (ICCompressBegin(This->hic, lpbi, This->lpbiOutput) != S_OK)
921     return AVIERR_COMPRESSOR;
922
923   /* allocate memory for current frame */
924   size += This->sInfo.dwSuggestedBufferSize;
925   This->lpbiCur = HeapAlloc(GetProcessHeap(), 0, size);
926   if (This->lpbiCur == NULL)
927     return AVIERR_MEMORY;
928   memcpy(This->lpbiCur, This->lpbiOutput, This->cbOutput);
929   This->lpCur = DIBPTR(This->lpbiCur);
930
931   /* allocate memory for last frame if needed */
932   if (This->lKeyFrameEvery != 1 &&
933       (This->dwICMFlags & VIDCF_FASTTEMPORALC) == 0) {
934     size = ICDecompressGetFormatSize(This->hic, This->lpbiOutput);
935     This->lpbiPrev = HeapAlloc(GetProcessHeap(), 0, size);
936     if (This->lpbiPrev == NULL)
937       return AVIERR_MEMORY;
938     if (ICDecompressGetFormat(This->hic, This->lpbiOutput, This->lpbiPrev) < S_OK)
939       return AVIERR_COMPRESSOR;
940
941     if (This->lpbiPrev->biSizeImage == 0) {
942       This->lpbiPrev->biSizeImage =
943         DIBWIDTHBYTES(*This->lpbiPrev) * This->lpbiPrev->biHeight;
944     }
945
946     /* get memory for format and picture */
947     size += This->lpbiPrev->biSizeImage;
948     This->lpbiPrev = HeapReAlloc(GetProcessHeap(), 0, This->lpbiPrev, size );
949     if (This->lpbiPrev == NULL)
950       return AVIERR_MEMORY;
951     This->lpPrev = DIBPTR(This->lpbiPrev);
952
953     /* prepare codec also for decompression */
954     if (ICDecompressBegin(This->hic,This->lpbiOutput,This->lpbiPrev) != S_OK)
955       return AVIERR_COMPRESSOR;
956   }
957
958   return AVIERR_OK;
959 }