archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/multimedia/media/avi/drawdib.16/dith775.c

898 lines
25 KiB
Raw Blame History

//////////////////////////////////////////////////////////////////////////////
//
// DITH775.C - full color dither (to a palette with 7 red, 7 green 5 blue
// levels)
//
// NOTE this file contains the 'C' code and DITH775A.ASM has the ASM code.
//
// This file does the following dithering
//
// 24bpp -> 8bpp
// 16bpp -> 8bpp
//
// 8bpp -> 4bpp N/I
// 16bpp -> 4bpp N/I
// 24bpp -> 4bpp N/I
//
// Using four different methods
//
// Lookup - fastest 1 table lookup per 16bpp pel (160K for table)
// Scale - fast 2 table lookups per 16bpp pel (128K for tables)
// Table - fast 3 table lookups plus shifting (~1K for tables)
//
// Lookup and Scale are 386 asm code *only* (in dith775a.asm)
// Table is in 'C' and 386 asm.
//
//////////////////////////////////////////////////////////////////////////////
#include <windows.h>
#include <windowsx.h>
#include "drawdibi.h"
#include "dither.h"
#include "dith775.h"
//#define OLDDITHER
#ifdef WIN32
#define DITHER_DEFAULT DITHER_TABLEC
#else
#define DITHER_DEFAULT DITHER_SCALE
#endif
#define DITHER_TABLEC 0 // table based 'C' code
#define DITHER_TABLE 1 // table based assembler
#define DITHER_SCALE 2 // scale tables
#define DITHER_LOOKUP 3 // 5 lookup tables!
UINT wDitherMethod = (UINT)-1;
LPVOID Dither16InitScale(void);
LPVOID Dither16InitLookup(void);
int giDitherTableUsage = 0;
LPVOID glpDitherTable;
static void Get775Colors(LPBITMAPINFOHEADER lpbi);
//////////////////////////////////////////////////////////////////////////////
//
//
//////////////////////////////////////////////////////////////////////////////
void FAR PASCAL Dither24C(LPBITMAPINFOHEADER,LPVOID,int,int,int,int,LPBITMAPINFOHEADER,LPVOID,int,int,LPVOID);
void FAR PASCAL Dither24S(LPBITMAPINFOHEADER,LPVOID,int,int,int,int,LPBITMAPINFOHEADER,LPVOID,int,int,LPVOID);
void FAR PASCAL Dither32C(LPBITMAPINFOHEADER,LPVOID,int,int,int,int,LPBITMAPINFOHEADER,LPVOID,int,int,LPVOID);
void FAR PASCAL Dither32S(LPBITMAPINFOHEADER,LPVOID,int,int,int,int,LPBITMAPINFOHEADER,LPVOID,int,int,LPVOID);
void FAR PASCAL Dither16C(LPBITMAPINFOHEADER,LPVOID,int,int,int,int,LPBITMAPINFOHEADER,LPVOID,int,int,LPVOID);
void FAR PASCAL Dither16T(LPBITMAPINFOHEADER,LPVOID,int,int,int,int,LPBITMAPINFOHEADER,LPVOID,int,int,LPVOID);
void FAR PASCAL Dither16L(LPBITMAPINFOHEADER,LPVOID,int,int,int,int,LPBITMAPINFOHEADER,LPVOID,int,int,LPVOID);
void FAR PASCAL Dither16S(LPBITMAPINFOHEADER,LPVOID,int,int,int,int,LPBITMAPINFOHEADER,LPVOID,int,int,LPVOID);
//////////////////////////////////////////////////////////////////////////////
//
// DitherTableInit()
//
//////////////////////////////////////////////////////////////////////////////
static LPVOID DitherTableInit()
{
// no need to re-init table.
if (glpDitherTable || wDitherMethod != (UINT)-1)
{
giDitherTableUsage++;
return glpDitherTable;
}
//
// choose a dither method
//
if (wDitherMethod == -1)
{
wDitherMethod = DITHER_DEFAULT;
}
#ifdef DEBUG
wDitherMethod = (int)GetProfileInt(TEXT("DrawDib"), TEXT("DitherMethod"), (UINT)wDitherMethod);
#endif
switch (wDitherMethod)
{
default:
case DITHER_TABLEC:
case DITHER_TABLE:
break;
#ifndef WIN32
case DITHER_SCALE:
glpDitherTable = Dither16InitScale();
if (glpDitherTable == NULL)
wDitherMethod = DITHER_TABLE;
break;
case DITHER_LOOKUP:
glpDitherTable = Dither16InitLookup();
if (glpDitherTable == NULL)
wDitherMethod = DITHER_TABLE;
break;
#endif // WIN32
}
giDitherTableUsage = 1;
return glpDitherTable;
}
//////////////////////////////////////////////////////////////////////////////
//
// DitherTableFree()
//
//////////////////////////////////////////////////////////////////////////////
void FAR PASCAL DitherTableFree()
{
if (giDitherTableUsage == 0 || --giDitherTableUsage > 0)
return;
if (glpDitherTable)
{
GlobalFreePtr(glpDitherTable);
glpDitherTable = NULL;
wDitherMethod = (UINT)-1;
}
}
//////////////////////////////////////////////////////////////////////////////
//
// DitherInit()
//
//////////////////////////////////////////////////////////////////////////////
LPVOID FAR PASCAL Dither8Init(LPBITMAPINFOHEADER lpbi, LPBITMAPINFOHEADER lpbiOut, DITHERPROC FAR *lpDitherProc, LPVOID lpDitherTable)
{
return DitherDeviceInit(lpbi, lpbiOut, lpDitherProc, lpDitherTable);
}
//////////////////////////////////////////////////////////////////////////////
//
// DitherInit()
//
//////////////////////////////////////////////////////////////////////////////
LPVOID FAR PASCAL Dither16Init(LPBITMAPINFOHEADER lpbi, LPBITMAPINFOHEADER lpbiOut, DITHERPROC FAR *lpDitherProc, LPVOID lpDitherTable)
{
Get775Colors(lpbiOut);
//
// choose a dither method
//
if (lpDitherTable == NULL)
lpDitherTable = DitherTableInit();
switch (wDitherMethod)
{
default:
case DITHER_TABLEC:
*lpDitherProc = Dither16C;
break;
#ifndef WIN32
case DITHER_TABLE:
*lpDitherProc = Dither16T;
break;
case DITHER_SCALE:
*lpDitherProc = Dither16S;
break;
case DITHER_LOOKUP:
*lpDitherProc = Dither16L;
break;
#endif // WIN32
}
return lpDitherTable;
}
//////////////////////////////////////////////////////////////////////////////
//
// DitherTerm()
//
//////////////////////////////////////////////////////////////////////////////
void FAR PASCAL Dither16Term(LPVOID lpDitherTable)
{
DitherTableFree();
}
//////////////////////////////////////////////////////////////////////////////
//
// Dither24Init()
//
//////////////////////////////////////////////////////////////////////////////
LPVOID FAR PASCAL Dither24Init(LPBITMAPINFOHEADER lpbi, LPBITMAPINFOHEADER lpbiOut, DITHERPROC FAR *lpDitherProc, LPVOID lpDitherTable)
{
Get775Colors(lpbiOut);
//
// choose a dither method
//
if (lpDitherTable == NULL)
lpDitherTable = DitherTableInit();
switch (wDitherMethod)
{
default:
case DITHER_TABLE:
case DITHER_TABLEC:
*lpDitherProc = Dither24C;
break;
#ifndef WIN32
case DITHER_SCALE:
*lpDitherProc = Dither24S;
break;
#endif // WIN32
}
return lpDitherTable;
}
//////////////////////////////////////////////////////////////////////////////
//
// Dither24Term()
//
//////////////////////////////////////////////////////////////////////////////
void FAR PASCAL Dither24Term(LPVOID lpDitherTable)
{
DitherTableFree();
}
//////////////////////////////////////////////////////////////////////////////
//
// Dither32Init()
//
//////////////////////////////////////////////////////////////////////////////
LPVOID FAR PASCAL Dither32Init(LPBITMAPINFOHEADER lpbi, LPBITMAPINFOHEADER lpbiOut, DITHERPROC FAR *lpDitherProc, LPVOID lpDitherTable)
{
// no need to re-init table.
Get775Colors(lpbiOut);
//
// choose a dither method
//
if (lpDitherTable == NULL)
lpDitherTable = DitherTableInit();
switch (wDitherMethod)
{
default:
case DITHER_TABLE:
case DITHER_TABLEC:
*lpDitherProc = Dither32C;
break;
#ifndef WIN32
case DITHER_SCALE:
*lpDitherProc = Dither32S;
break;
#endif // WIN32
}
return lpDitherTable;
}
//////////////////////////////////////////////////////////////////////////////
//
// Dither32Term()
//
//////////////////////////////////////////////////////////////////////////////
void FAR PASCAL Dither32Term(LPVOID lpDitherTable)
{
DitherTableFree();
}
//////////////////////////////////////////////////////////////////////////////
//
// Dither16InitScale()
//
//////////////////////////////////////////////////////////////////////////////
LPVOID Dither16InitScale()
{
LPVOID p;
LPBYTE pbLookup;
LPWORD pwScale;
UINT r,g,b;
p = GlobalAllocPtr(GMEM_MOVEABLE|GMEM_SHARE, 32768l*2+64000);
if (p == NULL)
return NULL;
pwScale = (LPWORD)p;
for (r=0; r<32; r++)
for (g=0; g<32; g++)
for (b=0; b<32; b++)
*pwScale++ = 1600 * r + 40 * g + b;
/* should this be WORD or UINT ? */
pbLookup = (LPBYTE)(((WORD _huge *)p) + 32768l);
for (r=0; r<40; r++)
for (g=0; g<40; g++)
for (b=0; b<40; b++)
*pbLookup++ = lookup775[35*rlevel[r] + 5*glevel[g] + blevel[b]];
return p;
}
//////////////////////////////////////////////////////////////////////////////
//
// Dither16InitLookup()
//
//////////////////////////////////////////////////////////////////////////////
LPVOID Dither16InitLookup()
{
LPVOID p;
BYTE _huge *pb;
UINT r,g,b,i,j;
p = GlobalAllocPtr(GHND|GMEM_SHARE, 32768l*5);
if (p == NULL)
return NULL;
pb = (BYTE _huge *)p;
for (i=0; i<5; i++) {
j = ((i < 3) ? i*2 : i*2-1);
for (r=0; r<32; r++) {
for (g=0; g<32; g++) {
for (b=0; b<32; b++) {
*pb++ = lookup775[rlevel[r+i]*35 + glevel[g+i]*5 + blevel[b+j]];
}
}
}
}
return p;
}
//////////////////////////////////////////////////////////////////////////////
//
// GetDithColors() get the dither palette
//
//////////////////////////////////////////////////////////////////////////////
static void Get775Colors(LPBITMAPINFOHEADER lpbi)
{
LPRGBQUAD prgb = (LPRGBQUAD)(((LPBYTE)lpbi) + (UINT)lpbi->biSize);
int i;
for (i=0; i<256; i++)
{
prgb[i].rgbRed = dpal775[i][0];
prgb[i].rgbGreen = dpal775[i][1];
prgb[i].rgbBlue = dpal775[i][2];
prgb[i].rgbReserved = 0;
}
lpbi->biClrUsed = 256;
}
#if 0
//////////////////////////////////////////////////////////////////////////////
//
// CreateDith775Palette() create the dither palette
//
//////////////////////////////////////////////////////////////////////////////
HPALETTE FAR CreateDith775Palette()
{
int i;
HDC hdc;
HPALETTE hpal;
struct {
WORD palVersion;
WORD palNumEntries;
PALETTEENTRY palPalEntry[256];
} pal;
pal.palVersion = 0x300;
pal.palNumEntries = 256;
for (i=0; i<(int)pal.palNumEntries; i++)
{
pal.palPalEntry[i].peRed = dpal775[i][0];
pal.palPalEntry[i].peGreen = dpal775[i][1];
pal.palPalEntry[i].peBlue = dpal775[i][2];
pal.palPalEntry[i].peFlags = PC_NOCOLLAPSE;
}
#ifndef OLDDITHER
//
// our palette is built assuming the "cosmic" colors at the
// beging and the end. so put the real mcoy there!
//
hdc = GetDC(NULL);
if (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE)
{
GetSystemPaletteEntries(hdc, 0, 10, &pal.palPalEntry[0]);
GetSystemPaletteEntries(hdc, 246, 10, &pal.palPalEntry[246]);
}
ReleaseDC(NULL, hdc);
#endif
hpal = CreatePalette((LPLOGPALETTE)&pal);
return hpal;
}
#endif
//////////////////////////////////////////////////////////////////////////////
//
// Dither24TC - dither from 24 to 8 using the Table method in 'C' Code
//
//////////////////////////////////////////////////////////////////////////////
void FAR PASCAL Dither24C(
LPBITMAPINFOHEADER biDst, // --> BITMAPINFO of the dest
LPVOID lpDst, // --> to destination bits
int DstX, // Destination origin - x coordinate
int DstY, // Destination origin - y coordinate
int DstXE, // x extent of the BLT
int DstYE, // y extent of the BLT
LPBITMAPINFOHEADER biSrc, // --> BITMAPINFO of the source
LPVOID lpSrc, // --> to source bits
int SrcX, // Source origin - x coordinate
int SrcY, // Source origin - y coordinate
LPVOID lpDitherTable) // dither table.
{
int x,y;
int r,g,b;
UINT wWidthSrc;
UINT wWidthDst;
BYTE _huge *pbS;
BYTE _huge *pbD;
if (biDst->biBitCount != 8 || biSrc->biBitCount != 24)
return;
DstXE &= ~3;
wWidthSrc = ((UINT)biSrc->biWidth*3+3)&~3;
wWidthDst = ((UINT)biDst->biWidth+3)&~3;
pbD = (BYTE _huge *)lpDst + DstX + (DWORD)(UINT)DstY * (DWORD)wWidthDst;
pbS = (BYTE _huge *)lpSrc + SrcX*3 + (DWORD)(UINT)SrcY * (DWORD)wWidthSrc;
wWidthSrc -= DstXE*3;
wWidthDst -= DstXE;
#define GET24() \
b = (int)*pbS++; \
g = (int)*pbS++; \
r = (int)*pbS++;
#define DITHER24(mr, mg, mb) \
GET24(); *pbD++ = (BYTE)lookup775[ rdith775[r + mr] + gdith775[g + mg] + ((b + mb) >> 6) ];
for (y=0; y<DstYE; y++) {
switch (y & 3) {
case 0:
for (x=0; x<DstXE; x+=4)
{
DITHER24( 1, 1, 2);
DITHER24( 17, 17, 26);
DITHER24( 25, 25, 38);
DITHER24( 41, 41, 62);
}
break;
case 1:
for (x=0; x<DstXE; x+=4)
{
DITHER24( 31, 31, 46);
DITHER24( 36, 36, 54);
DITHER24( 7, 7, 10);
DITHER24( 12, 12, 18);
}
break;
case 2:
for (x=0; x<DstXE; x+=4)
{
DITHER24( 20, 20, 30);
DITHER24( 4, 4, 6);
DITHER24( 39, 39, 58);
DITHER24( 23, 23, 34);
}
break;
case 3:
for (x=0; x<DstXE; x+=4)
{
DITHER24( 33, 33, 50);
DITHER24( 28, 28, 42);
DITHER24( 15, 15, 22);
DITHER24( 9, 9, 14);
}
break;
} /*switch*/
pbS += wWidthSrc;
pbD += wWidthDst;
}
}
//////////////////////////////////////////////////////////////////////////////
//
// Dither32C - dither from 32 to 8 using the Table method in 'C' Code
//
//////////////////////////////////////////////////////////////////////////////
void FAR PASCAL Dither32C(
LPBITMAPINFOHEADER biDst, // --> BITMAPINFO of the dest
LPVOID lpDst, // --> to destination bits
int DstX, // Destination origin - x coordinate
int DstY, // Destination origin - y coordinate
int DstXE, // x extent of the BLT
int DstYE, // y extent of the BLT
LPBITMAPINFOHEADER biSrc, // --> BITMAPINFO of the source
LPVOID lpSrc, // --> to source bits
int SrcX, // Source origin - x coordinate
int SrcY, // Source origin - y coordinate
LPVOID lpDitherTable) // dither table.
{
int x,y;
int r,g,b;
UINT wWidthSrc;
UINT wWidthDst;
BYTE _huge *pbS;
BYTE _huge *pbD;
if (biDst->biBitCount != 8 || biSrc->biBitCount != 32)
return;
DstXE &= ~3;
wWidthSrc = ((UINT)biSrc->biWidth*4+3)&~3;
wWidthDst = ((UINT)biDst->biWidth+3)&~3;
pbD = (BYTE _huge *)lpDst + DstX + (DWORD)(UINT)DstY * (DWORD)wWidthDst;
pbS = (BYTE _huge *)lpSrc + SrcX*4 + (DWORD)(UINT)SrcY * (DWORD)wWidthSrc;
wWidthSrc -= DstXE*4;
wWidthDst -= DstXE;
#define GET32() \
b = (int)*pbS++; \
g = (int)*pbS++; \
r = (int)*pbS++; \
pbS++;
#define DITHER32(mr, mg, mb) \
GET32(); *pbD++ = (BYTE)lookup775[ rdith775[r + mr] + gdith775[g + mg] + ((b + mb) >> 6) ];
for (y=0; y<DstYE; y++) {
switch (y & 3) {
case 0:
for (x=0; x<DstXE; x+=4)
{
DITHER32( 1, 1, 2);
DITHER32( 17, 17, 26);
DITHER32( 25, 25, 38);
DITHER32( 41, 41, 62);
}
break;
case 1:
for (x=0; x<DstXE; x+=4)
{
DITHER32( 31, 31, 46);
DITHER32( 36, 36, 54);
DITHER32( 7, 7, 10);
DITHER32( 12, 12, 18);
}
break;
case 2:
for (x=0; x<DstXE; x+=4)
{
DITHER32( 20, 20, 30);
DITHER32( 4, 4, 6);
DITHER32( 39, 39, 58);
DITHER32( 23, 23, 34);
}
break;
case 3:
for (x=0; x<DstXE; x+=4)
{
DITHER32( 33, 33, 50);
DITHER32( 28, 28, 42);
DITHER32( 15, 15, 22);
DITHER32( 9, 9, 14);
}
break;
} /*switch*/
pbS += wWidthSrc;
pbD += wWidthDst;
}
}
//////////////////////////////////////////////////////////////////////////////
//
// Dither16TC - dither from 16 to 8 using the Table method in 'C' Code
//
//////////////////////////////////////////////////////////////////////////////
void FAR PASCAL Dither16C(
LPBITMAPINFOHEADER biDst, // --> BITMAPINFO of the dest
LPVOID lpDst, // --> to destination bits
int DstX, // Destination origin - x coordinate
int DstY, // Destination origin - y coordinate
int DstXE, // x extent of the BLT
int DstYE, // y extent of the BLT
LPBITMAPINFOHEADER biSrc, // --> BITMAPINFO of the source
LPVOID lpSrc, // --> to source bits
int SrcX, // Source origin - x coordinate
int SrcY, // Source origin - y coordinate
LPVOID lpDitherTable) // dither table.
{
int x,y;
int r,g,b;
WORD w;
UINT wWidthSrc;
UINT wWidthDst;
BYTE _huge *pbS;
BYTE _huge *pbD;
if (biDst->biBitCount != 8 || biSrc->biBitCount != 16)
return;
DstXE = DstXE & ~3; // round down!
wWidthSrc = ((UINT)biSrc->biWidth*2+3)&~3;
wWidthDst = ((UINT)biDst->biWidth+3)&~3;
pbD = (BYTE _huge *)lpDst + DstX + (DWORD)(UINT)DstY * (DWORD)wWidthDst;
pbS = (BYTE _huge *)lpSrc + SrcX*2 + (DWORD)(UINT)SrcY * (DWORD)wWidthSrc;
wWidthSrc -= DstXE*2;
wWidthDst -= DstXE;
#define GET16() \
w = *((WORD _huge *)pbS)++; \
r = (int)((w >> 7) & 0xF8); \
g = (int)((w >> 2) & 0xF8); \
b = (int)((w << 3) & 0xF8);
#define DITHER16(mr, mg, mb) \
GET16(); *pbD++ = (BYTE)lookup775[ rdith775[r + mr] + gdith775[g + mg] + ((b + mb) >> 6)];
for (y=0; y<DstYE; y++) {
switch (y & 3) {
case 0:
for (x=0; x<DstXE; x+=4)
{
DITHER16( 1, 1, 2);
DITHER16( 17, 17, 26);
DITHER16( 25, 25, 38);
DITHER16( 41, 41, 62);
}
break;
case 1:
for (x=0; x<DstXE; x+=4)
{
DITHER16( 31, 31, 46);
DITHER16( 36, 36, 54);
DITHER16( 7, 7, 10);
DITHER16( 12, 12, 18);
}
break;
case 2:
for (x=0; x<DstXE; x+=4)
{
DITHER16( 20, 20, 30);
DITHER16( 4, 4, 6);
DITHER16( 39, 39, 58);
DITHER16( 23, 23, 34);
}
break;
case 3:
for (x=0; x<DstXE; x+=4)
{
DITHER16( 33, 33, 50);
DITHER16( 28, 28, 42);
DITHER16( 15, 15, 22);
DITHER16( 9, 9, 14);
}
break;
} /*switch*/
pbS += wWidthSrc;
pbD += wWidthDst;
}
}
//////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////
#if 0
//
// this is the original code
//
//
void Dith775ScanLine(Rbuf, Gbuf, Bbuf, n, row, paloffset)
DWORD n; // pixels per row
int *Rbuf, *Gbuf, *Bbuf;
int row; // distance from top of image
WORD *paloffset;
{
int i;
// DITHER(x,y,rgb)
switch (row & 3)
{
case 0:
for (i=0; i<n; i+=4)
{
paloffset[i] = lookup775[ rdith775[Rbuf[i] + 1] + gdith775[Gbuf[i] + 1] + ((Bbuf[i] + 2) >> 6) ];
paloffset[i+1] = lookup775[ rdith775[Rbuf[i+1] + 17] + gdith775[Gbuf[i+1] + 17] + ((Bbuf[i+1] + 26) >> 6) ];
paloffset[i+2] = lookup775[ rdith775[Rbuf[i+2] + 25] + gdith775[Gbuf[i+2] + 25] + ((Bbuf[i+2] + 38) >> 6) ];
paloffset[i+3] = lookup775[ rdith775[Rbuf[i+3] + 41] + gdith775[Gbuf[i+3] + 41] + ((Bbuf[i+3] + 62) >> 6) ];
}
break;
case 1:
for (i=0; i<n; i+=4)
{
paloffset[i] = lookup775[ rdith775[Rbuf[i] + 31] + gdith775[Gbuf[i] + 31] + ((Bbuf[i] + 46) >> 6) ];
paloffset[i+1] = lookup775[ rdith775[Rbuf[i+1] + 36] + gdith775[Gbuf[i+1] + 36] + ((Bbuf[i+1] + 54) >> 6) ];
paloffset[i+2] = lookup775[ rdith775[Rbuf[i+2] + 7] + gdith775[Gbuf[i+2] + 7] + ((Bbuf[i+2] + 10) >> 6) ];
paloffset[i+3] = lookup775[ rdith775[Rbuf[i+3] + 12] + gdith775[Gbuf[i+3] + 12] + ((Bbuf[i+3] + 18) >> 6) ];
}
break;
case 2:
for (i=0; i<n; i+=4)
{
paloffset[i] = lookup775[ rdith775[Rbuf[i] + 20] + gdith775[Gbuf[i] + 20] + ((Bbuf[i] + 30) >> 6) ];
paloffset[i+1] = lookup775[ rdith775[Rbuf[i+1] + 4] + gdith775[Gbuf[i+1] + 4] + ((Bbuf[i+1] + 6) >> 6) ];
paloffset[i+2] = lookup775[ rdith775[Rbuf[i+2] + 39] + gdith775[Gbuf[i+2] + 39] + ((Bbuf[i+2] + 58) >> 6) ];
paloffset[i+3] = lookup775[ rdith775[Rbuf[i+3] + 23] + gdith775[Gbuf[i+3] + 23] + ((Bbuf[i+3] + 34) >> 6) ];
}
break;
case 3:
for (i=0; i<n; i+=4)
{
paloffset[i] = lookup775[ rdith775[Rbuf[i] + 33] + gdith775[Gbuf[i] + 33] + ((Bbuf[i] + 50) >> 6) ];
paloffset[i+1] = lookup775[ rdith775[Rbuf[i+1] + 28] + gdith775[Gbuf[i+1] + 28] + ((Bbuf[i+1] + 42) >> 6) ];
paloffset[i+2] = lookup775[ rdith775[Rbuf[i+2] + 15] + gdith775[Gbuf[i+2] + 15] + ((Bbuf[i+2] + 22) >> 6) ];
paloffset[i+3] = lookup775[ rdith775[Rbuf[i+3] + 9] + gdith775[Gbuf[i+3] + 9] + ((Bbuf[i+3] + 14) >> 6) ];
}
break;
} /*switch*/
}
#endif
#if 0
{
HPALETTE hpalT;
HWND hwnd;
BYTE xlat[256];
int fh;
static BOOL fHack = TRUE;
OFSTRUCT of;
char buf[80];
//
// convert palette to a palette that mappes 1:1 to the system
// palette, this will allow us to draw faster
//
hwnd = GetActiveWindow();
hdc = GetDC(hwnd);
if (fHack && (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE))
{
fHack = FALSE;
for (i=0; i<(int)pal.palNumEntries; i++)
{
pal.palPalEntry[i].peRed = (BYTE)0;
pal.palPalEntry[i].peGreen = (BYTE)0;
pal.palPalEntry[i].peBlue = (BYTE)0;
pal.palPalEntry[i].peFlags = (BYTE)PC_RESERVED;
}
hpalT = CreatePalette((LPLOGPALETTE)&pal);
hpalT = SelectPalette(hdc, hpalT, FALSE);
RealizePalette(hdc);
hpalT = SelectPalette(hdc, hpalT, FALSE);
DeleteObject(hpalT);
hpalT = SelectPalette(hdc, hpal, FALSE);
RealizePalette(hdc);
GetSystemPaletteEntries(hdc, 0, 256, pal.palPalEntry);
SelectPalette(hdc, hpalT, FALSE);
PostMessage(hwnd, WM_QUERYNEWPALETTE, 0, 0);
for (i=0; i<256; i++)
{
// this wont work right for dup's in the palette
j = GetNearestPaletteIndex(hpal,RGB(pal.palPalEntry[i].peRed,
pal.palPalEntry[i].peGreen,pal.palPalEntry[i].peBlue));
xlat[j] = (BYTE)i;
}
SetPaletteEntries(hpal, 0, 256, pal.palPalEntry);
for (i=0; i < sizeof(lookup775)/sizeof(lookup775[0]); i++)
lookup775[i] = xlat[lookup775[i]];
//
// dump the new palette and lookup table out.
//
fh = OpenFile("c:/foo775.h", &of, OF_CREATE|OF_READWRITE);
if (fh != -1)
{
wsprintf(buf, "BYTE lookup775[245] = {\r\n");
_lwrite(fh, buf, lstrlen(buf));
for (i=0; i < sizeof(lookup775)/sizeof(lookup775[0]); i++) {
wsprintf(buf, "%3d,", lookup775[i]);
if (i % 16 == 0 && i != 0)
_lwrite(fh, "\r\n", 2);
_lwrite(fh, buf, lstrlen(buf));
}
wsprintf(buf, "}\r\n\r\nint dpal775[256][3] = {\r\n");
_lwrite(fh, buf, lstrlen(buf));
for (i=0; i < 256; i++) {
wsprintf(buf, "{0x%02x, 0x%02x, 0x%02x},",
pal.palPalEntry[i].peRed,
pal.palPalEntry[i].peGreen,
pal.palPalEntry[i].peBlue);
if (i % 4 == 0 && i != 0)
_lwrite(fh, "\r\n", 2);
_lwrite(fh, buf, lstrlen(buf));
}
wsprintf(buf, "}\r\n");
_lwrite(fh, buf, lstrlen(buf));
_lclose(fh);
}
}
ReleaseDC(hwnd, hdc);
}
#endif