mirror of
https://github.com/reactos/reactos.git
synced 2024-08-20 02:13:29 +00:00
1925 lines
51 KiB
C
1925 lines
51 KiB
C
/*
|
|
* Copyright 2002-2003 Michael Günnewig
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
/* TODO:
|
|
* - some improvements possible
|
|
* - implement DecompressSetPalette? -- do we need it for anything?
|
|
*/
|
|
|
|
#include <assert.h>
|
|
|
|
#include "msrle_private.h"
|
|
|
|
#include "winnls.h"
|
|
#include "winuser.h"
|
|
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(msrle32);
|
|
|
|
static HINSTANCE MSRLE32_hModule = 0;
|
|
|
|
#define compare_fourcc(fcc1, fcc2) (((fcc1)^(fcc2))&~0x20202020)
|
|
|
|
static inline WORD ColorCmp(WORD clr1, WORD clr2)
|
|
{
|
|
UINT a = clr1 - clr2;
|
|
return a * a;
|
|
}
|
|
static 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 BYTE MSRLE32_GetNearestPaletteIndex(UINT count, const RGBQUAD *clrs, RGBQUAD clr);
|
|
|
|
/* compression functions */
|
|
static void computeInternalFrame(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn, const BYTE *lpIn);
|
|
static LONG MSRLE32_GetMaxCompressedSize(LPCBITMAPINFOHEADER lpbi);
|
|
static LRESULT MSRLE32_CompressRLE4(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
|
|
const BYTE *lpIn, LPBITMAPINFOHEADER lpbiOut,
|
|
LPBYTE lpOut, BOOL isKey);
|
|
static LRESULT MSRLE32_CompressRLE8(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
|
|
const BYTE *lpIn, LPBITMAPINFOHEADER lpbiOut,
|
|
LPBYTE lpOut, BOOL isKey);
|
|
|
|
/* decompression functions */
|
|
static LRESULT MSRLE32_DecompressRLE4(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
|
|
const BYTE *lpIn, LPBYTE lpOut);
|
|
static LRESULT MSRLE32_DecompressRLE8(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
|
|
const BYTE *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(const 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 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) * (DWORD)lpbi->biHeight >= (1UL << 31) - 1)
|
|
return FALSE; /* image too big ! */
|
|
|
|
/* check for nonexistent 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 idx = 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) {
|
|
idx = i;
|
|
diff = r;
|
|
if (diff == 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return idx;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
void computeInternalFrame(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn, const BYTE *lpIn)
|
|
{
|
|
WORD wIntensityTbl[256];
|
|
DWORD lInLine, lOutLine;
|
|
LPWORD lpOut;
|
|
UINT i;
|
|
LONG y;
|
|
|
|
/* pre-conditions */
|
|
assert(pi != NULL && lpbiIn != NULL && lpIn != NULL);
|
|
assert(pi->pCurFrame != NULL);
|
|
|
|
lInLine = DIBWIDTHBYTES(*lpbiIn);
|
|
lOutLine = WIDTHBYTES((WORD)lpbiIn->biWidth * 8u * sizeof(WORD)) / 2u;
|
|
lpOut = pi->pCurFrame;
|
|
|
|
assert(lpbiIn->biClrUsed != 0);
|
|
|
|
{
|
|
const RGBQUAD *lp =
|
|
(const RGBQUAD *)((const BYTE*)lpbiIn + lpbiIn->biSize);
|
|
|
|
for (i = 0; i < lpbiIn->biClrUsed; i++)
|
|
wIntensityTbl[i] = Intensity(lp[i]);
|
|
}
|
|
|
|
for (y = 0; y < lpbiIn->biHeight; y++) {
|
|
LONG x;
|
|
|
|
switch (lpbiIn->biBitCount) {
|
|
case 1:
|
|
for (x = 0; x < lpbiIn->biWidth / 8; x++) {
|
|
for (i = 0; i < 7; i++)
|
|
lpOut[8 * x + i] = wIntensityTbl[(lpIn[x] >> (7 - i)) & 1];
|
|
}
|
|
break;
|
|
case 4:
|
|
for (x = 0; x < lpbiIn->biWidth / 2; x++) {
|
|
lpOut[2 * x + 0] = wIntensityTbl[(lpIn[x] >> 4)];
|
|
lpOut[2 * 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 + 2;
|
|
}
|
|
|
|
/* lpP => current pos in previous frame
|
|
* lpA => previous pos in current frame
|
|
* lpB => current pos in current frame
|
|
*/
|
|
static INT countDiffRLE4(const WORD *lpP, const WORD *lpA, const WORD *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 at least ?? more encodable pixels */
|
|
if (pos + 2 < width && ColorCmp(clr1,lpB[pos+1]) <= lDist &&
|
|
ColorCmp(clr2,lpB[pos+2]) <= lDist) {
|
|
if (pos + 4 < width && ColorCmp(lpB[pos+1],lpB[pos+3]) <= lDist &&
|
|
ColorCmp(lpB[pos+2],lpB[pos+4]) <= lDist)
|
|
return count - 3; /* followed by at least 4 encodable pixels */
|
|
return count - 2;
|
|
}
|
|
} else if (lpP != NULL && ColorCmp(lpP[pos], lpB[pos]) <= lDist) {
|
|
/* 'compare' with previous frame for end of diff */
|
|
INT count2 = 0;
|
|
|
|
/* FIXME */
|
|
|
|
if (count2 >= 8)
|
|
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(const WORD *lpP, const WORD *lpA, const WORD *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 some more encodable pixel */
|
|
if (pos + 1 < width && ColorCmp(lpB[pos], lpB[pos+1]) <= lDist)
|
|
return count - 1;
|
|
if (pos + 2 < width && ColorCmp(lpB[pos+1], lpB[pos+2]) <= lDist)
|
|
return count - 1;
|
|
} 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(const CodecInfo *pi, const WORD *lpP,
|
|
const WORD *lpC, LPCBITMAPINFOHEADER lpbi,
|
|
const 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);
|
|
|
|
assert(count > 0);
|
|
|
|
/* check for near end of line */
|
|
if (x + count > lpbi->biWidth)
|
|
count = lpbi->biWidth - x;
|
|
|
|
/* absolute pixel(s) in groups of at least 3 and at most 254 pixels */
|
|
while (count > 2) {
|
|
INT i;
|
|
INT size = min(count, 254);
|
|
int bytes = ((size + 1) & (~1)) / 2;
|
|
int extra_byte = bytes & 0x01;
|
|
|
|
*lpSizeImage += 2 + bytes + extra_byte;
|
|
assert(((*lpSizeImage) % 2) == 0);
|
|
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 little 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(const CodecInfo *pi, const WORD *lpP,
|
|
const WORD *lpC, LPCBITMAPINFOHEADER lpbi,
|
|
const BYTE *lpIn, 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++]) > 0)
|
|
break;
|
|
}
|
|
|
|
if (count < 2) {
|
|
/* add some more pixels for absoluting if possible */
|
|
count += countDiffRLE8(lpP, lpC - 1, lpC, pos-1, 0, lpbi->biWidth);
|
|
|
|
assert(count > 0);
|
|
|
|
/* check for over end of line */
|
|
if (x + count > lpbi->biWidth)
|
|
count = lpbi->biWidth - x;
|
|
|
|
/* absolute pixel(s) in groups of at least 3 and at most 255 pixels */
|
|
while (count > 2) {
|
|
INT i;
|
|
INT size = min(count, 255);
|
|
int 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 little 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(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
|
|
const BYTE *lpIn, LPBITMAPINFOHEADER lpbiOut,
|
|
LPBYTE lpOut, BOOL isKey)
|
|
{
|
|
LPWORD lpC;
|
|
LONG lLine, lInLine;
|
|
LPBYTE lpOutStart = lpOut;
|
|
|
|
/* pre-conditions */
|
|
assert(pi != NULL && lpbiOut != NULL);
|
|
assert(lpIn != NULL && lpOut != NULL);
|
|
assert(pi->pCurFrame != NULL);
|
|
|
|
lpC = pi->pCurFrame;
|
|
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, 0, x,
|
|
&lpOut, &lpbiOut->biSizeImage);
|
|
} while (x < lpbiOut->biWidth);
|
|
|
|
lpC += lLine;
|
|
lpIn += lInLine;
|
|
|
|
/* add EOL -- end of line */
|
|
lpbiOut->biSizeImage += 2;
|
|
*(LPWORD)lpOut = 0;
|
|
lpOut += sizeof(WORD);
|
|
assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
|
|
}
|
|
} 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]) > 0)
|
|
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;
|
|
lpOut += sizeof(WORD);
|
|
}
|
|
|
|
/* 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, 0, 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;
|
|
lpOut += sizeof(WORD);
|
|
assert(lpOut == lpOutStart + lpbiOut->biSizeImage);
|
|
}
|
|
}
|
|
|
|
/* add EOL -- will be changed to EOI */
|
|
lpbiOut->biSizeImage += 2;
|
|
*((LPWORD)lpOut) = 0;
|
|
lpOut += sizeof(WORD);
|
|
}
|
|
|
|
/* change EOL to EOI -- end of image */
|
|
lpOut[-1] = 1;
|
|
assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
|
|
|
|
return ICERR_OK;
|
|
}
|
|
|
|
LRESULT MSRLE32_CompressRLE8(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
|
|
const BYTE *lpIn, LPBITMAPINFOHEADER lpbiOut,
|
|
LPBYTE lpOut, BOOL isKey)
|
|
{
|
|
LPWORD lpC;
|
|
LONG lInLine, lLine;
|
|
LPBYTE lpOutStart = lpOut;
|
|
|
|
assert(pi != NULL && lpbiOut != NULL);
|
|
assert(lpIn != NULL && lpOut != NULL);
|
|
assert(pi->pCurFrame != NULL);
|
|
|
|
lpC = pi->pCurFrame;
|
|
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, x,
|
|
&lpOut, &lpbiOut->biSizeImage);
|
|
assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
|
|
} while (x < lpbiOut->biWidth);
|
|
|
|
lpC += lLine;
|
|
lpIn += lInLine;
|
|
|
|
/* add EOL -- end of line */
|
|
lpbiOut->biSizeImage += 2;
|
|
*((LPWORD)lpOut) = 0;
|
|
lpOut += sizeof(WORD);
|
|
assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
|
|
}
|
|
} 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]) > 0)
|
|
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 an EOL then jump */
|
|
assert(jumpy > 0);
|
|
|
|
jumpx = 0;
|
|
jumpy--;
|
|
|
|
/* add EOL -- end of line */
|
|
lpbiOut->biSizeImage += 2;
|
|
*((LPWORD)lpOut) = 0;
|
|
lpOut += sizeof(WORD);
|
|
assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
|
|
}
|
|
|
|
/* 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, x,
|
|
&lpOut, &lpbiOut->biSizeImage);
|
|
assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
|
|
}
|
|
} while (x < lpbiOut->biWidth);
|
|
|
|
lpP += lLine;
|
|
lpC += lLine;
|
|
lpIn += lInLine;
|
|
|
|
if (jumpy == 0) {
|
|
/* add EOL -- end of line */
|
|
lpbiOut->biSizeImage += 2;
|
|
*((LPWORD)lpOut) = 0;
|
|
lpOut += sizeof(WORD);
|
|
assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
|
|
}
|
|
}
|
|
|
|
/* add EOL */
|
|
lpbiOut->biSizeImage += 2;
|
|
*((LPWORD)lpOut) = 0;
|
|
lpOut += sizeof(WORD);
|
|
}
|
|
|
|
/* add EOI -- end of image */
|
|
lpbiOut->biSizeImage += 2;
|
|
*lpOut++ = 0;
|
|
*lpOut++ = 1;
|
|
assert(lpOut == (lpOutStart + lpbiOut->biSizeImage));
|
|
|
|
return ICERR_OK;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static LRESULT MSRLE32_DecompressRLE4(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
|
|
const BYTE *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 + 1) & (~1)) / 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 + 1 <= 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 + 1 <= 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 + 1 <= 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;
|
|
}
|
|
}
|
|
}
|
|
if (code0 & 0x01) {
|
|
if (bytes_per_pixel == 1) {
|
|
code1 = lpIn[i];
|
|
lpOut[pixel_ptr++] = pi->palette_map[(code1 >> 4)];
|
|
} 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];
|
|
} 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;
|
|
}
|
|
lpIn++;
|
|
}
|
|
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(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbi,
|
|
const BYTE *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) > %d\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) > %d\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;
|
|
}
|
|
|
|
if (compare_fourcc(icinfo->fccType, ICTYPE_VIDEO)) return NULL;
|
|
|
|
TRACE("(%p = {%u,0x%08X(%4.4s),0x%08X(%4.4s),0x%X,0x%X,...})\n", icinfo,
|
|
icinfo->dwSize, icinfo->fccType, (char*)&icinfo->fccType,
|
|
icinfo->fccHandler, (char*)&icinfo->fccHandler,
|
|
icinfo->dwVersion,icinfo->dwFlags);
|
|
|
|
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%08X(%4.4s) !\n",
|
|
icinfo->fccHandler,(char*)&icinfo->fccHandler);
|
|
return NULL;
|
|
}
|
|
|
|
pi = LocalAlloc(LPTR, sizeof(CodecInfo));
|
|
|
|
if (pi != NULL) {
|
|
pi->fccHandler = icinfo->fccHandler;
|
|
|
|
pi->bCompress = FALSE;
|
|
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(pi);
|
|
return 1;
|
|
}
|
|
|
|
static LRESULT GetInfo(const 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 = ICTYPE_VIDEO;
|
|
icinfo->fccHandler = (pi != NULL ? pi->fccHandler : FOURCC_MRLE);
|
|
icinfo->dwFlags = VIDCF_QUALITY | VIDCF_TEMPORAL | VIDCF_CRUNCH | VIDCF_FASTTEMPORALC;
|
|
icinfo->dwVersion = ICVERSION;
|
|
icinfo->dwVersionICM = ICVERSION;
|
|
|
|
LoadStringW(MSRLE32_hModule, IDS_NAME, icinfo->szName, ARRAY_SIZE(icinfo->szName));
|
|
LoadStringW(MSRLE32_hModule, IDS_DESCRIPTION, icinfo->szDescription, ARRAY_SIZE(icinfo->szDescription));
|
|
|
|
return sizeof(ICINFO);
|
|
}
|
|
|
|
static LRESULT Configure(const CodecInfo *pi, HWND hWnd)
|
|
{
|
|
/* pre-condition */
|
|
assert(pi != NULL);
|
|
|
|
/* FIXME */
|
|
return ICERR_OK;
|
|
}
|
|
|
|
static LRESULT About(CodecInfo *pi, HWND hWnd)
|
|
{
|
|
WCHAR szTitle[20];
|
|
WCHAR szAbout[128];
|
|
|
|
/* pre-condition */
|
|
assert(MSRLE32_hModule != 0);
|
|
|
|
LoadStringW(MSRLE32_hModule, IDS_NAME, szTitle, ARRAY_SIZE(szTitle));
|
|
LoadStringW(MSRLE32_hModule, IDS_ABOUT, szAbout, ARRAY_SIZE(szAbout));
|
|
|
|
MessageBoxW(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 at least 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, 1 << lpbiOut->biBitCount);
|
|
lpbiOut->biClrImportant = 0;
|
|
|
|
memcpy((LPBYTE)lpbiOut + lpbiOut->biSize,
|
|
(const BYTE*)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 at least 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(const CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
|
|
LPCBITMAPINFOHEADER lpbiOut)
|
|
{
|
|
/* pre-condition */
|
|
assert(pi != NULL);
|
|
|
|
/* need at least 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)
|
|
{
|
|
const RGBQUAD *rgbIn;
|
|
const RGBQUAD *rgbOut;
|
|
UINT 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 same 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 = GlobalLock(GlobalAlloc(GPTR, size * sizeof(WORD)));
|
|
if (pi->pPrevFrame == NULL)
|
|
return ICERR_MEMORY;
|
|
pi->pCurFrame = GlobalLock(GlobalAlloc(GPTR, size * sizeof(WORD)));
|
|
if (pi->pCurFrame == NULL) {
|
|
CompressEnd(pi);
|
|
return ICERR_MEMORY;
|
|
}
|
|
pi->nPrevFrame = -1;
|
|
pi->bCompress = TRUE;
|
|
|
|
rgbIn = (const RGBQUAD*)((const BYTE*)lpbiIn + lpbiIn->biSize);
|
|
rgbOut = (const RGBQUAD*)((const BYTE*)lpbiOut + lpbiOut->biSize);
|
|
|
|
switch (lpbiOut->biBitCount) {
|
|
case 4:
|
|
case 8:
|
|
pi->palette_map = 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)
|
|
{
|
|
BOOL is_key;
|
|
int i;
|
|
|
|
TRACE("(%p,%p,%u)\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%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);
|
|
|
|
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;
|
|
|
|
pi->pPrevFrame = pi->pCurFrame;
|
|
pi->pCurFrame = pTmp;
|
|
} else if ((lpic->dwFlags & ICCOMPRESS_KEYFRAME) == 0) {
|
|
LPWORD pTmp;
|
|
|
|
WARN(": prev=%d cur=%d gone back? -- untested\n",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=%d cur=%d 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 too much time and they are of equal size ! */
|
|
pTmp = pi->pPrevFrame;
|
|
pi->pPrevFrame = pi->pCurFrame;
|
|
pi->pCurFrame = pTmp;
|
|
pi->nPrevFrame = lpic->lFrameNum;
|
|
}
|
|
|
|
is_key = (lpic->dwFlags & ICCOMPRESS_KEYFRAME) != 0;
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
lpic->lpbiOutput->biSizeImage = 0;
|
|
|
|
if (lpic->lpbiOutput->biBitCount == 4)
|
|
MSRLE32_CompressRLE4(pi, lpic->lpbiInput, lpic->lpInput, lpic->lpbiOutput, lpic->lpOutput, is_key);
|
|
else
|
|
MSRLE32_CompressRLE8(pi, lpic->lpbiInput, lpic->lpInput, lpic->lpbiOutput, lpic->lpOutput, is_key);
|
|
|
|
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, lpic->lpInput,
|
|
lpic->lpbiOutput, lpic->lpOutput, TRUE);
|
|
else
|
|
MSRLE32_CompressRLE8(pi, lpic->lpbiInput, lpic->lpInput,
|
|
lpic->lpbiOutput, lpic->lpOutput, TRUE);
|
|
|
|
if (lpic->dwFrameSize == 0 ||
|
|
lpic->lpbiOutput->biSizeImage < lpic->dwFrameSize) {
|
|
WARN("switched to keyframe, was small enough!\n");
|
|
is_key = TRUE;
|
|
*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 too much time and they are of equal size ! */
|
|
LPWORD pTmp = pi->pPrevFrame;
|
|
|
|
pi->pPrevFrame = pi->pCurFrame;
|
|
pi->pCurFrame = pTmp;
|
|
pi->nPrevFrame = lpic->lFrameNum;
|
|
}
|
|
|
|
/* FIXME: What is AVIIF_TWOCC? */
|
|
*lpic->lpdwFlags |= AVIIF_TWOCC | (is_key ? AVIIF_KEYFRAME : 0);
|
|
return ICERR_OK;
|
|
}
|
|
|
|
static LRESULT CompressEnd(CodecInfo *pi)
|
|
{
|
|
TRACE("(%p)\n",pi);
|
|
|
|
if (pi != NULL) {
|
|
if (pi->pPrevFrame != NULL)
|
|
{
|
|
GlobalUnlock(GlobalHandle(pi->pPrevFrame));
|
|
GlobalFree(GlobalHandle(pi->pPrevFrame));
|
|
}
|
|
if (pi->pCurFrame != NULL)
|
|
{
|
|
GlobalUnlock(GlobalHandle(pi->pCurFrame));
|
|
GlobalFree(GlobalHandle(pi->pCurFrame));
|
|
}
|
|
pi->pPrevFrame = NULL;
|
|
pi->pCurFrame = NULL;
|
|
pi->nPrevFrame = -1;
|
|
pi->bCompress = FALSE;
|
|
|
|
if (pi->palette_map != NULL) {
|
|
LocalFree(pi->palette_map);
|
|
pi->palette_map = NULL;
|
|
}
|
|
}
|
|
|
|
return ICERR_OK;
|
|
}
|
|
|
|
static LRESULT DecompressGetFormat(CodecInfo *pi, LPCBITMAPINFOHEADER lpbiIn,
|
|
LPBITMAPINFOHEADER lpbiOut)
|
|
{
|
|
DWORD 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 (lpbiIn->biBitCount <= 8) {
|
|
int colors;
|
|
|
|
if (lpbiIn->biClrUsed == 0)
|
|
colors = 1 << lpbiIn->biBitCount;
|
|
else
|
|
colors = lpbiIn->biClrUsed;
|
|
|
|
size += colors * sizeof(RGBQUAD);
|
|
}
|
|
|
|
if (lpbiOut != NULL) {
|
|
memcpy(lpbiOut, lpbiIn, size);
|
|
lpbiOut->biCompression = BI_RGB;
|
|
lpbiOut->biSizeImage = DIBWIDTHBYTES(*lpbiOut) * lpbiOut->biHeight;
|
|
|
|
return ICERR_OK;
|
|
} 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 at least one format */
|
|
if (lpbiIn == NULL && lpbiOut == NULL)
|
|
return ICERR_BADPARAM;
|
|
|
|
/* check input format if given */
|
|
if (lpbiIn != NULL) {
|
|
if (!isSupportedMRLE(lpbiIn) && !isSupportedDIB(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)
|
|
{
|
|
const RGBQUAD *rgbIn;
|
|
const RGBQUAD *rgbOut;
|
|
UINT 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);
|
|
|
|
if (lpbiIn->biCompression != BI_RGB)
|
|
{
|
|
int colors;
|
|
|
|
if (lpbiIn->biBitCount <= 8 && lpbiIn->biClrUsed == 0)
|
|
colors = 1 << lpbiIn->biBitCount;
|
|
else
|
|
colors = lpbiIn->biClrUsed;
|
|
|
|
rgbIn = (const RGBQUAD*)((const BYTE*)lpbiIn + lpbiIn->biSize);
|
|
rgbOut = (const RGBQUAD*)((const BYTE*)lpbiOut + lpbiOut->biSize);
|
|
|
|
switch (lpbiOut->biBitCount) {
|
|
case 4:
|
|
case 8:
|
|
pi->palette_map = LocalAlloc(LPTR, colors);
|
|
if (pi->palette_map == NULL)
|
|
return ICERR_MEMORY;
|
|
|
|
for (i = 0; i < colors; i++)
|
|
pi->palette_map[i] = MSRLE32_GetNearestPaletteIndex(colors, rgbOut, rgbIn[i]);
|
|
break;
|
|
case 15:
|
|
case 16:
|
|
pi->palette_map = LocalAlloc(LPTR, colors * 2);
|
|
if (pi->palette_map == NULL)
|
|
return ICERR_MEMORY;
|
|
|
|
for (i = 0; i < colors; 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 = LocalAlloc(LPTR, colors * sizeof(RGBQUAD));
|
|
if (pi->palette_map == NULL)
|
|
return ICERR_MEMORY;
|
|
memcpy(pi->palette_map, rgbIn, colors * sizeof(RGBQUAD));
|
|
break;
|
|
};
|
|
}
|
|
pi->bDecompress = TRUE;
|
|
|
|
return ICERR_OK;
|
|
}
|
|
|
|
static LRESULT Decompress(CodecInfo *pi, ICDECOMPRESS *pic, DWORD dwSize)
|
|
{
|
|
TRACE("(%p,%p,%u)\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);
|
|
|
|
/* Uncompressed frame? */
|
|
if (pic->lpbiInput->biCompression == BI_RGB)
|
|
{
|
|
pic->lpbiOutput->biSizeImage = pic->lpbiInput->biSizeImage;
|
|
memcpy(pic->lpOutput, pic->lpInput, pic->lpbiOutput->biSizeImage);
|
|
return ICERR_OK;
|
|
}
|
|
|
|
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(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, (const BYTE*)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_PTR dwDrvID, HDRVR hDrv, UINT uMsg,
|
|
LPARAM lParam1, LPARAM lParam2)
|
|
{
|
|
CodecInfo *pi = (CodecInfo*)dwDrvID;
|
|
|
|
TRACE("(%lx,%p,0x%04X,0x%08lX,0x%08lX)\n", dwDrvID, hDrv, uMsg, lParam1, lParam2);
|
|
|
|
switch (uMsg) {
|
|
/* standard driver messages */
|
|
case DRV_LOAD:
|
|
return DRVCNF_OK;
|
|
case DRV_OPEN:
|
|
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_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 DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved)
|
|
{
|
|
TRACE("(%p,%d,%p)\n",hModule,dwReason,lpReserved);
|
|
|
|
switch (dwReason) {
|
|
case DLL_PROCESS_ATTACH:
|
|
DisableThreadLibraryCalls(hModule);
|
|
MSRLE32_hModule = hModule;
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|