RLE decoder

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Michael Günnewig submitted this RLE decoder to rewind... so wine can
benefit from it

Alexandre, the patch implies that the dlls/msrle32 directory is removed
and this new stuff is installed in dlls/msvideo/msrle32 instead
I think it's better to have video codecs under the dlls/msvideo dir (as
we have audio codecs under dlls/msacm)

A+
Name:          msrle
ChangeLog:     Michael Günnewig: implemented the MS RLE video codec
License:       X11
GenDate:       2002/10/07 20:57:42 UTC
ModifiedFiles: configure.ac dlls/Makefile.in
AddedFiles:    dlls/msvideom/msrle32/Makefile.in dlls/msvideo/msrle32/.cvsignore dlls/msvideo/msrle32/msrle32.c dlls/msvideo/msrle32/msrle32.spec dlls/msvideo/msrle32/msrle_private.h dlls/msvideo/msrle32/rsrc.rc dlls/msvideo/msrle32/msrle_En.rc dlls/msvideo/msrle32/msrle_De.rc dlls/msvideo/msrle32/msrle_Fr.rc
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/configure.ac,v
retrieving revision 1.81
diff -u -u -r1.81 configure.ac
--- configure.ac	2 Oct 2002 19:58:27 -0000	1.81
+++ configure.ac	5 Oct 2002 07:24:30 -0000
@@ -1412,10 +1413,10 @@
 dlls/msimg32/Makefile
 dlls/msisys/Makefile
 dlls/msnet32/Makefile
-dlls/msrle32/Makefile
 dlls/msvcrt/Makefile
 dlls/msvcrt20/Makefile
 dlls/msvideo/Makefile
+dlls/msvideo/msrle32/Makefile
 dlls/netapi32/Makefile
 dlls/netapi32/tests/Makefile
 dlls/ntdll/Makefile
Index: dlls/Makefile.in
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/dlls/Makefile.in,v
retrieving revision 1.153
diff -u -u -r1.153 Makefile.in
--- dlls/Makefile.in	2 Oct 2002 02:34:10 -0000	1.153
+++ dlls/Makefile.in	5 Oct 2002 07:27:31 -0000
 	msisys \
 	msnet32 \
-	msrle32 \
 	msvcrt \
 	msvcrt20 \
 	msvideo \
+	msvideo/msrle32 \
 	netapi32 \
 	ntdll \
 	odbc32 \
@@ -396,8 +401,8 @@
 msnet32.dll$(DLLEXT): msnet32/msnet32.dll$(DLLEXT)
 	$(RM) $@ && $(LN_S) msnet32/msnet32.dll$(DLLEXT) $@
 
-msrle32.dll$(DLLEXT): msrle32/msrle32.dll$(DLLEXT)
-	$(RM) $@ && $(LN_S) msrle32/msrle32.dll$(DLLEXT) $@
+msrle32.dll$(DLLEXT): msvideo/msrle32/msrle32.dll$(DLLEXT)
+	$(RM) $@ && $(LN_S) msvideo/msrle32/msrle32.dll$(DLLEXT) $@
 
 msvcrt.dll$(DLLEXT): msvcrt/msvcrt.dll$(DLLEXT)
 	$(RM) $@ && $(LN_S) msvcrt/msvcrt.dll$(DLLEXT) $@
@@ -605,7 +611,7 @@
 msimg32/msimg32.dll$(DLLEXT): msimg32
 msisys/msisys.ocx$(DLLEXT): msisys
 msnet32/msnet32.dll$(DLLEXT): msnet32
-msrle32/msrle32.dll$(DLLEXT): msrle32
+msvideo/msrle32/msrle32.dll$(DLLEXT): msvideo/msrle32
 msvcrt/msvcrt.dll$(DLLEXT): msvcrt
 msvcrt20/msvcrt20.dll$(DLLEXT): msvcrt20
 msvideo/msvfw32.dll$(DLLEXT): msvideo
@@ -704,7 +711,7 @@
 msimg32/__install__: msimg32.dll$(DLLEXT)
 msisys/__install__: msisys.ocx$(DLLEXT)
 msnet32/__install__: msnet32.dll$(DLLEXT)
-msrle32/__install__: msrle32.dll$(DLLEXT)
+msvideo/msrle32/__install__: msrle32.dll$(DLLEXT)
 msvcrt/__install__: msvcrt.dll$(DLLEXT)
 msvcrt20/__install__: msvcrt20.dll$(DLLEXT)
 msvideo/__install__: msvfw32.dll$(DLLEXT)
@@ -799,9 +807,9 @@
 msimg32:  kernel32.dll$(DLLEXT)
 msisys:   kernel32.dll$(DLLEXT)
 msnet32:  kernel32.dll$(DLLEXT)
-msrle32:  kernel32.dll$(DLLEXT)
 msvcrt20: msvcrt.dll$(DLLEXT)
 msvcrt:   kernel32.dll$(DLLEXT) ntdll.dll$(DLLEXT)
