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