Don't include windows.h & co in the Wine sources.
[wine] / dlls / avifil32 / getframe.c
1 /*
2  * Copyright 2002-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., 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 "winnls.h"
25 #include "wingdi.h"
26 #include "winuser.h"
27 #include "vfw.h"
28
29 #include "avifile_private.h"
30
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(avifile);
34
35 #ifndef DIBPTR
36 #define DIBPTR(lp)      ((LPBYTE)(lp) + (lp)->biSize + \
37                          (lp)->biClrUsed * sizeof(RGBQUAD))
38 #endif
39
40 /***********************************************************************/
41
42 static HRESULT WINAPI IGetFrame_fnQueryInterface(IGetFrame *iface,
43                                                  REFIID refiid, LPVOID *obj);
44 static ULONG   WINAPI IGetFrame_fnAddRef(IGetFrame *iface);
45 static ULONG   WINAPI IGetFrame_fnRelease(IGetFrame *iface);
46 static LPVOID  WINAPI IGetFrame_fnGetFrame(IGetFrame *iface, LONG lPos);
47 static HRESULT WINAPI IGetFrame_fnBegin(IGetFrame *iface, LONG lStart,
48                                         LONG lEnd, LONG lRate);
49 static HRESULT WINAPI IGetFrame_fnEnd(IGetFrame *iface);
50 static HRESULT WINAPI IGetFrame_fnSetFormat(IGetFrame *iface,
51                                             LPBITMAPINFOHEADER lpbi,
52                                             LPVOID lpBits, INT x, INT y,
53                                             INT dx, INT dy);
54
55 static const struct IGetFrameVtbl igetframeVtbl = {
56   IGetFrame_fnQueryInterface,
57   IGetFrame_fnAddRef,
58   IGetFrame_fnRelease,
59   IGetFrame_fnGetFrame,
60   IGetFrame_fnBegin,
61   IGetFrame_fnEnd,
62   IGetFrame_fnSetFormat
63 };
64
65 typedef struct _IGetFrameImpl {
66   /* IUnknown stuff */
67   const IGetFrameVtbl *lpVtbl;
68   LONG               ref;
69
70   /* IGetFrame stuff */
71   BOOL               bFixedStream;
72   PAVISTREAM         pStream;
73
74   LPVOID             lpInBuffer;
75   LONG               cbInBuffer;
76   LPBITMAPINFOHEADER lpInFormat;
77   LONG               cbInFormat;
78
79   LONG               lCurrentFrame;
80   LPBITMAPINFOHEADER lpOutFormat;
81   LPVOID             lpOutBuffer;
82
83   HIC                hic;
84   BOOL               bResize;
85   DWORD              x;
86   DWORD              y;
87   DWORD              dx;
88   DWORD              dy;
89
90   BOOL               bFormatChanges;
91   DWORD              dwFormatChangeCount;
92   DWORD              dwEditCount;
93 } IGetFrameImpl;
94
95 /***********************************************************************/
96
97 static void AVIFILE_CloseCompressor(IGetFrameImpl *This)
98 {
99   if (This->lpInFormat != This->lpOutFormat) {
100     HeapFree(GetProcessHeap(), 0, This->lpOutFormat);
101     This->lpOutFormat = NULL;
102   }
103   HeapFree(GetProcessHeap(), 0, This->lpInFormat);
104   This->lpInFormat = NULL;
105   if (This->hic != NULL) {
106     if (This->bResize)
107       ICDecompressExEnd(This->hic);
108     else
109       ICDecompressEnd(This->hic);
110     ICClose(This->hic);
111     This->hic = NULL;
112   }
113 }
114
115 PGETFRAME AVIFILE_CreateGetFrame(PAVISTREAM pStream)
116 {
117   IGetFrameImpl *pg;
118
119   /* check parameter */
120   if (pStream == NULL)
121     return NULL;
122
123   pg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IGetFrameImpl));
124   if (pg != NULL) {
125     pg->lpVtbl        = &igetframeVtbl;
126     pg->ref           = 1;
127     pg->lCurrentFrame = -1;
128     pg->pStream       = pStream;
129     IAVIStream_AddRef(pStream);
130   }
131
132   return (PGETFRAME)pg;
133 }
134
135 static HRESULT WINAPI IGetFrame_fnQueryInterface(IGetFrame *iface,
136                                                  REFIID refiid, LPVOID *obj)
137 {
138   IGetFrameImpl *This = (IGetFrameImpl *)iface;
139
140   TRACE("(%p,%s,%p)\n", This, debugstr_guid(refiid), obj);
141
142   if (IsEqualGUID(&IID_IUnknown, refiid) ||
143       IsEqualGUID(&IID_IGetFrame, refiid)) {
144     *obj = iface;
145     return S_OK;
146   }
147
148   return OLE_E_ENUM_NOMORE;
149 }
150
151 static ULONG   WINAPI IGetFrame_fnAddRef(IGetFrame *iface)
152 {
153   IGetFrameImpl *This = (IGetFrameImpl *)iface;
154   ULONG ref = InterlockedIncrement(&This->ref);
155
156   TRACE("(%p)\n", iface);
157
158   return ref;
159 }
160
161 static ULONG   WINAPI IGetFrame_fnRelease(IGetFrame *iface)
162 {
163   IGetFrameImpl *This = (IGetFrameImpl *)iface;
164   ULONG ref = InterlockedDecrement(&This->ref);
165
166   TRACE("(%p)\n", iface);
167
168   if (!ref) {
169     AVIFILE_CloseCompressor(This);
170     if (This->pStream != NULL) {
171       IAVIStream_Release(This->pStream);
172       This->pStream = NULL;
173     }
174
175     HeapFree(GetProcessHeap(), 0, iface);
176     return 0;
177   }
178
179   return ref;
180 }
181
182 static LPVOID  WINAPI IGetFrame_fnGetFrame(IGetFrame *iface, LONG lPos)
183 {
184   IGetFrameImpl *This = (IGetFrameImpl *)iface;
185
186   LONG readBytes;
187   LONG readSamples;
188
189   TRACE("(%p,%d)\n", iface, lPos);
190
191   /* We don't want negative start values! -- marks invalid buffer content */
192   if (lPos < 0)
193     return NULL;
194
195   /* check state */
196   if (This->pStream == NULL)
197     return NULL;
198   if (This->lpInFormat == NULL)
199     return NULL;
200
201   /* Could stream have changed? */
202   if (! This->bFixedStream) {
203     AVISTREAMINFOW sInfo;
204
205     IAVIStream_Info(This->pStream, &sInfo, sizeof(sInfo));
206
207     if (sInfo.dwEditCount != This->dwEditCount) {
208       This->dwEditCount   = sInfo.dwEditCount;
209       This->lCurrentFrame = -1;
210     }
211
212     if (sInfo.dwFormatChangeCount != This->dwFormatChangeCount) {
213       /* stream has changed */
214       if (This->lpOutFormat != NULL) {
215         BITMAPINFOHEADER bi;
216
217         memcpy(&bi, This->lpOutFormat, sizeof(bi));
218         AVIFILE_CloseCompressor(This);
219
220         if (FAILED(IGetFrame_SetFormat(iface, &bi, NULL, 0, 0, -1, -1))) {
221           if (FAILED(IGetFrame_SetFormat(iface, NULL, NULL, 0, 0, -1, -1)))
222             return NULL;
223         }
224       } else if (FAILED(IGetFrame_SetFormat(iface, NULL, NULL, 0, 0, -1, -1)))
225         return NULL;
226     }
227   }
228
229   if (lPos != This->lCurrentFrame) {
230     LONG lNext = IAVIStream_FindSample(This->pStream,lPos,FIND_KEY|FIND_PREV);
231
232     if (lNext == -1)
233       return NULL; /* frame doesn't exist */
234     if (lNext <= This->lCurrentFrame && This->lCurrentFrame < lPos)
235       lNext = This->lCurrentFrame + 1;
236
237     for (; lNext <= lPos; lNext++) {
238       /* new format for this frame? */
239       if (This->bFormatChanges) {
240         IAVIStream_ReadFormat(This->pStream, lNext,
241                               This->lpInFormat, &This->cbInFormat);
242         if (This->lpOutFormat != NULL) {
243           if (This->lpOutFormat->biBitCount <= 8)
244             ICDecompressGetPalette(This->hic, This->lpInFormat,
245                                    This->lpOutFormat);
246         }
247       }
248
249       /* read input frame */
250       while (FAILED(AVIStreamRead(This->pStream, lNext, 1, This->lpInBuffer,
251                                   This->cbInBuffer, &readBytes, &readSamples))) {
252         /* not enough memory for input buffer? */
253         readBytes = 0;
254         if (FAILED(AVIStreamSampleSize(This->pStream, lNext, &readBytes)))
255           return NULL; /* bad thing, but bad things will happen */
256         if (readBytes <= 0) {
257           ERR(": IAVIStream::REad doesn't return needed bytes!\n");
258           return NULL;
259         }
260
261         /* IAVIStream::Read failed because of other reasons not buffersize? */
262         if (This->cbInBuffer >= readBytes)
263           break;
264         This->cbInBuffer = This->cbInFormat + readBytes;
265         This->lpInFormat = HeapReAlloc(GetProcessHeap(), 0, This->lpInFormat, This->cbInBuffer);
266         if (This->lpInFormat == NULL)
267           return NULL; /* out of memory */
268         This->lpInBuffer = (BYTE*)This->lpInFormat + This->cbInFormat;
269       }
270
271       if (readSamples != 1) {
272         ERR(": no frames read\n");
273         return NULL;
274       }
275       if (readBytes != 0) {
276         This->lpInFormat->biSizeImage = readBytes;
277
278         /* nothing to decompress? */
279         if (This->hic == NULL) {
280           This->lCurrentFrame = lPos;
281           return This->lpInFormat;
282         }
283
284         if (This->bResize) {
285           ICDecompressEx(This->hic,0,This->lpInFormat,This->lpInBuffer,0,0,
286                          This->lpInFormat->biWidth,This->lpInFormat->biHeight,
287                          This->lpOutFormat,This->lpOutBuffer,This->x,This->y,
288                          This->dx,This->dy);
289         } else {
290           ICDecompress(This->hic, 0, This->lpInFormat, This->lpInBuffer,
291                        This->lpOutFormat, This->lpOutBuffer);
292         }
293       }
294     } /* for (lNext < lPos) */
295   } /* if (This->lCurrentFrame != lPos) */
296
297   return (This->hic == NULL ? This->lpInFormat : This->lpOutFormat);
298 }
299
300 static HRESULT WINAPI IGetFrame_fnBegin(IGetFrame *iface, LONG lStart,
301                                         LONG lEnd, LONG lRate)
302 {
303   IGetFrameImpl *This = (IGetFrameImpl *)iface;
304
305   TRACE("(%p,%d,%d,%d)\n", iface, lStart, lEnd, lRate);
306
307   This->bFixedStream = TRUE;
308
309   return (IGetFrame_GetFrame(iface, lStart) ? AVIERR_OK : AVIERR_ERROR);
310 }
311
312 static HRESULT WINAPI IGetFrame_fnEnd(IGetFrame *iface)
313 {
314   IGetFrameImpl *This = (IGetFrameImpl *)iface;
315
316   TRACE("(%p)\n", iface);
317
318   This->bFixedStream = FALSE;
319
320   return AVIERR_OK;
321 }
322
323 static HRESULT WINAPI IGetFrame_fnSetFormat(IGetFrame *iface,
324                                             LPBITMAPINFOHEADER lpbiWanted,
325                                             LPVOID lpBits, INT x, INT y,
326                                             INT dx, INT dy)
327 {
328   IGetFrameImpl *This = (IGetFrameImpl *)iface;
329
330   AVISTREAMINFOW     sInfo;
331   LPBITMAPINFOHEADER lpbi         = lpbiWanted;
332   BOOL               bBestDisplay = FALSE;
333
334   TRACE("(%p,%p,%p,%d,%d,%d,%d)\n", iface, lpbiWanted, lpBits,
335         x, y, dx, dy);
336
337   if (This->pStream == NULL)
338     return AVIERR_ERROR;
339
340   if (lpbiWanted == (LPBITMAPINFOHEADER)AVIGETFRAMEF_BESTDISPLAYFMT) {
341     lpbi = NULL;
342     bBestDisplay = TRUE;
343   }
344
345   IAVIStream_Info(This->pStream, &sInfo, sizeof(sInfo));
346   if (sInfo.fccType != streamtypeVIDEO)
347     return AVIERR_UNSUPPORTED;
348
349   This->bFormatChanges =
350     (sInfo.dwFlags & AVISTREAMINFO_FORMATCHANGES ? TRUE : FALSE );
351   This->dwFormatChangeCount = sInfo.dwFormatChangeCount;
352   This->dwEditCount         = sInfo.dwEditCount;
353   This->lCurrentFrame       = -1;
354
355   /* get input format from stream */
356   if (This->lpInFormat == NULL) {
357     HRESULT hr;
358
359     This->cbInBuffer = (LONG)sInfo.dwSuggestedBufferSize;
360     if (This->cbInBuffer == 0)
361       This->cbInBuffer = 1024;
362
363     IAVIStream_ReadFormat(This->pStream, sInfo.dwStart,
364                           NULL, &This->cbInFormat);
365
366     This->lpInFormat = HeapAlloc(GetProcessHeap(), 0, This->cbInFormat + This->cbInBuffer);
367     if (This->lpInFormat == NULL) {
368       AVIFILE_CloseCompressor(This);
369       return AVIERR_MEMORY;
370     }
371
372     hr = IAVIStream_ReadFormat(This->pStream, sInfo.dwStart, This->lpInFormat, &This->cbInFormat);
373     if (FAILED(hr)) {
374       AVIFILE_CloseCompressor(This);
375       return hr;
376     }
377
378     This->lpInBuffer = ((LPBYTE)This->lpInFormat) + This->cbInFormat;
379   }
380
381   /* check input format */
382   if (This->lpInFormat->biClrUsed == 0 && This->lpInFormat->biBitCount <= 8)
383     This->lpInFormat->biClrUsed = 1u << This->lpInFormat->biBitCount;
384   if (This->lpInFormat->biSizeImage == 0 &&
385       This->lpInFormat->biCompression == BI_RGB) {
386     This->lpInFormat->biSizeImage =
387       DIBWIDTHBYTES(*This->lpInFormat) * This->lpInFormat->biHeight;
388   }
389
390   /* only to pass through? */
391   if (This->lpInFormat->biCompression == BI_RGB && lpBits == NULL) {
392     if (lpbi == NULL || 
393         (lpbi->biCompression == BI_RGB &&
394          lpbi->biWidth == This->lpInFormat->biWidth &&
395          lpbi->biHeight == This->lpInFormat->biHeight &&
396          lpbi->biBitCount == This->lpInFormat->biBitCount)) {
397       This->lpOutFormat = This->lpInFormat;
398       This->lpOutBuffer = DIBPTR(This->lpInFormat);
399       return AVIERR_OK;
400     }
401   }
402
403   /* need memory for output format? */
404   if (This->lpOutFormat == NULL) {
405     This->lpOutFormat =
406       HeapAlloc(GetProcessHeap(), 0, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
407     if (This->lpOutFormat == NULL) {
408       AVIFILE_CloseCompressor(This);
409       return AVIERR_MEMORY;
410     }
411   }
412
413   /* need handle to video compressor */
414   if (This->hic == NULL) {
415     FOURCC fccHandler;
416
417     if (This->lpInFormat->biCompression == BI_RGB)
418       fccHandler = comptypeDIB;
419     else if (This->lpInFormat->biCompression == BI_RLE8)
420       fccHandler = mmioFOURCC('R','L','E',' ');
421     else
422       fccHandler = sInfo.fccHandler;
423
424     if (lpbi != NULL) {
425       if (lpbi->biWidth == 0)
426         lpbi->biWidth = This->lpInFormat->biWidth;
427       if (lpbi->biHeight == 0)
428         lpbi->biHeight = This->lpInFormat->biHeight;
429     }
430
431     This->hic = ICLocate(ICTYPE_VIDEO, fccHandler, This->lpInFormat, lpbi, ICMODE_DECOMPRESS);
432     if (This->hic == NULL) {
433       AVIFILE_CloseCompressor(This);
434       return AVIERR_NOCOMPRESSOR;
435     }
436   }
437
438   /* output format given? */
439   if (lpbi != NULL) {
440     /* check the given output format ... */
441     if (lpbi->biClrUsed == 0 && lpbi->biBitCount <= 8)
442       lpbi->biClrUsed = 1u << lpbi->biBitCount;
443
444     /* ... and remember it */
445     memcpy(This->lpOutFormat, lpbi,
446            lpbi->biSize + lpbi->biClrUsed * sizeof(RGBQUAD));
447     if (lpbi->biBitCount <= 8)
448       ICDecompressGetPalette(This->hic, This->lpInFormat, This->lpOutFormat);
449
450     return AVIERR_OK;
451   } else {
452     if (bBestDisplay) {
453       ICGetDisplayFormat(This->hic, This->lpInFormat,
454                          This->lpOutFormat, 0, dx, dy);
455     } else if (ICDecompressGetFormat(This->hic, This->lpInFormat,
456                                      This->lpOutFormat) < 0) {
457       AVIFILE_CloseCompressor(This);
458       return AVIERR_NOCOMPRESSOR;
459     }
460
461     /* check output format */
462     if (This->lpOutFormat->biClrUsed == 0 &&
463         This->lpOutFormat->biBitCount <= 8)
464       This->lpOutFormat->biClrUsed = 1u << This->lpOutFormat->biBitCount;
465     if (This->lpOutFormat->biSizeImage == 0 &&
466         This->lpOutFormat->biCompression == BI_RGB) {
467       This->lpOutFormat->biSizeImage =
468         DIBWIDTHBYTES(*This->lpOutFormat) * This->lpOutFormat->biHeight;
469     }
470
471     if (lpBits == NULL) {
472       register DWORD size = This->lpOutFormat->biClrUsed * sizeof(RGBQUAD);
473
474       size += This->lpOutFormat->biSize + This->lpOutFormat->biSizeImage;
475       This->lpOutFormat = HeapReAlloc(GetProcessHeap(), 0, This->lpOutFormat, size);
476       if (This->lpOutFormat == NULL) {
477         AVIFILE_CloseCompressor(This);
478         return AVIERR_MEMORY;
479       }
480       This->lpOutBuffer = DIBPTR(This->lpOutFormat);
481     } else
482       This->lpOutBuffer = lpBits;
483
484     /* for user size was irrelevant */
485     if (dx == -1)
486       dx = This->lpOutFormat->biWidth;
487     if (dy == -1)
488       dy = This->lpOutFormat->biHeight;
489
490     /* need to resize? */
491     if (x != 0 || y != 0) {
492       if (dy == This->lpOutFormat->biHeight &&
493           dx == This->lpOutFormat->biWidth)
494         This->bResize = FALSE;
495       else
496         This->bResize = TRUE;
497     }
498
499     if (This->bResize) {
500       This->x  = x;
501       This->y  = y;
502       This->dx = dx;
503       This->dy = dy;
504
505       if (ICDecompressExBegin(This->hic,0,This->lpInFormat,This->lpInBuffer,0,
506                               0,This->lpInFormat->biWidth,
507                               This->lpInFormat->biHeight,This->lpOutFormat,
508                               This->lpOutBuffer, x, y, dx, dy) == ICERR_OK)
509         return AVIERR_OK;
510     } else if (ICDecompressBegin(This->hic, This->lpInFormat,
511                                  This->lpOutFormat) == ICERR_OK)
512       return AVIERR_OK;
513
514     AVIFILE_CloseCompressor(This);
515
516     return AVIERR_COMPRESSOR;
517   }
518 }
519
520 /***********************************************************************/