ReactOS 0.4.15-dev-7931-gfd331f1
msvideo1.c
Go to the documentation of this file.
1/*
2 * Microsoft Video-1 Decoder
3 * Copyright (C) 2003 the ffmpeg project
4 *
5 * Portions Copyright (C) 2004 Mike McCormack for 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 */
22
34#include <stdarg.h>
35#include "windef.h"
36#include "winbase.h"
37#include "wingdi.h"
38#include "winuser.h"
39#include "commdlg.h"
40#include "vfw.h"
41#include "mmsystem.h"
42#include "msvidc32_private.h"
43
44#include "wine/debug.h"
45
47
49
50#define CRAM_MAGIC mmioFOURCC('C', 'R', 'A', 'M')
51#define MSVC_MAGIC mmioFOURCC('M', 'S', 'V', 'C')
52#define WHAM_MAGIC mmioFOURCC('W', 'H', 'A', 'M')
53#define compare_fourcc(fcc1, fcc2) (((fcc1)^(fcc2))&~0x20202020)
54
55#define PALETTE_COUNT 256
56#define LE_16(x) ((((const uint8_t *)(x))[1] << 8) | ((const uint8_t *)(x))[0])
57
58/* FIXME - check the stream size */
59#define CHECK_STREAM_PTR(n) \
60 if ((stream_ptr + n) > buf_size ) { \
61 WARN("stream_ptr out of bounds (%d >= %d)\n", \
62 stream_ptr + n, buf_size); \
63 return; \
64 }
65
66typedef BYTE uint8_t;
67
68typedef struct Msvideo1Context {
70 int depth;
72
73static inline int get_stride(int width, int depth)
74{
75 return ((depth * width + 31) >> 3) & ~3;
76}
77
78static void
79msvideo1_decode_8bit( int width, int height, const unsigned char *buf, int buf_size,
80 unsigned char *pixels, int stride)
81{
82 int block_ptr, pixel_ptr;
83 int total_blocks;
84 int pixel_x, pixel_y; /* pixel width and height iterators */
85 int block_x, block_y; /* block width and height iterators */
86 int blocks_wide, blocks_high; /* width and height in 4x4 blocks */
87 int block_inc;
88 int row_dec;
89
90 /* decoding parameters */
91 int stream_ptr;
92 unsigned char byte_a, byte_b;
93 unsigned short flags;
94 int skip_blocks;
95 unsigned char colors[8];
96
97 stream_ptr = 0;
98 skip_blocks = 0;
99 blocks_wide = width / 4;
100 blocks_high = height / 4;
101 total_blocks = blocks_wide * blocks_high;
102 block_inc = 4;
103#ifdef ORIGINAL
104 row_dec = stride + 4;
105#else
106 row_dec = - (stride - 4); /* such that -row_dec > 0 */
107#endif
108
109 for (block_y = blocks_high; block_y > 0; block_y--) {
110#ifdef ORIGINAL
111 block_ptr = ((block_y * 4) - 1) * stride;
112#else
113 block_ptr = ((blocks_high - block_y) * 4) * stride;
114#endif
115 for (block_x = blocks_wide; block_x > 0; block_x--) {
116 /* check if this block should be skipped */
117 if (skip_blocks) {
118 block_ptr += block_inc;
119 skip_blocks--;
120 total_blocks--;
121 continue;
122 }
123
124 pixel_ptr = block_ptr;
125
126 /* get the next two bytes in the encoded data stream */
128 byte_a = buf[stream_ptr++];
129 byte_b = buf[stream_ptr++];
130
131 /* check if the decode is finished */
132 if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0))
133 return;
134 else if ((byte_b & 0xFC) == 0x84) {
135 /* skip code, but don't count the current block */
136 skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1;
137 } else if (byte_b < 0x80) {
138 /* 2-color encoding */
139 flags = (byte_b << 8) | byte_a;
140
142 colors[0] = buf[stream_ptr++];
143 colors[1] = buf[stream_ptr++];
144
145 for (pixel_y = 0; pixel_y < 4; pixel_y++) {
146 for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
147 pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1];
148 pixel_ptr -= row_dec;
149 }
150 } else if (byte_b >= 0x90) {
151 /* 8-color encoding */
152 flags = (byte_b << 8) | byte_a;
153
155 memcpy(colors, &buf[stream_ptr], 8);
156 stream_ptr += 8;
157
158 for (pixel_y = 0; pixel_y < 4; pixel_y++) {
159 for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
160 pixels[pixel_ptr++] =
161 colors[((pixel_y & 0x2) << 1) +
162 (pixel_x & 0x2) + ((flags & 0x1) ^ 1)];
163 pixel_ptr -= row_dec;
164 }
165 } else {
166 /* 1-color encoding */
167 colors[0] = byte_a;
168
169 for (pixel_y = 0; pixel_y < 4; pixel_y++) {
170 for (pixel_x = 0; pixel_x < 4; pixel_x++)
171 pixels[pixel_ptr++] = colors[0];
172 pixel_ptr -= row_dec;
173 }
174 }
175
176 block_ptr += block_inc;
177 total_blocks--;
178 }
179 }
180}
181
182static void
183msvideo1_decode_16bit( int width, int height, const unsigned char *buf, int buf_size,
184 unsigned short *pixels, int stride)
185{
186 int block_ptr, pixel_ptr;
187 int total_blocks;
188 int pixel_x, pixel_y; /* pixel width and height iterators */
189 int block_x, block_y; /* block width and height iterators */
190 int blocks_wide, blocks_high; /* width and height in 4x4 blocks */
191 int block_inc;
192 int row_dec;
193
194 /* decoding parameters */
195 int stream_ptr;
196 unsigned char byte_a, byte_b;
197 unsigned short flags;
198 int skip_blocks;
199 unsigned short colors[8];
200
201 stream_ptr = 0;
202 skip_blocks = 0;
203 blocks_wide = width / 4;
204 blocks_high = height / 4;
205 total_blocks = blocks_wide * blocks_high;
206 block_inc = 4;
207#ifdef ORIGINAL
208 row_dec = stride + 4;
209#else
210 row_dec = - (stride - 4); /* such that -row_dec > 0 */
211#endif
212
213 for (block_y = blocks_high; block_y > 0; block_y--) {
214#ifdef ORIGINAL
215 block_ptr = ((block_y * 4) - 1) * stride;
216#else
217 block_ptr = ((blocks_high - block_y) * 4) * stride;
218#endif
219 for (block_x = blocks_wide; block_x > 0; block_x--) {
220 /* check if this block should be skipped */
221 if (skip_blocks) {
222 block_ptr += block_inc;
223 skip_blocks--;
224 total_blocks--;
225 continue;
226 }
227
228 pixel_ptr = block_ptr;
229
230 /* get the next two bytes in the encoded data stream */
232 byte_a = buf[stream_ptr++];
233 byte_b = buf[stream_ptr++];
234
235 /* check if the decode is finished */
236 if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0)) {
237 return;
238 } else if ((byte_b & 0xFC) == 0x84) {
239 /* skip code, but don't count the current block */
240 skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1;
241 } else if (byte_b < 0x80) {
242 /* 2- or 8-color encoding modes */
243 flags = (byte_b << 8) | byte_a;
244
246 colors[0] = LE_16(&buf[stream_ptr]);
247 stream_ptr += 2;
248 colors[1] = LE_16(&buf[stream_ptr]);
249 stream_ptr += 2;
250
251 if (colors[0] & 0x8000) {
252 /* 8-color encoding */
254 colors[2] = LE_16(&buf[stream_ptr]);
255 stream_ptr += 2;
256 colors[3] = LE_16(&buf[stream_ptr]);
257 stream_ptr += 2;
258 colors[4] = LE_16(&buf[stream_ptr]);
259 stream_ptr += 2;
260 colors[5] = LE_16(&buf[stream_ptr]);
261 stream_ptr += 2;
262 colors[6] = LE_16(&buf[stream_ptr]);
263 stream_ptr += 2;
264 colors[7] = LE_16(&buf[stream_ptr]);
265 stream_ptr += 2;
266
267 for (pixel_y = 0; pixel_y < 4; pixel_y++) {
268 for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
269 pixels[pixel_ptr++] =
270 colors[((pixel_y & 0x2) << 1) +
271 (pixel_x & 0x2) + ((flags & 0x1) ^ 1)];
272 pixel_ptr -= row_dec;
273 }
274 } else {
275 /* 2-color encoding */
276 for (pixel_y = 0; pixel_y < 4; pixel_y++) {
277 for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
278 pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1];
279 pixel_ptr -= row_dec;
280 }
281 }
282 } else {
283 /* otherwise, it's a 1-color block */
284 colors[0] = (byte_b << 8) | byte_a;
285
286 for (pixel_y = 0; pixel_y < 4; pixel_y++) {
287 for (pixel_x = 0; pixel_x < 4; pixel_x++)
288 pixels[pixel_ptr++] = colors[0];
289 pixel_ptr -= row_dec;
290 }
291 }
292
293 block_ptr += block_inc;
294 total_blocks--;
295 }
296 }
297}
298
299static LRESULT
301{
302 TRACE("ICM_DECOMPRESS_QUERY %p %p %p\n", info, in, out);
303
304 if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
305 return ICERR_BADPARAM;
306
307 TRACE("in->planes = %d\n", in->bmiHeader.biPlanes );
308 TRACE("in->bpp = %d\n", in->bmiHeader.biBitCount );
309 TRACE("in->height = %d\n", in->bmiHeader.biHeight );
310 TRACE("in->width = %d\n", in->bmiHeader.biWidth );
311 TRACE("in->compr = 0x%x\n", in->bmiHeader.biCompression );
312
313 if( ( in->bmiHeader.biCompression != CRAM_MAGIC ) &&
314 ( in->bmiHeader.biCompression != MSVC_MAGIC ) &&
315 ( in->bmiHeader.biCompression != WHAM_MAGIC ) )
316 {
317 TRACE("can't do 0x%x compression\n", in->bmiHeader.biCompression);
318 return ICERR_BADFORMAT;
319 }
320
321 if( ( in->bmiHeader.biBitCount != 16 ) &&
322 ( in->bmiHeader.biBitCount != 8 ) )
323 {
324 TRACE("can't do %d bpp\n", in->bmiHeader.biBitCount );
325 return ICERR_BADFORMAT;
326 }
327
328 /* output must be same dimensions as input */
329 if( out )
330 {
331 TRACE("out->planes = %d\n", out->bmiHeader.biPlanes );
332 TRACE("out->bpp = %d\n", out->bmiHeader.biBitCount );
333 TRACE("out->height = %d\n", out->bmiHeader.biHeight );
334 TRACE("out->width = %d\n", out->bmiHeader.biWidth );
335
336 if ((in->bmiHeader.biBitCount != out->bmiHeader.biBitCount) &&
337 (in->bmiHeader.biBitCount != 16 || out->bmiHeader.biBitCount != 24))
338 {
339 TRACE("incompatible depth requested\n");
340 return ICERR_BADFORMAT;
341 }
342
343 if(( in->bmiHeader.biPlanes != out->bmiHeader.biPlanes ) ||
344 ( in->bmiHeader.biHeight != out->bmiHeader.biHeight ) ||
345 ( in->bmiHeader.biWidth != out->bmiHeader.biWidth ))
346 {
347 TRACE("incompatible output requested\n");
348 return ICERR_BADFORMAT;
349 }
350 }
351
352 TRACE("OK!\n");
353 return ICERR_OK;
354}
355
356static LRESULT
358{
359 DWORD size;
360
361 TRACE("ICM_DECOMPRESS_GETFORMAT %p %p %p\n", info, in, out);
362
363 if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
364 return ICERR_BADPARAM;
365
366 size = in->bmiHeader.biSize;
367 if (in->bmiHeader.biBitCount <= 8)
368 size += in->bmiHeader.biClrUsed * sizeof(RGBQUAD);
369
370 if (in->bmiHeader.biBitCount != 8 && in->bmiHeader.biBitCount != 16)
371 return ICERR_BADFORMAT;
372
373 if( out )
374 {
375 memcpy( out, in, size );
376 out->bmiHeader.biWidth = in->bmiHeader.biWidth & ~1;
377 out->bmiHeader.biHeight = in->bmiHeader.biHeight & ~1;
378 out->bmiHeader.biCompression = BI_RGB;
379 out->bmiHeader.biSizeImage = in->bmiHeader.biHeight *
380 get_stride(out->bmiHeader.biWidth, out->bmiHeader.biBitCount);
381 return ICERR_OK;
382 }
383
384 return size;
385}
386
388{
389 TRACE("ICM_DECOMPRESS_BEGIN %p %p %p\n", info, in, out);
390
391 if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
392 return ICERR_BADPARAM;
393
394 TRACE("bitmap is %d bpp\n", in->bmiHeader.biBitCount);
395 if( in->bmiHeader.biBitCount == 8 )
396 info->depth = 8;
397 else if( in->bmiHeader.biBitCount == 16 )
398 info->depth = 16;
399 else
400 {
401 info->depth = 0;
402 FIXME("Unsupported output format %i\n", in->bmiHeader.biBitCount);
403 }
404
405 return ICERR_OK;
406}
407
408static void convert_depth(char *input, int depth_in, char *output, BITMAPINFOHEADER *out_hdr)
409{
410 int x, y;
411 int stride_in = get_stride(out_hdr->biWidth, depth_in);
412 int stride_out = get_stride(out_hdr->biWidth, out_hdr->biBitCount);
413
414 if (depth_in == 16 && out_hdr->biBitCount == 24)
415 {
416 static const unsigned char convert_5to8[] =
417 {
418 0x00, 0x08, 0x10, 0x19, 0x21, 0x29, 0x31, 0x3a,
419 0x42, 0x4a, 0x52, 0x5a, 0x63, 0x6b, 0x73, 0x7b,
420 0x84, 0x8c, 0x94, 0x9c, 0xa5, 0xad, 0xb5, 0xbd,
421 0xc5, 0xce, 0xd6, 0xde, 0xe6, 0xef, 0xf7, 0xff,
422 };
423
424 for (y = 0; y < out_hdr->biHeight; y++)
425 {
426 WORD *src_row = (WORD *)(input + y * stride_in);
427 char *out_row = output + y * stride_out;
428
429 for (x = 0; x < out_hdr->biWidth; x++)
430 {
431 WORD pixel = *src_row++;
432 *out_row++ = convert_5to8[(pixel & 0x7c00u) >> 10];
433 *out_row++ = convert_5to8[(pixel & 0x03e0u) >> 5];
434 *out_row++ = convert_5to8[(pixel & 0x001fu)];
435 }
436 }
437 }
438 else
439 FIXME("Conversion from %d to %d bit unimplemented\n", depth_in, out_hdr->biBitCount);
440}
441
443{
444 LONG width, height, stride, sz;
445 void *output;
446
447 TRACE("ICM_DECOMPRESS %p %p %d\n", info, icd, size);
448
449 if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
450 return ICERR_BADPARAM;
451
452 /* FIXME: flags are ignored */
453
454 width = icd->lpbiInput->biWidth;
455 height = icd->lpbiInput->biHeight;
456 sz = icd->lpbiInput->biSizeImage;
457
458 output = icd->lpOutput;
459
460 if (icd->lpbiOutput->biBitCount != info->depth)
461 {
462 output = HeapAlloc(GetProcessHeap(), 0, icd->lpbiOutput->biWidth * icd->lpbiOutput->biHeight * info->depth / 8);
463 if (!output) return ICERR_MEMORY;
464 }
465
466 if (info->depth == 8)
467 {
468 stride = get_stride(width, 8);
469 msvideo1_decode_8bit( width, height, icd->lpInput, sz,
470 output, stride );
471 }
472 else
473 {
474 stride = get_stride(width, 16) / 2;
475 msvideo1_decode_16bit( width, height, icd->lpInput, sz,
476 output, stride );
477 }
478
479 if (icd->lpbiOutput->biBitCount != info->depth)
480 {
481 convert_depth(output, info->depth, icd->lpOutput, icd->lpbiOutput);
482 HeapFree(GetProcessHeap(), 0, output);
483 }
484
485 return ICERR_OK;
486}
487
489{
490 LONG width, height, stride, sz;
491 void *output;
492
493 TRACE("ICM_DECOMPRESSEX %p %p %d\n", info, icd, size);
494
495 if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
496 return ICERR_BADPARAM;
497
498 /* FIXME: flags are ignored */
499
500 width = icd->lpbiSrc->biWidth;
501 height = icd->lpbiSrc->biHeight;
502 sz = icd->lpbiSrc->biSizeImage;
503
504 output = icd->lpDst;
505
506 if (icd->lpbiDst->biBitCount != info->depth)
507 {
508 output = HeapAlloc(GetProcessHeap(), 0, icd->lpbiDst->biWidth * icd->lpbiDst->biHeight * info->depth / 8);
509 if (!output) return ICERR_MEMORY;
510 }
511
512 if (info->depth == 8)
513 {
514 stride = get_stride(width, 8);
516 output, stride );
517 }
518 else
519 {
520 stride = get_stride(width, 16) / 2;
522 output, stride );
523 }
524
525 if (icd->lpbiDst->biBitCount != info->depth)
526 {
527 convert_depth(output, info->depth, icd->lpDst, icd->lpbiDst);
528 HeapFree(GetProcessHeap(), 0, output);
529 }
530
531 return ICERR_OK;
532}
533
535{
536 if (!icinfo) return sizeof(ICINFO);
537 if (dwSize < sizeof(ICINFO)) return 0;
538
539 icinfo->dwSize = sizeof(ICINFO);
540 icinfo->fccType = ICTYPE_VIDEO;
541#ifdef __REACTOS__
542 icinfo->fccHandler = MSVC_MAGIC;
543#else
544 icinfo->fccHandler = info ? info->dwMagic : CRAM_MAGIC;
545#endif
546 icinfo->dwFlags = 0;
547 icinfo->dwVersion = ICVERSION;
548 icinfo->dwVersionICM = ICVERSION;
549
552 /* msvfw32 will fill icinfo->szDriver for us */
553
554 return sizeof(ICINFO);
555}
556
557/***********************************************************************
558 * DriverProc (MSVIDC32.@)
559 */
560LRESULT WINAPI CRAM_DriverProc( DWORD_PTR dwDriverId, HDRVR hdrvr, UINT msg,
561 LPARAM lParam1, LPARAM lParam2 )
562{
563 Msvideo1Context *info = (Msvideo1Context *) dwDriverId;
565
566 TRACE("%ld %p %04x %08lx %08lx\n", dwDriverId, hdrvr, msg, lParam1, lParam2);
567
568 switch( msg )
569 {
570 case DRV_LOAD:
571 TRACE("Loaded\n");
572 r = 1;
573 break;
574
575 case DRV_ENABLE:
576 break;
577
578 case DRV_OPEN:
579 {
580 ICINFO *icinfo = (ICINFO *)lParam2;
581
582 TRACE("Opened\n");
583
584 if (icinfo && compare_fourcc(icinfo->fccType, ICTYPE_VIDEO)) return 0;
585
586 info = HeapAlloc( GetProcessHeap(), 0, sizeof (Msvideo1Context) );
587 if( info )
588 {
589 memset( info, 0, sizeof *info );
590 info->dwMagic = CRAM_MAGIC;
591 }
592 r = (LRESULT) info;
593 break;
594 }
595
596 case DRV_CLOSE:
598 break;
599
600 case DRV_DISABLE:
601 break;
602
603 case DRV_FREE:
604 break;
605
606 case ICM_GETINFO:
607 r = CRAM_GetInfo( info, (ICINFO *)lParam1, (DWORD)lParam2 );
608 break;
609
612 (LPBITMAPINFO) lParam2 );
613 break;
614
617 (LPBITMAPINFO) lParam2 );
618 break;
619
621 FIXME("ICM_DECOMPRESS_GET_PALETTE\n");
622 break;
623
625 FIXME("ICM_DECOMPRESSEX_QUERY\n");
626 break;
627
628 case ICM_DECOMPRESS:
629 r = CRAM_Decompress( info, (ICDECOMPRESS*) lParam1,
630 (DWORD) lParam2 );
631 break;
632
635 (LPBITMAPINFO) lParam2 );
636 break;
637
638 case ICM_DECOMPRESSEX:
639 r = CRAM_DecompressEx( info, (ICDECOMPRESSEX*) lParam1,
640 (DWORD) lParam2 );
641 break;
642
644 r = ICERR_OK;
645 break;
646
649 /* fall through */
651 case ICM_COMPRESS_END:
652 case ICM_COMPRESS:
653 FIXME("compression not implemented\n");
654 break;
655
656 case ICM_CONFIGURE:
657 break;
658
659 default:
660 FIXME("Unknown message: %04x %ld %ld\n", msg, lParam1, lParam2);
661 }
662
663 return r;
664}
665
666/***********************************************************************
667 * DllMain
668 */
670{
671 TRACE("(%p,%d,%p)\n", hModule, dwReason, lpReserved);
672
673 switch (dwReason)
674 {
678 break;
679 }
680 return TRUE;
681}
#define msg(x)
Definition: auth_time.c:54
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define IDS_DESCRIPTION
Definition: resource.h:4
#define ARRAY_SIZE(A)
Definition: main.h:33
DWORD dwReason
Definition: misc.cpp:154
#define FIXME(fmt,...)
Definition: debug.h:111
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define IDS_NAME
Definition: resource.h:90
HMODULE hModule
Definition: animate.c:44
#define GetProcessHeap()
Definition: compat.h:736
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
#define BI_RGB
Definition: precomp.h:56
ULONG RGBQUAD
Definition: precomp.h:59
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: gl.h:1546
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLint GLint GLsizei width
Definition: gl.h:1546
GLsizeiptr size
Definition: glext.h:5919
GLsizei stride
Definition: glext.h:5848
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLuint in
Definition: glext.h:9616
GLbitfield flags
Definition: glext.h:7161
GLenum GLenum GLenum input
Definition: glext.h:9031
#define DRV_LOAD(x)
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define ICTYPE_VIDEO
Definition: mmreg.h:531
#define DRV_CLOSE
Definition: mmsystem.h:122
#define DRV_ENABLE
Definition: mmsystem.h:120
#define DRV_OPEN
Definition: mmsystem.h:121
#define DRV_FREE
Definition: mmsystem.h:124
#define DRV_DISABLE
Definition: mmsystem.h:123
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define MSVC_MAGIC
Definition: msvideo1.c:51
static void msvideo1_decode_16bit(int width, int height, const unsigned char *buf, int buf_size, unsigned short *pixels, int stride)
Definition: msvideo1.c:183
static int get_stride(int width, int depth)
Definition: msvideo1.c:73
BYTE uint8_t
Definition: msvideo1.c:66
BOOL WINAPI DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved)
Definition: msvideo1.c:669
LRESULT WINAPI CRAM_DriverProc(DWORD_PTR dwDriverId, HDRVR hdrvr, UINT msg, LPARAM lParam1, LPARAM lParam2)
Definition: msvideo1.c:560
static LRESULT CRAM_Decompress(Msvideo1Context *info, ICDECOMPRESS *icd, DWORD size)
Definition: msvideo1.c:442
static LRESULT CRAM_DecompressEx(Msvideo1Context *info, ICDECOMPRESSEX *icd, DWORD size)
Definition: msvideo1.c:488
#define LE_16(x)
Definition: msvideo1.c:56
#define CHECK_STREAM_PTR(n)
Definition: msvideo1.c:59
static LRESULT CRAM_DecompressQuery(Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out)
Definition: msvideo1.c:300
static void msvideo1_decode_8bit(int width, int height, const unsigned char *buf, int buf_size, unsigned char *pixels, int stride)
Definition: msvideo1.c:79
static LRESULT CRAM_GetInfo(const Msvideo1Context *info, ICINFO *icinfo, DWORD dwSize)
Definition: msvideo1.c:534
static void convert_depth(char *input, int depth_in, char *output, BITMAPINFOHEADER *out_hdr)
Definition: msvideo1.c:408
#define CRAM_MAGIC
Definition: msvideo1.c:50
static LRESULT CRAM_DecompressBegin(Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out)
Definition: msvideo1.c:387
#define compare_fourcc(fcc1, fcc2)
Definition: msvideo1.c:53
#define WHAM_MAGIC
Definition: msvideo1.c:52
static LRESULT CRAM_DecompressGetFormat(Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out)
Definition: msvideo1.c:357
static HINSTANCE MSVIDC32_hModule
Definition: msvideo1.c:48
unsigned int UINT
Definition: ndis.h:50
#define LRESULT
Definition: ole.h:14
long LONG
Definition: pedump.c:60
static FILE * out
Definition: regtests2xml.c:44
#define memset(x, y, z)
Definition: compat.h:39
#define TRACE(s)
Definition: solgame.cpp:4
DWORD biSizeImage
Definition: amvideo.idl:36
LPBITMAPINFOHEADER lpbiSrc
Definition: vfw.h:344
LPVOID lpDst
Definition: vfw.h:347
LPVOID lpSrc
Definition: vfw.h:345
LPBITMAPINFOHEADER lpbiDst
Definition: vfw.h:346
LPBITMAPINFOHEADER lpbiInput
Definition: vfw.h:335
LPBITMAPINFOHEADER lpbiOutput
Definition: vfw.h:337
Definition: vfw.h:280
DWORD dwSize
Definition: vfw.h:281
DWORD dwVersionICM
Definition: vfw.h:286
DWORD fccType
Definition: vfw.h:282
DWORD dwFlags
Definition: vfw.h:284
DWORD dwVersion
Definition: vfw.h:285
DWORD fccHandler
Definition: vfw.h:283
WCHAR szDescription[128]
Definition: vfw.h:291
WCHAR szName[16]
Definition: vfw.h:290
DWORD dwMagic
Definition: msvideo1.c:69
uint32_t DWORD_PTR
Definition: typedefs.h:65
#define ICVERSION
Definition: vfw.h:45
#define ICERR_BADPARAM
Definition: vfw.h:61
#define ICERR_OK
Definition: vfw.h:50
#define ICM_COMPRESS_QUERY
Definition: vfw.h:101
#define ICM_DECOMPRESS_GET_PALETTE
Definition: vfw.h:112
#define ICM_DECOMPRESS_QUERY
Definition: vfw.h:107
#define ICERR_UNSUPPORTED
Definition: vfw.h:56
#define ICM_GETINFO
Definition: vfw.h:82
#define ICM_DECOMPRESSEX
Definition: vfw.h:140
#define ICERR_BADFORMAT
Definition: vfw.h:57
#define ICM_COMPRESS
Definition: vfw.h:103
#define ICM_DECOMPRESS_GET_FORMAT
Definition: vfw.h:106
#define ICM_CONFIGURE
Definition: vfw.h:84
#define ICM_DECOMPRESS_END
Definition: vfw.h:110
#define ICM_DECOMPRESSEX_QUERY
Definition: vfw.h:139
#define ICM_COMPRESS_GET_FORMAT
Definition: vfw.h:99
#define ICM_DECOMPRESS_BEGIN
Definition: vfw.h:108
#define ICERR_MEMORY
Definition: vfw.h:58
#define ICM_COMPRESS_END
Definition: vfw.h:104
#define ICM_DECOMPRESS
Definition: vfw.h:109
LONG_PTR LPARAM
Definition: windef.h:208
LONG_PTR LRESULT
Definition: windef.h:209
#define WINAPI
Definition: msvc.h:6
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
unsigned char BYTE
Definition: xxhash.c:193