/*====================================================================*
- Copyright (C) 2001 Leptonica. All rights reserved.
- This software is distributed in the hope that it will be
- useful, but with NO WARRANTY OF ANY KIND.
- No author or distributor accepts responsibility to anyone for the
- consequences of using this software, or for whether it serves any
- particular purpose or works at all, unless he or she says so in
- writing. Everyone is granted permission to copy, modify and
- redistribute this source code, for commercial or non-commercial
- purposes, with the following restrictions: (1) the origin of this
- source code must not be misrepresented; (2) modified versions must
- be plainly marked as such; and (3) this notice may not be removed
- or altered from any source or modified source distribution.
*====================================================================*/
/*
* rotateamlow.c
*
* Grayscale and color rotation (area mapped)
*
* 32 bpp grayscale rotation about image center
* void rotateAMColorLow()
*
* 8 bpp grayscale rotation about image center
* void rotateAMGrayLow()
*
* 32 bpp grayscale rotation about UL corner of image
* void rotateAMColorCornerLow()
*
* 8 bpp grayscale rotation about UL corner of image
* void rotateAMGrayCornerLow()
*
* Fast RGB color rotation about center:
* void rotateAMColorFastLow()
*
*/
#include <stdio.h>
#include <string.h>
#include <math.h> /* required for sin and tan */
#include "allheaders.h"
/*------------------------------------------------------------------*
* 32 bpp grayscale rotation about the center *
*------------------------------------------------------------------*/
void
rotateAMColorLow(l_uint32 *datad,
l_int32 w,
l_int32 h,
l_int32 wpld,
l_uint32 *datas,
l_int32 wpls,
l_float32 angle,
l_uint32 colorval)
{
l_int32 i, j, xcen, ycen, wm2, hm2;
l_int32 xdif, ydif, xpm, ypm, xp, yp, xf, yf;
l_int32 rval, gval, bval;
l_uint32 word00, word01, word10, word11;
l_uint32 *lines, *lined;
l_float32 sina, cosa;
xcen = w / 2;
wm2 = w - 2;
ycen = h / 2;
hm2 = h - 2;
sina = 16. * sin(angle);
cosa = 16. * cos(angle);
for (i = 0; i < h; i++) {
ydif = ycen - i;
lined = datad + i * wpld;
for (j = 0; j < w; j++) {
xdif = xcen - j;
xpm = (l_int32)(-xdif * cosa - ydif * sina);
ypm = (l_int32)(-ydif * cosa + xdif * sina);
xp = xcen + (xpm >> 4);
yp = ycen + (ypm >> 4);
xf = xpm & 0x0f;
yf = ypm & 0x0f;
/* if off the edge, write input colorval */
if (xp < 0 || yp < 0 || xp > wm2 || yp > hm2) {
*(lined + j) = colorval;
continue;
}
lines = datas + yp * wpls;
/* do area weighting. Without this, we would
* simply do:
* *(lined + j) = *(lines + xp);
* which is faster but gives lousy results!
*/
word00 = *(lines + xp);
word10 = *(lines + xp + 1);
word01 = *(lines + wpls + xp);
word11 = *(lines + wpls + xp + 1);
rval = ((16 - xf) * (16 - yf) * ((word00 >> L_RED_SHIFT) & 0xff) +
xf * (16 - yf) * ((word10 >> L_RED_SHIFT) & 0xff) +
(16 - xf) * yf * ((word01 >> L_RED_SHIFT) & 0xff) +
xf * yf * ((word11 >> L_RED_SHIFT) & 0xff) + 128) / 256;
gval = ((16 - xf) * (16 - yf) * ((word00 >> L_GREEN_SHIFT) & 0xff) +
xf * (16 - yf) * ((word10 >> L_GREEN_SHIFT) & 0xff) +
(16 - xf) * yf * ((word01 >> L_GREEN_SHIFT) & 0xff) +
xf * yf * ((word11 >> L_GREEN_SHIFT) & 0xff) + 128) / 256;
bval = ((16 - xf) * (16 - yf) * ((word00 >> L_BLUE_SHIFT) & 0xff) +
xf * (16 - yf) * ((word10 >> L_BLUE_SHIFT) & 0xff) +
(16 - xf) * yf * ((word01 >> L_BLUE_SHIFT) & 0xff) +
xf * yf * ((word11 >> L_BLUE_SHIFT) & 0xff) + 128) / 256;
composeRGBPixel(rval, gval, bval, lined + j);
}
}
return;
}
/*------------------------------------------------------------------*
* 8 bpp grayscale rotation about the center *
*------------------------------------------------------------------*/
void
rotateAMGrayLow(l_uint32 *datad,
l_int32 w,
l_int32 h,
l_int32 wpld,
l_uint32 *datas,
l_int32 wpls,
l_float32 angle,
l_uint8 grayval)
{
l_int32 i, j, xcen, ycen, wm2, hm2;
l_int32 xdif, ydif, xpm, ypm, xp, yp, xf, yf;
l_int32 v00, v01, v10, v11;
l_uint8 val;
l_uint32 *lines, *lined;
l_float32 sina, cosa;
xcen = w / 2;
wm2 = w - 2;
ycen = h / 2;
hm2 = h - 2;
sina = 16. * sin(angle);
cosa = 16. * cos(angle);
for (i = 0; i < h; i++) {
ydif = ycen - i;
lined = datad + i * wpld;
for (j = 0; j < w; j++) {
xdif = xcen - j;
xpm = (l_int32)(-xdif * cosa - ydif * sina);
ypm = (l_int32)(-ydif * cosa + xdif * sina);
xp = xcen + (xpm >> 4);
yp = ycen + (ypm >> 4);
xf = xpm & 0x0f;
yf = ypm & 0x0f;
/* if off the edge, write input grayval */
if (xp < 0 || yp < 0 || xp > wm2 || yp > hm2) {
SET_DATA_BYTE(lined, j, grayval);
continue;
}
lines = datas + yp * wpls;
/* do area weighting. Without this, we would
* simply do:
* SET_DATA_BYTE(lined, j, GET_DATA_BYTE(lines, xp));
* which is faster but gives lousy results!
*/
v00 = (16 - xf) * (16 - yf) * GET_DATA_BYTE(lines, xp);
v10 = xf * (16 - yf) * GET_DATA_BYTE(lines, xp + 1);
v01 = (16 - xf) * yf * GET_DATA_BYTE(lines + wpls, xp);
v11 = xf * yf * GET_DATA_BYTE(lines + wpls, xp + 1);
val = (l_uint8)((v00 + v01 + v10 + v11 + 128) / 256);
SET_DATA_BYTE(lined, j, val);
}
}
return;
}
/*------------------------------------------------------------------*
* 32 bpp grayscale rotation about the UL corner *
*------------------------------------------------------------------*/
void
rotateAMColorCornerLow(l_uint32 *datad,
l_int32 w,
l_int32 h,
l_int32 wpld,
l_uint32 *datas,
l_int32 wpls,
l_float32 angle,
l_uint32 colorval)
{
l_int32 i, j, wm2, hm2;
l_int32 xpm, ypm, xp, yp, xf, yf;
l_int32 rval, gval, bval;
l_uint32 word00, word01, word10, word11;
l_uint32 *lines, *lined;
l_float32 sina, cosa;
wm2 = w - 2;
hm2 = h - 2;
sina = 16. * sin(angle);
cosa = 16. * cos(angle);
for (i = 0; i < h; i++) {
lined = datad + i * wpld;
for (j = 0; j < w; j++) {
xpm = (l_int32)(j * cosa + i * sina);
ypm = (l_int32)(i * cosa - j * sina);
xp = xpm >> 4;
yp = ypm >> 4;
xf = xpm & 0x0f;
yf = ypm & 0x0f;
/* if off the edge, write input colorval */
if (xp < 0 || yp < 0 || xp > wm2 || yp > hm2) {
*(lined + j) = colorval;
continue;
}
lines = datas + yp * wpls;
/* do area weighting. Without this, we would
* simply do:
* *(lined + j) = *(lines + xp);
* which is faster but gives lousy results!
*/
word00 = *(lines + xp);
word10 = *(lines + xp + 1);
word01 = *(lines + wpls + xp);
word11 = *(lines + wpls + xp + 1);
rval = ((16 - xf) * (16 - yf) * ((word00 >> L_RED_SHIFT) & 0xff) +
xf * (16 - yf) * ((word10 >> L_RED_SHIFT) & 0xff) +
(16 - xf) * yf * ((word01 >> L_RED_SHIFT) & 0xff) +
xf * yf * ((word11 >> L_RED_SHIFT) & 0xff) + 128) / 256;
gval = ((16 - xf) * (16 - yf) * ((word00 >> L_GREEN_SHIFT) & 0xff) +
xf * (16 - yf) * ((word10 >> L_GREEN_SHIFT) & 0xff) +
(16 - xf) * yf * ((word01 >> L_GREEN_SHIFT) & 0xff) +
xf * yf * ((word11 >> L_GREEN_SHIFT) & 0xff) + 128) / 256;
bval = ((16 - xf) * (16 - yf) * ((word00 >> L_BLUE_SHIFT) & 0xff) +
xf * (16 - yf) * ((word10 >> L_BLUE_SHIFT) & 0xff) +
(16 - xf) * yf * ((word01 >> L_BLUE_SHIFT) & 0xff) +
xf * yf * ((word11 >> L_BLUE_SHIFT) & 0xff) + 128) / 256;
composeRGBPixel(rval, gval, bval, lined + j);
}
}
return;
}
/*------------------------------------------------------------------*
* 8 bpp grayscale rotation about the UL corner *
*------------------------------------------------------------------*/
void
rotateAMGrayCornerLow(l_uint32 *datad,
l_int32 w,
l_int32 h,
l_int32 wpld,
l_uint32 *datas,
l_int32 wpls,
l_float32 angle,
l_uint8 grayval)
{
l_int32 i, j, wm2, hm2;
l_int32 xpm, ypm, xp, yp, xf, yf;
l_int32 v00, v01, v10, v11;
l_uint8 val;
l_uint32 *lines, *lined;
l_float32 sina, cosa;
wm2 = w - 2;
hm2 = h - 2;
sina = 16. * sin(angle);
cosa = 16. * cos(angle);
for (i = 0; i < h; i++) {
lined = datad + i * wpld;
for (j = 0; j < w; j++) {
xpm = (l_int32)(j * cosa + i * sina);
ypm = (l_int32)(i * cosa - j * sina);
xp = xpm >> 4;
yp = ypm >> 4;
xf = xpm & 0x0f;
yf = ypm & 0x0f;
/* if off the edge, write input grayval */
if (xp < 0 || yp < 0 || xp > wm2 || yp > hm2) {
SET_DATA_BYTE(lined, j, grayval);
continue;
}
lines = datas + yp * wpls;
/* do area weighting. Without this, we would
* simply do:
* SET_DATA_BYTE(lined, j, GET_DATA_BYTE(lines, xp));
* which is faster but gives lousy results!
*/
v00 = (16 - xf) * (16 - yf) * GET_DATA_BYTE(lines, xp);
v10 = xf * (16 - yf) * GET_DATA_BYTE(lines, xp + 1);
v01 = (16 - xf) * yf * GET_DATA_BYTE(lines + wpls, xp);
v11 = xf * yf * GET_DATA_BYTE(lines + wpls, xp + 1);
val = (l_uint8)((v00 + v01 + v10 + v11 + 128) / 256);
SET_DATA_BYTE(lined, j, val);
}
}
return;
}
/*------------------------------------------------------------------*
* Fast RGB color rotation about center *
*------------------------------------------------------------------*/
/*!
* rotateAMColorFastLow()
*
* This is a special simplification of area mapping with division
* of each pixel into 16 sub-pixels. The exact coefficients that
* should be used are the same as for the 4x linear interpolation
* scaling case, and are given there. I tried to approximate these
* as weighted coefficients with a maximum sum of 4, which
* allows us to do the arithmetic in parallel for the R, G and B
* components in a 32 bit pixel. However, there are three reasons
* for not doing that:
* (1) the loss of accuracy in the parallel implementation
* is visually significant
* (2) the parallel implementation (described below) is slower
* (3) the parallel implementation requires allocation of
* a temporary color image
*
* There are 16 cases for the choice of the subpixel, and
* for each, the mapping to the relevant source
* pixels is as follows:
*
* subpixel src pixel weights
* -------- -----------------
* 0 sp1
* 1 (3 * sp1 + sp2) / 4
* 2 (sp1 + sp2) / 2
* 3 (sp1 + 3 * sp2) / 4
* 4 (3 * sp1 + sp3) / 4
* 5 (9 * sp1 + 3 * sp2 + 3 * sp3 + sp4) / 16
* 6 (3 * sp1 + 3 * sp2 + sp3 + sp4) / 8
* 7 (3 * sp1 + 9 * sp2 + sp3 + 3 * sp4) / 16
* 8 (sp1 + sp3) / 2
* 9 (3 * sp1 + sp2 + 3 * sp3 + sp4) / 8
* 10 (sp1 + sp2 + sp3 + sp4) / 4
* 11 (sp1 + 3 * sp2 + sp3 + 3 * sp4) / 8
* 12 (sp1 + 3 * sp3) / 4
* 13 (3 * sp1 + sp2 + 9 * sp3 + 3 * sp4) / 16
* 14 (sp1 + sp2 + 3 * sp3 + 3 * sp4) / 8
* 15 (sp1 + 3 * sp2 + 3 * sp3 + 9 * sp4) / 16
*
* Another way to visualize this is to consider the area mapping
* (or linear interpolation) coefficients for the pixel sp1.
* Expressed in fourths, they can be written as asymmetric matrix:
*
* 4 3 2 1
* 3 2.25 1.5 0.75
* 2 1.5 1 0.5
* 1 0.75 0.5 0.25
*
* The coefficients for the three neighboring pixels can be
* similarly written.
*
* This is implemented here, where, for each color component,
* we inline its extraction from each participating word,
* construct the linear combination, and combine the results
* into the destination 32 bit RGB pixel, using the appropriate shifts.
*
* It is interesting to note that an alternative method, where
* we do the arithmetic on the 32 bit pixels directly (after
* shifting the components so they won't overflow into each other)
* is significantly inferior. Because we have only 8 bits for
* internal overflows, which can be distributed as 2, 3, 3, it
* is impossible to add these with the correct linear
* interpolation coefficients, which require a sum of up to 16.
* Rounding off to a sum of 4 causes appreciable visual artifacts
* in the rotated image. The code for the inferior method
* can be found in prog/rotatefastalt.c, for reference.
*
* *** Warning: explicit assumption about RGB component ordering ***
*/
void
rotateAMColorFastLow(l_uint32 *datad,
l_int32 w,
l_int32 h,
l_int32 wpld,
l_uint32 *datas,
l_int32 wpls,
l_float32 angle,
l_uint32 colorval)
{
l_int32 i, j, xcen, ycen, wm2, hm2;
l_int32 xdif, ydif, xpm, ypm, xp, yp, xf, yf;
l_uint32 word1, word2, word3, word4, red, blue, green;
l_uint32 *pword, *lines, *lined;
l_float32 sina, cosa;
xcen = w / 2;
wm2 = w - 2;
ycen = h / 2;
hm2 = h - 2;
sina = 4. * sin(angle);
cosa = 4. * cos(angle);
for (i = 0; i < h; i++) {
ydif = ycen - i;
lined = datad + i * wpld;
for (j = 0; j < w; j++) {
xdif = xcen - j;
xpm = (l_int32)(-xdif * cosa - ydif * sina);
ypm = (l_int32)(-ydif * cosa + xdif * sina);
xp = xcen + (xpm >> 2);
yp = ycen + (ypm >> 2);
xf = xpm & 0x03;
yf = ypm & 0x03;
/* if off the edge, write input grayval */
if (xp < 0 || yp < 0 || xp > wm2 || yp > hm2) {
*(lined + j) = colorval;
continue;
}
lines = datas + yp * wpls;
pword = lines + xp;
switch (xf + 4 * yf)
{
case 0:
*(lined + j) = *pword;
break;
case 1:
word1 = *pword;
word2 = *(pword + 1);
red = 3 * (word1 >> 24) + (word2 >> 24);
green = 3 * ((word1 >> 16) & 0xff) +
((word2 >> 16) & 0xff);
blue = 3 * ((word1 >> 8) & 0xff) +
((word2 >> 8) & 0xff);
*(lined + j) = ((red << 22) & 0xff000000) |
((green << 14) & 0x00ff0000) |
((blue << 6) & 0x0000ff00);
break;
case 2:
word1 = *pword;
word2 = *(pword + 1);
red = (word1 >> 24) + (word2 >> 24);
green = ((word1 >> 16) & 0xff) + ((word2 >> 16) & 0xff);
blue = ((word1 >> 8) & 0xff) + ((word2 >> 8) & 0xff);
*(lined + j) = ((red << 23) & 0xff000000) |
((green << 15) & 0x00ff0000) |
((blue << 7) & 0x0000ff00);
break;
case 3:
word1 = *pword;
word2 = *(pword + 1);
red = (word1 >> 24) + 3 * (word2 >> 24);
green = ((word1 >> 16) & 0xff) +
3 * ((word2 >> 16) & 0xff);
blue = ((word1 >> 8) & 0xff) +
3 * ((word2 >> 8) & 0xff);
*(lined + j) = ((red << 22) & 0xff000000) |
((green << 14) & 0x00ff0000) |
((blue << 6) & 0x0000ff00);
break;
case 4:
word1 = *pword;
word3 = *(pword + wpls);
red = 3 * (word1 >> 24) + (word3 >> 24);
green = 3 * ((word1 >> 16) & 0xff) +
((word3 >> 16) & 0xff);
blue = 3 * ((word1 >> 8) & 0xff) +
((word3 >> 8) & 0xff);
*(lined + j) = ((red << 22) & 0xff000000) |
((green << 14) & 0x00ff0000) |
((blue << 6) & 0x0000ff00);
break;
case 5:
word1 = *pword;
word2 = *(pword + 1);
word3 = *(pword + wpls);
word4 = *(pword + wpls + 1);
red = 9 * (word1 >> 24) + 3 * (word2 >> 24) +
3 * (word3 >> 24) + (word4 >> 24);
green = 9 * ((word1 >> 16) & 0xff) +
3 * ((word2 >> 16) & 0xff) +
3 * ((word3 >> 16) & 0xff) +
((word4 >> 16) & 0xff);
blue = 9 * ((word1 >> 8) & 0xff) +
3 * ((word2 >> 8) & 0xff) +
3 * ((word3 >> 8) & 0xff) +
((word4 >> 8) & 0xff);
*(lined + j) = ((red << 20) & 0xff000000) |
((green << 12) & 0x00ff0000) |
((blue << 4) & 0x0000ff00);
break;
case 6:
word1 = *pword;
word2 = *(pword + 1);
word3 = *(pword + wpls);
word4 = *(pword + wpls + 1);
red = 3 * (word1 >> 24) + 3 * (word2 >> 24) +
(word3 >> 24) + (word4 >> 24);
green = 3 * ((word1 >> 16) & 0xff) +
3 * ((word2 >> 16) & 0xff) +
((word3 >> 16) & 0xff) +
((word4 >> 16) & 0xff);
blue = 3 * ((word1 >> 8) & 0xff) +
3 * ((word2 >> 8) & 0xff) +
((word3 >> 8) & 0xff) +
((word4 >> 8) & 0xff);
*(lined + j) = ((red << 21) & 0xff000000) |
((green << 13) & 0x00ff0000) |
((blue << 5) & 0x0000ff00);
break;
case 7:
word1 = *pword;
word2 = *(pword + 1);
word3 = *(pword + wpls);
word4 = *(pword + wpls + 1);
red = 3 * (word1 >> 24) + 9 * (word2 >> 24) +
(word3 >> 24) + 3 * (word4 >> 24);
green = 3 * ((word1 >> 16) & 0xff) +
9 * ((word2 >> 16) & 0xff) +
((word3 >> 16) & 0xff) +
3 * ((word4 >> 16) & 0xff);
blue = 3 * ((word1 >> 8) & 0xff) +
9 * ((word2 >> 8) & 0xff) +
((word3 >> 8) & 0xff) +
3 * ((word4 >> 8) & 0xff);
*(lined + j) = ((red << 20) & 0xff000000) |
((green << 12) & 0x00ff0000) |
((blue << 4) & 0x0000ff00);
break;
case 8:
word1 = *pword;
word3 = *(pword + wpls);
red = (word1 >> 24) + (word3 >> 24);
green = ((word1 >> 16) & 0xff) + ((word3 >> 16) & 0xff);
blue = ((word1 >> 8) & 0xff) + ((word3 >> 8) & 0xff);
*(lined + j) = ((red << 23) & 0xff000000) |
((green << 15) & 0x00ff0000) |
((blue << 7) & 0x0000ff00);
break;
case 9:
word1 = *pword;
word2 = *(pword + 1);
word3 = *(pword + wpls);
word4 = *(pword + wpls + 1);
red = 3 * (word1 >> 24) + (word2 >> 24) +
3 * (word3 >> 24) + (word4 >> 24);
green = 3 * ((word1 >> 16) & 0xff) + ((word2 >> 16) & 0xff) +
3 * ((word3 >> 16) & 0xff) + ((word4 >> 16) & 0xff);
blue = 3 * ((word1 >> 8) & 0xff) + ((word2 >> 8) & 0xff) +
3 * ((word3 >> 8) & 0xff) + ((word4 >> 8) & 0xff);
*(lined + j) = ((red << 21) & 0xff000000) |
((green << 13) & 0x00ff0000) |
((blue << 5) & 0x0000ff00);
break;
case 10:
word1 = *pword;
word2 = *(pword + 1);
word3 = *(pword + wpls);
word4 = *(pword + wpls + 1);
red = (word1 >> 24) + (word2 >> 24) +
(word3 >> 24) + (word4 >> 24);
green = ((word1 >> 16) & 0xff) + ((word2 >> 16) & 0xff) +
((word3 >> 16) & 0xff) + ((word4 >> 16) & 0xff);
blue = ((word1 >> 8) & 0xff) + ((word2 >> 8) & 0xff) +
((word3 >> 8) & 0xff) + ((word4 >> 8) & 0xff);
*(lined + j) = ((red << 22) & 0xff000000) |
((green << 14) & 0x00ff0000) |
((blue << 6) & 0x0000ff00);
break;
case 11:
word1 = *pword;
word2 = *(pword + 1);
word3 = *(pword + wpls);
word4 = *(pword + wpls + 1);
red = (word1 >> 24) + 3 * (word2 >> 24) +
(word3 >> 24) + 3 * (word4 >> 24);
green = ((word1 >> 16) & 0xff) + 3 * ((word2 >> 16) & 0xff) +
((word3 >> 16) & 0xff) + 3 * ((word4 >> 16) & 0xff);
blue = ((word1 >> 8) & 0xff) + 3 * ((word2 >> 8) & 0xff) +
((word3 >> 8) & 0xff) + 3 * ((word4 >> 8) & 0xff);
*(lined + j) = ((red << 21) & 0xff000000) |
((green << 13) & 0x00ff0000) |
((blue << 5) & 0x0000ff00);
break;
case 12:
word1 = *pword;
word3 = *(pword + wpls);
red = (word1 >> 24) + 3 * (word3 >> 24);
green = ((word1 >> 16) & 0xff) +
3 * ((word3 >> 16) & 0xff);
blue = ((word1 >> 8) & 0xff) +
3 * ((word3 >> 8) & 0xff);
*(lined + j) = ((red << 22) & 0xff000000) |
((green << 14) & 0x00ff0000) |
((blue << 6) & 0x0000ff00);
break;
case 13:
word1 = *pword;
word2 = *(pword + 1);
word3 = *(pword + wpls);
word4 = *(pword + wpls + 1);
red = 3 * (word1 >> 24) + (word2 >> 24) +
9 * (word3 >> 24) + 3 * (word4 >> 24);
green = 3 * ((word1 >> 16) & 0xff) + ((word2 >> 16) & 0xff) +
9 * ((word3 >> 16) & 0xff) + 3 * ((word4 >> 16) & 0xff);
blue = 3 *((word1 >> 8) & 0xff) + ((word2 >> 8) & 0xff) +
9 * ((word3 >> 8) & 0xff) + 3 * ((word4 >> 8) & 0xff);
*(lined + j) = ((red << 20) & 0xff000000) |
((green << 12) & 0x00ff0000) |
((blue << 4) & 0x0000ff00);
break;
case 14:
word1 = *pword;
word2 = *(pword + 1);
word3 = *(pword + wpls);
word4 = *(pword + wpls + 1);
red = (word1 >> 24) + (word2 >> 24) +
3 * (word3 >> 24) + 3 * (word4 >> 24);
green = ((word1 >> 16) & 0xff) +((word2 >> 16) & 0xff) +
3 * ((word3 >> 16) & 0xff) + 3 * ((word4 >> 16) & 0xff);
blue = ((word1 >> 8) & 0xff) + ((word2 >> 8) & 0xff) +
3 * ((word3 >> 8) & 0xff) + 3 * ((word4 >> 8) & 0xff);
*(lined + j) = ((red << 21) & 0xff000000) |
((green << 13) & 0x00ff0000) |
((blue << 5) & 0x0000ff00);
break;
case 15:
word1 = *pword;
word2 = *(pword + 1);
word3 = *(pword + wpls);
word4 = *(pword + wpls + 1);
red = (word1 >> 24) + 3 * (word2 >> 24) +
3 * (word3 >> 24) + 9 * (word4 >> 24);
green = ((word1 >> 16) & 0xff) + 3 * ((word2 >> 16) & 0xff) +
3 * ((word3 >> 16) & 0xff) + 9 * ((word4 >> 16) & 0xff);
blue = ((word1 >> 8) & 0xff) + 3 * ((word2 >> 8) & 0xff) +
3 * ((word3 >> 8) & 0xff) + 9 * ((word4 >> 8) & 0xff);
*(lined + j) = ((red << 20) & 0xff000000) |
((green << 12) & 0x00ff0000) |
((blue << 4) & 0x0000ff00);
break;
default:
fprintf(stderr, "shouldn't get here\n");
break;
}
}
}
return;
}