mirror of
https://github.com/ultimatepp/ultimatepp.git
synced 2026-05-16 22:02:58 -06:00
352 lines
8.5 KiB
C
352 lines
8.5 KiB
C
/*====================================================================*
|
|
- 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.
|
|
*====================================================================*/
|
|
|
|
/*
|
|
* arrayaccess.c
|
|
*
|
|
* Access within an array of 32-bit words
|
|
*
|
|
* l_int32 l_getDataBit()
|
|
* void l_setDataBit()
|
|
* void l_clearDataBit()
|
|
* void l_setDataBitVal()
|
|
* l_int32 l_getDataDibit()
|
|
* void l_setDataDibit()
|
|
* void l_clearDataDibit()
|
|
* l_int32 l_getDataQbit()
|
|
* void l_setDataQbit()
|
|
* void l_clearDataQbit()
|
|
* l_int32 l_getDataByte()
|
|
* void l_setDataByte()
|
|
* l_int32 l_getDataTwoBytes()
|
|
* void l_setDataTwoBytes()
|
|
* l_int32 l_getDataFourBytes()
|
|
* void l_setDataFourBytes()
|
|
*
|
|
* Note that these all require 32-bit alignment, and hence an input
|
|
* ptr to l_uint32. However, this is not enforced by the compiler.
|
|
* Instead, we allow the use of a void* ptr, because the line ptrs
|
|
* are an efficient way to get random access (see pixGetLinePtrs()).
|
|
* It is then necessary to cast internally within each function
|
|
* because ptr arithmetic requires knowing the size of the units
|
|
* being referenced.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include "allheaders.h"
|
|
|
|
|
|
/*----------------------------------------------------------------------*
|
|
* Access within an array of 32-bit words *
|
|
*----------------------------------------------------------------------*/
|
|
/*!
|
|
* l_getDataBit()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* Return: val of the nth (1-bit) pixel.
|
|
*/
|
|
l_int32
|
|
l_getDataBit(void *line,
|
|
l_int32 n)
|
|
{
|
|
return (*((l_uint32 *)line + (n >> 5)) >> (31 - (n & 31))) & 1;
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_setDataBit()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* Return: void
|
|
*
|
|
* Action: sets the pixel to 1
|
|
*/
|
|
void
|
|
l_setDataBit(void *line,
|
|
l_int32 n)
|
|
{
|
|
*((l_uint32 *)line + (n >> 5)) |= (0x80000000 >> (n & 31));
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_clearDataBit()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* Return: void
|
|
*
|
|
* Action: sets the (1-bit) pixel to 0
|
|
*/
|
|
void
|
|
l_clearDataBit(void *line,
|
|
l_int32 n)
|
|
{
|
|
*((l_uint32 *)line + (n >> 5)) &= ~(0x80000000 >> (n & 31));
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_setDataBitVal()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* val (val to be inserted: 0 - 3)
|
|
* Return: void
|
|
*
|
|
* Notes:
|
|
* (1) This is actually a little slower than using:
|
|
* if (val == 0)
|
|
* l_ClearDataBit(line, n);
|
|
* else
|
|
* l_SetDataBit(line, n);
|
|
*/
|
|
void
|
|
l_setDataBitVal(void *line,
|
|
l_int32 n,
|
|
l_int32 val)
|
|
{
|
|
l_uint32 *pword;
|
|
|
|
pword = (l_uint32 *)line + (n >> 5);
|
|
*pword &= ~(0x80000000 >> (n & 31)); /* clear */
|
|
*pword |= val << (31 - (n & 31)); /* set */
|
|
return;
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_getDataDibit()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* Return: val of the nth (2-bit) pixel.
|
|
*/
|
|
l_int32
|
|
l_getDataDibit(void *line,
|
|
l_int32 n)
|
|
{
|
|
return (*((l_uint32 *)line + (n >> 4)) >> (2 * (15 - (n & 15)))) & 3;
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_setDataDibit()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* val (val to be inserted: 0 - 3)
|
|
* Return: void
|
|
*/
|
|
void
|
|
l_setDataDibit(void *line,
|
|
l_int32 n,
|
|
l_int32 val)
|
|
{
|
|
l_uint32 *pword;
|
|
|
|
pword = (l_uint32 *)line + (n >> 4);
|
|
*pword &= ~(0xc0000000 >> (2 * (n & 15))); /* clear */
|
|
*pword |= val << (30 - 2 * (n & 15)); /* set */
|
|
return;
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_clearDataDibit()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* Return: void
|
|
*
|
|
* Action: sets the (2-bit) pixel to 0
|
|
*/
|
|
void
|
|
l_clearDataDibit(void *line,
|
|
l_int32 n)
|
|
{
|
|
*((l_uint32 *)line + (n >> 4)) &= ~(0xc0000000 >> (2 * (n & 15)));
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_getDataQbit()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* Return: val of the nth (4-bit) pixel.
|
|
*/
|
|
l_int32
|
|
l_getDataQbit(void *line,
|
|
l_int32 n)
|
|
{
|
|
return (*((l_uint32 *)line + (n >> 3)) >> (4 * (7 - (n & 7)))) & 0xf;
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_setDataQbit()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* val (val to be inserted: 0 - 0xf)
|
|
* Return: void
|
|
*/
|
|
void
|
|
l_setDataQbit(void *line,
|
|
l_int32 n,
|
|
l_int32 val)
|
|
{
|
|
l_uint32 *pword;
|
|
|
|
pword = (l_uint32 *)line + (n >> 3);
|
|
*pword &= ~(0xf0000000 >> (4 * (n & 7))); /* clear */
|
|
*pword |= val << (28 - 4 * (n & 7)); /* set */
|
|
return;
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_clearDataQbit()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* Return: void
|
|
*
|
|
* Action: sets the (4-bit) pixel to 0
|
|
*/
|
|
void
|
|
l_clearDataQbit(void *line,
|
|
l_int32 n)
|
|
{
|
|
*((l_uint32 *)line + (n >> 3)) &= ~(0xf0000000 >> (4 * (n & 7)));
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_getDataByte()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* Return: value of the n-th (byte) pixel
|
|
*/
|
|
l_int32
|
|
l_getDataByte(void *line,
|
|
l_int32 n)
|
|
{
|
|
#ifdef L_BIG_ENDIAN
|
|
return *((l_uint8 *)line + n);
|
|
#else /* L_LITTLE_ENDIAN */
|
|
return *(l_uint8 *)((l_uintptr_t)((l_uint8 *)line + n) ^ 3);
|
|
#endif /* L_BIG_ENDIAN */
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_setDataByte()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* val (val to be inserted: 0 - 0xff)
|
|
* Return: void
|
|
*/
|
|
void
|
|
l_setDataByte(void *line,
|
|
l_int32 n,
|
|
l_int32 val)
|
|
{
|
|
#ifdef L_BIG_ENDIAN
|
|
*((l_uint8 *)line + n) = val;
|
|
#else /* L_LITTLE_ENDIAN */
|
|
*(l_uint8 *)((l_uintptr_t)((l_uint8 *)line + n) ^ 3) = val;
|
|
#endif /* L_BIG_ENDIAN */
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_getDataTwoBytes()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* Return: value of the n-th (2-byte) pixel
|
|
*/
|
|
l_int32
|
|
l_getDataTwoBytes(void *line,
|
|
l_int32 n)
|
|
{
|
|
#ifdef L_BIG_ENDIAN
|
|
return *((l_uint16 *)line + n);
|
|
#else /* L_LITTLE_ENDIAN */
|
|
return *(l_uint16 *)((l_uintptr_t)((l_uint16 *)line + n) ^ 2);
|
|
#endif /* L_BIG_ENDIAN */
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_setDataTwoBytes()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* val (val to be inserted: 0 - 0xffff)
|
|
* Return: void
|
|
*/
|
|
void
|
|
l_setDataTwoBytes(void *line,
|
|
l_int32 n,
|
|
l_int32 val)
|
|
{
|
|
#ifdef L_BIG_ENDIAN
|
|
*((l_uint16 *)line + n) = val;
|
|
#else /* L_LITTLE_ENDIAN */
|
|
*(l_uint16 *)((l_uintptr_t)((l_uint16 *)line + n) ^ 2) = val;
|
|
#endif /* L_BIG_ENDIAN */
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_getDataFourBytes()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* Return: value of the n-th (4-byte) pixel
|
|
*/
|
|
l_int32
|
|
l_getDataFourBytes(void *line,
|
|
l_int32 n)
|
|
{
|
|
return *((l_uint32 *)line + n);
|
|
}
|
|
|
|
|
|
/*!
|
|
* l_setDataFourBytes()
|
|
*
|
|
* Input: line (ptr to beginning of data line)
|
|
* n (pixel index)
|
|
* val (val to be inserted: 0 - 0xffffffff)
|
|
* Return: void
|
|
*/
|
|
void
|
|
l_setDataFourBytes(void *line,
|
|
l_int32 n,
|
|
l_int32 val)
|
|
{
|
|
*((l_uint32 *)line + n) = val;
|
|
}
|
|
|
|
|
|
|