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