This is iminternal.h in view mode; [Download] [Up]
/** ** $Header: /sdsc/dev/vis/image/imtools/v3.0/libim/src/include/RCS/iminternal.h,v 1.15 1995/06/30 22:13:26 bduggan Exp $ ** Copyright (c) 1989-1995 San Diego Supercomputer Center (SDSC) ** a division of General Atomics, San Diego, California, USA ** ** Users and possessors of this source code are hereby granted a ** nonexclusive, royalty-free copyright and design patent license to ** use this code in individual software. License is not granted for ** commercial resale, in whole or in part, without prior written ** permission from SDSC. This source is provided "AS IS" without express ** or implied warranty of any kind. ** ** For further information contact: ** E-Mail: info@sds.sdsc.edu ** ** Surface Mail: Information Center ** San Diego Supercomputer Center ** P.O. Box 85608 ** San Diego, CA 92138-5608 ** (619) 534-5000 **/ /** ** FILE ** iminternal.h - Internal header definitions for libim ** ** PROJECT ** libim - SDSC image manipulation library ** ** DESCRIPTION ** iminternal.h contains macros common to most file read and ** write functions. It should not be used outside of the scope ** of libim read and write routines. ** ** PUBLIC CONTENTS ** d =defined constant ** f =function ** m =defined macro ** t =typedef/struct/union ** v =variable ** ? =other ** ** ** __IMINTERNALH__ d file inclusion flag ** ** ImReturnBinError m return right error based on Bin call ** ImMalloc m malloc memory & return -1 on error ** ImMallocRetOnError m malloc memory & return specified value on error ** ImCalloc m calloc memory & return -1 on error ** ImCallocRetOnError m calloc memory & return specified value on error ** ImBinReadStruct m binary struct read from fd or fp ** ImBinRead m binary read from fd or fp ** ImBinWrite m binary write from fd or fp ** ImSeek m file seek from fd or fp ** ** ImErrorFatal m issue a fatal error ** ImErrorWarning m issue a warning error ** ImErrorInfo m issue an info error ** ImInfo m issue general information message ** ** NULL d an empty pointer ** xxxxx d abbreviations for items in Read/Write maps ** ** ImHist ? stuff for imvfbhist.c ** ** PRIVATE CONTENTS ** none ** ** HISTORY ** $Log: iminternal.h,v $ ** Revision 1.15 1995/06/30 22:13:26 bduggan ** removed strings.h ** ** Revision 1.14 1995/06/29 00:32:03 bduggan ** updated copyright ** ** Revision 1.13 1995/06/16 09:04:16 bduggan ** Added prototypes for ** ImGetTransparency,ImVfbProcessMapRequests,imLzwReadByte, ** imLzwCompGif,PackBits,UnPackBits,UnpackBits,UnpackBits3 ** Added ImErrorFatalExit ** Added IM_NOTHING ** Added some include files ** ** Revision 1.12 1995/05/18 00:08:28 bduggan ** Changed 'return ( ret ) ' into 'return ret' so that ** the parameter IM_NOTHING can be passed to macros. ** ** Revision 1.11 1995/01/18 21:52:23 bduggan ** Added ImCallocRetOnError macros ** added #include <stdlib.h> and prototypes for strlen and strcpy ** ** Revision 1.10 94/10/03 16:05:10 nadeau ** Added definitions of TRUE, FALSE, L_SET et al, and F_SET et al for ** internal routine use. ** Updated copyright message. ** ** Revision 1.9 92/12/03 02:19:42 nadeau ** Updated histogram information. ** ** Revision 1.8 92/11/06 17:02:24 groening ** added #defines for format reading ** ** Revision 1.7 92/10/12 16:12:52 vle ** Added ImInfo declarations. ** ** Revision 1.6 92/09/23 15:27:50 groening ** Added histogram declarations. ** ** Revision 1.5 91/10/03 12:57:05 nadeau ** Added error code to ImErrorHandler() call. ** ** Revision 1.4 90/07/23 13:52:38 nadeau ** Added curly braces to ImMalloc macro. Added ImTell macro. ** ** Revision 1.3 90/07/02 13:24:00 nadeau ** Added new error handling macros and globals and updated existing macros ** to use them. ** ** Revision 1.2 90/06/26 09:10:39 todd ** Useful macros for writing image file read and write routines. ** These should be taken out of imras.c someday. ** ** Revision 1.1 90/05/15 14:00:06 todd ** Initial revision ** ** **/ #ifndef __IMINTERNALH__ #define __IMINTERNALH__ #ifndef __SDSCCOPYRIGHTH__ #include "sdsccopyright.h" #endif #include <errno.h> extern int sys_nerr; extern char *sys_errlist[]; #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> #include <ctype.h> #ifndef __SDSCH__ #include "sdsc.h" #endif /* __SDSCH__ */ #ifndef __IMH__ #include "im.h" #endif /* __IMH__ */ #ifndef NULL #define NULL (0) #endif /* NULL */ #ifndef TRUE #define TRUE (1) #endif #ifndef FALSE #define FALSE (0) #endif #include <string.h> /* * CONSTANTS * L_* - file descriptor seek types * F_* - file pointer seek types * * DESCRIPTION * Not all OS variants define values for the lseek() and fseek() * seek types, though the actual type values are highly standardized * by existing heavy use as raw numbers. If this OS hasn't defined * constants for these, we do. */ #ifndef L_SET #define L_SET 0 /* Absolute offset */ #define L_INCR 1 /* Relative to current offset */ #define L_XTND 2 /* Relative to end of file */ #endif #ifndef F_SET #define F_SET 0 /* Absolute offset */ #define F_INCR 1 /* Relative to current offset */ #define F_XTND 2 /* Relative to end of file */ #endif /* * CONSTANTS * XXX - abbreviations for Read/Write map fields * * DESCRIPTION * These constants are simply shorthands for flags used in initialization * of the file format read/write maps. They are only provided so that * such initializations don't look too cluttered. */ #define C IMCLTYES /* CLT included */ #define A IMALPHAYES /* Alpha plane included */ #define RLE IMCOMPRLE /* RLE compression */ #define LZW IMCOMPLZW /* LZW compression */ #define PB IMCOMPPACKBITS /* Packbits compression */ #define DCT IMCOMPDCT /* DCT compression */ #define ASC IMCOMPASCII /* ASCII compression */ #define LI IMINTERLINE /* Line interleaved */ #define PI IMINTERPLANE /* Plane interleaved */ #define IN IMTYPEINDEX /* Index type of image */ #define RGB IMTYPERGB /* RGB type of image */ #define T IMGROUPTILES /* Group into tiles */ #define Q IMQUALITYYES /* Optional quality control */ /* * CONSTANTS * IMFILEIO... - Image file I/O type * * DESCRIPTIONS * These constants are bitwise OR-ed together to create the ioType * argument to the internal per-format read and write routines. * They should never be used by the applications programmer. */ #define IMFILEIOFD 0x1 /* Use file descriptor */ #define IMFILEIOFP 0x2 /* Use file pointer */ #define IMFILEIOFILE 0x10 /* I/O on file */ #define IMFILEIOPIPE 0x20 /* I/O on pipe */ /* * MACROS * ImReturnBinError - set correct error based on Bin call, and return -1 * ImReturnValBinError - Same as above, but return specified value * ImCalloc - calloc memory & return -1 on error * ImCallocRetOnError - calloc memory & return specified value on error * ImMalloc - malloc memory & return -1 on error * ImMallocRetOnError - malloc memory & return specified value on error * ImBinReadStruct - binary struct read from fd or fp * ImBinRead - binary read from fd or fp * ImBinWrite - binary write from fd or fp * ImSeek - file seek from fd or fp * * DESCRIPTION * These actions occur so often in the imfile read/write code that they * have been turned into macros in order to reduce clutter and make the * algorithms more apparent. */ #define ImReturnBinError() \ ImReturnValBinError( -1 ) #define ImReturnValBinError( ret ) \ { \ if ( BinErrNo == BINEMALLOC ) \ { \ ImErrorFatal( BinQError( ), ret, IMEMALLOC ); \ } \ else \ { \ ImErrorFatal( BinQError( ), ret, IMESYS ); \ } \ } #define ImMallocRetOnError(variable,type,nbytes,retvalue) \ { \ if ( ((variable) = (type)malloc( (nbytes) )) == NULL ) \ { \ ImErrNo = IMEMALLOC; \ ImErrorFatal( ImQError( ), retvalue, IMEMALLOC ); \ } \ } #define ImMalloc(variable,type,nbytes) \ ImMallocRetOnError(variable,type,nbytes,-1) #define ImCallocRetOnError(variable,type,nbytes,size,errvalue) \ { \ if ( ((variable) = (type)calloc( (nbytes),(size) )) == NULL ) \ { \ ImErrNo = IMEMALLOC; \ ImErrorFatal( ImQError( ), errvalue, IMEMALLOC ); \ } \ } #define ImCalloc(variable,type,nbytes,size) \ ImCallocRetOnError(variable,type,nbytes,size,-1) #define ImBinReadStruct(ioType,fd,fp,buf,fields) \ (((ioType)&IMFILEIOFD) ? \ BinReadStruct( (fd), (buf), (fields) ) \ : \ BinFReadStruct( (fp), (buf), (fields) ) \ ) #define ImBinRead(ioType,fd,fp,buf,type,nbytes,len) \ (((ioType)&IMFILEIOFD) ? \ BinRead( (fd), (buf), (type), (nbytes), (len) ) \ : \ BinFRead( (fp), (buf), (type), (nbytes), (len) ) \ ) #define ImBinWriteStruct(ioType,fd,fp,buf,fields) \ (((ioType)&IMFILEIOFD) ? \ BinWriteStruct( (fd), (buf), (fields) ) \ : \ BinFWriteStruct( (fp), (buf), (fields) ) \ ) #define ImBinWrite(ioType,fd,fp,buf,type,nbytes,len) \ (((ioType)&IMFILEIOFD) ? \ BinWrite( (fd), (buf), (type), (nbytes), (len) ) \ : \ BinFWrite( (fp), (buf), (type), (nbytes), (len) ) \ ) #define ImSeek(ioType,fd,fp,offset,type) \ (((ioType)&IMFILEIOFD) ? \ lseek( (fd), (offset), (type) ) \ : \ fseek( (fp), (offset), (type) ) \ ) #define ImTell(ioType,fd,fp) \ (((ioType)&IMFILEIOFD) ? \ lseek( (fd), 0, 1 ) \ : \ ftell( (fp) ) \ ) /* * MACROS and CONSTANTS * ImErrorFatal - issue a fatal error and return a value * ImErrorFatalExit - issue a fatal error and exit the process * ImErrorWarning - issue a warning error and possibly return a value * ImErrorInfo - issue an info error * ImInfo - issue an information message * IMINFOMSGWIDTH... - Image Info Message Widths * IMINFOMSGLENGTH - Image Info Message Length * IM_NOTHING - Nothing * * DESCRIPTION * These macros cover up some of the busy-work of issueing error * and info messages and codes while processing file formats. * * IM_NOTHING can be used with the error macros, if your * function does not return a value. */ #define IM_NOTHING /* nothing */ extern char *ImErrorProgramName; /* Program name */ extern char *ImErrorFileName; /* File name */ extern FILE *ImErrorStream; /* Error stream */ extern FILE *ImInfoStream; /* Info stream */ #ifdef __STDC__ extern int (*ImErrorHandler)(int, int, char* ); /* Error handler */ extern int (*ImInfoHandler)(char*,char*,char*); /* Info handler */ #else extern int (*ImErrorHandler)( ); /* Error handler */ extern int (*ImInfoHandler)( ); /* Info handler */ #endif #define ImErrorFatal(msg,ret,er) \ { \ if ( ImErrorHandler ) \ { \ char errorMessage[500]; \ sprintf( errorMessage, "%s: %s: %s\n", ImErrorProgramName,\ ImErrorFileName, (msg) ); \ (*ImErrorHandler)( IMERRORFATAL, er, errorMessage ); \ ImErrNo = (er); \ return ret ; \ } \ else if ( ImErrorStream ) \ { \ fprintf( ImErrorStream, "%s: %s: %s\n", ImErrorProgramName,\ ImErrorFileName, (msg) ); \ ImErrNo = (er); \ return ret ; \ } \ else \ { \ ImErrNo = (er); \ return ret ; \ } \ } #define ImErrorWarning(msg,ret,er) \ { \ if ( ImErrorHandler ) \ { \ char errorMessage[500]; \ sprintf( errorMessage, "%s: %s: %s\n", ImErrorProgramName,\ ImErrorFileName, (msg) ); \ if ( (*ImErrorHandler)( IMERRORWARNING, er, errorMessage ) == -1 )\ { \ ImErrNo = (er); \ return ret ; \ } \ } \ else if ( ImErrorStream ) \ fprintf( ImErrorStream, "%s: %s: %s\n", ImErrorProgramName,\ ImErrorFileName, (msg) ); \ else \ { \ ImErrNo = (er); \ return ret ; \ } \ } #define ImErrorInfo(msg,ret,er) \ { \ if ( ImErrorHandler ) \ { \ char errorMessage[500]; \ sprintf( errorMessage, "%s: %s: %s\n", ImErrorProgramName,\ ImErrorFileName, (msg) ); \ if ( (*ImErrorHandler)( IMERRORINFO, er, errorMessage ) == -1 )\ { \ ImErrNo = (er); \ return ret ; \ } \ } \ else if ( ImErrorStream ) \ fprintf( ImErrorStream, "%s: %s: %s\n", ImErrorProgramName,\ ImErrorFileName, (msg) ); \ } #define ImErrorFatalExit(msg,status,er) \ { \ if ( ImErrorHandler ) \ { \ char errorMessage[500]; \ sprintf( errorMessage, "%s: %s: %s\n", ImErrorProgramName,\ ImErrorFileName, (msg) ); \ (*ImErrorHandler)( IMERRORFATAL, er, errorMessage ); \ exit (status) ; \ } \ else if ( ImErrorStream ) \ { \ fprintf( ImErrorStream, "%s: %s: %s\n", ImErrorProgramName,\ ImErrorFileName, (msg) ); \ exit (status) ; \ } \ else \ { \ exit (status) ; \ } \ } #define IMINFOMSGWIDTH1 20 #define ImInfo(label,msg) \ { \ char infoMessage[500]; \ char infoLabel[IMINFOMSGWIDTH1+2]; \ sprintf( infoLabel, "%s:", label ); \ sprintf( infoMessage, "%-*s %s\n", IMINFOMSGWIDTH1, infoLabel, msg );\ if ( ImInfoHandler ) \ (*ImInfoHandler)( ImErrorProgramName, ImErrorFileName, \ infoMessage ); \ else if ( ImInfoStream ) \ fprintf( ImInfoStream, "%s: %s: %s", ImErrorProgramName,\ ImErrorFileName, (infoMessage) ); \ } /* * Following are some functions that are used in a variety of places * within the library. */ #ifdef __STDC__ extern int ImGetTransparency(TagTable* tagTable, TagTable* flagsTable, ImVfb* vfb); extern int ImVfbProcessMapRequests( TagTable* flagsTable, TagTable* tagTable); extern int imLzwReadByte(int ioType,int fd,FILE *fp,int flag,int input_code_size); extern int imLzwCompGif(int ioType,int fd,FILE *fp,int code_size, unsigned char *rasterdata, int size); extern void PackBits( unsigned char *cIn, unsigned char *cOut, unsigned int *width ); extern void PackBits3( unsigned char *cIn, unsigned char *cOut, unsigned int * width ); extern void UnpackBits( unsigned char *srcPtr, unsigned char *dstPtr, unsigned int *cnt ); extern void UnpackBits3( unsigned char *srcPtr, unsigned char *dstPtr, unsigned int *cnt ); #else extern int ImGetTransparency( ); /* declared in imvfb.c */ extern int ImVfbProcessMapRequests( ); /* declared in imvfbchan.c */ extern int imLzwReadByte(); /* declared in imgiflzw.c */ extern int imLzwCompGif(); /* declared in imgiflzw.c */ extern void PackBits(); /* macpack.c */ extern void UnPackBits(); /* macpack.c */ extern void UnpackBits( ); /* macpack.c */ extern void UnpackBits3( ); /* macpack.c */ #endif #endif /* __IMINTERNALH__ */
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.