+msvideo/msrle32: kernel32.dll$(DLLEXT) user32.dll$(DLLEXT) winmm.dll$(DLLEXT)
 msvideo:  winmm.dll$(DLLEXT) comctl32.dll$(DLLEXT) version.dll$(DLLEXT) user32.dll$(DLLEXT) \
           gdi32.dll$(DLLEXT) kernel32.dll$(DLLEXT)
 netapi32: advapi32.dll$(DLLEXT) kernel32.dll$(DLLEXT)
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/msvideo/msrle32/.cvsignore	Mon Oct  7 22:12:49 2002
@@ -0,0 +1,3 @@
+Makefile
+msrle32.dll.dbg.c
+msrle32.spec.c
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/msvideo/msrle32/msrle32.c	Mon Oct  7 22:08:20 2002
@@ -0,0 +1,1871 @@
+/*
+ * Copyright 2002 Michael Günnewig
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/* TODO:
+ *   - compression of RLE4 is buggy -- see FIXME's
+ *   - many improvements possible
+ *   - implement DecompressSetPalette? -- does we need it for anything?
+ */
+
+#include <assert.h>
+
+#include "msrle_private.h"
+
+#include "winnls.h"
+#include "winuser.h"
+#include "windowsx.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msrle32);
+
+static HINSTANCE MSRLE32_hModule = 0;
+
+#define ABS(a)                ((a) < 0 ? -(a) : (a))
+#define SQR(a)                ((a) * (a))
+
+#define QUALITY_to_DIST(q)    (ICQUALITY_HIGH - q)
+inline WORD ColorCmp(WORD clr1, WORD clr2)
+{
+  register UINT a = (clr1-clr2);
+  return SQR(a);
+}
+inline WORD Intensity(RGBQUAD clr)
+{
+  return (30 * clr.rgbRed + 59 * clr.rgbGreen + 11 * clr.rgbBlue)/4;
+}
+
+#define GetRawPixel(lpbi,lp,x) \
+  ((lpbi)->biBitCount == 1 ? ((lp)[(x)/8] >> (8 - (x)%8)) & 1 : \
+   ((lpbi)->biBitCount == 4 ? ((lp)[(x)/2] >> (4 * (1 - (x)%2))) & 15 : lp[x]))
+
+/*****************************************************************************/
+
+/* utility functions */
+static BOOL    isSupportedDIB(LPCBITMAPINFOHEADER lpbi);
+static BOOL    isSupportedMRLE(LPCBITMAPINFOHEADER lpbi);
+static void    LoadWideString(UINT id, LPWSTR str, INT len);
+static BYTE    MSRLE32_GetNearestPaletteIndex(UINT count, const RGBQUAD *clrs, RGBQUAD clr);
+
+/* compression functions */
+static void    computeInternalFrame(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn, LPBYTE lpIn);
+static LONG    MSRLE32_GetMaxCompressedSize(LPCBITMAPINFOHEADER lpbi);
+static LRESULT MSRLE32_CompressRLE4(CodecInfo *pi, LPBITMAPINFOHEADER lpbiIn, LPBYTE lpIn, LPBITMAPINFOHEADER lpbiOut, LPBYTE lpOut, BOOL isKey);
+static LRESULT MSRLE32_CompressRLE8(CodecInfo *pi, LPBITMAPINFOHEADER lpbiIn, LPBYTE lpIn, LPBITMAPINFOHEADER lpbiOut, LPBYTE lpOut, BOOL isKey);
+
+/* decompression functions */
+static LRESULT MSRLE32_DecompressRLE4(CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
+				      LPBYTE lpIn, LPBYTE lpOut);
+static LRESULT MSRLE32_DecompressRLE8(CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
+				      LPBYTE lpIn, LPBYTE lpOut);
+
+/* API functions */
+static LRESULT CompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+				 LPBITMAPINFOHEADER lpbiOut);
+static LRESULT CompressGetSize(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+			       LPCBITMAPINFOHEADER lpbiOut);
+static LRESULT CompressQuery(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+			     LPCBITMAPINFOHEADER lpbiOut);
+static LRESULT CompressBegin(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+			     LPCBITMAPINFOHEADER lpbiOut);
+static LRESULT Compress(CodecInfo *pi, ICCOMPRESS* lpic, DWORD dwSize);
+static LRESULT CompressEnd(CodecInfo *pi);
+
+static LRESULT DecompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+				   LPBITMAPINFOHEADER lpbiOut);
+static LRESULT DecompressQuery(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+			       LPCBITMAPINFOHEADER lpbiOut);
+static LRESULT DecompressBegin(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+			       LPCBITMAPINFOHEADER lpbiOut);
+static LRESULT Decompress(CodecInfo *pi, ICDECOMPRESS *pic, DWORD dwSize);
+static LRESULT DecompressEnd(CodecInfo *pi);
+static LRESULT DecompressGetPalette(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+				    LPBITMAPINFOHEADER lpbiOut);
+
+/*****************************************************************************/
+
+static void LoadWideString(UINT id, LPWSTR str, INT len)
+{
+  char szTemp[80];
+
+  LoadStringA(MSRLE32_hModule, id, szTemp, sizeof(szTemp));
+  MultiByteToWideChar(CP_ACP, 0, szTemp, -1, str, len);
+}
+
+static BOOL isSupportedMRLE(LPCBITMAPINFOHEADER lpbi)
+{
+  /* pre-conditions */
+  assert(lpbi != NULL);
+
+  if (lpbi->biSize < sizeof(BITMAPINFOHEADER) || \
+      lpbi->biPlanes != 1)
+    return FALSE;
+
+  if (lpbi->biCompression == BI_RLE4) {
+    if (lpbi->biBitCount != 4 || \
+	(lpbi->biWidth % 2) != 0)
+      return FALSE;
+  } else if (lpbi->biCompression == BI_RLE8) {
+    if (lpbi->biBitCount != 8)
+      return FALSE;
+  } else
+    return FALSE;
+
+  return TRUE;
+}
+
+static BOOL  isSupportedDIB(LPCBITMAPINFOHEADER lpbi)
+{
+  /* pre-conditions */
+  assert(lpbi != NULL);
+
+  /* check structure version/planes/compression */
+  if (lpbi->biSize < sizeof(BITMAPINFOHEADER) ||
+      lpbi->biPlanes != 1)
+    return FALSE;
+  if (lpbi->biCompression != BI_RGB &&
+      lpbi->biCompression != BI_BITFIELDS)
+    return FALSE;
+
+  /* check bit-depth */
+  if (lpbi->biBitCount != 1 &&
+      lpbi->biBitCount != 4 &&
+      lpbi->biBitCount != 8 &&
+      lpbi->biBitCount != 15 &&
+      lpbi->biBitCount != 16 &&
+      lpbi->biBitCount != 24 &&
+      lpbi->biBitCount != 32)
+    return FALSE;
+
+  /* check for size(s) */
+  if (!lpbi->biWidth || !lpbi->biHeight)
+    return FALSE; /* image with zero size, makes no sense so error ! */
+  if (DIBWIDTHBYTES(*lpbi) * lpbi->biHeight >= (1UL << 31) - 1)
+    return FALSE; /* image too big ! */
+
+  /* check for non existing colortable for hi- and true-color DIB's */
+  if (lpbi->biBitCount >= 15 && lpbi->biClrUsed > 0)
+    return FALSE;
+
+  return TRUE;
+}
+
+static BYTE MSRLE32_GetNearestPaletteIndex(UINT count, const RGBQUAD *clrs, RGBQUAD clr)
+{
+  INT  diff = 0x00FFFFFF;
+  UINT i;
+  UINT index = 0;
+
+  /* pre-conditions */
+  assert(clrs != NULL);
+
+  for (i = 0; i < count; i++) {
+    int r = ((int)clrs[i].rgbRed   - (int)clr.rgbRed);
+    int g = ((int)clrs[i].rgbGreen - (int)clr.rgbGreen);
+    int b = ((int)clrs[i].rgbBlue  - (int)clr.rgbBlue);
+
+    r = r*r + g*g + b*b;
+
+    if (r < diff) {
+      index = i;
+      diff  = r;
+      if (diff == 0)
+	break;
+    }
+  }
+
+  return index;
+}
+
+/*****************************************************************************/
+
+void computeInternalFrame(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn, LPBYTE lpIn)
+{
+  WORD   wIntensityTbl[256];
+  LONG   lInLine, lOutLine;
+  LPWORD lpOut;
+  int i, y;
+
+  /* pre-conditions */
+  assert(pi != NULL && lpbiIn != NULL && lpIn != NULL);
+  assert(pi->pCurFrame != NULL);
+
+  lInLine  = DIBWIDTHBYTES(*lpbiIn);
+  lOutLine = WIDTHBYTES(lpbiIn->biWidth * 8*sizeof(WORD)) / 2;
+  lpOut    = pi->pCurFrame;
+
+  assert(lpbiIn->biClrUsed != 0);
+
+  {
+    const RGBQUAD *lp = (LPRGBQUAD)((LPBYTE)lpbiIn + lpbiIn->biSize);
+
+    for (i = 0; i < lpbiIn->biClrUsed; i++)
+      wIntensityTbl[i] = Intensity(lp[i]);
+  }
+
+  for (y = 0; y < lpbiIn->biHeight; y++) {
+    int x;
+
+    switch (lpbiIn->biBitCount) {
+    case 1:
+      for (x = 0; x < lpbiIn->biWidth; x += 8) {
+	for (i = 0; i < 7; i++)
+	  lpOut[x + i] = wIntensityTbl[(lpIn[x] >> (7 - i)) & 1];
+      }
+      break;
+    case 4:
+      for (x = 0; x < lpbiIn->biWidth; x += 2) {
+	lpOut[x + 0] = wIntensityTbl[(lpIn[x] >> 4)];
+	lpOut[x + 1] = wIntensityTbl[(lpIn[x] & 0x0F)];
+      }
+      break;
+    case 8:
+      for (x = 0; x < lpbiIn->biWidth; x++)
+	lpOut[x] = wIntensityTbl[lpIn[x]];
+      break;
+    }
+
+    lpIn  += lInLine;
+    lpOut += lOutLine;
+  }
+}
+
+static LONG MSRLE32_GetMaxCompressedSize(LPCBITMAPINFOHEADER lpbi)
+{
+  LONG a, b, size;
+
+  /* pre-condition */
+  assert(lpbi != NULL);
+
+  a = lpbi->biWidth / 255;
+  b = lpbi->biWidth % 255;
+  if (lpbi->biBitCount <= 4) {
+    a /= 2;
+    b /= 2;
+  }
+
+  size = (2 + a * (2 + ((a + 2) & ~2)) + b * (2 + ((b + 2) & ~2)));
+  return size * lpbi->biHeight;
+}
+
+/* lpP => current  pos in previous frame
+ * lpA => previous pos in current  frame
+ * lpB => current  pos in current  frame
+ */
+static INT countDiffRLE4(LPWORD lpP, LPWORD lpA, LPWORD lpB, INT pos, LONG lDist, LONG width)
+{
+  INT  count;
+  WORD clr1, clr2;
+
+  /* pre-conditions */
+  assert(lpA && lpB && lDist >= 0 && width > 0);
+
+  if (pos >= width)
+    return 0;
+  if (pos+1 == width)
+    return 1;
+
+  clr1 = lpB[pos++];
+  clr2 = lpB[pos];
+
+  count = 2;
+  while (pos + 1 < width) {
+    WORD clr3, clr4;
+
+    clr3 = lpB[++pos];
+    if (pos + 1 >= width)
+      return count + 1;
+
+    clr4 = lpB[++pos];
+    if (ColorCmp(clr1, clr3) <= lDist &&
+	ColorCmp(clr2, clr4) <= lDist) {
+      /* diff at end? -- look-ahead for atleast ?? more encodable pixel */
+
+      /* FIXME */
+
+      return count;
+    } else if (lpP && ColorCmp(lpP[pos], lpB[pos]) <= lDist) {
+      /* 'compare' with previous frame for end of diff */
+      INT count2 = 0;
+
+      /* FIXME */
+
+      if (count2 >= 4)
+	return count;
+
+      pos -= count2;
+    }
+
+    count += 2;
+    clr1 = clr3;
+    clr2 = clr4;
+  }
+
+  return count;
+}
+
+/* lpP => current  pos in previous frame
+ * lpA => previous pos in current  frame
+ * lpB => current  pos in current  frame
+ */
+static INT countDiffRLE8(LPWORD lpP, LPWORD lpA, LPWORD lpB, INT pos, LONG lDist, LONG width)
+{
+  INT count;
+
+  for (count = 0; pos < width; pos++, count++) {
+    if (ColorCmp(lpA[pos], lpB[pos]) <= lDist) {
+      /* diff at end? -- look-ahead for atleast one more encodable pixel */
+      if (pos + 1 < width && ColorCmp(lpA[pos], lpB[pos+1]) <= lDist)
+	return count;
+    } else if (lpP != NULL && ColorCmp(lpP[pos], lpB[pos]) <= lDist) {
+      /* 'compare' with previous frame for end of diff */
+      INT count2 = 0;
+
+      for (count2 = 0, pos++; pos < width && count2 <= 5; pos++, count2++) {
+	if (ColorCmp(lpP[pos], lpB[pos]) > lDist)
+	  break;
+      }
+      if (count2 > 4)
+	return count;
+
+      pos -= count2;
+    }
+  }
+
+  return count;
+}
+
+static INT MSRLE32_CompressRLE4Line(CodecInfo *pi, LPWORD lpP, LPWORD lpC, LPCBITMAPINFOHEADER lpbi, BYTE *lpIn, LONG lDist, INT x, LPBYTE *ppOut, DWORD *lpSizeImage)
+{
+  LPBYTE lpOut = *ppOut;
+  INT    count, pos;
+  WORD   clr1, clr2;
+
+  /* try to encode as many pixel as possible */
+  count = 1;
+  pos   = x;
+  clr1  = lpC[pos++];
+  if (pos < lpbi->biWidth) {
+    clr2 = lpC[pos];
+    for (++count; pos + 1 < lpbi->biWidth; ) {
+      ++pos;
+      if (ColorCmp(clr1, lpC[pos]) > lDist)
+	break;
+      count++;
+      if (pos + 1 >= lpbi->biWidth)
+	break;
+      ++pos;
+      if (ColorCmp(clr2, lpC[pos]) > lDist)
+	break;
+      count++;
+    }
+  }
+
+  if (count < 4) {
+    /* add some pixel for absoluting if possible */
+    count += countDiffRLE4(lpP, lpC - 1, lpC, pos-1, lDist, lpbi->biWidth);
+
+    /* check for near end of line */
+    if (x + count > lpbi->biWidth)
+      count = lpbi->biWidth - x;
+
+    /* absolute pixel(s) in groups of atleast 3 and maximal 254 pixel */
+    while (count > 2) {
+      INT  i;
+      INT  size       = min(count, 254);
+      BOOL extra_byte = size % 2;
+
+      *lpSizeImage += 2 + size + extra_byte;
+      count -= size;
+      *lpOut++ = 0;
+      *lpOut++ = size;
+      for (i = 0; i < size; i += 2) {
+	clr1 = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
+	x++;
+	if (i + 1 < size) {
+	  clr2 = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
+	  x++;
+	} else
+	  clr2 = 0;
+
+	*lpOut++ = (clr1 << 4) | clr2;
+      }
+      if (extra_byte)
+	*lpOut++ = 0;
+    }
+
+    if (count > 0) {
+      /* too less for absoluting so we must encode them */
+      assert(count <= 2);
+
+      *lpSizeImage += 2;
+      clr1 = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
+      x++;
+      if (count == 2) {
+	clr2 = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
+	x++;
+      } else
+	clr2 = 0;
+      *lpOut++ = count;
+      *lpOut++ = (clr1 << 4) | clr2;
+    }
+  } else {
+    /* encode count pixel(s) */
+    clr1 = ((pi->palette_map[GetRawPixel(lpbi,lpIn,x)] << 4) |
+	    pi->palette_map[GetRawPixel(lpbi,lpIn,x + 1)]);
+
+    x += count;
+    while (count > 0) {
+      INT size = min(count, 254);
+
+      *lpSizeImage += 2;
+      count    -= size;
+      *lpOut++  = size;
+      *lpOut++  = clr1;
+    }
+  }
+
+  *ppOut = lpOut;
+
+  return x;
+}
+
+static INT MSRLE32_CompressRLE8Line(CodecInfo *pi, LPWORD lpP, LPWORD lpC, LPCBITMAPINFOHEADER lpbi, BYTE *lpIn, LONG lDist, INT x, LPBYTE *ppOut, DWORD *lpSizeImage)
+{
+  LPBYTE lpOut = *ppOut;
+  INT    count, pos;
+  WORD   clr;
+
+  assert(lpbi->biBitCount <= 8);
+  assert(lpbi->biCompression == BI_RGB);
+
+  /* try to encode as much as possible */
+  pos = x;
+  clr = lpC[pos++];
+  for (count = 1; pos < lpbi->biWidth; count++) {
+    if (ColorCmp(clr, lpC[pos++]) > lDist)
+      break;
+  }
+
+  if (count < 2) {
+    /* add some more pixels for absoluting if possible */
+    count += countDiffRLE8(lpP, lpC - 1, lpC, pos-1, lDist, lpbi->biWidth);
+
+    /* check for over end of line */
+    if (x + count > lpbi->biWidth)
+      count = lpbi->biWidth - x;
+
+    /* absolute pixel(s) in groups of atleast 3 and maximal 255 pixels */
+    while (count > 2) {
+      INT  i;
+      INT  size       = min(count, 255);
+      BOOL extra_byte = size % 2;
+
+      *lpSizeImage += 2 + size + extra_byte;
+      count -= size;
+      *lpOut++ = 0;
+      *lpOut++ = size;
+      for (i = 0; i < size; i++) {
+	*lpOut++ = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
+	x++;
+      }
+      if (extra_byte)
+	*lpOut++ = 0;
+    }
+    if (count > 0) {
+      /* too less for absoluting so we must encode them even if it's expensive! */
+      assert(count <= 2);
+
+      *lpSizeImage += 2 * count;
+      *lpOut++ = 1;
+      *lpOut++ = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
+      x++;
+
+      if (count == 2) {
+	*lpOut++ = 1;
+	*lpOut++ = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
+	x++;
+      }
+    }
+  } else {
+    /* encode count pixel(s) */
+    clr = pi->palette_map[GetRawPixel(lpbi,lpIn,x)];
+
+    /* optimize end of line */
+    if (x + count + 1 == lpbi->biWidth)
+      count++;
+
+    x += count;
+    while (count > 0) {
+      INT size = min(count, 255);
+
+      *lpSizeImage += 2;
+      count    -= size;
+      *lpOut++  = size;
+      *lpOut++  = clr;
+    }
+  }
+
+  *ppOut = lpOut;
+
+  return x;
+}
+
+LRESULT MSRLE32_CompressRLE4(CodecInfo *pi, LPBITMAPINFOHEADER lpbiIn, LPBYTE lpIn, LPBITMAPINFOHEADER lpbiOut, LPBYTE lpOut, BOOL isKey)
+{
+  LPWORD lpC;
+  LONG   lLine, lInLine, lDist;
+
+  /* pre-conditions */
+  assert(pi != NULL && lpbiOut != NULL);
+  assert(lpIn != NULL && lpOut != NULL);
+  assert(pi->pCurFrame != NULL);
+
+  lpC      = pi->pCurFrame;
+  lDist    = QUALITY_to_DIST(pi->dwQuality);
+  lInLine  = DIBWIDTHBYTES(*lpbiIn);
+  lLine    = WIDTHBYTES(lpbiOut->biWidth * 16) / 2;
+
+  lpbiOut->biSizeImage = 0;
+  if (isKey) {
+    /* keyframe -- convert internal frame to output format */
+    INT x, y;
+
+    for (y = 0; y < lpbiOut->biHeight; y++) {
+      x = 0;
+
+      do {
+	x = MSRLE32_CompressRLE4Line(pi, NULL, lpC, lpbiIn, lpIn, lDist, x,
+				     &lpOut, &lpbiOut->biSizeImage);
+      } while (x < lpbiOut->biWidth);
+
+      lpC   += lLine;
+      lpIn  += lInLine;
+
+      /* add EOL -- end of line */
+      lpbiOut->biSizeImage += 2;
+      *((LPWORD)lpOut)++ = 0;
+    }
+  } else {
+    /* delta-frame -- compute delta between last and this internal frame */
+    LPWORD lpP;
+    INT    x, y;
+    INT    jumpx, jumpy;
+
+    assert(pi->pPrevFrame != NULL);
+
+    lpP   = pi->pPrevFrame;
+    jumpy = 0;
+    jumpx = -1;
+
+    for (y = 0; y < lpbiOut->biHeight; y++) {
+      x = 0;
+
+      do {
+	INT count, pos;
+
+	if (jumpx == -1)
+	  jumpx = x;
+	for (count = 0, pos = x; pos < lpbiOut->biWidth; pos++, count++) {
+	  if (ColorCmp(lpP[pos], lpC[pos]) > lDist)
+	    break;
+	}
+
+	if (pos == lpbiOut->biWidth && count > 8) {
+	  /* (count > 8) secures that we will save space */
+	  jumpy++;
+	  break;
+	} else if (jumpy || jumpx != pos) {
+	  /* time to jump */
+	  assert(jumpx != -1);
+
+	  if (pos < jumpx) {
+	    /* can only jump in positive direction -- jump until EOL, EOL */
+	    INT w = lpbiOut->biWidth - jumpx;
+
+	    assert(jumpy > 0);
+	    assert(w >= 4);
+
+	    jumpx = 0;
+	    jumpy--;
+	    /* if (w % 255 == 2) then equal costs
+	     * else if (w % 255 < 4 && we could encode all) then 2 bytes too expensive
+	     * else it will be cheaper
+	     */
+	    while (w > 0) {
+	      lpbiOut->biSizeImage += 4;
+	      *lpOut++ = 0;
+	      *lpOut++ = 2;
+	      *lpOut   = min(w, 255);
+	      w       -= *lpOut++;
+	      *lpOut++ = 0;
+	    }
+	    /* add EOL -- end of line */
+	    lpbiOut->biSizeImage += 2;
+	    *((LPWORD)lpOut)++ = 0;
+	  }
+
+	  /* FIXME: if (jumpy == 0 && could encode all) then jump too expensive */
+
+	  /* write out real jump(s) */
+	  while (jumpy || pos != jumpx) {
+	    lpbiOut->biSizeImage += 4;
+	    *lpOut++ = 0;
+	    *lpOut++ = 2;
+	    *lpOut   = min(pos - jumpx, 255);
+	    x       += *lpOut;
+	    jumpx   += *lpOut++;
+	    *lpOut   = min(jumpy, 255);
+	    jumpy   -= *lpOut++;
+	  }
+
+	  jumpy = 0;
+	}
+
+	jumpx = -1;
+
+	if (x < lpbiOut->biWidth) {
+	  /* skipped the 'same' things corresponding to previous frame */
+	  x = MSRLE32_CompressRLE4Line(pi, lpP, lpC, lpbiIn, lpIn, lDist, x,
+			       &lpOut, &lpbiOut->biSizeImage);
+	}
+      } while (x < lpbiOut->biWidth);
+
+      lpP   += lLine;
+      lpC   += lLine;
+      lpIn  += lInLine;
+
+      if (jumpy == 0) {
+	assert(jumpx == -1);
+
+	/* add EOL -- end of line */
+	lpbiOut->biSizeImage += 2;
+	*((LPWORD)lpOut)++ = 0;
+      }
+    }
+  }
+
+  /* add EOI -- end of image */
+  lpbiOut->biSizeImage += 2;
+  *lpOut++ = 0;
+  *lpOut++ = 1;
+
+  return ICERR_OK;
+}
+
+LRESULT MSRLE32_CompressRLE8(CodecInfo *pi, LPBITMAPINFOHEADER lpbiIn, LPBYTE lpIn, LPBITMAPINFOHEADER lpbiOut, LPBYTE lpOut, BOOL isKey)
+{
+  LPWORD lpC;
+  LONG   lDist, lInLine, lLine;
+
+  assert(pi != NULL && lpbiOut != NULL);
+  assert(lpIn != NULL && lpOut != NULL);
+  assert(pi->pCurFrame != NULL);
+
+  lpC     = pi->pCurFrame;
+  lDist   = QUALITY_to_DIST(pi->dwQuality);
+  lInLine = DIBWIDTHBYTES(*lpbiIn);
+  lLine   = WIDTHBYTES(lpbiOut->biWidth * 16) / 2;
+
+  lpbiOut->biSizeImage = 0;
+  if (isKey) {
+    /* keyframe -- convert internal frame to output format */
+    INT x, y;
+
+    for (y = 0; y < lpbiOut->biHeight; y++) {
+      x = 0;
+
+      do {
+	x = MSRLE32_CompressRLE8Line(pi, NULL, lpC, lpbiIn, lpIn, lDist, x,
+			     &lpOut, &lpbiOut->biSizeImage);
+      } while (x < lpbiOut->biWidth);
+
+      lpC  += lLine;
+      lpIn += lInLine;
+
+      /* add EOL -- end of line */
+      lpbiOut->biSizeImage += 2;
+      *((LPWORD)lpOut)++ = 0;
+    }
+  } else {
+    /* delta-frame -- compute delta between last and this internal frame */
+    LPWORD lpP;
+    INT    x, y;
+    INT    jumpx, jumpy;
+
+    assert(pi->pPrevFrame != NULL);
+
+    lpP   = pi->pPrevFrame;
+    jumpx = -1;
+    jumpy = 0;
+
+    for (y = 0; y < lpbiOut->biHeight; y++) {
+      x = 0;
+
+      do {
+	INT count, pos;
+
+	if (jumpx == -1)
+	  jumpx = x;
+	for (count = 0, pos = x; pos < lpbiOut->biWidth; pos++, count++) {
+	  if (ColorCmp(lpP[pos], lpC[pos]) > lDist)
+	    break;
+	}
+
+	if (pos == lpbiOut->biWidth && count > 4) {
+	  /* (count > 4) secures that we will save space */
+	  jumpy++;
+	  break;
+	} else if (jumpy || jumpx != pos) {
+	  /* time to jump */
+	  assert(jumpx != -1);
+
+	  if (pos < jumpx) {
+	    /* can only jump in positive direction -- do a EOL then jump */
+	    assert(jumpy > 0);
+
+	    jumpx = 0;
+	    jumpy--;
+
+	    /* add EOL -- end of line */
+	    lpbiOut->biSizeImage += 2;
+	    *((LPWORD)lpOut)++ = 0;
+	  }
+
+	  /* FIXME: if (jumpy == 0 && could encode all) then jump too expensive */
+
+	  /* write out real jump(s) */
+	  while (jumpy || pos != jumpx) {
+	    lpbiOut->biSizeImage += 4;
+	    *lpOut++ = 0;
+	    *lpOut++ = 2;
+	    *lpOut   = min(pos - jumpx, 255);
+	    jumpx   += *lpOut++;
+	    *lpOut   = min(jumpy, 255);
+	    jumpy   -= *lpOut++;
+	  }
+	  x = pos;
+
+	  jumpy = 0;
+	}
+
+	jumpx = -1;
+
+	if (x < lpbiOut->biWidth) {
+	  /* skip the 'same' things corresponding to previous frame */
+	  x = MSRLE32_CompressRLE8Line(pi, lpP, lpC, lpbiIn, lpIn, lDist, x,
+			       &lpOut, &lpbiOut->biSizeImage);
+	}
+      } while (x < lpbiOut->biWidth);
+
+      lpP  += lLine;
+      lpC  += lLine;
+      lpIn += lInLine;
+
+      if (jumpy == 0) {
+	/* add EOL -- end of line */
+	lpbiOut->biSizeImage += 2;
+	*lpOut++ = 0;
+	*lpOut++ = 0;
+      }
+    }
+  }
+
+  /* add EOI -- end of image */
+  lpbiOut->biSizeImage += 2;
+  *lpOut++ = 0;
+  *lpOut++ = 1;
+
+  return ICERR_OK;
+}
+
+/*****************************************************************************/
+
+static LRESULT MSRLE32_DecompressRLE4(CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
+				      LPBYTE lpIn, LPBYTE lpOut)
+{
+  int  bytes_per_pixel;
+  int  line_size;
+  int  pixel_ptr  = 0;
+  int  i;
+  BOOL bEndFlag   = FALSE;
+
+  assert(pi != NULL);
+  assert(lpbi != NULL && lpbi->biCompression == BI_RGB);
+  assert(lpIn != NULL && lpOut != NULL);
+
+  bytes_per_pixel = (lpbi->biBitCount + 1) / 8;
+  line_size       = DIBWIDTHBYTES(*lpbi);
+
+  do {
+    BYTE code0, code1;
+
+    code0 = *lpIn++;
+    code1 = *lpIn++;
+
+    if (code0 == 0) {
+      int  extra_byte;
+
+      switch (code1) {
+      case  0: /* EOL - end of line  */
+	pixel_ptr = 0;
+	lpOut += line_size;
+	break;
+      case  1: /* EOI - end of image */
+	bEndFlag = TRUE;
+	break;
+      case  2: /* skip */
+	pixel_ptr += *lpIn++ * bytes_per_pixel;
+	lpOut     += *lpIn++ * line_size;
+	if (pixel_ptr >= lpbi->biWidth * bytes_per_pixel) {
+	  pixel_ptr = 0;
+	  lpOut    += line_size;
+	}
+	break;
+      default: /* absolute mode */
+	extra_byte = (code1 / 2) & 0x01;
+
+	if (pixel_ptr/bytes_per_pixel + code1 > lpbi->biWidth)
+	  return ICERR_ERROR;
+
+	code0 = code1;
+	for (i = 0; i < code0 / 2; i++) {
+	  if (bytes_per_pixel == 1) {
+	    code1 = lpIn[i];
+	    lpOut[pixel_ptr++] = pi->palette_map[(code1 >> 4)];
+	    if (2 * i <= code0)
+	      lpOut[pixel_ptr++] = pi->palette_map[(code1 & 0x0F)];
+	  } else if (bytes_per_pixel == 2) {
+	    code1 = lpIn[i] >> 4;
+	    lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 0];
+	    lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 1];
+
+	    if (2 * i <= code0) {
+	      code1 = lpIn[i] & 0x0F;
+	      lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 0];
+	      lpOut[pixel_ptr++] = pi->palette_map[code1 * 2 + 1];
+	    }
+	  } else {
+	    code1 = lpIn[i] >> 4;
+	    lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 4 + 0];
+	    lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 4 + 1];
+	    lpOut[pixel_ptr + 2] = pi->palette_map[code1 * 4 + 2];
+	    pixel_ptr += bytes_per_pixel;
+
+	    if (2 * i <= code0) {
+	      code1 = lpIn[i] & 0x0F;
+	      lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 4 + 0];
+	      lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 4 + 1];
+	      lpOut[pixel_ptr + 2] = pi->palette_map[code1 * 4 + 2];
+	      pixel_ptr += bytes_per_pixel;
+	    }
+	  }
+	}
+	lpIn += code0 / 2;
+
+	/* if the RLE code is odd, skip a byte in the stream */
+	if (extra_byte)
+	  lpIn++;
+      };
+    } else {
+      /* coded mode */
+      if (pixel_ptr/bytes_per_pixel + code0 > lpbi->biWidth)
+	return ICERR_ERROR;
+
+      if (bytes_per_pixel == 1) {
+	BYTE c1 = pi->palette_map[(code1 >> 4)];
+	BYTE c2 = pi->palette_map[(code1 & 0x0F)];
+
+	for (i = 0; i < code0; i++) {
+	  if ((i & 1) == 0)
+	    lpOut[pixel_ptr++] = c1;
+	  else
+	    lpOut[pixel_ptr++] = c2;
+	}
+      } else if (bytes_per_pixel == 2) {
+	BYTE hi1 = pi->palette_map[(code1 >> 4) * 2 + 0];
+	BYTE lo1 = pi->palette_map[(code1 >> 4) * 2 + 1];
+
+	BYTE hi2 = pi->palette_map[(code1 & 0x0F) * 2 + 0];
+	BYTE lo2 = pi->palette_map[(code1 & 0x0F) * 2 + 1];
+
+	for (i = 0; i < code0; i++) {
+	  if ((i & 1) == 0) {
+	    lpOut[pixel_ptr++] = hi1;
+	    lpOut[pixel_ptr++] = lo1;
+	  } else {
+	    lpOut[pixel_ptr++] = hi2;
+	    lpOut[pixel_ptr++] = lo2;
+	  }
+	}
+      } else {
+	BYTE b1 = pi->palette_map[(code1 >> 4) * 4 + 0];
+	BYTE g1 = pi->palette_map[(code1 >> 4) * 4 + 1];
+	BYTE r1 = pi->palette_map[(code1 >> 4) * 4 + 2];
+
+	BYTE b2 = pi->palette_map[(code1 & 0x0F) * 4 + 0];
+	BYTE g2 = pi->palette_map[(code1 & 0x0F) * 4 + 1];
+	BYTE r2 = pi->palette_map[(code1 & 0x0F) * 4 + 2];
+
+	for (i = 0; i < code0; i++) {
+	  if ((i & 1) == 0) {
+	    lpOut[pixel_ptr + 0] = b1;
+	    lpOut[pixel_ptr + 1] = g1;
+	    lpOut[pixel_ptr + 2] = r1;
+	  } else {
+	    lpOut[pixel_ptr + 0] = b2;
+	    lpOut[pixel_ptr + 1] = g2;
+	    lpOut[pixel_ptr + 2] = r2;
+	  }
+	  pixel_ptr += bytes_per_pixel;
+	}
+      }
+    }
+  } while (! bEndFlag);
+
+  return ICERR_OK;
+}
+
+static LRESULT MSRLE32_DecompressRLE8(CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
+				      LPBYTE lpIn, LPBYTE lpOut)
+{
+  int  bytes_per_pixel;
+  int  line_size;
+  int  pixel_ptr  = 0;
+  BOOL bEndFlag   = FALSE;
+
+  assert(pi != NULL);
+  assert(lpbi != NULL && lpbi->biCompression == BI_RGB);
+  assert(lpIn != NULL && lpOut != NULL);
+
+  bytes_per_pixel = (lpbi->biBitCount + 1) / 8;
+  line_size       = DIBWIDTHBYTES(*lpbi);
+
+  do {
+    BYTE code0, code1;
+
+    code0 = *lpIn++;
+    code1 = *lpIn++;
+
+    if (code0 == 0) {
+      int  extra_byte;
+
+      switch (code1) {
+      case  0: /* EOL - end of line  */
+	pixel_ptr = 0;
+	lpOut += line_size;
+	break;
+      case  1: /* EOI - end of image */
+	bEndFlag = TRUE;
+	break;
+      case  2: /* skip */
+	pixel_ptr += *lpIn++ * bytes_per_pixel;
+	lpOut     += *lpIn++ * line_size;
+	if (pixel_ptr >= lpbi->biWidth * bytes_per_pixel) {
+	  pixel_ptr = 0;
+	  lpOut    += line_size;
+	}
+	break;
+      default: /* absolute mode */
+	if (pixel_ptr/bytes_per_pixel + code1 > lpbi->biWidth) {
+	  WARN("aborted absolute: (%d=%d/%d+%d) > %ld\n",pixel_ptr/bytes_per_pixel + code1,pixel_ptr,bytes_per_pixel,code1,lpbi->biWidth);
+	  return ICERR_ERROR;
+	}
+	extra_byte = code1 & 0x01;
+
+	code0 = code1;
+	while (code0--) {
+	  code1 = *lpIn++;
+	  if (bytes_per_pixel == 1) {
+	    lpOut[pixel_ptr] = pi->palette_map[code1];
+	  } else if (bytes_per_pixel == 2) {
+	    lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 2 + 0];
+	    lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 2 + 1];
+	  } else {
+	    lpOut[pixel_ptr + 0] = pi->palette_map[code1 * 4 + 0];
+	    lpOut[pixel_ptr + 1] = pi->palette_map[code1 * 4 + 1];
+	    lpOut[pixel_ptr + 2] = pi->palette_map[code1 * 4 + 2];
+	  }
+	  pixel_ptr += bytes_per_pixel;
+	}
+
+	/* if the RLE code is odd, skip a byte in the stream */
+	if (extra_byte)
+	  lpIn++;
+      };
+    } else {
+      /* coded mode */
+      if (pixel_ptr/bytes_per_pixel + code0 > lpbi->biWidth) {
+	WARN("aborted coded: (%d=%d/%d+%d) > %ld\n",pixel_ptr/bytes_per_pixel + code1,pixel_ptr,bytes_per_pixel,code1,lpbi->biWidth);
+	return ICERR_ERROR;
+      }
+
+      if (bytes_per_pixel == 1) {
+	code1 = pi->palette_map[code1];
+	while (code0--)
+	  lpOut[pixel_ptr++] = code1;
+      } else if (bytes_per_pixel == 2) {
+	BYTE hi = pi->palette_map[code1 * 2 + 0];
+	BYTE lo = pi->palette_map[code1 * 2 + 1];
+
+	while (code0--) {
+	  lpOut[pixel_ptr + 0] = hi;
+	  lpOut[pixel_ptr + 1] = lo;
+	  pixel_ptr += bytes_per_pixel;
+	}
+      } else {
+	BYTE r = pi->palette_map[code1 * 4 + 2];
+	BYTE g = pi->palette_map[code1 * 4 + 1];
+	BYTE b = pi->palette_map[code1 * 4 + 0];
+
+	while (code0--) {
+	  lpOut[pixel_ptr + 0] = b;
+	  lpOut[pixel_ptr + 1] = g;
+	  lpOut[pixel_ptr + 2] = r;
+	  pixel_ptr += bytes_per_pixel;
+	}
+      }
+    }
+  } while (! bEndFlag);
+
+  return ICERR_OK;
+}
+
+/*****************************************************************************/
+
+static CodecInfo* Open(LPICOPEN icinfo)
+{
+  CodecInfo* pi = NULL;
+
+  if (icinfo == NULL) {
+    TRACE("(NULL)\n");
+    return (LPVOID)0xFFFF0000;
+  }
+
+  TRACE("(%p = {%lu,0x%08lX(%4.4s),0x%08lX(%4.4s),0x%lX,0x%lX,...})\n", icinfo,
+	icinfo->dwSize,	icinfo->fccType, (char*)&icinfo->fccType,
+	icinfo->fccHandler, (char*)&icinfo->fccHandler,
+	icinfo->dwVersion,icinfo->dwFlags);
+
+  if (icinfo->fccType != ICTYPE_VIDEO)
+    return NULL;
+
+  switch (icinfo->fccHandler) {
+  case FOURCC_RLE:
+  case FOURCC_RLE4:
+  case FOURCC_RLE8:
+  case FOURCC_MRLE:
+    break;
+  case mmioFOURCC('m','r','l','e'):
+    icinfo->fccHandler = FOURCC_MRLE;
+    break;
+  default:
+    WARN("unknown FOURCC = 0x%08lX(%4.4s) !\n",
+	 icinfo->fccHandler,(char*)&icinfo->fccHandler);
+    return NULL;
+  }
+
+  pi = (CodecInfo*)LocalAlloc(LPTR, sizeof(CodecInfo));
+
+  if (pi != NULL) {
+    pi->fccHandler  = icinfo->fccHandler;
+
+    pi->bCompress   = FALSE;
+    pi->dwQuality   = MSRLE32_DEFAULTQUALITY;
+    pi->nPrevFrame  = -1;
+    pi->pPrevFrame  = pi->pCurFrame = NULL;
+
+    pi->bDecompress = FALSE;
+    pi->palette_map = NULL;
+  }
+
+  icinfo->dwError = (pi != NULL ? ICERR_OK : ICERR_MEMORY);
+
+  return pi;
+}
+
+static LRESULT Close(CodecInfo *pi)
+{
+  TRACE("(%p)\n", pi);
+
+  /* pre-condition */
+  assert(pi != NULL);
+
+  if (pi->pPrevFrame != NULL || pi->pCurFrame != NULL)
+    CompressEnd(pi);
+
+  LocalFree((HLOCAL)pi);
+  return 1;
+}
+
+static LRESULT GetInfo(CodecInfo *pi, ICINFO *icinfo, DWORD dwSize)
+{
+  /* pre-condition */
+  assert(pi != NULL);
+
+  /* check parameters */
+  if (icinfo == NULL)
+    return sizeof(ICINFO);
+  if (dwSize < sizeof(ICINFO))
+    return 0;
+
+  icinfo->dwSize       = sizeof(ICINFO);
+  icinfo->fccType      = streamtypeVIDEO;
+  icinfo->fccHandler   = (pi != NULL ? pi->fccHandler : FOURCC_MRLE);
+  icinfo->dwFlags      = VIDCF_QUALITY | VIDCF_TEMPORAL | VIDCF_CRUNCH | VIDCF_FASTTEMPORALC;
+  icinfo->dwVersion    = MSRLE32_VERSION;
+  icinfo->dwVersionICM = 0x01040000; /* Version 1.4 build 0 */
+
+  LoadWideString(IDS_NAME, icinfo->szName, sizeof(icinfo->szName));
+  LoadWideString(IDS_DESCRIPTION, icinfo->szDescription, sizeof(icinfo->szDescription));
+
+  return sizeof(ICINFO);
+}
+
+static LRESULT SetQuality(CodecInfo *pi, LONG lQuality)
+{
+  /* pre-condition */
+  assert(pi != NULL);
+
+  if (lQuality == -1)
+    lQuality = MSRLE32_DEFAULTQUALITY;
+  else if (ICQUALITY_LOW > lQuality || lQuality > ICQUALITY_HIGH)
+    return ICERR_BADPARAM;
+
+  pi->dwQuality = (DWORD)lQuality;
+
+  return ICERR_OK;
+}
+
+static LRESULT Configure(CodecInfo *pi, HWND hWnd)
+{
+  /* pre-condition */
+  assert(pi != NULL);
+
+  /* FIXME */
+  return ICERR_OK;
+}
+
+static LRESULT About(CodecInfo *pi, HWND hWnd)
+{
+  CHAR szTitle[20];
+  CHAR szAbout[128];
+
+  /* pre-condition */
+  assert(MSRLE32_hModule != 0);
+
+  LoadStringA(MSRLE32_hModule, IDS_NAME, szTitle, sizeof(szTitle));
+  LoadStringA(MSRLE32_hModule, IDS_ABOUT, szAbout, sizeof(szAbout));
+
+  MessageBoxA(hWnd, szAbout, szTitle, MB_OK|MB_ICONINFORMATION);
+
+  return ICERR_OK;
+}
+
+static LRESULT CompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+				 LPBITMAPINFOHEADER lpbiOut)
+{
+  LRESULT size;
+
+  TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
+
+  /* pre-condition */
+  assert(pi != NULL);
+
+  /* check parameters -- need atleast input format */
+  if (lpbiIn == NULL) {
+    if (lpbiOut != NULL)
+      return ICERR_BADPARAM;
+    return 0;
+  }
+
+  /* handle unsupported input format */
+  if (CompressQuery(pi, lpbiIn, NULL) != ICERR_OK)
+    return (lpbiOut == NULL ? ICERR_BADFORMAT : 0);
+
+  assert(0 < lpbiIn->biBitCount && lpbiIn->biBitCount <= 8);
+
+  switch (pi->fccHandler) {
+  case FOURCC_RLE4:
+    size = 1 << 4;
+    break;
+  case FOURCC_RLE8:
+    size = 1 << 8;
+    break;
+  case FOURCC_RLE:
+  case FOURCC_MRLE:
+    size = (lpbiIn->biBitCount <= 4 ? 1 << 4 : 1 << 8);
+    break;
+  default:
+    return ICERR_ERROR;
+  }
+
+  if (lpbiIn->biClrUsed != 0)
+    size = lpbiIn->biClrUsed;
+
+  size = sizeof(BITMAPINFOHEADER) + size * sizeof(RGBQUAD);
+
+  if (lpbiOut != NULL) {
+    lpbiOut->biSize          = sizeof(BITMAPINFOHEADER);
+    lpbiOut->biWidth         = lpbiIn->biWidth;
+    lpbiOut->biHeight        = lpbiIn->biHeight;
+    lpbiOut->biPlanes        = 1;
+    if (pi->fccHandler == FOURCC_RLE4 ||
+	lpbiIn->biBitCount <= 4) {
+      lpbiOut->biCompression = BI_RLE4;
+      lpbiOut->biBitCount    = 4;
+    } else {
+      lpbiOut->biCompression = BI_RLE8;
+      lpbiOut->biBitCount    = 8;
+    }
+    lpbiOut->biSizeImage     = MSRLE32_GetMaxCompressedSize(lpbiOut);
+    lpbiOut->biXPelsPerMeter = lpbiIn->biXPelsPerMeter;
+    lpbiOut->biYPelsPerMeter = lpbiIn->biYPelsPerMeter;
+    if (lpbiIn->biClrUsed == 0)
+      size = 1<<lpbiIn->biBitCount;
+    else
+      size = lpbiIn->biClrUsed;
+    lpbiOut->biClrUsed       = min(size, 1u << lpbiOut->biBitCount);
+    lpbiOut->biClrImportant  = 0;
+
+    memcpy((LPBYTE)lpbiOut + lpbiOut->biSize,
+	   (LPBYTE)lpbiIn + lpbiIn->biSize, lpbiOut->biClrUsed * sizeof(RGBQUAD));
+
+    return ICERR_OK;
+  } else
+    return size;
+}
+
+static LRESULT CompressGetSize(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+			       LPCBITMAPINFOHEADER lpbiOut)
+{
+  /* pre-condition */
+  assert(pi != NULL);
+
+  TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
+
+  /* check parameter -- need atleast one format */
+  if (lpbiIn == NULL && lpbiOut == NULL)
+    return 0;
+  /* check if the given format is supported */
+  if (CompressQuery(pi, lpbiIn, lpbiOut) != ICERR_OK)
+    return 0;
+
+  /* the worst case is coding the complete image in absolute mode. */
+  if (lpbiIn)
+    return MSRLE32_GetMaxCompressedSize(lpbiIn);
+  else
+    return MSRLE32_GetMaxCompressedSize(lpbiOut);
+}
+
+static LRESULT CompressQuery(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+			     LPCBITMAPINFOHEADER lpbiOut)
+{
+  /* pre-condition */
+  assert(pi != NULL);
+
+  /* need atleast one format */
+  if (lpbiIn == NULL && lpbiOut == NULL)
+    return ICERR_BADPARAM;
+
+  /* check input format if given */
+  if (lpbiIn != NULL) {
+    if (!isSupportedDIB(lpbiIn))
+      return ICERR_BADFORMAT;
+
+    /* for 4-bit need an even width */
+    if (lpbiIn->biBitCount <= 4 && (lpbiIn->biWidth % 2))
+      return ICERR_BADFORMAT;
+
+    if (pi->fccHandler == FOURCC_RLE4 && lpbiIn->biBitCount > 4)
+      return ICERR_UNSUPPORTED;
+    else if (lpbiIn->biBitCount > 8)
+      return ICERR_UNSUPPORTED;
+  }
+
+  /* check output format if given */
+  if (lpbiOut != NULL) {
+    if (!isSupportedMRLE(lpbiOut))
+      return ICERR_BADFORMAT;
+
+    if (lpbiIn != NULL) {
+      if (lpbiIn->biWidth  != lpbiOut->biWidth)
+	return ICERR_UNSUPPORTED;
+      if (lpbiIn->biHeight != lpbiOut->biHeight)
+	return ICERR_UNSUPPORTED;
+      if (lpbiIn->biBitCount > lpbiOut->biBitCount)
+	return ICERR_UNSUPPORTED;
+    }
+  }
+
+  return ICERR_OK;
+}
+
+static LRESULT CompressBegin(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+			     LPCBITMAPINFOHEADER lpbiOut)
+{
+  RGBQUAD *rgbIn;
+  RGBQUAD *rgbOut;
+  int      i;
+  size_t   size;
+
+  TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
+
+  /* pre-condition */
+  assert(pi != NULL);
+
+  /* check parameters -- need both formats */
+  if (lpbiIn == NULL || lpbiOut == NULL)
+    return ICERR_BADPARAM;
+  /* And both must be supported */
+  if (CompressQuery(pi, lpbiIn, lpbiOut) != ICERR_OK)
+    return ICERR_BADFORMAT;
+
+  /* FIXME: cannot compress and decompress at a time! */
+  if (pi->bDecompress) {
+    FIXME("cannot compress and decompress at same time!\n");
+    return ICERR_ERROR;
+  }
+
+  if (pi->bCompress)
+    CompressEnd(pi);
+
+  size = WIDTHBYTES(lpbiOut->biWidth * 16) / 2 * lpbiOut->biHeight;
+  pi->pPrevFrame = (LPWORD)GlobalAllocPtr(GPTR, size * sizeof(WORD));
+  if (pi->pPrevFrame == NULL)
+    return ICERR_MEMORY;
+  pi->pCurFrame = (LPWORD)GlobalAllocPtr(GPTR, size * sizeof(WORD));
+  if (pi->pCurFrame == NULL) {
+    CompressEnd(pi);
+    return ICERR_MEMORY;
+  }
+  pi->nPrevFrame = -1;
+  pi->bCompress  = TRUE;
+
+  rgbIn  = (RGBQUAD*)((LPBYTE)lpbiIn  + lpbiIn->biSize);
+  rgbOut = (RGBQUAD*)((LPBYTE)lpbiOut + lpbiOut->biSize);
+
+  switch (lpbiOut->biBitCount) {
+  case 4:
+  case 8:
+    pi->palette_map = (LPBYTE)LocalAlloc(LPTR, lpbiIn->biClrUsed);
+    if (pi->palette_map == NULL) {
+      CompressEnd(pi);
+      return ICERR_MEMORY;
+    }
+
+    for (i = 0; i < lpbiIn->biClrUsed; i++) {
+      pi->palette_map[i] = MSRLE32_GetNearestPaletteIndex(lpbiOut->biClrUsed, rgbOut, rgbIn[i]);
+    }
+    break;
+  };
+
+  return ICERR_OK;
+}
+
+static LRESULT Compress(CodecInfo *pi, ICCOMPRESS* lpic, DWORD dwSize)
+{
+  int i;
+
+  TRACE("(%p,%p,%lu)\n",pi,lpic,dwSize);
+
+  /* pre-condition */
+  assert(pi != NULL);
+
+  /* check parameters */
+  if (lpic == NULL || dwSize < sizeof(ICCOMPRESS))
+    return ICERR_BADPARAM;
+  if (!lpic->lpbiOutput || !lpic->lpOutput ||
+      !lpic->lpbiInput  || !lpic->lpInput)
+    return ICERR_BADPARAM;
+
+  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);
+
+  if (! pi->bCompress) {
+    LRESULT hr = CompressBegin(pi, lpic->lpbiInput, lpic->lpbiOutput);
+    if (hr != ICERR_OK)
+      return hr;
+  } else if (CompressQuery(pi, lpic->lpbiInput, lpic->lpbiOutput) != ICERR_OK)
+    return ICERR_BADFORMAT;
+
+  if (lpic->lFrameNum >= pi->nPrevFrame + 1) {
+    /* we continue in the sequence so we need to initialize 
+     * our internal framedata */
+
+    computeInternalFrame(pi, lpic->lpbiInput, lpic->lpInput);
+  } else if (lpic->lFrameNum == pi->nPrevFrame) {
+    /* Oops, compress same frame again ? Okay, as you wish.
+     * No need to recompute internal framedata, because we only swapped buffers */
+    LPWORD pTmp = pi->pPrevFrame;
+
+    FIXME(": prev=%ld cur=%ld swap\n",pi->nPrevFrame,lpic->lFrameNum);
+    pi->pPrevFrame = pi->pCurFrame;
+    pi->pCurFrame  = pTmp;
+  } else if ((lpic->dwFlags & ICCOMPRESS_KEYFRAME) == 0) {
+    LPWORD pTmp;
+
+    WARN(": prev=%ld cur=%ld gone back? -- untested",pi->nPrevFrame,lpic->lFrameNum);
+    if (lpic->lpbiPrev == NULL || lpic->lpPrev == NULL)
+      return ICERR_GOTOKEYFRAME; /* Need a keyframe if you go back */
+    if (CompressQuery(pi, lpic->lpbiPrev, lpic->lpbiOutput) != ICERR_OK)
+      return ICERR_BADFORMAT;
+
+    WARN(": prev=%ld cur=%ld compute swapped -- untested\n",pi->nPrevFrame,lpic->lFrameNum);
+    computeInternalFrame(pi, lpic->lpbiPrev, lpic->lpPrev);
+
+    /* swap buffers for current and previous frame */
+    /* Don't free and alloc new -- costs to much time and they are of equal size ! */
+    pTmp = pi->pPrevFrame;
+    pi->pPrevFrame = pi->pCurFrame;
+    pi->pCurFrame  = pTmp;
+    pi->nPrevFrame = lpic->lFrameNum;
+  }
+
+  for (i = 0; i < 3; i++) {
+    SetQuality(pi, lpic->dwQuality);
+
+    lpic->lpbiOutput->biSizeImage = 0;
+
+    if (lpic->lpbiOutput->biBitCount == 4)
+      MSRLE32_CompressRLE4(pi, lpic->lpbiInput, (LPBYTE)lpic->lpInput,
+		   lpic->lpbiOutput, (LPBYTE)lpic->lpOutput, TRUE);
+    /*MSRLE32_CompressRLE4(pi, lpic->lpbiInput, (LPBYTE)lpic->lpInput,
+		   lpic->lpbiOutput, (LPBYTE)lpic->lpOutput, (lpic->dwFlags & ICCOMPRESS_KEYFRAME) != 0);*/
+    else
+      MSRLE32_CompressRLE8(pi, lpic->lpbiInput, (LPBYTE)lpic->lpInput,
+		   lpic->lpbiOutput, (LPBYTE)lpic->lpOutput, (lpic->dwFlags & ICCOMPRESS_KEYFRAME) != 0);
+
+    if (lpic->dwFrameSize == 0 ||
+	lpic->lpbiOutput->biSizeImage < lpic->dwFrameSize)
+      break;
+
+    if ((*lpic->lpdwFlags & ICCOMPRESS_KEYFRAME) == 0) {
+      if (lpic->lpbiOutput->biBitCount == 4)
+	MSRLE32_CompressRLE4(pi, lpic->lpbiInput, (LPBYTE)lpic->lpInput,
+			     lpic->lpbiOutput, (LPBYTE)lpic->lpOutput, TRUE);
+      else
+	MSRLE32_CompressRLE8(pi, lpic->lpbiInput, (LPBYTE)lpic->lpInput,
+			     lpic->lpbiOutput, (LPBYTE)lpic->lpOutput, TRUE);
+
+      if (lpic->dwFrameSize == 0 ||
+	  lpic->lpbiOutput->biSizeImage < lpic->dwFrameSize) {
+	WARN("switched to keyframe, was small enough!\n");
+	*lpic->lpdwFlags |= ICCOMPRESS_KEYFRAME;
+	*lpic->lpckid    = MAKEAVICKID(cktypeDIBbits,
+				       StreamFromFOURCC(*lpic->lpckid));
+	break;
+      }
+    }
+
+    if (lpic->dwQuality < 1000)
+      break;
+
+    lpic->dwQuality -= 1000; /* reduce quality by 10% */
+  }
+
+  { /* swap buffer for current and previous frame */
+    /* Don't free and alloc new -- costs to much time and they are of equal size ! */
+    register LPWORD pTmp = pi->pPrevFrame;
+
+    pi->pPrevFrame = pi->pCurFrame;
+    pi->pCurFrame  = pTmp;
+    pi->nPrevFrame = lpic->lFrameNum;
+  }
+
+  return ICERR_OK;
+}
+
+static LRESULT CompressEnd(CodecInfo *pi)
+{
+  TRACE("(%p)\n",pi);
+
+  if (pi != NULL) {
+    if (pi->pPrevFrame != NULL)
+      GlobalFreePtr(pi->pPrevFrame);
+    if (pi->pCurFrame != NULL)
+      GlobalFreePtr(pi->pCurFrame);
+    pi->pPrevFrame = NULL;
+    pi->pCurFrame  = NULL;
+    pi->nPrevFrame = -1;
+    pi->bCompress  = FALSE;
+  }
+
+  return ICERR_OK;
+}
+
+static LRESULT DecompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+				   LPBITMAPINFOHEADER lpbiOut)
+{
+  int size;
+
+  TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
+
+  /* pre-condition */
+  assert(pi != NULL);
+
+  if (lpbiIn == NULL)
+    return (lpbiOut != NULL ? ICERR_BADPARAM : 0);
+
+  if (DecompressQuery(pi, lpbiIn, NULL) != ICERR_OK)
+    return (lpbiOut != NULL ? ICERR_BADFORMAT : 0);
+
+  size = lpbiIn->biSize;
+
+  if (lpbiOut != NULL) {
+    memcpy(lpbiOut, lpbiIn, size);
+    lpbiOut->biBitCount     = 32;
+    lpbiOut->biCompression  = BI_RGB;
+    lpbiOut->biSizeImage    = DIBWIDTHBYTES(*lpbiOut) * lpbiOut->biHeight;
+    lpbiOut->biClrImportant = 0;
+
+    if (lpbiOut->biBitCount <= 8 && lpbiOut->biClrUsed == 0)
+      lpbiOut->biClrUsed = 1 << lpbiOut->biBitCount;
+    else
+      lpbiOut->biClrUsed = 0;
+
+    return size;
+  } else
+    return size;
+}
+
+static LRESULT DecompressQuery(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+			       LPCBITMAPINFOHEADER lpbiOut)
+{
+  LRESULT hr = ICERR_OK;
+
+  TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
+
+  /* pre-condition */
+  assert(pi != NULL);
+
+  /* need atleast one format */
+  if (lpbiIn == NULL && lpbiOut == NULL)
+    return ICERR_BADPARAM;
+
+  /* check input format if given */
+  if (lpbiIn != NULL) {
+    if (!isSupportedMRLE(lpbiIn))
+      return ICERR_BADFORMAT;
+  }
+
+  /* check output format if given */
+  if (lpbiOut != NULL) {
+    if (!isSupportedDIB(lpbiOut))
+      hr = ICERR_BADFORMAT;
+
+    if (lpbiIn != NULL) {
+      if (lpbiIn->biWidth  != lpbiOut->biWidth)
+	hr = ICERR_UNSUPPORTED;
+      if (lpbiIn->biHeight != lpbiOut->biHeight)
+	hr = ICERR_UNSUPPORTED;
+      if (lpbiIn->biBitCount > lpbiOut->biBitCount)
+	hr = ICERR_UNSUPPORTED;
+    }
+  }
+
+  return hr;
+}
+
+static LRESULT DecompressBegin(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+			       LPCBITMAPINFOHEADER lpbiOut)
+{
+  RGBQUAD *rgbIn;
+  RGBQUAD *rgbOut;
+  int      i;
+
+  TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
+
+  /* pre-condition */
+  assert(pi != NULL);
+
+  /* check parameters */
+  if (lpbiIn == NULL || lpbiOut == NULL)
+    return ICERR_BADPARAM;
+  if (DecompressQuery(pi, lpbiIn, lpbiOut) != ICERR_OK)
+    return ICERR_BADFORMAT;
+
+  /* FIXME: cannot compress and decompress at a time! */
+  if (pi->bCompress) {
+    FIXME("cannot compress and decompress at same time!\n");
+    return ICERR_ERROR;
+  }
+
+  if (pi->bDecompress)
+    DecompressEnd(pi);
+
+  rgbIn  = (RGBQUAD*)((LPBYTE)lpbiIn  + lpbiIn->biSize);
+  rgbOut = (RGBQUAD*)((LPBYTE)lpbiOut + lpbiOut->biSize);
+
+  switch (lpbiOut->biBitCount) {
+  case 4:
+  case 8:
+    pi->palette_map = (LPBYTE)LocalAlloc(LPTR, lpbiIn->biClrUsed);
+    if (pi->palette_map == NULL)
+      return ICERR_MEMORY;
+
+    for (i = 0; i < lpbiIn->biClrUsed; i++) {
+      pi->palette_map[i] = MSRLE32_GetNearestPaletteIndex(lpbiOut->biClrUsed, rgbOut, rgbIn[i]);
+    }
+    break;
+  case 15:
+  case 16:
+    pi->palette_map = (LPBYTE)LocalAlloc(LPTR, lpbiIn->biClrUsed * 2);
+    if (pi->palette_map == NULL)
+      return ICERR_MEMORY;
+
+    for (i = 0; i < lpbiIn->biClrUsed; i++) {
+      WORD color;
+
+      if (lpbiOut->biBitCount == 15)
+	color = ((rgbIn[i].rgbRed >> 3) << 10)
+	  | ((rgbIn[i].rgbGreen >> 3) << 5) | (rgbIn[i].rgbBlue >> 3);
+      else
+	color = ((rgbIn[i].rgbRed >> 3) << 11)
+	  | ((rgbIn[i].rgbGreen >> 3) << 5) | (rgbIn[i].rgbBlue >> 3);
+
+      pi->palette_map[i * 2 + 1] = color >> 8;
+      pi->palette_map[i * 2 + 0] = color & 0xFF;
+    };
+    break;
+  case 24:
+  case 32:
+    pi->palette_map = (LPBYTE)LocalAlloc(LPTR, lpbiIn->biClrUsed * sizeof(RGBQUAD));
+    if (pi->palette_map == NULL)
+      return ICERR_MEMORY;
+    memcpy(pi->palette_map, rgbIn, lpbiIn->biClrUsed * sizeof(RGBQUAD));
+    break;
+  };
+
+  pi->bDecompress = TRUE;
+
+  return ICERR_OK;
+}
+
+static LRESULT Decompress(CodecInfo *pi, ICDECOMPRESS *pic, DWORD dwSize)
+{
+  TRACE("(%p,%p,%lu)\n",pi,pic,dwSize);
+
+  /* pre-condition */
+  assert(pi != NULL);
+
+  /* check parameters */
+  if (pic == NULL)
+    return ICERR_BADPARAM;
+  if (pic->lpbiInput == NULL || pic->lpInput == NULL ||
+      pic->lpbiOutput == NULL || pic->lpOutput == NULL)
+    return ICERR_BADPARAM;
+
+  /* check formats */
+  if (! pi->bDecompress) {
+    LRESULT hr = DecompressBegin(pi, pic->lpbiInput, pic->lpbiOutput);
+    if (hr != ICERR_OK)
+      return hr;
+  } else if (DecompressQuery(pi, pic->lpbiInput, pic->lpbiOutput) != ICERR_OK)
+    return ICERR_BADFORMAT;
+
+  assert(pic->lpbiInput->biWidth  == pic->lpbiOutput->biWidth);
+  assert(pic->lpbiInput->biHeight == pic->lpbiOutput->biHeight);
+
+  pic->lpbiOutput->biSizeImage = DIBWIDTHBYTES(*pic->lpbiOutput) * pic->lpbiOutput->biHeight;
+  if (pic->lpbiInput->biBitCount == 4)
+    return MSRLE32_DecompressRLE4(pi, pic->lpbiOutput, pic->lpInput, pic->lpOutput);
+  else
+    return MSRLE32_DecompressRLE8(pi, pic->lpbiOutput, pic->lpInput, pic->lpOutput);
+}
+
+static LRESULT DecompressEnd(CodecInfo *pi)
+{
+  TRACE("(%p)\n",pi);
+
+  /* pre-condition */
+  assert(pi != NULL);
+
+  pi->bDecompress = FALSE;
+
+  if (pi->palette_map != NULL) {
+    LocalFree((HLOCAL)pi->palette_map);
+    pi->palette_map = NULL;
+  }
+
+  return ICERR_OK;
+}
+
+static LRESULT DecompressGetPalette(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
+				    LPBITMAPINFOHEADER lpbiOut)
+{
+  int size;
+
+  TRACE("(%p,%p,%p)\n",pi,lpbiIn,lpbiOut);
+
+  /* pre-condition */
+  assert(pi != NULL);
+
+  /* check parameters */
+  if (lpbiIn == NULL || lpbiOut == NULL)
+    return ICERR_BADPARAM;
+
+  if (DecompressQuery(pi, lpbiIn, lpbiOut) != ICERR_OK)
+    return ICERR_BADFORMAT;
+
+  if (lpbiOut->biBitCount > 8)
+    return ICERR_ERROR;
+
+  if (lpbiIn->biBitCount <= 8) {
+    if (lpbiIn->biClrUsed > 0)
+      size = lpbiIn->biClrUsed;
+    else
+      size = (1 << lpbiIn->biBitCount);
+
+    lpbiOut->biClrUsed = size;
+
+    memcpy((LPBYTE)lpbiOut + lpbiOut->biSize, (LPBYTE)lpbiIn + lpbiIn->biSize, size * sizeof(RGBQUAD));
+  } /* else could never occur ! */
+
+  return ICERR_OK;
+}
+
+/* DriverProc - entry point for an installable driver */
+LRESULT CALLBACK MSRLE32_DriverProc(DWORD dwDrvID, HDRVR hDrv, UINT uMsg,
+				    LPARAM lParam1, LPARAM lParam2)
+{
+  CodecInfo *pi = (CodecInfo*)dwDrvID;
+
+  TRACE("(%p,%p,0x%04X,0x%08lX,0x%08lX)\n", (LPVOID)dwDrvID, (LPVOID)hDrv,
+	uMsg, lParam1, lParam2);
+
+  switch (uMsg) {
+    /* standard driver messages */
+  case DRV_LOAD:
+    return DRVCNF_OK;
+  case DRV_OPEN:
+    if (lParam2 == 0)
+      return (LRESULT)0xFFFF0000;
+    else
+      return (LRESULT)Open((ICOPEN*)lParam2);
+  case DRV_CLOSE:
+    if (dwDrvID != 0xFFFF0000 && (LPVOID)dwDrvID != NULL)
+      Close(pi);
+    return DRVCNF_OK;
+  case DRV_ENABLE:
+  case DRV_DISABLE:
+    return DRVCNF_OK;
+  case DRV_FREE:
+    return DRVCNF_OK;
+  case DRV_QUERYCONFIGURE:
+    return DRVCNF_CANCEL; /* FIXME */
+  case DRV_CONFIGURE:
+    return DRVCNF_OK;     /* FIXME */
+  case DRV_INSTALL:
+  case DRV_REMOVE:
+    return DRVCNF_OK;
+
+    /* installable compression manager messages */
+  case ICM_CONFIGURE:
+    FIXME("ICM_CONFIGURE (%ld)\n",lParam1);
+    if (lParam1 == -1)
+      return ICERR_UNSUPPORTED; /* FIXME */
+    else
+      return Configure(pi, (HWND)lParam1);
+  case ICM_ABOUT:
+    if (lParam1 == -1)
+      return ICERR_OK;
+    else
+      return About(pi, (HWND)lParam1);
+  case ICM_GETSTATE:
+  case ICM_SETSTATE:
+    return 0; /* no state */
+  case ICM_GETINFO:
+    return GetInfo(pi, (ICINFO*)lParam1, (DWORD)lParam2);
+  case ICM_GETDEFAULTQUALITY:
+    if ((LPVOID)lParam1 != NULL) {
+      *((LPDWORD)lParam1) = MSRLE32_DEFAULTQUALITY;
+      return ICERR_OK;
+    }
+    break;
+  case ICM_GETQUALITY:
+    if ((LPVOID)lParam1 != NULL) {
+      *((LPDWORD)lParam1) = pi->dwQuality;
+      return ICERR_OK;
+    }
+    break;
+  case ICM_SETQUALITY:
+    return SetQuality(pi, *(LPLONG)lParam1);
+    break;
+  case ICM_COMPRESS_GET_FORMAT:
+    return CompressGetFormat(pi, (LPCBITMAPINFOHEADER)lParam1,
+			     (LPBITMAPINFOHEADER)lParam2);
+  case ICM_COMPRESS_GET_SIZE:
+    return CompressGetSize(pi, (LPCBITMAPINFOHEADER)lParam1,
+			   (LPCBITMAPINFOHEADER)lParam2);
+  case ICM_COMPRESS_QUERY:
+    return CompressQuery(pi, (LPCBITMAPINFOHEADER)lParam1,
+			 (LPCBITMAPINFOHEADER)lParam2);
+  case ICM_COMPRESS_BEGIN:
+    return CompressBegin(pi, (LPCBITMAPINFOHEADER)lParam1,
+			 (LPCBITMAPINFOHEADER)lParam2);
+  case ICM_COMPRESS:
+    return Compress(pi, (ICCOMPRESS*)lParam1, (DWORD)lParam2);
+  case ICM_COMPRESS_END:
+    return CompressEnd(pi);
+  case ICM_DECOMPRESS_GET_FORMAT:
+    return DecompressGetFormat(pi, (LPCBITMAPINFOHEADER)lParam1,
+			       (LPBITMAPINFOHEADER)lParam2);
+  case ICM_DECOMPRESS_QUERY:
+    return DecompressQuery(pi, (LPCBITMAPINFOHEADER)lParam1,
+			   (LPCBITMAPINFOHEADER)lParam2);
+  case ICM_DECOMPRESS_BEGIN:
+    return DecompressBegin(pi, (LPCBITMAPINFOHEADER)lParam1,
+			   (LPCBITMAPINFOHEADER)lParam2);
+  case ICM_DECOMPRESS:
+    return Decompress(pi, (ICDECOMPRESS*)lParam1, (DWORD)lParam2);
+  case ICM_DECOMPRESS_END:
+    return DecompressEnd(pi);
+  case ICM_DECOMPRESS_SET_PALETTE:
+    FIXME("(...) -> SetPalette(%p,%p,%p): stub!\n", pi, (LPVOID)lParam1, (LPVOID)lParam2);
+    return ICERR_UNSUPPORTED;
+  case ICM_DECOMPRESS_GET_PALETTE:
+    return DecompressGetPalette(pi, (LPBITMAPINFOHEADER)lParam1,
+				(LPBITMAPINFOHEADER)lParam2);
+  case ICM_GETDEFAULTKEYFRAMERATE:
+    if ((LPVOID)lParam1 != NULL)
+      *(LPDWORD)lParam1 = 15;
+    return ICERR_OK;
+  default:
+    if (uMsg < DRV_USER)
+      return DefDriverProc(dwDrvID, hDrv, uMsg, lParam1, lParam2);
+    else
+      FIXME("Unknown message uMsg=0x%08X lParam1=0x%08lX lParam2=0x%08lX\n",uMsg,lParam1,lParam2);
+  };
+
+  return ICERR_UNSUPPORTED;
+}
+
+/* DllMain - library initialization code */
+BOOL WINAPI MSRLE32_DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved)
+{
+  TRACE("(%p,%ld,%p)\n",(LPVOID)hModule,dwReason,lpReserved);
+
+  switch (dwReason) {
+  case DLL_PROCESS_ATTACH:
+    if (MSRLE32_hModule == 0)
+      MSRLE32_hModule = hModule;
+    break;
+  case DLL_THREAD_ATTACH:
+    break;
+  case DLL_THREAD_DETACH:
+    break;
+  case DLL_PROCESS_DETACH:
+    break;
+  };
+
+  return TRUE;
+}
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/msvideo/msrle32/msrle32.spec	Mon Oct  7 22:16:36 2002
@@ -0,0 +1,3 @@
+init MSRLE32_DllMain
+
+@ stdcall DriverProc(long long long long long) MSRLE32_DriverProc
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/msvideo/msrle32/msrle_private.h	Mon Oct  7 22:08:20 2002
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2002 Michael Günnewig
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef __MSRLE32_PRIVATE_H
+#define __MSRLE32_PRIVATE_H
+
+#include "winbase.h"
+#include "mmsystem.h"
+#include "vfw.h"
+
+#define IDS_NAME        100
+#define IDS_DESCRIPTION 101
+#define IDS_ABOUT       102
+
+#define MSRLE32_VERSION  0x00010000 /* Version 1.0 build 0 */
+#define MSRLE32_DEFAULTQUALITY (75 * ICQUALITY_HIGH) / 100
+
+#define FOURCC_RLE   mmioFOURCC('R','L','E',' ')
+#define FOURCC_RLE4  mmioFOURCC('R','L','E','4')
+#define FOURCC_RLE8  mmioFOURCC('R','L','E','8')
+#define FOURCC_MRLE  mmioFOURCC('M','R','L','E')
+
+#define WIDTHBYTES(i)     ((WORD)((i+31)&(~31))/8) /* ULONG aligned ! */
+#define DIBWIDTHBYTES(bi) WIDTHBYTES((WORD)(bi).biWidth * (WORD)(bi).biBitCount)
+
+typedef struct _CodecInfo {
+  FOURCC  fccHandler;
+  DWORD   dwQuality;
+
+  BOOL    bCompress;
+  LONG    nPrevFrame;
+  LPWORD  pPrevFrame;
+  LPWORD  pCurFrame;
+
+  BOOL    bDecompress;
+  LPBYTE  palette_map;
+} CodecInfo;
+
+typedef const BITMAPINFOHEADER * LPCBITMAPINFOHEADER;
+
+#endif
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/msvideo/msrle32/rsrc.rc	Mon Oct  7 22:56:32 2002
@@ -0,0 +1,29 @@
+/*
+ * Top level resource file for MS-RLE
+ *
+ * Copyright 2002 Michael Günnewig
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "windef.h"
+
+#include "msrle_private.h"
+
+/*
+ * Everything specific to any language goes
+ * in one of the specific files.
+ * Note that you can and may override resources
+ * which also have a neutral version. This is to
+ * get localized bitmaps for example.
+ */
+
+#include "msrle_En.rc"
+#include "msrle_De.rc"
+#include "msrle_Fr.rc"
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/msvideo/msrle32/msrle_En.rc	Mon Oct  7 22:56:30 2002
@@ -0,0 +1,22 @@
+/*
+ * English resource file for MS-RLE
+ *
+ * Copyright 2002 Michael Günnewig
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+LANGUAGE LANG_ENGLISH, SUBLANG_DEFAULT
+
+STRINGTABLE DISCARDABLE
+{
+	IDS_NAME	"WINE-MS-RLE"
+	IDS_DESCRIPTION	"Wine MS-RLE video codec"
+	IDS_ABOUT       "Wine MS-RLE video codec\nCopyright 2002 by Michael Günnewig"
+}
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/msvideo/msrle32/msrle_De.rc	Mon Oct  7 22:56:29 2002
@@ -0,0 +1,22 @@
+/*
+ * German resource file for MS-RLE
+ *
+ * Copyright 2002 Michael Günnewig
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+LANGUAGE LANG_GERMAN, SUBLANG_DEFAULT
+
+STRINGTABLE DISCARDABLE
+{
+	IDS_NAME	"WINE-MS-RLE"
+	IDS_DESCRIPTION	"Wine MS-RLE Videodekoder"
+	IDS_ABOUT       "Wine MS-RLE Videodekoder\nCopyright 2002 by Michael Günnewig"
+}
--- /dev/null	Thu Jan  1 01:00:00 1970
+++ dlls/msvideo/msrle32/msrle_Fr.rc	Mon Oct  7 22:56:30 2002
@@ -0,0 +1,22 @@
+/*
+ * French resource file for MS-RLE
+ *
+ * Copyright 2002 Michael Günnewig
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+LANGUAGE LANG_FRENCH, SUBLANG_DEFAULT
+
+STRINGTABLE DISCARDABLE
+{
+	IDS_NAME	"WINE-MS-RLE"
+	IDS_DESCRIPTION	"Wine: décodeur/encodeur vidéo MS-RLE"
+	IDS_ABOUT       "Wine: décodeur/encodeur vidéo MS-RLE\nCopyright 2002 par Michael Günnewig"
+}

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux