IL_FREE_XCOLORS/XGRAYS, or ~0 for everything.
*/
static void ilFreeColorData (
- register ilXWCPtr pXWC,
+ ilXWCPtr pXWC,
unsigned long freeMask
)
{
)
{
ilObject object = (ilObject)pPrivate;
-register ilXWCPtr pXWC;
+ilXWCPtr pXWC;
pXWC = (ilXWCPtr)object;
int maxValue
)
{
-register int allocValue;
+int allocValue;
if (value == 0)
allocValue = 0;
*/
static ilBool ilAllocateXDitherColors (
ilContext context,
- register ilXWCPtr pXWC
+ ilXWCPtr pXWC
)
{
*/
static ilBool ilAllocateXGrays (
ilContext context,
- register ilXWCPtr pXWC,
+ ilXWCPtr pXWC,
int nGrays
)
{
levels not alloc'd.
*/
static ilBool ilAllocateXDirectColors (
- register ilXWCPtr pXWC,
+ ilXWCPtr pXWC,
int nLevels
)
{
void *pData
)
{
-register ilXWCPtr pXWC;
-register ilContext context;
+ilXWCPtr pXWC;
+ilContext context;
pXWC = (ilXWCPtr)XWC;
context = pXWC->o.p.context;
ilXWCInfo *pInfo
)
{
-register ilXWCPtr pXWC;
+ilXWCPtr pXWC;
pXWC = (ilXWCPtr)XWC;
if (pXWC->o.p.objectType != IL_XWC) {
unsigned long mustBeZero2
)
{
-register ilXWCPtr pXWC;
+ilXWCPtr pXWC;
XVisualInfo template, *pVisualInfo;
int notUsed;
ilImageInfo *pDstImage /* ignored */
)
{
-register ilXPrivPtr pPriv = (ilXPrivPtr)pPrivate;
-register ilXWCPtr pXWC;
-register XImage *pXImage;
+ilXPrivPtr pPriv = (ilXPrivPtr)pPrivate;
+ilXWCPtr pXWC;
+XImage *pXImage;
/* Create a temp buffer for image pixels if requested. */
if (pPriv->bufferSize > 0) {
XDestroyImage() will try to free the pixels; destroy the image,
created by Init().
*/
- register ilXPrivPtr pPriv = (ilXPrivPtr)pPrivate;
+ ilXPrivPtr pPriv = (ilXPrivPtr)pPrivate;
if (!aborting)
XFlush (pPriv->pXWC->i.display);
if (pPriv->pBuffer)
written *pNLines below this one in the drawable.
*/
static ilError ilWriteXExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
long dstLine,
long *pNLines,
float ratio
)
{
-register ilXPrivPtr pPriv;
-register XImage *pXImage;
+ilXPrivPtr pPriv;
+XImage *pXImage;
ilXWCPtr pXWC;
unsigned int nSrcLines;
unsigned int scaledWidth,scaledHeight;
XPutImage(), then bump linesDone.
*/
static ilError ilWriteXOptLongExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
long dstLine,
long *pNLines,
float ratio
ilXWCPtr pXWC;
ilPtr pSrcLine;
long srcRowBytes, width, nSrcLines, nLinesM1;
-register long nLongsM1;
-register ilPtr pSrc;
-register CARD32 *pDst, temp;
+long nLongsM1;
+ilPtr pSrc;
+CARD32 *pDst, temp;
unsigned int scaledWidth,scaledHeight;
int scaledX, scaledY ;
ilImageDes des;
ilImageFormat format;
unsigned int writeType;
-register ilXWCPtr pXWC;
+ilXWCPtr pXWC;
/* Table indexed by [dst visual type], yielding writeType when in raw
mode */
)
{
ilPipeInfo info;
-register ilXWCPtr pXWC;
-register ilXPrivPtr pPriv;
+ilXWCPtr pXWC;
+ilXPrivPtr pPriv;
ilSrcElementData *pSrcData, srcData;
unsigned long bufferSize;
/*
** We need to use the execute fucntion with the ratio parameter.
*/
-ilError (*executeFunction)( register ilExecuteData *,
+ilError (*executeFunction)( ilExecuteData *,
long,
long *,
float);
long nLinesDiv2, halfWidth;
long CbRowBytes, CrRowBytes;
ilPtr pYLine, pCbLine, pCrLine, pDstLine;
-register unsigned long *pTable;
-register long YRowBytes, dstRowBytes, nPixelsDiv2, CbCr, temp0, temp1;
-register ilPtr pY, pCb, pCr, pDst;
+unsigned long *pTable;
+long YRowBytes, dstRowBytes, nPixelsDiv2, CbCr, temp0, temp1;
+ilPtr pY, pCb, pCr, pDst;
/* This filter handles a pipe image of YCbCr subsampled by 2 in Cb/Cr only.
The # of lines of Cb/Cr is therefore 1/2 the # of lines of Y.
long nLinesDiv2, halfWidth;
long CbRowBytes, CrRowBytes, dstRowBytes;
ilPtr pYLine, pCbLine, pCrLine;
-register unsigned long *pTable;
-register long YRowBytes, nPixelsDiv2, CbCr, temp0, temp1;
-register long dstRowShorts, dstRowShortsTimes2, dstRowShortsTimes3;
-register ilPtr pY, pCb, pCr;
-register unsigned short *pDst;
+unsigned long *pTable;
+long YRowBytes, nPixelsDiv2, CbCr, temp0, temp1;
+long dstRowShorts, dstRowShortsTimes2, dstRowShortsTimes3;
+ilPtr pY, pCb, pCr;
+unsigned short *pDst;
unsigned short *pDstLine;
/* This filter handles a pipe image of YCbCr subsampled by 2 in Cb/Cr only.
/* Setup *pTable as necessary for the YCbCr to RGB (dither) conversion.
*/
static void ilSetupYCbCrDitherTables (
- register ilYCbCrInfo *pYCbCr,
+ ilYCbCrInfo *pYCbCr,
int nBitsR,
int nBitsG,
int nBitsB,
{
int nTableEntries, nLevelsY, nLevelsCbCr;
int Y, Cb, Cr, refY, refCb, refCr;
-register int R, G, B, pixel, i, temp, kernel;
+int R, G, B, pixel, i, temp, kernel;
double Lr, Lg, Lb;
double ditherR, ditherG, ditherB, ditherY, ditherCbCr;
#include "ilerrors.h"
#ifdef LSB_BIT_ORDER
-extern void flip_bits(register ilPtr start, register unsigned n);
+extern void flip_bits(ilPtr start, unsigned n);
#else
# define flip_bits(s,n) /*EMPTY*/
#endif
long nLines, nLinesWritten;
ilPtr pSrcLine, pDstLine;
long colAcc, nDstBits, dstWidth, bottomLine, line;
-register long srcBytesAbove, srcBytesBelow;
-register ilBiGrayPrivPtr pPriv;
-register CARD32 index, *pSrc;
-register int shift, bitNumber;
+long srcBytesAbove, srcBytesBelow;
+ilBiGrayPrivPtr pPriv;
+CARD32 index, *pSrc;
+int shift, bitNumber;
/* Point pSrcLine to srcLine: = middle line of 3x3 matrix.
Set bottomLine to last available line in the buffer.
ilPipeInfo *pInfo
)
{
-register ilBiGrayPrivPtr pPriv;
+ilBiGrayPrivPtr pPriv;
ilDstElementData dstData;
ilImageDes des;
ilPipeInfo *pInfo
)
{
-register ilBiGrayPrivPtr pPriv;
+ilBiGrayPrivPtr pPriv;
ilDstElementData dstData;
#define DEFAULT_GRAY_THRESHOLD 128 /* assumes 256 levels */
unsigned long minNewSize
)
{
-register ilImagePlaneInfo *pPlane;
+ilImagePlaneInfo *pPlane;
pPlane = &pImage->plane[plane];
pPlane->bufferSize = minNewSize + 10000; /* A GUESS - DO SOMETHING SMARTER !!!!! */
Copies one strip of compressed data.
*/
static ilError ilCopyCompressedExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
long dstLine,
long *pNLines
)
{
- register ilImagePlaneInfo *pSrcPlane, *pDstPlane;
+ ilImagePlaneInfo *pSrcPlane, *pDstPlane;
long nBytes, dstOffset, requiredBufferSize;
nBytes = pData->compressed.nBytesToRead; /* # of bytes to write */
{
int rel_diff, abs_diff;
- register unsigned char *bp;
- register int ini_diff;
- register int n, fin_diff;
- register unsigned char *table ;
+ unsigned char *bp;
+ int ini_diff;
+ int n, fin_diff;
+ unsigned char *table ;
bp = sByte;
======================================================================== */
static ilBool _ilCompressG3G4ReallocBuffer (
-register ilCompressG3G4PrivPtr pPriv
+ilCompressG3G4PrivPtr pPriv
)
{
- register unsigned long offset;
+ unsigned long offset;
offset = pPriv->pDstByte - pPriv->pDstImage->plane[0].pPixels;
if (!_ilReallocCompressedBuffer (pPriv->pDstImage, 0, offset + G3_G4_MAX_BUFFER_WRITE))
======================================================================== */
static ilError
_ilPutData (
-register ilCompressG3G4PrivPtr pPriv)
+ ilCompressG3G4PrivPtr pPriv)
{
/* use local variables here, copy the values from pPriv to local & copy them
back at the end of the function; this is expected to be faster */
- register unsigned int bitCount; /* # of bits waiting to be output */
+ unsigned int bitCount; /* # of bits waiting to be output */
/* compatibility problem with long and unsigned long data fields */
- register CARD32 bits; /* bits waiting to be output */
- register ilPtr pDstByte; /* ptr to spot for next byte in output buffer */
- register ilBool Is_Lsb_First;
+ CARD32 bits; /* bits waiting to be output */
+ ilPtr pDstByte; /* ptr to spot for next byte in output buffer */
+ ilBool Is_Lsb_First;
/* Output 3 bytes; check for room in buffer; realloc if not room.
*/
======================================================================== */
static ilError
_ilGetNdPutNewBits(
-register ilCompressG3G4PrivPtr pPriv,
+ ilCompressG3G4PrivPtr pPriv,
int count,
ilBool pixelValue
)
======================================================================== */
static ilError
_ilCompressG3Line(
-register ilCompressG3G4PrivPtr pPriv,
-register ilPtr pSrc
+ ilCompressG3G4PrivPtr pPriv,
+ ilPtr pSrc
)
{
- register int a0, b2; /* changing elements pertaining to the pSrcLine */
- register ilBool pixelValue; /* value of the pixel 0 or 1 */
+ int a0, b2; /* changing elements pertaining to the pSrcLine */
+ ilBool pixelValue; /* value of the pixel 0 or 1 */
ilError error;
- register long width; /* width of the image */
- register ilBool white; /* value of the white pixel */
+ long width; /* width of the image */
+ ilBool white; /* value of the white pixel */
#ifndef NOINLINEG3
- register int ini_diff;
- register int n, fin_diff;
- register unsigned char *table ;
- register ilBool termFlag ;
- register int index;
- register int tnumBits ;
- register int count;
+ int ini_diff;
+ int n, fin_diff;
+ unsigned char *table ;
+ ilBool termFlag ;
+ int index;
+ int tnumBits ;
+ int count;
CARD32 tnewBits;
#endif
======================================================================== */
ilError
_ilCompressG4Line(
-register ilCompressG3G4PrivPtr pPriv,
+ ilCompressG3G4PrivPtr pPriv,
ilPtr pSrcLine,
ilPtr pRefLine
)
/* Reallocate the output (compressed) buffer and reset pPriv->pDst(BufferEnd).
*/
static ilBool ilLZWReallocBuffer (
- register ilCompLZWPrivPtr pPriv
+ ilCompLZWPrivPtr pPriv
)
{
- register unsigned long offset;
+ unsigned long offset;
offset = pPriv->pDst - pPriv->pDstImage->plane[0].pPixels;
if (!_ilReallocCompressedBuffer (pPriv->pDstImage, 0, offset + LZW_MAX_BUFFER_WRITE))
Initializes the encode table with the first 256 strings (i.e. 0-ff).
*/
static void ilInitEncodeTable (
- register ilCompLZWPrivPtr pPriv
+ ilCompLZWPrivPtr pPriv
)
{
- register int i;
+ int i;
for (i = 0; i < 256; i++) {
pPriv->ennodes[i].value = i;
ilCompLZWPrivPtr pPriv,
ilPtr string,
unsigned int count,
- register unsigned int *pCurrentNode
+ unsigned int *pCurrentNode
)
{
- register unsigned int byte; /* current character in string */
- register ilEnnodePtr ennodes;
+ unsigned int byte; /* current character in string */
+ ilEnnodePtr ennodes;
ennodes = pPriv->ennodes;
byte = string[count-1];
If the bit stream is longer than 16 bits, two bytes will be written.
*/
static ilError ilWriteCode (
- register ilCompLZWPrivPtr pPriv,
+ ilCompLZWPrivPtr pPriv,
unsigned int code
)
{
unsigned long *pNLines
)
{
- register ilCompLZWPrivPtr pPriv;
+ ilCompLZWPrivPtr pPriv;
ilPtr pSrcLine, pSrc;
ilByte srcByte;
long nLines, srcRowBytes, nSrcBytes;
unsigned long nBytes = 0; /* Number of source image bytes to unpack for current strip */
unsigned long nLines; /* Number of lines per source image strip */
- register ilPtr pSrcByte; /* Pointer to source image data first byte */
+ ilPtr pSrcByte; /* Pointer to source image data first byte */
ilPtr pSrcLine; /* Pointer to source image data first byte of line */
- register ilPtr pDstByte; /* Pointer to destination image data */
+ ilPtr pDstByte; /* Pointer to destination image data */
ilPtr pDstBufferEnd; /* Ptr to byte "PB_MAX_BUFFER_WRITE" from end of compressed buffer */
unsigned long srcNBytes; /* Number of source image bytes per row */
ilCompPBPrivPtr pPriv; /* Pointer to private image data */
long offset; /* difference between current dst image address pointer and the
start address of the dst image buffer */
long length; /* number of bytes written to dst image */
- register int count; /* run count value */
- register int start, j; /* indices into source data */
- register int nBytesM1; /* bytes per row of data minus one */
+ int count; /* run count value */
+ int start, j; /* indices into source data */
+ int nBytesM1; /* bytes per row of data minus one */
/* ========================================================================
Set up for execution of compression algorithm code
ilCompressJPEGPrivPtr pPriv
)
{
- register int i;
+ int i;
ilPtr pTable;
- register ilJPEGData *pCompData;
+ ilJPEGData *pCompData;
/* Free pCompData and any non-default Q tables */
if (pCompData = pPriv->pCompData) {
unsigned long *pNLines
)
{
- register ilCompressJPEGPrivPtr pPriv;
+ ilCompressJPEGPrivPtr pPriv;
ilJPEGEncodeStream streamRec;
ilImageInfo *pImage;
ilImagePlaneInfo *pSrcPlane;
and return ptr to new table, or null if error.
*/
static ilPtr _ilScaleQTable (
- register ilPtr pSrc, /* ptr to 64 byte Q table to scale */
+ ilPtr pSrc, /* ptr to 64 byte Q table to scale */
int Q /* IL Q factor: != 0, or no scale needed */
)
{
ilPtr pTable;
- register ilPtr pDst;
- register int i, value;
+ ilPtr pDst;
+ int i, value;
if (!(pTable = (ilPtr)IL_MALLOC (64)))
return (ilPtr)NULL;
unsigned long mustBeZero
)
{
-register ilContextPtr pContext;
+ilContextPtr pContext;
/* If internal version # > the version # the library was built with, then
error; if <, old IL program using new library: supported.
unsigned long nBytes
)
{
-register ilPtr p, pMalloc;
+ilPtr p, pMalloc;
pMalloc = (ilPtr)malloc (nBytes);
if (p = pMalloc) {
ilContext context
)
{
-register ilContextPtr pContext;
+ilContextPtr pContext;
/* Increment code (but not if it has wrapped to zero! and return it.
*/
ilContext context
)
{
-register ilContextPtr pContext;
+ilContextPtr pContext;
int i;
/* Destroy all objects associated with this context, then free
Not in this file for any particular reason; no other logical place for it.
*/
IL_PRIVATE void _ilIntersectRect (
- register ilRect *pSrcRect,
- register ilRect *pDstRect
+ ilRect *pSrcRect,
+ ilRect *pDstRect
)
{
long left, top, right, bottom, i;
ilImageDes *pSrcDes,
ilImageFormat *pSrcFormat,
void *pOptionData,
- register ilConvertPtr pCvtData
+ ilConvertPtr pCvtData
)
{
ilPtr pPriv;
ilPipe pipe,
ilPipeInfo *pInfo,
const ilImageFormat *pNewFormat,
- register ilFormatPtr pData
+ ilFormatPtr pData
)
{
ilPtr pPriv;
*/
unsigned int ilCheckPipeFormat (
ilPipe pipe,
- register unsigned long formatMask,
+ unsigned long formatMask,
ilPipeInfo *pInfo, /* RETURNED */
- register ilImageDes *pDes, /* RETURNED */
- register ilImageFormat *pFormat /* RETURNED */
+ ilImageDes *pDes, /* RETURNED */
+ ilImageFormat *pFormat /* RETURNED */
)
{
ilPipeInfo localInfo;
IL_EXTERN ilBool _ilConvertRGBToPalette (
ilPipe pipe,
ilPipeInfo *pInfo,
- register ilImageDes *pDes,
+ ilImageDes *pDes,
ilImageFormat *pFormat,
int option,
ilConvertToPaletteInfo *pData
ilPipe pipe,
ilPipeInfo *pInfo,
ilImageDes *pDes,
- register const ilImageDes *pNewDes,
+ const ilImageDes *pNewDes,
ilImageFormat *pFormat
);
long *pNLines
)
{
-register ilCropCompPrivPtr pPriv;
+ilCropCompPrivPtr pPriv;
/* If this strip is out of range of strips to be written, return 0 for
# lines written (crops the strip); otherwise pass strip on to next filter.
)
{
ilRect rect;
-register long stripHeight, bottom;
+long stripHeight, bottom;
long topStrip, bottomStrip, topLine;
ilDstElementData dstData;
ilCropCompPrivPtr pPriv;
============================================================================================================================= */
static ilError ilCropBitonalExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register CARD32 *psrc, *pdst, *psrcline, *pdstline, srca, srcb;
-register long srcnwords, dstnwords, nlines;
-register unsigned long dstwidth;
-register long nlongs, firstword;
+CARD32 *psrc, *pdst, *psrcline, *pdstline, srca, srcb;
+long srcnwords, dstnwords, nlines;
+unsigned long dstwidth;
+long nlongs, firstword;
ilImagePlaneInfo *pplane;
-register unsigned long local_noDstLine, Lwordoff, Rwordoff;
-register int x, y, lastcount, yextent;
-register ilCropPrivptr pPriv;
+unsigned long local_noDstLine, Lwordoff, Rwordoff;
+int x, y, lastcount, yextent;
+ilCropPrivptr pPriv;
============================================================================================================================= */
static ilError ilCrop3ByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes, nlines;
-register unsigned long dstwidth;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes, nlines;
+unsigned long dstwidth;
ilImagePlaneInfo *pplane;
-register unsigned long local_noDstLine;
-register int x, y, lastcount, yextent, xextent;
-register ilCropPrivptr pPriv;
+unsigned long local_noDstLine;
+int x, y, lastcount, yextent, xextent;
+ilCropPrivptr pPriv;
nlines = *pNLines;
============================================================================================================================= */
static ilError ilCropByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes, nlines;
-register unsigned long dstwidth;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes, nlines;
+unsigned long dstwidth;
ilImagePlaneInfo *pplane;
-register unsigned long local_noDstLine;
-register int x, y, lastcount, yextent, xextent;
-register ilCropPrivptr pPriv;
+unsigned long local_noDstLine;
+int x, y, lastcount, yextent, xextent;
+ilCropPrivptr pPriv;
nlines = *pNLines;
{
unsigned int state;
ilPipeInfo info;
-register ilCropPrivptr pPriv;
+ilCropPrivptr pPriv;
ilDstElementData dstdata;
ilImageDes imdes;
ilImageFormat imformat;
======================================================================== */
static ilError _ilDecompG3Line(
-register ilDecompG3G4PrivPtr pPriv,
+ilDecompG3G4PrivPtr pPriv,
ilPtr dstImageP
)
{
ilPtr ImageP;
int srcpos;
- register ilDecompG4HuffTablePtrConst pDecodeWhite = ilArFax1DDecodeWhite;
- register ilDecompG4HuffTablePtrConst pDecodeTemp;
- register ilDecompG4HuffTablePtrConst pDecodeBlack = ilArFax1DDecodeBlack;
- register ilPtr sByte;
- register int no_of_ones;
- register int startPixel;
+ ilDecompG4HuffTablePtrConst pDecodeWhite = ilArFax1DDecodeWhite;
+ ilDecompG4HuffTablePtrConst pDecodeTemp;
+ ilDecompG4HuffTablePtrConst pDecodeBlack = ilArFax1DDecodeBlack;
+ ilPtr sByte;
+ int no_of_ones;
+ int startPixel;
static const unsigned char fillmasks[] =
{
int temp; /* some temp var.. */
ilBool tag_bit; /* True or 1 for G3 1D coded line ,else G3 2d */
long nLines; /* no. of lines in the current strip */
- register ilDecompG4HuffTablePtrConst pDecodeWhite = ilArFax1DDecodeWhite;
- register ilDecompG4HuffTablePtrConst pDecodeTemp;
+ ilDecompG4HuffTablePtrConst pDecodeWhite = ilArFax1DDecodeWhite;
+ ilDecompG4HuffTablePtrConst pDecodeTemp;
/* ========================================================================
IL_PRIVATE void
_ilPutOnes(
-register char *sByte,
-register int startPixel,
-register int no_of_ones )
+char *sByte,
+int startPixel,
+int no_of_ones )
{
static const unsigned char masks[] =
int nTimes)
{
- register unsigned char *bp;
- register int ini_diff;
- register int n, fin_diff;
- register unsigned char *table ;
+ unsigned char *bp;
+ int ini_diff;
+ int n, fin_diff;
+ unsigned char *table ;
bp = sByte;
image by Two dimensional coding.
======================================================================== */
ilError _ilDecompG4Line(
-register ilDecompG3G4PrivPtr pPriv,
+ilDecompG3G4PrivPtr pPriv,
ilPtr pRefLine,
ilPtr dstImageP
)
ilPtr ImageP;
int srcpos;
- register ilDecompG4HuffTablePtrConst pDecodeWhite = ilArFax1DDecodeWhite;
- register ilDecompG4HuffTablePtrConst pDecodeTemp;
- register ilDecompG4HuffTablePtrConst pDecodeBlack = ilArFax1DDecodeBlack;
+ ilDecompG4HuffTablePtrConst pDecodeWhite = ilArFax1DDecodeWhite;
+ ilDecompG4HuffTablePtrConst pDecodeTemp;
+ ilDecompG4HuffTablePtrConst pDecodeBlack = ilArFax1DDecodeBlack;
/* Deccompression Procedure ....
IL_EXTERN const ilDecompG4HuffTableRec ilArFax2DDecodeTable[G4K_DecodeTableSize];
IL_EXTERN ilError _ilDecompG4Line(
-register ilDecompG3G4PrivPtr pPriv,
+ilDecompG3G4PrivPtr pPriv,
ilPtr pRefLine,
ilPtr dstImageP
);
unsigned long *pNLines
)
{
- register ilJPEGPrivPtr pPriv;
+ ilJPEGPrivPtr pPriv;
ilJPEGDecodeStream streamRec;
ilError error;
iljpgPtr pPixels[ILJPG_MAX_COMPS];
long nBytesPerRow[ILJPG_MAX_COMPS];
int i;
ilImagePlaneInfo *pPlane;
- register ilImageInfo *pSrcImage, *pDstImage;
+ ilImageInfo *pSrcImage, *pDstImage;
pPriv = (ilJPEGPrivPtr)pData->pPrivate;
pSrcImage = pData->pSrcImage;
unsigned long *pNLines
)
{
- register ilJPEGPrivPtr pPriv;
+ ilJPEGPrivPtr pPriv;
ilError error;
int i;
iljpgPtr pPixels[ILJPG_MAX_COMPS];
======================================================================== */
static int ilCurrentBitsRead (
- register ilDecompPrivPtr pPriv
+ ilDecompPrivPtr pPriv
)
{
int retval;
{
unsigned int index;
int node;
- register ilDenodePtr denodes = pPriv->denodes;
+ ilDenodePtr denodes = pPriv->denodes;
if (code > 255) node = code - 2; /* remove for extra codes */
else node = code;
======================================================================== */
static ilError ilInitializeDecodeTable (
- register ilDecompPrivPtr pPriv
+ ilDecompPrivPtr pPriv
)
{
unsigned int i;
long nLines; /* Number of lines per source image strip */
long nBytesToGo; /* Number of source image bytes left to unpack for current strip */
long nDstLineBytesToGo; /* Number of bytes left to write to this line of destination */
- register ilPtr pSrcByte; /* Pointer to source image data */
- register ilPtr pDstByte; /* Pointer to destination image data first byte */
+ ilPtr pSrcByte; /* Pointer to source image data */
+ ilPtr pDstByte; /* Pointer to destination image data first byte */
ilPtr pSrcStart; /* Pointer to initial src (comp) byte */
ilPtr pDstLine; /* Pointer to destination image data first byte of each scanline */
- register ilDecompPrivPtr pPriv; /* Pointer to private image data */
+ ilDecompPrivPtr pPriv; /* Pointer to private image data */
ilImagePlaneInfo *pPlane;
/* Greeley defines */
- register unsigned int bitCount;
+ unsigned int bitCount;
unsigned int numBits;
/* compatibility problem with long and unsigned long data fields */
CARD32 bits;
long k;
- register unsigned int code;
+ unsigned int code;
unsigned int oldCode;
unsigned int stringCount = 0;
ilError status = IL_OK;
unsigned long dstNBytes; /* Number of destination image bytes per row */
long nLines; /* Number of lines per source image strip */
- register long nBytesToGo; /* Number of source image bytes left to unpack for current strip */
- register long nDstLineBytesToGo; /* Number of bytes left to write to this line of destination */
- register ilPtr pSrcByte; /* Pointer to source image data */
- register ilPtr pDstByte; /* Pointer to destination image data first byte */
+ long nBytesToGo; /* Number of source image bytes left to unpack for current strip */
+ long nDstLineBytesToGo; /* Number of bytes left to write to this line of destination */
+ ilPtr pSrcByte; /* Pointer to source image data */
+ ilPtr pDstByte; /* Pointer to destination image data first byte */
ilPtr pSrcLine; /* Pointer to source image data first byte of each scanline */
ilPtr pDstLine; /* Pointer to destination image data first byte of each scanline */
ilDecompPBPrivPtr pPriv; /* Pointer to private image data */
ilImagePlaneInfo *pPlane;
- register int count; /* run-length code value */
- register ilByte repeatbyte; /* repeated data */
+ int count; /* run-length code value */
+ ilByte repeatbyte; /* repeated data */
/* ========================================================================
long nLinesM1;
long srcRowBytes, dstRowBytes;
ilPtr pSrcLine, pDstLine;
-register long x, yMod8Times8, width;
-register const unsigned short *pMulR, *pMulG, *pMulB;
-register ilPtr pSrc, pDst, pTranslate;
-register unsigned long pixel, kernel;
-register int upShiftR, upShiftG;
+long x, yMod8Times8, width;
+const unsigned short *pMulR, *pMulG, *pMulB;
+ilPtr pSrc, pDst, pTranslate;
+unsigned long pixel, kernel;
+int upShiftR, upShiftG;
pPriv = (ilDitherPrivPtr)pData->pPrivate;
width = pPriv->width;
long nLinesM1;
long srcRowBytes, dstRowBytes;
ilPtr pSrcLine, pDstLine;
-register long x, yMod8Times8, width;
-register const unsigned short *pMul8, *pMul4;
-register ilPtr pSrc, pDst, pTranslate;
-register unsigned long pixel, kernel;
+long x, yMod8Times8, width;
+const unsigned short *pMul8, *pMul4;
+ilPtr pSrc, pDst, pTranslate;
+unsigned long pixel, kernel;
pPriv = (ilDitherPrivPtr)pData->pPrivate;
width = pPriv->width;
ilDitherPrivPtr pPriv;
long srcRowBytes, dstRowBytes;
long nLinesM1, nPixelsM1, nPixelsM1Init;
-register int red, green, blue;
-register int redAboveError, greenAboveError, blueAboveError;
-register int redAboveLeftError, greenAboveLeftError, blueAboveLeftError;
-register int redAboveRightError, greenAboveRightError, blueAboveRightError;
+int red, green, blue;
+int redAboveError, greenAboveError, blueAboveError;
+int redAboveLeftError, greenAboveLeftError, blueAboveLeftError;
+int redAboveRightError, greenAboveRightError, blueAboveRightError;
int redRShift, greenRShift, blueRShift;
-register long pixel;
-register int *pError;
-register ilPtr pSrc;
+long pixel;
+int *pError;
+ilPtr pSrc;
long *pColorTable;
ilPtr pDst, pSrcLine, pDstLine;
ilDitherPrivPtr pPriv;
long srcRowBytes, dstRowBytes;
long nLinesM1, nPixelsM1, nPixelsM1Init;
-register int red, green, blue;
-register int redAboveError, greenAboveError, blueAboveError;
-register int redAboveLeftError, greenAboveLeftError, blueAboveLeftError;
-register int redAboveRightError, greenAboveRightError, blueAboveRightError;
-register long pixel;
-register int *pError;
-register ilPtr pSrc;
+int red, green, blue;
+int redAboveError, greenAboveError, blueAboveError;
+int redAboveLeftError, greenAboveLeftError, blueAboveLeftError;
+int redAboveRightError, greenAboveRightError, blueAboveRightError;
+long pixel;
+int *pError;
+ilPtr pSrc;
long *pColorTable;
ilPtr pDst, pSrcLine, pDstLine;
ilDitherPrivPtr pPriv;
long srcRowBytes, dstRowBytes;
long nLinesM1, nPixelsM1, nPixelsM1Init;
-register int red, green, blue;
-register int redRShift, greenRShift, blueRShift;
-register long pixel;
-register int *pError;
-register ilPtr pSrc;
-register long *pColorTable;
+int red, green, blue;
+int redRShift, greenRShift, blueRShift;
+long pixel;
+int *pError;
+ilPtr pSrc;
+long *pColorTable;
ilPtr pDst, pSrcLine, pDstLine;
/* Same as regular diffusion above, except spread the errors in a simpler and
convertBoxTotalRec total, part1, part2;
convertBoxCountRec count;
convertBoxRec slice;
-register convertBoxRec *pBox = &BoxTable[box];
+convertBoxRec *pBox = &BoxTable[box];
double temp, ssq1, ssq2;
-register int axis, plane, rgb, n;
+int axis, plane, rgb, n;
if ( CountBox( pBox, Ftable, &count ) ) {
long *pNLines
)
{
-register ilDitherPrivPtr pPriv;
+ilDitherPrivPtr pPriv;
long srcRowBytes, dstRowBytes, nRowsM1, nLinesM1;
long width, height;
ilPtr pSrcLine, pDstLine;
-register long rowCount;
-register ilPtr pSrc, pDst;
-register unsigned short *pPalette;
+long rowCount;
+ilPtr pSrc, pDst;
+unsigned short *pPalette;
int nBoxes, nColors;
int index, axis, plane, inner, outer;
unsigned long *Ftable;
pSrcLine += srcRowBytes;
rowCount = nRowsM1;
do {
- register ilByte R, G, B;
+ ilByte R, G, B;
R = *pSrc++; /* red */
G = *pSrc++; /* green */
}
for ( outer = 0 ; outer < nBoxes ; outer++ ) {
- register convertBoxRec *pBox = &box[outer];
- register int R, G, B;
+ convertBoxRec *pBox = &box[outer];
+ int R, G, B;
int rgb_inner, rgb_outer, rgb_limit;
unsigned char multiple, candidate[256];
double ssq_inner, ssq_outer, distance;
pDstLine += dstRowBytes;
rowCount = nRowsM1;
do {
- register ilByte R, G, B, P;
+ ilByte R, G, B, P;
R = *pSrc++; /* red */
G = *pSrc++; /* green */
IL_PRIVATE ilBool _ilConvertRGBToPalette (
ilPipe pipe,
ilPipeInfo *pInfo,
- register ilImageDes *pDes,
+ ilImageDes *pDes,
ilImageFormat *pFormat,
int option,
- register ilConvertToPaletteInfo *pData
+ ilConvertToPaletteInfo *pData
)
{
- register ilDitherPrivPtr pPriv;
+ ilDitherPrivPtr pPriv;
ilDstElementData dstData;
ilSrcElementData srcData;
ilError (*executeFunction)(), (*cleanupFunction)();
with r/g/b/pixel together, instead of 0..65535 and rgb spread apart.
*/
if (diffusion) {
- register int i, index;
+ int i, index;
int red, green, blue;
int redLevel, greenLevel, blueLevel;
- register long *pColorTemp;
+ long *pColorTemp;
pColorTable = (long *)IL_MALLOC (sizeof (long) * 256);
if (!pColorTable) {
ilDeclarePipeInvalid (pipe, IL_ERROR_MALLOC);
goto cleanup;
}
if (!chooseColors) {
- register int red, green, blue;
- register int redLevel, greenLevel, blueLevel;
- register unsigned short *pPal;
+ int red, green, blue;
+ int redLevel, greenLevel, blueLevel;
+ unsigned short *pPal;
pPal = pPalette;
for (red = 0; red < pData->levels[0]; red++) {
ilContext context
)
{
-register ilEFSPrivatePtr pPriv;
+ilEFSPrivatePtr pPriv;
/* If EFS file type data not present malloc and zero it, and then point
context pAlloc to it - if not, could recurse forever.
ilEFSFileTypePtr pListHead
)
{
-register ilEFSFileTypePtr pFileType;
+ilEFSFileTypePtr pFileType;
pFileType = pListHead->h.pNext;
while (pFileType != pListHead) {
checkOrder.
*/
static void ilAddFileTypeToList (
- register ilEFSFileTypePtr pFileType,
+ ilEFSFileTypePtr pFileType,
ilEFSFileTypePtr pListHead
)
{
-register ilEFSFileTypePtr pListFileType;
-register int checkOrder;
+ilEFSFileTypePtr pListFileType;
+int checkOrder;
checkOrder = pFileType->info.checkOrder;
pListFileType = pListHead->h.pNext;
/* Object Destroy() function for file type objects. */
static void ilDestroyFileType (
- register ilEFSFileTypePtr pFileType
+ ilEFSFileTypePtr pFileType
)
{
ilEFSPrivatePtr pPriv;
-register ilEFSFileTypePtr pReplaced;
+ilEFSFileTypePtr pReplaced;
pPriv = (ilEFSPrivatePtr)
((ilContextPtr)(pFileType->h.o.p.context))->pAlloc[IL_CONTEXT_ALLOC_EFS];
ilEFSFileType ilEFSAddFileType (
ilContext context,
- register ilEFSFileTypeInfo *pInfo,
+ ilEFSFileTypeInfo *pInfo,
void *pOptions
)
{
ilEFSPrivatePtr pPriv;
int i;
-register ilEFSFileTypePtr pFileType, pReplace;
-register unsigned long openModes;
+ilEFSFileTypePtr pFileType, pReplace;
+unsigned long openModes;
/* masks for defined bits in ilEFSFileTypeInfo - others invalid */
#define OPEN_MODE_MASKS (1<<IL_EFS_READ | 1<<IL_EFS_READ_SEQUENTIAL | 1<<IL_EFS_WRITE)
ilEFSFileTypeInfo *pInfo
)
{
-register ilEFSFileTypePtr pFileType;
+ilEFSFileTypePtr pFileType;
pFileType = (ilEFSFileTypePtr)fileType;
if (pFileType->h.o.p.objectType != IL_EFS_FILE_TYPE) {
)
{
ilEFSPrivatePtr pPriv;
-register int nFileTypes;
-register ilEFSFileTypePtr pFileType;
-register ilEFSFileType *pfileType;
+int nFileTypes;
+ilEFSFileTypePtr pFileType;
+ilEFSFileType *pfileType;
*pNFileTypes = 0;
*pfileTypes = (ilEFSFileType *)NULL;
ilEFSFilePtr pFile
)
{
-register ilEFSFileTypePtr pFileType;
+ilEFSFileTypePtr pFileType;
/* Get ptr to file type; if null, file not actually open yet; skip Close() */
pFileType = (ilEFSFileTypePtr)pFile->info.fileType;
)
{
ilEFSPrivatePtr pPriv;
-register ilEFSFilePtr pFile;
-register ilEFSFileTypePtr pFileType, pListHead;
+ilEFSFilePtr pFile;
+ilEFSFileTypePtr pFileType, pListHead;
ilBool readOpen;
long nPages;
ilPtr pOpenPriv;
/* If not found, search for extension if enabled. */
if (!pFileType && (searchOptions & IL_EFS_BY_EXTENSION)) {
char *pExtension;
- register ilEFSFileTypePtr pSearch;
+ ilEFSFileTypePtr pSearch;
int nChars;
pExtension = strrchr (fileName, '.');
/* Search list for extension match until pFileType found or list done */
pSearch = pListHead->h.pNext;
while (!pFileType && (pSearch != pListHead)) {
- register int nExtensions = pSearch->info.nExtensions;
+ int nExtensions = pSearch->info.nExtensions;
while (nExtensions-- > 0)
if (STRING_EQUAL (extension, pSearch->info.extensions[nExtensions])) {
pFileType = pSearch; /* extension found; quit */
try open if enabled (checkOrder != 0) and openMode supported for file type.
*/
if (!pFileType && readOpen && (searchOptions & IL_EFS_BY_CHECKING)) {
- register ilEFSFileTypePtr pSearch;
+ ilEFSFileTypePtr pSearch;
pSearch = pListHead->h.pNext;
while (pSearch != pListHead) {
ilEFSFileInfo *pInfo /* RETURNED */
)
{
-register ilEFSFilePtr pFile;
+ilEFSFilePtr pFile;
pFile = (ilEFSFilePtr)file;
if (pFile->o.p.objectType != IL_EFS_FILE) {
void *pOptions
)
{
-register ilEFSFilePtr pFile;
+ilEFSFilePtr pFile;
pFile = (ilEFSFilePtr)file;
if (pOptions) {
ilEFSPageInfo *pInfo
)
{
-register ilEFSFilePtr pFile;
+ilEFSFilePtr pFile;
pFile = (ilEFSFilePtr)file;
if (pFile->o.p.objectType != IL_EFS_FILE) {
void *pOptions
)
{
-register ilEFSFilePtr pFile;
+ilEFSFilePtr pFile;
pFile = (ilEFSFilePtr)file;
if (pOptions) {
void *pOptions
)
{
-register ilEFSFilePtr pFile;
+ilEFSFilePtr pFile;
pFile = (ilEFSFilePtr)file;
if (pOptions) {
maskImage = (ilClientImage)NULL;
else {
ilImageInfo *pInfo;
- register const ilImageDes *pDes;
- register const ilImageFormat *pFormat;
+ const ilImageDes *pDes;
+ const ilImageFormat *pFormat;
if (!ilQueryClientImage (maskImage, &pInfo, 0))
return FALSE;
{
ilImagePlaneInfo *pImagePlane;
long srcRowBytes, dstRowBytes;
-register long nLinesM1, nBytes;
-register ilPtr pSrc, pDst;
+long nLinesM1, nBytes;
+ilPtr pSrc, pDst;
/* Use bcopy to copy each line; copy the lesser of the src/dstRowBytes.
Exit if no lines or pixels.
ilImagePlaneInfo *pImagePlane;
long src0RowBytes, src1RowBytes, src2RowBytes, dstRowBytes;
long nPixelsM1Init;
-register long nLinesM1, nPixelsM1;
+long nLinesM1, nPixelsM1;
ilPtr pSrc0Line, pSrc1Line, pSrc2Line, pDstLine;
-register ilPtr pSrc0, pSrc1, pSrc2, pDst;
+ilPtr pSrc0, pSrc1, pSrc2, pDst;
/* Get ptr to start of 3 src planes and to dst */
pImagePlane = pData->pSrcImage->plane;
ilImagePlaneInfo *pImagePlane;
long dst0RowBytes, dst1RowBytes, dst2RowBytes, srcRowBytes;
long nPixelsM1Init;
-register long nLinesM1, nPixelsM1;
+long nLinesM1, nPixelsM1;
ilPtr pDst0Line, pDst1Line, pDst2Line, pSrcLine;
-register ilPtr pDst0, pDst1, pDst2, pSrc;
+ilPtr pDst0, pDst1, pDst2, pSrc;
/* Get ptr to start src plane and to 3 dst planes */
pImagePlane = pData->pSrcImage->plane;
long srcRowBytes, dstRowBytes, nBytesM1Init, nLinesM1;
ilBool oddNumberOfNibbles;
ilPtr pSrcLine, pDstLine;
-register long nBytesM1;
-register ilPtr pSrc, pDst;
-register ilByte byte;
+long nBytesM1;
+ilPtr pSrc, pDst;
+ilByte byte;
/* Exit if no lines or pixels. */
pSrcImage = pData->pSrcImage;
long srcRowBytes, dstRowBytes, nBytesM1Init, nLinesM1;
ilBool oddNumberOfNibbles;
ilPtr pSrcLine, pDstLine;
-register long nBytesM1;
-register ilPtr pSrc, pDst;
-register ilByte byte0, byte1;
+long nBytesM1;
+ilPtr pSrc, pDst;
+ilByte byte0, byte1;
/* Exit if no lines or pixels. */
pSrcImage = pData->pSrcImage;
long srcRowBytes, dstRowBytes, nBytesM1Init, nLinesM1;
ilBool oddNumberOfNibbles;
ilPtr pSrcLine, pDstLine;
-register long nBytesM1;
-register ilPtr pSrc, pDst;
-register ilByte byte;
+long nBytesM1;
+ilPtr pSrc, pDst;
+ilByte byte;
/* Use bcopy to copy each line; copy the lesser of the src/dstRowBytes.
Exit if no lines or pixels.
ilImagePlaneInfo *pImagePlane;
long srcRowBytes, dstRowBytes, nBytesM1Init, nLinesM1;
ilPtr pSrcLine, pDstLine;
-register long nBytesM1;
-register ilPtr pSrc, pDst;
-register ilByte byte;
+long nBytesM1;
+ilPtr pSrc, pDst;
+ilByte byte;
/* Use bcopy to copy each line; copy the lesser of the src/dstRowBytes.
Exit if no lines or pixels.
#ifndef LSB_BIT_ORDER
# define flip_bits(start,n) /*EMPTY*/
#else
-extern void flip_bits(register ilPtr start, register unsigned n);
+extern void flip_bits(ilPtr start, unsigned n);
extern void
-flip_bits(register ilPtr start,
- register unsigned n )
+flip_bits(ilPtr start,
+ unsigned n )
{
- register int i;
+ int i;
unsigned char c;
for (i = 0; i < n; i++) {
#endif
ilBiDiffusionPrivPtr pPriv;
long nLinesM1, nPixelsM1Init, nPixelsM1;
-register short *pPrevError, *pError;
-register int errorAcc, invert;
+short *pPrevError, *pError;
+int errorAcc, invert;
long srcRowBytes, dstRowBytes;
ilPtr pSrcLine, pDstLine;
-register ilPtr pSrc;
-register CARD32 mask, *pDst;
+ilPtr pSrc;
+CARD32 mask, *pDst;
CARD32 outLong;
pPriv = (ilBiDiffusionPrivPtr)pData->pPrivate;
long nLinesM1, nPixelsM1Init;
long srcRowBytes, dstRowBytes;
ilPtr pSrcLine, pDstLine;
-register long nPixelsM1;
-register ilPtr pSrc;
-register CARD32 mask, *pDst;
+long nPixelsM1;
+ilPtr pSrc;
+CARD32 mask, *pDst;
CARD32 outLong;
-register ilByte threshold;
+ilByte threshold;
pPriv = (ilThresholdPrivPtr)pData->pPrivate;
threshold = *pPriv->pThreshold;
============================================================================================================================= */
static ilError ilRotateCleanup (
- register ilRotatePrivptr pPriv,
+ ilRotatePrivptr pPriv,
ilBool aborting
)
{
============================================================================================================================= */
static ilError ilRotateExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
ilImagePlaneInfo *pplane;
-register ilRotatePrivptr pPriv;
+ilRotatePrivptr pPriv;
int nrows, nlines, nlinesout;
if (*pNLines <= 0) return IL_OK;
{
unsigned int state;
ilPipeInfo info;
-register ilRotatePrivptr pPriv;
+ilRotatePrivptr pPriv;
ilDstElementData dstdata;
ilImageDes imdes;
ilImageFormat imformat;
OPERAND first_pix, last_pix, col;
float Y, x, y;
OPERAND ex, ey, dx, dy;
- register DATA_IN_PTR data;
+ DATA_IN_PTR data;
/* Find coord of first & last pixels in the new image coord. system */
first_pix = First_Pixel(r_next_row_out);
OPERAND first_pix, last_pix, col;
float Y, x, y;
OPERAND ex, ey, dx, dy;
- register DATA_IN_PTR data, data2;
+ DATA_IN_PTR data, data2;
OPERAND val1, val2, x1, y1, t;
size_t input_row_size;
*/
IL_PRIVATE ilError _ilValidateDesFormat (
ilBool allowPrivateTypes,
- register const ilImageDes *pDes,
- register const ilImageFormat *pFormat
+ const ilImageDes *pDes,
+ const ilImageFormat *pFormat
)
{
#define MAX_BITS_PER_SAMPLE 24 /* maximum # of bits/sample supported */
-register unsigned int i, j, nBits, nLevels, nSamplesPerPixel;
+unsigned int i, j, nBits, nLevels, nSamplesPerPixel;
const ilYCbCrSampleInfo *pSample;
/* reserved must = 0; # samples must be 1 .. IL_MAX_SAMPLES.
format "*pFormat".
*/
void ilGetBytesPerRow (
- register const ilImageDes *pDes,
- register const ilImageFormat *pFormat,
+ const ilImageDes *pDes,
+ const ilImageFormat *pFormat,
long width,
long *pnBytesPerRow /* RETURNED */
)
{
-register const unsigned short *pNBits;
-register int rowBitAlign, nBits, nSamplesPerPixel, i;
+const unsigned short *pNBits;
+int rowBitAlign, nBits, nSamplesPerPixel, i;
pNBits = pFormat->nBitsPerSample;
rowBitAlign = pFormat->rowBitAlign;
* (rowBitAlign / 8);
}
else {
- register const ilYCbCrSampleInfo *pYCbCr;
+ const ilYCbCrSampleInfo *pYCbCr;
/* Planar order: each plane is independent; return nSamplesPerPixel rowbytes.
Take into account subsampling if YCbCr image.
Returns: zero if success, else error code.
*/
IL_PRIVATE ilError _ilMallocImagePixels (
- register ilImagePtr pImage
+ ilImagePtr pImage
)
{
-register int plane, nPlanes;
+int plane, nPlanes;
int MCUMinus1;
-register long nBytesToAlloc, nBytesPerRow, allocHeight;
+long nBytesToAlloc, nBytesPerRow, allocHeight;
ilPtr pPixels;
long rowBytesPerPlane [IL_MAX_SAMPLES];
-register ilYCbCrSampleInfo *pYCbCr;
+ilYCbCrSampleInfo *pYCbCr;
/* Get the bytes per row, set into the image. */
Free the pixels of the image only if the IL owns them.
*/
IL_PRIVATE void _ilFreeImagePixels (
- register ilImagePtr pImage
+ ilImagePtr pImage
)
{
int plane;
is zero (0). Locks image to that strip height.
*/
IL_PRIVATE ilBool _ilAllocStripOffsets (
- register ilImagePtr pImage,
- register long stripHeight
+ ilImagePtr pImage,
+ long stripHeight
)
{
-register long nStrips;
+long nStrips;
if (stripHeight <= 0)
stripHeight = ilRecommendedStripHeight (pImage->i.pDes, pImage->i.pFormat,
unsigned long mustBeZero
)
{
-register ilImagePtr pImage;
+ilImagePtr pImage;
ilError error;
unsigned long mustBeZero
)
{
-register ilImagePtr pImage;
+ilImagePtr pImage;
/* Check that given image is an internal image.
unsigned long mustBeZero
)
{
-register ilImagePtr pImage;
+ilImagePtr pImage;
ilError error;
int plane, nPlanes;
unsigned long mustBeZero
)
{
-register ilImagePtr pImage;
+ilImagePtr pImage;
/* Validate given image of correct type; return false if not realized.
*/
is zero (0). Locks image to that strip height.
*/
IL_EXTERN ilBool _ilAllocStripOffsets (
- register ilImagePtr pImage,
+ ilImagePtr pImage,
long stripHeight
);
*/
IL_EXTERN ilError _ilValidateDesFormat (
ilBool allowPrivateTypes,
- register const ilImageDes *pDes,
- register const ilImageFormat *pFormat
+ const ilImageDes *pDes,
+ const ilImageFormat *pFormat
);
{
ilinvertPtr pPriv;
long srcnbytes, dstnbytes;
-register ilPtr psrcline, pdstline;
-register ilPtr psrc, pdst;
-register long nLines, nPixels;
+ilPtr psrcline, pdstline;
+ilPtr psrc, pdst;
+long nLines, nPixels;
*/
ILJPG_PUBLIC_EXTERN
iljpgError iljpgDecodeInit (
- register iljpgDataPtr pData,
+ iljpgDataPtr pData,
iljpgPtr *pPrivate /* RETURNED */
)
{
- register iljpgDecodePrivPtr pPriv;
- register iljpgCompPtr pComp;
+ iljpgDecodePrivPtr pPriv;
+ iljpgCompPtr pComp;
int comp;
iljpgCompDataPtr pCompData;
iljpgError error;
int outHuff[64];
iljpgByte outDCT[64];
int restartInterval;
- register iljpgCompPtr pComp;
+ iljpgCompPtr pComp;
int nBytesInit;
- register int nLines, dc;
- register iljpgPtr pDstLine;
+ int nLines, dc;
+ iljpgPtr pDstLine;
pPriv = (iljpgDecodePrivPtr)pPrivate;
}
/* Clip and output 8x8 block to position (bX, bY) */
- { register int nBytesM1;
- register iljpgPtr pSrc, pSrcLine, pDst;
+ { int nBytesM1;
+ iljpgPtr pSrc, pSrcLine, pDst;
if (nBytesInit > 8)
nBytesInit = 8;
iljpgDataPtr *ppData /* RETURNED */
)
{
- register iljpgDataPtr pData;
+ iljpgDataPtr pData;
iljpgBool firstMarker, SOSFound, SOF0Found;
iljpgError error;
int value, nFrameComps, length;
iljpgPtr *ppTable;
iljpgCompDataPtr pComp;
- register int i, index;
- register iljpgPtr pTable;
+ int i, index;
+ iljpgPtr pTable;
struct {
int id, horiFactor, vertFactor, QTableIndex;
} frameComp[ILJPG_MAX_COMPS], *pFrame;
float *s /* pointer to pointer to descaling matrix */
)
{
- register int i, j, prevValue, value, QIndex;
+ int i, j, prevValue, value, QIndex;
double a, c0, b[8], pi;
- register iljpgPtr qptr;
- register float *sptr;
+ iljpgPtr qptr;
+ float *sptr;
pi = 4.0 * atan(1.0);
c0 = 1.0 / (2.0 * 0.707106718);
)
{
iljpgDataPtr pData;
- register int i;
+ int i;
pData = pPriv->pData;
iljpgDecodePrivPtr pPriv
)
{
- register int i;
+ int i;
/* Free any "rev scale" tables that were allocated in iljpgDeDCTInit() */
for (i = 0; i < 4; i++) {
*/
ILJPG_PRIVATE_EXTERN
void _iljpgDeDCTFull (
- register int *pSrc,
+ int *pSrc,
long nBytesPerRow,
iljpgPtr ix, /* RETURNED */
- register float *pRevScale
+ float *pRevScale
)
{
- register int i;
- register int *zptr;
+ int i;
+ int *zptr;
float ox[64];
- register float in0, in1, in2, in3, in4, in5, in6, in7;
- register float tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
- register float tmp;
- register int clipValue;
- register iljpgPtr ixaddr;
- register float *oxaddr;
+ float in0, in1, in2, in3, in4, in5, in6, in7;
+ float tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+ float tmp;
+ int clipValue;
+ iljpgPtr ixaddr;
+ float *oxaddr;
/* Constants needed by the 16 point Winograd Fourier Transform for inv. DCT */
- register float b1 = 1.41421356;
- register float b2 = -2.61312587;
- register float b3 = 1.41421356;
- register float b4 = 1.08239220;
- register float b5 = 0.76536686;
+ float b1 = 1.41421356;
+ float b2 = -2.61312587;
+ float b3 = 1.41421356;
+ float b4 = 1.08239220;
+ float b5 = 0.76536686;
oxaddr = ox;
*/
ILJPG_PRIVATE_EXTERN
void _iljpgDeDCT4x4 (
- register int *pSrc,
+ int *pSrc,
long nBytesPerRow,
iljpgPtr ix, /* RETURNED */
- register float *pRevScale
+ float *pRevScale
)
{
- register int i;
- register int *zptr;
+ int i;
+ int *zptr;
float ox[64];
- register float in0, in2, in3, in4, in5, in7;
- register float tmp0, tmp1, tmp2, tmp5, tmp6, tmp7;
- register float tmp;
- register float *oxaddr;
- register int clipValue;
- register iljpgPtr ixaddr;
+ float in0, in2, in3, in4, in5, in7;
+ float tmp0, tmp1, tmp2, tmp5, tmp6, tmp7;
+ float tmp;
+ float *oxaddr;
+ int clipValue;
+ iljpgPtr ixaddr;
/* Constants needed by the 16 point Winograd Fourier Transform for inv. DCT */
- register float b1 = 1.41421356;
- register float b2 = -2.61312587;
- register float b3 = 1.41421356;
- register float b4 = 1.08239220;
- register float b5 = 0.76536686;
+ float b1 = 1.41421356;
+ float b2 = -2.61312587;
+ float b3 = 1.41421356;
+ float b4 = 1.08239220;
+ float b5 = 0.76536686;
#ifdef NOTDEF
orxptr = ox;
void _iljpgDeDCTDCOnly (
int *pSrc,
long nBytesPerRow,
- register iljpgPtr pDst, /* RETURNED */
+ iljpgPtr pDst, /* RETURNED */
float *pRevScale
)
{
- register int i, dc;
- register int j;
+ int i, dc;
+ int j;
j = *pSrc;
j = (j < -2047) ? -2047 : ((j > 2047) ? 2047 : j);
#define is_dc (!coeff_ct) /* First coefficient is DC */
int delta;
int len, zrun;
- register BITBUF bitbuf, ch, c;
- register int bitsleft;
+ BITBUF bitbuf, ch, c;
+ int bitsleft;
iljpgError error = 0; /* assume no error */
int index;
int is_fourx4 = 1, is_dconly = 0;
*/
ILJPG_PUBLIC
iljpgError iljpgEncodeInit (
- register iljpgDataPtr pData,
+ iljpgDataPtr pData,
iljpgPtr *pPrivate /* RETURNED */
)
{
- register iljpgEncodePrivPtr pPriv;
- register iljpgECompPtr pComp;
+ iljpgEncodePrivPtr pPriv;
+ iljpgECompPtr pComp;
iljpgCompDataPtr pCompData;
int comp;
iljpgError error;
- register unsigned int index, i;
+ unsigned int index, i;
/* Validate *pData: valid hori/vertFactor, tables present, etc. */
if (!_iljpgValidPars (pData))
iljpgPtr pPrivate
)
{
- register int i;
- register iljpgEncodePrivPtr pPriv;
+ int i;
+ iljpgEncodePrivPtr pPriv;
iljpgError error;
/* Free any scaled Q tables created by Init() */
{
iljpgEncodePrivPtr pPriv;
iljpgDataPtr pData;
- register iljpgECompPtr pComp;
+ iljpgECompPtr pComp;
iljpgPtr pPixels;
iljpgError error;
long nBytesPerRow, mcuMaxX, mcuMaxY, bX, bY;
clipped replicate pixel or above scan line out to 8x8.
*/
{ int nBytesInit;
- register int nLines, nBytesM1, *pDst, *pDstLine;
- register iljpgPtr pSrc, pSrcLine;
+ int nLines, nBytesM1, *pDst, *pDstLine;
+ iljpgPtr pSrc, pSrcLine;
nLines = pComp->height - bY;
if (nLines > 8)
ILJPG_ENCODE_STREAM stream
)
{
- register int i, nBytes;
+ int i, nBytes;
iljpgError error;
/* Huffman tables are: 16 bytes of # occurrences each # bits, followed by
iljpgJIFOffsetsPtr pOffsets
)
{
- register int index, i;
- register iljpgPtr pTable;
- register iljpgError error;
- register iljpgCompDataPtr pComp;
+ int index, i;
+ iljpgPtr pTable;
+ iljpgError error;
+ iljpgCompDataPtr pComp;
long startOffset;
# define PUT_BYTE(_byte) { \
float *pDst
)
{
- register int i, j, k, temp;
+ int i, j, k, temp;
double a, c0, b[8], pi;
- register float *sptr;
- register iljpgPtr qptr;
- register int *cptr;
+ float *sptr;
+ iljpgPtr qptr;
+ int *cptr;
pi = 4.0 * atan(1.0);
c0 = 1.0 / (2.0 * 0.707106718);
float *ox /* pointer to 8x8 output array containing DCT coefficients */
)
{
- register float in0, in1, in2, in3, in4, in5, in6, in7;
- register float tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
- register float tmp;
- register int *ixaddr;
- register float *oxaddr;
+ float in0, in1, in2, in3, in4, in5, in6, in7;
+ float tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+ float tmp;
+ int *ixaddr;
+ float *oxaddr;
int i;
int j;
/* constants needed by the 16 point Winograd Fourier Transform method */
- register float a1 = 0.707106718;
- register float a2 = -0.541196100;
- register float a3 = 0.707106718;
- register float a4 = 1.306562963;
- register float a5 = 0.382683432;
+ float a1 = 0.707106718;
+ float a2 = -0.541196100;
+ float a3 = 0.707106718;
+ float a4 = 1.306562963;
+ float a5 = 0.382683432;
#ifdef DEBUG
ixaddr = ix;
float *pScale
)
{
- register int i, value;
- register float *sptr;
- register int *ixptr;
- register float *oxptr;
- register int *zptr;
- register float fvalue;
+ int i, value;
+ float *sptr;
+ int *ixptr;
+ float *oxptr;
+ int *zptr;
+ float fvalue;
float ox[64]; /* DCT coefficient buffer */
*/
ILJPG_PRIVATE
iljpgError _iljpgBuildEnhuffTable (
- register iljpgPtr pTableIn,
+ iljpgPtr pTableIn,
iljpgEnhuffTablePtr *ppTableOut /* RETURNED */
)
{
- register iljpgEnhuffTablePtr pTable;
- register int i, j, nValues, value;
+ iljpgEnhuffTablePtr pTable;
+ int i, j, nValues, value;
int huffSize[257]; /* called "HUFFSIZE" in JPEG spec */
int huffCode[257]; /* called "HUFFCODE" in JPEG spec */
iljpgEncodePrivPtr pPriv
)
{
- register iljpgEnhuffPtr pHuffPriv;
- register iljpgDataPtr pData;
+ iljpgEnhuffPtr pHuffPriv;
+ iljpgDataPtr pData;
iljpgError error;
- register int i;
+ int i;
/* Allocate Huffman private area and point to it in encode private */
pData = pPriv->pData;
*/
static iljpgError _iljpgPackHuffman (
iljpgEnhuffPtr pHuffPriv,
- register int *pHuff,
- register int nHuff,
+ int *pHuff,
+ int nHuff,
ILJPG_ENCODE_STREAM stream
)
{
- register int size, value, huffBits, nHuffBits;
+ int size, value, huffBits, nHuffBits;
iljpgError error;
static int sizeMasks[9] = /* masks for lower "i" bits, indexed by i */
{0x0, 0x1, 0x3, 0x7, 0x0f, 0x1f, 0x3f, 0x7f, 0x0ff};
)
{
iljpgEnhuffPtr pHuffPriv;
- register iljpgEnhuffTablePtr pTable;
+ iljpgEnhuffTablePtr pTable;
int huff[4 * 64 + 10]; /* room for 64 * 2 pairs plus some slop */
- register int *pHuff;
- register int size, value, nACLeft, nZeros;
+ int *pHuff;
+ int size, value, nACLeft, nZeros;
# define ENHUFF(_value) { \
*pHuff++ = pTable->size[_value]; \
*pHuff++ = pTable->code[_value]; \
ILJPG_ENCODE_STREAM stream
)
{
- register iljpgEnhuffPtr pHuffPriv;
- register int nHuffBits, huffBits;
+ iljpgEnhuffPtr pHuffPriv;
+ int nHuffBits, huffBits;
iljpgError error;
/* If any bits left, flush them out. Pad with binary 1's, and
*/
ILJPG_PRIVATE_EXTERN
iljpgBool _iljpgValidPars (
- register iljpgDataPtr pData
+ iljpgDataPtr pData
);
#endif
*/
ILJPG_PRIVATE
iljpgBool _iljpgValidPars (
- register iljpgDataPtr pData
+ iljpgDataPtr pData
)
{
int comp;
iljpgCompDataPtr pCompData;
- register unsigned int index;
+ unsigned int index;
#define VALID_FACTOR(_f) ( ((_f) == 1) || ((_f) == 2) || ((_f) == 4) )
/* Validate *pData: valid hori/vertFactor, tables present, etc. */
ilMapPrivPtr pPriv;
long srcRowBytes, dstRowBytes, nRowsM1, nLinesM1;
ilPtr pSrcLine, pDstLine;
-register long rowCount;
-register ilPtr pSrc, pDst, pTranslate;
+long rowCount;
+ilPtr pSrc, pDst, pTranslate;
/* Get data from private, exit if no rows or lines to do.
*/
ilMapPrivPtr pPriv;
long srcRowBytes, dstRowBytes, nRowsM1, nLinesM1;
ilPtr pSrcLine, pDstLine;
-register long rowCount;
-register ilPtr pSrc, pDst, pTranslate;
+long rowCount;
+ilPtr pSrc, pDst, pTranslate;
/* Get data from private, exit if no rows or lines to do.
*/
ilClientImage mapImage
)
{
-register ilMapPrivPtr pPriv;
-register ilContext context;
+ilMapPrivPtr pPriv;
+ilContext context;
ilPipeInfo info;
ilImageDes des;
ilImageFormat format;
)
{
- register unsigned char *pdstline;
+ unsigned char *pdstline;
ilImagePlaneInfo *pplane;
============================================================================================================================= */
static ilError ilMirrorXBitonalExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
ilImagePlaneInfo *pplane;
-register int x, y, lastcount, srcnbytes, dstnbytes;
-register ilMirrorPrivptr pPriv;
+int x, y, lastcount, srcnbytes, dstnbytes;
+ilMirrorPrivptr pPriv;
============================================================================================================================= */
static ilError ilMirrorYBitonalExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *psrcbefore, *pdstline;
-register unsigned char srcbyte;
+unsigned char *psrc, *pdst, *psrcline, *psrcbefore, *pdstline;
+unsigned char srcbyte;
ilImagePlaneInfo *pplane;
-register int x, y, lastcount, loffset, roffset;
-register int srcnbytes, dstnbytes, widthbytes;
-register ilMirrorPrivptr pPriv;
+int x, y, lastcount, loffset, roffset;
+int srcnbytes, dstnbytes, widthbytes;
+ilMirrorPrivptr pPriv;
if (*pNLines <= 0) return IL_OK;
============================================================================================================================= */
static ilError ilMirrorX3ByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
ilImagePlaneInfo *pplane;
-register int x, y, lastcount;
-register ilMirrorPrivptr pPriv;
+int x, y, lastcount;
+ilMirrorPrivptr pPriv;
if (*pNLines <= 0) return IL_OK;
============================================================================================================================= */
static ilError ilMirrorY3ByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
ilImagePlaneInfo *pplane;
-register int x, y, xoffset, lastcount;
-register ilMirrorPrivptr pPriv;
+int x, y, xoffset, lastcount;
+ilMirrorPrivptr pPriv;
if (*pNLines <= 0) return IL_OK;
============================================================================================================================= */
static ilError ilMirrorXByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
ilImagePlaneInfo *pplane;
-register int x, y, lastcount;
-register ilMirrorPrivptr pPriv;
+int x, y, lastcount;
+ilMirrorPrivptr pPriv;
if (*pNLines <= 0) return IL_OK;
============================================================================================================================= */
static ilError ilMirrorYByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
ilImagePlaneInfo *pplane;
-register int x, y, lastcount;
-register ilMirrorPrivptr pPriv;
+int x, y, lastcount;
+ilMirrorPrivptr pPriv;
if (*pNLines <= 0) return IL_OK;
{
unsigned int state;
ilPipeInfo info;
-register ilMirrorPrivptr pPriv;
+ilMirrorPrivptr pPriv;
ilDstElementData dstdata;
ilImageDes imdes;
ilImageFormat imformat;
size_t sizeInBytes /* size of object to create */
)
{
-register ilContextPtr pContext;
-register ilObjectPtr pObject;
+ilContextPtr pContext;
+ilObjectPtr pObject;
/* Allocate object rec, return if failure.
*/
ilObject object
)
{
-register ilObjectPtr pObject;
+ilObjectPtr pObject;
/* Downcount refCount, exit if not zero - object is still attached to others.
Call object-specific destroy function, free client private if present,
ilContextPtr pContext
)
{
-register ilObjectPtr pObject, pNextObject, pObjectHead;
+ilObjectPtr pObject, pNextObject, pObjectHead;
/* Loop thru and destroy all objects until list points back to head (done).
*/
ilPaletteToRGBPrivPtr pPriv
)
{
-register int i;
-register unsigned long *pPacked, packed;
-register unsigned short *pRed, *pGreen, *pBlue, temp;
+int i;
+unsigned long *pPacked, packed;
+unsigned short *pRed, *pGreen, *pBlue, temp;
/* Pack the upper 8 bits of the rgb value, with blue in the high order bits. */
pPacked = pPriv->palette;
ilPaletteToRGBPrivPtr pPriv;
long srcRowBytes, dstRowBytes, nPixelsM1;
ilPtr pSrcLine, pDstLine;
-register ilPtr pSrc, pDst;
-register unsigned long rgb, *pPackedPalette;
-register long nLinesM1, nPixelsM1Temp;
+ilPtr pSrc, pDst;
+unsigned long rgb, *pPackedPalette;
+long nLinesM1, nPixelsM1Temp;
/* If firstStrip, init the packed palette in private */
pPriv = (ilPaletteToRGBPrivPtr)pData->pPrivate;
ilError (*Cleanup)();
ilError (*Destroy)();
ilError (*ExecuteThree)();
- ilError (*ExecuteFour)(register ilExecuteData *,
+ ilError (*ExecuteFour)(ilExecuteData *,
long,
long *,
float);
structures are not freed; just the pixels.
*/
static void ilFreeTempImageBuffers (
- register ilPipePtr pPipe
+ ilPipePtr pPipe
)
{
-register ilImagePtr pImage;
+ilImagePtr pImage;
pImage = (ilImagePtr)pPipe->imageHead.pNext;
while (pImage != (ilImagePtr)&pPipe->imageHead) {
height of the image is not set; the caller must do that.
*/
static ilImagePtr ilAllocTempImage (
- register ilPipePtr pPipe,
+ ilPipePtr pPipe,
ilPipeInfo *pInfo,
ilImageDes *pDes,
ilImageFormat *pFormat
)
{
-register ilImagePtr pImage;
+ilImagePtr pImage;
pImage = (ilImagePtr)IL_MALLOC (sizeof (ilImageRec));
if (!pImage)
The pipe state is set to IL_PIPE_COMPLETE.
*/
static ilError ilCleanupRunningPipe (
- register ilPipePtr pPipe,
+ ilPipePtr pPipe,
ilBool aborting
)
{
-register ilElementPtr pElement, pElementHead;
+ilElementPtr pElement, pElementHead;
ilError error, prevError;
/* Run thru the list of elements and call Cleanup function if non-null, then
ilPipe pipe
)
{
-register ilPipePtr pPipe;
-register ilElementPtr pElement, pNextElement, pElementHead;
-register ilImagePtr pImage, pNextImage;
+ilPipePtr pPipe;
+ilElementPtr pElement, pNextElement, pElementHead;
+ilImagePtr pImage, pNextImage;
int i;
ilError error;
unsigned long mustBeZero
)
{
-register ilPipePtr pPipe;
+ilPipePtr pPipe;
if (mustBeZero != 0) {
context->error = IL_ERROR_PAR_NOT_ZERO;
ilError error
)
{
-register ilPipePtr pPipe;
+ilPipePtr pPipe;
pPipe = (ilPipePtr)pipe;
ilEmptyPipe ((ilPipe)pPipe);
ilImageDes *pDes /* RETURNED */
)
{
-register ilPipePtr pPipe;
+ilPipePtr pPipe;
pPipe = (ilPipePtr)pipe;
if (pPipe->o.p.objectType != IL_PIPE) {
ilImageFormat *pFormat
)
{
-register ilPipePtr pPipe;
+ilPipePtr pPipe;
pPipe = (ilPipePtr)pipe;
if (pPipe->o.p.objectType != IL_PIPE) {
)
{
long bytesPerRow [IL_MAX_SAMPLES];
-register long stripHeight, nBytes;
+long stripHeight, nBytes;
int i;
/* Get the bytes/row, per plane. If pixel format, all bytes are in plane 0,
pipe height is changed (limits stripHeight to image height).
*/
static void ilChangeStripHeight (
- register ilPipePtr pPipe
+ ilPipePtr pPipe
)
{
-register long stripHeight;
+long stripHeight;
/* Limit stripHeight to pipe height. */
stripHeight = pPipe->image.info.stripHeight;
/* If uncompressed image, calc recommendedStripHeight else current stripHeight */
if (pPipe->image.des.compression == IL_UNCOMPRESSED) {
- register long i;
+ long i;
i = ilRecommendedStripHeight (&pPipe->image.des, &pPipe->image.format,
pPipe->image.info.width, pPipe->image.info.height);
pPipe->image.info.recommendedStripHeight = (i > stripHeight) ? stripHeight : i;
ilObject object
)
{
-register ilPipePtr pPipe;
+ilPipePtr pPipe;
pPipe = (ilPipePtr)pipe;
if (pPipe->nDestroyObjects >= IL_MAX_DESTROY_OBJECTS) {
*/
IL_PRIVATE ilBool _ilAddProducerImage (
ilPipe pipe,
- register ilImagePtr pImage,
+ ilImagePtr pImage,
unsigned int producerCode,
long height,
long stripHeight,
ilBool needProducerThrottle
)
{
-register ilPipePtr pPipe;
+ilPipePtr pPipe;
/* Copy image data into pipe info, point to given image as producer. */
pPipe = (ilPipePtr)pipe;
long nCompBytes
)
{
-register ilPipePtr pPipe;
-register ilImagePtr pImage;
+ilPipePtr pPipe;
+ilImagePtr pImage;
pPipe = (ilPipePtr)pipe;
if (pPipe->producerCode != IL_PIPE_FEED_IMAGE)
ilImageFormat *pFormat
)
{
-register ilPipePtr pPipe;
+ilPipePtr pPipe;
pPipe = (ilPipePtr)pipe;
if (pDes)
** parameter which is a floating pointing.
*/
ilError (*ExecuteThree)(),
- ilError (*ExecuteFour)(register ilExecuteData *,
+ ilError (*ExecuteFour)(ilExecuteData *,
long,
long *,
float),
unsigned long mustBeZero
)
{
-register ilPipePtr pPipe;
+ilPipePtr pPipe;
unsigned int newState; /* pipe state after this element added */
-register ilElementPtr pElement; /* ptr to new element to add to list */
+ilElementPtr pElement; /* ptr to new element to add to list */
ilElementPtr pPrevElement;
ilError error;
long stripHeight, srcBufferHeight;
ilPipe pipe
)
{
-register ilPipePtr pPipe;
+ilPipePtr pPipe;
pPipe = (ilPipePtr)pipe;
if (pPipe->o.p.objectType != IL_PIPE) {
float ratio
)
{
-register ilPipePtr pPipe;
-register ilElementPtr pElement, pExecHead, pElementHead;
+ilPipePtr pPipe;
+ilElementPtr pElement, pExecHead, pElementHead;
ilImagePtr pImage;
long nLines, initNLines;
ilError error;
*/
IL_EXTERN ilBool _ilAddProducerImage (
ilPipe pipe,
- register ilImagePtr pImage,
+ ilImagePtr pImage,
unsigned int producerCode,
long height,
long stripHeight,
** parameter which is a floating pointing.
*/
ilError (*ExecuteThree)(),
- ilError (*ExecuteFour)( register ilExecuteData *,
+ ilError (*ExecuteFour)( ilExecuteData *,
long,
long *,
float),
long *pNLines
)
{
-register ilReadXPrivPtr pPriv;
+ilReadXPrivPtr pPriv;
Drawable readDrawable;
ilBool lastStrip;
long nLines;
/* If a long/pixel image, must extract IL RGB bytes from X long/pixel image.
*/
if (pPriv->isLongImage) {
- register ilPtr pDst;
- register unsigned long temp, *pSrc;
- register long nLongsM1;
+ ilPtr pDst;
+ unsigned long temp, *pSrc;
+ long nLongsM1;
while (nLines-- > 0) {
pSrc = (unsigned long *)pSrcLine;
copy buffer, else one line at a time.
*/
if ((Ximage->depth == 1) && (Ximage->bitmap_bit_order == LSBFirst)) {
- register ilPtr pSrc, pDst;
- register long nBytesM1;
+ ilPtr pSrc, pDst;
+ long nBytesM1;
if (nBytesToCopy > 0)
while (nLines-- > 0) {
long *pNLines
)
{
-register ilReadXPrivPtr pPriv;
+ilReadXPrivPtr pPriv;
ilReadXPrivRec priv;
Drawable readDrawable;
ilBool lastStrip;
/* If a long/pixel image, must extract IL RGB bytes from X long/pixel image.
*/
if (pPriv->isLongImage) {
- register ilPtr pDst;
- register unsigned long temp, *pSrc;
- register long nLongsM1;
+ ilPtr pDst;
+ unsigned long temp, *pSrc;
+ long nLongsM1;
unsigned int X, Y;
XVisualInfo *pVisualInfo;
copy buffer, else one line at a time.
*/
if ((Ximage->depth == 1) && (Ximage->bitmap_bit_order == LSBFirst)) {
- register ilPtr pSrc, pDst;
- register long nBytesM1;
+ ilPtr pSrc, pDst;
+ long nBytesM1;
if (nBytesToCopy > 0)
while (nLines-- > 0) {
/* Execute() for ilReadImage() producer when the image is compressed.
*/
static ilError ilRCIExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
long dstLine, /* ignored */
long *pNLines /* ignored on input */
)
{
-register ilRCIPrivPtr pPriv;
-register ilImagePtr pImage;
+ilRCIPrivPtr pPriv;
+ilImagePtr pImage;
long offset;
pPriv = (ilRCIPrivPtr)pData->pPrivate;
ilObject image
)
{
-register ilImagePtr pImage;
-register ilRCIPrivPtr pPriv;
+ilImagePtr pImage;
+ilRCIPrivPtr pPriv;
/* Validate that pipe and image are such, have same context and pipe empty */
pImage = (ilImagePtr)image;
)
{
- register unsigned char *pdstline;
+ unsigned char *pdstline;
ilImagePlaneInfo *pplane;
int bitoff;
============================================================================================================================= */
static ilError ilRotate90BitonalExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned long *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnwords, dstnwords;
+unsigned long *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnwords, dstnwords;
ilImagePlaneInfo *pplane;
-register int x, y, xoffset, lastcount;
-register ilRotatePrivptr pPriv;
+int x, y, xoffset, lastcount;
+ilRotatePrivptr pPriv;
-register unsigned long srcMask;
-register unsigned long srcLong;
-register ilBool shortwidth;
+unsigned long srcMask;
+unsigned long srcLong;
+ilBool shortwidth;
if (*pNLines <= 0) return IL_OK;
============================================================================================================================= */
static ilError ilRotate180BitonalExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *psrcbefore, *pdstline;
-register unsigned char srcbyte;
+unsigned char *psrc, *pdst, *psrcline, *psrcbefore, *pdstline;
+unsigned char srcbyte;
ilImagePlaneInfo *pplane;
-register int x, y, lastcount, loffset, roffset;
-register int srcnbytes, dstnbytes, widthbytes;
-register ilRotatePrivptr pPriv;
+int x, y, lastcount, loffset, roffset;
+int srcnbytes, dstnbytes, widthbytes;
+ilRotatePrivptr pPriv;
if (*pNLines <= 0) return IL_OK;
============================================================================================================================= */
static ilError ilRotate270BitonalExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned long *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnwords, dstnwords;
+unsigned long *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnwords, dstnwords;
ilImagePlaneInfo *pplane;
-register int x, y, xoffset, lastcount;
-register ilRotatePrivptr pPriv;
+int x, y, xoffset, lastcount;
+ilRotatePrivptr pPriv;
-register unsigned long srcMask, dstMask;
-register unsigned long srcLong, dstLong;
-register ilBool shortwidth;
+unsigned long srcMask, dstMask;
+unsigned long srcLong, dstLong;
+ilBool shortwidth;
============================================================================================================================= */
static ilError ilRotate903ByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
ilImagePlaneInfo *pplane;
-register int x, y, xoffset, lastcount;
-register ilRotatePrivptr pPriv;
+int x, y, xoffset, lastcount;
+ilRotatePrivptr pPriv;
if (*pNLines <= 0) return IL_OK;
============================================================================================================================= */
static ilError ilRotate1803ByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
ilImagePlaneInfo *pplane;
-register int x, y, xoffset, lastcount;
-register ilRotatePrivptr pPriv;
+int x, y, xoffset, lastcount;
+ilRotatePrivptr pPriv;
if (*pNLines <= 0) return IL_OK;
============================================================================================================================= */
static ilError ilRotate2703ByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
ilImagePlaneInfo *pplane;
-register int x, y, lastcount, xoffset;
-register ilRotatePrivptr pPriv;
+int x, y, lastcount, xoffset;
+ilRotatePrivptr pPriv;
if (*pNLines <= 0) return IL_OK;
============================================================================================================================= */
static ilError ilRotate90ByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
ilImagePlaneInfo *pplane;
-register int x, y, xoffset, lastcount;
+int x, y, xoffset, lastcount;
unsigned int dstrowpixels;
-register ilRotatePrivptr pPriv;
+ilRotatePrivptr pPriv;
if (*pNLines <= 0) return IL_OK;
============================================================================================================================= */
static ilError ilRotate180ByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
ilImagePlaneInfo *pplane;
-register int x, y, lastcount;
-register ilRotatePrivptr pPriv;
+int x, y, lastcount;
+ilRotatePrivptr pPriv;
if (*pNLines <= 0) return IL_OK;
============================================================================================================================= */
static ilError ilRotate270ByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrc, *pdst, *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
+unsigned char *psrc, *pdst, *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
ilImagePlaneInfo *pplane;
-register int x, y, lastcount, xoffset;
-register ilRotatePrivptr pPriv;
+int x, y, lastcount, xoffset;
+ilRotatePrivptr pPriv;
if (*pNLines <= 0) return IL_OK;
{
unsigned int state;
ilPipeInfo info;
-register ilRotatePrivptr pPriv;
+ilRotatePrivptr pPriv;
ilDstElementData dstdata;
ilImageDes imdes;
ilImageFormat imformat;
error on last one.
*/
static ilError ilProducerThrottleExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
long dstLine, /* ignored */
long *pNLines /* ignored on input */
)
{
-register ilThrottlePrivPtr pPriv;
+ilThrottlePrivPtr pPriv;
/* Set the next elements srcLine to our current line. Bump srcLine by
stripHeight (# lines just "written"), but if that is to/past end of image,
pData->srcLine must be startLine, as passed to ilFeedPipe()
*/
static ilError ilFeedProducerThrottleExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
long dstLine, /* ignored */
long *pNLines
)
{
-register ilThrottlePrivPtr pPriv;
+ilThrottlePrivPtr pPriv;
long nLines;
/* Point next element to the feed data, set into pData by ilExecutePipe():
/* Execute() for when not the producer, but constant strips are not required.
*/
static ilError ilNonConstantThrottleExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
long dstLine, /* ignored */
long *pNLines
)
{
-register ilThrottlePrivPtr pPriv;
+ilThrottlePrivPtr pPriv;
/* Not from a producer, but !constantStrip; easy: caller just wants strips
/* Execute() for when not a producer and constant strips are required.
*/
static ilError ilConstantThrottleExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
long dstLine, /* ignored */
long *pNLines
)
{
-register ilThrottlePrivPtr pPriv;
+ilThrottlePrivPtr pPriv;
long nLines, nLinesToWrite;
-register ilError returnCode;
+ilError returnCode;
pPriv = (ilThrottlePrivPtr)pData->pPrivate;
if (pPriv->beingRecalled)
Handles uncompressed images only; compressed images handled separately.
*/
static ilError ilCopyImageExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
long dstLine,
long *pNLines
)
long nLines, nBytes, srcStart, dstStart;
int nPlanes;
ilPtr pSrcLine, pDstLine;
-register long lineCount;
+long lineCount;
/* Point to src/dst image and first plane of each */
pSrcImage = pData->pSrcImage;
} ilScalePriv, *ilScalePrivptr;
#ifdef LSB_BIT_ORDER
-extern void flip_bits(register ilPtr start, register unsigned n);
+extern void flip_bits(ilPtr start, unsigned n);
#else
# define flip_bits(start,n) /*EMPTY*/
#endif
============================================================================================================================= */
static void ilswbitdown(
- register CARD32 *psrcline,
- register CARD32 *pdstline,
+ CARD32 *psrcline,
+ CARD32 *pdstline,
unsigned long srcwidth,
unsigned long dstwidth
)
{
-register int acc, nbits;
-register CARD32 srcMask;
-register CARD32 srcLong;
+int acc, nbits;
+CARD32 srcMask;
+CARD32 srcLong;
CARD32 dstLong;
ilBool copy;
ilBool Lastbit;
============================================================================================================================= */
static void ilswbitup(
- register CARD32 *psrcline,
- register CARD32 *pdstline,
+ CARD32 *psrcline,
+ CARD32 *pdstline,
unsigned long srcwidth,
unsigned long dstwidth
)
{
-register int acc, nbits;
-register CARD32 srcMask;
-register CARD32 srcLong;
+int acc, nbits;
+CARD32 srcMask;
+CARD32 srcLong;
CARD32 dstLong;
ilBool Lastbit;
============================================================================================================================= */
static void ilsw3bytedown(
- register unsigned char *psrcline,
- register unsigned char *pdstline,
+ unsigned char *psrcline,
+ unsigned char *pdstline,
unsigned long srcwidth,
unsigned long dstwidth
)
{
-register int acc, n3bytes;
+int acc, n3bytes;
ilBool copy;
============================================================================================================================= */
static void ilsw3byteup(
- register unsigned char *psrcline,
- register unsigned char *pdstline,
+ unsigned char *psrcline,
+ unsigned char *pdstline,
unsigned long srcwidth,
unsigned long dstwidth
)
{
-register int acc, n3bytes;
+int acc, n3bytes;
acc = dstwidth - srcwidth;
n3bytes = srcwidth;
============================================================================================================================= */
static void ilswbytedown(
- register unsigned char *psrcline,
- register unsigned char *pdstline,
+ unsigned char *psrcline,
+ unsigned char *pdstline,
unsigned long srcwidth,
unsigned long dstwidth
)
{
-register int acc, nbytes;
+int acc, nbytes;
ilBool copy;
============================================================================================================================= */
static void ilswbyteup(
- register unsigned char *psrcline,
- register unsigned char *pdstline,
+ unsigned char *psrcline,
+ unsigned char *pdstline,
unsigned long srcwidth,
unsigned long dstwidth
)
{
-register int acc, nbytes;
+int acc, nbytes;
acc = dstwidth - srcwidth;
nbytes = srcwidth;
to scale the width.
============================================================================================================================= */
static ilError ilScaleBitonalExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register CARD32 *psrcline, *pdstline;
-register unsigned long srcnwords, dstnwords;
-register long nlines;
-register unsigned long srcwidth, dstwidth;
+CARD32 *psrcline, *pdstline;
+unsigned long srcnwords, dstnwords;
+long nlines;
+unsigned long srcwidth, dstwidth;
ilImagePlaneInfo *pplane;
-register unsigned long local_noDstLine;
-register ilScalePrivptr pPriv;
+unsigned long local_noDstLine;
+ilScalePrivptr pPriv;
to scale the width.
============================================================================================================================= */
static ilError ilScale3ByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
-register long nlines;
-register unsigned long srcwidth, dstwidth;
+unsigned char *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
+long nlines;
+unsigned long srcwidth, dstwidth;
ilImagePlaneInfo *pplane;
-register unsigned long local_noDstLine;
-register ilScalePrivptr pPriv;
+unsigned long local_noDstLine;
+ilScalePrivptr pPriv;
to scale the width.
============================================================================================================================= */
static ilError ilScaleByteExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
unsigned long dstLine,
unsigned long *pNLines
)
{
-register unsigned char *psrcline, *pdstline;
-register unsigned long srcnbytes, dstnbytes;
-register long nlines;
-register unsigned long srcwidth, dstwidth;
+unsigned char *psrcline, *pdstline;
+unsigned long srcnbytes, dstnbytes;
+long nlines;
+unsigned long srcwidth, dstwidth;
ilImagePlaneInfo *pplane;
-register unsigned long local_noDstLine;
-register ilScalePrivptr pPriv;
+unsigned long local_noDstLine;
+ilScalePrivptr pPriv;
{
unsigned int state;
ilPipeInfo info;
-register ilScalePrivptr pPriv;
+ilScalePrivptr pPriv;
ilDstElementData dstdata;
ilImageDes imdes;
ilImageFormat imformat;
long *pNLines
)
{
-register ilScaleSamplePtr pPriv;
-register ilPtr pSrc, pDst, pSrcTemp;
-register long pixel, i, j, right;
-register unsigned long *pCornerTable, *pTopBelowTable;
-register long colAcc, dstWidth;
+ilScaleSamplePtr pPriv;
+ilPtr pSrc, pDst, pSrcTemp;
+long pixel, i, j, right;
+unsigned long *pCornerTable, *pTopBelowTable;
+long colAcc, dstWidth;
long nDstPixels, widthDiff;
ilPtr psrcline, pdstline, pSrcEnd;
long srcnbytes, dstnbytes;
long *pNLines
)
{
-register ilScaleSamplePtr pPriv;
-register ilPtr pSrc, pDst, pSrcTemp;
-register long pixel, i, j, right;
-register unsigned long *pCornerTable, *pTopBelowTable;
-register long colAcc, dstWidth;
+ilScaleSamplePtr pPriv;
+ilPtr pSrc, pDst, pSrcTemp;
+long pixel, i, j, right;
+unsigned long *pCornerTable, *pTopBelowTable;
+long colAcc, dstWidth;
long nDstPixels, widthDiff;
ilPtr psrcline, pdstline, pSrcEnd;
long srcnbytes, dstnbytes;
)
{
-register ilScaleSamplePtr pPriv;
+ilScaleSamplePtr pPriv;
ilDstElementData dstdata;
ilBool constantStrip
)
{
-register ilImagePtr pImage;
+ilImagePtr pImage;
/* Validate that pipe and image are such, and that they have the same context. */
pImage = (ilImagePtr)image;
ilImageInfo *pDstImage
)
{
-register int plane;
+int plane;
ilImageInfo *pFeedInfo;
pFeedInfo = pPriv->pFeedInfo;
Feed the pipe bits entering this filter down the offshoot pipe.
*/
static ilError ilTapExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
long dstLine,
long *pNLines
)
{
-register ilTapPrivPtr pPriv;
-register int plane;
+ilTapPrivPtr pPriv;
+int plane;
ilImageInfo *pFeedInfo, *pSrcImage;
long start, nCompBytes;
/* Public function: see spec.
*/
ilPipe ilTapPipe (
- register ilPipe pipe,
+ ilPipe pipe,
unsigned long mustBeZero,
void *mustBeNull
)
ilImageInfo imageInfo, *pFeedInfo;
ilSrcElementData srcData;
ilError error;
-register ilTapPrivPtr pPriv;
+ilTapPrivPtr pPriv;
context = pipe->context;
feedImage = (ilClientImage)NULL;
ilFilePtr pFile
)
{
-register ilFileImagePtr pFileImage, pAltFileImage, pFileImageTemp;
+ilFileImagePtr pFileImage, pAltFileImage, pFileImageTemp;
/* Run thru the list of file images; for each: if a mask image destroy it
(only one); if child images, destroy them - they are linked by pChild.
ilFilePtr pFile;
ilFileTag *pTag, **ppTag;
int tagNumber, nFileTags, nItems, nTags, tagType, i;
-register ilBool bigEndian;
+ilBool bigEndian;
pFileImage = (ilFileImagePtr)fileImage;
if (mustBeZero != 0) {
*/
static void ilAddImageToList (
ilFilePtr pFile,
- register ilFileImagePtr pFileImage,
+ ilFileImagePtr pFileImage,
ilFileImagePtr pPrevFileImage
)
{
static ilError ilReadTagsAndAddImageToList (
ilFilePtr pFile,
ilFileImagePtr *ppPrevFileImage,
- register ilFileImagePtr pFileImage
+ ilFileImagePtr pFileImage
)
{
/* Indexes into "tagNumbers" below. NOTE: order is important, as tags are checked
ilBool present;
ilError error;
ilPtr pTagAlloc;
-register unsigned long value;
+unsigned long value;
int i, tagIndex, nBits, resolutionUnit, fillOrder;
unsigned long group3CompData;
unsigned long group4CompData;
-register ilFileTag *pTag;
+ilFileTag *pTag;
ilYCbCrInfo *pYCbCr; /* null if not YCbCr ; else -> des...YCbCr */
/* Init/zero des and format in *pFileImage.
}
else {
/* compatibility problem with long or unsigned long data fields */
- register INT32 *pLong = (INT32 *)pTag->pItems;
+ INT32 *pLong = (INT32 *)pTag->pItems;
double num, denom;
if ((pTag->nItems != 3) || (pTag->type != IL_TAG_RATIONAL))
AIL_FATAL_ERROR (IL_ERROR_FILE_MALFORMED_TAG);
*/
case REFERENCE_BLACK_WHITE:
if (pYCbCr) {
- register ilYCbCrSampleInfo *pSample = pYCbCr->sample;
+ ilYCbCrSampleInfo *pSample = pYCbCr->sample;
int i;
if (!present) {
pSample->refBlack = 0; pSample->refWhite = 255; pSample++;
}
else {
/* compatibility problem with long and unsigned long data fields */
- register INT32 *pLong = (INT32 *)pTag->pItems;
+ INT32 *pLong = (INT32 *)pTag->pItems;
if (pTag->nItems != 6)
AIL_FATAL_ERROR (IL_ERROR_FILE_MALFORMED_TAG);
if (pTag->type == IL_TAG_LONG) { /* old type */
if (present) {
if (value & IL_TAG_P0_FLAG_DITHER_LEVELS) {
if (pFileImage->p.des.type == IL_PALETTE) {
- register short *pLevel = ((short *)pTag->pItems + 1);
+ short *pLevel = ((short *)pTag->pItems + 1);
if ((pTag->nItems < 4) || (pTag->type != IL_TAG_SHORT))
AIL_FATAL_ERROR (IL_ERROR_FILE_MALFORMED_TAG);
pFileImage->p.des.flags |= IL_DITHERED_PALETTE;
/* If mask image: must be bitonal or discard it. */
if (imageType == maskImage) {
- register ilFileImagePtr pPrevFileImage = *ppPrevFileImage;
+ ilFileImagePtr pPrevFileImage = *ppPrevFileImage;
if (!pPrevFileImage /* no image before it */
|| pPrevFileImage->p.pMask /* already has mask */
|| (pFileImage->p.des.nSamplesPerPixel != 1)
ilFileOffset IFDOffset;
ilFileImagePtr pFileImage, pPrevFileImage;
ilTIFFHeader header;
-register ilFilePtr pFile;
-register ilBool bigEndian;
+ilFilePtr pFile;
+ilBool bigEndian;
/* Check if image list already built - if so, return ptr to it.
*/
*/
/* compatibility problem with long and unsigned long data fields */
#define IL_FLIP_LONG(_bigEndian, _4b, _long) { \
- register CARD32 _l; \
+ CARD32 _l; \
if (_bigEndian) { \
_l = *((ilPtr)(_4b)+0); _l <<= 8; \
_l |= *((ilPtr)(_4b)+1); _l <<= 8; \
/* Same for a short.
*/
#define IL_FLIP_SHORT(_bigEndian, _2b, _short) {\
- register unsigned short _s; \
+ unsigned short _s; \
if (_bigEndian) { \
_s = *((ilPtr)(_2b)+0); _s <<= 8; \
_s |= *((ilPtr)(_2b)+1); \
long *pQOffsets, /* array of nComps file offsets to tables */
long *pDCOffsets,
long *pACOffsets,
- register ilJPEGData *pCompData /* ptr to structure to fill in */
+ ilJPEGData *pCompData /* ptr to structure to fill in */
)
{
- register int i, c, nBytes;
- register ilJPEGSampleData *pSample;
- register ilPtr pTable;
+ int i, c, nBytes;
+ ilJPEGSampleData *pSample;
+ ilPtr pTable;
ilByte buffer[16]; /* buffer for DC/AC table prefix (# codes) */
/* Use sample/component index as table index; load tables based on sample */
ilImageInfo *pDstImage
)
{
-register ilReadFilePrivPtr pPriv = (ilReadFilePrivPtr)pPrivate;
+ilReadFilePrivPtr pPriv = (ilReadFilePrivPtr)pPrivate;
ilFileImagePtr pFileImage;
ilError error;
-register ilFileTag *pTag;
+ilFileTag *pTag;
/* Data for tags to read: "numbers" is the array of tag ids, "nTags" in length.
"?Index" vars are indices into "numbers" and returned data "tags".
Copy TIFF palette (size = 2 ** nBits) to pPriv->pPalette (size = 3 * 256).
*/
if (pPriv->pPalette) {
- register unsigned short *pPalette, *pFilePalette;
- register int nPaletteEntries, i;
+ unsigned short *pPalette, *pFilePalette;
+ int nPaletteEntries, i;
pTag = tags [colorMapIndex];
if (!pTag)
long *pNLines
)
{
-register ilReadFilePrivPtr pPriv;
+ilReadFilePrivPtr pPriv;
unsigned long nBytes, offset;
ilPtr pDst;
ilImagePlaneInfo *pDstImagePlane;
)
{
ilDstElementData dstData;
-register ilFileImagePtr pFileImage;
-register ilReadFilePrivPtr pPriv;
+ilFileImagePtr pFileImage;
+ilReadFilePrivPtr pPriv;
unsigned short *pPalette;
ilPtr pCompData;
/* Init() function for ilWriteFileImage().
*/
static ilError ilWriteFileInit (
- register ilWriteFilePrivPtr pPriv,
+ ilWriteFilePrivPtr pPriv,
ilImageInfo *pSrcImage,
ilImageInfo *pDstImage
)
/* Cleanup() function for ilWriteFileImage().
*/
static ilError ilWriteFileCleanup (
- register ilWriteFilePrivPtr pPriv,
+ ilWriteFilePrivPtr pPriv,
ilBool aborting
)
{
-register ilFilePtr pFile;
+ilFilePtr pFile;
ilFileOffset position;
ilByte fourBytes[4], nextBytes[4];
ilPtr pBytes, pTag;
-register CARD32 *pTagOffsets, l;
+CARD32 *pTagOffsets, l;
int i;
/* If aborting pipe, just exit. The net effect is that if
into the tag memory buffer, so it will be written out by ilWriteFileCleanup().
*/
static void ilCopyPalette (
- register ilWriteFilePrivPtr pPriv,
- register unsigned short *pSrcPalette
+ ilWriteFilePrivPtr pPriv,
+ unsigned short *pSrcPalette
)
{
-register unsigned short *pDstPalette;
-register ilPtr pBytes;
+unsigned short *pDstPalette;
+ilPtr pBytes;
/* Since using IL_WRITE_FLIP_SHORT, palEntry should be unsigned short */
-register unsigned short palEntry;
+unsigned short palEntry;
unsigned long greenOffset, blueOffset;
int i;
long *pNLines
)
{
-register ilWriteFilePrivPtr pPriv;
+ilWriteFilePrivPtr pPriv;
ilFilePtr pFile;
unsigned long nBytes, rowBytes;
ilPtr pBytes;
and write a JIF header into the TIFF file.
*/
static ilError ilWriteJIFData (
- register ilWriteFilePrivPtr pPriv,
+ ilWriteFilePrivPtr pPriv,
ilFilePtr pFile,
ilImageInfo *pImage
)
ilJPEGData *pCompData;
ilError error;
long mcuWidth, mcuHeight;
- register ilPtr pBytes;
+ ilPtr pBytes;
/* Init streamRec so output is written into malloc'd memory, and encode
long *pNLines
)
{
- register ilWriteFilePrivPtr pPriv;
+ ilWriteFilePrivPtr pPriv;
ilFilePtr pFile;
ilError error;
long position, nBytes, i, j;
- register ilPtr pBytes;
+ ilPtr pBytes;
ilByte marker[2];
/* The overall approach is to write a JIF image into the file plus strips.
ilTagInfoPtr pInfo) /* returned tag info */
{
ilFileTag **ppTagsInit, **ppLastTag;
-register ilFileTag **ppTag, **ppTagTemp, *pTag;
+ilFileTag **ppTag, **ppTagTemp, *pTag;
ilPtr pTagData, pFileTags;
long tagArraySize, tagDataSize, l;
CARD32 *pTagOffsets, *pLong;
int nTags, i;
unsigned short tagType, *pShort;
-register int tagNumber;
+int tagNumber;
/* Allocate and null an array of ptrs to tags, size = # user + std tags, + 1
so that there is at least one guaranteed null tag ptr, for "end of array".
unsigned int compression,
ilPtr pCompData,
long *pStripHeight,
- register ilPipeInfo *pInfo,
- register ilImageDes *pDes,
- register ilImageFormat *pFormat
+ ilPipeInfo *pInfo,
+ ilImageDes *pDes,
+ ilImageFormat *pFormat
)
{
#define IL_WRITE_TIFF_STRIP_SIZE (16 * 1024) /* write 16KB strips as default */
-register long stripHeight;
+long stripHeight;
long i, nLevels;
ilBool mustConvert;
unsigned long g3Flags, g4Flags;
long nStripsPerImage;
ilFileTag tags [MAX_WRITE_TAGS];
-register ilFileTag *pTag;
+ilFileTag *pTag;
int nTags, i;
ilTagInfoRec tagInfo;
ilFilePtr pFile;
/* TIFF only allows subsampling as follows: Y = 1, Cr/Cb = 1,2,4 but
Cr and CB equal to each other; vert <= horiz.
*/
- { register ilYCbCrSampleInfo *pSample = des.typeInfo.YCbCr.sample;
+ { ilYCbCrSampleInfo *pSample = des.typeInfo.YCbCr.sample;
if ((pSample[0].subsampleHoriz != 1)
|| (pSample[0].subsampleVert != 1)
void *pOptionData /* not used */
)
{
- register int i;
+ int i;
/* Init tables, index by R/G/B, which effectively multiply each component
(0..255) by the NTSC conversion formula: 0.30 * R + 0.587 * G + 0.114 * B,
long *pNLines
)
{
-register ilRGBToGrayRecPtr pPriv;
+ilRGBToGrayRecPtr pPriv;
long srcnbytes, dstnbytes;
-register ilPtr psrcline, pdstline;
-register ilPtr psrc, pdst;
-register long nLines, nPixels;
-register INT32 i;
+ilPtr psrcline, pdstline;
+ilPtr psrc, pdst;
+long nLines, nPixels;
+INT32 i;
)
{
ilRGBToGrayRecPtr pPriv;
-register long nLinesM1, nPixelsM1;
+long nLinesM1, nPixelsM1;
long srcRowBytes, dstRowBytes, nPixelsM1Init;
ilPtr pSrcLine, pDstLine;
-register ilPtr pSrc, pDst;
-register ilByte byte;
+ilPtr pSrc, pDst;
+ilByte byte;
pPriv = (ilRGBToGrayRecPtr)pData->pPrivate;
nPixelsM1Init = pPriv->nPixels - 1;
long nSrcBytes,
long srcRowBytes,
ilPtr pSrcLine,
- register long dstRowBytes,
+ long dstRowBytes,
ilPtr pDstLine
)
{
-register int temp0, temp1, delta;
-register unsigned long aLong;
+int temp0, temp1, delta;
+unsigned long aLong;
long nSrcBytesM1, dstOffset;
-register ilPtr pSrc, pSrcBelow, pDst;
-register int left, leftBelow, right, rightBelow;
+ilPtr pSrc, pSrcBelow, pDst;
+int left, leftBelow, right, rightBelow;
#define FUPINTER(_start, _delta, _temp, _result) { \
_result = (_start) << 8; \
int sample, subsampleShift;
ilPtr pSrcLine, pDstLine;
long width, nLines, nSrcLines, nSrcBytes, srcRowBytes, nSrcBytesM2;
-register long dstRowBytes;
-register ilPtr pSrc, pSrcBelow, pDst;
-register int left, leftBelow, right, rightBelow;
+long dstRowBytes;
+ilPtr pSrc, pSrcBelow, pDst;
+int left, leftBelow, right, rightBelow;
/* Get width and height of _upsampled_ image; exit if zero. */
pPriv = (ilUpFastPrivPtr)pData->pPrivate;
int scaleFactor
)
{
- register ilUpFastPrivPtr pUpPriv;
+ ilUpFastPrivPtr pUpPriv;
ilUpFastPrivRec upPriv;
int i, j;
ilYCbCrSampleInfo *pSample;
)
{
long nMidPixels, nEndPixels;
-register long nPixelsM1;
-register ilPtr pSrc, pDst;
-register ilByte pixel, prevPixel;
+long nPixelsM1;
+ilPtr pSrc, pDst;
+ilByte pixel, prevPixel;
if (nLines <= 0)
return;
3 (prevPixel) | (12+3)/4=3 (15+3)/4=4 (18+3)/4=5 6 (src pixel) |
*/
case 2: {
- register int delta, temp;
+ int delta, temp;
nMidPixels = (width >> 2) - 1;
nEndPixels = width - (nMidPixels << 2) - 1;
unsigned int shift, /* 0 = no upsample; 1 = * 2 (doubling); 2 = * 4 */
long width, /* width of _whole_ (un-upsampled) image */
long nLines, /* # of dst lines (after upsampling) */
- register long rowBytes, /* bytes / row in src/dst image */
+ long rowBytes, /* bytes / row in src/dst image */
ilPtr pLine /* ptr to first line of src/dst image */
)
{
long nPixelsM1Init;
-register long nPixelsM1;
+long nPixelsM1;
/* Return if no pixels or lines to do. */
if (nLines <= 0)
and third lines, filling in the second with the average of the two.
*/
case 1: {
- register ilPtr pDst, pSrc1, pSrc2;
+ ilPtr pDst, pSrc1, pSrc2;
nLines--; /* don't count first line already in buffer */
while (nLines >= 2) { /* two src lines, line between to interpolate */
0 and 4, interpolating 1..3 - see horizontal upsampling.
*/
case 2: {
- register ilPtr pSrc, pDst;
- register int pixel, delta;
+ ilPtr pSrc, pDst;
+ int pixel, delta;
long rowBytesTimes4 = rowBytes << 2;
nLines--; /* don't count first line already in buffer */
long *pNLines /* ignored on input */
)
{
-register ilUpsamplePrivPtr pPriv;
+ilUpsamplePrivPtr pPriv;
ilImagePlaneInfo *pSrcPlane, *pDstPlane;
int nSamples;
ilPtr pSrcLine, pDstLine;
ilBool upSample
)
{
- register ilUpsamplePrivPtr pUpPriv;
+ ilUpsamplePrivPtr pUpPriv;
ilImageDes pipeDes;
ilUpsampleShiftRec *pShift;
ilYCbCrSampleInfo *pSample;
int sample;
ilDstElementData dstData;
ilSrcElementData srcData;
- register long i, j;
+ long i, j;
/* Only 8 bit planar YCbCr can currently be upsampled; if not that and upsampling
needed, error; if no upsampling (only convert to gray) convert to planar.
IL JPG package format.
*/
IL_PRIVATE void _ilJPEGDataIn (
- register const ilImageDes *pDes,
+ const ilImageDes *pDes,
long width,
long height,
- register iljpgDataPtr pDst
+ iljpgDataPtr pDst
)
{
int maxSubsample;
NOTE: currently only YCbCr data in IL is subsampled!
*/
if (pDes->type == IL_YCBCR) {
- register const ilYCbCrSampleInfo *pSample = pDes->typeInfo.YCbCr.sample;
+ const ilYCbCrSampleInfo *pSample = pDes->typeInfo.YCbCr.sample;
maxSubsample = pSample[0].subsampleHoriz;
if (pSample[1].subsampleHoriz > maxSubsample)
Note: the restartInterval is also copied.
*/
IL_PRIVATE void _ilJPEGTablesIn (
- register ilJPEGData *pSrc,
- register iljpgDataPtr pDst
+ ilJPEGData *pSrc,
+ iljpgDataPtr pDst
)
{
/* Free the tables in the given IL JPEG data block, which is not freed.
*/
IL_PRIVATE void _ilJPEGFreeTables (
- register ilJPEGData *pData
+ ilJPEGData *pData
)
{
- register int i;
+ int i;
for (i = 0; i < 4; i++) {
if (pData->QTables[i]) {
to it or null if malloc failed.
*/
static ilPtr _ilJPEGCopyHuffmanTable (
- register ilPtr pSrc
+ ilPtr pSrc
)
{
- register int i, nBytes;
- register ilPtr pDst;
+ int i, nBytes;
+ ilPtr pDst;
/* Huffman tables are: 16 bytes of # occurrences each # bits, followed by
bytes for each of those # occurrences. Size of table = 16 + sum(0..15).
If an error, free all malloc'd tables in dest, null them and return false.
*/
IL_PRIVATE ilBool _ilJPEGCopyData (
- register ilJPEGData *pSrc,
- register ilJPEGData *pDst
+ ilJPEGData *pSrc,
+ ilJPEGData *pDst
)
{
- register int i;
+ int i;
/* Zero table ptrs in *pDst in case of error; copy index info */
bzero ((char *)pDst, sizeof (ilJPEGData));
to be written. Zero (0) is returned if success else an error code.
*/
IL_PRIVATE iljpgError _ilReallocJPEGEncode (
- register ilJPEGEncodeStreamPtr pStream,
+ ilJPEGEncodeStreamPtr pStream,
long nBytes
)
{
- register long offset;
+ long offset;
/* Allocate space so exactly "nBytes" more bytes will fit in output buffer.
There are "offset" bytes in the buffer now so allocate offset + nBytes.
ilBool aborting
)
{
-register ilImagePlaneInfo *pImagePlane;
-register ilImagePtr pImage;
+ilImagePlaneInfo *pImagePlane;
+ilImagePtr pImage;
ilError error;
pImage = pPriv->pImage;
/* Execute() function for ilWriteImage(), writing compressed images.
*/
static ilError ilWriteCompressedExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
long dstLine,
long *pNLines
)
{
-register ilImagePrivPtr pPriv;
-register ilImagePtr pImage;
+ilImagePrivPtr pPriv;
+ilImagePtr pImage;
pPriv = (ilImagePrivPtr)pData->pPrivate;
pImage = pPriv->pImage;
ilObject image
)
{
-register ilImagePtr pImage;
+ilImagePtr pImage;
ilPipeInfo info;
ilImageDes des;
ilImageFormat format;
ilBool mustConvert;
-register ilImagePrivPtr pPriv;
+ilImagePrivPtr pPriv;
ilSrcElementData srcData;
long stripHeight;
ilPtr pCompData;
/* Execute() for WriteImage(): merely bumps srcLine by # lines written.
*/
static ilError ilWriteImageExecute (
- register ilExecuteData *pData,
+ ilExecuteData *pData,
long dstLine,
long *pNLines
)
ilObject image
)
{
-register ilImagePtr pImage;
-register ilImagePrivPtr pPriv;
-register ilContext context;
+ilImagePtr pImage;
+ilImagePrivPtr pPriv;
+ilContext context;
ilPipeInfo info;
ilSrcElementData srcData;
int red, int green, int blue));
FUNC(xpmFreeRgbNames, void, (xpmRgbName * rgbn, int rgbn_max));
-FUNC(xpm_xynormalizeimagebits, int, (register unsigned char *bp,
- register XImage * img));
-FUNC(xpm_znormalizeimagebits, int, (register unsigned char *bp,
- register XImage * img));
+FUNC(xpm_xynormalizeimagebits, int, (unsigned char *bp,
+ XImage * img));
+FUNC(xpm_znormalizeimagebits, int, (unsigned char *bp,
+ XImage * img));
*/
/*
* Macros
long *pNLines /* ignored on input */
)
{
-register ilSubsamplePrivPtr pPriv;
+ilSubsamplePrivPtr pPriv;
ilImagePlaneInfo *pSrcPlane, *pDstPlane;
int nSamples;
ilPtr pSrcLine, pDstLine;
long srcRowInc, dstRowBytes;
long nDstLinesM1, nDstPixelsM1Init;
ilSubsampleShiftPtr pShift;
-register long nDstPixelsM1, srcRowBytes, i;
-register ilPtr pSrc, pDst;
-register unsigned int pixel;
+long nDstPixelsM1, srcRowBytes, i;
+ilPtr pSrc, pDst;
+unsigned int pixel;
/* Get width and height of _upsampled_ image; exit if zero. */
pPriv = (ilSubsamplePrivPtr)pData->pPrivate;
ilImageFormat *pFormat
)
{
- register ilSubsamplePrivPtr pSubPriv;
+ ilSubsamplePrivPtr pSubPriv;
ilSubsamplePrivRec priv;
ilSubsampleShiftRec *pShift;
ilYCbCrSampleInfo *pSample;
)
{
ilPtr pYLine, pCbLine, pCrLine, pDstLine;
-register ilRGBTransPtr pTrans;
-register ilPtr pY, pCb, pCr, pDst;
-register long YTrans, CbTrans, CrTrans, pixel, nPixelsM1;
-register int Y;
+ilRGBTransPtr pTrans;
+ilPtr pY, pCb, pCr, pDst;
+long YTrans, CbTrans, CrTrans, pixel, nPixelsM1;
+int Y;
long nPixelsM1Init, nLinesM1;
long YRowBytes, CbRowBytes, CrRowBytes, dstRowBytes;
ilImagePlaneInfo *pPlane;
)
{
ilPtr pSrcLine, pDstLine;
-register ilRGBTransPtr pTrans;
-register ilPtr pSrc, pDst;
-register long YTrans, CbTrans, CrTrans, pixel, nPixelsM1;
-register int Y;
+ilRGBTransPtr pTrans;
+ilPtr pSrc, pDst;
+long YTrans, CbTrans, CrTrans, pixel, nPixelsM1;
+int Y;
long nPixelsM1Init, nLinesM1;
long srcRowBytes, dstRowBytes;
ilImagePlaneInfo *pPlane;
ilImageDes *pDes
)
{
- register ilRGBTransPtr pTrans;
+ ilRGBTransPtr pTrans;
const ilYCbCrInfo *pYCbCr, *pStdYCbCr;
double Lr, Lg, Lb, scaledY;
- register double factor, gFactor;
- register int i, refBlack, upper, lower;
+ double factor, gFactor;
+ int i, refBlack, upper, lower;
ilBool isStd;
struct {
int refBlack;
ilDstElementData dstData;
ilError (*executeFunction)(), (*destroyFunction)();
ilYCbCrToRGBPrivPtr pPriv;
- register ilRGBTransPtr pTrans;
+ ilRGBTransPtr pTrans;
if ((pFormat->nBitsPerSample[0] != 8)
|| (pFormat->nBitsPerSample[1] != 8)
int *pKernelRowEnd;
long nPixelsDiv2M1;
ilPtr pCb, pCr;
-register long YRowBytes, dstRowBytes;
-register long Y, Cb, Cr, YTrans, CbTrans, CrTrans, comp, pixel;
-register ilPtr pY, pDst;
-register ilRGBTransPtr pTrans;
-register ilPtr pTranslate;
-register int *pKernel, kernel;
+long YRowBytes, dstRowBytes;
+long Y, Cb, Cr, YTrans, CbTrans, CrTrans, comp, pixel;
+ilPtr pY, pDst;
+ilRGBTransPtr pTrans;
+ilPtr pTranslate;
+int *pKernel, kernel;
#define YCBCR2_KERNEL_SIZE 8 /* size of dither kernel used */
/* This filter handles a pipe image of YCbCr subsampled by 2 in Cb/Cr only.
with the dither values pre-multiplied into them.
*/
static void ilSetupYCbCrDitherTable (
- register ilRGBTransPtr pTrans,
+ ilRGBTransPtr pTrans,
ilImageDes *pDes
)
{
ilYCbCrInfo *pYCbCr;
double Lr, Lg, Lb, scaledY;
- register double factor, gFactor, rbDither, gDither;
- register int i, refBlack, upper, lower;
+ double factor, gFactor, rbDither, gDither;
+ int i, refBlack, upper, lower;
struct {
int refBlack;
double scale;
/* alloc pPalette unless not palette dst; init with ramp if not choosing */
pPalette = (unsigned short *)NULL;
if (pData->dstType == IL_PALETTE) {
- register int red, green, blue;
- register int redLevel, greenLevel, blueLevel;
- register unsigned short *pPal;
+ int red, green, blue;
+ int redLevel, greenLevel, blueLevel;
+ unsigned short *pPal;
pPalette = (unsigned short *)IL_MALLOC_ZERO (3 * 256 * sizeof(unsigned short));
if (!pPalette)
long *pNLines
)
{
-register ilRGBToYCbCrPrivPtr pPriv;
+ilRGBToYCbCrPrivPtr pPriv;
ilPtr pSrcLine, pYLine, pCbLine, pCrLine;
-register ilPtr pSrc, pY, pCb, pCr;
-register long nPixelsM1;
-register long YRefBlack, CbRefBlack, CrRefBlack;
+ilPtr pSrc, pY, pCb, pCr;
+long nPixelsM1;
+long YRefBlack, CbRefBlack, CrRefBlack;
long nPixelsM1Init, nLinesM1;
long YRowBytes, CbRowBytes, CrRowBytes, srcRowBytes;
ilImagePlaneInfo *pPlane;
-register long R, G, B, pixel;
+long R, G, B, pixel;
/* Set nPixels/LinesM1 to # pixels / lines - 1; exit if either 0. */
IL_PRIVATE ilBool _ilConvertRGBToYCbCr (
ilPipe pipe,
ilPipeInfo *pInfo,
- register ilImageDes *pDes,
- register const ilImageDes *pNewDes,
+ ilImageDes *pDes,
+ const ilImageDes *pNewDes,
ilImageFormat *pFormat
)
{
- register ilRGBToYCbCrPrivPtr pPriv;
- register ilYCbCrInfo *pYCbCr;
+ ilRGBToYCbCrPrivPtr pPriv;
+ ilYCbCrInfo *pYCbCr;
ilDstElementData dstData;
double Lr, Lg, Lb, range;
long YR, YG, YB;
projects / oweals / cde.git / commitdiff