/*
* StretchC.C
*
* StretchBlt for DIBs
*
* C version of stretch.asm: StretchDIB optimised for AVI.
*
* NOTES
* - does not handle mirroring in x or y
* - does not handle pixel translation
* - will not work in place.
*
* AUTHOR
* C version by Geraint Davies
*/
#include <windows.h>
#include "drawdibi.h"
#include "stretch.h"
/* Outline:
*
* we select a y-stretching function depending on the ratio (eg 1:N or N:1).
* it copies scanlines from source to destination, duplicating or omitting
* scanlines as necessary to fit the destination. It copies each scanline
* via the X_FUNC function we passed as an argument: this copies one scanline
* duplicating or omitting pixels to fit the destination: we select an X_FUNC
* depending on the bit-depth as well as the x-stretching ratio.
*
* both x and y stretching functions use the following basic model for deciding
* when to insert/omit elements:
*
* delta = <larger extent> -1;
*
* for (number of destination elements) {
*
* copy one element
* advance pointer to larger region
* delta -= <smaller extent>
* if (delta < 0) {
* delta += <larger extent>;
* advance pointer to smaller region
* }
* }
*/
/* stretch proportions */
#define STRETCH_1_1 1
#define STRETCH_1_2 2
#define STRETCH_1_4 3
#define STRETCH_1_N 4
#define STRETCH_N_1 5
#define STRETCH_4_1 6
#define STRETCH_2_1 7
/*
* an X_FUNC is a function that copies one scanline, stretching or shrinking it
* to fit a destination scanline. Pick an X_FUNC depending on
* bitdepth and stretch ratio (1:1, 1:2, 1:4, 1:N, N:1, 4:1, 2:1)
*
* the x_fract argument is the delta fraction: it is a representation
* of the smaller extent (whichever that is) as a fraction of the larger,
* and is used when stretching or shrinking to advance the pointer to the
* smaller scanline every (fract) pixels of the larger.
* Thus if we are expanding 1:8, x_fract will be 1/8, we will advance the
* source pointer once every 8 pixels, and thus copy each source pixel to
* 8 dest pixels. Note that if shrinking 8:1, x_fract will still be 1/8
* and we will use it to control advancement of the dest pointer.
* the fraction is multiplied by 65536.
*/
typedef void (*X_FUNC) (LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract);
void X_Stretch_1_1_8Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE, int DstXE, int x_fract);
void X_Stretch_1_2_8Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE, int DstXE, int x_fract);
void X_Stretch_1_4_8Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE, int DstXE, int x_fract);
void X_Stretch_1_N_8Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE, int DstXE, int x_fract);
void X_Stretch_N_1_8Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE, int DstXE, int x_fract);
void X_Stretch_1_1_16Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE, int DstXE, int x_fract);
void X_Stretch_1_2_16Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE, int DstXE, int x_fract);
void X_Stretch_1_N_16Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE, int DstXE, int x_fract);
void X_Stretch_N_1_16Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE, int DstXE, int x_fract);
void X_Stretch_1_1_24Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE, int DstXE, int x_fract);
void X_Stretch_1_N_24Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE, int DstXE, int x_fract);
void X_Stretch_N_1_24Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE, int DstXE, int x_fract);
/*
* Y_Stretch_* functions copy DstYE scanlines (using
* an X_FUNC to copy each scanline) omitting or duplicating scanlines to
* fit the destination extent. Pick a Y_ depending on the ratio
* (1:N, N:1...)
*/
void Y_Stretch_1_N(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE,int SrcYE, int DstXE,
int DstYE, int SrcWidth, int DstWidth, int x_fract,
X_FUNC x_func);
void Y_Stretch_N_1(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE,int SrcYE, int DstXE,
int DstYE, int SrcWidth, int DstWidth, int x_fract,
X_FUNC x_func);
/*
* special case y-stretch functions for 1:2 in both dimensions for 8 and 16 bits
* takes no X_FUNC arg. Will do entire stretch.
*/
void Stretch_1_2_8Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE,int SrcYE, int DstXE,
int DstYE, int SrcWidth, int DstWidth, int x_fract);
void Stretch_1_2_16Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE,int SrcYE, int DstXE,
int DstYE, int SrcWidth, int DstWidth, int x_fract);
/* straight copy of one scanline of count bytes */
void X_CopyScanline(LPBYTE lpSrc, LPBYTE lpDst, int count);
/* -------------------------------------------------------------------- */
/*
* StretchFactor
*
* calculate the stretch factor (proportion of source extent to destination
* extent: 1:1, 1:2, 1:4, 1:N, N:1, 4:1,or 2:1) and also the
* delta fraction (see above comment on X_FUNC). This is the ratio of
* the smaller extent to the larger extent, represented as a fraction
* multiplied by 65536.
*
* returns: the stretch factor (stores the delta fraction in *pfract)
*/
int
StretchFactor(int SrcE, int DstE, int *pfract)
{
if (SrcE == DstE) {
if (pfract != NULL) {
pfract = 0;
}
return(STRETCH_1_1);
}
if (SrcE > DstE) {
if (pfract != NULL) {
*pfract = ( (DstE << 16) / SrcE) & 0xffff;
}
if (SrcE == (DstE * 2)) {
return(STRETCH_2_1);
} else if (SrcE == (DstE * 4)) {
return(STRETCH_4_1);
} else {
return(STRETCH_N_1);
}
} else {
/* calculate delta fraction based on smallest / largest */
if (pfract != NULL) {
*pfract = ( (SrcE << 16) / DstE) & 0xffff;
}
if (DstE == (SrcE * 2)) {
return(STRETCH_1_2);
} else if (DstE == (SrcE * 4)) {
return(STRETCH_1_4);
} else {
return(STRETCH_1_N);
}
}
}
/* -------------------------------------------------------------------- */
/*
* StretchDIB
*
*/
void FAR PASCAL
StretchDIB(
LPBITMAPINFOHEADER biDst, // --> BITMAPINFO of destination
LPVOID lpvDst, // --> 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 source
LPVOID lpvSrc, // --> to source bits
int SrcX, // Source origin - x coordinate
int SrcY, // Source origin - y coordinate
int SrcXE, // x extent of the BLT
int SrcYE // y extent of the BLT
)
{
int nBits;
int SrcWidth, DstWidth;
LPBYTE lpDst = lpvDst, lpSrc = lpvSrc;
int x_fract;
int x_factor;
int y_factor;
X_FUNC xfunc;
/*
* check that bit depths are same and 8, 16 or 24
*/
if ((nBits = biDst->biBitCount) != biSrc->biBitCount) {
return;
}
if ( (nBits != 8 ) && (nBits != 16) && (nBits != 24)) {
return;
}
/*
* check that extents are not bad
*/
if ( (SrcXE <= 0) || (SrcYE <= 0) || (DstXE <= 0) || (DstYE <= 0)) {
return;
}
/*
* calculate width of one scan line in bytes, rounded up to
* DWORD boundary.
*/
SrcWidth = (((biSrc->biWidth * nBits) + 31) & ~31) / 8;
DstWidth = (((biDst->biWidth * nBits) + 31) & ~31) / 8;
/*
* set initial source and dest pointers
*/
lpSrc += (SrcY * SrcWidth) + ((SrcX * nBits) / 8);
lpDst += (DstY * DstWidth) + ((DstX * nBits) / 8);
/*
* calculate stretch proportions (1:1, 1:2, 1:N, N:1 etc) and
* also the fractional stretch factor. (we are not interested in
* the y stretch fraction - this is only used in x stretching.
*/
y_factor = StretchFactor(SrcYE, DstYE, NULL);
x_factor = StretchFactor(SrcXE, DstXE, &x_fract);
/*
* we have special case routines for 1:2 in both dimensions
* for 8 and 16 bits
*/
if ((y_factor == x_factor) && (y_factor == STRETCH_1_2)) {
if (nBits == 8) {
StartCounting();
Stretch_1_2_8Bits(lpSrc, lpDst, SrcXE, SrcYE,
DstXE, DstYE, SrcWidth, DstWidth,
x_fract);
EndCounting("8 bit");
return;
} else if (nBits == 16) {
StartCounting();
Stretch_1_2_16Bits(lpSrc, lpDst, SrcXE, SrcYE,
DstXE, DstYE, SrcWidth, DstWidth,
x_fract);
EndCounting("16 bit");
return;
}
}
/* pick an X stretch function */
switch(nBits) {
case 8:
switch(x_factor) {
case STRETCH_1_1:
xfunc = X_Stretch_1_1_8Bits;
break;
case STRETCH_1_2:
xfunc = X_Stretch_1_2_8Bits;
break;
case STRETCH_1_4:
xfunc = X_Stretch_1_4_8Bits;
break;
case STRETCH_1_N:
xfunc = X_Stretch_1_N_8Bits;
break;
case STRETCH_N_1:
case STRETCH_4_1:
case STRETCH_2_1:
xfunc = X_Stretch_N_1_8Bits;
break;
}
break;
case 16:
switch(x_factor) {
case STRETCH_1_1:
xfunc = X_Stretch_1_1_16Bits;
break;
case STRETCH_1_2:
xfunc = X_Stretch_1_2_16Bits;
break;
case STRETCH_1_4:
case STRETCH_1_N:
xfunc = X_Stretch_1_N_16Bits;
break;
case STRETCH_N_1:
case STRETCH_4_1:
case STRETCH_2_1:
xfunc = X_Stretch_N_1_16Bits;
break;
}
break;
case 24:
switch(x_factor) {
case STRETCH_1_1:
xfunc = X_Stretch_1_1_24Bits;
break;
case STRETCH_1_2:
case STRETCH_1_4:
case STRETCH_1_N:
xfunc = X_Stretch_1_N_24Bits;
break;
case STRETCH_N_1:
case STRETCH_4_1:
case STRETCH_2_1:
xfunc = X_Stretch_N_1_24Bits;
break;
}
break;
}
/*
* now call appropriate stretching function depending
* on the y stretch factor
*/
switch (y_factor) {
case STRETCH_1_1:
case STRETCH_1_2:
case STRETCH_1_4:
case STRETCH_1_N:
Y_Stretch_1_N(lpSrc, lpDst, SrcXE, SrcYE,
DstXE, DstYE, SrcWidth, DstWidth, x_fract, xfunc);
break;
case STRETCH_N_1:
case STRETCH_4_1:
case STRETCH_2_1:
Y_Stretch_N_1(lpSrc, lpDst, SrcXE, SrcYE,
DstXE, DstYE, SrcWidth, DstWidth, x_fract, xfunc);
break;
}
return;
}
/* ---- y stretching -------------------------------------------- */
/*
* call an X_FUNC to copy scanlines from lpSrc to lpDst. Duplicate or
* omit scanlines to stretch SrcYE to DstYE.
*/
/*
* Y_Stretch_1_N
*
* write DstYE scanlines based on SrcYE scanlines, DstYE > SrcYE
*
*/
void
Y_Stretch_1_N(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int SrcYE,
int DstXE,
int DstYE,
int SrcWidth,
int DstWidth,
int x_fract,
X_FUNC x_func)
{
int ydelta;
int i;
LPBYTE lpPrev = NULL;
ydelta = DstYE -1;
for (i = 0; i < DstYE; i++) {
/* have we already stretched this scanline ? */
if (lpPrev == NULL) {
/* no - copy one scanline */
(*x_func)(lpSrc, lpDst, SrcXE, DstXE, x_fract);
lpPrev = lpDst;
} else {
/* yes - this is a duplicate scanline. do
* a straight copy of one that has already
* been stretched/shrunk
*/
X_CopyScanline(lpPrev, lpDst, DstWidth);
}
/* advance dest pointer */
lpDst += DstWidth;
/* should we advance source pointer this time ? */
if ( (ydelta -= SrcYE) < 0) {
ydelta += DstYE;
lpSrc += SrcWidth;
lpPrev = NULL;
}
}
}
/*
* Y_Stretch_N_1
*
* write DstYE scanlines based on SrcYE scanlines, DstYE < SrcYE
*
*/
void
Y_Stretch_N_1(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int SrcYE,
int DstXE,
int DstYE,
int SrcWidth,
int DstWidth,
int x_fract,
X_FUNC x_func)
{
int ydelta;
int i;
ydelta = SrcYE -1;
for (i = 0; i < DstYE; i++) {
/* copy one scanline */
(*x_func)(lpSrc, lpDst, SrcXE, DstXE, x_fract);
/* advance dest pointer */
lpDst += DstWidth;
/* how many times do we advance source pointer this time ? */
do {
lpSrc += SrcWidth;
ydelta -= DstYE;
} while (ydelta >= 0);
ydelta += SrcYE;
}
}
/* ---8-bit X stretching -------------------------------------------------- */
/*
* X_Stretch_1_N_8Bits
*
* copy one scan line, stretching 1:N (DstXE > SrcXE). For 8-bit depth.
*/
void
X_Stretch_1_N_8Bits(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract)
{
int xdelta;
int i;
xdelta = DstXE -1;
for (i = 0; i < DstXE; i++) {
/* copy one byte and advance dest */
*lpDst++ = *lpSrc;
/* should we advance source pointer this time ? */
if ( (xdelta -= SrcXE) < 0) {
xdelta += DstXE;
lpSrc++;
}
}
}
/*
* X_Stretch_N_1_8Bits
*
* copy one scan line, shrinking N:1 (DstXE < SrcXE). For 8-bit depth.
*/
void
X_Stretch_N_1_8Bits(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract)
{
int xdelta;
int i;
xdelta = SrcXE -1;
for (i = 0; i < DstXE; i++) {
/* copy one byte and advance dest */
*lpDst++ = *lpSrc;
/* how many times do we advance source pointer this time ? */
do {
lpSrc++;
xdelta -= DstXE;
} while (xdelta >= 0);
xdelta += SrcXE;
}
}
/*
* copy one scanline of count bytes from lpSrc to lpDst. used by 1:1
* scanline functions for all bit depths
*/
void
X_CopyScanline(LPBYTE lpSrc, LPBYTE lpDst, int count)
{
int i;
/*
* if the alignment of lpSrc and lpDst is the same, then
* we can get them aligned and do a faster copy
*/
if (((DWORD) lpSrc & 0x3) == ( (DWORD) lpDst & 0x3)) {
/* align on WORD boundary */
if ( (DWORD) lpSrc & 0x1) {
*lpDst++ = *lpSrc++;
count--;
}
/* align on DWORD boundary */
if ((DWORD) lpSrc & 0x2) {
* ((LPWORD) lpDst) = *((LPWORD) lpSrc);
lpDst += sizeof(WORD);
lpSrc += sizeof(WORD);
count -= sizeof(WORD);
}
/* copy whole DWORDS */
for ( i = (count / 4); i > 0; i--) {
*((LPDWORD) lpDst) = *((LPDWORD) lpSrc);
lpSrc += sizeof(DWORD);
lpDst += sizeof(DWORD);
}
} else {
/* the lpSrc and lpDst pointers are different
* alignment, so leave them unaligned and
* copy all the whole DWORDs
*/
for (i = (count / 4); i> 0; i--) {
*( (DWORD UNALIGNED FAR *) lpDst) =
*((DWORD UNALIGNED FAR *) lpSrc);
lpSrc += sizeof(DWORD);
lpDst += sizeof(DWORD);
}
}
/* in either case, copy last (up to 3) bytes. */
for ( i = count % 4; i > 0; i--) {
*lpDst++ = *lpSrc++;
}
}
/*
* X_Stretch_1_1_8Bits
*
* copy a scanline with no change (1:1)
*/
void
X_Stretch_1_1_8Bits(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract)
{
X_CopyScanline(lpSrc, lpDst, DstXE);
}
/*
* X_Stretch_1_2_8Bits
*
* copy a scanline, doubling all the pixels (1:2)
*/
void
X_Stretch_1_2_8Bits(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract)
{
WORD wPix;
int i;
for (i = 0; i < SrcXE; i++) {
/* get a pixel and double it */
wPix = *lpSrc++;
wPix |= (wPix << 8);
* ((WORD UNALIGNED *) lpDst) = wPix;
lpDst += sizeof(WORD);
}
}
/*
* X_Stretch_1_4_8Bits
*
* copy a scanline, quadrupling all the pixels (1:4)
*/
void
X_Stretch_1_4_8Bits(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract)
{
DWORD dwPix;
int i;
for (i = 0; i < SrcXE; i++) {
/* get a pixel and make four copies of it */
dwPix = *lpSrc++;
dwPix |= (dwPix <<8);
dwPix |= (dwPix << 16);
* ((DWORD UNALIGNED *) lpDst) = dwPix;
lpDst += sizeof(DWORD);
}
}
/* -- 16-bit X functions -----------------------------------------------*/
/*
* copy one scan-line of 16 bits with no change (1:1)
*/
void
X_Stretch_1_1_16Bits(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract)
{
X_CopyScanline(lpSrc, lpDst, DstXE * sizeof(WORD));
}
/*
* copy one scanline of 16 bpp duplicating each pixel
*/
void
X_Stretch_1_2_16Bits(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract)
{
DWORD dwPix;
int i;
for (i = 0; i < SrcXE; i++) {
/* get a pixel and double it */
dwPix = * ((WORD *)lpSrc);
dwPix |= (dwPix << 16);
* ((DWORD UNALIGNED *) lpDst) = dwPix;
lpDst += sizeof(DWORD);
lpSrc += sizeof(WORD);
}
}
/*
* copy one scanline of 16 bits, stretching 1:n (dest > source)
*/
void
X_Stretch_1_N_16Bits(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract)
{
int xdelta;
int i;
xdelta = DstXE -1;
for (i = 0; i < DstXE; i++) {
/* copy one pixel and advance dest */
*((WORD *) lpDst) = *((WORD *) lpSrc);
lpDst += sizeof(WORD);
/* should we advance source pointer this time ? */
if ( (xdelta -= SrcXE) < 0) {
xdelta += DstXE;
lpSrc += sizeof(WORD);
}
}
}
/*
* copy one scanline of 16bits, shrinking n:1 (dest < source)
*/
void
X_Stretch_N_1_16Bits(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract)
{
int xdelta;
int i;
xdelta = SrcXE -1;
for (i = 0; i < DstXE; i++) {
/* copy one pixel and advance dest */
*((WORD *) lpDst) = *((WORD *)lpSrc);
lpDst += sizeof(WORD);
/* how many times do we advance source pointer this time ? */
do {
lpSrc += sizeof(WORD);
xdelta -= DstXE;
} while (xdelta >= 0);
xdelta += SrcXE;
}
}
/* 24-bits ---------------------------------------------------------*/
/*
* copy one 24-bpp scanline as is (1:1)
*/
void
X_Stretch_1_1_24Bits(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract)
{
X_CopyScanline(lpSrc, lpDst, DstXE * 3);
}
/*
* copy one 24-bpp scanline stretching 1:n (dest > source)
*/
void
X_Stretch_1_N_24Bits(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract)
{
int xdelta;
int i;
xdelta = DstXE -1;
for (i = 0; i < DstXE; i++) {
/* copy first word of pixel and advance dest */
*((WORD UNALIGNED *) lpDst) = *((WORD UNALIGNED *) lpSrc);
lpDst += sizeof(WORD);
/* copy third byte and advance dest */
*lpDst++ = lpSrc[sizeof(WORD)];
/* should we advance source pointer this time ? */
if ( (xdelta -= SrcXE) < 0) {
xdelta += DstXE;
lpSrc += 3;
}
}
}
/*
* copy one scanline of 24 bits, shrinking n:1 (dest < source)
*/
void
X_Stretch_N_1_24Bits(LPBYTE lpSrc,
LPBYTE lpDst,
int SrcXE,
int DstXE,
int x_fract)
{
int xdelta;
int i;
xdelta = SrcXE -1;
for (i = 0; i < DstXE; i++) {
/* copy first word of pixel and advance dest */
*((WORD UNALIGNED *) lpDst) = *((WORD UNALIGNED *) lpSrc);
lpDst += sizeof(WORD);
/* copy third byte and advance dest */
*lpDst++ = lpSrc[sizeof(WORD)];
/* how many times do we advance source pointer this time ? */
do {
lpSrc += 3;
xdelta -= DstXE;
} while (xdelta >= 0);
xdelta += SrcXE;
}
}
/* -- special-case 1:2 -------------------------------------------*/
/*
* stretch 1:2 in both directions, for 8 bits.
*
* An experiment was done on x86 to only write every other line during
* the stretch and when the whole frame was done to use memcpy to fill
* in the gaps. This is slower than doing the stretch in a single pass.
*/
void
Stretch_1_2_8Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE,int SrcYE, int DstXE,
int DstYE, int SrcWidth, int DstWidth, int x_fract)
{
int SrcInc, DstInc;
int i, j;
WORD wPix;
DWORD dwPix4;
/* amount to advance source by at the end of each scan */
SrcInc = SrcWidth - SrcXE;
/* amount to advance dest by at the end of each scan - note
* that we write two scans at once, so advance past the next
* scan line
*/
DstInc = (DstWidth * 2) - DstXE;
/*
* we would like to copy the pixels DWORD at a time. this means
* being aligned. if we are currently aligned on a WORD boundary,
* then copy one pixel to get aligned. If we are on a byte
* boundary, we can never get aligned, so use the slower loop.
*/
if ( ((DWORD)lpDst) & 1) {
/*
* dest is byte aligned - so we can never align it
* by writing WORDs - use slow loop.
*/
for (i = 0; i < SrcYE; i++) {
for (j = 0; j < SrcXE; j++) {
/* get a pixel and double it */
wPix = *lpSrc++;
wPix |= (wPix<<8);
/* write doubled pixel to this scanline */
*( (WORD UNALIGNED *) lpDst) = wPix;
/* write double pixel to next scanline */
*( (WORD UNALIGNED *) (lpDst + DstWidth)) = wPix;
lpDst += sizeof(WORD);
}
lpSrc += SrcInc;
lpDst += DstInc;
}
return;
}
/*
* this will be the aligned version. align each scan line
*/
for ( i = 0; i < SrcYE; i++) {
/* count of pixels remaining */
j = SrcXE;
/* align this scan line */
if (((DWORD)lpDst) & 2) {
/* word aligned - copy one doubled pixel and we are ok */
wPix = *lpSrc++;
wPix |= (wPix << 8);
*( (WORD *) lpDst) = wPix;
*( (WORD *) (lpDst + DstWidth)) = wPix;
lpDst += sizeof(WORD);
j -= 1;
}
/* now dest is aligned - so loop eating two pixels at a time
* until there is at most one left
*/
for ( ; j > 1; j -= 2) {
/* read two pixels and double them */
wPix = * ((WORD UNALIGNED *) lpSrc);
lpSrc += sizeof(WORD);
dwPix4 = (wPix & 0xff) | ((wPix & 0xff) << 8);
dwPix4 |= ((wPix & 0xff00) << 8) | ((wPix & 0xff00) << 16);
*((DWORD *) lpDst) = dwPix4;
*((DWORD *) (lpDst + DstWidth)) = dwPix4;
lpDst += sizeof(DWORD);
}
/* odd byte remaining ? */
if (j > 0) {
/* word aligned - copy one doubled pixel and we are ok */
wPix = *lpSrc++;
wPix |= (wPix << 8);
*( (WORD *) lpDst) = wPix;
*( (WORD *) (lpDst + DstWidth)) = wPix;
lpDst += sizeof(WORD);
j -= 1;
}
lpSrc += SrcInc;
lpDst += DstInc;
}
}
/* ----------------------------------------------------------------*/
/*
* stretch 1:2 in both directions, for 16-bits
*/
void
Stretch_1_2_16Bits(LPBYTE lpSrc, LPBYTE lpDst, int SrcXE,int SrcYE, int DstXE,
int DstYE, int SrcWidth, int DstWidth, int x_fract)
{
int SrcInc, DstInc;
int i, j;
DWORD dwPix;
/* amount to advance source by at the end of each scan */
SrcInc = SrcWidth - (SrcXE * sizeof(WORD));
/* amount to advance dest by at the end of each scan - note
* that we write two scans at once, so advance past the next
* scan line
*/
DstInc = (DstWidth * 2) - (DstXE * sizeof(WORD));
for (i = 0; i < SrcYE; i++) {
for (j = 0; j < SrcXE; j++) {
/* get a pixel and double it */
dwPix = *((WORD *)lpSrc);
dwPix |= (dwPix<<16);
lpSrc += sizeof(WORD);
/* write doubled pixel to this scanline */
*( (DWORD UNALIGNED *) lpDst) = dwPix;
/* write double pixel to next scanline */
*( (DWORD UNALIGNED *) (lpDst + DstWidth)) = dwPix;
lpDst += sizeof(DWORD);
}
lpSrc += SrcInc;
lpDst += DstInc;
}
}