Leaked source code of windows server 2003
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.
 
 
 
 
 
 

384 lines
13 KiB

/*-----------------------------------------------------------------------------+
| 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.
*/
RGBQUAD
ThresholdToRGB(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");
}