|
|
/*-----------------------------------------------------------------------------+
| BLTPROP.C || || Emulates the 16 bit BLTPROP.ASM for WIN32 || || (C) Copyright Microsoft Corporation 1993. All rights reserved. || || Revision History || 21-Oct-1992 MikeTri Created || 09-Apr-1993 GeraintD Added error propagation| |+-----------------------------------------------------------------------------*/
#include <windows.h>
#include <stdlib.h>
#include "mplayer.h"
#include "bltprop.h"
/*
* 256 colour to 16 colour dithering by error propagation * * This function takes an 8-bit DIB using 256 colours and converts * it to a DIB that uses only 16 distinct colours. * * We take a pixel and convert it to one of the 16 standard vga colours * by taking each component and comparing it against a low and high * threshold. Less than the low gets 0 of that component; between low * and high gets an intensity of 128, and above the high threshold gets * an intensity of 255 for that component. (the standard 16 colours * have the 8 combinations of 0 or 128 for each component, and the * 8 combinations of 0 or 255 for each component - there are no colours * combining intensities of 255 and 128). So if any of our colours * are above the high threshold, we use 255 for any non-0 intensity. * We also have 2 grey levels that are picked out if all colour intensities * are less than a given threshold. * * The conversion is done by building an 8-bit value with bits set to * indicate if each component is above either of the two thresholds, * and then using this as a palette index. We thus use an output colour * table that contains 256 entries, though only 16 distinct colours. * * Having converted the pixel into the new palette index, we calculate the * difference for each r,g,b component between the original and the final * colour. We then add a fraction of this error to the adjacent pixels * along, down and diagonally. These error values are added to the * red, green and blue values for the adjacent pixels before comparing * against the thresholds in the colour conversion process. */
/*
* y error propagation - this contains the error for each component that * we wish to pass to the line below. Thus there is one entry for each * colour component for each pixel. The same max line length is assumed * in the win-16 version. */#define MAXBITMAPWIDTH 1500
typedef struct _colour_error { int red_error; int green_error; int blue_error;} colour_error, *pcolour_error;
colour_error y_error[MAXBITMAPWIDTH];
/*
* we take the difference between the actual and desired components, * multiply up by SCALE_UP, and then pass the result divided by SCALE_X * to both the pixel across and below, and divided by SCALE_Z to the pixel * diagonally across and below. (Below of course, means further down the * DIB, and therefore higher up the screen) */#define SCALE_UP 8
#define SCALE_X 32
#define SCALE_Z 64
/*
* The final pixel has the following form: * * bits 7x543210 * | |||||| * | |||||+-- set iff RED > HiThresh * | ||||+--- set iff RED > LoThresh * | |||+---- set iff GREEN > HiThresh * | ||+----- set iff GREEN > LoThresh * | |+------ set iff BLUE > HiThresh * | +------- set iff BLUE > LoThresh * +--------- set iff all colors > GrayThresh */
#define RED_HITHRESH 0x01
#define RED_LOTHRESH 0x02
#define GREEN_HITHRESH 0x04
#define GREEN_LOTHRESH 0x08
#define BLUE_HITHRESH 0x10
#define BLUE_LOTHRESH 0x20
#define GRAY_THRESH 0x80
#define ALL_HITHRESH (RED_HITHRESH | GREEN_HITHRESH | BLUE_HITHRESH)
#define ALL_LOTHRESH (RED_LOTHRESH | GREEN_LOTHRESH | BLUE_LOTHRESH)
/*
* convert a palette index in the above threshold format into the * rgb component values. */RGBQUADThresholdToRGB(int PalIndex){ RGBQUAD rgbq; BYTE RGBVal;
/* Special case greys */
if (PalIndex == (GRAY_THRESH | ALL_LOTHRESH)) {
rgbq.rgbRed = rgbq.rgbGreen = rgbq.rgbBlue = 0xc0;
} else if (PalIndex == GRAY_THRESH) {
rgbq.rgbRed = rgbq.rgbGreen = rgbq.rgbBlue = 0x80;
} else {
rgbq.rgbRed = 0; rgbq.rgbGreen = 0; rgbq.rgbBlue = 0;
/*
* if any components are above hi-threshold, then * use the high threshold for all non-zero components; otherwise * use the low threshold for all non-zero components. */ if (PalIndex & ALL_HITHRESH) { RGBVal = 0xff; } else { RGBVal = 0x80; }
if (PalIndex & (RED_HITHRESH | RED_LOTHRESH)) { rgbq.rgbRed = RGBVal; }
if (PalIndex & (GREEN_HITHRESH | GREEN_LOTHRESH)) { rgbq.rgbGreen = RGBVal; }
if (PalIndex & (BLUE_HITHRESH | BLUE_LOTHRESH)) { rgbq.rgbBlue = RGBVal; } }
return (rgbq);
}
/*
* copy a dib from pbSrc to pbDst reducing to 16 distinct colours */void FAR PASCAL BltProp(LPBITMAPINFOHEADER pbiSrc, LPBYTE pbSrc, UINT SrcX, UINT SrcY, UINT SrcXE, UINT SrcYE, LPBITMAPINFOHEADER pbiDst, LPBYTE pbDst, UINT DstX, UINT DstY){ UINT count, row, column; BYTE TempByte; BYTE ColourTableIndex;
int RedVal; int GreenVal; int BlueVal; colour_error x_error, z_error; int scaled_error, scaled_x, scaled_z; RGBQUAD rgbq;
LPBITMAPINFO ColourTable;
DPF2("BltProp");
/*
* clear the y_error to zero at start of bitmap */ for (count = 0; count < SrcXE; count++) { y_error[count].red_error = 0; y_error[count].green_error = 0; y_error[count].blue_error = 0; }
/*****************************************************************************\
* * Loop through the bitmap picking up the pixel r,g,b values, adjust for * the error propagated and then compare the components against the two * threshold values. The resulting byte has the following form: * * bits 7x543210 * | |||||| * | |||||+-- set iff RED > HiThresh * | ||||+--- set iff RED > LoThresh * | |||+---- set iff GREEN > HiThresh * | ||+----- set iff GREEN > LoThresh * | |+------ set iff BLUE > HiThresh * | +------- set iff BLUE > LoThresh * +--------- set iff all colors > GrayThresh * * This is an index into the 256-entry colour table generated below (that * uses only 16 distinct colours). * * After creating the correct colour, we calculate the difference between * this colour and the original, and propagate that error forwards and down. *\*****************************************************************************/
/* offset source, dest pointers by SrcX rows */ pbSrc += (SrcY * pbiSrc->biWidth) + SrcX; pbDst += (DstY * pbiDst->biWidth) + DstX; ColourTable = (LPBITMAPINFO)pbiSrc;
for (row=0; row < SrcYE ; row++) {
/* clear x error for start of row */ x_error.red_error = 0; x_error.green_error = 0; x_error.blue_error = 0; z_error.red_error = 0; z_error.green_error = 0; z_error.blue_error = 0;
for (column = 0; column < SrcXE; column++) {
/* pick up the source palette index and get rgb components */ ColourTableIndex = *pbSrc++; RedVal = ColourTable->bmiColors[ColourTableIndex].rgbRed; GreenVal = ColourTable->bmiColors[ColourTableIndex].rgbGreen; BlueVal = ColourTable->bmiColors[ColourTableIndex].rgbBlue;
/* add on error - x-error is propagated from
* previous column. y-error is passed down from pixel above. * z-error is passed diagonally and has already been added * into y-error for this pixel. */ RedVal += x_error.red_error + y_error[column].red_error; GreenVal += x_error.green_error + y_error[column].green_error; BlueVal += x_error.blue_error + y_error[column].blue_error;
/*
* As we move along the line, y_error[] for the pixels * ahead of us contains the error to be added to the pixels * on this row. y_error[] for the pixels we have done contains * the error to be propagated to those pixels on the row * below. * * Now that we have picked up the error for this pixel, we * can start accumulating errors for this column on the * row below. We start with the z_error from the previous pixel * and then add in (later) the y_error from the current pixel. */ y_error[column] = z_error;
TempByte = 0x00; // Our "new" bitmap entry, once it has been munged
/*
* set threshold bits for each component based on adjusted colours */
if (RedVal > LoThresh) { TempByte |= RED_LOTHRESH; if (RedVal > HiThresh){ TempByte |= RED_HITHRESH; } } if (GreenVal > LoThresh) { TempByte |= GREEN_LOTHRESH; if (GreenVal > HiThresh){ TempByte |= GREEN_HITHRESH; } } if (BlueVal > LoThresh) { TempByte |= BLUE_LOTHRESH; if (BlueVal > HiThresh){ TempByte |= BLUE_HITHRESH; } }
/* set grey scale bit if all colours > grey threshold */ if ( (RedVal > GrayThresh) && (BlueVal > GrayThresh) && (GreenVal > GrayThresh) ) { TempByte |= GRAY_THRESH; }
/* we now have palette index into new colour table */ *pbDst++ = TempByte;
/*
* calculate difference for each component between * desired colour (after error adjustment) and actual * colour. Remember to add in to the y-error, since this * already contains the z_error from the previous cell. * Hold the z_error for this cell, since we can't add this * to the next y_error until we have used it for the next cell * on this row. * * do the scaling on the absolute values and then * put the sign back in afterwards - to make sure * we handle small negative numbers ok. */ rgbq = ThresholdToRGB(TempByte);
scaled_error = (RedVal - rgbq.rgbRed) * SCALE_UP; scaled_x = abs(scaled_error) / SCALE_X; scaled_z = abs(scaled_error) / SCALE_Z; x_error.red_error = (scaled_error > 0) ? scaled_x : -scaled_x; z_error.red_error = (scaled_error > 0) ? scaled_z : -scaled_z; y_error[column].red_error += x_error.red_error;
scaled_error = (GreenVal - rgbq.rgbGreen) * SCALE_UP; scaled_x = abs(scaled_error) / SCALE_X; scaled_z = abs(scaled_error) / SCALE_Z; x_error.green_error = (scaled_error > 0) ? scaled_x : -scaled_x; z_error.green_error = (scaled_error > 0) ? scaled_z : -scaled_z; y_error[column].green_error += x_error.green_error;
scaled_error = (BlueVal - rgbq.rgbBlue) * SCALE_UP; scaled_x = abs(scaled_error) / SCALE_X; scaled_z = abs(scaled_error) / SCALE_Z; x_error.blue_error = (scaled_error > 0) ? scaled_x : -scaled_x; z_error.blue_error = (scaled_error > 0) ? scaled_z : -scaled_z; y_error[column].blue_error += x_error.blue_error;
}
/* advance source and dest pointers from end of rectangle to start of
* next line */ pbSrc += pbiSrc->biWidth - SrcXE; pbDst += pbiDst->biWidth - SrcXE; }
DPF2("BltProp - finished first loop");/*****************************************************************************\
* * This part generates a new output colour table entry that is accessed by the * modified bitmap generated above, and updates the destination DIB colour * table with that new entry. *\*****************************************************************************/
ColourTable = (LPBITMAPINFO)pbiDst;
for (count=0; count<256; count++ ) {
/* Update the original colour table within the destination DIB */
ColourTable->bmiColors[count] = ThresholdToRGB(count);
} DPF2("BltProp - finished second loop");}
|
