/*====================================================================*
- 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.
*====================================================================*/
/*
* rotateorthlow.c
*
* 90-degree rotation (cw)
* void rotate90Low()
*
* LR-flip
* void flipLRLow()
*
* TB-flip
* void flipTBLow()
*
* Byte reverse tables
* l_uint8 *makeReverseByteTab1()
* l_uint8 *makeReverseByteTab2()
* l_uint8 *makeReverseByteTab4()
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "allheaders.h"
/*------------------------------------------------------------------*
* 90 degree rotation *
*------------------------------------------------------------------*/
/*!
* rotate90Low()
*
* direction: 1 for cw rotation
* -1 for ccw rotation
*
* Notes:
* (1) The dest must be cleared in advance because not
* all source pixels are written to the destination.
*/
void
rotate90Low(l_uint32 *datad,
l_int32 wd,
l_int32 hd,
l_int32 d,
l_int32 wpld,
l_uint32 *datas,
l_int32 wpls,
l_int32 direction)
{
l_int32 i, j, k, m, iend, nswords;
l_uint32 val, word;
l_uint32 *lines, *lined;
PROCNAME("rotate90Low");
if (direction == 1) { /* clockwise */
switch (d)
{
case 32:
for (i = 0; i < hd; i++) {
lined = datad + i * wpld;
lines = datas + (wd - 1) * wpls;
for (j = 0; j < wd; j++) {
lined[j] = lines[i];
lines -= wpls;
}
}
break;
case 16:
for (i = 0; i < hd; i++) {
lined = datad + i * wpld;
lines = datas + (wd - 1) * wpls;
for (j = 0; j < wd; j++) {
if ((val = GET_DATA_TWO_BYTES(lines, i)))
SET_DATA_TWO_BYTES(lined, j, val);
lines -= wpls;
}
}
break;
case 8:
for (i = 0; i < hd; i++) {
lined = datad + i * wpld;
lines = datas + (wd - 1) * wpls;
for (j = 0; j < wd; j++) {
if ((val = GET_DATA_BYTE(lines, i)))
SET_DATA_BYTE(lined, j, val);
lines -= wpls;
}
}
break;
case 4:
for (i = 0; i < hd; i++) {
lined = datad + i * wpld;
lines = datas + (wd - 1) * wpls;
for (j = 0; j < wd; j++) {
if ((val = GET_DATA_QBIT(lines, i)))
SET_DATA_QBIT(lined, j, val);
lines -= wpls;
}
}
break;
case 2:
for (i = 0; i < hd; i++) {
lined = datad + i * wpld;
lines = datas + (wd - 1) * wpls;
for (j = 0; j < wd; j++) {
if ((val = GET_DATA_DIBIT(lines, i)))
SET_DATA_DIBIT(lined, j, val);
lines -= wpls;
}
}
break;
case 1:
nswords = hd / 32;
for (j = 0; j < wd; j++) {
lined = datad;
lines = datas + (wd - 1 - j) * wpls;
for (k = 0; k < nswords; k++) {
word = lines[k];
if (!word) {
lined += 32 * wpld;
continue;
}
else {
iend = 32 * (k + 1);
for (m = 0, i = 32 * k; i < iend; i++, m++) {
if ((word << m) & 0x80000000)
SET_DATA_BIT(lined, j);
lined += wpld;
}
}
}
for (i = 32 * nswords; i < hd; i++) {
if (GET_DATA_BIT(lines, i))
SET_DATA_BIT(lined, j);
lined += wpld;
}
}
break;
default:
ERROR_VOID("illegal depth", procName);
}
}
else { /* direction counter-clockwise */
switch (d)
{
case 32:
for (i = 0; i < hd; i++) {
lined = datad + i * wpld;
lines = datas;
for (j = 0; j < wd; j++) {
lined[j] = lines[hd - 1 - i];
lines += wpls;
}
}
break;
case 16:
for (i = 0; i < hd; i++) {
lined = datad + i * wpld;
lines = datas;
for (j = 0; j < wd; j++) {
if ((val = GET_DATA_TWO_BYTES(lines, hd - 1 - i)))
SET_DATA_TWO_BYTES(lined, j, val);
lines += wpls;
}
}
break;
case 8:
for (i = 0; i < hd; i++) {
lined = datad + i * wpld;
lines = datas;
for (j = 0; j < wd; j++) {
if ((val = GET_DATA_BYTE(lines, hd - 1 - i)))
SET_DATA_BYTE(lined, j, val);
lines += wpls;
}
}
break;
case 4:
for (i = 0; i < hd; i++) {
lined = datad + i * wpld;
lines = datas;
for (j = 0; j < wd; j++) {
if ((val = GET_DATA_QBIT(lines, hd - 1 - i)))
SET_DATA_QBIT(lined, j, val);
lines += wpls;
}
}
break;
case 2:
for (i = 0; i < hd; i++) {
lined = datad + i * wpld;
lines = datas;
for (j = 0; j < wd; j++) {
if ((val = GET_DATA_DIBIT(lines, hd - 1 - i)))
SET_DATA_DIBIT(lined, j, val);
lines += wpls;
}
}
break;
case 1:
nswords = hd / 32;
for (j = 0; j < wd; j++) {
lined = datad + (hd - 1) * wpld;
lines = datas + (wd - 1 - j) * wpls;
for (k = 0; k < nswords; k++) {
word = lines[k];
if (!word) {
lined -= 32 * wpld;
continue;
}
else {
iend = 32 * (k + 1);
for (m = 0, i = 32 * k; i < iend; i++, m++) {
if ((word << m) & 0x80000000)
SET_DATA_BIT(lined, wd - 1 - j);
lined -= wpld;
}
}
}
for (i = 32 * nswords; i < hd; i++) {
if (GET_DATA_BIT(lines, i))
SET_DATA_BIT(lined, wd - 1 - j);
lined -= wpld;
}
}
break;
default:
ERROR_VOID("illegal depth", procName);
}
}
return;
}
/*------------------------------------------------------------------*
* Left/right flip *
*------------------------------------------------------------------*/
/*!
* flipLRLow()
*
* Notes:
* (1) The pixel access routines allow a trivial implementation.
* However, for d < 8, it is more efficient to right-justify
* each line to a 32-bit boundary and then extract bytes and
* do pixel reversing. In those cases, as in the 180 degree
* rotation, we right-shift the data (if necessary) to
* right-justify on the 32 bit boundary, and then read the
* bytes off each raster line in reverse order, reversing
* the pixels in each byte using a table. These functions
* for 1, 2 and 4 bpp were tested against the "trivial"
* version (shown here for 4 bpp):
* for (i = 0; i < h; i++) {
* line = data + i * wpl;
* memcpy(buffer, line, bpl);
* for (j = 0; j < w; j++) {
* val = GET_DATA_QBIT(buffer, w - 1 - j);
* SET_DATA_QBIT(line, j, val);
* }
* }
* (2) This operation is in-place.
*/
void
flipLRLow(l_uint32 *data,
l_int32 w,
l_int32 h,
l_int32 d,
l_int32 wpl,
l_uint8 *tab,
l_uint32 *buffer)
{
l_int32 extra, shift, databpl, bpl, i, j;
l_uint32 val;
l_uint32 *line;
PROCNAME("flipLRLow");
bpl = 4 * wpl;
switch (d)
{
case 32:
for (i = 0; i < h; i++) {
line = data + i * wpl;
memcpy(buffer, line, bpl);
for (j = 0; j < w; j++)
line[j] = buffer[w - 1 - j];
}
break;
case 16:
for (i = 0; i < h; i++) {
line = data + i * wpl;
memcpy(buffer, line, bpl);
for (j = 0; j < w; j++) {
val = GET_DATA_TWO_BYTES(buffer, w - 1 - j);
SET_DATA_TWO_BYTES(line, j, val);
}
}
break;
case 8:
for (i = 0; i < h; i++) {
line = data + i * wpl;
memcpy(buffer, line, bpl);
for (j = 0; j < w; j++) {
val = GET_DATA_BYTE(buffer, w - 1 - j);
SET_DATA_BYTE(line, j, val);
}
}
break;
case 4:
extra = (w * d) & 31;
if (extra)
shift = 8 - extra / 4;
else
shift = 0;
if (shift)
rasteropHipLow(data, h, d, wpl, 0, h, shift);
databpl = (w + 1) / 2;
for (i = 0; i < h; i++) {
line = data + i * wpl;
memcpy(buffer, line, bpl);
for (j = 0; j < databpl; j++) {
val = GET_DATA_BYTE(buffer, bpl - 1 - j);
SET_DATA_BYTE(line, j, tab[val]);
}
}
break;
case 2:
extra = (w * d) & 31;
if (extra)
shift = 16 - extra / 2;
else
shift = 0;
if (shift)
rasteropHipLow(data, h, d, wpl, 0, h, shift);
databpl = (w + 3) / 4;
for (i = 0; i < h; i++) {
line = data + i * wpl;
memcpy(buffer, line, bpl);
for (j = 0; j < databpl; j++) {
val = GET_DATA_BYTE(buffer, bpl - 1 - j);
SET_DATA_BYTE(line, j, tab[val]);
}
}
break;
case 1:
extra = (w * d) & 31;
if (extra)
shift = 32 - extra;
else
shift = 0;
if (shift)
rasteropHipLow(data, h, d, wpl, 0, h, shift);
databpl = (w + 7) / 8;
for (i = 0; i < h; i++) {
line = data + i * wpl;
memcpy(buffer, line, bpl);
for (j = 0; j < databpl; j++) {
val = GET_DATA_BYTE(buffer, bpl - 1 - j);
SET_DATA_BYTE(line, j, tab[val]);
}
}
break;
default:
ERROR_VOID("depth not permitted for LR rot", procName);
return;
}
return;
}
/*------------------------------------------------------------------*
* Top/bottom flip *
*------------------------------------------------------------------*/
/*!
* flipTBLow()
*
* Notes:
* (1) This is simple and fast. We use the memcpy function
* to do all the work on aligned data, regardless of pixel
* depth.
* (2) This operation is in-place.
*/
void
flipTBLow(l_uint32 *data,
l_int32 h,
l_int32 wpl,
l_uint32 *buffer)
{
l_int32 i, k, h2, bpl;
l_uint32 *linet, *lineb;
h2 = h / 2;
bpl = 4 * wpl;
for (i = 0, k = h - 1; i < h2; i++, k--) {
linet = data + i * wpl;
lineb = data + k * wpl;
memcpy(buffer, linet, bpl);
memcpy(linet, lineb, bpl);
memcpy(lineb, buffer, bpl);
}
return;
}
/*------------------------------------------------------------------*
* Byte reverse tables *
*------------------------------------------------------------------*/
/*!
* makeReverseByteTab1()
*
* Notes:
* (1) This generates an 8 bit lookup table for reversing
* the order of eight 1-bit pixels.
*/
l_uint8 *
makeReverseByteTab1(void)
{
l_int32 i;
l_uint8 *tab;
PROCNAME("makeReverseByteTab1");
if ((tab = (l_uint8 *)CALLOC(256, sizeof(l_uint8))) == NULL)
return (l_uint8 *)ERROR_PTR("calloc fail for tab", procName, NULL);
for (i = 0; i < 256; i++)
tab[i] = ((0x80 & i) >> 7) |
((0x40 & i) >> 5) |
((0x20 & i) >> 3) |
((0x10 & i) >> 1) |
((0x08 & i) << 1) |
((0x04 & i) << 3) |
((0x02 & i) << 5) |
((0x01 & i) << 7);
return tab;
}
/*!
* makeReverseByteTab2()
*
* Notes:
* (1) This generates an 8 bit lookup table for reversing
* the order of four 2-bit pixels.
*/
l_uint8 *
makeReverseByteTab2(void)
{
l_int32 i;
l_uint8 *tab;
PROCNAME("makeReverseByteTab2");
if ((tab = (l_uint8 *)CALLOC(256, sizeof(l_uint8))) == NULL)
return (l_uint8 *)ERROR_PTR("calloc fail for tab", procName, NULL);
for (i = 0; i < 256; i++)
tab[i] = ((0xc0 & i) >> 6) |
((0x30 & i) >> 2) |
((0x0c & i) << 2) |
((0x03 & i) << 6);
return tab;
}
/*!
* makeReverseByteTab4()
*
* Notes:
* (1) This generates an 8 bit lookup table for reversing
* the order of two 4-bit pixels.
*/
l_uint8 *
makeReverseByteTab4(void)
{
l_int32 i;
l_uint8 *tab;
PROCNAME("makeReverseByteTab4");
if ((tab = (l_uint8 *)CALLOC(256, sizeof(l_uint8))) == NULL)
return (l_uint8 *)ERROR_PTR("calloc fail for tab", procName, NULL);
for (i = 0; i < 256; i++)
tab[i] = ((0xf0 & i) >> 4) | ((0x0f & i) << 4);
return tab;
}