From 192e46c32f7baededf8df7b1777f8c5409110e8a Mon Sep 17 00:00:00 2001 From: Parvatha Elangovan Date: Wed, 28 Feb 2007 15:31:56 +0000 Subject: [PATCH] Enabled compression of TIF image format to j2k by tifftoimage() and decompression of codestream to TIF image format using imagetotif(). Modifications in image_to_j2k.c, j2k_to_image.c, convert.c, convert.h --- ChangeLog | 1 + codec/convert.c | 356 ++++++++++++++++++++++++++++++++++++ codec/convert.h | 3 + codec/image_to_j2k.c | 35 ++-- codec/j2k_to_image.c | 58 ++++-- libopenjpeg/openjpeg.h | 2 +- libs/libtiff/Tiffcomp.h | 214 ++++++++++++++++++++++ libs/libtiff/Tiffconf.h | 131 ++++++++++++++ libs/libtiff/Tiffiop.h | 287 +++++++++++++++++++++++++++++ libs/libtiff/Version.h | 1 + libs/libtiff/libtiff.lib | Bin 0 -> 229770 bytes libs/libtiff/tiff.h | 380 +++++++++++++++++++++++++++++++++++++++ libs/libtiff/tiffio.h | 311 ++++++++++++++++++++++++++++++++ 13 files changed, 1751 insertions(+), 28 deletions(-) create mode 100644 libs/libtiff/Tiffcomp.h create mode 100644 libs/libtiff/Tiffconf.h create mode 100644 libs/libtiff/Tiffiop.h create mode 100644 libs/libtiff/Version.h create mode 100644 libs/libtiff/libtiff.lib create mode 100644 libs/libtiff/tiff.h create mode 100644 libs/libtiff/tiffio.h diff --git a/ChangeLog b/ChangeLog index baa216c9..10bf62e0 100644 --- a/ChangeLog +++ b/ChangeLog @@ -6,6 +6,7 @@ What's New for OpenJPEG + : added February 28, 2007 ++ [Parvatha] Enabled compression of TIF image format to j2k by tifftoimage() and decompression of codestream to TIF image format using imagetotif(). Modifications in image_to_j2k.c, j2k_to_image.c, convert.c, convert.h * [antonin] fixed a bug in context numerotation that prevented the RESET switch to work correctly : mqc_reset_enc in mqc.c * [Fod] Corrected codec Makefile by adding the compilation of "compat/getopt.c" diff --git a/codec/convert.c b/codec/convert.c index 5c84cbdb..3ff6eb88 100644 --- a/codec/convert.c +++ b/codec/convert.c @@ -32,6 +32,7 @@ #include #include #include "openjpeg.h" +#include "../libs/libtiff/tiffio.h" /* * Get logarithm of an integer and round downwards. @@ -1063,4 +1064,359 @@ int imagetopnm(opj_image_t * image, const char *outfile) { return 0; } +/* -->> -->> -->> -->> + TIFF IMAGE FORMAT + + <<-- <<-- <<-- <<-- */ + +typedef struct tiff_infoheader{ + DWORD tiWidth; // Width of Image in pixel + DWORD tiHeight; // Height of Image in pixel + DWORD tiPhoto; // Photometric + WORD tiBps; // Bits per sample + WORD tiSf; // Sample Format + WORD tiSpp; // Sample per pixel 1-bilevel,gray scale , 2- RGB + WORD tiPC; // Planar config (1-Interleaved, 2-Planarcomp) +}tiff_infoheader_t; + +int imagetotif(opj_image_t * image, const char *outfile) { + int width, height; + int bps,index; + TIFF *tif; + tdata_t buf; + tstrip_t strip; + tsize_t strip_size; + + if (image->numcomps == 3 && image->comps[0].dx == image->comps[1].dx + && image->comps[1].dx == image->comps[2].dx + && image->comps[0].dy == image->comps[1].dy + && image->comps[1].dy == image->comps[2].dy + && image->comps[0].prec == image->comps[1].prec + && image->comps[1].prec == image->comps[2].prec) { + + /* -->> -->> -->> + RGB color + <<-- <<-- <<-- */ + + tif = TIFFOpen(outfile, "wb"); + if (!tif) { + fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile); + return 1; + } + + width = image->comps[0].w; + height= image->comps[0].h; + bps = image->comps[0].prec; + /* Set tags */ + TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width); + TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height); + TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 3); + TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps); + TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT); + TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG); + TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB); + TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1); + + /* Get a buffer for the data */ + buf = _TIFFmalloc(TIFFStripSize(tif)); + index=0; + strip_size=0; + strip_size=TIFFStripSize(tif); + for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) { + unsigned char *dat8; + int i; + dat8 = buf; + if (image->comps[0].prec == 8){ + for (i=0; icomps[0].data[index] ; // R + dat8[i+1] = image->comps[1].data[index] ; // G + dat8[i+2] = image->comps[2].data[index] ; // B + index++; + } + }else if (image->comps[0].prec == 12){ + for (i=0; icomps[0].data[index]>>8)<<4 | (image->comps[0].data[index]>>4); + dat8[i+1] = (image->comps[0].data[index]<<4)|((image->comps[1].data[index]>>8)& 0x0f); + dat8[i+2] = (image->comps[1].data[index]); + dat8[i+3] = (image->comps[2].data[index]>>8)<<4 | (image->comps[2].data[index]>>4); + dat8[i+4] = (image->comps[2].data[index]<<4)|((image->comps[1].data[index+1]>>8)& 0x0f); + dat8[i+5] = (image->comps[0].data[index+1]); + dat8[i+6] = (image->comps[1].data[index+1]>>8)<<4 | (image->comps[1].data[index+1]>>4); + dat8[i+7] = (image->comps[1].data[index+1]<<4)|((image->comps[2].data[index+1]>>8)& 0x0f); + dat8[i+8] = (image->comps[2].data[index+1]); + index+=2; + } + }else if (image->comps[0].prec == 16){ + for (i=0; icomps[0].data[index];//LSB + dat8[i+1] = (image->comps[0].data[index]>> 8);//MSB + dat8[i+2] = image->comps[1].data[index]; + dat8[i+3] = (image->comps[1].data[index]>> 8); + dat8[i+4] = image->comps[2].data[index]; + dat8[i+5] = (image->comps[2].data[index]>> 8); + index++; + } + }else{ + fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",image->comps[0].prec); + fprintf(stderr,"Aborting\n"); + return 1; + } + TIFFWriteEncodedStrip(tif, strip, buf, strip_size); + } + _TIFFfree(buf); + TIFFClose(tif); + }else if (image->numcomps == 1){ + /* -->> -->> -->> + Black and White + <<-- <<-- <<-- */ + + tif = TIFFOpen(outfile, "wb"); + if (!tif) { + fprintf(stderr, "ERROR -> failed to open %s for writing\n", outfile); + return 1; + } + + width = image->comps[0].w; + height= image->comps[0].h; + bps = image->comps[0].prec; + + /* Set tags */ + TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width); + TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height); + TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1); + TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bps); + TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT); + TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG); + TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK); + TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1); + + /* Get a buffer for the data */ + buf = _TIFFmalloc(TIFFStripSize(tif)); + index = 0; + strip_size = 0; + strip_size = TIFFStripSize(tif); + for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) { + unsigned char *dat8; + int i; + dat8 = buf; + if (image->comps[0].prec == 8){ + for (i=0; icomps[0].data[index] ; + index++; + } + }else if (image->comps[0].prec == 12){ + for (i = 0; icomps[0].data[index]>>8)<<4 | (image->comps[0].data[index]>>4); + dat8[i+1] = (image->comps[0].data[index]<<4)|((image->comps[0].data[index+1]>>8)& 0x0f); + dat8[i+2] = (image->comps[0].data[index+1]); + index+=2; + } + }else if (image->comps[0].prec == 16){ + for (i=0; icomps[0].data[index]; + dat8[i+1] = (image->comps[0].data[index]>> 8); + index++; + } + }else{ + fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",image->comps[0].prec); + fprintf(stderr,"Aborting\n"); + return 1; + } + TIFFWriteEncodedStrip(tif, strip, buf, strip_size); + } + _TIFFfree(buf); + TIFFClose(tif); + }else{ + fprintf(stderr,"False color format. Only RGB & Grayscale has been implemented\n"); + fprintf(stderr,"Aborting\n"); + return 1; + } + return 0; +} + +opj_image_t* tiftoimage(char *filename, opj_cparameters_t *parameters) +{ + int subsampling_dx = parameters->subsampling_dx; + int subsampling_dy = parameters->subsampling_dy; + TIFF *tif; + tiff_infoheader_t Info; + tdata_t buf; + tstrip_t strip; + tsize_t strip_size; + int j, numcomps, w, h,index; + OPJ_COLOR_SPACE color_space; + opj_image_cmptparm_t cmptparm[3]; + opj_image_t * image = NULL; + + tif = TIFFOpen(filename, "r"); + + if (!tif) { + fprintf(stderr, "Failed to open %s for reading\n", filename); + return 0; + } + + TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &Info.tiWidth); + TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &Info.tiHeight); + TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &Info.tiBps); + TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &Info.tiSf); + TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &Info.tiSpp); + Info.tiPhoto = 0; + TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &Info.tiPhoto); + TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &Info.tiPC); + w= Info.tiWidth; + h= Info.tiHeight; + + if (Info.tiPhoto == 2) { + /* -->> -->> -->> + RGB color + <<-- <<-- <<-- */ + + numcomps = 3; + color_space = CLRSPC_SRGB; + /* initialize image components*/ + memset(&cmptparm[0], 0, 3 * sizeof(opj_image_cmptparm_t)); + for(j = 0; j < numcomps; j++) { + cmptparm[j].prec = Info.tiBps; + cmptparm[j].bpp = Info.tiBps; + cmptparm[j].sgnd = 0; + cmptparm[j].dx = subsampling_dx; + cmptparm[j].dy = subsampling_dy; + cmptparm[j].w = w; + cmptparm[j].h = h; + } + /* create the image*/ + image = opj_image_create(numcomps, &cmptparm[0], color_space); + if(!image) { + TIFFClose(tif); + return NULL; + } + + /* set image offset and reference grid */ + image->x0 = parameters->image_offset_x0; + image->y0 = parameters->image_offset_y0; + image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1; + image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1; + + buf = _TIFFmalloc(TIFFStripSize(tif)); + strip_size=0; + strip_size=TIFFStripSize(tif); + index = 0; + /* Read the Image components*/ + for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) { + unsigned char *dat8; + int i, ssize; + ssize = TIFFReadEncodedStrip(tif, strip, buf, strip_size); + dat8 = buf; + + if (Info.tiBps==12){ + for (i=0; icomps[0].data[index] = ( dat8[i+0]<<4 ) |(dat8[i+1]>>4); + image->comps[1].data[index] = ((dat8[i+1]& 0x0f)<< 8) | dat8[i+2]; + image->comps[2].data[index] = ( dat8[i+3]<<4) |(dat8[i+4]>>4); + image->comps[0].data[index+1] = ((dat8[i+4]& 0x0f)<< 8) | dat8[i+5]; + image->comps[1].data[index+1] = ( dat8[i+6] <<4) |(dat8[i+7]>>4); + image->comps[2].data[index+1] = ((dat8[i+7]& 0x0f)<< 8) | dat8[i+8]; + index+=2; + } + } + else if( Info.tiBps==16){ + for (i=0; icomps[0].data[index] = ( dat8[i+1] << 8 ) | dat8[i+0]; // R + image->comps[1].data[index] = ( dat8[i+3] << 8 ) | dat8[i+2]; // G + image->comps[2].data[index] = ( dat8[i+5] << 8 ) | dat8[i+4]; // B + index++; + } + } + else if ( Info.tiBps==8){ + for (i=0; icomps[0].data[index] = dat8[i+0]; // R + image->comps[1].data[index] = dat8[i+1]; // G + image->comps[2].data[index] = dat8[i+2]; // B + index++; + } + } + else{ + fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",Info.tiBps); + fprintf(stderr,"Aborting\n"); + return NULL; + } + } + + _TIFFfree(buf); + TIFFClose(tif); + }else if(Info.tiPhoto == 1) { + /* -->> -->> -->> + Black and White + <<-- <<-- <<-- */ + + numcomps = 1; + color_space = CLRSPC_GRAY; + /* initialize image components*/ + memset(&cmptparm[0], 0, sizeof(opj_image_cmptparm_t)); + cmptparm[0].prec = Info.tiBps; + cmptparm[0].bpp = Info.tiBps; + cmptparm[0].sgnd = 0; + cmptparm[0].dx = subsampling_dx; + cmptparm[0].dy = subsampling_dy; + cmptparm[0].w = w; + cmptparm[0].h = h; + + /* create the image*/ + image = opj_image_create(numcomps, &cmptparm[0], color_space); + if(!image) { + TIFFClose(tif); + return NULL; + } + /* set image offset and reference grid */ + image->x0 = parameters->image_offset_x0; + image->y0 = parameters->image_offset_y0; + image->x1 = !image->x0 ? (w - 1) * subsampling_dx + 1 : image->x0 + (w - 1) * subsampling_dx + 1; + image->y1 = !image->y0 ? (h - 1) * subsampling_dy + 1 : image->y0 + (h - 1) * subsampling_dy + 1; + + buf = _TIFFmalloc(TIFFStripSize(tif)); + strip_size = 0; + strip_size = TIFFStripSize(tif); + index = 0; + /* Read the Image components*/ + for (strip = 0; strip < TIFFNumberOfStrips(tif); strip++) { + unsigned char *dat8; + int i, ssize; + ssize = TIFFReadEncodedStrip(tif, strip, buf, strip_size); + dat8 = buf; + + if (Info.tiBps==12){ + for (i=0; icomps[0].data[index] = ( dat8[i+0]<<4 ) |(dat8[i+1]>>4) ; + image->comps[0].data[index] = ((dat8[i+1]& 0x0f)<< 8) | dat8[i+2]; + index+=2; + } + } + else if( Info.tiBps==16){ + for (i=0; icomps[0].data[index] = ( dat8[i+1] << 8 ) | dat8[i+0]; + index++; + } + } + else if ( Info.tiBps==8){ + for (i=0; icomps[0].data[index] = dat8[i+0]; + index++; + } + } + else{ + fprintf(stderr,"Bits=%d, Only 8,12,16 bits implemented\n",Info.tiBps); + fprintf(stderr,"Aborting\n"); + return NULL; + } + } + + _TIFFfree(buf); + TIFFClose(tif); + }else{ + fprintf(stderr,"False color format. Only RGB & Grayscale has been implemented\n"); + fprintf(stderr,"Aborting\n"); + return NULL; + } + return image; +} diff --git a/codec/convert.h b/codec/convert.h index 95c3b357..68aed4b3 100644 --- a/codec/convert.h +++ b/codec/convert.h @@ -35,6 +35,9 @@ opj_image_t* bmptoimage(const char *filename, opj_cparameters_t *parameters); int imagetobmp(opj_image_t *image, const char *outfile); +/* TIFF to image conversion*/ +opj_image_t* tiftoimage(const char *filename, opj_cparameters_t *parameters); +int imagetotif(opj_image_t *image, const char *outfile); /** Load a single image component encoded in PGX file format @param filename Name of the PGX file to load diff --git a/codec/image_to_j2k.c b/codec/image_to_j2k.c index 71e3dd6a..28208c5c 100644 --- a/codec/image_to_j2k.c +++ b/codec/image_to_j2k.c @@ -52,6 +52,7 @@ #define PGX_DFMT 11 #define BMP_DFMT 12 #define YUV_DFMT 13 +#define TIF_DFMT 14 /* ----------------------------------------------------------------------- */ @@ -356,10 +357,10 @@ int load_images(dircnt_t *dirptr, char *imgdirpath){ int get_file_format(char *filename) { unsigned int i; static const char *extension[] = { - "pgx", "pnm", "pgm", "ppm", "bmp", "j2k", "jp2" + "pgx", "pnm", "pgm", "ppm", "bmp","tif", "j2k", "jp2" }; static const int format[] = { - PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, J2K_CFMT, JP2_CFMT + PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT,TIF_DFMT, J2K_CFMT, JP2_CFMT }; char * ext = strrchr(filename, '.'); if (ext == NULL) @@ -443,11 +444,12 @@ int parse_cmdline_encoder(int argc, char **argv, opj_cparameters_t *parameters,i case PGX_DFMT: case PXM_DFMT: case BMP_DFMT: + case TIF_DFMT: break; default: fprintf(stderr, "!! Unrecognized format for infile : %s " - "[accept only *.pnm, *.pgm, *.ppm, *.pgx or *.bmp] !!\n\n", + "[accept only *.pnm, *.pgm, *.ppm, *.pgx, *.bmp or *.tif] !!\n\n", infile); return 1; } @@ -1145,8 +1147,8 @@ int parse_cmdline_encoder(int argc, char **argv, opj_cparameters_t *parameters,i } /* check for possible errors */ - if(img_fol->set_imgdir==1){ - if(!(parameters->infile[0]==0)){ + if(img_fol->set_imgdir == 1){ + if(!(parameters->infile[0] == 0)){ fprintf(stderr, "Error: options -ImgDir and -i cannot be used together !!\n"); return 1; } @@ -1234,7 +1236,6 @@ int main(int argc, char **argv) { opj_image_t *image = NULL; int i,num_images; int imageno; - char process_file = 1; dircnt_t *dirptr; /* @@ -1319,7 +1320,9 @@ int main(int argc, char **argv) { break; case BMP_DFMT: break; - + case TIF_DFMT: + break; + default: fprintf(stderr,"skipping file...\n"); continue; @@ -1332,15 +1335,15 @@ int main(int argc, char **argv) { case PGX_DFMT: image = pgxtoimage(parameters.infile, ¶meters); if (!image) { - fprintf(stderr, " unable to load pgx file\n"); - return 1; + fprintf(stderr, "Unable to load pgx file\n"); + return 1; } break; case PXM_DFMT: image = pnmtoimage(parameters.infile, ¶meters); if (!image) { - fprintf(stderr, " not a pnm file\n"); + fprintf(stderr, "Unable to load pnm file\n"); return 1; } break; @@ -1348,11 +1351,19 @@ int main(int argc, char **argv) { case BMP_DFMT: image = bmptoimage(parameters.infile, ¶meters); if (!image) { - fprintf(stderr, " not a bmp file\n"); + fprintf(stderr, "Unable to load bmp file\n"); return 1; } break; - } + + case TIF_DFMT: + image = tiftoimage(parameters.infile, ¶meters); + if (!image) { + fprintf(stderr, "Unable to load tiff file\n"); + return 1; + } + break; + } /* encode the destination image */ /* ---------------------------- */ diff --git a/codec/j2k_to_image.c b/codec/j2k_to_image.c index 91651de9..223f44ee 100644 --- a/codec/j2k_to_image.c +++ b/codec/j2k_to_image.c @@ -52,6 +52,7 @@ #define PGX_DFMT 11 #define BMP_DFMT 12 #define YUV_DFMT 13 +#define TIF_DFMT 14 /* ----------------------------------------------------------------------- */ @@ -179,8 +180,8 @@ int load_images(dircnt_t *dirptr, char *imgdirpath){ int get_file_format(char *filename) { unsigned int i; - static const char *extension[] = {"pgx", "pnm", "pgm", "ppm", "bmp", "j2k", "jp2", "jpt" }; - static const int format[] = { PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, J2K_CFMT, JP2_CFMT, JPT_CFMT }; + static const char *extension[] = {"pgx", "pnm", "pgm", "ppm", "bmp","tif", "j2k", "jp2", "jpt" }; + static const int format[] = { PGX_DFMT, PXM_DFMT, PXM_DFMT, PXM_DFMT, BMP_DFMT, TIF_DFMT, J2K_CFMT, JP2_CFMT, JPT_CFMT }; char * ext = strrchr(filename, '.'); if (ext == NULL) return -1; @@ -200,7 +201,7 @@ char get_next_file(int imageno,dircnt_t *dirptr,img_fol_t *img_fol, opj_dparamet char image_filename[OPJ_PATH_LEN], infilename[OPJ_PATH_LEN],outfilename[OPJ_PATH_LEN],temp_ofname[OPJ_PATH_LEN]; strcpy(image_filename,dirptr->filename[imageno]); - fprintf(stderr,"Imageno=%d %s\n",imageno,image_filename); + fprintf(stderr,"File Number %d \"%s\"\n",imageno,image_filename); parameters->decod_format = get_file_format(image_filename); if (parameters->decod_format == -1) return 1; @@ -271,6 +272,7 @@ int parse_cmdline_decoder(int argc, char **argv, opj_dparameters_t *parameters,i case PGX_DFMT: case PXM_DFMT: case BMP_DFMT: + case TIF_DFMT: break; default: fprintf(stderr, "Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx or *.bmp]!! \n", outfile); @@ -299,6 +301,9 @@ int parse_cmdline_decoder(int argc, char **argv, opj_dparameters_t *parameters,i case BMP_DFMT: img_fol->out_format = "bmp"; break; + case TIF_DFMT: + img_fol->out_format = "tif"; + break; default: fprintf(stderr, "Unknown output format image %s [only *.pnm, *.pgm, *.ppm, *.pgx or *.bmp]!! \n"); return 1; @@ -484,7 +489,6 @@ int main(int argc, char **argv) { int num_images; int i,imageno; dircnt_t *dirptr; - char process_file = 1; opj_dinfo_t* dinfo = NULL; /* handle to a decompressor */ opj_cio_t *cio = NULL; @@ -657,7 +661,7 @@ int main(int argc, char **argv) { break; default: - fprintf(stderr, "False input image format skipping file..\n"); + fprintf(stderr, "skipping file..\n"); continue; } @@ -667,26 +671,50 @@ int main(int argc, char **argv) { /* create output image */ /* ------------------- */ - switch (parameters.cod_format) { + switch (parameters.cod_format) { case PXM_DFMT: /* PNM PGM PPM */ - imagetopnm(image, parameters.outfile); + if (imagetopnm(image, parameters.outfile)) { + fprintf(stdout,"Outfile %s not generated\n",parameters.outfile); + } + else { + fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile); + } break; case PGX_DFMT: /* PGX */ - imagetopgx(image, parameters.outfile); + if(imagetopgx(image, parameters.outfile)){ + fprintf(stdout,"Outfile %s not generated\n",parameters.outfile); + } + else { + fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile); + } break; case BMP_DFMT: /* BMP */ - imagetobmp(image, parameters.outfile); + if(imagetobmp(image, parameters.outfile)){ + fprintf(stdout,"Outfile %s not generated\n",parameters.outfile); + } + else { + fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile); + } break; - } - /* free remaining structures */ - if(dinfo) { - opj_destroy_decompress(dinfo); + case TIF_DFMT: /* TIFF */ + if(imagetotif(image, parameters.outfile)){ + fprintf(stdout,"Outfile %s not generated\n",parameters.outfile); } - /* free image data structure */ - opj_image_destroy(image); + else { + fprintf(stdout,"Successfully generated Outfile %s\n",parameters.outfile); + } + break; + } + + /* free remaining structures */ + if(dinfo) { + opj_destroy_decompress(dinfo); + } + /* free image data structure */ + opj_image_destroy(image); } return 0; diff --git a/libopenjpeg/openjpeg.h b/libopenjpeg/openjpeg.h index 6b529138..ceb5df2c 100644 --- a/libopenjpeg/openjpeg.h +++ b/libopenjpeg/openjpeg.h @@ -277,7 +277,7 @@ typedef struct opj_cparameters { int subsampling_dx; /** subsampling value for dy */ int subsampling_dy; - /** input file format 0: PGX, 1: PxM, 2: BMP */ + /** input file format 0: PGX, 1: PxM, 2: BMP 3:TIF*/ int decod_format; /** output file format 0: J2K, 1: JP2, 2: JPT */ int cod_format; diff --git a/libs/libtiff/Tiffcomp.h b/libs/libtiff/Tiffcomp.h new file mode 100644 index 00000000..516e6384 --- /dev/null +++ b/libs/libtiff/Tiffcomp.h @@ -0,0 +1,214 @@ +/* $Header: /usr/people/sam/tiff/libtiff/RCS/tiffcomp.h,v 1.49 1996/04/29 21:56:21 sam Rel $ */ + +/* + * Copyright (c) 1990-1996 Sam Leffler + * Copyright (c) 1991-1996 Silicon Graphics, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that (i) the above copyright notices and this permission notice appear in + * all copies of the software and related documentation, and (ii) the names of + * Sam Leffler and Silicon Graphics may not be used in any advertising or + * publicity relating to the software without the specific, prior written + * permission of Sam Leffler and Silicon Graphics. + * + * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, + * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY + * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. + * + * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR + * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, + * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, + * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF + * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef _COMPAT_ +#define _COMPAT_ +/* + * This file contains a hodgepodge of definitions and + * declarations that are needed to provide compatibility + * between the native system and the base implementation + * that the library assumes. + * + * NB: This file is a mess. + */ + +/* + * Setup basic type definitions and function declaratations. + */ + +/* + * Simplify Acorn RISC OS identifier (to avoid confusion with Acorn RISC iX + * and with defunct Unix Risc OS) + * No need to specify __arm - hey, Acorn might port the OS, no problem here! + */ +#ifdef __acornriscos +#undef __acornriscos +#endif +#if defined(__acorn) && defined(__riscos) +#define __acornriscos +#endif + +#if defined(__MWERKS__) || defined(THINK_C) +#include +#include +#endif + +#include + +#if defined(__PPCC__) || defined(__SC__) || defined(__MRC__) +#include +#elif !defined(__MWERKS__) && !defined(THINK_C) && !defined(__acornriscos) && !defined(applec) +#include +#endif + +#if defined(VMS) +#include +#include +#elif !defined(__acornriscos) +#include +#endif + +/* + * This maze of checks controls defines or not the + * target system has BSD-style typdedefs declared in + * an include file and/or whether or not to include + * to get the SEEK_* definitions. Some + * additional includes are also done to pull in the + * appropriate definitions we're looking for. + */ +#if defined(__MWERKS__) || defined(THINK_C) || defined(__PPCC__) || defined(__SC__) || defined(__MRC__) +#include +#define BSDTYPES +#define HAVE_UNISTD_H 0 +#elif defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows) +#define BSDTYPES +#elif defined(OS2_16) || defined(OS2_32) +#define BSDTYPES +#elif defined(__acornriscos) +#include +#define BSDTYPES +#define HAVE_UNISTD_H 0 +#elif defined(VMS) +#define HAVE_UNISTD_H 0 +#else +#define HAVE_UNISTD_H 1 +#endif + +/* + * The library uses the ANSI C/POSIX SEEK_* + * definitions that should be defined in unistd.h + * (except on system where they are in stdio.h and + * there is no unistd.h). + */ +#if !defined(SEEK_SET) && HAVE_UNISTD_H +#include +#endif + +/* + * The library uses memset, memcpy, and memcmp. + * ANSI C and System V define these in string.h. + */ +#include + +/* + * The BSD typedefs are used throughout the library. + * If your system doesn't have them in , + * then define BSDTYPES in your Makefile. + */ +#if defined(BSDTYPES) +typedef unsigned char u_char; +typedef unsigned short u_short; +typedef unsigned int u_int; +typedef unsigned long u_long; +#endif + +/* + * dblparam_t is the type that a double precision + * floating point value will have on the parameter + * stack (when coerced by the compiler). + */ +/* Note: on MacPowerPC "extended" is undefined. So only use it for 68K-Macs */ +#if defined(__SC__) || defined(THINK_C) +typedef extended dblparam_t; +#else +typedef double dblparam_t; +#endif + +/* + * If your compiler supports inline functions, then + * set INLINE appropriately to get the known hotspots + * in the library expanded inline. + */ +#if defined(__GNUC__) +#if defined(__STRICT_ANSI__) +#define INLINE __inline__ +#else +#define INLINE inline +#endif +#else /* !__GNUC__ */ +#define INLINE +#endif + +/* + * GLOBALDATA is a macro that is used to define global variables + * private to the library. We use this indirection to hide + * brain-damage in VAXC (and GCC) under VAX/VMS. In these + * environments the macro places the variable in a non-shareable + * program section, which ought to be done by default (sigh!) + * + * Apparently DEC are aware of the problem as this behaviour is the + * default under VMS on AXP. + * + * The GNU C variant is untested. + */ +#if defined(VAX) && defined(VMS) +#if defined(VAXC) +#define GLOBALDATA(TYPE,NAME) extern noshare TYPE NAME +#endif +#if defined(__GNUC__) +#define GLOBALDATA(TYPE,NAME) extern TYPE NAME \ + asm("_$$PsectAttributes_NOSHR$$" #NAME) +#endif +#else /* !VAX/VMS */ +#define GLOBALDATA(TYPE,NAME) extern TYPE NAME +#endif + +#if defined(__acornriscos) +/* + * osfcn.h is part of C++Lib on Acorn C/C++, and as such can't be used + * on C alone. For that reason, the relevant functions are + * implemented in tif_acorn.c, and the elements from the header + * file are included here. + */ +#if defined(__cplusplus) +#include +#else +#define O_RDONLY 0 +#define O_WRONLY 1 +#define O_RDWR 2 +#define O_APPEND 8 +#define O_CREAT 0x200 +#define O_TRUNC 0x400 +typedef long off_t; +extern int open(const char *name, int flags, int mode); +extern int close(int fd); +extern int write(int fd, const char *buf, int nbytes); +extern int read(int fd, char *buf, int nbytes); +extern off_t lseek(int fd, off_t offset, int whence); +extern int creat(const char *path, int mode); +#endif /* __cplusplus */ +#endif /* __acornriscos */ + +/* Bit and byte order, the default is MSB to LSB */ +#ifdef VMS +#undef HOST_FILLORDER +#undef HOST_BIGENDIAN +#define HOST_FILLORDER FILLORDER_LSB2MSB +#define HOST_BIGENDIAN 0 +#endif + + +#endif /* _COMPAT_ */ diff --git a/libs/libtiff/Tiffconf.h b/libs/libtiff/Tiffconf.h new file mode 100644 index 00000000..c1215507 --- /dev/null +++ b/libs/libtiff/Tiffconf.h @@ -0,0 +1,131 @@ +/* $Header: /usr/people/sam/tiff/libtiff/RCS/tiffconf.h,v 1.13 1996/04/05 17:36:53 sam Rel $ */ +/* + * Copyright (c) 1988-1996 Sam Leffler + * Copyright (c) 1991-1996 Silicon Graphics, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that (i) the above copyright notices and this permission notice appear in + * all copies of the software and related documentation, and (ii) the names of + * Sam Leffler and Silicon Graphics may not be used in any advertising or + * publicity relating to the software without the specific, prior written + * permission of Sam Leffler and Silicon Graphics. + * + * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, + * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY + * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. + * + * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR + * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, + * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, + * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF + * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef _TIFFCONF_ +#define _TIFFCONF_ +/* + * Library Configuration Definitions. + * + * This file defines the default configuration for the library. + * If the target system does not have make or a way to specify + * #defines on the command line, this file can be edited to + * configure the library. Otherwise, one can override portability + * and configuration-related definitions from a Makefile or command + * line by defining FEATURE_SUPPORT and COMPRESSION_SUPPORT (see below). + */ + +/* + * General portability-related defines: + * + * HAVE_IEEEFP define as 0 or 1 according to the floating point + * format suported by the machine + * BSDTYPES define this if your system does NOT define the + * usual 4BSD typedefs u_int et. al. + * HAVE_MMAP enable support for memory mapping read-only files; + * this is typically deduced by the configure script + * HOST_FILLORDER native cpu bit order: one of FILLORDER_MSB2LSB + * or FILLODER_LSB2MSB; this is typically set by the + * configure script + * HOST_BIGENDIAN native cpu byte order: 1 if big-endian (Motorola) + * or 0 if little-endian (Intel); this may be used + * in codecs to optimize code + */ +#ifndef HAVE_IEEEFP +#define HAVE_IEEEFP 1 +#endif +#ifndef HOST_FILLORDER +#define HOST_FILLORDER FILLORDER_MSB2LSB +#endif +#ifndef HOST_BIGENDIAN +#define HOST_BIGENDIAN 1 +#endif + +#ifndef FEATURE_SUPPORT +/* + * Feature support definitions: + * + * COLORIMETRY_SUPPORT enable support for 6.0 colorimetry tags + * YCBCR_SUPPORT enable support for 6.0 YCbCr tags + * CMYK_SUPPORT enable support for 6.0 CMYK tags + */ +#define COLORIMETRY_SUPPORT +#define YCBCR_SUPPORT +#define CMYK_SUPPORT +#endif /* FEATURE_SUPPORT */ + +#ifndef COMPRESSION_SUPPORT +/* + * Compression support defines: + * + * CCITT_SUPPORT enable support for CCITT Group 3 & 4 algorithms + * PACKBITS_SUPPORT enable support for Macintosh PackBits algorithm + * LZW_SUPPORT enable support for LZW algorithm + * THUNDER_SUPPORT enable support for ThunderScan 4-bit RLE algorithm + * NEXT_SUPPORT enable support for NeXT 2-bit RLE algorithm + * OJPEG_SUPPORT enable support for 6.0-style JPEG DCT algorithms + * (no builtin support, only a codec hook) + * JPEG_SUPPORT enable support for post-6.0-style JPEG DCT algorithms + * (requires freely available IJG software, see tif_jpeg.c) + * ZIP_SUPPORT enable support for Deflate algorithm + * (requires freely available zlib software, see tif_zip.c) + * PIXARLOG_SUPPORT enable support for Pixar log-format algorithm + */ +/* doesn't work with Windows makefile??? */ +#if 0 +#define CCITT_SUPPORT +#endif +#define PACKBITS_SUPPORT +#define LZW_SUPPORT +#define THUNDER_SUPPORT +#define NEXT_SUPPORT +#endif /* COMPRESSION_SUPPORT */ + +/* + * If JPEG compression is enabled then we must also include + * support for the colorimetry and YCbCr-related tags. + */ +#ifdef JPEG_SUPPORT +#ifndef YCBCR_SUPPORT +#define YCBCR_SUPPORT +#endif +#ifndef COLORIMETRY_SUPPORT +#define COLORIMETRY_SUPPORT +#endif +#endif /* JPEG_SUPPORT */ + +/* + * ``Orthogonal Features'' + * + * STRIPCHOP_SUPPORT automatically convert single-strip uncompressed images + * to mutiple strips of ~8Kb (for reducing memory use) + * SUBIFD_SUPPORT enable support for SubIFD tag (thumbnails and such) + */ +#ifndef STRIPCHOP_SUPPORT +#define STRIPCHOP_SUPPORT 1 /* enable strip chopping */ +#endif +#ifndef SUBIFD_SUPPORT +#define SUBIFD_SUPPORT 1 /* enable SubIFD tag (330) support */ +#endif +#endif /* _TIFFCONF_ */ diff --git a/libs/libtiff/Tiffiop.h b/libs/libtiff/Tiffiop.h new file mode 100644 index 00000000..e4ffc59b --- /dev/null +++ b/libs/libtiff/Tiffiop.h @@ -0,0 +1,287 @@ +/* $Header: /usr/people/sam/tiff/libtiff/RCS/tiffiop.h,v 1.80 1996/04/05 17:36:53 sam Rel $ */ + +/* + * Copyright (c) 1988-1996 Sam Leffler + * Copyright (c) 1991-1996 Silicon Graphics, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that (i) the above copyright notices and this permission notice appear in + * all copies of the software and related documentation, and (ii) the names of + * Sam Leffler and Silicon Graphics may not be used in any advertising or + * publicity relating to the software without the specific, prior written + * permission of Sam Leffler and Silicon Graphics. + * + * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, + * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY + * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. + * + * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR + * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, + * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, + * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF + * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef _TIFFIOP_ +#define _TIFFIOP_ +/* + * ``Library-private'' definitions. + */ +/* + * UNIX systems should run the configure script to generate + * a port.h file that reflects the system capabilities. + * Doing this obviates all the dreck done in tiffcomp.h. + */ +#if defined(unix) || defined(__unix) +#include "port.h" +#include "tiffconf.h" +#else +#include "tiffconf.h" +#include "tiffcomp.h" +#endif +#include "tiffio.h" +#include "tif_dir.h" + +#ifndef TRUE +#define TRUE 1 +#define FALSE 0 +#endif + +/* + * Typedefs for ``method pointers'' used internally. + */ +typedef unsigned char tidataval_t; /* internal image data value type */ +typedef tidataval_t* tidata_t; /* reference to internal image data */ + +typedef void (*TIFFVoidMethod)(TIFF*); +typedef int (*TIFFBoolMethod)(TIFF*); +typedef int (*TIFFPreMethod)(TIFF*, tsample_t); +typedef int (*TIFFCodeMethod)(TIFF*, tidata_t, tsize_t, tsample_t); +typedef int (*TIFFSeekMethod)(TIFF*, uint32); +typedef void (*TIFFPostMethod)(TIFF*, tidata_t, tsize_t); +typedef int (*TIFFVSetMethod)(TIFF*, ttag_t, va_list); +typedef int (*TIFFVGetMethod)(TIFF*, ttag_t, va_list); +typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long); +typedef uint32 (*TIFFStripMethod)(TIFF*, uint32); +typedef void (*TIFFTileMethod)(TIFF*, uint32*, uint32*); + +struct tiff { + char* tif_name; /* name of open file */ + int tif_fd; /* open file descriptor */ + int tif_mode; /* open mode (O_*) */ + uint32 tif_flags; +#define TIFF_FILLORDER 0x0003 /* natural bit fill order for machine */ +#define TIFF_DIRTYHEADER 0x0004 /* header must be written on close */ +#define TIFF_DIRTYDIRECT 0x0008 /* current directory must be written */ +#define TIFF_BUFFERSETUP 0x0010 /* data buffers setup */ +#define TIFF_CODERSETUP 0x0020 /* encoder/decoder setup done */ +#define TIFF_BEENWRITING 0x0040 /* written 1+ scanlines to file */ +#define TIFF_SWAB 0x0080 /* byte swap file information */ +#define TIFF_NOBITREV 0x0100 /* inhibit bit reversal logic */ +#define TIFF_MYBUFFER 0x0200 /* my raw data buffer; free on close */ +#define TIFF_ISTILED 0x0400 /* file is tile, not strip- based */ +#define TIFF_MAPPED 0x0800 /* file is mapped into memory */ +#define TIFF_POSTENCODE 0x1000 /* need call to postencode routine */ +#define TIFF_INSUBIFD 0x2000 /* currently writing a subifd */ +#define TIFF_UPSAMPLED 0x4000 /* library is doing data up-sampling */ +#define TIFF_STRIPCHOP 0x8000 /* enable strip chopping support */ + toff_t tif_diroff; /* file offset of current directory */ + toff_t tif_nextdiroff; /* file offset of following directory */ + TIFFDirectory tif_dir; /* internal rep of current directory */ + TIFFHeader tif_header; /* file's header block */ + tidata_t tif_clientdir; /* client TIFF directory */ + const int* tif_typeshift; /* data type shift counts */ + const long* tif_typemask; /* data type masks */ + uint32 tif_row; /* current scanline */ + tdir_t tif_curdir; /* current directory (index) */ + tstrip_t tif_curstrip; /* current strip for read/write */ + toff_t tif_curoff; /* current offset for read/write */ + toff_t tif_dataoff; /* current offset for writing dir */ +#if SUBIFD_SUPPORT + uint16 tif_nsubifd; /* remaining subifds to write */ + toff_t tif_subifdoff; /* offset for patching SubIFD link */ +#endif +/* tiling support */ + uint32 tif_col; /* current column (offset by row too) */ + ttile_t tif_curtile; /* current tile for read/write */ + tsize_t tif_tilesize; /* # of bytes in a tile */ +/* compression scheme hooks */ + TIFFBoolMethod tif_setupdecode;/* called once before predecode */ + TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */ + TIFFBoolMethod tif_setupencode;/* called once before preencode */ + TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */ + TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */ + TIFFCodeMethod tif_decoderow; /* scanline decoding routine */ + TIFFCodeMethod tif_encoderow; /* scanline encoding routine */ + TIFFCodeMethod tif_decodestrip;/* strip decoding routine */ + TIFFCodeMethod tif_encodestrip;/* strip encoding routine */ + TIFFCodeMethod tif_decodetile; /* tile decoding routine */ + TIFFCodeMethod tif_encodetile; /* tile encoding routine */ + TIFFVoidMethod tif_close; /* cleanup-on-close routine */ + TIFFSeekMethod tif_seek; /* position within a strip routine */ + TIFFVoidMethod tif_cleanup; /* cleanup state routine */ + TIFFStripMethod tif_defstripsize;/* calculate/constrain strip size */ + TIFFTileMethod tif_deftilesize;/* calculate/constrain tile size */ + tidata_t tif_data; /* compression scheme private data */ +/* input/output buffering */ + tsize_t tif_scanlinesize;/* # of bytes in a scanline */ + tsize_t tif_scanlineskew;/* scanline skew for reading strips */ + tidata_t tif_rawdata; /* raw data buffer */ + tsize_t tif_rawdatasize;/* # of bytes in raw data buffer */ + tidata_t tif_rawcp; /* current spot in raw buffer */ + tsize_t tif_rawcc; /* bytes unread from raw buffer */ +/* memory-mapped file support */ + tidata_t tif_base; /* base of mapped file */ +#ifdef __WIN32__ + void* pv_map_handle; /* WIN32 file mapping handle; + * must be contiguous with tif_base + * since map & unmap only get tif_base + * and assume 4 byte offset to + * pv_map_handle. */ +#endif + toff_t tif_size; /* size of mapped file region (bytes) */ + TIFFMapFileProc tif_mapproc; /* map file method */ + TIFFUnmapFileProc tif_unmapproc;/* unmap file method */ +/* input/output callback methods */ + thandle_t tif_clientdata; /* callback parameter */ + TIFFReadWriteProc tif_readproc; /* read method */ + TIFFReadWriteProc tif_writeproc;/* write method */ + TIFFSeekProc tif_seekproc; /* lseek method */ + TIFFCloseProc tif_closeproc; /* close method */ + TIFFSizeProc tif_sizeproc; /* filesize method */ +/* post-decoding support */ + TIFFPostMethod tif_postdecode; /* post decoding routine */ +/* tag support */ + TIFFFieldInfo** tif_fieldinfo; /* sorted table of registered tags */ + int tif_nfields; /* # entries in registered tag table */ + TIFFVSetMethod tif_vsetfield; /* tag set routine */ + TIFFVGetMethod tif_vgetfield; /* tag get routine */ + TIFFPrintMethod tif_printdir; /* directory print routine */ +}; + +#define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */ + +#define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0) +#define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0) +#define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0) +#define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0) +#define TIFFReadFile(tif, buf, size) \ + ((*(tif)->tif_readproc)((tif)->tif_clientdata,buf,size)) +#define TIFFWriteFile(tif, buf, size) \ + ((*(tif)->tif_writeproc)((tif)->tif_clientdata,buf,size)) +#define TIFFSeekFile(tif, off, whence) \ + ((*(tif)->tif_seekproc)((tif)->tif_clientdata,(toff_t)(off),whence)) +#define TIFFCloseFile(tif) \ + ((*(tif)->tif_closeproc)((tif)->tif_clientdata)) +#define TIFFGetFileSize(tif) \ + ((*(tif)->tif_sizeproc)((tif)->tif_clientdata)) +#define TIFFMapFileContents(tif, paddr, psize) \ + ((*(tif)->tif_mapproc)((tif)->tif_clientdata,paddr,psize)) +#ifdef __WIN32__ +#define TIFFUnmapFileContents(tif, addr, dummy) \ + ((*(tif)->tif_unmapproc)((tif)->tif_clientdata,addr,\ + (toff_t)(tif)->pv_map_handle)) +#else +#define TIFFUnmapFileContents(tif, addr, size) \ + ((*(tif)->tif_unmapproc)((tif)->tif_clientdata,addr,size)) +#endif + +/* + * Default Read/Seek/Write definitions. + */ +#ifndef ReadOK +#define ReadOK(tif, buf, size) \ + (TIFFReadFile(tif, (tdata_t) buf, (tsize_t) size) == (tsize_t) size) +#endif +#ifndef SeekOK +#define SeekOK(tif, off) \ + (TIFFSeekFile(tif, (toff_t) off, SEEK_SET) == (toff_t) off) +#endif +#ifndef WriteOK +#define WriteOK(tif, buf, size) \ + (TIFFWriteFile(tif, (tdata_t) buf, (tsize_t) size) == (tsize_t) size) +#endif + +/* NB: the uint32 casts are to silence certain ANSI-C compilers */ +#define TIFFhowmany(x, y) ((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y))) +#define TIFFroundup(x, y) (TIFFhowmany(x,y)*((uint32)(y))) + +#if defined(__cplusplus) +extern "C" { +#endif +extern int _TIFFgetMode(const char*, const char*); +extern int _TIFFNoRowEncode(TIFF*, tidata_t, tsize_t, tsample_t); +extern int _TIFFNoStripEncode(TIFF*, tidata_t, tsize_t, tsample_t); +extern int _TIFFNoTileEncode(TIFF*, tidata_t, tsize_t, tsample_t); +extern int _TIFFNoRowDecode(TIFF*, tidata_t, tsize_t, tsample_t); +extern int _TIFFNoStripDecode(TIFF*, tidata_t, tsize_t, tsample_t); +extern int _TIFFNoTileDecode(TIFF*, tidata_t, tsize_t, tsample_t); +extern void _TIFFNoPostDecode(TIFF*, tidata_t, tsize_t); +extern int _TIFFNoSeek(TIFF*, uint32); +extern void _TIFFSwab16BitData(TIFF*, tidata_t, tsize_t); +extern void _TIFFSwab32BitData(TIFF*, tidata_t, tsize_t); +extern void _TIFFSwab64BitData(TIFF*, tidata_t, tsize_t); +extern int TIFFFlushData1(TIFF*); +extern void TIFFFreeDirectory(TIFF*); +extern int TIFFDefaultDirectory(TIFF*); +extern int TIFFSetCompressionScheme(TIFF*, int); +extern uint32 _TIFFDefaultStripSize(TIFF*, uint32); +extern void _TIFFDefaultTileSize(TIFF*, uint32*, uint32*); + +extern void _TIFFsetByteArray(void**, void*, long); +extern void _TIFFsetString(char**, char*); +extern void _TIFFsetShortArray(uint16**, uint16*, long); +extern void _TIFFsetLongArray(uint32**, uint32*, long); +extern void _TIFFsetFloatArray(float**, float*, long); +extern void _TIFFsetDoubleArray(double**, double*, long); + +extern void _TIFFprintAscii(FILE*, const char*); +extern void _TIFFprintAsciiTag(FILE*, const char*, const char*); + +GLOBALDATA(TIFFErrorHandler,_TIFFwarningHandler); +GLOBALDATA(TIFFErrorHandler,_TIFFerrorHandler); + +extern int TIFFInitDumpMode(TIFF*, int); +#ifdef PACKBITS_SUPPORT +extern int TIFFInitPackBits(TIFF*, int); +#endif +#ifdef CCITT_SUPPORT +extern int TIFFInitCCITTRLE(TIFF*, int), TIFFInitCCITTRLEW(TIFF*, int); +extern int TIFFInitCCITTFax3(TIFF*, int), TIFFInitCCITTFax4(TIFF*, int); +#endif +#ifdef THUNDER_SUPPORT +extern int TIFFInitThunderScan(TIFF*, int); +#endif +#ifdef NEXT_SUPPORT +extern int TIFFInitNeXT(TIFF*, int); +#endif +#ifdef LZW_SUPPORT +extern int TIFFInitLZW(TIFF*, int); +#endif +#ifdef OJPEG_SUPPORT +extern int TIFFInitOJPEG(TIFF*, int); +#endif +#ifdef JPEG_SUPPORT +extern int TIFFInitJPEG(TIFF*, int); +#endif +#ifdef JBIG_SUPPORT +extern int TIFFInitJBIG(TIFF*, int); +#endif +#ifdef ZIP_SUPPORT +extern int TIFFInitZIP(TIFF*, int); +#endif +#ifdef PIXARLOG_SUPPORT +extern int TIFFInitPixarLog(TIFF*, int); +#endif +#ifdef VMS +extern const TIFFCodec _TIFFBuiltinCODECS[]; +#else +extern TIFFCodec _TIFFBuiltinCODECS[]; +#endif + +#if defined(__cplusplus) +} +#endif +#endif /* _TIFFIOP_ */ diff --git a/libs/libtiff/Version.h b/libs/libtiff/Version.h new file mode 100644 index 00000000..11b9435c --- /dev/null +++ b/libs/libtiff/Version.h @@ -0,0 +1 @@ +#define VERSION "LIBTIFF, Version 3.4beta024\nCopyright (c) 1988-1995 Sam Leffler\nCopyright (c) 1991-1995 Silicon Graphics, Inc." diff --git a/libs/libtiff/libtiff.lib b/libs/libtiff/libtiff.lib new file mode 100644 index 0000000000000000000000000000000000000000..224b1e8d250857da3770d8cb59973660a69dd94a GIT binary patch literal 229770 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 literal 0 HcmV?d00001 diff --git a/libs/libtiff/tiff.h b/libs/libtiff/tiff.h new file mode 100644 index 00000000..d6e146e7 --- /dev/null +++ b/libs/libtiff/tiff.h @@ -0,0 +1,380 @@ +/* $Header: /usr/people/sam/tiff/libtiff/RCS/tiff.h,v 1.71 1996/04/29 22:16:05 sam Rel $ */ + +/* + * Copyright (c) 1988-1996 Sam Leffler + * Copyright (c) 1991-1996 Silicon Graphics, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that (i) the above copyright notices and this permission notice appear in + * all copies of the software and related documentation, and (ii) the names of + * Sam Leffler and Silicon Graphics may not be used in any advertising or + * publicity relating to the software without the specific, prior written + * permission of Sam Leffler and Silicon Graphics. + * + * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, + * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY + * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. + * + * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR + * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, + * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, + * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF + * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef _TIFF_ +#define _TIFF_ +/* + * Tag Image File Format (TIFF) + * + * Based on Rev 6.0 from: + * Developer's Desk + * Aldus Corporation + * 411 First Ave. South + * Suite 200 + * Seattle, WA 98104 + * 206-622-5500 + */ +#define TIFF_VERSION 42 + +#define TIFF_BIGENDIAN 0x4d4d +#define TIFF_LITTLEENDIAN 0x4949 + +#ifndef _TIFF_DATA_TYPEDEFS_ +#define _TIFF_DATA_TYPEDEFS_ +/* + * Intrinsic data types required by the file format: + * + * 8-bit quantities int8/uint8 + * 16-bit quantities int16/uint16 + * 32-bit quantities int32/uint32 + * strings unsigned char* + */ +#ifdef __STDC__ +typedef signed char int8; /* NB: non-ANSI compilers may not grok */ +#else +typedef char int8; +#endif +typedef unsigned char uint8; +typedef short int16; +typedef unsigned short uint16; /* sizeof (uint16) must == 2 */ +#if defined(__alpha) || (defined(_MIPS_SZLONG) && _MIPS_SZLONG == 64) +typedef int int32; +typedef unsigned int uint32; /* sizeof (uint32) must == 4 */ +#else +typedef long int32; +typedef unsigned long uint32; /* sizeof (uint32) must == 4 */ +#endif +#endif /* _TIFF_DATA_TYPEDEFS_ */ + +typedef struct { + uint16 tiff_magic; /* magic number (defines byte order) */ + uint16 tiff_version; /* TIFF version number */ + uint32 tiff_diroff; /* byte offset to first directory */ +} TIFFHeader; + +/* + * TIFF Image File Directories are comprised of + * a table of field descriptors of the form shown + * below. The table is sorted in ascending order + * by tag. The values associated with each entry + * are disjoint and may appear anywhere in the file + * (so long as they are placed on a word boundary). + * + * If the value is 4 bytes or less, then it is placed + * in the offset field to save space. If the value + * is less than 4 bytes, it is left-justified in the + * offset field. + */ +typedef struct { + uint16 tdir_tag; /* see below */ + uint16 tdir_type; /* data type; see below */ + uint32 tdir_count; /* number of items; length in spec */ + uint32 tdir_offset; /* byte offset to field data */ +} TIFFDirEntry; + +/* + * NB: In the comments below, + * - items marked with a + are obsoleted by revision 5.0, + * - items marked with a ! are introduced in revision 6.0. + * - items marked with a % are introduced post revision 6.0. + * - items marked with a $ are obsoleted by revision 6.0. + */ + +/* + * Tag data type information. + * + * Note: RATIONALs are the ratio of two 32-bit integer values. + */ +typedef enum { + TIFF_NOTYPE = 0, /* placeholder */ + TIFF_BYTE = 1, /* 8-bit unsigned integer */ + TIFF_ASCII = 2, /* 8-bit bytes w/ last byte null */ + TIFF_SHORT = 3, /* 16-bit unsigned integer */ + TIFF_LONG = 4, /* 32-bit unsigned integer */ + TIFF_RATIONAL = 5, /* 64-bit unsigned fraction */ + TIFF_SBYTE = 6, /* !8-bit signed integer */ + TIFF_UNDEFINED = 7, /* !8-bit untyped data */ + TIFF_SSHORT = 8, /* !16-bit signed integer */ + TIFF_SLONG = 9, /* !32-bit signed integer */ + TIFF_SRATIONAL = 10, /* !64-bit signed fraction */ + TIFF_FLOAT = 11, /* !32-bit IEEE floating point */ + TIFF_DOUBLE = 12 /* !64-bit IEEE floating point */ +} TIFFDataType; + +/* + * TIFF Tag Definitions. + */ +#define TIFFTAG_SUBFILETYPE 254 /* subfile data descriptor */ +#define FILETYPE_REDUCEDIMAGE 0x1 /* reduced resolution version */ +#define FILETYPE_PAGE 0x2 /* one page of many */ +#define FILETYPE_MASK 0x4 /* transparency mask */ +#define TIFFTAG_OSUBFILETYPE 255 /* +kind of data in subfile */ +#define OFILETYPE_IMAGE 1 /* full resolution image data */ +#define OFILETYPE_REDUCEDIMAGE 2 /* reduced size image data */ +#define OFILETYPE_PAGE 3 /* one page of many */ +#define TIFFTAG_IMAGEWIDTH 256 /* image width in pixels */ +#define TIFFTAG_IMAGELENGTH 257 /* image height in pixels */ +#define TIFFTAG_BITSPERSAMPLE 258 /* bits per channel (sample) */ +#define TIFFTAG_COMPRESSION 259 /* data compression technique */ +#define COMPRESSION_NONE 1 /* dump mode */ +#define COMPRESSION_CCITTRLE 2 /* CCITT modified Huffman RLE */ +#define COMPRESSION_CCITTFAX3 3 /* CCITT Group 3 fax encoding */ +#define COMPRESSION_CCITTFAX4 4 /* CCITT Group 4 fax encoding */ +#define COMPRESSION_LZW 5 /* Lempel-Ziv & Welch */ +#define COMPRESSION_OJPEG 6 /* !6.0 JPEG */ +#define COMPRESSION_JPEG 7 /* %JPEG DCT compression */ +#define COMPRESSION_NEXT 32766 /* NeXT 2-bit RLE */ +#define COMPRESSION_CCITTRLEW 32771 /* #1 w/ word alignment */ +#define COMPRESSION_PACKBITS 32773 /* Macintosh RLE */ +#define COMPRESSION_THUNDERSCAN 32809 /* ThunderScan RLE */ +/* compression codes 32908-32911 are reserved for Pixar */ +#define COMPRESSION_PIXARFILM 32908 /* Pixar companded 10bit LZW */ +#define COMPRESSION_PIXARLOG 32909 /* Pixar companded 11bit ZIP */ +#define COMPRESSION_DEFLATE 32946 /* Deflate compression */ +/* compression code 32947 is reserved for Oceana Matrix */ +#define COMPRESSION_DCS 32947 /* Kodak DCS encoding */ +#define COMPRESSION_JBIG 34661 /* ISO JBIG */ +#define TIFFTAG_PHOTOMETRIC 262 /* photometric interpretation */ +#define PHOTOMETRIC_MINISWHITE 0 /* min value is white */ +#define PHOTOMETRIC_MINISBLACK 1 /* min value is black */ +#define PHOTOMETRIC_RGB 2 /* RGB color model */ +#define PHOTOMETRIC_PALETTE 3 /* color map indexed */ +#define PHOTOMETRIC_MASK 4 /* $holdout mask */ +#define PHOTOMETRIC_SEPARATED 5 /* !color separations */ +#define PHOTOMETRIC_YCBCR 6 /* !CCIR 601 */ +#define PHOTOMETRIC_CIELAB 8 /* !1976 CIE L*a*b* */ +#define TIFFTAG_THRESHHOLDING 263 /* +thresholding used on data */ +#define THRESHHOLD_BILEVEL 1 /* b&w art scan */ +#define THRESHHOLD_HALFTONE 2 /* or dithered scan */ +#define THRESHHOLD_ERRORDIFFUSE 3 /* usually floyd-steinberg */ +#define TIFFTAG_CELLWIDTH 264 /* +dithering matrix width */ +#define TIFFTAG_CELLLENGTH 265 /* +dithering matrix height */ +#define TIFFTAG_FILLORDER 266 /* data order within a byte */ +#define FILLORDER_MSB2LSB 1 /* most significant -> least */ +#define FILLORDER_LSB2MSB 2 /* least significant -> most */ +#define TIFFTAG_DOCUMENTNAME 269 /* name of doc. image is from */ +#define TIFFTAG_IMAGEDESCRIPTION 270 /* info about image */ +#define TIFFTAG_MAKE 271 /* scanner manufacturer name */ +#define TIFFTAG_MODEL 272 /* scanner model name/number */ +#define TIFFTAG_STRIPOFFSETS 273 /* offsets to data strips */ +#define TIFFTAG_ORIENTATION 274 /* +image orientation */ +#define ORIENTATION_TOPLEFT 1 /* row 0 top, col 0 lhs */ +#define ORIENTATION_TOPRIGHT 2 /* row 0 top, col 0 rhs */ +#define ORIENTATION_BOTRIGHT 3 /* row 0 bottom, col 0 rhs */ +#define ORIENTATION_BOTLEFT 4 /* row 0 bottom, col 0 lhs */ +#define ORIENTATION_LEFTTOP 5 /* row 0 lhs, col 0 top */ +#define ORIENTATION_RIGHTTOP 6 /* row 0 rhs, col 0 top */ +#define ORIENTATION_RIGHTBOT 7 /* row 0 rhs, col 0 bottom */ +#define ORIENTATION_LEFTBOT 8 /* row 0 lhs, col 0 bottom */ +#define TIFFTAG_SAMPLESPERPIXEL 277 /* samples per pixel */ +#define TIFFTAG_ROWSPERSTRIP 278 /* rows per strip of data */ +#define TIFFTAG_STRIPBYTECOUNTS 279 /* bytes counts for strips */ +#define TIFFTAG_MINSAMPLEVALUE 280 /* +minimum sample value */ +#define TIFFTAG_MAXSAMPLEVALUE 281 /* +maximum sample value */ +#define TIFFTAG_XRESOLUTION 282 /* pixels/resolution in x */ +#define TIFFTAG_YRESOLUTION 283 /* pixels/resolution in y */ +#define TIFFTAG_PLANARCONFIG 284 /* storage organization */ +#define PLANARCONFIG_CONTIG 1 /* single image plane */ +#define PLANARCONFIG_SEPARATE 2 /* separate planes of data */ +#define TIFFTAG_PAGENAME 285 /* page name image is from */ +#define TIFFTAG_XPOSITION 286 /* x page offset of image lhs */ +#define TIFFTAG_YPOSITION 287 /* y page offset of image lhs */ +#define TIFFTAG_FREEOFFSETS 288 /* +byte offset to free block */ +#define TIFFTAG_FREEBYTECOUNTS 289 /* +sizes of free blocks */ +#define TIFFTAG_GRAYRESPONSEUNIT 290 /* $gray scale curve accuracy */ +#define GRAYRESPONSEUNIT_10S 1 /* tenths of a unit */ +#define GRAYRESPONSEUNIT_100S 2 /* hundredths of a unit */ +#define GRAYRESPONSEUNIT_1000S 3 /* thousandths of a unit */ +#define GRAYRESPONSEUNIT_10000S 4 /* ten-thousandths of a unit */ +#define GRAYRESPONSEUNIT_100000S 5 /* hundred-thousandths */ +#define TIFFTAG_GRAYRESPONSECURVE 291 /* $gray scale response curve */ +#define TIFFTAG_GROUP3OPTIONS 292 /* 32 flag bits */ +#define GROUP3OPT_2DENCODING 0x1 /* 2-dimensional coding */ +#define GROUP3OPT_UNCOMPRESSED 0x2 /* data not compressed */ +#define GROUP3OPT_FILLBITS 0x4 /* fill to byte boundary */ +#define TIFFTAG_GROUP4OPTIONS 293 /* 32 flag bits */ +#define GROUP4OPT_UNCOMPRESSED 0x2 /* data not compressed */ +#define TIFFTAG_RESOLUTIONUNIT 296 /* units of resolutions */ +#define RESUNIT_NONE 1 /* no meaningful units */ +#define RESUNIT_INCH 2 /* english */ +#define RESUNIT_CENTIMETER 3 /* metric */ +#define TIFFTAG_PAGENUMBER 297 /* page numbers of multi-page */ +#define TIFFTAG_COLORRESPONSEUNIT 300 /* $color curve accuracy */ +#define COLORRESPONSEUNIT_10S 1 /* tenths of a unit */ +#define COLORRESPONSEUNIT_100S 2 /* hundredths of a unit */ +#define COLORRESPONSEUNIT_1000S 3 /* thousandths of a unit */ +#define COLORRESPONSEUNIT_10000S 4 /* ten-thousandths of a unit */ +#define COLORRESPONSEUNIT_100000S 5 /* hundred-thousandths */ +#define TIFFTAG_TRANSFERFUNCTION 301 /* !colorimetry info */ +#define TIFFTAG_SOFTWARE 305 /* name & release */ +#define TIFFTAG_DATETIME 306 /* creation date and time */ +#define TIFFTAG_ARTIST 315 /* creator of image */ +#define TIFFTAG_HOSTCOMPUTER 316 /* machine where created */ +#define TIFFTAG_PREDICTOR 317 /* prediction scheme w/ LZW */ +#define TIFFTAG_WHITEPOINT 318 /* image white point */ +#define TIFFTAG_PRIMARYCHROMATICITIES 319 /* !primary chromaticities */ +#define TIFFTAG_COLORMAP 320 /* RGB map for pallette image */ +#define TIFFTAG_HALFTONEHINTS 321 /* !highlight+shadow info */ +#define TIFFTAG_TILEWIDTH 322 /* !rows/data tile */ +#define TIFFTAG_TILELENGTH 323 /* !cols/data tile */ +#define TIFFTAG_TILEOFFSETS 324 /* !offsets to data tiles */ +#define TIFFTAG_TILEBYTECOUNTS 325 /* !byte counts for tiles */ +#define TIFFTAG_BADFAXLINES 326 /* lines w/ wrong pixel count */ +#define TIFFTAG_CLEANFAXDATA 327 /* regenerated line info */ +#define CLEANFAXDATA_CLEAN 0 /* no errors detected */ +#define CLEANFAXDATA_REGENERATED 1 /* receiver regenerated lines */ +#define CLEANFAXDATA_UNCLEAN 2 /* uncorrected errors exist */ +#define TIFFTAG_CONSECUTIVEBADFAXLINES 328 /* max consecutive bad lines */ +#define TIFFTAG_SUBIFD 330 /* subimage descriptors */ +#define TIFFTAG_INKSET 332 /* !inks in separated image */ +#define INKSET_CMYK 1 /* !cyan-magenta-yellow-black */ +#define TIFFTAG_INKNAMES 333 /* !ascii names of inks */ +#define TIFFTAG_DOTRANGE 336 /* !0% and 100% dot codes */ +#define TIFFTAG_TARGETPRINTER 337 /* !separation target */ +#define TIFFTAG_EXTRASAMPLES 338 /* !info about extra samples */ +#define EXTRASAMPLE_UNSPECIFIED 0 /* !unspecified data */ +#define EXTRASAMPLE_ASSOCALPHA 1 /* !associated alpha data */ +#define EXTRASAMPLE_UNASSALPHA 2 /* !unassociated alpha data */ +#define TIFFTAG_SAMPLEFORMAT 339 /* !data sample format */ +#define SAMPLEFORMAT_UINT 1 /* !unsigned integer data */ +#define SAMPLEFORMAT_INT 2 /* !signed integer data */ +#define SAMPLEFORMAT_IEEEFP 3 /* !IEEE floating point data */ +#define SAMPLEFORMAT_VOID 4 /* !untyped data */ +#define TIFFTAG_SMINSAMPLEVALUE 340 /* !variable MinSampleValue */ +#define TIFFTAG_SMAXSAMPLEVALUE 341 /* !variable MaxSampleValue */ +#define TIFFTAG_JPEGTABLES 347 /* %JPEG table stream */ +/* + * Tags 512-521 are obsoleted by Technical Note #2 + * which specifies a revised JPEG-in-TIFF scheme. + */ +#define TIFFTAG_JPEGPROC 512 /* !JPEG processing algorithm */ +#define JPEGPROC_BASELINE 1 /* !baseline sequential */ +#define JPEGPROC_LOSSLESS 14 /* !Huffman coded lossless */ +#define TIFFTAG_JPEGIFOFFSET 513 /* !pointer to SOI marker */ +#define TIFFTAG_JPEGIFBYTECOUNT 514 /* !JFIF stream length */ +#define TIFFTAG_JPEGRESTARTINTERVAL 515 /* !restart interval length */ +#define TIFFTAG_JPEGLOSSLESSPREDICTORS 517 /* !lossless proc predictor */ +#define TIFFTAG_JPEGPOINTTRANSFORM 518 /* !lossless point transform */ +#define TIFFTAG_JPEGQTABLES 519 /* !Q matrice offsets */ +#define TIFFTAG_JPEGDCTABLES 520 /* !DCT table offsets */ +#define TIFFTAG_JPEGACTABLES 521 /* !AC coefficient offsets */ +#define TIFFTAG_YCBCRCOEFFICIENTS 529 /* !RGB -> YCbCr transform */ +#define TIFFTAG_YCBCRSUBSAMPLING 530 /* !YCbCr subsampling factors */ +#define TIFFTAG_YCBCRPOSITIONING 531 /* !subsample positioning */ +#define YCBCRPOSITION_CENTERED 1 /* !as in PostScript Level 2 */ +#define YCBCRPOSITION_COSITED 2 /* !as in CCIR 601-1 */ +#define TIFFTAG_REFERENCEBLACKWHITE 532 /* !colorimetry info */ +/* tags 32952-32956 are private tags registered to Island Graphics */ +#define TIFFTAG_REFPTS 32953 /* image reference points */ +#define TIFFTAG_REGIONTACKPOINT 32954 /* region-xform tack point */ +#define TIFFTAG_REGIONWARPCORNERS 32955 /* warp quadrilateral */ +#define TIFFTAG_REGIONAFFINE 32956 /* affine transformation mat */ +/* tags 32995-32999 are private tags registered to SGI */ +#define TIFFTAG_MATTEING 32995 /* $use ExtraSamples */ +#define TIFFTAG_DATATYPE 32996 /* $use SampleFormat */ +#define TIFFTAG_IMAGEDEPTH 32997 /* z depth of image */ +#define TIFFTAG_TILEDEPTH 32998 /* z depth/data tile */ +/* tags 33300-33309 are private tags registered to Pixar */ +/* + * TIFFTAG_PIXAR_IMAGEFULLWIDTH and TIFFTAG_PIXAR_IMAGEFULLLENGTH + * are set when an image has been cropped out of a larger image. + * They reflect the size of the original uncropped image. + * The TIFFTAG_XPOSITION and TIFFTAG_YPOSITION can be used + * to determine the position of the smaller image in the larger one. + */ +#define TIFFTAG_PIXAR_IMAGEFULLWIDTH 33300 /* full image size in x */ +#define TIFFTAG_PIXAR_IMAGEFULLLENGTH 33301 /* full image size in y */ +/* tag 33405 is a private tag registered to Eastman Kodak */ +#define TIFFTAG_WRITERSERIALNUMBER 33405 /* device serial number */ +/* tag 33432 is listed in the 6.0 spec w/ unknown ownership */ +#define TIFFTAG_COPYRIGHT 33432 /* copyright string */ +/* tags 34232-34236 are private tags registered to Texas Instruments */ +#define TIFFTAG_FRAMECOUNT 34232 /* Sequence Frame Count */ +/* tag 34750 is a private tag registered to Pixel Magic */ +#define TIFFTAG_JBIGOPTIONS 34750 /* JBIG options */ +/* tags 34908-34914 are private tags registered to SGI */ +#define TIFFTAG_FAXRECVPARAMS 34908 /* encoded Class 2 ses. parms */ +#define TIFFTAG_FAXSUBADDRESS 34909 /* received SubAddr string */ +#define TIFFTAG_FAXRECVTIME 34910 /* receive time (secs) */ +/* tag 65535 is an undefined tag used by Eastman Kodak */ +#define TIFFTAG_DCSHUESHIFTVALUES 65535 /* hue shift correction data */ + +/* + * The following are ``pseudo tags'' that can be + * used to control codec-specific functionality. + * These tags are not written to file. Note that + * these values start at 0xffff+1 so that they'll + * never collide with Aldus-assigned tags. + * + * If you want your private pseudo tags ``registered'' + * (i.e. added to this file), send mail to sam@sgi.com + * with the appropriate C definitions to add. + */ +#define TIFFTAG_FAXMODE 65536 /* Group 3/4 format control */ +#define FAXMODE_CLASSIC 0x0000 /* default, include RTC */ +#define FAXMODE_NORTC 0x0001 /* no RTC at end of data */ +#define FAXMODE_NOEOL 0x0002 /* no EOL code at end of row */ +#define FAXMODE_BYTEALIGN 0x0004 /* byte align row */ +#define FAXMODE_WORDALIGN 0x0008 /* word align row */ +#define FAXMODE_CLASSF FAXMODE_NORTC /* TIFF Class F */ +#define TIFFTAG_JPEGQUALITY 65537 /* Compression quality level */ +/* Note: quality level is on the IJG 0-100 scale. Default value is 75 */ +#define TIFFTAG_JPEGCOLORMODE 65538 /* Auto RGB<=>YCbCr convert? */ +#define JPEGCOLORMODE_RAW 0x0000 /* no conversion (default) */ +#define JPEGCOLORMODE_RGB 0x0001 /* do auto conversion */ +#define TIFFTAG_JPEGTABLESMODE 65539 /* What to put in JPEGTables */ +#define JPEGTABLESMODE_QUANT 0x0001 /* include quantization tbls */ +#define JPEGTABLESMODE_HUFF 0x0002 /* include Huffman tbls */ +/* Note: default is JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF */ +#define TIFFTAG_FAXFILLFUNC 65540 /* G3/G4 fill function */ +#define TIFFTAG_PIXARLOGDATAFMT 65549 /* PixarLogCodec I/O data sz */ +#define PIXARLOGDATAFMT_8BIT 0 /* regular u_char samples */ +#define PIXARLOGDATAFMT_8BITABGR 1 /* ABGR-order u_chars */ +#define PIXARLOGDATAFMT_11BITLOG 2 /* 11-bit log-encoded (raw) */ +#define PIXARLOGDATAFMT_12BITPICIO 3 /* as per PICIO (1.0==2048) */ +#define PIXARLOGDATAFMT_16BIT 4 /* signed short samples */ +#define PIXARLOGDATAFMT_FLOAT 5 /* IEEE float samples */ +/* 65550-65556 are allocated to Oceana Matrix */ +#define TIFFTAG_DCSIMAGERTYPE 65550 /* imager model & filter */ +#define DCSIMAGERMODEL_M3 0 /* M3 chip (1280 x 1024) */ +#define DCSIMAGERMODEL_M5 1 /* M5 chip (1536 x 1024) */ +#define DCSIMAGERMODEL_M6 2 /* M6 chip (3072 x 2048) */ +#define DCSIMAGERFILTER_IR 0 /* infrared filter */ +#define DCSIMAGERFILTER_MONO 1 /* monochrome filter */ +#define DCSIMAGERFILTER_CFA 2 /* color filter array */ +#define DCSIMAGERFILTER_OTHER 3 /* other filter */ +#define TIFFTAG_DCSINTERPMODE 65551 /* interpolation mode */ +#define DCSINTERPMODE_NORMAL 0x0 /* whole image, default */ +#define DCSINTERPMODE_PREVIEW 0x1 /* preview of image (384x256) */ +#define TIFFTAG_DCSBALANCEARRAY 65552 /* color balance values */ +#define TIFFTAG_DCSCORRECTMATRIX 65553 /* color correction values */ +#define TIFFTAG_DCSGAMMA 65554 /* gamma value */ +#define TIFFTAG_DCSTOESHOULDERPTS 65555 /* toe & shoulder points */ +#define TIFFTAG_DCSCALIBRATIONFD 65556 /* calibration file desc */ +/* Note: quality level is on the ZLIB 1-9 scale. Default value is -1 */ +#define TIFFTAG_ZIPQUALITY 65557 /* compression quality level */ +#define TIFFTAG_PIXARLOGQUALITY 65558 /* PixarLog uses same scale */ +#endif /* _TIFF_ */ diff --git a/libs/libtiff/tiffio.h b/libs/libtiff/tiffio.h new file mode 100644 index 00000000..2c1e16ff --- /dev/null +++ b/libs/libtiff/tiffio.h @@ -0,0 +1,311 @@ +/* $Header: /usr/people/sam/tiff/libtiff/RCS/tiffio.h,v 1.93 1996/03/07 17:00:14 sam Rel $ */ + +/* + * Copyright (c) 1988-1996 Sam Leffler + * Copyright (c) 1991-1996 Silicon Graphics, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that (i) the above copyright notices and this permission notice appear in + * all copies of the software and related documentation, and (ii) the names of + * Sam Leffler and Silicon Graphics may not be used in any advertising or + * publicity relating to the software without the specific, prior written + * permission of Sam Leffler and Silicon Graphics. + * + * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, + * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY + * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. + * + * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR + * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, + * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, + * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF + * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef _TIFFIO_ +#define _TIFFIO_ + +/* + * TIFF I/O Library Definitions. + */ +#include "tiff.h" + +/* + * This define can be used in code that requires + * compilation-related definitions specific to a + * version or versions of the library. Runtime + * version checking should be done based on the + * string returned by TIFFGetVersion. + */ +#define TIFFLIB_VERSION 19960307 /* March 7, 1996 */ + +/* + * TIFF is defined as an incomplete type to hide the + * library's internal data structures from clients. + */ +typedef struct tiff TIFF; + +/* + * The following typedefs define the intrinsic size of + * data types used in the *exported* interfaces. These + * definitions depend on the proper definition of types + * in tiff.h. Note also that the varargs interface used + * pass tag types and values uses the types defined in + * tiff.h directly. + * + * NB: ttag_t is unsigned int and not unsigned short because + * ANSI C requires that the type before the ellipsis be a + * promoted type (i.e. one of int, unsigned int, pointer, + * or double) and because we defined pseudo-tags that are + * outside the range of legal Aldus-assigned tags. + * NB: tsize_t is int32 and not uint32 because some functions + * return -1. + * NB: toff_t is not off_t for many reasons; TIFFs max out at + * 32-bit file offsets being the most important + */ +typedef unsigned int ttag_t; /* directory tag */ +typedef uint16 tdir_t; /* directory index */ +typedef uint16 tsample_t; /* sample number */ +typedef uint32 tstrip_t; /* strip number */ +typedef uint32 ttile_t; /* tile number */ +typedef int32 tsize_t; /* i/o size in bytes */ +#if defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows) +#include +#ifdef __WIN32__ +DECLARE_HANDLE(thandle_t); /* Win32 file handle */ +#else +typedef HFILE thandle_t; /* client data handle */ +#endif +#else +typedef void* thandle_t; /* client data handle */ +#endif +typedef void* tdata_t; /* image data ref */ +typedef int32 toff_t; /* file offset */ + +#ifndef NULL +#define NULL 0 +#endif + +/* + * Flags to pass to TIFFPrintDirectory to control + * printing of data structures that are potentially + * very large. Bit-or these flags to enable printing + * multiple items. + */ +#define TIFFPRINT_NONE 0x0 /* no extra info */ +#define TIFFPRINT_STRIPS 0x1 /* strips/tiles info */ +#define TIFFPRINT_CURVES 0x2 /* color/gray response curves */ +#define TIFFPRINT_COLORMAP 0x4 /* colormap */ +#define TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */ +#define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */ +#define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */ + +/* + * RGBA-style image support. + */ +typedef unsigned char TIFFRGBValue; /* 8-bit samples */ +typedef struct _TIFFRGBAImage TIFFRGBAImage; +/* + * The image reading and conversion routines invoke + * ``put routines'' to copy/image/whatever tiles of + * raw image data. A default set of routines are + * provided to convert/copy raw image data to 8-bit + * packed ABGR format rasters. Applications can supply + * alternate routines that unpack the data into a + * different format or, for example, unpack the data + * and draw the unpacked raster on the display. + */ +typedef void (*tileContigRoutine) + (TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32, + unsigned char*); +typedef void (*tileSeparateRoutine) + (TIFFRGBAImage*, uint32*, uint32, uint32, uint32, uint32, int32, int32, + unsigned char*, unsigned char*, unsigned char*, unsigned char*); +/* + * RGBA-reader state. + */ +typedef struct { /* YCbCr->RGB support */ + TIFFRGBValue* clamptab; /* range clamping table */ + int* Cr_r_tab; + int* Cb_b_tab; + int32* Cr_g_tab; + int32* Cb_g_tab; + float coeffs[3]; /* cached for repeated use */ +} TIFFYCbCrToRGB; + +struct _TIFFRGBAImage { + TIFF* tif; /* image handle */ + int stoponerr; /* stop on read error */ + int isContig; /* data is packed/separate */ + int alpha; /* type of alpha data present */ + uint32 width; /* image width */ + uint32 height; /* image height */ + uint16 bitspersample; /* image bits/sample */ + uint16 samplesperpixel; /* image samples/pixel */ + uint16 orientation; /* image orientation */ + uint16 photometric; /* image photometric interp */ + uint16* redcmap; /* colormap pallete */ + uint16* greencmap; + uint16* bluecmap; + /* get image data routine */ + int (*get)(TIFFRGBAImage*, uint32*, uint32, uint32); + union { + void (*any)(TIFFRGBAImage*); + tileContigRoutine contig; + tileSeparateRoutine separate; + } put; /* put decoded strip/tile */ + TIFFRGBValue* Map; /* sample mapping array */ + uint32** BWmap; /* black&white map */ + uint32** PALmap; /* palette image map */ + TIFFYCbCrToRGB* ycbcr; /* YCbCr conversion state */ +}; + +/* + * Macros for extracting components from the + * packed ABGR form returned by TIFFReadRGBAImage. + */ +#define TIFFGetR(abgr) ((abgr) & 0xff) +#define TIFFGetG(abgr) (((abgr) >> 8) & 0xff) +#define TIFFGetB(abgr) (((abgr) >> 16) & 0xff) +#define TIFFGetA(abgr) (((abgr) >> 24) & 0xff) + +/* + * A CODEC is a software package that implements decoding, + * encoding, or decoding+encoding of a compression algorithm. + * The library provides a collection of builtin codecs. + * More codecs may be registered through calls to the library + * and/or the builtin implementations may be overridden. + */ +typedef int (*TIFFInitMethod)(TIFF*, int); +typedef struct { + char* name; + uint16 scheme; + TIFFInitMethod init; +} TIFFCodec; + +#include +#include + +#if defined(__cplusplus) +extern "C" { +#endif +typedef void (*TIFFErrorHandler)(const char*, const char*, va_list); +typedef tsize_t (*TIFFReadWriteProc)(thandle_t, tdata_t, tsize_t); +typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int); +typedef int (*TIFFCloseProc)(thandle_t); +typedef toff_t (*TIFFSizeProc)(thandle_t); +typedef int (*TIFFMapFileProc)(thandle_t, tdata_t*, toff_t*); +typedef void (*TIFFUnmapFileProc)(thandle_t, tdata_t, toff_t); +typedef void (*TIFFExtendProc)(TIFF*); + +extern const char* TIFFGetVersion(void); + +extern const TIFFCodec* TIFFFindCODEC(uint16); +extern TIFFCodec* TIFFRegisterCODEC(uint16, const char*, TIFFInitMethod); +extern void TIFFUnRegisterCODEC(TIFFCodec*); + +extern tdata_t _TIFFmalloc(tsize_t); +extern tdata_t _TIFFrealloc(tdata_t, tsize_t); +extern void _TIFFmemset(tdata_t, int, tsize_t); +extern void _TIFFmemcpy(tdata_t, const tdata_t, tsize_t); +extern int _TIFFmemcmp(const tdata_t, const tdata_t, tsize_t); +extern void _TIFFfree(tdata_t); + +extern void TIFFClose(TIFF*); +extern int TIFFFlush(TIFF*); +extern int TIFFFlushData(TIFF*); +extern int TIFFGetField(TIFF*, ttag_t, ...); +extern int TIFFVGetField(TIFF*, ttag_t, va_list); +extern int TIFFGetFieldDefaulted(TIFF*, ttag_t, ...); +extern int TIFFVGetFieldDefaulted(TIFF*, ttag_t, va_list); +extern int TIFFReadDirectory(TIFF*); +extern tsize_t TIFFScanlineSize(TIFF*); +extern tsize_t TIFFRasterScanlineSize(TIFF*); +extern tsize_t TIFFStripSize(TIFF*); +extern tsize_t TIFFVStripSize(TIFF*, uint32); +extern tsize_t TIFFTileRowSize(TIFF*); +extern tsize_t TIFFTileSize(TIFF*); +extern tsize_t TIFFVTileSize(TIFF*, uint32); +extern uint32 TIFFDefaultStripSize(TIFF*, uint32); +extern void TIFFDefaultTileSize(TIFF*, uint32*, uint32*); +extern int TIFFFileno(TIFF*); +extern int TIFFGetMode(TIFF*); +extern int TIFFIsTiled(TIFF*); +extern int TIFFIsByteSwapped(TIFF*); +extern int TIFFIsUpSampled(TIFF*); +extern int TIFFIsMSB2LSB(TIFF*); +extern uint32 TIFFCurrentRow(TIFF*); +extern tdir_t TIFFCurrentDirectory(TIFF*); +extern uint32 TIFFCurrentDirOffset(TIFF*); +extern tstrip_t TIFFCurrentStrip(TIFF*); +extern ttile_t TIFFCurrentTile(TIFF*); +extern int TIFFReadBufferSetup(TIFF*, tdata_t, tsize_t); +extern int TIFFWriteBufferSetup(TIFF*, tdata_t, tsize_t); +extern int TIFFLastDirectory(TIFF*); +extern int TIFFSetDirectory(TIFF*, tdir_t); +extern int TIFFSetSubDirectory(TIFF*, uint32); +extern int TIFFUnlinkDirectory(TIFF*, tdir_t); +extern int TIFFSetField(TIFF*, ttag_t, ...); +extern int TIFFVSetField(TIFF*, ttag_t, va_list); +extern int TIFFWriteDirectory(TIFF *); +#if defined(c_plusplus) || defined(__cplusplus) +extern void TIFFPrintDirectory(TIFF*, FILE*, long = 0); +extern int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t = 0); +extern int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t = 0); +extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int = 0); +#else +extern void TIFFPrintDirectory(TIFF*, FILE*, long); +extern int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t); +extern int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t); +extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int); +#endif +extern int TIFFRGBAImageOK(TIFF*, char [1024]); +extern int TIFFRGBAImageBegin(TIFFRGBAImage*, TIFF*, int, char [1024]); +extern int TIFFRGBAImageGet(TIFFRGBAImage*, uint32*, uint32, uint32); +extern void TIFFRGBAImageEnd(TIFFRGBAImage*); +extern TIFF* TIFFOpen(const char*, const char*); +extern TIFF* TIFFFdOpen(int, const char*, const char*); +extern TIFF* TIFFClientOpen(const char*, const char*, + thandle_t, + TIFFReadWriteProc, TIFFReadWriteProc, + TIFFSeekProc, TIFFCloseProc, + TIFFSizeProc, + TIFFMapFileProc, TIFFUnmapFileProc); +extern const char* TIFFFileName(TIFF*); +extern void TIFFError(const char*, const char*, ...); +extern void TIFFWarning(const char*, const char*, ...); +extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler); +extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler); +extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc); +extern ttile_t TIFFComputeTile(TIFF*, uint32, uint32, uint32, tsample_t); +extern int TIFFCheckTile(TIFF*, uint32, uint32, uint32, tsample_t); +extern ttile_t TIFFNumberOfTiles(TIFF*); +extern tsize_t TIFFReadTile(TIFF*, + tdata_t, uint32, uint32, uint32, tsample_t); +extern tsize_t TIFFWriteTile(TIFF*, + tdata_t, uint32, uint32, uint32, tsample_t); +extern tstrip_t TIFFComputeStrip(TIFF*, uint32, tsample_t); +extern tstrip_t TIFFNumberOfStrips(TIFF*); +extern tsize_t TIFFReadEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t); +extern tsize_t TIFFReadRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t); +extern tsize_t TIFFReadEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t); +extern tsize_t TIFFReadRawTile(TIFF*, ttile_t, tdata_t, tsize_t); +extern tsize_t TIFFWriteEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t); +extern tsize_t TIFFWriteRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t); +extern tsize_t TIFFWriteEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t); +extern tsize_t TIFFWriteRawTile(TIFF*, ttile_t, tdata_t, tsize_t); +extern void TIFFSetWriteOffset(TIFF*, toff_t); +extern void TIFFSwabShort(uint16*); +extern void TIFFSwabLong(uint32*); +extern void TIFFSwabDouble(double*); +extern void TIFFSwabArrayOfShort(uint16*, unsigned long); +extern void TIFFSwabArrayOfLong(uint32*, unsigned long); +extern void TIFFSwabArrayOfDouble(double*, unsigned long); +extern void TIFFReverseBits(unsigned char *, unsigned long); +extern const unsigned char* TIFFGetBitRevTable(int); +#if defined(__cplusplus) +} +#endif +#endif /* _TIFFIO_ */