?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winedbg: Copy floating point status to the dbgcontext.
[wine/hacks.git] / dlls / msrle32 / msrle32.c
blob6f44048ea5d884838f4739acfd12f40cfa3d1c5f
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19 /* TODO:
20 * - some improvements possible
21 * - implement DecompressSetPalette? -- do we need it for anything?
22 */
23
24 #include <assert.h>
25
26 #include "msrle_private.h"
27
28 #include "winnls.h"
29 #include "winuser.h"
30
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(msrle32);
34
35 static HINSTANCE MSRLE32_hModule = 0;
36
37 #define ABS(a) ((a) < 0 ? -(a) : (a))
38 #define SQR(a) ((a) * (a))
39
40 #define QUALITY_to_DIST(q) (ICQUALITY_HIGH - q)
41 inline WORD ColorCmp(WORD clr1, WORD clr2)
42 {
43 register UINT a = (clr1-clr2);
44 return SQR(a);
45 }
46 inline WORD Intensity(RGBQUAD clr)
47 {
48 return (30 * clr.rgbRed + 59 * clr.rgbGreen + 11 * clr.rgbBlue)/4;
49 }
50
51 #define GetRawPixel(lpbi,lp,x) \
52 ((lpbi)->biBitCount == 1 ? ((lp)[(x)/8] >> (8 - (x)%8)) & 1 : \
53 ((lpbi)->biBitCount == 4 ? ((lp)[(x)/2] >> (4 * (1 - (x)%2))) & 15 : lp[x]))
54
55 /*****************************************************************************/
56
57 /* utility functions */
58 static BOOL isSupportedDIB(LPCBITMAPINFOHEADER lpbi);
59 static BOOL isSupportedMRLE(LPCBITMAPINFOHEADER lpbi);
60 static BYTE MSRLE32_GetNearestPaletteIndex(UINT count, const RGBQUAD *clrs, RGBQUAD clr);
61
62 /* compression functions */
63 static void computeInternalFrame(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn, LPBYTE lpIn);
64 static LONG MSRLE32_GetMaxCompressedSize(LPCBITMAPINFOHEADER lpbi);
65 static LRESULT MSRLE32_CompressRLE4(CodecInfo *pi, LPBITMAPINFOHEADER lpbiIn, LPBYTE lpIn, LPBITMAPINFOHEADER lpbiOut, LPBYTE lpOut, BOOL isKey);
66 static LRESULT MSRLE32_CompressRLE8(CodecInfo *pi, LPBITMAPINFOHEADER lpbiIn, LPBYTE lpIn, LPBITMAPINFOHEADER lpbiOut, LPBYTE lpOut, BOOL isKey);
67
68 /* decompression functions */
69 static LRESULT MSRLE32_DecompressRLE4(CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
70 LPBYTE lpIn, LPBYTE lpOut);
71 static LRESULT MSRLE32_DecompressRLE8(CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
72 LPBYTE lpIn, LPBYTE lpOut);
73
74 /* API functions */
75 static LRESULT CompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
76 LPBITMAPINFOHEADER lpbiOut);
77 static LRESULT CompressGetSize(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
78 LPCBITMAPINFOHEADER lpbiOut);
79 static LRESULT CompressQuery(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
80 LPCBITMAPINFOHEADER lpbiOut);
81 static LRESULT CompressBegin(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
82 LPCBITMAPINFOHEADER lpbiOut);
83 static LRESULT Compress(CodecInfo *pi, ICCOMPRESS* lpic, DWORD dwSize);
84 static LRESULT CompressEnd(CodecInfo *pi);
85
86 static LRESULT DecompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
87 LPBITMAPINFOHEADER lpbiOut);
88 static LRESULT DecompressQuery(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
89 LPCBITMAPINFOHEADER lpbiOut);
90 static LRESULT DecompressBegin(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
91 LPCBITMAPINFOHEADER lpbiOut);
92 static LRESULT Decompress(CodecInfo *pi, ICDECOMPRESS *pic, DWORD dwSize);
93 static LRESULT DecompressEnd(CodecInfo *pi);
94 static LRESULT DecompressGetPalette(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
95 LPBITMAPINFOHEADER lpbiOut);
96
97 /*****************************************************************************/
98
99 static BOOL isSupportedMRLE(LPCBITMAPINFOHEADER lpbi)
100 {
101 /* pre-conditions */
102 assert(lpbi != NULL);
103
104 if (lpbi->biSize < sizeof(BITMAPINFOHEADER) || \
105 lpbi->biPlanes != 1)
106 return FALSE;
107
108 if (lpbi->biCompression == BI_RLE4) {
109 if (lpbi->biBitCount != 4 || \
110 (lpbi->biWidth % 2) != 0)
111 return FALSE;
112 } else if (lpbi->biCompression == BI_RLE8) {
113 if (lpbi->biBitCount != 8)
114 return FALSE;
115 } else
116 return FALSE;
117
118 return TRUE;
119 }
120
121 static BOOL isSupportedDIB(LPCBITMAPINFOHEADER lpbi)
122 {
123 /* pre-conditions */
124 assert(lpbi != NULL);
125
126 /* check structure version/planes/compression */
127 if (lpbi->biSize < sizeof(BITMAPINFOHEADER) ||
128 lpbi->biPlanes != 1)
129 return FALSE;
130 if (lpbi->biCompression != BI_RGB &&
131 lpbi->biCompression != BI_BITFIELDS)
132 return FALSE;
133
134 /* check bit-depth */
135 if (lpbi->biBitCount != 1 &&
136 lpbi->biBitCount != 4 &&
137 lpbi->biBitCount != 8 &&
138 lpbi->biBitCount != 15 &&
139 lpbi->biBitCount != 16 &&
140 lpbi->biBitCount != 24 &&
141 lpbi->biBitCount != 32)
142 return FALSE;
143
144 /* check for size(s) */
145 if (!lpbi->biWidth || !lpbi->biHeight)
146 return FALSE; /* image with zero size, makes no sense so error ! */
147 if (DIBWIDTHBYTES(*lpbi) * (DWORD)lpbi->biHeight >= (1UL << 31) - 1)
148 return FALSE; /* image too big ! */
149
150 /* check for nonexistent colortable for hi- and true-color DIB's */
151 if (lpbi->biBitCount >= 15 && lpbi->biClrUsed > 0)
152 return FALSE;
153
154 return TRUE;
155 }
156
157 static BYTE MSRLE32_GetNearestPaletteIndex(UINT count, const RGBQUAD *clrs, RGBQUAD clr)
158 {
159 INT diff = 0x00FFFFFF;
160 UINT i;
161 UINT idx = 0;
162
163 /* pre-conditions */
164 assert(clrs != NULL);
165
166 for (i = 0; i < count; i++) {
167 int r = ((int)clrs[i].rgbRed - (int)clr.rgbRed);
168 int g = ((int)clrs[i].rgbGreen - (int)clr.rgbGreen);
169 int b = ((int)clrs[i].rgbBlue - (int)clr.rgbBlue);
170
171 r = r*r + g*g + b*b;
172
173 if (r < diff) {
174 idx = i;
175 diff = r;
176 if (diff == 0)
177 break;
178 }
179 }
180
181 return idx;
182 }
183
184 /*****************************************************************************/
185
186 void computeInternalFrame(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn, LPBYTE lpIn)
187 {
188 WORD wIntensityTbl[256];
189 DWORD lInLine, lOutLine;
190 LPWORD lpOut;
191 UINT i;
192 LONG y;
193
194 /* pre-conditions */
195 assert(pi != NULL && lpbiIn != NULL && lpIn != NULL);
196 assert(pi->pCurFrame != NULL);
197
198 lInLine = DIBWIDTHBYTES(*lpbiIn);
199 lOutLine = WIDTHBYTES((WORD)lpbiIn->biWidth * 8u * sizeof(WORD)) / 2u;
200 lpOut = pi->pCurFrame;
201
202 assert(lpbiIn->biClrUsed != 0);
203
204 {
205 const RGBQUAD *lp =
206 (const RGBQUAD *)((const BYTE*)lpbiIn + lpbiIn->biSize);
207
208 for (i = 0; i < lpbiIn->biClrUsed; i++)
209 wIntensityTbl[i] = Intensity(lp[i]);
210 }
211
212 for (y = 0; y < lpbiIn->biHeight; y++) {
213 LONG x;
214
215 switch (lpbiIn->biBitCount) {
216 case 1:
217 for (x = 0; x < lpbiIn->biWidth / 8; x++) {
218 for (i = 0; i < 7; i++)
219 lpOut[8 * x + i] = wIntensityTbl[(lpIn[x] >> (7 - i)) & 1];
220 }
221 break;
222 case 4:
223 for (x = 0; x < lpbiIn->biWidth / 2; x++) {
224 lpOut[2 * x + 0] = wIntensityTbl[(lpIn[x] >> 4)];
225 lpOut[2 * x + 1] = wIntensityTbl[(lpIn[x] & 0x0F)];
226 }
227 break;
228 case 8:
229 for (x = 0; x < lpbiIn->biWidth; x++)
230 lpOut[x] = wIntensityTbl[lpIn[x]];
231 break;
232 }
233
234 lpIn += lInLine;
235 lpOut += lOutLine;
236 }
237 }
238
239 static LONG MSRLE32_GetMaxCompressedSize(LPCBITMAPINFOHEADER lpbi)
240 {
241 LONG a, b, size;
242
243 /* pre-condition */
244 assert(lpbi != NULL);
245
246 a = lpbi->biWidth / 255;
247 b = lpbi->biWidth % 255;
248 if (lpbi->biBitCount <= 4) {
249 a /= 2;
250 b /= 2;
251 }
252
253 size = (2 + a * (2 + ((a + 2) & ~2)) + b * (2 + ((b + 2) & ~2)));
254 return size * lpbi->biHeight;
255 }
256
257 /* lpP => current pos in previous frame
258 * lpA => previous pos in current frame
259 * lpB => current pos in current frame
260 */
261 static INT countDiffRLE4(LPWORD lpP, LPWORD lpA, LPWORD lpB, INT pos, LONG lDist, LONG width)
262 {
263 INT count;
264 WORD clr1, clr2;
265
266 /* pre-conditions */
267 assert(lpA && lpB && lDist >= 0 && width > 0);
268
269 if (pos >= width)
270 return 0;
271 if (pos+1 == width)
272 return 1;
273
274 clr1 = lpB[pos++];
275 clr2 = lpB[pos];
276
277 count = 2;
278 while (pos + 1 < width) {
279 WORD clr3, clr4;
280
281 clr3 = lpB[++pos];
282 if (pos + 1 >= width)
283 return count + 1;
284
285 clr4 = lpB[++pos];
286 if (ColorCmp(clr1, clr3) <= lDist &&
287 ColorCmp(clr2, clr4) <= lDist) {
288 /* diff at end? -- look-ahead for at least ?? more encodable pixels */
289 if (pos + 2 < width && ColorCmp(clr1,lpB[pos+1]) <= lDist &&
290 ColorCmp(clr2,lpB[pos+2]) <= lDist) {
291 if (pos + 4 < width && ColorCmp(lpB[pos+1],lpB[pos+3]) <= lDist &&
292 ColorCmp(lpB[pos+2],lpB[pos+4]) <= lDist)
293 return count - 3; /* followed by at least 4 encodable pixels */
294 return count - 2;
295 }
296 } else if (lpP != NULL && ColorCmp(lpP[pos], lpB[pos]) <= lDist) {
297 /* 'compare' with previous frame for end of diff */
298 INT count2 = 0;
299
300 /* FIXME */
301
302 if (count2 >= 8)
303 return count;
304
305 pos -= count2;
306 }
307
308 count += 2;
309 clr1 = clr3;
310 clr2 = clr4;
311 }
312
313 return count;
314 }
315
316 /* lpP => current pos in previous frame
317 * lpA => previous pos in current frame
318 * lpB => current pos in current frame
319 */
320 static INT countDiffRLE8(LPWORD lpP, LPWORD lpA, LPWORD lpB, INT pos, LONG lDist, LONG width)
321 {
322 INT count;
323
324 for (count = 0; pos < width; pos++, count++) {
325 if (ColorCmp(lpA[pos], lpB[pos]) <= lDist) {
326 /* diff at end? -- look-ahead for some more encodable pixel */
327 if (pos + 1 < width && ColorCmp(lpB[pos], lpB[pos+1]) <= lDist)
328 return count - 1;
329 if (pos + 2 < width && ColorCmp(lpB[pos+1], lpB[pos+2]) <= lDist)
330 return count - 1;
331 } else if (lpP != NULL && ColorCmp(lpP[pos], lpB[pos]) <= lDist) {
332 /* 'compare' with previous frame for end of diff */
333 INT count2 = 0;
334
335 for (count2 = 0, pos++; pos < width && count2 <= 5; pos++, count2++) {
336 if (ColorCmp(lpP[pos], lpB[pos]) > lDist)
337 break;
338 }
339 if (count2 > 4)
340 return count;
341
342 pos -= count2;
343 }
344 }
345
346 return count;
347 }
348
349 static INT MSRLE32_CompressRLE4Line(CodecInfo *pi, LPWORD lpP, LPWORD lpC, LPCBITMAPINFOHEADER lpbi, BYTE *lpIn, LONG lDist, INT x, LPBYTE *ppOut, DWORD *lpSizeImage)
350 {
351 LPBYTE lpOut = *ppOut;
352 INT count, pos;
353 WORD clr1, clr2;
354
355 /* try to encode as many pixel as possible */
356 count = 1;
357 pos = x;
358 clr1 = lpC[pos++];
359 if (pos < lpbi->biWidth) {
360 clr2 = lpC[pos];
361 for (++count; pos + 1 < lpbi->biWidth; ) {
362 ++pos;
363 if (ColorCmp(clr1, lpC[pos]) > lDist)
364 break;
365 count++;
366 if (pos + 1 >= lpbi->biWidth)
367 break;
368 ++pos;
369 if (ColorCmp(clr2, lpC[pos]) > lDist)
370 break;
371 count++;
372 }
373 }
374
375 if (count < 4) {
376 /* add some pixel for absoluting if possible */
377 count += countDiffRLE4(lpP, lpC - 1, lpC, pos-1, lDist, lpbi->biWidth);
378
379 assert(count > 0);
380
381 /* check for near end of line */
382 if (x + count > lpbi->biWidth)
383 count = lpbi->biWidth - x;
384
385 /* absolute pixel(s) in groups of at least 3 and at most 254 pixels */
386 while (count > 2) {
387 INT i;
388 INT size = min(count, 254);
389 int bytes = ((size + 1) & (~1)) / 2;
390 BOOL extra_byte = bytes & 0x01;
391
392 *lpSizeImage += 2 + bytes + extra_byte;
393 assert(((*lpSizeImage) % 2) == 0);
394 count -= size;
395 *lpOut++ = 0;
396 *lpOut++ = size;
397 for (i = 0; i < size; i += 2) {
398 clr1 = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
399 x++;
400 if (i + 1 < size) {
401 clr2 = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
402 x++;
403 } else
404 clr2 = 0;
405
406 *lpOut++ = (clr1 << 4) | clr2;
407 }
408 if (extra_byte)
409 *lpOut++ = 0;
410 }
411
412 if (count > 0) {
413 /* too little for absoluting so we must encode them */
414 assert(count <= 2);
415
416 *lpSizeImage += 2;
417 clr1 = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
418 x++;
419 if (count == 2) {
420 clr2 = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
421 x++;
422 } else
423 clr2 = 0;
424 *lpOut++ = count;
425 *lpOut++ = (clr1 << 4) | clr2;
426 }
427 } else {
428 /* encode count pixel(s) */
429 clr1 = ((pi->palette_map[GetRawPixel(lpbi,lpIn,x)] << 4) |
430 pi->palette_map[GetRawPixel(lpbi,lpIn,x + 1)]);
431
432 x += count;
433 while (count > 0) {
434 INT size = min(count, 254);
435
436 *lpSizeImage += 2;
437 count -= size;
438 *lpOut++ = size;
439 *lpOut++ = clr1;
440 }
441 }
442
443 *ppOut = lpOut;
444
445 return x;
446 }
447
448 static INT MSRLE32_CompressRLE8Line(CodecInfo *pi, LPWORD lpP, LPWORD lpC, LPCBITMAPINFOHEADER lpbi, BYTE *lpIn, LONG lDist, INT x, LPBYTE *ppOut, DWORD *lpSizeImage)
449 {
450 LPBYTE lpOut = *ppOut;
451 INT count, pos;
452 WORD clr;
453
454 assert(lpbi->biBitCount <= 8);
455 assert(lpbi->biCompression == BI_RGB);
456
457 /* try to encode as much as possible */
458 pos = x;
459 clr = lpC[pos++];
460 for (count = 1; pos < lpbi->biWidth; count++) {
461 if (ColorCmp(clr, lpC[pos++]) > lDist)
462 break;
463 }
464
465 if (count < 2) {
466 /* add some more pixels for absoluting if possible */
467 count += countDiffRLE8(lpP, lpC - 1, lpC, pos-1, lDist, lpbi->biWidth);
468
469 assert(count > 0);
470
471 /* check for over end of line */
472 if (x + count > lpbi->biWidth)
473 count = lpbi->biWidth - x;
474
475 /* absolute pixel(s) in groups of at least 3 and at most 255 pixels */
476 while (count > 2) {
477 INT i;
478 INT size = min(count, 255);
479 BOOL extra_byte = size % 2;
480
481 *lpSizeImage += 2 + size + extra_byte;
482 count -= size;
483 *lpOut++ = 0;
484 *lpOut++ = size;
485 for (i = 0; i < size; i++) {
486 *lpOut++ = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
487 x++;
488 }
489 if (extra_byte)
490 *lpOut++ = 0;
491 }
492 if (count > 0) {
493 /* too little for absoluting so we must encode them even if it's expensive! */
494 assert(count <= 2);
495
496 *lpSizeImage += 2 * count;
497 *lpOut++ = 1;
498 *lpOut++ = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
499 x++;
500
501 if (count == 2) {
502 *lpOut++ = 1;
503 *lpOut++ = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
504 x++;
505 }
506 }
507 } else {
508 /* encode count pixel(s) */
509 clr = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
510
511 /* optimize end of line */
512 if (x + count + 1 == lpbi->biWidth)
513 count++;
514
515 x += count;
516 while (count > 0) {
517 INT size = min(count, 255);
518
519 *lpSizeImage += 2;
520 count -= size;
521 *lpOut++ = size;
522 *lpOut++ = clr;
523 }
524 }
525
526 *ppOut = lpOut;
527
528 return x;
529 }
530
531 LRESULT MSRLE32_CompressRLE4(CodecInfo *pi, LPBITMAPINFOHEADER lpbiIn, LPBYTE lpIn, LPBITMAPINFOHEADER lpbiOut, LPBYTE lpOut, BOOL isKey)
532 {
533 LPWORD lpC;
534 LONG lLine, lInLine, lDist;
535 LPBYTE lpOutStart = lpOut;
536
537 /* pre-conditions */
538 assert(pi != NULL && lpbiOut != NULL);
539 assert(lpIn != NULL && lpOut != NULL);
540 assert(pi->pCurFrame != NULL);
541
542 lpC = pi->pCurFrame;
543 lDist = QUALITY_to_DIST(pi->dwQuality);
544 lInLine = DIBWIDTHBYTES(*lpbiIn);
545 lLine = WIDTHBYTES(lpbiOut->biWidth * 16) / 2;
546
547 lpbiOut->biSizeImage = 0;
548 if (isKey) {
549 /* keyframe -- convert internal frame to output format */
550 INT x, y;
551
552 for (y = 0; y < lpbiOut->biHeight; y++) {
553 x = 0;
554
555 do {
556 x = MSRLE32_CompressRLE4Line(pi, NULL, lpC, lpbiIn, lpIn, lDist, x,
557 &lpOut, &lpbiOut->biSizeImage);
558 } while (x < lpbiOut->biWidth);
559
560 lpC += lLine;
561 lpIn += lInLine;
562
563 /* add EOL -- end of line */
564 lpbiOut->biSizeImage += 2;
565 *(LPWORD)lpOut = 0;
566 lpOut += sizeof(WORD);
567 assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
568 }
569 } else {
570 /* delta-frame -- compute delta between last and this internal frame */
571 LPWORD lpP;
572 INT x, y;
573 INT jumpx, jumpy;
574
575 assert(pi->pPrevFrame != NULL);
576
577 lpP = pi->pPrevFrame;
578 jumpy = 0;
579 jumpx = -1;
580
581 for (y = 0; y < lpbiOut->biHeight; y++) {
582 x = 0;
583
584 do {
585 INT count, pos;
586
587 if (jumpx == -1)
588 jumpx = x;
589 for (count = 0, pos = x; pos < lpbiOut->biWidth; pos++, count++) {
590 if (ColorCmp(lpP[pos], lpC[pos]) > lDist)
591 break;
592 }
593
594 if (pos == lpbiOut->biWidth && count > 8) {
595 /* (count > 8) secures that we will save space */
596 jumpy++;
597 break;
598 } else if (jumpy || jumpx != pos) {
599 /* time to jump */
600 assert(jumpx != -1);
601
602 if (pos < jumpx) {
603 /* can only jump in positive direction -- jump until EOL, EOL */
604 INT w = lpbiOut->biWidth - jumpx;
605
606 assert(jumpy > 0);
607 assert(w >= 4);
608
609 jumpx = 0;
610 jumpy--;
611 /* if (w % 255 == 2) then equal costs
612 * else if (w % 255 < 4 && we could encode all) then 2 bytes too expensive
613 * else it will be cheaper
614 */
615 while (w > 0) {
616 lpbiOut->biSizeImage += 4;
617 *lpOut++ = 0;
618 *lpOut++ = 2;
619 *lpOut = min(w, 255);
620 w -= *lpOut++;
621 *lpOut++ = 0;
622 }
623 /* add EOL -- end of line */
624 lpbiOut->biSizeImage += 2;
625 *((LPWORD)lpOut) = 0;
626 lpOut += sizeof(WORD);
627 }
628
629 /* FIXME: if (jumpy == 0 && could encode all) then jump too expensive */
630
631 /* write out real jump(s) */
632 while (jumpy || pos != jumpx) {
633 lpbiOut->biSizeImage += 4;
634 *lpOut++ = 0;
635 *lpOut++ = 2;
636 *lpOut = min(pos - jumpx, 255);
637 x += *lpOut;
638 jumpx += *lpOut++;
639 *lpOut = min(jumpy, 255);
640 jumpy -= *lpOut++;
641 }
642
643 jumpy = 0;
644 }
645
646 jumpx = -1;
647
648 if (x < lpbiOut->biWidth) {
649 /* skipped the 'same' things corresponding to previous frame */
650 x = MSRLE32_CompressRLE4Line(pi, lpP, lpC, lpbiIn, lpIn, lDist, x,
651 &lpOut, &lpbiOut->biSizeImage);
652 }
653 } while (x < lpbiOut->biWidth);
654
655 lpP += lLine;
656 lpC += lLine;
657 lpIn += lInLine;
658
659 if (jumpy == 0) {
660 assert(jumpx == -1);
661
662 /* add EOL -- end of line */
663 lpbiOut->biSizeImage += 2;
664 *((LPWORD)lpOut) = 0;
665 lpOut += sizeof(WORD);
666 assert(lpOut == lpOutStart + lpbiOut->biSizeImage);
667 }
668 }
669
670 /* add EOL -- will be changed to EOI */
671 lpbiOut->biSizeImage += 2;
672 *((LPWORD)lpOut) = 0;
673 lpOut += sizeof(WORD);
674 }
675
676 /* change EOL to EOI -- end of image */
677 lpOut[-1] = 1;
678 assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
679
680 return ICERR_OK;
681 }
682
683 LRESULT MSRLE32_CompressRLE8(CodecInfo *pi, LPBITMAPINFOHEADER lpbiIn, LPBYTE lpIn, LPBITMAPINFOHEADER lpbiOut, LPBYTE lpOut, BOOL isKey)
684 {
685 LPWORD lpC;
686 LONG lDist, lInLine, lLine;
687 LPBYTE lpOutStart = lpOut;
688
689 assert(pi != NULL && lpbiOut != NULL);
690 assert(lpIn != NULL && lpOut != NULL);
691 assert(pi->pCurFrame != NULL);
692
693 lpC = pi->pCurFrame;
694 lDist = QUALITY_to_DIST(pi->dwQuality);
695 lInLine = DIBWIDTHBYTES(*lpbiIn);
696 lLine = WIDTHBYTES(lpbiOut->biWidth * 16) / 2;
697
698 lpbiOut->biSizeImage = 0;
699 if (isKey) {
700 /* keyframe -- convert internal frame to output format */
701 INT x, y;
702
703 for (y = 0; y < lpbiOut->biHeight; y++) {
704 x = 0;
705
706 do {
707 x = MSRLE32_CompressRLE8Line(pi, NULL, lpC, lpbiIn, lpIn, lDist, x,
708 &lpOut, &lpbiOut->biSizeImage);
709 assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
710 } while (x < lpbiOut->biWidth);
711
712 lpC += lLine;
713 lpIn += lInLine;
714
715 /* add EOL -- end of line */
716 lpbiOut->biSizeImage += 2;
717 *((LPWORD)lpOut) = 0;
718 lpOut += sizeof(WORD);
719 assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
720 }
721 } else {
722 /* delta-frame -- compute delta between last and this internal frame */
723 LPWORD lpP;
724 INT x, y;
725 INT jumpx, jumpy;
726
727 assert(pi->pPrevFrame != NULL);
728
729 lpP = pi->pPrevFrame;
730 jumpx = -1;
731 jumpy = 0;
732
733 for (y = 0; y < lpbiOut->biHeight; y++) {
734 x = 0;
735
736 do {
737 INT count, pos;
738
739 if (jumpx == -1)
740 jumpx = x;
741 for (count = 0, pos = x; pos < lpbiOut->biWidth; pos++, count++) {
742 if (ColorCmp(lpP[pos], lpC[pos]) > lDist)
743 break;
744 }
745
746 if (pos == lpbiOut->biWidth && count > 4) {
747 /* (count > 4) secures that we will save space */
748 jumpy++;
749 break;
750 } else if (jumpy || jumpx != pos) {
751 /* time to jump */
752 assert(jumpx != -1);
753
754 if (pos < jumpx) {
755 /* can only jump in positive direction -- do an EOL then jump */
756 assert(jumpy > 0);
757
758 jumpx = 0;
759 jumpy--;
760
761 /* add EOL -- end of line */
762 lpbiOut->biSizeImage += 2;
763 *((LPWORD)lpOut) = 0;
764 lpOut += sizeof(WORD);
765 assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
766 }
767
768 /* FIXME: if (jumpy == 0 && could encode all) then jump too expensive */
769
770 /* write out real jump(s) */
771 while (jumpy || pos != jumpx) {
772 lpbiOut->biSizeImage += 4;
773 *lpOut++ = 0;
774 *lpOut++ = 2;
775 *lpOut = min(pos - jumpx, 255);
776 jumpx += *lpOut++;
777 *lpOut = min(jumpy, 255);
778 jumpy -= *lpOut++;
779 }
780 x = pos;
781
782 jumpy = 0;
783 }
784
785 jumpx = -1;
786
787 if (x < lpbiOut->biWidth) {
788 /* skip the 'same' things corresponding to previous frame */
789 x = MSRLE32_CompressRLE8Line(pi, lpP, lpC, lpbiIn, lpIn, lDist, x,
790 &lpOut, &lpbiOut->biSizeImage);
791 assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
792 }
793 } while (x < lpbiOut->biWidth);
794
795 lpP += lLine;
796 lpC += lLine;
797 lpIn += lInLine;
798
799 if (jumpy == 0) {
800 /* add EOL -- end of line */
801 lpbiOut->biSizeImage += 2;
802 *((LPWORD)lpOut) = 0;
803 lpOut += sizeof(WORD);
804 assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
805 }
806 }
807
808 /* add EOL -- will be changed to EOI */
809 lpbiOut->biSizeImage += 2;
810 *((LPWORD)lpOut) = 0;
811 lpOut += sizeof(WORD);
812 }
813
814 /* change EOL to EOI -- end of image */
815 lpOut[-1] = 1;
816 assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
817
818 return ICERR_OK;
819 }
820
821 /*****************************************************************************/
822
823 static LRESULT MSRLE32_DecompressRLE4(CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
824 LPBYTE lpIn, LPBYTE lpOut)
825 {
826 int bytes_per_pixel;
827 int line_size;
828 int pixel_ptr = 0;
829 int i;
830 BOOL bEndFlag = FALSE;
831
832 assert(pi != NULL);
833 assert(lpbi != NULL && lpbi->biCompression == BI_RGB);
834 assert(lpIn != NULL && lpOut != NULL);
835
836 bytes_per_pixel = (lpbi->biBitCount + 1) / 8;
837 line_size = DIBWIDTHBYTES(*lpbi);
838
839 do {
840 BYTE code0, code1;
841
842 code0 = *lpIn++;
843 code1 = *lpIn++;
844
845 if (code0 == 0) {
846 int extra_byte;
847
848 switch (code1) {
849 case 0: /* EOL - end of line */
850 pixel_ptr = 0;
851 lpOut += line_size;
852 break;
853 case 1: /* EOI - end of image */
854 bEndFlag = TRUE;
855 break;
856 case 2: /* skip */
857 pixel_ptr += *lpIn++ * bytes_per_pixel;
858 lpOut += *lpIn++ * line_size;
859 if (pixel_ptr >= lpbi->biWidth * bytes_per_pixel) {
860 pixel_ptr = 0;
861 lpOut += line_size;
862 }
863 break;
864 default: /* absolute mode */
865 extra_byte = (((code1 + 1) & (~1)) / 2) & 0x01;
866
867 if (pixel_ptr/bytes_per_pixel + code1 > lpbi->biWidth)
868 return ICERR_ERROR;
869
870 code0 = code1;
871 for (i = 0; i < code0 / 2; i++) {
872 if (bytes_per_pixel == 1) {
873 code1 = lpIn[i];
874 lpOut[pixel_ptr++] = pi->palette_map[(code1 >> 4)];
875 if (2 * i + 1 <= code0)
876 lpOut[pixel_ptr++] = pi->palette_map[(code1 & 0x0F)];
877 } else if (bytes_per_pixel == 2) {
878 code1 = lpIn[i] >> 4;
879 lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 0];
880 lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 1];
881
882 if (2 * i + 1 <= code0) {
883 code1 = lpIn[i] & 0x0F;
884 lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 0];
885 lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 1];
886 }
887 } else {
888 code1 = lpIn[i] >> 4;
889 lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 4 + 0];
890 lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 4 + 1];
891 lpOut[pixel_ptr + 2] = pi->palette_map[code1 * 4 + 2];
892 pixel_ptr += bytes_per_pixel;
893
894 if (2 * i + 1 <= code0) {
895 code1 = lpIn[i] & 0x0F;
896 lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 4 + 0];
897 lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 4 + 1];
898 lpOut[pixel_ptr + 2] = pi->palette_map[code1 * 4 + 2];
899 pixel_ptr += bytes_per_pixel;
900 }
901 }
902 }
903 if (code0 & 0x01) {
904 if (bytes_per_pixel == 1) {
905 code1 = lpIn[i];
906 lpOut[pixel_ptr++] = pi->palette_map[(code1 >> 4)];
907 } else if (bytes_per_pixel == 2) {
908 code1 = lpIn[i] >> 4;
909 lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 0];
910 lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 1];
911 } else {
912 code1 = lpIn[i] >> 4;
913 lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 4 + 0];
914 lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 4 + 1];
915 lpOut[pixel_ptr + 2] = pi->palette_map[code1 * 4 + 2];
916 pixel_ptr += bytes_per_pixel;
917 }
918 lpIn++;
919 }
920 lpIn += code0 / 2;
921
922 /* if the RLE code is odd, skip a byte in the stream */
923 if (extra_byte)
924 lpIn++;
925 };
926 } else {
927 /* coded mode */
928 if (pixel_ptr/bytes_per_pixel + code0 > lpbi->biWidth)
929 return ICERR_ERROR;
930
931 if (bytes_per_pixel == 1) {
932 BYTE c1 = pi->palette_map[(code1 >> 4)];
933 BYTE c2 = pi->palette_map[(code1 & 0x0F)];
934
935 for (i = 0; i < code0; i++) {
936 if ((i & 1) == 0)
937 lpOut[pixel_ptr++] = c1;
938 else
939 lpOut[pixel_ptr++] = c2;
940 }
941 } else if (bytes_per_pixel == 2) {
942 BYTE hi1 = pi->palette_map[(code1 >> 4) * 2 + 0];
943 BYTE lo1 = pi->palette_map[(code1 >> 4) * 2 + 1];
944
945 BYTE hi2 = pi->palette_map[(code1 & 0x0F) * 2 + 0];
946 BYTE lo2 = pi->palette_map[(code1 & 0x0F) * 2 + 1];
947
948 for (i = 0; i < code0; i++) {
949 if ((i & 1) == 0) {
950 lpOut[pixel_ptr++] = hi1;
951 lpOut[pixel_ptr++] = lo1;
952 } else {
953 lpOut[pixel_ptr++] = hi2;
954 lpOut[pixel_ptr++] = lo2;
955 }
956 }
957 } else {
958 BYTE b1 = pi->palette_map[(code1 >> 4) * 4 + 0];
959 BYTE g1 = pi->palette_map[(code1 >> 4) * 4 + 1];
960 BYTE r1 = pi->palette_map[(code1 >> 4) * 4 + 2];
961
962 BYTE b2 = pi->palette_map[(code1 & 0x0F) * 4 + 0];
963 BYTE g2 = pi->palette_map[(code1 & 0x0F) * 4 + 1];
964 BYTE r2 = pi->palette_map[(code1 & 0x0F) * 4 + 2];
965
966 for (i = 0; i < code0; i++) {
967 if ((i & 1) == 0) {
968 lpOut[pixel_ptr + 0] = b1;
969 lpOut[pixel_ptr + 1] = g1;
970 lpOut[pixel_ptr + 2] = r1;
971 } else {
972 lpOut[pixel_ptr + 0] = b2;
973 lpOut[pixel_ptr + 1] = g2;
974 lpOut[pixel_ptr + 2] = r2;
975 }
976 pixel_ptr += bytes_per_pixel;
977 }
978 }
979 }
980 } while (! bEndFlag);
981
982 return ICERR_OK;
983 }
984
985 static LRESULT MSRLE32_DecompressRLE8(CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
986 LPBYTE lpIn, LPBYTE lpOut)
987 {
988 int bytes_per_pixel;
989 int line_size;
990 int pixel_ptr = 0;
991 BOOL bEndFlag = FALSE;
992
993 assert(pi != NULL);
994 assert(lpbi != NULL && lpbi->biCompression == BI_RGB);
995 assert(lpIn != NULL && lpOut != NULL);
996
997 bytes_per_pixel = (lpbi->biBitCount + 1) / 8;
998 line_size = DIBWIDTHBYTES(*lpbi);
999
1000 do {
1001 BYTE code0, code1;
1002
1003 code0 = *lpIn++;
1004 code1 = *lpIn++;
1005
1006 if (code0 == 0) {
1007 int extra_byte;
1008
1009 switch (code1) {
1010 case 0: /* EOL - end of line */
1011 pixel_ptr = 0;
1012 lpOut += line_size;
1013 break;
1014 case 1: /* EOI - end of image */
1015 bEndFlag = TRUE;
1016 break;
1017 case 2: /* skip */
1018 pixel_ptr += *lpIn++ * bytes_per_pixel;
1019 lpOut += *lpIn++ * line_size;
1020 if (pixel_ptr >= lpbi->biWidth * bytes_per_pixel) {
1021 pixel_ptr = 0;
1022 lpOut += line_size;
1023 }
1024 break;
1025 default: /* absolute mode */
1026 if (pixel_ptr/bytes_per_pixel + code1 > lpbi->biWidth) {
1027 WARN("aborted absolute: (%d=%d/%d+%d) > %ld\n",pixel_ptr/bytes_per_pixel + code1,pixel_ptr,bytes_per_pixel,code1,lpbi->biWidth);
1028 return ICERR_ERROR;
1029 }
1030 extra_byte = code1 & 0x01;
1031
1032 code0 = code1;
1033 while (code0--) {
1034 code1 = *lpIn++;
1035 if (bytes_per_pixel == 1) {
1036 lpOut[pixel_ptr] = pi->palette_map[code1];
1037 } else if (bytes_per_pixel == 2) {
1038 lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 2 + 0];
1039 lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 2 + 1];
1040 } else {
1041 lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 4 + 0];
1042 lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 4 + 1];
1043 lpOut[pixel_ptr + 2] = pi->palette_map[code1 * 4 + 2];
1044 }
1045 pixel_ptr += bytes_per_pixel;
1046 }
1047
1048 /* if the RLE code is odd, skip a byte in the stream */
1049 if (extra_byte)
1050 lpIn++;
1051 };
1052 } else {
1053 /* coded mode */
1054 if (pixel_ptr/bytes_per_pixel + code0 > lpbi->biWidth) {
1055 WARN("aborted coded: (%d=%d/%d+%d) > %ld\n",pixel_ptr/bytes_per_pixel + code1,pixel_ptr,bytes_per_pixel,code1,lpbi->biWidth);
1056 return ICERR_ERROR;
1057 }
1058
1059 if (bytes_per_pixel == 1) {
1060 code1 = pi->palette_map[code1];
1061 while (code0--)
1062 lpOut[pixel_ptr++] = code1;
1063 } else if (bytes_per_pixel == 2) {
1064 BYTE hi = pi->palette_map[code1 * 2 + 0];
1065 BYTE lo = pi->palette_map[code1 * 2 + 1];
1066
1067 while (code0--) {
1068 lpOut[pixel_ptr + 0] = hi;
1069 lpOut[pixel_ptr + 1] = lo;
1070 pixel_ptr += bytes_per_pixel;
1071 }
1072 } else {
1073 BYTE r = pi->palette_map[code1 * 4 + 2];
1074 BYTE g = pi->palette_map[code1 * 4 + 1];
1075 BYTE b = pi->palette_map[code1 * 4 + 0];
1076
1077 while (code0--) {
1078 lpOut[pixel_ptr + 0] = b;
1079 lpOut[pixel_ptr + 1] = g;
1080 lpOut[pixel_ptr + 2] = r;
1081 pixel_ptr += bytes_per_pixel;
1082 }
1083 }
1084 }
1085 } while (! bEndFlag);
1086
1087 return ICERR_OK;
1088 }
1089
1090 /*****************************************************************************/
1091
1092 static CodecInfo* Open(LPICOPEN icinfo)
1093 {
1094 CodecInfo* pi = NULL;
1095
1096 if (icinfo == NULL) {
1097 TRACE("(NULL)\n");
1098 return (LPVOID)0xFFFF0000;
1099 }
1100
1101 if (icinfo->fccType != ICTYPE_VIDEO) return NULL;
1102
1103 TRACE("(%p = {%lu,0x%08lX(%4.4s),0x%08lX(%4.4s),0x%lX,0x%lX,...})\n", icinfo,
1104 icinfo->dwSize, icinfo->fccType, (char*)&icinfo->fccType,
1105 icinfo->fccHandler, (char*)&icinfo->fccHandler,
1106 icinfo->dwVersion,icinfo->dwFlags);
1107
1108 switch (icinfo->fccHandler) {
1109 case FOURCC_RLE:
1110 case FOURCC_RLE4:
1111 case FOURCC_RLE8:
1112 case FOURCC_MRLE:
1113 break;
1114 case mmioFOURCC('m','r','l','e'):
1115 icinfo->fccHandler = FOURCC_MRLE;
1116 break;
1117 default:
1118 WARN("unknown FOURCC = 0x%08lX(%4.4s) !\n",
1119 icinfo->fccHandler,(char*)&icinfo->fccHandler);
1120 return NULL;
1121 }
1122
1123 pi = (CodecInfo*)LocalAlloc(LPTR, sizeof(CodecInfo));
1124
1125 if (pi != NULL) {
1126 pi->fccHandler = icinfo->fccHandler;
1127
1128 pi->bCompress = FALSE;
1129 pi->dwQuality = MSRLE32_DEFAULTQUALITY;
1130 pi->nPrevFrame = -1;
1131 pi->pPrevFrame = pi->pCurFrame = NULL;
1132
1133 pi->bDecompress = FALSE;
1134 pi->palette_map = NULL;
1135 }
1136
1137 icinfo->dwError = (pi != NULL ? ICERR_OK : ICERR_MEMORY);
1138
1139 return pi;
1140 }
1141
1142 static LRESULT Close(CodecInfo *pi)
1143 {
1144 TRACE("(%p)\n", pi);
1145
1146 /* pre-condition */
1147 assert(pi != NULL);
1148
1149 if (pi->pPrevFrame != NULL || pi->pCurFrame != NULL)
1150 CompressEnd(pi);
1151
1152 LocalFree((HLOCAL)pi);
1153 return 1;
1154 }
1155
1156 static LRESULT GetInfo(CodecInfo *pi, ICINFO *icinfo, DWORD dwSize)
1157 {
1158 /* pre-condition */
1159 assert(pi != NULL);
1160
1161 /* check parameters */
1162 if (icinfo == NULL)
1163 return sizeof(ICINFO);
1164 if (dwSize < sizeof(ICINFO))
1165 return 0;
1166
1167 icinfo->dwSize = sizeof(ICINFO);
1168 icinfo->fccType = ICTYPE_VIDEO;
1169 icinfo->fccHandler = (pi != NULL ? pi->fccHandler : FOURCC_MRLE);
1170 icinfo->dwFlags = VIDCF_QUALITY | VIDCF_TEMPORAL | VIDCF_CRUNCH | VIDCF_FASTTEMPORALC;
1171 icinfo->dwVersion = ICVERSION;
1172 icinfo->dwVersionICM = ICVERSION;
1173
1174 LoadStringW(MSRLE32_hModule, IDS_NAME, icinfo->szName, sizeof(icinfo->szName)/sizeof(WCHAR));
1175 LoadStringW(MSRLE32_hModule, IDS_DESCRIPTION, icinfo->szDescription, sizeof(icinfo->szDescription)/sizeof(WCHAR));
1176
1177 return sizeof(ICINFO);
1178 }
1179
1180 static LRESULT SetQuality(CodecInfo *pi, LONG lQuality)
1181 {
1182 /* pre-condition */
1183 assert(pi != NULL);
1184
1185 if (lQuality == -1)
1186 lQuality = MSRLE32_DEFAULTQUALITY;
1187 else if (ICQUALITY_LOW > lQuality || lQuality > ICQUALITY_HIGH)
1188 return ICERR_BADPARAM;
1189
1190 pi->dwQuality = (DWORD)lQuality;
1191
1192 return ICERR_OK;
1193 }
1194
1195 static LRESULT Configure(CodecInfo *pi, HWND hWnd)
1196 {
1197 /* pre-condition */
1198 assert(pi != NULL);
1199
1200 /* FIXME */
1201 return ICERR_OK;
1202 }
1203
1204 static LRESULT About(CodecInfo *pi, HWND hWnd)
1205 {
1206 CHAR szTitle[20];
1207 CHAR szAbout[128];
1208
1209 /* pre-condition */
1210 assert(MSRLE32_hModule != 0);
1211
1212 LoadStringA(MSRLE32_hModule, IDS_NAME, szTitle, sizeof(szTitle));
1213 LoadStringA(MSRLE32_hModule, IDS_ABOUT, szAbout, sizeof(szAbout));
1214
1215 MessageBoxA(hWnd, szAbout, szTitle, MB_OK|MB_ICONINFORMATION);
1216
1217 return ICERR_OK;
1218 }
1219
1220 static LRESULT CompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1221 LPBITMAPINFOHEADER lpbiOut)
1222 {
1223 LRESULT size;
1224
1225 TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1226
1227 /* pre-condition */
1228 assert(pi != NULL);
1229
1230 /* check parameters -- need at least input format */
1231 if (lpbiIn == NULL) {
1232 if (lpbiOut != NULL)
1233 return ICERR_BADPARAM;
1234 return 0;
1235 }
1236
1237 /* handle unsupported input format */
1238 if (CompressQuery(pi, lpbiIn, NULL) != ICERR_OK)
1239 return (lpbiOut == NULL ? ICERR_BADFORMAT : 0);
1240
1241 assert(0 < lpbiIn->biBitCount && lpbiIn->biBitCount <= 8);
1242
1243 switch (pi->fccHandler) {
1244 case FOURCC_RLE4:
1245 size = 1 << 4;
1246 break;
1247 case FOURCC_RLE8:
1248 size = 1 << 8;
1249 break;
1250 case FOURCC_RLE:
1251 case FOURCC_MRLE:
1252 size = (lpbiIn->biBitCount <= 4 ? 1 << 4 : 1 << 8);
1253 break;
1254 default:
1255 return ICERR_ERROR;
1256 }
1257
1258 if (lpbiIn->biClrUsed != 0)
1259 size = lpbiIn->biClrUsed;
1260
1261 size = sizeof(BITMAPINFOHEADER) + size * sizeof(RGBQUAD);
1262
1263 if (lpbiOut != NULL) {
1264 lpbiOut->biSize = sizeof(BITMAPINFOHEADER);
1265 lpbiOut->biWidth = lpbiIn->biWidth;
1266 lpbiOut->biHeight = lpbiIn->biHeight;
1267 lpbiOut->biPlanes = 1;
1268 if (pi->fccHandler == FOURCC_RLE4 ||
1269 lpbiIn->biBitCount <= 4) {
1270 lpbiOut->biCompression = BI_RLE4;
1271 lpbiOut->biBitCount = 4;
1272 } else {
1273 lpbiOut->biCompression = BI_RLE8;
1274 lpbiOut->biBitCount = 8;
1275 }
1276 lpbiOut->biSizeImage = MSRLE32_GetMaxCompressedSize(lpbiOut);
1277 lpbiOut->biXPelsPerMeter = lpbiIn->biXPelsPerMeter;
1278 lpbiOut->biYPelsPerMeter = lpbiIn->biYPelsPerMeter;
1279 if (lpbiIn->biClrUsed == 0)
1280 size = 1<<lpbiIn->biBitCount;
1281 else
1282 size = lpbiIn->biClrUsed;
1283 lpbiOut->biClrUsed = min(size, 1 << lpbiOut->biBitCount);
1284 lpbiOut->biClrImportant = 0;
1285
1286 memcpy((LPBYTE)lpbiOut + lpbiOut->biSize,
1287 (const BYTE*)lpbiIn + lpbiIn->biSize, lpbiOut->biClrUsed * sizeof(RGBQUAD));
1288
1289 return ICERR_OK;
1290 } else
1291 return size;
1292 }
1293
1294 static LRESULT CompressGetSize(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1295 LPCBITMAPINFOHEADER lpbiOut)
1296 {
1297 /* pre-condition */
1298 assert(pi != NULL);
1299
1300 TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1301
1302 /* check parameter -- need at least one format */
1303 if (lpbiIn == NULL && lpbiOut == NULL)
1304 return 0;
1305 /* check if the given format is supported */
1306 if (CompressQuery(pi, lpbiIn, lpbiOut) != ICERR_OK)
1307 return 0;
1308
1309 /* the worst case is coding the complete image in absolute mode. */
1310 if (lpbiIn)
1311 return MSRLE32_GetMaxCompressedSize(lpbiIn);
1312 else
1313 return MSRLE32_GetMaxCompressedSize(lpbiOut);
1314 }
1315
1316 static LRESULT CompressQuery(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1317 LPCBITMAPINFOHEADER lpbiOut)
1318 {
1319 /* pre-condition */
1320 assert(pi != NULL);
1321
1322 /* need at least one format */
1323 if (lpbiIn == NULL && lpbiOut == NULL)
1324 return ICERR_BADPARAM;
1325
1326 /* check input format if given */
1327 if (lpbiIn != NULL) {
1328 if (!isSupportedDIB(lpbiIn))
1329 return ICERR_BADFORMAT;
1330
1331 /* for 4-bit need an even width */
1332 if (lpbiIn->biBitCount <= 4 && (lpbiIn->biWidth % 2))
1333 return ICERR_BADFORMAT;
1334
1335 if (pi->fccHandler == FOURCC_RLE4 && lpbiIn->biBitCount > 4)
1336 return ICERR_UNSUPPORTED;
1337 else if (lpbiIn->biBitCount > 8)
1338 return ICERR_UNSUPPORTED;
1339 }
1340
1341 /* check output format if given */
1342 if (lpbiOut != NULL) {
1343 if (!isSupportedMRLE(lpbiOut))
1344 return ICERR_BADFORMAT;
1345
1346 if (lpbiIn != NULL) {
1347 if (lpbiIn->biWidth != lpbiOut->biWidth)
1348 return ICERR_UNSUPPORTED;
1349 if (lpbiIn->biHeight != lpbiOut->biHeight)
1350 return ICERR_UNSUPPORTED;
1351 if (lpbiIn->biBitCount > lpbiOut->biBitCount)
1352 return ICERR_UNSUPPORTED;
1353 }
1354 }
1355
1356 return ICERR_OK;
1357 }
1358
1359 static LRESULT CompressBegin(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1360 LPCBITMAPINFOHEADER lpbiOut)
1361 {
1362 const RGBQUAD *rgbIn;
1363 const RGBQUAD *rgbOut;
1364 UINT i;
1365 size_t size;
1366
1367 TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1368
1369 /* pre-condition */
1370 assert(pi != NULL);
1371
1372 /* check parameters -- need both formats */
1373 if (lpbiIn == NULL || lpbiOut == NULL)
1374 return ICERR_BADPARAM;
1375 /* And both must be supported */
1376 if (CompressQuery(pi, lpbiIn, lpbiOut) != ICERR_OK)
1377 return ICERR_BADFORMAT;
1378
1379 /* FIXME: cannot compress and decompress at same time! */
1380 if (pi->bDecompress) {
1381 FIXME("cannot compress and decompress at same time!\n");
1382 return ICERR_ERROR;
1383 }
1384
1385 if (pi->bCompress)
1386 CompressEnd(pi);
1387
1388 size = WIDTHBYTES(lpbiOut->biWidth * 16) / 2 * lpbiOut->biHeight;
1389 pi->pPrevFrame = GlobalLock(GlobalAlloc(GPTR, size * sizeof(WORD)));
1390 if (pi->pPrevFrame == NULL)
1391 return ICERR_MEMORY;
1392 pi->pCurFrame = GlobalLock(GlobalAlloc(GPTR, size * sizeof(WORD)));
1393 if (pi->pCurFrame == NULL) {
1394 CompressEnd(pi);
1395 return ICERR_MEMORY;
1396 }
1397 pi->nPrevFrame = -1;
1398 pi->bCompress = TRUE;
1399
1400 rgbIn = (const RGBQUAD*)((const BYTE*)lpbiIn + lpbiIn->biSize);
1401 rgbOut = (const RGBQUAD*)((const BYTE*)lpbiOut + lpbiOut->biSize);
1402
1403 switch (lpbiOut->biBitCount) {
1404 case 4:
1405 case 8:
1406 pi->palette_map = (LPBYTE)LocalAlloc(LPTR, lpbiIn->biClrUsed);
1407 if (pi->palette_map == NULL) {
1408 CompressEnd(pi);
1409 return ICERR_MEMORY;
1410 }
1411
1412 for (i = 0; i < lpbiIn->biClrUsed; i++) {
1413 pi->palette_map[i] = MSRLE32_GetNearestPaletteIndex(lpbiOut->biClrUsed, rgbOut, rgbIn[i]);
1414 }
1415 break;
1416 };
1417
1418 return ICERR_OK;
1419 }
1420
1421 static LRESULT Compress(CodecInfo *pi, ICCOMPRESS* lpic, DWORD dwSize)
1422 {
1423 int i;
1424
1425 TRACE("(%p,%p,%lu)\n",pi,lpic,dwSize);
1426
1427 /* pre-condition */
1428 assert(pi != NULL);
1429
1430 /* check parameters */
1431 if (lpic == NULL || dwSize < sizeof(ICCOMPRESS))
1432 return ICERR_BADPARAM;
1433 if (!lpic->lpbiOutput || !lpic->lpOutput ||
1434 !lpic->lpbiInput || !lpic->lpInput)
1435 return ICERR_BADPARAM;
1436
1437 TRACE("lpic={0x%lX,%p,%p,%p,%p,%p,%p,%ld,%lu,%lu,%p,%p}\n",lpic->dwFlags,lpic->lpbiOutput,lpic->lpOutput,lpic->lpbiInput,lpic->lpInput,lpic->lpckid,lpic->lpdwFlags,lpic->lFrameNum,lpic->dwFrameSize,lpic->dwQuality,lpic->lpbiPrev,lpic->lpPrev);
1438
1439 if (! pi->bCompress) {
1440 LRESULT hr = CompressBegin(pi, lpic->lpbiInput, lpic->lpbiOutput);
1441 if (hr != ICERR_OK)
1442 return hr;
1443 } else if (CompressQuery(pi, lpic->lpbiInput, lpic->lpbiOutput) != ICERR_OK)
1444 return ICERR_BADFORMAT;
1445
1446 if (lpic->lFrameNum >= pi->nPrevFrame + 1) {
1447 /* we continue in the sequence so we need to initialize
1448 * our internal framedata */
1449
1450 computeInternalFrame(pi, lpic->lpbiInput, lpic->lpInput);
1451 } else if (lpic->lFrameNum == pi->nPrevFrame) {
1452 /* Oops, compress same frame again ? Okay, as you wish.
1453 * No need to recompute internal framedata, because we only swapped buffers */
1454 LPWORD pTmp = pi->pPrevFrame;
1455
1456 pi->pPrevFrame = pi->pCurFrame;
1457 pi->pCurFrame = pTmp;
1458 } else if ((lpic->dwFlags & ICCOMPRESS_KEYFRAME) == 0) {
1459 LPWORD pTmp;
1460
1461 WARN(": prev=%ld cur=%ld gone back? -- untested\n",pi->nPrevFrame,lpic->lFrameNum);
1462 if (lpic->lpbiPrev == NULL || lpic->lpPrev == NULL)
1463 return ICERR_GOTOKEYFRAME; /* Need a keyframe if you go back */
1464 if (CompressQuery(pi, lpic->lpbiPrev, lpic->lpbiOutput) != ICERR_OK)
1465 return ICERR_BADFORMAT;
1466
1467 WARN(": prev=%ld cur=%ld compute swapped -- untested\n",pi->nPrevFrame,lpic->lFrameNum);
1468 computeInternalFrame(pi, lpic->lpbiPrev, lpic->lpPrev);
1469
1470 /* swap buffers for current and previous frame */
1471 /* Don't free and alloc new -- costs to much time and they are of equal size ! */
1472 pTmp = pi->pPrevFrame;
1473 pi->pPrevFrame = pi->pCurFrame;
1474 pi->pCurFrame = pTmp;
1475 pi->nPrevFrame = lpic->lFrameNum;
1476 }
1477
1478 for (i = 0; i < 3; i++) {
1479 SetQuality(pi, lpic->dwQuality);
1480
1481 lpic->lpbiOutput->biSizeImage = 0;
1482
1483 if (lpic->lpbiOutput->biBitCount == 4)
1484 MSRLE32_CompressRLE4(pi, lpic->lpbiInput, (LPBYTE)lpic->lpInput,
1485 lpic->lpbiOutput, (LPBYTE)lpic->lpOutput, (lpic->dwFlags & ICCOMPRESS_KEYFRAME) != 0);
1486 else
1487 MSRLE32_CompressRLE8(pi, lpic->lpbiInput, (LPBYTE)lpic->lpInput,
1488 lpic->lpbiOutput, (LPBYTE)lpic->lpOutput, (lpic->dwFlags & ICCOMPRESS_KEYFRAME) != 0);
1489
1490 if (lpic->dwFrameSize == 0 ||
1491 lpic->lpbiOutput->biSizeImage < lpic->dwFrameSize)
1492 break;
1493
1494 if ((*lpic->lpdwFlags & ICCOMPRESS_KEYFRAME) == 0) {
1495 if (lpic->lpbiOutput->biBitCount == 4)
1496 MSRLE32_CompressRLE4(pi, lpic->lpbiInput, (LPBYTE)lpic->lpInput,
1497 lpic->lpbiOutput, (LPBYTE)lpic->lpOutput, TRUE);
1498 else
1499 MSRLE32_CompressRLE8(pi, lpic->lpbiInput, (LPBYTE)lpic->lpInput,
1500 lpic->lpbiOutput, (LPBYTE)lpic->lpOutput, TRUE);
1501
1502 if (lpic->dwFrameSize == 0 ||
1503 lpic->lpbiOutput->biSizeImage < lpic->dwFrameSize) {
1504 WARN("switched to keyframe, was small enough!\n");
1505 *lpic->lpdwFlags |= ICCOMPRESS_KEYFRAME;
1506 *lpic->lpckid = MAKEAVICKID(cktypeDIBbits,
1507 StreamFromFOURCC(*lpic->lpckid));
1508 break;
1509 }
1510 }
1511
1512 if (lpic->dwQuality < 1000)
1513 break;
1514
1515 lpic->dwQuality -= 1000; /* reduce quality by 10% */
1516 }
1517
1518 { /* swap buffer for current and previous frame */
1519 /* Don't free and alloc new -- costs to much time and they are of equal size ! */
1520 register LPWORD pTmp = pi->pPrevFrame;
1521
1522 pi->pPrevFrame = pi->pCurFrame;
1523 pi->pCurFrame = pTmp;
1524 pi->nPrevFrame = lpic->lFrameNum;
1525 }
1526
1527 return ICERR_OK;
1528 }
1529
1530 static LRESULT CompressEnd(CodecInfo *pi)
1531 {
1532 TRACE("(%p)\n",pi);
1533
1534 if (pi != NULL) {
1535 if (pi->pPrevFrame != NULL)
1536 {
1537 GlobalUnlock(GlobalHandle(pi->pPrevFrame));
1538 GlobalFree(GlobalHandle(pi->pPrevFrame));
1539 }
1540 if (pi->pCurFrame != NULL)
1541 {
1542 GlobalUnlock(GlobalHandle(pi->pCurFrame));
1543 GlobalFree(GlobalHandle(pi->pCurFrame));
1544 }
1545 pi->pPrevFrame = NULL;
1546 pi->pCurFrame = NULL;
1547 pi->nPrevFrame = -1;
1548 pi->bCompress = FALSE;
1549 }
1550
1551 return ICERR_OK;
1552 }
1553
1554 static LRESULT DecompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1555 LPBITMAPINFOHEADER lpbiOut)
1556 {
1557 DWORD size;
1558
1559 TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1560
1561 /* pre-condition */
1562 assert(pi != NULL);
1563
1564 if (lpbiIn == NULL)
1565 return (lpbiOut != NULL ? ICERR_BADPARAM : 0);
1566
1567 if (DecompressQuery(pi, lpbiIn, NULL) != ICERR_OK)
1568 return (lpbiOut != NULL ? ICERR_BADFORMAT : 0);
1569
1570 size = lpbiIn->biSize;
1571
1572 if (lpbiIn->biBitCount <= 8)
1573 size += lpbiIn->biClrUsed * sizeof(RGBQUAD);
1574
1575 if (lpbiOut != NULL) {
1576 memcpy(lpbiOut, lpbiIn, size);
1577 lpbiOut->biCompression = BI_RGB;
1578 lpbiOut->biSizeImage = DIBWIDTHBYTES(*lpbiOut) * lpbiOut->biHeight;
1579
1580 return ICERR_OK;
1581 } else
1582 return size;
1583 }
1584
1585 static LRESULT DecompressQuery(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1586 LPCBITMAPINFOHEADER lpbiOut)
1587 {
1588 LRESULT hr = ICERR_OK;
1589
1590 TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1591
1592 /* pre-condition */
1593 assert(pi != NULL);
1594
1595 /* need at least one format */
1596 if (lpbiIn == NULL && lpbiOut == NULL)
1597 return ICERR_BADPARAM;
1598
1599 /* check input format if given */
1600 if (lpbiIn != NULL) {
1601 if (!isSupportedMRLE(lpbiIn))
1602 return ICERR_BADFORMAT;
1603 }
1604
1605 /* check output format if given */
1606 if (lpbiOut != NULL) {
1607 if (!isSupportedDIB(lpbiOut))
1608 hr = ICERR_BADFORMAT;
1609
1610 if (lpbiIn != NULL) {
1611 if (lpbiIn->biWidth != lpbiOut->biWidth)
1612 hr = ICERR_UNSUPPORTED;
1613 if (lpbiIn->biHeight != lpbiOut->biHeight)
1614 hr = ICERR_UNSUPPORTED;
1615 if (lpbiIn->biBitCount > lpbiOut->biBitCount)
1616 hr = ICERR_UNSUPPORTED;
1617 }
1618 }
1619
1620 return hr;
1621 }
1622
1623 static LRESULT DecompressBegin(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1624 LPCBITMAPINFOHEADER lpbiOut)
1625 {
1626 const RGBQUAD *rgbIn;
1627 const RGBQUAD *rgbOut;
1628 UINT i;
1629
1630 TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1631
1632 /* pre-condition */
1633 assert(pi != NULL);
1634
1635 /* check parameters */
1636 if (lpbiIn == NULL || lpbiOut == NULL)
1637 return ICERR_BADPARAM;
1638 if (DecompressQuery(pi, lpbiIn, lpbiOut) != ICERR_OK)
1639 return ICERR_BADFORMAT;
1640
1641 /* FIXME: cannot compress and decompress at a time! */
1642 if (pi->bCompress) {
1643 FIXME("cannot compress and decompress at same time!\n");
1644 return ICERR_ERROR;
1645 }
1646
1647 if (pi->bDecompress)
1648 DecompressEnd(pi);
1649
1650 rgbIn = (const RGBQUAD*)((const BYTE*)lpbiIn + lpbiIn->biSize);
1651 rgbOut = (const RGBQUAD*)((const BYTE*)lpbiOut + lpbiOut->biSize);
1652
1653 switch (lpbiOut->biBitCount) {
1654 case 4:
1655 case 8:
1656 pi->palette_map = (LPBYTE)LocalAlloc(LPTR, lpbiIn->biClrUsed);
1657 if (pi->palette_map == NULL)
1658 return ICERR_MEMORY;
1659
1660 for (i = 0; i < lpbiIn->biClrUsed; i++) {
1661 pi->palette_map[i] = MSRLE32_GetNearestPaletteIndex(lpbiOut->biClrUsed, rgbOut, rgbIn[i]);
1662 }
1663 break;
1664 case 15:
1665 case 16:
1666 pi->palette_map = (LPBYTE)LocalAlloc(LPTR, lpbiIn->biClrUsed * 2);
1667 if (pi->palette_map == NULL)
1668 return ICERR_MEMORY;
1669
1670 for (i = 0; i < lpbiIn->biClrUsed; i++) {
1671 WORD color;
1672
1673 if (lpbiOut->biBitCount == 15)
1674 color = ((rgbIn[i].rgbRed >> 3) << 10)
1675 | ((rgbIn[i].rgbGreen >> 3) << 5) | (rgbIn[i].rgbBlue >> 3);
1676 else
1677 color = ((rgbIn[i].rgbRed >> 3) << 11)
1678 | ((rgbIn[i].rgbGreen >> 3) << 5) | (rgbIn[i].rgbBlue >> 3);
1679
1680 pi->palette_map[i * 2 + 1] = color >> 8;
1681 pi->palette_map[i * 2 + 0] = color & 0xFF;
1682 };
1683 break;
1684 case 24:
1685 case 32:
1686 pi->palette_map = (LPBYTE)LocalAlloc(LPTR, lpbiIn->biClrUsed * sizeof(RGBQUAD));
1687 if (pi->palette_map == NULL)
1688 return ICERR_MEMORY;
1689 memcpy(pi->palette_map, rgbIn, lpbiIn->biClrUsed * sizeof(RGBQUAD));
1690 break;
1691 };
1692
1693 pi->bDecompress = TRUE;
1694
1695 return ICERR_OK;
1696 }
1697
1698 static LRESULT Decompress(CodecInfo *pi, ICDECOMPRESS *pic, DWORD dwSize)
1699 {
1700 TRACE("(%p,%p,%lu)\n",pi,pic,dwSize);
1701
1702 /* pre-condition */
1703 assert(pi != NULL);
1704
1705 /* check parameters */
1706 if (pic == NULL)
1707 return ICERR_BADPARAM;
1708 if (pic->lpbiInput == NULL || pic->lpInput == NULL ||
1709 pic->lpbiOutput == NULL || pic->lpOutput == NULL)
1710 return ICERR_BADPARAM;
1711
1712 /* check formats */
1713 if (! pi->bDecompress) {
1714 LRESULT hr = DecompressBegin(pi, pic->lpbiInput, pic->lpbiOutput);
1715 if (hr != ICERR_OK)
1716 return hr;
1717 } else if (DecompressQuery(pi, pic->lpbiInput, pic->lpbiOutput) != ICERR_OK)
1718 return ICERR_BADFORMAT;
1719
1720 assert(pic->lpbiInput->biWidth == pic->lpbiOutput->biWidth);
1721 assert(pic->lpbiInput->biHeight == pic->lpbiOutput->biHeight);
1722
1723 pic->lpbiOutput->biSizeImage = DIBWIDTHBYTES(*pic->lpbiOutput) * pic->lpbiOutput->biHeight;
1724 if (pic->lpbiInput->biBitCount == 4)
1725 return MSRLE32_DecompressRLE4(pi, pic->lpbiOutput, pic->lpInput, pic->lpOutput);
1726 else
1727 return MSRLE32_DecompressRLE8(pi, pic->lpbiOutput, pic->lpInput, pic->lpOutput);
1728 }
1729
1730 static LRESULT DecompressEnd(CodecInfo *pi)
1731 {
1732 TRACE("(%p)\n",pi);
1733
1734 /* pre-condition */
1735 assert(pi != NULL);
1736
1737 pi->bDecompress = FALSE;
1738
1739 if (pi->palette_map != NULL) {
1740 LocalFree((HLOCAL)pi->palette_map);
1741 pi->palette_map = NULL;
1742 }
1743
1744 return ICERR_OK;
1745 }
1746
1747 static LRESULT DecompressGetPalette(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
1748 LPBITMAPINFOHEADER lpbiOut)
1749 {
1750 int size;
1751
1752 TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
1753
1754 /* pre-condition */
1755 assert(pi != NULL);
1756
1757 /* check parameters */
1758 if (lpbiIn == NULL || lpbiOut == NULL)
1759 return ICERR_BADPARAM;
1760
1761 if (DecompressQuery(pi, lpbiIn, lpbiOut) != ICERR_OK)
1762 return ICERR_BADFORMAT;
1763
1764 if (lpbiOut->biBitCount > 8)
1765 return ICERR_ERROR;
1766
1767 if (lpbiIn->biBitCount <= 8) {
1768 if (lpbiIn->biClrUsed > 0)
1769 size = lpbiIn->biClrUsed;
1770 else
1771 size = (1 << lpbiIn->biBitCount);
1772
1773 lpbiOut->biClrUsed = size;
1774
1775 memcpy((LPBYTE)lpbiOut + lpbiOut->biSize, (const BYTE*)lpbiIn + lpbiIn->biSize, size * sizeof(RGBQUAD));
1776 } /* else could never occur ! */
1777
1778 return ICERR_OK;
1779 }
1780
1781 /* DriverProc - entry point for an installable driver */
1782 LRESULT CALLBACK MSRLE32_DriverProc(DWORD_PTR dwDrvID, HDRVR hDrv, UINT uMsg,
1783 LPARAM lParam1, LPARAM lParam2)
1784 {
1785 CodecInfo *pi = (CodecInfo*)dwDrvID;
1786
1787 TRACE("(%lx,%p,0x%04X,0x%08lX,0x%08lX)\n", dwDrvID, hDrv, uMsg, lParam1, lParam2);
1788
1789 switch (uMsg) {
1790 /* standard driver messages */
1791 case DRV_LOAD:
1792 return DRVCNF_OK;
1793 case DRV_OPEN:
1794 return (LRESULT)Open((ICOPEN*)lParam2);
1795 case DRV_CLOSE:
1796 if (dwDrvID != 0xFFFF0000 && (LPVOID)dwDrvID != NULL)
1797 Close(pi);
1798 return DRVCNF_OK;
1799 case DRV_ENABLE:
1800 case DRV_DISABLE:
1801 return DRVCNF_OK;
1802 case DRV_FREE:
1803 return DRVCNF_OK;
1804 case DRV_QUERYCONFIGURE:
1805 return DRVCNF_CANCEL; /* FIXME */
1806 case DRV_CONFIGURE:
1807 return DRVCNF_OK; /* FIXME */
1808 case DRV_INSTALL:
1809 case DRV_REMOVE:
1810 return DRVCNF_OK;
1811
1812 /* installable compression manager messages */
1813 case ICM_CONFIGURE:
1814 FIXME("ICM_CONFIGURE (%ld)\n",lParam1);
1815 if (lParam1 == -1)
1816 return ICERR_UNSUPPORTED; /* FIXME */
1817 else
1818 return Configure(pi, (HWND)lParam1);
1819 case ICM_ABOUT:
1820 if (lParam1 == -1)
1821 return ICERR_OK;
1822 else
1823 return About(pi, (HWND)lParam1);
1824 case ICM_GETSTATE:
1825 case ICM_SETSTATE:
1826 return 0; /* no state */
1827 case ICM_GETINFO:
1828 return GetInfo(pi, (ICINFO*)lParam1, (DWORD)lParam2);
1829 case ICM_GETDEFAULTQUALITY:
1830 if ((LPVOID)lParam1 != NULL) {
1831 *((LPDWORD)lParam1) = MSRLE32_DEFAULTQUALITY;
1832 return ICERR_OK;
1833 }
1834 break;
1835 case ICM_GETQUALITY:
1836 if ((LPVOID)lParam1 != NULL) {
1837 *((LPDWORD)lParam1) = pi->dwQuality;
1838 return ICERR_OK;
1839 }
1840 break;
1841 case ICM_SETQUALITY:
1842 return SetQuality(pi, *(LPLONG)lParam1);
1843 case ICM_COMPRESS_GET_FORMAT:
1844 return CompressGetFormat(pi, (LPCBITMAPINFOHEADER)lParam1,
1845 (LPBITMAPINFOHEADER)lParam2);
1846 case ICM_COMPRESS_GET_SIZE:
1847 return CompressGetSize(pi, (LPCBITMAPINFOHEADER)lParam1,
1848 (LPCBITMAPINFOHEADER)lParam2);
1849 case ICM_COMPRESS_QUERY:
1850 return CompressQuery(pi, (LPCBITMAPINFOHEADER)lParam1,
1851 (LPCBITMAPINFOHEADER)lParam2);
1852 case ICM_COMPRESS_BEGIN:
1853 return CompressBegin(pi, (LPCBITMAPINFOHEADER)lParam1,
1854 (LPCBITMAPINFOHEADER)lParam2);
1855 case ICM_COMPRESS:
1856 return Compress(pi, (ICCOMPRESS*)lParam1, (DWORD)lParam2);
1857 case ICM_COMPRESS_END:
1858 return CompressEnd(pi);
1859 case ICM_DECOMPRESS_GET_FORMAT:
1860 return DecompressGetFormat(pi, (LPCBITMAPINFOHEADER)lParam1,
1861 (LPBITMAPINFOHEADER)lParam2);
1862 case ICM_DECOMPRESS_QUERY:
1863 return DecompressQuery(pi, (LPCBITMAPINFOHEADER)lParam1,
1864 (LPCBITMAPINFOHEADER)lParam2);
1865 case ICM_DECOMPRESS_BEGIN:
1866 return DecompressBegin(pi, (LPCBITMAPINFOHEADER)lParam1,
1867 (LPCBITMAPINFOHEADER)lParam2);
1868 case ICM_DECOMPRESS:
1869 return Decompress(pi, (ICDECOMPRESS*)lParam1, (DWORD)lParam2);
1870 case ICM_DECOMPRESS_END:
1871 return DecompressEnd(pi);
1872 case ICM_DECOMPRESS_SET_PALETTE:
1873 FIXME("(...) -> SetPalette(%p,%p,%p): stub!\n", pi, (LPVOID)lParam1, (LPVOID)lParam2);
1874 return ICERR_UNSUPPORTED;
1875 case ICM_DECOMPRESS_GET_PALETTE:
1876 return DecompressGetPalette(pi, (LPBITMAPINFOHEADER)lParam1,
1877 (LPBITMAPINFOHEADER)lParam2);
1878 case ICM_GETDEFAULTKEYFRAMERATE:
1879 if ((LPVOID)lParam1 != NULL)
1880 *(LPDWORD)lParam1 = 15;
1881 return ICERR_OK;
1882 default:
1883 if (uMsg < DRV_USER)
1884 return DefDriverProc(dwDrvID, hDrv, uMsg, lParam1, lParam2);
1885 else
1886 FIXME("Unknown message uMsg=0x%08X lParam1=0x%08lX lParam2=0x%08lX\n",uMsg,lParam1,lParam2);
1887 };
1888
1889 return ICERR_UNSUPPORTED;
1890 }
1891
1892 /* DllMain - library initialization code */
1893 BOOL WINAPI DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved)
1894 {
1895 TRACE("(%p,%ld,%p)\n",(LPVOID)hModule,dwReason,lpReserved);
1896
1897 switch (dwReason) {
1898 case DLL_PROCESS_ATTACH:
1899 DisableThreadLibraryCalls(hModule);
1900 MSRLE32_hModule = hModule;
1901 break;
1902
1903 case DLL_PROCESS_DETACH:
1904 break;
1905 }
1906
1907 return TRUE;
1908 }
useful hacks and other patches not (yet) suitable for mainline