Papyrus3/0000777000175000017500000000000010076705560007536 5ustar Papyrus3/PapyRead3.c0000755000175000017500000026003110044177214011465 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyRead3.c */ /* Function : contains all the reading functions */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 04.1991 version 1.1 */ /* 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifdef Mac #pragma segment papy3 #endif /* ------------------------- includes ---------------------------------------*/ #include #include #include #include "setjmp.h" #include "jpegless.h" /* interface for JPEG lossless decompressor */ #include "jpeglib.h" /* interface for JPEG lossy decompressor */ #ifdef MAYO_WAVE #include "Mayo.h" /* interface for wavelet decompressor */ #define TO_SWAP_MAYO #endif /* MAYO_WAVE */ #ifndef Papyrus3H #include "Papyrus3.h" #endif /********************************************************************************/ /* */ /* Papy3GetElement : gets the value(s) of the specified element */ /* return : the value(s) of the element */ /* */ /********************************************************************************/ UValue_T * CALLINGCONV Papy3GetElement (SElement *inGrOrModP, int inElement, PapyULong *outNbValueP, int *outElemTypeP) /*SElement *inGrOrModP; ptr on the group or the module */ /*PapyShort inElement; the position of the element in the group */ /*PapyULong *outNbValueP; the number of values to read */ /*PapyShort *outElemTypeP; what is the type of the element */ { SElement *theElemP; /* work pointer on the elements of the group */ UValue_T *theValueP; /* the value we are looking for */ if (inGrOrModP == NULL) return NULL; theElemP = inGrOrModP; theElemP += inElement; /* points on the desired element */ *outElemTypeP = theElemP->vr; /* is it a short a long or an ASCII char ? */ if (theElemP->nb_val > 0L) /* there is an introduced value */ { *outNbValueP = theElemP->nb_val; theValueP = theElemP->value; } /* then */ else { *outNbValueP = 0L; theValueP = NULL; } /* else */ return theValueP; } /* endof Papy3GetElement */ /********************************************************************************/ /* */ /* ExtractJPEGlosslessDicom : gets and decode JPEG lossless pixel data */ /* Nota : the PAPYRUS toolkit JPEG utility is based in part on the work of */ /* the Independent JPEG Group (see copyright file included) */ /* return : the image */ /* */ /********************************************************************************/ PapyShort ExtractJPEGlosslessDicom (PapyShort inFileNb, PapyUChar *outBufferP, PapyULong inPixelStart, PapyULong *inOffsetTableP, int inImageNb) { PapyUChar theTmpBuf [256]; PapyUChar *theTmpBufP; PapyShort theErr; PapyUShort theGroup, theElement; PapyULong i, thePos, theLength; /* void *aFSSpec; PAPY_FILE tmpFile; PapyUChar *myBufPtr; */ /* position the file pointer at the begining of the pixel datas */ Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, (PapyLong) (inPixelStart + inOffsetTableP [inImageNb - 1])); /* read 8 chars from the file */ theTmpBufP = (PapyUChar *) &theTmpBuf [0]; i = 8L; /* grNb, elemNb & elemLength */ if ((theErr = (PapyShort) Papy3FRead (gPapyFile [inFileNb], &i, 1L, theTmpBufP)) < 0) { Papy3FClose (&gPapyFile [inFileNb]); RETURN (theErr); } /* if */ thePos = 0L; theGroup = Extract2Bytes (theTmpBufP, &thePos); theElement = Extract2Bytes (theTmpBufP, &thePos); /* extract the element length */ theLength = Extract4Bytes (theTmpBufP, &thePos); /* if length is 0xFFFFFFFF (undefined) we have to extract it HERE !!! */ /* Pixel data fragment not found when expected */ if ((theGroup != 0xFFFE) || (theElement != 0xE000)) RETURN (papBadArgument); /******/ /* extract the compressed datas from the file and put it in temp file */ /******/ /* first : create a new file and opens it */ /* avoid to create more than one image */ /* allocate the buffer to store the temp compressed datas */ /* read the compressed stream from the file */ /* and put it in the temp file */ /* close the temp file */ /* and free the allocated memory */ /* then reset the file pointer to its previous position */ /* strcpy ((char *) theTmpBufP, "Compressed.jpg"); theErr = Papy3FCreate ((char *) theTmpBufP, 0, NULL, &aFSSpec); if (theErr == 0) { theErr = Papy3FOpen (NULL, 'w', 0, &tmpFile, &aFSSpec); myBufPtr = (PapyUChar *) emalloc3 (theLength + 1L); theErr = (PapyShort) Papy3FRead (gPapyFile [inFileNb], &theLength, 1L, myBufPtr); theErr = (PapyShort) Papy3FWrite (tmpFile, &theLength, 1L, (void *) myBufPtr); theErr = Papy3FClose (&tmpFile); efree3 ((void **) &myBufPtr); theErr = (PapyShort) Papy3FSeek (gPapyFile [inFileNb], SEEK_CUR, - (PapyLong) theLength); } /* if ...no error creating the temp file */ /******/ /******/ /* Get ready to receive decompressed rows */ JPEGLosslessDecodeImage (gPapyFile [inFileNb], (PapyUShort *) outBufferP, gx0028BitsAllocated [inFileNb], theLength); return 0; } /* endof ExtractJPEGlosslessDicom */ /********************************************************************************/ /* */ /* ExtractJPEGlosslessPap : gets and decode JPEG lossless pixel data */ /* Nota : the PAPYRUS toolkit JPEG utility is based in part on the work of */ /* the Independent JPEG Group (see copyright file included) */ /* return : the image */ /* */ /********************************************************************************/ PapyShort ExtractJPEGlosslessPap (PapyShort inFileNb, PapyUChar *outBufferP, PapyULong inPixelStart, PapyULong inLength) { /* position the file pointer at the begining of the pixel datas */ Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, (PapyLong) inPixelStart); /* Get ready to receive decompressed rows */ JPEGLosslessDecodeImage (gPapyFile [inFileNb], (PapyUShort *) outBufferP, gx0028BitsAllocated [inFileNb], inLength); return 0; } /* endof ExtractJPEGlosslessPap */ /********************************************************************************/ /* */ /* Needed for the error manager of the JPEG lossy library */ /* */ /********************************************************************************/ struct SErrorMgr { struct jpeg_error_mgr pub; /* "public" fields */ jmp_buf setjmp_buffer; /* for return to caller */ }; /* struct */ typedef struct SErrorMgr *SErrorMgrP; /********************************************************************************/ /* */ /* Here's the routine that will replace the standard error_exit method: */ /* for JPEG lossy */ /* */ /********************************************************************************/ METHODDEF(void) my_error_exit (j_common_ptr ioCInfo) { /* ioCInfo->err really points to a SErrorMgr struct, so coerce pointer */ SErrorMgrP theErr = (SErrorMgrP) ioCInfo->err; /* Always display the message. */ /* We could postpone this until after returning, if we chose. */ (*ioCInfo->err->output_message) (ioCInfo); /* Return control to the setjmp point */ #ifdef Mac longjmp (theErr->setjmp_buffer, 1); #endif } /* endofunction my_error_exit */ /********************************************************************************/ /* */ /* ExtractJPEGlossy : gets and decode JPEG lossy pixel data */ /* Nota : the PAPYRUS toolkit JPEG utility is based in part on the work of */ /* the Independent JPEG Group (see copyright file included) */ /* return : the image */ /* */ /********************************************************************************/ PapyShort ExtractJPEGlossy (PapyShort inFileNb, PapyUChar *ioImage8P, PapyULong inPixelStart, PapyULong *inOffsetTableP, int inImageNb, int inDepth) { struct SErrorMgr theJErr; /* the JPEG error manager var */ struct jpeg_decompress_struct theCInfo; PapyUChar theTmpBuf [256]; PapyUChar *theTmpBufP; PapyUShort theGroup, theElement; PapyShort theErr = 0; PapyULong i, thePos, theLimit; int theRowStride; /* physical row width in output buffer */ int theLoop; PapyUChar *theWrkChP; /* ptr to the image */ PapyUChar *theWrkCh8P; /* ptr to the image 8 bits */ PapyUShort *theWrkCh16P; /* ptr to the image 16 bits */ PapyUShort *theBuffer16P; PapyUChar *theBuffer8P; /* position the file pointer to the begining of the image */ Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, (PapyLong) (inPixelStart + inOffsetTableP [inImageNb - 1])); /* read 8 chars from the file */ theTmpBufP = (PapyUChar *) &theTmpBuf [0]; i = 8L; /* grNb, elemNb & elemLength */ if ((theErr = (PapyShort) Papy3FRead (gPapyFile [inFileNb], &i, 1L, theTmpBufP)) < 0) { Papy3FClose (&gPapyFile [inFileNb]); RETURN (theErr); } /* if */ thePos = 0L; theGroup = Extract2Bytes (theTmpBufP, &thePos); theElement = Extract2Bytes (theTmpBufP, &thePos); /* Pixel data fragment not found when expected */ if ((theGroup != 0xFFFE) || (theElement != 0xE000)) RETURN (papBadArgument); /* We set up the normal JPEG error routines, then override error_exit. */ theCInfo.err = jpeg_std_error (&theJErr.pub); theJErr.pub.error_exit = my_error_exit; /* Establish the setjmp return context for my_error_exit to use. */ #ifdef Mac if (setjmp (theJErr.setjmp_buffer)) { jpeg_destroy_decompress (&theCInfo); return NULL; }/* if */ #endif /* initialize the JPEG decompression object */ jpeg_create_decompress (&theCInfo); /* specify the data source */ jpeg_stdio_src (&theCInfo, gPapyFile [inFileNb]); /* read file parameter */ (void) jpeg_read_header (&theCInfo, TRUE); if (gArrPhotoInterpret [inFileNb] == MONOCHROME1 || gArrPhotoInterpret [inFileNb] == MONOCHROME2) theCInfo.out_color_space = JCS_GRAYSCALE; if (gArrPhotoInterpret [inFileNb] == RGB) theCInfo.out_color_space = JCS_RGB; /* theCInfo.out_color_space = JCS_YCbCr; */ /* start the decompressor (set the decompression default params) */ (void) jpeg_start_decompress (&theCInfo); /* JSAMPLEs per row in output buffer */ theRowStride = theCInfo.output_width * theCInfo.output_components; if (inDepth == 16) theRowStride *= 2; /* allocate a one-row-high sample array that will go away when done with image */ if (inDepth == 16) { theBuffer16P = (PapyUShort *) emalloc3 ((PapyULong) theRowStride); theWrkCh16P = (PapyUShort *) ioImage8P; } else { theBuffer8P = (PapyUChar *) emalloc3 ((PapyULong) theRowStride); theWrkCh8P = (PapyUChar *) ioImage8P; } theWrkChP = (PapyUChar *) ioImage8P; theLimit = theCInfo.output_width * theCInfo.output_components; /* decompress the image line by line 8 bits */ if (inDepth == 8) { while (theCInfo.output_scanline < theCInfo.output_height) { (void) jpeg_read_scanlines (&theCInfo, (JSAMPARRAY) &theBuffer8P, 1); /* put the scanline in the image */ for (theLoop = 0; theLoop < (int) theLimit; theLoop ++) { if (theCInfo.out_color_space == JCS_GRAYSCALE) if (theBuffer8P [theLoop] > 255) theBuffer8P [theLoop] = 255; *theWrkChP = (PapyUChar) theBuffer8P [theLoop]; theWrkChP++; } /* for */ } /* while ...line by line decompression of the image */ /* frees the row used by the decompressor */ efree3 ((void **) &theBuffer8P); } /* if ...depth = 8 */ /* decompress the image line by line 16 bits */ else if (inDepth == 16) { while (theCInfo.output_scanline < theCInfo.output_height) { (void) jpeg_read_scanlines (&theCInfo, (JSAMPARRAY) &theBuffer16P, 1); /* put the scanline in the image */ for (theLoop = 0; theLoop < (int) theLimit; theLoop ++) { *theWrkCh16P = theBuffer16P [theLoop]; theWrkCh16P++; } /* for */ } /* while ...line by line decompression of the image */ /* frees the row used by the decompressor */ efree3 ((void **) &theBuffer16P); } /* else ...depth = 16 bits */ /* tell the JPEG decompressor we have finish the decompression */ (void) jpeg_finish_decompress (&theCInfo); /* MAL added : cf Example.c */ /* Step 8: Release JPEG decompression object */ /* This is an important step since it will release a good deal of memory. */ jpeg_destroy_decompress(&theCInfo); return theErr; } /* endof ExtractJPEGlossy */ /********************************************************************************/ /* */ /* ExtractWavelet : gets and decode Wavelet pixel data */ /* return : the image */ /* */ /********************************************************************************/ #ifdef MAYO_WAVE PapyShort ExtractWavelet (PapyShort inFileNb, PapyUChar *ioImage8P, PapyULong inPixelStart, PapyULong *inOffsetTableP, int inImageNb, int inDepth) { PapyUShort theGroup, theElement; MayoCompressedImage *theCompressedP; MayoRawImage *theRawP ; int theJs, theIs; PapyUChar theTmpBuf [256]; PapyUChar *theTmpBufP; PapyUChar *tmpBufPtr2; PapyULong i, thePos, theSize, theLength; PapyShort theErr; PapyUShort *theImage16P; PapyUChar *theValTempP, *theValFinalP; PapyUChar theHigh, theLow; Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, (PapyLong) (inPixelStart + inOffsetTableP [inImageNb - 1])); theTmpBufP = (PapyUChar *) &theTmpBuf [0]; i = 8L; if ((theErr = (PapyShort) Papy3FRead (gPapyFile [inFileNb], &i, 1L, theTmpBufP)) < 0) { Papy3FClose (&gPapyFile [inFileNb]); RETURN (theErr); } thePos = 0L; theGroup = Extract2Bytes (theTmpBufP, &thePos); theElement = Extract2Bytes (theTmpBufP, &thePos); /* Pixel data fragment not found when expected */ if ((theGroup != 0xFFFE) || (theElement != 0xE000)) RETURN (papBadArgument); /* Load the compressed file into memory */ /* theCompressedP = MayoReadCompressed (gPapyFile [inFileNb]) ; if ( theCompressedP == NULL ) { exit(MayoGetError()) ; } */ tmpBufPtr2 = (PapyUChar *) &theTmpBuf [0]; theCompressedP = (MayoCompressedImage *) emalloc3(sizeof(MayoCompressedImage)) ; if ( theCompressedP == NULL ) { return (-1); } /* if */ i = 8L; if ((theErr = (PapyShort) Papy3FRead (gPapyFile [inFileNb], &i, 1L,theTmpBufP)) < 0) { Papy3FClose (&gPapyFile [inFileNb]); efree3((void **) &theCompressedP) ; RETURN (theErr); } /* if */ thePos = 0L; theCompressedP->length = Extract4Bytes (theTmpBufP, &thePos); theCompressedP->version = Extract4Bytes (theTmpBufP, &thePos); /* Allocate memory for the image data */ theCompressedP->buf = (unsigned char *) emalloc3 (theCompressedP->length) ; if (theCompressedP->buf == NULL) { efree3 ((void **) &theCompressedP); return(-1); } /* if */ /* Read the image data */ theLength = (PapyULong) theCompressedP->length; if ((theErr = (PapyShort) Papy3FRead (gPapyFile [inFileNb], &theLength, 1L, theCompressedP->buf)) < 0) { Papy3FClose (&gPapyFile [inFileNb]); efree3((void **) &theCompressedP->buf) ; efree3((void **) &theCompressedP) ; RETURN (theErr); } /* if */ theCompressedP->length = (int) theLength; /* Run the decompressor */ theRawP = MayoDecompress (theCompressedP); if (theRawP == NULL) { return (MayoGetError()); } /* if */ /* Copy decompressed image */ theSize = (PapyULong) theRawP->xsize * theRawP->ysize * theRawP->bytesperpixel; if (inDepth == 8) memcpy (ioImage8P, theRawP->buf, theSize); else { theImage16P = (PapyUShort *) ioImage8P; memcpy (ioImage8P, theRawP->buf, theSize); } /* else */ /* Swap bytes if it is a 16-bit image*/ #ifdef TO_SWAP_MAYO theValTempP = (PapyUChar *) ioImage8P; theValFinalP = (PapyUChar *) ioImage8P; if (inDepth == 16) { for (theJs = 0; theJs < theRawP->xsize; theJs++) { for (theIs = 0; theIs < theRawP->ysize; theIs++) { theLow = *theValTempP; theValTempP++; theHigh = *theValTempP; theValTempP++; *theValFinalP = theHigh; theValFinalP++; *theValFinalP = theLow; theValFinalP++; } /* for */ } /* for */ } /* if ...inDepth = 16 */ #endif /* TO_SWAP_MAYO */ /* Free allocated memory MayoFreeCompressed(theCompressedP) ; MayoFreeRaw(theRawP) ; */ if (theRawP != NULL ) { if (theRawP->buf != NULL ) { efree3 ((void **) &(theRawP->buf)); } /* if */ efree3 ((void **) &theRawP); } /* if */ if (theCompressedP != NULL) { if (theCompressedP->buf != NULL) { efree3 ((void **) &(theCompressedP->buf)); } /* if */ efree3 ((void **) &theCompressedP); } /* if */ return (0); } /* endof ExtractWavelet */ #endif /* MAYO_WAVE */ /********************************************************************************/ /* */ /* DecodeRLESegment */ /* */ /********************************************************************************/ void DecodeRLESegment (PapyShort inFileNb, PapyUShort *ioImageP, PapyUChar *inRleP, PapyULong inLength, int inSegtot, int inSegNb) /* decode a RLE segment */ /* ioImageP : pointer on real image (8 or 16 bits) */ /* inRleP : pointer on rle buffer (8bits) */ /* inLength : length of rle buffer */ /* inSegtot : total number of segments (1, 2 or 3) */ /* inSegNb : number of current segment (1, 2 or 3) (only if inSegtot > 2) */ { PapyLong j, theIndj; PapyUChar *thePixP; PapyUChar theVal; char theCode; PapyShort i, theIMax; /* *** single segment *** */ /* ********************** */ if (inSegtot == 1) { /* convert rle into real image */ thePixP = (PapyUChar *) ioImageP; theIndj = 0L; for (j = 0L; j < (int) inLength;) { theCode = (char) inRleP [j]; j++; /* yes, I know but do not move it */ /* sequence of different bytes */ if (theCode == 0) { if (j < (int) (inLength - 1)) thePixP [theIndj++] = inRleP [j++]; } /* if */ /* repetition of the same byte */ else if ((theCode <= -1) && (theCode >= -127)) { theVal = inRleP [j++]; theIMax = -theCode; for (i = 0; i <= theIMax; i++) thePixP [theIndj++] = theVal; } /* if */ else /* if ((theCode > 0) && (theCode <= 127)) */ { for (i = 0; i < (theCode + 1); i++) thePixP [theIndj++] = inRleP [j++]; } /* if */ } /* for */ } /* if ...single segment */ /* *** two segments *** */ /* ******************** */ else if (inSegtot == 2) { /* we assume it is a 16 bit image */ /* convert rle into real image */ thePixP = (PapyUChar *) ioImageP; theIndj = 0L; if (inSegNb == 2) theIndj++; for (j = 0L; j < (int)inLength; ) { theCode = (char) inRleP [j]; j++; /* yes, I know but do not move it */ /* sequence of different bytes */ if (theCode == 0) { if (j < (int) (inLength - 1)) thePixP [theIndj] = inRleP [j++]; theIndj = theIndj + 2; } /* if */ /* repetition of the same byte */ else if ((theCode <= -1) && (theCode >= -127)) { theVal = inRleP [j++]; theIMax = -theCode; for (i = 0; i <= theIMax; i++) { thePixP [theIndj] = theVal; theIndj = theIndj + 2; } /* for */ } /* if */ else /* if ((theCode > 0) && (theCode <= 127)) */ { for (i = 0; i < (theCode + 1); i++) { thePixP [theIndj] = inRleP [j++]; theIndj = theIndj + 2; } /* for */ } /* if */ } /* for */ } /* if ...two segments */ /* *** three segments *** */ /* ******************** */ else if (inSegtot == 3) { /* this must be a RGB or YBR image */ /* so convert each channel at a time */ thePixP = (PapyUChar *) ioImageP; /* computes the offset in the resulting pixmap */ /* assuming that each plane is 8 bits depth */ theIndj = 0L; theIndj += ((PapyLong) gx0028Rows [inFileNb] * (PapyLong) gx0028Columns [inFileNb]) * (PapyLong) (inSegNb - 1); for (j = 0L; j < (int)inLength; ) { theCode = (char) inRleP [j]; j++; /* yes, I know but do not move it */ /* sequence of different bytes */ if (theCode == 0) { if (j < (int)(inLength - 1)) thePixP [theIndj++] = inRleP [j++]; }/* if */ /* repetition of the same byte */ else if ((theCode <= -1) && (theCode >= -127)) { theVal = inRleP [j++]; theIMax = -theCode; for (i = 0; i <= theIMax; i++) thePixP [theIndj++] = theVal; } /* if */ else /* if ((theCode > 0) && (theCode <= 127)) */ { for (i = 0; i < (theCode + 1); i++) thePixP [theIndj++] = inRleP [j++]; } /* if */ } /* for */ } /* if ...three segments */ } /* endof DecodeRLESegment */ /********************************************************************************/ /* */ /* ExtractRLE : gets and decode a RLE pixel data element */ /* return : the image */ /* */ /********************************************************************************/ PapyShort ExtractRLE (PapyShort inFileNb, PapyUShort *ioImage16P, PapyULong inPixelStart, PapyULong *inOffsetTableP, int inImageNb) { PapyUChar theTmpBuf [256]; PapyUChar *theTmpBufP; PapyUShort theGroup, theElement; PapyShort theErr; PapyULong theNbOfSegments, i, thePos, theLength; PapyUChar *theRleP; long theOffset1, theOffset2, theOffset3, theRleLen; /* for each image */ /* FFFE E000 length RLE_header RLE_segment1 RLE_segment2 ... */ /* length is 4 bytes, in the case of a single image */ Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, (PapyLong) (inPixelStart + inOffsetTableP [inImageNb - 1])); /* read 8 chars from the file */ theTmpBufP = (PapyUChar *) &theTmpBuf [0]; i = 8L; /* grNb, elemNb & elemLength */ if ((theErr = (PapyShort) Papy3FRead (gPapyFile [inFileNb], &i, 1L, theTmpBufP)) < 0) { Papy3FClose (&gPapyFile [inFileNb]); RETURN (theErr); } /* if */ thePos = 0L; theGroup = Extract2Bytes (theTmpBufP, &thePos); theElement = Extract2Bytes (theTmpBufP, &thePos); theLength = Extract4Bytes (theTmpBufP, &thePos); /* Pixel data fragment not found when expected */ if ((theGroup != 0xFFFE) || (theElement != 0xE000)) RETURN (papBadArgument); /* read 4 chars from the file = number of segments */ theTmpBufP = (PapyUChar *) &theTmpBuf [0]; i = 4L; thePos = 0L; /* grNb, elemNb & elemLength */ if ((theErr = (PapyShort) Papy3FRead (gPapyFile [inFileNb], &i, 1L, theTmpBufP)) < 0) { Papy3FClose (&gPapyFile [inFileNb]); RETURN (theErr); } /* if */ theNbOfSegments = Extract4Bytes (theTmpBufP, &thePos); if (theNbOfSegments > 3L) RETURN (papWrongValue); /* we allow to read 8, 16 and 32 bit images */ /* read theOffset1, theOffset2, theOffset3 and skip 48 bytes */ theTmpBufP = (PapyUChar *) &theTmpBuf [0]; i = 12L; thePos = 0L; /* grNb, elemNb & elemLength */ if ((theErr = (PapyShort) Papy3FRead (gPapyFile [inFileNb], &i, 1L, theTmpBufP)) < 0) { Papy3FClose (&gPapyFile [inFileNb]); RETURN (theErr); } /* if */ theOffset1 = Extract4Bytes (theTmpBufP, &thePos); theOffset2 = Extract4Bytes (theTmpBufP, &thePos); theOffset3 = Extract4Bytes (theTmpBufP, &thePos); Papy3FSeek (gPapyFile [inFileNb], SEEK_CUR, (PapyLong) 48L); if (theNbOfSegments == 1) { /* read rle image */ theRleLen = theLength - 64L; theRleP = (PapyUChar *) emalloc3 ((PapyULong) (theRleLen + 10L)); /* extract the image from the file */ theErr = Papy3FRead (gPapyFile [inFileNb], (PapyULong *) &theRleLen, 1L, (void *) theRleP); DecodeRLESegment (inFileNb, ioImage16P, theRleP, theRleLen, theNbOfSegments, 1); /* delete rle image */ efree3 ((void **) &theRleP); }/* if ...single segment */ else if (theNbOfSegments == 2) { /* deal with first segment */ theRleLen = theOffset2 - 64L; theRleP = (PapyUChar *) emalloc3 ((PapyULong) (theRleLen + 10L)); /* extract the image from the file */ theErr = Papy3FRead (gPapyFile [inFileNb], (PapyULong *) &theRleLen, 1L, (void *) theRleP); DecodeRLESegment (inFileNb, ioImage16P, theRleP, theRleLen, theNbOfSegments, 2); /* delete rle image */ efree3 ((void **) &theRleP); /* deal with second segment */ theRleLen = theLength - theOffset2; theRleP = (PapyUChar *) emalloc3 ((PapyULong) (theRleLen + 10L)); /* extract the image from the file */ theErr = Papy3FRead (gPapyFile [inFileNb], (PapyULong *) &theRleLen, 1L, (void *) theRleP); DecodeRLESegment (inFileNb, ioImage16P, theRleP, theRleLen, theNbOfSegments, 1); /* delete rle image */ efree3 ((void **) &theRleP); }/* if ...two segments */ else if (theNbOfSegments == 3) { /* deal with first segment */ theRleLen = theOffset2 - 64L; theRleP = (PapyUChar *) emalloc3 ((PapyULong) (theRleLen + 10L)); /* extract the image from the file */ theErr = Papy3FRead (gPapyFile [inFileNb], (PapyULong *) &theRleLen, 1L, (void *) theRleP); DecodeRLESegment (inFileNb, ioImage16P, theRleP, theRleLen, theNbOfSegments, 1); /* delete rle image */ efree3 ((void **) &theRleP); /* deal with second segment */ theRleLen = theOffset3 - theOffset2; theRleP = (PapyUChar *) emalloc3 ((PapyULong) (theRleLen + 10L)); /* extract the image from the file */ theErr = Papy3FRead (gPapyFile [inFileNb], (PapyULong *) &theRleLen, 1L, (void *) theRleP); DecodeRLESegment (inFileNb, ioImage16P, theRleP, theRleLen, theNbOfSegments, 2); /* delete rle image */ efree3 ((void **) &theRleP); /* deal with third segment */ theRleLen = theLength - theOffset3; theRleP = (PapyUChar *) emalloc3 ((PapyULong) (theRleLen + 10L)); /* extract the image from the file */ theErr = Papy3FRead (gPapyFile [inFileNb], (PapyULong *) &theRleLen, 1L, (void *) theRleP); DecodeRLESegment (inFileNb, ioImage16P, theRleP, theRleLen, theNbOfSegments, 3); /* delete rle image */ efree3 ((void **) &theRleP); } /* if ...three segments */ return 0; } /* endof ExtractRLE */ /********************************************************************************/ /* */ /* Papy3GetPixelData : gets the specified image or icon and put it either */ /* in the passed module or group. The moduleId parameter should contain */ /* the value IconImage if one wants to extract an icon or ImagePixel if */ /* one wants to extract the image itsself, wether a group or a module has */ /* been passed to the routine (this is important). */ /* BEWARE : in case of extracting the pixel data to a module, you should */ /* have gotten the module before calling this routine. */ /* in case of extracting the pixel data to a group, you should */ /* have read the group 0x0028 and the group 0x7FE0 before calling this */ /* routine. */ /* return : the image, or NULL if something went wrong */ /* */ /********************************************************************************/ PapyUShort * CALLINGCONV Papy3GetPixelData (PapyShort inFileNb, int inImageNb, SElement *inGrOrModP, int inModuleId) { PapyUChar *theBufP, theTmpBuf [256], *theTmpBufP; PapyUChar *theCharP, theChar0, theChar1; PapyUShort *theUShortP, theUShort1, theUShort2; PapyShort theErr; int theFrameCount = 1, theLoop, ok, theIsModule; PAPY_FILE theFp; PapyULong theBytesToRead, i, theULong, thePos, *theOffsetTableP; PapyULong theRefPoint, thePixelStart; SElement *theElemP; /* work pointer on the element of the module */ /* some usefull tests */ if (inImageNb > gArrNbImages [inFileNb] || inModuleId > END_MODULE) return NULL; /* test to learn if the routine was passed a module or a group in parameter */ if (inGrOrModP->group == 0x0028) theIsModule = TRUE; else theIsModule = FALSE; theOffsetTableP = NULL; /* get the file pointer from the file number */ theFp = gPapyFile [inFileNb]; /* position the file pointer to the pixel data to read */ switch (inModuleId) { case IconImage : /* only allow to get an icon from a PAPYRUS 3 file */ if (gIsPapyFile [inFileNb] != PAPYRUS3) return NULL; /* it is one of the pointer sequence module, so go to the given ptr sequence */ if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) gOffsetToPtrSeq [inFileNb] + 8L) != 0) return NULL; /* look for the given item of the ptr seq */ for (i = 1L; i < (PapyULong) inImageNb; i++) { theBytesToRead = Papy3ExtractItemLength (inFileNb); if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_CUR, (PapyLong) theBytesToRead) != 0) return NULL; } /* for */ /* then points to the first element of the item */ if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_CUR, (PapyLong) 8L) != 0) return NULL; /* look now for the right group, i.e. image */ if ((theErr = Papy3GotoGroupNb (inFileNb, 0x7FE0)) < 0) return NULL; /* ... then the right element */ theErr = Papy3GotoElemNb (inFileNb, 0x7FE0, 0x0010, &theBytesToRead); /* jump over the description of the element */ if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_IMPL) { if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_CUR, (PapyLong) 8L) != 0) return NULL; } /* if */ else if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL) { if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_CUR, (PapyLong) 12L) != 0) return NULL; } /* else */ /* position to the right element knowing if it is a group or a module */ if (theIsModule) theElemP = inGrOrModP + papPixelDataII; else theElemP = inGrOrModP + papPixelDataGr; break; case ImagePixel : /* go to the begining of the specified image */ if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) *(gRefPixelOffset [inFileNb] + inImageNb - 1)) != 0) return NULL; /* position to the right element knowing if it is a group or a module */ if (theIsModule) theElemP = inGrOrModP + papPixelData; else theElemP = inGrOrModP + papPixelDataGr; break; default : return NULL; break; } /* switch */ /* get the size of the pixel data */ if (inModuleId == IconImage) theBytesToRead = theElemP->length; else theBytesToRead = (PapyULong) gx0028Rows [inFileNb] * (PapyULong) gx0028Columns [inFileNb] * (PapyULong) (((gx0028BitsAllocated [inFileNb] - 1) / 8) + 1L); if (gArrCompression [inFileNb] == JPEG_LOSSY && (gArrPhotoInterpret [inFileNb] == YBR_FULL_422 || gArrPhotoInterpret [inFileNb] == YBR_PARTIAL_422)) gArrPhotoInterpret [inFileNb] = RGB; /* DAB modification */ /* if it is a RGB or a YBR_FULL image, multiply the bytes to read by 3 */ if (inModuleId == ImagePixel && (gArrPhotoInterpret [inFileNb] == RGB || gArrPhotoInterpret [inFileNb] == YBR_FULL)) theBytesToRead *= 3L; /* if it is a YBR_FULL_422 or a YBR_PARTIAL_422 then multiply the bytes to read by 2 */ else if (inModuleId == ImagePixel && (gArrPhotoInterpret [inFileNb] == YBR_FULL_422 || gArrPhotoInterpret [inFileNb] == YBR_PARTIAL_422)) theBytesToRead *= 2L; /* allocate the memory for the pixel data */ theBufP = (PapyUChar *) emalloc3 ((PapyULong) theBytesToRead); /* image reading depending on the image encoding */ /* first test if the images is not encoded */ if (inModuleId == IconImage || (gArrCompression [inFileNb] == NONE && (gArrPhotoInterpret [inFileNb] == MONOCHROME1 || gArrPhotoInterpret [inFileNb] == MONOCHROME2 || gArrPhotoInterpret [inFileNb] == PALETTE || gArrPhotoInterpret [inFileNb] == RGB || gArrPhotoInterpret [inFileNb] == YBR_FULL || gArrPhotoInterpret [inFileNb] == YBR_FULL_422 || gArrPhotoInterpret [inFileNb] == YBR_PARTIAL_422))) { /* if it is a DICOM file then jump to the right image */ if (gIsPapyFile [inFileNb] == DICOM10 || gIsPapyFile [inFileNb] == DICOM_NOT10) theErr = Papy3FSeek (theFp, SEEK_CUR, (PapyLong) (theBytesToRead * (inImageNb - 1))); /* read theBytesToRead bytes from the file */ if ((theErr = (PapyShort) Papy3FRead (theFp, &theBytesToRead, 1L, theBufP)) < 0) { theErr = Papy3FClose (&theFp); efree3 ((void **) &theBufP); return NULL; } /* if */ /* swap the bytes if necessary */ if (inModuleId == ImagePixel && gx0028BitsAllocated [inFileNb] > 8) { theUShortP = (PapyUShort *) theBufP; for (i = 0L, theCharP = theBufP; i < (theBytesToRead / 2); i++, theCharP += 2, theUShortP++) { theChar0 = *theCharP; theChar1 = *(theCharP + 1); *theUShortP = (PapyUShort) theChar1; *theUShortP = *theUShortP << 8; *theUShortP |= (PapyUShort) theChar0; } /* for */ } /* if ...more than 8 bits depth image */ } /* if ...module IconImage or photometric interpretation is monochrome/palette/rgb */ /* *** not IconImage module and the pixels are compressed *** */ else { /* if the image conforms to the DICOM standard there should be an offset table */ if (!(gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_IMPL && gArrCompression [inFileNb] != NONE)) { /* check to see if there is an offset table, as expected */ /* so read 8 chars from the file */ theTmpBufP = (unsigned char *) &theTmpBuf [0]; i = 8L; /* grNb, elemNb & elemLength */ if ((theErr = (PapyShort) Papy3FRead (theFp, &i, 1L, theTmpBufP)) < 0) { theErr = Papy3FClose (&theFp); return NULL; } /* if */ thePos = 0L; theUShort1 = Extract2Bytes (theTmpBufP, &thePos); theUShort2 = Extract2Bytes (theTmpBufP, &thePos); /* test if the values are correct */ if (theUShort1 != 0xFFFE || theUShort2 != 0xE000) return NULL; /* offset table size */ /* extract the element length according to the little-endian syntax */ theULong = Extract4Bytes (theTmpBufP, &thePos); if (theULong > 0) { /* the offset table size does give the number of frames */ theFrameCount = (int) (theULong / 4L); /* allocate room to store the offset table */ theOffsetTableP = (PapyULong *) emalloc3 ((PapyULong) (theFrameCount * sizeof (PapyULong))); for (theLoop = 0; theLoop < theFrameCount; theLoop++) { /* read 4 chars from the file */ i = 4L; thePos = 0L; theTmpBufP = (unsigned char *) &theTmpBuf [0]; if ((theErr = (PapyShort) Papy3FRead (theFp, &i, 1L, theTmpBufP)) < 0) { theErr = Papy3FClose (&theFp); efree3 ((void **) &theOffsetTableP); return NULL; } /* if */ theOffsetTableP [theLoop] = Extract4Bytes (theTmpBufP, &thePos); } /* for */ } /* if */ else { ok = FALSE; theFrameCount = 0; /* initialize a file reference point */ Papy3FTell (theFp, (PapyLong *) &theRefPoint); /* allocate memory for the offset table */ theOffsetTableP = (PapyULong *) emalloc3 ((PapyULong) (1000L * sizeof (PapyULong))); while (!ok) { /* read fragment information : 0xFFFE, 0xE000, length */ Papy3FTell (theFp, (PapyLong *) &thePixelStart); /* read 8 chars from the file */ i = 8L; thePos = 0L; theTmpBufP = (unsigned char *) &theTmpBuf [0]; if ((theErr = (PapyShort) Papy3FRead (theFp, &i, 1L, theTmpBufP)) < 0) { theErr = Papy3FClose (&theFp); efree3 ((void **) &theOffsetTableP); return NULL; } /* if */ thePos = 0L; theUShort1 = Extract2Bytes (theTmpBufP, &thePos); theUShort2 = Extract2Bytes (theTmpBufP, &thePos); theULong = Extract4Bytes (theTmpBufP, &thePos); /* offset table found ? */ if ((theUShort1 == 0xFFFE) && (theUShort2 == 0xE000)) { theOffsetTableP [theFrameCount] = thePixelStart - theRefPoint; theFrameCount ++; Papy3FSeek (theFp, SEEK_CUR, theULong); } /* if */ else if ((theUShort1 == 0xFFFE) && (theUShort2 == 0xE0DD)) ok = TRUE; } /* while */ /* position the file pointer on the first image */ Papy3FSeek (theFp, SEEK_SET, theRefPoint); } /* else */ } /* if ...not a Papyrus compressed image */ else { /* allocate room to store the offset table */ theOffsetTableP = (PapyULong *) emalloc3 ((PapyULong) (sizeof (PapyULong))); /* there is no offset to the JPEG encoded image */ theOffsetTableP [0] = 0L; } /* else ...Papyrus compressed image */ /* get the position of the first pixel */ Papy3FTell (theFp, (PapyLong *) &thePixelStart); /* in case of a PAPYRUS file, there should be only one frame. */ /* The positioning of the file pointer to the right image has already been performed */ if (gIsPapyFile [inFileNb] == PAPYRUS3) inImageNb = 1; /* *** different ways of reading depending on the compression algorithm *** */ /********************************************************************/ /******************* Lossless JPEG **************************/ /********************************************************************/ if (gArrCompression [inFileNb] == JPEG_LOSSLESS) { if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL) theErr = ExtractJPEGlosslessDicom (inFileNb, theBufP, thePixelStart, theOffsetTableP, inImageNb); else /* little-endian-explicit VR */ theErr = ExtractJPEGlosslessPap (inFileNb, theBufP, thePixelStart, theElemP->length); } /* if ...JPEG lossless */ /********************************************************************/ /******************* Lossy JPEG *****************************/ /********************************************************************/ else if (gArrCompression [inFileNb] == JPEG_LOSSY) { theErr = ExtractJPEGlossy (inFileNb, theBufP, thePixelStart, theOffsetTableP, inImageNb, (int) gx0028BitsAllocated [inFileNb]); } /* if ...JPEG lossy */ #ifdef MAYO_WAVE /********************************************************************/ /******************* MAYO WAVELET *****************************/ /********************************************************************/ else if (gArrCompression [inFileNb] == MAYO_WAVELET) { theErr = ExtractWavelet ((PapyShort) inFileNb, (PapyUChar *) theBufP, thePixelStart, theOffsetTableP, inImageNb, (int) gx0028BitsAllocated [inFileNb]); } /* if ...Mayo Wavelet */ #endif /********************************************************************/ /******************* RLE ************************************/ /********************************************************************/ else if (gArrCompression [inFileNb] == RLE) { theErr = ExtractRLE (inFileNb, (PapyUShort *) theBufP, thePixelStart, theOffsetTableP, inImageNb); } /* if ...Run Length Encoding */ /********************************************************************/ /******************* unknown ********************************/ /********************************************************************/ else { /* black image, that is better than nothing ... */ for (i = 0L; i < theBytesToRead; i++) theBufP [i] = 0; } /* if ...nothing known */ } /* else ...not icon image or compressed pixel data */ /* allocate room in the element in order to put the pixel data in the module */ theElemP->value = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); theElemP->nb_val = 1L; /* extract the pixel data depending on the value representation */ if (inModuleId == IconImage || gArrCompression [inFileNb] == NONE) { theElemP->vr = OW; theElemP->value->ow = (PapyUShort *) theBufP; } /* if ...icon image or uncompressed file */ else { theElemP->vr = OB; theElemP->value->a = (char *) theBufP; } /* else ...compressed image */ if (theOffsetTableP != NULL) efree3 ((void **) &theOffsetTableP); return (PapyUShort *) theBufP; } /* endof Papy3GetPixelData */ /********************************************************************************/ /* */ /* Extract2Bytes : extract a 2-Bytes value (USS, SS or AT) from the buf and*/ /* increment pos accordingly. */ /* return : the extracted value */ /* */ /********************************************************************************/ PapyUShort Extract2Bytes (unsigned char *inBufP, PapyULong *ioPosP) /*unsigned char *inBufP; the buffer to read from */ /*PapyULong *ioPosP; the position in the buffer */ { PapyUShort theUShort; unsigned char *theCharP; /* points to the right place in the buffer */ theCharP = inBufP; theCharP += *ioPosP; /* updates the current position in the read buffer */ *ioPosP += 2; /* extract the element according to the little-endian syntax */ theUShort = (PapyUShort) (*(theCharP + 1)); theUShort = theUShort << 8; theUShort |= (PapyUShort) *theCharP; return theUShort; } /* endof Extract2Bytes */ /********************************************************************************/ /* */ /* Extract4Bytes : extract a 4-Bytes value (UL, SL or FL) of the buf and */ /* increment pos accordingly. */ /* return : the extracted value */ /* */ /********************************************************************************/ PapyULong Extract4Bytes (unsigned char *inBufP, PapyULong *ioPosP) /*unsigned char *inBufP; the buffer to read from */ /*PapyULong *ioPosP; the position in the buffer */ { unsigned char *theCharP; PapyULong theULong = 0L, theTmpULong; /* points to the right place in the buffer */ theCharP = inBufP; theCharP += *ioPosP; /* updates the current position in the read buffer */ *ioPosP += 4; /* extract the element according to the little-endian syntax */ theTmpULong = (PapyULong) (*(theCharP + 3)); theTmpULong = theTmpULong << 24; theULong |= theTmpULong; theTmpULong = (PapyULong) (*(theCharP + 2)); theTmpULong = theTmpULong << 16; theULong |= theTmpULong; theTmpULong = (PapyULong) (*(theCharP + 1)); theTmpULong = theTmpULong << 8; theULong |= theTmpULong; theTmpULong = (PapyULong) *theCharP; theULong |= theTmpULong; return theULong; } /* endof Extract4Bytes */ /********************************************************************************/ /* */ /* Extract8Bytes : extract a 8-Bytes value (FD) of the buf and */ /* increment pos accordingly. */ /* return : the extracted value */ /* */ /********************************************************************************/ PapyFloatDouble Extract8Bytes (unsigned char *inBufP, PapyULong *ioPosP) /*unsigned char *inBufP; the buffer to read from */ /*PapyULong *ioPosP; the position in the buffer */ { unsigned char *theCharP, theDoubleArr [8], i; PapyFloatDouble *theFloatDoubleP; /* points to the right place in the buffer */ theCharP = inBufP; theCharP += *ioPosP; /* updates the current position in the read buffer */ *ioPosP += 8; /* extract the element according to the little-endian syntax */ for (i = 0; i < 4; i++) { theDoubleArr [2 * i] = *theCharP; theDoubleArr [(2 * i) + 1] = *(theCharP + 1); theCharP += 2; } /* for ...extraction of the value */ theFloatDoubleP = (PapyFloatDouble *) &theDoubleArr; return *theFloatDoubleP; } /* endof Extract8Bytes */ /********************************************************************************/ /* */ /* ExtractString : extract a string from the buffer and put it in the */ /* given element. Increment pos accordingly. */ /* */ /********************************************************************************/ void ExtractString (SElement *ioElemP, unsigned char *inBufP, PapyULong *ioBufPosP, PapyULong inElemLength) { char *theStringP, *theP, *theCharValP, *theCharWrkP; unsigned char *theTmpP; int ii, j, theStringLength; /* 1 for the string terminator */ theStringP = (char *) emalloc3 ((PapyULong) (inElemLength + 1)); theP = theStringP; theTmpP = inBufP; /* extract the element from the buffer */ for (ii = 0L; ii < (int) inElemLength; ii++, (*ioBufPosP)++) *(theP++) = theTmpP [*ioBufPosP]; theStringP [ii] = '\0'; theCharValP = theStringP; theStringLength = strlen (theCharValP); ioElemP->nb_val = 1L; /* number of strings */ theCharWrkP = theCharValP; /* count the number of strings */ for (j = 0; j < theStringLength; j++, theCharWrkP ++) { /* value separator */ if (*theCharWrkP == '\\') { ioElemP->nb_val++; *theCharWrkP = '\0'; } /* if */ } /* for ...counting the number of values */ ioElemP->value = (UValue_T *) ecalloc3 ((PapyULong) ioElemP->nb_val, (PapyULong) sizeof (UValue_T)); /* extraction of the strings */ for (j = 0, theCharWrkP = theCharValP; j < (int) ioElemP->nb_val; j ++, theCharWrkP += theStringLength + 1) { theStringLength = strlen (theCharWrkP); /* addition to delete the blank if odd string */ if (ioElemP->vr == UI) { /* suppress the blank by shifting all the chars to the left */ /* old was : theCharWrkP [theStringLength - 1] == '0') */ if (theCharWrkP [theStringLength - 1] == 0x00) theCharWrkP [theStringLength - 1] = '\0'; } /* then ...VR = UI */ else { if (theCharWrkP [theStringLength - 1] == ' ') theCharWrkP [theStringLength - 1] = '\0'; } /* else ...VR <> UI */ ioElemP->value [j].a = theCharWrkP; } /* for ...extraction of the strings */ } /* endof ExtractString */ /********************************************************************************/ /* */ /* PutBufferInElement3 : fill_in an element structure (one element) */ /* from a buffer made of unsigned chars */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort PutBufferInElement3 (PapyShort inFileNb, unsigned char *ioBuffP, PapyULong inElemLength, SElement *ioElemP, PapyULong *ioBufPosP, PapyLong inInitFilePos) { Item *theSeqItemP, *theDSitemP; Object *theObjectP, *theObjectP2; /* MAL */ SElement *theSeqGroupP; UValue_T *theValueTP; unsigned char *theTmp0P, theTmp1, *theCharP; unsigned char theDoubleArr [8], theIncr; PapyLong theCurrFilePos, theInitialFilePos = inInitFilePos; PapyULong ii, i, j, thePosInSeq, thePosInItem, theSeqSize, theSeqGrSize, theImLength; PapyULong theTmpULong, theULong = 0L; PapyUShort theSeqGrNb, theElemNb, *theTmpUsP; /* *imOW */ char *theCharValP, *theCharWrkP; char *theStringP, *theP; int theEnumSeqNb, theStringLength, theFirstTime, theIsUndefItemLen; PapyShort theErr; /* extract the element depending on the value representation */ switch (ioElemP->vr) { case RET : *ioBufPosP += ioElemP->length; break; case SS : /* 16 bits binary signed */ ioElemP->nb_val = (PapyULong) (inElemLength / 2); ioElemP->value = (UValue_T *) ecalloc3 ((PapyULong) ioElemP->nb_val, (PapyULong) sizeof (UValue_T)); theValueTP = ioElemP->value; for (j = 0; j < ioElemP->nb_val; j++, theValueTP++) { /* points to the right place in the buffer */ theTmp0P = ioBuffP; theTmp0P += *ioBufPosP; /* updates the current position in the read buffer */ *ioBufPosP += 2L; /* extract the element according to the little-endian syntax */ theValueTP->ss = (PapyUShort) (*(theTmp0P + 1)); theValueTP->ss = theValueTP->ss << 8; theValueTP->ss |= (PapyUShort) *theTmp0P; } /* for */ break; /* SS */ case AT : case USS : /* 16 bits binary unsigned */ ioElemP->nb_val = (PapyULong) (inElemLength / 2); ioElemP->value = (UValue_T *) ecalloc3 ((PapyULong) ioElemP->nb_val, (PapyULong) sizeof (UValue_T)); theValueTP = ioElemP->value; for (j = 0; j < ioElemP->nb_val; j++, theValueTP++) { /* points to the right place in the buffer */ theTmp0P = ioBuffP; theTmp0P += *ioBufPosP; /* updates the current position in the read buffer */ *ioBufPosP += 2L; /* extract the element according to the little-endian syntax */ theValueTP->us = (PapyUShort) (*(theTmp0P + 1)); theValueTP->us = theValueTP->us << 8; theValueTP->us |= (PapyUShort) *theTmp0P; } /* for */ break; /* USS */ case SL : /* 32 bits binary signed */ ioElemP->nb_val = (PapyULong) (inElemLength / 4); ioElemP->value = (UValue_T *) ecalloc3 ((PapyULong) ioElemP->nb_val, (PapyULong) sizeof (UValue_T)); theValueTP = ioElemP->value; for (j = 0; j < ioElemP->nb_val; j++, theValueTP++) { /* points to the right place in the buffer */ theTmp0P = ioBuffP; theTmp0P += *ioBufPosP; /* updates the current position in the read buffer */ *ioBufPosP += 4L; /* extract the element according to the little-endian syntax */ theTmpULong = (PapyULong) (*(theTmp0P + 3)); theTmpULong = theTmpULong << 24; theULong = theTmpULong; theTmpULong = (PapyULong) (*(theTmp0P + 2)); theTmpULong = theTmpULong << 16; theULong |= theTmpULong; theTmpULong = (PapyULong) (*(theTmp0P + 1)); theTmpULong = theTmpULong << 8; theULong |= theTmpULong; theTmpULong = (PapyULong) *theTmp0P; theULong |= theTmpULong; theValueTP->sl = theULong; } /* for */ break; /* SL */ case UL : /* 32 bits binary unsigned */ ioElemP->nb_val = (PapyULong) (inElemLength / 4); ioElemP->value = (UValue_T *) ecalloc3 ((PapyULong) ioElemP->nb_val, (PapyULong) sizeof (UValue_T)); theValueTP = ioElemP->value; for (j = 0; j < ioElemP->nb_val; j++, theValueTP++) { /* points to the right place in the buffer */ theTmp0P = ioBuffP; theTmp0P += *ioBufPosP; /* updates the current position in the read buffer */ *ioBufPosP += 4L; /* extract the element according to the little-endian syntax */ theTmpULong = (PapyULong) (*(theTmp0P + 3)); theTmpULong = theTmpULong << 24; theULong = theTmpULong; theTmpULong = (PapyULong) (*(theTmp0P + 2)); theTmpULong = theTmpULong << 16; theULong |= theTmpULong; theTmpULong = (PapyULong) (*(theTmp0P + 1)); theTmpULong = theTmpULong << 8; theULong |= theTmpULong; theTmpULong = (PapyULong) *theTmp0P; theULong |= theTmpULong; theValueTP->ul = theULong; } /* for */ break; /* UL */ case FL : /* 32 bits binary floating */ ioElemP->nb_val = (PapyULong) (inElemLength / 4); ioElemP->value = (UValue_T *) ecalloc3 ((PapyULong) ioElemP->nb_val, (PapyULong) sizeof (UValue_T)); theValueTP = ioElemP->value; for (j = 0; j < ioElemP->nb_val; j++, theValueTP++) { /* points to the right place in the buffer */ theTmp0P = ioBuffP; theTmp0P += *ioBufPosP; /* updates the current position in the read buffer */ *ioBufPosP += 4L; /* extract the element according to the little-endian syntax */ theTmpULong = (PapyULong) (*(theTmp0P + 3)); theTmpULong = theTmpULong << 24; theULong = theTmpULong; theTmpULong = (PapyULong) (*(theTmp0P + 2)); theTmpULong = theTmpULong << 16; theULong |= theTmpULong; theTmpULong = (PapyULong) (*(theTmp0P + 1)); theTmpULong = theTmpULong << 8; theULong |= theTmpULong; theTmpULong = (PapyULong) *theTmp0P; theULong |= theTmpULong; theValueTP->fl = (float)theULong; } /* for */ break; /* FL */ case FD : /* 64 bits binary floating */ ioElemP->nb_val = (PapyULong) (inElemLength / 8); ioElemP->value = (UValue_T *) ecalloc3 ((PapyULong) ioElemP->nb_val, (PapyULong) sizeof (UValue_T)); theValueTP = ioElemP->value; for (j = 0; j < ioElemP->nb_val; j++, theValueTP++) { /* points to the right place in the buffer */ theTmp0P = ioBuffP; theTmp0P += *ioBufPosP; /* updates the current position in the read buffer */ *ioBufPosP += 8L; /* extract the element according to the little-endian syntax */ for (theIncr = 0; theIncr < 4; theIncr++) { theDoubleArr [2 * theIncr] = *theTmp0P; theDoubleArr [(2 * theIncr) + 1] = *(theTmp0P + 1); theTmp0P += 2; } /* for ...extraction of the value */ theValueTP->fd = *((PapyFloatDouble *) &theDoubleArr); } /* for */ break; /* FD */ case OB : /* 1 byte image */ ioElemP->nb_val = (PapyULong) 1L; ioElemP->value = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); /* allocate room for the element */ theCharP = (unsigned char *) emalloc3 ((PapyULong) inElemLength); /* copy the bits of the image to the value */ theTmp0P = theCharP; ioBuffP += *ioBufPosP; for (i = 0L; i < inElemLength; theTmp0P++, ioBuffP++, i++) { *theTmp0P = *ioBuffP; } /* for */ ioElemP->value->a = (char *) theCharP; *ioBufPosP += inElemLength; break; /* OB */ case OW : /* 2 Bytes image */ theValueTP = ioElemP->value; ioElemP->nb_val = (PapyULong) 1L; /*ioElemP->value= (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T));*/ ioElemP->value = (UValue_T *) ecalloc3 ((PapyULong) ioElemP->nb_val, (PapyULong) sizeof (UValue_T)); theImLength = inElemLength / 2; /* pixel data */ if (ioElemP->group == 0x7FE0 && ioElemP->element == 0x0010) { //#ifndef __alpha /* swap the bytes (little endian) */ for (i = 0L, theCharP = ioBuffP + (*ioBufPosP); i < theImLength; i++, theCharP += 2) { theTmp1 = *(theCharP + 1); *(theCharP + 1) = *theCharP; *theCharP = theTmp1; } /* for */ //#endif ioElemP->value->ow = (PapyUShort *) (ioBuffP + (*ioBufPosP)); } /* if ...pixel data */ else /* not pixel data */ { ioElemP->value->ow = (PapyUShort *) ecalloc3 ((PapyULong) theImLength, (PapyULong) sizeof (PapyUShort)); /*ioElemP->value->ow = (PapyUShort *) emalloc3 ((PapyULong)theImLength * sizeof (PapyUShort) + 1L);*/ for (i = 0L, theTmpUsP = ioElemP->value->ow, ioBuffP += *ioBufPosP; i < theImLength; i++, theTmpUsP++, ioBuffP += 2) { *theTmpUsP = (PapyUShort) (*(ioBuffP + 1)); *theTmpUsP = *theTmpUsP << 8; *theTmpUsP |= (PapyUShort) *ioBuffP; } /* for */ /*ioElemP->value->ow = imOW;*/ } /* else ...not pixel data */ *ioBufPosP += inElemLength; break; /* OW */ case SQ : /* sequence */ /* if not the pointer sequence or the image sequence extract the seq */ if (!(ioElemP->group == 0x0041 && (ioElemP->element == Papy3EnumToElemNb (ioElemP, papPointerSequenceGr) || ioElemP->element == Papy3EnumToElemNb (ioElemP, papImageSequenceGr))) && !(ioElemP->group == 0x0088 && ioElemP->element == Papy3EnumToElemNb (ioElemP, papIconImageSequenceGr))) { ioElemP->nb_val = 1L; ioElemP->value = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); ioElemP->value->sq = NULL; /* loop on the items of the sequence */ thePosInSeq = 0L; theFirstTime = TRUE; /*theIsUndefItemLen = FALSE;*/ while (thePosInSeq < inElemLength) { theIsUndefItemLen = FALSE; /* read the basic info on the item */ if ((theSeqGrNb = Extract2Bytes (ioBuffP, ioBufPosP)) != 0xFFFE) RETURN (papGroupNumber); if ((theElemNb = Extract2Bytes (ioBuffP, ioBufPosP)) != 0xE000) RETURN (papElemNumber); theSeqSize = Extract4Bytes (ioBuffP, ioBufPosP); thePosInSeq += 8L; /* size of the item delimiter */ thePosInItem = 0L; /* the position in this item of the sequence */ /* if undefined item length, compute it */ if (theSeqSize == 0xFFFFFFFF) { /* set a boolean for futur computing of the seq length */ theIsUndefItemLen = TRUE; /* get the current position of the file pointer */ theErr = Papy3FTell (gPapyFile [inFileNb], &theCurrFilePos); /* position the file pointer at the begining of the item */ theErr = Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, (theInitialFilePos + (PapyLong) (*ioBufPosP))); /* computes the item length from the file */ theSeqSize = 0L; theErr = ComputeUndefinedItemLength3 (inFileNb, &theSeqSize); /* reset the file pointer to its previous position */ theErr = Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, theCurrFilePos); } /* if */ /* creates an empty object that will point to the list of groups */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papItem; theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->group = NULL; theObjectP->record = NULL; theObjectP->tmpFileLength = 0L; theSeqItemP = InsertLastInList (&(ioElemP->value->sq), theObjectP); /* keep track of the place where to insert a new object (group) */ /*theSeqItemP = theObjectP->item; /* problem de conservation du pointeur */ /* loop on the groups of the item */ /*while (theSeqSize > (thePosInSeq - 8L))*/ /*while (inElemLength > (thePosInSeq - 8L))*/ /*while (inElemLength > thePosInSeq) last = CHG 5.11.99 */ /*while (theSeqSize > thePosInSeq) last = CHG 8.11.99 */ /*while (theSeqSize > (thePosInSeq - 8L)) last = CHG 8.11.99 */ /* or see PapOldPatch.tar.gzip */ if (theSeqSize > 8L) while (theSeqSize > thePosInItem) { /* read the basic info on the new group */ theSeqGrNb = Extract2Bytes (ioBuffP, ioBufPosP); theElemNb = Extract2Bytes (ioBuffP, ioBufPosP); /* test if it is the group length element */ if (theElemNb == 0x0000) { /* jump over : implicit : the length of the element (1 * 4 bytes) */ /* explicit : the VR and the length of the element (2 * 2 bytes) */ *ioBufPosP += 4L; theSeqGrSize = Extract4Bytes (ioBuffP, ioBufPosP); /* the theFirstTime ioElemP must be taken into account ... */ theSeqGrSize += 12L; /* reset the ioBuffP pos to begining of the group */ *ioBufPosP -= 12L; } /* if ...ioElemP = group length */ /* else, we have to compute the group length */ else { /* reset the ioBuffP pos to the begining of the group */ *ioBufPosP -= 4L; /* get the current position of the file pointer */ theErr = Papy3FTell (gPapyFile [inFileNb], &theCurrFilePos); /* position the file pointer at the begining of the item */ theErr = Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, (theInitialFilePos + (PapyLong) (*ioBufPosP))); /* computes the group length */ theSeqGrSize = ComputeUndefinedGroupLength3 (inFileNb, (PapyLong) theSeqSize); /* then reset the file pointer to its previous position */ theErr = Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, theCurrFilePos); } /* else ...compute the group length */ /* search the enum group number */ theEnumSeqNb = Papy3ToEnumGroup (theSeqGrNb); /* it could be a private group that has an unknown definition */ if (theEnumSeqNb < 0) { /* add the group size plus grNb and elemNb */ thePosInSeq += theSeqGrSize; thePosInItem+= theSeqGrSize; *ioBufPosP += theSeqGrSize; } /* if ...private group with unknown definition */ /* known group => extract it from the buffer */ else { /* create the group */ theSeqGroupP = Papy3GroupCreate (theEnumSeqNb); /* fill the group struct from the content of the buffer */ theErr = PutBufferInGroup3 (inFileNb, ioBuffP, theSeqGroupP, theSeqGrNb, theSeqGrSize, ioBufPosP, theInitialFilePos); if (theErr < 0) { efree3 ((void **) &ioBuffP); RETURN (theErr); } /* if ...theErr */ thePosInSeq += theSeqGrSize; /* add the grNb and elemNb */ thePosInItem+= theSeqGrSize; /* creation of the object that will encapsulate the group */ theObjectP2 = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP2->whoAmI = papGroup; theObjectP2->objID = theEnumSeqNb; theObjectP2->group = theSeqGroupP; theObjectP2->item = NULL; theObjectP2->module = NULL; theObjectP2->tmpFileLength = 0L; /* add the object to the list of this element */ theDSitemP = InsertLastInList ((Item **) &(theObjectP->item), theObjectP2); /*theObjectP->item = theDSitemP; /* MAL added */ /* MAL theDSitemP = InsertLastInList ((Item **) &theSeqItemP, theObjectP); if (theFirstTime) { theFirstTime = FALSE; ioElemP->value->sq->object->item = theDSitemP; } /* if ...theFirstTime time we are in the loop */ } /* else ..known group = extracted group */ } /* while ...loop on the groups of the item */ /* if it was an item with undefined length move the buffer further the delimiter */ if (theIsUndefItemLen) { thePosInSeq += 8L; *ioBufPosP += 8L; } /* if */ } /* while ...loop on the items of the sequence */ } /* if ...not pointer or image sequence */ /* pointer or image sequence group 41 */ else { /* there is a value, but set to NULL */ ioElemP->nb_val = 1L; /* CHG */ ioElemP->value = NULL; } /* else ...pointer or image sequence */ break; case AE : case AS : case CS : case DA : case DS : case DT : case IS : case LO : case LT : case PN : case SH : case ST : case TM : case UI : case UN : case UT : /* all kind of strings */ /*theCharValP = ExtractString (ioBuffP, ioBufPosP, inElemLength);*/ /* 1 for the string terminator */ theStringP = (char *) emalloc3 ((PapyULong) (inElemLength + 1L)); theP = theStringP; theTmp0P = ioBuffP; /* extract the element from the buffer */ for (ii = 0L; ii < inElemLength; ii++, (*ioBufPosP)++) { *(theP++) = theTmp0P [(int) *ioBufPosP]; } theStringP [ii] = '\0'; theCharValP = theStringP; theStringLength = strlen (theCharValP); ioElemP->nb_val = 1L; /* number of strings */ theCharWrkP = theCharValP; /* count the number of strings */ for (j = 0; j < (PapyULong)theStringLength; j++, theCharWrkP ++) { /* value separator */ if (*theCharWrkP == '\\') { ioElemP->nb_val++; *theCharWrkP = '\0'; } /* if */ } /* for ...counting the number of values */ ioElemP->value = (UValue_T *) ecalloc3 ((PapyULong) ioElemP->nb_val, (PapyULong) sizeof (UValue_T)); /* extraction of the strings */ for (j = 0, theCharWrkP = theCharValP; j < ioElemP->nb_val; j ++, theCharWrkP += theStringLength + 1) { theStringLength = strlen (theCharWrkP); /* addition to delete the blank if odd string */ if (ioElemP->vr == UI) { /* suppress the blank by shifting all the chars to the left */ /* old was : theCharWrkP [theStringLength - 1] == '0') */ if (theCharWrkP [theStringLength - 1] == 0x00) theCharWrkP [theStringLength - 1] = '\0'; } /* then ...VR = UI */ else if (theCharWrkP [theStringLength - 1] == ' ') theCharWrkP [theStringLength - 1] = '\0'; ioElemP->value[j].a = PapyStrDup (theCharWrkP); } /* for ...extraction of the strings */ efree3 ((void **) &theStringP); break; /* strings */ } /* switch ...value representation */ return 0; } /* endof PutBufferInElement3 */ /********************************************************************************/ /* */ /* PutBufferInGroup3 : fill_in a group structure (all the elements) */ /* from a buffer made of unsigned chars */ /* return : the enum group number if successfull */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort PutBufferInGroup3 (PapyShort inFileNb, unsigned char *ioBuffP, SElement *ioGroupP, PapyUShort inPapyGrNb, PapyULong inBytesToRead, PapyULong *ioBufPosP, PapyLong inInitFilePos) { SElement *theArrElemP; PapyULong theElemLength; PapyULong j, theInitialBufPos; PapyULong theTmpULong, theULong = 0L; PapyLong theInitialFilePos, theCurrFilePos; PapyUShort theGrNb; PapyUShort theElemNb, theElemLengthGr2; char theFoo [3], *theFooP; unsigned char *theCharP; int theStructPos, theEnumGrNb, i, theIsOld, theIsUndefSeqLen = FALSE; int theShadow, theEnabledShadow [0x00FF], theMaxElem; PapyShort theErr, theCreator; theInitialBufPos = *ioBufPosP; theInitialFilePos = inInitFilePos; theIsOld = TRUE; theEnumGrNb = Papy3ToEnumGroup (inPapyGrNb); /* gr_nb papyrus -> enum */ if (theEnumGrNb < 0) /* unknown group number */ { efree3 ((void **) &ioBuffP); RETURN (papGroupNumber) } /* if */ /* the number of elements of this group */ theMaxElem = gArrGroup [theEnumGrNb].size; if (inPapyGrNb >= 0x6000 && inPapyGrNb <= 0x6FFF) /* overlay or UIN overlay */ { for (j = 0, theArrElemP = ioGroupP; j < (PapyULong)theMaxElem; j++, theArrElemP++) theArrElemP->group = inPapyGrNb; } /* if ...overlay or UINOverlay group */ if (inPapyGrNb % 2 != 0) /* is it a shadow group ? */ { theShadow = TRUE; /* disables all elements (initialisation) */ for (i = 0; i < 0x00FF; i++) theEnabledShadow [i] = FALSE; } /* then */ else theShadow = FALSE; theArrElemP = ioGroupP; while ((*ioBufPosP - theInitialBufPos) < inBytesToRead) /* loop on the elements */ { theIsUndefSeqLen = FALSE; theStructPos = 0; /* pos in the array of elements */ /* points to the right place in the buffer */ theCharP = ioBuffP; theCharP += *ioBufPosP; /* extract the group number according to the little-endian syntax */ theGrNb = (PapyUShort) (*(theCharP + 1)); theGrNb = theGrNb << 8; theGrNb |= (PapyUShort) *theCharP; /* updates the current position in the read buffer */ *ioBufPosP += 2L; /* points to the right place in the buffer */ theCharP += 2; /* extract the element according to the little-endian syntax */ theElemNb = (PapyUShort) (*(theCharP + 1)); theElemNb = theElemNb << 8; theElemNb |= (PapyUShort) *theCharP; /* updates the current position in the read buffer */ *ioBufPosP += 2L; /* points to the right place in the buffer */ theCharP += 2; /* some special test for the group 2 are necessary */ if (theGrNb == 0x0002) { /* test to discover which transfert syntax was used to create the file (implicit or explicit VR) */ theFooP = (char *) &theFoo [0]; theFooP [0] = (char) *theCharP; theFooP [1] = (char) (*(theCharP + 1)); theFooP [2] = '\0'; /* if the VR is unknown assume the group 2 is using implicit VR */ if (!(strcmp (theFooP, "AE") == 0 || strcmp (theFooP, "AS") == 0 || strcmp (theFooP, "AT") == 0 || strcmp (theFooP, "CS") == 0 || strcmp (theFooP, "DA") == 0 || strcmp (theFooP, "DS") == 0 || strcmp (theFooP, "DT") == 0 || strcmp (theFooP, "FL") == 0 || strcmp (theFooP, "FD") == 0 || strcmp (theFooP, "IS") == 0 || strcmp (theFooP, "LO") == 0 || strcmp (theFooP, "LT") == 0 || strcmp (theFooP, "OW") == 0 || strcmp (theFooP, "PN") == 0 || strcmp (theFooP, "SH") == 0 || strcmp (theFooP, "SL") == 0 || strcmp (theFooP, "SQ") == 0 || strcmp (theFooP, "SS") == 0 || strcmp (theFooP, "ST") == 0 || strcmp (theFooP, "TM") == 0 || strcmp (theFooP, "UI") == 0 || strcmp (theFooP, "UL") == 0 || strcmp (theFooP, "UN") == 0 || strcmp (theFooP, "US") == 0 || strcmp (theFooP, "UT") == 0 || strcmp (theFooP, "OB") == 0)) gArrTransfSyntax [inFileNb] = LITTLE_ENDIAN_IMPL; /* if there are OB values in group 2 it is a recent version of the toolkit ( > 3.3) */ /* the theIsOld variable will be used later in the code of this routine */ if (strcmp (theFooP, "OB") == 0) theIsOld = FALSE; } /* if ...group 2 */ /* test wether the transfert syntax is the little-endian explicit VR one */ if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL) { /* extract the VR */ theFooP = (char *) &theFoo [0]; theFooP [0] = (char) *theCharP; theFooP [1] = (char) (*(theCharP + 1)); theFooP [2] = '\0'; /* updates the current position in the read buffer */ *ioBufPosP += 2L; /* points to the right place in the buffer */ theCharP += 2; /* extract the element length depending on the extracted VR */ if (strcmp (theFooP, "OB") == 0 || strcmp (theFooP, "OW") == 0 || strcmp (theFooP, "SQ") == 0 || strcmp (theFooP, "UN") == 0 || strcmp (theFooP, "UT") == 0) { /* updates the current position in the read buffer by jumping over the 2 bytes set to 0 */ *ioBufPosP += 2L; /* points to the right place in the buffer */ theCharP += 2; /* extract the element length according to the little-endian explicit VR syntax */ theTmpULong = (PapyULong) (*(theCharP + 3)); theTmpULong = theTmpULong << 24; theULong = theTmpULong; theTmpULong = (PapyULong) (*(theCharP + 2)); theTmpULong = theTmpULong << 16; theULong |= theTmpULong; theTmpULong = (PapyULong) (*(theCharP + 1)); theTmpULong = theTmpULong << 8; theULong |= theTmpULong; theTmpULong = (PapyULong) *theCharP; theULong |= theTmpULong; theElemLength = theULong; /* updates the current position in the read buffer */ *ioBufPosP += 4L; } /* if ...VR = OB, OW or SQ */ else { /* extract the element length according to the little-endian explicit VR syntax */ theElemLengthGr2 = (PapyUShort) (*(theCharP + 1)); theElemLengthGr2 = theElemLengthGr2 << 8; theElemLengthGr2 |= (PapyUShort) *theCharP; theElemLength = (PapyULong) theElemLengthGr2; /* updates the current position in the read buffer */ *ioBufPosP += 2L; } /* else ...other VRs */ } /* if ...transfert syntax is little_endian explicit VR */ /* little_endian implicit VR */ else { /* extract the element length according to the little-endian implicit VR syntax */ theTmpULong = (PapyULong) (*(theCharP + 3)); theTmpULong = theTmpULong << 24; theULong = theTmpULong; theTmpULong = (PapyULong) (*(theCharP + 2)); theTmpULong = theTmpULong << 16; theULong |= theTmpULong; theTmpULong = (PapyULong) (*(theCharP + 1)); theTmpULong = theTmpULong << 8; theULong |= theTmpULong; theTmpULong = (PapyULong) *theCharP; theULong |= theTmpULong; theElemLength = theULong; /* updates the current position in the read buffer */ *ioBufPosP += 4L; } /* else ...little_endian implicit VR */ /* it could be an undefined length, i.e. VR = SQ or VR = UN */ if (theElemLength == 0xFFFFFFFF) { /* for futur move of the buffer pointer */ /* a Sequence Delimiter Item (8 bytes: (FFFE,E0DD) et 00000000) will be added */ /* at the end of the data element value ...*/ theIsUndefSeqLen = TRUE; theElemLength = 0L; if (!(theGrNb == 0x7FE0 && theElemNb == 0x0010)) { /* get the current file position */ theErr = Papy3FTell (gPapyFile [inFileNb], &theCurrFilePos); /* position the file pointer to point to the item */ theErr = Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, theInitialFilePos + (PapyLong) (*ioBufPosP)); if ((theErr = ComputeUndefinedSequenceLength3 (inFileNb, &theElemLength)) < 0) RETURN (theErr); /* theElemLength should not contain the Sequence Delimitation Item which exist only if we have a Data Element of undefined length */ if (theIsUndefSeqLen) theElemLength -= 8L; /* reset the file pointer to its previous position */ theErr = Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, theCurrFilePos); } /* if ...not image pixel */ else /* just decide it is the last readable thing */ theElemLength = inBytesToRead - (*ioBufPosP - theInitialBufPos); } /* if ...undefined length */ /* odd element length are forbidden */ if (theElemLength % 2 != 0) RETURN (papLengthIsNotEven); /* it is a shadow group, so we are looking dynamically for our element range */ if (theShadow && theElemNb >= 0x0010 && theElemNb <= 0x00FF) { theCreator = Papy3CheckValidOwnerId (inFileNb, ioBuffP, ioBufPosP, theElemNb, theElemLength, ioGroupP); /* look for the position in the enum of the group */ if (theCreator) { while (theStructPos <= theMaxElem && theElemNb != theArrElemP [theStructPos].element) theStructPos++; theEnabledShadow [theArrElemP [theStructPos].element] = TRUE; } /* if */ } /* if */ else { if (!theShadow || (theShadow && theElemNb < 0x0010) || (theShadow && theElemNb >= 0x1000 && theEnabledShadow [theElemNb >> 8])) { /* search the element in the array */ while (theStructPos <= theMaxElem && theElemNb != theArrElemP [theStructPos].element) theStructPos++; /* element number out of range */ if (theStructPos >= theMaxElem) { /* it could be an unknown element (who knows with DICOM ?) */ /* so we just skip the element */ *ioBufPosP += theElemLength; } /* if */ else { theArrElemP [theStructPos].length = theElemLength; /* there has been a change in the dictionary. */ /* This helps the new version to read the old files ( < 3.3) */ if (theIsOld && theGrNb == 0x0002 && (theElemNb == 0x0001 || theElemNb == 0x0102)) theArrElemP [theStructPos].vr = USS; /* extract the value of the element from the buffer */ if (theElemLength > 0 && !(theArrElemP [theStructPos].group == 0x7FE0 && theArrElemP [theStructPos].element == 0x0010)) { /* extract the element depending on the value representation */ if ((theErr = PutBufferInElement3 (inFileNb, ioBuffP, theElemLength, &theArrElemP [theStructPos], ioBufPosP, theInitialFilePos)) < 0) RETURN (theErr); /* if it was a sequence with an undefined length, move the buffer accordingly */ if (theIsUndefSeqLen) *ioBufPosP += 8L; } /* if ...theElemLength > 0 */ } /* else ...element found */ } /* if ...we can read this element */ else /* we dont know how to read this element... */ *ioBufPosP += theElemLength; /* ...so we skip it */ } /* else ...not creator of a private data element */ } /* while ... loop on the elements */ return (PapyShort) theEnumGrNb; } /* endof PutBufferInGroup3 */ /********************************************************************************/ /* */ /* Papy3GroupRead : read the group from the file in a buffer then fill_in */ /* the group structure (all the elements) from the buffer. */ /* return : the group number (in the enum_type) if able to fill it */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3GroupRead (PapyShort inFileNb, SElement **ioGroupP) { unsigned char *theBuffP; PapyULong theBytesToRead, theGrLength, theBufPos; PapyLong theInitFilePos; PapyUShort thePapyGrNb; PapyShort theErr; int theEnumGrNb; enum ETransf_Syntax thePrevSyntax; /* get the position in the file for any eventual unknown seq length */ theErr = Papy3FTell (gPapyFile [inFileNb], &theInitFilePos); theBufPos = 0L; /* read the buffer from the file */ if (ReadGroup3 (inFileNb, &thePapyGrNb, &theBuffP, &theBytesToRead, &theGrLength) < 0) { efree3 ((void **) &theBuffP); RETURN (papReadGroup) } /* if */ /* makes sure we keep the right syntax and set the default syntax instead */ if (thePapyGrNb == 0x0002) { thePrevSyntax = gArrTransfSyntax [inFileNb]; gArrTransfSyntax [inFileNb] = LITTLE_ENDIAN_EXPL; } /* if */ theEnumGrNb = Papy3ToEnumGroup (thePapyGrNb); /* gr_nb papyrus -> enum */ if (theEnumGrNb < 0) /* unknown group number */ { efree3 ((void **) &theBuffP); RETURN (papGroupNumber) } /* if */ /* allocates the structure of the given group */ *ioGroupP = Papy3GroupCreate (theEnumGrNb); /* if the group do not have the group length element, fill it ... */ if (theGrLength != 0) { (*ioGroupP)->nb_val = 1L; (*ioGroupP)->value = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); (*ioGroupP)->value->ul = theGrLength; } /* if ...undefined group length */ /* extract the elements of the buffer and put them in the group structure */ theBufPos = 0L; theErr = PutBufferInGroup3 (inFileNb, theBuffP, *ioGroupP, thePapyGrNb, theBytesToRead, &theBufPos, theInitFilePos); if (theErr < 0) { efree3 ((void **) &theBuffP); RETURN (theErr); } /* if */ /* frees the read buffer */ efree3 ((void **) &theBuffP); /* restore any previous transfert syntax */ if (thePapyGrNb == 0x0002) gArrTransfSyntax [inFileNb] = thePrevSyntax; RETURN ((PapyShort) thePapyGrNb); } /* endof Papy3GroupRead */ Papyrus3/PapyUtils3.c0000755000175000017500000007470310044200354011713 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyUtils3.c */ /* Function : contains all the utility functions */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 04.1991 version 1.1 */ /* 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifdef Mac #pragma segment papy3 #endif /* ------------------------- includes ---------------------------------------*/ #include #include #ifndef Papyrus3H #include "Papyrus3.h" #endif /********************************************************************************/ /* */ /* Papy3SetIconSize : set the size of the icon pixel data. The icon is */ /* square. */ /* */ /********************************************************************************/ void CALLINGCONV Papy3SetIconSize (PapyUShort inSize) { gIconSize = inSize; } /* endof Papy3SetIconSize */ /********************************************************************************/ /* */ /* Papy3GetIconSize : get the size of the icon pixel data. The icon is */ /* square. */ /* */ /********************************************************************************/ PapyUShort CALLINGCONV Papy3GetIconSize () { return gIconSize; } /* endof Papy3GetIconSize */ /********************************************************************************/ /* */ /* PapyStrDup : home made duplification of a string */ /* return : the pointer on the duplicated string */ /* */ /********************************************************************************/ char * PapyStrDup (char *inS) { char *theStr; if (inS != NULL) { theStr = (char *) emalloc3 ((PapyULong) (strlen (inS) + 1)); strcpy (theStr, inS); } else theStr = NULL; return theStr; } /* endof PapyStrDup */ /********************************************************************************/ /* */ /* Papy3GotoUID : goto the specified data set or the image given the UID */ /* nota : the images are referenced from 1 to nb_images. */ /* return : 0 if there is no error */ /* papUIDUnknow if the UID is unknow */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3GotoUID (PapyShort inFileNb, char *inUIDP, enum EDataSet_Image inDSorIM) /*int inFileNb; file pointer */ /*char *inUIDP; Data Set IDentificator */ /*enum EDataSet_Image inDSorIM; is it a Data Set or an Image ? */ { char **theUIDP; int theNumber = 1; /* corresponding number */ theUIDP = gImageSOPinstUID [inFileNb]; if (*theUIDP == NULL) RETURN (papProblemInValue); while (theNumber <= gArrNbImages [inFileNb] && strcmp (*theUIDP, inUIDP) != 0) { theUIDP++; theNumber++; } /* while */ if (theNumber > gArrNbImages [inFileNb]) RETURN (papUIDUnknow) else RETURN (Papy3GotoNumber (inFileNb, theNumber, inDSorIM)); } /* endof Papy3GotoUID */ /********************************************************************************/ /* */ /* Papy3GotoNumber : goto the data set or the image from its number */ /* nota : the first image has a number of 1. */ /* return : 0 if all is OK */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3GotoNumber (PapyShort inFileNb, PapyShort inNb, enum EDataSet_Image inDSorIM) /*PapyShort inNb; the position of the offset in the list */ /*enum EDataSet_Image inDSorIM; is it a Data Set or an Image ? */ { PapyULong theOffset; if (inDSorIM == DataSetID) theOffset = *(gRefImagePointer [inFileNb] + inNb - 1); else theOffset = *(gRefPixelOffset [inFileNb] + inNb - 1); /* move the file pointer */ if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) theOffset) < 0) RETURN (papPositioning); RETURN (papNoError); } /* endof Papy3GotoNumber */ /********************************************************************************/ /* */ /* Papy3CheckValidOwnerId : check if the present code can read the current */ /* range of element of the shadow group (i.e.: are we the owner of this */ /* range ?). It extracts the value of the element, and if necessary change */ /* the group definition for the given range. */ /* return : TRUE if we are the owner of the element (i.e.: we can read it) */ /* FALSE if we are not the owner,or if we dont know this element */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3CheckValidOwnerId (PapyShort inFileNb, unsigned char *inBuffP, PapyULong *ioBufPosP, PapyUShort inElemNb, PapyULong inElemLength, SElement *inGroupP) /*unsigned char *inBuffP; the buffer to read from */ /*PapyULong *ioBufPosP; the position in the read buffer */ /*PapyULong inElemLength; the length of the element */ /*SElement *inGroupP; the pointer to the group */ { int i, found = FALSE; SShadowOwner *theShOwP; SElement *theElemP; char *theStringP, *theP; unsigned char *theTmpP; PapyUShort theDefElemNb, theOldNb; PapyULong ii, theGrSize; /* extract the element value (string value) we know it has a VM = 1 */ /*char_val = extract_char (buff, ioBufPosP, inElemLength);*/ /* 1 for the string terminator */ theStringP = (char *) emalloc3 ((PapyULong) (inElemLength + 1)); theP = theStringP; theTmpP = inBuffP; /* extract the element from the buffer */ for (ii = 0L; ii < inElemLength; ii++, (*ioBufPosP)++) { *(theP++) = theTmpP [(int) *ioBufPosP]; } theStringP [ii] = '\0'; /* string terminator */ /* see if this version of PAPYRUS knows the definition of this range */ for (i = 0, theShOwP = gShadowOwner [inFileNb]; i < gNbShadowOwner [inFileNb]; i++, theShOwP++) { /* compares the read value with the known values */ if (strncmp (theStringP, theShOwP->str_value, strlen (theShOwP->str_value)) == 0) { /* we own this range of elements */ /* find this element in the group definition */ theElemP = inGroupP; theGrSize = gArrGroup [Papy3ToEnumGroup (inGroupP->group)].size; ii = 0L; while ((ii < theGrSize) && !found) { if (theElemP->value != NULL && theElemP->value->a != NULL && theElemP->vr != SS && theElemP->vr != USS && theElemP->vr != AT && theElemP->vr != OW && theElemP->vr != SL && theElemP->vr != UL && theElemP->vr != FL && theElemP->vr != FD && theElemP->vr != SQ && (strncmp (theElemP->value->a, theStringP, strlen (theShOwP->str_value)) == 0)) found = TRUE; else { theElemP++; ii++; } /* else */ } /* while */ if (!found) {efree3 ((void **) &theStringP); return FALSE;} /* error ...! */ /* BEWARE : it is not necessary to assign the value to the element as */ /* the right value has been introduced during the initialisation step */ /* different element number => set the element numbers for the whole group */ if (theElemP->element != inElemNb) { theDefElemNb = theElemP->element; /* originaly defined range */ /* change the definition of the creator... */ theElemP->element = inElemNb; theElemP = inGroupP; /* loop on the elements of the group */ for (ii = 0L; ii < theGrSize; ii++, theElemP++) { /* we have to change this elements definition */ if (theElemP->element >> 8 == theDefElemNb) { theOldNb = theElemP->element; /* this deletes the range information and keeps only the element one */ theOldNb = theOldNb << 8; theOldNb = theOldNb >> 8; /* assign the new element number given the extracted range */ theElemP->element = inElemNb << 8; theElemP->element |= theOldNb; } /* if ...change element definition */ } /* for ...loop on the elements of the group */ } /* if ...element numbers must be changed */ efree3 ((void **) &theStringP); return TRUE; /* exits the research loop and the procedure */ } /* if ...we are the owner of this range of elements */ } /* for */ efree3 ((void **) &theStringP); return FALSE; /* if we have reached this point we dont know this element */ } /* endof Papy3CheckValidOwnerId */ /********************************************************************************/ /* */ /* Papy3ToEnumGroup : given the real number (short) of the group returns */ /* the enum_place of this group (as it is defined in "PapyInitGroups3.h") */ /* return : positive number (= enumeration place) if we were successful */ /* standard error message otherwise */ /* */ /********************************************************************************/ int CALLINGCONV Papy3ToEnumGroup (PapyUShort inPapyrusNb) /*PapyUShort inPapyrusNb; the Papyrus defined number */ { int i, theEnumPlace; theEnumPlace = -1; /* there could be more than one OVERLAY in a group, */ /* but all have the same enumeration number */ if (inPapyrusNb >= 0x6000 && inPapyrusNb <= 0x6FFF) if (inPapyrusNb % 2 == 0) return Group6000; else return UINOVERLAY; else for (i = 0; i < END_GROUP; i ++) { if (gArrGroup[i].number == inPapyrusNb) return i; } /* for */ RETURN (papEnumGroup) } /* endof Papy3ToEnumGroup */ /********************************************************************************/ /* */ /* Papy3EnumToElemNb : given the enum name of an element find the element */ /* number in the group definition. This is especially usefull with the */ /* odd number groups (private data elements). */ /* return : positive number (= elem nb) if we were successful */ /* */ /********************************************************************************/ PapyUShort CALLINGCONV Papy3EnumToElemNb (SElement *inElemP, int inEnumNb) { SElement *theElemP; /* look for the pointer to the begining of the group */ theElemP = inElemP; while (theElemP->element != 0x0000) theElemP--; /* now goto the desired element */ theElemP += inEnumNb; return theElemP->element; } /* endof Papy3EnumToElemNb */ /********************************************************************************/ /* */ /* Papy3ElemTagToEnumNb : given the elem tag (gr, elem) look for the enum */ /* number in the group definition. */ /* return : positive number (= elem nb) if we were successful */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3ElemTagToEnumNb (PapyUShort inGrTag, PapyUShort inElemTag, int *outEnumGrP, int *outEnumElemP) { SElement *theElemP, *theGroupP; /* first convert the gr tag to enum position */ *outEnumGrP = Papy3ToEnumGroup (inGrTag); /* create the group in order to scan it */ theGroupP = Papy3GroupCreate (*outEnumGrP); /* look for the element in the group */ theElemP = theGroupP; for (*outEnumElemP = 0; *outEnumElemP < (int) gArrGroup [*outEnumGrP].size; (*outEnumElemP)++, theElemP++) if (theElemP->element == inElemTag) break; /* delete the group */ Papy3GroupFree (&theGroupP, TRUE); /* not found */ if (*outEnumElemP == (int) gArrGroup [*outEnumGrP].size) RETURN (papNotFound); /* found */ return 0; } /* endof Papy3ElemTagToEnumNb */ /********************************************************************************/ /* */ /* ExtractDicomdirFromPath : Papyrus function to extract the DICOMDIR */ /* name from a whole file path. */ /* */ /********************************************************************************/ void ExtractDicomdirFromPath (char *inFilePathP, char *outExtrNameP) { int length; int toExtract = 8; /* length of the DICOMDIR string */ int i; /* first check that the file path is not NULL */ if (inFilePathP == NULL) { outExtrNameP [0] = '\0'; return; } /* if ...file path NULL */ /* initialization */ length = (int) strlen (inFilePathP); /* one more if ISO 9XXXX encoding */ if (inFilePathP [length - 1] == '.') toExtract++; /* it is not necessary to get any further */ if (length < toExtract) { outExtrNameP [0] = '\0'; return; } /* if ...file path smaller than DICOMDIR name */ /* copy the last toExtract chars from the file path */ for (i = 0; i < toExtract; i++) { outExtrNameP [i] = inFilePathP [(length - (toExtract)) + i]; } /* for */ outExtrNameP [toExtract] = '\0'; } /* endof ExtractDicomdirFromPath */ /********************************************************************************/ /* */ /* ExtractModality : Papyrus function to extract the modality */ /* */ /********************************************************************************/ void ExtractModality (UValue_T *inValP, PapyShort inFileNb) { int i; char theModality [8]; /* is there a value ? */ if (inValP != NULL) { strcpy (theModality, inValP->a); switch (theModality [0]) { case 'A' : i = (int) CR_IM; break; case 'B' : i = (int) MR_IM; break; case 'C' : switch (theModality [1]) { case 'R' : i = (int) CR_IM; break; case 'T' : i = (int) CT_IM; break; case 'D' : i = (int) US_IM; break; case 'F' : i = (int) CR_IM; break; case 'P' : i = (int) SEC_CAPT_IM; break; case 'S' : i = (int) SEC_CAPT_IM; break; } /* switch */ break; case 'D' : switch (theModality [1]) { case 'S' : i = (int) CR_IM; break; case 'D' : i = (int) US_IM; break; case 'F' : i = (int) CR_IM; break; case 'G' : i = (int) SEC_CAPT_IM; break; case 'M' : i = (int) SEC_CAPT_IM; break; case 'X' : i = (int) DX_IM; break; } /* switch */ break; case 'E' : switch (theModality [1]) { case 'C' : i = (int) CR_IM; break; case 'S' : i = (int) SEC_CAPT_IM; break; } /* switch */ break; case 'F' : switch (theModality [1]) { case 'A' : i = (int) SEC_CAPT_IM; break; case 'S' : i = (int) SEC_CAPT_IM; break; } /* switch */ break; case 'I' : switch (theModality [1]) { case 'O' : i = (int) IO_IM; break; } /* switch */ break; case 'L' : switch (theModality [1]) { case 'P' : i = (int) SEC_CAPT_IM; break; case 'S' : i = (int) SEC_CAPT_IM; break; } /* switch */ break; case 'M' : switch (theModality [1]) { case 'A' : i = (int) MR_IM; break; case 'G' : i = (int) MG_IM; break; case 'R' : i = (int) MR_IM; break; case 'S' : i = (int) MR_IM; break; default : switch (theModality [2]) { case 'S' : i = (int) MFSBSC_IM; case 'T' : i = (int) MFTCSC_IM; case 'G' : switch (theModality [3]) { case 'B' : i = (int) MFGBSC_IM; case 'W' : i = (int) MFGWSC_IM; } /* switch ...modality [3] */ break; }/* switch ...modality [2] */ } /* switch */ break; case 'N' : i = (int) NM_IM; break; case 'O' : i = (int) SEC_CAPT_IM; break; case 'P' : switch (theModality [1]) { case 'E' : i = (int) PET_IM; break; case 'X' : i = (int) PX_IM; break; default : i = (int) NM_IM; break; } /* switch */ break; case 'R' : switch (theModality [1]) { case 'F' : i = (int) RF_IM; break; default : i = (int) CR_IM; break; } /* switch */ break; case 'S' : i = (int) NM_IM; break; case 'T' : i = (int) SEC_CAPT_IM; break; case 'U' : i = (int) US_IM; break; case 'V' : switch (theModality [2]) { case 'E' : i = (int) VLE_IM; break; case 'M' : i = (int) VLM_IM; break; case 'S' : i = (int) VLS_IM; break; case 'P' : i = (int) VLP_IM; break; default : i = (int) SEC_CAPT_IM; break; } /* switch */ break; case 'X' : i = (int) CR_IM; break; default : i = (int) SEC_CAPT_IM; break; } /* switch ...first char of the modality */ /* set the modality of the file */ gFileModality [inFileNb] = i; } /* if ...inValP not NULL */ } /* endof ExtractModality */ /********************************************************************************/ /* */ /* Pap2ToPap3Date : convert the Date from Papyrus2 format to */ /* Papyrus3(DICOM) format */ /* */ /********************************************************************************/ void Pap2ToPap3Date (char *pap2Date, char *pap3Date) { int theEnd = FALSE; char *tmp2, *tmp3; /* initialisation of work ptrs */ tmp2 = pap2Date; tmp3 = pap3Date; /* loop on the chars of the Papyrus 2 date string */ while (theEnd == FALSE) { if (*tmp2 != '.') { *tmp3 = *tmp2; tmp3++; } /* if */ if (*tmp2 == '\0') theEnd = TRUE; else tmp2++; } /* while */ } /* endof Pap2ToPap3Date */ /********************************************************************************/ /* */ /* Pap2ToPap3Time : convert the date from Papyrus2 format to */ /* Papyrus3(DICOM) format */ /* */ /********************************************************************************/ void Pap2ToPap3Time (char *pap2Time, char *pap3Time) { int theEnd = FALSE; char *tmp2, *tmp3; /* initialisation of work ptrs */ tmp2 = pap2Time; tmp3 = pap3Time; /* loop on the chars of the Papyrus 2 date string */ while (theEnd == FALSE) { if (*tmp2 != ':') { *tmp3 = *tmp2; tmp3++; } /* if */ if (*tmp2 == '\0') theEnd = TRUE; else tmp2++; } /* while */ } /* endof Pap2ToPap3Time */ /********************************************************************************/ /* */ /* Pap2ToPap3Name : convert the Name from Papyrus2 format to */ /* Papyrus3(DICOM) format */ /* */ /********************************************************************************/ void Pap2ToPap3Name (char *pap2Name, char *pap3Name) { int theEnd = FALSE; char *tmp2, *tmp3; /* initialisation of work ptrs */ tmp2 = pap2Name; tmp3 = pap3Name; /* loop on the chars of the Papyrus 2 name string */ while (theEnd == FALSE) { if (*tmp2 != ' ') *tmp3 = *tmp2; else *tmp3 = '^'; if (*tmp2 == '\0') theEnd = TRUE; else { tmp2++; tmp3++; } /* else */ } /* while */ } /* endof Pap2ToPap3Name */ /********************************************************************************/ /* */ /* ConvertYbrToRgb : Convert a YBR_FULL, a YBR_FULL_422 or a */ /* YBR_422_PARTIAL image to a RGB image. */ /* return : */ /* */ /********************************************************************************/ PapyUChar * ConvertYbrToRgb (PapyUChar *ybrImage, int width, int height, enum EPhoto_Interpret theKind, char planarConfig) { PapyULong loop, size; PapyUChar *pYBR, *pRGB; PapyUChar *theRGB; int y, b, r; /* the planar configuration should be set to 0 whenever YBR_FULL_422 or YBR_PARTIAL_422 is used */ if (theKind != YBR_FULL && planarConfig == 1) return NULL; size = (PapyULong) width * (PapyULong) height; /* allocate room for the RGB image */ theRGB = (PapyUChar *) emalloc3 (size * 3L); if (theRGB == NULL) return NULL; pRGB = theRGB; switch (planarConfig) { case 0 : /* all pixels stored one after the other */ switch (theKind) { case YBR_FULL : /* YBR_FULL */ /* loop on the pixels of the image */ for (loop = 0L, pYBR = ybrImage; loop < size; loop++, pYBR += 3) { /* get the Y, B and R channels from the original image */ y = (int) pYBR [0]; b = (int) pYBR [1]; r = (int) pYBR [2]; /* red */ *pRGB = (PapyUChar) (y + (1.402 * r)); pRGB++; /* move the ptr to the Green */ /* green */ *pRGB = (PapyUChar) (y - (0.344 * b) - (0.714 * r)); pRGB++; /* move the ptr to the Blue */ /* blue */ *pRGB = (PapyUChar) (y + (1.772 * b)); pRGB++; /* move the ptr to the next Red */ } /* for ...loop on the elements of the image to convert */ break; /* YBR_FULL */ case YBR_FULL_422 : /* YBR_FULL_422 */ case YBR_PARTIAL_422 : /* YBR_PARTIAL_422 */ /* loop on the pixels of the image */ for (loop = 0L, pYBR = ybrImage; loop < size; loop++) { /* get the Y, B and R channels from the original image */ y = (int) pYBR [0]; /* the Cb and Cr values are sampled horizontally at half the Y rate */ if (loop % 2 == 0) { b = (int) pYBR [1]; r = (int) pYBR [2]; } /* endif */ /* red */ *pRGB = (PapyUChar) ((1.1685 * y) + (0.0389 * b) + (1.596 * r)); pRGB++; /* move the ptr to the Green */ /* green */ *pRGB = (PapyUChar) ((1.1685 * y) - (0.401 * b) - (0.813 * r)); pRGB++; /* move the ptr to the Blue */ /* blue */ *pRGB = (PapyUChar) ((1.1685 * y) + (2.024 * b)); pRGB++; /* move the ptr to the next Red */ /* the Cb and Cr values are sampled horizontally at half the Y rate */ if (loop % 2 == 0) pYBR += 3; else pYBR++; } /* for ...loop on the elements of the image to convert */ break; /* YBR_FULL_422 and YBR_PARTIAL_422 */ default : /* none... */ break; } /* switch ...kind of YBR */ break; case 1 : /* each plane is stored separately (only allowed for YBR_FULL) */ { PapyUChar *pY, *pB, *pR; /* ptr to Y, Cb and Cr channels of the original image */ /* points to the begining of each channel in memory */ pY = ybrImage; pB = (PapyUChar *) (pY + size); pR = (PapyUChar *) (pB + size); /* loop on the pixels of the image */ for (loop = 0L; loop < size; loop++, pY++, pB++, pR++) { /* red */ *pRGB = (PapyUChar) ((int) *pY + (1.402 * (int) *pR) - 179.448); pRGB++; /* move the ptr to the Green */ /* green */ *pRGB = (PapyUChar) ((int) *pY - (0.344 * (int) *pB) - (0.714 * (int) *pR) + 135.45); pRGB++; /* move the ptr to the Blue */ /* blue */ *pRGB = (PapyUChar) ((int) *pY + (1.772 * (int) *pB) - 226.8); pRGB++; /* move the ptr to the next Red */ } /* for ...loop on the elements of the image to convert */ break; } /* case 1 */ default : /* none */ break; } /* switch EPhoto_Interpret */ return theRGB; } /* endof ConvertYbrToRgb */ Papyrus3/Papyrus3.ncb0000755000175000017500000126200007751472376011764 0ustar Microsoft C/C++ program database 2.00 JGY ÐDPQ üÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿòÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿQ’ BBa FF@ë >> 44% 55. 666l 77þ 00 11 22uÓ ½Ô {› \\( nxý_ ZZŒ‘¥¹ÃŒì¥¹Ã5?Q,º0Êe¦?ÐD$ðDDDQ <<a @@@ 88 ..% ,,º 11. --® 006 //£ ++þ (( )) **E izƒg )K –½gm Ðñö b£ …”p ¦ì  óý\a “Ž Ñ!ï 3L0 •¼Êc #Ú}?p &ýŸs# (Ns¯ )°¸* ,›ž .©€ 1&Vöp 2_gÇ 3{{ 4mm 5ll'_ 6]]ç 7tt¿ 8ssŒRiuŒ—Ÿi«ºŒ_iŒt}ŒýŒýŒŒŒýŒýŒýŒØëŒýJŒýŒŒý7ŒýŒý7üÕ45Ì@ 66 ..% ,,. --® 006 //þ (( )) **ì ¼G ð  Jmá ÆÏp ÒÛ ~¨£ GGö gk0 .2¬ *,f FF· MMÏ NNŒû«ŒûS¹ŒûŒz†SŒz†‘Œûü==ÃQ 00a 44% ''. ((6 ))þ ## $$ %%< |±w Å(‚ 9?à ei# NUž JJõ KKN HHÒ IIŒûŒØŒŽéï+©©\\Q ++a //% "". ##6 $$þ\   !!y SqX …’P ??H ??2 >>A @@Œ†aŒaq;;;Q ++a //_ $$% ºv ##.i !!6 ""þ á UºÎ @@ŒèýQ 99a ==@ 55% ,,º //. --6 ..J i ))þ ''n ((e ++T  __ê c • â g ^^C p z†_  ZZÎ  YYn  [[~  XX²  aaŽ  ``Q p ]]›  \\Ú # WWÃŒJ  - 8 ¹5?Q55… Á è ¨ . þ ¸  1w” ÿ ËŒÀ —Ÿ«ºÈ Ï ¡ © Œ—Ÿ«º¡ ©  ((% &&. ''6 ))þ! ##n $$ %%,  |‚B E ;  ¯äJ ) öþo f )\ d ²¹«  oŸ†  11! 6i!  ii  Ëâ²  ô1Q ) Dn` ( €–  ”6 ŒŒûŒûûv ŒûŒû™ ! ! ûûûŒQ 11a 55 **% ((. ))6 ++þr "" ## ''s  •š  ªÁ  Ñá'  „B  ñZ  #!  oo! Go~  kpb  59ô  I[Œ_Œý  ŒýŒ2 ŒýJ Œý! ŒýŒýŒý@ ''% 66â NN·DDÏEEçCC¿BB² HHŽ GGÎIIÃ5ÌÁ Ã? mŸ ¦Úò  'Kgá ,-B4@ ,‡‡œ@ ,’’‹@ ,‘‘›@ ,yy@ ,è@ ,€€@ ,ss\@ ,ŒŒe@ , rrL@ , qqç@ , žžÆ@ , zz­@ , ˜˜É@ ,õ@ ,ÁÁD@ ,ÌÌ1@ ,ËËo@ ,³³Ù@ ,»»½@ ,ººQ@ ,­­@ ,ÆÆ5@ ,¬¬@ ,««µ@ ,ÙÙŸ@ ,´´w@ ,ÓÓW@ ,ÒÒ•@ ,ØØÿ @ ,PPY @ ,__| @ , `` @ ,!QQÀ @ ,"cc @ ,#bb@ ,$eeA @ ,%XXà @ ,&dd@ ,'ffó@ ,(22@ ,)33r@ ,*AA4@ ,+::S@ ,,;;+ ,-&&6  ,.(( ,/''î   _   „¹ „¹ ï!£$ï("#&%)'g*W+,./-P²âxââPˆâxââ n ‘ 4 Ö ³ 4õ 4âââââ1Ô @ <<% HH_ íOOÎ iNNn ,PP~ ,MMQ iRR› ,QQÚ iSS55… ¨ ¨ öH && ''P++HH++2))A** ;;;@H 11. ,,¹ Æ - OÃi cf­i WZñs ’´‡i v‡×R áäùº ÕÞ_ ¿ÐÒ ýäAMääääœäéä ä qä¹ Æ = %9©* w j LnäQä½”ä”<*""H !6¹  Æ © ŽÙØ ôFH  TŠû  ”Àÿ  66T@ 22×s@ ''³R@ &&kH@ $$—H@ %%SH@ ""AI@ 55· 88ì G[„ c€ÉÌ É  d 5 ä'ä'ä'ä ŒŒ<aÃää”3 ¹  Æ  ï à ~  *HH _ÊÊ  +@ ,+@ ^H 4Lb+ TW¹H  ¹Ôn &«T+ (Uq  äk€–¬äk€–¬äÚ3Läk€–¬ääk€–¬äk€–¬ä¬l &Çÿ ¹ Æ   ³Ð  NÉ X‚l &&@ è@ R@ ##ˆ@ $$Ð@  ((½ 5§í  ¼   äâÿ,AVäâÿ,AVäl7s«¬‹ä¥þ 6G077Q   OTN ¹ ÆG s  ZZ00  ! -OŸ /  ÂÓ¯!  „ F!O Û ¼  `ºÁ! Mo_ ';! SZ}! ";{¥ #GGã@ $EE‚@ %AA¨@ &DD<@ '@@@ (==º@ )77ð@ *<<Ô@ +99w  ,IIj! .zŒš 2ÀEÍ 7²Q0 8 ? @ 9' @ : ù@ ;p >i§ ?TT@ @SSn@ ARRI@ BQQ @ CPPE"!c R(D'¼&`%_<< !2!<¬ äV!äV!<Í Ü ì !ää<äÍ Ü !ž!¥ÌbÌbÔQˆ ää±ÁäåòüQZ ! 䀖Qg@¹ Æ  " Gä‡"G¶"G /¹  ÆÑ ž"G ô$¶"G //r#G@ ''á"G@ I#G@ !!É"G@ #G@  ##G@  ª#G@  --V"x  116$G ¨êí#G pw" Df D  d5 ä¶"#Œg#‡"ŒA#Ê#b"äk$$äk$$ä”$ÙVV%Ù UY¹"  ÆÙ  i% G Pi% PP÷$Ù ‚‡æ$Ù ©†$  kuu%G  Ý%Ù ·Ù~%G ³®%G Ä$Ù \{í%_ y~0& /J& 3X‡%G  „—£$Ù ![[%e "YYA%Ù@ #XX+%Ù@ $VVÉ%( &Ôá›%G (Y\Ó$Ù *í·%C -ÁÅ &t 1µ¾Û%) 3&Q& 5g|íi%ä_ääéää %ä äääù%ä9&ää±$%Ô$ääääéä ää¬&ñ&Ù #¹$ Æ .' .' Ù Š& ö¿'Ù -{Í' Mñ&Ù  ##:'Ù@  'Ù@  'Ù@  s'Ù@  ""V'Ù@   'Ù %%ä&Ù èî&& 3„'Ù Ú½&  /Ô&Ù í  _ Ld .'ääää'ñ&.'¬&®'äääää¹ Æ& 1( 5\(B air(B U]O(B DL<(<(<(<(¹( ÆB K*B —±‘*B ÚæÑ(B üÝ) éù‰) ;q) f~6*B "i)B %†Ô¿( ' ^*B +?e=)B /ƒö)B 1_&*B 3µýäZ*n*€*ß(*è)ï)) )ß(÷() )ß(÷(è)ï)) )äž)¬)Ì)Z)äN)ä$)ääÌ)Z)äN)Z)ääB‘+6 ;* ¹ Æ) s  ``06 ÌÖ! ãP+6  (3…+6  ;RŸ  Zo+6  ã- Ï0N. iá÷- xÆë*B  :a5. "þ%Ñ- $éö;! & <+6 (->‘+ );;ú,B@ *,,Ü,@ +++»,@ ,**-@ ---{,B@ .$$¯-@ /::‹-@ 077,B@ 1!!Â+B@ 2˜,@ 3''ë+B@ 4 c-@ 511§+6@ 6[,B@ 7##9,B@ 8""=-@ 900 . :==Ú** =i¼P!'d#5"gscf$ Ñ-++ !2!+c+r+++¬ +&+1+äV!äV!äV!äV!ää+ä‘+ÔÔ6-–ÌbgA#Z @! Ô.䀆/55[/I 4C¹ Æ é.-  0ÿ.I ir…0  :a[/I  CC/I@  ::Ú/I@  ==0I@ AAn/I@ 55»/I@ <<û/I@ @@d0 EE@0 š. "¸T0 %M`P (*    ä/(/”$3B  %3  ÜÜ×B@  ÕÕ³B@  ÔÔO3@  ÛÛkB@ ÒÒ—B@ ÓÓSB@ ÐÐA@ ØØ· ÞÞì âö„ þê2B jƒ¾3   *  d5 ä'Ž3§3ä3 ŒŒ<<3Ãää”ä3ä3¹ Æ Ô4B qÑ—4B Rí4B fi­4B EA4B Z]Y4B pŠ43 \cÀ4B MTp4B ð*4*4AM*4*4*4*4*4*4*44¹ Æ4 s B P5B üŒ5B ¸×c5B —¯:54 %R±5B ãñŸ5B ^†Ÿ5*4*4½w5*4w5*4*4Ã5*4 6 ¹ Æ5 &6B Wc]6B +<:6B ˆ6B p~äääJ6äñ6B±6B  6 ¹6 Æ …7? Ys¥6Ð +4e7? ¹×±6Ð 7B@  7B@  Þ6B@  -7B@  J7B  ¿6Ð ƒ–—7? ¬¯P   Ð *4*4*4t7±6@ñ6A#U7*4Ï6*48B ;¹7 Æ6 s ? GGÚ8 ó.”8? :u8B  ’Û±8?  Ì™ç8 ãæë7 £ß ;;B@ //-8B@  ×B@ ""³B@ !!j8?@ 88SB@ A?@ 33· ==¤8 ”Äì NbÚ7B  jnÈ8? "v„4 !d 5¤8*4*4€*4€*4€*4*4I8ŒŽ88aÃ*4*4*4*4°9Ù×9B ¹  Æ8  m97 Eh‚:E Øé~E ÈÎ9B /‹Ê' ×9E %:B@ c:E@ D:E@ :B@ ì9B@ ^B ¨¾“:E $'Ç9 %wœ097 +ô4  ‚ 1 *4*4'B9W9¬*4'B9W9¬*4™9×9Ž8LLŽ8°9*4'B9W9¬*4*4'B9W9¬*4'B9W9¬Ø;E++;B :Bî:B *3Çm ¹9 Æ9 Ü:B ö ;B BB†;B@ @@L;B@ ==;B@ ;;î:B 33é;B@ 22À;B@  ++<E  55?<E  Xîí 4 C 4 *4;¤;j;0;î:<Ø;*<*4,=B 3KŠ<B 44QE <t ¹H ÆB 9? r,= KK‚>E@ GG>E@ AAã>E@ JJ[=B@ 99:>E@ FFÎ=B@ @@¤>E@ IIA=B@ 44©=B@ ===B@ ::w  MMT? zŠ? #„Ÿ<B °g? !” D? #ÓñQB $? @ %=B 'U‰C4 ÿÐJ <  g *4V!,=\>ô=Ä>z=\>ô=Ä>Š<ÔQ"?*4°<Í<å<?°<Í<å<ó<=*4åò?*4QZ *4@4â?N ¹ Æ< s N D@N JT@N ¿'N &tË?1  h|£@4  Ûòâ?4  %@N@  ö?N@ }@4 &X xÂf@N R_Ú7N ýN  D@*4*4*4*4*4â?A#@@*4*4*4dASrr¶"ß qƒ¹ Æ' í@4 œ¾KBM Ûÿ‘Be Âé¶"4 ƒƒr#ß@ uu{Aß@ wwäA4@ €€*B4@ ‚‚É"ß@ rr#ß@ xxB4@ ÇA4@ ›Aß@ }}V"& ……wBE €¾Aß ÊÑí#4 !XwcBd # *Aß %íw"$ (2OO De  N@  *4*4*4¶"#A#ŒdAŒŒ·Ab"*4W92AJA*4W92AJA*4W92AJA*4*4*4”;DpZZ-C. Yh¹ ÆB i% _ Ti%y TTêE GîC.  “®•Cß  ˜¬¸E t˜ÎE ¢åÿE é÷Eÿ #7Cß ²Ü¢Cß ì(ËCß ÄèÓCß ,nRCß !í fCß $§ÑÜBB (:oEm ,DO£$. -jj-CP .hhREe@ /ffES@ 0eeèDE@ 1bbÅDd@ 2aa†DM@ 3^^ND.@ 4]]%D.@ 5ZZD. 7i”«Eÿ 9·H>Cß ;XrÖE =Ùä‰Cß ?âFÀE AL\A!A@i%*4üC D*4üC D*4*4*4*4*4*4*4ªCºC*4*4*4*4}C*4îBþB*4îB‰EÛC-CÔFB  ¹E ÆE OFC ñø‡FE ,¬GB SÈuFB ›GB  ¨>F  µFB@  ŸFB@  ûFB@ 4GB@ ÓFB@  'B ""VGB µéGB ÷ÝG +H 4 C d*4*4*4*4*4>FbFGGA#nG*4*4*4'H,,MHB +C¹ ##ÆF $$m9B RuèI á·IB e6HB qMIB ÀÏýI ¼J EEMH CC™HB@ !55ÇHB@ "77°HB@ #66‚HB@ $44lHB@ %/1IB@ &AAZHB@ ',,4IB@ (BBÿHB@ )??ÞHB@ *>>œIB ,}…ß4C d5 g*4*4'ÌIW9*4'ÌIW9*4*4'`I}IW92AJA*4'`I}IW92AJA JMHŽ8LLŽ8Œ'HŒA#öH*4Š<B88£JB 7GQT "< ¹ Æ »K d¯ŽJB êx§KT  [eJB  ¹âzJB €™£J GG[KT@ FFÔJT@ ==7KT@ DD¹JT@ 88KT@ AAôJT@ >> . IID? ãQB ""‘KT@  ? T@ !!çK [À Id5 Š4*4V!*4V!*4V!*4V!*4£JKz=ô=Š<ÔQÏK*4QÔZ *47LK¨LG '¹ ÆJ œMG ù!¨LG ''MG@ ""lMG@ &&»LG@ KMG@ %%*MG@  ##ÓLG@  !!NLG  ))‰MG }“€LG Éï“LG #ÁoLG &Ht BI I 9*4¨LMŒ7LŒŒóLZL*4'`I}IW92AJA*4'`I}IW92AJA*4'`I}IW92AJA*4”'HB!!MHY  :¹M Æ# ûMY œ %OG  /L9OG èûGO X†=NY KNY ¼ßëM/  ŽÝJ !<<MH "::XNY@ #**ßNG@ $88pNY@ %--¦NY@ &//ZHY@ '!!ÁNG@ (334IG@ )00OG@ *99[O /©­iO 7X‹)NY 9DLBD *4âï0 N*4âï0 N*4âï0 N*4âï0 N*4âï0 N*4âï0 N*4 JMH#öN†N'H<ŒöN*4âï0 N*4'`I}IW92AJA*4¹ ÆO s B ¬O ,WÃON `ŽÃO*4*4YPBåå 6B 22 6G ¹ ÆL Pe "PB ÆP[ ‘xPB EN.PB œÇ¦PB 14ƒPB æûJPB aphPB ÓØ<(ÓP<(<(=P°P’P<(<(Ç ''¹; %%ÆP &&QG 11QB :¥.QÇ0 ##¹ÿ !!ÆP ""QB --vQ4 q݆QÇm ¹_ Æ QB &&ËQ, ‹†QÇT ))¹e ''ÆB ((Q4 33RB Cï*4â"RW96RÇf %%¹_ ##Æ $$QB //ƒR §m*4â"RW96RÇN ¹_ Æ QB ((ÊR “‚*4â"RW96RÇ ¹C Æ QG ##S z‹SB q-SB u*4â"RW96R*4â"RW96R*4â"RW96RÊSÐtt$Y ¥³'TG •£Ô[ elÔ[ccæ[@ fjµV 's‰%X'XX%X *Za7X@ -[_¹Q -qS -Æ -s  -""}S -H™Œ[ - óDÊ\ -ºáQ[ -Uy8V -Š±}V -CY -#ÒïÚSÐ -'±Î­[ -(öú][ -)ðôX -,¡àÍ[--""ãW -/]ÑZ@ -0²²—Z@ -1°°ŠY@ -2¨¨Z@ -3¬¬{Z@ -4¯¯6Z@ -5­­­Y@ -6©©9Y@ -7¦¦¶Z@ -8±±\Z@ -9®®fY@ -:§§ÍY@ -;ªªïY@ -<««ÉU@ -=¢¢U[@ ->   U[@ -?œœsU[@ -@ŸŸ.U[@ -A¥TG@ -B™™^ IM:]õ 37I]õ ]a ^S x|^õ ‚Ÿ]õ ko<(ö]‰V<(ö]‰V<(‰V<(‰V<(\]r]ˆ]<(<(<(·]Î]ÈGŽŽÂ^D ¤¹ Æ]  aÿ a_[ ††Š_D €€ïa KK}a LL“^õ ÑÜ*aÿ NcÐ^õ ÊâËa æþa L‚»aÿ Dt_D ¯ÂÕ`  K_) 4U§a !t^ $‹¥é` %¦¦Â^õ &¤¤`@ '››Ü_@ (””‹`@ )¢¢ö_@ *™™R`@ +ŸŸ»`@ ,££•_D@ -ŽŽ9`@ .žžÃ_D@ /’’¨_D@ 0‘‘ga 2),¦^õ 7ôþ_õ <4]_ AaÉÛa F0._S I¹ðß^õ Lä:FSSgaj_þaa*4=a*4kW9¬*4kW9¬*4*4*4*4*4*4*³^¹^*4‡^ú`Â^&`M£`A#i`A#ÈGM*4*4*³^¹^*4kW9¬*4kW9¬*4kW9¬*4=_*4ò^¬bõ  ÈGÁÁÂ^ Àй^ Æ  a ´´a_õ »»Š_õ µµ¬bõ   \c@ Qcõ@ rc@ gc@ ˆc@  }c@  Ÿc@   “c@  5d   ébõ òUdÿ VŠ¶d Rcõ ! |bõ $$4.e *…Dcõ ,v7cõ .ƒ†|d /––d 0——ßc 1˜˜Oe 2’’Bd 3””°bõ 5Snd 7Ûcõ <§îé` =ÒÒÂ^õ >ÐЯc@ ?ÅÅdÿ@ @ÏÏ‹`@ AÍÍÆcÿ@ BÈÈæc@ CÊÊ»`@ DÎΕ_@ EÁÁ¨_ÿ@ FÄÄVb HÍÓlb^ M´>_e R’°Ábõ Wß÷Ae Z5e ]ŽÅÒbõ `8£ 4   5 *4+$'(5&)%aj_¬b! >ggI AAa9 êfm îhI ++÷o@ KK÷o@ WXkp@ SS€o@ CCšo@ EE×o@ HH‹p@ TTLp@ PPho@ AA"p@ NN·o@ GG’nI ^cénI óöúnI ëõh CoI ÆÓ¶hI Öè4oI !):¯p #þ ¨hI &D]gX (htÃhI ,x†nI .Žš[nm 0ž»ÙnI 3eë®nI 4>>oI 5YYB4  d 5 gs 1Œp–MŒgg@póLœnägägägägägägäägjnjnÑhÝhjnjnäg½noêfn Áko QI  GqI « qe .qb ==ôph ==ôp ;;Yq ˜¢!qI LŽ*42q*4Ž8*42qlq*42q»q q }»qQ }}»q9rÐ PVgg %gg îr .EîrI ,,frI QQrh  6+ ¹: Æq s  vvusI XXxrÐ@ RRÌr@ UUMrÐ@ QQ¤rÐ@ SS¢sI Øs@ Øs@ t@ ##1t@ $$õs@ !!rÐ ,,s\@ 23:sI@ CCTsI@ DDs[@ ==O  'b^d(Ðs…sfr³sŒpMŒrMŒ‰tr ‰tI —t@ Át+@ ‰t­t‘ A# 1uI @u ??‡uI 99[uI 77s  ``Pukukuvuz=I QTÚu[ VbÌuI -ovI GGz= TTêvI@ SSËvI@ RRÚuI bb|vI@ __&vI@ ZZvI@ aaMvI@ ^^ðuI@ YYÌu4 --owI@ ++¢wI@ ,,wI@ PwI@ $$+wI@    d N^d! z=ovÚugºvovvÌu‰wºwwcwDw xS ¼¼ x =  ¼ xaS 33Px« \xS ""þS --' &&uxS KKgxS **@yS Š¨@yIˆˆçxÙ {·x „„ÝxÜ yys I ÄÄâxÙ xxèUÙ ¨¨ÉyI ˆˆUyS@ŒsyS@ ššyS@ ››çxÙ  'yS@  ~~ôxS@  ||yS@  }}d   NP ùy ÁxÛyçx°yçxÝxââxaÙ šš!    GzÙ bbŒI ªªMzÙ mm?zÙ ::XeÙ ’’9zç ††A#Ù ââââÔ11 1< KO‡" 7<†/ ?H3 RW°9 õúÈG ý¬& ,48 ¥­dA ¢7LI °¹bFÙ ˆŽ›1 ZbŠ< ÐØÙ pt¬ em@ ‘šØ; àä;D '¼Í$I (w‚'HÙ *çò$Y +……'T ,„„s  ,MMg# ,g# ,@},~~H|ÿ@,MNH|@,LLË{@,88}@, @@ŠzG@, SS }@, ööÅ~@, þþë{.@, --|@ ,22)|@ ,33ž|@,§§ž|@,¦¦ž|@,©ª¾|@ ,¬¬]@,žž{I@,±±Q{I@,‰‰m{I@ ,â|^@,[[ü|@ ,aa¨z@,ÑѨzG@,!ÒÓÆzn@ ,"××({Ù@,%rr({Ù@,&qqh|@,'ffã~@,*’’ã~@,+““:@ ,,™™@ ,-˜˜d~@,.áá~~@ ,/ããŸ}@,0½½Ÿ}@,3ÂÂ@~@ ,4ÌÌ~@ ,5ËË»}@ ,6ÄÄÿ}@ ,7ÊÊã}@ ,8Éɯ{I@,9xxîzÙ@,:èè{Ù@ ,;ññX}@ ,<……‚|^@ ,=„„'&&d/ '!"#%&$%'$(&)(*+,-/./0%123(547ð6$89$;:¤>n@d?5=<ÿA BC.D%Et}g#J}A#©A#A#Ú8”8<3A#A#A#9?A#A#F{A#A#œ~«EÔlDA#A#A#rŠ s~Ί bn< MM<‡" KK‡"››†/œœ†/ LL3TŸŸ3G OO°9 \\°9 ƒƒÈG „„ÈG ]]  ¬& JJ¬&ššq‡ 'ƒÂHš'Hš h¥8h||8 iUUdAi{{dA jTT7L kVV7Lk}}bFGkzzbFG lSS£‹l£‹ Ī…>€G ÈØß>€GÈ›1 ÉPP›1É  Š<G ÊYYŠ<GÊ€€G ËRRGË¢¢YP Ö’ÇYPÖ  È„@ ؤ§¬ ÙQQ¬Ù¡¡@Ù~~@ ÚWWØ; ÛZZØ;Û;DÛ;D ÜXX]¤ÜÐÐ]¤ áÒÙ$ âNN$âžžÊS í=ÊSí  fr òÌÓfrò  ؆ øÇÌñ6 ýïøñ6ý®®'HGý‚‚'HG þ[[$Yþ  $Y ÿII'T HH'T  [† äé@  Px  6G kk³ À jjF¥ UUZY WW|¥ XXèG VV-€G ZZrŠ ~~|Š@ uu˜Š@ ww¸Š@  }}Ί  nnÙŠ@  gg‹@  mmM  RR‚ SSöH QQ0ƒ ää0ƒ Ýäˆ èìˆ ì콆 ÷û½† ûû¥ – ºv ‚@ MMF‚@ KK…‹@ LLÌ$@ OOm„@ \\¥@ ]]¨@   $@   ó@   Ï@   M@   w@ !  …‚@ "JJq‡ #½ˆ@ $¢¢–‰@ %µµv‰@ &´´¶‰@ '¶¶W‰@ (³³Sˆ@ )‘‘…‡@ *‡‡§‡@ +ˆˆ1‰@ ,¯¯4ˆ@ -SŠ@ .ÁÁ ‰@ /ªªâˆ@ 0©©Ì‡@ 1‰‰—ˆ@ 2››Ü‰@ 3··Š@ 4¸¸%Š@ 5¾¾ˆ@ 6‹‹ï‡@ 7ŠŠrˆ@ 8ššÒ¡@ 9••ë¡@ :••'ž@ ;RR Ÿ@ <aa4Ÿ@ =bb`¡@ >‘‘¡@ ?ŽŽò @ @¹¡@ A•• ¡@ B••€Ÿ@ Chh Ÿ@ DiiÝœ@ EAAF@ FFFà@ GPP@ HDD%@ IEE<¡@ J£@ KŸŸ°š@ Lœ¢@ Mqœ@ N::ª @ O‰‰Π@ PŠŠœ@ Q55¶œ@ R@@už@ STT]Ÿ@ Tgg›@ U8£@ V  š£@ W¢¢]š@ Xl£@ Y¡¡øš@ Zo›@ [''M›@ \&&¹›@ ]))’›@ ^((Þ›@ _++Òš@ `Jœ@ a884¢@ b››Т@ cžž¢@ dšš4 @ e{{\ @ f||wš@ géŸ@ hqq%œ@ i77g@ jHHž@ kQQh¢@ lœœ‘š@ m  @ nzz‘œ@ o==¾@ pOO½ž@ q\\–ž@ r[[‡@ sIIÏ£@ t££¤@ u¤¤Nž@ vSS„ @ w~~ÀŸ@ xjjãž@ y``ùƒ@ zUU²¥@ {TTó€@ |VVÙ€G@ }SSÿ”@ ~==©—@ ooÄ—@ €oo'•@ ??”@ ‚77B”@ ƒ881—@ „kkâ–@ …hh½–@ †ggŽ—@ ‡oos—@ ˆoo’”@ ‰::´”@ Š;;q’@ ‹›@ Œíí£“@ .."“@ Ž**E“@ ,,€“@ -- —@ ‘jjÞ@ ’ÃÃá™@ “ƒƒŒ@ ”««o˜@ •||¸‘@ –Ë@ —îîÁ’@ ˜&&G–@ ™ccš@ š„„m–@ ›ddš’@ œ$$,’@ *Ž@ žÆÆm”@ Ÿ99@  ÎÎÌŽ@ ¡ÌÌyŽ@ ¢ÈÈMŽ@ £ÇÇK@ ¤ÐФ@ ¥ÒÒv@ ¦ÑÑH™@ §€€º‹@ ¨««_Œ@ ©««™@ ªÖŒ@ «´´²Œ@ ¬³³>‘@ ­þþ‘@ ®ýýÛ˜@ ¯~~7Œ@ °««"@ ±¶¶9˜@ ²{{™@ ³P•@ ´EE˜@ µzzt•@ ¶NNž•@ ·OOÖ‹@ ¸««È•@ ¹QQûŒ@ ºµµ@ »ÜÜK@ ¼½½G@ ½Ýݹ@ ¾ÁÁô@ ¿ÛÛ‘@ Àe‘@ Áì@ ÂøøÏ@ ÃÚÚ¥˜@ Ä}}ò‹@ Å««ù’@ Æ))ç‘@ ǤŽ@ ÈÊÊŽ@ ÉÄÄq@ ÊááÆ“@ Ë00–@ Ì\\Ö”@ Í<<ï“@ Î55•@ Ï¿¿s@ п¿„Œ@ Ñ®®ô•@ ÒSSðŽ@ ÓÍÍß—@ Ôuu¯™@ Õ‚‚Ÿ€G@ØÝÝŸ€G@ÙÜÜz€G@ ÚÚÚS€G@ ÛÙÙ7„@ ÜPPûG@ ÝYY½€G@ ÞRR—„@ß””ä„@ ॥ …@ ᦦð…@ âÄĆ@ ãÅÅ—…@ ä¿¿8†@ åÆÆÎ…@ æÀÀ¯„@ 碢E…@ 觧z…@ é³³^…@ ê««»‚@ ëQQ_¥@ ìWWE¤@ íZZ+¤@ îXXè¤@ ï××Ȥ@ ðÖÖ‰¤@ ñÔÔp¤@ òÓÓ¤¤@ óÕÕ,‚@ ôNNÓ‚@÷Ó‚@úÓ‚@ýÓ‚@'+Ó‚@Ó‚@,0Ó‚@&&Ó‚@  %Ó‚@ ƒ@ <<ì‚@ 99\ƒ@Í͵ƒ@ ÑÑwƒ@ ÏÏ—ƒ@ ÐÐÙƒ@ ÒÒ?=gGsFBHJKðIäLeToSfRyQdO5PYXWUV%Z[Ô]ÔcbaM¥‹„ˆ¥ò6€rŠŒŠ«ŠA#ΊîŠA#=š‚@k0ƒË†½†*¥Ð¥„È<A#e”q‡A#ÈŒŒŒFŠŒA#9z9z…¡ŒŒXeXeU’h“A#h“h“!£È·¢ã’“–U’ˆ9z6›Y£¸£<‡£ŒŒ0ƒYA#0ƒO¢í¢!¢eŒA#ƒ¢”A#’A#Ô§ò£ŒA#A#9zA#9z9zX—ŒŒXeXeU’h“A#h“h“A#šÈŒ˜Ú‘Mã’G“–U’ˆ9z½†A#A#A#A#A#h™<œ™ŒŒŒü˜A#0ƒV˜3™ƒp‚[†@>€f©G #(S¦G º& ÆG þ\  M ‡© Y³§G  šÕ£¦ P U¨ G áየG 2w`¦1 ¾á¨G exf¨G #Žõ§G ,ßέ¦; 2‚„¨G 5ÿû¨G >È~©@ ?''u©@ @&&l©G@ A%%Ù©®©¹©Ç©Ó©Ý©Õ¦Á§Õ§ì§ú§Á œ¨µ¨¹Ų̃Өڨßmp¦}¦Š¦Œé꨽¦t¨î¦§ §½¦(§B§P§`§p§§¥§½¦Õ¦î¦§ § ¨6¨©©(©1©:©C©¹L©Y©S¦ þ\ ¦ £ªÐ þÿª¨ ºðҪР“4¸ªÐ .…„ªÐ B¬RªÐ ÿ ¯ª5ª?ª5ª?ª5ª?ª5ª?ª?ªaªuªS¦Ð --·xß &&«ß ##(«ß ((þ\  ª £ªi úû̬ ¢­ •ïž­ <ˆ"® †á¬ H1¯ •ê­ ‘µ¬ Uƒ¦¬ ÀÏd«Ð ‘ õ®  §§£¦  =>U¨  <<“« i ==€¬ $Ƙ·¬ (¥„3«Ð -Y›\® 2Û ¹­ 4¥¹÷¬ 9ºá¬ ;x™ÿ­ >gtÿ® A•¢«i Cûþ*¬ E kš® K§ô±«i OCY¯ S!8O¬ WN.® [;¯ _H©ø«5ª?ªÄ«5ª<­?ª§K­h­‚­5ª?ª§K­h­Á 5ª?ª5ª?ªÄ«5ª?ª5ª?ª5ª?ª5ª?ªs«„«5ª?ª•¬t¬5ª?ª•¬t¬Œ?ªuªC«S«ŒØ­uªs®‡®ŒØ­?ªÄ«t¬ ­?ªÄ«®Ä«uª?ª=¬Ø­´®Á®Û®è®Ä«Õ«è«Ä«Ø­®5ª?ªb¬t¬5ª<­?ª@®5ª?ª•¬t¬@B $$u¯B ''£¬ \x þ\  "P­ 33ƒ¯¬ fmš¯¯ ’§°B H[÷¯B wˆÄ¯B ±ÃÈŒ¯È£¯³¯Œ°ÈدÈίدç¯8° @¯ þ\ %±B ¶¼Ž°B ÇÜë°B ?s±B «G±B 66V°B 88Å°B 77_±B 55j±B 44w±B 22G°B 33~°B vv6±Œž°¬°º°ù°Œ¬°±S±d°Ó°S±±6-S¦ß ''»±ß ++°±ß $$þ± ""\ !! ##³B ïƒR³B ùpÖ²ß |ᣦ ß µµU¨ i ´´“« ß ´´e²ß WhŽ´i ;LÙ´i Ëí±ß ¸I´i ²Ÿ³B #v¢œ´i 'F>³B )•°º³i .¾±²ß 15Œ³B 3¾ùLµi 6 |õ±ß <ˆm ´i @yŠ‡³ B @00µi EŽ­5?ª+³5ª?ªn³5ª?ªö²5ªo²}²‘²¢²Ñ±ð´?ªÑ±?ªç±Ñ±o²}²Y´K­§h­o´~´¢²Ñ±o²}²­³¢²°´?ªÊ³Ç´Ñ±?ªÑ±?ªÊ³ß³ó³Ñ±?ªÂ²Ñ±?ªÑ±?ªç±5ª?ª²²1²J²5ª<­´0´5ª<­µ!µ9µa\ ''Ÿµ »±± þ´ ² ± ’µß gxß "Pß !!©µß :·ß {‚0·ß >N§¶ß Œ‘S¶ß Yq×µß ¶ß œªÈ¶ß áûó¶ß #ÌØa·C (µÁºµÊµ ·^¶=· ·P·^¶´¶5ª^¶p¶‚¶‘²—¶Œãµóµ¶5ª<­¶4¶C¶<­Ó¶á¶<­þ¶5ª<­m·4¶ˆ·S¦\ £ª· …†£¸Ù ’–@¸Ù 6:€¸Ù (,"¸Ù x|È·¶ ]aþ·Ù jno¸Ù CGX¸Ù †‰é·_ PT6-£ª?ªÙ·?ª¸?ªÙ·3¸Ù·?ªÑ±¸Ñ±?ª£ª?ªÞ¸n ))S¦¸ $$þ\ !!£ªß •–Óºi ­¹‰ºß ª¹£¦ ßÄÄU¨ i  uºß VB » ' ® ¢ºi {ÿó¸· · › +»i KºÙ ¦ ˜ºß Ll¶ºi 9Q»i È+ ô¹Ù vŠá¹B – Î Vºß –¢X¹B 8 ‰ áºi "  ºÙ #]ž»» 'Û  ;»i ) )ºÙ +%J»i 0gqˆ¹B 2IJ¹B 4U\"¹B 7BJ» 907ø«¯ªuªÑ±ŒŒ«»¹ŒŒÿ¸¹ŒŒŒѱ?ªÄºðº»{¹Œg¹Ø­uªgºg¹{¹ðºÑ±Ë»uª{¹Œ§Œ>ºŒ[»d»m»v»”¹£¹ŒǹŒ4¹F¹Œ»S¦º þ\ º½ à/¬½ R(‰(ǽ 8ïj½ *“Ô½ ø-Ó¼S ’(s)â¼S |){*ñ¼S „*+ˆ¼S  +-+¦¼S 6+Ç+ļS Ð+ó+—¼S ü+e,µ¼S n,¥,½S ®,Û,½S ä,M-"¾ 7„[¼» "V-#.j¼» $,./y¼¹ &!/ò0 ¼ (û04.¼º * 4ù<=¼S ,=>L¼S . >9>¾ 0–û½ 2Ÿ€<¾ 4‰’v½ 6œ_¾ 8›æ!-½ :B>e><½ <n>‹?á½ >ï!–"î½ @Ÿ"þ"½I B”?§@V¾n D#&‘½ F°@AI¾ H!&l&‚½} JAIB/¾ Lu&ì'K½{ NgC€C ½ Ph×c¾S Rõ'J(Z½ TRB^CŒ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼S¦½ þ\ ßÇs )C Ãg Mz)ÅE „ã˜ÉO í_Ê ‹È —ºò¿Ô ÄUÄe (bÞ 2KwÉ UnJÊ x‘å¿S •:mÆi D‹É¡ ™˜ÄC ›¸Çc ‹ÃZ "¢GèÄV $Q’§Ày &LpÅL (zŽUÃP *˜o ½¾¼ ,y P ¿¼ .Z ~ HÅm 0œ«æÅD 2µâ:Ë 4ìB|Às 6ˆ — ›Ë 8¡ ° 2Á :º É Ü¾S <Ó â Æa >ì  FÈU @# G É BQ j ·È Dt — ÝÉ_ F¡  4Ä H( ¹ ÂÃP Jà  Ò¿S L © 0ÂN N³ à aÈ  Pê S„ÅM R]žÆG T¨Ë¶ÆN VÕp?ÉA Xz‰ž¾ Z“ü¸¿S \)ËÇN ^4C¼À‚ `NqwÄi b{¼Èq dÇ׳ÄP fâ¥]ÆŸ h°çËÿ jñŽÇŒ l JÂf n#2¦Ãi p<iŠÊ rsŒlÂg t–ö‰ vÍÜ_¿S xæÿ¬Êÿ z @ÊÈ\ |J‚£¿S ~ŒœÍÊ €¦¿ÇG ‚‚*Æ „ÉÆA †)9nË ˆC\çÀ Šf“¿¼ ŒŒ¥lÅS Ž¯ÈòÃ_ Òá¹É] ’ë® ÊN ”¸ùFÄ_ –&M¿S ˜0àøÀ šê!\À/ œ+:ÞÈc žD{€ÇI  …ž·Á ¢©Â˜Ä ¤Íú‚Á† ¦Û-À ¨¦ñ:Ã8 ªû@ÁÅe ¬Jc(È ®m®ÃÄC °Û\!TÅt ²åN;À ´XÁsÈU ¶ËfÊ ¸pÅ{Æb ºÏ$ôÈj ¼.QÕÀ ¾[œÞÆL À¸ÑqÁ Âg!v!©Èq Äé!4"tÃu Æ€!ß!@ÆU ȧ"Ë"÷Çj ÊÕ"ù"Åe Ì#1#ÂS Î;#s#Åo Ð;$h$оS Ò}#$˜Ân Ô"$1$ûÁn Ör$$iÀM Ø‹$%@¿S Ú&%Å&4Åh ÜÏ&Þ&>ÇO Þè&'ýÊ à ''”Á â$'['Á‚ äe't']É æ>"W"Åf è„""ZÁ êa"z"xË ìÓ'ì'RÇA îö'K(Œ¿S ðU(È(2Ê òÒ()%Äa ôh)³)ÒÄd ö')^)#Éj ø½)×)óÉe ú~'É'…Ë üá)T*äÊ þ^**¿½ ‹*®*Ç3 ¸*ï*NË ù*+”Ã$ +5+Äl ?+b+§Âb l++ÆÉ; ™+Ú+¢Á ä+a,}Ê k,{,"ÃL …, ,hÇ, ª,'-3¿S 1-/ÎÁ‹  ///HÃc «01µÅV (1U1HÀ 9/Ž/&Ë ˜/Å/ÅÆN "Ï/0¡Ç $0)0ÑÅT &30j0ÇA (t0¡0à *°5Ý5ÝÃt ,_1ú1À .2Û2õÂS 0å2:3çÁ 2D3q3x¿S 4{3ø3Æ 64W4òÆr 8a45‰Âe :$5[5ÖÂ¥ <e5¦5Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼S¦ !!°±É þ\ fÌÀ 1B³ÌÅ NgÖÌS t”̾ Ü%TÌS .?ÄÌS ¢ÍìËÉ "r–CÌS %Kf5ª?ªÌxÌ…Ì{¹5ª?ªÌxÌ…Ì{¹5ª?ªÌxÌ…Ì{¹5ª?ªÌxÌ…Ì{¹ûËÌÌûËÌÌûËÌÌ3ÌûËÌÌlÍS ÞãYPSààÍN **S¦N //ºN &&ÆN ''ÍÙ %%ÍZ ##þ\ !!Ì ""£ªS <=ÐS FÕHÎS  æüÎS  '€Ð 4OYÏS kº©ÏS ÈÔ…ÎS # ¦ÍS )ácöÏS .Z™aÎS 5©;%ÍN :=]ˆÏS ?xÚJÏS Bí0 lÐ I¦®–ÎS Q¼ßvÍS@ Ràà…ÍS@ Sââ,ÏS TååÓÏS VïýlDÎŒ?ª,ÐAÐÀÏSÐ`ÐVÎ Î6Î5 Î6ÎŽÐ Î6Î5ª?ªrÏÈÍßÍùÍ5ª?ªrÏÈÍÀÏ5ª?ªpÎÈÍßÍùÍÇ©5ª?ª±ÍÈÍßÍùÍŒ¹ ÎÏÐ5ª?ªpÎÈÍßÍùÍÇ©ðº5ÍCÍZÍ?ªùÍðºšÏ?ªg¹5ª?ª¨ÎйÏÏ5ª?ª¨Î¿ÎÒÎèÎÏÏYPžÍ7ÏáÏS¦à &&þ\ "" ##GÒI …úÑ Ipu Ò IéÐI ² Ó »ÇÒ ˜®3Ó Û÷ÒI ¹Ð°Ò ¹&ÑI !eƒ`Ó $JY…ÑI %CG–ÑI )–ªÓ -o‰ÆÐÏ /37ÒÑI 1(=ôÒ 3SbÃWÒkÒuÒ€ÒžÒŒÑÑŒS«?ªŒÖÒåÒŒBÓQÓŒ)Ò8Òѱ?ª´Ïß³Ðիѱ;ÑNÑcÑsÑ°´rÓ„Ó°´Ñ±?ª¦ÑµÑѱ?ª&ÓµÑ6±×ÐÙ·ãÑ6-ÿÒS¦Ò þ\ dmÒ þ\  èÓI NaßÓÑ +EŒîÓýÓ6-o²u¯ $$þ\ ° ™ÔI ?CYÔI 55­ÔI 66zÔI LP7Ô Y]ÔI ±¾ÂÔI f{îÔI “™¹ÔI „ŠøÔI ¢¨ŒbÔŒŒ=ÔŒŒÌÔÝÔŒ㵌㵌ãµÍ 22S¦ ))º --Æ ..Ÿµ &&þ\ $$Ô %%\ÕI 3… Öi ‘ÝÊØ è£¦ I TU“«  38rÕ I ŸŸa× “Eý× Ë…ÔÕi Ç&A× #3;yÕI ,Hü*Õ 1 'ŽØ 6ÚõñÕi :?RgÖi ?ÿ!õÖ C[p¨Ø Gy•× O ¿áØ TžÐMÖi Y+hØ cSºšÖi iv†5rÓµK­5ªÂ²¿Î4ÖK­5b¬K­5ª?ª¥§vבש×Â×Ú×ì×Ç©æÖѱ?ª¿Î Øѱðº5ÍäÕѱ?ªaªN×ѱ?ªðº5͇՚լÕÁÕKÕѱðº5Í:ÕKÕŒœØ Ö6ÎKÕŒûÕ Ö6ÎŒvÖˆÖ6ÎKÕŒÿÖ Ö6ÎŒ²Ø Ö6Î5ª?ª!×gºÕ«¨Î6Î2׌ëØVÖ Ö6ÎŒS«VÖ Ö6Î5ª-Ø9Ø‘×FØ^ØuØ‚ØÇ©h­5ª¤Ö»Ö<­ÑÖæÖ@ $$"Ù \x\ ZÙ\ sÙ ± )U‡³ Ø ¥²‡³ ± Qm‡³ -M‡³ ­ )‡³  ‡³  ßü‡³  ×Û‡³  ÍÓ‡³  ®É‡³ i Ū‡³ i sÁ‡³ i ?o‡³ i #;‡³ i ‡³ i û‡³ i ò÷‡³ i è i Ú䇳 i ÑÖ‡³ Ø ¾Í‡³ Ø ¶º‡³ i qt‡³ Ø ‡¡‡³ Ø lƒ‡³ Ø bh‡³ Ø U^‡³ Ø *P‡³ Ø %‡³ ȇ³ ºÄ‡³ ¥¶‡³ ¡‡³ ú‡³ ßö‡³ ÀÛ‡³ g¼‡³ *c‡³ à&‡³ ºÜ‡³ D¶‡³ ,@‡³ (‡³ JQ‡³ Æ·³ ºÁ‡³ ¡µ‡³  ’œ‡³  ‡³  tz‡³ ¼ eo‡³  I`‡³  3D‡³  (.‡³  #‡³  ‡³  ‡³  ÷û‡³  ëò‡³  à懳  ÑÛ‡³  É̇³  ’ć³  ‡³  vz‡³  nq‡³  [i‡³  NV‡³  DI‡³  :?‡³  05‡³ (+‡³ #‡³ ‡³  ‡³ ö‡³ íñ‡³ ß至 ÓÚ‡³ Å·³ ³À‡³ ¤®‡³ ›Ÿ‡³ Œ•‡³ „‡‡³ — x‡³ ps‡³  gk‡³  _b‡³ š /Z‡³ *‡³  ‡³   ‡³ Ž ÿ‡³ éú‡³  Ý䇳  Ò؇³ Œ È͇³ ¾Ã‡³  µ¹‡³ ð ¬°‡³ Ð £§‡³ Ð •ž‡³ Ð …‡³ Ð }€‡³ Ð Px‡³ CK‡³ :>‡³ 5‡³ ‡³ ü‡³ ï÷‡³ åꇳ Öà‡³ Çч³ ±Â‡³  ¬‡³ ›‡³ sŠ‡³ hn‡³ _c‡³ VZ‡³ ÓÙ‡³ BE‡³ 6=‡³ 1‡³ ‡³ ‡³ 퇳 å至 Üà‡³  Óׇ³ n œÎ‡³ ‘—‡³ L ˆŒ‡³ f €ƒ‡³ _ q{‡³ hl‡³ `c‡³ T[‡³ HO‡³  ?C‡³ 7:‡³ ÿ ,2‡³ #'‡³ ÿ ‡³ ‡³  ‡³ ‡³ ÿ ôû‡³ Ú ÿ ÒÕ‡³ Å͇³ »À‡³ ³¶‡³  ©®‡³ ˜¤‡³ “‡³ z‹‡³ pu‡³ ck‡³ R^‡³ GM‡³ 1B‡³ $,‡³ ‡³ ü ‡³ ò÷‡³ é퇳 ß䇳 ÔÚ‡³ Ìχ³ ÄLJ³ ÿ ¼¿‡³ ´·‡³ ÿ ª¯‡³ Ž¥‡³ l‰‡³ Pg‡³ ‚ FK‡³ 7A‡³ ,2‡³ $'‡³ ‡³ ‡³ àû‡³ ÒÛ‡³ »Í‡³ ¨¶‡³ —£‡³ Ž’‡³ …‰‡³ |€‡³  tw‡³ fo‡³ ÿ \a‡³ IW‡³ ÿ @D‡³ 0;‡³  %+‡³  Ú\ 1Ú I %Å)Ú  ÉÜS± [[S± Ì [ë°bbV°\ddÅ°cc_±aaS±ù°ù°üS±þ\ 8° @\ dà 99U¨ NN Ò QQ“« KKÈþ NNIõ __zâ HHKâ EE€ó TTOÞ ccj÷ ``Ùé ddüý BBuü QQ‹ú KKò ff£þ ¦¦Iß œœ¸ï Ã÷ ÖÖså <<Øò ooH rrmè hh…ã ——× °°˜í ]]ôèÿ 22¥ä 99lá ££ß ww{è ŠÝÙ ¿¿Èè ??xä 55‚ø **¥ò !--û "''²ù #WWèò $ÇÇrê %¹¹9ÞÙ &ÊÊýö 'ÒÒMÿ (ÎÎë )¼¼Læ *ZZûç +ll›õ ,ŽŽÔë -Žý .^ü /Èȹû 0cã 1‰‰êê 2³³só 3‘‘>ç 4ËËÛâ 5ÓÓ‹þ 6ÏÏ_÷ 7““qö 8’’€ 9––Qï :¶¶gñ ;ŒŒ8ú <‡‡éý =ˆˆìô >••…õ ?””ÿÞ @¥¥)ø Ayy×ç B¡¡3ã C¤¤õú D©©©â E¨¨Në FŸŸÑß Gô÷ H€€aï I~~ê J||¹Þ K}}!ä Lyy­õ MzzDÛ N{{‰ç O||ìÜ P}}Úü Q~~µý Rî S€€ã Tì U‚‚è V……ø W††€û X‡‡¤ö YƒƒÄî Z„„Vý [ˆˆºõ \‰‰Œó ]Sð ^ŽŽ½å _«ì `#ß a‘‘òî bŠŠVù c‹‹#î dŒŒ¥æ e’’`î f““ƒê g””Âÿ h••£û i––2ô j——Þì k˜˜+èÿ l™™ ú mššëá n››¢ oœœ3õ pŸë qžžýõ rŸŸüñ s  ±ê t¡¡]ø u¢¢ñ v££+êÿ w¤¤½ÝÙ x¥¥i y¦¦Qô z§§(ë {¨¨cç |©©õ }ªªòï ~««#ú ¬¬(ñ €­­Îú ®®á ‚¯¯ÿ ƒ°°ãë „±±uí …²²ÿò †³³­ß ‡´´9ï ˆµµgû ‰¶¶Wþ Š··Šß ‹¼¼‡ô Œ¸¸­Ü ¹¹`á Žºº|ö »»7à ½½ ‘¾¾àåÿ ’¿¿gé “ÀÀ§á ”ÁÁyú •ÂÂ>ñ –ÃÃ4ì —ÄÄ¢ù ˜ÅÅ»ô ™ÆÆ šÇÇïù ›ÈÈUó œÉÉKî Êʬþ žËËÎö ŸÌÌ ô  Íͼü ¡ÎÎ[ ¢ÏÏüæ £ÐÐÆù ¤ÑÑÔá ¥ÒÒ—ì ¦ÓÓ:î §ÕÕ3ó ¨ÔÔ©ç ©ÖÖšý ªØØqþ «××sá ¬ÙÙJà ­ÚÚ9é ®ÛÛ°ð ¯ÜÜ„ÿ °ÝÝNò ±ÞÞ½ë ²ßßÈí ³ààýã ´ááRû µââ¡åÿ ¶ããxß ·ää®Û ¸åå°è ¹ææîã ºççÏð »èèõ ¼éé Ü ½êê§î ¾ëëŒõ ¿òònõ Àììð ÁííŠé ÂîîÅû ÃïïŸñ Äððô Åññ”÷ Æóó«í ÇôôÛÝÙ Èõõ·ñ Éöö9ã Ê÷÷êç ËøøÉã Ìùù•Þ Íúú3ù Îûû’à ÏÙÙBð ÐÚÚßû ÑÛÛçÿ ÒÜÜ:ü ÓÝÝ!þ ÔÞÞíû ÕßßIö ÖààÞ ×áá þ Øââù Ùãã-÷ Úææóå Ûçç¡ã Üèèßä Ýääî ÞååŸÜ ßééæ àêêZë áîîåß âïïûê ãðð à äññ@û åòòTç æëëìä çìì4æ èíí¥ó éóó©ø êôôoï ëõõí ìööèÞ í÷÷ï îøøRè ïùùsù ðúú*ÛÈ ñûûÞ÷ òüüŽÛ óýý¬÷ ôþþ€Ü õÿÿoã ö°ö ÷0ò øoø ùoà úNåÿ ûûø üó ý#û þÕæÿ ÿ  Öõ   ö   Ûù   Á   ²ã ëÿ Ýö  å >÷ %ö 9ý é  ÿ mô ëð ®à ì \ì óó jò á Îê ð   êø !!Iá ""ÙÜ ##½á $$|æ %%é &&Áâ ''æ ((Kéÿ ))eÿ **%ÿ !++0ð "44÷ #55×à $66ƒá %77$ &88<ä ',,)ý (--”ð )..Yä *//Úï +00.â ,11cú -22Šù .334ß /99;ÿ 0;;Ùý 1::ÞÙ 2??ùß 3@@KÜS 4AA# 5BBËï 6EEÚø 7CCÚÛ 8DD¾é 9FFvý :GGAè ;HHëà <IIøì =JJ7 >KKEþ ?LL ë @MM:í A<<Û B>>â C==ý DNNtë EOOXí FPP0å GQQ'ü HSSþü IRRwì JTT‰ñ KUUžï LVV.ÜÏ MWWèÚ\ NXXëí OYYÝ PZZS Q[[îÛ R\\ à S]]yð T^^aÝÙ U__ìñ V``Áì WaaCÝÙ Xbbaê YccÎñ ZddÆçÿ [kkzÝÙ \llÔô ]eeêÿ ^ffÖó _ggHú `hhï aiiyÛ bjjò cvvpñ dmmô enn¦é foo¿à gppÚî hqqü irrø jssÞÙ ktt\Ü luuØþSõ†âUâ]æ^Þu÷æéèˆüœúˆòßV߶âÍ÷„åÄÞÄÞ„åãè]æ¶â±äßÄޚݚÝÕè‚ä˜ø¹òû]æšÝùâšÝùâùâùâ]æèãããšÝãÛùâãšÝùâùâããŽùâãÕèÛóôóôß6øß߶â¶âßÄÞÄÞÄÞÕèÄÞgÛBógÛPã ÝÈÛÇÜgÛgÛgÛèOêûöPãcýÈÛ ÝfðÍåÍå ÝÇÜ7áòÝÇÜÇÜÇÜÇÜ7á ÝgÛ ÝPãâÈÛè7áöÈÛ ÝèÇÜOê ÝÇÜ ÝÈÛÇÜwé§ÞÇÜÇÜÇÜ7ágÛ7áÇÜgÛ§Þ§ÞÇÜgÛšßòÝÇÜgÛ7ágÛgÛÇÜwéÈÛ ÝTñ§ÞÇܧÞgÛgÛ7áÍåööèòÝòÝ ÝÈÛgÛÇÜOêBógÛgÛgÛgÛòÝÈÛgÛö Ý Ý§ÞÇÜ Ý Ý ÝÈÛPãÇÜgÛPãÜÇÜ7áòÝ7á§ÞgÛ§Þ7áèÍåòÝ7áPãòÝÛã§ÞÈÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛS¦\ £¦ ::U¨ 99“« \99úÑ ßÔÔõ® ,,£¦ IIU¨ II Ò üõõ“« HH– llQ bb) PP= SS8° hhaä eeR YYe \\~ __@ VVu¯ jj\ %%˜  # ÊÔû ×ÛY äè¯ý òüÛ»»ß þaz Þá(ü "½Èþ\ "ê "úÑ { "––dà  "õ® "©©£¦  "™œU¨ ÿ " Ò k "“”“«  "ŠŠú û "¦¦Ê . "ŸŸrÕ ð "¢£˜ ÿ "¯¯ó û "­­ü "¬¬Í  "®® "‘k "îîÕÿ "üüÿ "}}Š "mm±. "yyŽÐ "zzÁ. " rr5ªü " nnÌ " ll5k " ssVÎ " ooÍ "ì÷ "ðð£@ "  º@ "  ó "ÔÔ>@ "ÍÍ-@ "ÌÌQ@ "ÎΪ@ "ÒÒ‹@ "ÑѼ@ "ÓÓ}@ "ÐÐc@ "ÏÏâ "ÛÛ û@ "ÙÙü@ "ÚÚÖ "èèe@ "ææw@ " ççJ@ "!ûû@ ""øøèý@ "#öö÷@ "$÷÷Øý@ "%õõ@ "&ùù2@ "'úú¸ý@ "(ôôA@ ")$Þ@ "*Ñû "+ááo{@ ",ààˆk "-  ".ÈÈ”ý@ "/ÆƆý@ "0ÅÅxý@ "1ÄÄNü@ "2ÁÁ\ü@ "3¡ý@ "4ÇÇ2ü@ "5¿¿jü@ "6ÃÃ@ü@ "7ÀÀÒ'(++*,1d05.-/Ï3B4(6Ñ7õ?e<‚:d;d95=>8A‚@ÐCíLÓNIJdM5HGFpKóÍóÜ5ª“»Yâ1Ô ×ó VÎVÎ55Î6-q VÎ5á5ª5ªÈø«S¯ª)5ÉS8Þ6-Í6-ŽÐ±Á ÁS5ª5VΖ þ\  £ª "#U #Ñ)?ªd– £ª $%ý Óî< %8& Ei® »ÇØ –®W t‹ÑŒd‡®?ªØ­ÀèÄ«kÀ–Ù »±Ù °±, þª  ³Ù 2ªç ·à‡³  ##ѱo²Ç}²o´Õѱ?ªç±– 5  þ M Ù ½É[ Ù Qn…  x±e Ù 1Gu  Ôê)dѱŒ‘ ¹Œѱèd{¹– þ X  + ¨ Æ i ² / ® i EÂñ  ™ º i ˜Ž i  Y  5²J  £*   §"  ¢ i –=  kÜ  cþ‚ i ±`2  Íhj  ½:w  "sŒ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼Œ¼   .= I KVM  5DŒ" / Œ" / Œ" / Œ  ò S ++¹  %%Ö S ((¤  ""S¦\ ‡³ S ºË‡³ B Vd‡³ ã AP‡³ B ,;‡³ S &‡³ S û‡³ S æõ‡³ S Ðà‡³ iw‡³ S §µ‡³ S ”¢‡³ S ‡³ S m|‡³ i Yh‡³ i CT‡³ i +>‡³ i &‹  |  – ¶â DSS n X`Á  +5 CCC  FVðS '7Dð'44° '``AE@ '\\[(@ ']]‘M@ '__-A@ '[[xl@ '^^_@ 'ZZÎN '55)@ ' //^Ð@ ' 00±@ ' 33ú @ ' ..Ï Û@ ' --˜@ '22}@ '11Æ@ '44í 'VVWi@ 'JJri@ 'KK L@ 'RRBi@ 'II´n@ 'SSÞi@ 'NN§i@ 'MMi@ 'LLñC@ 'UUÚ_@ 'TT@ 'HHl @ 'QQa@ 'OO8 @ 'PP£ # ' DD't@ '!;;A(@ '"<<@ '#BBD@ '$::ü @ '%99"ò@ '&CC^@ ''==ñ@ '(AAÜ@ ')@@¾@ '*??Ž@ '+>>Ï Ï d d 5 /¼Fd5ï"¯d5$%i#dye! l+d*s'("- 10/.i)d,»EESÌÛEE6-ê EEßùEE6-ÌÿÅ3‡ES® EE6-ß3uÅEE¥, r ¶  C !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRC !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR!STUVWXYZ[\]^_`abcdefghijklmnopqrs!STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€tuvwxyz{|}~€1Hax‘ª‚Á(@@ @@  ¹t=dž'8€‚„‚ €!  €@€‚€¹t=°á€‚„€@B€¹t=ìõ€„@€€¹t=y  ’!%¹t=‘á €’!€ ¹t= Q  ’!‘„I¹t=_(^ ¸ @¹t= SÖ ² ‰’ "B)„ H¹t=PEÀ ~ €”* ‚A‘¹t=Ž â   €€¹t=¿ r3,/€@@‚@A "B ˆA!B‘@ˆ ¹t=Q €¹t=ÄH$¹t=AL¹t=N@@¹t=‚ñ * $"¹t=© ¹t=Íû HA  ’¹t=ý~( ’"T¹t=ãÉ€ °$¹t=QÛÁ!)CL*„€!Šˆ$ˆ FA¹t=ãÔ! "¹t=Y"6$€L‰‚€¹t=.O$J&5€c­âµ¦¹t=ÕS&Í'Ô\™R¹t= û'r(€,¹t=-‰(‘*30ˆP@UA¹t=ñ¤*N.'=0PŒ+‘”¤"IV ¹t=c.…0%0 (ÐJÉ ¹t=0n210‚-ª¹t=´2¾30ª’‚ˆ„¹t=Û3í4 iÚ¹t=5±5 `9¹t=Ó5]6 йt=n6—7€»™¹t=£7ç8"€ (nä¹t=ú8“:+1]Õ¹t=¥:?< `q ¹t=J<g? ' ˆ€6 Ey¹t=•?£@ @½+¹t=¶@‘B ( Œ MÕ¹t=¥BÿE$A@|SO”ʹt=FÝG€¾R]¹t=ñGJ , н:¹t=/JçK€|«\¹t=LœM&0€ýª¹t=´MiO90h`Wë¹t=vOÃO0€¹t=àOÆP¿¹t=áPQ@¹t=?QvQ@¹t=”QËQ@ ¹t=ÛQR@¹t=LRƒR@ ¹t=“RÊR@¹t=ÚR-S@0¹t=;Sï\R -xdoÛ«|YßÕºíM¿­¹t=].^ @L¹t=>^ïa' L€€ïÿÖç¹t= b_e3` 8@ ûÿïx¹t=oeŠf‹¹t=¶fõh! €ÿ¹t=i”i €à¹t=iÑi€¹t=ài{k* €„âþ¹t=km ~¹t=-mn o¹t=%n¯p! 5PXÀÿ¿¹t=ÀpYq €à¹t=…q»q¹t=Îq1t  ðý÷¹t=TtÁt¹t=×tA#¹t= u‡u¹t=—u¢w `ÿ¹t=Õw x€¹t=xux ¹t=xÉy  Ð/¹t=zMz ¹t=Tz]F,=   @@ðÿ¿¾Í¹t=}²¥dC/€€@@B €@@€@  a@ € @üÿÿ¿÷ÿÿÿÿÿÿÿÿÿ÷ûÿÝûîûÿÿÿÿÿ¾÷ÿ¹t=t=%¦‡©A` @Em¹t=ç©Òª `@йt=îª1¯'_`@€yÿü¹t=H¯°  €€À¹t=°w± ü¹t=ˆ±LµE  p½ý¹t=cµa·(  @ lâf¦?™·£¸ >¹t=·¸»»9 Àÿ¹t=à»c¾,T €üÿ¹t=p¾›Ë <ðÿÿÿÿÿÿÿ¹t=ÅËÖÌ %è¹t=áÌ€ÐV0 €@;ÿ¹t=žÐ`Ó30÷¹t=‘ÓS¦@ ¹t=¸ÓèÓ0€¹t= ÔøÔ €À¹t=ÕáØi0À@ {§¹t=ùØ"Ù ¹t=-ÙsÙ¹t=zÙ‡³* ¹t=¬Ù‡³ž ¹t=àÙ1ÚÀ¹t=9Ú_±h¹t=aÚþ@¹t=Ú8°€¹t=¼Ú[pl@Àÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ?¹t=rS¦ ¹t= “« ¹t=Ò Ò  @¹t=– 0H¹t=£ÖO "7@@A@øÿ¹t=ô¹t=U  ¹t=sW€¹t=ç À ¹t= …  `¹t=¢ Æ "€¹t=Ù M  0¹t=] ò À¹t= ‡³ ¹t=C ‹ ¹t=µ ¹t=ï ¹t=. ¹t=l "2'+ÿÿ¹t=:¹t=ÝçÛâ‹þ€Qï_÷qögñ8úéýìô…õÿÞsÙ)ø×ç3ãõú©âÑßô÷aïê¹ÞNë2%OèI9O1GO·IC2=Nçx|ddßcOeBd}!,=¥w ?s¯ò † *‡ußÇ Ã)ŘÉX _Ê‹Èò¿UÄÆ bÃwÉJÊĸÇå¿mÆ‹ÉÃèÄ® ]6HÅæÅ:˧ÀÅUý¾¿°b|À›Ë2ÁܾÆFÈñ  É·ÈÝÉ4ÄÂÃÒ¿0ÂaÈ„Åƺ½¬½Ç½j½Ô½Ó¼â¼ñ¼ˆ¼¦¼Ä¼—¼µ¼½½"¾[¼j¼y¼ ¼.¼=¼L¼¾û½<¾v½¾-½<½á½î½½V¾‘½I¾‚½/¾K½ ½c¾¶Æ?Éž¾¸¿ËǼÀwÄȳÄ]Æ˺ ŽÇJÂŽ ¦ÃŠÊl¶Â_¿¬ÊÊÈ£¿ÍÊ*ÆÆnËçÀ Ç¿lÅòÃ¹É ÊFÄøÀM¿\ÀÞȀǷÁ˜Ä‚ÁJ TÅ;ÀsÈÊ{Æ ôÈÕÀÞÆ-À:ÃÁÅ(ÈÃÄqÁtéÈ" ¢ ]ÉÅZÁ@Æ÷ÇÅÂо˜ÂÅûÁiÀ@¿4Å>ÇýÊ”ÁÁxËRÇŒ¿2Ê= ÒÄ%Ä¥6#ÉóÉ…ËäÊ¿ÇÜ NË”ÃÄ‚ §ÂÆÉ¢Á}Ê2 Z½"ÃhÇ3¿ÎÁw HÀ&ËÅÆ¡ÇÑÅÇHõÅj ÝÃÀõÂçÁx¿ÆòƉÂÖÂÃá¨uº »¢º¿'yó¸+»º… e ˜º·Ï_ TÌÄÌìËCÌa! ,1KN[u€¬·¬g#0ƒ¥–ˆºv½† xF¥ZY|¥èGz-€QfôeŒæerŠK_dûž"Í'…0H9 "ë7KBœM;1ÉT?j!Ë?Ü:RC‡%‡FãW6HzJ<+2hÑi9j†l¯pëMq¦PMz1(Ãí4‰)\(r(<‡"†/¬G3°9ÈG¬&q‡Hš­4p3-—48dA7LbF£‹q)>€O(­A4›1Š<YPQvQËQ?ñY4P5¬æ].^š^:]4Ÿ<SS-SRƒRÊRÀ4@Ø;Íg?i%;D]¤$I] ^^ÊSŠfuFŸ]fr6*¬Op4Œ5c5fCÜBFd‚[† 2M1ÓÏlî:<â?}@¶"V"£$-C% ' TµV¨LNL[/d0±6J7JMHgaVbD [O^b'AçÎ Õïa}aVâ JPŸ5¦^¿n ÇÒ3ÓÒ¶º¹­Ž°°Ò»÷¬¬<&ÿ­®©µ³&Ñ`ÓÙ´·0·§¶Â±I´Ÿ³Øÿ®œ´S¶×µ¶ô¹á¹È¶ó¶a·£¸@¸%Í€¸"¸¢«…ÑÈ·Rªþ·o¸>³ˆÏU*¬X¸é·º³±²–ÑÓVºX¹JÏý×Ạºš®±«¯W»»%±ÔÕA×yÕ*Õu ÆÐŒ³ÒÑçLµÍŠë°±ŽÐÁ±f¨§­¦5ªôÒÌ5VÎlb_eä&”i&£J‘+ .ápá‰M€L“LHjj@0š.¸ ¨hVG'GÁb½[X6$wBAí#D?² ~ ŽØñÕgÖõÖ¨ØlЖÎ×áØMÖ__Ûa” g…iÃh:i«EntiGiîm>C[n¡mÎmn¨Q õ±² Ž Î(` ûUì)Úï\[hPf@ÖE¹nTqôpÁlYqÊlmQ‰Cj±˜Ae._½&ó#Ÿ[n2iOˆO¬w±lÍ,ÏcBnmnA;»)ºJ»ˆ¹²¹"¹»G°° ÖY¿6ÀE !ä­õDÛ‰çìÜÚüµýîãì¤öÄîèø€ûVýºõòîVù#îŒóSð½å«ì#ߥæ`îƒêÂÿ£û2ôÞì+è úëá¢3õŸëýõüñ±ê]øñ+ê½ÝiQô(ëcçõòï#ú(ñÎúáÿãëuíÿò­ß9ïgûWþ‡ô­Ü`á|öŠß7ààågé§áyú>ñ4ì¢ù»ôïùUóKî¬þÎö ô¼ü[üæÆùÔá—ì:î3ó©çšýqþsáJà9é°ð„ÿNò½ëÈíýãRû¡åx߮۰èîãÏðõ ܧînõðŠéÅûŸñôŒõ”÷«íÛÝ·ñ9ãêçÉã•Þ3ùðZ{X%X’àBðßûç:ü!þíûIöÞ þùßäî-÷óå¡ãŸÜæTçìä4æZëåßûê à@û¥ó©øoïíèÞïRèsù*ÛÞ÷ŽÛ¬÷€Üoã°ö0òoøoàNåûøó#ûÕæÖõöÛùÁ²ãëÿÝö å>÷%ö9ýé ÿmôëðì\ìóójò®àáÎêðêøIáÙܽá|æéÁâæKéeÿ%ÿ<ä)ý”ðYäÚï.âcúŠù0ð÷×àƒá$4ß;ÿÙý:íÛâÞùßKÜ#ÚøÚÛËï¾évýAèëàøì7Eþ ëýtëXí0åþü'üwì‰ñžï.ÜèÚëíÝSîÛ àyðaÝìñÁìCÝaêÎñÔôêÖóHúïyÛÆçzÝpñô¦é¿àÚîüøÞ\Üò¤8¯Q~°ÎÁ í Ña£ ðìAhÚ7kj•lÙnÈ8!q?<ß^e„“:¬1oL½p=w"œIÚ*çKT0)N&*€Ô6—7ˆm®noû¨Q › ÃOê2¾3îh+6 Xe9zzÔÒbÝG (Ô&Ú ØÂÔèÓîÔ¹ÔßÓøÔÉ%›%Ó$·% &µÛ%&.®šÖ~ b ´C ô ¯âxÇ909Ÿ&‚àÙ½®ñx™eà‡øMA¢ÂdþŸÁ‹ºô^èÿHøê÷{‘ÿ=øÿAíýQ)~dýRäq÷3tªÉi-°vü óýã«pâÜÊßœƒþŸqþrþ§ü‡xË%˜þAøÎÀ?ràÿø “?>Ð2¼nÈ}Kv½‡ Á±bäÿÝðž¯u?€Gvåx˜¾„ÿM§ÃòA$ü É=åÿ_êÀß”¤-ü'Iö9ÉßµÏK dû‘™§ÁèƒÆoKð¯Ëç':ëۇà çÀÿ{Ø÷Ü ñAÛƤXøÑ2ìÀè¡?Èo°.Ãåìh|?§a>§ã~L§!ÍLºÏ!ÇßÈŸ9 å ‘ryÎ4QÉ’§f ñ¡1‘¯ çýßtñÏùC$ßà{šÊw?r'êþÿÆÑÇ ™&ÿ@,ø+"7x\ˆœýÍü‡\Õ‰dz˜3þñÒ|˜^•Cúÿæ÷ko°È¿Ô9€—Þw#ž¹ÓcÁá}X¼Oë첎© ünÓðþÜÉdBÉ6B>n2 ŽøcÙà¦c.züñ2,-žø¾Xê¡…`Á ¢þ[ÅÙÞ€É ø`ÿ¨7hûzÂÊ?Ý?žÍ¯.`äàô]\8E&Þú‰?k´]sxˆ£÷úŸAÿO4x³Ý¡?!/@é`h)ÎÁ]qEÆP1£@ (úÑ r°±ùe‘ Q5 8%€m…0Nò´m!q E»±¨ï .â/m ÒrMjQçÁš]±X$)m ¡ŒQ aØ.s ÐQ Ò `w 0ùaOjòmûÁl]a ;7AmKâm‘ QGqE¹¡‹Qòm*a ;wkQl#€Âh]o YqESTmŸ Hùí@)Ò¡ƒQõ±XGÒ`Q @õQ2Ô0¸‘àQzâm0Â(]i|mA)¥ò$më¡„Q¼  ¨fQŸ  €€<mJÂ8]ga ;A)¢®Q´€ç‘Q©âHm½ }a;ØòmÏiQ¢rmlÂ;]1Áâ mèò'm»qØœ"Ù Ú!€4¢¬QvQ3,1 Ám‰Âž]§a;°Ò `ÿò‰móhQe² XÛâ8m;1 !¨ùñ €dA"õ ˜Âk],’çQ×m»a;ÇÒ`M1(‚§Â†]óm{A )‚UQ €Ëa ;\1h¢¶Q ¶Â<];!ˆ’! €Ûa$;3ó«mrGF! ,‚<Qþ"Xö›A)rGôÒ`- € )”mãWmïa;1 ËQ4ÖŸ]±²X)F‚aQq’ÕQUóŸm Ó` $ D œ¢—Qj!3ãFm#8mA€% Èõ9ãÍm›1À&ÓÓ`õ™].  ÐÇA)9rGW }!d‚_QÖ²X6 à,[ €só6m¬1@  Ã]MrGš’æQ3Ó `€ómHmäA )Ã]Â1Q èÑÕŒó`mw Т­QR5…‚lQcã4mx €"Ê][¥mfr7QoãùmaØ-!¯! Ö1Á’âQ¥óìm‚`QB)• xr G³XVb,<:ÃV]`Ó `u Á!…ãm‘ €HÃŽ]£•Qlb-<°€»‚3QUÃ]¡ãßmµ *B )|b<bà ]¤rGÖóbm>³X2²ãmù’Q΀tÃd] 2 R³XKB)ÉãÏmÖ]óómá 8£ Q "ì‚GQÌr GƒR6ôhm¬bHk ð€cB)°b<"“ØQ”Ä]ó+ C2 Ô ü+€îã½mÁb/<¦Ã9]wB)ƒFQôÈmîrG‡³Ûˆ¢ Z2ýã·mŒ³X, *€Òb2<E“ÙQl££QßÓb2ômm‘B)ÂÃ&]èÓbn2ýŸ³X0ƒ`“!''€ éb<V"x“!ÊR7!äOm4. sG Ý×]Qô}mº³XA(€c<š£¡Qr( )q€“ÚQòÃI]w"À“!S/ <ä*m:sGmômc!<5#r^-€Ä…]‡"ð“!=qÜB*Yä-mwƒJQ7ÔcTsGr- £“×Q‡ômRqÄ]7c<Ï£¾Qž"S8%Ä{]Dc<S8xä"meq ô£m—ƒKQŽ1€¶"8”!us G4Ä%]Qc <YÔc-S8Æ“Q ´Xê2\c <É"h”!~qFÄL]C *»ôœmgc <µƒIQ¤¿QzÔcUÄ ]rc <¥äm-Cø"–€Sá"¢sGï“Q}c<Ôô`m¾0€Ôc£¨.!ˆc <>C *I´XÙƒLQ™Ôc®À.!“c<wÄ2]+¤6Q$3ìôAmqSÈG!#àG!Ü/€ºXSŸc<RC*­Ôc}S9”ÌQÇ!õ€mE¤5Q¯c$<¹Ô cùƒÄQfC*ßäàm˜ÄS]ö Í%rñ.€ÂÔ c## ìäêmõ¿mO3  ]¤2QÆc'<)€ê r³Ä4]B”ÍQõsGŽ´ Xï‰C"*p¤:QA#pH! å m3õsmœ´Xßc<ÃÄY]•C*p3I#îÔ c",€æc(<r7„$QÒÄ|]¢C*tGøÔ c‰¤9QIõm"ÊS5Q Erm”éQg#ÐH!ÚS90åJmd%< èÄ]#rr#I!1tG¤¤;Q*-+rËC*nõÃmÙ´XÅg]Nåþmd <’”ÓQÓC**Õdm„dQ>*rÅ]K¾3…õBmȤ8Q T<95d<ŒõÂmQ,rÅi]îC*Bd<´”ÔQª# )Å]›õ/msåmµXc1r'TA4Åo]è¤7Q\ÕdUd<s­õPm}0r÷ mõÖd8†-Q 3rÉU(9ôe=«E*ÞÆa]m–åQ=Œ5!4r&v Ki%ø( ¸E *×d_÷:mȶY£¦r(ru% èUN[†Ø&Ó>ç7mŸ5!òÆ]ÀE#*0j÷ m~% ­¦S2LrÎE *ÇB]‡%ûUG9n†cQ±5!TçémÖE!*@NrMv KjE Ç•]NIr›%cçmV69ó¶YêE*A×d††bQÇ‚]”÷Ém\Jr÷E *®% ovK½–ÐQÿE *jMr·%Qf=¢†aQ· Y¬÷÷m‰çRm>Çp]|vKa× dxHr8V9É%€©†GrÃ÷mRÇx]â–ÏQ½† ú0· YÛ%#v K”Fr©ç¬m 6¨Sˆ{ž§ShÇ‹]í%¡Kr6"Þ÷õmŠf=>FÐ’!؆{¯rºv_QÆç^m&6" —ÛQç†TQ€ÇQ]OF+ô÷Km¸?r &}V9a·YËvK×çEmŽÇ7]:6"bF“!øZm&‡SQêçÎmØ<r¡Ç“]1—ÎQømmuF+VE9êvK0&ûç.mè:r]6"ì )øDm¸Ç]0“!‡F+%‡RQµV`k ÷;rJ&wKËÇ0]ÃV@9êf8$ ŸF +8‡QQ9rý×dõf><“!+èomÖVA9ßÇ]=rK‡OQs—ÒQµF +  +wK]øxmÈ·ZØdAè>m^‡PQ÷Çf]0S¨“!2>r¥6#oøüm³§SŽ—ÑQg°"ÓF+Š&Rèòm±6È"q‡¸ÿÈ3]kØ“!PwKé· ZG ‚ø#mJ8r¿6#&èÿW>9©—ÉQ…‡tQmèmYrþ·Z¬&(ÈX]ûF +owKf{èmŒOe6rOg >Þ6 #Ä—ÊQ©øímp ½&—”!§‡uQw7rèYmFÈ!]ñ6:Q"¸ZggGÔ&ß—QŠr³€”!LWD97 #¨S{g>ä&aÈ)]˜r¢wK̇{Q°è¼m@¸Z4G+Úø:mŽØd££'rñ&.!7 #sÈ\]¬lWC9˜ÿQêøm•g>×°”!' Èè!mX¸ Z·¨Ød-7 #º(rVG+ï‡Qûøÿm‹È]' Ì"ro¸ZŒW\Qϲg >Ö5rJ7 #U¨r@H!ÊØ d€¸ZWB9ôèmá .'ˆˆ€Q©Èc]9˜üQùÜmG+f¨S:' émÒg >·È#]e7#áØd3ùÑmém£¸ZÊÈ?] xˆH!4ˆwQÂW?9›G +V'ñg >‹¨ S…7#¬G+ÞÈP]o˜ßQA¸H!VùfmSˆsQ# ãW99é±ms' —7#h>ôÈ_]ÈGI!"ÙeôW59Ké"msùómÞ¸[<rˆ‚Q' É"]ÝG+Px0I!N2h>¥˜Qó¸ [Šù1mgé–m '¸\x`I!Ut#É}]X9Ah>„xI!gxðk ᨠS%X9—ˆ|QÚ7@ž"¢ù›muxMZÙfQh>¿'ŠéÅmw ?É-]7X 9ë7 $²ù&mû¨S"¹[Í'‚ ©Û˜ùQsÙfÆù§m½ˆnQ'Hà!8(ø¦éim·Èl ]Ét]VXO9}h >ž 6H,Ûùm8$¾é<m·xXm ®uwÉ ]âˆzQØïùžmX¹[MH¸N-8 ${XL9™ýQZHP #‹É]¨hXøÙé mì`e ŠXN9˜É] úpmÒ¶hˆøÝxNûâxN ‰yQØuçx¨PÃh øà 1(ˆ¹[#ú‚môxN‚H,f©Sêaml©S¹ÉJ]H™ñQõµXM9j8$u©SýuÆɇ]8ú?m1‰vQ™H ,O(yNêMm~©SîhÐø‡©SHúcm\(²¹[õhèøÝÉ$]+êzm°H,'y NÚiàXQ9”8$r(W‰rQ&u™ôQcú0móÉ~]ÇH ,2 ¤8$@yN÷XP9)Úi<uÊ]]á¹[±8$A yú˜m1ÚiÞH,v‰pQH aê\mP ‹úmô¹[È8$:i?X Y9 ÊK]¯™QWuöHVQrê(mGi?$YÀœ"ÿH,–‰oQsy N º[Ú8$2Êz]ƒêjmTi?¿( º [ç8 $y9Y"9I,JÊ ]Ñ(y N¶‰qQ)º[á™ÝQti`ùÎú„m_Ê]ªT4Iȯ ZYIQ±êwm…i?fY%9܉}Q”ixù³vVº[MI,}ʉ]5ª!rÎêmõúGm09%ÉyNŠÊ:]) šäQû%mŠY9Î Š~Quº[RªTêê5má¬Ê>]‰º[ûêæm#ûmçvÑi@­Y!9=) HšQ%ŠQ˜º[ ëCmèÚQmm9Øù¢º [œI,ÍÊA]@ûèm]š¢Q„ªT3à( ÍY&99%¶º[(ë~mRû¸mäÊ€]·I,ÛEmwš±QHSŠxQq)£ªÀgûŒm9zOjAïY'9Óº[?zOýÊq]5 w^) NëIm‘š·Q¸ªTGzO*Ûôm‰)áº[°9 ’!rŠP"MzO'j AZëäm€û[mJ |ŠNQË6]M wèI,Z9T  ÒªTDÛQmÇ9%9j A°š–Q[ w&Ë‘]_ tëHm»[HjAýI ,×9¸’!e w˜ŠOQ£ûlmn :Ë]u wJˆú6Z 9ì9%ë,mÒšªQ~ ¹û3m… wN˃]kjA¸ŠPQ+» [yÛemŸëtmÅûÆmŽ Ý)¹ : %{j A;»[› Ίh"\Z$9ŽÛöm«Uøš¤QÊèzßûÔmnËE]J»[ÙŠRQö) ½ëµm(«UŒjAxËw]² %: %íûØm3«Uj“!Æz0P{Z9…Ë]®Û»mÔë0m* ›ŸQï¯jAeJ -Î ãë‡m‹SQD: %›Ë]—Z9&*0k Ú »[ülmÜ xzJ -â  ÆjAd«U‹YQ6*ê  ÚÛ;m'üKm ìXmc: %ñ xŽJ-M›¦Q¶Z#9{CP » [K*îÛUm:üÖm x, ìmëjA9‹XQ£Jxk ‚:%ÑZ9  x“«r»»[o›¥Q ÜÀm4ìšm¹J-“:%kAìË ^^ü2m¢«U"  xTðZK92 x±«"Uuü mb ÔJ -’›¨Q=  x.ÜPm%kAC ‘*n\ìmJ  xQ …‹bQ~Ðÿ[I9X xôJ-KÜ7mm{+PwìMm¹›§QJkAÜ:& ¼\j x\Üom£‹Qw xK-^k ACÌ ^î: ”!¼ü¤m—ì©m‚ x¬UÞ›©Qº‹òQokA.¼\TÌ^Ú*&;P”!Ž x€ÜømQ[9” «ìcm{k A¬U=¼\fÌ^7K-ë*Ç ¨#][9; &ÚüTm¢  xÖ‹QÐL¼\œ›QÁìZm*¬ U® xŸÜâm¸ [¼\º x­Ümò‹Q[K -þüLmÆ xj¼\Þìnm”Ì^+ Œ[9%œ³QO¬$Uy¼\L; &ÁkH!ýGmŸ[J9ŒÞQøì@mÉk Bˆ¼ \ÙÜm³Ì^­[9<+)ý+mJœ«Q—¼ \‘K-ÝkB|"PíïmÄÌ^ìÜSm½[F99ý m€¬UP+¦¼ \7ŒúQ ðkBÖÌ^§K- yµ¼\ †;&Ô[9qœ˜QVý^m)|#P!  H!ļ \»K-lB:íDmæ[9¦¬U, _ŒóQÝSmÓ¼\6 1 …+ ·¬U;  ‘œ¹Q"l Bvý=mâ¼\Í_B = yXíIm‘+(ž"l \99Í_J  M yÀ; &çK-̬Uñ¼ \Q „ŒQCÝ[m:lBÍHI!Žý1m§+!%Í_½\` uíˆm¶œœQšý­mᬠUØ;*\89½\o  aÝXmÂ+é; &‚|]l B ÷¬U½"\µýUm  ²ŒöQ˜ím¬0† ÝœQ-½\zÝ_mŒ z½U\79«íÊm<½\ŠÝ m7Lœ!­ Uë+†lBÙý4mlÍ_¤ zÖŒõQK½(\Ð «  <&’QvÍ_éý@m•lB² ¾|'PÈí¶mNL .Z½+\¹ z…Í_¥lBè €\;9üý m,j½\ûŒQ°l B?<&½Ý{m%“Q þÛmv½\Ö zoL.ëíRm—\:9ÁlB¦Í_‚½&\ÊlB!þ×m€L.ÛÝËm9,#‘½$\FQü|-P"ûQ ô  ò z“L.îVm ½)\  ¬½\EþBmÊ\9<ˆN[,"¨LPœ!#îgmõl Bg´QÞnmº½\Š<È#KQmBWþm  ž­ U»L.ǽ\:îªm'  Þ5mR Ÿ<'{,‡½Qï\H9Ô½\qþ®mKî mÓL .¹­Uá½ \B  sQÎ _9Þ)m˜,î½!\X}¨œ"`îim‹þ9mû½\Z  óL^QOÞ mb  ˆ •Q¾\¾ºQ£þmM.ê­U»,¬þ¡ms  ¾\:]:îám~  | |dm@‡HÎ _"¾\ÿ­UMTQ¹QnmCà‘QI]:/¾'\ÈþmVÎ$rÜ,ÞÚm*M .§îÁm‹ |aÎ_<¾\='Ɉm C"® U•ÞÐmI¾%\žµQú,ÞÜQÄî]m»}>P.®%UKM .V¾#\,=௠¡mC…Î_c¾*\Úîkm-¹ÞNm–Î_A=''ž…Q ÿmlM.ŽQã}@Pòîem\®UŸ] :[= 'ÎmC%ÿ$mðœ"ïdm‰M .ò  =-$ "ÿ}?PNžÀQèÞðm*ŽèQž¾.]ÿ ! ;ÿ3mœM.ïñmz=@‚îmC08"~=PÿÞCmMÿ+mc- ='nC½¾] $ užQš®!UMŽíQ9ï‹mßmæ]:eÿ#mQh^оj]nC#ßdm@~<P©='_ܾ]Qï=m‹-–ž¼QA ( ^ :4ß2myŽìQ„ÿ³mp#aïLmëM /^:Y " IßmÎ= 'oïîm¿] ^ :ÿ†m,Ï_ûM/¯-½ž»Q¿G].^:š~~9P¤ŽQ[nDõ® r| # ¿]JÏ_ÿ®UÑ-ÂÿkmxߺmžïOmãžÃQYÏ_)N/¯&U3¿Œ]ã- nDŠßŽm & ÌŽëQ@¿n]¯#U> '£ &€¸ïm=N/Í÷-M¿M]’nDëÿmKN / Ÿ†Q1¯ Ut^;Ëï9m_¿=]­ßŠmÀ % ˆÏ_XN / .è’!ðŽQÁ €Úï.m:> '®nDÏ €“^ ;x¿›]pN/4Ÿ‡Qòïmà ) ©Ï_ÑßJm¦^!;5.êQŒ¿y]€"ðmÙnDåßåmu¯˜" (ú €' N. £¿@]Â^H“!énD7P]ŸžQƒ¯VðÄmÓÏ_ùß6m¦N/‚>'Ð^ ;únD* ¸¿/]KîQ0ð%mš¯V àVmß^&;I'o DÁN/€ŸQ+0 )€öÏ_BðÓm:6PÒ¿']¤>' àçm? Sðamå¿ ]vðQßN/n&į V ŸŽQ7à“mL _";š.4oDò¿]Ð _%Jà°m_#;^€CoDe yðWmÀŸÂQ–^Qã> 'UoD._%;¤ïQÀ˜]O/dà r÷¯ V}€ ¥à"oàým”ð,mhoD° V-ÀU]%O/K_;?'韲Qº˜€;À[]› €o Dé.°ð²mÏ Q9O/a_˜”!lÐ_’àÒmHÀ]³FQÔGO/±€ÿ.šo D  ¸Q€Ð_ÀGQt_;\ÀO]8°ž"Ïð¾m®àmÌcQ[O/ô QÆ 9?'iÀm]ŽÐrðG° WŠ_È”!Æ€iO/D?Ø.!·oD¿àjm•_øG!ëðmV°W|À]4 ¯QèKQT?'è ×à'm¨_(H!Qí€û%Qñym×o Dg?'ëà?mÆÐ`~°WÃ_;\ °Q§À]€ZQ €[/XH!Ž°W¬O0(ñƒm<ámGQ ¼À1]"€Ü_;éÐ`n/ -€LQá…mÃO0>ñ™m„ ÁQÕÀ`]4 >€Qö_;†/èH!"pDqQB€çÀF]S€#QÅ° W/`;gñ>mª ™QøÀN]W€Ë?(Iám\ ‚&Ñ `pñgmLp D›ÖQë°Wâ?Ðz€"Q`á‘m»/ r€‰ñNmΠšQÁs]9`;P1lám¨ö? (sá¯mkpD±W"Pø#‹ ŸñÇmÚ/ 2Á]€R`;ƒá(m.P 1ËáQœ @Hò ŠQ·ñÌm‹p D§€%±W­ û/ JP 1%@ (½€&QZÁv]§á—mÎñ]mì Q…Ñ`㡉QYP&QÉ ¯pDG±W‹`àl –Ñ`Ù€ÇQhP 1½ámD@(0 qÁb]S±pøìñYmÞ€xP1 "T@(_± W‚ÁT]‘øQ<¡”Qç Ôá¨mó€ÆQüñvmƒP 1j± W”Ár]f@(@0! Ow± Wëáqm»`Àe ¢Áˆ]' !2 òfmQT0`¡ˆQ}@ (ÒÑ`¦P 1>‘÷Qôp8œ!·ÁR]Õ`;d0? ¸ø $gQ0òûm$€qEâFm];"<X^vXvY;<!$(0 9 GJNP'  2345678BEFF PQ   MSTUVWX[\]^_`abcdk rtvwxY   MSUVXcY   STUX _`bd qtvyY    P Q   CQVWel q :q >?ACDMqY<<Xggggggggg g g g g ggggggggggggggggggg g!g"g#g$g%g&g'g(g)ghhhhhhhhh h h h h hhhhhhhhhhhhhhhhhhh h!h"h#h$h%h&h'h(h)h*h+h,h-h.h/h0h1h2h3h4h5h6h7h8h9h:h;h<h=h>h?h@hAhBhChDhEhFhGhHhIhJhKhLhMhNhOhPhQhRhShThUhVhWhXhYhZh[h\h]h^h_h`hahbhchdhehfhghhhihjhkhlhmhnhohphqhrhshthuhvhwhxhyhzh{h|h}h~hh€hh‚hƒh„h…h†h‡hˆh‰hŠh‹hŒhhŽhhh‘h’h“h”h•h–h—h˜h™hšh›hœhhv{{{{{{{{{ { { { { {{{{WQXQ ))PQ))  )**qtuvwx V 9:  )S_dIOPP)9P@QHH !"#$%&'()*+,-./012345678 9:;<=G !"#$%&'()*+,-./012345678 9:;<= GS_dP0Q) dYP3Q*K KKKSTUXZ[\]^_`adnz**BQ`Q[Q\Q"#11GEQYQZQ+ +9QNQ PQ$ $9=9>?@ABCDEPQ $>D##QmQ  (PQ    $  $  $LL$P QMDQ+MVeMY$((P=QPQ$NU, ,/ /,/>D$>DN N>D>AD>D9P?Q?A,/?A%,P QTUZ[ _tu %P QQMQ% % , /QQQ%AA- -%& &&&&2345678BE  _dP-QEP]QP)Q PQ'-.. P"QDP[QCb'' P$QKK''--%-$Vc q;;<#<;<Wlq;<'-;*<;+<PQ( (1VYP,Q;&<jj;)<EE '- þïþï0Jpglless - Win32 ReleaseJpglless - Win32 DebugJpglossy - Win32 DebugJpglossy - Win32 ReleasePapyrus3 - Win32 DebugPapyrus3 - Win32 Releasedicomdir - Win32 Releasedicomdir - Win32 DebugD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\decompoptimise.c"io.h""jpeg.h""mcu.h""proto.h""PapyTypeDef3.h""PapyEalloc3.h""PapyFileSystem3.h"JPEGDecode_WithoutFilevoidPapyUShort *JPEGPixPapyUShort *image16int depthPapyULong lengthJPEGLosslessDecodeImagePAPY_FILE inFiledcInfoDecompressInfoJpegInFilePAPY_FILEReadJpegDataPapyULongPapyUChar *bufferPapyULong numBytesD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\huffcoptimisebug.c"predict.h""jpegless.h"freqCountPtrslong *%[7][NUM_HUFF_TBLS]FreqCountInitCompressInfo *cPtrhuffPutBitsintFlushBitsHuffOptimizelong *bestTotalBitsAllPredCountOneDiffint valueint tblNoHuffEncoderInitAllPredCountOneCompint colint curCompMCU *curRowBufMCU *prevRowBufGenHuffCodingHuffmanTable *htbllong *freqbmaskint %[]EncodeFirstRowPapyUShort *ImageInnumBitsTableint %[256]HuffEncodePapyUShort *ImageFlushBytesCountOneDiffint difflong *countTableFreqCountAllSelValueEmitRestartHuffEncoderTermoutputBufferPapyUChar %[JPEG_BUF_SIZE]numOutputBytesEmitBitsSumlongint curCountTblNoHuffmanTable **htblPtrFreqCountSelValueSetAddHuffTableHuffmanTable **htblptrUchar *bitsUchar *valStdPickSelValuehuffPutBufferLoadStdHuffTablesD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\huffdoptimise.cDecodeFirstRowDecompressInfo *dcPtrProcessRestartHuffDecoderInitextendOffsetint %[17]DecodeImagePapyUShort **imagegetBufferPmPutRow8MCU *RowBufint numColPapyUChar **imagebitsLeftextendTestinputBufferPapyUChar *inputBufferOffsetPmPutRow16D:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\JPEGUTIL.CbitMaskunsigned int %[]DecoderStructInitmcuROW1Memorychar %[4096 * sizeof(MCU)]FixHuffTblFreeArray2Dchar **arrayPtrbuf1Memorychar %[4096 * 4 * sizeof(ComponentType)]mcuROW2MemoryJroundUpint aint bbuf2MemoryD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\MCU.CmcuTableMCU *numMCUmcuROW2mcuROW1PrintMCUint compsInScanMCU mcuInitMcuTableint numMCUD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\pmreadoptimise.creadimBufferOffsetPmReadCompressInfo *enInfoint optimiD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\pnmtoljpoptimisebug.cJPEGBufferinputFileBytesoutputFileBytespsvSetint %[7]readimBuffertotalHuffSymlong %[7]readim16BufferPapyUShort *numSelValueverboseOutFileJPEGLosslessEncodeImagePapyUChar **JPEGInputPapyULong *JPEGBytesint nbcolsint nbrowsWriteJpegDatatotalAddBitsD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\PREDICT.CQuickPredictint psvint *predictorPredictint rowint Print PtD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\READ.CNextMarkerSkipVariableJpegMarkerGet2bytesUintGetDhtGetApp0GetDriReadFileHeaderReadScanHeaderGetSofint codeGetSoiHuffmanTableMemoryHuffmanTable %[4]GetSosProcessTablesD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\WRITE.CWriteScanHeaderEmitDhtint indexint isAcEmitDriEmitMarkerJpegMarker markEmitSofJpegMarker codeEmitSosWriteFileTrailerEmit2bytesWriteFileHeaderD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\IO.HD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\JPEG.HHuffmanTableHuffmanTable::bitsUchar %[17]HuffmanTable::huffvalUchar %[256]HuffmanTable::sentTableHuffmanTable::ehufcoUshort %[256]HuffmanTable::ehufsichar %[256]HuffmanTable::mincodeUshort %[17]HuffmanTable::maxcodeint %[18]HuffmanTable::valptrshort %[17]HuffmanTable::numbitsHuffmanTable::valueUcharunsigned charCompressInfoCompressInfo::imageWidthCompressInfo::imageHeightCompressInfo::dataPrecisionCompressInfo::compInfoJpegComponentInfo *CompressInfo::numComponentsshortCompressInfo::curCompInfoJpegComponentInfo *%[4]CompressInfo::compsInScanCompressInfo::MCUmembershipshort %[10]CompressInfo::dcHuffTblPtrsHuffmanTable *%[4]CompressInfo::SsCompressInfo::PtCompressInfo::restartInRowsCompressInfo::restartRowsToGoCompressInfo::nextRestartNumUshortunsigned shortDecompressInfo::imageWidthDecompressInfo::imageHeightDecompressInfo::dataPrecisionDecompressInfo::compInfoJpegComponentInfo %[4]DecompressInfo::numComponentsDecompressInfo::curCompInfoDecompressInfo::compsInScanDecompressInfo::MCUmembershipDecompressInfo::dcHuffTblPtrsDecompressInfo::SsDecompressInfo::PtDecompressInfo::restartIntervalDecompressInfo::restartInRowsDecompressInfo::restartRowsToGoDecompressInfo::nextRestartNumunsigned intJpegComponentInfoJpegComponentInfo::componentIdJpegComponentInfo::componentIndexJpegComponentInfo::hSampFactorJpegComponentInfo::vSampFactorJpegComponentInfo::dcTblNoD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\JPEGLESS.HD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\MCU.HComponentTypeMCUComponentType *D:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\PREDICT.HD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\PROTO.HD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcapimin.c"jinclude.h""jpeglib.h"jpeg_write_tablesj_compress_ptr cinfojpeg_write_m_headerint markerunsigned int datalenjpeg_CreateCompressint versionsize_t structsizejpeg_write_markerconst JOCTET *dataptrjpeg_suppress_tablesboolean suppressjpeg_destroy_compressjpeg_abort_compressjpeg_write_m_byteint valjpeg_finish_compressD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcapistd.cjpeg_start_compressboolean write_all_tablesjpeg_write_scanlinesJSAMPARRAY scanlinesJDIMENSION num_linesjpeg_write_raw_dataJSAMPIMAGE dataD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jccoefct.cmy_coef_controllercompress_outputJSAMPIMAGE input_bufjpeg_c_coef_controllermy_coef_controller::pubmy_coef_controller::iMCU_row_numJDIMENSIONmy_coef_controller::mcu_ctrmy_coef_controller::MCU_vert_offsetmy_coef_controller::MCU_rows_per_iMCU_rowmy_coef_controller::MCU_bufferJBLOCKROW %[C_MAX_BLOCKS_IN_MCU]my_coef_controller::whole_imagejvirt_barray_ptr %[MAX_COMPONENTS]start_pass_coefJ_BUF_MODE pass_modecompress_datamy_coef_ptrmy_coef_controller *compress_first_passstart_iMCU_rowjinit_c_coef_controllerboolean need_full_bufferC:\Program Files\Microsoft Visual Studio\Common\MSDev98\Bin\win32.ncbC:\Program Files\Microsoft Visual Studio\Common\MSDev98\Bin\crt.ncbC:\Program Files\Microsoft Visual Studio\Common\MSDev98\Bin\mfcatl.ncbD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jccolor.cjpeg_color_converterjinit_color_converternull_convertJSAMPARRAY input_bufJSAMPIMAGE output_bufJDIMENSION output_rowint num_rowsrgb_gray_convertmy_cconvert_ptrmy_color_converter *cmyk_ycck_convertmy_color_convertermy_color_converter::pubmy_color_converter::rgb_ycc_tabINT32 *rgb_ycc_startnull_methodrgb_ycc_convertgrayscale_convertD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcdctmgr.c"jdct.h"forward_DCT_floatjpeg_component_info *compptrJSAMPARRAY sample_dataJBLOCKROW coef_blocksJDIMENSION start_rowJDIMENSION start_colJDIMENSION num_blocksmy_fdct_controllermy_fdct_ptrmy_fdct_controller *forward_DCTjpeg_forward_dctstart_pass_fdctmgrmy_fdct_controller::pubmy_fdct_controller::do_dctforward_DCT_method_ptrmy_fdct_controller::divisorsDCTELEM *%[NUM_QUANT_TBLS]my_fdct_controller::do_float_dctfloat_DCT_method_ptrmy_fdct_controller::float_divisorsFAST_FLOAT *%[NUM_QUANT_TBLS]jinit_forward_dctD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jchuff.c"jchuff.h"jpeg_entropy_encoderdump_bufferworking_state *statesavable_statefinish_pass_huffstart_pass_huffboolean gather_statisticsjpeg_gen_optimal_tableJHUFF_TBL *htbllong freq[]jpeg_make_c_derived_tblboolean isDCint tblnoc_derived_tbl **pdtblworking_stateworking_state::next_output_byteJOCTET *working_state::free_in_buffersize_tworking_state::curworking_state::cinfoj_compress_ptrhuff_entropy_encoderhuff_entropy_encoder::pubhuff_entropy_encoder::savedhuff_entropy_encoder::restarts_to_gohuff_entropy_encoder::next_restart_numhuff_entropy_encoder::dc_derived_tblsc_derived_tbl *%[NUM_HUFF_TBLS]huff_entropy_encoder::ac_derived_tblshuff_entropy_encoder::dc_count_ptrslong *%[NUM_HUFF_TBLS]huff_entropy_encoder::ac_count_ptrssavable_state::put_bufferINT32savable_state::put_bitssavable_state::last_dc_valint %[MAX_COMPS_IN_SCAN]JPPhuff_entropy_ptrhuff_entropy_encoder *emit_restartint restart_numencode_one_blockJCOEFPTR blockint last_dc_valc_derived_tbl *dctblc_derived_tbl *actblemit_bitsunsigned int codeint sizeflush_bitsencode_mcu_huffJBLOCKROW *MCU_datajinit_huff_encoderhtest_one_blocklong dc_counts[]long ac_counts[]encode_mcu_gatherfinish_pass_gatherD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcinit.cjinit_compress_masterD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcmainct.cmy_main_ptrmy_main_controller *start_pass_mainjpeg_c_main_controllerjinit_c_main_controllermy_main_controllermy_main_controller::pubmy_main_controller::cur_iMCU_rowmy_main_controller::rowgroup_ctrmy_main_controller::suspendedbooleanmy_main_controller::pass_modeJ_BUF_MODEmy_main_controller::bufferJSAMPARRAY %[MAX_COMPONENTS]my_main_controller::whole_imagejvirt_sarray_ptr %[MAX_COMPONENTS]process_data_simple_mainJDIMENSION *in_row_ctrJDIMENSION in_rows_availprocess_data_buffer_mainD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcmarker.cemit_bytejpeg_marker_writermy_marker_ptrmy_marker_writer *emit_jfif_app0write_frame_headeremit_adobe_app14emit_2bytesemit_dhtboolean is_acmy_marker_writermy_marker_writer::pubmy_marker_writer::last_restart_intervalJPEG_MARKERemit_dacemit_dqtjinit_marker_writerwrite_file_traileremit_driwrite_marker_bytewrite_file_headerwrite_scan_headeremit_markerJPEG_MARKER markwrite_marker_headerwrite_tables_onlyemit_sofJPEG_MARKER codeemit_sosD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcmaster.cfinish_pass_masterper_scan_setupjpeg_comp_masterselect_scan_parametersvalidate_scriptpass_startupmy_comp_mastermy_comp_master::pubmy_comp_master::pass_typec_pass_typemy_comp_master::pass_numbermy_comp_master::total_passesmy_comp_master::scan_numberprepare_for_passmy_master_ptrmy_comp_master *initial_setupjinit_c_master_controlboolean transcode_onlyD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcomapi.cjpeg_abortj_common_ptr cinfojpeg_destroyjpeg_alloc_huff_tablejpeg_alloc_quant_tableD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcparam.cjpeg_set_defaultsfill_dc_scansjpeg_scan_info *scanptrint ncompsint Ahint Aljpeg_set_colorspaceJ_COLOR_SPACE colorspacejpeg_set_qualityint qualityboolean force_baselinejpeg_default_colorspacejpeg_add_quant_tableint which_tblconst unsigned int *basic_tableint scale_factorfill_scansint Ssint Sejpeg_simple_progressionjpeg_set_linear_qualitystd_huff_tablesjpeg_quality_scalingadd_huff_tableJHUFF_TBL **htblptrconst UINT8 *bitsconst UINT8 *valfill_a_scanint ciD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcphuff.cstart_pass_phuffencode_mcu_DC_refinephuff_entropy_ptr entropyemit_symbolint tbl_noint symboljinit_phuff_encoderemit_buffered_bitschar *bufstartunsigned int nbitsemit_eobrunphuff_entropy_encoderphuff_entropy_encoder::pubphuff_entropy_encoder::gather_statisticsphuff_entropy_encoder::next_output_bytephuff_entropy_encoder::free_in_bufferphuff_entropy_encoder::put_bufferphuff_entropy_encoder::put_bitsphuff_entropy_encoder::cinfophuff_entropy_encoder::last_dc_valphuff_entropy_encoder::ac_tbl_nophuff_entropy_encoder::EOBRUNphuff_entropy_encoder::BEphuff_entropy_encoder::bit_bufferchar *phuff_entropy_encoder::restarts_to_gophuff_entropy_encoder::next_restart_numphuff_entropy_encoder::derived_tblsphuff_entropy_encoder::count_ptrsfinish_pass_phuffencode_mcu_AC_firstencode_mcu_DC_firstphuff_entropy_ptrphuff_entropy_encoder *finish_pass_gather_phuffencode_mcu_AC_refineD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcprepct.cpre_process_dataJDIMENSION *out_row_group_ctrJDIMENSION out_row_groups_availcreate_context_bufferexpand_bottom_edgeJSAMPARRAY image_dataJDIMENSION num_colsint input_rowsint output_rowsmy_prep_controllermy_prep_controller::pubjpeg_c_prep_controllermy_prep_controller::color_bufmy_prep_controller::rows_to_gomy_prep_controller::next_buf_rowmy_prep_controller::this_row_groupmy_prep_controller::next_buf_stoppre_process_contextstart_pass_prepmy_prep_ptrmy_prep_controller *jinit_c_prep_controllerD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcsample.cfullsize_smooth_downsampleJSAMPARRAY input_dataJSAMPARRAY output_datah2v2_downsampleint_downsamplejinit_downsamplermy_downsamplerexpand_right_edgeJDIMENSION input_colsJDIMENSION output_colsjpeg_downsamplerstart_pass_downsamplemy_downsampler::pubmy_downsampler::methodsdownsample1_ptr %[MAX_COMPONENTS]h2v1_downsamplemy_downsample_ptrmy_downsampler *h2v2_smooth_downsamplefullsize_downsamplesep_downsampleJDIMENSION in_row_indexJDIMENSION out_row_group_indexD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jctrans.ctransencode_coef_controllerjvirt_barray_ptr *coef_arraysjpeg_write_coefficientsjvirt_barray_ptr *my_coef_controller::dummy_bufferjpeg_copy_critical_parametersj_decompress_ptr srcinfoj_compress_ptr dstinfotransencode_master_selectionD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdapimin.cjpeg_has_multiple_scansj_decompress_ptr cinfojpeg_destroy_decompressjpeg_finish_decompressjpeg_read_headerboolean require_imagejpeg_CreateDecompressjpeg_consume_inputjpeg_input_completedefault_decompress_parmsjpeg_abort_decompressD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdapistd.cjpeg_start_decompressjpeg_finish_outputjpeg_read_scanlinesJDIMENSION max_linesjpeg_read_raw_dataoutput_pass_setupjpeg_start_outputint scan_numberD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdatadst.c"jerror.h"term_destinationempty_output_bufferjpeg_stdio_destPAPY_FILE *outfileinit_destinationD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdatasrc.cinit_sourcemy_source_mgrskip_input_datalong num_bytesmy_source_mgr::pubjpeg_source_mgrmy_source_mgr::infilemy_source_mgr::buffermy_source_mgr::start_of_filemy_src_ptrmy_source_mgr *jpeg_stdio_srcPAPY_FILE infilefill_input_bufferterm_sourceD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdcoefct.cstart_input_passjinit_d_coef_controllerjpeg_d_coef_controllerdecompress_onepassmy_coef_controller::MCU_ctrJBLOCKROW %[D_MAX_BLOCKS_IN_MCU]my_coef_controller::coef_bits_latchint *decompress_datasmoothing_okdecompress_smooth_datastart_output_passconsume_datadummy_consume_dataD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdcolor.cycck_cmyk_convertJDIMENSION input_rowJSAMPARRAY output_bufbuild_ycc_rgb_tablejinit_color_deconvertermy_color_deconverter *jpeg_color_deconverterycc_rgb_convertmy_color_deconvertermy_color_deconverter::pubmy_color_deconverter::Cr_r_tabmy_color_deconverter::Cb_b_tabmy_color_deconverter::Cr_g_tabmy_color_deconverter::Cb_g_tabgray_rgb_convertstart_pass_dcolorD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jddctmgr.cjinit_inverse_dctmy_idct_controllermultiplier_tablemultiplier_table::islow_arrayISLOW_MULT_TYPE %[DCTSIZE2]multiplier_table::ifast_arrayIFAST_MULT_TYPE %[DCTSIZE2]multiplier_table::float_arrayFLOAT_MULT_TYPE %[DCTSIZE2]my_idct_controller::pubjpeg_inverse_dctmy_idct_controller::cur_methodint %[MAX_COMPONENTS]my_idct_ptrmy_idct_controller *start_passD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdhuff.c"jdhuff.h"jpeg_entropy_decoderjpeg_huff_decodebitread_working_state *statebit_buf_type get_bufferint bits_leftd_derived_tbl *htblint min_bitsstart_pass_huff_decoderhuff_entropy_decoderhuff_entropy_decoder::pubhuff_entropy_decoder::bitstatebitread_perm_statehuff_entropy_decoder::savedhuff_entropy_decoder::restarts_to_gohuff_entropy_decoder::dc_derived_tblsd_derived_tbl *%[NUM_HUFF_TBLS]huff_entropy_decoder::ac_derived_tblshuff_entropy_decoder::dc_cur_tblsd_derived_tbl *%[D_MAX_BLOCKS_IN_MCU]huff_entropy_decoder::ac_cur_tblshuff_entropy_decoder::dc_neededboolean %[D_MAX_BLOCKS_IN_MCU]huff_entropy_decoder::ac_neededjpeg_fill_bit_bufferint nbitshuff_entropy_decoder *decode_mcuprocess_restartjinit_huff_decoderjpeg_make_d_derived_tbld_derived_tbl **pdtblD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdinput.cjinit_input_controllermy_input_controllermy_input_controller::pubjpeg_input_controllermy_input_controller::inheadersconsume_markersfinish_input_passreset_input_controllermy_inputctl_ptrmy_input_controller *latch_quant_tablesD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdmainct.calloc_funny_pointersset_wraparound_pointersprocess_data_crank_postJDIMENSION *out_row_ctrJDIMENSION out_rows_availjpeg_d_main_controllermy_main_controller::buffer_fullmy_main_controller::xbufferJSAMPIMAGE %[2]my_main_controller::whichptrmy_main_controller::context_statemy_main_controller::rowgroups_availmy_main_controller::iMCU_row_ctrjinit_d_main_controllerset_bottom_pointersprocess_data_context_mainmake_funny_pointersD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdmarker.cjpeg_save_markersint marker_codeunsigned int length_limitget_interesting_appnmy_marker_readerread_restart_markerjinit_marker_readerjpeg_resync_to_restartint desiredsave_markerfirst_markerget_sofboolean is_progboolean is_arithget_soiget_sosmy_marker_reader *examine_app14JOCTET *dataINT32 remainingnext_markermy_marker_reader::pubjpeg_marker_readermy_marker_reader::process_COMjpeg_marker_parser_methodmy_marker_reader::process_APPnjpeg_marker_parser_method %[16]my_marker_reader::length_limit_COMmy_marker_reader::length_limit_APPnunsigned int %[16]my_marker_reader::cur_markerjpeg_saved_marker_ptrmy_marker_reader::bytes_readjpeg_set_marker_processorjpeg_marker_parser_method routineread_markersget_dacskip_variableget_dhtreset_marker_readerexamine_app0get_driget_dqtD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdmaster.cmy_decomp_masterfinish_output_passjpeg_decomp_masterjpeg_new_colormapjinit_master_decompressmy_decomp_master::pubmy_decomp_master::pass_numbermy_decomp_master::using_merged_upsamplemy_decomp_master::quantizer_1passjpeg_color_quantizer *my_decomp_master::quantizer_2passprepare_for_output_passmy_decomp_master *prepare_range_limit_tablemaster_selectionjpeg_calc_output_dimensionsjpeg_color_quantizeruse_merged_upsampleD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdmerge.cjpeg_upsamplerjinit_merged_upsamplermy_upsamplermy_upsampler::pubmy_upsampler::JMETHODmy_upsampler::Cr_r_tabmy_upsampler::Cb_b_tabmy_upsampler::Cr_g_tabmy_upsampler::Cb_g_tabmy_upsampler::spare_rowJSAMPROWmy_upsampler::spare_fullmy_upsampler::out_row_widthmy_upsampler::rows_to_gomerged_1v_upsampleJDIMENSION *in_row_group_ctrJDIMENSION in_row_groups_availstart_pass_merged_upsampleh2v2_merged_upsampleJDIMENSION in_row_group_ctrh2v1_merged_upsamplemerged_2v_upsamplemy_upsample_ptrmy_upsampler *D:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdphuff.cdecode_mcu_DC_refinejinit_phuff_decoderdecode_mcu_AC_refinephuff_entropy_decoderphuff_entropy_decoder::pubphuff_entropy_decoder::bitstatephuff_entropy_decoder::savedphuff_entropy_decoder::restarts_to_gophuff_entropy_decoder::derived_tblsphuff_entropy_decoder::ac_derived_tbld_derived_tbl *savable_state::EOBRUNdecode_mcu_DC_firstdecode_mcu_AC_firstphuff_entropy_decoder *start_pass_phuff_decoderD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdpostct.cjpeg_d_post_controllermy_post_ptrmy_post_controller *start_pass_dpostpost_process_2passpost_process_prepassmy_post_controllermy_post_controller::pubmy_post_controller::whole_imagejvirt_sarray_ptrmy_post_controller::bufferJSAMPARRAYmy_post_controller::strip_heightmy_post_controller::starting_rowmy_post_controller::next_rowpost_process_1passjinit_d_post_controllerD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdsample.cjinit_upsamplerfullsize_upsampleJSAMPARRAY *output_data_ptrstart_pass_upsampleh2v2_upsampleint_upsamplemy_upsampler::color_bufmy_upsampler::methodsupsample1_ptr %[MAX_COMPONENTS]my_upsampler::next_row_outmy_upsampler::rowgroup_heightmy_upsampler::h_expandUINT8 %[MAX_COMPONENTS]my_upsampler::v_expandh2v1_fancy_upsampleh2v1_upsampleh2v2_fancy_upsamplenoop_upsamplesep_upsampleD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdtrans.cjpeg_read_coefficientstransdecode_master_selectionD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jerror.c"jversion.h"format_messagechar *bufferoutput_messagejpeg_error_mgrreset_error_mgrerror_exitjpeg_std_errorjpeg_error_mgr *errjMsgTableconst char *const %[]emit_messageint msg_levelD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jfdctflt.cSorryjpeg_fdct_floatFAST_FLOAT *dataD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jfdctfst.cjpeg_fdct_ifastDCTELEM *dataD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jfdctint.cjpeg_fdct_islowD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jidctflt.cjpeg_idct_floatJCOEFPTR coef_blockJDIMENSION output_colD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jidctfst.cjpeg_idct_ifastD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jidctint.cjpeg_idct_islowD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jidctred.cjpeg_idct_1x1jpeg_idct_2x2jpeg_idct_4x4D:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jmemmgr.c"jmemsys.h"access_virt_barrayjvirt_barray_ptr ptrJDIMENSION num_rowsboolean writablejpeg_memory_mgrdo_sarray_iojvirt_sarray_ptr ptrboolean writingmy_mem_ptrmy_memory_mgr *jvirt_sarray_controljvirt_sarray_control::mem_bufferjvirt_sarray_control::rows_in_arrayjvirt_sarray_control::samplesperrowjvirt_sarray_control::maxaccessjvirt_sarray_control::rows_in_memjvirt_sarray_control::rowsperchunkjvirt_sarray_control::cur_start_rowjvirt_sarray_control::first_undef_rowjvirt_sarray_control::pre_zerojvirt_sarray_control::dirtyjvirt_sarray_control::b_s_openjvirt_sarray_control::nextjvirt_sarray_control::b_s_infobacking_store_inforealize_virt_arrayslarge_pool_ptrunion large_pool_struct *alloc_sarrayint pool_idJDIMENSION samplesperrowJDIMENSION numrowsalloc_smallsize_t sizeofobjectout_of_memoryint whichmy_memory_mgrmy_memory_mgr::pubmy_memory_mgr::small_listsmall_pool_ptr %[JPOOL_NUMPOOLS]my_memory_mgr::large_listlarge_pool_ptr %[JPOOL_NUMPOOLS]my_memory_mgr::virt_sarray_listmy_memory_mgr::virt_barray_listjvirt_barray_ptrmy_memory_mgr::total_space_allocatedmy_memory_mgr::last_rowsperchunkjinit_memory_mgrlarge_pool_hdrunion large_pool_structfree_poolsmall_pool_structsmall_pool_struct::__unnamed_1small_pool_struct::__unnamed_1::nextsmall_pool_ptrsmall_pool_struct::__unnamed_1::bytes_usedsmall_pool_struct::__unnamed_1::bytes_leftsmall_pool_struct::hdrsmall_pool_struct::dummydoubledo_barray_iojvirt_barray_controljvirt_barray_control::mem_bufferJBLOCKARRAYjvirt_barray_control::rows_in_arrayjvirt_barray_control::blocksperrowjvirt_barray_control::maxaccessjvirt_barray_control::rows_in_memjvirt_barray_control::rowsperchunkjvirt_barray_control::cur_start_rowjvirt_barray_control::first_undef_rowjvirt_barray_control::pre_zerojvirt_barray_control::dirtyjvirt_barray_control::b_s_openjvirt_barray_control::nextjvirt_barray_control::b_s_infosmall_pool_hdrunion small_pool_structrequest_virt_sarrayboolean pre_zeroJDIMENSION maxaccessalloc_largefirst_pool_slopconst size_t %[JPOOL_NUMPOOLS]access_virt_sarrayself_destructextra_pool_slopprint_mem_statsgetenvlarge_pool_structlarge_pool_struct::__unnamed_1large_pool_struct::__unnamed_1::nextlarge_pool_struct::__unnamed_1::bytes_usedlarge_pool_struct::__unnamed_1::bytes_leftlarge_pool_struct::hdrlarge_pool_struct::dummyunion small_pool_struct *alloc_barrayJDIMENSION blocksperrowrequest_virt_barrayD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jmemnobs.cjpeg_get_smalljpeg_mem_availablelong min_bytes_neededlong max_bytes_neededlong already_allocatedjpeg_open_backing_storebacking_store_ptr infolong total_bytes_neededjpeg_free_largevoid *objectjpeg_mem_termjpeg_get_largejpeg_mem_initjpeg_free_smallD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jquant1.cmake_odither_arrayint ncolorsalloc_fs_workspaceoutput_valueint jint maxjmy_cquantizercolor_quantizestart_pass_1_quantboolean is_pre_scanquantize3_ord_ditherquantize_fs_ditherselect_ncolorsint Ncolors[]jinit_1pass_quantizerFSERRPTRFSERROR *create_odither_tablesLOCFSERRORmy_cquantizer::pubmy_cquantizer::sv_colormapmy_cquantizer::sv_actualmy_cquantizer::colorindexmy_cquantizer::is_paddedmy_cquantizer::Ncolorsint %[MAX_Q_COMPS]my_cquantizer::row_indexmy_cquantizer::oditherODITHER_MATRIX_PTR %[MAX_Q_COMPS]my_cquantizer::fserrorsFSERRPTR %[MAX_Q_COMPS]my_cquantizer::on_odd_rowfinish_pass_1_quantmy_cquantize_ptrmy_cquantizer *FSERRORINT16create_colorindexbase_dither_matrixconst UINT8 %[ODITHER_SIZE][ODITHER_SIZE]new_color_map_1_quantODITHER_MATRIX_PTRint (*%)[ODITHER_SIZE]largest_input_valuecreate_colormapcolor_quantize3quantize_ord_ditherODITHER_MATRIXint %[ODITHER_SIZE][ODITHER_SIZE]D:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jquant2.cnew_color_map_2_quantpass2_fs_ditherfind_biggest_volumeboxptr boxlistint numboxesboxinit_error_limitprescan_quantizeupdate_boxboxptr boxpcompute_colorint icolorfind_biggest_color_popmedian_cutint desired_colorsfinish_pass2finish_pass1box::c0minbox::c0maxbox::c1minbox::c1maxbox::c2minbox::c2maxbox::volumebox::colorcountmy_cquantizer::desiredmy_cquantizer::histogramhist3dmy_cquantizer::needs_zeroedmy_cquantizer::error_limiterjinit_2pass_quantizerboxptrbox *histptrhistcell *fill_inverse_cmapint c0int c1int c2hist1dhistcell %[HIST_C2_ELEMS]hist2dhist1d *hist2d *find_best_colorsint minc0int minc1int minc2int numcolorsJSAMPLE colorlist[]JSAMPLE bestcolor[]start_pass_2_quantfind_nearby_colorsselect_colorshistcellUINT16pass2_no_ditherD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jutils.cjround_uplong along bjzero_farvoid *targetsize_t bytestozerojdiv_round_upjcopy_sample_rowsJSAMPARRAY input_arrayint source_rowJSAMPARRAY output_arrayint dest_rowjcopy_block_rowJBLOCKROW input_rowJBLOCKROW output_rowjpeg_natural_orderconst int %[DCTSIZE2+16]D:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdbmp.c"cdjpeg.h"finish_input_bmpcjpeg_source_ptr sinforead_bytebmp_source_ptr sinfo_bmp_source_struct_bmp_source_struct::pubcjpeg_source_struct_bmp_source_struct::cinfo_bmp_source_struct::colormap_bmp_source_struct::whole_image_bmp_source_struct::source_row_bmp_source_struct::row_width_bmp_source_struct::bits_per_pixeljinit_read_bmpstart_input_bmpbmp_source_structstruct _bmp_source_structbmp_source_ptrstruct _bmp_source_struct *preload_imageget_8bit_rowread_colormapint cmaplenint mapentrysizeU_CHARget_24bit_rowD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdcolmap.cread_gif_mapread_ppm_mapadd_map_entryint Rint Gint Bread_pbm_integerread_color_mappbm_getcD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdgif.cjinit_read_gifD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdppm.cget_scaled_rgb_rowget_text_gray_rowjinit_read_ppmppm_source_ptrppm_source_struct *start_input_ppmget_word_rgb_rowfinish_input_ppmppm_source_structppm_source_struct::pubppm_source_struct::iobufferU_CHAR *ppm_source_struct::pixrowppm_source_struct::buffer_widthppm_source_struct::rescaleJSAMPLE *get_scaled_gray_rowget_text_rgb_rowget_raw_rowget_word_gray_rowD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdrle.cget_pseudocolor_row_rle_source_struct_rle_source_struct::pub_rle_source_struct::image_rle_source_struct::row_rle_source_struct::headerrle_hdr_rle_source_struct::rle_rowrle_pixel **jinit_read_rlestart_input_rleload_imagefinish_input_rlerle_kindrle_source_ptrstruct _rle_source_struct *get_rle_rowrle_source_structstruct _rle_source_structD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdswitch.cset_quant_slotschar *argtext_getcPAPY_FILE fileread_scan_integerlong *resultint *termcharread_scan_scriptchar *filenameread_quant_tablesset_sample_factorsread_text_integerD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdtarga.cread_rle_pixeltga_source_ptr sinforead_non_rle_pixelc5to8bitsconst UINT8 %[32]tga_source_ptrstruct _tga_source_struct *start_input_tgafinish_input_tgaget_16bit_rowtga_source_structstruct _tga_source_structget_memory_rowget_8bit_gray_row_tga_source_struct_tga_source_struct::pub_tga_source_struct::cinfo_tga_source_struct::colormap_tga_source_struct::whole_image_tga_source_struct::current_row_tga_source_struct::JMETHODget_pixel_rows_tga_source_struct::tga_pixelU_CHAR %[4]_tga_source_struct::pixel_size_tga_source_struct::block_count_tga_source_struct::dup_pixel_countjinit_read_targaD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\wrrle.crle_dest_structrle_dest_ptrjinit_write_rlestart_output_rledjpeg_dest_ptr dinfofinish_output_rlerle_put_pixel_rowsJDIMENSION rows_suppliedD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\cderror.hADDON_MESSAGE_CODED:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\cdjpeg.h"cderror.h"djpeg_dest_ptrstruct djpeg_dest_struct *cdjpeg_progress_mgrcdjpeg_progress_mgr::pubjpeg_progress_mgrcdjpeg_progress_mgr::completed_extra_passescdjpeg_progress_mgr::total_extra_passescdjpeg_progress_mgr::percent_donedjpeg_dest_structdjpeg_dest_struct::JMETHODdjpeg_dest_struct::output_filedjpeg_dest_struct::bufferdjpeg_dest_struct::buffer_heightcd_progress_ptrstruct cdjpeg_progress_mgr *cjpeg_source_ptrstruct cjpeg_source_struct *jIRdBMPcjpeg_source_struct::JMETHODcjpeg_source_struct::input_filecjpeg_source_struct::buffercjpeg_source_struct::buffer_heightD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jchuff.hc_derived_tblc_derived_tbl::ehufcounsigned int %[256]c_derived_tbl::ehufsiD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jconfig.hD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdct.hFLOAT_MULT_TYPEFAST_FLOATISLOW_MULT_TYPEMULTIPLIERjFDislowDCTELEMIFAST_MULT_TYPED:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdhuff.hd_derived_tblbitread_working_statebitread_working_state::next_input_byteconst JOCTET *bitread_working_state::bytes_in_bufferbitread_working_state::get_bufferbit_buf_typebitread_working_state::bits_leftbitread_working_state::cinfoj_decompress_ptrbitread_perm_state::get_bufferbitread_perm_state::bits_leftd_derived_tbl::maxcodeINT32 %[18]d_derived_tbl::valoffsetINT32 %[17]d_derived_tbl::pubJHUFF_TBL *d_derived_tbl::look_nbitsint %[1<D:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jmemsys.hstruct backing_store_structEMSHXMSHhandle_unionhandle_union::file_handlehandle_union::xms_handlehandle_union::ems_handlebacking_store_structbacking_store_struct::JMETHODbacking_store_struct::handlebacking_store_struct::temp_namechar %[TEMP_NAME_LENGTH]backing_store_ptrstruct backing_store_struct *jMemInitD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jmorecfg.hUINT8JSAMPLEJCOEFJOCTETD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jpegint.hjpeg_color_converter::JMETHODjpeg_entropy_decoder::JMETHODjpeg_entropy_decoder::insufficient_datajpeg_upsampler::JMETHODjpeg_upsampler::need_context_rowsjpeg_entropy_encoder::JMETHODencode_mcujpeg_decomp_master::JMETHODjpeg_decomp_master::is_dummy_passjpeg_d_post_controller::JMETHODjpeg_marker_writer::JMETHODjpeg_c_main_controller::JMETHODjpeg_comp_master::JMETHODjpeg_comp_master::call_pass_startupjpeg_comp_master::is_last_passjpeg_c_coef_controller::JMETHODjpeg_forward_dct::JMETHODjvirt_sarray_control::dummyjpeg_d_coef_controller::JMETHODjpeg_d_coef_controller::coef_arraysjpeg_downsampler::JMETHODjpeg_downsampler::need_context_rowsjpeg_color_deconverter::JMETHODjZAGTableconst int %[]jvirt_barray_control::dummyjICompressjpeg_c_prep_controller::JMETHODjpeg_marker_reader::JMETHODjpeg_marker_reader::read_restart_markerjpeg_marker_reader::saw_SOIjpeg_marker_reader::saw_SOFjpeg_marker_reader::next_restart_numjpeg_marker_reader::discarded_bytesjpeg_inverse_dct::JMETHODjpeg_inverse_dct::inverse_DCTinverse_DCT_method_ptr %[MAX_COMPONENTS]jpeg_color_quantizer::JMETHODjpeg_input_controller::JMETHODconsume_inputjpeg_input_controller::has_multiple_scansjpeg_input_controller::eoi_reachedjpeg_d_main_controller::JMETHODD:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jpeglib.h"jmorecfg.h""jpegint.h"jpeg_color_converter::dummyJBLOCKROWJBLOCK *jpeg_entropy_decoder::dummyjpeg_upsampler::dummyJCOEFPTRJCOEF *jpeg_destination_mgrjpeg_destination_mgr::next_output_bytejpeg_destination_mgr::free_in_bufferjpeg_destination_mgr::JMETHODjpeg_entropy_encoder::dummyjpeg_decomp_master::dummyjpeg_d_post_controller::dummyjpeg_common_structjpeg_common_struct::errjpeg_error_mgr *jpeg_common_struct::memjpeg_memory_mgr *jpeg_common_struct::progressjpeg_progress_mgr *jpeg_common_struct::client_datavoid *jpeg_common_struct::is_decompressorjpeg_common_struct::global_stateJSAMPIMAGEJSAMPARRAY *jpeg_marker_writer::dummyjpeg_c_main_controller::dummymy_dest_ptrmy_destination_mgr *jpeg_comp_master::dummyjpeg_c_coef_controller::dummyjpeg_forward_dct::dummyjpeg_memory_mgr::JMETHODjpeg_memory_mgr::max_memory_to_usejpeg_memory_mgr::max_alloc_chunkJ_COLOR_SPACEstruct jvirt_sarray_control *jpeg_progress_mgr::JMETHODjpeg_progress_mgr::pass_counterjpeg_progress_mgr::pass_limitjpeg_progress_mgr::completed_passesjpeg_progress_mgr::total_passesjpeg_d_coef_controller::dummystruct jpeg_decompress_struct *jpeg_downsampler::dummystruct jvirt_barray_control *jpeg_color_deconverter::dummyJBLOCKROW *jpeg_error_mgr::JMETHODjpeg_error_mgr::msg_codejpeg_error_mgr::__unnamed_1jpeg_error_mgr::__unnamed_1::iint %[8]jpeg_error_mgr::__unnamed_1::schar %[JMSG_STR_PARM_MAX]jpeg_error_mgr::msg_parmjpeg_error_mgr::trace_leveljpeg_error_mgr::num_warningsjpeg_error_mgr::jpeg_message_tableconst char *const *jpeg_error_mgr::last_jpeg_messagejpeg_error_mgr::addon_message_tablejpeg_error_mgr::first_addon_messagejpeg_error_mgr::last_addon_messagemy_destination_mgrmy_destination_mgr::pubmy_destination_mgr::outfilemy_destination_mgr::bufferJ_DITHER_MODEJ_DCT_METHODjpeg_scan_infojpeg_scan_info::comps_in_scanjpeg_scan_info::component_indexjpeg_scan_info::Ssjpeg_scan_info::Sejpeg_scan_info::Ahjpeg_scan_info::Aljpeg_component_infojpeg_component_info::component_idjpeg_component_info::component_indexjpeg_component_info::h_samp_factorjpeg_component_info::v_samp_factorjpeg_component_info::quant_tbl_nojpeg_component_info::dc_tbl_nojpeg_component_info::ac_tbl_nojpeg_component_info::width_in_blocksjpeg_component_info::height_in_blocksjpeg_component_info::DCT_scaled_sizejpeg_component_info::downsampled_widthjpeg_component_info::downsampled_heightjpeg_component_info::component_neededjpeg_component_info::MCU_widthjpeg_component_info::MCU_heightjpeg_component_info::MCU_blocksjpeg_component_info::MCU_sample_widthjpeg_component_info::last_col_widthjpeg_component_info::last_row_heightjpeg_component_info::quant_tableJQUANT_TBL *jpeg_component_info::dct_tableJHUFF_TBLJHUFF_TBL::bitsUINT8 %[17]JHUFF_TBL::huffvalUINT8 %[256]JHUFF_TBL::sent_tableJQUANT_TBLJQUANT_TBL::quantvalUINT16 %[DCTSIZE2]JQUANT_TBL::sent_tablejpeg_source_mgr::next_input_bytejpeg_source_mgr::bytes_in_bufferjpeg_source_mgr::JMETHODresync_to_restartjpeg_c_prep_controller::dummyjpeg_decompress_structjpeg_decompress_struct::errjpeg_decompress_struct::memjpeg_decompress_struct::progressjpeg_decompress_struct::client_datajpeg_decompress_struct::is_decompressorjpeg_decompress_struct::global_statejpeg_decompress_struct::srcjpeg_source_mgr *jpeg_decompress_struct::image_widthjpeg_decompress_struct::image_heightjpeg_decompress_struct::num_componentsjpeg_decompress_struct::jpeg_color_spacejpeg_decompress_struct::out_color_spacejpeg_decompress_struct::scale_numjpeg_decompress_struct::scale_denomjpeg_decompress_struct::output_gammajpeg_decompress_struct::buffered_imagejpeg_decompress_struct::raw_data_outjpeg_decompress_struct::dct_methodjpeg_decompress_struct::do_fancy_upsamplingjpeg_decompress_struct::do_block_smoothingjpeg_decompress_struct::quantize_colorsjpeg_decompress_struct::dither_modejpeg_decompress_struct::two_pass_quantizejpeg_decompress_struct::desired_number_of_colorsjpeg_decompress_struct::enable_1pass_quantjpeg_decompress_struct::enable_external_quantjpeg_decompress_struct::enable_2pass_quantjpeg_decompress_struct::output_widthjpeg_decompress_struct::output_heightjpeg_decompress_struct::out_color_componentsjpeg_decompress_struct::output_componentsjpeg_decompress_struct::rec_outbuf_heightjpeg_decompress_struct::actual_number_of_colorsjpeg_decompress_struct::colormapjpeg_decompress_struct::output_scanlinejpeg_decompress_struct::input_scan_numberjpeg_decompress_struct::input_iMCU_rowjpeg_decompress_struct::output_scan_numberjpeg_decompress_struct::output_iMCU_rowjpeg_decompress_struct::coef_bitsint (*%)[64]jpeg_decompress_struct::quant_tbl_ptrsJQUANT_TBL *%[NUM_QUANT_TBLS]jpeg_decompress_struct::dc_huff_tbl_ptrsJHUFF_TBL *%[NUM_HUFF_TBLS]jpeg_decompress_struct::ac_huff_tbl_ptrsjpeg_decompress_struct::data_precisionjpeg_decompress_struct::comp_infojpeg_component_info *jpeg_decompress_struct::progressive_modejpeg_decompress_struct::arith_codejpeg_decompress_struct::arith_dc_LUINT8 %[NUM_ARITH_TBLS]jpeg_decompress_struct::arith_dc_Ujpeg_decompress_struct::arith_ac_Kjpeg_decompress_struct::restart_intervaljpeg_decompress_struct::saw_JFIF_markerjpeg_decompress_struct::JFIF_major_versionjpeg_decompress_struct::JFIF_minor_versionjpeg_decompress_struct::density_unitjpeg_decompress_struct::X_densityjpeg_decompress_struct::Y_densityjpeg_decompress_struct::saw_Adobe_markerjpeg_decompress_struct::Adobe_transformjpeg_decompress_struct::CCIR601_samplingjpeg_decompress_struct::marker_listjpeg_decompress_struct::max_h_samp_factorjpeg_decompress_struct::max_v_samp_factorjpeg_decompress_struct::min_DCT_scaled_sizejpeg_decompress_struct::total_iMCU_rowsjpeg_decompress_struct::sample_range_limitjpeg_decompress_struct::comps_in_scanjpeg_decompress_struct::cur_comp_infojpeg_component_info *%[MAX_COMPS_IN_SCAN]jpeg_decompress_struct::MCUs_per_rowjpeg_decompress_struct::MCU_rows_in_scanjpeg_decompress_struct::blocks_in_MCUjpeg_decompress_struct::MCU_membershipint %[D_MAX_BLOCKS_IN_MCU]jpeg_decompress_struct::Ssjpeg_decompress_struct::Sejpeg_decompress_struct::Ahjpeg_decompress_struct::Aljpeg_decompress_struct::unread_markerjpeg_decompress_struct::masterjpeg_decomp_master *jpeg_decompress_struct::mainjpeg_d_main_controller *jpeg_decompress_struct::coefjpeg_d_coef_controller *jpeg_decompress_struct::postjpeg_d_post_controller *jpeg_decompress_struct::inputctljpeg_input_controller *jpeg_decompress_struct::markerjpeg_marker_reader *jpeg_decompress_struct::entropyjpeg_entropy_decoder *jpeg_decompress_struct::idctjpeg_inverse_dct *jpeg_decompress_struct::upsamplejpeg_upsampler *jpeg_decompress_struct::cconvertjpeg_color_deconverter *jpeg_decompress_struct::cquantizeJSAMPROW *jpeg_compress_structjpeg_compress_struct::errjpeg_compress_struct::memjpeg_compress_struct::progressjpeg_compress_struct::client_datajpeg_compress_struct::is_decompressorjpeg_compress_struct::global_statejpeg_compress_struct::destjpeg_destination_mgr *jpeg_compress_struct::image_widthjpeg_compress_struct::image_heightjpeg_compress_struct::input_componentsjpeg_compress_struct::in_color_spacejpeg_compress_struct::input_gammajpeg_compress_struct::data_precisionjpeg_compress_struct::num_componentsjpeg_compress_struct::jpeg_color_spacejpeg_compress_struct::comp_infojpeg_compress_struct::quant_tbl_ptrsjpeg_compress_struct::dc_huff_tbl_ptrsjpeg_compress_struct::ac_huff_tbl_ptrsjpeg_compress_struct::arith_dc_Ljpeg_compress_struct::arith_dc_Ujpeg_compress_struct::arith_ac_Kjpeg_compress_struct::num_scansjpeg_compress_struct::scan_infoconst jpeg_scan_info *jpeg_compress_struct::raw_data_injpeg_compress_struct::arith_codejpeg_compress_struct::optimize_codingjpeg_compress_struct::CCIR601_samplingjpeg_compress_struct::smoothing_factorjpeg_compress_struct::dct_methodjpeg_compress_struct::restart_intervaljpeg_compress_struct::restart_in_rowsjpeg_compress_struct::write_JFIF_headerjpeg_compress_struct::JFIF_major_versionjpeg_compress_struct::JFIF_minor_versionjpeg_compress_struct::density_unitjpeg_compress_struct::X_densityjpeg_compress_struct::Y_densityjpeg_compress_struct::write_Adobe_markerjpeg_compress_struct::next_scanlinejpeg_compress_struct::progressive_modejpeg_compress_struct::max_h_samp_factorjpeg_compress_struct::max_v_samp_factorjpeg_compress_struct::total_iMCU_rowsjpeg_compress_struct::comps_in_scanjpeg_compress_struct::cur_comp_infojpeg_compress_struct::MCUs_per_rowjpeg_compress_struct::MCU_rows_in_scanjpeg_compress_struct::blocks_in_MCUjpeg_compress_struct::MCU_membershipint %[C_MAX_BLOCKS_IN_MCU]jpeg_compress_struct::Ssjpeg_compress_struct::Sejpeg_compress_struct::Ahjpeg_compress_struct::Aljpeg_compress_struct::masterjpeg_comp_master *jpeg_compress_struct::mainjpeg_c_main_controller *jpeg_compress_struct::prepjpeg_c_prep_controller *jpeg_compress_struct::coefjpeg_c_coef_controller *jpeg_compress_struct::markerjpeg_marker_writer *jpeg_compress_struct::cconvertjpeg_color_converter *jpeg_compress_struct::downsamplejpeg_downsampler *jpeg_compress_struct::fdctjpeg_forward_dct *jpeg_compress_struct::entropyjpeg_entropy_encoder *jpeg_compress_struct::script_spacejpeg_scan_info *jpeg_compress_struct::script_space_sizejpeg_marker_reader::dummyjpeg_inverse_dct::dummyjpeg_marker_structjpeg_marker_struct::nextjpeg_marker_struct::markerjpeg_marker_struct::original_lengthjpeg_marker_struct::data_lengthjpeg_marker_struct::datajpeg_color_quantizer::dummyj_common_ptrstruct jpeg_common_struct *JBLOCKJCOEF %[DCTSIZE2]jpeg_input_controller::dummyJBLOCKIMAGEJBLOCKARRAY *struct jpeg_marker_struct *jpeg_d_main_controller::dummystruct jpeg_compress_struct *D:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\jversion.hD:\Osiris\NewCode\Papyrus3\PapyConvertFile3.c"Papyrus3.h"GetPapyFileTypeint *imageNbint *imageNoenum EModality *modalityEModalityPapyrus2Papyruschar *inPapyrusFilenamechar *outPapyrusFilenamePAPY_FILE aRefNumint nbImagesint *tabImagePapyrus2Jpegchar *outJpegBaseFilenameshort aRefNumint *inTabImageint inJpegWidthint inJpegHeightenum EPap_Compression inCompressionint inQualityDicom2Papyrusint inNbDicomImageschar **inDicomFilenameint inIsSerieenum EModality modalityReadDicomFilechar *inDicomFilenamePapyShort inPapyrusFilePointerEPap_CompressionPapyrus2Dicomchar *outDicomFilenameExtractSelectionPapyUShort *image_bufferint image_widthint x1int y1int x2int y2InitClutcolor thisClut[]TI_tailleunsigned char *unsigned char *oriint orixint oriyint dstxint dstyint numPlanslong *taillecolorcolor::rcolor::gcolor::bCompute8bitsImagePapyUShort *inPixmapint inRowsint inColumnsint inDepthint inMinint inMaxD:\Osiris\NewCode\Papyrus3\PapyDataSetRead3.cExtractDicomDataSetInformation3PapyShortPapyShort inFileNbPapy3GetModulePapyShort inImageNbint inModuleIDExtractPapyDataSetInformation3CALLINGCONVModule *ExtractGroup28InformationExtractFileMetaInformation3D:\Osiris\NewCode\Papyrus3\PapyDataSetWrite3.cKeepReferences3int inElementIDUValue_T *inValPCreateTmpFile3PAPY_FILE *ioFpPvoid **ioVoidPETransf_SyntaxPapy3GetGroup2Papy3LinkGroupToDSItem *inDataSetPSElement *inGroupPint inGroupNameSElement *Papy3CreateDataSetCreateStudySummary3Papy3GetRecordTypeSElement *inGroupSequencesToGroups3Item *inSequencePint inToDelItemModulesToGroups3Item *ioDataSetPCreateSummaries3ItemRecordsToGroups3CheckDataSetModules3CreatePatientSummary3Papy3CloseDataSetint inPerformCheckCreateDicomFileMetaInformation3PAPY_FILE inFpenum ETransf_Syntax inSyntaxenum EModality inModalityPapyULong *OutMetaInfoSizePCreateFileMetaInformation3Papy3CheckDirectoryInformationModule *inModulePCreateSeriesSummary3Papy3CreateModuleint inModuleNameCreateIcon3WriteDicomHeader3PapyULong *outMetaInfoSizePLookForGroupsInModule3int *inDSGroupsTotPint *inGrToCreatePPapy3InsertItemToSequenceint inElemNbenum EKind_Obj inItemTypevoid *inItemint inItemIdEKind_ObjPapy3FindModuleWriteTmpFile3Papy3LinkModuleToDSCreatePointerSequence3D:\Osiris\NewCode\Papyrus3\PapyEallocPC3.cpp"PapyWild3.h"checkvp3void *pointerecalloc3PapyULong nelemPapyULong elsizeerealloc3void *ptrPapyULong sizePapyULong size2emalloc3efree3void **pD:\Osiris\NewCode\Papyrus3\PapyError3.c"PapyError3.h"sExitWhenErrorgPapyErrFilePchar *%[kMax_Error_Level]sPapyErrorDecoPPapy3CheckErrorint inCodeErrchar *inFilePint inLinegPapyErrLigneint %[kMax_Error_Level]PapyErrorListchar *%[]PapyPrintErrMsg3PapyShort inLinePAPY3PRINTERRMSGvoid CALLINGCONVgFirstErrorEPapyError3gPapyErrNosCrtErrLevelsERRMSGchar %[]D:\Osiris\NewCode\Papyrus3\PapyFiles3.cPapy3FileClosePapyShort CALLINGCONVint inToCloseReadGroup3PapyUShort *outGroupNbPunsigned char **outBuffPPapyULong *outBytesReadPPapyULong *outGroupLengthPFileOpen3char *inNamePPAPY_FILE inVRefNumPAPY_FILE *outFpvoid *inFSSpecPapy3GotoGroupNbPapyShort inGroupNbComputeUndefinedSequenceLength3PapyULong *ioSeqLengthPComputeUndefinedGroupLength3PapyLong inMaxSizePapy3GetNextGroupNbComputeUndefinedItemLength3PapyULong *ioItemLengthPenumPapy3SkipNextGroupPapy3FileOpenint inToOpenPapy3GotoElemNbPapyUShort inGroupNbPapyUShort inElemNbPapyULong *outElemLengthPWriteGroup3unsigned char *inBuffPPapyULong ioBytesToWritePapy3FileCreatePapyUShort inNbImagesint inToCreateint inIsPapyrusFindFreeFile3Papy3FindOwnerRangePapyUShort CALLINGCONVchar *inOwnerStrPPapy3ExtractItemLengthPapyULong CALLINGCONVwrite_pos3PapyULong inPosunsigned char **ioBuffPPapyShort inLengthPapy3WriteAndCloseFileD:\Osiris\NewCode\Papyrus3\PapyFileSystemPC3.cPapy3DGetNbFileschar *dicomPathint *nbFilesPapy3FPrintchar *inStringPchar *inFormatPint inValuePapy3FReadPapyULong *ioBytesToReadPPapyULong inNbvoid *ioBufferPPapy3FOpenchar *inFilenamePchar inPermissionPAPY_FILE inVolumeNbvoid *inFSSpecPPapy3FDeletevoid *inIdentifierPPapy3FSeekint inPosModePapyLong inOffsetPapy3FTellPapyLong *outFilePosPPapy3FClosePAPY_FILE *inFpPapy3FCreatePAPY_FILE inVolumevoid **inFSSpecPPapy3FWritePapyULong *ioBytesToWritePvoid *outBufferPD:\Osiris\NewCode\Papyrus3\PapyGetGlobalVar3.cPapy3GetModalityint CALLINGCONVPapy3GetTransfSyntaxPapy3GetNbElemInModuleint moduleIdPapy3GetFileKindint inFileNbPapy3GetCurrTmpFilenamePapy3GetToolkitVersionPapy3GetNbImagesPapy3GetFilePAPY_FILE CALLINGCONVPapy3GetCompressionD:\Osiris\NewCode\Papyrus3\PapyInit3.c"PapyInitModules3.h"InitModule3int inModuleEnumSElement *ioElemPSetWindowingValueint inWindowLevelint inWindowWidthPapy3GroupFreeSElement **ioGroupPint inDelSeqSetModalityenum EModalitychar *modalitySetSubSamplingFactorfloat inSubSamplingFactorPapy3FreeSQElementPapy3FreeDataSetModulesPapy3InitInitModulesLabels3SetCompressionFactorint inCompressionFactorPapy3GroupCreateint inGroupNbInitDataSetModules3Dicom2PapyInitInitUIDs3InitGroupNbAndSize3Papy3AddOwnerchar *inValuePCreateModule3Papy3ImageFreeSElement *inGrOrModPPapy3ClearElementPapyShort inElementInitModuleSize3SetCompressionSetCropingPointsfloat X1float Y1float X2float Y2SetZoomFactorfloat inZoomFactorInitGroup3int inGroupEnumPapy3ModuleFreeSElement **ioModulePD:\Osiris\NewCode\Papyrus3\PapyInitGroups3.cinit_group3008SElement ioElem[]init_group300Ainit_group300Cinit_group300Einit_group3002init_group3004init_group3006init_group2030init_group2100init_group2040init_group2110init_group2050init_group2000init_group2010init_group2020init_group2120init_group2130init_group5000init_group4000init_group4008init_group7FE0init_uinoverlayinit_group2init_group4init_group6000init_group5400init_group8init_group100init_group10init_group18init_group20init_group41init_group50init_group38init_group32init_group40init_group28init_group70init_group3Ainit_group60init_group54init_group88D:\Osiris\NewCode\Papyrus3\PapyInitModules3.cinit_ImageBoxPixelPresentationinit_DXPositioninginit_RTDoseinit_ExternalVisitReferenceSequenceinit_DXSeriesinit_Multi_Frameinit_StudyComponentinit_USImageinit_RTImageinit_NMMultiFrameinit_InterpretationStateinit_XRayGenerationinit_SCMultiFrameImageinit_IntraOralSeriesinit_ImageBoxRelationshipinit_GeneralSeriesinit_CRImageinit_BasicFilmSessionPresentationinit_XRayAcquisitionDoseinit_PETCurveinit_Patientinit_VisitAdmissioninit_NMPhaseinit_RTGeneralPlaninit_ExternalPapyrus_FileReferenceSequenceinit_DXAnatomyImagedinit_ImageIdentificationinit_PatientStudyinit_ModalityLUTinit_NMMulti_gatedAcquisitionImageinit_RTToleranceTablesinit_ExternalStudyFileReferenceSequenceinit_ResultsImpressioninit_PixelOffsetinit_OverlayPlaneinit_RTSeriesinit_StudySchedulinginit_NMTomoAcquisitioninit_USRegionCalibrationinit_XRayFiltrationinit_RTFractionSchemeinit_RTBrachyApplicationSetupsinit_GeneralSeriesSummaryinit_InternalImagePointerSequenceinit_InterpretationRecordinginit_XRayTableinit_RTDoseROIinit_StudyReadinit_InterpretationRelationshipinit_XRayTomographyAcquisitioninit_XRayCollimatorinit_Approvalinit_Curveinit_UINOverlaySequenceinit_PETImageinit_VLImageinit_DXImageinit_BiPlaneImageinit_Printerinit_XRFPositionerinit_StudyContentinit_InterpretationApprovalinit_GeneralPatientSummaryinit_XRayAcquisitioninit_NMDetectorinit_StudyIdentificationinit_Cineinit_SOPCommoninit_GeneralImageinit_NMIsotopeinit_BasicFilmSessionRelationshipinit_ImageOverlayBoxPresentationinit_OverlayIdentificationinit_ImagePixelinit_PETSeriesinit_SlideCoordinatesinit_CurveIdentificationinit_RTBeamsinit_DXDetectorinit_RTDVHinit_Audioinit_RTPatientSetupinit_Deviceinit_PaletteColorLookupinit_Multi_frameOverlayinit_GeneralStudySummaryinit_ResultRelationshipinit_VOILUTinit_PETIsotopeinit_VisitSchedulinginit_DirectoryInformationinit_MammographySeriesinit_FileReferenceinit_MammographyImageinit_RFTomographyAcquisitioninit_ImagePlaneinit_CRSeriesinit_PatientMedicalinit_XRayGridinit_GeneralVisitSummaryinit_IconImageinit_VisitIdentificationinit_PatientSummaryinit_XRayImageinit_MRImageinit_VisitStatusinit_StudyComponentAcquisitioninit_RTPrescriptioninit_SCImageEquipmentinit_USFrameofReferenceinit_NMSeriesinit_ImageSequenceinit_VisitRelationshipinit_ContrastBolusinit_ImageHistograminit_AcquisitionContextinit_ROIContourinit_ImageOverlayBoxRelationshipinit_PETMultiGatedAcquisitioninit_FileSetIdentificationinit_GeneralStudyinit_PatientDemographicinit_BasicFilmBoxRelationshipinit_PrintJobinit_FramePointersinit_IntraOralImageinit_NMReconstructioninit_PatientRelationshipinit_FrameOfReferenceinit_SpecimenIdentificationinit_IdentifyingImageSequenceinit_ResultIdentificationinit_BiPlaneOverlayinit_CTImageinit_BasicAnnotationPresentationinit_NMImageinit_StudyRelationshipinit_GeneralEquipmentinit_StructureSetinit_PatientIdentificationinit_NMImagePixelinit_SCMultiFrameVectorinit_BiPlaneSequenceinit_BasicFilmBoxPresentationinit_Therapyinit_InterpretationIdentificationinit_InterpretationTranscriptioninit_LUTIdentificationinit_StudyClassificationinit_RTROIObservationsinit_ImagePointerinit_VisitDischargeinit_DisplayShutterinit_StudyComponentRelationshipinit_Maskinit_SCImageinit_StudyAcquisitioninit_ExternalPatientFileReferenceSequenceD:\Osiris\NewCode\Papyrus3\PapyList3.cInsertInListAtPapy_List *Papy_List **ioListPObject *inElemToInsertPPapyShort inPosInsertLastInListInsertFirstInListDeleteFirstInListint inDelAllint inDelGroupFreeCellPapy_List **ioToFreePDeleteLastInListInsertGroupInListDeleteListD:\Osiris\NewCode\Papyrus3\PapyRead3.c"setjmp.h""Mayo.h"Papy3GetElementint inElementPapyULong *outNbValuePint *outElemTypePSErrorMgrSErrorMgr::pubSErrorMgr::setjmp_bufferjmp_bufExtractRLEPapyUShort *ioImage16PPapyULong inPixelStartPapyULong *inOffsetTablePint inImageNbUValue_T *Extract4Bytesunsigned char *inBufPPapyULong *ioPosPExtract2BytesPapyUShortExtractWaveletPapyUChar *ioImage8PExtractJPEGlossyPutBufferInGroup3unsigned char *ioBuffPSElement *ioGroupPPapyUShort inPapyGrNbPapyULong inBytesToReadPapyULong *ioBufPosPPapyLong inInitFilePosSErrorMgrPstruct SErrorMgr *Papy3GroupReadExtractJPEGlosslessDicomPapyUChar *outBufferPPapy3GetPixelDataint inModuleIdExtractJPEGlosslessPapPapyULong inLengthmy_error_exitj_common_ptr ioCInfoExtractStringPapyULong inElemLengthDecodeRLESegmentPapyUShort *ioImagePPapyUChar *inRlePint inSegtotint inSegNbPutBufferInElement3Extract8BytesPapyFloatDoubleD:\Osiris\NewCode\Papyrus3\PapyUtils3.cPapy3SetIconSizePapyUShort inSizeExtractDicomdirFromPathchar *inFilePathPchar *outExtrNamePPapy3ElemTagToEnumNbPapyUShort inGrTagPapyUShort inElemTagint *outEnumGrPint *outEnumElemPPapy3GetIconSizePapy3GotoNumberPapyShort inNbenum EDataSet_Image inDSorIMPapy3ToEnumGroupPapyUShort inPapyrusNbEDataSet_ImageEPhoto_InterpretPap2ToPap3Timechar *pap2Timechar *pap3TimeConvertYbrToRgbPapyUChar *ybrImageint widthint heightenum EPhoto_Interpret theKindchar planarConfigPapy3CheckValidOwnerIdPap2ToPap3Datechar *pap2Datechar *pap3DatePapyStrDupchar *inSExtractModalityPapy3GotoUIDchar *inUIDPPap2ToPap3Namechar *pap2Namechar *pap3NamePapy3EnumToElemNbSElement *inElemPint inEnumNbD:\Osiris\NewCode\Papyrus3\PapyVars3.cD:\Osiris\NewCode\Papyrus3\PapyWild3.cwildnamewild3char *inPart1Pchar *inPart2PD:\Osiris\NewCode\Papyrus3\PapyWildexit3.cexsetvoid (__cdecl *funcp)(void)EX_funcpvoid (__cdecl *%)(void)UnactiveExitWhenErrortameexitActiveExitWhenErrorExitEnabledwildexitwild2exitchar *inString1Pchar *inString2PwildcexitwildrexitD:\Osiris\NewCode\Papyrus3\PapyWrite3.cPapy3PutUnknownPapyChar *inValPPapyULong inSizeComputeElementLength3EV_R_TPapy3PutImagePapyUShort *inValPPapyUShort inRowsPapyUShort inColumnsPapyUShort inDepthPapy3PutElementvoid *inValPPut2BytesPapyUShort inSunsigned char *ioBufPComputeGroupLength3PapyULong *outImSeqSizePPutValueenum EV_R_T inVRPut2BytesImagePapyUShort *inImPPapyUChar *ioBufPWriteFilej_compress_ptr inCinfoPapyULong inDataCountPapyUChar *outJpegDPint inSaveJpegPut4BytesPapyULong inLongPutGroupInBufferPapyShort inImNbint inIsPtrSeqPapy3PutIconPapyUChar *inIconPJPEGLossyEncodeImagePapyUChar *outJpegFilenamePapyUChar *inImageBuffPPapyUChar **outJPEGDataPPapyULong *outJPEGsizePint inImageHeightint inImageWidthPapy3GroupWriteint inFreeGrWaveletEncodeImageint inRatioint inLevelsPapyUChar **outWavDataPPapyULong *outWavsizePint inHeightint inWidthPut1ByteImagechar *inImPPut8BytesPapyFloatDouble inFlDblComputeSequenceLength3PutStringchar *inCharPD:\Osiris\NewCode\Papyrus3\PapyEalloc3.hD:\Osiris\NewCode\Papyrus3\PapyEnumGroups3.h"PapyEnumImageGroups3.h"groupsD:\Osiris\NewCode\Papyrus3\PapyEnumImageGroups3.hD:\Osiris\NewCode\Papyrus3\PapyEnumImagesModules3.hD:\Osiris\NewCode\Papyrus3\PapyEnumModules3.h"PapyEnumImagesModules3.h"recordsmodulesD:\Osiris\NewCode\Papyrus3\PapyError3.hD:\Osiris\NewCode\Papyrus3\PapyErrorMacros3.hD:\Osiris\NewCode\Papyrus3\PapyFileSystem3.hD:\Osiris\NewCode\Papyrus3\PapyGlobalVar3.hsModule_Study_ComponentWHERE3 char *sModule_Result_RelationshipsModule_General_EquipmentsLabel_BasicAnnotationPresentationWHERE3 char *%[3]sModule_Visit_StatussModule_General_Patient_SummarysLabel_Study_RelationshipWHERE3 char *%[7]sModule_RT_Dose_ROIsModule_Study_IdentificationsLabel_US_ImageWHERE3 char *%[47]sModule_Study_ClassificationsModule_RT_BeamssModule_XRay_Tomography_AcquisitionsModule_General_Series_SummarysModule_CurvesLabel_Mammography_SeriesWHERE3 char *%[2]sModule_NM_IsotopesLabel_BasicFilmBoxRelationshipWHERE3 char *%[4]sModule_Study_Component_RelationshipsModule_US_Frame_of_ReferencesModule_Study_SchedulingsModule_VOI_LUTgOffsetToPtrSeqWHERE3 PapyULong %[kMax_file_open]sLabel_Image_Box_RelationshipsLabel_XRay_CollimatorWHERE3 char *%[9]sModule_XRay_TablesModule_RF_Tomography_AcquisitiongPosLastPatientOffsetgArrModalitiesWHERE3 Data_Set *%[END_MODALITY]sModule_BiPlane_ImagesLabel_XRay_TableWHERE3 char *%[6]gx0028RowsWHERE3 PapyUShort %[kMax_file_open]sModule_File_ReferencegRightXWHERE3 floatgNbShadowOwnersLabel_DX_SeriessModule_Pixel_OffsetgCompressionWHERE3 enum enum EPap_CompressionsLabel_Study_ReadsLabel_MR_ImageWHERE3 char *%[49]sLabel_Interpretation_Transcriptiongx0028BitsAllocatedsModule_DX_DetectorsModule_ROI_ContoursModule_Study_ReadsModule_DX_PositioningsLabel_Multi_FramesLabel_SC_Image_EquipmentEFile_TypesModule_Identifying_Image_SequencesModule_Acquisition_ContextsModule_MR_ImagesModule_XRay_FiltrationsModule_PET_IsotopesModule_RT_Patient_SetupsModule_Multi_FramesLabel_Interpretation_ApprovalWHERE3 char *%[5]sModule_NM_Image_PixelsLabel_MaskgLeftXsLabel_SC_ImagesModule_PET_Multi_Gated_AcquisitionsLabel_NM_Image_PixelsModule_NM_Multi_FramesLabel_Patient_SummarysLabel_General_ImageWHERE3 char *%[15]sModule_Results_ImpressionsModule_Patient_RelationshipgArrIconsWHERE3 PapyUChar **%[kMax_file_open]gArrGroup41WHERE3 SElement *%[kMax_file_open]gWindowWidthWHERE3 intsModule_NM_ReconstructiongRefLowerLevelDirRecordOffsetWHERE3 PapyULong *%[kMax_file_open]sLabel_BiPlaneOverlaygTopYsLabel_XRay_GenerationWHERE3 char *%[13]gRefImageNbsModule_General_StudygIconSizeWHERE3 PapyUShortsModule_CT_ImagesModule_Image_SequencesLabel_XRay_ImageWHERE3 char *%[19]sLabel_TherapysLabel_Study_Component_RelationshipsLabel_Acquisition_ContextsModule_Palette_Color_LookupsModule_Patient_IdentificationgPapyFileWHERE3 PAPY_FILE %[kMax_file_open]gIsPapyFileWHERE3 enum enum EFile_Type %[kMax_file_open]sModule_CinesModule_Directory_InformationsModule_Interpretation_IdentificationsModule_SC_Multi_Frame_VectorsModule_Image_Box_Pixel_PresentationgCurrTmpFilenameWHERE3 int %[kMax_file_open]sLabel_Study_IdentificationsLabel_DX_ImageWHERE3 char *%[22]sLabel_NM_DetectorsModule_CR_SeriessModule_NM_SeriessModule_Curve_IdentificationsModule_Display_ShuttergPtrSequenceItemWHERE3 Item *%[kMax_file_open]sModule_NM_Multi_gated_Acquisition_ImagesLabel_External_Papyrus_File_Reference_SequencesModule_Image_Overlay_Box_PresentationsLabel_Patient_RelationshipsModule_Basic_Annotation_PresentationgRefLastPatientOffsetsModule_DevicesLabel_Image_Overlay_Box_RelationshipsLabel_BasicFilmBoxPresentationsLabel_Result_IdentificationsModule_VL_ImagegSubSamplingFactorsLabel_XRay_GridgReadOrWriteWHERE3 PapyShort %[kMax_file_open]sLabel_Frame_PointerssModule_RT_ImagesModule_Frame_Of_ReferencegFileModalitygOffsetToImageSeqsLabel_CR_ImageWHERE3 char *%[16]sLabel_Study_SchedulinggPapFilenameWHERE3 char *%[kMax_file_open]gIsPapy3InitedsModule_NM_PhasesModule_Interpretation_TranscriptionsLabel_SOP_CommonsModule_NM_Tomo_AcquisitionsLabel_NM_ImageWHERE3 char *%[20]sLabel_Visit_IdentificationsModule_XRay_CollimatorsModule_RT_Fraction_SchemegArrModuleNbWHERE3 int %[END_MODALITY]sModule_Visit_Dischargegx0028ImageFormatsLabel_Image_Box_Pixel_PresentationWHERE3 char *%[8]sModule_US_ImagegPosImagePointersLabel_External_Study_File_Reference_SequencesLabel_General_Visit_SummarysModule_Multi_frame_OverlaygRefImagePointersModule_DX_ImagesModule_RT_Tolerance_TablessLabel_Image_Overlay_Box_PresentationgZoomFactorsModule_DX_Anatomy_ImagedsModule_SC_Image_EquipmentgPosPixelOffsetsLabel_General_Series_SummarysLabel_Study_ComponentgRefBitsStoredsLabel_Interpretation_RecordingsLabel_BiPlaneSequencesModule_Mammography_ImagesLabel_NM_Multi_gated_Acquisition_ImagesModule_Mammography_SeriessModule_Specimen_IdentificationsLabel_Pixel_OffsetsLabel_DX_PositioningsModule_UIN_Overlay_SequencesLabel_Frame_Of_ReferencesModule_RT_PrescriptionsModule_External_Visit_Reference_SequencesModule_Result_IdentificationsModule_SC_Multi_Frame_ImagesLabel_Interpretation_RelationshipgImageSequenceItemsLabel_XRay_Acquisition_DosesLabel_Study_Component_AcquisitionsModule_Study_Component_AcquisitionsLabel_BiPlaneImagesLabel_Display_ShuttersLabel_Print_JobsLabel_Overlay_PlanesLabel_External_Patient_File_Reference_SequencesModule_Contrast_BolussLabel_US_Region_CalibrationsLabel_Contrast_BolussModule_XRay_GenerationsLabel_DevicesModule_Visit_SchedulingsModule_File_Set_IdentificationsLabel_Intra_Oral_ImagegRefPixelOffsetgx0028ColumnssModule_External_Study_File_Reference_SequencesModule_Study_AcquisitiongCompressionFactorsModule_RT_DVHsModule_Patient_MedicalsLabel_Image_PlanesModule_NM_DetectorsLabel_Visit_DischargesModule_PET_CurvesModule_ApprovalsLabel_DX_DetectorWHERE3 char *%[28]sModule_Study_RelationshipsModule_Patient_DemographicsLabel_Specimen_IdentificationsLabel_UIN_Overlay_SequencesModule_LUT_IdentificationsLabel_Identifying_Image_SequencesLabel_Image_SequencesLabel_NM_Multi_FrameWHERE3 char *%[18]gRefRowssModule_XRay_AcquisitionsModule_Structure_SetsLabel_Visit_SchedulingsLabel_XRay_FiltrationsModule_US_Region_CalibrationsModule_TherapysLabel_General_Study_SummarysModule_XRF_PositionersModule_General_Visit_SummarysLabel_Study_ClassificationsModule_Modality_LUTgArrUIDsWHERE3 char *%[END_MODALITY]gPapyrusFileVersionWHERE3 float %[kMax_file_open]gCurrentOverlaygPosFirstPatientOffsetsLabel_Interpretation_StatesModule_Image_HistogramsLabel_PrinterWHERE3 char *%[10]sLabel_Overlay_IdentificationgRefIsSignedgArrMemFilesLabel_DX_Anatomy_ImagedsModule_External_Papyrus_File_Reference_SequencesModule_Visit_IdentificationsModule_MasksModule_XRay_Acquisition_DosesLabel_Visit_StatussLabel_File_Set_IdentificationsLabel_Image_IdentificationsModule_Intra_Oral_SeriessLabel_Mammography_ImagesLabel_Patient_DemographicsLabel_NM_ReconstructionsModule_Visit_AdmissiongRefWLWHERE3 PapyLongsLabel_Image_PixelsLabel_US_Frame_of_ReferencesLabel_General_SeriesgArrGroupWHERE3 SGroup %[END_GROUP]sLabel_Visit_AdmissiongRefWWsLabel_VOI_LUTgRefBitsAllocatedsLabel_AudiosLabel_Curve_IdentificationsModule_Image_Overlay_Box_RelationshipsLabel_General_StudyWHERE3 char *%[11]sModule_Interpretation_RelationshipsModule_Basic_Film_Session_RelationshipgRefPixMinsLabel_Modality_LUTsModule_Image_PixelsLabel_CinesModule_General_Study_SummarysLabel_PatientsModule_Interpretation_ApprovalgPosLowerLevelDirRecordOffsetsModule_PET_ImagesModule_CR_ImagesModule_Interpretation_RecordinggRefPixMaxgArrModuleWHERE3 PapyShort %[END_MODULE]sLabel_XRay_AcquisitionsModule_General_SeriesgCurrFileWHERE3 PapyShortsModule_General_Imagegx0028BitsStoredsLabel_CR_SeriessModule_XRay_ImagegShadowOwnerWHERE3 SShadowOwner *%[kMax_file_open]sLabel_Icon_ImagesModule_Icon_ImagegPapyrusCompatibilityWHERE3 char %[2]sModule_External_Patient_File_Reference_SequencesModule_RT_DosesModule_NM_ImagesModule_Image_Box_RelationshipsModule_BiPlane_SequencesLabel_XRay_Tomography_AcquisitionsLabel_Directory_InformationsModule_Frame_PointerssModule_Patient_SummarysLabel_NM_PhasegPatientSummaryItemsLabel_Patient_StudysModule_Image_PlanesLabel_NM_Tomo_AcquisitionsLabel_General_EquipmentsLabel_Image_PointergRefSOPClassUIDsModule_Visit_RelationshipsModule_Patient_StudysLabel_NM_IsotopegArrTransfSyntaxWHERE3 enum enum ETransf_Syntax %[kMax_file_open]sLabel_Internal_Image_Pointer_SequencegWindowLevelgPapyrusVersionWHERE3 char %[6]sModule_Image_IdentificationsModule_DX_SeriessLabel_Study_ContentsLabel_Intra_Oral_SeriessLabel_CT_ImageWHERE3 char *%[26]sLabel_File_ReferencegRefHighBitsLabel_Visit_RelationshipsModule_AudiosModule_Basic_Film_Session_PresentationsModule_XRay_GridsModule_SOP_CommonsModule_Basic_Film_Box_PresentationgRefFirstPatientOffsetgArrPhotoInterpretWHERE3 enum enum EPhoto_Interpret %[kMax_file_open]sLabel_Patient_IdentificationsLabel_BasicFilmSessionPresentationsModule_Slice_CoordinatessModule_SC_ImagesModule_PatientsModule_Interpretation_StatesLabel_CurveWHERE3 char *%[17]sModule_RT_General_PlangRefColumnssLabel_Result_RelationshipsLabel_BasicFilmSessionRelationshipsModule_PrintergRefSOPInstanceUIDgArrNbImagessModule_BiPlane_OverlaysModule_Basic_Film_Box_RelationshipsModule_RT_SeriessLabel_LUT_IdentificationsLabel_Results_ImpressiongRefNextDirRecordOffsetgBottomYsLabel_Palette_Color_LookupgArrCompressionWHERE3 enum enum EPap_Compression %[kMax_file_open]sModule_Intra_Oral_ImagesModule_Overlay_PlanesModule_Print_JobgPosNextDirRecordOffsetsModule_Overlay_IdentificationsLabel_Study_AcquisitionsLabel_Interpretation_IdentificationsLabel_External_Visit_Reference_SequencesModule_Internal_Image_Pointer_SequencesLabel_NM_SeriessModule_PET_SeriessModule_RT_ROI_ObservationssModule_Study_ContentsLabel_Image_HistogramgRefPixelDataWHERE3 PapyUShort *sLabel_General_Patient_SummarysModule_Image_PointergImageSOPinstUIDWHERE3 char **%[kMax_file_open]sLabel_Multi_frame_OverlaysModule_RT_Brachy_Application_SetupsgCurrentUINOverlaysLabel_Patient_MedicalD:\Osiris\NewCode\Papyrus3\PapyInitModules3.hD:\Osiris\NewCode\Papyrus3\PapyPrivFunctionDef3.hD:\Osiris\NewCode\Papyrus3\PapyPubFunctionDef3.hD:\Osiris\NewCode\Papyrus3\PAPYRUS3.h"PapyEnumGroups3.h""PapyEnumModules3.h""PapyGlobalVar3.h""PapyPrivFunctionDef3.h""PapyPubFunctionDef3.h""DicomDir.h"D:\Osiris\NewCode\Papyrus3\PapyTypeDef3.hPapy_Liststruct SPapy_List_Data_Setstruct SData_Set_ItemUValue_Tunion UValue_T_SElement_SElement_::groupSElement_::elementSElement_::lengthSElement_::vrenum EV_R_TSElement_::vmSElement_::type_tenum EType_TSElement_::nb_valSElement_::valueE_StyleObjectstruct SObject_RecordSElementE_ROISGroupstruct SGroup_SPapy_List_SPapy_List_::objectObject *SPapy_List_::nextSPapy_List_ *SShadowOwner_SShadowOwner_::str_valueSequenceModuleE_Colorstruct SElement_PapyFloatfloatPapyLongEUsageSShadowOwnerstruct SShadowOwner_E_FontEType_TSGroup_SGroup_::numberSGroup_::sizeUValue_T_UValue_T_::ssUValue_T_::usUValue_T_::owUValue_T_::slUValue_T_::ulUValue_T_::flUValue_T_::fdUValue_T_::aUValue_T_::sqSObject_SObject_::whoAmIenum EKind_ObjSObject_::objIDSObject_::itemSObject_::moduleSObject_::groupSObject_::recordRecord *SObject_::tmpFileLengthSObject_::fileSImageList_SImageList_::fileSImageList_::imagePapyCharcharSData_Set_SData_Set_::moduleNameSData_Set_::usagePapyUCharSImageListstruct SImageList_D:\Osiris\NewCode\Papyrus3\PapyWild3.hD:\Osiris\NewCode\Papyrus3\dicomdir\DicomDirDataSetRead.cPapy3GetRecordint inRecordIDD:\Osiris\NewCode\Papyrus3\dicomdir\DicomDirDataSetWrite.cPapy3CreateRecordint inRecordNameItem *Papy3FillRecordSElement **ioRecordPLookForGroupsInRecord3Record *inRecordPPapy3CreateDirRecItemPapy3CreateDicomDirDataSetPapy3LinkRecordToDSSElement *inRecordPD:\Osiris\NewCode\Papyrus3\dicomdir\DicomDirFiles.cPapy3DicomDirCreateint inNbFilesvoid *MacFileSpecPapy3WriteAndCloseDicomDirD:\Osiris\NewCode\Papyrus3\dicomdir\DicomDirInit.c"DicomDirInitRecords.h"CreateRecord3DicD3InitInitRecordSize3Papy3RecordFreeInitRecord3int inRecordEnumD:\Osiris\NewCode\Papyrus3\dicomdir\DicomDirInitRecords.cinit_StudyComponentRinit_FilmSessioninit_ModalityLUTRinit_PatientRinit_PrintQueueinit_Topicinit_SeriesRinit_OverlayRinit_BasicFilmBoxinit_VOILUTRinit_Visitinit_StudyRinit_Interpretationinit_Resultinit_CurveRinit_ImageRinit_BasicImageBoxD:\Osiris\NewCode\Papyrus3\dicomdir\OGlobalDicomFunc.cppDicomDateToDatechar *inCharchar *outCharDicomNameToNameDicomTimeToTimeD:\Osiris\NewCode\Papyrus3\dicomdir\DicomDir.h"DicomDirEnumRecords.h""DicomDirTypeDef3.h""DicomDirPrivFunctionDef3.h""DicomDirPubFunctionDef3.h""DicomDirGlobalVar3.h"D:\Osiris\NewCode\Papyrus3\dicomdir\DicomDirEnumRecords.hD:\Osiris\NewCode\Papyrus3\dicomdir\DicomdirGlobalVar3.hgIsDicd3InitedgArrRecordWHERE3 PapyShort %[END_RECORD]D:\Osiris\NewCode\Papyrus3\dicomdir\DicomDirInitRecords.hD:\Osiris\NewCode\Papyrus3\dicomdir\DicomdirPrivFunctionDef3.hD:\Osiris\NewCode\Papyrus3\dicomdir\DicomdirPubFunctionDef3.hD:\Osiris\NewCode\Papyrus3\dicomdir\DicomdirTypeDef3.hSStudyDatastruct SStudyData_SPatientData_SPatientData_::nextPatientSPatientData_ *SPatientData_::fileIDchar %[VR_CS_LENGTH + 1]SPatientData_::SOP_ClassUIDchar %[VR_UI_LENGTH + 1]SPatientData_::SOP_InstanceUIDSPatientData_::patientNameSPatientData_::patientIDSPatientData_::entrySPatientData_::studyInfoSStudyData_ *SSeriesDatastruct SSeriesData_SSeriesData_SSeriesData_::nextSeriesSSeriesData_ *SSeriesData_::fileIDSSeriesData_::SOP_ClassUIDSSeriesData_::SOP_InstanceUIDSSeriesData_::modalitySSeriesData_::institutionNamechar %[VR_LO_LENGTH + 1]SSeriesData_::institutionAddresschar %[VR_ST_LENGTH + 1]SSeriesData_::seriesInstanceUIDSSeriesData_::seriesNumberchar %[VR_IS_LENGTH + 1]SSeriesData_::performingMDchar %[VR_PN_LENGTH + 1]SSeriesData_::entrySSeriesData_::imageInfoSImageData_ *SSeriesData_::nbImagesSSeriesData_::multiFrameSImageData_SImageData_::nextImageSImageData_::fileIDSImageData_::SOP_ClassUIDSImageData_::SOP_InstanceUIDSImageData_::imageNumberSImageData_::calibrationObjectSImageDatastruct SImageData_SPatientDatastruct SPatientData_SStudyData_SStudyData_::nextStudySStudyData_::fileIDSStudyData_::SOP_ClassUIDSStudyData_::SOP_InstanceUIDSStudyData_::studyDatechar %[VR_DA_LENGTH + 1]SStudyData_::studyTimechar %[VR_TM_LENGTH + 1]SStudyData_::studyInstanceUIDSStudyData_::studyIDSStudyData_::studyDescriptionSStudyData_::entrySStudyData_::seriesInfoD:\Osiris\NewCode\Papyrus3\dicomdir\OGlobalDicomFunc.hPapyFileSystemPC3Danssauvegarderemplac wsprintf avec sprintf car les fichiers temporaires g n r s avaient un nom erron qui emp chait laErnetremplac wsprintf avec sprintf car les fichiers temporaires g n r s avaient un nom erron qui emp chait laErneremplac wsprintf avec sprintf car les fichiers temporaires g n r s avaient un nom erron qui emp chait laErnestremplac wsprintf avec sprintf car les fichiers temporaires g n r s avaient un nom erron qui emp chait laErnesto Dremplac wsprintf avec sprintf car les fichiers temporaires g n r s avaient un nom erron qui emp chait laErnesto Duranteremplac wsprintf avec sprintf car les fichiers temporaires g n r s avaient un nom erron qui emp chait la‚¶[,G\ÕZ2&vBÓ}cH¯XNrˆÇHZ ÿHS&õhb ŸFÂÔöÏO3ТÞ6X 2Ú 4I†;êñgãù’Yê¨ã~>ƒW.UžÐ¶Æ+=‹xÅD|öÿÒŽVýøÔ^kšÃVËC¿'Êl=P#éŸ+¤ò£¢Cy¿îÔqö>÷$Ðz=”ÁÓC_¿aô•TU%L¼ý÷E-½×ÐFÈd«‹É—tUóªCȶÊRÈ„Êâ?µÅk6ηS<äò *¥ùß»/o˜c5®%gºÚR¦Ã)lWIß©ø(x†…qD?8ÒƒP—ˆÛ"WLW¹J_ÖEŸ C2±¹^²¹æct}»‚¼Úë7Æ“Y´ÈÛ$n1J}© ZLMÿŠ_,’µA¼ƒR¥ó?’›ì4ßQÓU¨s g@}„Ó#Éû½^÷¯Y H8° †6JPßÀ / Ÿ[áã-¤>õîmßN†â "ýÊ<¾Ó°ó¶hê)ÚnÇ9'j¶@gxe7²tëDÝÃ+%= {õf»¹€ÒŽý| }!Û®ÚûØÎE}¦†‘š:5÷$VXŸcž|gé§ÀR³§ïÔ½ . Yq£‹{AJ7Læ4Ô&E¤‰CÄÞf@Ž´šý'yš’Jt^ù2² ±Á§ÂgÛVÖ…Ë\]¤ŽòîÞÈrՇˆÑiì9.®:Õ*iòžÒxž"GMz}£*¬)ÒçT‚W÷ÇàO¨L 09{,K_  Zë‘ I^…­A%@ðu}@èµeåßÊð´QTÌñÕ‹„6¨z…’PprŠ÷b<¡j±¬&cwæé'ü\˜ŠÁl`¦”÷Mr]æ…sTs;嬗4°yšÖTç¹SÈþwÉ`I“c}2Ø£JÙn(/=a…õ" ¿e²èÞ×tÏK‡^Ôx¿GO¥lÇÍï0ƒê–¥lqŒŠîrp¦€\.âûÁœ~û¨VùÙý‚ÆœìÚ‘=¸ïÚ*:<â|Î…lD›jV` «ìÑZ4ÖÖõö-ÀKOg?cZ*\®Ìu=¼è‰tç8õs8*4óóh™êêDÛÅÎúp‚³Çò¿KîžEsU®n‘Ã_ !1¯ÆcMv ·Ú7Î=%X+÷-:'9‹½ßä]Ÿ)N; »}ÆÉÇö]³s{¹J _ [K=N%Í—7ÃhJ ”sógûÙ€Ìfr9ý¯j«»dÔJÉã¤;¥ò~ v‰Œ¿à!£™HÒÎ1+£¹*\MH8ìMŽzÙ¬°@u?ü0·ô ¥®'-7j %:HÃÏ3óèÓ談®ÜôeŒõPA%rÓt`¡- šßls1©ö¬þY4[nŒ,fßÇp§ïÐèé· ]lCÍœ¢;ÑÉ.؆ZÁRè}Cƒá½F!¯™'(ÈTiaJ4Ÿ‘âPãèÛãáÏÖ1¶Z)Ç´–žTñ3ÌBóSõöS:©ècýÂÿËïA® ±¥y¼ˆþ¶yÛ¶âFØM¥wšgñWþH™Ž°Sðqþb"]øŒY£€ó=í%RÇD:Î]” FŠÊj;À}6*cµQ[O‘BÛù<Œ³•g¯-&6NDǩʳ7énÃ7Ô˜º4Å»ôº°€¸èíZ­ÜÁÅÿÓL1Øs(ë-ØQÞHà Ö‘KÕ« Îÿ”Ÿ€¼ešýÓîÓ×µ"PhÇkjpν†ú`’à6Â^ˆ±ì ZYþ·¬¸Ç©âlÐQVýI"¾-m‚­HÅ@®6Rëퟳø]TÀÏŸ]cÑ£$°´.¼Ì)YÔK/šÕ%OòÝsyw5#úú8ŸÜAºv@¿wJAxÌ­³ŽÛ×9wĺ8„<hP°Ò²gõÖ_ )€Ü&Ó¤ § ÉÀmôè¢ü|0´Ó©Ÿn_±=t_¥ÁÎöho¥SOF‡Ú×`ÓÓPKB>€v SˆLÐ¥­Yj8ÊHjfÌáØiÀG°Ì™Oe†l¬÷ “«B9<c¾!áÆzXeêv%œÑ±Ü:~~·¢$)º®U Ÿñ\Ýö<(¥¸Ó=Æ¡mÚÛ]šÛ ^ÎmYÏó€‚ÁÓ5?ªREÖó7áÕwùytà Ï6&jòi%|JœÀâßÍ‚øýu÷Uâæ]jnÛõ$šÝ£@' *ÕN§ú§?zÁb àá¬sÈÿÖyÕö²Õ¤e§‡³`й›”ÃaXá®Ë»˜M1B£¦îB2×›Ë@Ɖ(ùÍ{jF{Ä«‚ä‹wb¬?×ç°HA4/j¼Ö‹;S¾éÓYäi)gÁtù%J&£Á£][-Ù~SS£¿´2œ™Vºo´;!Ÿ5`§ßÓ—ìF@pUÄ9˜ovûèUwé+Íå2 ¦PÜ,œúfð» ok ÏÍYcúË?ÞŽ—èDdä&>s®Ž Aá½Þ%Äb#C ådŸµ¿>ºNž°öuxŽ †/°<ÙÜ"p#0;]lÅEVûUŠßVbIõÆ$˜ÑÖÂÃR¤öxP„ÿ xË+³â–ÑufóZ ²‘ ©ç^‡dàÔ[MÖB ´MÒÄ”i‰)h| bÑhz¾© üCUyÓFÅ~K½ûMë¡*ŽÆe\ {X€¬Úüñ¼ˆ¼Ó¼â¼;À7K¦¼Ä¼Ó‚QcŸ*M3õܾv×½€ˆòP5UoÔ뺵9ã·¬ì§Òp¾ýõ›%Pu}hÒšrÌr5.vOV°!þãWŽJ'Á§Ì‡ÕJà,϶œYàåøšKÜß³I]½ád»é«íIö£þŽHÎã] nõš®[†`áS€, K°\Áìô]¤Á…Ì4ı«’T?¦Íǽßmǹ¢s‚ˆ·~ ™·Šùt¨¨h„1ó¸Ë{ôx ÿ¶fP+†Q?M7}‘5 —îhuÀ ÜB€[/ Œ°è¨ØÉyWs« uöHV"ÙŠ uØ Øýn ÚSÀ ¬1Ñ(.Ü‘+W‰“eèI°P)Ån.zÝ¥D^Øᨠ¨ãð˜ÉšoÈG)ýüæA[¼ª#ëM›G샢Ãbô=±Ô0._§¶:î~%×\4ˆÒgœ¿"l¶‰Ù§‡ýöôȇž¾çðºò±¦é€oow3ùggøì±5 ´Þ~mûŒ˜ôÒ¿¹ÉRªŽ3\ìn4 ùysù xý×ÆjòߤrÙ·Øþ–½[Üwì}Êmèÿ® £“Df£`H½¾Gÿ.S¦ÔáÆ<°€L5ªç„ Kk…Ño¸3Ó º­¦,=NË™ÔÐs;»p¯ïY_H|ˆ¹7”Ì<½&ËQï÷ÒªÆ [þa€ÐeGiò Z½PwçSñ&ú Qí¢ÛdÇdÑd±¸èaŠ­ßñëØ4 ½åw”ðÛ39Þn ,‚™ZÍxäÌ@=_eJÛCŒj6±ë{W" ¢º0ƒ ŸÔ4X—²ãóå˜,r#©=î µ ­¥˜“ŒW²Øqœf J‘Ó3 ††oà]6KM…Í«EyðϱêX õ®u© ‰j½áv½4ÍÊ ½ÎêíŒ ‘]ƽ–Í[ Ãï ZÙzJÖ %ž”Uló<ÝhvÖ×GO¬Þ죒n{ZÓ$nËÕæª\È•Æfvý· TÕ§Ím–&ÑO¢V»Éè©ÇÇÒ ^ gdw"õ é`1Ñg¯ÚYîCÝÔ¯!0%¦h¢6H;`î]ÉŸëËQ{è;î:â M¿m{qga†N›õÖOÞVfCìëàçÀ£7ÈèÈó³ ÖV'^2ôl Tl¶ÂÙƒ…¡M›Ö”Øéý‘‡u¨zæÅ)?gcÆù|ddßc…‹çKÔ!µÀpž!oã^‘Ã^³Ä­t=Ô€%öj_J<Ø­±ÍCX}ìt7†õúfI¾JÊ[»‡^¶É%op3ÿ­R.^£ûÑÅDw22ùâŲ̃aê7à|æˆ]àÙÁknd›%‡7XªK‡L©l+…2¬G…‡¦^p0¬O²¯ªaï‰Vá™9ŽÈ ¶]ÄÕ¦óûøð…¹©â–æ[2hΊc.»aá"º½åÒV¾zŽ  Sá…¬½ÒѺ6ZhˆÖ:yú#ß}IoLëM÷osák¦NÒJdq‡*Ûl©HP±²©—ʵEþ­9r¾5ˆc &U\‘*F¥üài®nG„« ¡qÁ•lKÕºKâ—-8ª¨_¥ñê Ó¶í#½lÍV·%Ï ;1÷ˆm£–ΧÞê yŽx“–Á =·À4½¦÷(ìË$YÏ£èÎIeÝbì×,({_÷€äAq¹¡?Q¡ êçÓ¨Ú¨Ís8†m[lHud‹ ®à¢w¬Õ– ÎX¸-÷†D¯5ͦÑ[ã’¹*Q{Q Π0&IÃ5þF‚Èí2!0‘œÁ „è)¢«¡Jk²9¥6‰ç+èraÍ÷RC®ÛоºV°€“ŽàXÖÒ5æÖÃOjÅû5ê2Ð×Ø;I´¹ò•C°bî1<[ði)øh­èò7Œ# !¢¯{óÇÜaÝ1C©Ñ;D­p¶EÅãÑe‘d0Â×eAh0;ÿO$¬ÙýBGzßû*B6€gÎÁ Eáºôp:>xÚÖŒÈ8:]ù°Ä€Ÿ0ÂîŠé;ãžå<9`£ª¹Þ×oFŠÜ‰Œó³ ÃÔ»qg¹’mýã„Åíûð¥:¬)ÎîzeNÑþB,1‡©Ä-n/ìq)Px×à!½&ŠéKâŠ<¨_üö?ÖVO(a×Ý©²¥¢†Ö²ÝœÏ á™Në´Z‹e £ Qô+[A=ÛÝᶊ&¤Ö6$s'£M~\À D°±®f¨ÕµX«.ë+¥TáP‹p¸FÄÆ~°r¢ …+:s‚v»Ûaƒdã>•~´v½ˆ'o²A#¼ 8£Õ_× oïïa»s¬bÿJ»¥B¬Vß±$‚:9O?¾|¤8ç{k2q©¼Sqï\ÕÀ>‘ö¹¯„¢èÚ'ž¸çĺgÖaB§òÆ¿6® É|b«V¨âj>ç5d› /¾§+õ [=ÄîÉ"Xku̬ۘ(ú,úSkpn³vק:ËAèBðKN¢Á˜ÄóÉ-¡ãáÌ(«bÔ8‡¼ÀçxðŽÍß^6-Ÿ<—Z1(9ï€MµüuÚï '”Tÿ¸µVNW9 ÜËv΂HJuü9µS¶ž)ÛQ:üQ[m”YP‡"Þ›!%±iÓÏÑß¿à:f©à ‹ÈÙéñ @HÀuFÜ_.Q•¬E\ƒÄ¯ëán6Ô!C «r(?<ÊÈu¯jÐ@yLד^í4øoø1—)ߘˆÇÌ)|÷X¢ù¶ºuíJ6œn~3¸už²Œ9?¸ 4oÛyaaf¢²…içÁžÍ –ŒsÑœØ@¸ÌŽ|v–ºCus³¯‘½3ãÌUÃ+wB :6«Qüñj÷Ð^ÿÞÁìK*eÛâ\1^(©¸Š`Ëau%…ãÖÌ“LûÊS@~ÖÂÈÍt¬yls È·Î¥æ–Ö ûòï·È´®9&ü˜NòÿZ8 @<+sK­sÙ46ø±6@$)}aÃ÷½m»û'U7¸£Â1d‚ô÷ôc+˜ÂŽØ>C&`ÀÆçëÕ`2 ŠˆÇApñŒ¯¾\xÅ°VGwüýø«käÕ¾3·A þÛ%æ$U’2Á<̧î%ÿ›Lp?É$3µ¨ a•2~©SÚ8ËÉU»`"“è€û‚Ø^Þu©×kÒͺÍ<0å§K@Vç‘·ñÁÕa·3™JÂæboÒC¶9Yç±9é­õØN.+ê©È>ñkö)I8 ò^'H=D@ÃÄvQ10òÁ!€Çþü0dµýÍ>FÅ©Ïlá_e Ù Ÿb¤dG–iOY©}S­dºõÿ}ƒã}>³õÂ1t»KŒ[Í'aάrr]wšô”-µO„ˆ¥Ü"R_ŒUdÿÄ$7Ͻ½—¼Ñ4cµ¼ûŒuÒ,ÐfYdm_… \ZU·x8ðV‡ôÀŸûêó¶Áâ'•Œh»»„ªch#î‚>‚è¤ZHîãT·Á%³. Hšºw¸‘:Ã\cÞzÔÍ ’”éÐÝkn2´”ãë ¼µFõÄÌ0æe%DI#,'T@§a"ÙpNæ N1ÚâxŠÝP·#—„Ýxw ¥Þo ðkîÝG°šaÚ B”¶ZT Ò—uÚ/(§! àί ¬Ê<‘|¥J qP§‚ ¿ Tz&°ˆ² ½nE…xro¤SŠ:i¹ûFž°4GR`ïù˜K鱜I„åÌIº…p¤|Àóô' WÒƒÅvG±9,‚|>rÏ»Ùlò‹n†mLR©µ¹­¨ Co¹ Ôôº³Ö  U»Ö| ¦¬bFï\=šqd°‰º˜í3«¤ ‹`!äa_ÉkÊ E“T01‰ï)´¶ 媠óñ4¢ç†2ÊÒbÌ9jÓeM lMl£¸-C‹-îÛ yö_¹3ä…7»u2=-Й<3—…A7LÊØØò“RD C«d~N×{8V·%oEvÍcã}²Á’-S¸ª›A°lúnRûÊ#r±8%©•?”¹'g }_Êc:¡Ç§3ËQ{g ·]³Ì ôo›‹ú=¬‚[*Áx½Ýœ´òÃ+ÛdJ²,† à»ÅÆ‹¥§‹þQ-€Â+lb“:¯cA×·|Šêf4 o3¿-\(ôJ"?¤¤\> ëÌÔî½ãµÜ )2A …! ¤*äÊLü†$À;iqŽÇß(@0aªmoe…‚÷¬¿(ÁNŽTÅÞ÷aÈëj¾h“ç©©™©¼ülÇuªšÏ‰wËÇS? ž‘×°9¯p×}§"¹ÕÀE6›°óL$c²ùöNÏ7c˜—\®eS±Úî@ûcç1²« ””Q•ÞȤÞ4¶gvus—wƒ:lîªù¨ìñjqOg{ÆFš¯WjÏðÚ\Ü<ò èÄž­øÀ®©…ÎbÃ"¸cB(ñc…0¯óµŠfêESжԧás‹‰¤É!׊YˆÏÞÆØ}ƒ¯m·GÒ¹Ô°ðg#ÆÐ7­["Ÿ}n¶%™ µÑÿEIáç¯'N³§0ðu ‰ñµƒ#û/J"®Â˜AeŒ5w+W Ôدëÿ ÊS« —<##ùØrêA ƒs°7 Ÿ*ÆÅ 9ÚÆP2¡ô¹+»üSº‹Hså죸¥äÏ„Œ·¸NåñôÒŠX½ëûÕ´¨Î\M‘²$lG )v[zµ 1 :„<~Ê 9Ê\À 5Ø&Ù ŒBp& +EZ´ ‹dM ;D!‡ 8nv+F÷QÏ"'Ã|y"B6l^(MqÀX¡n{éE: 3äˆ5u~Wƒúœi6! } 4I 8RH‚>^±!’/JbŒ!ë”(ÐD©&`CDDˆjH¯C x6D4M DXJF8ðÎC,ØCPÀDȨ6DHCˆ6D°àDÔØOE„èOE¼OE˜OEÀè Dœ˜6D¬ DxøOEø D ¸ DÈ D|Ø D´è D¨Hgz€( DØ D8ÐÎC@ÏC¬ˆ¬FÈhoF€xoF¼ˆoF¤˜oFÌÀÎCì¨oFиoF˜ Dب D”ÈoFXØoF$èoFðøoFD(!Cx8!ClH!CDàÎC`h!C°x$CHˆ$C˜$CÀ¨$C„¸$CdÈ$CØ$C\è$C\ø$C\%Cl%Cl(%ClX!C¼P%C´`%C,p%CÈ0‚ðPÏCÔL LÌ°L(ÀL<ÐL¼àLðLMàM$ M00MT@MPMd`M pM$€MpMH M´°MÀM8%C€LpàMÄðMìNô@‚4P‚Ô`‚Ðp‚ø€‚Ô‚ÐMð ‚DÀ‚@Ђ à‚ ð‚d‚‚t ‚00‚ @‚ P‚à `‚0p‚t€‚‚  ‚°À‚°‚0Ø‚`è‚Àø‚T˜%C°‚`¸%CÄÈ%C¤Ø%C¬è%C¸ø%Cd&C`&C(&C(8&C¨%CH&CX&Chh&Cx&C$HJF$8JFŠ(JFŠJFFJFFàIF ÐIF ÀIFh6DFGHIJKLMNOëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDE±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄŨÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèé !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§©ª«¬­®¯°êPapyrus3/PapyGetGlobalVar3.c0000755000175000017500000002026510044204150013114 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyGetGlobalVar3.c */ /* Function : functions that will get some important vars. This file has */ /* been added to let the PCs compile DLL and still have access */ /* to global variables. */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifdef Mac #pragma segment papy3 #endif #ifndef Papyrus3H #include "Papyrus3.h" #endif /********************************************************************************/ /* */ /* Papy3GetFile : gets the file pointer (machine) of the file given */ /* its Papyrus reference number. */ /* */ /********************************************************************************/ PAPY_FILE CALLINGCONV Papy3GetFile (PapyShort inFileNb) { return gPapyFile [inFileNb]; } /********************************************************************************/ /* */ /* Papy3GetCurrTmpFilename : gets the current name (iteration) allocated */ /* to the temp file. */ /* */ /********************************************************************************/ int CALLINGCONV Papy3GetCurrTmpFilename (PapyShort inFileNb) { return gCurrTmpFilename [inFileNb]; } /********************************************************************************/ /* */ /* Papy3GetNbImages : gets the number of images of the given file. */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3GetNbImages (PapyShort inFileNb) { return gArrNbImages [inFileNb]; } /********************************************************************************/ /* */ /* Papy3GetTransfSyntax : gets the syntax used by the given file. */ /* */ /********************************************************************************/ enum ETransf_Syntax CALLINGCONV Papy3GetTransfSyntax (PapyShort inFileNb) { return gArrTransfSyntax [inFileNb]; } /********************************************************************************/ /* */ /* Papy3GetModality : gets the modality of the images of the given file. */ /* */ /********************************************************************************/ int CALLINGCONV Papy3GetModality (PapyShort inFileNb) { return gFileModality [inFileNb]; } /********************************************************************************/ /* */ /* Papy3GetNbElemInModule : gets the number of elements in the given module*/ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3GetNbElemInModule (int moduleId) { return gArrModule [moduleId]; } /********************************************************************************/ /* */ /* Papy3GetFileKind : gets the kind of file (0 = DICOM part 10 file, */ /* 1 = PAPYRUS 3.X file, 2 = DICOM non-part 10 file */ /* */ /********************************************************************************/ int CALLINGCONV Papy3GetFileKind (int inFileNb) { return gIsPapyFile [inFileNb]; } /********************************************************************************/ /* */ /* Papy3GetToolkitVersion : gets the current version of the toolkit */ /* */ /********************************************************************************/ char* CALLINGCONV Papy3GetToolkitVersion () { return gPapyrusVersion; } /********************************************************************************/ /* */ /* Papy3GetCompression : gets the compression algorithm used for the file */ /* */ /********************************************************************************/ enum EPap_Compression CALLINGCONV Papy3GetCompression (PapyShort inFileNb) { return gArrCompression [inFileNb]; } Papyrus3/PapyFileSystemPC3.c0000755000175000017500000002611310044202452013113 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyFileSystemPC3.c */ /* Function : contain specific reading/writing fcts for all kind */ /* of architecture */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ /* ------------------------- includes ----------------------------------------*/ #include #include #include #include /* open */ #include #include #include #ifdef _WINDOWS #include #endif #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PapyDef3.h" #endif #ifndef __PapyError3__ #include "PAPERR3.h" #endif #endif /********************************************************************************/ /* */ /* Papy3FCreate : overwrites the standard create file function */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FCreate (char *inFilenameP, PAPY_FILE inVolume, PAPY_FILE *inFp, void **inFSSpecP) { if ((*inFp = _open (inFilenameP, _O_RDONLY)) != -1) { (void) _close (*inFp); RETURN (papFileAlreadyExist); } if ((*inFp = _open (inFilenameP, _O_WRONLY | _O_CREAT | _O_BINARY, _S_IREAD | _S_IWRITE )) == -1) RETURN (papFileCreationFailed); (void) _close (*inFp); return 0; } /* endof Papy3FCreate */ /********************************************************************************/ /* */ /* Papy3FOpen : overwrites the standard open file function */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort Papy3FOpen (char *inFilenameP, char inPermission, PAPY_FILE inVolumeNb, PAPY_FILE *outFp, void *inFSSpecP) { long pos; switch (inPermission) { case 'r' : if ((*outFp = _open (inFilenameP, _O_RDONLY | _O_BINARY)) == -1) RETURN (papOpenFile); break; case 'w' : default : if ((*outFp = _open (inFilenameP, _O_WRONLY | _O_CREAT | _O_BINARY, _S_IREAD | _S_IWRITE)) == -1) RETURN (papOpenFile); break; } pos = _lseek(*outFp, 0L, SEEK_SET); if (pos == -1L) return -1; return 0; } /* endof Papy3FOpen */ /********************************************************************************/ /* */ /* Papy3FClose : overwrites the standard close file function */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FClose (PAPY_FILE *inFp) { _close (*inFp); return 0; } /* endof Papy3FClose */ /********************************************************************************/ /* */ /* Papy3FDelete : overwrites the standard delete file function */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FDelete (char *inFilenameP, void *inIdentifierP) { return (unlink ((char *) inFilenameP)); } /* endof Papy3FDelete */ /******************************************************************************/ /* */ /* Papy3FRead : rewrite the standard fread function */ /* return : the numbers of reading bytes */ /* */ /******************************************************************************/ PapyShort Papy3FRead (PAPY_FILE inFp, PapyULong *ioBytesToReadP, PapyULong inNb, void *ioBufferP) { unsigned int max_size = (unsigned int)*ioBytesToReadP * (unsigned int)inNb; int bytesRead = -1; if (max_size > 0) { bytesRead = _read (inFp, (void *)ioBufferP, max_size); if (bytesRead <= 0) return -1; } return 0; } /* endof Papy3FRead */ /******************************************************************************/ /* */ /* Papy3FWrite : rewrite the standard fwrite function */ /* return : the numbers of writing bytes */ /* */ /******************************************************************************/ PapyShort Papy3FWrite (PAPY_FILE inFp, PapyULong *ioBytesToWriteP, PapyULong inNb, void *outBufferP) { unsigned int max_size = (unsigned int)*ioBytesToWriteP * (unsigned int)inNb; int bytesWrite = -1; bytesWrite = _write (inFp, (const void *)outBufferP, max_size); if (bytesWrite < 0) return -1; return 0; } /* endof Papy3FWrite */ /********************************************************************************/ /* */ /* Papy3FTell : Papyrus function to get the current position of the file */ /* pointer. */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FTell (PAPY_FILE inFp, PapyLong *outFilePosP) { int err = 0; *outFilePosP = (long) _tell(inFp); if( *outFilePosP < 0 ) return -1; return err; } /* endof Papy3FTell */ /********************************************************************************/ /* */ /* Papy3FSeek : Papyrus own build file pointer positioning function. */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FSeek (PAPY_FILE inFp, int inPosMode, PapyLong inOffset) { PapyLong startPos, fileLimit; long err; /*if (inOffset == 0L) return 0;*/ if (inOffset > 100000L) { Papy3FTell (inFp, (PapyLong *) &startPos); /* get the end of file */ err = _lseek (inFp, 0L, SEEK_END); err = Papy3FTell (inFp, (PapyLong *) &fileLimit); if (inOffset > fileLimit) return -1; err = _lseek (inFp, (long) startPos, SEEK_SET); } if ((err = _lseek (inFp, (long) inOffset, inPosMode)) == -1L) return -1; return 0; } /* endof Papy3FSeek */ /********************************************************************************/ /* */ /* Papy3FPrint : Papyrus function to set a string. */ /* */ /* Ernesto Durante: remplacer wsprintf avec sprintf car les fichiers */ /* temporaires générés avaient un nom erroné qui empêchait la sauvegarde. */ /********************************************************************************/ void Papy3FPrint (char *inStringP, char *inFormatP, int inValue) { //wsprintf (inStringP, inFormatP, inValue); sprintf (inStringP, inFormatP, inValue); } /* endof Papy3FPrint */ Papyrus3/JpegDir/0000777000175000017500000000000010076701542011056 5ustar Papyrus3/JpegDir/.DS_Store0000777000175000017500000001400410076701542012543 0ustar Bud1 right Copyright JPEG losslessIlocblobP'ÿÿÿÿÿÿCopyright JPEG lossyIlocblobð'ÿÿÿÿÿÿJpgLlessIlocblobPŒÿÿÿÿÿÿJpgLlessdsclboolJpgLossyIlocblobðŒÿÿÿÿÿÿJpgLossydsclbool  @€ @€ @€ @ E DSDB `€ @€ @€ @Papyrus3/JpegDir/JPEG_lossy_modif.rtf0000644000175000017500000000111310035011712014703 0ustar {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \paperw11900\paperh16840\margl1440\margr1440\vieww9660\viewh15200\viewkind0 \pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\ql\qnatural \f0\fs24 \cf0 This library, made by the Independant Group's JPEG software has been modified by the Digital Imaging Unit of the Service of Medical informatics, University Hospitals of Geneva, Switzerland.\ \ The modifications are regarding the file and memory systems.\ \ Geneva, April 2004\ }Papyrus3/JpegDir/JpgLossy/0000777000175000017500000000000010047674414012635 5ustar Papyrus3/JpegDir/JpgLossy/JUTILS.C0000755000175000017500000001245307535143454013762 0ustar /* * jutils.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains tables and miscellaneous utility routines needed * for both compression and decompression. * Note we prefix all global names with "j" to minimize conflicts with * a surrounding application. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element * of a DCT block read in natural order (left to right, top to bottom). */ #if 0 /* This table is not actually needed in v6a */ const int jpeg_zigzag_order[DCTSIZE2] = { 0, 1, 5, 6, 14, 15, 27, 28, 2, 4, 7, 13, 16, 26, 29, 42, 3, 8, 12, 17, 25, 30, 41, 43, 9, 11, 18, 24, 31, 40, 44, 53, 10, 19, 23, 32, 39, 45, 52, 54, 20, 22, 33, 38, 46, 51, 55, 60, 21, 34, 37, 47, 50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63 }; #endif /* * jpeg_natural_order[i] is the natural-order position of the i'th element * of zigzag order. * * When reading corrupted data, the Huffman decoders could attempt * to reference an entry beyond the end of this array (if the decoded * zero run length reaches past the end of the block). To prevent * wild stores without adding an inner-loop test, we put some extra * "63"s after the real entries. This will cause the extra coefficient * to be stored in location 63 of the block, not somewhere random. * The worst case would be a run-length of 15, which means we need 16 * fake entries. */ const int jpeg_natural_order[DCTSIZE2+16] = { 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63, 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */ 63, 63, 63, 63, 63, 63, 63, 63 }; /* * Arithmetic utilities */ GLOBAL(long) jdiv_round_up (long a, long b) /* Compute a/b rounded up to next integer, ie, ceil(a/b) */ /* Assumes a >= 0, b > 0 */ { return (a + b - 1L) / b; } GLOBAL(long) jround_up (long a, long b) /* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */ /* Assumes a >= 0, b > 0 */ { a += b - 1L; return a - (a % b); } /* On normal machines we can apply MEMCOPY() and MEMZERO() to sample arrays * and coefficient-block arrays. This won't work on 80x86 because the arrays * are FAR and we're assuming a small-pointer memory model. However, some * DOS compilers provide far-pointer versions of memcpy() and memset() even * in the small-model libraries. These will be used if USE_FMEM is defined. * Otherwise, the routines below do it the hard way. (The performance cost * is not all that great, because these routines aren't very heavily used.) */ #ifndef NEED_FAR_POINTERS /* normal case, same as regular macros */ #define FMEMCOPY(dest,src,size) MEMCOPY(dest,src,size) #define FMEMZERO(target,size) MEMZERO(target,size) #else /* 80x86 case, define if we can */ #ifdef USE_FMEM #define FMEMCOPY(dest,src,size) _fmemcpy((void FAR *)(dest), (const void FAR *)(src), (size_t)(size)) #define FMEMZERO(target,size) _fmemset((void FAR *)(target), 0, (size_t)(size)) #endif #endif GLOBAL(void) jcopy_sample_rows (JSAMPARRAY input_array, int source_row, JSAMPARRAY output_array, int dest_row, int num_rows, JDIMENSION num_cols) /* Copy some rows of samples from one place to another. * num_rows rows are copied from input_array[source_row++] * to output_array[dest_row++]; these areas may overlap for duplication. * The source and destination arrays must be at least as wide as num_cols. */ { register JSAMPROW inptr, outptr; #ifdef FMEMCOPY register size_t count = (size_t) (num_cols * SIZEOF(JSAMPLE)); #else register JDIMENSION count; #endif register int row; input_array += source_row; output_array += dest_row; for (row = num_rows; row > 0; row--) { inptr = *input_array++; outptr = *output_array++; #ifdef FMEMCOPY FMEMCOPY(outptr, inptr, count); #else for (count = num_cols; count > 0; count--) *outptr++ = *inptr++; /* needn't bother with GETJSAMPLE() here */ #endif } } GLOBAL(void) jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row, JDIMENSION num_blocks) /* Copy a row of coefficient blocks from one place to another. */ { #ifdef FMEMCOPY FMEMCOPY(output_row, input_row, num_blocks * (DCTSIZE2 * SIZEOF(JCOEF))); #else register JCOEFPTR inptr, outptr; register long count; inptr = (JCOEFPTR) input_row; outptr = (JCOEFPTR) output_row; for (count = (long) num_blocks * DCTSIZE2; count > 0; count--) { *outptr++ = *inptr++; } #endif } GLOBAL(void) jzero_far (void FAR * target, size_t bytestozero) /* Zero out a chunk of FAR memory. */ /* This might be sample-array data, block-array data, or alloc_large data. */ { #ifdef FMEMZERO FMEMZERO(target, bytestozero); #else register char FAR * ptr = (char FAR *) target; register size_t count; for (count = bytestozero; count > 0; count--) { *ptr++ = 0; } #endif } Papyrus3/JpegDir/JpgLossy/readme0000755000175000017500000004755207535143454014034 0ustar The Independent JPEG Group's JPEG software ========================================== README for release 6b of 27-Mar-1998 ==================================== This distribution contains the sixth public release of the Independent JPEG Group's free JPEG software. You are welcome to redistribute this software and to use it for any purpose, subject to the conditions under LEGAL ISSUES, below. Serious users of this software (particularly those incorporating it into larger programs) should contact IJG at jpeg-info@uunet.uu.net to be added to our electronic mailing list. Mailing list members are notified of updates and have a chance to participate in technical discussions, etc. This software is the work of Tom Lane, Philip Gladstone, Jim Boucher, Lee Crocker, Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi, Guido Vollbeding, Ge' Weijers, and other members of the Independent JPEG Group. IJG is not affiliated with the official ISO JPEG standards committee. DOCUMENTATION ROADMAP ===================== This file contains the following sections: OVERVIEW General description of JPEG and the IJG software. LEGAL ISSUES Copyright, lack of warranty, terms of distribution. REFERENCES Where to learn more about JPEG. ARCHIVE LOCATIONS Where to find newer versions of this software. RELATED SOFTWARE Other stuff you should get. FILE FORMAT WARS Software *not* to get. TO DO Plans for future IJG releases. Other documentation files in the distribution are: User documentation: install.doc How to configure and install the IJG software. usage.doc Usage instructions for cjpeg, djpeg, jpegtran, rdjpgcom, and wrjpgcom. *.1 Unix-style man pages for programs (same info as usage.doc). wizard.doc Advanced usage instructions for JPEG wizards only. change.log Version-to-version change highlights. Programmer and internal documentation: libjpeg.doc How to use the JPEG library in your own programs. example.c Sample code for calling the JPEG library. structure.doc Overview of the JPEG library's internal structure. filelist.doc Road map of IJG files. coderules.doc Coding style rules --- please read if you contribute code. Please read at least the files install.doc and usage.doc. Useful information can also be found in the JPEG FAQ (Frequently Asked Questions) article. See ARCHIVE LOCATIONS below to find out where to obtain the FAQ article. If you want to understand how the JPEG code works, we suggest reading one or more of the REFERENCES, then looking at the documentation files (in roughly the order listed) before diving into the code. OVERVIEW ======== This package contains C software to implement JPEG image compression and decompression. JPEG (pronounced "jay-peg") is a standardized compression method for full-color and gray-scale images. JPEG is intended for compressing "real-world" scenes; line drawings, cartoons and other non-realistic images are not its strong suit. JPEG is lossy, meaning that the output image is not exactly identical to the input image. Hence you must not use JPEG if you have to have identical output bits. However, on typical photographic images, very good compression levels can be obtained with no visible change, and remarkably high compression levels are possible if you can tolerate a low-quality image. For more details, see the references, or just experiment with various compression settings. This software implements JPEG baseline, extended-sequential, and progressive compression processes. Provision is made for supporting all variants of these processes, although some uncommon parameter settings aren't implemented yet. For legal reasons, we are not distributing code for the arithmetic-coding variants of JPEG; see LEGAL ISSUES. We have made no provision for supporting the hierarchical or lossless processes defined in the standard. We provide a set of library routines for reading and writing JPEG image files, plus two sample applications "cjpeg" and "djpeg", which use the library to perform conversion between JPEG and some other popular image file formats. The library is intended to be reused in other applications. In order to support file conversion and viewing software, we have included considerable functionality beyond the bare JPEG coding/decoding capability; for example, the color quantization modules are not strictly part of JPEG decoding, but they are essential for output to colormapped file formats or colormapped displays. These extra functions can be compiled out of the library if not required for a particular application. We have also included "jpegtran", a utility for lossless transcoding between different JPEG processes, and "rdjpgcom" and "wrjpgcom", two simple applications for inserting and extracting textual comments in JFIF files. The emphasis in designing this software has been on achieving portability and flexibility, while also making it fast enough to be useful. In particular, the software is not intended to be read as a tutorial on JPEG. (See the REFERENCES section for introductory material.) Rather, it is intended to be reliable, portable, industrial-strength code. We do not claim to have achieved that goal in every aspect of the software, but we strive for it. We welcome the use of this software as a component of commercial products. No royalty is required, but we do ask for an acknowledgement in product documentation, as described under LEGAL ISSUES. LEGAL ISSUES ============ In plain English: 1. We don't promise that this software works. (But if you find any bugs, please let us know!) 2. You can use this software for whatever you want. You don't have to pay us. 3. You may not pretend that you wrote this software. If you use it in a program, you must acknowledge somewhere in your documentation that you've used the IJG code. In legalese: The authors make NO WARRANTY or representation, either express or implied, with respect to this software, its quality, accuracy, merchantability, or fitness for a particular purpose. This software is provided "AS IS", and you, its user, assume the entire risk as to its quality and accuracy. This software is copyright (C) 1991-1998, Thomas G. Lane. All Rights Reserved except as specified below. Permission is hereby granted to use, copy, modify, and distribute this software (or portions thereof) for any purpose, without fee, subject to these conditions: (1) If any part of the source code for this software is distributed, then this README file must be included, with this copyright and no-warranty notice unaltered; and any additions, deletions, or changes to the original files must be clearly indicated in accompanying documentation. (2) If only executable code is distributed, then the accompanying documentation must state that "this software is based in part on the work of the Independent JPEG Group". (3) Permission for use of this software is granted only if the user accepts full responsibility for any undesirable consequences; the authors accept NO LIABILITY for damages of any kind. These conditions apply to any software derived from or based on the IJG code, not just to the unmodified library. If you use our work, you ought to acknowledge us. Permission is NOT granted for the use of any IJG author's name or company name in advertising or publicity relating to this software or products derived from it. This software may be referred to only as "the Independent JPEG Group's software". We specifically permit and encourage the use of this software as the basis of commercial products, provided that all warranty or liability claims are assumed by the product vendor. ansi2knr.c is included in this distribution by permission of L. Peter Deutsch, sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA. ansi2knr.c is NOT covered by the above copyright and conditions, but instead by the usual distribution terms of the Free Software Foundation; principally, that you must include source code if you redistribute it. (See the file ansi2knr.c for full details.) However, since ansi2knr.c is not needed as part of any program generated from the IJG code, this does not limit you more than the foregoing paragraphs do. The Unix configuration script "configure" was produced with GNU Autoconf. It is copyright by the Free Software Foundation but is freely distributable. The same holds for its supporting scripts (config.guess, config.sub, ltconfig, ltmain.sh). Another support script, install-sh, is copyright by M.I.T. but is also freely distributable. It appears that the arithmetic coding option of the JPEG spec is covered by patents owned by IBM, AT&T, and Mitsubishi. Hence arithmetic coding cannot legally be used without obtaining one or more licenses. For this reason, support for arithmetic coding has been removed from the free JPEG software. (Since arithmetic coding provides only a marginal gain over the unpatented Huffman mode, it is unlikely that very many implementations will support it.) So far as we are aware, there are no patent restrictions on the remaining code. The IJG distribution formerly included code to read and write GIF files. To avoid entanglement with the Unisys LZW patent, GIF reading support has been removed altogether, and the GIF writer has been simplified to produce "uncompressed GIFs". This technique does not use the LZW algorithm; the resulting GIF files are larger than usual, but are readable by all standard GIF decoders. We are required to state that "The Graphics Interchange Format(c) is the Copyright property of CompuServe Incorporated. GIF(sm) is a Service Mark property of CompuServe Incorporated." REFERENCES ========== We highly recommend reading one or more of these references before trying to understand the innards of the JPEG software. The best short technical introduction to the JPEG compression algorithm is Wallace, Gregory K. "The JPEG Still Picture Compression Standard", Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44. (Adjacent articles in that issue discuss MPEG motion picture compression, applications of JPEG, and related topics.) If you don't have the CACM issue handy, a PostScript file containing a revised version of Wallace's article is available at ftp://ftp.uu.net/graphics/jpeg/wallace.ps.gz. The file (actually a preprint for an article that appeared in IEEE Trans. Consumer Electronics) omits the sample images that appeared in CACM, but it includes corrections and some added material. Note: the Wallace article is copyright ACM and IEEE, and it may not be used for commercial purposes. A somewhat less technical, more leisurely introduction to JPEG can be found in "The Data Compression Book" by Mark Nelson and Jean-loup Gailly, published by M&T Books (New York), 2nd ed. 1996, ISBN 1-55851-434-1. This book provides good explanations and example C code for a multitude of compression methods including JPEG. It is an excellent source if you are comfortable reading C code but don't know much about data compression in general. The book's JPEG sample code is far from industrial-strength, but when you are ready to look at a full implementation, you've got one here... The best full description of JPEG is the textbook "JPEG Still Image Data Compression Standard" by William B. Pennebaker and Joan L. Mitchell, published by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1. Price US$59.95, 638 pp. The book includes the complete text of the ISO JPEG standards (DIS 10918-1 and draft DIS 10918-2). This is by far the most complete exposition of JPEG in existence, and we highly recommend it. The JPEG standard itself is not available electronically; you must order a paper copy through ISO or ITU. (Unless you feel a need to own a certified official copy, we recommend buying the Pennebaker and Mitchell book instead; it's much cheaper and includes a great deal of useful explanatory material.) In the USA, copies of the standard may be ordered from ANSI Sales at (212) 642-4900, or from Global Engineering Documents at (800) 854-7179. (ANSI doesn't take credit card orders, but Global does.) It's not cheap: as of 1992, ANSI was charging $95 for Part 1 and $47 for Part 2, plus 7% shipping/handling. The standard is divided into two parts, Part 1 being the actual specification, while Part 2 covers compliance testing methods. Part 1 is titled "Digital Compression and Coding of Continuous-tone Still Images, Part 1: Requirements and guidelines" and has document numbers ISO/IEC IS 10918-1, ITU-T T.81. Part 2 is titled "Digital Compression and Coding of Continuous-tone Still Images, Part 2: Compliance testing" and has document numbers ISO/IEC IS 10918-2, ITU-T T.83. Some extensions to the original JPEG standard are defined in JPEG Part 3, a newer ISO standard numbered ISO/IEC IS 10918-3 and ITU-T T.84. IJG currently does not support any Part 3 extensions. The JPEG standard does not specify all details of an interchangeable file format. For the omitted details we follow the "JFIF" conventions, revision 1.02. A copy of the JFIF spec is available from: Literature Department C-Cube Microsystems, Inc. 1778 McCarthy Blvd. Milpitas, CA 95035 phone (408) 944-6300, fax (408) 944-6314 A PostScript version of this document is available by FTP at ftp://ftp.uu.net/graphics/jpeg/jfif.ps.gz. There is also a plain text version at ftp://ftp.uu.net/graphics/jpeg/jfif.txt.gz, but it is missing the figures. The TIFF 6.0 file format specification can be obtained by FTP from ftp://ftp.sgi.com/graphics/tiff/TIFF6.ps.gz. The JPEG incorporation scheme found in the TIFF 6.0 spec of 3-June-92 has a number of serious problems. IJG does not recommend use of the TIFF 6.0 design (TIFF Compression tag 6). Instead, we recommend the JPEG design proposed by TIFF Technical Note #2 (Compression tag 7). Copies of this Note can be obtained from ftp.sgi.com or from ftp://ftp.uu.net/graphics/jpeg/. It is expected that the next revision of the TIFF spec will replace the 6.0 JPEG design with the Note's design. Although IJG's own code does not support TIFF/JPEG, the free libtiff library uses our library to implement TIFF/JPEG per the Note. libtiff is available from ftp://ftp.sgi.com/graphics/tiff/. ARCHIVE LOCATIONS ================= The "official" archive site for this software is ftp.uu.net (Internet address 192.48.96.9). The most recent released version can always be found there in directory graphics/jpeg. This particular version will be archived as ftp://ftp.uu.net/graphics/jpeg/jpegsrc.v6b.tar.gz. If you don't have direct Internet access, UUNET's archives are also available via UUCP; contact help@uunet.uu.net for information on retrieving files that way. Numerous Internet sites maintain copies of the UUNET files. However, only ftp.uu.net is guaranteed to have the latest official version. You can also obtain this software in DOS-compatible "zip" archive format from the SimTel archives (ftp://ftp.simtel.net/pub/simtelnet/msdos/graphics/), or on CompuServe in the Graphics Support forum (GO CIS:GRAPHSUP), library 12 "JPEG Tools". Again, these versions may sometimes lag behind the ftp.uu.net release. The JPEG FAQ (Frequently Asked Questions) article is a useful source of general information about JPEG. It is updated constantly and therefore is not included in this distribution. The FAQ is posted every two weeks to Usenet newsgroups comp.graphics.misc, news.answers, and other groups. It is available on the World Wide Web at http://www.faqs.org/faqs/jpeg-faq/ and other news.answers archive sites, including the official news.answers archive at rtfm.mit.edu: ftp://rtfm.mit.edu/pub/usenet/news.answers/jpeg-faq/. If you don't have Web or FTP access, send e-mail to mail-server@rtfm.mit.edu with body send usenet/news.answers/jpeg-faq/part1 send usenet/news.answers/jpeg-faq/part2 RELATED SOFTWARE ================ Numerous viewing and image manipulation programs now support JPEG. (Quite a few of them use this library to do so.) The JPEG FAQ described above lists some of the more popular free and shareware viewers, and tells where to obtain them on Internet. If you are on a Unix machine, we highly recommend Jef Poskanzer's free PBMPLUS software, which provides many useful operations on PPM-format image files. In particular, it can convert PPM images to and from a wide range of other formats, thus making cjpeg/djpeg considerably more useful. The latest version is distributed by the NetPBM group, and is available from numerous sites, notably ftp://wuarchive.wustl.edu/graphics/graphics/packages/NetPBM/. Unfortunately PBMPLUS/NETPBM is not nearly as portable as the IJG software is; you are likely to have difficulty making it work on any non-Unix machine. A different free JPEG implementation, written by the PVRG group at Stanford, is available from ftp://havefun.stanford.edu/pub/jpeg/. This program is designed for research and experimentation rather than production use; it is slower, harder to use, and less portable than the IJG code, but it is easier to read and modify. Also, the PVRG code supports lossless JPEG, which we do not. (On the other hand, it doesn't do progressive JPEG.) FILE FORMAT WARS ================ Some JPEG programs produce files that are not compatible with our library. The root of the problem is that the ISO JPEG committee failed to specify a concrete file format. Some vendors "filled in the blanks" on their own, creating proprietary formats that no one else could read. (For example, none of the early commercial JPEG implementations for the Macintosh were able to exchange compressed files.) The file format we have adopted is called JFIF (see REFERENCES). This format has been agreed to by a number of major commercial JPEG vendors, and it has become the de facto standard. JFIF is a minimal or "low end" representation. We recommend the use of TIFF/JPEG (TIFF revision 6.0 as modified by TIFF Technical Note #2) for "high end" applications that need to record a lot of additional data about an image. TIFF/JPEG is fairly new and not yet widely supported, unfortunately. The upcoming JPEG Part 3 standard defines a file format called SPIFF. SPIFF is interoperable with JFIF, in the sense that most JFIF decoders should be able to read the most common variant of SPIFF. SPIFF has some technical advantages over JFIF, but its major claim to fame is simply that it is an official standard rather than an informal one. At this point it is unclear whether SPIFF will supersede JFIF or whether JFIF will remain the de-facto standard. IJG intends to support SPIFF once the standard is frozen, but we have not decided whether it should become our default output format or not. (In any case, our decoder will remain capable of reading JFIF indefinitely.) Various proprietary file formats incorporating JPEG compression also exist. We have little or no sympathy for the existence of these formats. Indeed, one of the original reasons for developing this free software was to help force convergence on common, open format standards for JPEG files. Don't use a proprietary file format! TO DO ===== The major thrust for v7 will probably be improvement of visual quality. The current method for scaling the quantization tables is known not to be very good at low Q values. We also intend to investigate block boundary smoothing, "poor man's variable quantization", and other means of improving quality-vs-file-size performance without sacrificing compatibility. In future versions, we are considering supporting some of the upcoming JPEG Part 3 extensions --- principally, variable quantization and the SPIFF file format. As always, speeding things up is of great interest. Please send bug reports, offers of help, etc. to jpeg-info@uunet.uu.net. Papyrus3/JpegDir/JpgLossy/JDMASTER.C0000755000175000017500000004745307535143454014171 0ustar /* * jdmaster.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains master control logic for the JPEG decompressor. * These routines are concerned with selecting the modules to be executed * and with determining the number of passes and the work to be done in each * pass. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* Private state */ typedef struct { struct jpeg_decomp_master pub; /* public fields */ int pass_number; /* # of passes completed */ boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */ /* Saved references to initialized quantizer modules, * in case we need to switch modes. */ struct jpeg_color_quantizer * quantizer_1pass; struct jpeg_color_quantizer * quantizer_2pass; } my_decomp_master; typedef my_decomp_master * my_master_ptr; /* * Determine whether merged upsample/color conversion should be used. * CRUCIAL: this must match the actual capabilities of jdmerge.c! */ LOCAL(boolean) use_merged_upsample (j_decompress_ptr cinfo) { #ifdef UPSAMPLE_MERGING_SUPPORTED /* Merging is the equivalent of plain box-filter upsampling */ if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling) return FALSE; /* jdmerge.c only supports YCC=>RGB color conversion */ if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 || cinfo->out_color_space != JCS_RGB || cinfo->out_color_components != RGB_PIXELSIZE) return FALSE; /* and it only handles 2h1v or 2h2v sampling ratios */ if (cinfo->comp_info[0].h_samp_factor != 2 || cinfo->comp_info[1].h_samp_factor != 1 || cinfo->comp_info[2].h_samp_factor != 1 || cinfo->comp_info[0].v_samp_factor > 2 || cinfo->comp_info[1].v_samp_factor != 1 || cinfo->comp_info[2].v_samp_factor != 1) return FALSE; /* furthermore, it doesn't work if we've scaled the IDCTs differently */ if (cinfo->comp_info[0].DCT_scaled_size != cinfo->min_DCT_scaled_size || cinfo->comp_info[1].DCT_scaled_size != cinfo->min_DCT_scaled_size || cinfo->comp_info[2].DCT_scaled_size != cinfo->min_DCT_scaled_size) return FALSE; /* ??? also need to test for upsample-time rescaling, when & if supported */ return TRUE; /* by golly, it'll work... */ #else return FALSE; #endif } /* * Compute output image dimensions and related values. * NOTE: this is exported for possible use by application. * Hence it mustn't do anything that can't be done twice. * Also note that it may be called before the master module is initialized! */ GLOBAL(void) jpeg_calc_output_dimensions (j_decompress_ptr cinfo) /* Do computations that are needed before master selection phase */ { #ifdef IDCT_SCALING_SUPPORTED int ci; jpeg_component_info *compptr; #endif /* Prevent application from calling me at wrong times */ if (cinfo->global_state != DSTATE_READY) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); #ifdef IDCT_SCALING_SUPPORTED /* Compute actual output image dimensions and DCT scaling choices. */ if (cinfo->scale_num * 8 <= cinfo->scale_denom) { /* Provide 1/8 scaling */ cinfo->output_width = (JDIMENSION) jdiv_round_up((long) cinfo->image_width, 8L); cinfo->output_height = (JDIMENSION) jdiv_round_up((long) cinfo->image_height, 8L); cinfo->min_DCT_scaled_size = 1; } else if (cinfo->scale_num * 4 <= cinfo->scale_denom) { /* Provide 1/4 scaling */ cinfo->output_width = (JDIMENSION) jdiv_round_up((long) cinfo->image_width, 4L); cinfo->output_height = (JDIMENSION) jdiv_round_up((long) cinfo->image_height, 4L); cinfo->min_DCT_scaled_size = 2; } else if (cinfo->scale_num * 2 <= cinfo->scale_denom) { /* Provide 1/2 scaling */ cinfo->output_width = (JDIMENSION) jdiv_round_up((long) cinfo->image_width, 2L); cinfo->output_height = (JDIMENSION) jdiv_round_up((long) cinfo->image_height, 2L); cinfo->min_DCT_scaled_size = 4; } else { /* Provide 1/1 scaling */ cinfo->output_width = cinfo->image_width; cinfo->output_height = cinfo->image_height; cinfo->min_DCT_scaled_size = DCTSIZE; } /* In selecting the actual DCT scaling for each component, we try to * scale up the chroma components via IDCT scaling rather than upsampling. * This saves time if the upsampler gets to use 1:1 scaling. * Note this code assumes that the supported DCT scalings are powers of 2. */ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { int ssize = cinfo->min_DCT_scaled_size; while (ssize < DCTSIZE && (compptr->h_samp_factor * ssize * 2 <= cinfo->max_h_samp_factor * cinfo->min_DCT_scaled_size) && (compptr->v_samp_factor * ssize * 2 <= cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size)) { ssize = ssize * 2; } compptr->DCT_scaled_size = ssize; } /* Recompute downsampled dimensions of components; * application needs to know these if using raw downsampled data. */ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { /* Size in samples, after IDCT scaling */ compptr->downsampled_width = (JDIMENSION) jdiv_round_up((long) cinfo->image_width * (long) (compptr->h_samp_factor * compptr->DCT_scaled_size), (long) (cinfo->max_h_samp_factor * DCTSIZE)); compptr->downsampled_height = (JDIMENSION) jdiv_round_up((long) cinfo->image_height * (long) (compptr->v_samp_factor * compptr->DCT_scaled_size), (long) (cinfo->max_v_samp_factor * DCTSIZE)); } #else /* !IDCT_SCALING_SUPPORTED */ /* Hardwire it to "no scaling" */ cinfo->output_width = cinfo->image_width; cinfo->output_height = cinfo->image_height; /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE, * and has computed unscaled downsampled_width and downsampled_height. */ #endif /* IDCT_SCALING_SUPPORTED */ /* Report number of components in selected colorspace. */ /* Probably this should be in the color conversion module... */ switch (cinfo->out_color_space) { case JCS_GRAYSCALE: cinfo->out_color_components = 1; break; case JCS_RGB: #if RGB_PIXELSIZE != 3 cinfo->out_color_components = RGB_PIXELSIZE; break; #endif /* else share code with YCbCr */ case JCS_YCbCr: cinfo->out_color_components = 3; break; case JCS_CMYK: case JCS_YCCK: cinfo->out_color_components = 4; break; default: /* else must be same colorspace as in file */ cinfo->out_color_components = cinfo->num_components; break; } cinfo->output_components = (cinfo->quantize_colors ? 1 : cinfo->out_color_components); /* See if upsampler will want to emit more than one row at a time */ if (use_merged_upsample(cinfo)) cinfo->rec_outbuf_height = cinfo->max_v_samp_factor; else cinfo->rec_outbuf_height = 1; } /* * Several decompression processes need to range-limit values to the range * 0..MAXJSAMPLE; the input value may fall somewhat outside this range * due to noise introduced by quantization, roundoff error, etc. These * processes are inner loops and need to be as fast as possible. On most * machines, particularly CPUs with pipelines or instruction prefetch, * a (subscript-check-less) C table lookup * x = sample_range_limit[x]; * is faster than explicit tests * if (x < 0) x = 0; * else if (x > MAXJSAMPLE) x = MAXJSAMPLE; * These processes all use a common table prepared by the routine below. * * For most steps we can mathematically guarantee that the initial value * of x is within MAXJSAMPLE+1 of the legal range, so a table running from * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient. But for the initial * limiting step (just after the IDCT), a wildly out-of-range value is * possible if the input data is corrupt. To avoid any chance of indexing * off the end of memory and getting a bad-pointer trap, we perform the * post-IDCT limiting thus: * x = range_limit[x & MASK]; * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit * samples. Under normal circumstances this is more than enough range and * a correct output will be generated; with bogus input data the mask will * cause wraparound, and we will safely generate a bogus-but-in-range output. * For the post-IDCT step, we want to convert the data from signed to unsigned * representation by adding CENTERJSAMPLE at the same time that we limit it. * So the post-IDCT limiting table ends up looking like this: * CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE, * MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times), * 0 (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times), * 0,1,...,CENTERJSAMPLE-1 * Negative inputs select values from the upper half of the table after * masking. * * We can save some space by overlapping the start of the post-IDCT table * with the simpler range limiting table. The post-IDCT table begins at * sample_range_limit + CENTERJSAMPLE. * * Note that the table is allocated in near data space on PCs; it's small * enough and used often enough to justify this. */ LOCAL(void) prepare_range_limit_table (j_decompress_ptr cinfo) /* Allocate and fill in the sample_range_limit table */ { JSAMPLE * table; int i; table = (JSAMPLE *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (5 * (MAXJSAMPLE+1) + CENTERJSAMPLE) * SIZEOF(JSAMPLE)); table += (MAXJSAMPLE+1); /* allow negative subscripts of simple table */ cinfo->sample_range_limit = table; /* First segment of "simple" table: limit[x] = 0 for x < 0 */ MEMZERO(table - (MAXJSAMPLE+1), (MAXJSAMPLE+1) * SIZEOF(JSAMPLE)); /* Main part of "simple" table: limit[x] = x */ for (i = 0; i <= MAXJSAMPLE; i++) table[i] = (JSAMPLE) i; table += CENTERJSAMPLE; /* Point to where post-IDCT table starts */ /* End of simple table, rest of first half of post-IDCT table */ for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++) table[i] = MAXJSAMPLE; /* Second half of post-IDCT table */ MEMZERO(table + (2 * (MAXJSAMPLE+1)), (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE) * SIZEOF(JSAMPLE)); MEMCOPY(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE), cinfo->sample_range_limit, CENTERJSAMPLE * SIZEOF(JSAMPLE)); } /* * Master selection of decompression modules. * This is done once at jpeg_start_decompress time. We determine * which modules will be used and give them appropriate initialization calls. * We also initialize the decompressor input side to begin consuming data. * * Since jpeg_read_header has finished, we know what is in the SOF * and (first) SOS markers. We also have all the application parameter * settings. */ LOCAL(void) master_selection (j_decompress_ptr cinfo) { my_master_ptr master = (my_master_ptr) cinfo->master; boolean use_c_buffer; long samplesperrow; JDIMENSION jd_samplesperrow; /* Initialize dimensions and other stuff */ jpeg_calc_output_dimensions(cinfo); prepare_range_limit_table(cinfo); /* Width of an output scanline must be representable as JDIMENSION. */ samplesperrow = (long) cinfo->output_width * (long) cinfo->out_color_components; jd_samplesperrow = (JDIMENSION) samplesperrow; if ((long) jd_samplesperrow != samplesperrow) ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); /* Initialize my private state */ master->pass_number = 0; master->using_merged_upsample = use_merged_upsample(cinfo); /* Color quantizer selection */ master->quantizer_1pass = NULL; master->quantizer_2pass = NULL; /* No mode changes if not using buffered-image mode. */ if (! cinfo->quantize_colors || ! cinfo->buffered_image) { cinfo->enable_1pass_quant = FALSE; cinfo->enable_external_quant = FALSE; cinfo->enable_2pass_quant = FALSE; } if (cinfo->quantize_colors) { if (cinfo->raw_data_out) ERREXIT(cinfo, JERR_NOTIMPL); /* 2-pass quantizer only works in 3-component color space. */ if (cinfo->out_color_components != 3) { cinfo->enable_1pass_quant = TRUE; cinfo->enable_external_quant = FALSE; cinfo->enable_2pass_quant = FALSE; cinfo->colormap = NULL; } else if (cinfo->colormap != NULL) { cinfo->enable_external_quant = TRUE; } else if (cinfo->two_pass_quantize) { cinfo->enable_2pass_quant = TRUE; } else { cinfo->enable_1pass_quant = TRUE; } if (cinfo->enable_1pass_quant) { #ifdef QUANT_1PASS_SUPPORTED jinit_1pass_quantizer(cinfo); master->quantizer_1pass = cinfo->cquantize; #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } /* We use the 2-pass code to map to external colormaps. */ if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) { #ifdef QUANT_2PASS_SUPPORTED jinit_2pass_quantizer(cinfo); master->quantizer_2pass = cinfo->cquantize; #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } /* If both quantizers are initialized, the 2-pass one is left active; * this is necessary for starting with quantization to an external map. */ } /* Post-processing: in particular, color conversion first */ if (! cinfo->raw_data_out) { if (master->using_merged_upsample) { #ifdef UPSAMPLE_MERGING_SUPPORTED jinit_merged_upsampler(cinfo); /* does color conversion too */ #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } else { jinit_color_deconverter(cinfo); jinit_upsampler(cinfo); } jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant); } /* Inverse DCT */ jinit_inverse_dct(cinfo); /* Entropy decoding: either Huffman or arithmetic coding. */ if (cinfo->arith_code) { ERREXIT(cinfo, JERR_ARITH_NOTIMPL); } else { if (cinfo->progressive_mode) { #ifdef D_PROGRESSIVE_SUPPORTED jinit_phuff_decoder(cinfo); #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } else jinit_huff_decoder(cinfo); } /* Initialize principal buffer controllers. */ use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image; jinit_d_coef_controller(cinfo, use_c_buffer); if (! cinfo->raw_data_out) jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */); /* We can now tell the memory manager to allocate virtual arrays. */ (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo); /* Initialize input side of decompressor to consume first scan. */ (*cinfo->inputctl->start_input_pass) (cinfo); #ifdef D_MULTISCAN_FILES_SUPPORTED /* If jpeg_start_decompress will read the whole file, initialize * progress monitoring appropriately. The input step is counted * as one pass. */ if (cinfo->progress != NULL && ! cinfo->buffered_image && cinfo->inputctl->has_multiple_scans) { int nscans; /* Estimate number of scans to set pass_limit. */ if (cinfo->progressive_mode) { /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */ nscans = 2 + 3 * cinfo->num_components; } else { /* For a nonprogressive multiscan file, estimate 1 scan per component. */ nscans = cinfo->num_components; } cinfo->progress->pass_counter = 0L; cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans; cinfo->progress->completed_passes = 0; cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2); /* Count the input pass as done */ master->pass_number++; } #endif /* D_MULTISCAN_FILES_SUPPORTED */ } /* * Per-pass setup. * This is called at the beginning of each output pass. We determine which * modules will be active during this pass and give them appropriate * start_pass calls. We also set is_dummy_pass to indicate whether this * is a "real" output pass or a dummy pass for color quantization. * (In the latter case, jdapistd.c will crank the pass to completion.) */ METHODDEF(void) prepare_for_output_pass (j_decompress_ptr cinfo) { my_master_ptr master = (my_master_ptr) cinfo->master; if (master->pub.is_dummy_pass) { #ifdef QUANT_2PASS_SUPPORTED /* Final pass of 2-pass quantization */ master->pub.is_dummy_pass = FALSE; (*cinfo->cquantize->start_pass) (cinfo, FALSE); (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST); (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST); #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif /* QUANT_2PASS_SUPPORTED */ } else { if (cinfo->quantize_colors && cinfo->colormap == NULL) { /* Select new quantization method */ if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) { cinfo->cquantize = master->quantizer_2pass; master->pub.is_dummy_pass = TRUE; } else if (cinfo->enable_1pass_quant) { cinfo->cquantize = master->quantizer_1pass; } else { ERREXIT(cinfo, JERR_MODE_CHANGE); } } (*cinfo->idct->start_pass) (cinfo); (*cinfo->coef->start_output_pass) (cinfo); if (! cinfo->raw_data_out) { if (! master->using_merged_upsample) (*cinfo->cconvert->start_pass) (cinfo); (*cinfo->upsample->start_pass) (cinfo); if (cinfo->quantize_colors) (*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass); (*cinfo->post->start_pass) (cinfo, (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU)); (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU); } } /* Set up progress monitor's pass info if present */ if (cinfo->progress != NULL) { cinfo->progress->completed_passes = master->pass_number; cinfo->progress->total_passes = master->pass_number + (master->pub.is_dummy_pass ? 2 : 1); /* In buffered-image mode, we assume one more output pass if EOI not * yet reached, but no more passes if EOI has been reached. */ if (cinfo->buffered_image && ! cinfo->inputctl->eoi_reached) { cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1); } } } /* * Finish up at end of an output pass. */ METHODDEF(void) finish_output_pass (j_decompress_ptr cinfo) { my_master_ptr master = (my_master_ptr) cinfo->master; if (cinfo->quantize_colors) (*cinfo->cquantize->finish_pass) (cinfo); master->pass_number++; } #ifdef D_MULTISCAN_FILES_SUPPORTED /* * Switch to a new external colormap between output passes. */ GLOBAL(void) jpeg_new_colormap (j_decompress_ptr cinfo) { my_master_ptr master = (my_master_ptr) cinfo->master; /* Prevent application from calling me at wrong times */ if (cinfo->global_state != DSTATE_BUFIMAGE) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); if (cinfo->quantize_colors && cinfo->enable_external_quant && cinfo->colormap != NULL) { /* Select 2-pass quantizer for external colormap use */ cinfo->cquantize = master->quantizer_2pass; /* Notify quantizer of colormap change */ (*cinfo->cquantize->new_color_map) (cinfo); master->pub.is_dummy_pass = FALSE; /* just in case */ } else ERREXIT(cinfo, JERR_MODE_CHANGE); } #endif /* D_MULTISCAN_FILES_SUPPORTED */ /* * Initialize master decompression control and select active modules. * This is performed at the start of jpeg_start_decompress. */ GLOBAL(void) jinit_master_decompress (j_decompress_ptr cinfo) { my_master_ptr master; master = (my_master_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_decomp_master)); cinfo->master = (struct jpeg_decomp_master *) master; master->pub.prepare_for_output_pass = prepare_for_output_pass; master->pub.finish_output_pass = finish_output_pass; master->pub.is_dummy_pass = FALSE; master_selection(cinfo); } Papyrus3/JpegDir/JpgLossy/JCMAINCT.C0000755000175000017500000002236507535143454014143 0ustar /* * jcmainct.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains the main buffer controller for compression. * The main buffer lies between the pre-processor and the JPEG * compressor proper; it holds downsampled data in the JPEG colorspace. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* Note: currently, there is no operating mode in which a full-image buffer * is needed at this step. If there were, that mode could not be used with * "raw data" input, since this module is bypassed in that case. However, * we've left the code here for possible use in special applications. */ #undef FULL_MAIN_BUFFER_SUPPORTED /* Private buffer controller object */ typedef struct { struct jpeg_c_main_controller pub; /* public fields */ JDIMENSION cur_iMCU_row; /* number of current iMCU row */ JDIMENSION rowgroup_ctr; /* counts row groups received in iMCU row */ boolean suspended; /* remember if we suspended output */ J_BUF_MODE pass_mode; /* current operating mode */ /* If using just a strip buffer, this points to the entire set of buffers * (we allocate one for each component). In the full-image case, this * points to the currently accessible strips of the virtual arrays. */ JSAMPARRAY buffer[MAX_COMPONENTS]; #ifdef FULL_MAIN_BUFFER_SUPPORTED /* If using full-image storage, this array holds pointers to virtual-array * control blocks for each component. Unused if not full-image storage. */ jvirt_sarray_ptr whole_image[MAX_COMPONENTS]; #endif } my_main_controller; typedef my_main_controller * my_main_ptr; /* Forward declarations */ METHODDEF(void) process_data_simple_main JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail)); #ifdef FULL_MAIN_BUFFER_SUPPORTED METHODDEF(void) process_data_buffer_main JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail)); #endif /* * Initialize for a processing pass. */ METHODDEF(void) start_pass_main (j_compress_ptr cinfo, J_BUF_MODE pass_mode) { my_main_ptr main = (my_main_ptr) cinfo->main; /* Do nothing in raw-data mode. */ if (cinfo->raw_data_in) return; main->cur_iMCU_row = 0; /* initialize counters */ main->rowgroup_ctr = 0; main->suspended = FALSE; main->pass_mode = pass_mode; /* save mode for use by process_data */ switch (pass_mode) { case JBUF_PASS_THRU: #ifdef FULL_MAIN_BUFFER_SUPPORTED if (main->whole_image[0] != NULL) ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); #endif main->pub.process_data = process_data_simple_main; break; #ifdef FULL_MAIN_BUFFER_SUPPORTED case JBUF_SAVE_SOURCE: case JBUF_CRANK_DEST: case JBUF_SAVE_AND_PASS: if (main->whole_image[0] == NULL) ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); main->pub.process_data = process_data_buffer_main; break; #endif default: ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); break; } } /* * Process some data. * This routine handles the simple pass-through mode, * where we have only a strip buffer. */ METHODDEF(void) process_data_simple_main (j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail) { my_main_ptr main = (my_main_ptr) cinfo->main; while (main->cur_iMCU_row < cinfo->total_iMCU_rows) { /* Read input data if we haven't filled the main buffer yet */ if (main->rowgroup_ctr < DCTSIZE) (*cinfo->prep->pre_process_data) (cinfo, input_buf, in_row_ctr, in_rows_avail, main->buffer, &main->rowgroup_ctr, (JDIMENSION) DCTSIZE); /* If we don't have a full iMCU row buffered, return to application for * more data. Note that preprocessor will always pad to fill the iMCU row * at the bottom of the image. */ if (main->rowgroup_ctr != DCTSIZE) return; /* Send the completed row to the compressor */ if (! (*cinfo->coef->compress_data) (cinfo, main->buffer)) { /* If compressor did not consume the whole row, then we must need to * suspend processing and return to the application. In this situation * we pretend we didn't yet consume the last input row; otherwise, if * it happened to be the last row of the image, the application would * think we were done. */ if (! main->suspended) { (*in_row_ctr)--; main->suspended = TRUE; } return; } /* We did finish the row. Undo our little suspension hack if a previous * call suspended; then mark the main buffer empty. */ if (main->suspended) { (*in_row_ctr)++; main->suspended = FALSE; } main->rowgroup_ctr = 0; main->cur_iMCU_row++; } } #ifdef FULL_MAIN_BUFFER_SUPPORTED /* * Process some data. * This routine handles all of the modes that use a full-size buffer. */ METHODDEF(void) process_data_buffer_main (j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail) { my_main_ptr main = (my_main_ptr) cinfo->main; int ci; jpeg_component_info *compptr; boolean writing = (main->pass_mode != JBUF_CRANK_DEST); while (main->cur_iMCU_row < cinfo->total_iMCU_rows) { /* Realign the virtual buffers if at the start of an iMCU row. */ if (main->rowgroup_ctr == 0) { for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { main->buffer[ci] = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, main->whole_image[ci], main->cur_iMCU_row * (compptr->v_samp_factor * DCTSIZE), (JDIMENSION) (compptr->v_samp_factor * DCTSIZE), writing); } /* In a read pass, pretend we just read some source data. */ if (! writing) { *in_row_ctr += cinfo->max_v_samp_factor * DCTSIZE; main->rowgroup_ctr = DCTSIZE; } } /* If a write pass, read input data until the current iMCU row is full. */ /* Note: preprocessor will pad if necessary to fill the last iMCU row. */ if (writing) { (*cinfo->prep->pre_process_data) (cinfo, input_buf, in_row_ctr, in_rows_avail, main->buffer, &main->rowgroup_ctr, (JDIMENSION) DCTSIZE); /* Return to application if we need more data to fill the iMCU row. */ if (main->rowgroup_ctr < DCTSIZE) return; } /* Emit data, unless this is a sink-only pass. */ if (main->pass_mode != JBUF_SAVE_SOURCE) { if (! (*cinfo->coef->compress_data) (cinfo, main->buffer)) { /* If compressor did not consume the whole row, then we must need to * suspend processing and return to the application. In this situation * we pretend we didn't yet consume the last input row; otherwise, if * it happened to be the last row of the image, the application would * think we were done. */ if (! main->suspended) { (*in_row_ctr)--; main->suspended = TRUE; } return; } /* We did finish the row. Undo our little suspension hack if a previous * call suspended; then mark the main buffer empty. */ if (main->suspended) { (*in_row_ctr)++; main->suspended = FALSE; } } /* If get here, we are done with this iMCU row. Mark buffer empty. */ main->rowgroup_ctr = 0; main->cur_iMCU_row++; } } #endif /* FULL_MAIN_BUFFER_SUPPORTED */ /* * Initialize main buffer controller. */ GLOBAL(void) jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer) { my_main_ptr main; int ci; jpeg_component_info *compptr; main = (my_main_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_main_controller)); cinfo->main = (struct jpeg_c_main_controller *) main; main->pub.start_pass = start_pass_main; /* We don't need to create a buffer in raw-data mode. */ if (cinfo->raw_data_in) return; /* Create the buffer. It holds downsampled data, so each component * may be of a different size. */ if (need_full_buffer) { #ifdef FULL_MAIN_BUFFER_SUPPORTED /* Allocate a full-image virtual array for each component */ /* Note we pad the bottom to a multiple of the iMCU height */ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { main->whole_image[ci] = (*cinfo->mem->request_virt_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, compptr->width_in_blocks * DCTSIZE, (JDIMENSION) jround_up((long) compptr->height_in_blocks, (long) compptr->v_samp_factor) * DCTSIZE, (JDIMENSION) (compptr->v_samp_factor * DCTSIZE)); } #else ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); #endif } else { #ifdef FULL_MAIN_BUFFER_SUPPORTED main->whole_image[0] = NULL; /* flag for no virtual arrays */ #endif /* Allocate a strip buffer for each component */ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { main->buffer[ci] = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, compptr->width_in_blocks * DCTSIZE, (JDIMENSION) (compptr->v_samp_factor * DCTSIZE)); } } } Papyrus3/JpegDir/JpgLossy/LIBJPEG.A0000755000175000017500000075763007535143454014037 0ustar ! / 938694729 0 0 0 2444 ` g Ð Ð Ð Ð Ð Ð Ð Ð ÐhhhDD22222222TDZD` €<—Ìž\¯ÄÙ°òðòðòðü9ØKôUÜ`pmÀmÀmÀmÀmÀmÀmÀmÀ€€€€€”,šØšØšØ´ÌÆðÆðÆðÆð    7ÌXpm¬“pž¤ª¼º´ÉÀÝÝÝòXD;ÜoH€`€`€`€`„¬„¬„¬„¬„¬„¬‹p‹p°4Ú¤Ú¤Ú¤Ú¤Ú¤Ú¤Ú¤Ú¤jpeg_write_m_headerjpeg_abort_compressjpeg_CreateCompressjpeg_finish_compressjpeg_suppress_tablesjpeg_write_m_bytejpeg_write_markerjpeg_write_tablesjpeg_destroy_compressjpeg_write_raw_datajpeg_start_compressjpeg_write_scanlinesjpeg_write_coefficientsjpeg_copy_critical_parametersjpeg_set_colorspacejpeg_default_colorspacejpeg_simple_progressionjpeg_set_linear_qualityjpeg_set_qualityjpeg_add_quant_tablejpeg_quality_scalingjpeg_set_defaultsjpeg_stdio_destjinit_compress_masterjinit_c_master_controljinit_marker_writerjinit_c_main_controllerjinit_c_prep_controllerjinit_c_coef_controllerjinit_color_converterjinit_downsamplerjpeg_make_c_derived_tbljinit_huff_encoderjpeg_gen_optimal_tablejinit_phuff_encoderjinit_forward_dctjpeg_fdct_ifastjpeg_fdct_floatjpeg_fdct_islowjpeg_input_completejpeg_has_multiple_scansjpeg_destroy_decompressjpeg_read_headerjpeg_abort_decompressjpeg_CreateDecompressjpeg_consume_inputjpeg_finish_decompressjpeg_read_scanlinesjpeg_start_outputjpeg_start_decompressjpeg_read_raw_datajpeg_finish_outputjpeg_read_coefficientsjpeg_stdio_srcjinit_master_decompressjpeg_calc_output_dimensionsjpeg_new_colormapjinit_input_controllerjpeg_save_markersjpeg_set_marker_processorjinit_marker_readerjpeg_resync_to_restartjpeg_make_d_derived_tbljpeg_huff_decodejpeg_fill_bit_bufferjinit_huff_decoderjinit_phuff_decoderjinit_d_main_controllerjinit_d_coef_controllerjinit_d_post_controllerjinit_inverse_dctjpeg_idct_ifastjpeg_idct_floatjpeg_idct_islowjpeg_idct_1x1jpeg_idct_2x2jpeg_idct_4x4jinit_upsamplerjinit_color_deconverterjinit_1pass_quantizerjinit_2pass_quantizerjinit_merged_upsamplerjpeg_destroyjpeg_abortjpeg_alloc_huff_tablejpeg_alloc_quant_tablejdiv_round_upjcopy_sample_rowsjround_upjzero_farjcopy_block_rowjpeg_natural_orderjpeg_std_errorjpeg_std_message_tablejinit_memory_mgrjpeg_free_largejpeg_free_smalljpeg_open_backing_storejpeg_mem_termjpeg_mem_initjpeg_get_largejpeg_get_smalljpeg_mem_availablejcapimin.o/ 938694461 1729 22250 100664 3420 ` ELF 4(.shstrtab.text.rodata.symtab.strtab.rela.text.commentã¿€ð' Dò' Hô' LРDÀ" РH€¢ >€Ð DÒ Ð"`РDÒ >Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð L€¢!x€Ð DÒ Ð"`РDÒ!xÐ"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð DÒÒ'¿èРDÒ Ò'¿äРD’ ”!x@РDÒ¿èÒ"РDÒ¿äÒ" РDÀ" РD@РDÀ" РDÀ" РDÀ" DÀ'¿ìп쀢 €€ РDÒ¿ì” “*  À" HÐ¿ì’ Ò'¿ì¿ÿñÀ'¿ìп쀢 €€Ð DÒ¿ì” “*  À" XРDÒ¿ì” “*  À" hÐ¿ì’ Ò'¿ì¿ÿëРDÀ"!pРDÔ`Ô: 0РD’ dÒ" Çàèã¿ð' DРD@Çàèã¿ð' DРD@Çàèã¿€ð' Dò' HÀ'¿ìп쀢 €€Ð DÒ¿ì” “*  Ò HÒ'¿è€¢`€Ð¿èÒ HÒ" €Ð¿ì’ Ò'¿ì¿ÿêÀ'¿ìп쀢 €€!РDÒ¿ì” “*  Ò XÒ'¿ä€¢`€Ð¿äÒ HÒ"!РDÒ¿ì” “*  Ò hÒ'¿ä€¢`€Ð¿äÒ HÒ"!Ð¿ì’ Ò'¿ì¿ÿÝÇàè㿈ð' DРDÒ €¢`e€ РDÒ €¢`f€€Ð DÒ DÐ àÒ` €¢ € РDÒ CÐ"`РDÒÔ@РDŸÂ€Ð DÒ!LÔ`РDŸÂ€€Ð DÒ €¢`g€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!LÐ`€¢ €€FРDÒ!LÔ@РDŸÂ€À'¿ìРDÒ¿ìÐ ð€¢@ €€/РDÒ €¢`€Ð DÒ Ð¿ìÐ"`Ò DÐ`Ò DÔ`ðÔ" РDÒ Ô@РDŸÂ€Ð DÒ!XÔ`РD’ ŸÂ€€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ì’ Ò'¿ì¿ÿÍРDÒ!LÔ`РDŸÂ€¿ÿ¶Ð DÒ!\Ô` РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð D@Çàè㿈ð' Dò' Hô' Lö' PРDÒ à€¢`€Ð DÒ €¢`e€Ð DÒ €¢`f€Ð DÒ €¢`g€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!\Ö`РDÒ HÔ PŸÂÀРDÒ!\Ð`Ð'¿ìÒ Pÿ’Ò' P€¢ÿ€€Ð LÔ ’  ÿÔ¿ìРDŸÂ€Ð L’ Ò' L¿ÿíÇàèã¿ð' Dò' Hô' LРDÒ à€¢`€Ð DÒ €¢`e€Ð DÒ €¢`f€Ð DÒ €¢`g€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!\Ö`РDÒ HÔ LŸÂÀÇàèã¿ð' Dò' HРDÒ!\Ô`РDÒ HŸÂ€Çàèã¿ð' DРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒÔ`РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð D@РDÒ!\Ô`РDŸÂ€Ð DÒ Ô`РDŸÂ€Çàè?ðÿñÿñ ,ôÌ@,Thu|\d‘H¦À0¸À4ÊðÌÜçýjcapimin.cgcc2_compiled.jinit_memory_mgrjpeg_write_m_headerjpeg_abort_compressjpeg_CreateCompressjpeg_destroymemsetjpeg_finish_compressjpeg_suppress_tablesjpeg_write_m_bytejpeg_write_markerjpeg_write_tablesjpeg_abortjpeg_destroy_compressjinit_marker_writerì ð ô  8°|as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14= t¼ 0 80! h) |` 4 Ü>jcapistd.o/ 938694463 1729 22250 100664 1952 ` ELFˆ4(.shstrtab.text.symtab.strtab.rela.text.commentã¿ð' Dò' HРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð H€¢ €Ð D’ @РDÒÔ`РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð D@РDÒ!LÔ@РDŸÂ€Ð DÀ" àРDÒ DÔ`°€¢ €’ f€’ eÒ" Çàè㿈ð' Dò' Hô' LРDÒ €¢`e€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ DÐ àÒ` €¢ € РDÒ {Ð"`РDÒÔ`РD’?ÿŸÂ€Ð DÒ €¢`€Ò DÐ`Ò DÔ`àÔ" Ò DÐ`Ò DÔ` Ô" РDÒ Ô@РDŸÂ€Ð DÒ!LÐ` €¢ €Ð DÒ!LÔ`РDŸÂ€Ð DÒ DÐ Ò`à" Ð'¿èРLҿ耢 €Ð¿èÐ' LÀ'¿ìРDÒ!P”¿ìØ`РDÒ HÖ LŸÃРDÒ DÔ`àҿ씀 Ô" àп찀Çàè㿈ð' Dò' Hô' LРDÒ €¢`f€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ DÐ àÒ` €¢ €Ð DÒ {Ð"`РDÒÔ`РD’?ÿŸÂ€° €NРDÒ €¢`€Ò DÐ`Ò DÔ`àÔ" Ò DÐ`Ò DÔ` Ô" РDÒ Ô@РDŸÂ€Ð DÒ!LÐ` €¢ €Ð DÒ!LÔ`РDŸÂ€Ð DÒ ì “* Ò'¿ìРLҿ쀢 € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ!XÔ`РDÒ HŸÂ€€¢ €° € РDÒ DÔ`àҿ씀 Ô" àп찀Çàèÿñÿñ Äì/ C ¸Xmjcapistd.cgcc2_compiled.jpeg_write_raw_datajpeg_start_compressjpeg_write_scanlinesjpeg_suppress_tablesjinit_compress_mastert°as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l°¬ƒ!0 ,H>jctrans.o/ 938694494 1729 22250 100664 4736 ` ELFh4(.shstrtab.text.symtab.strtab.rela.text.commentã¿ð' Dò' HРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð D’ @РDÒÔ`РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð DÒ H@@РDÀ" àРD’ gÒ" Çàèã¿pð' Dò' HРHÒ €¢`d€Ð HÒ Ð"`Ò HÐ@Ò HÔ`Ô" РHÒÔ@РHŸÂ€Ð HÒ DÔ`Ô" РHÒ DÔ` Ô" РHÒ DÔ`$Ô" $РHÒ DÔ`(Ô" (РH@Ò DРHÒ`(@РHÒ DÔ`ÔÔ" 8РHÒ DÔa,Ô" ¼À'¿Øп؀¢ €€/РDÒ¿Ø” “*  Ò ¤€¢`€!пؒ‘*`’ HРH’ Ò'¿ìпìÒ€¢`€Ð H@Ò¿ìÐ"@пìÒ DÔ¿Ø– •*à’@ ÐÒ`¤” €@пìÒÀ"`€Ð¿Ø’ Ò'¿Ø¿ÿÏРHÒ DÔ`$Ô" <РHÒ <€¢`€ РHÒ <€¢` €€Ð HÒ Ð"`Ò HÐ@Ò HÔ`<Ô" РHÒ Ð"`РHÒÔ@РHŸÂ€À'¿ÔРDÒ ØÒ'¿èРHÒ DÒ'¿äРHÒ¿ÔÐ <€¢@€€zпäÒ¿èÔ@Ô"пäÒ¿èÔ`Ô" пäÒ¿èÔ` Ô" пäÒ¿èÔ`Ô" пäÒ Ò'¿Øп؀¢ €Ð¿Ø€¢ € РDÒ¿Ø” “*  Ò ¤€¢`€€Ð HÒ 4Ð"`РHÒпØÐ"`РHÒÔ@РHŸÂ€Ð DÒ¿Ø” “*  Ò ¤Ò'¿ÜпèÒ LÒ'¿àÐ¿à€¢ €-À'¿ÐпЀ¢ ?€€&пàҿЖ •*àÒ¿ÜֿИ —+ Ð •* ‘2 Ò@ •*`“2 €¢ €Ð HÒ ,Ð"`РHÒпØÐ"`РHÒÔ@РHŸÂ€Ð¿Ð’ Ò'¿Ð¿ÿØпԒ Ò'¿ÔÐ¿è’ TÒ'¿èÐ¿ä’ TÒ'¿ä¿ÿ‚РDÒ!€¢`€Ð DÒ ! `ÿ€¢ € РHÒ DÔ aÔ* ÔРHÒ DÔ aÔ* ÕРHÒ DÔ aÔ* ÖРHÒ DÔa Ô2 ØРHÒ DÔa"Ô2 ÚÇàèã¿ð' Dò' HРD’ Ò" $РD’ @РDÒ ´€¢`€Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ 䀢`€Ð D@€Ð D@РDÒ H@wРD@РDÒ Ô`РDŸÂ€Ð DÒ!\Ô@РDŸÂ€Çàè㿈ð' DРDÒ!XÒ'¿ìРDÒ ô€¢`€Ð¿ì’ Ò" €Ð¿ìÒ DÔ`ð’¿ÿÐ €¢ € пìÒ DÔ`øÒ  Ò" €Ð¿ìÒ DÔ`øÒ HÒ" пìÀ" пìÀ" Çàè㿈ð' Dò' HРDÒ!XÒ'¿ìРH€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ìÀ" РDÿÿÀÇàèã¿ ð' Dò' HРDÒ!XÒ'¿ìРDÒ!ÿÐ'¿äРDÒ ðÿÐ'¿àÀ'¿ØРDÒ¿ØÐ ô€¢@€€+РDÒ¿Ø” “*  Ò øÒ'¿€Ð Dà пìÒ¿€Ô`’ •*`Ð ¢€Ð¿ìÒ¿€Ð Ò` @”Ö¿€Ú РDÒ@Öà ˜ ŸÃ@Ò¿Ø” “* ”¿°Ð"€ пؒ Ò'¿Ø¿ÿÑпìÒ Ò'¿ÌпìÒ¿ÌÐ €¢@€€ÈпìÒ Ò'¿èРDÒ¿èÐ!€¢@ €€¶À'¿ÜÀ'¿ØРDÒ¿ØÐ ô€¢@€€”РDÒ¿Ø” “*  Ò øÒ'¿€Ò¿€Ð¿èÒ`4@Ð'¿Äпèҿ䀢 €Ò¿€Ð`4€Ò¿€Ð`DÐ'¿ÈÀ'¿Ðп€Ò¿ÐÐ 8€¢@€€mпìÒ Ð¿à€¢@ € пÐÒ¿Ì Ò¿€Ô`H€¢ €€.пؒ‘*`’¿°Ô¿ÐÖ¿Ì”€ – •*àÒ@€ Ò¿Ä” “* Ð’ Ò'¿„À'¿ÔпÔÒ¿È€¢ €€¿ÜÒ– •*àš¿ˆ–¿„ØÀØ#@ ˜ €Ø"À’`Ò"пԒ Ò'¿Ô¿ÿê€À'¿Ôп€Ò¿ÔÐ 4€¢@€€"пܒ‘*`’¿ˆÔ¿ìֿܘ —+ ”€ Ö Ö"@пܒ‘*`’¿ˆÐ@Ô¿Ü’¿ÿ” “* ”¿ˆÒ€ Ô@Ô2пܒ Ò'¿ÜпԒ Ò'¿Ô¿ÿÚпВ Ò'¿Ð¿ÿпؒ Ò'¿Ø¿ÿhРDÔ!l’¿ˆÔ Ð DŸÂ€€¢ € пìÒ¿ÌÒ" пìÒ¿èÒ" ° €Ð¿è’ Ò'¿è¿ÿFпìÀ" п̒ Ò'¿Ì¿ÿ4Ò¿ìпìÒ¿ìÔ`’ Ò" РDÿþ£° €Çàèã¿€ð' Dò' HРDÒ Ö@РD’ ” DŸÂÀÐ'¿ìРDÒ¿ìÒ"!Xп쒠Ò"п쒠Ò" пìÒ HÒ" РDÒ Ö`РD’ ”%ŸÂÀÐ'¿èпè’%@À'¿äп䀢 €€Ð¿ìÒ¿ä” “*  Ò¿ä” “* Ô¿è’€ Ò" Ð¿ä’ Ò'¿ä¿ÿìÇàèÿñÿñ ¨€<l+: (V¤ôs˜¤‚–È®µ»ÐâìÿÈÜ4H\jctrans.ccompress_outputstart_pass_coefgcc2_compiled.transencode_coef_controllertransencode_master_selectionstart_iMCU_rowjpeg_set_colorspacejpeg_write_coefficientsmemcpy.umuljpeg_suppress_tablesjpeg_set_defaultsjzero_farjinit_huff_encoderjinit_c_master_controljpeg_copy_critical_parametersjinit_marker_writerjinit_phuff_encoderjpeg_alloc_quant_tabled h| L Ä(<XT  T  h < l < x ¨ | ¨ ¼as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l ( ”` ôs!hÀ ,(>jcparam.o/ 938694483 1729 22250 100664 8712 ` ELF È4(.shstrtab.text.rodata.symtab.strtab.rela.text.commentã¿€ð' Dò' Hô' Lö' Pø' TРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð H€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð H’‘*`’ HРD’ Ò'¿ìпìÒ€¢`€Ð D@Ò¿ìÐ"@À'¿èп耢 ?€€6п蒑*`Ô L’ Ð@Ò P@’ 2 ’ d@Ð'¿äп䀢 € Ð'¿äп䒣ÿ€¢ €cÿÐ'¿äРT€¢ €Ð¿ä€¢ ÿ€ ÿÐ'¿äÒ¿ìÐ@Ò¿è” “* Ô¿æÔ2 Ð¿è’ Ò'¿è¿ÿÈпìÒÀ"`€Çàèã¿ð' Dò' Hô' LРD’ ”àÖ HØ L@РD’ ”àÖ HØ L@Çàèã¿ð' DРD€¢ € Ð' DРD€¢ d€ dÐ' DРD€¢ 1€ cˆÒ D@Ð' D€Ð D’‘*`’ È"@Ð' DРD°€Çàèã¿ð' Dò' Hô' LРH@Ð' HРDÒ HÔ L@Çàè㿈ð' Dò' Hô' Lö' PРHÒ€¢`€Ð D@Ò HÐ"@Ò HÐ@Ò L” @À'¿ì Ð'¿èп耢 €€Ð LÒ¿è Ò `ÿÒ¿ì@Ð'¿ìÐ¿è’ Ò'¿è¿ÿïп쀢 €Ð¿ì€¢!€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð HÔ’  Ò PÔ¿ì@РHÒÀ"aÇàèã¿ð' DРD’ XРD”à– ÿÿ«Ð D’ hРD”à– ÿÿ¢Ð D’ \РD”à– ÿÿ™Ð D’ lРD”à– ÿÿÇàè㿈ð' DРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ D€¢`€ РDÒ Ö@РD’ ”#HŸÂÀÒ DÐ"`DРD’ Ò" 8РD’ K” @РDÿÿªÀ'¿ìп쀢 €€Ð DÒ¿ì À* xРDÒ¿ì ’ Ò* ˆÐ DÒ¿ì ’ Ò* ˜Ð¿ì’ Ò'¿ì¿ÿéРDÀ" ¬Ð DÀ" ¨Ð DÀ" °Ð DÀ" ´Ð DÀ" ¸Ð DÒ 8€¢`€Ð D’ Ò" ¸Ð DÀ" ¼Ð DÀ" ÀРDÀ" ÄРDÀ" ÈРDÀ" ÌРD’ Ò* ÔРD’ Ò* ÕРDÀ* ÖРD’ Ò2 ØРD’ Ò2 ÚРD@Çàèã¿ð' DРDÒ (€¢`€4Ð (’‘*`’ Ð ÂРD’ @€*РD’ @€$РD’ @€Ð D’ @€Ð D’ @€Ð D’ @€ РDÒ Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' Dò' HРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ HÒ" @РDÀ" ÐРDÀ" ÜРH€¢ €ªÐ H’‘*`’ Ð ÂРD’ Ò" ÐРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" €ŒÐ D’ Ò" ÜРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ RÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`TÐ'¿ìÐ¿ì’ GÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`¨Ð'¿ìÐ¿ì’ BÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" €LРD’ Ò" ÐРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`TÐ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" РDÒ D`¨Ð'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" €Ð D’ Ò" ÜРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ CÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`TÐ'¿ìÐ¿ì’ MÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`¨Ð'¿ìÐ¿ì’ YÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`üÐ'¿ìÐ¿ì’ KÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" €³Ð D’ Ò" ÜРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`TÐ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" РDÒ D`¨Ð'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" РDÒ D`üÐ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" €ZРDÒ DÔ`$Ô" <РDÒ <€¢`€ РDÒ <€¢` €€Ð DÒ Ð"`Ò DÐ@Ò DÔ`<Ô" РDÒ Ð"`РDÒÔ@РDŸÂ€À'¿èРDÒ¿èÐ <€¢@€€!РDÒ¿è– •*à”€ —* –À “*àÐ D’ Ò'¿ìпìÒ¿èÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" Ð¿è’ Ò'¿è¿ÿÛ€ РDÒ Ð"`РDÒÔ@РDŸÂ€Çàèã¿ð' Dò' Hô' Lö' Pø' Tú' XРD’ Ò"РDÒ HÒ" РDÒ LÒ" РDÒ PÒ" РDÒ TÒ" РDÒ XÒ" РD’ $Ò' DРD°€Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XÀ'¿ìпìÒ H€¢ €€Ð D’ Ò"РDÒ¿ìÒ" РDÒ LÒ" РDÒ PÒ" РDÒ TÒ" РDÒ XÒ" РD’ $Ò' DÐ¿ì’ Ò'¿ì¿ÿáРD°€Çàè㿈ð' Dò' Hô' Lö' PРH€¢ €(РDÒ HÒ"À'¿ìпìÒ H€¢ €€Ð DÒ¿ì” “*  Ò¿ìÒ" Ð¿ì’ Ò'¿ì¿ÿïРDÒ DÀ"`À" РDÒ LÒ" РDÒ PÒ" РD’ $Ò' D€ РDÒ H” – Ø LÚ PÿÿœÐ' DРD°€Çàèã¿€ð' DРDÒ <Ò'¿ìРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð¿ì€¢ € РDÒ @€¢`€ Ð'¿è€Ð¿ì€¢ € п씓* ’@‘*`Ð'¿è€Ð¿ì’‘*`’ Ò'¿èРDÒ!p€¢`€ РDÒ!tп耢@€€Ð Dҿ耢` €’ Ò"!tÒ DÐ`Ô DÒ¡t” —* –À •*àÖРD’ ŸÂÀÒ DÐ"apРDÒ!pÒ'¿äРDÒ¿äÒ" ¬Ð DÒ¿èÒ" ¨Ð¿ì€¢ €_РDÒ @€¢`€ZпäÒ¿ì” – ÿÿRÐ'¿äÐ¿ä’ ” – ˜ š ÿþøÐ'¿äÐ¿ä’ ” – ?˜ š ÿþïÐ'¿äÐ¿ä’ ” – ?˜ š ÿþæÐ'¿äÐ¿ä’ ” – ?˜ š ÿþÝÐ'¿äÐ¿ä’ ” – ?˜ š ÿþÔÐ'¿äпäÒ¿ì” – ÿÿÐ'¿äÐ¿ä’ ” – ?˜ š ÿþÄÐ'¿äÐ¿ä’ ” – ?˜ š ÿþ»Ð'¿äÐ¿ä’ ” – ?˜ š ÿþ²Ð'¿ä€4пäÒ¿ì” – ÿþúÐ'¿äпäÒ¿ì” – ˜ š ÿþÂÐ'¿äпäÒ¿ì” – ?˜ š ÿþ¹Ð'¿äпäÒ¿ì” – ?˜ š ÿþ°Ð'¿äпäÒ¿ì” – ÿþØÐ'¿äпäÒ¿ì” – ?˜ š ÿþ Ð'¿äÇàè (3= :<7 (9E83WP>%8DmgM#7@Qhq\1@NWgyxeH\_bpdgc/ccccBcccc8ccccc/Bcccccccccccccccccccccccccccccccccccccc  }!1AQa"q2‘¡#B±ÁRÑð$3br‚ %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚáâãäåæçèéêñòóôõö÷øùúw!1AQaq"2B‘¡±Á #3RðbrÑ $4á%ñ&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz‚ƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚâãäåæçèéêòóôõö÷øùúÿñÿñ l 0PE øS(i@Ž<0¹ä¼Ä\ˆÐähø(&@XTðl˜à„Xœ£<´ºÏh˜ä äöûjcparam.cstd_huff_tablesbits_dc_luminance.14bits_ac_luminance.18fill_dc_scansval_ac_chrominance.21val_dc_chrominance.17gcc2_compiled.add_huff_tablestd_chrominance_quant_tbl.5fill_scansfill_a_scanval_dc_luminance.15val_ac_luminance.19bits_ac_chrominance.20bits_dc_chrominance.16std_luminance_quant_tbl.4jpeg_set_colorspacejpeg_default_colorspacejpeg_simple_progressionjpeg_set_linear_qualitymemcpyjpeg_set_quality.umuljpeg_add_quant_tablejpeg_quality_scalingjpeg_set_defaults.divjpeg_alloc_huff_tablejpeg_alloc_quant_tableü H\( , 8H L X¼,hˆP€ „ ˆ Œ ¤ P¨ P¬ h° hÈ (Ì (Ð @Ô @ì ð ô (ø (¸à , ,,¼0D4\8t<Œ@¤Ld|”¬Ä˜ ¬œ ¬¬ ô°Ä´ ,¸ ,¼ DÀ as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14= txðʼ!Ì()ô” 4 ˆ>jdatadst.o/ 938694499 1729 22250 100664 1476 ` ELF¬4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' DРDÒ Ò'¿ìРDÒ Ö@РD’ ŸÂÀÒ¿ìÐ"`пìÒ¿ìÔ`Ô"пìÒ" Çàè㿈ð' DРDÒ Ò'¿ìпìÖ¿ìÐ ’ Öà@€¢ € РDÒ %Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿ìÔ`Ô"пìÒ" ° €Çàè㿈ð' DРDÒ Ò'¿ìпìÐ ’"@Ò'¿èп耢 €Ð¿ìÖ¿ìÐ ’ Ô¿èÖà@ҿ耢 € РDÒ %Ð"`РDÒÔ@РDŸÂ€Ò¿ìÐ`@пìÒ Ð ` ’ `ÿ€¢ € РDÒ %Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' Dò' HРDÒ €¢`€ РDÒ Ö@РD’ ” ŸÂÀÒ DÐ"`РDÒ Ò'¿ìп쒠Ò" п쒠Ò" п쒠Ò" пìÒ HÒ" Çàèÿñÿñ üð`œ1`BQì˜ahjdatadst.cterm_destinationempty_output_bufferinit_destinationgcc2_compiled.jpeg_stdio_destfflushfwriteŒ L ”D H T `X `d üh üas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l„ð o!l ,l>jcinit.o/ 938694472 1729 22250 100664 1440 ` ELFˆ4(.shstrtab.text.symtab.strtab.rela.text.commentã¿ð' DРD’ @РDÒ °€¢`€ РD@РD@РD’ @РD@РDÒ ´€¢`€Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ 䀢`€Ð D@€Ð D@’ РDÔ ¨€¢ € РDÔ ¸€¢ €€’ РD@РD’ @РD@РDÒ Ô`РDŸÂ€Ð DÒ!\Ô@РDŸÂ€Çàèÿñÿñ 1Ias…›p±ÄÛïjcinit.cgcc2_compiled.jinit_c_main_controllerjinit_c_coef_controllerjinit_c_prep_controllerjinit_downsamplerjinit_forward_dctjinit_color_converterjinit_compress_masterjinit_huff_encoderjinit_c_master_controljinit_marker_writerjinit_phuff_encoder 0 <LX¼Ð $0 as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 lpÜðÌ!Ðx ,H>jcmaster.o/ 938694479 1729 22250 100664 8160 ` ELFÈ4(.shstrtab.text.symtab.strtab.rela.text.commentã¿€ð' DРDÒ €¢`€Ð DÒ €¢`€Ð DÒ <€¢`€ РDÒ $€¢`€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ò DÐ` ?’£Ü€¢ € Ò DÐ`?’£Ü€¢ €€Ð DÒ )Ð"`Ò DÐ@?’£ÜÒ" РDÒÔ@РDŸÂ€Ð DÒ DÐ Ò`$@Ð'¿äпäÐ'¿àпàҿ䀢 € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð DÒ 8€¢`€Ð DÒ Ð"`Ò DÐ@Ò DÔ`8Ô" РDÒÔ@РDŸÂ€Ð DÒ <€¢` €Ð DÒ Ð"`Ò DÐ@Ò DÔ`<Ô" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð D’ Ò" èРD’ Ò" ìÀ'¿ìРDÒ DÒ'¿èРDÒ¿ìÐ <€¢@€€>пèÒ €¢`€Ð¿èÒ €¢`€Ð¿èÒ €¢`€ пèÒ €¢`€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÖ¿èÔàÖ`耢€ €Ô`èÔ" èРDÒ DÖ¿èÔà Ö`쀢€ €Ô`ìÔ" ìÐ¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ¾À'¿ìРDÒ DÒ'¿èРDÒ¿ìÐ <€¢@€€IпèÒ¿ìÒ" Ð¿è’ Ò" $РDÒ¿èÐ Ò`@Ò DÔ`è’ •*`’ @Ò¿èÐ"`РDÒ¿èÐ Ò` @Ò DÔ`ì’ •*`’ @Ò¿èÐ"` РDÒ¿èÐ Ò`@Ò DÒ`è@Ò¿èÐ"`(РDÒ¿èÐ Ò` @Ò DÒ`ì@Ò¿èÐ"`,Ð¿è’ Ò" 0Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ³Ð DÒ DÔ`ì’ •*`Ð ’ @Ò DÐ"`ðÇàèãµ8ð' DРDÒ ¨€¢`€Ð DÒ Ð"`РDÒÀ"`РDÒÔ@РDŸÂ€Ð DÒ ¬Ò'¿ìпìÒ €¢`€ пìÒ €¢`?€€*РD’ Ò" 䵘Ð'¿œÀ'¿àРDÒ¿àÐ <€¢@€€À'¿Üп܀¢ ?€€ ¿œÒ”?ÿÔ"@’`Ò"пܒ Ò'¿Ü¿ÿñÐ¿à’ Ò'¿à¿ÿâ€Ð DÀ" äÀ'¿àРDÒ¿àÐ <€¢@€€ Ð¿à’‘*`’¿ À"@Ð¿à’ Ò'¿à¿ÿð Ð'¿èРDÒ¿èÐ ¨€¢@€€·Ð¿ìÒÒ'¿äп䀢 €Ð¿ä€¢ €€Ð DÒ Ð"`РDÒпäÐ"`РDÒ Ð"`РDÒÔ@РDŸÂ€À'¿àпàҿ䀢 €€EпìÒ¿à” “*  Ò Ò'¿Øп؀¢ € РDÒ¿ØÐ <€¢@€€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿à€¢ €Ð¿ìÔ¿à’¿ÿ” “*  Ò¿ØÐ €¢@€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿à’ Ò'¿à¿ÿ¸Ð¿ìÒ Ò'¿ÔпìÒ Ò'¿ÐпìÒ Ò'¿ÌпìÒ Ò'¿ÈРDÒ 䀢`€âпԀ¢ €!пԀ¢ ?€Ð¿ÐÒ¿Ô€¢ €Ð¿Ð€¢ ?€Ð¿Ì€¢ €Ð¿Ì€¢ € пȀ¢ €Ð¿È€¢ €€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿Ô€¢ €Ð¿Ð€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€€Ð¿ä€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€À'¿àпàҿ䀢 €€|µ˜Ò¿ìÔ¿à– •*à’@ Ô`’ •*` Ð'¿œÐ¿Ô€¢ €Ð¿œÒ€¢`€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿ÔÐ'¿ÜпÜҿЀ¢ €€Kпܒ‘*`Ò¿œ Ò€¢`€Ð¿Ì€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€€"пܒ‘*`Ò¿œ Ò¿ÌЀ¢@€ Ò¿ÌÿÒ¿È€¢@€€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿Ü’‘*`Ò¿œ Ò¿ÈÒ"пܒ Ò'¿Ü¿ÿ²Ð¿à’ Ò'¿à¿ÿ€SпԀ¢ €Ð¿Ð€¢ ?€ п̀¢ €Ð¿È€¢ €€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€À'¿àпàҿ䀢 €€*пìÒ¿à” “*  Ò Ò'¿Øпؒ‘*`’¿ Ð@€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿Ø’‘*`’¿ ” Ô"@Ð¿à’ Ò'¿à¿ÿÓÐ¿ì’ $Ò'¿ìÐ¿è’ Ò'¿è¿þEРDÒ 䀢`€$À'¿àРDÒ¿àÐ <€¢@€€Ð¿à’‘*`’µ˜Ð@€¢ € РDÒ -Ð"`РDÒÔ@РDŸÂ€Ð¿à’ Ò'¿à¿ÿã€"À'¿àРDÒ¿àÐ <€¢@€€Ð¿à’‘*`’¿ Ð@€¢ € РDÒ -Ð"`РDÒÔ@РDŸÂ€Ð¿à’ Ò'¿à¿ÿãÇàèã¿€ð' DРDÒ ¬€¢`€HРDÒ!LÒ'¿èРDÔ¿èÒ  – •*à”€ “* Ð ¬’ Ò'¿äРDÒ¿äÔ@Ô" ôÀ'¿ìпäÒ¿ìЀ¢@€€Ð DÒ¿ì” “*  Ò DÔ¿äÖ¿ì˜ —+ ˜€ Ô ˜ —+ –À ™*à˜ •+ Ò`D”@ Ô" øÐ¿ì’ Ò'¿ì¿ÿàРDÒ¿äÔ`Ô"!<РDÒ¿äÔ`Ô"!@РDÒ¿äÔ`Ô"!DРDÒ¿äÔ` Ô"!H€EРDÒ <€¢`€Ð DÒ Ð"`Ò DÐ@Ò DÔ`<Ô" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÔ`<Ô" ôÀ'¿ìРDÒ¿ìÐ <€¢@€€Ð DÒ¿ì” “*  Ò DÔ¿ì˜ —+ –À ™*à˜ •+ Ò`D”@ Ô" øÐ¿ì’ Ò'¿ì¿ÿåРDÀ"!<РD’ ?Ò"!@РDÀ"!DРDÀ"!HÇàèã¿xð' DРDÒ ô€¢`€5РDÒ øÒ'¿àРDÒ¿àÔ`Ô"!РDÒ¿àÔ` Ô"! Ð¿à’ Ò" 4Ð¿à’ Ò" 8Ð¿à’ Ò" <Ð¿à’ Ò" @Ð¿à’ Ò" DпàÒ¿àÔ  Ò` @Ð'¿äп䀢 €Ð¿àÒ Ò'¿äпàÒ¿äÒ" HРD’ Ò"!РDÀ"!€´Ð DÒ ô€¢`€ РDÒ ô€¢`€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`ôÔ" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÔ`è’ •*`Ð ’ @Ò DÐ"aРDÒ DÔ`ì’ •*`Ð ’ @Ò DÐ"a РDÀ"!À'¿ìРDÒ¿ìÐ ô€¢@€€tРDÒ¿ì” “*  Ò øÒ'¿àпàÒ¿àÔ`Ô" 4пàÒ¿àÔ` Ô" 8à¿àпàÒ¿àÐ 4Ò`8@Ð$ <пàÒ¿àÔ`4’ •*`Ô" @пàÒ¿àÔ  Ò`4@Ð'¿äп䀢 €Ð¿àÒ 4Ò'¿äпàÒ¿äÒ" DпàÒ¿àÔ  Ò`8@Ð'¿äп䀢 €Ð¿àÒ 8Ò'¿äпàÒ¿äÒ" HпàÒ <Ò'¿èРDÒ!Ô¿è@ €¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€¿èÒ” ’ÿÒ"€¢ €€Ô DÒ DaÒ– ™*à”€ Ö¿ìÖ"¡’`Ò"¿ÿëÐ¿ì’ Ò'¿ì¿ÿˆÐ DÒ Ì€¢`€Ð DÒ DÐ ÌÒa@Ð'¿ÜРDÒ¿Ü?”ãÿ€¢@ €?’£ÿÒ" ÈÇàè㿈ð' DРDÒ!LÒ'¿ìÒ¿ìÐ`€¢ €Z€¢  €€¢ €†€²Ð DÿþWРDÿþæРDÒ °€¢`€Ð DÒ!`Ô@РDŸÂ€Ð DÒ!dÔ@РDŸÂ€Ð DÒ!TÔ@РD’ ŸÂ€Ð DÒ!hÔ@РDŸÂ€Ð DÔ!lÒ DԀРDÒ`¸ŸÂ€Ò DÐaXÒ¿ìÔ`€¢ €’ €’ ÔРDŸÂ€Ð DÒ!PÔ@РD’ ŸÂ€Ð DÒ ¸€¢`€Ð¿ìÀ" €Ð¿ì’ Ò" €lРDÿþРDÿþ–РDÒ!<€¢`€Ð DÒ!D€¢`€ РDÒ ´€¢`€€Ð DÒ!lÔ@РD’ ŸÂ€Ð DÒ!XÔ@РD’ ŸÂ€Ð¿ìÀ" €CÐ¿ì’ Ò" Ò¿ìпìÒ¿ìÔ`’ Ò" РDÒ ¸€¢`€Ð DÿýÐРDÿþ_РDÒ!lÔ@РD’ ŸÂ€Ð DÒ!XÔ@РD’ ŸÂ€Ð¿ìÒ €¢`€Ð DÒ!\Ô`РDŸÂ€Ð DÒ!\Ô`РDŸÂ€Ð¿ìÀ" € РDÒ 0Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿ìÔ¿ìÖ ”ÿÿÒ`”@ €  ’`?ÿÒ" РDÒ €¢`€ Ò DÐ`Ò¿ìÔ`Ô" Ò DÐ`Ò¿ìÔ`Ô" Çàèã¿ð' DРDÒ!LÀ"` РDÒ!\Ô`РDŸÂ€Ð DÒ!\Ô`РDŸÂ€Çàè㿈ð' DРDÒ!LÒ'¿ìРDÒ!lÔ`РDŸÂ€Ò¿ìÐ`€¢ €€¢  €€¢ €€'Ð¿ì’ Ò" РDÒ ¸€¢`€Ò¿ìпìÒ¿ìÔ` ’ Ò" €Ð¿ì’ Ò" €Ð DÒ ¸€¢`€Ð¿ì’ Ò" Ò¿ìпìÒ¿ìÔ` ’ Ò" €Ò¿ìпìÒ¿ìÔ`’ Ò" Çàè㿈ð' Dò' HРDÒ Ö@РD’ ” $ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Lп쒠Ò"п쒠Ò" п쒠Ò" пìÀ" РDÿùpРDÒ ¬€¢`€Ð Dÿúœ€Ð DÀ" äРD’ Ò" ¨Ð DÒ 䀢`€Ð D’ Ò" ¸Ð H€¢ €Ð DÒ ¸€¢`€Ð¿ì’ Ò" €Ð¿ì’ Ò" €Ð¿ìÀ" пìÀ" пìÀ" РDÒ ¸€¢`€ пìÒ DÔ`¨’ •*`Ô" €Ð¿ìÒ DÔ`¨Ô" Çàèÿñÿñ Ìœ,Ð:¼IÐ ¤Y´ltHƒhLž¤ªÈŒjcmaster.cprepare_for_passgcc2_compiled.initial_setupper_scan_setupvalidate_scriptfinish_pass_masterselect_scan_parameterspass_startupjdiv_round_up.umul.uremjinit_c_master_control ¨ Ä ä   0 P ` ¸ T < h ô , t   Ì Ì h h( ´, ´as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 lTÀð °Á!t ,ˆ>jcmarker.o/ 938694476 1729 22250 100664 5972 ` ELF<4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' Dò' HРDÒ Ò'¿ìпìÒÔ KÔ*@’`Ò"Ò¿ìпìÒ¿ìÔ`’¿ÿ” Ô" €¢ €Ð¿ìÒ Ð DŸÂ@€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Çàèã¿ð' Dò' HРD’ ÿÿÿÑРDÒ HÿÿÍÇàèã¿ð' Dò' HÒ H‘:`’ ÿРDÿÿÂРH’ ÿРDÿÿ½Çàèã¿€ð' Dò' HРDÒ H” “*  Ò HÒ'¿ìп쀢 €Ð DÒ 4Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€À'¿èÀ'¿äп䀢 ?€€Ð¿ìÒ¿ä” “* Ð “* ‘2`€¢ ÿ€ Ð'¿èÐ¿ä’ Ò'¿ä¿ÿëпìÒ €€¢`€CРD’ Ûÿÿ§Ð¿è€¢ €’ ƒ€’ CРDÿÿ©Ò¿è‘*`Ô H’ РDÿÿkÀ'¿äп䀢 ?€€#пìÔ¿ä– •*à–`’€ Ô@’ •*`Ð “* ‘2`Ð'¿àп耢 €Ð¿à“2 РDÿÿMÐ¿à’ ÿРDÿÿHÐ¿ä’ Ò'¿ä¿ÿÛÐ¿ì’ Ò" €Ð¿è°€Çàèã¿€ð' Dò' Hô' LРL€¢ €Ð DÒ H” “*  Ò hÒ'¿ìРH’ Ò' H€ РDÒ H” “*  Ò XÒ'¿ìп쀢 €Ð DÒ 2Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð¿ìÒ!€¢`€QРD’ Äÿÿ.À'¿è Ð'¿äп䀢 €€Ð¿ìÒ¿äÔ  ÿÒ¿è@Ð'¿èÐ¿ä’ Ò'¿ä¿ÿðÐ¿è’ Ð Dÿÿ!РDÒ Hÿþæ Ð'¿äп䀢 €€Ð¿ìÒ¿äÐ ’ ÿРDÿþ×Ð¿ä’ Ò'¿ä¿ÿðÀ'¿äпäҿ耢 €€Ð¿ìÒ¿ä Ô ’  ÿРDÿþÁÐ¿ä’ Ò'¿ä¿ÿîÐ¿ì’ Ò"!Çàèã¿ð' DÇàèã¿ð' DРD’ Ýÿþ×РD’ ÿþàÒ DРDÒ`ÈÿþÛÇàè㿈ð' Dò' HРDÒ HÿþÅÒ DÐ`<”“* ’@”`РD’ ÿþÈÒ DÐ` ?’£ÿ€¢ € Ò DÐ`?’£ÿ€¢ €€Ð DÒ )Ð"`Ò DÐ@?’£ÿÒ" РDÒÔ@РDŸÂ€Ò DРDÒ`8ÿþmÒ DРDÒ` ÿþŸÒ DРDÒ`ÿþšÒ DРDÒ`<ÿþ^À'¿ìРDÒ DÒ'¿èРDÒ¿ìÐ <€¢@€€Ò¿èРDÒ@ÿþMпèÒ ‘*`Ò¿èÔ` ’ РDÿþDÒ¿èРDÒ`ÿþ?Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿßÇàèã¿€ð' DРD’ ÚÿþYРDÒ ô “* ”`РD’ ÿþ]Ò DРDÒ`ôÿþ!À'¿ìРDÒ¿ìÐ ô€¢@€€9РDÒ¿ì” “*  Ò øÒ'¿àÒ¿àРDÒ@ÿþ пàÒ Ò'¿èпàÒ Ò'¿äРDÒ 䀢`€Ð DÒ!<€¢`€À'¿äРDÒ!D€¢`€Ð DÒ ´€¢`€À'¿è€À'¿èÒ¿è‘*`Ô¿ä’ Ð DÿýæÐ¿ì’ Ò'¿ì¿ÿÃÒ DРDÒa<ÿýÜÒ DРDÒa@ÿý×РDÒ!D‘*`Ò DÔaH’ РDÿýÎÇàèã¿ð' DРD’ àÿýðРD’ ÿýùРD’ Jÿý¾Ð D’ FÿýºÐ D’ Iÿý¶Ð D’ Fÿý²Ð D’ ÿý®Ð DÔ Ô’  ÿРDÿý¨Ð DÔ Õ’  ÿРDÿý¢Ð DÔ Ö’  ÿРDÿýœÐ DÒ Ø‘*`“2 РDÿýÌРDÒ Ú‘*`“2 РDÿýÅРD’ ÿýŠÐ D’ ÿý†Çàèã¿ð' DРD’ îÿý¨Ð D’ ÿý±Ð D’ AÿývРD’ dÿýrРD’ oÿýnРD’ bÿýjРD’ eÿýfРD’ dÿý™Ð D’ ÿý•Ð D’ ÿý‘Ò DÐ`@€¢ €€¢ € €Ð D’ ÿýL€Ð D’ ÿýF€Ð D’ ÿý@€Çàèã¿ð' Dò' Hô' LРL?’£ý€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ HÿýNРL’ РDÿýVÇàèã¿ð' Dò' HРDÒ HÿýÇàè㿈ð' DРDÒ!\Ò'¿ìРD’ Øÿý5пìÀ" РDÒ Ѐ¢`€Ð Dÿÿ7РDÒ Ü€¢`€Ð DÿÿwÇàèã¿€ð' DÀ'¿èÀ'¿ìРDÒ DÒ'¿àРDÒ¿ìÐ <€¢@€€Ò¿àРDÒ`ÿý*Ò¿è@Ð'¿èÐ¿ì’ Ò'¿ìÐ¿à’ TÒ'¿à¿ÿêРDÒ ´€¢`€Ð DÒ 䀢`€ РDÒ 8€¢`€€À'¿ä€9 Ð'¿äÀ'¿ìРDÒ DÒ'¿àРDÒ¿ìÐ <€¢@€€Ð¿àÒ €¢`€ пàÒ €¢`€€À'¿äÐ¿ì’ Ò'¿ìÐ¿à’ TÒ'¿à¿ÿåп耢 €Ð¿ä€¢ €À'¿äРDÒ KÐ"`РDÒÔ`РD’ ŸÂ€Ð DÒ ´€¢`€Ð D’ Éÿýä€Ð DÒ 䀢`€Ð D’ Âÿýـп䀢 €Ð D’ ÀÿýπРD’ ÁÿýÉÇàèã¿€ð' DРDÒ!\Ò'¿ìРDÒ ´€¢`€Ð Dÿý¥€BÀ'¿èРDÒ¿èÐ ô€¢@€€9РDÒ¿è” “*  Ò øÒ'¿äРDÒ 䀢`€Ð DÒ!<€¢`€Ð DÒ!D€¢`€Ò¿äРDÒ`” ÿüû€Ò¿äРDÒ`” ÿüó€Ò¿äРDÒ`” ÿüëÒ¿äРDÒ`” ÿüåÐ¿è’ Ò'¿è¿ÿÃРDÒ¿ìÐ ÈÒ`€¢ € РDÿý]пìÒ DÔ`ÈÔ" РDÿýÔÇàèã¿ð' DРD’ Ùÿü)Çàè㿈ð' DРD’ Øÿü!À'¿ìп쀢 €€Ð DÒ¿ì” “*  Ò H€¢`€Ð DÒ¿ìÿü*Ð¿ì’ Ò'¿ì¿ÿêРDÒ ´€¢`€*À'¿ìп쀢 €€#РDÒ¿ì” “*  Ò X€¢`€Ð DÒ¿ì” ÿüŒÐ DÒ¿ì” “*  Ò h€¢`€Ð DÒ¿ì” ÿü~Ð¿ì’ Ò'¿ì¿ÿÛРD’ Ùÿû×Çàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!\п쒠Ò"п쒠Ò" п쒠Ò" п쒠Ò" п쒠Ò" п쒠Ò" п쒠Ò" пìÀ" Çàèÿñÿñ ,€´<D'4¤0  9B |V ø g¨q€ ”$’lˆ¤ ¸t¶HÈØ ר4ãÜ@ïô  ,@(\¸jcmarker.cemit_dacemit_sofemit_driemit_sosemit_dhtemit_dqtwrite_marker_headeremit_adobe_app14emit_bytegcc2_compiled.write_marker_bytewrite_scan_headerwrite_file_headerwrite_tables_onlyemit_jfif_app0emit_markeremit_2byteswrite_file_trailerwrite_frame_headerjpeg_natural_orderjinit_marker_writer| Œ ˜ ¸œ ¸¨ ,¬ ,¸ l¼ lÈ ôÌ ôØ Ü è ì ø ”ü ”as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l€€<!<À ,ü>jcmainct.o/ 938694474 1729 22250 100664 1620 ` ELF<4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' Dò' HРDÒ!PÒ'¿ìРDÒ °€¢`€€#пìÀ" пìÀ" пìÀ" пìÒ HÒ" РH€¢ €€Ð¿ì’ Ò" €Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Çàèã¿€ð' Dò' Hô' Lö' PРDÒ!PÒ'¿ìпìÒ DÐ Ò`ð€¢ €€OпìÒ €¢`€Ò DÐaTÒ¿ì˜`Ò¿ìš` ’ Ò# \Ä Ð DÒ HÔ LÖ PŸÀ€Ð¿ìÒ €¢`€€4Ò DÐaXÔ¿ì’ Ô Ð DŸÂ€€¢ €Ð¿ìÒ €¢`€ Ò LРLÒ LÔ@’¿ÿÒ"Ð¿ì’ Ò" €Ð¿ìÒ €¢`€ Ò LРLÒ LÔ@’ Ò"пìÀ" пìÀ" Ò¿ìпìÒ¿ìÔ`’ Ò" ¿ÿ¬Çàèã¿€ð' Dò' HРDÒ Ö@РD’ ” @ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Pп쒠Ò"РDÒ °€¢`€€;РH€¢ €Ð DÒ Ð"`РDÒÔ@РDŸÂ€€+À'¿èРDÒ DÒ'¿äРDÒ¿èÐ <€¢@€€Ò DÐ`Ò¿äÔ`’ •*`Ò¿äÖ` ’ —*`Ø Ð D’ ŸÃÒ¿ìÔ¿è– •*à’@ Ð"`Ð¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÝÇàèÿñÿñ À+À€D@Tjcmainct.cstart_pass_maingcc2_compiled.process_data_simple_mainjinit_c_main_controllert Àx À€ „ as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l”pp\!Ì0 ,ü>jcprepct.o/ 938694490 1729 22250 100664 4200 ` ELFP4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' Dò' HРDÒ!TÒ'¿ìРH€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ DÔ` Ô" 0пìÀ" 4пìÀ" 8пìÒ DÔ`ì’ •*`Ô" <Çàèã¿ð' Dò' Hô' Lö' Pà LРP€¤€€Ð L’?ÿРDÔ D–˜ Ú H@  ¿ÿðÇàèã¿xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!TÒ'¿ìРLÒРP€¢@€ РXÒР\€¢@ €€€ÂРLÒ PÐ’"@Ò'¿àРDÒ¿ìÐ ìÒ`4" Ð'¿èпèÒ¿à€¢ €Ð¿à€Ð¿èÐ'¿èÒ DÐa`Ò LÔ@’ •*`Ö H’€ Ö¿ì”àÖ¿ìÚ Ð DÖà4Ø¿èŸÃ@РLÒ LÔ@ҿ蔀 Ô"пìÒ¿ìÔ`4ҿ蔀 Ô" 4пìÒ¿ìÔ`0Ò¿è”"€ Ô" 0пìÒ 0€¢`€)пìÒ DÐ 4Ò`쀢 €"À'¿äРDÒ¿äÐ <€¢@€€Ð¿ìÒ¿ä” “*  Ò DÔ¿ìÖ DÐ Ò`Ô 4ÖàìÿÿsÐ¿ä’ Ò'¿ä¿ÿçпìÒ DÔ`ìÔ" 4пìÒ DÐ 4Ò`쀢 €Ò DÐadÔ¿ì’ Ø XÚ Ð D” Ö TØŸÃ@пìÀ" 4Ò XРXÒ XÔ@’ Ò"пìÒ 0€¢`€<РXÒР\€¢@€6À'¿äРDÒ DÒ'¿ÜРDÒ¿äÐ <€¢@€€%п䒑*`Ò T  пÜÒ  £* РXÒ¿ÜÐÒ` @¤Ò¿ÜР\Ò` @–Ð’”ÿÿÐ¿ä’ Ò'¿äпܒ TÒ'¿Ü¿ÿ×РXÒ \Ò"€¿ÿ2Çàèã¿xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!TÒ'¿ìÒ DÐ`ì’•*`€Ð'¿àРXÒР\€¢@ €€âРLÒРP€¢@€tРLÒ PÐ’"@Ò'¿ÜпìÒ¿ìÐ <Ò`4" Ð'¿èпèÒ¿Ü€¢ €Ð¿Ü€Ð¿èÐ'¿èÒ DÐa`Ò LÔ@’ •*`Ö H’€ Ö¿ì”àÖ¿ìÚ Ð DÖà4Ø¿èŸÃ@пìÒ DÐ 0Ò` €¢ €3À'¿äРDÒ¿äÐ <€¢@€€* Ð'¿ØРDÒ¿ØÐ 쀢@€€Ð¿ìÒ¿ä” “*  Ò¿ìÔ¿ä– ™*à”@ Ò¿Ø– Ú DÐ ’ Ô ˜ Ú`@пؒ Ò'¿Ø¿ÿáÐ¿ä’ Ò'¿ä¿ÿÒРLÒ LÔ@ҿ蔀 Ô"пìÒ¿ìÔ`4ҿ蔀 Ô" 4пìÒ¿ìÔ`0Ò¿è”"€ Ô" 0€0пìÒ 0€¢`€€cпìÒ¿ìÐ 4Ò`<€¢ €"À'¿äРDÒ¿äÐ <€¢@€€Ð¿ìÒ¿ä” “*  Ò DÔ¿ìÖ¿ìÐ Ò`Ô 4Öà<ÿþWÐ¿ä’ Ò'¿ä¿ÿçпìÒ¿ìÔ`<Ô" 4пìÒ¿ìÐ 4Ò`<€¢ €3Ò DÐadÔ¿ì’ Ô¿ìØ XÚ Ð DÔ 8Ö TØŸÃ@Ò XРXÒ XÔ@’ Ò"пìÒ¿ìÔ DÒ`8Ô ì’@ Ò" 8пìÒ 8Ð¿à€¢@€Ð¿ìÀ" 8пìÒ 4Ð¿à€¢@€Ð¿ìÀ" 4пìÒ¿ìÔ DÒ`4Ô ì’@ Ò" <¿ÿÇàèã¿pð' DРDÒ!TÒ'¿ìРDÒ ìÒ'¿èРDà Ò Dп薕*à”€ Ò`<@’•*`ÖРD’ ŸÂÀÐ'¿ÔÀ'¿äРDÒ DÒ'¿ÜРDÒ¿äÐ <€¢@€€qРDà Ò¿ÜРDÔ è •*  Ò`@Ò¿ÜÒ`@”п蒗*`–ÀØ Ð D’ ŸÃÐ'¿Øп蒑*`Ò¿Ô Ò¿è” —* –À •*àÒ¿Ø@À'¿àпàҿ耢 €€'Ð¿à’‘*`Ò¿Ô Ò¿è” “* Ô¿à’@ ” “* Ô¿Ø’@ Ô@Ô"п蒑*`Ò¿à ’‘*`Ò¿Ô Ò¿à” “* Ô¿Ø’@ Ô@Ô"Ð¿à’ Ò'¿à¿ÿÖпìÒ¿ä” “*  Ò¿è” “* Ô¿Ô’€ Ò" п蔓* ’@‘*`Ò¿Ô@Ð'¿ÔÐ¿ä’ Ò'¿äпܒ TÒ'¿Ü¿ÿ‹Çàèã¿€ð' Dò' HРH€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ö@РD’ ” @ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Tп쒠Ò"РDÒ!dÐ`€¢ € п쒠Ò" РDÿÿ<€7п쒠Ò" À'¿èРDÒ DÒ'¿äРDÒ¿èÐ <€¢@€€'РDà Ò¿äРDÔ è •*  Ò`@Ò¿äÒ`@”Ö DØ Ð D’ ÖàìŸÃÒ¿ìÔ¿è– •*à’@ Ð"`Ð¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÕÇàèÿñÿñ h/hèCøpTcP`y °œ‘£ª°jcprepct.cexpand_bottom_edgestart_pass_preppre_process_contextpre_process_datagcc2_compiled.create_context_bufferjinit_c_prep_controllerjcopy_sample_rowsmemcpy.umul.divÜ ì  ( ”     €  ( , P h T h t ø x ø Ô  ä as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l L ¸à  ˜µ!PÀ ,>jccoefct.o/ 938694464 1729 22250 100664 5320 ` ELF°4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' DРDÒ!XÒ'¿ìРDÒ ô€¢`€Ð¿ì’ Ò" €Ð¿ìÒ DÔ`ð’¿ÿÐ €¢ € пìÒ DÔ`øÒ  Ò" €Ð¿ìÒ DÔ`øÒ HÒ" пìÀ" пìÀ" Çàè㿈ð' Dò' HРDÒ!XÒ'¿ìпìÀ" РDÿÿÎРH€¢ €9€¢ €€¢ € €F€¢ €€AпìÒ @€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ì’ Ò" €8пìÒ @€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ì’ Ò" €#пìÒ @€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ì’ Ò" €Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Çàèã¿Pð' Dò' HРDÒ!XÒ'¿ìРDÒ!ÿÐ'¿äРDÒ ðÿÐ'¿àпìÒ Ò'¿ÌпìÒ¿ÌÐ €¢@€€üпìÒ Ò'¿èпèҿ䀢 €€ëÀ'¿ÜÀ'¿ÔРDÒ¿ÔÐ ô€¢@€€ÈРDÒ¿Ô” “*  Ò øÒ'¿¼Ð¿èҿ䀢 €Ò¿¼Ð`4€Ò¿¼Ð`DÐ'¿ÈÒ¿¼Ð¿èÒ`@@Ð'¿Àп̒‘*`Ð'¿ÄÀ'¿Ðп¼Ò¿ÐÐ 8€¢@€€Ð¿ìÒ Ð¿à€¢@ € пÌÒ¿Ð Ò¿¼Ô`H€¢ €€TÒ DÐahÒ¿¼Ô`’ •*`Ò H”€ Ò¿ìֿܘ ›+ –@ Ò¿ÈÒ# \Ä Ð DÒ¿¼Ô€ÖàØ¿ÄÚ¿ÀŸÀ€Ð¿¼Ò¿ÈÐ 4€¢@€4пìÒ¿ÜÔ¿È’@ ” “*  Ò¿¼Ô`4Ö¿È’"€ ” “* Ð @пÈÐ'¿Øп¼Ò¿ØÐ 4€¢@€€Ð¿ìÒ¿ÜÔ¿Ø’@ ” “* ” РҿìÔ¿ÜÖ¿Ø”€ –¿ÿ” —* ”@ Ò Ô@Ô2пؒ Ò'¿Ø¿ÿâ€.пìÒ¿Ü” “*  Ò¿¼Ô`4’ •*`Ð ’ @À'¿Øп¼Ò¿ØÐ 4€¢@€€Ð¿ìÒ¿ÜÔ¿Ø’@ ” “* ” РҿìÖ¿Ü”ÿÿ– •*à–@ ÒàÔ@Ô2пؒ Ò'¿Ø¿ÿäп¼Ò¿ÜÐ 4’@Ò'¿ÜпĒ Ò'¿ÄпВ Ò'¿Ð¿ÿ_пԒ Ò'¿Ô¿ÿ4Ò DÐalÔ¿ì’ Ô Ð DŸÂ€€¢ € пìÒ¿ÌÒ" пìÒ¿èÒ" ° €Ð¿è’ Ò'¿è¿ÿпìÀ" п̒ Ò'¿Ì¿ÿÒ¿ìпìÒ¿ìÔ`’ Ò" РDÿþT° €Çàèã¿Hð' Dò' HРDÒ!XÒ'¿ìРDÒ ðÿÐ'¿èÀ'¿ÔРDÒ DÒ'¿¼Ð DÒ¿ÔÐ <€¢@€€ РDà пìÒ¿Ô” “* ¢ пìÒ¿¼Ð Ò` @”Ö¿¼Ú РDÒ`@Öà ˜ ŸÃ@Ð'¿¸Ð¿ìÒ Ð¿è€¢@€Ð¿¼Ò Ò'¿È€Ð¿¼Ò¿¼Ô  Ò` @Ð'¿ÈпȀ¢ €Ð¿¼Ò Ò'¿Èп¼Ò Ò'¿äп¼Ò Ò'¿ÐÒ¿ä Ò¿Ð@Ð'¿ÄпĀ¢ €Ð¿ÐÒ¿Ä" Ð'¿ÄÀ'¿ÌпÌÒ¿È€¢ €€Lп̒‘*`Ò¿¸ ÒÒ'¿´Ò DÐahÒ¿Ô” “* Ö H”@ Ò¿Ì– ™*àÒ¿äÒ# \Ä Ð DÒ¿¼Ô€Ö¿´š ŸÀ€Ð¿Ä€¢ €(п䒑*`Ò¿´@Ð'¿´Ð¿Ä’•*`п´’ @?€Ò¿´ ÒÒ7¿ÂÀ'¿ØпØÒ¿Ä€¢ €€Ð¿Ø’‘*`Ò¿´ Ò¿ÂÒ2пؒ Ò'¿Ø¿ÿïп̒ Ò'¿Ì¿ÿ±Ð¿ìÒ Ð¿è€¢@€cпäÒ¿Ä Ð'¿äпäÒ¿Ð@Ð'¿àпÈÐ'¿Ìп¼Ò¿ÌÐ €¢@€€Pп̒‘*`Ò¿¸ ÒÒ'¿´Ð¿Ì’‘*`Ò¿¸ Ò?üÒ'¿°Ð¿ä’•*`п´’ @À'¿ÜпÜÒ¿à€¢ €€.пВ‘*`Ò¿° Ò?€Ò7¿ÂÀ'¿ØпØҿЀ¢ €€Ð¿Ø’‘*`Ò¿´ Ò¿ÂÒ2пؒ Ò'¿Ø¿ÿïпВ‘*`Ò¿´@Ð'¿´Ð¿Ð’‘*`Ò¿°@Ð'¿°Ð¿Ü’ Ò'¿Ü¿ÿÏп̒ Ò'¿Ì¿ÿ¬Ð¿Ô’ Ò'¿Ôп¼’ TÒ'¿¼¿þóРDÒ H@°€Çàèã¿Xð' Dò' HРDÒ!XÒ'¿ìÀ'¿àРDÒ¿àÐ ô€¢@€€*РDÒ¿à” “*  Ò øÒ'¿¸Ð Dà пìÒ¿¸Ô`’ •*`¢ пìÒ¿¸Ð Ò` @”Ö¿¸Ú РDÒ`@Öà ˜ ŸÃ@Ò¿à” “* ”¿ÀÐ"€ Ð¿à’ Ò'¿à¿ÿÒпìÒ Ò'¿ÔпìÒ¿ÔÐ €¢@€€ƒÐ¿ìÒ Ò'¿èРDÒ¿èÐ!€¢@ €€qÀ'¿äÀ'¿àРDÒ¿àÐ ô€¢@€€NРDÒ¿à” “*  Ò øÒ'¿¸Ò¿¸Ð¿èÒ`4@Ð'¿ÐÀ'¿Øп¸Ò¿ØÐ 8€¢@€€3Ð¿à’‘*`’¿ÀÔ¿ØÖ¿Ô”€ – •*àÒ@€ ҿД “* Ð’ Ò'¿¼À'¿Üп¸Ò¿ÜÐ 4€¢@€€Ô¿ì¿äÒ– ›*à˜€ ”¿¼Ö€Ö# –à€Ö"€’`Ò"пܒ Ò'¿Ü¿ÿèпؒ Ò'¿Ø¿ÿÉÐ¿à’ Ò'¿à¿ÿ®Ò DÐalÔ¿ì’ Ô Ð DŸÂ€€¢ € пìÒ¿ÔÒ" пìÒ¿èÒ" ° €Ð¿è’ Ò'¿è¿ÿ‹Ð¿ìÀ" пԒ Ò'¿Ô¿ÿyÒ¿ìпìÒ¿ìÔ`’ Ò" РDÿü\° €Çàèã¿€ð' Dò' HРDÒ Ö@РD’ ” hŸÂÀÐ'¿ìРDÒ¿ìÒ"!Xп쒠Ò"РH€¢ €7À'¿èРDÒ DÒ'¿äРDÒ¿èÐ <€¢@€€)РDà пäÒ¿äÐ Ò`@¢Ð¿äÒ¿äÐ Ò` @˜Ú¿äÄ Ð D’ ” –Ú` ŸÀ€Ò¿ìÔ¿è– •*à’@ Ð"`@Ð¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÓ€$РDÒ Ö`РD’ ”%ŸÂÀÐ'¿äÀ'¿èп耢 €€Ð¿ìÒ¿è” “*  Ò¿è” “* Ô¿ä’€ Ò" Ð¿è’ Ò'¿è¿ÿìпìÀ" @Çàèÿñÿñ dH̘0¤¤@OH„]¤l¬À„Š– jccoefct.ccompress_outputcompress_first_passstart_pass_coefgcc2_compiled.compress_datastart_iMCU_rowjinit_c_coef_controller.umul.urem.udivjround_upjzero_farT HX H¨ ̬ Ìü d dT „HP À    ´  4 ì  ì ì ¤ð ¤P l as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 llØð Ȫ!tü ,p>jccolor.o/ 938694466 1729 22250 100664 5488 ` ELFX4(.shstrtab.text.symtab.strtab.rela.text.commentã¿€ð' DРDÒ!`Ò'¿ìРDÒ Ö@РD’ ŸÂÀ’пìÒ'¿èÒ" À'¿äп䀢 ÿ€€’п䒑*`Ò¿è Ò¿ä– •*à”€ —* ”€ —* –À •*à”"€ —* ’"À Ò"п䒑*`Ò¿è Ò¿ä– •*à”"€ —* –À •*à”"€ “* ”€ “* Ò"$п䒑*`Ò¿è Ò¿ä– •*à”"€ —* –À “*à’"@  ’@ Ò"(п䒑*`Ò¿è Ò¿ä– •*à”€ —* ”€ —* –"À •*à”"€ —* ’"À ” Ô",п䒑*`Ò¿è Ô¿ä˜ —+ –À ™*à˜# —+ –À •*à–À ” Ô" п䒑*`Ò¿è Ô¿ä– •*à –#ÿ”€ Ô" п䒑*`Ò¿è Ô¿ä– ™*à˜ —+ –À ™*à–À ™*à˜# —+ ”"À – Ö" п䒑*`Ò¿è Ô¿ä– ™*à˜ —+ –À ™*à–À ™*à” – Ö" Ð¿ä’ Ò'¿ä¿ÿlÇàè㿈ð' Dò' Hô' Lö' Pø' TРDÒ!`Ò'¿ìØ¿ìÖ à Dâ â'¿èâ T ÿ¢â' T€¤`€€j  HâØ@¢`â$à Lâ P¤£, ä @Ú  â L â P¤£, ä @Ä  â L â P¤£, ä @Æà P¢ â' Pž à¿è€£À €€@à ÿà ’ ÿà ” ÿ˜ ¢¡,`¢ ¥,`¢€ àÀâd ¢ ¥,`¢€ äh £< â+@ £,  @ ¢ ¥,`¢€ %à,â@ ¢ ¥,`¢€ %â@ £< â(€ £,  @ #¤ §, ¤À 'à†¢ ¥,`¢€ %â@ £< â(Àžà¿ÿ¾¿ÿ‘Çàè㿈ð' Dò' Hô' Lö' Pø' TРDÒ!`Ò'¿ìØ¿ìÖ Æ DÞàÞ'¿èÞ T†ÿÿžÞ' T€£à€€3† HÞÀØÀžàÞ ÀÆ LÞ P Ÿ, àÀ†ÀÚÀÆ PžàÞ' P„ ƿ耠€ €€Æ àÿÆ ’àÿÆ ”àÿ˜ ž‡+àž ¡+àž ÆÀÞä†Àž ¡+àž àè†ÀŸ8àÞ+@„ ¿ÿã¿ÿÈÇàè㿈ð' Dò' Hô' Lö' Pø' TРDÒ!`Ò'¿ìØ¿ìÖ â Dä`ä'¿èä T¢¿ÿ¤ä' T€¤ €€{¢ Hä@Ø€¤ ä$@â Lä P¦¥,àæ@¢€Ú@¢ ä L¢@ä P¦¥,àæ@¢€Ä@¢ ä L¢@ä P¦¥,àæ@¢€Æ@¢ ä L¢@ä P¦¥,àæ@¢€Þ@â P¤`ä' P  â¿è€¤ €€Hä ¢  ÿ¤ ÿ$€ä ¢  ÿ¤ ÿ’$€ä ¢  ÿ¤ ÿ”$€â â+À˜ ¤£, ¤ §, ¤À âÀ䤢@¤ §, ¤À 樢@¥<`ä+@¢¥,`¢€ ¤ §, ¤À 'âl䀢@¤ §, ¤À '䀢@¥<`ä(€¢¥,`¢€ %¦ ©,ঠ)â@äÀ¢@¤ §, ¤À '䀢@¥<`ä(À  ¿ÿ¶¿ÿ€Çàè㿈ð' Dò' Hô' Lö' Pø' TÖ DØàØ'¿ìÖ DØà$Ø'¿èØ T–?ÿ˜ Ø' T€£ €€!– HØÀИ Ø"ÀÖ LØ Pš ™+`ÚÀ– ÒÀÖ P˜àØ' P” ֿ쀢€ €€ Ö Ö*@ Ö¿è ” ¿ÿõ¿ÿÚÇàè㿈ð' Dò' Hô' Lö' Pø' TØ DÚ <Ú'¿ìØ DÚ Ú'¿èÚ T˜ÿš Ú' T€£`€€.– ؿ쀢À €€Ø HИ ›+ Ä L˜@Ú P„ ›( Ä˜@Ò” ؿ耢€ €€ Ø Ø*@ Ø¿ì ” ¿ÿõ–à¿ÿßØ Hš Ú' HØ Pš Ú' P¿ÿÍÇàèã¿ð' DÇàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!`п쒠Ò"РDÒ (ÿ€¢ €A’‘*`’ Ð ÂРDÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€5РDÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€$РDÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ @ÿ€¢ €’‘*`’ Ð ÂРDÒ <€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ (€¢`€Ð¿ì’ Ò" €&РDÒ (€¢`€ п쒠Ò"п쒠Ò" €Ð DÒ (€¢`€Ð¿ì’ Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€ØРDÒ <€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ (€¢`€Ð¿ì’ Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€²Ð DÒ <€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ (€¢`€ п쒠Ò"п쒠Ò" €Ð DÒ (€¢`€Ð¿ì’ Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€}РDÒ <€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ (€¢`€Ð¿ì’ Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€WРDÒ <€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ (€¢`€ п쒠Ò"п쒠Ò" €Ð DÒ (€¢`€Ð¿ì’ Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€"РDÒ DÐ @Ò`(€¢ € РDÒ DÐ <Ò`$€¢ €€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ì’ Ò" €Çàèÿñÿñ ¬((¨6ô CRÔHdØv¨† Hjccolor.cnull_methodrgb_gray_convertrgb_ycc_startnull_convertgcc2_compiled.cmyk_ycck_convertgrayscale_convertrgb_ycc_convertjinit_color_converter L P x Œ | Œ Œ     ä ”  ä ˜  ( œ  ( Ð ä Ô ä ä  ø è  ø ì  ð d ô ü L  P  x | ˆ ¬ Œ ¬ ´  ¸  L ô P ô ä è ô ¨ ø ¨ ô$ ô¸ ô¼ ôP T ` Ôd ÔŒ ô ô< ô@ ôas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 lXÄÀ „œ! ø ,>jcsample.o/ 938694493 1729 22250 100664 6404 ` ELFì4(.shstrtab.text.symtab.strtab.rela.text.commentã¿ð' DÇàè㿈ð' Dò' Hô' Lö' PÖ PØ L–"À Ö'¿èֿ耢à€#À'¿ìÖ¿ìØ H€¢À €€Ö¿ì˜ —+ Ø D–À ØÀÖ L Ò ?ÿԿ耢 €€Ò* ”¿ÿ¿ÿøÖ¿ì˜àØ'¿ì¿ÿâÇàèã¿xð' Dò' Hô' Lö' Pø' TРDÒ!dÒ'¿ìÀ'¿èРDÒ DÒ'¿äРDÒ¿èÐ <€¢@€€0п蒑*`Ò H Ò L” “* Ð’ Ò'¿àп蒑*`Ò P  Ò¿äРTÒ` @’‘*`Ò@Ð'¿ÜпìÒ¿è” “*  Ø Ð DÒ¿äÔ¿àÖ¿ÜŸÃÐ¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÌÇàèã¿Xð' Dò' Hô' Lö' PРHÒ  “* Ò'¿ÄРDÒ HÐ èÒ`@Ð'¿äРDÒ HÐ ìÒ` @Ð'¿àпäÒ¿à@Ð'¿Üпܓ: •2`’ ‘:`Ð'¿Øà Dâ DпÄÒ¿ä@–РLÒ ìÔ`ÿÿ^À'¿ìÀ'¿èРHÒ¿èÐ €¢@€€aп蒑*`Ò P ÒÒ'¿¼À'¿ÌÀ'¿ÈпÌÒ¿Ä€¢ €€HÀ'¿¸À'¿ÐпÐÒ¿à€¢ €€(пìÒ¿Ð ’‘*`Ò L ÒпȒ@Ò'¿ÀÀ'¿ÔпÔҿ䀢 €€¿ÀÒÖ @” àÿÖ¿¸”À Ô'¿¸’`Ò"пԒ Ò'¿Ô¿ÿíпВ Ò'¿Ð¿ÿÕ ¿¼âп¸Ô¿Ø’  Ò¿Ü@’ Ð,@¢`â$п̒ Ò'¿ÌпÈÒ¿ä Ð'¿È¿ÿµÐ¿ìÒ¿à Ð'¿ìÐ¿è’ Ò'¿è¿ÿ›Çàèã¿ð' Dò' Hô' Lö' PØ DÚ DРL’ Ô P– Ø ìÚ`@Ò DÔ DРHÖ  —* РPÒ`ìÔ ÿþÙÇàèã¿€ð' Dò' Hô' Lö' PРHÒ  “* Ò'¿äÒ DÔ Dп䘗+ РLÒ`ìÔ ÿþÃÀ'¿ìРHÒ¿ìÐ €¢@€€-п쒑*`Ò P âп쒑*`Ò L ठÀ'¿èпèҿ䀢 €€Ò `ÿÔ ’  ÿ ’•:` Ð,@¢`¤   Ð¿è’ Ò'¿è¿ÿêÐ¿ì’ Ò'¿ì¿ÿÏÇàèã¿€ð' Dò' Hô' Lö' PРHÒ  “* Ò'¿àÒ DÔ DÐ¿à˜—+ РLÒ`ìÔ ÿþyÀ'¿ìÀ'¿èРHÒ¿èÐ €¢@€€=п蒑*`Ò P äп쒑*`Ò L àп쒑*`Ò L â ¦ À'¿äпäÒ¿à€¢ €€Ò `ÿÔ ’  ÿ Ô @’  ÿ Ô `’  ÿ ’•:` Ð,€¤ ¦à  ¢`Ð¿ä’ Ò'¿ä¿ÿãÐ¿ì’ Ò'¿ìÐ¿è’ Ò'¿è¿ÿ¿Çàèã¿pð' Dò' Hô' Lö' PРHÒ  “* Ò'¿àÒ LüÒ DÔ`ì’ Ô DÖ¿à˜ —+ Ô ÿþÒ DÐ`À”“* ’@‘*`"@Ð'¿ÔРDÒ À “* Ò'¿ÐÀ'¿ìÀ'¿èРHÒ¿èÐ €¢@€€Ð¿è’‘*`Ò P èп쒑*`Ò L àп쒑*`Ò L â п쒑*`Ò L ä?üп쒑*`Ò L æ Ò `ÿÔ ’  ÿ Ô @’  ÿ Ô `’  ÿ Ð'¿ÜÒ € `ÿÔ  ’  ÿ Ô À’  ÿ Ô à’  ÿ Ô ’  ÿ Ô ’  ÿ Ô @’  ÿ Ô `’  ÿ Ð'¿ØпØÒ¿Ø Ð'¿ØÒ € `ÿÔ  ’  ÿ Ô À’  ÿ Ô à’  ÿ Ò¿Ø@Ð'¿ØпÜÒ¿Ô@ªÐ¿ØÒ¿Ð@’@Ò'¿ÜÐ¿Ü  “:  Ð-¨   ¢`¤ ¦àпà’?þÒ'¿äп䀢 €€SÒ `ÿÔ ’  ÿ Ô @’  ÿ Ô `’  ÿ Ð'¿ÜÒ € `ÿÔ  ’  ÿ Ô À’  ÿ Ô à’  ÿ Ô ?ÿ’  ÿ Ô ’  ÿ Ô ÿ’  ÿ Ô `’  ÿ Ð'¿ØпØÒ¿Ø Ð'¿ØÒ ¿ÿ `ÿÔ  ’  ÿ Ô ÿÿ’  ÿ Ô à’  ÿ Ò¿Ø@Ð'¿ØпÜÒ¿Ô@ªÐ¿ØÒ¿Ð@’@Ò'¿ÜÐ¿Ü  “:  Ð-¨   ¢`¤ ¦àпä’?ÿÒ'¿ä¿ÿ«Ò `ÿÔ ’  ÿ Ô @’  ÿ Ô `’  ÿ Ð'¿ÜÒ € `ÿÔ  ’  ÿ Ô À’  ÿ Ô à’  ÿ Ô ?ÿ’  ÿ Ô ’  ÿ Ô ÿ’  ÿ Ô `’  ÿ Ð'¿ØпØÒ¿Ø Ð'¿ØÒ ¿ÿ `ÿÔ  ’  ÿ Ô ÿÿ’  ÿ Ô à’  ÿ Ò¿Ø@Ð'¿ØпÜÒ¿Ô@ªÐ¿ØÒ¿Ð@’@Ò'¿ÜÐ¿Ü  “: Ò-Ð¿ì’ Ò'¿ìÐ¿è’ Ò'¿è¿þèÇàèã¿hð' Dò' Hô' Lö' PРHÒ  “* Ò'¿äÒ LüÒ DÔ`ì’ Ô DÔ Ö¿äÿüÜРDÒ À “* @’" Ò'¿ØРDÒ À “* Ò'¿ÔÀ'¿ìРHÒ¿ìÐ €¢@€€«Ð¿ì’‘*`Ò P æп쒑*`Ò L àп쒑*`Ò L â?üп쒑*`Ò L ä Ò @ `ÿÔ €’  ÿ Ô ’  ÿ Ð'¿Ð¤ ¢`Ð ’ ÿÒ'¿à  Ò @ `ÿÔ €’  ÿ Ô ’  ÿ Ð'¿ÈпÐÒ¿à" Ò¿Ð Ò¿È Ð'¿ÜпàÒ¿Ø@¨Ð¿ÜÒ¿Ô@’Ò'¿àÐ¿à  “:  Ð,À¦àпÐÐ'¿ÌпÈÐ'¿Ðпä’?þÒ'¿èп耢 €€4Ð ’ ÿÒ'¿à  ¢`¤ Ò @ `ÿÔ €’  ÿ Ô ’  ÿ Ð'¿ÈпÐÒ¿à" Ò¿Ì Ò¿È Ð'¿ÜпàÒ¿Ø@¨Ð¿ÜÒ¿Ô@’Ò'¿àÐ¿à  “:  Ð,À¦àпÐÐ'¿ÌпÈÐ'¿Ðпè’?ÿÒ'¿è¿ÿÊÐ ’ ÿÒ'¿àпÐÒ¿à" Ò¿Ì Ò¿Ð Ð'¿ÜпàÒ¿Ø@¨Ð¿ÜÒ¿Ô@’Ò'¿àÐ¿à  “: Ò,ÀÐ¿ì’ Ò'¿ì¿ÿQÇàèã¿€ð' D Ð'¿àРDÒ Ö@РD’ ” 4ŸÂÀÐ'¿ìРDÒ¿ìÒ"!dп쒠Ò"п쒠Ò" пìÀ" РDÒ ¼€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€À'¿èРDÒ DÒ'¿äРDÒ¿èÐ <€¢@€€¦Ð¿äÒ DÐ Ò`耢 €%пäÒ DÐ Ò`쀢 €Ð DÒ À€¢`€Ð¿ìÒ¿è” “*  ’ Ò" Ð¿ì’ Ò" € пìÒ¿è” “*  ’ Ò" €tпäÒ ” ‘* Ò DÔ`耢 €Ð¿äÒ DÐ Ò`쀢 € À'¿àпìÒ¿è” “*  ’ Ò" €YпäÒ ” ‘* Ò DÔ`耢 €'пäÒ ” ‘* Ò DÔ`쀢 €Ð DÒ À€¢`€Ð¿ìÒ¿è” “*  ’ Ò" Ð¿ì’ Ò" € пìÒ¿è” “*  ’ Ò" €+РDÒ¿äÔ è Ò`@€¢ €Ð DÒ¿äÔ ì Ò` @€¢ € À'¿àпìÒ¿è” “*  ’ Ò" € РDÒ &Ð"`РDÒÔ@РDŸÂ€Ð¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿVРDÒ À€¢`€Ð¿à€¢ € РDÒ cÐ"`РDÒÔ`РD’ ŸÂ€Çàèÿñÿñ XP'Lp;PRaälq¼(ÐähŸÀ±ÇÌÞä¨Àöjcsample.cfullsize_smooth_downsamplefullsize_downsampleh2v2_smooth_downsamplegcc2_compiled.h2v2_downsampleh2v1_downsamplesep_downsampleint_downsampleexpand_right_edgestart_pass_downsample.remjcopy_sample_rows.umuljinit_downsampler.divp8L€à€ ` t ´ È ø  ä ø¼ÐThì ð ü Ð Ðà Xä X L L€ ¼„ ¼ P P8 ä< ä` ˆ ´ ä¸ äas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 lhÔ  ôû!ð¼ ,¬>jchuff.o/ 938694470 1729 22250 100664 10192 ` ELF&¸4(.shstrtab.text.symtab.strtab.rela.text.commentã¿xð' Dò' HРDÒ!lÒ'¿ìРH€¢ € п쒠Ò" п쒠Ò" € п쒠Ò" п쒠Ò" À'¿èРDÒ¿èÐ ô€¢@€€¨Ð DÒ¿è” “*  Ò øÒ'¿ÜпÜÒ Ò'¿äпÜÒ Ò'¿àРH€¢ €vп䀢 €Ð¿ä€¢ €€Ð DÒ 2Ð"`РDÒпäÐ"`РDÒÔ@РDŸÂ€Ð¿à€¢ €Ð¿à€¢ €€Ð DÒ 2Ð"`РDÒпàÐ"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿ä” “*  Ò L€¢`€Ð DÒ Ö@РD’ ”$ŸÂÀÒ¿ìÔ¿ä– •*à’@ Ð"`LпìÒ¿ä” “* ” РL’ ”$@пìÒ¿à” “*  Ò \€¢`€Ð DÒ Ö@РD’ ”$ŸÂÀÒ¿ìÔ¿à– •*à’@ Ð"`\пìÒ¿à” “* ” Р\’ ”$@€Ð¿ä’‘*`’ ,пì–@РD’ Ô¿ä@Ð¿à’‘*`’ <пì–@РD’ Ô¿à@пìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿTпìÀ" пìÀ" пìÒ DÔ`ÈÔ" $пìÀ" (ÇàèãºXð' Dò' Hô' Lö' PРL€¢ €Ð L€¢ €€Ð DÒ 2Ð"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð H€¢ € РDÒ L” “* ” РX€Ò DÔ L– •*à’@ Ð`hÐ'¿ìп쀢 €Ð DÒ 2Ð"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð PÒ€¢`€ РDÒ Ö@РD’ ”%ŸÂÀÒ PÐ"@РPÒÒ'¿èÀ'¿ä Ð'¿Üп܀¢ €€6пìÒ¿ÜÐ ’ ÿÒ'¿àÐ¿à€¢ € пäÒ¿à €¢!€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿àÿ’Ò'¿à€¢ÿ€€ ¿äÒ” –¾ÈØ¿ßØ*À ’`Ò"¿ÿïпܒ Ò'¿Ü¿ÿÈп䒾ÈÀ*@пäÐ'¿ØÀ'º¼Ð¾È“* ‘:`Ð'¿ÔÀ'¿äп䒾ÈÐ @“* ‘:`€¢ €€4п䒾ÈÐ @“* ‘:`Ò¿Ô€¢ €€¿äÒ– •*à–ºÀغ¼Ø"À ’`Ò"к¼’ Ò'º¼¿ÿé Ò¿Ô‘* Òº¼€¢@€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ðº¼“* Ò'º¼Ð¿Ô’ Ò'¿Ô¿ÿÆпè’$ ’ ”!@РH€¢ € € ÿÐ'¿ÐÀ'¿äпäÒ¿Ø€¢ €€<пìÒ¿ä Ò  `ÿÐ'¿àÐ¿à€¢ €Ð¿àҿЀ¢ € пèÒ¿à Ò $•*`‘: €¢ €€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿èÒ¿à” “* Ô¿ä– •*à–ºÀÔÀ Ô" пèÒ¿à ҿ䔾ÈÒ € Ò*$Ð¿ä’ Ò'¿ä¿ÿÁÇàè㿈ð' DРDÒ Ð`Ð'¿ìпìÒ DÔ Ð` ŸÂ€€¢ €° € РDÒ¿ìÔ@Ô"РDÒ¿ìÔ`Ô" ° €Çàèã¿ð' DРD’ ” @€¢ €° € РDÀ" РDÀ" ° €Çàèã¿ð' Dò' Hô' Lö' Pø' TРHÒ‘*`£: РL¢$@ €¤ €  ¢ÿ¤ €¤ €€¤ ¡< ¿ÿù€¤  €Ð DÒ Ð@’ Ò" РDÒ Ð@Ò DÔÐ` ŸÂ€Ò P•* РP–Ð ä™* —; РDÒ@ ” @»€¢ €° €œ€¤ € РD’”@­€¢ €° €Ž¨ ¦ €¤à?€€r’•*`’ € Ò “* Ô H@ Ò‘*`¡: €¢ €¨ €[€¥ €€Ò TРTÔ $ð‘* •: РDÒcÀ@~€¢ €° €_¨?ð¿ÿ뢀¤ €  ¢ÿ¤ ¡< €¢ €€¤ ¿ÿø€¤  €Ð DÒ Ð@’ Ò" РDÒ Ð@Ò DÔÐ` ŸÂ€«- ª@Ò T•* РT–Ð ä™* —; РDÒ@ ” @E€¢ €° €&РD’”@:€¢ €° €¨ ¦à¿ÿ€¥ €Ò TРTÔ $‘* •: РDÒ@@$€¢ €° €° €Çàè㿈ð' Dò' HРDÿÿ €¢ €° €NРDÒ” ÿÔ*@’`Ò"Ò DРDÒ DÔ`’¿ÿ” Ô" €¢ € РDÿþÒ€¢ €° €5РDÒÔ K–¿ÐÖ*@’`Ò"Ò DРDÒ DÔ`’¿ÿ” Ô" €¢ € РDÿþ¸€¢ €° €À'¿ìРDÒ Ð¿ìÒ`ô€¢ €€ РDÒ¿ì” “*  À" Ð¿ì’ Ò'¿ì¿ÿî° €Çàèã¿Pð' Dò' HРDÒ!lÒ'¿ìРDÒ Ð@Ð'¿ÀРDÒ Ð`Ð'¿ÄпìÒ Ò'¿ÈÒ Ò'¿ÌÒ Ò'¿ÐÒ Ò'¿ÔÒ Ò'¿ØÐ Ð'¿ÜРDÐ'¿àРDÒ È€¢`€Ð¿ìÒ $€¢`€ ¿ÀÒ¿ìÒ`(ÿÿ|€¢ €° €ˆÀ'¿¼Ð DÒ¿¼Ð!€¢@€€GРDÒ¿¼” “*  Ò!Ò'¿¸Ð DÒ¿¸” “*  Ò øÒ'¿´¿ÀÒ¿¼” “* Ô H’@ Ô¿¸– •*à–¿À”À Ö¿ìØ¿´Ú ˜ ›+ –À Ø¿ìÚ¿´Ä`š…+`˜Ò@Ô Öà,Ø <ÿþe€¢ €° €Mп¸’‘*`’¿À@Ò¿¼” “* Ô H’@ Ô@Ò€•*`“: Ò" п¼’ Ò'¿¼¿ÿµÐ DÒ Ð¿ÀÐ"@РDÒ Ð¿ÄÐ"`пìÒ¿ÈÒ" Ò¿ÌÒ" Ò¿ÐÒ" Ò¿ÔÒ" Ò¿ØÒ" Ò¿ÜÒ" РDÒ È€¢`€Ð¿ìÒ $€¢`€Ð¿ìÒ DÔ`ÈÔ" $Ò¿ìпìÒ¿ìÔ`(’ Ò" (пìÒ¿ìÔ`(’  Ò" (Ò¿ìпìÒ¿ìÔ`$’¿ÿÒ" $° €Çàèã¿`ð' DРDÒ!lÒ'¿ìРDÒ Ð@Ð'¿ÀРDÒ Ð`Ð'¿ÄпìÒ Ò'¿ÈÒ Ò'¿ÌÒ Ò'¿ÐÒ Ò'¿ÔÒ Ò'¿ØÐ Ð'¿ÜРDÐ'¿à’¿À ÿýÜ€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ð¿ÀÐ"@РDÒ Ð¿ÄÐ"`пìÒ¿ÈÒ" Ò¿ÌÒ" Ò¿ÐÒ" Ò¿ÔÒ" Ò¿ØÒ" Ò¿ÜÒ" Çàèã¿ð' Dò' Hô' Lö' Pø' TРHÒ‘*`¡: РL $€¤ €  ¢ €¤ €€¢`¡< ¿ÿù€¤` € РDÒ Ð"`РDÒÔ@РDŸÂ€“* Ô P@ ’‘*`Ò P ’•*`Ö P’€ Ô@’ Ò"¦ ¤ €¤ ?€€_’•*`’ € Ò “* Ô H@ Ò‘*`¡: €¢ €¦à€H€¤à€€#ÀÒ T ’#ÀÔ T@ ’#ÀÔ T’@ Ô@’ Ò"¦ÿð¿ÿ €  ¢ ¡< €¢ €€¢`¿ÿø€¤` € РDÒ Ð"`РDÒÔ@РDŸÂ€‘,à’ “* Ô T@ “,à@’‘*`Ò T “,à”@’ •*`Ö T’€ Ô@’ Ò"¦ ¤ ¿ÿ €¤à€Ò TРTÒ TÔ@’ Ò"Çàèã¿€ð' Dò' HРDÒ!lÒ'¿ìРDÒ È€¢`€%пìÒ $€¢`€À'¿äРDÒ¿äÐ ô€¢@€€ пìÒ¿ä” “*  À" Ð¿ä’ Ò'¿ä¿ÿïпìÒ DÔ`ÈÔ" $Ò¿ìпìÒ¿ìÔ`$’¿ÿÒ" $À'¿èРDÒ¿èÐ!€¢@€€AРDÒ¿è” “*  Ò!Ò'¿äРDÒ¿ä” “*  Ò øÒ'¿àп蒑*`Ô H’ пìÔ¿ä– ™*à” Ð¿ìÖ¿àØà– ™*à– Ð¿ìØ¿àÚ ˜ ›+ ˜ РDÒ@Ô ÖàLØ \ÿþúпìÒ¿ä” “*  Ò¿è” “* Ô H’@ Ô@Ò€•*`“: Ò" Ð¿è’ Ò'¿è¿ÿ»° €Çàèã·@ð' Dò' Hô' L’¿È ’ ” !@’»À ’ ”$@À'·¨Ð·¨€¢!€€ з¨’‘*`’·¸”?ÿÔ"@з¨’ Ò'·¨¿ÿñ$Ò L ’ Ò"?ÿÐ'·´æ²bÐ'· À'·¨Ð·¨€¢!€€#з¨’‘*`Ò L Ò€¢`€Ð·¨’‘*`Ò L Òз €¢@€ з¨’‘*`Ò L ÒÒ'· Ð·¨Ð'·´Ð·¨’ Ò'·¨¿ÿÛ?ÿÐ'·°æ²bÐ'· À'·¨Ð·¨€¢!€€(з¨’‘*`Ò L Ò€¢`€Ð·¨’‘*`Ò L Òз €¢@€Ð·¨Ò·´€¢ € з¨’‘*`Ò L ÒÒ'· Ð·¨Ð'·°Ð·¨’ Ò'·¨¿ÿÖз°€¢ €€ƒÐ·´’‘*`Ò L Ò·´” “* Ô L’@ Ô·°– •*àÖ L”€ Ò@Ô€’@ Ò"з°’‘*`Ò L À"з´’‘*`’»Àз´’‘*`’»ÀÔ·´– •*à–»ÀÔÀ – Ö"@з´’‘*`’·¸Ð@€¢ €€Ð·´’‘*`’·¸Ð@Ð'·´Ð·´’‘*`’»Àз´’‘*`’»ÀÔ·´– •*à–»ÀÔÀ – Ö"@¿ÿáз´’‘*`’·¸Ô·°Ô"@з°’‘*`’»Àз°’‘*`’»ÀÔ·°– •*à–»ÀÔÀ – Ö"@з°’‘*`’·¸Ð@€¢ €€Ð·°’‘*`’·¸Ð@Ð'·°Ð·°’‘*`’»Àз°’‘*`’»ÀÔ·°– •*à–»ÀÔÀ – Ö"@¿ÿá¿ÿÀ'·¨Ð·¨€¢!€€6з¨’‘*`’»ÀÐ@€¢ €)з¨’‘*`’»ÀÐ@€¢ € РDÒ 'Ð"`РDÒÔ@РDŸÂ€Ð·¨’‘*`’»ÀÐ@’¿Èз¨’‘*`’»ÀÐ@’¿ÈÔ·¨– •*à–»ÀÔÀ –¿ÈÔ À – Ö*@з¨’ Ò'·¨¿ÿÈ Ð'·¨Ð·¨€¢ €€Hз¨’¿ÈÔ @  ÿ€¢ €€:з¨’?þÒ'·¤Ð·¤’¿ÈÔ @  ÿ€¢ €€Ð·¤’?ÿÒ'·¤¿ÿôз¨’¿ÈÔ·¨–¿ÈÔ À –¿þÖ*@Ò·¨ÿ’¿ÈÔ·¨¿ÿ’¿ÈÖ·¨”ÿÿ–¿ÈÔ À – Ö*@Ò·¤`’¿ÈÖ·¤”à–¿ÈÔ À – Ö*@з¤’¿Èз¤’¿ÈÔ·¤–¿ÈÔ À –¿ÿÖ*@¿ÿÁз¨’?ÿÒ'·¨¿ÿ¶Ð·¨’¿ÈÔ @  ÿ€¢ €€Ð·¨’?ÿÒ'·¨¿ÿôз¨’¿Èз¨’¿ÈÔ·¨–¿ÈÔ À –¿ÿÖ*@’¿ÈРH” @À'·¬ Ð'·¨Ð·¨€¢ €€$À'·¤Ð·¤€¢ ÿ€€Ð·¤’‘*`’»ÀÐ@Ò·¨€¢ € РHÒ·¬ Ò·§Ò* з¬’ Ò'·¬Ð·¤’ Ò'·¤¿ÿæз¨’ Ò'·¨¿ÿÚРHÀ"!Çàèã¿Xð' DРDÒ!lÒ'¿ì’¿È ’ ” @’¿¸ ’ ” @À'¿èРDÒ¿èÐ ô€¢@€€hРDÒ¿è” “*  Ò øÒ'¿ÜпÜÒ Ò'¿äпÜÒ Ò'¿àп䒑*`’¿ÈÐ@€¢ €$п䒑*`’ XРD’ Ò'¿ØпØÒ€¢`€Ð D@Ò¿ØÐ"@Ò¿ØпìÔ¿ä– ™*à” Ð DÒ@Ô L@п䒑*`’¿È” Ô"@Ð¿à’‘*`’¿¸Ð@€¢ €$Ð¿à’‘*`’ hРD’ Ò'¿ØпØÒ€¢`€Ð D@Ò¿ØÐ"@Ò¿ØпìÔ¿à– ™*à” Ð DÒ@Ô \@Ð¿à’‘*`’¿¸” Ô"@Ð¿è’ Ò'¿è¿ÿ”Çàè㿈ð' DРDÒ Ö@РD’ ” lŸÂÀÐ'¿ìРDÒ¿ìÒ"!lп쒠Ò"À'¿èп耢 €€Ð¿ìÒ¿è” “*  Ò¿ìÔ¿è– •*à’@ À"`<À" ,пìÒ¿è” “*  Ò¿ìÔ¿è– •*à’@ À"`\À" LÐ¿è’ Ò'¿è¿ÿßÇàè㿈¤ ¢¦è  €¤`€ Р Ò (Ð"`Р ÒÔ@Р ŸÂ€’ ‘*@’?ÿ¦ À ¨’ "@§,ÀР¦À€¥ €€6‘<à’ ÿÒ'¿ìЀҿïÒ* Ð$€Ò ÿ’Ò$ €¢`€ ÿù¦€¢ €° €#п쀢 ÿ€Ð€À* Ð$€Ò ÿ’Ò$ €¢`€ ÿùŽ€¢ €° € §,à¨?ø¿ÿÉæ$ è$  ° €Çàèÿñÿñ | Th#¤4`D´”Täpe °to~HðŒX›È® ¼è¾`°ÖÝäÐà÷  8jchuff.cdump_bufferemit_restartfinish_pass_huffstart_pass_huffhtest_one_blockencode_one_blockemit_bitsgcc2_compiled.encode_mcu_gatherflush_bitsfinish_pass_gatherencode_mcu_huffjpeg_make_c_derived_tblmemsetmemcpyjinit_huff_encoderjpeg_alloc_huff_tablejpeg_natural_orderjpeg_gen_optimal_table, H0 H< È@ ÈT ¼X ¼d ¤h ¤œÐüÔ 8 D ¨ ´ Xpì¸ì`”  as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l"$"`#ð7!%(P ,&x>jcphuff.o/ 938694487 1729 22250 100664 7840 ` ELFˆ4(.shstrtab.text.symtab.strtab.rela.text.commentã¿xð' Dò' HРDÒ!lÒ'¿ìпìÒ DÒ" пìÒ HÒ" РDÒ!<”`€  `?ÿÐ'¿èРDÒ!D€¢`€Ð¿è€¢ €Ð¿ì’ Ò" €Ð¿ì’ Ò" €Ð¿è€¢ €Ð¿ì’ Ò" €Ð¿ì’ Ò" пìÒ @€¢`€ РDÒ Ö@РD’ ”#èŸÂÀÒ¿ìÐ"`@РH€¢ €Ð¿ì’ Ò" €Ð¿ì’ Ò" À'¿äРDÒ¿äÐ ô€¢@€€sРDÒ¿ä” “*  Ò øÒ'¿ÜпìÒ¿ä” “*  À" $п耢 €Ð DÒ!D€¢`€€VпÜÒ Ò'¿à€Ð¿ìÒ¿ÜÔ`Ô'¿àÔ" 4РH€¢ €=Ð¿à€¢ €Ð¿à€¢ €€Ð DÒ 2Ð"`РDÒпàÐ"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿à” “*  Ò \€¢`€Ð DÒ Ö@РD’ ”$ŸÂÀÒ¿ìÔ¿à– •*à’@ Ð"`\пìÒ¿à” “* ” Р\’ ”$@€ Ð¿à’‘*`’ Lпì–@РDÒ¿èÔ¿à@Ð¿ä’ Ò'¿ä¿ÿ‰Ð¿ìÀ" 8пìÀ" <пìÀ" пìÀ" пìÒ DÔ`ÈÔ" DпìÀ" HÇàè㿈ð' DРDÒ Ð`Ð'¿ìпìÒ DÔ Ð` ŸÂ€€¢ €Ð DÒ Ð@’ Ò" РDÒ Ð@Ò DÔÐ` ŸÂ€Ð DÒ¿ìÔ@Ô" РDÒ¿ìÔ`Ô" Çàèã¿ð' DРD’ ” @›Ð DÀ" РDÀ" Çàèã¿ð' Dò' Hô' LРDÒ €¢`€€Ð L€¢ €€Ð HÒ ‘*`“: РD” @{РH’ Ò' HРL’?ÿÒ' L¿ÿìÇàèã¿ð' DРDÒ 8€¢`€9РDà 8¢ ¡< €¢ €€¢`¿ÿø€¤`€Ð DÒ Ð@’ (Ò" РDÒ Ð@Ò DÔÐ` ŸÂ€Ò D•,`РDÒ`4@€¤`€Ò DРDÒ`8”@>РDÀ" 8Ò DÔ DРDÒ`@Ô <ÿÿ¢Ð DÀ" <Çàè㿈ð' Dò' HРDÿÿ¼Ð DÒ €¢`€.РDÿÿƒÒ D`Ò” ÿÔ*@’`Ò"Ò DРDÒ DÔ`’¿ÿ” Ô" €¢ €Ð DÿÿIÒ D`ÒÔ K–¿ÐÖ*@’`Ò"Ò DРDÒ DÔ`’¿ÿ” Ô" €¢ €Ð Dÿÿ4РDÒ Ða<€¢ €À'¿ìРDÒ Ð¿ìÒ`ô€¢ €€ РDÒ¿ì” “*  À" $Ð¿ì’ Ò'¿ì¿ÿî€Ð DÀ" 8РDÀ" <Çàèã¿xð' Dò' HРDÒ!lÒ'¿ìРDÒ!HÒ'¿àпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" РDÒ È€¢`€ пìÒ D€¢`€Ò¿ìпìÒ`Hÿÿ†À'¿èРDÒ¿èÐ!€¢@€€Zп蒑*`Ò H ÒÒ'¿ÜРDÒ¿è” “*  Ò!Ò'¿äРDÒ¿ä” “*  Ò øÒ'¿ØпÜÒ‘*`£: пà£<@пìÒ¿ä” “*  Ò $ $@ пìÒ¿ä” “*  â" $¢€¤ €  ¢ÿ¤ €¤ €€¤ ¡< ¿ÿù€¤  € РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿ØпìÒ`”@¶€¤ €Ð¿ì’”@XÐ¿è’ Ò'¿è¿ÿ¢Ò DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" РDÒ È€¢`€Ð¿ìÒ D€¢`€Ð¿ìÒ DÔ`ÈÔ" DÒ¿ìпìÒ¿ìÔ`H’ Ò" HпìÒ¿ìÔ`H’  Ò" HÒ¿ìпìÒ¿ìÔ`D’¿ÿÒ" D° €Çàèã¿€ð' Dò' HРDÒ!lÒ'¿ìРDÒ!@Ò'¿èРDÒ!HÒ'¿äпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" РDÒ È€¢`€ пìÒ D€¢`€Ò¿ìпìÒ`HÿþÑРHÒÒ'¿à¦ РDè!<п耥€€g’•*`’ € Ò “* Ô¿à@ Ò‘*`¡: €¢ €¦à€P€¤ €  пä¡<¢< €Ð¿ä¡<¢€¤ €¦à€>пìÒ 8€¢`€Ð¿ìÿþW€¤à€€ Ò¿ìпìÒ`4” ð@¦ÿð¿ÿô¤ ¡< €¢ €€¤ ¿ÿø€¤  € РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿ì‘,à”пìÒ`4@îп쒔@“¦ ¨ ¿ÿ—€¤à€Ò¿ìпìÒ¿ìÔ`8’ Ò" 8Ò¿ìÐ`8’£ÿ€¢ €Ð¿ìÿþ Ò DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" РDÒ È€¢`€Ð¿ìÒ D€¢`€Ð¿ìÒ DÔ`ÈÔ" DÒ¿ìпìÒ¿ìÔ`H’ Ò" HпìÒ¿ìÔ`H’  Ò" HÒ¿ìпìÒ¿ìÔ`D’¿ÿÒ" D° €Çàèã¿€ð' Dò' HРDÒ!lÒ'¿ìРDÒ!HÒ'¿äпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" РDÒ È€¢`€ пìÒ D€¢`€Ò¿ìпìÒ`HÿýýÀ'¿èРDÒ¿èÐ!€¢@€€Ð¿è’‘*`Ò H ÒÒ'¿àпàÒ‘*`¡: пä“<Ð¿ì” @Ð¿è’ Ò'¿è¿ÿäÒ DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" РDÒ È€¢`€Ð¿ìÒ D€¢`€Ð¿ìÒ DÔ`ÈÔ" DÒ¿ìпìÒ¿ìÔ`H’ Ò" HпìÒ¿ìÔ`H’  Ò" HÒ¿ìпìÒ¿ìÔ`D’¿ÿÒ" D° €Çàèã¾pð' Dò' HРDÒ!lÒ'¿ìРDÒ!@Ò'¿ÜРDÒ!HÒ'¿ØпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" РDÒ È€¢`€ пìÒ D€¢`€Ò¿ìпìÒ`HÿýŠÐ HÒÒ'¿ÔÀ'¿èРDä!<п܀¤€€€ ’•*`’ € Ò “* Ô¿Ô@ Ò‘*`¡: €¤ €  пء<“* ¾Ðà" €¤ €ä'¿è¤ ¿ÿÞ¢ À'¿àпìÒ¿ìÐ @Ò`< Ð'¿äРDä!<п܀¤€€€g“* ¾Ðà €¢ €¢`€Y€¤`€Ð¿è€¤€€€€Ð¿ìÿüöÒ¿ìпìÒ`4” ð@µ¢ðпìÒ¿äÔ¿àÿüÆпìÒ @Ò'¿äÀ'¿à¿ÿ․ € ¿àÒÖ¿ä”@ –˜ àØ*€’`Ò"€*пìÿüÓÒ¿ì‘,`” пìÒ`4@‘’•*`’ € Ò “* Ô¿Ô@ Ò•*`‘: ’: ¡2`п쒔 @'пìÒ¿äÔ¿àÿüпìÒ @Ò'¿äÀ'¿à¢ ¤ ¿ÿ—€¤`€Ð¿à€¢ €€Ò¿ìпìÒ¿ìÔ`8’ Ò" 8пìÒ¿ìÔ`<Ò¿à”€ Ô" <Ò¿ìÐ`8’£ÿ€¢ € пìÒ <€¢c©€€Ð¿ìÿü…Ò DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" РDÒ È€¢`€Ð¿ìÒ D€¢`€Ð¿ìÒ DÔ`ÈÔ" DÒ¿ìпìÒ¿ìÔ`H’ Ò" HпìÒ¿ìÔ`H’  Ò" HÒ¿ìпìÒ¿ìÔ`D’¿ÿÒ" D° €Çàè㿈ð' DРDÒ!lÒ'¿ìпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" пìÿüEпìÿüÒ DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" Çàèã¿hð' DРDÒ!lÒ'¿ìпìÿü.РDÒ!<”`€  `?ÿÐ'¿è’¿È ’ ” @À'¿äРDÒ¿äÐ ô€¢@€€XРDÒ¿ä” “*  Ò øÒ'¿Üп耢 €Ð DÒ!D€¢`€€AпÜÒ Ò'¿à€Ð¿ÜÒ Ò'¿àÐ¿à’‘*`’¿ÈÐ@€¢ €1п耢 € Ð¿à’‘*`’ XРD’ Ò'¿Ø€ Ð¿à’‘*`’ hРD’ Ò'¿ØпØÒ€¢`€Ð D@Ò¿ØÐ"@Ò¿ØпìÔ¿à– ™*à” Ð DÒ@Ô \@Ð¿à’‘*`’¿È” Ô"@Ð¿ä’ Ò'¿ä¿ÿ¤Çàè㿈ð' DРDÒ Ö@РD’ ” lŸÂÀÐ'¿ìРDÒ¿ìÒ"!lп쒠Ò"À'¿èп耢 €€Ð¿ìÒ¿è” “*  À" LпìÒ¿è” “*  À" \Ð¿è’ Ò'¿è¿ÿëпìÀ" @Çàè㿈¤ ¢¦è €¤`€ Р Ò (Ð"`Р ÒÔ@Р ŸÂ€Ð  €¢ €€=’ ‘*@’?ÿ¦ À ¨’ "@§,ÀР¦À€¥ €€,‘<à’ ÿÒ'¿ì ÒÔ¿ïÔ*@’`Ò"Ò ÿ’Ò$ €¢`€ÿûп쀢 ÿ€ ÒÀ*@’`Ò"Ò ÿ’Ò$ €¢`€ÿúî§,à¨?ø¿ÿÓæ$ è$ Çàè㿈¤ ¢Ð  €¢ €’‘*`”“* €Ô \@ ’‘*`”“* €Ô \@ ”“* –•*à’€ Ö`\’€ Ô@’ Ò"€“* € Ò LÒ'¿ìÒ¿ì•* пì–Ð ä™* —; Ò@ ” ÿÿxÇàèÿñÿñ t˜ \+8È?ÐhLŒXVÔo`„ \À™|„«ºtË 4Ö@éäØõÐ 6IÔ¸]jcphuff.cdump_bufferencode_mcu_AC_firstencode_mcu_DC_firstemit_restartemit_bitsfinish_pass_gather_phuffencode_mcu_AC_refineencode_mcu_DC_refinefinish_pass_phuffgcc2_compiled.start_pass_phuffflush_bitsemit_buffered_bitsemit_symbolemit_eobrunjpeg_make_c_derived_tblmemsetjpeg_alloc_huff_tablejpeg_natural_orderjinit_phuff_encoderjpeg_gen_optimal_tablep 8t 8ˆ Œ ° \´ \È Ì $ ( < |@ |ä Ä Ð à ì ¨ ´ Hd˜  as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l¼(€¨t!, ,H>jcdctmgr.o/ 938694468 1729 22250 100664 4576 ` ELF 4(.shstrtab.text.rodata.symtab.strtab.rela.text.commentã¿hð' DРDÒ!hÒ'¿ìÀ'¿èРDÒ DÒ'¿ÜРDÒ¿èÐ <€¢@€€1пÜÒ Ò'¿äп䀢 €Ð¿ä€¢ € РDÒ¿ä” “*  Ò H€¢`€€Ð DÒ 4Ð"`РDÒпäÐ"`РDÒÔ@РDŸÂ€Ð DÒ¿ä” “*  Ò HÒ'¿ØÒ DÐ`Ä€¢ €D€¢  €€¢ €„€åпìÒ¿ä” “*  Ò €¢`€Ð DÒ Ö@РD’ ”!ŸÂÀÒ¿ìÔ¿ä– •*à’@ Ð"` пìÒ¿ä” “*  Ò Ò'¿ÔÀ'¿àÐ¿à€¢ ?€€Ð¿à’‘*`Ò¿Ô Ò¿ØÔ¿à– •*àÒ@ •*`“2 •*`Ô"Ð¿à’ Ò'¿à¿ÿ逷пìÒ¿ä” “*  Ò €¢`€Ð DÒ Ö@РD’ ”!ŸÂÀÒ¿ìÔ¿ä– •*à’@ Ð"` пìÒ¿ä” “*  Ò Ò'¿ÔÀ'¿àÐ¿à€¢ ?€€!Ð¿à’‘*`Ò¿Ô  пØÒ¿à” “* Ð “* ‘2`Ô¿à– •*à–`’€ Ô@—* “:à@’$‘:` Ð$Ð¿à’ Ò'¿à¿ÿÝ€qпìÒ¿ä” “*  Ò €¢`€Ð DÒ Ö@РD’ ”!ŸÂÀÒ¿ìÔ¿ä– •*à’@ Ð"` пìÒ¿ä” “*  Ò Ò'¿ÐÀ'¿àÀ'¿Ìп̀¢ €€=À'¿ÈпȀ¢ €€1Ð¿à’‘*`Ò¿Ð Ò¿ØÔ¿à– •*àÒ@ •*`“2 Ò'¿ðÍ¿ð… Ô¿Ì– •*à–`’€ É@… ‰DÔ¿È– •*à–`’€ É@… ‰DÉ`… ‰DÉ`…¡ ‰ ÂÉ"Ð¿à’ Ò'¿àпȒ Ò'¿È¿ÿÍп̒ Ò'¿Ì¿ÿÁ€Ð DÒ 0Ð"`РDÒÔ@РDŸÂ€€Ð¿è’ Ò'¿èпܒ TÒ'¿Ü¿þËÇàèã¾xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!hÒ'¿ìпìÒ Ò'¿èпìÒ HÔ`’ •*` Ò Ò'¿äРT’‘*`Ò L@Ð' LÀ'¾ÜоÜÒ \€¢ €€Š¾à” €¢ €€<– ™*àÚ L– ØÀÖ X’ Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` ” ¿ÿþàÒ¿èŸÂ@оܒ‘*`Ò P¦ ¤ €¤ ?€€2“* Ô¿ä@ â“* ¾àà €¤ €  ‘<` €¤€ ’@ €    €‘<` €¤€ ’@ €  “* à4À ¤ ¿ÿÍоܒ Ò'¾ÜРX’ Ò' X¿ÿsÇàèã¾xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!hÒ'¿ìпìÒ Ò'¿èпìÒ HÔ`’ •*` Ò Ò'¿äРT’‘*`Ò L@Ð' LÀ'¾ÜоÜÒ \€¢ €€‹¾à” €¢ €€T– ™*àÚ L– ØÀÖ X’ Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` ” ¿ÿ«¾àÒ¿èŸÂ@Ծܖ •*àÖ P’€  €¢ ?€€–•*à–¾à˜›+ Ä¿ä˜@ÇÀ É… É$–•*àÉà‡ ˆ$‹ #Ë'¿ðÖ¿ð˜ ?ÿð– Ö2@  ¿ÿäоܒ Ò'¾ÜРX’ Ò' X¿ÿrÇàè㿈ð' DРDÒ Ö@РD’ ” 0ŸÂÀÐ'¿ìРDÒ¿ìÒ"!hп쒠Ò"Ò DÐ`Ä€¢ €€¢  €€¢ €€ п쒠Ò" п쒠Ò" €"п쒠Ò" п쒠Ò" €Ð¿ì’ Ò" п쒠Ò" €Ð DÒ 0Ð"`РDÒÔ@РDŸÂ€€À'¿èп耢 €€Ð¿ìÒ¿è” “*  À" пìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿëÇàè@XÅSŸKB@2I"£¨XÅ{!sühbXÅE¿0 ~SŸsümAbTSŸA³-AKBhbbTX~KB;!(ºÃ@XÅSŸKB@2I"£¨2IE¿A³;!2I'‚7 à"£0 -A(º"£7¿ Ž¨~è à Žß?ð?ö1P±Haï?ô箑MoÊ?òÐbïlª?ð?é$iÀ§¿;?áQz{Ç »?ѨUÞr«]@ ?ðF€ÿñÿñ €'¼¸9´E€@Viy‰™Ÿ t±jcdctmgr.cgcc2_compiled.aanscales.2forward_DCT_floatforward_DCTaanscalefactor.3start_pass_fdctmgrjpeg_fdct_floatjpeg_fdct_ifastjpeg_fdct_islow.umuljinit_forward_dct.divÐ à ô  €$ €4 €D €T ÀX À` Èd È$d  Ð  Ð ° ´ ô  ø        , 0 D ¼ H ¼ T X as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14= t  xÔ L !L¶)\ 4`>jfdctfst.o/ 938694528 1729 22250 100664 2476 ` ELF¼4(.shstrtab.text.symtab.strtab.commentã¿8ð' DРDÐ'¿  Ð'¿œÐ¿œ€¢ €€êп ’ Ô¿ ’@ ÐÒ@ Ð'¿ìп ’ Ô¿ ’@ ÐÒ@" Ð'¿Ð Ò¿  ’ Ô¿ ’@ ÐÒ@ Ð'¿è Ò¿  ’ Ô¿ ’@ ÐÒ@" Ð'¿Ô Ò¿  ’ Ô¿ ’@ ÐÒ@ Ð'¿ä Ò¿  ’ Ô¿ ’@ ÐÒ@" Ð'¿Ø Ò¿  ’ Ô¿ ’@ ÐÒ@ Ð'¿à Ò¿  ’ Ô¿ ’@ ÐÒ@" Ð'¿ÜпìÒ¿à Ð'¿ÌпìÒ¿à" Ð'¿ÀпèÒ¿ä Ð'¿ÈпèÒ¿ä" Ð'¿Äп Ò¿ÌÔ¿È’@ Ò" Ò¿  Ò¿ÌÔ¿È’"@ Ò"пÄÒ¿À ’•*`”€“* ’"@ •*`”€‘: Ð'¿¼ Ò¿  Ò¿ÀÔ¿¼’@ Ò" Ò¿  Ò¿ÀÔ¿¼’"@ Ò"пÜÒ¿Ø Ð'¿ÌпØÒ¿Ô Ð'¿ÈпÔÒ¿Ð Ð'¿ÄпÌÒ¿Ä" ”“* ’@•*`”€‘* “: Ò'¿¬Ð¿Ì”“* ’@•*`”"€“* ’"@‘:`Ò¿¬ Ð'¿¸Ð¿Ä”“* ’@•*`”€“* ’"@‘*`“: п¬’@Ò'¿°Ð¿È’•*`”€“* ’"@ •*`”€‘: Ð'¿´Ð¿ÐÒ¿´ Ð'¿¨Ð¿ÐÒ¿´" Ð'¿¤ Ò¿  Ò¿¤Ô¿¸’@ Ò" Ò¿  Ò¿¤Ô¿¸’"@ Ò" Ò¿  Ò¿¨Ô¿°’@ Ò" Ò¿  Ò¿¨Ô¿°’"@ Ò"п ’ Ò'¿ Ð¿œ’?ÿÒ'¿œ¿ÿРDÐ'¿  Ð'¿œÐ¿œ€¢ €€êп ’ àÔ¿ ’@ ÐÒ@ Ð'¿ìп ’ àÔ¿ ’@ ÐÒ@" Ð'¿Ð Ò¿  ’ ÀÔ¿ ’@ ÐÒ@ Ð'¿è Ò¿  ’ ÀÔ¿ ’@ ÐÒ@" Ð'¿Ô @Ò¿  ’  Ô¿ ’@ ÐÒ@ Ð'¿ä @Ò¿  ’  Ô¿ ’@ ÐÒ@" Ð'¿Ø `Ò¿  ’ €Ô¿ ’@ ÐÒ@ Ð'¿à `Ò¿  ’ €Ô¿ ’@ ÐÒ@" Ð'¿ÜпìÒ¿à Ð'¿ÌпìÒ¿à" Ð'¿ÀпèÒ¿ä Ð'¿ÈпèÒ¿ä" Ð'¿Äп Ò¿ÌÔ¿È’@ Ò" €Ò¿  Ò¿ÌÔ¿È’"@ Ò"пÄÒ¿À ’•*`”€“* ’"@ •*`”€‘: Ð'¿¼ @Ò¿  Ò¿ÀÔ¿¼’@ Ò" ÀÒ¿  Ò¿ÀÔ¿¼’"@ Ò"пÜÒ¿Ø Ð'¿ÌпØÒ¿Ô Ð'¿ÈпÔÒ¿Ð Ð'¿ÄпÌÒ¿Ä" ”“* ’@•*`”€‘* “: Ò'¿¬Ð¿Ì”“* ’@•*`”"€“* ’"@‘:`Ò¿¬ Ð'¿¸Ð¿Ä”“* ’@•*`”€“* ’"@‘*`“: п¬’@Ò'¿°Ð¿È’•*`”€“* ’"@ •*`”€‘: Ð'¿´Ð¿ÐÒ¿´ Ð'¿¨Ð¿ÐÒ¿´" Ð'¿¤  Ò¿  Ò¿¤Ô¿¸’@ Ò" `Ò¿  Ò¿¤Ô¿¸’"@ Ò" Ò¿  Ò¿¨Ô¿°’@ Ò" àÒ¿  Ò¿¨Ô¿°’"@ Ò"п ’ Ò'¿ Ð¿œ’?ÿÒ'¿œ¿ÿÇàèÿñÿñ  jfdctfst.cgcc2_compiled.jpeg_fdct_ifastas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14* ` PP+!{>jfdctflt.o/ 938694527 1729 22250 100664 2648 ` ELF 4(.shstrtab.text.rodata.symtab.strtab.rela.text.commentã¿8ð' DРDÐ'¿  Ð'¿œÐ¿œ€¢ €€Ñп ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿ìп ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿Ð Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿è Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿Ô Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿ä Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿Ø Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿à Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿ÜÅ¿ìÇ¿à… ˆ#Å'¿ÌÅ¿ìÇ¿à… ˆ£Å'¿ÀÅ¿èÇ¿ä… ˆ#Å'¿ÈÅ¿èÇ¿ä… ˆ£Å'¿Äп Å¿ÌÇ¿È… ˆ#Å" Ò¿  Å¿ÌÇ¿È… ˆ£Å"Å¿ÄÇ¿À… ˆ#Ç … ‰#Å'¿¼ Ò¿  Å¿ÀÇ¿¼… ˆ#Å" Ò¿  Å¿ÀÇ¿¼… ˆ£Å"Å¿ÜÇ¿Ø… ˆ#Å'¿ÌÅ¿ØÇ¿Ô… ˆ#Å'¿ÈÅ¿ÔÇ¿Ð… ˆ#Å'¿ÄÅ¿ÌÇ¿Ä… ˆ£Ç … ‰#Å'¿¬Å¿ÌÇ … ‰#Ç¿¬… ˆ#Å'¿¸Å¿ÄÇ … ‰#Ç¿¬… ˆ#Å'¿°Å¿ÈÇ … ‰#Å'¿´Å¿ÐÇ¿´… ˆ#Å'¿¨Å¿ÐÇ¿´… ˆ£Å'¿¤ Ò¿  Å¿¤Ç¿¸… ˆ#Å" Ò¿  Å¿¤Ç¿¸… ˆ£Å" Ò¿  Å¿¨Ç¿°… ˆ#Å" Ò¿  Å¿¨Ç¿°… ˆ£Å"п ’ Ò'¿ Ð¿œ’?ÿÒ'¿œ¿ÿ-РDÐ'¿  Ð'¿œÐ¿œ€¢ €€Ñп ’ àÔ¿ ’@ ÅÇ@… ˆ#Å'¿ìп ’ àÔ¿ ’@ ÅÇ@… ˆ£Å'¿Ð Ò¿  ’ ÀÔ¿ ’@ ÅÇ@… ˆ#Å'¿è Ò¿  ’ ÀÔ¿ ’@ ÅÇ@… ˆ£Å'¿Ô @Ò¿  ’  Ô¿ ’@ ÅÇ@… ˆ#Å'¿ä @Ò¿  ’  Ô¿ ’@ ÅÇ@… ˆ£Å'¿Ø `Ò¿  ’ €Ô¿ ’@ ÅÇ@… ˆ#Å'¿à `Ò¿  ’ €Ô¿ ’@ ÅÇ@… ˆ£Å'¿ÜÅ¿ìÇ¿à… ˆ#Å'¿ÌÅ¿ìÇ¿à… ˆ£Å'¿ÀÅ¿èÇ¿ä… ˆ#Å'¿ÈÅ¿èÇ¿ä… ˆ£Å'¿Äп Å¿ÌÇ¿È… ˆ#Å" €Ò¿  Å¿ÌÇ¿È… ˆ£Å"Å¿ÄÇ¿À… ˆ#Ç … ‰#Å'¿¼ @Ò¿  Å¿ÀÇ¿¼… ˆ#Å" ÀÒ¿  Å¿ÀÇ¿¼… ˆ£Å"Å¿ÜÇ¿Ø… ˆ#Å'¿ÌÅ¿ØÇ¿Ô… ˆ#Å'¿ÈÅ¿ÔÇ¿Ð… ˆ#Å'¿ÄÅ¿ÌÇ¿Ä… ˆ£Ç … ‰#Å'¿¬Å¿ÌÇ … ‰#Ç¿¬… ˆ#Å'¿¸Å¿ÄÇ … ‰#Ç¿¬… ˆ#Å'¿°Å¿ÈÇ … ‰#Å'¿´Å¿ÐÇ¿´… ˆ#Å'¿¨Å¿ÐÇ¿´… ˆ£Å'¿¤  Ò¿  Å¿¤Ç¿¸… ˆ#Å" `Ò¿  Å¿¤Ç¿¸… ˆ£Å" Ò¿  Å¿¨Ç¿°… ˆ#Å" àÒ¿  Å¿¨Ç¿°… ˆ£Å"п ’ Ò'¿ Ð¿œ’?ÿÒ'¿œ¿ÿ-Çàè?5ó>Ãï? ‹Ô?§=uÿñÿñ Øjfdctflt.cgcc2_compiled.jpeg_fdct_floatÜ à ` d t x  ” ¬ ° @ D Ä È Ø Ü ô ø   as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14= tØL\`!¼+)èð 4Ø>jfdctint.o/ 938694530 1729 22250 100664 3348 ` ELF $4(.shstrtab.text.symtab.strtab.commentã¿@ð' DРDÐ'¿¨ Ð'¿¤Ð¿¤€¢ €€Sп¨’ Ô¿¨’@ ÐÒ@ Ð'¿ìп¨’ Ô¿¨’@ ÐÒ@" Ð'¿Ð Ò¿¨ ’ Ô¿¨’@ ÐÒ@ Ð'¿è Ò¿¨ ’ Ô¿¨’@ ÐÒ@" Ð'¿Ô Ò¿¨ ’ Ô¿¨’@ ÐÒ@ Ð'¿ä Ò¿¨ ’ Ô¿¨’@ ÐÒ@" Ð'¿Ø Ò¿¨ ’ Ô¿¨’@ ÐÒ@ Ð'¿à Ò¿¨ ’ Ô¿¨’@ ÐÒ@" Ð'¿ÜпìÒ¿à Ð'¿ÌпìÒ¿à" Ð'¿ÀпèÒ¿ä Ð'¿ÈпèÒ¿ä" Ð'¿Äп¨Ò¿ÌÔ¿È’@ •*`Ô" Ò¿¨ Ò¿ÌÔ¿È’"@ •*`Ô"пÄÒ¿À ”“* ’@•*`”"€‘* ’" Ò'¿¼ Ò¿¨ Ò¿À– •*à”€ —* –À •*à”"€ “* Ô¿¼’@ ”d“:  Ò" Ò¿¨ Ò¿Ä– •*à”"€ —* –"À •*à”€ —* –À ’ Ô¿¼’@ ”d“:  Ò"пÜÒ¿Ð Ð'¿¼Ð¿ØÒ¿Ô Ð'¿¸Ð¿ÜÒ¿Ô Ð'¿´Ð¿ØÒ¿Ð Ð'¿°Ð¿´Ò¿° ’•*`”€“* ’"@ •*`”€“* @Ð'¿¬Ð¿Ü”“* ’@•*`’@ •*`”"€‘* Ð'¿Üпؔ“* ’@•*`”"€“* ’"@•*`”€“* "@Ð'¿ØпԔ“* ’@•*`’@ •*`”"€‘* " “* Ò'¿ÔпД“* ’@•*` ’@ •*`"€Ð'¿Ðп¼”“* ’"@•*`”€“* ’"@•*`”€“* ’"@•*`€’ Ò'¿¼Ð¿¸”“* ’@•*`”€“* ’@•*`"€’ Ò'¿¸Ð¿´”“* ’"@•*`”"€“* ’@•*`€’ Ò'¿´Ð¿°”“* ’@•*`”€“* ’"@‘*`’ Ò'¿°Ð¿´Ò¿¬ Ð'¿´Ð¿°Ò¿¬ Ð'¿° Ò¿¨ Ò¿ÜÔ¿¼’@ Ô¿´’@ ”d“:  Ò" Ò¿¨ Ò¿ØÔ¿¸’@ Ô¿°’@ ”d“:  Ò" Ò¿¨ Ò¿ÔÔ¿¸’@ Ô¿´’@ ”d“:  Ò" Ò¿¨ Ò¿ÐÔ¿¼’@ Ô¿°’@ ”d“:  Ò"п¨’ Ò'¿¨Ð¿¤’?ÿÒ'¿¤¿þ«Ð DÐ'¿¨ Ð'¿¤Ð¿¤€¢ €€[п¨’ àÔ¿¨’@ ÐÒ@ Ð'¿ìп¨’ àÔ¿¨’@ ÐÒ@" Ð'¿Ð Ò¿¨ ’ ÀÔ¿¨’@ ÐÒ@ Ð'¿è Ò¿¨ ’ ÀÔ¿¨’@ ÐÒ@" Ð'¿Ô @Ò¿¨ ’  Ô¿¨’@ ÐÒ@ Ð'¿ä @Ò¿¨ ’  Ô¿¨’@ ÐÒ@" Ð'¿Ø `Ò¿¨ ’ €Ô¿¨’@ ÐÒ@ Ð'¿à `Ò¿¨ ’ €Ô¿¨’@ ÐÒ@" Ð'¿ÜпìÒ¿à Ð'¿ÌпìÒ¿à" Ð'¿ÀпèÒ¿ä Ð'¿ÈпèÒ¿ä" Ð'¿Äп¨Ò¿ÌÔ¿È’@ ”`“: Ò" €Ò¿¨ Ò¿ÌÔ¿È’"@ ”`“: Ò"пÄÒ¿À ”“* ’@•*`”"€‘* ’" Ò'¿¼ @Ò¿¨ Ò¿À– •*à”€ —* –À •*à”"€ “* Ô¿¼’@ ’@ •:`Ô" ÀÒ¿¨ Ò¿Ä– •*à”"€ —* –"À •*à”€ —* –À ’ Ô¿¼’@ ’@ •:`Ô"пÜÒ¿Ð Ð'¿¼Ð¿ØÒ¿Ô Ð'¿¸Ð¿ÜÒ¿Ô Ð'¿´Ð¿ØÒ¿Ð Ð'¿°Ð¿´Ò¿° ’•*`”€“* ’"@ •*`”€“* @Ð'¿¬Ð¿Ü”“* ’@•*`’@ •*`”"€‘* Ð'¿Üпؔ“* ’@•*`”"€“* ’"@•*`”€“* "@Ð'¿ØпԔ“* ’@•*`’@ •*`”"€‘* " “* Ò'¿ÔпД“* ’@•*` ’@ •*`"€Ð'¿Ðп¼”“* ’"@•*`”€“* ’"@•*`”€“* ’"@•*`€’ Ò'¿¼Ð¿¸”“* ’@•*`”€“* ’@•*`"€’ Ò'¿¸Ð¿´”“* ’"@•*`”"€“* ’@•*`€’ Ò'¿´Ð¿°”“* ’@•*`”€“* ’"@‘*`’ Ò'¿°Ð¿´Ò¿¬ Ð'¿´Ð¿°Ò¿¬ Ð'¿° àÒ¿¨ Ò¿ÜÔ¿¼’@ Ô¿´’@ ’@ •:`Ô"  Ò¿¨ Ò¿ØÔ¿¸’@ Ô¿°’@ ’@ •:`Ô" `Ò¿¨ Ò¿ÔÔ¿¸’@ Ô¿´’@ ’@ •:`Ô" Ò¿¨ Ò¿ÐÔ¿¼’@ Ô¿°’@ ’@ •:`Ô"п¨’ Ò'¿¨Ð¿¤’?ÿÒ'¿¤¿þ£Çàèÿñÿñ  jfdctint.cgcc2_compiled.jpeg_fdct_islowas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14* `  hP ¸+! ã>jdapimin.o/ 938694496 1729 22250 100664 4620 ` ELFÌ4(.shstrtab.text.rodata.symtab.strtab.rela.text.commentã¿€ð' Dò' Hô' LРDÀ" РH€¢ >€Ð DÒ Ð"`РDÒ >Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð L€¢!ЀРDÒ Ð"`РDÒ!ÐÐ"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð DÒÒ'¿èРDÒ Ò'¿äРD’ ”!Ð@РDÒ¿èÒ"РDÒ¿äÒ" РD’ Ò" РD@РDÀ" РDÀ" À'¿ìп쀢 €€ РDÒ¿ì” “*  À" ¤Ð¿ì’ Ò'¿ì¿ÿñÀ'¿ìп쀢 €€Ð DÒ¿ì” “*  À" ´Ð DÒ¿ì” “*  À" ÄÐ¿ì’ Ò'¿ì¿ÿëРDÀ"!0РD@РD@РD’ ÈÒ" Çàèã¿ð' DРD@Çàèã¿ð' DРD@Çàèã¿€ð' DÒ DÐ`$€¢ €€¢ €€¢ € €ß€¢ €¢€ÚРD’ Ò" (РD’ Ò" ,€ØРDÒ!€¢`€Ð D’ Ò" (€‰Ð DÒ!$€¢`€/РDÒ !( `ÿ€¢ €€¢ € € РD’ Ò" (€Ð D’ Ò" (€Ð DÒ rÐ"`Ò DÐ@Ò DÔ a(’  ÿÒ" РDÒÔ`РD’?ÿŸÂ€Ð D’ Ò" (€€WРDÒ ØÐ@Ð'¿ìРD’ TÔ Ø@ ÒÒ'¿èРD’ ¨Ô Ø@ ÒÒ'¿äп쀢 €Ð¿è€¢ € п䀢 €Ð D’ Ò" (€6п쀢 R€Ð¿è€¢ G€ п䀢 B€Ð D’ Ò" (€%РDÒ`Ð'¿àпàÒ¿ìÒ" Ò¿à Ò¿èÒ" Ò¿à Ò¿äÒ"РDÒ oÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿâРD’ Ò" (РD’ Ò" ,€BРDÒ!$€¢`€/РDÒ !( `ÿ€¢ €€¢ € € РD’ Ò" (€Ð D’ Ò" (€Ð DÒ rÐ"`Ò DÐ@Ò DÔ a(’  ÿÒ" РDÒÔ`РD’?ÿŸÂ€Ð D’ Ò" (€€Ð D’ Ò" (РD’ Ò" ,€Ð DÀ" (РDÀ" ,€Ð D’ Ò" 0РD’ Ò" 4РDÔ`Ô: 8РDÀ" @РDÀ" DРDÀ" HРD’ Ò" LРD’ Ò" PРDÀ" TРD’ Ò" XРD’ Ò" \РD’!Ò" `РDÀ" ˆÐ DÀ" dРDÀ" hРDÀ" lÇàè㿈ð' Dò' HРDÒ €¢`ȀРDÒ €¢`ɀРDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð D@Ð'¿ìп쀢 €€¢ €€¢ €"€"€¢ €€ Ð'¿ì€Ð H€¢ € РDÒ 3Ð"`РDÒÔ@РDŸÂ€Ð D@ Ð'¿ì€€Ð¿ì°€Çàè㿈ð' DÀ'¿ìРDÒ 8€¢ €C’‘*`’ Ð ÂРDÒ!´Ô`РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð D’ ÉÒ" РDÒ!´Ô@РDŸÂ€Ð'¿ìп쀢 €Ð Dÿþ[РD’ ÊÒ" € Ð'¿ì€Ð DÒ!´Ô@РDŸÂ€Ð'¿ì€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð¿ì°€Çàèã¿ð' DРDÒ €¢`Ç€ РDÒ €¢`Ò€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!´Ð`°€Çàèã¿ð' DРDÒ €¢`É€ РDÒ €¢`Ò€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!´Ð`°€Çàèã¿ð' DРDÒ €¢`Í€ РDÒ €¢`΀€#РDÒ @€¢`€Ð DÒ DÐ ŒÒ`t€¢ € РDÒ CÐ"`РDÒÔ@РDŸÂ€Ð DÒ!¤Ô`РDŸÂ€Ð D’ ÒÒ" € РDÒ €¢`πРD’ ÒÒ" €Ð DÒ €¢`ҀРDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!´Ð`€¢ €€Ð DÒ!´Ô@РDŸÂ€€¢ €° €¿ÿìРDÒ Ô`РDŸÂ€Ð D@° €Çàè?ðÿñÿñ Lt%4E „”Yf ”~–ÀH®¹0Ïåü|# ¬Èjdapimin.cdefault_decompress_parmsgcc2_compiled.jinit_memory_mgrjpeg_input_completejpeg_destroyjpeg_has_multiple_scansjpeg_destroy_decompressmemsetjpeg_read_headerjpeg_abortjpeg_abort_decompressjpeg_CreateDecompressjinit_input_controllerjpeg_consume_inputjinit_marker_readerjpeg_finish_decompressì ìø < 0 4 4Ð 4 H8 HHtL°PüT X \ ` d h l 0p X as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14= t t è ð@!0:)l  4Œ>jdapistd.o/ 938694498 1729 22250 100664 3268 ` ELF ¬4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' DРDÒ €¢`ʀРD@РDÒ @€¢`€Ð D’ ÏÒ" ° €yРD’ ËÒ" РDÒ €¢`Ë€WРDÒ!´Ð`€¢ €KРDÒ €¢`€Ð DÒ Ô@РDŸÂ€Ð DÒ!´Ô@РDŸÂ€Ð'¿ìп쀢 €° €Rп쀢 €€,РDÒ €¢`€%п쀢 €Ð¿ì€¢ €€Ò DÐ`Ò DÐ`Ò DÔ`Ò ”`’ Ò" РDÔ Ð €¢@€ Ò DÐ`Ò DÔ`Ò DÔ Òa@”€ Ô" ¿ÿ¹Ð DÒ DÔ`Ô" ˜€Ð DÒ €¢`̀РDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð D@°€Çàè㿈ð' DРDÒ €¢`Ì€ РDÒ!¤Ô@РDŸÂ€Ð DÀ" ŒÐ D’ ÌÒ" РDÒ!¤Ð`€¢ €€HРDÒ DÐ ŒÒ`t€¢ €€/РDÒ €¢`€Ò DÐ`Ò DÔ`ŒÔ" Ò DÐ`Ò DÔ`tÔ" РDÒ Ô@РDŸÂ€Ð DÒ ŒÒ'¿ìÒ DÐa¨Ò D”`ŒØ РD’ – ŸÃРDÒ ŒÐ¿ì€¢@€° €"¿ÿÌРDÒ!¤Ô`РDŸÂ€Ð DÒ!¤Ô@РDŸÂ€Ð DÀ" Œ¿ÿ´Ð DÒ DÔ`D€¢ €’ ΀’ ÍÒ" ° €Çàè㿈ð' Dò' Hô' LРDÒ €¢`̀РDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ DÐ ŒÒ`t€¢ €Ð DÒ {Ð"`РDÒÔ`РD’?ÿŸÂ€° €+РDÒ €¢`€Ò DÐ`Ò DÔ`ŒÔ" Ò DÐ`Ò DÔ`tÔ" РDÒ Ô@РDŸÂ€À'¿ìРDÒ!¨”¿ìØ`РDÒ HÖ LŸÃРDÒ DÔ`ŒÒ¿ì”€ Ô" ŒÐ¿ì°€Çàè㿈ð' Dò' Hô' LРDÒ €¢`΀РDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ DÐ ŒÒ`t€¢ €Ð DÒ {Ð"`РDÒÔ`РD’?ÿŸÂ€° €DРDÒ €¢`€Ò DÐ`Ò DÔ`ŒÔ" Ò DÐ`Ò DÔ`tÔ" РDÒ Ô@РDŸÂ€Ð DÒ DÐ!8Òa<@Ð'¿ìРLҿ쀢 € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ!¬Ô` РDÒ HŸÂ€€¢ €° € РDÒ DÔ`ŒÒ¿ì”€ Ô" ŒÐ¿ì°€Çàèã¿ð' Dò' HРDÒ €¢`πРDÒ €¢`̀РDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð H€¢ € Ð' HРDÒ!´Ð`€¢ € РDÒ HÐ €¢@€Ð DÒ Ò' HРDÒ HÒ" ˜Ð Dÿþ‘°€Çàèã¿ð' DРDÒ €¢`Í€ РDÒ €¢`΀€Ð DÒ @€¢`€ РDÒ!¤Ô`РDŸÂ€Ð D’ ÐÒ" €Ð DÒ €¢`ЀРDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ DÐ Ò`˜€¢ € РDÒ!´Ð`€¢ €€€Ð DÒ!´Ô@РDŸÂ€€¢ €° € ¿ÿãРD’ ÏÒ" ° €Çàèÿñÿñ 8Ä-Eü`Y_ ðq8‡\Äšhjdapistd.cgcc2_compiled.output_pass_setupjinit_master_decompressjpeg_read_scanlines.umuljpeg_start_outputjpeg_start_decompressjpeg_read_raw_datajpeg_finish_output tas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l x äÀ ¤­! T , l>jdtrans.o/ 938694524 1729 22250 100664 1768 ` ELFÐ4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' DРDÒ €¢`ʀРD@РD’ ÑÒ" РDÒ €¢`Ñ€NРDÒ €¢`€Ð DÒ Ô@РDŸÂ€Ð DÒ!´Ô@РDŸÂ€Ð'¿ìп쀢 €° €^п쀢 €€,РDÒ €¢`€%п쀢 €Ð¿ì€¢ €€Ò DÐ`Ò DÐ`Ò DÔ`Ò ”`’ Ò" РDÔ Ð €¢@€ Ò DÐ`Ò DÔ`Ò DÔ Òa@”€ Ô" ¿ÿ¹Ð D’ ÒÒ" РDÒ €¢`Ò€ РDÒ €¢`Ï€€ РDÒ @€¢`€Ð DÒ!¬Ð`°€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€° €Çàè㿈ð' DРD’ Ò" @РDÒ à€¢`€Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ Ü€¢`€Ð D@€Ð D@РD’ @РDÒ Ô`РDŸÂ€Ð DÒ!´Ô`РDŸÂ€Ð DÒ €¢`€/РDÒ Ü€¢`€ Ò DÐ`$”“* ’@`Ð'¿ì€Ð DÒ!´Ð`€¢ €Ð DÒ $Ò'¿ì€ Ð'¿ìРDÒ À"`РDà Ò DÐa@Ò¿ì@Ð$ РDÒ À"` РDÒ  Ð"`Çàèÿñÿñ $œ7OUh|$jdtrans.cgcc2_compiled.transdecode_master_selectionjinit_d_coef_controller.umuljinit_huff_decoderjinit_phuff_decoderjpeg_read_coefficients”¨¸as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 lÀ, Ì“!`0 ,>jdatasrc.o/ 938694500 1729 22250 100664 1648 ` ELFX4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' DРDÒ Ò'¿ìÐ¿ì’ Ò" $Çàè㿈ð' DРDÒ Ò'¿ìпìÖ¿ìÐ ’ Öà@Ð'¿èп耢 €(пìÒ $€¢`€ РDÒ *Ð"`РDÒÔ@РDŸÂ€Ð DÒ xÐ"`РDÒÔ`РD’?ÿŸÂ€Ð¿ìÒ  ÿÐ*@Ð¿ì’ Ô @ ’ ÙÒ* Ð'¿èпìÒ¿ìÔ` Ô"пìÒ¿èÒ" пìÀ" $° €Çàè㿈ð' Dò' HРDÒ Ò'¿ìРH€¢ € пìÒ HÐ €¢@€€ пìÒ HÐ ’"@Ò' HРDÿÿ¢¿ÿðпìÒ¿ìÔ@Ò H”€ Ô"пìÒ¿ìÔ`Ò H”"€ Ô" Çàèã¿ð' DÇàè㿈ð' Dò' HРDÒ €¢`€Ð DÒ Ö@РD’ ” (ŸÂÀÒ DÐ"`РDÒ Ò'¿ìРDÒ Ö@РD’ ŸÂÀÒ¿ìÐ"` РDÒ Ò'¿ìп쒠Ò" п쒠Ò" п쒠Ò" п쒠Ò" п쒠Ò" пìÒ HÒ" пìÀ" пìÀ"Çàèÿñÿñ (-è9(E@¨U[øüjjdatasrc.cfill_input_buffergcc2_compiled.term_sourceinit_sourceskip_input_datafreadjpeg_stdio_srcjpeg_resync_to_restartT„ ˆ ” (˜ (¤ @¨ @´ ¸ Ä èÈ èas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 lô`°!”„ ,>jdmaster.o/ 938694516 1729 22250 100664 6584 ` ELF 4(.shstrtab.text.symtab.strtab.rela.text.commentã¿ð' DРDÒ L€¢`€ РDÒ!,€¢`€€° €pРDÒ (€¢`€Ð DÒ $€¢`€Ð DÒ ,€¢`€ РDÒ x€¢`€€° €WРDÒ ØÐ`€¢ €*РD’ TÔ Ø@ Ò €¢`€"РD’ ¨Ô Ø@ Ò €¢`€Ð DÒ ØÐ` €¢ €Ð D’ TÔ Ø@ Ò €¢`€ РD’ ¨Ô Ø@ Ò €¢`€€° €&РDÒ ØРDÒ`$Ð!<€¢@€Ð D’ TÔ Ø@ Ò DÐ $Òa<€¢ €Ð D’ ¨Ô Ø@ Ò DÐ $Òa<€¢ €€° €° €Çàèã¿€ð' DРDÒ €¢`ʀРDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ 0” ‘* Ò DÔ`4€¢ €Ò DÐ`’ @Ò DÐ"`pÒ DÐ` ’ @Ò DÐ"`tРD’ Ò"!<€EРDÒ 0” ‘* Ò DÔ`4€¢ €Ò DÐ`’ @Ò DÐ"`pÒ DÐ` ’ @Ò DÐ"`tРD’ Ò"!<€)РDÒ 0” ‘* Ò DÔ`4€¢ €Ò DÐ`’ @Ò DÐ"`pÒ DÐ` ’ @Ò DÐ"`tРD’ Ò"!<€ РDÒ DÔ`Ô" pРDÒ DÔ` Ô" tРD’ Ò"!<À'¿ìРDÒ ØÒ'¿èРDÒ¿ìÐ $€¢@€€>РDÒ!<Ò'¿äп䀢 €$Ò¿èÐ`Ò¿ä@’¡*`РDÒ DÐ!4Òa<@€¤€Ò¿èÐ` Ò¿ä@’¡*`РDÒ DÐ!8Òa<@€¤€€€Ð¿ä’‘*`Ð'¿ä¿ÿÔпèÒ¿äÒ" $Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ¾À'¿ìРDÒ ØÒ'¿èРDÒ¿ìÐ $€¢@€€4à DпèÒ¿èÐ Ò`$@’ Ò @Ò DÔa4’ •*`’ @Ò¿èÐ"`(à DпèÒ¿èÐ Ò`$@’ Ò @Ò DÔa8’ •*`’ @Ò¿èÐ"`,Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿÈРDÒ ,ÿ€¢ €’‘*`’ Ð ÂРD’ Ò" x€Ð D’ Ò" x€ РD’ Ò" x€Ð DÒ DÔ`$Ô" x€Ð DÒ DÔ`T€¢ €Ô DÒ x€’ Ò" |РDÿþN€¢ €Ð DÒ DÔa8Ô" €€Ð D’ Ò" €Çàè㿈ð' DРDÒ Ö@РD’ ”%€ŸÂÀÐ'¿ìпì’!Ò'¿ìРDÒ¿ìÒ"!Dпì’? ’ ”!@À'¿èп耢 ÿ€€ пìÒ¿è Ò¿ëÒ*Ð¿è’ Ò'¿è¿ÿòÐ¿ì’ €Ò'¿ì €Ð'¿èп耢!ÿ€€ пìÒ¿è ’ ÿÒ*Ð¿è’ Ò'¿è¿ÿòпì’" ’ ”!€@Ò¿ìc€Ò DÒaD” €@Çàèã¿xð' DРDÒ!¤Ò'¿ìРD@РDÿÿ©Ð DÒ DÐ pÒ`x@Ð'¿äпäÐ'¿àпàҿ䀢 € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð¿ìÀ" РDÿýÊÒ¿ìÐ"`пìÀ" пìÀ" РDÒ T€¢`€ РDÒ @€¢`€ €Ð DÀ" dРDÀ" hРDÀ" lРDÒ T€¢`€WРDÒ D€¢`€ РDÒ /Ð"`РDÒÔ@РDŸÂ€Ð DÒ x€¢`€ РD’ Ò" dРDÀ" hРDÀ" lРDÀ" ˆ€Ð DÒ ˆ€¢`€Ð D’ Ò" h€Ð DÒ \€¢`€Ð D’ Ò" l€Ð D’ Ò" dРDÒ d€¢`€ РD@пìÒ DÔaÌÔ" РDÒ l€¢`€ РDÒ h€¢`€€ РD@пìÒ DÔaÌÔ" РDÒ D€¢`€Ð¿ìÒ €¢`€Ð D@€Ð D@РD@Ò DРDÒ`l@РD@РDÒ à€¢`€Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ Ü€¢`€Ð D@€Ð D@ Ò DÔa´Ò €¢`€ Ò DÔ`@€¢ €€ Ð'¿èРDÒ¿è@РDÒ D€¢`€Ð D’ @РDÒ Ô`РDŸÂ€Ð DÒ!´Ô`РDŸÂ€Ð DÒ €¢`€>РDÒ @€¢`€9РDÒ!´Ð`€¢ €3РDÒ Ü€¢`€ Ò DÐ`$”“* ’@`Ð'¿Ü€Ð DÒ $Ò'¿ÜРDÒ À"`РDà Ò DÐa@Ò¿Ü@Ð$ РDÒ À"` Ò DÐ`Ò DÔ`l€¢ €’ €’ Ò" Ò¿ìпìÒ¿ìÔ` ’ Ò" Çàè㿈ð' DРDÒ!¤Ò'¿ìпìÒ €¢`€Ð¿ìÀ" РDÒ!ÌÔ@РD’ ŸÂ€Ð DÒ!°Ô@РD’ ŸÂ€Ð DÒ!¨Ô@РD’ ŸÂ€€yРDÒ T€¢`€/РDÒ ˆ€¢`€*РDÒ \€¢`€Ð DÒ l€¢`€ РDÒ¿ìÔ`Ô"!ÌÐ¿ì’ Ò" €Ð DÒ d€¢`€Ð DÒ¿ìÔ`Ô"!Ì€ РDÒ .Ð"`РDÒÔ@РDŸÂ€Ð DÒ!ÀÔ@РDŸÂ€Ð DÒ!¬Ô`РDŸÂ€Ð DÒ D€¢`€6пìÒ €¢`€Ð DÒ!ÈÔ@РDŸÂ€Ð DÒ!ÄÔ@РDŸÂ€Ð DÒ T€¢`€ РDÔ!ÌÒ¿ìԀРDÒ`ŸÂ€Ò DÐa°Ò¿ìÔ`€¢ €’ €’ ÔРDŸÂ€Ð DÒ!¨Ô@РD’ ŸÂ€Ð DÒ €¢`€/Ò DÐ`Ò¿ìÔ` Ô" Ò DÐ`Ò¿ìà` Ò¿ìÔ`€¢ €’ €’ Ò" РDÒ @€¢`€Ð DÒ!´Ð`€¢ €Ò DÐ`Ò DÔ`â Ò DÔ`l€¢ €’`€’`Ò" Çàè㿈ð' DРDÒ!¤Ò'¿ìРDÒ T€¢`€Ð DÒ!ÌÔ`РDŸÂ€Ò¿ìпìÒ¿ìÔ` ’ Ò" Çàè㿈ð' DРDÒ!¤Ò'¿ìРDÒ €¢`πРDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ T€¢`€Ð DÒ h€¢`€Ð DÒ ˆ€¢`€Ð DÒ¿ìÔ`Ô"!ÌРDÒ!ÌÔ` РDŸÂ€Ð¿ìÀ" € РDÒ .Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!¤Ð¿ì’ Ò"п쒠Ò" пìÀ" РDÿý~Çàèÿñÿñ  D88G|`Z8t@…µÍåätý 5;McyÜ‹žµÅjdmaster.cuse_merged_upsampleprepare_for_output_passgcc2_compiled.finish_output_passprepare_range_limit_tablemaster_selectionjinit_d_main_controllerjinit_d_coef_controllerjinit_d_post_controllerjinit_color_deconverterjinit_master_decompressjdiv_round_upmemsetmemcpyjpeg_calc_output_dimensions.umuljinit_inverse_dctjinit_2pass_quantizerjinit_1pass_quantizerjpeg_new_colormapjinit_huff_decoderjinit_merged_upsamplerjinit_upsamplerjinit_phuff_decoderŒ¨ülˆ4Tt”DXt˜¬È , ,,@0T4T8h<h`0X| D  Ô è  ô    x Œ Ü   Ü  D$ D0 |4 |as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 lXÄ° tÙ!P ,`>jdinput.o/ 938694509 1729 22250 100664 4584 ` ELFÐ4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' DÒ DÐ` ?’£Ü€¢ € Ò DÐ`?’£Ü€¢ €€Ð DÒ )Ð"`Ò DÐ@?’£ÜÒ" РDÒÔ@РDŸÂ€Ð DÒ Ô€¢`€Ð DÒ Ð"`Ò DÐ@Ò DÔ`ÔÔ" РDÒÔ@РDŸÂ€Ð DÒ $€¢` €Ð DÒ Ð"`Ò DÐ@Ò DÔ`$Ô" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð D’ Ò"!4РD’ Ò"!8À'¿ìРDÒ ØÒ'¿èРDÒ¿ìÐ $€¢@€€>пèÒ €¢`€Ð¿èÒ €¢`€Ð¿èÒ €¢`€ пèÒ €¢`€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÖ¿èÔàÖa4€¢€ €Ôa4Ô"!4РDÒ DÖ¿èÔà Öa8€¢€ €Ôa8Ô"!8Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ¾Ð D’ Ò"!<À'¿ìРDÒ ØÒ'¿èРDÒ¿ìÐ $€¢@€€HÐ¿è’ Ò" $РDÒ¿èÐ Ò`@Ò DÔa4’ •*`’ @Ò¿èÐ"`РDÒ¿èÐ Ò` @Ò DÔa8’ •*`’ @Ò¿èÐ"` РDÒ¿èÐ Ò`@Ò DÒa4@Ò¿èÐ"`(РDÒ¿èÐ Ò` @Ò DÒa8@Ò¿èÐ"`,Ð¿è’ Ò" 0пèÀ" LÐ¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ´Ð DÒ DÔa8’ •*`Ð ’ @Ò DÐ"a@РDÒ DÐ!HÒ`$€¢ € РDÒ Ü€¢`€€Ð DÒ!´ Ð"`€Ð DÒ!´À"`Çàèã¿€ð' DРDÒ!H€¢`€6РDÒ!LÒ'¿àРDÒ¿àÔ`Ô"!\РDÒ¿àÔ` Ô"!`Ð¿à’ Ò" 4Ð¿à’ Ò" 8Ð¿à’ Ò" <пàÒ¿àÔ`$Ô" @Ð¿à’ Ò" DпàÒ¿àÔ  Ò` @Ð'¿äп䀢 €Ð¿àÒ Ò'¿äпàÒ¿äÒ" HРD’ Ò"!dРDÀ"!h€¶Ð DÒ!H€¢`€ РDÒ!H€¢`€€Ð DÒ Ð"`Ò DÐ@Ò DÔaHÔ" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÔa4’ •*`Ð ’ @Ò DÐ"a\РDÒ DÔa8’ •*`Ð ’ @Ò DÐ"a`РDÀ"!dÀ'¿ìРDÒ¿ìÐ!H€¢@€€vРDÒ¿ì” “*  Ò!LÒ'¿àпàÒ¿àÔ`Ô" 4пàÒ¿àÔ` Ô" 8à¿àпàÒ¿àÐ 4Ò`8@Ð$ <à¿àпàÒ¿àÐ 4Ò`$@Ð$ @пàÒ¿àÔ  Ò`4@Ð'¿äп䀢 €Ð¿àÒ 4Ò'¿äпàÒ¿äÒ" DпàÒ¿àÔ  Ò`8@Ð'¿äп䀢 €Ð¿àÒ 8Ò'¿äпàÒ¿äÒ" HпàÒ <Ò'¿èРDÒ!dÔ¿è@ €¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€¿èÒ” ’ÿÒ"€¢ €€Ô DÒ DadÒ– ™*à”€ Ö¿ìÖ"¡h’`Ò"¿ÿëÐ¿ì’ Ò'¿ì¿ÿ†Çàèã¿€ð' DÀ'¿ìРDÒ¿ìÐ!H€¢@€€OРDÒ¿ì” “*  Ò!LÒ'¿äпäÒ L€¢`€€<пäÒ Ò'¿èп耢 €Ð¿è€¢ € РDÒ¿è” “*  Ò ¤€¢`€€Ð DÒ 4Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð DÒ Ö@РD’ ” „ŸÂÀÐ'¿àРDÒ¿è” “* ” пàÒ ¤” „@пäÒ¿àÒ" LÐ¿ì’ Ò'¿ì¿ÿ­Çàèã¿ð' DРDÿþ²Ð Dÿÿ Ð DÒ!¼Ô@РDŸÂ€Ð DÒ!¬Ô@РDŸÂ€Ò DÐa´Ò DÔa¬Ò Ò"Çàèã¿ð' DÒ DÐa´’ Ò"Çàè㿈ð' DРDÒ!´Ò'¿ìпìÒ €¢`€° €gРDÒ!¸Ô`РDŸÂ€Ð'¿èп耢 €€¢ €€¢ €P€P€¢ €$€KпìÒ €¢`€ РDÿýQпìÀ" €Ð¿ìÒ €¢`€ РDÒ #Ð"`РDÒÔ@РDŸÂ€Ð Dÿÿš€+Ð¿ì’ Ò" пìÒ €¢`€Ð DÒ!¸Ð`€¢ € РDÒ ;Ð"`РDÒÔ@РDŸÂ€€ РDÒ DÐ ˜Ò`€¢ €Ð DÒ DÔ`Ô" ˜€€Ð¿è°€Çàè㿈ð' DРDÒ!´Ò'¿ìп쒠Ò"пìÀ" пìÀ" Ð¿ì’ Ò" РDÒÔ`РDŸÂ€Ð DÒ!¸Ô@РDŸÂ€Ð DÀ"  Çàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!´Ð¿ì’ Ò"п쒠Ò" п쒠Ò" п쒠Ò" пìÀ" пìÀ" Ð¿ì’ Ò" Çàèÿñÿñ Ð ì$-< |pMP[PÄjh} à€”¢©¯µ `œjdinput.cconsume_markersfinish_input_passgcc2_compiled.start_input_passinitial_setupper_scan_setuplatch_quant_tablesreset_input_controllerjdiv_round_upmemcpy.umul.uremjinit_input_controllerÄ à   < L l | Ü ìÔ  Œ ¬ Ì L  ü   ø  ü  œ     ¬ à ° à ¼ | À | Ì ì Ð ìas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l ü h hÌ!4\ ,>jdmarker.o/ 938694514 1729 22250 100664 21364 ` ELFR\4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' DРDÒ fÐ"`РDÒÔ`РD’ ŸÂ€Ð DÒ!¸Ð` €¢ € РDÒ =Ð"`РDÒÔ@РDŸÂ€À'¿ìп쀢 €€Ð DÒ¿ì À* äРDÒ¿ì ’ Ò* ôРDÒ¿ì ’ Ò*!Ð¿ì’ Ò'¿ì¿ÿéРDÀ"!РDÀ" (РDÀ"!,РDÀ"!РD’ Ò*!РD’ Ò*!РDÀ*!РD’ Ò2! РD’ Ò2!"РDÀ"!$РDÀ*!(РDÒ!¸ Ð"` ° €Çàèã¿pð' Dò' Hô' LРDÒ Ò'¿ÜпÜÒÒ'¿ØпÜÒ Ò'¿ÔРDÒ HÒ" ÜРDÒ LÒ" àпԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €XпÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿Ô¿ØÒÖ @” àÿ—* Ö'¿ì’`Ò"пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €8пÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿Ô¿ØÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿Ô€¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €Ð¿ÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ D¿ØÒÖ @˜ àÿØ" Ô’`Ò"€¿ÿÞпԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €íпÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ D¿ØÒØ @– ÿ™*àØ"  ’`Ò"пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €ÌпÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔРDÖ D’¿ØÔ@Ú €˜ `ÿÖà ˜À Ø" ” Ô"@€¿ÿºÐ¿Ô€¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €¤Ð¿ÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ D¿ØÒØ @– ÿ™*àØ" ’`Ò"пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €ƒÐ¿ÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔРDÖ D’¿ØÔ@Ú €˜ `ÿÖà˜À Ø" ” Ô"@€¿ÿºÐ¿Ô€¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €[пÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ D¿ØÒÖ @˜ àÿØ" $’`Ò"€¿ÿÞпì’?øÒ'¿ìРDÒ`Ð'¿ÐпÐÒ DÔa Ô" Ò¿Ð Ò DÔ`Ô" Ò¿Ð Ò DÔ` Ô" Ò¿Ð Ò DÔ`$Ô"РDÒ dÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÙРDÒ!¸Ð`€¢ € РDÒ :Ð"`РDÒÔ@РDŸÂ€Ð DÒ €¢`€Ð DÒ €¢`€ РDÒ $€¢`€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ò DÐ`$”“* ’@п쀢 € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ø€¢`€Ò DÐ`Ô DÒ $– •*à”€ —* –À •*àÖРD’ ŸÂÀÒ DÐ"`ØÀ'¿äРDÒ ØÒ'¿àРDÒ¿äÐ $€¢@€€¬Ð¿àÒ¿äÒ" пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €§Ð¿ÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ¿à¿ØÒÖ @˜ àÿØ"€’`Ò"€¿ÿÞпԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €‚пÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿Ô¿ØÒÔ @–  ÿÖ'¿è’`Ò"€¿ÿßпàÔ¿è“: ” `Ô" пàÒ¿è” `Ô" пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €VпÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ¿à¿ØÒÖ @˜ àÿØ" ’`Ò"€¿ÿÞРDÒ`Ð'¿ÐпÐÒ¿àÔ@Ô" Ò¿Ð Ò¿àÔ`Ô" Ò¿Ð Ò¿àÔ` Ô" Ò¿Ð Ò¿àÔ`Ô"РDÒ eÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÙÐ¿ä’ Ò'¿äÐ¿à’ TÒ'¿à¿ÿPРDÒ!¸ Ð"`пÜÒ¿ØÒ"пÜÒ¿ÔÒ" ° €Çàèã¿`ð' DРDÒ Ò'¿ÐпÐÒÒ'¿ÌпÐÒ Ò'¿ÈРDÒ!¸Ð`€¢ € РDÒ >Ð"`РDÒÔ@РDŸÂ€Ð¿È€¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €ïпÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÖ @” àÿ—* Ö'¿ì’`Ò"пȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €ÏпÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿È€¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €©Ð¿ÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿à’`Ò"€¿ÿßРDÒ gÐ"`РDÒпàÐ"`РDÒÔ`РD’ ŸÂ€Ð¿à’‘*`’ п쀢 € Ð¿à€¢ €Ð¿à€¢ €€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ¿àÒ"!HÀ'¿èпèÒ¿à€¢ €€«Ð¿È€¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €PпÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ø’`Ò"€¿ÿßпȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €,пÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßÀ'¿äРDÒ ØÒ'¿ÔРDÒ¿äÐ $€¢@€€Ð¿ÔÒ¿ØЀ¢@€€Ð¿ä’ Ò'¿äпԒ TÒ'¿Ô¿ÿêРDÒ Ð"`РDÒпØÐ"`РDÒÔ@РDŸÂ€Ð DÒ¿è” “*  Ò¿ÔÒ"!LпÔÔ¿Ü“: ” `Ô" пÔÒ¿Ü” `Ô" РDÒ`Ð'¿ÄпÄÒ¿ØÒ" Ò¿Ä Ò¿ÔÔ`Ô" Ò¿Ä Ò¿ÔÔ`Ô"РDÒ hÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿàÐ¿è’ Ò'¿è¿ÿRпȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €¦Ð¿ÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßРDÒ¿ÜÒ"!пȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €€Ð¿ÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßРDÒ¿ÜÒ"!”пȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €ZпÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßРDÔ¿Ü“: ” `Ô"!˜Ð DÒ¿Ü” `Ô"!œÐ DÒ`Ð'¿ÄпÄÒ DÔaÔ" Ò¿Ä Ò DÔa”Ô" Ò¿Ä Ò DÔa˜Ô" Ò¿Ä Ò DÔaœÔ"РDÒ iÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÙРDÒ!¸À"`Ò DРDÒ DÔ`’ Ò" пÐÒ¿ÌÒ"пÐÒ¿ÈÒ" ° €Çàèã¾Pð' DРDÒ Ò'¾¼Ð¾¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €ßо¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´¾¸ÒÖ @” àÿ—* Ö'¿ì’`Ò"о´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €¿Ð¾¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´¾¸ÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì’?þÒ'¿ìп쀢 €€‰Ð¾´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €‘о¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´¾¸ÒÔ @–  ÿÖ'¾È’`Ò"€¿ÿßРDÒ PÐ"`РDÒоÈÐ"`РDÒÔ`РD’ ŸÂ€À/¿ÐÀ'¾Ä Ð'¾Ìо̀¢ €€2о´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €Uо¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´Ð¾Ì–¿Ð’¾¸Ô@Ø €Ø*À” Ô"@€¿ÿÞо̒¿ÐÔ @  ÿÒ¾Ä@Ð'¾Äо̒ Ò'¾Ì¿ÿÌпì’?ïÒ'¿ìРDÒ`Ð'¾°Ð¾°Ò¿Ñ” `ÿÔ" Ò¾° Ò¿Ò” `ÿÔ" Ò¾° Ò¿Ó” `ÿÔ" Ò¾° Ò¿Ô” `ÿÔ" Ò¾° Ò¿Õ” `ÿÔ" Ò¾° Ò¿Ö” `ÿÔ" Ò¾° Ò¿×” `ÿÔ" Ò¾° Ò¿Ø” `ÿÔ"РDÒ VÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÁРDÒ`Ð'¾°Ð¾°Ò¿Ù” `ÿÔ" Ò¾° Ò¿Ú” `ÿÔ" Ò¾° Ò¿Û” `ÿÔ" Ò¾° Ò¿Ü” `ÿÔ" Ò¾° Ò¿Ý” `ÿÔ" Ò¾° Ò¿Þ” `ÿÔ" Ò¾° Ò¿ß” `ÿÔ" Ò¾° Ò¿à” `ÿÔ"РDÒ VÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÁоĀ¢!€ оÄҿ쀢 €€ РDÒ Ð"`РDÒÔ@РDŸÂ€À'¾ÌоÌҾĀ¢ €€,о´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €€Ð¾¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´Ð¾Ì–¾Ð’¾¸Ô@Ø €Ø*À” Ô"@€¿ÿÞо̒ Ò'¾Ì¿ÿÑпìÒ¾Ä" Ð'¿ìÒ¾È `€¢ €Ð¾È’?ðÒ'¾ÈоȒ‘*`’ ÄРD’ Ò'¾À€ оȒ‘*`’ ´Ð D’ Ò'¾ÀоȀ¢ €Ð¾È€¢ €€Ð DÒ Ð"`РDÒоÈÐ"`РDÒÔ@РDŸÂ€Ð¾ÀÒ€¢`€Ð D@Ò¾ÀÐ"@оÀ’¿ÐД @оÀÒ`’¾Ð”!@¿þuп쀢 € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¾¼Ò¾¸Ò"о¼Ò¾´Ò" ° €Çàèã¿hð' DРDÒ Ò'¿ÔпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €ÔпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿ—* Ö'¿ì’`Ò"п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €´Ð¿ÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì’?þÒ'¿ìп쀢 €€~п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €†Ð¿ÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÔ @–  ÿÖ'¿è’`Ò"€¿ÿßпè“: Ò'¿àÐ¿è’ Ò'¿èРDÒ QÐ"`РDÒпèÐ"`РDÒпàÐ"`РDÒÔ`РD’ ŸÂ€Ð¿è€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð DÒ¿è” “*  Ò ¤€¢`€ РD@Ò DÔ¿è– •*à’@ Ð"`¤Ð DÒ¿è” “*  Ò ¤Ò'¿ØÀ'¿äп䀢 ?€€‚Ð¿à€¢ €Iп̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €Ð¿ÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿ—* Ö'¿Ü’`Ò"п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €ôпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿÖ¿Ü”À Ô'¿Ü’`Ò"€¿ÿ½€&п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €ÌпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßпØÔ¿ä– •*à–`’€ Ô@’ •*`Ò¿ÞÒ2 Ð¿ä’ Ò'¿ä¿ÿ|РDÒÐ`h€¢ €~À'¿äп䀢 ?€€wРDÒ`Ð'¿ÈпÈÒ¿ØÔ¿ä– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò"РDÒ ]Ð"`РDÒÔ`РD’ ŸÂ€€¿ÿ’Ð¿ä’ Ò'¿ä¿ÿ‡Ð¿ì’?¿Ò'¿ìÐ¿à€¢ €Ð¿ì’?ÀÒ'¿ì¿þ€Ð¿ì€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ÔÒ¿ÐÒ"пÔÒ¿ÌÒ" ° €Çàèã¿xð' DРDÒ Ò'¿äпäÒÒ'¿àпäÒ Ò'¿Üп܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €§Ð¿äÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÖ @” àÿ—* Ö'¿ì’`Ò"п܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €‡Ð¿äÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿Ü€¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €SпäÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÖ @” àÿ—* Ö'¿è’`Ò"п܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €3пäÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÖ @” àÿÖ¿è”À Ô'¿è’`Ò"€¿ÿ½Ð DÒ RÐ"`РDÒпèÐ"`РDÒÔ`РD’ ŸÂ€Ð DÒ¿èÒ"!пäÒ¿àÒ"пäÒ¿ÜÒ" ° €Çàè㿈ð' Dò' Hô' Lö' PРLÒ P Ð'¿ìРL€¢ €þРHÒ `ÿ€¢ J€ø Ò H Ò `ÿ€¢ F€ð Ò H Ò `ÿ€¢ I€è Ò H Ò `ÿ€¢ F€à Ò H Ò `ÿ€¢ €ØРD’ Ò"!РD’ Ô H’@ Ô @Ô*!РD’ Ô H’@ Ô @Ô*!РD’ Ô H’@ Ô @Ô*!РD’ Ô H’@ Ö @” àÿ“* ” Ö H”€ Ö €” àÿ’ ”@ Ô2! РD’ Ô H’@ Ö @” àÿ“* ” Ö H”€ Ö €” àÿ’ ”@ Ô2!"РDÒ ! `ÿ€¢ €Ð DÒ wÐ"`Ò DÐ@Ò DÔ a’  ÿÒ" Ò DÐ@Ò DÔ a’  ÿÒ" РDÒÔ`РD’?ÿŸÂ€Ð DÒ`Ð'¿èпèÒ DÔ a’  ÿÒ" Ò¿è Ò DÔ a’  ÿÒ" Ò¿è Ò DÔa —* “2àÒ" Ò¿è Ò DÔa"—* “2àÒ" Ò¿è Ò DÔ a’  ÿÒ"РDÒ WÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÌ Ò H ’ Ô H’@ Ð Ò @ ’ ÿ€¢`€Ð DÒ ZÐ"`Ò DÐ@’ Ô H’@ Ô @’  ÿÒ" Ò DÐ@’ Ô H’@ Ô @’  ÿÒ" РDÒÔ`РD’ ŸÂ€Ð¿ì’?òÒ'¿ì Ò H Ò `ÿ’ Ô H’@ Ô @’  ÿ@”“* ’@п쀢 €Ð DÒ XÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€žÐ L€¢ €‹Ð HÒ `ÿ€¢ J€… Ò H Ò `ÿ€¢ F€} Ò H Ò `ÿ€¢ X€u Ò H Ò `ÿ€¢ X€m Ò H Ò `ÿ€¢ €e Ò H Ò `ÿ€¢ € €¢ €€¢ € €:€¢ €&€5РDÒ lÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€=РDÒ mÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€,РDÒ nÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€Ð DÒ YÐ"`Ò DÐ@’ Ô H’@ Ô @’  ÿÒ" РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€€Ð DÒ MÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€Çàèã¿xð' Dò' Hô' Lö' PРL€¢ €‚РHÒ `ÿ€¢ A€| Ò H Ò `ÿ€¢ d€t Ò H Ò `ÿ€¢ o€l Ò H Ò `ÿ€¢ b€d Ò H Ò `ÿ€¢ e€\ Ò H Ô ’  ÿ‘*`’ Ô H’@ Ô @’  ÿ Ð'¿ì Ò H Ô ’  ÿ‘*`’ Ô H’@ Ô @’  ÿ Ð'¿è Ò H Ô ’  ÿ‘*`’ Ô H’@ Ô @’  ÿ Ð'¿ä Ò H Ò `ÿÐ'¿àРDÒ`Ð'¿ÜпÜÒ¿ìÒ" Ò¿Ü Ò¿èÒ" Ò¿Ü Ò¿äÒ" Ò¿Ü Ò¿àÒ"РDÒ LÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÝРD’ Ò"!$РDÒ¿ãÒ*!(€Ð DÒ NÐ"`Ò DÐ@Ò LÔ P’@ Ò" РDÒÔ`РD’ ŸÂ€Çàèã¿`ð' DРDÒ Ò'¿ÌпÌÒÒ'¿ÈпÌÒ Ò'¿ÄпĀ¢ €Ð¿ÌÒ Ð DŸÂ@€¢ €° €ÂпÌÒÒ'¿ÈпÌÒ Ò'¿ÄпĒ?ÿÒ'¿Ä¿ÈÒÖ @” àÿ—* Ö'¿ì’`Ò"пĀ¢ €Ð¿ÌÒ Ð DŸÂ@€¢ €° €¢Ð¿ÌÒÒ'¿ÈпÌÒ Ò'¿ÄпĒ?ÿÒ'¿Ä¿ÈÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì’?þÒ'¿ìп쀢 € Ð'¿Ð€ п쀢 €Ð¿ìÐ'¿Ð€À'¿ÐÀ'¿ÔпÔҿЀ¢ €€,пĀ¢ €Ð¿ÌÒ Ð DŸÂ@€¢ €° €_пÌÒÒ'¿ÈпÌÒ Ò'¿ÄпĒ?ÿÒ'¿ÄпԖ¿Ø’¿ÈÔ@Ø €Ø*À” Ô"@€¿ÿÞпԒ Ò'¿Ô¿ÿÑпìÒ¿Ð" Ð'¿ìÒ DÐa €¢ à€€¢ î€ €’¿ØРDÔ¿ÐÖ¿ìÿý€’¿ØРDÔ¿ÐÖ¿ìÿþ³€Ð DÒ DÐ"`Ò DÐ@Ò DÔa Ô" РDÒÔ@РDŸÂ€€Ð¿ÌÒ¿ÈÒ"пÌÒ¿ÄÒ" п쀢 € РDÒ Ô`РDÒ¿ìŸÂ€° €Çàèã¿hð' DРDÒ!¸Ò'¿ìпìÒ ¤Ò'¿èÀ'¿ØРDÒ Ò'¿ÔпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп耢 €“п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €GпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿ—* Ö'¿Ø’`Ò"п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €'пÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿÖ¿Ø”À Ô'¿Ø’`Ò"€¿ÿ½Ð¿Ø’?þÒ'¿Øп؀¢ €BРDÒ! €¢`þ€Ð¿ìÒ `Ò'¿È€ пìÒ DÔa ’¿ ” “*  Ò dÒ'¿ÈпØÒ¿È€¢ €Ð¿ØÐ'¿ÈÒ DÐ`Ò¿È”`Ö Ð D’ ŸÂÀÐ'¿èпèÀ"пèÒ DÔ a£Ô* пèÒ¿ØÒ" пèÒ¿ÈÒ" пèÔ¿è’ ” Ô" Ô'¿ÜпìÒ¿èÒ" ¤Ð¿ìÀ" ¨À'¿äпÈÐ'¿à€À'¿àÀ'¿äÀ'¿Ü€ пìÒ ¨Ò'¿äпèÒ Ò'¿àпèÒ Ð¿ä’@Ò'¿ÜпäÒ¿à€¢ €€BпÔÒ¿ÐÒ"пÔÒ¿ÌÒ" пìÒ¿äÒ" ¨Ð¿Ì€¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €šÐ¿ÔÒÒ'¿ÐпÔÒ Ò'¿ÌпäÒ¿à€¢ €Ð¿Ì€¢ €€€¿ÜÒ”¿ÐÖ€Ø ÀØ*@–àÖ"€’`Ò"п̒?ÿÒ'¿ÌÐ¿ä’ Ò'¿ä¿ÿã¿ÿ»Ð¿è€¢ €&РDÒ!0€¢`€Ð DÒ¿èÒ"!0€Ð DÒ!0Ò'¿ÈпÈÒ€¢`€€Ð¿ÈÒÒ'¿È¿ÿöпÈÒ¿èÒ"пèÒ Ò'¿ÜпèÒ Ð¿à’"@Ò'¿ØпìÀ" ¤Ò DÐa €¢ à€€¢ î€ €Ð DÒ¿ÜÔ¿àÖ¿Øÿû¯€"РDÒ¿ÜÔ¿àÖ¿ØÿýN€Ð DÒ [Ð"`Ò DÐ@Ò DÔa Ô" Ò DÐ@Ò¿àÔ¿Ø’@ Ò" РDÒÔ`РD’ ŸÂ€€Ð¿ÔÒ¿ÐÒ"пÔÒ¿ÌÒ" п؀¢ € РDÒ Ô`РDҿ؟€° €Çàèã¿€ð' DРDÒ Ò'¿èпèÒÒ'¿äпèÒ Ò'¿àÐ¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €cпèÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÖ @” àÿ—* Ö'¿ì’`Ò"Ð¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €CпèÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì’?þÒ'¿ìРDÒ [Ð"`Ò DÐ@Ò DÔa Ô" РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€Ð¿èÒ¿äÒ"пèÒ¿àÒ" п쀢 € РDÒ Ô`РDÒ¿ìŸÂ€° €Çàèã¿€ð' DРDÒ Ò'¿èпèÒÒ'¿äпèÒ Ò'¿àÐ¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €¼Ð¿èÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÔ @–  ÿÖ'¿ì’`Ò"€¿ÿßп쀢 ÿ€€6Ò DÐa¸Ò DÐa¸Ò DÔa¸Ò ”`Ô" пèÒ¿äÒ"пèÒ¿àÒ" Ð¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €ƒÐ¿èÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÔ @–  ÿÖ'¿ì’`Ò"€¿ÿß¿ÿÈÐ¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €]пèÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÔ @–  ÿÖ'¿ì’`Ò"€¿ÿßп쀢 ÿ€€¿ÿ×п쀢 €€Ò DÐa¸Ò DÔa¸Ò ”`Ô" пèÒ¿äÒ"пèÒ¿àÒ" ¿ÿcРDÒ!¸Ð`€¢ €Ð DÒ tÐ"`Ò DÐ@Ò DÔa¸Ò Ò" РDÒпìÐ"`РDÒÔ`РD’?ÿŸÂ€Ð DÒ!¸À"`РDÒ¿ìÒ"! Ð¿èÒ¿äÒ"пèÒ¿àÒ" ° €Çàèã¿xð' DРDÒ Ò'¿äпäÒÒ'¿àпäÒ Ò'¿Üп܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €bпäÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÔ @–  ÿÖ'¿ì’`Ò"€¿ÿßп܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €>пäÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÔ @–  ÿÖ'¿è’`Ò"€¿ÿßп쀢 ÿ€Ð¿è€¢ Ø€€Ð DÒ 5Ð"`РDÒпìÐ"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð DÒ¿èÒ"! Ð¿äÒ¿àÒ"пäÒ¿ÜÒ" ° €Çàèã¿ð' DРDÒ! €¢`€Ð DÒ!¸Ð` €¢ € РDÿÿv€¢ €° €Q€ РDÿþ•€¢ €° €FÒ DÐa €¢ Ï€,€¢ Í€€¢ Āƀ¢ Ä€€¢ Á€ €¢ À€O€¢ €ý€€¢ €T€¢ Àx€€¢ É€Y€¢ É€p€¢ Ë€m€¢ Ë€™€[€¢ Û€ª€¢ Û€€¢ Ø€ €¢ ؀ـ¢ Ù€x€¢ Ú€g€î€¢ ï€ €¢ à€©€¢ Ü€Ú€¢ Ý€˜€à€¢ þ€²€ÛРDÿï—€¢ €° €ç€áРD’ ” ÿï倢 €° €Ú€ÔРD’ ” ÿïØ€¢ €° €Í€ÇРD’ ” ÿïË€¢ €° €À€ºÐ D’ ” ÿï¾€¢ €° €³€­Ð DÒ <Ð"`Ò DÐ@Ò DÔa Ô" РDÒÔ@РDŸÂ€€œÐ Dÿò€¢ €° €—РDÀ"! ° €’РDÒ UÐ"`РDÒÔ`РD’ ŸÂ€Ð DÀ"! ° €‚РDÿýK€¢ €° €y€sРDÿô €¢ €° €n€hРDÿõû€¢ €° €c€]РDÿ÷Þ€¢ €° €X€RÒ DÐa¸Ò DÔa ’¿ ” “*  Ò Ð DŸÂ@€¢ €° €D€>РDÒ!¸Ô`РDŸÂ€€¢ €° €6€0РDÒ \Ð"`Ò DÐ@Ò DÔa Ô" РDÒÔ`РD’ ŸÂ€€Ð Dÿü뀢 €° €€Ð DÒ DÐ"`Ò DÐ@Ò DÔa Ô" РDÒÔ@РDŸÂ€€Ð DÀ"! ¿þŸÇàèã¿ð' DРDÒ! €¢`€ РDÿý?€¢ €° €:РDÒ DÔa¸Ö ’àÐÐ! €¢ €Ð DÒ bÐ"`Ò DÐ@Ò DÔa¸Ò Ò" РDÒÔ`РD’ ŸÂ€Ð DÀ"! €Ò DÐ`Ô DÒ¡¸Ô РDÒ`ŸÂ€€¢ €° € Ò DÐa¸Ò DÔa¸Ö ’à” `Ô" ° €Çàè㿈ð' Dò' HРDÒ! Ò'¿ì Ð'¿èРDÒ yÐ"`РDÒпìÐ"`РDÒРHÐ"`РDÒÔ`РD’?ÿŸÂ€Ð¿ì€¢ ¿€ Ð'¿è€>п쀢 πп쀢 ×€€ Ð'¿è€0Ò H`’ `Ðҿ쀢@€ Ò H`’ `Ðҿ쀢@€€ Ð'¿è€Ò Hÿ’ `Ðҿ쀢@€ Ò Hþ’ `Ðҿ쀢@€€ Ð'¿è€ Ð'¿èРDÒ aÐ"`РDÒпìÐ"`РDÒпèÐ"`РDÒÔ`РD’ ŸÂ€Ð¿è€¢ €€¢ €€¢ € €€¢ €€Ð DÀ"! ° €Ð Dÿüt€¢ €° € РDÒ! Ò'¿ì€° €¿ÿ‚Çàè㿈ð' DРDÒ!¸Ò'¿ìРDÀ" ØРDÀ" РDÀ"! Ð¿ìÀ" пìÀ" пìÀ" пìÀ" ¤Çàè㿈ð' DРDÒ Ö@РD’ ” ¬ŸÂÀÐ'¿ìРDÒ¿ìÒ"!¸Ð¿ì’ Ò"п쒠Ò" п쒠Ò" п쒠Ò" пìÀ" `À'¿èп耢 €€Ð¿ìÒ¿è” “*  ’ Ò" пìÒ¿è” “*  À" dÐ¿è’ Ò'¿è¿ÿéп쒠Ò" п쒠Ò" XРDÿÿ¨Çàèã¿€ð' Dò' Hô' LРDÒ!¸Ò'¿ìРDÒ Ð`0’?ìÒ'¿èРLҿ耢 €Ð¿èÐ' LРL€¢ €`Ð'¿äРH€¢ à€ Ð L€¢ € Ð' L€ РH€¢ î€Ð L€¢ € Ð' L€`Ð'¿äРH€¢ à€Ð H€¢ `Ð'¿äРH€¢ þ€ пìÒ¿äÒ" пìÒ LÒ" `€*РH€¢ ߀РH€¢ ï€Ð¿ìÔ H’¿ ” “*  Ò¿äÒ" пìÔ H’¿ ” “*  Ò LÒ" d€Ð DÒ DÐ"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Çàè㿈ð' Dò' Hô' LРDÒ!¸Ò'¿ìРH€¢ þ€Ð¿ìÒ LÒ" €"РH€¢ ߀РH€¢ ï€ Ð¿ìÔ H’¿ ” “*  Ò LÒ" €Ð DÒ DÐ"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Çàèÿñÿñ =Ôð/hp.8ˆô<&\œIXl è`#Xhlp Thx ¸€¼äˆ2Ø°”:|X ,øp®HüTÂE`(Ö?ÄœãêðJlàLLÈ2EIPYpFˆtjdmarker.cfirst_markerget_interesting_appnskip_variableexamine_app0gcc2_compiled.get_sofget_driget_soiget_sosget_dqtget_dhtsave_markernext_markerexamine_app14reset_marker_readerread_restart_markerread_markersmemcpy.umuljpeg_save_markersjpeg_alloc_huff_tablejpeg_set_marker_processorjpeg_natural_orderjinit_marker_readerjpeg_alloc_quant_tablejpeg_resync_to_restartð,d | Œ *IŒ HüI HüIœ ?ÄI  ?ÄI¬ E`I° E`I¼ 8ˆIÀ 8ˆJ 8ˆJ 8ˆJ< /hJ@ /hJL /hJP /hJÈ 2ØJÌ 2ØK4 8ˆK8 8ˆKh /hKl /has: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 lMM€ÐOP‡!PØD ,R>jdhuff.o/ 938694507 1729 22250 100664 7408 ` ELF°4(.shstrtab.text.rodata.symtab.strtab.rela.text.commentã¿xð' DРDÒ!¼Ò'¿ìРDÒ!€¢`€Ð DÒ!”€¢`?€Ð DÒ!˜€¢`€ РDÒ!œ€¢`€€ РDÒ zÐ"`РDÒÔ`РD’?ÿŸÂ€À'¿èРDÒ¿èÐ!H€¢@€€0РDÒ¿è” “*  Ò!LÒ'¿ØпØÒ Ò'¿àпØÒ Ò'¿ÜÐ¿à’‘*`’ (пì–@РD’ Ô¿à@пܒ‘*`’ 8пì–@РD’ Ô¿Ü@пìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿÌÀ'¿äРDÒ¿äÐ!d€¢@€€UРDÒ¿ä” “*  Ò!hÒ'¿èРDÒ¿è” “*  Ò!LÒ'¿ØпìÒ¿ä” “*  Ò¿ìÔ¿ØÖ ” —* ’@ Ô`(Ô" HпìÒ¿ä” “*  Ò¿ìÔ¿ØÖ ” —* ’@ Ô`8Ô" pпØÒ 0€¢`€Ð¿ìÒ¿ä” “*  ’ Ò" ˜Ð¿ìÒ¿ä” “*  Ò¿ØÔ`$€¢ 4€’ ’ Ò" À€Ð¿ìÒ¿ä” “*  Ò¿ìÔ¿ä– •*à’@ À"`ÀÀ" ˜Ð¿ä’ Ò'¿ä¿ÿ§Ð¿ìÀ" пìÀ" пìÀ" пìÒ DÔaÔ" $ÇàèãºPð' Dò' Hô' Lö' PРL€¢ €Ð L€¢ €€Ð DÒ 2Ð"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð H€¢ € РDÒ L” “* ” Р´€Ò DÔ L– •*à’@ Ð`ÄÐ'¿ìп쀢 €Ð DÒ 2Ð"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð PÒ€¢`€ РDÒ Ö@РD’ ”%ŸÂÀÒ PÐ"@РPÒÒ'¿èпèÒ¿ìÒ" ŒÀ'¿ä Ð'¿Üп܀¢ €€6пìÒ¿ÜÐ ’ ÿÒ'¿àÐ¿à€¢ € пäÒ¿à €¢!€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿àÿ’Ò'¿à€¢ÿ€€ ¿äÒ” –¾ÀØ¿ßØ*À ’`Ò"¿ÿïпܒ Ò'¿Ü¿ÿÈп䒾ÀÀ*@пäÐ'¿ÔÀ'º´Ð¾À“* ‘:`Ð'¿ØÀ'¿äп䒾ÀÐ @“* ‘:`€¢ €€4п䒾ÀÐ @“* ‘:`Ò¿Ø€¢ €€¿äÒ– •*à–º¸Øº´Ø"À ’`Ò"к´’ Ò'º´¿ÿé Ò¿Ø‘* Òº´€¢@€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ðº´“* Ò'º´Ð¿Ø’ Ò'¿Ø¿ÿÆÀ'¿ä Ð'¿Üп܀¢ €€5пìÒ¿ÜÔ  ÿ€¢ €#пèÒ¿Ü” “*  Ò¿ä” “* ”º¸Ö¿äÒ€ ”"À Ô" HпìÒ¿ÜÔ  ÿÒ¿ä@Ð'¿äпèÒ¿Ü” “* Ö¿ä”ÿÿ– •*à–º¸ÔÀ Ô" €Ð¿èÒ¿Ü” “* ”?ÿÔ" пܒ Ò'¿Ü¿ÿÉпèÿ’£ÿÒ" DÐ¿è’  ’ ”$@À'¿ä Ð'¿Üп܀¢ €€H Ð'¿àпìÒ¿ÜÔ  ÿÒ¿à€¢@€€7п䒑*`’º¸” Ö¿Ü”"€ Ð@“* Ò'¿Ð Ò¿Ü" ’ ‘*@Ð'¿Ìп̀¢ €€Ð¿èҿД “*  Ò¿ÜÒ" пèÒ¿Ð Ò¿ìÔ¿ä’@ Ô `Ô*$пВ Ò'¿Ðп̒?ÿÒ'¿Ì¿ÿåÐ¿à’ Ò'¿àÐ¿ä’ Ò'¿ä¿ÿÃпܒ Ò'¿Ü¿ÿ¶Ð H€¢ €)À'¿àпàÒ¿Ô€¢ €€!пìÒ¿à Ò  `ÿÐ'º°Ðº°€¢ €Ðº°€¢ €€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿à’ Ò'¿à¿ÿÜÇàè㿈ð' D ¢ö' PРDäРDæ РDÒ Ò'¿ìпìÒ! €¢`€T€¤`€€M€¤à€Ð¿ìÒ Ô` пìŸÂ€€¢ €° €hпìÒ ä@пìÒ æ`¦ÿÿÐ €¨ ÿ¤ €¥ ÿ€,€¤à€Ð¿ìÒ Ô` пìŸÂ€€¢ €° €LпìÒ ä@пìÒ æ`¦ÿÿÐ €¨ ÿ¤ €¥ ÿ€€¿ÿ‥ €¨ ÿ€Ð¿ìè"! € ¡,  ¢`¿ÿ²€Ð P€¢€Ð¿ìÒ!¼Ð`€¢ €Ð¿ìÒ uÐ"`пìÒÔ`пì’?ÿŸÂ€Ð¿ìÒ!¼ Ð"`’ "@¡,¢ РDä"РDæ" РDà" РDâ" ° €Çàèã¿ð' D ¢ö' Pø' Tä T€¤@€Ð D’”–@€¢ €°?ÿ€XРDà РDâ ¢$@§<’ ‘*@’?ÿ¦ À РP’•*`Ð €¤À€€§,à€¤`€Ð D’”– @€¢ €°?ÿ€4РDà РDâ ¢ÿ“< `¦À¤ ¿ÿÝРDà" РDâ" €¤ €Ð DÒ Ð@’ vÒ" РDÒ Ð@Ò DÔ Ð`’?ÿŸÂ€° €Ò PÐ`ŒÒ P”—* ’@ Ô`H’À  Ò  `ÿ°€Çàè㿈ð' DРDÒ!¼Ò'¿ìÒ DÐa¸Ô DÒ¡¸Ô¿ìÖ ” €¢ €” •: Ò`”@ Ô" пìÀ" РDÒ!¸Ô`РDŸÂ€€¢ €° €%À'¿èРDÒ¿èÐ!H€¢@€€ пìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿïпìÒ DÔaÔ" $РDÒ! €¢`€Ð¿ìÀ" ° €Çàèã¿Pð' Dò' HРDÒ!¼Ò'¿ìРDÒ!€¢`€Ð¿ìÒ $€¢`€ РDÿÿ¨€¢ €° €æпìÒ €¢`€ØРDÐ'¿àРDÒ Ð@Ð'¿ÐРDÒ Ð`Ð'¿Ôпìà пìâ пìÒ Ò'¿ÀÒ Ò'¿ÄÒ Ò'¿ÈÐ Ð'¿ÌÀ'¿èРDÒ¿èÐ!d€¢@€€£Ð¿è’‘*`Ò H ÒÒ'¿¼Ð¿ìÒ¿è” “*  Ò HÒ'¿¸Ð¿ìÒ¿è” “*  Ò pÒ'¿´€¤`€’¿Ð ’”– @€¢ €° €œà¿Øâ¿Ü€¤`€ª €ø­<¬  ÿп¸’•*` ê €¢ € ¢$@п¸’Ð d¤ ÿ€ª ’¿Ð ’”Ö¿¸˜@¤€¢ €° €pà¿Øâ¿Ü€¤ €-€¤@€’¿Ð ’”–@€¢ €° €[à¿Øâ¿Ü¢$@©<’ ‘*@’?ÿ¨ ”—* ”`’À Ô@€¥ € ”—* ”`’À Ô@ ¤Ð¿ìÒ¿è” “*  Ò ˜€¢`€Ð DÒ¿è” “*  Ò!hÒ'¿°Ð¿°’‘*`’¿ÀÐ@¤€Ð¿°’‘*`’¿Àä"@п¼ä2пìÒ¿è” “*  Ò À€¢`€¦ €¤à?€€‡€¤`€’¿Ð ’”– @€¢ €° €à¿Øâ¿Ü€¤`€ª €ø­<¬  ÿп´’•*` ê €¢ € ¢$@п´’Ð d¤ ÿ€ª ’¿Ð ’”Ö¿´˜@¤€¢ €° €Øà¿Øâ¿Ü©< ¤  €¤ €;¦À€¤@€’¿Ð ’”–@€¢ €° €Àà¿Øâ¿Ü¢$@©<’ ‘*@’?ÿ¨ ”—* ”`’À Ô@€¥ € ”—* ”`’À Ô@ ¤’•*`’ € Ò “* Ô¿¼@ ä2€€¥ €€¦à¦à¿ÿx€j¦ €¤à?€€d€¤`€’¿Ð ’”– @€¢ €° €wà¿Øâ¿Ü€¤`€ª €ø­<¬  ÿп´’•*` ê €¢ € ¢$@п´’Ð d¤ ÿ€ª ’¿Ð ’”Ö¿´˜@¤€¢ €° €Kà¿Øâ¿Ü©< ¤  €¤ €¦À€¤@€’¿Ð ’”–@€¢ €° €3à¿Øâ¿Ü¢$@€€¥ €€¦à¦à¿ÿ›Ð¿è’ Ò'¿è¿þYРDÒ Ð¿ÐÐ"@РDÒ Ð¿ÔÐ"`пìà" пìâ" пìÒ¿ÀÒ" Ò¿ÄÒ" Ò¿ÈÒ" Ò¿ÌÒ" Ò¿ìпìÒ¿ìÔ`$’¿ÿÒ" $° €Çàè㿈ð' DРDÒ Ö@РD’ ” èŸÂÀÐ'¿ìРDÒ¿ìÒ"!¼Ð¿ì’ Ò"п쒠Ò" À'¿èп耢 €€Ð¿ìÒ¿è” “*  Ò¿ìÔ¿è– •*à’@ À"`8À" (Ð¿è’ Ò'¿è¿ÿëÇàè @€ @ÿÿÿÿÿÿÿýÿÿÿùÿÿÿñÿÿÿáÿÿÿÁÿÿÿÿÿÿÿÿþÿÿüÿÿøÿÿðÿÿàÿÿÀÿÿ€ÿñÿñ €@&>œüIX@@fx~… ȸ– ”4«˜À¾jdhuff.cprocess_restartextend_teststart_pass_huff_decoderdecode_mcugcc2_compiled.extend_offsetjpeg_make_d_derived_tblmemsetjpeg_huff_decodejpeg_fill_bit_bufferjinit_huff_decoderjpeg_natural_order D œ    °  T ` x @„ @h  x À Ì ä @ð @  œ D ¬ Ô Ø ä œè œas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14= tXÌ€L !LÑ) P 4p>jdphuff.o/ 938694520 1729 22250 100664 8296 ` ELF(4(.shstrtab.text.rodata.symtab.strtab.rela.text.commentã¿hð' DРDÒ!¼Ò'¿ìРDÒ!”`€  `?ÿÐ'¿èÀ'¿äп耢 € РDÒ!”€¢`€ Ð'¿ä€Ð DÒ DÐ!Òa”€¢ € РDÒ!”€¢`?€€ Ð'¿äРDÒ!H€¢`€ Ð'¿äРDÒ!˜€¢`€ РDÒ DÔa˜’¿ÿÐ!œ€¢ € Ð'¿äРDÒ!œ€¢` € Ð'¿äп䀢 € РDÒ Ð"`Ò DÐ@Ò DÔaÔ" Ò DÐ@Ò DÔa”Ô" Ò DÐ@Ò DÔa˜Ô" Ò DÐ@Ò DÔaœÔ" $РDÒÔ@РDŸÂ€À'¿àРDÒ¿àÐ!H€¢@€€tРDÒ¿à” “* ” СLÒ Ò'¿ÌРDÒ¿Ì” “* Ð  ’ Ò'¿Ôп耢 €Ð¿ÔÒ€¢`€Ð DÒ sÐ"`РDÒпÌÐ"`РDÒÀ"`РDÒÔ`РD’?ÿŸÂ€Ð DÒ!Ò'¿ÜРDÒ¿ÜÐ!”€¢@€€9пܒ‘*`Ô¿Ô’ Ð@Ò¿Ü” “* Ô¿Ô’@ Ô@€¢ € Ð'¿ÈРDÒ!˜Ð¿È€¢@€Ð DÒ sÐ"`РDÒпÌÐ"`РDÒпÜÐ"`РDÒÔ`РD’?ÿŸÂ€Ð¿Ü’‘*`Ò¿Ô Ò DÔaœÔ"пܒ Ò'¿Ü¿ÿÃÐ¿à’ Ò'¿à¿ÿˆÐ DÒ!˜€¢`€Ð¿è€¢ €Ð¿ì’ Ò" €Ð¿ì’ Ò" €Ð¿è€¢ €Ð¿ì’ Ò" €Ð¿ì’ Ò" À'¿àРDÒ¿àÐ!H€¢@€€CРDÒ¿à” “*  Ò!LÒ'¿Ðп耢 €Ð DÒ!˜€¢`€Ð¿ÐÒ Ò'¿Øпؒ‘*`’ ,пì–@РD’ Ô¿Ø@€Ð¿ÐÒ Ò'¿Øпؒ‘*`’ ,пì–@РD’ Ô¿Ø@пìÒ¿ìÔ¿Ø– •*à’@ Ô`,Ô" <пìÒ¿à” “*  À" Ð¿à’ Ò'¿à¿ÿ¹Ð¿ìÀ" пìÀ" пìÀ" пìÀ" пìÒ DÔaÔ" (Çàè㿈ð' DРDÒ!¼Ò'¿ìÒ DÐa¸Ô DÒ¡¸Ô¿ìÖ ” €¢ €” •: Ò`”@ Ô" пìÀ" РDÒ!¸Ô`РDŸÂ€€¢ €° €'À'¿èРDÒ¿èÐ!H€¢@€€ пìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿïпìÀ" пìÒ DÔaÔ" (РDÒ! €¢`€Ð¿ìÀ" ° €Çàèã¿@ð' Dò' HРDÒ!¼Ò'¿ìРDÒ!œÒ'¿èРDÒ!€¢`€Ð¿ìÒ (€¢`€ РDÿÿ£€¢ €° €èпìÒ €¢`€ÚРDÐ'¿ÐРDÒ Ð@Ð'¿ÀРDÒ Ð`Ð'¿Äпìä пìæ пìÒ Ò'¿¨Ò Ò'¿¬Ò Ò'¿°Ò Ò'¿´Ð $Ð'¿¸À'¿äРDÒ¿äÐ!d€¢@€€¡Ð¿ä’‘*`Ò H ÒÒ'¿ÜРDÒ¿ä” “*  Ò!hÒ'¿àРDÒ¿à” “*  Ò!LÒ'¿ Ð¿ìÒ¿ Ô`’ •*` Ò ,Ò'¿¤€¤à€’¿À ’”– @€¢ €° €”ä¿Èæ¿Ì€¤à€¨ €ÿø«<€ª `ÿп¤’•*` è €¢ € ¦$Àп¤’Ð d  ÿ€¨ ’¿À ’”Ö¿¤˜@ €¢ €° €hä¿Èæ¿Ì€¤ €-€¤À€’¿À ’”–@€¢ €° €Sä¿Èæ¿Ì¦$À£<€’ ‘*@’?ÿ¢ @ ”—* ”`’À Ô@€¤@ € ”—* ”`’À Ô@  Ð¿à’‘*`’¿¨@Ò   Ð¿à’‘*`’¿¨@à" пÜÔ¿è“, Ò2Ð¿ä’ Ò'¿ä¿ÿ[РDÒ Ð¿ÀÐ"@РDÒ Ð¿ÄÐ"`пìä" пìæ" пìÒ¿¨Ò" Ò¿¬Ò" Ò¿°Ò" Ò¿´Ò" Ò¿¸Ò" $Ò¿ìпìÒ¿ìÔ`(’¿ÿÒ" (° €Çàèã¿Xð' Dò' HРDÒ!¼Ò'¿ìРDÒ!”Ò'¿èРDÒ!œÒ'¿äРDÒ!€¢`€Ð¿ìÒ (€¢`€ РDÿþœ€¢ €° €õпìÒ €¢`€çпìÒ Ò'¿àÐ¿à€¢ €Ð¿à’?ÿÒ'¿à€ØРDÐ'¿ÐРDÒ Ð@Ð'¿ÀРDÒ Ð`Ð'¿Äпìæ пìè РHÒÒ'¿ÜпìÒ <Ò'¿¼Ð Dâ!п耤@€€°€¥ €’¿À ’”– @€¢ €° €¸æ¿Èè¿Ì€¥ €ª €?ø­<À¬  ÿп¼’•*` ê €¢ € ¨%п¼’Ð d  ÿ€ª ’¿À ’”Ö¿¼˜@ €¢ €° €Œæ¿Èè¿Ì¥<   €¤ €=¢@€¥€’¿À ’”–@€¢ €° €tæ¿Èè¿Ì¨%¥<À’ ‘*@’?ÿ¤ € ”—* ”`’À Ô@€¤€ € ”—* ”`’À Ô@  ’•*`’ € Ò “* Ô¿Ü@ Ô¿ä“, Ò2€/€¤ €¢`€) “*Ò'¿à€¤ €€¥€’¿À ’”–@€¢ €° €.æ¿Èè¿Ì¨%’‘<À ” “*€”ÿ¤ пà’Ò'¿àпà’?ÿÒ'¿à€¢`¿ÿNРDÒ Ð¿ÀÐ"@РDÒ Ð¿ÄÐ"`пìæ" пìè" пìÒ¿àÒ" Ò¿ìпìÒ¿ìÔ`(’¿ÿÒ" (° €Çàèã¿hð' Dò' HРDÒ!¼Ò'¿ìРD’ Ð!œ“*@Ò'¿èРDÒ!€¢`€Ð¿ìÒ (€¢`€ РDÿý‰€¢ €° €YРDÐ'¿ØРDÒ Ð@Ð'¿ÈРDÒ Ð`Ð'¿Ìпìà пìâ À'¿äРDÒ¿äÐ!d€¢@€€-п䒑*`Ò H ÒÒ'¿à€¤`€’¿È ’”– @€¢ €° €+à¿Ðâ¿Ô¢ÿ“< `€¢ €Ð¿àÒ¿àÔ@ҿꔀ Ô2Ð¿ä’ Ò'¿ä¿ÿÏРDÒ Ð¿ÈÐ"@РDÒ Ð¿ÌÐ"`пìà" пìâ" Ò¿ìпìÒ¿ìÔ`(’¿ÿÒ" (° €Çàèã¾Hð' Dò' HРDÒ!¼Ò'¿ìРDÒ!”Ò'¿èРD’ Ð!œ“*@Ò'¿äРD’?ÿÐ!œ“*@Ò'¿àРDÒ!€¢`€Ð¿ìÒ (€¢`€ РDÿý €¢ €° €½Ð¿ìÒ €¢`€–РDÐ'¿ÈРDÒ Ð@Ð'¿¸Ð DÒ Ð`Ð'¿¼Ð¿ìæ пìè пìÒ Ò'¿ÜРHÒÒ'¿ØпìÒ <Ò'¿´À'¿°Ð Dâ!п܀¢ €Ð¿è€¤@€€ €¥ €’¿¸ ’”– @€¢ €€læ¿Àè¿Ä€¥ €ª €?ø­<À¬  ÿп´’•*` ê €¢ € ¨%п´’Ð d  ÿ€ª ’¿¸ ’”Ö¿´˜@ €¢ €€Aæ¿Àè¿Ä¥<   €¤ €.€¤ € РDÒ vÐ"`РDÒÔ`РD’?ÿŸÂ€€¥ €’¿¸ ’”– @€¢ €€æ¿Àè¿Ä¨?ÿ“<À `€¢ €à¿ä€à¿à€(€¤ €% “*Ò'¿Ü€¤ €€¥€’¿¸ ’”–@€¢ €€öæ¿Àè¿Ä¨%’‘<À ” “*€”ÿ¤ пܒÒ'¿Ü€x’•*`’ € Ò “* пؒ Ò'¿ÔпÔÒ•*`‘: €¢ €:€¥ €’¿¸ ’”– @€¢ €€Ææ¿Àè¿Ä¨?ÿ“<À `€¢ € пÔÒ•*`‘: Ò¿ä €¢ €Ð¿ÔÒ•*`‘: €¢ € пÔÒ¿ÔÔ@ҿ攀 Ô2€Ð¿ÔÒ¿ÔÔ@ҿ─ Ô2€¤¿ÿ€¤ €€ ¢`п耤@€€¿ÿ©€¤ €’•*`’ € ÒÒ'¾¬Ð¾¬’‘*`Ò¿Ø à2¿°Ò– •*à–¾°Ø¾¬Ø"À ’`Ò"¢`¿þóп܀¢ €Vп耤@€€M’•*`’ € Ò “* пؒ Ò'¿ÔпÔÒ•*`‘: €¢ €8€¥ €’¿¸ ’”– @€¢ €€Gæ¿Àè¿Ä¨?ÿ“<À `€¢ € пÔÒ•*`‘: Ò¿ä €¢ €Ð¿ÔÒ•*`‘: €¢ € пÔÒ¿ÔÔ@ҿ攀 Ô2€Ð¿ÔÒ¿ÔÔ@ҿ─ Ô2¢`¿ÿ±Ð¿Ü’?ÿÒ'¿ÜРDÒ Ð¿¸Ð"@РDÒ Ð¿¼Ð"`пìæ" пìè" пìÒ¿ÜÒ" Ò¿ìпìÒ¿ìÔ`(’¿ÿÒ" (° €Ð¿°€¢ €€Ò¿°ÿ’Ò'¿° “* ¾°Ò  “* Ô¿Ø@ À2¿ÿí° €Çàèã¿€ð' DРDÒ Ö@РD’ ” @ŸÂÀÐ'¿ìРDÒ¿ìÒ"!¼Ð¿ì’ Ò"À'¿àÐ¿à€¢ €€ пìÒ¿à” “*  À" ,Ð¿à’ Ò'¿à¿ÿñÒ DÐ`Ò DÔ`$’ •*`ÖРD’ ŸÂÀÒ DÐ"` Ð DÒ  Ò'¿èÀ'¿äРDÒ¿äÐ $€¢@€€À'¿àÐ¿à€¢ ?€€ ¿èÒ”?ÿÔ"@’`Ò"Ð¿à’ Ò'¿à¿ÿñÐ¿ä’ Ò'¿ä¿ÿâÇàè @€ @ÿÿÿÿÿÿÿýÿÿÿùÿÿÿñÿÿÿáÿÿÿÁÿÿÿÿÿÿÿÿþÿÿüÿÿøÿÿðÿÿàÿÿÀÿÿ€ÿñÿñ €$@'àŒ<ÜQ`€y@@‡ ´P›¤¯ÇØíl\jdphuff.cprocess_restartextend_testdecode_mcu_AC_refinedecode_mcu_DC_refinegcc2_compiled.start_pass_phuff_decoderextend_offsetdecode_mcu_AC_firstdecode_mcu_DC_firstjpeg_make_d_derived_tbljpeg_huff_decodejpeg_fill_bit_bufferjpeg_natural_orderjinit_phuff_decoder¸ ¤¼ ¤Ð ´Ô ´ø ü  à à´ ô Dì H  œ ´ @ À @  ¬  \ h € @ Œ @   ¬ ,<àxl x ÔÜ è h t Ш ¬ as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14= tÈ<€¼  !Ü)ðø 4è>jdmainct.o/ 938694510 1729 22250 100664 5376 ` ELFè4(.shstrtab.text.symtab.strtab.rela.text.commentã¿xð' DРDÒ!¨Ò'¿ìРDÒ!<Ò'¿àÒ DÐ`Ò DÔ`$’ •*`ÖРD’ ŸÂÀÒ¿ìÐ"`8пìÒ¿ìÔ DÖ $” —* Ò`8”@ Ô" <À'¿èРDÒ ØÒ'¿ÜРDÒ¿èÐ $€¢@€€FпÜÒ¿ÜÐ Ò`$@Ò DÒa<@Ð'¿äРDà Ð¿à’  Ò¿ä@’•*`ÖРD’ ŸÂÀÐ'¿Øп䒑*`Ò¿Ø@Ð'¿ØпìÒ¿è” “* Ô 8@ Ò¿ØÒ"Ð¿à’  Ò¿ä@’‘*`Ò¿Ø@Ð'¿ØпìÒ¿è” “* Ô <@ Ò¿ØÒ"Ð¿è’ Ò'¿èпܒ TÒ'¿Ü¿ÿ¶Çàèã¿hð' DРDÒ!¨Ò'¿ìРDÒ!<Ò'¿ÜÀ'¿èРDÒ ØÒ'¿ØРDÒ¿èÐ $€¢@€€¨Ð¿ØÒ¿ØÐ Ò`$@Ò DÒa<@Ð'¿àпìÒ¿è” “* Ô 8@ ÒÒ'¿ÐпìÒ¿è” “* Ô <@ ÒÒ'¿ÌпìÒ¿è” “*  Ò Ò'¿ÔÀ'¿äпܒ  Ò¿à@ҿ䀢@€€Ð¿ä’‘*`Ò¿Ð Ò¿ä” “* Ô¿Ì’@ Ô¿ä– •*àÖ¿Ô”€ Ö€Ö"@Ö"Ð¿ä’ Ò'¿ä¿ÿßÀ'¿äÐ¿à’‘*`ҿ䀢@€€7пܒ?þ Ò¿à@Ò¿ä ’‘*`Ò¿Ì  пàÒ¿Ü@Ò¿ä ’‘*`Ò¿Ô ÒÒ$пàÒ¿Ü@Ò¿ä ’‘*`Ò¿Ì  пܒ?þ Ò¿à@Ò¿ä ’‘*`Ò¿Ô ÒÒ$Ð¿ä’ Ò'¿ä¿ÿÄÀ'¿äпäÒ¿à€¢ €€Ð¿äÒ¿à" ’‘*`Ò¿Ð Ò¿ÐÔ@Ô"Ð¿ä’ Ò'¿ä¿ÿìÐ¿è’ Ò'¿èпؒ TÒ'¿Ø¿ÿTÇàèã¿pð' DРDÒ!¨Ò'¿ìРDÒ!<Ò'¿ÜÀ'¿èРDÒ ØÒ'¿ØРDÒ¿èÐ $€¢@€€‚пØÒ¿ØÐ Ò`$@Ò DÒa<@Ð'¿àпìÒ¿è” “* Ô 8@ ÒÒ'¿ÔпìÒ¿è” “* Ô <@ ÒÒ'¿ÐÀ'¿äпäÒ¿à€¢ €€WпäÒ¿à" ’‘*`Ò¿Ô  пܒ  Ò¿à@Ò¿ä ’‘*`Ò¿Ô ÒÒ$пäÒ¿à" ’‘*`ҿР пܒ  Ò¿à@Ò¿ä ’‘*`Ò¿Ð ÒÒ$пܒ  Ò¿à@Ò¿ä ’‘*`Ò¿Ô Ò¿ä” “* Ô¿Ô’@ Ô@Ô"пܒ  Ò¿à@Ò¿ä ’‘*`Ò¿Ð Ò¿ä” “* Ô¿Ð’@ Ô@Ô"Ð¿ä’ Ò'¿ä¿ÿ¦Ð¿è’ Ò'¿èпؒ TÒ'¿Ø¿ÿzÇàèã¿pð' DРDÒ!¨Ò'¿ìÀ'¿èРDÒ ØÒ'¿ÔРDÒ¿èÐ $€¢@€€[пÔÒ¿ÔÐ Ò`$@Ð'¿ÜÒ DпÜÒa<@Ð'¿àпÔÒ , Ò¿Ü@Ð'¿Øп؀¢ €Ð¿ÜÐ'¿Øп耢 € à¿ìпؒ?ÿ Ò¿à@’ Ò$ HпìÒ¿ìÔ`@– “*àÔ¿è– •*à Ò 8€ ÒÒ'¿ÐÀ'¿äÐ¿à’‘*`ҿ䀢@€€Ð¿ØÒ¿ä ’‘*`Ò¿Ð Ò¿Ø” “* Ô¿Ð’@ ÔüÔ"Ð¿ä’ Ò'¿ä¿ÿæÐ¿è’ Ò'¿èпԒ TÒ'¿Ô¿ÿ¡Çàè㿈ð' Dò' HРDÒ!¨Ò'¿ìРH€¢ €€¢ €#€'РDÒ!ÄÐ`€¢ €Ð¿ì’ Ò" РDÿþ(пìÀ" @пìÀ" DпìÀ" L€Ð¿ì’ Ò" пìÀ" 0пìÀ" 4€Ð¿ì’ Ò" €Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Çàèã¿€ð' Dò' Hô' Lö' PРDÒ!¨Ò'¿ìпìÒ 0€¢`€Ò DÐa¬Ô¿ì’ Ô РDŸÂ€€¢ €€!Ð¿ì’ Ò" 0РDÒ!<Ò'¿èÒ DÐa°Ô¿ì’ Ö¿ì”à4Ö PÖ# \Ä Ð DÖ¿èØ HÚ LŸÀ€Ð¿ìÒ 4п耢@ €Ð¿ìÀ" 0пìÀ" 4Çàèã¿€ð' Dò' Hô' Lö' PРDÒ!¨Ò'¿ìпìÒ 0€¢`€Ò DÐa¬Ò¿ìÔ¿ìÖ @” —* ’@ Ô Ð DÒ`8ŸÂ€€¢ €€“Ð¿ì’ Ò" 0Ò¿ìпìÒ¿ìÔ`L’ Ò" LÒ¿ìÐ`D€¢ €K€¢ €€¢ €1€}€¢ €€xÒ DÐa°Ò¿ìÔ¿ìÖ @” —* ’@ Ö¿ì”à4Ö¿ìØ PØ# \Ä Ð DÒ`8ÖàHØ HÚ LŸÀ€Ð¿ìÒ¿ìÐ 4Ò`H€¢ €€ZпìÀ" DРLÒРP€¢@ €€PпìÀ" 4пìÒ DÔa<’¿ÿÒ" HпìÒ DÐ LÒa@€¢ €Ð Dÿþ¦Ð¿ì’ Ò" DÒ DÐa°Ò¿ìÔ¿ìÖ @” —* ’@ Ö¿ì”à4Ö¿ìØ PØ# \Ä Ð DÒ`8ÖàHØ HÚ LŸÀ€Ð¿ìÒ¿ìÐ 4Ò`H€¢ €€Ð¿ìÒ L€¢`€Ð DÿýçпìÒ¿ìÔ`@’ Ò" @пìÀ" 0пìÒ DÔa<’ Ò" 4пìÒ DÔa<’ Ò" HÐ¿ì’ Ò" DÇàè㿈ð' Dò' Hô' Lö' PÒ DÐa°Ò PÒ# \Ä Ð D’ ” – Ø HÚ LŸÀ€Çàèã¿xð' Dò' HРDÒ Ö@РD’ ” PŸÂÀÐ'¿ìРDÒ¿ìÒ"!¨Ð¿ì’ Ò"РH€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ!ÄÐ`€¢ €Ð DÒ!<€¢`€ РDÒ /Ð"`РDÒÔ@РDŸÂ€Ð DÿüXРDÒ!<`Ð'¿à€Ð DÒ!<Ò'¿àÀ'¿èРDÒ ØÒ'¿ÜРDÒ¿èÐ $€¢@€€/пÜÒ¿ÜÐ Ò`$@Ò DÒa<@Ð'¿äРDà пÜÒ¿ÜÐ Ò`$@¢Ð¿äÒ¿à@–Ø Ð D’ ”ŸÃÒ¿ìÔ¿è– •*à’@ Ð"`Ð¿è’ Ò'¿èпܒ TÒ'¿Ü¿ÿÍÇàèÿñÿñ ¸ tP4ÀIX ÀìqÀð… ¬ÈŸ°³°XË Äøãéïjdmainct.cstart_pass_mainprocess_data_crank_postalloc_funny_pointersgcc2_compiled.process_data_simple_mainmake_funny_pointersprocess_data_context_mainset_bottom_pointersset_wraparound_pointersjinit_d_main_controller.umul.urem.div¸ Èì \  0¬ d Œ ¼ ì   ¸  D  \ tØ  ¬  ¬ L À P À t t x t ¸ ¸  D X as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l¼( (ô!Œ ,¨>jdcoefct.o/ 938694502 1729 22250 100664 9608 ` ELF$p4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' DРDÒ!¬Ò'¿ìРDÒ!H€¢`€Ð¿ì’ Ò" €Ð DÒ DÔa@’¿ÿÐ ”€¢ € пìÒ DÔaLÒ  Ò" €Ð¿ìÒ DÔaLÒ HÒ" пìÀ" пìÀ" Çàèã¿ð' DРDÀ" ”РDÿÿÒÇàè㿈ð' DРDÒ!¬Ò'¿ìпìÒ €¢`€Ð DÒ P€¢`€Ð D@Þ€¢ €Ð¿ì’ Ò" €Ð¿ì’ Ò" РDÀ" œÇàèã¿Pð' Dò' HРDÒ!¬Ò'¿ìРDÒ!\ÿÐ'¿äРDÒ!@ÿÐ'¿àпìÒ Ò'¿ÌпìÒ¿ÌÐ €¢@€€ÏпìÒ Ò'¿èпèҿ䀢 €€¾Ð¿ìÒ DÔad’ •*`Ð ’ @Ò DÐa¼Ô¿ì’  Ô Ð DŸÂ€€¢ € пìÒ¿ÌÒ" пìÒ¿èÒ" ° €ÉÀ'¿ÜÀ'¿ØРDÒ¿ØÐ!H€¢@€€’РDÒ¿Ø” “*  Ò!LÒ'¿¸Ð¿¸Ò 0€¢`€ п¸Ò¿ÜÐ <’@Ò'¿Ü€zÒ DÐaÀÒ¿¸Ô`’ •*` Ò Ò'¿´Ð¿èҿ䀢 €Ò¿¸Ð`4€Ò¿¸Ð`DÐ'¿Èп¸Ò  “* РH @Ò¿¸Ð¿ÌÒ`$@’‘*`Ò@Ð'¿ÄÒ¿¸Ð¿èÒ`@@Ð'¿ÀÀ'¿Ðп¸Ò¿ÐÐ 8€¢@€€FРDÒ ”Ð¿à€¢@ € пÌÒ¿Ð Ò¿¸Ô`H€¢ €€%пÀÐ'¿¼À'¿ÔпÔÒ¿È€¢ €€Ð¿ìÒ¿ÜÔ¿Ô’@ ” “* ” Ú¿´Ð DÒ¿¸Ô  Ö¿ÄØ¿¼ŸÃ@п¸Ò¿¼Ð $’@Ò'¿¼Ð¿Ô’ Ò'¿Ô¿ÿâп¸Ò¿ÜÐ 4’@Ò'¿Üп¸Ò $ “* пĒ Ò'¿ÄпВ Ò'¿Ð¿ÿ¶Ð¿Ø’ Ò'¿Ø¿ÿjÐ¿è’ Ò'¿è¿ÿ?пìÀ" п̒ Ò'¿Ì¿ÿ-Ò DРDÒ DÔ`œ’ Ò" œÒ DРDÒ DÖ`””à’ Ò" ”РDÔ!@€¢@ €Ð Dÿþ²° € РDÒ!´Ô` РDŸÂ€° €Çàèã¿ð' D° €Çàèã¿Xð' DРDÒ!¬Ò'¿ìÀ'¿àРDÒ¿àÐ!H€¢@€€*РDÒ¿à” “*  Ò!LÒ'¿¸Ð Dà пìÒ¿¸Ô`’ •*`¢ РDÒ¿¸Ð ”Ò` @”Ö¿¸Ú РDÒ`HÖà ˜ ŸÃ@Ò¿à” “* ”¿ÀÐ"€ Ð¿à’ Ò'¿à¿ÿÒпìÒ Ò'¿ÔпìÒ¿ÔÐ €¢@€€ƒÐ¿ìÒ Ò'¿èРDÒ¿èÐ!\€¢@ €€qÀ'¿äÀ'¿àРDÒ¿àÐ!H€¢@€€NРDÒ¿à” “*  Ò!LÒ'¿¸Ò¿¸Ð¿èÒ`4@Ð'¿ÐÀ'¿Øп¸Ò¿ØÐ 8€¢@€€3Ð¿à’‘*`’¿ÀÔ¿ØÖ¿Ô”€ – •*àÒ@€ ҿД “* Ð’ Ò'¿¼À'¿Üп¸Ò¿ÜÐ 4€¢@€€Ô¿ì¿äÒ– ›*à˜€ ”¿¼Ö€Ö# –à€Ö"€’`Ò"пܒ Ò'¿Ü¿ÿèпؒ Ò'¿Ø¿ÿÉÐ¿à’ Ò'¿à¿ÿ®Ò DÐa¼Ô¿ì’  Ô Ð DŸÂ€€¢ € пìÒ¿ÔÒ" пìÒ¿èÒ" ° €)Ð¿è’ Ò'¿è¿ÿ‹Ð¿ìÀ" пԒ Ò'¿Ô¿ÿyÒ DРDÒ DÖ`””à’ Ò" ”РDÔ!@€¢@ €Ð DÿýË° € РDÒ!´Ô` РDŸÂ€° €Çàèã¿`ð' Dò' HРDÒ!¬Ò'¿ìРDÒ!@ÿÐ'¿èРDÒ DÐ Ò`˜€¢ €Ð DÒ DÐ Ò`˜€¢ € РDÒ DÐ ”Ò`œ€¢ €€€Ð DÒ!´Ô@РDŸÂ€€¢ €° €¬¿ÿÛÀ'¿àРDÒ ØÒ'¿ÄРDÒ¿àÐ $€¢@€€‹Ð¿ÄÒ 0€¢`€€|РDà пìÒ¿à” “* ¢ РDÒ¿ÄÐ œÒ` @”Ö¿ÄÚ Ð DÒ`HÖà ˜ ŸÃ@Ð'¿ÔРDÒ œÐ¿è€¢@€Ð¿ÄÒ Ò'¿Ø€Ð¿ÄÒ¿ÄÔ  Ò` @Ð'¿Øп؀¢ €Ð¿ÄÒ Ò'¿ØÒ DÐaÀÒ¿à” “*  Ò Ò'¿ÀÐ¿à’‘*`Ò H ÒÒ'¿ÌÀ'¿ÜпÜÒ¿Ø€¢ €€4пܒ‘*`Ò¿Ô ÒÒ'¿ÐÀ'¿ÈÀ'¿äпÄÒ¿äÐ €¢@ €€Ú¿ÀРDÒ¿ÄÔ¿ÐÖ¿ÌØ¿ÈŸÃ@пВ €Ò'¿ÐпÄÒ¿ÈÐ $’@Ò'¿ÈÐ¿ä’ Ò'¿ä¿ÿåпÄÒ $ “* п̒ Ò'¿Ìпܒ Ò'¿Ü¿ÿÉÐ¿à’ Ò'¿àпĒ TÒ'¿Ä¿ÿqÒ DРDÒ DÖ`œ”à’ Ò" œÐ DÔ!@€¢@ €° €° €Çàèã¿pð' DРDÒ!¬Ò'¿ìÀ'¿èРDÒ Ü€¢`€ РDÒ  €¢`€€° € Ð¿ìÒ p€¢`€Ò DÐ`Ô DÒ $” —* –À •*àÖРD’ ŸÂÀÒ¿ìÐ"`pпìÒ pÒ'¿ÐÀ'¿äРDÒ ØÒ'¿ÜРDÒ¿äÐ $€¢@€€yпÜÒ LÒ'¿Ø€¢`€° €tпØÒ•*`‘2 €¢ €'пØÒ •*`‘2 €¢ € пØÒ •*`‘2 €¢ €Ð¿ØÒ •*`‘2 €¢ €Ð¿ØÒ •*`‘2 €¢ € пØÒ •*`‘2 €¢ €€° €EРDÒ¿ä” “* Ð  ’ Ò'¿ÔпÔÒ€¢`€° €6 Ð'¿àÐ¿à€¢ €€Ð¿à’‘*`Ò¿Ð Ò¿à” “* Ô¿Ô’@ Ô@Ô"Ð¿à’‘*`Ò¿Ô Ò€¢`€ Ð'¿èÐ¿à’ Ò'¿à¿ÿàпВ Ò'¿ÐÐ¿ä’ Ò'¿äпܒ TÒ'¿Ü¿ÿƒÐ¿è°€Çàèã¾pð' Dò' HРDÒ!¬Ò'¿ìРDÒ!@ÿÐ'¿èРDÒ DÐ Ò`˜€¢ € РDÒ!´Ð`€¢ €€€(РDÒ DÐ Ò`˜€¢ €Ð DÒ!”`€  `?ÿÐ'¾ÔРDÒ DÔ`œÖ¾Ô’€ Ð ”€¢ €€Ð DÒ!´Ô@РDŸÂ€€¢ €° €5¿ÿËÀ'¿ÜРDÒ ØÒ'¿´Ð DÒ¿ÜÐ $€¢@€€Ð¿´Ò 0€¢`€€Ð DÒ œÐ¿è€¢@€ п´Ò Ò'¿ÔпԒ‘*`Ð'¿ÐÀ'¿¨€Ð¿´Ò¿´Ô  Ò` @Ð'¿ÔпԀ¢ €Ð¿´Ò Ò'¿ÔпÔÐ'¿Ð Ð'¿¨Ð DÒ œ€¢`€(п´Ò¿ÐÐ ’@Ò'¿ÐРDà пìÒ¿Ü” “* ¢ РDÒ œÿÒ¿´Ò` @”Ú Ð DÒ`HֿИ ŸÃ@Ð'¿Ìп´Ò  “* п̒ Ò'¿ÌÀ'¿¬€Ò DÐ`Ò¿ìÔ¿Ü– •*à’@ Ú Ð DÒ`H” ֿИ ŸÃ@Ð'¿Ì Ð'¿¬Ð¿ìÒ¿Ü– •*à”€ “* Ð p’ Ò'¿$п´Ò LÒ'¿ п Ò•*`‘2 Ð'¿Ð¿ Ò •*`‘2 Ð'¿Ð¿ Ò •*`‘2 Ð'¿Ð¿ Ò •*`‘2 Ð'¿Ð¿ Ò •*`‘2 Ð'¿ п Ò •*`‘2 Ð'¿Ò DÐaÀÒ¿Ü” “*  Ò Ò'¿°Ð¿Ü’‘*`Ò H ÒÒ'¿¼À'¿ØпØÒ¿Ô€¢ €€dпؒ‘*`Ò¿Ì ÒÒ'¿È﬈¢ € п؀¢ €Ð¿ÈÐ'¿Ä€ пؒ‘*`Ò¿Ì Ò?üÒ'¿Äп¨€¢ € Ò¿ÔÿÒ¿Ø€¢@€Ð¿ÈÐ'¿À€ пؒ‘*`Ò¿Ì Ò Ò'¿ÀпÄÒ•*`‘: ’Ò'¾ø Ð'¾üÐ'¿Ð¿ÈÒ•*`‘: ’Ò'¾ì Ð'¾ðÐ'¾ôпÀÒ•*`‘: ’Ò'¾à Ð'¾äÐ'¾èÀ'¿¸Ð¿´Ò ÿÐ'¿àÀ'¿äпäÒ¿à€¢ €€’¿(пȔ @пäÒ¿à€¢ € €Ò¿Ä Ò•*`‘: Ð'¾ø €Ò¿È Ò•*`‘: Ð'¾ì €Ò¿À Ò•*`‘: Ð'¾à Ò¿$ ÒÒ'¾Ü€¢`€Qп*“* ‘:`€¢ €KоôÒ¾ì" ”“* ’@•*`п’ @Ð'¿Ð¿€¢ €Ò¿‘*`Ò¿ Ô¿“* @Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿‘*`Ò¿" Ô¿“* @Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿* Ò¿$ ÒÒ'¾Ü€¢`€Qп8“* ‘:`€¢ €KоüÒ¾ä" ”“* ’@•*`п’ @Ð'¿Ð¿€¢ €Ò¿‘*`Ò¿ Ô¿“* @Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿‘*`Ò¿" Ô¿“* @Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿8 Ò¿$ ÒÒ'¾Ü€¢`€SпH“* ‘:`€¢ €MоüÒ¾ä Ҿ𔠓* " ”“* ’@п@Ð'¿Ð¿€¢ €Ò¿‘*`Ò¿ Ô¿“* @Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿‘*`Ò¿" Ô¿“* @Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿H Ò¿$ ÒÒ'¾Ü€¢`€Sп:“* ‘:`€¢ €MпҾø" Ò¾è" Ò¾à ”“* ’@п@Ð'¿Ð¿€¢ €Ò¿ ‘*`Ò¿ Ô¿ “* @Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿ ‘*`Ò¿" Ô¿ “* @Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿: Ò¿$ ÒÒ'¾Ü€¢`€Sп,“* ‘:`€¢ €MоôÒ¾ì Ҿ𔠓* " ”“* ’@п@Ð'¿Ð¿€¢ €Ò¿‘*`Ò¿ Ô¿“* @Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿‘*`Ò¿" Ô¿“* @Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿,”¿(Ú¿°Ð DÒ¿´Ö¿¼Ø¿¸ŸÃ@оüÐ'¿Ð¾øÐ'¾üоðÐ'¾ôоìÐ'¾ðоäÐ'¾èоàÐ'¾äпȒ €Ò'¿ÈпĒ €Ò'¿ÄпÀ’ €Ò'¿Àп´Ò¿¸Ð $’@Ò'¿¸Ð¿ä’ Ò'¿ä¿ýüп´Ò $ “* п¼’ Ò'¿¼Ð¿Ø’ Ò'¿Ø¿ý™Ð¿Ü’ Ò'¿Üп´’ TÒ'¿´¿üèÒ DРDÒ DÖ`œ”à’ Ò" œÐ DÔ!@€¢@ €° €° €Çàèã¿€ð' Dò' HРDÒ Ö@РD’ ” tŸÂÀÐ'¿ìРDÒ¿ìÒ"!¬Ð¿ì’ Ò"п쒠Ò" пìÀ" pРH€¢ €OÀ'¿èРDÒ ØÒ'¿àРDÒ¿èÐ $€¢@€€5пàÒ Ò'¿äРDÒ Ü€¢`€Ð¿ä’•*`€Ð'¿äРDà пàÒ¿àÐ Ò`@¢Ð¿àÒ¿àÐ Ò` @˜Ä РD’ ” –Ú¿äŸÀ€Ò¿ìÔ¿è– •*à’@ Ð"`HÐ¿è’ Ò'¿èÐ¿à’ TÒ'¿à¿ÿÇп쒠Ò" п쒠Ò" пìÒ¿ì”`HÔ" €,РDÒ Ö`РD’ ”%ŸÂÀÐ'¿àÀ'¿äп䀢 €€Ð¿ìÒ¿ä” “*  Ò¿ä” “* Ô¿à’€ Ò" Ð¿ä’ Ò'¿ä¿ÿìп쒠Ò" п쒠Ò" пìÀ" Çàèÿñÿñ x €Ô,”€9H¤$YT$lT ЃȌ• l¥¤´$XÌÒØâìñjdcoefct.cdummy_consume_datasmoothing_okconsume_datagcc2_compiled.start_input_passdecompress_onepassdecompress_smooth_datastart_output_passdecompress_datastart_iMCU_rowjinit_d_coef_controller.umul.uremjround_upjzero_far.divjcopy_block_row T$ T8 < ü@h T ÄüŒ”`”¼ð\ TÀ„¸$èˆd ¤h ¤t Èx È0˜ ”œ ”¨ ¬ P xT x` Td Tas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l|è@ !(!", ,$0>jdpostct.o/ 938694521 1729 22250 100664 2808 ` ELF à4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' Dò' HРDÒ!°Ò'¿ìРH€¢ €I€¢ €€¢ € €V€¢ €)€QРDÒ T€¢`€Ð¿ì’ Ò" пìÒ €¢`€Ò DÐ`Ò¿ìÖ¿ìÚ Ð DÒ`” Öà˜ ŸÃ@Ò¿ìÐ"` €Ð¿ìÒ DÔaÄÒ Ò" €8пìÒ €¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ì’ Ò" €#пìÒ €¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ì’ Ò" €Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Ð¿ìÒ¿ìÀ"`À" Çàèã¿xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!°Ò'¿ìРXÒ \Ð’"@Ò'¿äпìÒ¿äÐ €¢@€Ð¿ìÒ Ò'¿äÀ'¿èÒ DÐaÄØ¿ìš¿èÒ¿äÒ# \Ä Ð DÒ HÔ LÖ PØ ŸÀ€Ò DÐaÌÒ¿ìÔ XÖ€” —* Ø T”À Ø Ð DÒ` Ö¿èŸÃРXÒ XÔ@ҿ蔀 Ô"Çàèã¿xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!°Ò'¿ìпìÒ €¢`€Ò DÐ`Ò¿ìÔ¿ìÖ¿ìÚ Ð DÒ`Ô Öà˜ ŸÃ@Ò¿ìÐ"` пìÒ Ò'¿èÒ DÐaÄØ¿ìÒ¿ìš`Ò¿ìÔ`Ô# \Ä Ð DÒ HÔ LÖ PØ ŸÀ€Ð¿ìÒ Ð¿è€¢@€Ð¿ìÒ Ð¿è’"@Ò'¿äÒ DÐaÌÒ¿ìÔ¿è– •*àÖ` ’€ Ø Ð D” Ö¿äŸÃРXÒ XÔ@ҿ䔀 Ô"пìÒ¿ìÐ Ò`€¢ € пìÒ¿ìÔ¿ìÒ`Ô ’@ Ò" пìÀ" Çàèã¿€ð' Dò' Hô' Lö' Pø' Tú' XРDÒ!°Ò'¿ìпìÒ €¢`€Ò DÐ`Ò¿ìÔ¿ìÖ¿ìÚ Ð DÒ`Ô Öà˜ ŸÃ@Ò¿ìÐ"` пìÒ¿ìÐ Ò`" Ð'¿èРXÒ \Ð’"@Ò'¿äпèҿ䀢 €Ð¿äÐ'¿èРDÒ¿ìÐ tÒ`" Ð'¿äпèҿ䀢 €Ð¿äÐ'¿èÒ DÐaÌÒ¿ìÔ¿ìÖ ” —* Ô` ’À Ô XÖ€” —* Ø T”À Ø Ð DÖ¿èŸÃРXÒ XÔ@ҿ蔀 Ô"пìÒ¿ìÔ`ҿ蔀 Ô" пìÒ¿ìÐ Ò`€¢ € пìÒ¿ìÔ¿ìÒ`Ô ’@ Ò" пìÀ" Çàè㿈ð' Dò' HРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!°Ð¿ì’ Ò"пìÀ" пìÀ" РDÒ T€¢`€9пìÒ DÔa8Ô" РH€¢ €Ð Dà РDÒ DÐ pÒ`x@¢Ð DÒ¿ìÐ tÒ`@˜Ú¿ìÄ Ð D’ ” –Ú`ŸÀ€Ò¿ìÐ"`€Ð Dà РDÒ DÐ pÒ`x@”Ö¿ìØ Ð D’ ÖàŸÃÒ¿ìÐ"` Çàèÿñÿñ ؈!0àA`¼TàøgT…jdpostct.cpost_process_prepassgcc2_compiled.start_pass_dpostpost_process_2passpost_process_1passjinit_d_post_controller.umuljround_upt àx à0 Ø4 Ø„ `ˆ `\ ` Ä à 8 as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 lpÜ°Œ! „ ,  >jddctmgr.o/ 938694505 1729 22250 100664 3036 ` ELF œ4(.shstrtab.text.rodata.symtab.strtab.rela.text.commentã¿hð' DРDÒ!ÀÒ'¿ìÀ'¿ÜÀ'¿ØÀ'¿èРDÒ ØÒ'¿àРDÒ¿èÐ $€¢@€€CÒ¿àÐ`$€¢ €€¢ €€¢ € €K€¢ €€¢ €€C`Ð'¿ØÀ'¿Ü€N`Ð'¿ØÀ'¿Ü€H`Ð'¿ØÀ'¿Ü€BÒ DÐ`H€¢ €€¢  €€¢ €€`Ð'¿ØÀ'¿Ü€`Ð'¿Ø Ð'¿Ü€`Ð'¿Ø Ð'¿Ü€Ð DÒ 0Ð"`РDÒÔ@РDŸÂ€€€Ð DÒ Ð"`Ò DÐ@Ò¿àÔ`$Ô" РDÒÔ@РDŸÂ€€Ð¿ìÒ¿è” “*  Ò¿ØÒ" пàÒ 0€¢`€Ð¿ìÒ¿è” “*  Ò ,п܀¢@€€€ºÐ¿àÒ LÒ'¿ÔпԀ¢ €€±Ð¿ìÒ¿è” “*  Ò¿ÜÒ" ,п܀¢ €-€¢ €€¢ € €’€¢ €M€Ð¿àÒ PÒ'¿ÐÀ'¿äп䀢 ?€€Ð¿ä’‘*`Ò¿Ð Ò¿ÔÔ¿ä– •*àÒ@ •*`“2 Ò"Ð¿ä’ Ò'¿ä¿ÿê€{пàÒ PÒ'¿ÐÀ'¿äп䀢 ?€€!п䒑*`ҿР пÔÒ¿ä” “* Ð “* ‘2`Ô¿ä– •*à–`’€ Ô@—* “:à@’(‘:` Ð$Ð¿ä’ Ò'¿ä¿ÿÝ€PпàÒ PÒ'¿ÐÀ'¿äÀ'¿Ìп̀¢ €€7À'¿ÈпȀ¢ €€+п䒑*`Ò¿Ð Ò¿ÔÔ¿ä– •*àÒ@ •*`“2 Ò'¿ðÍ¿ð… Ô¿Ì– •*à–`’€ É@… ‰DÔ¿È– •*à–`’€ É@… ‰D‰ ÂÉ"Ð¿ä’ Ò'¿äпȒ Ò'¿È¿ÿÓп̒ Ò'¿Ì¿ÿǀРDÒ 0Ð"`РDÒÔ@РDŸÂ€€Ð¿è’ Ò'¿èÐ¿à’ TÒ'¿à¿þ¹Çàèã¿€ð' DРDÒ Ö@РD’ ” TŸÂÀÐ'¿ìРDÒ¿ìÒ"!Àп쒠Ò"À'¿èРDÒ ØÒ'¿äРDÒ¿èÐ $€¢@€€!РDÒ Ö@РD’ ”!ŸÂÀÒ¿äÐ"`PÒ¿äÐ`P’ ”!@пìÒ¿è” “*  ’?ÿÒ" ,Ð¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÛÇàè@XÅSŸKB@2I"£¨XÅ{!sühbXÅE¿0 ~SŸsümAbTSŸA³-AKBhbbTX~KB;!(ºÃ@XÅSŸKB@2I"£¨2IE¿A³;!2I'‚7 à"£0 -A(º"£7¿ Ž¨~è à Žß?ð?ö1P±Haï?ô箑MoÊ?òÐbïlª?ð?é$iÀ§¿;?áQz{Ç »?ѨUÞr«]ÿñÿñ €'X2€@CScsz€Xü’ ®jddctmgr.cgcc2_compiled.aanscales.2start_passaanscalefactor.3jpeg_idct_floatjpeg_idct_ifastjpeg_idct_islowmemset.umuljinit_inverse_dctjpeg_idct_1x1jpeg_idct_2x2jpeg_idct_4x4  ¤ ¸ ¼ Ð Ô   4 8 P T ¤ ´ È | €Œ €œ €¬ €” ˜  as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14= tTÈÀˆ!˜¼) T 4 \>jidctfst.o/ 938694533 1729 22250 100664 4028 ` ELF¤4(.shstrtab.text.symtab.strtab.rela.text.commentã¾(ð' Dò' Hô' Lö' Pø' TРDÒ!D`€Ð'¿˜Ð LÐ'¿¨Ð HÒ PÒ'¿¤¾Ð'¿  Ð'¿”¢ €€  Ò¿¨ Ò•*`‘: €¢ €r Ò¿¨ Ò•*`‘: €¢ €i 0Ò¿¨ Ò•*`‘: €¢ €` @Ò¿¨ Ò•*`‘: €¢ €W PÒ¿¨ Ò•*`‘: €¢ €N `Ò¿¨ Ò•*`‘: €¢ €E pÒ¿¨ Ò•*`‘: €¢ €<п¨Ò•*`‘: Ò¿¤Ò@@Ð'¾ŒÐ¿ Ò¾ŒÒ" Ò¿  Ò¾ŒÒ" @Ò¿  Ò¾ŒÒ" `Ò¿  Ò¾ŒÒ" €Ò¿  Ò¾ŒÒ"  Ò¿  Ò¾ŒÒ" ÀÒ¿  Ò¾ŒÒ" àÒ¿  Ò¾ŒÒ"п¨’ Ò'¿¨Ð¿¤’ Ò'¿¤Ð¿ ’ Ò'¿ €"п¨Ò•*`‘: Ò¿¤Ò@@Ð'¿ì Ò¿¨ Ò•*`‘: ’ @Ô¿¤’@ Ò@@Ð'¿è @Ò¿¨ Ò•*`‘: ’ €Ô¿¤’@ Ò@@Ð'¿ä `Ò¿¨ Ò•*`‘: ’ ÀÔ¿¤’@ Ò@@Ð'¿àпìÒ¿ä Ð'¿ÌпìÒ¿ä" Ð'¿ÈпèÒ¿à Ð'¿ÀпèÒ¿à" ’•*`”€“* ’"@ •*`”€‘* “: пÀ’"@Ò'¿ÄпÌÒ¿À Ð'¿ìпÌÒ¿À" Ð'¿àпÈÒ¿Ä Ð'¿èпÈÒ¿Ä" Ð'¿ä Ò¿¨ Ò•*`‘: ’ Ô¿¤’@ Ò@@Ð'¿Ü 0Ò¿¨ Ò•*`‘: ’ `Ô¿¤’@ Ò@@Ð'¿Ø PÒ¿¨ Ò•*`‘: ’  Ô¿¤’@ Ò@@Ð'¿Ô pÒ¿¨ Ò•*`‘: ’ àÔ¿¤’@ Ò@@Ð'¿ÐпÔÒ¿Ø Ð'¿¬Ð¿ÔÒ¿Ø" Ð'¿¸Ð¿ÜÒ¿Ð Ð'¿´Ð¿ÜÒ¿Ð" Ð'¿°Ð¿´Ò¿¬ Ð'¿Ðп´Ò¿¬" ’•*`”€“* ’"@ •*`”€‘* “: Ò'¿Èп¸Ò¿° ”“* ’"@•*`”"€“* ’@‘:`Ð'¿¼Ð¿°”“* ’@•*`”€“* ’@‘:`Ò¿¼" Ð'¿Ìп¸”“* ’"@•*`”"€‘* " ’ ‘:`Ò¿¼ Ð'¿ÄпÄÒ¿Ð" Ð'¿ÔпÈÒ¿Ô" Ð'¿ØпÌÒ¿Ø Ð'¿Üп Ò¿ìÔ¿Ð’@ Ò" àÒ¿  Ò¿ìÔ¿Ð’"@ Ò" Ò¿  Ò¿èÔ¿Ô’@ Ò" ÀÒ¿  Ò¿èÔ¿Ô’"@ Ò" @Ò¿  Ò¿äÔ¿Ø’@ Ò"  Ò¿  Ò¿äÔ¿Ø’"@ Ò" €Ò¿  Ò¿àÔ¿Ü’@ Ò" `Ò¿  Ò¿àÔ¿Ü’"@ Ò"п¨’ Ò'¿¨Ð¿¤’ Ò'¿¤Ð¿ ’ Ò'¿ Ð¿”’?ÿÒ'¿”¿þ^¾Ð'¿ À'¿”¢ €€~п”’‘*`Ò P ÒРT’@Ò'¿œ Ò¿  Ò€¢`€_ Ò¿  Ò€¢`€X Ò¿  Ò€¢`€Q Ò¿  Ò€¢`€J Ò¿  Ò€¢`€C Ò¿  Ò€¢`€< Ò¿  Ò€¢`€5п Ò‘:`’ #ÿÔ¿˜@ Ò Ò/¾‹Ð¿œÒ¾‹Ò* Ò¿œ Ò¾‹Ò* Ò¿œ Ò¾‹Ò* Ò¿œ Ò¾‹Ò* Ò¿œ Ò¾‹Ò* Ò¿œ Ò¾‹Ò* Ò¿œ Ò¾‹Ò* Ò¿œ Ò¾‹Ò*п ’ Ò'¿ € п ’ Ô¿ ’@ ÐÒ@ Ð'¿Ìп ’ Ô¿ ’@ ÐÒ@" Ð'¿È Ò¿  ’ Ô¿ ’@ ÐÒ@ Ð'¿À Ò¿  ’ Ô¿ ’@ ÐÒ@" ’•*`”€“* ’"@ •*`”€‘* “: пÀ’"@Ò'¿ÄпÌÒ¿À Ð'¿ìпÌÒ¿À" Ð'¿àпÈÒ¿Ä Ð'¿èпÈÒ¿Ä" Ð'¿ä Ò¿  ’ Ô¿ ’@ ÐÒ@ Ð'¿¬ Ò¿  ’ Ô¿ ’@ ÐÒ@" Ð'¿¸ Ò¿  ’ Ô¿ ’@ ÐÒ@ Ð'¿´ Ò¿  ’ Ô¿ ’@ ÐÒ@" Ð'¿°Ð¿´Ò¿¬ Ð'¿Ðп´Ò¿¬" ’•*`”€“* ’"@ •*`”€‘* “: Ò'¿Èп¸Ò¿° ”“* ’"@•*`”"€“* ’@‘:`Ð'¿¼Ð¿°”“* ’@•*`”€“* ’@‘:`Ò¿¼" Ð'¿Ìп¸”“* ’"@•*`”"€‘* " ’ ‘:`Ò¿¼ Ð'¿ÄпÄÒ¿Ð" Ð'¿ÔпÈÒ¿Ô" Ð'¿ØпÌÒ¿Ø Ð'¿ÜпœÒ¿ìÔ¿Ð’@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿ìÔ¿Ð’"@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿èÔ¿Ô’@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿èÔ¿Ô’"@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿äÔ¿Ø’@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿äÔ¿Ø’"@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿àÔ¿Ü’@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿àÔ¿Ü’"@ •:`’ £ÿÔ¿˜’@ Ô @Ô*п ’ Ò'¿ Ð¿”’ Ò'¿”¿þ€Çàèÿñÿñ  ø+jidctfst.cgcc2_compiled.jpeg_idct_ifast.umulx`”ÈüÜDxas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l ø d` Ä1! øl ,d>jidctflt.o/ 938694531 1729 22250 100664 3792 ` ELF 4(.shstrtab.text.rodata.symtab.strtab.rela.text.commentã¾(ð' Dò' Hô' Lö' Pø' TРDÒ!D`€Ð'¿˜Ð LÐ'¿¨Ð HÒ PÒ'¿¤¾Ð'¿  Ð'¿”¢ €€– Ò¿¨ Ò•*`‘: €¢ €t Ò¿¨ Ò•*`‘: €¢ €k 0Ò¿¨ Ò•*`‘: €¢ €b @Ò¿¨ Ò•*`‘: €¢ €Y PÒ¿¨ Ò•*`‘: €¢ €P `Ò¿¨ Ò•*`‘: €¢ €G pÒ¿¨ Ò•*`‘: €¢ €>п¨Ò•*`‘: Ð'¿ðÉ¿ð… „Ð¿¤Ç… ‰#Å'¾ŒÐ¿ Ò¾ŒÒ" Ò¿  Ò¾ŒÒ" @Ò¿  Ò¾ŒÒ" `Ò¿  Ò¾ŒÒ" €Ò¿  Ò¾ŒÒ"  Ò¿  Ò¾ŒÒ" ÀÒ¿  Ò¾ŒÒ" àÒ¿  Ò¾ŒÒ"п¨’ Ò'¿¨Ð¿¤’ Ò'¿¤Ð¿ ’ Ò'¿ €Ð¿¨Ò•*`‘: Ð'¿ðÉ¿ð… „Ð¿¤Ç… ‰#Å'¿ì Ò¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „ @Ò¿¤ Ç… ‰#Å'¿è @Ò¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „ €Ò¿¤ Ç… ‰#Å'¿ä `Ò¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „ ÀÒ¿¤ Ç… ‰#Å'¿àÅ¿ìÇ¿ä… ˆ#Å'¿ÌÅ¿ìÇ¿ä… ˆ£Å'¿ÈÅ¿èÇ¿à… ˆ#Å'¿ÀÅ¿èÇ¿à… ˆ£Ç … ‰#Ç¿À… ˆ£Å'¿ÄÅ¿ÌÇ¿À… ˆ#Å'¿ìÅ¿ÌÇ¿À… ˆ£Å'¿àÅ¿ÈÇ¿Ä… ˆ#Å'¿èÅ¿ÈÇ¿Ä… ˆ£Å'¿ä Ò¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „ Ò¿¤ Ç… ‰#Å'¿Ü 0Ò¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „ `Ò¿¤ Ç… ‰#Å'¿Ø PÒ¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „  Ò¿¤ Ç… ‰#Å'¿Ô pÒ¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „ àÒ¿¤ Ç… ‰#Å'¿ÐÅ¿ÔÇ¿Ø… ˆ#Å'¿¬Å¿ÔÇ¿Ø… ˆ£Å'¿¸Å¿ÜÇ¿Ð… ˆ#Å'¿´Å¿ÜÇ¿Ð… ˆ£Å'¿°Å¿´Ç¿¬… ˆ#Å'¿ÐÅ¿´Ç¿¬… ˆ£Ç … ‰#Å'¿ÈÅ¿¸Ç¿°… ˆ#Ç … ‰#Å'¿¼Å¿°Ç … ‰#Ç¿¼… ˆ£Å'¿ÌÅ¿¸Ç … ‰#Ç¿¼… ˆ#Å'¿ÄÅ¿ÄÇ¿Ð… ˆ£Å'¿ÔÅ¿ÈÇ¿Ô… ˆ£Å'¿ØÅ¿ÌÇ¿Ø… ˆ#Å'¿Üп Å¿ìÇ¿Ð… ˆ#Å" àÒ¿  Å¿ìÇ¿Ð… ˆ£Å" Ò¿  Å¿èÇ¿Ô… ˆ#Å" ÀÒ¿  Å¿èÇ¿Ô… ˆ£Å" @Ò¿  Å¿äÇ¿Ø… ˆ#Å"  Ò¿  Å¿äÇ¿Ø… ˆ£Å" €Ò¿  Å¿àÇ¿Ü… ˆ#Å" `Ò¿  Å¿àÇ¿Ü… ˆ£Å"п¨’ Ò'¿¨Ð¿¤’ Ò'¿¤Ð¿ ’ Ò'¿ Ð¿”’?ÿÒ'¿”¿þh¾Ð'¿ À'¿”¢ €€Ð¿”’‘*`Ò P ÒРT’@Ò'¿œÐ¿ ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿Ìп ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿È Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿À Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ£Ç … ‰#Ç¿À… ˆ£Å'¿ÄÅ¿ÌÇ¿À… ˆ#Å'¿ìÅ¿ÌÇ¿À… ˆ£Å'¿àÅ¿ÈÇ¿Ä… ˆ#Å'¿èÅ¿ÈÇ¿Ä… ˆ£Å'¿ä Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿¬ Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿¸ Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿´ Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿°Å¿´Ç¿¬… ˆ#Å'¿ÐÅ¿´Ç¿¬… ˆ£Ç … ‰#Å'¿ÈÅ¿¸Ç¿°… ˆ#Ç … ‰#Å'¿¼Å¿°Ç … ‰#Ç¿¼… ˆ£Å'¿ÌÅ¿¸Ç … ‰#Ç¿¼… ˆ#Å'¿ÄÅ¿ÄÇ¿Ð… ˆ£Å'¿ÔÅ¿ÈÇ¿Ô… ˆ£Å'¿ØÅ¿ÌÇ¿Ø… ˆ#Å'¿ÜпœÅ¿ìÇ¿Ð… ˆ#‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿ìÇ¿Ð… ˆ£‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿èÇ¿Ô… ˆ#‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿èÇ¿Ô… ˆ£‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿äÇ¿Ø… ˆ#‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿äÇ¿Ø… ˆ£‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿àÇ¿Ü… ˆ#‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿àÇ¿Ü… ˆ£‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô*п ’ Ò'¿ Ð¿”’ Ò'¿”¿þàÇàè?µó?ìƒ^?Š‹ÔÀ'=uÿñÿñ  Pjidctflt.cgcc2_compiled.jpeg_idct_floatl p   , 0 @ D \ ` ˆ Œ œ   ¸ ¼ Ì Ð è ì as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14= t P Ä Ô`! 4+) `ð 4 P>jidctint.o/ 938694534 1729 22250 100664 4892 ` ELF4(.shstrtab.text.symtab.strtab.rela.text.commentã¾8ð' Dò' Hô' Lö' Pø' TРDÒ!D`€Ð'¿¨Ð LÐ'¿¸Ð HÒ PÒ'¿´¾ Ð'¿° Ð'¿¤Ð¿¤€¢ €€ Ò¿¸ Ò•*`‘: €¢ €s Ò¿¸ Ò•*`‘: €¢ €j 0Ò¿¸ Ò•*`‘: €¢ €a @Ò¿¸ Ò•*`‘: €¢ €X PÒ¿¸ Ò•*`‘: €¢ €O `Ò¿¸ Ò•*`‘: €¢ €F pÒ¿¸ Ò•*`‘: €¢ €=п¸Ò•*`‘: Ò¿´Ò@@“* Ò'¾œÐ¿°Ò¾œÒ" Ò¿° Ò¾œÒ" @Ò¿° Ò¾œÒ" `Ò¿° Ò¾œÒ" €Ò¿° Ò¾œÒ"  Ò¿° Ò¾œÒ" ÀÒ¿° Ò¾œÒ" àÒ¿° Ò¾œÒ"п¸’ Ò'¿¸Ð¿´’ Ò'¿´Ð¿°’ Ò'¿°€ Ò¿¸ Ò•*`‘: ’ @Ô¿´’@ Ò@@Ð'¿È `Ò¿¸ Ò•*`‘: ’ ÀÔ¿´’@ Ò@@Ð'¿ÄпÈÒ¿Ä ”“* ’@•*`”"€‘* ’" Ò'¿ÌпĔ“* ’"@•*`”"€“* ’@•*`”€ Ò¿Ì@Ð'¿äпȔ“* ’@•*`”€“* ’"@‘*`Ò¿Ì@Ð'¿àп¸Ò•*`‘: Ò¿´Ò@@Ð'¿È @Ò¿¸ Ò•*`‘: ’ €Ô¿´’@ Ò@@Ð'¿ÄпÈÒ¿Ä “* Ò'¿ìпÈÒ¿Ä" “* Ò'¿èпìÒ¿à Ð'¿ÜпìÒ¿à" Ð'¿ÐпèÒ¿ä Ð'¿ØпèÒ¿ä" Ð'¿Ô pÒ¿¸ Ò•*`‘: ’ àÔ¿´’@ Ò@@Ð'¿ì PÒ¿¸ Ò•*`‘: ’  Ô¿´’@ Ò@@Ð'¿è 0Ò¿¸ Ò•*`‘: ’ `Ô¿´’@ Ò@@Ð'¿ä Ò¿¸ Ò•*`‘: ’ Ô¿´’@ Ò@@Ð'¿àпìÒ¿à Ð'¿ÌпèÒ¿ä Ð'¿ÈпìÒ¿ä Ð'¿ÄпèÒ¿à Ð'¿ÀпÄÒ¿À ’•*`”€“* ’"@ •*`”€“* @Ð'¿¼Ð¿ì”“* ’@•*`’@ •*`”"€‘* Ð'¿ìп蔓* ’@•*`”"€“* ’"@•*`”€“* "@Ð'¿èп䔓* ’@•*`’@ •*`”"€‘* " “* Ò'¿äÐ¿à”“* ’@•*` ’@ •*`"€Ð'¿àп̔“* ’"@•*`”€“* ’"@•*`”€“* ’"@•*`€’ Ò'¿ÌпȔ“* ’@•*`”€“* ’@•*`"€’ Ò'¿ÈпĔ“* ’"@•*`”"€“* ’@•*`€’ Ò'¿ÄпÀ”“* ’@•*`”€“* ’"@‘*`’ Ò'¿ÀпÄÒ¿¼ Ð'¿ÄпÀÒ¿¼ Ð'¿ÀпÌÒ¿Ä Ò¿ì@Ð'¿ìпÈÒ¿À Ò¿è@Ð'¿èпÈÒ¿Ä Ò¿ä@Ð'¿äпÌÒ¿À Ò¿à@Ð'¿àп°Ò¿ÜÔ¿à’@ ”d“:  Ò" àÒ¿° Ò¿ÜÔ¿à’"@ ”d“:  Ò" Ò¿° Ò¿ØÔ¿ä’@ ”d“:  Ò" ÀÒ¿° Ò¿ØÔ¿ä’"@ ”d“:  Ò" @Ò¿° Ò¿ÔÔ¿è’@ ”d“:  Ò"  Ò¿° Ò¿ÔÔ¿è’"@ ”d“:  Ò" `Ò¿° Ò¿ÐÔ¿ì’@ ”d“:  Ò" €Ò¿° Ò¿ÐÔ¿ì’"@ ”d“:  Ò"п¸’ Ò'¿¸Ð¿´’ Ò'¿´Ð¿°’ Ò'¿°Ð¿¤’?ÿÒ'¿¤¿ýï¾ Ð'¿°À'¿¤Ð¿¤€¢ €€çп¤’‘*`Ò P ÒРT’@Ò'¿¬ Ò¿° Ò€¢`€` Ò¿° Ò€¢`€Y Ò¿° Ò€¢`€R Ò¿° Ò€¢`€K Ò¿° Ò€¢`€D Ò¿° Ò€¢`€= Ò¿° Ò€¢`€6п°Ò`“:  cÿÒ¿¨ Ò Ò/¾›Ð¿¬Ò¾›Ò* Ò¿¬ Ò¾›Ò* Ò¿¬ Ò¾›Ò* Ò¿¬ Ò¾›Ò* Ò¿¬ Ò¾›Ò* Ò¿¬ Ò¾›Ò* Ò¿¬ Ò¾›Ò* Ò¿¬ Ò¾›Ò*п°’ Ò'¿°€t Ò¿° ÒÒ'¿È Ò¿° ÒÒ'¿ÄпÈÒ¿Ä ”“* ’@•*`”"€‘* ’" Ò'¿ÌпĔ“* ’"@•*`”"€“* ’@•*`”€ Ò¿Ì@Ð'¿äпȔ“* ’@•*`”€“* ’"@‘*`Ò¿Ì@Ð'¿àп°’ Ô¿°’@ ÐÒ@ “* Ò'¿ìп°’ Ô¿°’@ ÐÒ@" “* Ò'¿èпìÒ¿à Ð'¿ÜпìÒ¿à" Ð'¿ÐпèÒ¿ä Ð'¿ØпèÒ¿ä" Ð'¿Ô Ò¿° ÒÒ'¿ì Ò¿° ÒÒ'¿è Ò¿° ÒÒ'¿ä Ò¿° ÒÒ'¿àпìÒ¿à Ð'¿ÌпèÒ¿ä Ð'¿ÈпìÒ¿ä Ð'¿ÄпèÒ¿à Ð'¿ÀпÄÒ¿À ’•*`”€“* ’"@ •*`”€“* @Ð'¿¼Ð¿ì”“* ’@•*`’@ •*`”"€‘* Ð'¿ìп蔓* ’@•*`”"€“* ’"@•*`”€“* "@Ð'¿èп䔓* ’@•*`’@ •*`”"€‘* " “* Ò'¿äÐ¿à”“* ’@•*` ’@ •*`"€Ð'¿àп̔“* ’"@•*`”€“* ’"@•*`”€“* ’"@•*`€’ Ò'¿ÌпȔ“* ’@•*`”€“* ’@•*`"€’ Ò'¿ÈпĔ“* ’"@•*`”"€“* ’@•*`€’ Ò'¿ÄпÀ”“* ’@•*`”€“* ’"@‘*`’ Ò'¿ÀпÄÒ¿¼ Ð'¿ÄпÀÒ¿¼ Ð'¿ÀпÌÒ¿Ä Ò¿ì@Ð'¿ìпÈÒ¿À Ò¿è@Ð'¿èпÈÒ¿Ä Ò¿ä@Ð'¿äпÌÒ¿À Ò¿à@Ð'¿àп¬Ò¿ÜÔ¿à’@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ÜÔ¿à’"@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ØÔ¿ä’@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ØÔ¿ä’"@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ÔÔ¿è’@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ÔÔ¿è’"@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ÐÔ¿ì’@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ÐÔ¿ì’"@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô*п°’ Ò'¿°Ð¿¤’ Ò'¿¤¿þÇàèÿñÿñ X+jidctint.cgcc2_compiled.jpeg_idct_islow.umulxt¨`”0d˜Ìas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 lXÄ`$1!Xl ,Ä>jidctred.o/ 938694536 1729 22250 100664 5380 ` ELFì4(.shstrtab.text.symtab.strtab.rela.text.commentã¾Ðð' Dò' Hô' Lö' Pø' TРDÒ!D`€Ð'¿¼Ð LÐ'¿ÌРHÒ PÒ'¿È¿8Ð'¿Ä Ð'¿¸Ð¿¸€¢ €€_п¸€¢ €€K Ò¿Ì Ò•*`‘: €¢ €M Ò¿Ì Ò•*`‘: €¢ €D 0Ò¿Ì Ò•*`‘: €¢ €; PÒ¿Ì Ò•*`‘: €¢ €2 `Ò¿Ì Ò•*`‘: €¢ €) pÒ¿Ì Ò•*`‘: €¢ € пÌÒ•*`‘: Ò¿ÈÒ@@“* Ò'¿4пÄÒ¿4Ò" Ò¿Ä Ò¿4Ò" @Ò¿Ä Ò¿4Ò" `Ò¿Ä Ò¿4Ò"€÷пÌÒ•*`‘: Ò¿ÈÒ@@Ð'¿ìпì“* Ò'¿ì Ò¿Ì Ò•*`‘: ’ @Ô¿È’@ Ò@@Ð'¿Ø `Ò¿Ì Ò•*`‘: ’ ÀÔ¿È’@ Ò@@Ð'¿ÔÒ¿Ø” ‘* " •* ”"€ —* –À ‘*à Ò¿Ô– •*à”€ —* –À •*à”"€ “* ”  Ð'¿èпìÒ¿è Ð'¿äпìÒ¿è" Ð'¿à pÒ¿Ì Ò•*`‘: ’ àÔ¿È’@ Ò@@Ð'¿Ü PÒ¿Ì Ò•*`‘: ’  Ô¿È’@ Ò@@Ð'¿Ø 0Ò¿Ì Ò•*`‘: ’ `Ô¿È’@ Ò@@Ð'¿Ô Ò¿Ì Ò•*`‘: ’ Ô¿È’@ Ò@@Ð'¿Ðпܔ“* ’"@•*`”"€“* ’@•*` Ò¿Ø– •*à”"€ —* –"À •*à”"€ —* –À  Ò¿Ô– •*à”€ —* –"À •*à”"€ “* ”€ ’  ҿЖ •*à”€ —* –"À •*à”€  Ð'¿ìпܔ“* ’@•*`”€“*  Ò¿Ø– •*à”€ —* –"À •*à”€ —* –"À “*à”  Ò¿Ô– •*à”"€ —* –À •*à”"€ —* –À •*à”"€ —* –À  ҿЖ •*à”€ —* –À •*à”€ —* –"À  Ð'¿èпÄÒ¿äÔ¿è’@ ”h“:  Ò" `Ò¿Ä Ò¿äÔ¿è’"@ ”h“:  Ò" Ò¿Ä Ò¿àÔ¿ì’@ ”h“:  Ò" @Ò¿Ä Ò¿àÔ¿ì’"@ ”h“:  Ò"п̒ Ò'¿ÌпȒ Ò'¿ÈпĒ Ò'¿Äп¸’?ÿÒ'¿¸¿þŸ¿8Ð'¿ÄÀ'¿¸Ð¿¸€¢ €€*п¸’‘*`Ò P ÒРT’@Ò'¿À Ò¿Ä Ò€¢`€E Ò¿Ä Ò€¢`€> Ò¿Ä Ò€¢`€7 Ò¿Ä Ò€¢`€0 Ò¿Ä Ò€¢`€) Ò¿Ä Ò€¢`€"пÄÒ`“:  cÿÒ¿¼ Ò Ò/¿3пÀÒ¿3Ò* Ò¿À Ò¿3Ò* Ò¿À Ò¿3Ò* Ò¿À Ò¿3Ò*пĒ Ò'¿Ä€ÒпÄÒ‘*`Ð'¿ì Ò¿Ä Ò” ‘* " •* ”"€ —* –À ‘*à ’ Ö¿Ä”@ Ò€– •*à”€ —* –À •*à”"€ “* ”  Ð'¿èпìÒ¿è Ð'¿äпìÒ¿è" Ð'¿à Ò¿Ä ÒÒ'¿Ü Ò¿Ä ÒÒ'¿Ø Ò¿Ä ÒÒ'¿Ô Ò¿Ä ÒÒ'¿Ðпܔ“* ’"@•*`”"€“* ’@•*` Ò¿Ø– •*à”"€ —* –"À •*à”"€ —* –À  Ò¿Ô– •*à”€ —* –"À •*à”"€ “* ”€ ’  ҿЖ •*à”€ —* –"À •*à”€  Ð'¿ìпܔ“* ’@•*`”€“*  Ò¿Ø– •*à”€ —* –"À •*à”€ —* –"À “*à”  Ò¿Ô– •*à”"€ —* –À •*à”"€ —* –À •*à”"€ —* –À  ҿЖ •*à”€ —* –À •*à”€ —* –"À  Ð'¿èпÀÒ¿äÔ¿è’@ ’@ •:`’ £ÿÔ¿¼’@ Ô @Ô* Ò¿À Ò¿äÔ¿è’"@ ’@ •:`’ £ÿÔ¿¼’@ Ô @Ô* Ò¿À Ò¿àÔ¿ì’@ ’@ •:`’ £ÿÔ¿¼’@ Ô @Ô* Ò¿À Ò¿àÔ¿ì’"@ ’@ •:`’ £ÿÔ¿¼’@ Ô @Ô*пĒ Ò'¿Äп¸’ Ò'¿¸¿þÔÇàèã¿ ð' Dò' Hô' Lö' Pø' TРDÒ!D`€Ð'¿ÐРLÐ'¿àРHÒ PÒ'¿Ü¿ˆÐ'¿Ø Ð'¿Ìп̀¢ €€áп̀¢ € п̀¢ €Ð¿Ì€¢ €€€Ã Ò¿à Ò•*`‘: €¢ €1 0Ò¿à Ò•*`‘: €¢ €( PÒ¿à Ò•*`‘: €¢ € pÒ¿à Ò•*`‘: €¢ €Ð¿àÒ•*`‘: Ò¿ÜÒ@@“* Ò'¿„пØÒ¿„Ò" Ò¿Ø Ò¿„Ò"€‹Ð¿àÒ•*`‘: Ò¿ÜÒ@@Ð'¿äпä“* Ò'¿è pÒ¿à Ò•*`‘: ’ àÔ¿Ü’@ Ò@@Ð'¿äп䔓* ’@•*`”"€“* ’@•*`”€‘* ’ Ò'¿ì PÒ¿à Ò•*`‘: ’  Ô¿Ü’@ Ò@@Ð'¿äп䒕*`”"€“* ’"@•*`’@ •*`€Ò¿ì@Ð'¿ì 0Ò¿à Ò•*`‘: ’ `Ô¿Ü’@ Ò@@Ð'¿äп䔓* ’@•*`”€“* ’"@•*`”"€“* ’@‘*`’ Ð¿ì’ Ò'¿ì Ò¿à Ò•*`‘: ’ Ô¿Ü’@ Ò@@Ð'¿äп䔓* ’"@•*`”€“* ’"@‘*`Ò¿ì@Ð'¿ìпØÒ¿èÔ¿ì’@ ’@ •:` Ô" Ò¿Ø Ò¿èÔ¿ì’"@ ’@ •:` Ô"Ð¿à’ Ò'¿àпܒ Ò'¿Üпؒ Ò'¿Øп̒?ÿÒ'¿Ì¿ÿ¿ˆÐ'¿ØÀ'¿Ìп̀¢ €€ Ð¿Ì’‘*`Ò P ÒРT’@Ò'¿Ô Ò¿Ø Ò€¢`€- Ò¿Ø Ò€¢`€& Ò¿Ø Ò€¢`€ Ò¿Ø Ò€¢`€Ð¿ØÒ`“:  cÿÒ¿Ð Ò Ò/¿ƒÐ¿ÔÒ¿ƒÒ* Ò¿Ô Ò¿ƒÒ*пؒ Ò'¿Ø€`пØÒ‘*`Ð'¿è Ô¿Ø’ Ð@”“* ’@•*`”"€“* ’@•*`”€“*  ’ Ö¿Ø”@ Ò€” —* –"À •*à”"€ —* ”€ —* ’À  ’ Ö¿Ø”@ Ò€– •*à”€ —* –À •*à”"€ —* –"À •*à”€ “* ”  ’ Ö¿Ø”@ Ò€– •*à”"€ —* –À •*à”"€ “*  Ð'¿ìпÔÒ¿èÔ¿ì’@ ’@ •:`’ £ÿÔ¿Ð’@ Ô @Ô* Ò¿Ô Ò¿èÔ¿ì’"@ ’@ •:`’ £ÿÔ¿Ð’@ Ô @Ô*пؒ Ò'¿Øп̒ Ò'¿Ì¿ÿ^Çàèã¿€ð' Dò' Hô' Lö' Pø' TРDÒ!D`€Ð'¿äРHÒ PÒ'¿èРLÒ•*`‘: Ò¿èÒ@@Ð'¿ìÒ¿ì`“: Ò'¿ìРPÒÔ T@ Ô¿ì’ £ÿÔ¿ä’@ Ô @Ô*Çàèÿñÿñ !(˜/ ¤„= ¤jidctred.cgcc2_compiled..umuljpeg_idct_1x1jpeg_idct_2x2jpeg_idct_4x4lä$X8l  ð @ € è P Ètas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 lÀ,€¬K!ø´ ,¬>jdsample.o/ 938694523 1729 22250 100664 5296 ` ELF˜4(.shstrtab.text.symtab.strtab.rela.text.comment㿈ð' DРDÒ!ÄÒ'¿ìпìÒ DÔa8Ô" \пìÒ DÔ`tÔ" `Çàèã¿€ð' Dò' Hô' Lö' Pø' Tú' XРDÒ!ÄÒ'¿ìпìÒ DÐ \Òa8€¢ €;À'¿èРDÒ ØÒ'¿äРDÒ¿èÐ $€¢@€€-пìÒ¿è” “*   п蒑*`Ò H¢ РLÒ¿ìÔ¿è– •*à’@ ÐÒ`d@’‘*`Ò@” п蒑*`’ пì–@Ø 4РDÒ¿äŸÃÐ¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÏпìÀ" \РDÒ¿ìÐ!8Ò`\" Ð'¿àпìÒ¿àÐ `€¢@€Ð¿ìÒ `Ò'¿àРXÒ \Ð’"@Ò' \пàÒ \€¢ €Ð \Ð'¿àÒ DÐaÈÔ¿ì’  Ô¿ìÖ XØÀ– ™*àÚ T– Ú Ð DÔ \Ø¿àŸÃ@РXÒ XÔ@Ò¿à”€ Ô"пìÒ¿ìÔ``Ò¿à”"€ Ô" `пìÒ¿ìÔ`\Ò¿à”€ Ô" \пìÒ DÐ \Òa8€¢ €Ò LРLÒ LÔ@’ Ò"Çàèã¿ð' Dò' Hô' Lö' PРPÒ LÒ"Çàèã¿ð' Dò' Hô' Lö' PРPÀ"Çàèã¿pð' Dò' Hô' Lö' PРDÒ!ÄÒ'¿ìРPÒÒ'¿èпìÒ HÔ` Ò Œ `ÿÐ'¿àпìÒ HÔ` Ò – `ÿÐ'¿ÜÀ'¿ÔÀ'¿ØРDÒ¿ÔÐ!8€¢@€€?пؒ‘*`Ò L àпԒ‘*`Ò¿è âРDÒ p@ Ð'¿äп䀤@ €€ä   æ¿à€¤à€€ä,@¢`¦ÿÿ¿ÿø¿ÿíп܀¢ € пԖ пܘ?ÿÚ DпèÒ¿ÔÔ¿èÚ`p@пؒ Ò'¿ØпÔÒ¿Ü Ð'¿Ô¿ÿ½Çàèã¿€ð' Dò' Hô' Lö' PРPÒÒ'¿ìÀ'¿äÖ DØ¿äÖá8€£ €€%Ö¿ä˜ —+ Ø L–À ÐÀÖ¿ä˜ —+ Ø¿ì–À ÒÀÖ DØàp–@ Ö'¿èֿ耢@ €€ Ô  Ô*@’`Ô*@’`¿ÿôÖ¿ä˜àØ'¿ä¿ÿ×Çàèã¿€ð' Dò' Hô' Lö' PРPÒÒ'¿ìÀ'¿àÀ'¿äРDÒ¿àÐ!8€¢@€€2п䒑*`Ò L àÐ¿à’‘*`Ò¿ì âРDÒ p@ Ð'¿èп耤@ €€ ä   ä,@¢`ä,@¢`¿ÿôÐ¿à– Ú DпìÒ¿àÔ¿ì˜ Ú`p@Ð¿ä’ Ò'¿äÐ¿à’ Ò'¿à¿ÿÊÇàè㿈ð' Dò' Hô' Lö' PРPÒÒ'¿ìÀ'¿èØ DÚ¿èØ!8€£@ €€UØ¿èš ™+`Ú L˜ ÐØ¿èš ™+`Ú¿ì˜ ÒØ ” ÿ ˜ Ø*@’`š ™+`˜ Ä š ÿ˜ š …;`˜Ø*@’`Ø HÚ (–þ€¢à€€Ø ” ÿ˜ ›+ ”€  Ú ?þ˜ `ÿš€ ˜`›; ˜ Ø*@’`Ú ˜ `ÿš€ ˜`›; ˜ Ø*@’`–ÿÿ¿ÿäØ ” ÿš ™+`˜ Ä ?ÿš ÿ˜ š …;`˜Ø*@’`˜ Ø*@’`Ø¿èš Ú'¿è¿ÿ§Çàèã¿€ð' Dò' Hô' Lö' PРPÒÒ'¿ìÀ'¿äÀ'¿èÆ DÞ¿äÆá8€£À€€”À'¿àÆ¿à€ à€€ˆÆ¿èž‡+àÞ L†ÀÐÀÆ¿à€ à€ Æ¿èž‡+àÞ L†ÀÒÿü€Æ¿èž‡+àÞ L†ÀÒà†¿äÞÀ ¢¡,`â¿ì ÔžàÞ ÀÆ –àÿ† Ÿ(à–ÀÞ @† àÿ–À’` Æ šàÿ† Ÿ(àš@Þ @† àÿš@’` † Ÿ(à†àŸ8à†Æ*€” ž ‡+à†À žÀ †àŸ8à†Æ*€” ˜ – Æ HÞà(„ÿþ€  €€#Æ šàÿ† Ÿ(àš@Þ @† àÿš@’` ž ‡+à†À žÀ †àŸ8à†Æ*€” ž ‡+à†À žÀ †àŸ8à†Æ*€” ˜ – „¿ÿ¿ÿÜž ‡+à†À žÀ †àŸ8à†Æ*€” † Ÿ(à†àŸ8à†Æ*€” Æ¿àžàÞ'¿à¿ÿvÆ¿èžàÞ'¿è¿ÿhÇàèã¿hð' DРDÒ Ö@РD’ ”  ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Äп쒠Ò"п쒠Ò" пìÀ" РDÒ!,€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€ Ò DÔ`L€¢ €Ò DÔa<€¢ € Ð'¿ÜÀ'¿èРDÒ ØÒ'¿äРDÒ¿èÐ $€¢@€€ùпäÒ¿äÐ Ò`$@Ò DÒa<@Ð'¿ØпäÒ¿äÐ Ò`$@Ò DÒa<@Ð'¿ÔРDÒ!4Ò'¿ÐРDÒ!8Ò'¿ÌпìÒ¿è” “*  Ò¿ÔÒ" d Ð'¿àпäÒ 0€¢`€ пìÒ¿è” “*  ’ Ò" 4À'¿à€¢Ð¿ØҿЀ¢ €Ð¿ÔÒ¿Ì€¢ € пìÒ¿è” “*  ’ Ò" 4À'¿à€Ð¿Ø’‘*`ҿЀ¢ €$пÔÒ¿Ì€¢ €Ð¿Ü€¢ €Ð¿äÒ (€¢`€ пìÒ¿è” “*  ’ Ò" 4€ пìÒ¿è” “*  ’ Ò" 4€dпؒ‘*`ҿЀ¢ €)пԒ‘*`Ò¿Ì€¢ €"п܀¢ €Ð¿äÒ (€¢`€Ð¿ìÒ¿è” “*  ’ Ò" 4Ð¿ì’ Ò" € пìÒ¿è” “*  ’ Ò" 4€6Ò¿Ð Ò¿Ø@€¢ €$Ò¿Ì Ò¿Ô@€¢ €Ð¿ìÒ¿è” “*  ’ Ò" 4пìÒ¿è  Ð¿ÐÒ¿Ø@Ð, ŒÐ¿ìÒ¿è  Ð¿ÌÒ¿Ô@Ð, –€ РDÒ &Ð"`РDÒÔ@РDŸÂ€Ð¿à€¢ €Ð Dà РDÒ DÐ pÒa4@”Ö DØ Ð D’ Öá8ŸÃÒ¿ìÔ¿è– •*à’@ Ð"` Ð¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÇàèÿñÿñ äˆ<-<À$Jì˜^T˜r˜(„D’lØ <\­²ÄÊÔÙ „äjdsample.cint_upsamplestart_pass_upsamplegcc2_compiled.noop_upsampleh2v2_fancy_upsampleh2v1_fancy_upsamplefullsize_upsampleh2v2_upsampleh2v1_upsamplesep_upsample.remjcopy_sample_rows.umuljround_up.divjinit_upsamplerø8$ À Ä Ð < Ô < ” ¤ À Ð @ À D À ” ˜ ˜ ˜  T  T < l @ l À ì Ä ì ô D ø D 4 \ ä` ä|œas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 lhÔ0 é!ðh ,X>jdcolor.o/ 938694504 1729 22250 100664 4496 ` ELFx4(.shstrtab.text.symtab.strtab.rela.text.commentã¿€ð' DРDÒ!ÈÒ'¿ìРDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`РDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"` РDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`РDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`À'¿è?€Ð'¿äп耢 ÿ€€[пìÒ¿è” “* Ô @ Ò¿ä– •*à”€ —* –"À •*à”€ “* ”€  ’€ •:`Ô"пìÒ¿è” “* Ô @ Ò¿ä– •*à”"€ —* –À •*à”"€ “* ’"@ •*` ’€ •:`Ô"пìÒ¿è” “* Ô @ Ò¿ä” —* –À •*à”"€ —* ”€ —* –À “*à” Ô"пìÒ¿è” “* Ô @ Ò¿ä” —* –À •*à”"€ —* –"À “*à’"@ •*`’  ’@ Ò"Ð¿è’ Ò'¿èÐ¿ä’ Ò'¿ä¿ÿ£Çàè㿈ð' Dò' Hô' Lö' Pø' TРDÒ!ÈÒ'¿ìÞ Dààpà'¿èà DÞ!Dâ¿ìà`ä¿ìâ  æ¿ìäàè¿ìæ ê T¨ÿªê' T€¥`€€Mè Hê L¬«- ì¨@ب ê H¨ê L¬«- ì¨@Ú¨ ê H¨ê L¬«- ì¨@Äè Lª ê' L¨ PêÖ@ª`ê%† è¿è€ À €€#è  ÿè @’ ÿ耔 ÿ¨ «- ì¨ê Àê*Àª ©-`ª ­-`èÀꀨ«= ¨ê Àê*ਠ«- ì@¨ê Àê*à–à†à¿ÿÛ¿ÿ®Çàè㿈ð' Dò' Hô' Lö' Pø' TØ DÖ $Ø DÚ pÚ'¿ìÚ T˜ÿš Ú' T€£`€€2À'¿èؿ耣 €€#Ø¿èš ™+`Ú H˜ Ú L„ ›( Ä˜@ÐØ PÚØ¿è’@ Կ쀢 €€ Ø Ø*@ ’@ ”¿ÿ¿ÿöØ¿èš Ú'¿è¿ÿÛØ Lš Ú' LØ Pš Ú' P¿ÿÉÇàèã¿ð' Dò' Hô' Lö' Pø' TРHÚ DÐÒ LÔ P– Ø TÚ`p@Çàè㿈ð' Dò' Hô' Lö' Pø' TÖ DØàpØ'¿ìØ T–?ÿ˜ Ø' T€£ €€#Ú H– LØÀ„ †…(àÆ@š€Ð@˜ Ø"À– PØÀÒ˜ Ø"À” ֿ쀢€ €€ Ö Ö*`Ö*`Ö*@’`” ¿ÿô¿ÿØÇàè㿈ð' Dò' Hô' Lö' Pø' TРDÒ!ÈÒ'¿ìà Dâ pâ'¿èâ DàaDä¿ìâ æ¿ìäà è¿ìæ ê¿ìè`ì Tª¿ÿ¬ì' T€¥ €€^ê Hì L®­-àî@ª€Ø@ª ì Hª@ì L®­-àî@ª€Ú@ª ì Hª@ì L®­-àî@ª€Ä@ª ì Hª@ì L®­-àî@ª€Æ@ê L¬`ì' Lª Pì@Ö€¬ ì%@ž ê¿è€£À €€+ê  `ÿê @’ `ÿꀔ `ÿª ÿ¬ ¯- ð@¬ª%@ì @ì*Àª ÿ® ­-à® ±-àìîÀ¬€¯= ¬ª%@ì @ì*ઠÿ¬ ¯- ð€¬ª%@ì @ì*àêÀê*à–àžà¿ÿÓ¿ÿÇàèã¿ð' DÇàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Èп쒠Ò"РDÒ (ÿ€¢ €A’‘*`’ Ð ÂРDÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€5РDÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€$РDÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€Ò DÐ`,€¢ €J€¢ €€¢ € €€¢ €r€˜Ð D’ Ò" xРDÒ (€¢`€ РDÒ (€¢`€€"п쒠Ò"  Ð'¿èРDÒ¿èÐ $€¢@€€Ð DÒ¿è– •*à”€ —* –À “*àÔ Ø@ À" 0Ð¿è’ Ò'¿è¿ÿê€ Ð DÒ Ð"`РDÒÔ@РDŸÂ€€zРD’ Ò" xРDÒ (€¢`€ п쒠Ò" РDÿý3€"РDÒ (€¢`€Ð¿ì’ Ò" €Ð DÒ (€¢`€Ð¿ì’ Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€GРD’ Ò" xРDÒ (€¢`€ п쒠Ò" РDÿý€Ð DÒ (€¢`€Ð¿ì’ Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ DÐ ,Ò`(€¢ € РDÒ DÔ`$Ô" xп쒠Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ T€¢`€Ð D’ Ò" |€Ð DÒ DÔ`xÔ" |Çàèÿñÿñ (ôD1ô>TÔO^ Hp‚D°’,ôªjdcolor.cycck_cmyk_convertbuild_ycc_rgb_tablenull_convertgray_rgb_convertgcc2_compiled.grayscale_convertstart_pass_dcolorycc_rgb_convertjinit_color_deconverterjcopy_sample_rowsD h l ” ¨˜ ¨¨ ¼¬  °  ´  D¸  D T  X  $ D ( D \ T ` T ˆ ô Œ ô ð ( ô ( ( ô , ô œ ô   ôas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l  ŒÐ \¼!  ,8>jquant1.o/ 938694548 1729 22250 100664 8848 ` ELF!P4(.shstrtab.text.rodata.symtab.strtab.rela.text.commentã¿pð' Dò' HРDÒ xÒ'¿ìРDÒ `Ò'¿è Ð'¿àÐ¿à’ Ò'¿àпàÐ'¿Ð Ð'¿ÜпÜҿ쀢 €€ пÐÒ¿à@Ð'¿Ðпܒ Ò'¿Ü¿ÿñпÐҿ耢 €€¿ÿáпà’?ÿÒ'¿àÐ¿à€¢ €Ð DÒ 8Ð"`РDÒпÐÐ"`РDÒÔ@РDŸÂ€ Ð'¿äÀ'¿ÜпÜҿ쀢 €€Ð¿Ü’‘*`Ò H Ò¿àÒ"пäÒ¿à@Ð'¿äпܒ Ò'¿Ü¿ÿêÀ'¿ÔÀ'¿ÜпÜҿ쀢 €€IРDÒ ,€¢`€ Ò¿Ü” “*  ’@Ð@€Ð¿ÜÐ'¿Øпؒ‘*`Ô H’ пäÒ@@Ð'¿Ðпؒ‘*`Ò H Ô’ Ð¿Ð@Ð'¿ÐпÐҿ耢 €€Ð¿Ø’‘*`Ò H Ò¿Ø “* Ô H@ Ò¿Ø” “* Ô H’@ Ô@’ Ò"пÐÐ'¿ä Ð'¿Ôпܒ Ò'¿Ü¿ÿ´Ð¿Ô€¢ €€¿ÿªÐ¿ä°€Çàèã¿ð' Dò' Hô' Lö' PРL’•*`’"€Ð P•: —2 ” ‘: ’@ Ò P@°€Çàèã¿ð' Dò' Hô' Lö' PРL’•*` ’•*`"€Ò P Ò P” “* @°€Çàèã¿`ð' DРDÒ!ÌÒ'¿ìÐ¿ì’ Ð Dÿÿ Ð'¿äРDÒ x€¢`€,РDÒ`Ð'¿ÀпÀÒ¿äÒ" Ò¿À Ò¿ìÔ` Ô" Ò¿À Ò¿ìÔ`$Ô" Ò¿À Ò¿ìÔ`(Ô"РDÒ ^Ð"`РDÒÔ`РD’ ŸÂ€€¿ÿڀРDÒ _Ð"`РDÒпäÐ"`РDÒÔ`РD’ ŸÂ€Ð DÒ Ö DØ`РD’ Ô¿äÖàxŸÃÐ'¿èпäÐ'¿ÌÀ'¿àРDÒ¿àÐ x€¢@€€UпìÒ¿à” “*  Ò Ò'¿ÔпÌÒ¿Ô@Ð'¿ÐÀ'¿ÜпÜÒ¿Ô€¢ €€:пԖ?ÿРDÒ¿àÔ¿ÜÿÿXÐ'¿ÄпÜÒ¿Ð@Ð'¿ÈпÈҿ䀢 €€!À'¿ØпØҿЀ¢ €€Ð¿à’‘*`Ò¿è Ò¿ÈÔ¿Ø’@ Ô@ Ò¿ÇÒ*пؒ Ò'¿Ø¿ÿêпÈÒ¿Ì Ð'¿È¿ÿÜпܒ Ò'¿Ü¿ÿÃпÐÐ'¿ÌÐ¿à’ Ò'¿à¿ÿ§Ð¿ìÒ¿èÒ" пìÒ¿äÒ" Çàèã¿hð' DРDÒ!ÌÒ'¿ìРDÒ X€¢`€ !þÐ'¿ÌÐ¿ì’ Ò" €À'¿ÌпìÀ" Ò DÐ`Ò¿Ì”aÖ DØ Ð D’ ÖàxŸÃÒ¿ìÐ"`пìÒ Ò'¿ÔÀ'¿äРDÒ¿äÐ x€¢@€€~пìÒ¿ä” “*  Ò Ò'¿ØпÔÒ¿Ø@Ð'¿Ôп̀¢ €Ð¿ìÒ¿ä” “* Ô @ Ò¿ìÔ¿ä– •*àÖ`’€ Ô@’ ÿÒ"пìÒ¿ä” “* Ô @ ÒÒ'¿èÀ'¿Ðпؖ?ÿРDÒ¿ä” ÿþÔÐ'¿ÜÀ'¿àÐ¿à€¢ ÿ€€#пàÒ¿Ü€¢ €€Ò¿Ð`”Ô'¿Ðпؖ?ÿРDÒ¿äÿþ»Ð'¿Ü¿ÿîпèÒ¿à  Ð¿ÐÒ¿Ô@Ð,Ð¿à’ Ò'¿à¿ÿÛп̀¢ € Ð'¿àÐ¿à€¢ ÿ€€Ð¿èÒ¿à" Ò¿èÔ @Ô*пàÒ¿è ’ ÿÔ¿è’@ Ô @Ô* ÿÐ¿à’ Ò'¿à¿ÿéÐ¿ä’ Ò'¿ä¿ÿ~Çàèã¿xð' Dò' HРDÒ Ö@РD’ ”$ŸÂÀÐ'¿ìÒ Hÿ’‘*` Ð'¿ÜÀ'¿èп耢 €€?À'¿äп䀢 €€3Ò¿è” “* Ô¿ä’@ ” @ Ò `ÿ’‘*`’ ÿ"@’•*`"€Ð'¿àпèÒ¿ä” ¡* “* пì¢@Ð¿à€¢ € пठҿÜ@¤ €Ð¿àÒ¿Ü@¤ä$@Ð¿ä’ Ò'¿ä¿ÿËÐ¿è’ Ò'¿è¿ÿ¿Ð¿ì°€Çàèã¿xð' DРDÒ!ÌÒ'¿ìÀ'¿äРDÒ¿äÐ x€¢@€€?пìÒ¿ä” “*  Ò Ò'¿ÜÀ'¿èÀ'¿àпàҿ䀢 €€Ð¿ìÒ¿à” “*  Ò¿ÜÐ €¢@€ пìÒ¿à” “*  Ò 4Ò'¿è€Ð¿à’ Ò'¿à¿ÿãп耢 €Ð DÒ¿ÜÿÿiÐ'¿èпìÒ¿ä” “*  Ò¿èÒ" 4Ð¿ä’ Ò'¿ä¿ÿ½Çàèã¿xð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìпìÒ Ò'¿èØ DÚ pÚ'¿ÜÚ DØ`xÀ'¿äÚ¿äÄ P€£@€€9Ú¿ä„ ›( Ä Hš@Ô@Ú¿ä„ ›( Ä Lš@Ö@Ú¿ÜÚ'¿àÚ¿à€£`€€  ’ €¢@ €€š …+`Æ¿èš€Æ €„àÿÆ@š€Ä @š ÿ ” ’`¿ÿîšÚ*À–àÚ¿à„ÿÄ'¿à¿ÿÞÚ¿ä„`Ä'¿ä¿ÿÄÇàèã¿pð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìÖ¿ìØàÖÖ'¿èÖ¿ì˜ Úà– ØÀØ'¿äÖ¿ì˜ Úà– ØÀØ'¿àÖ DØàpØ'¿ÔÀ'¿ÜÖ¿ÜØ P€¢À €€:ֿܘ —+ Ø H–À ÒÀֿܘ —+ Ø L–À ÔÀÖ¿ÔÖ'¿ØÖ¿Ø€¢à€€!Ø @– ÿØ¿è–À Ø À ÿ’`Ø @– ÿØ¿ä–À Ø À– ÿ ’`Ø @– ÿØ¿à–À Ø À– ÿ ’`–Ö*€” Ö¿Ø˜ÿÿØ'¿Ø¿ÿÝֿܘàØ'¿Ü¿ÿÃÇàèã¿hð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìРDÒ xÒ'¿ØРDÒ pÒ'¿ÈÀ'¿ÐпÐÒ P€¢ €€lпВ‘*`Ô L’ Ð@Ò¿È@пìÒ 0Ò'¿àÀ'¿ÔпÔÒ¿Ø€¢ €€LпВ‘*`Ò H ÒпԠ@пВ‘*`Ò L âпìÒ¿Ô” “* Ô @ ÒÒ'¿èпìÒ¿Ô” “*  Ò¿à” “* Ð 4’ Ò'¿äÀ'¿ÜпÈÐ'¿Ìп̀¢ €€Ò `ÿÒ¿Ü” “* Ô¿ä’@ Ô@ Ò¿è Ò @Ð ’@Ò,@пؠ¢`Ò¿Ü`’ Ò'¿Üп̒?ÿÒ'¿Ì¿ÿáпԒ Ò'¿Ô¿ÿ±Ò¿à`’ Ò'¿àпìÒ¿àÒ" 0пВ Ò'¿Ð¿ÿ‘Çàèã¿`ð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìÖ¿ìØàÖÖ'¿èÖ¿ì˜ Úà– ØÀØ'¿äÖ¿ì˜ Úà– ØÀØ'¿àÖ DØàpØ'¿ÀÀ'¿ÈÖ¿ÈØ P€¢À €€sÖ¿ìØà0Ø'¿ÐֿȘ —+ Ø H–À ÒÀֿȘ —+ Ø L–À ÔÀÖ¿ìؿК ™+`Öà4˜À Ø'¿ÜÖ¿ìؿК ™+`Öà8˜À Ø'¿ØÖ¿ìؿК ™+`Öà<˜À Ø'¿ÔÀ'¿ÌÖ¿ÀÖ'¿ÄÖ¿Ä€¢à€€:Ø @– ÿØ¿Ìš ™+`ڿܘ Ú–À Ø¿è–À Ø À ÿ’`Ø @– ÿØ¿Ìš ™+`ڿؘ Ú–À Ø¿ä–À Ø À– ÿ ’`Ø @– ÿØ¿Ìš ™+`Ú¿Ô˜ Ú–À Ø¿à–À Ø À– ÿ ’`–Ö*€” Ø¿Ì– ˜ àØ'¿ÌֿĘÿÿØ'¿Ä¿ÿÄؿЖ ˜ àØ'¿ÐÖ¿ìØ¿ÐØ"à0ֿȘàØ'¿È¿ÿŠÇàèã¿Pð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìРDÒ xÒ'¿ÌРDÒ pÒ'¿´Ð DÒ!DÒ'¿°À'¿¼Ð¿¼Ò P€¢ €€¹Ð¿¼’‘*`Ô L’ Ð@Ò¿´@À'¿ÀпÀÒ¿Ì€¢ €€œÐ¿¼’‘*`Ò H ÒпÀ¤@п¼’‘*`Ò L æпìÒ T€¢`€Ð¿´’?ÿ Ò¿Ì@¤€Ò¿´ÿ¦À?ÿÐ'¿Èп̒ Ò'¿ÄпìÒ¿À” “*  Ò¿´” “* ”`Ð D¢€€  Ð'¿ÈпÌÐ'¿ÄпìÒ¿À” “*  â DпìÒ¿À” “* Ô @ ÒÒ'¿ØпìÒ¿À” “* Ô @ ÒÒ'¿Ô  À'¿äÀ'¿èп´Ð'¿¸Ð¿¸€¢ €€AпȒ‘*`Ò@•*`‘:    ¡< Ò € `ÿ Ò¿° Ò   `ÿÒ¿Ø Ò `ÿÐ'¿ÐÐ ÀÒ¿Ó Ð,ÀпÔÒ¿Ð Ò `ÿ $à'¿à“* Ò'¿ÜÐ¿Ü Ð¿æ’ Ð4@пܠпè’Ò'¿äпàÐ'¿èпܠпĤ€Ð¿È¦ÀпȒ‘*`¢@п¸’?ÿÒ'¿¸¿ÿ½Ð¿æÐ4@пÀ’ Ò'¿À¿ÿaпìÒ¿ìÔ`T– €  ’`?ÿÒ" Tп¼’ Ò'¿¼¿ÿDÇàèã¿€ð' DРDÒ!ÌÒ'¿ìРDÒ p`’‘*`Ð'¿èÀ'¿äРDÒ¿äÐ x€¢@€€Ð DÒ Ö`РD’ Ô¿èŸÂÀÒ¿ìÔ¿ä– •*à’@ Ð"`DÐ¿ä’ Ò'¿ä¿ÿçÇàèã¿€ð' Dò' HРDÒ!ÌÒ'¿ìРDÒ¿ìÔ`Ô" ˆÐ DÒ¿ìÔ`Ô" „Ò DÐ`X€¢ €€¢  €€¢ €8€cРDÒ x€¢`€Ð¿ì’ Ò" €Ð¿ì’ Ò" €^РDÒ x€¢`€Ð¿ì’ Ò" €Ð¿ì’ Ò" пìÀ" 0пìÒ €¢`€Ð Dÿû©Ð¿ìÒ 4€¢`€Ð Dÿü§€;п쒠Ò" пìÀ" TпìÒ D€¢`€Ð Dÿÿ|РDÒ p`’‘*`Ð'¿èÀ'¿äРDÒ¿äÐ x€¢@€€Ð¿ìÒ¿ä” “* ” РDÒ¿è@Ð¿ä’ Ò'¿ä¿ÿì€Ð DÒ 0Ð"`РDÒÔ@РDŸÂ€€Çàèã¿ð' DÇàèã¿ð' DРDÒ .Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' DРDÒ Ö@РD’ ” XŸÂÀÐ'¿ìРDÒ¿ìÒ"!Ìп쒠Ò"п쒠Ò" п쒠Ò" пìÀ" DпìÀ" 4РDÒ x€¢`€Ð DÒ 7Ð"`РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ `€¢a€Ð DÒ 9Ð"`РDÒ!Ð"`РDÒÔ@РDŸÂ€Ð DÿúQРDÿûРDÒ X€¢`€Ð DÿþëÇàèÀ0ð Ì<üÃ3óÏ?ÿ€@°pŒL¼|ƒC³sO¿ àÐ,ìÜ#ãÓ/ïß `P¬lœ\£c“S¯oŸ_È8øÄ4ô Ë;ûÇ7÷ˆH¸x„D´t‹K»{‡G·w(èØ$äÔ+ëÛ'çרh˜X¤d”T«k›[§g—WÂ2òÎ>þÁ1ñ Í=ý‚B²rŽN¾~A±qM½}"âÒ.îÞ!áÑ-íÝ¢b’R®nž^¡a‘Q­m] Ê:úÆ6ö É9ùÅ5õŠJºz†F¶v‰I¹y…Eµu*êÚ&æÖ)éÙ%åÕªjšZ¦f–V©i™Y¥e•Uÿñÿñ øH $t.¬è>˜Rì`_n8„쓦 @l¹ XΔ¬à àDï ¬4L`@¤, 8 Lä(_eTP{…jquant1.cquantize_fs_dithercolor_quantize3create_colormapquantize_ord_ditheroutput_valuegcc2_compiled.new_color_map_1_quantselect_ncolorsbase_dither_matrixmake_odither_arrayquantize3_ord_dithercreate_colorindexcolor_quantizecreate_odither_tableslargest_input_valuealloc_fs_workspaceRGB_order.2finish_pass_1_quantstart_pass_1_quant.umuljinit_1pass_quantizerjzero_far.divlP¬ ¼ ô 0L lˆ ¼ Ô @ \ xüh $l $€ à„ à¬  °  Ä ˜È ˜$ ø( ø° ä” ä   ¤  ° ´ as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14= t¤ $°!ÔŠ)`° 4!>jquant2.o/ 938694551 1729 22250 100664 13104 ` ELF24(.shstrtab.text.symtab.strtab.rela.text.commentã¿€ð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìÖ¿ìÔàÖ DØàpØ'¿àÀ'¿èÖ¿èØ P€¢À €€<Ö¿è˜ —+ Ø H–À ÐÀÖ¿àÖ'¿äÖ¿ä€¢à€€)Ø – ÿ™2à– ÿ˜ —+ Ú ˜ `ÿ›3 ˜ `ÿš ™+`Ö€ ’ Ø – ÿ™2à– ÿ˜ —+ ’@ Ö@˜à– Ö2@™*à—3 €¢à€Ö@˜ÿÿØ2@ Ö¿ä˜ÿÿØ'¿ä¿ÿÕÖ¿è˜àØ'¿è¿ÿÁÇàè㿈ð' Dò' H” À'¿ì’ РDÖ H€¢@ €€Ö €¢À €Ö €¢à€Ð'¿ìÔ ’` ¿ÿîÖ¿ì° €Çàè㿈ð' Dò' H” À'¿ì’ РDÖ H€¢@ €€ Ö €¢À €Ð'¿ìÔ ’` ¿ÿòÖ¿ì° €Çàèã¿Pð' Dò' HРDÒ!ÌÒ'¿ìпìÒ Ò'¿èРHÒÒ'¿ÔРHÒ Ò'¿ÐРHÒ Ò'¿ÌРHÒ Ò'¿ÈРHÒ Ò'¿ÄРHÒ Ò'¿ÀпÐÒ¿Ô€¢ €LпÔÐ'¿àпàҿЀ¢ €€CпÌÐ'¿ÜпÜÒ¿È€¢ €€4Ð¿à’‘*`Ò¿è Ò¿Ü” “* Ô@ Ò¿Ä” “*  Ð'¿äпÄÐ'¿ØпØÒ¿À€¢ €€¿äÒÔ@—* •2à’`Ò"€¢ €Ð HÒ¿àÒ'¿ÔÒ"€Ð¿Ø’ Ò'¿Ø¿ÿæпܒ Ò'¿Ü¿ÿÉÐ¿à’ Ò'¿à¿ÿºÐ¿ÐÒ¿Ô€¢ €LпÐÐ'¿àпàÒ¿Ô€¢ €€CпÌÐ'¿ÜпÜÒ¿È€¢ €€4Ð¿à’‘*`Ò¿è Ò¿Ü” “* Ô@ Ò¿Ä” “*  Ð'¿äпÄÐ'¿ØпØÒ¿À€¢ €€¿äÒÔ@—* •2à’`Ò"€¢ €Ð HÒ¿àÒ'¿ÐÒ" €Ð¿Ø’ Ò'¿Ø¿ÿæпܒ Ò'¿Ü¿ÿÉпà’?ÿÒ'¿à¿ÿºÐ¿ÈÒ¿Ì€¢ €LпÌÐ'¿ÜпÜÒ¿È€¢ €€CпÔÐ'¿àпàҿЀ¢ €€4Ð¿à’‘*`Ò¿è Ò¿Ü” “* Ô@ Ò¿Ä” “*  Ð'¿äпÄÐ'¿ØпØÒ¿À€¢ €€¿äÒÔ@—* •2à’`Ò"€¢ €Ð HÒ¿ÜÒ'¿ÌÒ" €Ð¿Ø’ Ò'¿Ø¿ÿæÐ¿à’ Ò'¿à¿ÿÉпܒ Ò'¿Ü¿ÿºÐ¿ÈÒ¿Ì€¢ €LпÈÐ'¿ÜпÜÒ¿Ì€¢ €€CпÔÐ'¿àпàҿЀ¢ €€4Ð¿à’‘*`Ò¿è Ò¿Ü” “* Ô@ Ò¿Ä” “*  Ð'¿äпÄÐ'¿ØпØÒ¿À€¢ €€¿äÒÔ@—* •2à’`Ò"€¢ €Ð HÒ¿ÜÒ'¿ÈÒ" €Ð¿Ø’ Ò'¿Ø¿ÿæÐ¿à’ Ò'¿à¿ÿÉпܒ?ÿÒ'¿Ü¿ÿºÐ¿ÀÒ¿Ä€¢ €LпÄÐ'¿ØпØÒ¿À€¢ €€CпÔÐ'¿àпàҿЀ¢ €€4Ð¿à’‘*`Ò¿è Ò¿Ì” “* Ô@ Ò¿Ø” “*  Ð'¿äпÌÐ'¿ÜпÜÒ¿È€¢ €€Ð¿äÒ•*`‘2 €¢ €Ð HÒ¿ØÒ'¿ÄÒ" €Ð¿Ü’ Ò'¿ÜÐ¿ä’ @Ò'¿ä¿ÿæÐ¿à’ Ò'¿à¿ÿÉпؒ Ò'¿Ø¿ÿºÐ¿ÀÒ¿Ä€¢ €LпÀÐ'¿ØпØÒ¿Ä€¢ €€CпÔÐ'¿àпàҿЀ¢ €€4Ð¿à’‘*`Ò¿è Ò¿Ì” “* Ô@ Ò¿Ø” “*  Ð'¿äпÌÐ'¿ÜпÜÒ¿È€¢ €€Ð¿äÒ•*`‘2 €¢ €Ð HÒ¿ØÒ'¿ÀÒ" €Ð¿Ü’ Ò'¿ÜÐ¿ä’ @Ò'¿ä¿ÿæÐ¿à’ Ò'¿à¿ÿÉпؒ?ÿÒ'¿Ø¿ÿºÐ¿ÐÒ¿Ô" “*  “* Ò'¿¼Ð¿ÈÔ¿Ì’" ‘*`’•*`€Ð'¿¸Ð¿ÀÒ¿Ä" “* Ò'¿´à Hп¼Ò¿¼@¢Ð¿¸Ò¿¸@¢@п´Ò¿´@’@Ò$ À'¿°Ð¿ÔÐ'¿àпàҿЀ¢ €€@пÌÐ'¿ÜпÜÒ¿È€¢ €€1Ð¿à’‘*`Ò¿è Ò¿Ü” “* Ô@ Ò¿Ä” “*  Ð'¿äпÄÐ'¿ØпØÒ¿À€¢ €€Ð¿äÒ•*`‘2 €¢ €Ð¿°’ Ò'¿°Ð¿Ø’ Ò'¿ØÐ¿ä’ Ò'¿ä¿ÿéпܒ Ò'¿Ü¿ÿÌÐ¿à’ Ò'¿à¿ÿ½Ð HÒ¿°Ò" Çàèã¿xð' Dò' Hô' Lö' PРLÒ P€¢ €€Ð L’‘*`Ò P€¢ € РHÒ Lÿý@ €Ð HÒ LÿýZ €¤ €€…РL’‘*`Ò H¢ Ð Ð$`Ð Ð$` Ð Ð$`ÐÐ$@Ð Ð$`Ð Ð$`Ð Ò" “*  “* Ò'¿äÐ Ô ’" ‘*`’•*`€Ð'¿àÐ Ò " “* Ò'¿ÜпàÐ'¿Ø Ð'¿ìпäÒ¿Ø€¢ €Ð¿äÐ'¿ØÀ'¿ìпÜÒ¿Ø€¢ € Ð'¿ìп쀢 €€¢ €€¢ € €4€¢ €"€/Ð Ò “: •2` “: Ò'¿èпèÐ$ Ð¿è’ Ò$@€ Ð Ò  “: •2` “: Ò'¿èпèÐ$ Ð¿è’ Ò$`€Ð Ò  “: •2` “: Ò'¿èпèÐ$ Ð¿è’ Ò$`€Ð D’ÿü÷РD’ÿüóРL’ Ò' L¿ÿ`РL°€Çàèã¿Hð' Dò' Hô' LРDÒ!ÌÒ'¿ìпìÒ Ò'¿èÀ'¿¸À'¿´À'¿°À'¿¬Ð HÒÒ'¿ÔРHÒ Ò'¿ÐРHÒ Ò'¿ÌРHÒ Ò'¿ÈРHÒ Ò'¿ÄРHÒ Ò'¿ÀпÔÐ'¿àпàҿЀ¢ €€aпÌÐ'¿ÜпÜÒ¿È€¢ €€RÐ¿à’‘*`Ò¿è Ò¿Ü” “* Ô@ Ò¿Ä” “*  Ð'¿äпÄÐ'¿ØпØÒ¿À€¢ €€5¿äÒÔ@™* —3 ” Ô'¿¼’`Ò"€¢ €$п¸Ò¿¼ Ð'¿¸Ò¿à‘*`’  Ò¿¼@Ò¿´@Ð'¿´Ò¿Ü‘*`’  Ò¿¼@Ò¿°@Ð'¿°Ò¿Ø‘*`’  Ò¿¼@Ò¿¬@Ð'¿¬Ð¿Ø’ Ò'¿Ø¿ÿÈпܒ Ò'¿Ü¿ÿ«Ð¿à’ Ò'¿à¿ÿœÐ DÒ ˆÐ@Ò L  Ò¿¸‘:`Ô¿´’  Ò¿¸@Ð,РD’ Ô ˆ@ ÒРL @Ò¿¸‘:`Ô¿°’  Ò¿¸@Ð,РD’ Ô ˆ@ ÒРL @Ò¿¸‘:`Ô¿¬’  Ò¿¸@Ð,Çàèã¿€ð' Dò' HÒ DÐ`Ò H– •*àÖРD’ ŸÂÀÐ'¿ì Ð'¿èпìÀ"Ð¿ì’ Ò" пìÀ" Ð¿ì’ ?Ò" пìÀ" Ð¿ì’ Ò" РDÒ¿ìÿü РDÒ¿ìÔ¿èÖ HÿþtÐ'¿èÀ'¿äпäҿ耢 €€Ð¿ä’‘*`Ô¿ì’ Ð DÔ¿äÿÿÐ¿ä’ Ò'¿ä¿ÿíРDÒ¿èÒ" „РDÒ `Ð"`РDÒпèÐ"`РDÒÔ`РD’ ŸÂ€Çàèã»Xð' Dò' Hô' Lö' Pø' TРDÒ „Ò'¿ìРH’ Ò'¿èРHÒ¿è “: Ò'¿ÜРL’ Ò'¿äРLÒ¿ä “: Ò'¿ØРP’ Ò'¿àРPÒ¿à “: Ò'¿ÔÿÿcÿÐ'¿ÄÀ'¿ÐпÐҿ쀢 €€HРDÒ ˆÐ@Ò¿Ð Ò `ÿÐ'¿ÌпÌÒ H€¢ €Ð¿ÌÒ H" ’‘*`Ð'¿¸Ð¿¸Ò¿¸@Ð'¿ÀпÌÒ¿è" ’‘*`Ð'¿¸Ð¿¸Ò¿¸@Ð'¿¼€=пÌҿ耢 €Ð¿ÌÒ¿è" ’‘*`Ð'¿¸Ð¿¸Ò¿¸@Ð'¿ÀпÌÒ H" ’‘*`Ð'¿¸Ð¿¸Ò¿¸@Ð'¿¼€ À'¿ÀпÌÒ¿Ü€¢ €Ð¿ÌÒ¿è" ’‘*`Ð'¿¸Ð¿¸Ò¿¸@Ð'¿¼€ пÌÒ H" ’‘*`Ð'¿¸Ð¿¸Ò¿¸@Ð'¿¼Ð D’ Ô ˆ@ ÒÔ¿Ð@ Ò `ÿÐ'¿ÌпÌÒ L€¢ € пÌÒ L" ’•*`€Ð'¿¸Ð¿¸Ò¿¸@Ò¿À@Ð'¿ÀпÌÒ¿ä" ’•*`€Ð'¿¸Ð¿¸Ò¿¸@Ò¿¼@Ð'¿¼€HпÌҿ䀢 € пÌÒ¿ä" ’•*`€Ð'¿¸Ð¿¸Ò¿¸@Ò¿À@Ð'¿ÀпÌÒ L" ’•*`€Ð'¿¸Ð¿¸Ò¿¸@Ò¿¼@Ð'¿¼€%пÌÒ¿Ø€¢ €Ð¿ÌÒ¿ä" ’•*`€Ð'¿¸Ð¿¸Ò¿¸@Ò¿¼@Ð'¿¼€Ð¿ÌÒ L" ’•*`€Ð'¿¸Ð¿¸Ò¿¸@Ò¿¼@Ð'¿¼Ð D’ Ô ˆ@ ÒÔ¿Ð@ Ò `ÿÐ'¿ÌпÌÒ P€¢ €Ð¿ÌÒ P" Ð'¿¸Ð¿¸Ò¿¸@Ò¿À@Ð'¿ÀпÌÒ¿à" Ð'¿¸Ð¿¸Ò¿¸@Ò¿¼@Ð'¿¼€<пÌÒ¿à€¢ €Ð¿ÌÒ¿à" Ð'¿¸Ð¿¸Ò¿¸@Ò¿À@Ð'¿ÀпÌÒ P" Ð'¿¸Ð¿¸Ò¿¸@Ò¿¼@Ð'¿¼€Ð¿ÌÒ¿Ô€¢ €Ð¿ÌÒ¿à" Ð'¿¸Ð¿¸Ò¿¸@Ò¿¼@Ð'¿¼€ пÌÒ P" Ð'¿¸Ð¿¸Ò¿¸@Ò¿¼@Ð'¿¼Ð¿Ð’‘*`’»¸Ô¿ÀÔ"@п¼Ò¿Ä€¢ €Ð¿¼Ð'¿ÄпВ Ò'¿Ð¿þµÀ'¿ÈÀ'¿ÐпÐҿ쀢 €€Ð¿Ð’‘*`’»¸Ð@Ò¿Ä€¢ € ¿ÈÒÖ T”@ Ö¿ÓÖ*€’`Ò"пВ Ò'¿Ð¿ÿåпȰ€Çàèã½Xð' Dò' Hô' Lö' Pø' Tú' X ½¸ Ð'¿àÐ¿à€¢ €€ ÿÿcÿÐ$  пà’?ÿÒ'¿à¿ÿóÀ'¿àпàÒ T€¢ €€¦Ð XÒ¿à Ò `ÿÐ'¿ÜРDÒ ˆÐ@Ò¿Ü Ò `ÿÒ H"@’‘*`Ð'¿ÄпÄÒ¿Ä@Ð'¿ÔРD’ Ô ˆ@ ÒÔ¿Ü@ Ò `ÿÒ L"@’•*`€Ð'¿ÀпÀÒ¿À@Ò¿Ô@Ð'¿ÔРD’ Ô ˆ@ ÒÔ¿Ü@ Ò `ÿÒ P"@Ð'¿¼Ð¿¼Ò¿¼@Ò¿Ô@Ð'¿ÔпĒ‘*`’!Ò'¿ÄпÀ”“* ’@‘*`’ Ò'¿Àп¼’‘*`’ @Ò'¿¼ ½¸Ð \Ð'¿ØпÄÐ'¿Ì Ð'¿ìп쀢 €€CпÔÐ'¿ÐпÀÐ'¿È Ð'¿èп耢 €€+â¿Ð俼 Ð'¿äп䀢 €€Ð€¤@€â$пØÒ¿ßÒ*¢@¤ €  пؒ Ò'¿Øпä’?ÿÒ'¿ä¿ÿéпÐÒ¿È Ð'¿ÐпȒ! Ò'¿Èпè’?ÿÒ'¿è¿ÿÓпÔÒ¿Ì Ð'¿Ôп̒"Ò'¿Ìпì’?ÿÒ'¿ì¿ÿ»Ð¿à’ Ò'¿à¿ÿWÇàèã½àð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìпìÒ Ò'¿èРH“: Ò' HРL“: Ò' LРP“: Ò' PÒ H‘*`’ Ò'¿äÒ L‘*`’ Ò'¿àÒ P‘*`’ Ò'¿Ü˜¾ÐРDÒ¿äÔ¿àÖ¿Üÿý|Ð'¾Ìš¾Ð¾HÐ# \РDÒ¿äÔ¿àÖ¿ÜؾÌÿÿРH“* Ò' HРL“* Ò' LРP“* Ò' P ¾HÀ'¿Øп؀¢ €€7À'¿ÔпԀ¢ €€+РHÒ¿Ø ’‘*`Ò¿è Ò LÔ¿Ô’@ ” “* Ð¢@РP’‘*`¢@À'¿ÐпЀ¢ €€ Ò `ÿ’ Ò4@  ¢`пВ Ò'¿Ð¿ÿñпԒ Ò'¿Ô¿ÿÓпؒ Ò'¿Ø¿ÿÇÇàèã¿xð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìпìÒ Ò'¿èРDÒ pÒ'¿ÜÀ'¿äпäÒ P€¢ €€Jп䒑*`Ò H àп䒑*`Ò L âпÜÐ'¿àÐ¿à€¢ €€1Ò `ÿ“2 ¦ `ÿ  Ò `ÿ“2 ¨ `ÿ  Ò `ÿ“2 ª `ÿ  “* Ô¿è@ ’•*`Ф€“* ¤€ Ѐ“* ‘2`€¢ €Ð D’”–ÿÿ8Ð  ’?ÿÒ,@¢`пà’?ÿÒ'¿à¿ÿÍÐ¿ä’ Ò'¿ä¿ÿ³Çàèã¿8ð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìпìÒ Ò'¿èРDÒ pÒ'¿°Ð DÒ!DÒ'¿¬Ð¿ìÒ (Ò'¿¨Ð DÒ ˆÐ@Ð'¿¤Ð D’ Ô ˆ@ ÒÒ'¿ Ð D’ Ô ˆ@ ÒÒ'¿œÀ'¿¸Ð¿¸Ò P€¢ €€Ð¿¸’‘*`Ò H ÒÒ'¿Ìп¸’‘*`Ò L ÒÒ'¿ÈпìÒ $€¢`€ Ò¿°ÿ”“* ’@п̒ Ò'¿ÌÒ¿°ÿÒ¿È@Ð'¿È?ÿÐ'¿À?ýÐ'¿¼Ð¿ìÔ¿°’ – •*à”€ “* Ð ¦@пìÀ" $€  Ð'¿À Ð'¿¼Ð¿ìæ Ð¿ì’ Ò" $¤ ¢   À'¿ÜÀ'¿àÀ'¿äÀ'¿ÐÀ'¿ÔÀ'¿Øп°Ð'¿´Ð¿´€¢ €€ºÐ¿¼’‘*`ÒÀ•*`‘:    ¡< п¼’‘*`’Ð`“* ‘:`¢@¢`£<`п¼’‘*`’Ð`“* ‘:`¤€¤ ¥< “* Ô¿¨@ à“* Ô¿¨@ â“* Ô¿¨@ äпÌÒ `ÿ  Ò¿Ì Ò `ÿ¢@ Ò¿Ì Ò `ÿ¤€Ò¿¬ Ò   `ÿÒ¿¬@ Ò ¢ `ÿÒ¿¬€ Ò ¤ `ÿ‘< ’‘*`Ò¿è “<`” “* Ô@ “< ” “*  Ð'¿ÄпÄÒ•*`‘2 €¢ €“< •<`—< Ð DÿþMÒ¿ÄÔ@“* ‘2`?ÿÒ¿ÈÐ*@Ô¿¤’ Ô @’  ÿ $ Ô¿ ’ Ô @’  ÿ¢$@ Ô¿œ’ Ô @’  ÿ¤$€ ”—* ’   Ô¿Ú–”€ Ô4À  Ô¿ä–€Ö'¿ØÐ'¿ä  ”—* ’ ¢@ Ô¿Ö–”€ Ô4à¢@ Ô¿à–€Ö'¿ÔÐ'¿à¢@ ”—* ’ ¤€ Ô¿Ò–”€ Ô4ऀ Ô¿Ü–€Ö'¿ÐÐ'¿Ü¤€ пÌÒ¿¼ Ð'¿ÌпÈÒ¿À Ð'¿Èп¼’‘*`¦Àп´’?ÿÒ'¿´¿ÿDпÚÐ4ÀпÖÐ4àпÒÐ4àп¸’ Ò'¿¸¿þíÇàèã¿€ð' DРDÒ!ÌÒ'¿ìРDÒ Ö@РD’ ”'üŸÂÀÐ'¿èпè’#üÒ'¿èпìÒ¿èÒ" (À'¿àÀ'¿äп䀢 €€Ð¿ä’‘*`Ò¿è Ò¿àÒ"Ò¿ä ’‘*`Ò¿è Ò¿à” Ô"Ð¿ä’ Ò'¿äÐ¿à’ Ò'¿à¿ÿäп䀢 /€€Ð¿ä’‘*`Ò¿è Ò¿àÒ"Ò¿ä ’‘*`Ò¿è Ò¿à” Ô"Ð¿ä’ Ò'¿äÒ¿ä` Ò¿à Ð'¿à¿ÿáп䀢 ÿ€€Ð¿ä’‘*`Ò¿è Ò¿àÒ"Ò¿ä ’‘*`Ò¿è Ò¿à” Ô"Ð¿ä’ Ò'¿ä¿ÿçÇàè㿈ð' DРDÒ!ÌÒ'¿ìРDÒ¿ìÔ`Ô" ˆÒ¿ìРDÒ`ÿú·Ð¿ì’ Ò" Çàèã¿ð' DÇàèã¿€ð' Dò' HРDÒ!ÌÒ'¿ìпìÒ Ò'¿èРDÒ X€¢`€Ð D’ Ò" XРH€¢ €Ð¿ì’ Ò" п쒠Ò" Ð¿ì’ Ò" €gРDÒ X€¢`€Ð¿ì’ Ò" €Ð¿ì’ Ò" п쒠Ò" РDÒ „Ò'¿äп䀢 €Ð DÒ 8Ð"`РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ä€¢!€Ð DÒ 9Ð"`РDÒ!Ð"`РDÒÔ@РDŸÂ€Ð DÒ X€¢`€(РDÒ p`”“* ’@‘*`Ð'¿àпìÒ €¢`€ РDÒ Ö`РD’ Ô¿àŸÂÀÒ¿ìÐ"` Ò¿ìÐ` Ò¿à@пìÒ (€¢`€Ð DÿþòпìÀ" $пìÒ €¢`€À'¿äп䀢 €€Ð¿ä’‘*`Ô¿è’ Ð@@Ð¿ä’ Ò'¿ä¿ÿîпìÀ" Çàè㿈ð' DРDÒ!ÌÒ'¿ìÐ¿ì’ Ò" Çàèã¿€ð' DРDÒ Ö@РD’ ” ,ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Ìп쒠Ò"п쒠Ò" пìÀ" пìÀ" (РDÒ x€¢`€ РDÒ /Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ö@РD’ ” €ŸÂÀÒ¿ìÐ"`À'¿èп耢 €€Ð DÒ Ö`РD’ ŸÂÀÒ¿ìÔ¿è– •*àÖ`’€ Ð"@Ð¿è’ Ò'¿è¿ÿèÐ¿ì’ Ò" РDÒ l€¢`€9РDÒ `Ò'¿äп䀢 €Ð DÒ 8Ð"`РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ä€¢!€Ð DÒ 9Ð"`РDÒ!Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ø`РD’ Ô¿ä– ŸÃÒ¿ìÐ"`пìÒ¿äÒ" €Ð¿ìÀ" РDÒ X€¢`€Ð D’ Ò" XРDÒ X€¢`€Ò DÐ`Ò DÔ`p’ ” —* –À •*àÖ Ð D’ ŸÂÀÒ¿ìÐ"` РDÿþÇàèÿñÿñ &xL&Ä%0 6„PD$¨ÐUDf ð´qP胒)h(¨¤à¶< ´Á¸ðÑ8€áÔ\ôD„ Èt&Ô”28)ÄNXjquant2.cfinish_pass1finish_pass2find_best_colorsselect_colorsinit_error_limitprescan_quantizemedian_cutfill_inverse_cmapgcc2_compiled.new_color_map_2_quantcompute_colorupdate_boxpass2_fs_ditherpass2_no_ditherfind_nearby_colorsfind_biggest_color_popfind_biggest_volumestart_pass_2_quant.umuljinit_2pass_quantizerjzero_far.div „ ˜ ¬$Ltð0pØLxÄødœð(|¼$P˜Ä @X¤', '0 '< &x'@ &x't ¸'x ¸'Œ 8' 8'œ &Ä'  &Ä(À)<)Ì &Ô)Ð &Ô)Ü )h)à )has: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l,T,À.P]!/°( ,1Ø>jdmerge.o/ 938694518 1729 22250 100664 4316 ` ELFÄ4(.shstrtab.text.symtab.strtab.rela.text.commentã¿€ð' DРDÒ!ÄÒ'¿ìРDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`РDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`РDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`РDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`À'¿è?€Ð'¿äп耢 ÿ€€[пìÒ¿è” “* Ô @ Ò¿ä– •*à”€ —* –"À •*à”€ “* ”€  ’€ •:`Ô"пìÒ¿è” “* Ô @ Ò¿ä– •*à”"€ —* –À •*à”"€ “* ’"@ •*` ’€ •:`Ô"пìÒ¿è” “* Ô @ Ò¿ä” —* –À •*à”"€ —* ”€ —* –À “*à” Ô"пìÒ¿è” “* Ô @ Ò¿ä” —* –À •*à”"€ —* –"À “*à’"@ •*`’  ’@ Ò"Ð¿è’ Ò'¿èÐ¿ä’ Ò'¿ä¿ÿ£Çàè㿈ð' DРDÒ!ÄÒ'¿ìпìÀ" $пìÒ DÔ`tÔ" ,Çàèã¿xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!ÄÒ'¿ìпìÒ $€¢`€Ò¿ì` Ò XÔ@’ •*`Ò T”€ Ú¿ì’ – ˜ Ú`(@ Ð'¿ÜпìÀ" $€> Ð'¿ÜпìÒ¿ÜÐ ,€¢@€Ð¿ìÒ ,Ò'¿ÜРXÒ \Ð’"@Ò' \пÜÒ \€¢ €Ð \Ð'¿ÜРXÒ “* Ô T@ ÒÒ'¿àп܀¢ € РXÒ “* Ô T@ Ò Ò'¿ä€Ð¿ìÒ Ò'¿äÐ¿ì’ Ò" $пìÔ L–¿àØ Ð DÒ HÔ€ŸÃРXÒ XÔ@Ò¿Ü”€ Ô"пìÒ¿ìÔ`,Ò¿Ü”"€ Ô" ,пìÒ $€¢`€Ò LРLÒ LÔ@’ Ò"Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XРDÒ!ÄÒ'¿ìпìÔ LÒ XÖ@’ —*`Ò T–À Ø Ð DÒ HÔ€ŸÃÒ XРXÒ XÔ@’ Ò"Ò LРLÒ LÔ@’ Ò"Çàèã¿`ð' Dò' Hô' Lö' PРDÒ!ÄÒ'¿ìÄ DÚ¡DÄ¿ìÆ Æ'¿ÐÄ¿ìÆ Æ'¿ÌÄ¿ìÆ Æ'¿ÈÄ¿ìÆ Æ'¿ÄÄ HÆ Lž‡+àÞ€„ÀÆ€Æ'¿à„ Æ H„€Æ Lž‡+àÞ€„ÀÆ€Æ'¿Ü„ Æ H„€Æ Lž‡+àÞ€„ÀÆ€Æ'¿ØÄ P؀ĠDÆ p…0àÄ'¿ÔÄ¿Ô€  €€O„¿ÜÆ€ÞÀ  àÿà'¿è†àÆ €„¿ØÆ€ÞÀ  àÿà'¿ä†àÆ €Ä¿ä†…(àƿЄ€Ò€Ä¿è†…(àÆ¿Ä„€Æ¿äž‡+à޿ȆÀÄ€ÆÀ”€•: Ä¿è†…(àÆ¿Ì„€Ö€„¿àÆ€ÞÀ àÿ†àÆ €„ Æ @Æ+„ Æ @Æ+ „ Æ @Æ+ ˜ „¿àÆ€ÞÀ àÿ†àÆ €„ Æ @Æ+„ Æ @Æ+ „ Æ @Æ+ ˜ Ä¿Ô†¿ÿÆ'¿Ô¿ÿ¯Ä DÆ p„à€  €0Ä¿ÜÆ€„àÿÄ'¿èÄ¿ØÆ€„àÿÄ'¿äĿ䆅(àƿЄ€Ò€Ä¿è†…(àÆ¿Ä„€Æ¿äž‡+à޿ȆÀÄ€ÆÀ”€•: Ä¿è†…(àÆ¿Ì„€Ö€Ä¿àÆ€àÿ„ Æ @Æ+„ Æ @Æ+ „ Æ @Æ+ Çàèã¿`ð' Dò' Hô' Lö' PРDÒ!ÄÒ'¿ìÆ DÄáDÆ¿ìÞàÞ'¿ÌÆ¿ìÞàÞ'¿ÈÆ¿ìÞàÞ'¿ÄÆ¿ìÞàÞ'¿ÀÆ HÞ L Ÿ, àÀ†ÀÞÀÞ'¿àÆ HÞ L Ÿ, àÀ†ÀÞàÞ'¿Ü† Þ H†ÀÞ L Ÿ, àÀ†ÀÞÀÞ'¿Ø† Þ H†ÀÞ L Ÿ, àÀ†ÀÞÀÞ'¿ÔÆ PØÀ† Þ P†ÀÚÀÆ DÞàp‡3àÆ'¿ÐƿЀ à€€o†¿ØÞÀà À¢ ÿâ'¿èžàÞ À†¿ÔÞÀà À¢ ÿâ'¿äžàÞ Àƿ䞇+à޿̆ÀÒÀƿ螇+àÞ¿À†ÀÞ¿ä Ÿ, à¿ÄžÀÆÀÞÀ”À•: Æ¿èž‡+à޿ȆÀÖÀ†¿àÞÀà À ÿžàÞ À† Þ€Þ+† Þ€Þ+ † Þ€Þ+ ˜ †¿àÞÀà À ÿžàÞ À† Þ€Þ+† Þ€Þ+ † Þ€Þ+ ˜ †¿ÜÞÀà À ÿžàÞ À† Þ€Þ+@† Þ€Þ+`† Þ€Þ+`š`†¿ÜÞÀà À ÿžàÞ À† Þ€Þ+@† Þ€Þ+`† Þ€Þ+`š`ƿОÿÿÞ'¿Ð¿ÿÆ DÞàp† à€ à€<Æ¿ØÞÀ† àÿÆ'¿èÆ¿ÔÞÀ† àÿÆ'¿äƿ䞇+à޿̆ÀÒÀƿ螇+àÞ¿À†ÀÞ¿ä Ÿ, à¿ÄžÀÆÀÞÀ”À•: Æ¿èž‡+à޿ȆÀÖÀÆ¿àÞÀ àÿ† Þ€Þ+† Þ€Þ+ † Þ€Þ+ Æ¿ÜÞÀ àÿ† Þ€Þ+@† Þ€Þ+`† Þ€Þ+`Çàè㿈ð' DРDÒ Ö@РD’ ” 0ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Äп쒠Ò"пìÀ" à¿ìРDÒ DÐ pÒ`x@Ð$ (РDÒ!8€¢`€Ð¿ì’ Ò" п쒠Ò" РDÒ Ô¿ìÖ`РD’ Ô (ŸÂÀÒ¿ìÐ"` € п쒠Ò" п쒠Ò" пìÀ" РDÿüÈÇàèÿñÿñ D4&D:I\˜\xäoøä„ô™«± Üjdmerge.cstart_pass_merged_upsamplebuild_ycc_rgb_tablegcc2_compiled.merged_1v_upsamplemerged_2v_upsampleh2v2_merged_upsampleh2v1_merged_upsamplejcopy_sample_rows.umuljinit_merged_upsamplerè   D  D @  d x h x t ø x ø ¸ \ ¼ \ È ô Ì ôas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l ð \Ð ,È!ô ,„>jcomapi.o/ 938694480 1729 22250 100664 1040 ` ELF 4(.shstrtab.text.symtab.strtab.comment㿈ð' DРDÒ €¢`€€& Ð'¿ìп쀢 €€Ð DÒ Ô`$РDÒ¿ìŸÂ€Ð¿ì’?ÿÒ'¿ì¿ÿðРDÒ €¢`€ РD’ ÈÒ" РDÀ"!0€Ð D’ dÒ" Çàèã¿ð' DРDÒ €¢`€Ð DÒ Ô`(РDŸÂ€Ð DÀ" РDÀ" Çàè㿈ð' DРDÒ Ö@РD’ ” „ŸÂÀÐ'¿ìпìÀ" €Ð¿ì°€Çàè㿈ð' DРDÒ Ö@РD’ ”!ŸÂÀÐ'¿ìпìÀ"!п찀Çàèÿñÿñ ¼L'¼2TLHLjcomapi.cgcc2_compiled.jpeg_destroyjpeg_abortjpeg_alloc_huff_tablejpeg_alloc_quant_tableas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14* ` €€_!ß>jutils.o/ 938694552 1729 22250 100664 1672 ` ELFH4(.shstrtab.text.rodata.symtab.strtab.rela.text.commentã¿ð' Dò' HРDÔ H’ ’ÿ Ò H@°€Çàèã¿ð' Dò' HÒ DÿÒ H Ð' DÒ D Ò H@Ò D"@°€Çàèã¿ð' Dò' Hô' Lö' Pø' Tú' Xä XРH’‘*`Ò D@Ð' DРP’‘*`Ò L@Ð' Læ T€¤à€€Ð Dà Ð' D LÒâ@’`Ò"’”@¦ÿÿ¿ÿìÇàèã¿ð' Dò' Hô' LРL’•*`РHÒ D@Çàèã¿ð' Dò' HРD’ Ô H@Çàè     !(0)" #*1892+$%,3:;4-&'.5<=6/7>?????????????????ÿñÿñ @,3´EL@PVx(`eD4u@jutils.cgcc2_compiled..remjdiv_round_upmemsetjcopy_sample_rowsmemcpyjround_upjzero_far.divjcopy_block_rowjpeg_natural_order$ l( h as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14= t @Tð!Dˆ)Ì< 4>jerror.o/ 938694525 1729 22250 100664 9352 ` ELF# 4( .shstrtab.text.rodata.symtab.strtab.rela.text.rela.rodata.commentã¿ð' DРDÒÔ`РDŸÂ€Ð D@ @Çàèã¾Èð' DРDÔ’¿(Ô  РDŸÂ€”¿(`’à@Çàè㿈ð' Dò' HРDÒÒ'¿ìРH€¢ €Ð¿ìÒ l€¢`€ пìÒ h€¢`€€Ð¿ìÒ Ð DŸÂ@Ò¿ìпìÒ¿ìÔ`l’ Ò" l€ пìÒ hРH€¢@€Ð¿ìÒ Ð DŸÂ@Çàèã¿hð' Dò' HРDÒÒ'¿ìпìÒ Ò'¿èÀ'¿äп耢 €Ð¿ìÒ¿èÐ t€¢@€ пìÒ¿è” “* Ô p@ ÒÒ'¿ä€Ð¿ìÒ x€¢`€Ð¿ìÒ¿èÐ |€¢@€Ð¿ìÒ¿èÐ €€¢@€ пìÒ¿ìÔ¿èÖ`|’"€ ” “* Ô x@ ÒÒ'¿äп䀢 € пìÒ¿èÒ" пìÒ pÐ@Ð'¿äÀ'¿ØпäÐ'¿à¿àÒÔ @Ô/¿ß—* •:à’`Ò"€¢ €€Ð¿ß“* ‘:`€¢ %€ пàÒ •*`‘: €¢ s€ Ð'¿Ø€¿ÿâп؀¢ € Ð¿ì” Ð HÒ¿ä@€Ô¿ìÖ¿ìØ¿ìÚ¿ìпìÒ (Ò# \пìÒ ,Ò# `пìÒ 0Ò# dпìÒ 4Ò# hРHÒ¿äÔ ÖàØ Ú`$@Çàèã¿ð' DРDÒÀ"`lРDÒÀ"`Çàèã¿ð' DРD’ Ò"РD’ Ò" РD’ Ò" РD’ Ò" РD’ Ò" РDÀ" hРDÀ" lРDÀ" РD’ Ò" pРD’ {Ò" tРDÀ" xРDÀ" |РDÀ" €Ð D°€ÇàèApplication transferred too many scanlinesInvalid SOS parameters for sequential JPEGCorrupt JPEG data: found marker 0x%02x instead of RST%dPremature end of JPEG fileWarning: unknown JFIF revision number %d.%02dCorrupt JPEG data: bad Huffman codeCorrupt JPEG data: premature end of data segmentCorrupt JPEG data: %u extraneous bytes before marker 0x%02xInconsistent progression sequence for component %d coefficient %dUnknown Adobe color transform code %dObtained XMS handle %uFreed XMS handle %uUnrecognized component IDs %d %d %d, assuming YCbCrJFIF extension marker: RGB thumbnail image, length %uJFIF extension marker: palette thumbnail image, length %uJFIF extension marker: JPEG-compressed thumbnail image, length %uOpened temporary file %sClosed temporary file %s Ss=%d, Se=%d, Ah=%d, Al=%d Component %d: dc=%d ac=%dStart Of Scan: %d componentsStart of Image Component %d: %dhx%dv q=%dStart Of Frame 0x%02x: width=%u, height=%u, components=%dSmoothing not supported with nonstandard sampling ratiosRST%dAt marker 0x%02x, recovery action %dSelected %d colors for quantizationQuantizing to %d colorsQuantizing to %d = %d*%d*%d colors %4u %4u %4u %4u %4u %4u %4u %4uUnexpected marker 0x%02xMiscellaneous marker 0x%02x, length %u with %d x %d thumbnail imageJFIF extension marker: type 0x%02x, length %uWarning: thumbnail image size does not match data length %uJFIF APP0 marker: version %d.%02d, density %dx%d %d %3d %3d %3d %3d %3d %3d %3d %3dEnd Of ImageObtained EMS handle %uFreed EMS handle %uDefine Restart Interval %uDefine Quantization Table %d precision %dDefine Huffman Table 0x%02xDefine Arithmetic Table 0x%02x: 0x%02xUnknown APP14 marker (not Adobe), length %uUnknown APP0 marker (not JFIF), length %uAdobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %dCaution: quantization tables are too coarse for baseline JPEG6b 27-Mar-1998Copyright (C) 1998, Thomas G. LaneWrite to XMS failedRead from XMS failedImage too wide for this implementationVirtual array controller messed upUnsupported marker type 0x%02xApplication transferred too few scanlinesWrite failed on temporary file --- out of disk space?Seek failed on temporary fileRead failed on temporary fileFailed to create temporary file %sInvalid JPEG file structure: SOS before SOFInvalid JPEG file structure: two SOI markersUnsupported JPEG process: SOF type 0x%02xInvalid JPEG file structure: missing SOS markerInvalid JPEG file structure: two SOF markersCannot quantize to more than %d colorsCannot quantize to fewer than %d colorsCannot quantize more than %d color componentsInsufficient memory (case %d)Not a JPEG file: starts with 0x%02x 0x%02xQuantization table 0x%02x was not definedJPEG datastream contains no imageHuffman table 0x%02x was not definedBacking store not supportedRequested feature was omitted at compile timeNot implemented yetInvalid color quantization mode changeScan script does not transmit all dataCannot transcode due to multiple use of quantization table %dPremature end of input fileEmpty input fileMaximum supported image dimension is %u pixelsMissing Huffman code table entryHuffman code size table overflowFractional sampling not implemented yetOutput file write error --- out of disk space?Input file read errorDidn't expect more than one scanWrite to EMS failedRead from EMS failedEmpty JPEG image (DNL not supported)Bogus DQT index %dBogus DHT index %dBogus DAC value 0x%xBogus DAC index %dUnsupported color conversion requestToo many color components: %d, max %dCCIR601 sampling not implemented yetSuspension not allowed hereBuffer passed to JPEG library is too smallBogus virtual array accessJPEG parameter struct mismatch: library thinks size is %u, caller expects %uImproper call to JPEG library in state %dInvalid scan script at entry %dBogus sampling factorsInvalid progressive parameters at scan script entry %dInvalid progressive parameters Ss=%d Se=%d Ah=%d Al=%dUnsupported JPEG data precision %dInvalid memory pool code %dSampling factors too large for interleaved scanWrong JPEG library version: library is %d, caller expects %dBogus marker lengthBogus JPEG colorspaceBogus input colorspaceBogus Huffman table definitionIDCT output block size %d not supportedDCT coefficient out of rangeInvalid component ID %d in SOSBogus buffer control modeMAX_ALLOC_CHUNK is wrong, please fixALIGN_TYPE is wrong, please fixSorry, there are legal restrictions on arithmetic codingBogus message code %d%s ÿñÿñ ˆÀ&@1H8@€(P@H_dq¨¼€ˆ–ôjerror.cemit_messagegcc2_compiled.error_exitformat_messagereset_error_mgroutput_messageexitjpeg_destroyjpeg_std_errorsprintffprintf__iobjpeg_std_message_table$ 0 h l p ht hx p ´ ¸ Ä ˆÈ ˆÔ @Ø @ä Hè Hô €ø €   Pð Ȩˆh@  $(ð,Ø0˜4h8H< @èD°H˜LxPHTøXØ\¨`ˆd`h8lpøtàxÈ|°€ˆ„pˆXŒ0”è˜Àœ˜ p¤@¨(¬°È´ ¸x¼`À0ÄÈ èÌ ÀÐ Ô `Ø @Ü à èä Àè ì `ð 0ô ø Ðü ¨ ˆ h 0   à ¸  x  `$ 8( (, è0  4 p8 @< @øDÈH¨LPxThX@\`Èd˜hplHp(txØ|À€˜„pˆhŒ(è”Ș¸œ˜ x¤X¨8¬°Ð´¸X¼ ÀÄðÈÈÌ€Ð@ÔØàÜ°àäXè(ìøas: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14J €dèlT !d­)ü 4Ð A"à>jmemmgr.o/ 938694542 1729 22250 100664 10804 ` ELF(ô4(.shstrtab.text.rodata.symtab.strtab.rela.text.commentã¿ð' Dò' HРDÒ 6Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Çàèã¿pð' Dò' Hô' LРDÒ Ò'¿ìРLæ²’¡ð€¢ €Ð D’ ÿÿÞРL’ Ò'¿Üп܀¢ €Ò L`Ò¿Ü" Ð' LРH€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€À'¿äпìÒ H” “*  Ò 4Ò'¿èп耢 €€Ð¿èÒ Ð L€¢@ €€ пèÐ'¿äпèÒÒ'¿è¿ÿíп耢 €dРL’ Ò'¿Øп䀢 € Ò H” “* ” @ ÒÒ'¿Ô€ Ò H” “* ” @ ÒÒ'¿Ôæ²bÒ¿Ø" Ò¿Ô€¢@€æ²bÒ¿Ø" Ð'¿ÔпØÔ¿Ô’ РD@Ð'¿èп耢 €€Ò¿Ô‘2`Ð'¿ÔпԀ¢ 1€Ð D’ ÿÿZ¿ÿèпìÒ¿ìÔ¿ØÖ¿Ô”€ Ò`L”@ Ô" LпèÀ"пèÀ" пèÒ LÔ¿Ô’@ Ò" п䀢 € пìÒ H” “*  Ò¿èÒ" 4€Ð¿äÒ¿èÒ"Ð¿è’ Ò'¿àпèÒ¿àÐ ’@Ò'¿àпèÒ¿èÔ`Ò L”€ Ô" пèÒ¿èÔ`Ò L”"€ Ô" пఀÇàèã¿€ð' Dò' Hô' LРDÒ Ò'¿ìРLæ²’¡ð€¢ €Ð D’ ÿÿ РL’ Ò'¿äп䀢 €Ò L`Ò¿ä" Ð' LРH€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð L’ РD@Ð'¿èп耢 €Ð D’ ÿþÚпìÒ¿ìÔ`L’ Ô L’@ Ò" LпèÒ¿ìÔ H– •*à’@ Ô`<Ô"пèÒ LÒ" пèÀ" пìÒ H” “*  Ò¿èÒ" <Ò¿è`°€Çàèã¿pð' Dò' Hô' Lö' PРDÒ Ò'¿ìæ²aðÒ L@Ð'¿ÔпԀ¢ € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð¿ÔÒ P€¢ €Ð¿ÔÐ'¿à€Ð PÐ'¿àпìÒ¿àÒ" PРP’•*`РDÒ HÿþšÐ'¿èÀ'¿ÜпÜÒ P€¢ €€3РPÒ¿Ü" Ò¿à€¢ €Ð¿àÐ'¿àпàÒ L@”РDÒ HÿÿQÐ'¿äпàÐ'¿Øп؀¢ €€¿ÜÒ” – •*àֿ蔀 Ö¿äÖ"€’`Ò"пäÒ L Ð'¿äпؒ?ÿÒ'¿Ø¿ÿè¿ÿÊп谀Çàèã¿pð' Dò' Hô' Lö' PРDÒ Ò'¿ìРL”“* æ²¡ð@Ð'¿ÔпԀ¢ € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð¿ÔÒ P€¢ €Ð¿ÔÐ'¿à€Ð PÐ'¿àпìÒ¿àÒ" PРP’•*`РDÒ Hÿþ'Ð'¿èÀ'¿ÜпÜÒ P€¢ €€6РPÒ¿Ü" Ò¿à€¢ €Ð¿àÐ'¿àпàÒ L@’•*`РDÒ HÿþÝÐ'¿äпàÐ'¿Øп؀¢ €€¿ÜÒ” – •*àֿ蔀 Ö¿äÖ"€’`Ò"РL’‘*`Ò¿ä@Ð'¿äпؒ?ÿÒ'¿Ø¿ÿæ¿ÿÇп谀Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XРDÒ Ò'¿ìРH€¢ €Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð DÒ H” €ÿýÃÐ'¿èпèÀ"пèÒ TÒ" пèÒ PÒ" пèÒ XÒ" пèÒ LÒ" пèÀ" (пèÒ¿ìÔ`DÔ" ,пìÒ¿èÒ" Dп谀Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XРDÒ Ò'¿ìРH€¢ €Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð DÒ H” €ÿý„Ð'¿èпèÀ"пèÒ TÒ" пèÒ PÒ" пèÒ XÒ" пèÒ LÒ" пèÀ" (пèÒ¿ìÔ`HÔ" ,пìÒ¿èÒ" Hп谀Çàèã¿pð' DРDÒ Ò'¿ìÀ'¿èÀ'¿äпìÒ DÒ'¿ÔпԀ¢ €€Ð¿ÔÒ€¢`€Ð¿ÔÒ¿ÔÐ Ò`@Ò¿è@Ð'¿èпÔÒ¿ÔÐ Ò`@Ò¿ä@Ð'¿äпÔÒ ,Ò'¿Ô¿ÿàпìÒ HÒ'¿ÐпЀ¢ €€"пÐÒ€¢`€Ð¿ÐÒ¿ÐÐ Ò`@’‘*`Ò¿è@Ð'¿èпÐÒ¿ÐÐ Ò`@’‘*`Ò¿ä@Ð'¿äпÐÒ ,Ò'¿Ð¿ÿÜп耢 €€ÆÖ¿ìРDÒ¿èÔ¿äÖàL@Ð'¿àпàҿ䀢 €æ²bÐ'¿Ø€ пàÒ¿è@Ð'¿Øп؀¢ € Ð'¿ØпìÒ DÒ'¿ÔпԀ¢ €€KпÔÒ€¢`€AпÔÒ ÿÒ¿ÔÒ` @’ Ò'¿ÜпÜÒ¿Ø€¢ €Ð¿ÔÒ¿ÔÔ`Ô" €à¿ÔÒ¿ÔпØÒ` @Ð$ пԠ 0пÔÒ¿ÔÐ Ò`@”РD’@пԒ Ò" (Ô¿ÔÖ¿ÔРD’ Ô ÖàÿýâÒ¿ÔÐ"@пÔÒ¿ìÔ`PÔ" пÔÀ" пÔÀ" пÔÀ" $пÔÒ ,Ò'¿Ô¿ÿ³Ð¿ìÒ HÒ'¿ÐпЀ¢ €€LпÐÒ€¢`€BпÐÒ ÿÒ¿ÐÒ` @’ Ò'¿ÜпÜÒ¿Ø€¢ €Ð¿ÐÒ¿ÐÔ`Ô" €à¿ÐÒ¿ÐпØÒ` @Ð$ пР 0пÐÒ¿ÐÐ Ò`@’•*`РD’@пВ Ò" (Ô¿ÐÖ¿ÐРD’ Ô ÖàÿýÿÒ¿ÐÐ"@пÐÒ¿ìÔ`PÔ" пÐÀ" пÐÀ" пÐÀ" $пÐÒ ,Ò'¿Ð¿ÿ²Çàèã¿xð' Dò' Hô' LРHÒ Ò'¿ìÒ HÐ`Ò¿ì@Ð'¿èÀ'¿ØРHÒ¿ØÐ €¢@€€iРHÒ HÔ`Ö¿Ø’"€ Ð €¢ €Ò HÐ`€Ò HÔ`Ò¿Ø"€ Ð'¿àРHÒ Ð¿Ø’@Ò'¿ÜРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àÐ¿à€¢ €€8пàÒ¿ì@Ð'¿äРL€¢ €Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 4РDÔ€Ö¿èØ¿äŸÃ@€Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 0РDÔ€Ö¿èØ¿äŸÃ@пèÒ¿ä Ð'¿èРHÒ¿ØÐ ’@Ò'¿Ø¿ÿ“Çàèã¿xð' Dò' Hô' LРHÒ  “* Ò'¿ìÒ HÐ`Ò¿ì@Ð'¿èÀ'¿ØРHÒ¿ØÐ €¢@€€iРHÒ HÔ`Ö¿Ø’"€ Ð €¢ €Ò HÐ`€Ò HÔ`Ò¿Ø"€ Ð'¿àРHÒ Ð¿Ø’@Ò'¿ÜРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àÐ¿à€¢ €€8пàÒ¿ì@Ð'¿äРL€¢ €Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 4РDÔ€Ö¿èØ¿äŸÃ@€Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 0РDÔ€Ö¿èØ¿äŸÃ@пèÒ¿ä Ð'¿èРHÒ¿ØÐ ’@Ò'¿Ø¿ÿ“Çàèã¿€ð' Dò' Hô' Lö' Pø' TРLÒ P Ð'¿ìРHÒ¿ìÐ €¢@€Ð HÒ PÐ €¢@€ РHÒ€¢`€€Ð DÒ Ð"`РDÒÔ@РDŸÂ€Ð HÒ LÐ €¢@ € РHÒ HÐ Ò` ҿ쀢@€€:РHÒ (€¢`€ РDÒ EÐ"`РDÒÔ@РDŸÂ€Ð HÒ $€¢`€ РDÒ H” ÿþ±Ð HÀ" $РHÒ LÐ €¢@€Ð HÒ LÒ" €Ð HÒ¿ìÐ ’"@Ò'¿äп䀢 €À'¿äРHÒ¿äÒ" РDÒ H” ÿþ’РHÒ Ð¿ì€¢@€\РHÒ Ð L€¢@€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð LÐ'¿è€Ð HÒ Ò'¿èРT€¢ €Ð HÒ¿ìÒ" РHÒ €¢`€'РHÒ Ò'¿äРHÒ¿èÐ ’"@Ò'¿èРHÒ¿ìÐ ’"@Ò'¿ìпèҿ쀢 €€Ð HÒ¿è” “* Ð’@Ð@Ò¿ä@Ð¿è’ Ò'¿è¿ÿì€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð T€¢ €Ð H’ Ò" $РHÒ HÔ LÖ`’"€ ” “* Ô@ °€Çàèã¿€ð' Dò' Hô' Lö' Pø' TРLÒ P Ð'¿ìРHÒ¿ìÐ €¢@€Ð HÒ PÐ €¢@€ РHÒ€¢`€€Ð DÒ Ð"`РDÒÔ@РDŸÂ€Ð HÒ LÐ €¢@ € РHÒ HÐ Ò` ҿ쀢@€€:РHÒ (€¢`€ РDÒ EÐ"`РDÒÔ@РDŸÂ€Ð HÒ $€¢`€ РDÒ H” ÿþKРHÀ" $РHÒ LÐ €¢@€Ð HÒ LÒ" €Ð HÒ¿ìÐ ’"@Ò'¿äп䀢 €À'¿äРHÒ¿äÒ" РDÒ H” ÿþ,РHÒ Ð¿ì€¢@€^РHÒ Ð L€¢@€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð LÐ'¿è€Ð HÒ Ò'¿èРT€¢ €Ð HÒ¿ìÒ" РHÒ €¢`€)РHÒ  “* Ò'¿äРHÒ¿èÐ ’"@Ò'¿èРHÒ¿ìÐ ’"@Ò'¿ìпèҿ쀢 €€Ð HÒ¿è” “* Ð’@Ð@Ò¿ä@Ð¿è’ Ò'¿è¿ÿì€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð T€¢ €Ð H’ Ò" $РHÒ HÔ LÖ`’"€ ” “* Ô@ °€Çàèã¿xð' Dò' HРDÒ Ò'¿ìРH€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð H€¢ €>пìÒ DÒ'¿Üп܀¢ €€Ð¿ÜÒ (€¢`€ пÜÀ" (пÜÔ¿Ü’ 0Ô 8РDŸÂ€Ð¿ÜÒ ,Ò'¿Ü¿ÿéпìÀ" DпìÒ HÒ'¿Øп؀¢ €€Ð¿ØÒ (€¢`€ пØÀ" (пØÔ¿Ø’ 0Ô 8РDŸÂ€Ð¿ØÒ ,Ò'¿Ø¿ÿéпìÀ" HпìÒ H” “*  Ò <Ò'¿äпìÒ H” “*  À" <п䀢 €€Ð¿äÒÒ'¿ØпäÒ¿äÐ Ò` ’ Ò'¿àРDÒ¿äÔ¿à@пìÒ¿ìÔ`LÒ¿à”"€ Ô" LпØÐ'¿ä¿ÿãпìÒ H” “*  Ò 4Ò'¿èпìÒ H” “*  À" 4п耢 €€Ð¿èÒÒ'¿ØпèÒ¿èÐ Ò` ’ Ò'¿àРDÒ¿èÔ¿à@пìÒ¿ìÔ`LÒ¿à”"€ Ô" LпØÐ'¿è¿ÿãÇàè㿈ð' D Ð'¿ìп쀢 €€ РDÒ¿ìÿÿ<пì’?ÿÒ'¿ì¿ÿóÒ DРDÒ`” T@РDÀ" РD@Çàèã¿xð' DРDÀ" € РDÒ Ð"`РDÒÔ@РDŸÂ€æ²bÐ'¿àпàæ²’¢€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð D@Ð'¿èРD’ T@Ð'¿ìп쀢 €Ð D@РDÒ 6Ð"`РDÒÀ"`РDÒÔ@РDŸÂ€Ð¿ì’ Ò"п쒠Ò" п쒠Ò" п쒠Ò" п쒠Ò" п쒠Ò" п쒠Ò" п쒠Ò" п쒠Ò" п쒠Ò" $п쒠Ò" (пìæ²’¢Ò" 0пìÒ¿èÒ" , Ð'¿äп䀢 €€Ð¿ìÒ¿ä” “*  À" 4пìÒ¿ä” “*  À" <пä’?ÿÒ'¿ä¿ÿëпìÀ" DпìÀ" HÐ¿ì’ TÒ" LРDÒ¿ìÒ" `@Ð'¿Üп܀¢ €- xÐ/¿Û”¿è–¿Ûпܒ @€¢ €!пۓ* ‘:`€¢ m€ пۓ* ‘:`€¢ M€€ п蔓* ’"@•*`”€‘* Ð'¿èпìÒ¿è– •*à”"€ —* –À “*àÒ" ,Çàè@>€ˆJPEGMEM%ld%cÿñÿñ ìØ(Ä%@2Dü?T€M]ltàvØœ‰D”œLª””¶LHÂÒ ¼ˆæ ÀüúÄü.Ô0?W^djx†—œ«ºjmemmgr.calloc_barrayalloc_sarraydo_barray_iodo_sarray_ioself_destructextra_pool_slopgcc2_compiled.free_poolaccess_virt_barrayaccess_virt_sarrayout_of_memoryalloc_largealloc_smallfirst_pool_sloprealize_virt_arraysrequest_virt_barrayrequest_virt_sarrayjpeg_free_largejpeg_free_smalljinit_memory_mgrjpeg_open_backing_storegetenv.umul.udivjpeg_mem_termjpeg_mem_initsscanfjzero_far.divjpeg_get_largejpeg_get_smalljpeg_mem_availableÀ Ð è ø P"t!T<   D ¸ ä @# |  ð < ` t<ˆ¬Älhpl(Äl°Ädx"˜Ø LÜ Lè ”ì ”ø (ü ( ì  ì Ä Ä( À, À8 ¼< ¼H DL DX Ø\ Øh tl tx T| T ,  0  4 d  h  las: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.14= t!!x!˜@!#ØÍ)%¨  4(´>jmemnobs.o/ 938694544 1729 22250 100664 1208 ` ELF 4(.shstrtab.text.symtab.strtab.rela.text.commentã¿ð' Dò' HРH@°€Çàèã¿ð' Dò' Hô' LРH@Çàèã¿ð' Dò' HРH@°€Çàèã¿ð' Dò' Hô' LРH@Çàèã¿ð' Dò' Hô' Lö' PРL°€Çàèã¿ð' Dò' Hô' LРDÒ 1Ð"`РDÒÔ@РDŸÂ€Çàèã¿ð' D° €Çàèã¿ð' DÇàèÿñÿñ  |$0,$@GÌ@_(m {P,Š,™ ,jmemnobs.cgcc2_compiled.freejpeg_free_largejpeg_free_smallmallocjpeg_open_backing_storejpeg_mem_termjpeg_mem_initjpeg_get_largejpeg_get_smalljpeg_mem_available@`as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.145 l8¤à„¬!00 ,`>Papyrus3/JpegDir/JpgLossy/JMEMNAME.C0000755000175000017500000002061607535143454014141 0ustar /* * jmemname.c * * Copyright (C) 1992-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file provides a generic implementation of the system-dependent * portion of the JPEG memory manager. This implementation assumes that * you must explicitly construct a name for each temp file. * Also, the problem of determining the amount of memory available * is shoved onto the user. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jmemsys.h" /* import the system-dependent declarations */ #ifndef HAVE_STDLIB_H /* should declare malloc(),free() */ extern void * malloc JPP((size_t size)); extern void free JPP((void *ptr)); #endif #ifndef SEEK_SET /* pre-ANSI systems may not define this; */ #define SEEK_SET 0 /* if not, assume 0 is correct */ #endif #ifdef DONT_USE_B_MODE /* define mode parameters for fopen() */ #define READ_BINARY "r" #define RW_BINARY "w+" #else #ifdef VMS /* VMS is very nonstandard */ #define READ_BINARY "rb", "ctx=stm" #define RW_BINARY "w+b", "ctx=stm" #else /* standard ANSI-compliant case */ #define READ_BINARY "rb" #define RW_BINARY "w+b" #endif #endif /* * Selection of a file name for a temporary file. * This is system-dependent! * * The code as given is suitable for most Unix systems, and it is easily * modified for most non-Unix systems. Some notes: * 1. The temp file is created in the directory named by TEMP_DIRECTORY. * The default value is /usr/tmp, which is the conventional place for * creating large temp files on Unix. On other systems you'll probably * want to change the file location. You can do this by editing the * #define, or (preferred) by defining TEMP_DIRECTORY in jconfig.h. * * 2. If you need to change the file name as well as its location, * you can override the TEMP_FILE_NAME macro. (Note that this is * actually a printf format string; it must contain %s and %d.) * Few people should need to do this. * * 3. mktemp() is used to ensure that multiple processes running * simultaneously won't select the same file names. If your system * doesn't have mktemp(), define NO_MKTEMP to do it the hard way. * (If you don't have , also define NO_ERRNO_H.) * * 4. You probably want to define NEED_SIGNAL_CATCHER so that cjpeg.c/djpeg.c * will cause the temp files to be removed if you stop the program early. */ #ifndef TEMP_DIRECTORY /* can override from jconfig.h or Makefile */ #define TEMP_DIRECTORY "/usr/tmp/" /* recommended setting for Unix */ #endif static int next_file_num; /* to distinguish among several temp files */ #ifdef NO_MKTEMP #ifndef TEMP_FILE_NAME /* can override from jconfig.h or Makefile */ #define TEMP_FILE_NAME "%sJPG%03d.TMP" #endif #ifndef NO_ERRNO_H #include /* to define ENOENT */ #endif /* ANSI C specifies that errno is a macro, but on older systems it's more * likely to be a plain int variable. And not all versions of errno.h * bother to declare it, so we have to in order to be most portable. Thus: */ #ifndef errno extern int errno; #endif LOCAL(void) select_file_name (char * fname) { FILE * tfile; /* Keep generating file names till we find one that's not in use */ for (;;) { next_file_num++; /* advance counter */ sprintf(fname, TEMP_FILE_NAME, TEMP_DIRECTORY, next_file_num); if ((tfile = fopen(fname, READ_BINARY)) == NULL) { /* fopen could have failed for a reason other than the file not * being there; for example, file there but unreadable. * If isn't available, then we cannot test the cause. */ #ifdef ENOENT if (errno != ENOENT) continue; #endif break; } fclose(tfile); /* oops, it's there; close tfile & try again */ } } #else /* ! NO_MKTEMP */ /* Note that mktemp() requires the initial filename to end in six X's */ #ifndef TEMP_FILE_NAME /* can override from jconfig.h or Makefile */ #define TEMP_FILE_NAME "%sJPG%dXXXXXX" #endif LOCAL(void) select_file_name (char * fname) { next_file_num++; /* advance counter */ sprintf(fname, TEMP_FILE_NAME, TEMP_DIRECTORY, next_file_num); mktemp(fname); /* make sure file name is unique */ /* mktemp replaces the trailing XXXXXX with a unique string of characters */ } #endif /* NO_MKTEMP */ /* * Memory allocation and freeing are controlled by the regular library * routines malloc() and free(). */ GLOBAL(void *) jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject) { return (void *) malloc(sizeofobject); } GLOBAL(void) jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject) { free(object); } /* * "Large" objects are treated the same as "small" ones. * NB: although we include FAR keywords in the routine declarations, * this file won't actually work in 80x86 small/medium model; at least, * you probably won't be able to process useful-size images in only 64KB. */ GLOBAL(void FAR *) jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject) { return (void FAR *) malloc(sizeofobject); } GLOBAL(void) jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject) { free(object); } /* * This routine computes the total memory space available for allocation. * It's impossible to do this in a portable way; our current solution is * to make the user tell us (with a default value set at compile time). * If you can actually get the available space, it's a good idea to subtract * a slop factor of 5% or so. */ #ifndef DEFAULT_MAX_MEM /* so can override from makefile */ #define DEFAULT_MAX_MEM 1000000L /* default: one megabyte */ #endif GLOBAL(long) jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed, long max_bytes_needed, long already_allocated) { return cinfo->mem->max_memory_to_use - already_allocated; } /* * Backing store (temporary file) management. * Backing store objects are only used when the value returned by * jpeg_mem_available is less than the total space needed. You can dispense * with these routines if you have plenty of virtual memory; see jmemnobs.c. */ METHODDEF(void) read_backing_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { if (fseek(info->temp_file, file_offset, SEEK_SET)) ERREXIT(cinfo, JERR_TFILE_SEEK); if (JFREAD(info->temp_file, buffer_address, byte_count) != (size_t) byte_count) ERREXIT(cinfo, JERR_TFILE_READ); } METHODDEF(void) write_backing_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { if (fseek(info->temp_file, file_offset, SEEK_SET)) ERREXIT(cinfo, JERR_TFILE_SEEK); if (JFWRITE(info->temp_file, buffer_address, byte_count) != (size_t) byte_count) ERREXIT(cinfo, JERR_TFILE_WRITE); } METHODDEF(void) close_backing_store (j_common_ptr cinfo, backing_store_ptr info) { fclose(info->temp_file); /* close the file */ unlink(info->temp_name); /* delete the file */ /* If your system doesn't have unlink(), use remove() instead. * remove() is the ANSI-standard name for this function, but if * your system was ANSI you'd be using jmemansi.c, right? */ TRACEMSS(cinfo, 1, JTRC_TFILE_CLOSE, info->temp_name); } /* * Initial opening of a backing-store object. */ GLOBAL(void) jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed) { select_file_name(info->temp_name); if ((info->temp_file = fopen(info->temp_name, RW_BINARY)) == NULL) ERREXITS(cinfo, JERR_TFILE_CREATE, info->temp_name); info->read_backing_store = read_backing_store; info->write_backing_store = write_backing_store; info->close_backing_store = close_backing_store; TRACEMSS(cinfo, 1, JTRC_TFILE_OPEN, info->temp_name); } /* * These routines take care of any system-dependent initialization and * cleanup required. */ GLOBAL(long) jpeg_mem_init (j_common_ptr cinfo) { next_file_num = 0; /* initialize temp file name generator */ return DEFAULT_MAX_MEM; /* default for max_memory_to_use */ } GLOBAL(void) jpeg_mem_term (j_common_ptr cinfo) { /* no work */ } Papyrus3/JpegDir/JpgLossy/makcjpeg.st0000755000175000017500000000342007535143454014767 0ustar ; Project file for Independent JPEG Group's software ; ; This project file is for Atari ST/STE/TT systems using Pure C or Turbo C. ; Thanks to Frank Moehle (Frank.Moehle@arbi.informatik.uni-oldenburg.de), ; Dr. B. Setzepfandt (bernd@gina.uni-muenster.de), ; and Guido Vollbeding (guivol@esc.de). ; ; To use this file, rename it to cjpeg.prj. ; If you are using Turbo C, change filenames beginning with "pc..." to "tc..." ; Read installation instructions before trying to make the program! ; ; ; * * * Output file * * * cjpeg.ttp ; ; * * * COMPILER OPTIONS * * * .C[-P] ; absolute calls .C[-M] ; and no string merging, folks .C[-w-cln] ; no "constant is long" warnings .C[-w-par] ; no "parameter xxxx unused" .C[-w-rch] ; no "unreachable code" .C[-wsig] ; warn if significant digits may be lost = ; * * * * List of modules * * * * pcstart.o cjpeg.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h,jversion.h) cdjpeg.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) rdswitch.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) rdppm.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) rdgif.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) rdtarga.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) rdbmp.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) rdrle.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) libjpeg.lib ; built by libjpeg.prj pcfltlib.lib ; floating point library ; the float library can be omitted if you've turned off DCT_FLOAT_SUPPORTED pcstdlib.lib ; standard library pcextlib.lib ; extended library Papyrus3/JpegDir/JpgLossy/install.doc0000755000175000017500000014737707535143454015017 0ustar INSTALLATION INSTRUCTIONS for the Independent JPEG Group's JPEG software Copyright (C) 1991-1998, Thomas G. Lane. This file is part of the Independent JPEG Group's software. For conditions of distribution and use, see the accompanying README file. This file explains how to configure and install the IJG software. We have tried to make this software extremely portable and flexible, so that it can be adapted to almost any environment. The downside of this decision is that the installation process is complicated. We have provided shortcuts to simplify the task on common systems. But in any case, you will need at least a little familiarity with C programming and program build procedures for your system. If you are only using this software as part of a larger program, the larger program's installation procedure may take care of configuring the IJG code. For example, Ghostscript's installation script will configure the IJG code. You don't need to read this file if you just want to compile Ghostscript. If you are on a Unix machine, you may not need to read this file at all. Try doing ./configure make make test If that doesn't complain, do make install (better do "make -n install" first to see if the makefile will put the files where you want them). Read further if you run into snags or want to customize the code for your system. TABLE OF CONTENTS ----------------- Before you start Configuring the software: using the automatic "configure" script using one of the supplied jconfig and makefile files by hand Building the software Testing the software Installing the software Optional stuff Optimization Hints for specific systems BEFORE YOU START ================ Before installing the software you must unpack the distributed source code. Since you are reading this file, you have probably already succeeded in this task. However, there is a potential for error if you needed to convert the files to the local standard text file format (for example, if you are on MS-DOS you may have converted LF end-of-line to CR/LF). You must apply such conversion to all the files EXCEPT those whose names begin with "test". The test files contain binary data; if you change them in any way then the self-test will give bad results. Please check the last section of this file to see if there are hints for the specific machine or compiler you are using. CONFIGURING THE SOFTWARE ======================== To configure the IJG code for your system, you need to create two files: * jconfig.h: contains values for system-dependent #define symbols. * Makefile: controls the compilation process. (On a non-Unix machine, you may create "project files" or some other substitute for a Makefile. jconfig.h is needed in any environment.) We provide three different ways to generate these files: * On a Unix system, you can just run the "configure" script. * We provide sample jconfig files and makefiles for popular machines; if your machine matches one of the samples, just copy the right sample files to jconfig.h and Makefile. * If all else fails, read the instructions below and make your own files. Configuring the software using the automatic "configure" script --------------------------------------------------------------- If you are on a Unix machine, you can just type ./configure and let the configure script construct appropriate configuration files. If you're using "csh" on an old version of System V, you might need to type sh configure instead to prevent csh from trying to execute configure itself. Expect configure to run for a few minutes, particularly on slower machines; it works by compiling a series of test programs. Configure was created with GNU Autoconf and it follows the usual conventions for GNU configure scripts. It makes a few assumptions that you may want to override. You can do this by providing optional switches to configure: * If you want to build libjpeg as a shared library, say ./configure --enable-shared To get both shared and static libraries, say ./configure --enable-shared --enable-static Note that these switches invoke GNU libtool to take care of system-dependent shared library building methods. If things don't work this way, please try running configure without either switch; that should build a static library without using libtool. If that works, your problem is probably with libtool not with the IJG code. libtool is fairly new and doesn't support all flavors of Unix yet. (You might be able to find a newer version of libtool than the one included with libjpeg; see ftp.gnu.org. Report libtool problems to bug-libtool@gnu.org.) * Configure will use gcc (GNU C compiler) if it's available, otherwise cc. To force a particular compiler to be selected, use the CC option, for example ./configure CC='cc' The same method can be used to include any unusual compiler switches. For example, on HP-UX you probably want to say ./configure CC='cc -Aa' to get HP's compiler to run in ANSI mode. * The default CFLAGS setting is "-O" for non-gcc compilers, "-O2" for gcc. You can override this by saying, for example, ./configure CFLAGS='-g' if you want to compile with debugging support. * Configure will set up the makefile so that "make install" will install files into /usr/local/bin, /usr/local/man, etc. You can specify an installation prefix other than "/usr/local" by giving configure the option "--prefix=PATH". * If you don't have a lot of swap space, you may need to enable the IJG software's internal virtual memory mechanism. To do this, give the option "--enable-maxmem=N" where N is the default maxmemory limit in megabytes. This is discussed in more detail under "Selecting a memory manager", below. You probably don't need to worry about this on reasonably-sized Unix machines, unless you plan to process very large images. Configure has some other features that are useful if you are cross-compiling or working in a network of multiple machine types; but if you need those features, you probably already know how to use them. Configuring the software using one of the supplied jconfig and makefile files ----------------------------------------------------------------------------- If you have one of these systems, you can just use the provided configuration files: Makefile jconfig file System and/or compiler makefile.manx jconfig.manx Amiga, Manx Aztec C makefile.sas jconfig.sas Amiga, SAS C makeproj.mac jconfig.mac Apple Macintosh, Metrowerks CodeWarrior mak*jpeg.st jconfig.st Atari ST/STE/TT, Pure C or Turbo C makefile.bcc jconfig.bcc MS-DOS or OS/2, Borland C makefile.dj jconfig.dj MS-DOS, DJGPP (Delorie's port of GNU C) makefile.mc6 jconfig.mc6 MS-DOS, Microsoft C (16-bit only) makefile.wat jconfig.wat MS-DOS, OS/2, or Windows NT, Watcom C makefile.vc jconfig.vc Windows NT/95, MS Visual C++ make*.ds jconfig.vc Windows NT/95, MS Developer Studio makefile.mms jconfig.vms Digital VMS, with MMS software makefile.vms jconfig.vms Digital VMS, without MMS software Copy the proper jconfig file to jconfig.h and the makefile to Makefile (or whatever your system uses as the standard makefile name). For more info see the appropriate system-specific hints section near the end of this file. Configuring the software by hand -------------------------------- First, generate a jconfig.h file. If you are moderately familiar with C, the comments in jconfig.doc should be enough information to do this; just copy jconfig.doc to jconfig.h and edit it appropriately. Otherwise, you may prefer to use the ckconfig.c program. You will need to compile and execute ckconfig.c by hand --- we hope you know at least enough to do that. ckconfig.c may not compile the first try (in fact, the whole idea is for it to fail if anything is going to). If you get compile errors, fix them by editing ckconfig.c according to the directions given in ckconfig.c. Once you get it to run, it will write a suitable jconfig.h file, and will also print out some advice about which makefile to use. You may also want to look at the canned jconfig files, if there is one for a system similar to yours. Second, select a makefile and copy it to Makefile (or whatever your system uses as the standard makefile name). The most generic makefiles we provide are makefile.ansi: if your C compiler supports function prototypes makefile.unix: if not. (You have function prototypes if ckconfig.c put "#define HAVE_PROTOTYPES" in jconfig.h.) You may want to start from one of the other makefiles if there is one for a system similar to yours. Look over the selected Makefile and adjust options as needed. In particular you may want to change the CC and CFLAGS definitions. For instance, if you are using GCC, set CC=gcc. If you had to use any compiler switches to get ckconfig.c to work, make sure the same switches are in CFLAGS. If you are on a system that doesn't use makefiles, you'll need to set up project files (or whatever you do use) to compile all the source files and link them into executable files cjpeg, djpeg, jpegtran, rdjpgcom, and wrjpgcom. See the file lists in any of the makefiles to find out which files go into each program. Note that the provided makefiles all make a "library" file libjpeg first, but you don't have to do that if you don't want to; the file lists identify which source files are actually needed for compression, decompression, or both. As a last resort, you can make a batch script that just compiles everything and links it all together; makefile.vms is an example of this (it's for VMS systems that have no make-like utility). Here are comments about some specific configuration decisions you'll need to make: Command line style ------------------ These programs can use a Unix-like command line style which supports redirection and piping, like this: cjpeg inputfile >outputfile cjpeg outputfile source program | cjpeg >outputfile The simpler "two file" command line style is just cjpeg inputfile outputfile You may prefer the two-file style, particularly if you don't have pipes. You MUST use two-file style on any system that doesn't cope well with binary data fed through stdin/stdout; this is true for some MS-DOS compilers, for example. If you're not on a Unix system, it's safest to assume you need two-file style. (But if your compiler provides either the Posix-standard fdopen() library routine or a Microsoft-compatible setmode() routine, you can safely use the Unix command line style, by defining USE_FDOPEN or USE_SETMODE respectively.) To use the two-file style, make jconfig.h say "#define TWO_FILE_COMMANDLINE". Selecting a memory manager -------------------------- The IJG code is capable of working on images that are too big to fit in main memory; data is swapped out to temporary files as necessary. However, the code to do this is rather system-dependent. We provide five different memory managers: * jmemansi.c This version uses the ANSI-standard library routine tmpfile(), which not all non-ANSI systems have. On some systems tmpfile() may put the temporary file in a non-optimal location; if you don't like what it does, use jmemname.c. * jmemname.c This version creates named temporary files. For anything except a Unix machine, you'll need to configure the select_file_name() routine appropriately; see the comments near the head of jmemname.c. If you use this version, define NEED_SIGNAL_CATCHER in jconfig.h to make sure the temp files are removed if the program is aborted. * jmemnobs.c (That stands for No Backing Store :-).) This will compile on almost any system, but it assumes you have enough main memory or virtual memory to hold the biggest images you work with. * jmemdos.c This should be used with most 16-bit MS-DOS compilers. See the system-specific notes about MS-DOS for more info. IMPORTANT: if you use this, define USE_MSDOS_MEMMGR in jconfig.h, and include the assembly file jmemdosa.asm in the programs. The supplied makefiles and jconfig files for 16-bit MS-DOS compilers already do both. * jmemmac.c Custom version for Apple Macintosh; see the system-specific notes for Macintosh for more info. To use a particular memory manager, change the SYSDEPMEM variable in your makefile to equal the corresponding object file name (for example, jmemansi.o or jmemansi.obj for jmemansi.c). If you have plenty of (real or virtual) main memory, just use jmemnobs.c. "Plenty" means about ten bytes for every pixel in the largest images you plan to process, so a lot of systems don't meet this criterion. If yours doesn't, try jmemansi.c first. If that doesn't compile, you'll have to use jmemname.c; be sure to adjust select_file_name() for local conditions. You may also need to change unlink() to remove() in close_backing_store(). Except with jmemnobs.c or jmemmac.c, you need to adjust the DEFAULT_MAX_MEM setting to a reasonable value for your system (either by adding a #define for DEFAULT_MAX_MEM to jconfig.h, or by adding a -D switch to the Makefile). This value limits the amount of data space the program will attempt to allocate. Code and static data space isn't counted, so the actual memory needs for cjpeg or djpeg are typically 100 to 150Kb more than the max-memory setting. Larger max-memory settings reduce the amount of I/O needed to process a large image, but too large a value can result in "insufficient memory" failures. On most Unix machines (and other systems with virtual memory), just set DEFAULT_MAX_MEM to several million and forget it. At the other end of the spectrum, for MS-DOS machines you probably can't go much above 300K to 400K. (On MS-DOS the value refers to conventional memory only. Extended/expanded memory is handled separately by jmemdos.c.) BUILDING THE SOFTWARE ===================== Now you should be able to compile the software. Just say "make" (or whatever's necessary to start the compilation). Have a cup of coffee. Here are some things that could go wrong: If your compiler complains about undefined structures, you should be able to shut it up by putting "#define INCOMPLETE_TYPES_BROKEN" in jconfig.h. If you have trouble with missing system include files or inclusion of the wrong ones, read jinclude.h. This shouldn't happen if you used configure or ckconfig.c to set up jconfig.h. There are a fair number of routines that do not use all of their parameters; some compilers will issue warnings about this, which you can ignore. There are also a few configuration checks that may give "unreachable code" warnings. Any other warning deserves investigation. If you don't have a getenv() library routine, define NO_GETENV. Also see the system-specific hints, below. TESTING THE SOFTWARE ==================== As a quick test of functionality we've included a small sample image in several forms: testorig.jpg Starting point for the djpeg tests. testimg.ppm The output of djpeg testorig.jpg testimg.bmp The output of djpeg -bmp -colors 256 testorig.jpg testimg.jpg The output of cjpeg testimg.ppm testprog.jpg Progressive-mode equivalent of testorig.jpg. testimgp.jpg The output of cjpeg -progressive -optimize testimg.ppm (The first- and second-generation .jpg files aren't identical since JPEG is lossy.) If you can generate duplicates of the testimg* files then you probably have working programs. With most of the makefiles, "make test" will perform the necessary comparisons. If you're using a makefile that doesn't provide the test option, run djpeg and cjpeg by hand and compare the output files to testimg* with whatever binary file comparison tool you have. The files should be bit-for-bit identical. If the programs complain "MAX_ALLOC_CHUNK is wrong, please fix", then you need to reduce MAX_ALLOC_CHUNK to a value that fits in type size_t. Try adding "#define MAX_ALLOC_CHUNK 65520L" to jconfig.h. A less likely configuration error is "ALIGN_TYPE is wrong, please fix": defining ALIGN_TYPE as long should take care of that one. If the cjpeg test run fails with "Missing Huffman code table entry", it's a good bet that you needed to define RIGHT_SHIFT_IS_UNSIGNED. Go back to the configuration step and run ckconfig.c. (This is a good plan for any other test failure, too.) If you are using Unix (one-file) command line style on a non-Unix system, it's a good idea to check that binary I/O through stdin/stdout actually works. You should get the same results from "djpeg out.ppm" as from "djpeg -outfile out.ppm testorig.jpg". Note that the makefiles all use the latter style and therefore do not exercise stdin/stdout! If this check fails, try recompiling with USE_SETMODE or USE_FDOPEN defined. If it still doesn't work, better use two-file style. If you chose a memory manager other than jmemnobs.c, you should test that temporary-file usage works. Try "djpeg -bmp -colors 256 -max 0 testorig.jpg" and make sure its output matches testimg.bmp. If you have any really large images handy, try compressing them with -optimize and/or decompressing with -colors 256 to make sure your DEFAULT_MAX_MEM setting is not too large. NOTE: this is far from an exhaustive test of the JPEG software; some modules, such as 1-pass color quantization, are not exercised at all. It's just a quick test to give you some confidence that you haven't missed something major. INSTALLING THE SOFTWARE ======================= Once you're done with the above steps, you can install the software by copying the executable files (cjpeg, djpeg, jpegtran, rdjpgcom, and wrjpgcom) to wherever you normally install programs. On Unix systems, you'll also want to put the man pages (cjpeg.1, djpeg.1, jpegtran.1, rdjpgcom.1, wrjpgcom.1) in the man-page directory. The pre-fab makefiles don't support this step since there's such a wide variety of installation procedures on different systems. If you generated a Makefile with the "configure" script, you can just say make install to install the programs and their man pages into the standard places. (You'll probably need to be root to do this.) We recommend first saying make -n install to see where configure thought the files should go. You may need to edit the Makefile, particularly if your system's conventions for man page filenames don't match what configure expects. If you want to install the IJG library itself, for use in compiling other programs besides ours, then you need to put the four include files jpeglib.h jerror.h jconfig.h jmorecfg.h into your include-file directory, and put the library file libjpeg.a (extension may vary depending on system) wherever library files go. If you generated a Makefile with "configure", it will do what it thinks is the right thing if you say make install-lib OPTIONAL STUFF ============== Progress monitor: If you like, you can #define PROGRESS_REPORT (in jconfig.h) to enable display of percent-done progress reports. The routine provided in cdjpeg.c merely prints percentages to stderr, but you can customize it to do something fancier. Utah RLE file format support: We distribute the software with support for RLE image files (Utah Raster Toolkit format) disabled, because the RLE support won't compile without the Utah library. If you have URT version 3.1 or later, you can enable RLE support as follows: 1. #define RLE_SUPPORTED in jconfig.h. 2. Add a -I option to CFLAGS in the Makefile for the directory containing the URT .h files (typically the "include" subdirectory of the URT distribution). 3. Add -L... -lrle to LDLIBS in the Makefile, where ... specifies the directory containing the URT "librle.a" file (typically the "lib" subdirectory of the URT distribution). Support for 12-bit-deep pixel data: The JPEG standard allows either 8-bit or 12-bit data precision. (For color, this means 8 or 12 bits per channel, of course.) If you need to work with deeper than 8-bit data, you can compile the IJG code for 12-bit operation. To do so: 1. In jmorecfg.h, define BITS_IN_JSAMPLE as 12 rather than 8. 2. In jconfig.h, undefine BMP_SUPPORTED, RLE_SUPPORTED, and TARGA_SUPPORTED, because the code for those formats doesn't handle 12-bit data and won't even compile. (The PPM code does work, as explained below. The GIF code works too; it scales 8-bit GIF data to and from 12-bit depth automatically.) 3. Compile. Don't expect "make test" to pass, since the supplied test files are for 8-bit data. Currently, 12-bit support does not work on 16-bit-int machines. Note that a 12-bit version will not read 8-bit JPEG files, nor vice versa; so you'll want to keep around a regular 8-bit compilation as well. (Run-time selection of data depth, to allow a single copy that does both, is possible but would probably slow things down considerably; it's very low on our to-do list.) The PPM reader (rdppm.c) can read 12-bit data from either text-format or binary-format PPM and PGM files. Binary-format PPM/PGM files which have a maxval greater than 255 are assumed to use 2 bytes per sample, LSB first (little-endian order). As of early 1995, 2-byte binary format is not officially supported by the PBMPLUS library, but it is expected that a future release of PBMPLUS will support it. Note that the PPM reader will read files of any maxval regardless of the BITS_IN_JSAMPLE setting; incoming data is automatically rescaled to either maxval=255 or maxval=4095 as appropriate for the cjpeg bit depth. The PPM writer (wrppm.c) will normally write 2-byte binary PPM or PGM format, maxval 4095, when compiled with BITS_IN_JSAMPLE=12. Since this format is not yet widely supported, you can disable it by compiling wrppm.c with PPM_NORAWWORD defined; then the data is scaled down to 8 bits to make a standard 1-byte/sample PPM or PGM file. (Yes, this means still another copy of djpeg to keep around. But hopefully you won't need it for very long. Poskanzer's supposed to get that new PBMPLUS release out Real Soon Now.) Of course, if you are working with 12-bit data, you probably have it stored in some other, nonstandard format. In that case you'll probably want to write your own I/O modules to read and write your format. Note that a 12-bit version of cjpeg always runs in "-optimize" mode, in order to generate valid Huffman tables. This is necessary because our default Huffman tables only cover 8-bit data. Removing code: If you need to make a smaller version of the JPEG software, some optional functions can be removed at compile time. See the xxx_SUPPORTED #defines in jconfig.h and jmorecfg.h. If at all possible, we recommend that you leave in decoder support for all valid JPEG files, to ensure that you can read anyone's output. Taking out support for image file formats that you don't use is the most painless way to make the programs smaller. Another possibility is to remove some of the DCT methods: in particular, the "IFAST" method may not be enough faster than the others to be worth keeping on your machine. (If you do remove ISLOW or IFAST, be sure to redefine JDCT_DEFAULT or JDCT_FASTEST to a supported method, by adding a #define in jconfig.h.) OPTIMIZATION ============ Unless you own a Cray, you'll probably be interested in making the JPEG software go as fast as possible. This section covers some machine-dependent optimizations you may want to try. We suggest that before trying any of this, you first get the basic installation to pass the self-test step. Repeat the self-test after any optimization to make sure that you haven't broken anything. The integer DCT routines perform a lot of multiplications. These multiplications must yield 32-bit results, but none of their input values are more than 16 bits wide. On many machines, notably the 680x0 and 80x86 CPUs, a 16x16=>32 bit multiply instruction is faster than a full 32x32=>32 bit multiply. Unfortunately there is no portable way to specify such a multiplication in C, but some compilers can generate one when you use the right combination of casts. See the MULTIPLYxxx macro definitions in jdct.h. If your compiler makes "int" be 32 bits and "short" be 16 bits, defining SHORTxSHORT_32 is fairly likely to work. When experimenting with alternate definitions, be sure to test not only whether the code still works (use the self-test), but also whether it is actually faster --- on some compilers, alternate definitions may compute the right answer, yet be slower than the default. Timing cjpeg on a large PGM (grayscale) input file is the best way to check this, as the DCT will be the largest fraction of the runtime in that mode. (Note: some of the distributed compiler-specific jconfig files already contain #define switches to select appropriate MULTIPLYxxx definitions.) If your machine has sufficiently fast floating point hardware, you may find that the float DCT method is faster than the integer DCT methods, even after tweaking the integer multiply macros. In that case you may want to make the float DCT be the default method. (The only objection to this is that float DCT results may vary slightly across machines.) To do that, add "#define JDCT_DEFAULT JDCT_FLOAT" to jconfig.h. Even if you don't change the default, you should redefine JDCT_FASTEST, which is the method selected by djpeg's -fast switch. Don't forget to update the documentation files (usage.doc and/or cjpeg.1, djpeg.1) to agree with what you've done. If access to "short" arrays is slow on your machine, it may be a win to define type JCOEF as int rather than short. This will cost a good deal of memory though, particularly in some multi-pass modes, so don't do it unless you have memory to burn and short is REALLY slow. If your compiler can compile function calls in-line, make sure the INLINE macro in jmorecfg.h is defined as the keyword that marks a function inline-able. Some compilers have a switch that tells the compiler to inline any function it thinks is profitable (e.g., -finline-functions for gcc). Enabling such a switch is likely to make the compiled code bigger but faster. In general, it's worth trying the maximum optimization level of your compiler, and experimenting with any optional optimizations such as loop unrolling. (Unfortunately, far too many compilers have optimizer bugs ... be prepared to back off if the code fails self-test.) If you do any experimentation along these lines, please report the optimal settings to jpeg-info@uunet.uu.net so we can mention them in future releases. Be sure to specify your machine and compiler version. HINTS FOR SPECIFIC SYSTEMS ========================== We welcome reports on changes needed for systems not mentioned here. Submit 'em to jpeg-info@uunet.uu.net. Also, if configure or ckconfig.c is wrong about how to configure the JPEG software for your system, please let us know. Acorn RISC OS: (Thanks to Simon Middleton for these hints on compiling with Desktop C.) After renaming the files according to Acorn conventions, take a copy of makefile.ansi, change all occurrences of 'libjpeg.a' to 'libjpeg.o' and change these definitions as indicated: CFLAGS= -throwback -IC: -Wn LDLIBS=C:o.Stubs SYSDEPMEM=jmemansi.o LN=Link AR=LibFile -c -o Also add a new line '.c.o:; $(cc) $< $(cflags) -c -o $@'. Remove the lines '$(RM) libjpeg.o' and '$(AR2) libjpeg.o' and the 'jconfig.h' dependency section. Copy jconfig.doc to jconfig.h. Edit jconfig.h to define TWO_FILE_COMMANDLINE and CHAR_IS_UNSIGNED. Run the makefile using !AMU not !Make. If you want to use the 'clean' and 'test' makefile entries then you will have to fiddle with the syntax a bit and rename the test files. Amiga: SAS C 6.50 reportedly is too buggy to compile the IJG code properly. A patch to update to 6.51 is available from SAS or AmiNet FTP sites. The supplied config files are set up to use jmemname.c as the memory manager, with temporary files being created on the device named by "JPEGTMP:". Atari ST/STE/TT: Copy the project files makcjpeg.st, makdjpeg.st, maktjpeg.st, and makljpeg.st to cjpeg.prj, djpeg.prj, jpegtran.prj, and libjpeg.prj respectively. The project files should work as-is with Pure C. For Turbo C, change library filenames "pc..." to "tc..." in each project file. Note that libjpeg.prj selects jmemansi.c as the recommended memory manager. You'll probably want to adjust the DEFAULT_MAX_MEM setting --- you want it to be a couple hundred K less than your normal free memory. Put "#define DEFAULT_MAX_MEM nnnn" into jconfig.h to do this. To use the 68881/68882 coprocessor for the floating point DCT, add the compiler option "-8" to the project files and replace pcfltlib.lib with pc881lib.lib in cjpeg.prj and djpeg.prj. Or if you don't have a coprocessor, you may prefer to remove the float DCT code by undefining DCT_FLOAT_SUPPORTED in jmorecfg.h (since without a coprocessor, the float code will be too slow to be useful). In that case, you can delete pcfltlib.lib from the project files. Note that you must make libjpeg.lib before making cjpeg.ttp, djpeg.ttp, or jpegtran.ttp. You'll have to perform the self-test by hand. We haven't bothered to include project files for rdjpgcom and wrjpgcom. Those source files should just be compiled by themselves; they don't depend on the JPEG library. There is a bug in some older versions of the Turbo C library which causes the space used by temporary files created with "tmpfile()" not to be freed after an abnormal program exit. If you check your disk afterwards, you will find cluster chains that are allocated but not used by a file. This should not happen in cjpeg/djpeg/jpegtran, since we enable a signal catcher to explicitly close temp files before exiting. But if you use the JPEG library with your own code, be sure to supply a signal catcher, or else use a different system-dependent memory manager. Cray: Should you be so fortunate as to be running JPEG on a Cray YMP, there is a compiler bug in old versions of Cray's Standard C (prior to 3.1). If you still have an old compiler, you'll need to insert a line reading "#pragma novector" just before the loop for (i = 1; i <= (int) htbl->bits[l]; i++) huffsize[p++] = (char) l; in fix_huff_tbl (in V5beta1, line 204 of jchuff.c and line 176 of jdhuff.c). [This bug may or may not still occur with the current IJG code, but it's probably a dead issue anyway...] HP-UX: If you have HP-UX 7.05 or later with the "software development" C compiler, you should run the compiler in ANSI mode. If using the configure script, say ./configure CC='cc -Aa' (or -Ae if you prefer). If configuring by hand, use makefile.ansi and add "-Aa" to the CFLAGS line in the makefile. If you have a pre-7.05 system, or if you are using the non-ANSI C compiler delivered with a minimum HP-UX system, then you must use makefile.unix (and do NOT add -Aa); or just run configure without the CC option. On HP 9000 series 800 machines, the HP C compiler is buggy in revisions prior to A.08.07. If you get complaints about "not a typedef name", you'll have to use makefile.unix, or run configure without the CC option. Macintosh, generic comments: The supplied user-interface files (cjpeg.c, djpeg.c, etc) are set up to provide a Unix-style command line interface. You can use this interface on the Mac by means of the ccommand() library routine provided by Metrowerks CodeWarrior or Think C. This is only appropriate for testing the library, however; to make a user-friendly equivalent of cjpeg/djpeg you'd really want to develop a Mac-style user interface. There isn't a complete example available at the moment, but there are some helpful starting points: 1. Sam Bushell's free "To JPEG" applet provides drag-and-drop conversion to JPEG under System 7 and later. This only illustrates how to use the compression half of the library, but it does a very nice job of that part. The CodeWarrior source code is available from http://www.pobox.com/~jsam. 2. Jim Brunner prepared a Mac-style user interface for both compression and decompression. Unfortunately, it hasn't been updated since IJG v4, and the library's API has changed considerably since then. Still it may be of some help, particularly as a guide to compiling the IJG code under Think C. Jim's code is available from the Info-Mac archives, at sumex-aim.stanford.edu or mirrors thereof; see file /info-mac/dev/src/jpeg-convert-c.hqx. jmemmac.c is the recommended memory manager back end for Macintosh. It uses NewPtr/DisposePtr instead of malloc/free, and has a Mac-specific implementation of jpeg_mem_available(). It also creates temporary files that follow Mac conventions. (That part of the code relies on System-7-or-later OS functions. See the comments in jmemmac.c if you need to run it on System 6.) NOTE that USE_MAC_MEMMGR must be defined in jconfig.h to use jmemmac.c. You can also use jmemnobs.c, if you don't care about handling images larger than available memory. If you use any memory manager back end other than jmemmac.c, we recommend replacing "malloc" and "free" by "NewPtr" and "DisposePtr", because Mac C libraries often have peculiar implementations of malloc/free. (For instance, free() may not return the freed space to the Mac Memory Manager. This is undesirable for the IJG code because jmemmgr.c already clumps space requests.) Macintosh, Metrowerks CodeWarrior: The Unix-command-line-style interface can be used by defining USE_CCOMMAND. You'll also need to define TWO_FILE_COMMANDLINE to avoid stdin/stdout. This means that when using the cjpeg/djpeg programs, you'll have to type the input and output file names in the "Arguments" text-edit box, rather than using the file radio buttons. (Perhaps USE_FDOPEN or USE_SETMODE would eliminate the problem, but I haven't heard from anyone who's tried it.) On 680x0 Macs, Metrowerks defines type "double" as a 10-byte IEEE extended float. jmemmgr.c won't like this: it wants sizeof(ALIGN_TYPE) to be a power of 2. Add "#define ALIGN_TYPE long" to jconfig.h to eliminate the complaint. The supplied configuration file jconfig.mac can be used for your jconfig.h; it includes all the recommended symbol definitions. If you have AppleScript installed, you can run the supplied script makeproj.mac to create CodeWarrior project files for the library and the testbed applications, then build the library and applications. (Thanks to Dan Sears and Don Agro for this nifty hack, which saves us from trying to maintain CodeWarrior project files as part of the IJG distribution...) Macintosh, Think C: The documentation in Jim Brunner's "JPEG Convert" source code (see above) includes detailed build instructions for Think C; it's probably somewhat out of date for the current release, but may be helpful. If you want to build the minimal command line version, proceed as follows. You'll have to prepare project files for the programs; we don't include any in the distribution since they are not text files. Use the file lists in any of the supplied makefiles as a guide. Also add the ANSI and Unix C libraries in a separate segment. You may need to divide the JPEG files into more than one segment; we recommend dividing compression and decompression modules. Define USE_CCOMMAND in jconfig.h so that the ccommand() routine is called. You must also define TWO_FILE_COMMANDLINE because stdin/stdout don't handle binary data correctly. On 680x0 Macs, Think C defines type "double" as a 12-byte IEEE extended float. jmemmgr.c won't like this: it wants sizeof(ALIGN_TYPE) to be a power of 2. Add "#define ALIGN_TYPE long" to jconfig.h to eliminate the complaint. jconfig.mac should work as a jconfig.h configuration file for Think C, but the makeproj.mac AppleScript script is specific to CodeWarrior. Sorry. MIPS R3000: MIPS's cc version 1.31 has a rather nasty optimization bug. Don't use -O if you have that compiler version. (Use "cc -V" to check the version.) Note that the R3000 chip is found in workstations from DEC and others. MS-DOS, generic comments for 16-bit compilers: The IJG code is designed to work well in 80x86 "small" or "medium" memory models (i.e., data pointers are 16 bits unless explicitly declared "far"; code pointers can be either size). You may be able to use small model to compile cjpeg or djpeg by itself, but you will probably have to use medium model for any larger application. This won't make much difference in performance. You *will* take a noticeable performance hit if you use a large-data memory model, and you should avoid "huge" model if at all possible. Be sure that NEED_FAR_POINTERS is defined in jconfig.h if you use a small-data memory model; be sure it is NOT defined if you use a large-data model. (The supplied makefiles and jconfig files for Borland and Microsoft C compile in medium model and define NEED_FAR_POINTERS.) The DOS-specific memory manager, jmemdos.c, should be used if possible. It needs some assembly-code routines which are in jmemdosa.asm; make sure your makefile assembles that file and includes it in the library. If you don't have a suitable assembler, you can get pre-assembled object files for jmemdosa by FTP from ftp.uu.net:/graphics/jpeg/jdosaobj.zip. (DOS-oriented distributions of the IJG source code often include these object files.) When using jmemdos.c, jconfig.h must define USE_MSDOS_MEMMGR and must set MAX_ALLOC_CHUNK to less than 64K (65520L is a typical value). If your C library's far-heap malloc() can't allocate blocks that large, reduce MAX_ALLOC_CHUNK to whatever it can handle. If you can't use jmemdos.c for some reason --- for example, because you don't have an assembler to assemble jmemdosa.asm --- you'll have to fall back to jmemansi.c or jmemname.c. You'll probably still need to set MAX_ALLOC_CHUNK in jconfig.h, because most DOS C libraries won't malloc() more than 64K at a time. IMPORTANT: if you use jmemansi.c or jmemname.c, you will have to compile in a large-data memory model in order to get the right stdio library. Too bad. wrjpgcom needs to be compiled in large model, because it malloc()s a 64KB work area to hold the comment text. If your C library's malloc can't handle that, reduce MAX_COM_LENGTH as necessary in wrjpgcom.c. Most MS-DOS compilers treat stdin/stdout as text files, so you must use two-file command line style. But if your compiler has either fdopen() or setmode(), you can use one-file style if you like. To do this, define USE_SETMODE or USE_FDOPEN so that stdin/stdout will be set to binary mode. (USE_SETMODE seems to work with more DOS compilers than USE_FDOPEN.) You should test that I/O through stdin/stdout produces the same results as I/O to explicitly named files... the "make test" procedures in the supplied makefiles do NOT use stdin/stdout. MS-DOS, generic comments for 32-bit compilers: None of the above comments about memory models apply if you are using a 32-bit flat-memory-space environment, such as DJGPP or Watcom C. (And you should use one if you have it, as performance will be much better than 8086-compatible code!) For flat-memory-space compilers, do NOT define NEED_FAR_POINTERS, and do NOT use jmemdos.c. Use jmemnobs.c if the environment supplies adequate virtual memory, otherwise use jmemansi.c or jmemname.c. You'll still need to be careful about binary I/O through stdin/stdout. See the last paragraph of the previous section. MS-DOS, Borland C: Be sure to convert all the source files to DOS text format (CR/LF newlines). Although Borland C will often work OK with unmodified Unix (LF newlines) source files, sometimes it will give bogus compile errors. "Illegal character '#'" is the most common such error. (This is true with Borland C 3.1, but perhaps is fixed in newer releases.) If you want one-file command line style, just undefine TWO_FILE_COMMANDLINE. jconfig.bcc already includes #define USE_SETMODE to make this work. (fdopen does not work correctly.) MS-DOS, Microsoft C: makefile.mc6 works with Microsoft C, DOS Visual C++, etc. It should only be used if you want to build a 16-bit (small or medium memory model) program. If you want one-file command line style, just undefine TWO_FILE_COMMANDLINE. jconfig.mc6 already includes #define USE_SETMODE to make this work. (fdopen does not work correctly.) Note that this makefile assumes that the working copy of itself is called "makefile". If you want to call it something else, say "makefile.mak", be sure to adjust the dependency line that reads "$(RFILE) : makefile". Otherwise the make will fail because it doesn't know how to create "makefile". Worse, some releases of Microsoft's make utilities give an incorrect error message in this situation. Old versions of MS C fail with an "out of macro expansion space" error because they can't cope with the macro TRACEMS8 (defined in jerror.h). If this happens to you, the easiest solution is to change TRACEMS8 to expand to nothing. You'll lose the ability to dump out JPEG coefficient tables with djpeg -debug -debug, but at least you can compile. Original MS C 6.0 is very buggy; it compiles incorrect code unless you turn off optimization entirely (remove -O from CFLAGS). 6.00A is better, but it still generates bad code if you enable loop optimizations (-Ol or -Ox). MS C 8.0 crashes when compiling jquant1.c with optimization switch /Oo ... which is on by default. To work around this bug, compile that one file with /Oo-. Microsoft Windows (all versions), generic comments: Some Windows system include files define typedef boolean as "unsigned char". The IJG code also defines typedef boolean, but we make it "int" by default. This doesn't affect the IJG programs because we don't import those Windows include files. But if you use the JPEG library in your own program, and some of your program's files import one definition of boolean while some import the other, you can get all sorts of mysterious problems. A good preventive step is to make the IJG library use "unsigned char" for boolean. To do that, add something like this to your jconfig.h file: /* Define "boolean" as unsigned char, not int, per Windows custom */ #ifndef __RPCNDR_H__ /* don't conflict if rpcndr.h already read */ typedef unsigned char boolean; #endif #define HAVE_BOOLEAN /* prevent jmorecfg.h from redefining it */ (This is already in jconfig.vc, by the way.) windef.h contains the declarations #define far #define FAR far Since jmorecfg.h tries to define FAR as empty, you may get a compiler warning if you include both jpeglib.h and windef.h (which windows.h includes). To suppress the warning, you can put "#ifndef FAR"/"#endif" around the line "#define FAR" in jmorecfg.h. When using the library in a Windows application, you will almost certainly want to modify or replace the error handler module jerror.c, since our default error handler does a couple of inappropriate things: 1. it tries to write error and warning messages on stderr; 2. in event of a fatal error, it exits by calling exit(). A simple stopgap solution for problem 1 is to replace the line fprintf(stderr, "%s\n", buffer); (in output_message in jerror.c) with MessageBox(GetActiveWindow(),buffer,"JPEG Error",MB_OK|MB_ICONERROR); It's highly recommended that you at least do that much, since otherwise error messages will disappear into nowhere. (Beginning with IJG v6b, this code is already present in jerror.c; just define USE_WINDOWS_MESSAGEBOX in jconfig.h to enable it.) The proper solution for problem 2 is to return control to your calling application after a library error. This can be done with the setjmp/longjmp technique discussed in libjpeg.doc and illustrated in example.c. (NOTE: some older Windows C compilers provide versions of setjmp/longjmp that don't actually work under Windows. You may need to use the Windows system functions Catch and Throw instead.) The recommended memory manager under Windows is jmemnobs.c; in other words, let Windows do any virtual memory management needed. You should NOT use jmemdos.c nor jmemdosa.asm under Windows. For Windows 3.1, we recommend compiling in medium or large memory model; for newer Windows versions, use a 32-bit flat memory model. (See the MS-DOS sections above for more info about memory models.) In the 16-bit memory models only, you'll need to put #define MAX_ALLOC_CHUNK 65520L /* Maximum request to malloc() */ into jconfig.h to limit allocation chunks to 64Kb. (Without that, you'd have to use huge memory model, which slows things down unnecessarily.) jmemnobs.c works without modification in large or flat memory models, but to use medium model, you need to modify its jpeg_get_large and jpeg_free_large routines to allocate far memory. In any case, you might like to replace its calls to malloc and free with direct calls on Windows memory allocation functions. You may also want to modify jdatasrc.c and jdatadst.c to use Windows file operations rather than fread/fwrite. This is only necessary if your C compiler doesn't provide a competent implementation of C stdio functions. You might want to tweak the RGB_xxx macros in jmorecfg.h so that the library will accept or deliver color pixels in BGR sample order, not RGB; BGR order is usually more convenient under Windows. Note that this change will break the sample applications cjpeg/djpeg, but the library itself works fine. Many people want to convert the IJG library into a DLL. This is reasonably straightforward, but watch out for the following: 1. Don't try to compile as a DLL in small or medium memory model; use large model, or even better, 32-bit flat model. Many places in the IJG code assume the address of a local variable is an ordinary (not FAR) pointer; that isn't true in a medium-model DLL. 2. Microsoft C cannot pass file pointers between applications and DLLs. (See Microsoft Knowledge Base, PSS ID Number Q50336.) So jdatasrc.c and jdatadst.c don't work if you open a file in your application and then pass the pointer to the DLL. One workaround is to make jdatasrc.c/jdatadst.c part of your main application rather than part of the DLL. 3. You'll probably need to modify the macros GLOBAL() and EXTERN() to attach suitable linkage keywords to the exported routine names. Similarly, you'll want to modify METHODDEF() and JMETHOD() to ensure function pointers are declared in a way that lets application routines be called back through the function pointers. These macros are in jmorecfg.h. Typical definitions for a 16-bit DLL are: #define GLOBAL(type) type _far _pascal _loadds _export #define EXTERN(type) extern type _far _pascal _loadds #define METHODDEF(type) static type _far _pascal #define JMETHOD(type,methodname,arglist) \ type (_far _pascal *methodname) arglist For a 32-bit DLL you may want something like #define GLOBAL(type) __declspec(dllexport) type #define EXTERN(type) extern __declspec(dllexport) type Although not all the GLOBAL routines are actually intended to be called by the application, the performance cost of making them all DLL entry points is negligible. The unmodified IJG library presents a very C-specific application interface, so the resulting DLL is only usable from C or C++ applications. There has been some talk of writing wrapper code that would present a simpler interface usable from other languages, such as Visual Basic. This is on our to-do list but hasn't been very high priority --- any volunteers out there? Microsoft Windows, Borland C: The provided jconfig.bcc should work OK in a 32-bit Windows environment, but you'll need to tweak it in a 16-bit environment (you'd need to define NEED_FAR_POINTERS and MAX_ALLOC_CHUNK). Beware that makefile.bcc will need alteration if you want to use it for Windows --- in particular, you should use jmemnobs.c not jmemdos.c under Windows. Borland C++ 4.5 fails with an internal compiler error when trying to compile jdmerge.c in 32-bit mode. If enough people complain, perhaps Borland will fix it. In the meantime, the simplest known workaround is to add a redundant definition of the variable range_limit in h2v1_merged_upsample(), at the head of the block that handles odd image width (about line 268 in v6 jdmerge.c): /* If image width is odd, do the last output column separately */ if (cinfo->output_width & 1) { register JSAMPLE * range_limit = cinfo->sample_range_limit; /* ADD THIS */ cb = GETJSAMPLE(*inptr1); Pretty bizarre, especially since the very similar routine h2v2_merged_upsample doesn't trigger the bug. Recent reports suggest that this bug does not occur with "bcc32a" (the Pentium-optimized version of the compiler). Another report from a user of Borland C 4.5 was that incorrect code (leading to a color shift in processed images) was produced if any of the following optimization switch combinations were used: -Ot -Og -Ot -Op -Ot -Om So try backing off on optimization if you see such a problem. (Are there several different releases all numbered "4.5"??) Microsoft Windows, Microsoft Visual C++: jconfig.vc should work OK with any Microsoft compiler for a 32-bit memory model. makefile.vc is intended for command-line use. (If you are using the Developer Studio environment, you may prefer the DevStudio project files; see below.) Some users feel that it's easier to call the library from C++ code if you force VC++ to treat the library as C++ code, which you can do by renaming all the *.c files to *.cpp (and adjusting the makefile to match). This avoids the need to put extern "C" { ... } around #include "jpeglib.h" in your C++ application. Microsoft Windows, Microsoft Developer Studio: We include makefiles that should work as project files in DevStudio 4.2 or later. There is a library makefile that builds the IJG library as a static Win32 library, and an application makefile that builds the sample applications as Win32 console applications. (Even if you only want the library, we recommend building the applications so that you can run the self-test.) To use: 1. Copy jconfig.vc to jconfig.h, makelib.ds to jpeg.mak, and makeapps.ds to apps.mak. (Note that the renaming is critical!) 2. Click on the .mak files to construct project workspaces. (If you are using DevStudio more recent than 4.2, you'll probably get a message saying that the makefiles are being updated.) 3. Build the library project, then the applications project. 4. Move the application .exe files from `app`\Release to an appropriate location on your path. 5. To perform the self-test, execute the command line NMAKE /f makefile.vc test OS/2, Borland C++: Watch out for optimization bugs in older Borland compilers; you may need to back off the optimization switch settings. See the comments in makefile.bcc. SGI: On some SGI systems, you may need to set "AR2= ar -ts" in the Makefile. If you are using configure, you can do this by saying ./configure RANLIB='ar -ts' This change is not needed on all SGIs. Use it only if the make fails at the stage of linking the completed programs. On the MIPS R4000 architecture (Indy, etc.), the compiler option "-mips2" reportedly speeds up the float DCT method substantially, enough to make it faster than the default int method (but still slower than the fast int method). If you use -mips2, you may want to alter the default DCT method to be float. To do this, put "#define JDCT_DEFAULT JDCT_FLOAT" in jconfig.h. VMS: On an Alpha/VMS system with MMS, be sure to use the "/Marco=Alpha=1" qualifier with MMS when building the JPEG package. VAX/VMS v5.5-1 may have problems with the test step of the build procedure reporting differences when it compares the original and test images. If the error points to the last block of the files, it is most likely bogus and may be safely ignored. It seems to be because the files are Stream_LF and Backup/Compare has difficulty with the (presumably) null padded files. This problem was not observed on VAX/VMS v6.1 or AXP/VMS v6.1. Papyrus3/JpegDir/JpgLossy/JVERSION.H0000755000175000017500000000056607535143454014216 0ustar /* * jversion.h * * Copyright (C) 1991-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains software version identification. */ #define JVERSION "6b 27-Mar-1998" #define JCOPYRIGHT "Copyright (C) 1998, Thomas G. Lane" Papyrus3/JpegDir/JpgLossy/testorig.jpg0000755000175000017500000001321207535143454015200 0ustar ÿØÿàJFIFÿÛC    $.' ",#(7),01444'9=82<.342ÿÛC  2!!22222222222222222222222222222222222222222222222222ÿÀ•ã"ÿÄ ÿĵ}!1AQa"q2‘¡#B±ÁRÑð$3br‚ %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚáâãäåæçèéêñòóôõö÷øùúÿÄ ÿĵw!1AQaq"2B‘¡±Á #3RðbrÑ $4á%ñ&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz‚ƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚâãäåæçèéêòóôõö÷øùúÿÚ ?òåjvúf)4šc÷óFñQŠ3E‡qäÒñQîÅ8Ñ`¸ð©Ô°)ÊNiX ‰.J²j àS•ðjKF¤ù} iZÝ8f®|KÅ]µ˜õÏVŸSÓÀâ}ÛBI¸zÔs¸XɬønJ¼T·HÆ+•ÅÜúEN“]H‹TNÔÒüÔlÔÔO:u.…&€ÜÔEªX”±­ns¹Ø¹n½MVÕãqn0‡µ4ø î3[Z†YíÇ8«§zìËŒ(ªkvyƒQšÖÔ¬Z&<~5ŒÄ†Á®Äîx—¾Ââ•NÇ )›©wUº:Pf™#^Iâ¶uŘـFä×7áR§T]ݺW¥-Œz„‹¤mÅo…«J—2›"³•¯Ðó«-JK ,|ã¨õ­Kýeõ8•Z&äWS/„ôûYV@ªI=:Õ]jh,Ûb…â°«Rz{TÞ‡%°QQ ´óEeíäth`éþVE9gš@=*ÉE6„ÓŠÒÙškGè(æ±V¹™åšpJºSEDËG5Á¢=*T†œƒš°£¦RQGQì9«.i€hLoB?,‘Å: ѶEt¶V–ö‹%Êy“8ܨIÔ@°!&KtéÁÛXδV‡« º­£&Ò¿õ©Ry…cøT¹*v° ú²d8Ë9§.÷r3•üÜX9®Çtpò²W)1¦Mj h|ýÇU?áMŠÊˆwo4öR¸ëëKžÍ¿³ñ ­4}J‡O¸[X®™1 ¤…lúT°.p¢´ÞáÌ xŒdà:…Igl¥‰‘Jª˜ûú ¨Í5s‡©Nª§M^åÝ7÷!w`S[Rüðô®rYcy¹  Ï¥Y扶Ç+…ÏcMU6Ÿ Ʋ¿µ÷úé û­5gVÈë\^¯£½»–QÅw u6p_ó’—ýlhãШ­¡'Ðç\3^I«|Ï.1²žE[Ò½&mÂór‹UF`pS‚=ÅsWšÕŒø1ù‘çå‘FAúúVª©É‹Êêáµ–«ÈÃÖ“Ãx· ¸\t®öÞõ¸#9ªè~»{_5ã#+ÀÅnÛøbùÙB®ëíYJž¶Äw¤än¨B:ˆ£‡$*\$£t|ê¥Dèå°T®;°ÅE›;šŠ§îõ¤nðAÎE]w’˜C/TaÐÕBª£’OÒ­Sm-˺ÙÁ«‡c’jQwÙ”%s3ŽÕzÙŽÌíÁ>µIã1¹SÁ/Ú?r¨G äU'ÜçMÂ\ÝMHÁtÏpjx”6[5P†ä4|ÖµÌx‰]q’pk¢”¬uƺ–ƒq´qÁïŸjŠâtÉØL~Û½LqvàNO½\H‹#`¨2qÔÐÖ’ËnhÆH'zÑÉßC›*R§(Ôzu±èÞ0^h‘«¼ z×DGû£ò¯+øm«Ë%Äö¬Ù äþ¯Y¯>•×M¾[U®kÃfC4q•ËŠäõOEªÜüŠÕ×¼BDd'¯V€ÈûÜTÊVFz4prøJ•” È4Wq5›É3>:š)û¦VgÌL¨L š—4 ÆçM†"`WEáëĶbà“XBž¤©Èâµ£WÙϘ™BêǤé©ç9¨nuÅ„ Ÿ¥rúUÓ– äàVåÄmP ,½=+Øž21‚”˜aðs¯S’Ük2]@ʘ¸$VnÏza`£1ž{Säp±’5óUëδù¦}Ö O KÙ¥f·ó!$ ã‘»'è9¡¤Y ÃôëU˜Ü2pjêE®b,~tö¬9JJMZBÊÊGä{S¢U'š$…à•¢‘pÊqOŒm\ã.z{Vm³J¼®.Æ “ß׌ÔBÏ$ÜäqR•Ç,ãùБy¸@ãæ=ª¡ÞÇ{ÃÂVæº#.FÁõ¥TvÎlÖƒéñEj^bD½@‡¿½gË:£È,=¸¡Á­NwÉåÍd#îFÚßþºš9$cnWŸ”ž¼çOþµ*ˆÇ2ŸÞ3|›O t?Ÿô¨¦%g§•­©Š’nòw&¹šÞq¹Qão¨oðªr«DåXý)ËÈ«1Å[¸k™Ç\`Sóf6öº@¦´Œô®ºÙÞhԂăžÝ+—h#ÇÊ6Ÿ­t>IBz®x«ƒM‘:S¤í#B8˜J ‡$.IÆ3øT q$“ÝƇæxŠ¯éþvá¶DIàšç./ ®ùÔÙÀüku£¹˜©a*·ü¬ê¾ZGc©Ì÷, ·#ë^•u­XÚ©Ìè[Ðñ+9nåMÊøÝÜUèmÙe•Ù½Í\j¸£àeQ¨¤zl%‰ä8ÆÒjôš€eY†ÞõæÑM´ iésO+¼^fÞˆTæva‡ž¼¬íN¿l¼È÷¢¼êæiæEó‡ÒŠíös7æå›hŸ`*`„œÉ®[\T’ÖœZLw8ÏjžÊÅbY±»®=+B%äÁˆÇë^ž̯3 Õ³Ðv•§ˆ8$šÛx.R6‘m^HÀä/_ÀVÞ‰gin¥Á>õ¥¨jv[·—· TcdÔ}…8]w4ÃU•9ûDõ<ÎY ˜¿wRŒ¸"³¥S´æµîõ¥¼,01&òž”é´ø®Ñ§³`ÈyÛÜW‹Rœ£¹öX<|1påz3Ò7˜Šv¸‚zjA*À†šH%…‰C±”sÓŽi³J·,²ªìr0Ã<íXÊÍÔ©Ï•ì8Ÿ2%ÜNS¿·¥>¥_•Á#·¦Ê±yQynwãç\t5 ܧøO¶qSªgl%ÞE‰¬Þ7!rè~ãcïtãõ¦ª5¬fY`“’QT‚¹ìyý?>”ë[÷· ¨Þ§å$|Ëþ­ö¢ÖR3³# ±ÉµŒV臈”–æeÅÕÅÈUhþfþý)° ц¸‘£|p¨úÓ" ,ŠòÎ6ƒ“’rjÚêrvR¸nŠhMnÂ¥ÎÉjS[x-13³ÌƒÏsQË ´˜f# 4>ÓËd¹ç4`îÉæ¡Êäª<¶Bà ~p`€w-žÔÀŤ,zšsŸóLS&t%%ʬ8ÖŸ…Ü ZhÏt$ŸÆ³M]ÑMJ[¤DîxÿªŽ6<ÉXØÔ®>b=«“Õ¦h-³Œïý?­mÜÎ$rÄáG$ŸJã¯dMv®rONÕÜ‘äg5½ŽQ[Ëò;kÛàðXî=kJ¾ómBç‘ZQËï\ÒÑØø)+3MdÆ9©&¹xâ-¾[c®k&[’¼-dÞ‹¦Úd`¾Æ”/ÍqEjAqö縑Ž¨rNzÑP> §Hã„|‹Ï©äÕ´aJœÔö#;—,íÁõ8¨žuTÜ>‚¡»|ÊrrEß'Šµ ‘[ìÛŒbY.Å÷““W!•\8>•$aÞœ·N•›9¨ãT%vmbšÄ äTý±ŒÆ –våŽjTõ;*cákĵqvÚ‡êjŒ’Tm'5;ˆ½j y5±2›»5´¹^(¤e82¹îE]CëùÕ(Wn¢¨ÅX3G y’“´œu­bŽZ•=Ý^ˆ}Ljl´{F‡H·iqûÉ›±®jæúîñL“ÊÌOSžµ«=½½ÙYgyäåž²ï.RR% pª¦¢¶ZŸ>­rfÿHê+¾·@mÓé^nq2Ù…z £·B=+Ý+©n'±"Äu¿ðî+Q!2ýÉëщx\JÕÁ%©Ÿ=Ùó©§j~™àc"D[Õqå3w®‚k8Fþó.ÊÚ‘ÙÚ-­ºÆAVh¢µ$£«hÖ:Ý¡¶¿dOá=¨=«ÈüMà‹íÚh7ÝXž’ó'ûÀ>•íT¸GZÊ­%?S« ‹©Aû¯NÇÌ— ”:ÖsŽkÞõχZV©¾[\ØÜ79A”'ÝÃÀê? µè\›Wµ¹^Ûiüø×:§(hÑèÔÆÓ«ªÑžxFiŒ§¥kk:£ Nê6þK¸Ü£z¶Gàk3 j´1uWr( ù{Ô¥p;S§‚dŽÒ~ð±ù¥3â"¶„… ŽJÔYRÓD¹¹×býO‘lò¬Àà°n úÕ½_/pÅÌQò}Í s–ue4sç4ÓV {Rlµn`VÍ&îjɈTmíT’‘ÁäUŻƊ>âö¬â¬§œÔ‘Jclöô¤ãqXÜŠée¬êsùZi òEc "85-Ôí5¨V+%r,Œ3ÔäQSéEtsvÑ ÓÊ€h¢¹ÑPcO\VLJ[f¥àQZCâAScÛìç#OFÇ8¬]OQ›æQ€:QE:ÊÌtõHÓÒIDÏ#<×RQU"\Ť'4QC%9$T;÷ǵʌòz(¥-ŠŽåŽÔŒp¹¢ŠS~ë%nxŸÆLj,ùãìÿÖ¼ì𹢊撳/ ÑóqRÁl²Ê2zœQEc7¹Ó^x~ ]3ÍŽVó1’Øëí\¸•‰ÁäQEM7u¨©¶÷ š5ê*¯J(®ˆì9‹ŽiÊ9¢Š¢u\rIcmt #ÒŠ*gð±=‹Z±X6ùh«ŸJ@M<’£8¢ŠÎ? 3[û8 F?Z(¢·5?ÿÙPapyrus3/JpegDir/JpgLossy/WRTARGA.C0000755000175000017500000001714107535143454014056 0ustar /* * wrtarga.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to write output images in Targa format. * * These routines may need modification for non-Unix environments or * specialized applications. As they stand, they assume output to * an ordinary stdio stream. * * Based on code contributed by Lee Daniel Crocker. */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ #ifdef TARGA_SUPPORTED /* * To support 12-bit JPEG data, we'd have to scale output down to 8 bits. * This is not yet implemented. */ #if BITS_IN_JSAMPLE != 8 Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */ #endif /* * The output buffer needs to be writable by fwrite(). On PCs, we must * allocate the buffer in near data space, because we are assuming small-data * memory model, wherein fwrite() can't reach far memory. If you need to * process very wide images on a PC, you might have to compile in large-memory * model, or else replace fwrite() with a putc() loop --- which will be much * slower. */ /* Private version of data destination object */ typedef struct { struct djpeg_dest_struct pub; /* public fields */ char *iobuffer; /* physical I/O buffer */ JDIMENSION buffer_width; /* width of one row */ } tga_dest_struct; typedef tga_dest_struct * tga_dest_ptr; LOCAL(void) write_header (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, int num_colors) /* Create and write a Targa header */ { char targaheader[18]; /* Set unused fields of header to 0 */ MEMZERO(targaheader, SIZEOF(targaheader)); if (num_colors > 0) { targaheader[1] = 1; /* color map type 1 */ targaheader[5] = (char) (num_colors & 0xFF); targaheader[6] = (char) (num_colors >> 8); targaheader[7] = 24; /* 24 bits per cmap entry */ } targaheader[12] = (char) (cinfo->output_width & 0xFF); targaheader[13] = (char) (cinfo->output_width >> 8); targaheader[14] = (char) (cinfo->output_height & 0xFF); targaheader[15] = (char) (cinfo->output_height >> 8); targaheader[17] = 0x20; /* Top-down, non-interlaced */ if (cinfo->out_color_space == JCS_GRAYSCALE) { targaheader[2] = 3; /* image type = uncompressed gray-scale */ targaheader[16] = 8; /* bits per pixel */ } else { /* must be RGB */ if (num_colors > 0) { targaheader[2] = 1; /* image type = colormapped RGB */ targaheader[16] = 8; } else { targaheader[2] = 2; /* image type = uncompressed RGB */ targaheader[16] = 24; } } if (JFWRITE(dinfo->output_file, targaheader, 18) != (size_t) 18) ERREXIT(cinfo, JERR_FILE_WRITE); } /* * Write some pixel data. * In this module rows_supplied will always be 1. */ METHODDEF(void) put_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied) /* used for unquantized full-color output */ { tga_dest_ptr dest = (tga_dest_ptr) dinfo; register JSAMPROW inptr; register char * outptr; register JDIMENSION col; inptr = dest->pub.buffer[0]; outptr = dest->iobuffer; for (col = cinfo->output_width; col > 0; col--) { outptr[0] = (char) GETJSAMPLE(inptr[2]); /* RGB to BGR order */ outptr[1] = (char) GETJSAMPLE(inptr[1]); outptr[2] = (char) GETJSAMPLE(inptr[0]); inptr += 3, outptr += 3; } (void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width); } METHODDEF(void) put_gray_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied) /* used for grayscale OR quantized color output */ { tga_dest_ptr dest = (tga_dest_ptr) dinfo; register JSAMPROW inptr; register char * outptr; register JDIMENSION col; inptr = dest->pub.buffer[0]; outptr = dest->iobuffer; for (col = cinfo->output_width; col > 0; col--) { *outptr++ = (char) GETJSAMPLE(*inptr++); } (void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width); } /* * Write some demapped pixel data when color quantization is in effect. * For Targa, this is only applied to grayscale data. */ METHODDEF(void) put_demapped_gray (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied) { tga_dest_ptr dest = (tga_dest_ptr) dinfo; register JSAMPROW inptr; register char * outptr; register JSAMPROW color_map0 = cinfo->colormap[0]; register JDIMENSION col; inptr = dest->pub.buffer[0]; outptr = dest->iobuffer; for (col = cinfo->output_width; col > 0; col--) { *outptr++ = (char) GETJSAMPLE(color_map0[GETJSAMPLE(*inptr++)]); } (void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width); } /* * Startup: write the file header. */ METHODDEF(void) start_output_tga (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) { tga_dest_ptr dest = (tga_dest_ptr) dinfo; int num_colors, i; FILE *outfile; if (cinfo->out_color_space == JCS_GRAYSCALE) { /* Targa doesn't have a mapped grayscale format, so we will */ /* demap quantized gray output. Never emit a colormap. */ write_header(cinfo, dinfo, 0); if (cinfo->quantize_colors) dest->pub.put_pixel_rows = put_demapped_gray; else dest->pub.put_pixel_rows = put_gray_rows; } else if (cinfo->out_color_space == JCS_RGB) { if (cinfo->quantize_colors) { /* We only support 8-bit colormap indexes, so only 256 colors */ num_colors = cinfo->actual_number_of_colors; if (num_colors > 256) ERREXIT1(cinfo, JERR_TOO_MANY_COLORS, num_colors); write_header(cinfo, dinfo, num_colors); /* Write the colormap. Note Targa uses BGR byte order */ outfile = dest->pub.output_file; for (i = 0; i < num_colors; i++) { putc(GETJSAMPLE(cinfo->colormap[2][i]), outfile); putc(GETJSAMPLE(cinfo->colormap[1][i]), outfile); putc(GETJSAMPLE(cinfo->colormap[0][i]), outfile); } dest->pub.put_pixel_rows = put_gray_rows; } else { write_header(cinfo, dinfo, 0); dest->pub.put_pixel_rows = put_pixel_rows; } } else { ERREXIT(cinfo, JERR_TGA_COLORSPACE); } } /* * Finish up at the end of the file. */ METHODDEF(void) finish_output_tga (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) { /* Make sure we wrote the output file OK */ fflush(dinfo->output_file); if (ferror(dinfo->output_file)) ERREXIT(cinfo, JERR_FILE_WRITE); } /* * The module selection routine for Targa format output. */ GLOBAL(djpeg_dest_ptr) jinit_write_targa (j_decompress_ptr cinfo) { tga_dest_ptr dest; /* Create module interface object, fill in method pointers */ dest = (tga_dest_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(tga_dest_struct)); dest->pub.start_output = start_output_tga; dest->pub.finish_output = finish_output_tga; /* Calculate output image dimensions so we can allocate space */ jpeg_calc_output_dimensions(cinfo); /* Create I/O buffer. Note we make this near on a PC. */ dest->buffer_width = cinfo->output_width * cinfo->output_components; dest->iobuffer = (char *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (size_t) (dest->buffer_width * SIZEOF(char))); /* Create decompressor output buffer. */ dest->pub.buffer = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, dest->buffer_width, (JDIMENSION) 1); dest->pub.buffer_height = 1; return (djpeg_dest_ptr) dest; } #endif /* TARGA_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/JDDCTMGR.C0000755000175000017500000002056207535143454014146 0ustar /* * jddctmgr.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains the inverse-DCT management logic. * This code selects a particular IDCT implementation to be used, * and it performs related housekeeping chores. No code in this file * is executed per IDCT step, only during output pass setup. * * Note that the IDCT routines are responsible for performing coefficient * dequantization as well as the IDCT proper. This module sets up the * dequantization multiplier table needed by the IDCT routine. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jdct.h" /* Private declarations for DCT subsystem */ /* * The decompressor input side (jdinput.c) saves away the appropriate * quantization table for each component at the start of the first scan * involving that component. (This is necessary in order to correctly * decode files that reuse Q-table slots.) * When we are ready to make an output pass, the saved Q-table is converted * to a multiplier table that will actually be used by the IDCT routine. * The multiplier table contents are IDCT-method-dependent. To support * application changes in IDCT method between scans, we can remake the * multiplier tables if necessary. * In buffered-image mode, the first output pass may occur before any data * has been seen for some components, and thus before their Q-tables have * been saved away. To handle this case, multiplier tables are preset * to zeroes; the result of the IDCT will be a neutral gray level. */ /* Private subobject for this module */ typedef struct { struct jpeg_inverse_dct pub; /* public fields */ /* This array contains the IDCT method code that each multiplier table * is currently set up for, or -1 if it's not yet set up. * The actual multiplier tables are pointed to by dct_table in the * per-component comp_info structures. */ int cur_method[MAX_COMPONENTS]; } my_idct_controller; typedef my_idct_controller * my_idct_ptr; /* Allocated multiplier tables: big enough for any supported variant */ typedef union { ISLOW_MULT_TYPE islow_array[DCTSIZE2]; #ifdef DCT_IFAST_SUPPORTED IFAST_MULT_TYPE ifast_array[DCTSIZE2]; #endif #ifdef DCT_FLOAT_SUPPORTED FLOAT_MULT_TYPE float_array[DCTSIZE2]; #endif } multiplier_table; /* The current scaled-IDCT routines require ISLOW-style multiplier tables, * so be sure to compile that code if either ISLOW or SCALING is requested. */ #ifdef DCT_ISLOW_SUPPORTED #define PROVIDE_ISLOW_TABLES #else #ifdef IDCT_SCALING_SUPPORTED #define PROVIDE_ISLOW_TABLES #endif #endif /* * Prepare for an output pass. * Here we select the proper IDCT routine for each component and build * a matching multiplier table. */ METHODDEF(void) start_pass (j_decompress_ptr cinfo) { my_idct_ptr idct = (my_idct_ptr) cinfo->idct; int ci, i; jpeg_component_info *compptr; int method = 0; inverse_DCT_method_ptr method_ptr = NULL; JQUANT_TBL * qtbl; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { /* Select the proper IDCT routine for this component's scaling */ switch (compptr->DCT_scaled_size) { #ifdef IDCT_SCALING_SUPPORTED case 1: method_ptr = jpeg_idct_1x1; method = JDCT_ISLOW; /* jidctred uses islow-style table */ break; case 2: method_ptr = jpeg_idct_2x2; method = JDCT_ISLOW; /* jidctred uses islow-style table */ break; case 4: method_ptr = jpeg_idct_4x4; method = JDCT_ISLOW; /* jidctred uses islow-style table */ break; #endif case DCTSIZE: switch (cinfo->dct_method) { #ifdef DCT_ISLOW_SUPPORTED case JDCT_ISLOW: method_ptr = jpeg_idct_islow; method = JDCT_ISLOW; break; #endif #ifdef DCT_IFAST_SUPPORTED case JDCT_IFAST: method_ptr = jpeg_idct_ifast; method = JDCT_IFAST; break; #endif #ifdef DCT_FLOAT_SUPPORTED case JDCT_FLOAT: method_ptr = jpeg_idct_float; method = JDCT_FLOAT; break; #endif default: ERREXIT(cinfo, JERR_NOT_COMPILED); break; } break; default: ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->DCT_scaled_size); break; } idct->pub.inverse_DCT[ci] = method_ptr; /* Create multiplier table from quant table. * However, we can skip this if the component is uninteresting * or if we already built the table. Also, if no quant table * has yet been saved for the component, we leave the * multiplier table all-zero; we'll be reading zeroes from the * coefficient controller's buffer anyway. */ if (! compptr->component_needed || idct->cur_method[ci] == method) continue; qtbl = compptr->quant_table; if (qtbl == NULL) /* happens if no data yet for component */ continue; idct->cur_method[ci] = method; switch (method) { #ifdef PROVIDE_ISLOW_TABLES case JDCT_ISLOW: { /* For LL&M IDCT method, multipliers are equal to raw quantization * coefficients, but are stored as ints to ensure access efficiency. */ ISLOW_MULT_TYPE * ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table; for (i = 0; i < DCTSIZE2; i++) { ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[i]; } } break; #endif #ifdef DCT_IFAST_SUPPORTED case JDCT_IFAST: { /* For AA&N IDCT method, multipliers are equal to quantization * coefficients scaled by scalefactor[row]*scalefactor[col], where * scalefactor[0] = 1 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7 * For integer operation, the multiplier table is to be scaled by * IFAST_SCALE_BITS. */ IFAST_MULT_TYPE * ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table; #define CONST_BITS 14 static const INT16 aanscales[DCTSIZE2] = { /* precomputed values scaled up by 14 bits */ 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270, 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906, 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315, 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552, 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446, 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247 }; SHIFT_TEMPS for (i = 0; i < DCTSIZE2; i++) { ifmtbl[i] = (IFAST_MULT_TYPE) DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i], (INT32) aanscales[i]), CONST_BITS-IFAST_SCALE_BITS); } } break; #endif #ifdef DCT_FLOAT_SUPPORTED case JDCT_FLOAT: { /* For float AA&N IDCT method, multipliers are equal to quantization * coefficients scaled by scalefactor[row]*scalefactor[col], where * scalefactor[0] = 1 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7 */ FLOAT_MULT_TYPE * fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table; int row, col; static const double aanscalefactor[DCTSIZE] = { 1.0, 1.387039845, 1.306562965, 1.175875602, 1.0, 0.785694958, 0.541196100, 0.275899379 }; i = 0; for (row = 0; row < DCTSIZE; row++) { for (col = 0; col < DCTSIZE; col++) { fmtbl[i] = (FLOAT_MULT_TYPE) ((double) qtbl->quantval[i] * aanscalefactor[row] * aanscalefactor[col]); i++; } } } break; #endif default: ERREXIT(cinfo, JERR_NOT_COMPILED); break; } } } /* * Initialize IDCT manager. */ GLOBAL(void) jinit_inverse_dct (j_decompress_ptr cinfo) { my_idct_ptr idct; int ci; jpeg_component_info *compptr; idct = (my_idct_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_idct_controller)); cinfo->idct = (struct jpeg_inverse_dct *) idct; idct->pub.start_pass = start_pass; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { /* Allocate and pre-zero a multiplier table for each component */ compptr->dct_table = (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(multiplier_table)); MEMZERO(compptr->dct_table, SIZEOF(multiplier_table)); /* Mark multiplier table not yet set up for any method */ idct->cur_method[ci] = -1; } } Papyrus3/JpegDir/JpgLossy/Jlossy.dsw0000755000175000017500000000103307535143454014636 0ustar Microsoft Developer Studio Workspace File, Format Version 5.00 # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! ############################################################################### Project: "Jpglossy"=.\Jlossy32.dsp - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Global: Package=<5> {{{ }}} Package=<3> {{{ }}} ############################################################################### Papyrus3/JpegDir/JpgLossy/JPEGINT.H0000755000175000017500000003735007535143454014060 0ustar /* * jpegint.h * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file provides common declarations for the various JPEG modules. * These declarations are considered internal to the JPEG library; most * applications using the library shouldn't need to include this file. */ /* Declarations for both compression & decompression */ typedef enum { /* Operating modes for buffer controllers */ JBUF_PASS_THRU, /* Plain stripwise operation */ /* Remaining modes require a full-image buffer to have been created */ JBUF_SAVE_SOURCE, /* Run source subobject only, save output */ JBUF_CRANK_DEST, /* Run dest subobject only, using saved data */ JBUF_SAVE_AND_PASS /* Run both subobjects, save output */ } J_BUF_MODE; /* Values of global_state field (jdapi.c has some dependencies on ordering!) */ #define CSTATE_START 100 /* after create_compress */ #define CSTATE_SCANNING 101 /* start_compress done, write_scanlines OK */ #define CSTATE_RAW_OK 102 /* start_compress done, write_raw_data OK */ #define CSTATE_WRCOEFS 103 /* jpeg_write_coefficients done */ #define DSTATE_START 200 /* after create_decompress */ #define DSTATE_INHEADER 201 /* reading header markers, no SOS yet */ #define DSTATE_READY 202 /* found SOS, ready for start_decompress */ #define DSTATE_PRELOAD 203 /* reading multiscan file in start_decompress*/ #define DSTATE_PRESCAN 204 /* performing dummy pass for 2-pass quant */ #define DSTATE_SCANNING 205 /* start_decompress done, read_scanlines OK */ #define DSTATE_RAW_OK 206 /* start_decompress done, read_raw_data OK */ #define DSTATE_BUFIMAGE 207 /* expecting jpeg_start_output */ #define DSTATE_BUFPOST 208 /* looking for SOS/EOI in jpeg_finish_output */ #define DSTATE_RDCOEFS 209 /* reading file in jpeg_read_coefficients */ #define DSTATE_STOPPING 210 /* looking for EOI in jpeg_finish_decompress */ /* Declarations for compression modules */ /* Master control module */ struct jpeg_comp_master { JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo)); JMETHOD(void, pass_startup, (j_compress_ptr cinfo)); JMETHOD(void, finish_pass, (j_compress_ptr cinfo)); /* State variables made visible to other modules */ boolean call_pass_startup; /* True if pass_startup must be called */ boolean is_last_pass; /* True during last pass */ }; /* Main buffer control (downsampled-data buffer) */ struct jpeg_c_main_controller { JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); JMETHOD(void, process_data, (j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail)); }; /* Compression preprocessing (downsampling input buffer control) */ struct jpeg_c_prep_controller { JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); JMETHOD(void, pre_process_data, (j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail, JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr, JDIMENSION out_row_groups_avail)); }; /* Coefficient buffer control */ struct jpeg_c_coef_controller { JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); JMETHOD(boolean, compress_data, (j_compress_ptr cinfo, JSAMPIMAGE input_buf)); }; /* Colorspace conversion */ struct jpeg_color_converter { JMETHOD(void, start_pass, (j_compress_ptr cinfo)); JMETHOD(void, color_convert, (j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)); }; /* Downsampling */ struct jpeg_downsampler { JMETHOD(void, start_pass, (j_compress_ptr cinfo)); JMETHOD(void, downsample, (j_compress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION in_row_index, JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)); boolean need_context_rows; /* TRUE if need rows above & below */ }; /* Forward DCT (also controls coefficient quantization) */ struct jpeg_forward_dct { JMETHOD(void, start_pass, (j_compress_ptr cinfo)); /* perhaps this should be an array??? */ JMETHOD(void, forward_DCT, (j_compress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY sample_data, JBLOCKROW coef_blocks, JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks)); }; /* Entropy encoding */ struct jpeg_entropy_encoder { JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics)); JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data)); JMETHOD(void, finish_pass, (j_compress_ptr cinfo)); }; /* Marker writing */ struct jpeg_marker_writer { JMETHOD(void, write_file_header, (j_compress_ptr cinfo)); JMETHOD(void, write_frame_header, (j_compress_ptr cinfo)); JMETHOD(void, write_scan_header, (j_compress_ptr cinfo)); JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo)); JMETHOD(void, write_tables_only, (j_compress_ptr cinfo)); /* These routines are exported to allow insertion of extra markers */ /* Probably only COM and APPn markers should be written this way */ JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker, unsigned int datalen)); JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val)); }; /* Declarations for decompression modules */ /* Master control module */ struct jpeg_decomp_master { JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo)); JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo)); /* State variables made visible to other modules */ boolean is_dummy_pass; /* True during 1st pass for 2-pass quant */ }; /* Input control module */ struct jpeg_input_controller { JMETHOD(int, consume_input, (j_decompress_ptr cinfo)); JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo)); JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo)); /* State variables made visible to other modules */ boolean has_multiple_scans; /* True if file has multiple scans */ boolean eoi_reached; /* True when EOI has been consumed */ }; /* Main buffer control (downsampled-data buffer) */ struct jpeg_d_main_controller { JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); JMETHOD(void, process_data, (j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); }; /* Coefficient buffer control */ struct jpeg_d_coef_controller { JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); JMETHOD(int, consume_data, (j_decompress_ptr cinfo)); JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo)); JMETHOD(int, decompress_data, (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)); /* Pointer to array of coefficient virtual arrays, or NULL if none */ jvirt_barray_ptr *coef_arrays; }; /* Decompression postprocessing (color quantization buffer control) */ struct jpeg_d_post_controller { JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); JMETHOD(void, post_process_data, (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); }; /* Marker reading & parsing */ struct jpeg_marker_reader { JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo)); /* Read markers until SOS or EOI. * Returns same codes as are defined for jpeg_consume_input: * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. */ JMETHOD(int, read_markers, (j_decompress_ptr cinfo)); /* Read a restart marker --- exported for use by entropy decoder only */ jpeg_marker_parser_method read_restart_marker; /* State of marker reader --- nominally internal, but applications * supplying COM or APPn handlers might like to know the state. */ boolean saw_SOI; /* found SOI? */ boolean saw_SOF; /* found SOF? */ int next_restart_num; /* next restart number expected (0-7) */ unsigned int discarded_bytes; /* # of bytes skipped looking for a marker */ }; /* Entropy decoding */ struct jpeg_entropy_decoder { JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)); /* This is here to share code between baseline and progressive decoders; */ /* other modules probably should not use it */ boolean insufficient_data; /* set TRUE after emitting warning */ }; /* Inverse DCT (also performs dequantization) */ typedef JMETHOD(void, inverse_DCT_method_ptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); struct jpeg_inverse_dct { JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); /* It is useful to allow each component to have a separate IDCT method. */ inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS]; }; /* Upsampling (note that upsampler must also call color converter) */ struct jpeg_upsampler { JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); JMETHOD(void, upsample, (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); boolean need_context_rows; /* TRUE if need rows above & below */ }; /* Colorspace conversion */ struct jpeg_color_deconverter { JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); JMETHOD(void, color_convert, (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)); }; /* Color quantization or color precision reduction */ struct jpeg_color_quantizer { JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan)); JMETHOD(void, color_quantize, (j_decompress_ptr cinfo, JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)); JMETHOD(void, finish_pass, (j_decompress_ptr cinfo)); JMETHOD(void, new_color_map, (j_decompress_ptr cinfo)); }; /* Miscellaneous useful macros */ #undef MAX #define MAX(a,b) ((a) > (b) ? (a) : (b)) #undef MIN #define MIN(a,b) ((a) < (b) ? (a) : (b)) /* We assume that right shift corresponds to signed division by 2 with * rounding towards minus infinity. This is correct for typical "arithmetic * shift" instructions that shift in copies of the sign bit. But some * C compilers implement >> with an unsigned shift. For these machines you * must define RIGHT_SHIFT_IS_UNSIGNED. * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity. * It is only applied with constant shift counts. SHIFT_TEMPS must be * included in the variables of any routine using RIGHT_SHIFT. */ #ifdef RIGHT_SHIFT_IS_UNSIGNED #define SHIFT_TEMPS INT32 shift_temp; #define RIGHT_SHIFT(x,shft) \ ((shift_temp = (x)) < 0 ? \ (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \ (shift_temp >> (shft))) #else #define SHIFT_TEMPS #define RIGHT_SHIFT(x,shft) ((x) >> (shft)) #endif /* Short forms of external names for systems with brain-damaged linkers. */ #ifdef NEED_SHORT_EXTERNAL_NAMES #define jinit_compress_master jICompress #define jinit_c_master_control jICMaster #define jinit_c_main_controller jICMainC #define jinit_c_prep_controller jICPrepC #define jinit_c_coef_controller jICCoefC #define jinit_color_converter jICColor #define jinit_downsampler jIDownsampler #define jinit_forward_dct jIFDCT #define jinit_huff_encoder jIHEncoder #define jinit_phuff_encoder jIPHEncoder #define jinit_marker_writer jIMWriter #define jinit_master_decompress jIDMaster #define jinit_d_main_controller jIDMainC #define jinit_d_coef_controller jIDCoefC #define jinit_d_post_controller jIDPostC #define jinit_input_controller jIInCtlr #define jinit_marker_reader jIMReader #define jinit_huff_decoder jIHDecoder #define jinit_phuff_decoder jIPHDecoder #define jinit_inverse_dct jIIDCT #define jinit_upsampler jIUpsampler #define jinit_color_deconverter jIDColor #define jinit_1pass_quantizer jI1Quant #define jinit_2pass_quantizer jI2Quant #define jinit_merged_upsampler jIMUpsampler #define jinit_memory_mgr jIMemMgr #define jdiv_round_up jDivRound #define jround_up jRound #define jcopy_sample_rows jCopySamples #define jcopy_block_row jCopyBlocks #define jzero_far jZeroFar #define jpeg_zigzag_order jZIGTable #define jpeg_natural_order jZAGTable #endif /* NEED_SHORT_EXTERNAL_NAMES */ /* Compression module initialization routines */ EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo, boolean transcode_only)); EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo, boolean need_full_buffer)); EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo, boolean need_full_buffer)); EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo, boolean need_full_buffer)); EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_phuff_encoder JPP((j_compress_ptr cinfo)); EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo)); /* Decompression module initialization routines */ EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo, boolean need_full_buffer)); EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo, boolean need_full_buffer)); EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo, boolean need_full_buffer)); EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo)); EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo)); /* Memory manager initialization */ EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo)); /* Utility routines in jutils.c */ EXTERN(long) jdiv_round_up JPP((long a, long b)); EXTERN(long) jround_up JPP((long a, long b)); EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row, JSAMPARRAY output_array, int dest_row, int num_rows, JDIMENSION num_cols)); EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row, JDIMENSION num_blocks)); EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero)); /* Constant tables in jutils.c */ #if 0 /* This table is not actually needed in v6a */ extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */ #endif extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */ /* Suppress undefined-structure complaints if necessary. */ #ifdef INCOMPLETE_TYPES_BROKEN #ifndef AM_MEMORY_MANAGER /* only jmemmgr.c defines these */ struct jvirt_sarray_control { long dummy; }; struct jvirt_barray_control { long dummy; }; #endif #endif /* INCOMPLETE_TYPES_BROKEN */ Papyrus3/JpegDir/JpgLossy/MAKEFILE.DJ0000755000175000017500000002756707535143454014254 0ustar # Makefile for Independent JPEG Group's software # This makefile is for DJGPP (Delorie's GNU C port on MS-DOS), v2.0 or later. # Thanks to Frank J. Donahoe for this version. # Read installation instructions before saying "make" !! # The name of your C compiler: CC= gcc # You may need to adjust these cc options: CFLAGS= -O2 -Wall -I. # Generally, we recommend defining any configuration symbols in jconfig.h, # NOT via -D switches here. # Link-time cc options: LDFLAGS= -s # To link any special libraries, add the necessary -l commands here. LDLIBS= # Put here the object file name for the correct system-dependent memory # manager file. For DJGPP this is usually jmemnobs.o, but you could # use jmemname.o if you want to use named temp files instead of swap space. SYSDEPMEM= jmemnobs.o # miscellaneous OS-dependent stuff # linker LN= $(CC) # file deletion command RM= del # library (.a) file creation command AR= ar rc # second step in .a creation (use "touch" if not needed) AR2= ranlib # End of configurable options. # source files: JPEG library proper LIBSOURCES= jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c \ jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c \ jcphuff.c jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c \ jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c \ jdinput.c jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c \ jdpostct.c jdsample.c jdtrans.c jerror.c jfdctflt.c jfdctfst.c \ jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c jquant1.c \ jquant2.c jutils.c jmemmgr.c # memmgr back ends: compile only one of these into a working library SYSDEPSOURCES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemmac.c # source files: cjpeg/djpeg/jpegtran applications, also rdjpgcom/wrjpgcom APPSOURCES= cjpeg.c djpeg.c jpegtran.c rdjpgcom.c wrjpgcom.c cdjpeg.c \ rdcolmap.c rdswitch.c transupp.c rdppm.c wrppm.c rdgif.c wrgif.c \ rdtarga.c wrtarga.c rdbmp.c wrbmp.c rdrle.c wrrle.c SOURCES= $(LIBSOURCES) $(SYSDEPSOURCES) $(APPSOURCES) # files included by source files INCLUDES= jchuff.h jdhuff.h jdct.h jerror.h jinclude.h jmemsys.h jmorecfg.h \ jpegint.h jpeglib.h jversion.h cdjpeg.h cderror.h transupp.h # documentation, test, and support files DOCS= README install.doc usage.doc cjpeg.1 djpeg.1 jpegtran.1 rdjpgcom.1 \ wrjpgcom.1 wizard.doc example.c libjpeg.doc structure.doc \ coderules.doc filelist.doc change.log MKFILES= configure makefile.cfg makefile.ansi makefile.unix makefile.bcc \ makefile.mc6 makefile.dj makefile.wat makefile.vc makelib.ds \ makeapps.ds makeproj.mac makcjpeg.st makdjpeg.st makljpeg.st \ maktjpeg.st makefile.manx makefile.sas makefile.mms makefile.vms \ makvms.opt CONFIGFILES= jconfig.cfg jconfig.bcc jconfig.mc6 jconfig.dj jconfig.wat \ jconfig.vc jconfig.mac jconfig.st jconfig.manx jconfig.sas \ jconfig.vms CONFIGUREFILES= config.guess config.sub install-sh ltconfig ltmain.sh OTHERFILES= jconfig.doc ckconfig.c ansi2knr.c ansi2knr.1 jmemdosa.asm TESTFILES= testorig.jpg testimg.ppm testimg.bmp testimg.jpg testprog.jpg \ testimgp.jpg DISTFILES= $(DOCS) $(MKFILES) $(CONFIGFILES) $(SOURCES) $(INCLUDES) \ $(CONFIGUREFILES) $(OTHERFILES) $(TESTFILES) # library object files common to compression and decompression COMOBJECTS= jcomapi.o jutils.o jerror.o jmemmgr.o $(SYSDEPMEM) # compression library object files CLIBOBJECTS= jcapimin.o jcapistd.o jctrans.o jcparam.o jdatadst.o jcinit.o \ jcmaster.o jcmarker.o jcmainct.o jcprepct.o jccoefct.o jccolor.o \ jcsample.o jchuff.o jcphuff.o jcdctmgr.o jfdctfst.o jfdctflt.o \ jfdctint.o # decompression library object files DLIBOBJECTS= jdapimin.o jdapistd.o jdtrans.o jdatasrc.o jdmaster.o \ jdinput.o jdmarker.o jdhuff.o jdphuff.o jdmainct.o jdcoefct.o \ jdpostct.o jddctmgr.o jidctfst.o jidctflt.o jidctint.o jidctred.o \ jdsample.o jdcolor.o jquant1.o jquant2.o jdmerge.o # These objectfiles are included in libjpeg.a LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS) # object files for sample applications (excluding library files) COBJECTS= cjpeg.o rdppm.o rdgif.o rdtarga.o rdrle.o rdbmp.o rdswitch.o \ cdjpeg.o DOBJECTS= djpeg.o wrppm.o wrgif.o wrtarga.o wrrle.o wrbmp.o rdcolmap.o \ cdjpeg.o TROBJECTS= jpegtran.o rdswitch.o cdjpeg.o transupp.o all: libjpeg.a cjpeg.exe djpeg.exe jpegtran.exe rdjpgcom.exe wrjpgcom.exe libjpeg.a: $(LIBOBJECTS) $(RM) libjpeg.a $(AR) libjpeg.a $(LIBOBJECTS) $(AR2) libjpeg.a cjpeg.exe: $(COBJECTS) libjpeg.a $(LN) $(LDFLAGS) -o cjpeg.exe $(COBJECTS) libjpeg.a $(LDLIBS) djpeg.exe: $(DOBJECTS) libjpeg.a $(LN) $(LDFLAGS) -o djpeg.exe $(DOBJECTS) libjpeg.a $(LDLIBS) jpegtran.exe: $(TROBJECTS) libjpeg.a $(LN) $(LDFLAGS) -o jpegtran.exe $(TROBJECTS) libjpeg.a $(LDLIBS) rdjpgcom.exe: rdjpgcom.o $(LN) $(LDFLAGS) -o rdjpgcom.exe rdjpgcom.o $(LDLIBS) wrjpgcom.exe: wrjpgcom.o $(LN) $(LDFLAGS) -o wrjpgcom.exe wrjpgcom.o $(LDLIBS) jconfig.h: jconfig.doc echo You must prepare a system-dependent jconfig.h file. echo Please read the installation directions in install.doc. exit 1 clean: $(RM) *.o $(RM) cjpeg.exe $(RM) djpeg.exe $(RM) jpegtran.exe $(RM) rdjpgcom.exe $(RM) wrjpgcom.exe $(RM) libjpeg.a $(RM) testout*.* test: cjpeg.exe djpeg.exe jpegtran.exe $(RM) testout*.* ./djpeg -dct int -ppm -outfile testout.ppm testorig.jpg ./djpeg -dct int -bmp -colors 256 -outfile testout.bmp testorig.jpg ./cjpeg -dct int -outfile testout.jpg testimg.ppm ./djpeg -dct int -ppm -outfile testoutp.ppm testprog.jpg ./cjpeg -dct int -progressive -opt -outfile testoutp.jpg testimg.ppm ./jpegtran -outfile testoutt.jpg testprog.jpg fc /b testimg.ppm testout.ppm fc /b testimg.bmp testout.bmp fc /b testimg.jpg testout.jpg fc /b testimg.ppm testoutp.ppm fc /b testimgp.jpg testoutp.jpg fc /b testorig.jpg testoutt.jpg jcapimin.o: jcapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcapistd.o: jcapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccoefct.o: jccoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccolor.o: jccolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcdctmgr.o: jcdctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jchuff.o: jchuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcinit.o: jcinit.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmainct.o: jcmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmarker.o: jcmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmaster.o: jcmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcomapi.o: jcomapi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcparam.o: jcparam.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcphuff.o: jcphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcprepct.o: jcprepct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcsample.o: jcsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jctrans.o: jctrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapimin.o: jdapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapistd.o: jdapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdatadst.o: jdatadst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdatasrc.o: jdatasrc.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdcoefct.o: jdcoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdcolor.o: jdcolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jddctmgr.o: jddctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jdhuff.o: jdhuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdinput.o: jdinput.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmainct.o: jdmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmarker.o: jdmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmaster.o: jdmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmerge.o: jdmerge.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdphuff.o: jdphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdpostct.o: jdpostct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdsample.o: jdsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdtrans.o: jdtrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jerror.o: jerror.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jversion.h jerror.h jfdctflt.o: jfdctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctfst.o: jfdctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctint.o: jfdctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctflt.o: jidctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctfst.o: jidctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctint.o: jidctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctred.o: jidctred.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jquant1.o: jquant1.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jquant2.o: jquant2.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jutils.o: jutils.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemmgr.o: jmemmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemansi.o: jmemansi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemname.o: jmemname.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemnobs.o: jmemnobs.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemdos.o: jmemdos.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemmac.o: jmemmac.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h cjpeg.o: cjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h djpeg.o: djpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h jpegtran.o: jpegtran.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.h jversion.h rdjpgcom.o: rdjpgcom.c jinclude.h jconfig.h wrjpgcom.o: wrjpgcom.c jinclude.h jconfig.h cdjpeg.o: cdjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdcolmap.o: rdcolmap.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdswitch.o: rdswitch.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.o: transupp.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h transupp.h rdppm.o: rdppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrppm.o: wrppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdgif.o: rdgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrgif.o: wrgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdtarga.o: rdtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrtarga.o: wrtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdbmp.o: rdbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrbmp.o: wrbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdrle.o: rdrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrrle.o: wrrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h Papyrus3/JpegDir/JpgLossy/JERROR.C0000755000175000017500000001756507535143454013764 0ustar /* * jerror.c * * Copyright (C) 1991-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains simple error-reporting and trace-message routines. * These are suitable for Unix-like systems and others where writing to * stderr is the right thing to do. Many applications will want to replace * some or all of these routines. * * If you define USE_WINDOWS_MESSAGEBOX in jconfig.h or in the makefile, * you get a Windows-specific hack to display error messages in a dialog box. * It ain't much, but it beats dropping error messages into the bit bucket, * which is what happens to output to stderr under most Windows C compilers. * * These routines are used by both the compression and decompression code. */ /* this is not a core library module, so it doesn't define JPEG_INTERNALS */ #include "jinclude.h" #include "jpeglib.h" #include "jversion.h" #include "jerror.h" #ifdef USE_WINDOWS_MESSAGEBOX #include #endif #ifndef EXIT_FAILURE /* define exit() codes if not provided */ #define EXIT_FAILURE 1 #endif /* * Create the message string table. * We do this from the master message list in jerror.h by re-reading * jerror.h with a suitable definition for macro JMESSAGE. * The message table is made an external symbol just in case any applications * want to refer to it directly. */ #ifdef NEED_SHORT_EXTERNAL_NAMES #define jpeg_std_message_table jMsgTable #endif #define JMESSAGE(code,string) string , const char * const jpeg_std_message_table[] = { #include "jerror.h" NULL }; /* * Error exit handler: must not return to caller. * * Applications may override this if they want to get control back after * an error. Typically one would longjmp somewhere instead of exiting. * The setjmp buffer can be made a private field within an expanded error * handler object. Note that the info needed to generate an error message * is stored in the error object, so you can generate the message now or * later, at your convenience. * You should make sure that the JPEG object is cleaned up (with jpeg_abort * or jpeg_destroy) at some point. */ METHODDEF(void) error_exit (j_common_ptr cinfo) { /* Always display the message */ (*cinfo->err->output_message) (cinfo); /* Let the memory manager delete any temp files before we die */ jpeg_destroy(cinfo); exit(EXIT_FAILURE); } /* * Actual output of an error or trace message. * Applications may override this method to send JPEG messages somewhere * other than stderr. * * On Windows, printing to stderr is generally completely useless, * so we provide optional code to produce an error-dialog popup. * Most Windows applications will still prefer to override this routine, * but if they don't, it'll do something at least marginally useful. * * NOTE: to use the library in an environment that doesn't support the * C stdio library, you may have to delete the call to fprintf() entirely, * not just not use this routine. */ METHODDEF(void) output_message (j_common_ptr cinfo) { char buffer[JMSG_LENGTH_MAX]; /* Create the message */ (*cinfo->err->format_message) (cinfo, buffer); #ifdef USE_WINDOWS_MESSAGEBOX /* Display it in a message dialog box */ MessageBox(GetActiveWindow(), buffer, "JPEG Library Error", MB_OK | MB_ICONERROR); #else /* Send it to stderr, adding a newline */ fprintf(stderr, "%s\n", buffer); #endif } /* * Decide whether to emit a trace or warning message. * msg_level is one of: * -1: recoverable corrupt-data warning, may want to abort. * 0: important advisory messages (always display to user). * 1: first level of tracing detail. * 2,3,...: successively more detailed tracing messages. * An application might override this method if it wanted to abort on warnings * or change the policy about which messages to display. */ METHODDEF(void) emit_message (j_common_ptr cinfo, int msg_level) { struct jpeg_error_mgr * err = cinfo->err; if (msg_level < 0) { /* It's a warning message. Since corrupt files may generate many warnings, * the policy implemented here is to show only the first warning, * unless trace_level >= 3. */ if (err->num_warnings == 0 || err->trace_level >= 3) (*err->output_message) (cinfo); /* Always count warnings in num_warnings. */ err->num_warnings++; } else { /* It's a trace message. Show it if trace_level >= msg_level. */ if (err->trace_level >= msg_level) (*err->output_message) (cinfo); } } /* * Format a message string for the most recent JPEG error or message. * The message is stored into buffer, which should be at least JMSG_LENGTH_MAX * characters. Note that no '\n' character is added to the string. * Few applications should need to override this method. */ METHODDEF(void) format_message (j_common_ptr cinfo, char * buffer) { struct jpeg_error_mgr * err = cinfo->err; int msg_code = err->msg_code; const char * msgtext = NULL; const char * msgptr; char ch; boolean isstring; /* Look up message string in proper table */ if (msg_code > 0 && msg_code <= err->last_jpeg_message) { msgtext = err->jpeg_message_table[msg_code]; } else if (err->addon_message_table != NULL && msg_code >= err->first_addon_message && msg_code <= err->last_addon_message) { msgtext = err->addon_message_table[msg_code - err->first_addon_message]; } /* Defend against bogus message number */ if (msgtext == NULL) { err->msg_parm.i[0] = msg_code; msgtext = err->jpeg_message_table[0]; } /* Check for string parameter, as indicated by %s in the message text */ isstring = FALSE; msgptr = msgtext; while ((ch = *msgptr++) != '\0') { if (ch == '%') { if (*msgptr == 's') isstring = TRUE; break; } } /* Format the message into the passed buffer */ if (isstring) sprintf(buffer, msgtext, err->msg_parm.s); else sprintf(buffer, msgtext, err->msg_parm.i[0], err->msg_parm.i[1], err->msg_parm.i[2], err->msg_parm.i[3], err->msg_parm.i[4], err->msg_parm.i[5], err->msg_parm.i[6], err->msg_parm.i[7]); } /* * Reset error state variables at start of a new image. * This is called during compression startup to reset trace/error * processing to default state, without losing any application-specific * method pointers. An application might possibly want to override * this method if it has additional error processing state. */ METHODDEF(void) reset_error_mgr (j_common_ptr cinfo) { cinfo->err->num_warnings = 0; /* trace_level is not reset since it is an application-supplied parameter */ cinfo->err->msg_code = 0; /* may be useful as a flag for "no error" */ } /* * Fill in the standard error-handling methods in a jpeg_error_mgr object. * Typical call is: * struct jpeg_compress_struct cinfo; * struct jpeg_error_mgr err; * * cinfo.err = jpeg_std_error(&err); * after which the application may override some of the methods. */ GLOBAL(struct jpeg_error_mgr *) jpeg_std_error (struct jpeg_error_mgr * err) { err->error_exit = error_exit; err->emit_message = emit_message; err->output_message = output_message; err->format_message = format_message; err->reset_error_mgr = reset_error_mgr; err->trace_level = 0; /* default = no tracing */ err->num_warnings = 0; /* no warnings emitted yet */ err->msg_code = 0; /* may be useful as a flag for "no error" */ /* Initialize message table pointers */ err->jpeg_message_table = jpeg_std_message_table; err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1; err->addon_message_table = NULL; err->first_addon_message = 0; /* for safety */ err->last_addon_message = 0; return err; } Papyrus3/JpegDir/JpgLossy/jconfig.mc60000755000175000017500000000327007535143454014667 0ustar /* jconfig.mc6 --- jconfig.h for Microsoft C on MS-DOS, version 6.00A & up. */ /* see jconfig.doc for explanations */ #define HAVE_PROTOTYPES #define HAVE_UNSIGNED_CHAR #define HAVE_UNSIGNED_SHORT /* #define void char */ /* #define const */ #undef CHAR_IS_UNSIGNED #define HAVE_STDDEF_H #define HAVE_STDLIB_H #undef NEED_BSD_STRINGS #undef NEED_SYS_TYPES_H #define NEED_FAR_POINTERS /* for small or medium memory model */ #undef NEED_SHORT_EXTERNAL_NAMES #undef INCOMPLETE_TYPES_BROKEN #ifdef JPEG_INTERNALS #undef RIGHT_SHIFT_IS_UNSIGNED #define USE_MSDOS_MEMMGR /* Define this if you use jmemdos.c */ #define MAX_ALLOC_CHUNK 65520L /* Maximum request to malloc() */ #define USE_FMEM /* Microsoft has _fmemcpy() and _fmemset() */ #define NEED_FHEAPMIN /* far heap management routines are broken */ #define SHORTxLCONST_32 /* enable compiler-specific DCT optimization */ /* Note: the above define is known to improve the code with Microsoft C 6.00A. * I do not know whether it is good for later compiler versions. * Please report any info on this point to jpeg-info@uunet.uu.net. */ #endif /* JPEG_INTERNALS */ #ifdef JPEG_CJPEG_DJPEG #define BMP_SUPPORTED /* BMP image file format */ #define GIF_SUPPORTED /* GIF image file format */ #define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ #undef RLE_SUPPORTED /* Utah RLE image file format */ #define TARGA_SUPPORTED /* Targa image file format */ #define TWO_FILE_COMMANDLINE #define USE_SETMODE /* Microsoft has setmode() */ #define NEED_SIGNAL_CATCHER /* Define this if you use jmemdos.c */ #undef DONT_USE_B_MODE #undef PROGRESS_REPORT /* optional */ #endif /* JPEG_CJPEG_DJPEG */ Papyrus3/JpegDir/JpgLossy/JFDCTINT.C0000755000175000017500000002612507535143454014156 0ustar /* * jfdctint.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains a slow-but-accurate integer implementation of the * forward DCT (Discrete Cosine Transform). * * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT * on each column. Direct algorithms are also available, but they are * much more complex and seem not to be any faster when reduced to code. * * This implementation is based on an algorithm described in * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics, * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991. * The primary algorithm described there uses 11 multiplies and 29 adds. * We use their alternate method with 12 multiplies and 32 adds. * The advantage of this method is that no data path contains more than one * multiplication; this allows a very simple and accurate implementation in * scaled fixed-point arithmetic, with a minimal number of shifts. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jdct.h" /* Private declarations for DCT subsystem */ #ifdef DCT_ISLOW_SUPPORTED /* * This module is specialized to the case DCTSIZE = 8. */ #if DCTSIZE != 8 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ #endif /* * The poop on this scaling stuff is as follows: * * Each 1-D DCT step produces outputs which are a factor of sqrt(N) * larger than the true DCT outputs. The final outputs are therefore * a factor of N larger than desired; since N=8 this can be cured by * a simple right shift at the end of the algorithm. The advantage of * this arrangement is that we save two multiplications per 1-D DCT, * because the y0 and y4 outputs need not be divided by sqrt(N). * In the IJG code, this factor of 8 is removed by the quantization step * (in jcdctmgr.c), NOT in this module. * * We have to do addition and subtraction of the integer inputs, which * is no problem, and multiplication by fractional constants, which is * a problem to do in integer arithmetic. We multiply all the constants * by CONST_SCALE and convert them to integer constants (thus retaining * CONST_BITS bits of precision in the constants). After doing a * multiplication we have to divide the product by CONST_SCALE, with proper * rounding, to produce the correct output. This division can be done * cheaply as a right shift of CONST_BITS bits. We postpone shifting * as long as possible so that partial sums can be added together with * full fractional precision. * * The outputs of the first pass are scaled up by PASS1_BITS bits so that * they are represented to better-than-integral precision. These outputs * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word * with the recommended scaling. (For 12-bit sample data, the intermediate * array is INT32 anyway.) * * To avoid overflow of the 32-bit intermediate results in pass 2, we must * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26. Error analysis * shows that the values given below are the most effective. */ #if BITS_IN_JSAMPLE == 8 #define CONST_BITS 13 #define PASS1_BITS 2 #else #define CONST_BITS 13 #define PASS1_BITS 1 /* lose a little precision to avoid overflow */ #endif /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus * causing a lot of useless floating-point operations at run time. * To get around this we use the following pre-calculated constants. * If you change CONST_BITS you may want to add appropriate values. * (With a reasonable C compiler, you can just rely on the FIX() macro...) */ #if CONST_BITS == 13 #define FIX_0_298631336 ((INT32) 2446) /* FIX(0.298631336) */ #define FIX_0_390180644 ((INT32) 3196) /* FIX(0.390180644) */ #define FIX_0_541196100 ((INT32) 4433) /* FIX(0.541196100) */ #define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */ #define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */ #define FIX_1_175875602 ((INT32) 9633) /* FIX(1.175875602) */ #define FIX_1_501321110 ((INT32) 12299) /* FIX(1.501321110) */ #define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */ #define FIX_1_961570560 ((INT32) 16069) /* FIX(1.961570560) */ #define FIX_2_053119869 ((INT32) 16819) /* FIX(2.053119869) */ #define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */ #define FIX_3_072711026 ((INT32) 25172) /* FIX(3.072711026) */ #else #define FIX_0_298631336 FIX(0.298631336) #define FIX_0_390180644 FIX(0.390180644) #define FIX_0_541196100 FIX(0.541196100) #define FIX_0_765366865 FIX(0.765366865) #define FIX_0_899976223 FIX(0.899976223) #define FIX_1_175875602 FIX(1.175875602) #define FIX_1_501321110 FIX(1.501321110) #define FIX_1_847759065 FIX(1.847759065) #define FIX_1_961570560 FIX(1.961570560) #define FIX_2_053119869 FIX(2.053119869) #define FIX_2_562915447 FIX(2.562915447) #define FIX_3_072711026 FIX(3.072711026) #endif /* Multiply an INT32 variable by an INT32 constant to yield an INT32 result. * For 8-bit samples with the recommended scaling, all the variable * and constant values involved are no more than 16 bits wide, so a * 16x16->32 bit multiply can be used instead of a full 32x32 multiply. * For 12-bit samples, a full 32-bit multiplication will be needed. */ #if BITS_IN_JSAMPLE == 8 #define MULTIPLY(var,const) MULTIPLY16C16(var,const) #else #define MULTIPLY(var,const) ((var) * (const)) #endif /* * Perform the forward DCT on one block of samples. */ GLOBAL(void) jpeg_fdct_islow (DCTELEM * data) { INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; INT32 tmp10, tmp11, tmp12, tmp13; INT32 z1, z2, z3, z4, z5; DCTELEM *dataptr; int ctr; SHIFT_TEMPS /* Pass 1: process rows. */ /* Note results are scaled up by sqrt(8) compared to a true DCT; */ /* furthermore, we scale the results by 2**PASS1_BITS. */ dataptr = data; for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { tmp0 = dataptr[0] + dataptr[7]; tmp7 = dataptr[0] - dataptr[7]; tmp1 = dataptr[1] + dataptr[6]; tmp6 = dataptr[1] - dataptr[6]; tmp2 = dataptr[2] + dataptr[5]; tmp5 = dataptr[2] - dataptr[5]; tmp3 = dataptr[3] + dataptr[4]; tmp4 = dataptr[3] - dataptr[4]; /* Even part per LL&M figure 1 --- note that published figure is faulty; * rotator "sqrt(2)*c1" should be "sqrt(2)*c6". */ tmp10 = tmp0 + tmp3; tmp13 = tmp0 - tmp3; tmp11 = tmp1 + tmp2; tmp12 = tmp1 - tmp2; dataptr[0] = (DCTELEM) ((tmp10 + tmp11) << PASS1_BITS); dataptr[4] = (DCTELEM) ((tmp10 - tmp11) << PASS1_BITS); z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100); dataptr[2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865), CONST_BITS-PASS1_BITS); dataptr[6] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065), CONST_BITS-PASS1_BITS); /* Odd part per figure 8 --- note paper omits factor of sqrt(2). * cK represents cos(K*pi/16). * i0..i3 in the paper are tmp4..tmp7 here. */ z1 = tmp4 + tmp7; z2 = tmp5 + tmp6; z3 = tmp4 + tmp6; z4 = tmp5 + tmp7; z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */ tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */ tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */ tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */ tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */ z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */ z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */ z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */ z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */ z3 += z5; z4 += z5; dataptr[7] = (DCTELEM) DESCALE(tmp4 + z1 + z3, CONST_BITS-PASS1_BITS); dataptr[5] = (DCTELEM) DESCALE(tmp5 + z2 + z4, CONST_BITS-PASS1_BITS); dataptr[3] = (DCTELEM) DESCALE(tmp6 + z2 + z3, CONST_BITS-PASS1_BITS); dataptr[1] = (DCTELEM) DESCALE(tmp7 + z1 + z4, CONST_BITS-PASS1_BITS); dataptr += DCTSIZE; /* advance pointer to next row */ } /* Pass 2: process columns. * We remove the PASS1_BITS scaling, but leave the results scaled up * by an overall factor of 8. */ dataptr = data; for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; /* Even part per LL&M figure 1 --- note that published figure is faulty; * rotator "sqrt(2)*c1" should be "sqrt(2)*c6". */ tmp10 = tmp0 + tmp3; tmp13 = tmp0 - tmp3; tmp11 = tmp1 + tmp2; tmp12 = tmp1 - tmp2; dataptr[DCTSIZE*0] = (DCTELEM) DESCALE(tmp10 + tmp11, PASS1_BITS); dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp10 - tmp11, PASS1_BITS); z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100); dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865), CONST_BITS+PASS1_BITS); dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065), CONST_BITS+PASS1_BITS); /* Odd part per figure 8 --- note paper omits factor of sqrt(2). * cK represents cos(K*pi/16). * i0..i3 in the paper are tmp4..tmp7 here. */ z1 = tmp4 + tmp7; z2 = tmp5 + tmp6; z3 = tmp4 + tmp6; z4 = tmp5 + tmp7; z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */ tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */ tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */ tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */ tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */ z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */ z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */ z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */ z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */ z3 += z5; z4 += z5; dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp4 + z1 + z3, CONST_BITS+PASS1_BITS); dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp5 + z2 + z4, CONST_BITS+PASS1_BITS); dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp6 + z2 + z3, CONST_BITS+PASS1_BITS); dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp7 + z1 + z4, CONST_BITS+PASS1_BITS); dataptr++; /* advance pointer to next column */ } } #endif /* DCT_ISLOW_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/JDPHUFF.C0000755000175000017500000005135307535143454014040 0ustar /* * jdphuff.c * * Copyright (C) 1995-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains Huffman entropy decoding routines for progressive JPEG. * * Much of the complexity here has to do with supporting input suspension. * If the data source module demands suspension, we want to be able to back * up to the start of the current MCU. To do this, we copy state variables * into local working storage, and update them back to the permanent * storage only upon successful completion of an MCU. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jdhuff.h" /* Declarations shared with jdhuff.c */ #ifdef D_PROGRESSIVE_SUPPORTED /* * Expanded entropy decoder object for progressive Huffman decoding. * * The savable_state subrecord contains fields that change within an MCU, * but must not be updated permanently until we complete the MCU. */ typedef struct { unsigned int EOBRUN; /* remaining EOBs in EOBRUN */ int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ } savable_state; /* This macro is to work around compilers with missing or broken * structure assignment. You'll need to fix this code if you have * such a compiler and you change MAX_COMPS_IN_SCAN. */ #ifndef NO_STRUCT_ASSIGN #define ASSIGN_STATE(dest,src) ((dest) = (src)) #else #if MAX_COMPS_IN_SCAN == 4 #define ASSIGN_STATE(dest,src) \ ((dest).EOBRUN = (src).EOBRUN, \ (dest).last_dc_val[0] = (src).last_dc_val[0], \ (dest).last_dc_val[1] = (src).last_dc_val[1], \ (dest).last_dc_val[2] = (src).last_dc_val[2], \ (dest).last_dc_val[3] = (src).last_dc_val[3]) #endif #endif typedef struct { struct jpeg_entropy_decoder pub; /* public fields */ /* These fields are loaded into local variables at start of each MCU. * In case of suspension, we exit WITHOUT updating them. */ bitread_perm_state bitstate; /* Bit buffer at start of MCU */ savable_state saved; /* Other state at start of MCU */ /* These fields are NOT loaded into local working state. */ unsigned int restarts_to_go; /* MCUs left in this restart interval */ /* Pointers to derived tables (these workspaces have image lifespan) */ d_derived_tbl * derived_tbls[NUM_HUFF_TBLS]; d_derived_tbl * ac_derived_tbl; /* active table during an AC scan */ } phuff_entropy_decoder; typedef phuff_entropy_decoder * phuff_entropy_ptr; /* Forward declarations */ METHODDEF(boolean) decode_mcu_DC_first JPP((j_decompress_ptr cinfo, JBLOCKROW *MCU_data)); METHODDEF(boolean) decode_mcu_AC_first JPP((j_decompress_ptr cinfo, JBLOCKROW *MCU_data)); METHODDEF(boolean) decode_mcu_DC_refine JPP((j_decompress_ptr cinfo, JBLOCKROW *MCU_data)); METHODDEF(boolean) decode_mcu_AC_refine JPP((j_decompress_ptr cinfo, JBLOCKROW *MCU_data)); /* * Initialize for a Huffman-compressed scan. */ METHODDEF(void) start_pass_phuff_decoder (j_decompress_ptr cinfo) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; boolean is_DC_band, bad; int ci, coefi, tbl; int *coef_bit_ptr; jpeg_component_info * compptr; is_DC_band = (cinfo->Ss == 0); /* Validate scan parameters */ bad = FALSE; if (is_DC_band) { if (cinfo->Se != 0) bad = TRUE; } else { /* need not check Ss/Se < 0 since they came from unsigned bytes */ if (cinfo->Ss > cinfo->Se || cinfo->Se >= DCTSIZE2) bad = TRUE; /* AC scans may have only one component */ if (cinfo->comps_in_scan != 1) bad = TRUE; } if (cinfo->Ah != 0) { /* Successive approximation refinement scan: must have Al = Ah-1. */ if (cinfo->Al != cinfo->Ah-1) bad = TRUE; } if (cinfo->Al > 13) /* need not check for < 0 */ bad = TRUE; /* Arguably the maximum Al value should be less than 13 for 8-bit precision, * but the spec doesn't say so, and we try to be liberal about what we * accept. Note: large Al values could result in out-of-range DC * coefficients during early scans, leading to bizarre displays due to * overflows in the IDCT math. But we won't crash. */ if (bad) ERREXIT4(cinfo, JERR_BAD_PROGRESSION, cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al); /* Update progression status, and verify that scan order is legal. * Note that inter-scan inconsistencies are treated as warnings * not fatal errors ... not clear if this is right way to behave. */ for (ci = 0; ci < cinfo->comps_in_scan; ci++) { int cindex = cinfo->cur_comp_info[ci]->component_index; coef_bit_ptr = & cinfo->coef_bits[cindex][0]; if (!is_DC_band && coef_bit_ptr[0] < 0) /* AC without prior DC scan */ WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0); for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) { int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi]; if (cinfo->Ah != expected) WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi); coef_bit_ptr[coefi] = cinfo->Al; } } /* Select MCU decoding routine */ if (cinfo->Ah == 0) { if (is_DC_band) entropy->pub.decode_mcu = decode_mcu_DC_first; else entropy->pub.decode_mcu = decode_mcu_AC_first; } else { if (is_DC_band) entropy->pub.decode_mcu = decode_mcu_DC_refine; else entropy->pub.decode_mcu = decode_mcu_AC_refine; } for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; /* Make sure requested tables are present, and compute derived tables. * We may build same derived table more than once, but it's not expensive. */ if (is_DC_band) { if (cinfo->Ah == 0) { /* DC refinement needs no table */ tbl = compptr->dc_tbl_no; jpeg_make_d_derived_tbl(cinfo, TRUE, tbl, & entropy->derived_tbls[tbl]); } } else { tbl = compptr->ac_tbl_no; jpeg_make_d_derived_tbl(cinfo, FALSE, tbl, & entropy->derived_tbls[tbl]); /* remember the single active table */ entropy->ac_derived_tbl = entropy->derived_tbls[tbl]; } /* Initialize DC predictions to 0 */ entropy->saved.last_dc_val[ci] = 0; } /* Initialize bitread state variables */ entropy->bitstate.bits_left = 0; entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */ entropy->pub.insufficient_data = FALSE; /* Initialize private state variables */ entropy->saved.EOBRUN = 0; /* Initialize restart counter */ entropy->restarts_to_go = cinfo->restart_interval; } /* * Figure F.12: extend sign bit. * On some machines, a shift and add will be faster than a table lookup. */ #ifdef AVOID_TABLES #define HUFF_EXTEND(x,s) ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x)) #else #define HUFF_EXTEND(x,s) ((x) < extend_test[s] ? (x) + extend_offset[s] : (x)) static const int extend_test[16] = /* entry n is 2**(n-1) */ { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 }; static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */ { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1, ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1, ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1, ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 }; #endif /* AVOID_TABLES */ /* * Check for a restart marker & resynchronize decoder. * Returns FALSE if must suspend. */ LOCAL(boolean) process_restart (j_decompress_ptr cinfo) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; int ci; /* Throw away any unused bits remaining in bit buffer; */ /* include any full bytes in next_marker's count of discarded bytes */ cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8; entropy->bitstate.bits_left = 0; /* Advance past the RSTn marker */ if (! (*cinfo->marker->read_restart_marker) (cinfo)) return FALSE; /* Re-initialize DC predictions to 0 */ for (ci = 0; ci < cinfo->comps_in_scan; ci++) entropy->saved.last_dc_val[ci] = 0; /* Re-init EOB run count, too */ entropy->saved.EOBRUN = 0; /* Reset restart counter */ entropy->restarts_to_go = cinfo->restart_interval; /* Reset out-of-data flag, unless read_restart_marker left us smack up * against a marker. In that case we will end up treating the next data * segment as empty, and we can avoid producing bogus output pixels by * leaving the flag set. */ if (cinfo->unread_marker == 0) entropy->pub.insufficient_data = FALSE; return TRUE; } /* * Huffman MCU decoding. * Each of these routines decodes and returns one MCU's worth of * Huffman-compressed coefficients. * The coefficients are reordered from zigzag order into natural array order, * but are not dequantized. * * The i'th block of the MCU is stored into the block pointed to by * MCU_data[i]. WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER. * * We return FALSE if data source requested suspension. In that case no * changes have been made to permanent state. (Exception: some output * coefficients may already have been assigned. This is harmless for * spectral selection, since we'll just re-assign them on the next call. * Successive approximation AC refinement has to be more careful, however.) */ /* * MCU decoding for DC initial scan (either spectral selection, * or first pass of successive approximation). */ METHODDEF(boolean) decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; int Al = cinfo->Al; register int s, r; int blkn, ci; JBLOCKROW block; BITREAD_STATE_VARS; savable_state state; d_derived_tbl * tbl; jpeg_component_info * compptr; /* Process restart marker if needed; may have to suspend */ if (cinfo->restart_interval) { if (entropy->restarts_to_go == 0) if (! process_restart(cinfo)) return FALSE; } /* If we've run out of data, just leave the MCU set to zeroes. * This way, we return uniform gray for the remainder of the segment. */ if (! entropy->pub.insufficient_data) { /* Load up working state */ BITREAD_LOAD_STATE(cinfo,entropy->bitstate); ASSIGN_STATE(state, entropy->saved); /* Outer loop handles each block in the MCU */ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { block = MCU_data[blkn]; ci = cinfo->MCU_membership[blkn]; compptr = cinfo->cur_comp_info[ci]; tbl = entropy->derived_tbls[compptr->dc_tbl_no]; /* Decode a single block's worth of coefficients */ /* Section F.2.2.1: decode the DC coefficient difference */ HUFF_DECODE(s, br_state, tbl, return FALSE, label1); if (s) { CHECK_BIT_BUFFER(br_state, s, return FALSE); r = GET_BITS(s); s = HUFF_EXTEND(r, s); } /* Convert DC difference to actual value, update last_dc_val */ s += state.last_dc_val[ci]; state.last_dc_val[ci] = s; /* Scale and output the coefficient (assumes jpeg_natural_order[0]=0) */ (*block)[0] = (JCOEF) (s << Al); } /* Completed MCU, so update state */ BITREAD_SAVE_STATE(cinfo,entropy->bitstate); ASSIGN_STATE(entropy->saved, state); } /* Account for restart interval (no-op if not using restarts) */ entropy->restarts_to_go--; return TRUE; } /* * MCU decoding for AC initial scan (either spectral selection, * or first pass of successive approximation). */ METHODDEF(boolean) decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; int Se = cinfo->Se; int Al = cinfo->Al; register int s, k, r; unsigned int EOBRUN; JBLOCKROW block; BITREAD_STATE_VARS; d_derived_tbl * tbl; /* Process restart marker if needed; may have to suspend */ if (cinfo->restart_interval) { if (entropy->restarts_to_go == 0) if (! process_restart(cinfo)) return FALSE; } /* If we've run out of data, just leave the MCU set to zeroes. * This way, we return uniform gray for the remainder of the segment. */ if (! entropy->pub.insufficient_data) { /* Load up working state. * We can avoid loading/saving bitread state if in an EOB run. */ EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */ /* There is always only one block per MCU */ if (EOBRUN > 0) /* if it's a band of zeroes... */ EOBRUN--; /* ...process it now (we do nothing) */ else { BITREAD_LOAD_STATE(cinfo,entropy->bitstate); block = MCU_data[0]; tbl = entropy->ac_derived_tbl; for (k = cinfo->Ss; k <= Se; k++) { HUFF_DECODE(s, br_state, tbl, return FALSE, label2); r = s >> 4; s &= 15; if (s) { k += r; CHECK_BIT_BUFFER(br_state, s, return FALSE); r = GET_BITS(s); s = HUFF_EXTEND(r, s); /* Scale and output coefficient in natural (dezigzagged) order */ (*block)[jpeg_natural_order[k]] = (JCOEF) (s << Al); } else { if (r == 15) { /* ZRL */ k += 15; /* skip 15 zeroes in band */ } else { /* EOBr, run length is 2^r + appended bits */ EOBRUN = 1 << r; if (r) { /* EOBr, r > 0 */ CHECK_BIT_BUFFER(br_state, r, return FALSE); r = GET_BITS(r); EOBRUN += r; } EOBRUN--; /* this band is processed at this moment */ break; /* force end-of-band */ } } } BITREAD_SAVE_STATE(cinfo,entropy->bitstate); } /* Completed MCU, so update state */ entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */ } /* Account for restart interval (no-op if not using restarts) */ entropy->restarts_to_go--; return TRUE; } /* * MCU decoding for DC successive approximation refinement scan. * Note: we assume such scans can be multi-component, although the spec * is not very clear on the point. */ METHODDEF(boolean) decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; int p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */ int blkn; JBLOCKROW block; BITREAD_STATE_VARS; /* Process restart marker if needed; may have to suspend */ if (cinfo->restart_interval) { if (entropy->restarts_to_go == 0) if (! process_restart(cinfo)) return FALSE; } /* Not worth the cycles to check insufficient_data here, * since we will not change the data anyway if we read zeroes. */ /* Load up working state */ BITREAD_LOAD_STATE(cinfo,entropy->bitstate); /* Outer loop handles each block in the MCU */ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { block = MCU_data[blkn]; /* Encoded data is simply the next bit of the two's-complement DC value */ CHECK_BIT_BUFFER(br_state, 1, return FALSE); if (GET_BITS(1)) (*block)[0] |= p1; /* Note: since we use |=, repeating the assignment later is safe */ } /* Completed MCU, so update state */ BITREAD_SAVE_STATE(cinfo,entropy->bitstate); /* Account for restart interval (no-op if not using restarts) */ entropy->restarts_to_go--; return TRUE; } /* * MCU decoding for AC successive approximation refinement scan. */ METHODDEF(boolean) decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; int Se = cinfo->Se; int p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */ int m1 = (-1) << cinfo->Al; /* -1 in the bit position being coded */ register int s, k, r; unsigned int EOBRUN; JBLOCKROW block; JCOEFPTR thiscoef; BITREAD_STATE_VARS; d_derived_tbl * tbl; int num_newnz; int newnz_pos[DCTSIZE2]; /* Process restart marker if needed; may have to suspend */ if (cinfo->restart_interval) { if (entropy->restarts_to_go == 0) if (! process_restart(cinfo)) return FALSE; } /* If we've run out of data, don't modify the MCU. */ if (! entropy->pub.insufficient_data) { /* Load up working state */ BITREAD_LOAD_STATE(cinfo,entropy->bitstate); EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */ /* There is always only one block per MCU */ block = MCU_data[0]; tbl = entropy->ac_derived_tbl; /* If we are forced to suspend, we must undo the assignments to any newly * nonzero coefficients in the block, because otherwise we'd get confused * next time about which coefficients were already nonzero. * But we need not undo addition of bits to already-nonzero coefficients; * instead, we can test the current bit to see if we already did it. */ num_newnz = 0; /* initialize coefficient loop counter to start of band */ k = cinfo->Ss; if (EOBRUN == 0) { for (; k <= Se; k++) { HUFF_DECODE(s, br_state, tbl, goto undoit, label3); r = s >> 4; s &= 15; if (s) { if (s != 1) /* size of new coef should always be 1 */ WARNMS(cinfo, JWRN_HUFF_BAD_CODE); CHECK_BIT_BUFFER(br_state, 1, goto undoit); if (GET_BITS(1)) s = p1; /* newly nonzero coef is positive */ else s = m1; /* newly nonzero coef is negative */ } else { if (r != 15) { EOBRUN = 1 << r; /* EOBr, run length is 2^r + appended bits */ if (r) { CHECK_BIT_BUFFER(br_state, r, goto undoit); r = GET_BITS(r); EOBRUN += r; } break; /* rest of block is handled by EOB logic */ } /* note s = 0 for processing ZRL */ } /* Advance over already-nonzero coefs and r still-zero coefs, * appending correction bits to the nonzeroes. A correction bit is 1 * if the absolute value of the coefficient must be increased. */ do { thiscoef = *block + jpeg_natural_order[k]; if (*thiscoef != 0) { CHECK_BIT_BUFFER(br_state, 1, goto undoit); if (GET_BITS(1)) { if ((*thiscoef & p1) == 0) { /* do nothing if already set it */ if (*thiscoef >= 0) *thiscoef += p1; else *thiscoef += m1; } } } else { if (--r < 0) break; /* reached target zero coefficient */ } k++; } while (k <= Se); if (s) { int pos = jpeg_natural_order[k]; /* Output newly nonzero coefficient */ (*block)[pos] = (JCOEF) s; /* Remember its position in case we have to suspend */ newnz_pos[num_newnz++] = pos; } } } if (EOBRUN > 0) { /* Scan any remaining coefficient positions after the end-of-band * (the last newly nonzero coefficient, if any). Append a correction * bit to each already-nonzero coefficient. A correction bit is 1 * if the absolute value of the coefficient must be increased. */ for (; k <= Se; k++) { thiscoef = *block + jpeg_natural_order[k]; if (*thiscoef != 0) { CHECK_BIT_BUFFER(br_state, 1, goto undoit); if (GET_BITS(1)) { if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */ if (*thiscoef >= 0) *thiscoef += p1; else *thiscoef += m1; } } } } /* Count one block completed in EOB run */ EOBRUN--; } /* Completed MCU, so update state */ BITREAD_SAVE_STATE(cinfo,entropy->bitstate); entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */ } /* Account for restart interval (no-op if not using restarts) */ entropy->restarts_to_go--; return TRUE; undoit: /* Re-zero any output coefficients that we made newly nonzero */ while (num_newnz > 0) (*block)[newnz_pos[--num_newnz]] = 0; return FALSE; } /* * Module initialization routine for progressive Huffman entropy decoding. */ GLOBAL(void) jinit_phuff_decoder (j_decompress_ptr cinfo) { phuff_entropy_ptr entropy; int *coef_bit_ptr; int ci, i; entropy = (phuff_entropy_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(phuff_entropy_decoder)); cinfo->entropy = (struct jpeg_entropy_decoder *) entropy; entropy->pub.start_pass = start_pass_phuff_decoder; /* Mark derived tables unallocated */ for (i = 0; i < NUM_HUFF_TBLS; i++) { entropy->derived_tbls[i] = NULL; } /* Create progression status table */ cinfo->coef_bits = (int (*)[DCTSIZE2]) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, cinfo->num_components*DCTSIZE2*SIZEOF(int)); coef_bit_ptr = & cinfo->coef_bits[0][0]; for (ci = 0; ci < cinfo->num_components; ci++) for (i = 0; i < DCTSIZE2; i++) *coef_bit_ptr++ = -1; } #endif /* D_PROGRESSIVE_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/JINCLUDE.H0000755000175000017500000000735107535143454014153 0ustar /* * jinclude.h * * Copyright (C) 1991-1994, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file exists to provide a single place to fix any problems with * including the wrong system include files. (Common problems are taken * care of by the standard jconfig symbols, but on really weird systems * you may have to edit this file.) * * NOTE: this file is NOT intended to be included by applications using the * JPEG library. Most applications need only include jpeglib.h. */ /* Include auto-config file to find out which system include files we need. */ #include "jconfig.h" /* auto configuration options */ #define JCONFIG_INCLUDED /* so that jpeglib.h doesn't do it again */ /* * We need the NULL macro and size_t typedef. * On an ANSI-conforming system it is sufficient to include . * Otherwise, we get them from or ; we may have to * pull in as well. * Note that the core JPEG library does not require ; * only the default error handler and data source/destination modules do. * But we must pull it in because of the references to FILE in jpeglib.h. * You can remove those references if you want to compile without . */ #ifdef HAVE_STDDEF_H #include #endif #ifdef HAVE_STDLIB_H #include #endif #ifdef NEED_SYS_TYPES_H #include #endif #include /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif /* * We need memory copying and zeroing functions, plus strncpy(). * ANSI and System V implementations declare these in . * BSD doesn't have the mem() functions, but it does have bcopy()/bzero(). * Some systems may declare memset and memcpy in . * * NOTE: we assume the size parameters to these functions are of type size_t. * Change the casts in these macros if not! */ #ifdef NEED_BSD_STRINGS #include #define MEMZERO(target,size) bzero((void *)(target), (size_t)(size)) #define MEMCOPY(dest,src,size) bcopy((const void *)(src), (void *)(dest), (size_t)(size)) #else /* not BSD, assume ANSI/SysV string lib */ #include #define MEMZERO(target,size) memset((void *)(target), 0, (size_t)(size)) #define MEMCOPY(dest,src,size) memcpy((void *)(dest), (const void *)(src), (size_t)(size)) #endif /* * In ANSI C, and indeed any rational implementation, size_t is also the * type returned by sizeof(). However, it seems there are some irrational * implementations out there, in which sizeof() returns an int even though * size_t is defined as long or unsigned long. To ensure consistent results * we always use this SIZEOF() macro in place of using sizeof() directly. */ #define SIZEOF(object) ((size_t) sizeof(object)) /* * The modules that use fread() and fwrite() always invoke them through * these macros. On some systems you may need to twiddle the argument casts. * CAUTION: argument order is different from underlying functions! */ #define JFREAD(file,buf,sizeofbuf) \ ((size_t) Papy3FRead (file, (PapyULong *) &sizeofbuf, 1L, (void *) buf)) /* ((size_t) fread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))*/ #define JFWRITE(file,buf,sizeofbuf) \ ((size_t) Papy3FWrite ((PAPY_FILE) file, (PapyULong *) &sizeofbuf, 1L, (void *) buf)) /* ((size_t) fwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))*/ Papyrus3/JpegDir/JpgLossy/structure.doc0000755000175000017500000014715407535143454015402 0ustar IJG JPEG LIBRARY: SYSTEM ARCHITECTURE Copyright (C) 1991-1995, Thomas G. Lane. This file is part of the Independent JPEG Group's software. For conditions of distribution and use, see the accompanying README file. This file provides an overview of the architecture of the IJG JPEG software; that is, the functions of the various modules in the system and the interfaces between modules. For more precise details about any data structure or calling convention, see the include files and comments in the source code. We assume that the reader is already somewhat familiar with the JPEG standard. The README file includes references for learning about JPEG. The file libjpeg.doc describes the library from the viewpoint of an application programmer using the library; it's best to read that file before this one. Also, the file coderules.doc describes the coding style conventions we use. In this document, JPEG-specific terminology follows the JPEG standard: A "component" means a color channel, e.g., Red or Luminance. A "sample" is a single component value (i.e., one number in the image data). A "coefficient" is a frequency coefficient (a DCT transform output number). A "block" is an 8x8 group of samples or coefficients. An "MCU" (minimum coded unit) is an interleaved set of blocks of size determined by the sampling factors, or a single block in a noninterleaved scan. We do not use the terms "pixel" and "sample" interchangeably. When we say pixel, we mean an element of the full-size image, while a sample is an element of the downsampled image. Thus the number of samples may vary across components while the number of pixels does not. (This terminology is not used rigorously throughout the code, but it is used in places where confusion would otherwise result.) *** System features *** The IJG distribution contains two parts: * A subroutine library for JPEG compression and decompression. * cjpeg/djpeg, two sample applications that use the library to transform JFIF JPEG files to and from several other image formats. cjpeg/djpeg are of no great intellectual complexity: they merely add a simple command-line user interface and I/O routines for several uncompressed image formats. This document concentrates on the library itself. We desire the library to be capable of supporting all JPEG baseline, extended sequential, and progressive DCT processes. Hierarchical processes are not supported. The library does not support the lossless (spatial) JPEG process. Lossless JPEG shares little or no code with lossy JPEG, and would normally be used without the extensive pre- and post-processing provided by this library. We feel that lossless JPEG is better handled by a separate library. Within these limits, any set of compression parameters allowed by the JPEG spec should be readable for decompression. (We can be more restrictive about what formats we can generate.) Although the system design allows for all parameter values, some uncommon settings are not yet implemented and may never be; nonintegral sampling ratios are the prime example. Furthermore, we treat 8-bit vs. 12-bit data precision as a compile-time switch, not a run-time option, because most machines can store 8-bit pixels much more compactly than 12-bit. For legal reasons, JPEG arithmetic coding is not currently supported, but extending the library to include it would be straightforward. By itself, the library handles only interchange JPEG datastreams --- in particular the widely used JFIF file format. The library can be used by surrounding code to process interchange or abbreviated JPEG datastreams that are embedded in more complex file formats. (For example, libtiff uses this library to implement JPEG compression within the TIFF file format.) The library includes a substantial amount of code that is not covered by the JPEG standard but is necessary for typical applications of JPEG. These functions preprocess the image before JPEG compression or postprocess it after decompression. They include colorspace conversion, downsampling/upsampling, and color quantization. This code can be omitted if not needed. A wide range of quality vs. speed tradeoffs are possible in JPEG processing, and even more so in decompression postprocessing. The decompression library provides multiple implementations that cover most of the useful tradeoffs, ranging from very-high-quality down to fast-preview operation. On the compression side we have generally not provided low-quality choices, since compression is normally less time-critical. It should be understood that the low-quality modes may not meet the JPEG standard's accuracy requirements; nonetheless, they are useful for viewers. *** Portability issues *** Portability is an essential requirement for the library. The key portability issues that show up at the level of system architecture are: 1. Memory usage. We want the code to be able to run on PC-class machines with limited memory. Images should therefore be processed sequentially (in strips), to avoid holding the whole image in memory at once. Where a full-image buffer is necessary, we should be able to use either virtual memory or temporary files. 2. Near/far pointer distinction. To run efficiently on 80x86 machines, the code should distinguish "small" objects (kept in near data space) from "large" ones (kept in far data space). This is an annoying restriction, but fortunately it does not impact code quality for less brain-damaged machines, and the source code clutter turns out to be minimal with sufficient use of pointer typedefs. 3. Data precision. We assume that "char" is at least 8 bits, "short" and "int" at least 16, "long" at least 32. The code will work fine with larger data sizes, although memory may be used inefficiently in some cases. However, the JPEG compressed datastream must ultimately appear on external storage as a sequence of 8-bit bytes if it is to conform to the standard. This may pose a problem on machines where char is wider than 8 bits. The library represents compressed data as an array of values of typedef JOCTET. If no data type exactly 8 bits wide is available, custom data source and data destination modules must be written to unpack and pack the chosen JOCTET datatype into 8-bit external representation. *** System overview *** The compressor and decompressor are each divided into two main sections: the JPEG compressor or decompressor proper, and the preprocessing or postprocessing functions. The interface between these two sections is the image data that the official JPEG spec regards as its input or output: this data is in the colorspace to be used for compression, and it is downsampled to the sampling factors to be used. The preprocessing and postprocessing steps are responsible for converting a normal image representation to or from this form. (Those few applications that want to deal with YCbCr downsampled data can skip the preprocessing or postprocessing step.) Looking more closely, the compressor library contains the following main elements: Preprocessing: * Color space conversion (e.g., RGB to YCbCr). * Edge expansion and downsampling. Optionally, this step can do simple smoothing --- this is often helpful for low-quality source data. JPEG proper: * MCU assembly, DCT, quantization. * Entropy coding (sequential or progressive, Huffman or arithmetic). In addition to these modules we need overall control, marker generation, and support code (memory management & error handling). There is also a module responsible for physically writing the output data --- typically this is just an interface to fwrite(), but some applications may need to do something else with the data. The decompressor library contains the following main elements: JPEG proper: * Entropy decoding (sequential or progressive, Huffman or arithmetic). * Dequantization, inverse DCT, MCU disassembly. Postprocessing: * Upsampling. Optionally, this step may be able to do more general rescaling of the image. * Color space conversion (e.g., YCbCr to RGB). This step may also provide gamma adjustment [ currently it does not ]. * Optional color quantization (e.g., reduction to 256 colors). * Optional color precision reduction (e.g., 24-bit to 15-bit color). [This feature is not currently implemented.] We also need overall control, marker parsing, and a data source module. The support code (memory management & error handling) can be shared with the compression half of the library. There may be several implementations of each of these elements, particularly in the decompressor, where a wide range of speed/quality tradeoffs is very useful. It must be understood that some of the best speedups involve merging adjacent steps in the pipeline. For example, upsampling, color space conversion, and color quantization might all be done at once when using a low-quality ordered-dither technique. The system architecture is designed to allow such merging where appropriate. Note: it is convenient to regard edge expansion (padding to block boundaries) as a preprocessing/postprocessing function, even though the JPEG spec includes it in compression/decompression. We do this because downsampling/upsampling can be simplified a little if they work on padded data: it's not necessary to have special cases at the right and bottom edges. Therefore the interface buffer is always an integral number of blocks wide and high, and we expect compression preprocessing to pad the source data properly. Padding will occur only to the next block (8-sample) boundary. In an interleaved-scan situation, additional dummy blocks may be used to fill out MCUs, but the MCU assembly and disassembly logic will create or discard these blocks internally. (This is advantageous for speed reasons, since we avoid DCTing the dummy blocks. It also permits a small reduction in file size, because the compressor can choose dummy block contents so as to minimize their size in compressed form. Finally, it makes the interface buffer specification independent of whether the file is actually interleaved or not.) Applications that wish to deal directly with the downsampled data must provide similar buffering and padding for odd-sized images. *** Poor man's object-oriented programming *** It should be clear by now that we have a lot of quasi-independent processing steps, many of which have several possible behaviors. To avoid cluttering the code with lots of switch statements, we use a simple form of object-style programming to separate out the different possibilities. For example, two different color quantization algorithms could be implemented as two separate modules that present the same external interface; at runtime, the calling code will access the proper module indirectly through an "object". We can get the limited features we need while staying within portable C. The basic tool is a function pointer. An "object" is just a struct containing one or more function pointer fields, each of which corresponds to a method name in real object-oriented languages. During initialization we fill in the function pointers with references to whichever module we have determined we need to use in this run. Then invocation of the module is done by indirecting through a function pointer; on most machines this is no more expensive than a switch statement, which would be the only other way of making the required run-time choice. The really significant benefit, of course, is keeping the source code clean and well structured. We can also arrange to have private storage that varies between different implementations of the same kind of object. We do this by making all the module-specific object structs be separately allocated entities, which will be accessed via pointers in the master compression or decompression struct. The "public" fields or methods for a given kind of object are specified by a commonly known struct. But a module's initialization code can allocate a larger struct that contains the common struct as its first member, plus additional private fields. With appropriate pointer casting, the module's internal functions can access these private fields. (For a simple example, see jdatadst.c, which implements the external interface specified by struct jpeg_destination_mgr, but adds extra fields.) (Of course this would all be a lot easier if we were using C++, but we are not yet prepared to assume that everyone has a C++ compiler.) An important benefit of this scheme is that it is easy to provide multiple versions of any method, each tuned to a particular case. While a lot of precalculation might be done to select an optimal implementation of a method, the cost per invocation is constant. For example, the upsampling step might have a "generic" method, plus one or more "hardwired" methods for the most popular sampling factors; the hardwired methods would be faster because they'd use straight-line code instead of for-loops. The cost to determine which method to use is paid only once, at startup, and the selection criteria are hidden from the callers of the method. This plan differs a little bit from usual object-oriented structures, in that only one instance of each object class will exist during execution. The reason for having the class structure is that on different runs we may create different instances (choose to execute different modules). You can think of the term "method" as denoting the common interface presented by a particular set of interchangeable functions, and "object" as denoting a group of related methods, or the total shared interface behavior of a group of modules. *** Overall control structure *** We previously mentioned the need for overall control logic in the compression and decompression libraries. In IJG implementations prior to v5, overall control was mostly provided by "pipeline control" modules, which proved to be large, unwieldy, and hard to understand. To improve the situation, the control logic has been subdivided into multiple modules. The control modules consist of: 1. Master control for module selection and initialization. This has two responsibilities: 1A. Startup initialization at the beginning of image processing. The individual processing modules to be used in this run are selected and given initialization calls. 1B. Per-pass control. This determines how many passes will be performed and calls each active processing module to configure itself appropriately at the beginning of each pass. End-of-pass processing, where necessary, is also invoked from the master control module. Method selection is partially distributed, in that a particular processing module may contain several possible implementations of a particular method, which it will select among when given its initialization call. The master control code need only be concerned with decisions that affect more than one module. 2. Data buffering control. A separate control module exists for each inter-processing-step data buffer. This module is responsible for invoking the processing steps that write or read that data buffer. Each buffer controller sees the world as follows: input data => processing step A => buffer => processing step B => output data | | | ------------------ controller ------------------ The controller knows the dataflow requirements of steps A and B: how much data they want to accept in one chunk and how much they output in one chunk. Its function is to manage its buffer and call A and B at the proper times. A data buffer control module may itself be viewed as a processing step by a higher-level control module; thus the control modules form a binary tree with elementary processing steps at the leaves of the tree. The control modules are objects. A considerable amount of flexibility can be had by replacing implementations of a control module. For example: * Merging of adjacent steps in the pipeline is done by replacing a control module and its pair of processing-step modules with a single processing- step module. (Hence the possible merges are determined by the tree of control modules.) * In some processing modes, a given interstep buffer need only be a "strip" buffer large enough to accommodate the desired data chunk sizes. In other modes, a full-image buffer is needed and several passes are required. The control module determines which kind of buffer is used and manipulates virtual array buffers as needed. One or both processing steps may be unaware of the multi-pass behavior. In theory, we might be able to make all of the data buffer controllers interchangeable and provide just one set of implementations for all. In practice, each one contains considerable special-case processing for its particular job. The buffer controller concept should be regarded as an overall system structuring principle, not as a complete description of the task performed by any one controller. *** Compression object structure *** Here is a sketch of the logical structure of the JPEG compression library: |-- Colorspace conversion |-- Preprocessing controller --| | |-- Downsampling Main controller --| | |-- Forward DCT, quantize |-- Coefficient controller --| |-- Entropy encoding This sketch also describes the flow of control (subroutine calls) during typical image data processing. Each of the components shown in the diagram is an "object" which may have several different implementations available. One or more source code files contain the actual implementation(s) of each object. The objects shown above are: * Main controller: buffer controller for the subsampled-data buffer, which holds the preprocessed input data. This controller invokes preprocessing to fill the subsampled-data buffer, and JPEG compression to empty it. There is usually no need for a full-image buffer here; a strip buffer is adequate. * Preprocessing controller: buffer controller for the downsampling input data buffer, which lies between colorspace conversion and downsampling. Note that a unified conversion/downsampling module would probably replace this controller entirely. * Colorspace conversion: converts application image data into the desired JPEG color space; also changes the data from pixel-interleaved layout to separate component planes. Processes one pixel row at a time. * Downsampling: performs reduction of chroma components as required. Optionally may perform pixel-level smoothing as well. Processes a "row group" at a time, where a row group is defined as Vmax pixel rows of each component before downsampling, and Vk sample rows afterwards (remember Vk differs across components). Some downsampling or smoothing algorithms may require context rows above and below the current row group; the preprocessing controller is responsible for supplying these rows via proper buffering. The downsampler is responsible for edge expansion at the right edge (i.e., extending each sample row to a multiple of 8 samples); but the preprocessing controller is responsible for vertical edge expansion (i.e., duplicating the bottom sample row as needed to make a multiple of 8 rows). * Coefficient controller: buffer controller for the DCT-coefficient data. This controller handles MCU assembly, including insertion of dummy DCT blocks when needed at the right or bottom edge. When performing Huffman-code optimization or emitting a multiscan JPEG file, this controller is responsible for buffering the full image. The equivalent of one fully interleaved MCU row of subsampled data is processed per call, even when the JPEG file is noninterleaved. * Forward DCT and quantization: Perform DCT, quantize, and emit coefficients. Works on one or more DCT blocks at a time. (Note: the coefficients are now emitted in normal array order, which the entropy encoder is expected to convert to zigzag order as necessary. Prior versions of the IJG code did the conversion to zigzag order within the quantization step.) * Entropy encoding: Perform Huffman or arithmetic entropy coding and emit the coded data to the data destination module. Works on one MCU per call. For progressive JPEG, the same DCT blocks are fed to the entropy coder during each pass, and the coder must emit the appropriate subset of coefficients. In addition to the above objects, the compression library includes these objects: * Master control: determines the number of passes required, controls overall and per-pass initialization of the other modules. * Marker writing: generates JPEG markers (except for RSTn, which is emitted by the entropy encoder when needed). * Data destination manager: writes the output JPEG datastream to its final destination (e.g., a file). The destination manager supplied with the library knows how to write to a stdio stream; for other behaviors, the surrounding application may provide its own destination manager. * Memory manager: allocates and releases memory, controls virtual arrays (with backing store management, where required). * Error handler: performs formatting and output of error and trace messages; determines handling of nonfatal errors. The surrounding application may override some or all of this object's methods to change error handling. * Progress monitor: supports output of "percent-done" progress reports. This object represents an optional callback to the surrounding application: if wanted, it must be supplied by the application. The error handler, destination manager, and progress monitor objects are defined as separate objects in order to simplify application-specific customization of the JPEG library. A surrounding application may override individual methods or supply its own all-new implementation of one of these objects. The object interfaces for these objects are therefore treated as part of the application interface of the library, whereas the other objects are internal to the library. The error handler and memory manager are shared by JPEG compression and decompression; the progress monitor, if used, may be shared as well. *** Decompression object structure *** Here is a sketch of the logical structure of the JPEG decompression library: |-- Entropy decoding |-- Coefficient controller --| | |-- Dequantize, Inverse DCT Main controller --| | |-- Upsampling |-- Postprocessing controller --| |-- Colorspace conversion |-- Color quantization |-- Color precision reduction As before, this diagram also represents typical control flow. The objects shown are: * Main controller: buffer controller for the subsampled-data buffer, which holds the output of JPEG decompression proper. This controller's primary task is to feed the postprocessing procedure. Some upsampling algorithms may require context rows above and below the current row group; when this is true, the main controller is responsible for managing its buffer so as to make context rows available. In the current design, the main buffer is always a strip buffer; a full-image buffer is never required. * Coefficient controller: buffer controller for the DCT-coefficient data. This controller handles MCU disassembly, including deletion of any dummy DCT blocks at the right or bottom edge. When reading a multiscan JPEG file, this controller is responsible for buffering the full image. (Buffering DCT coefficients, rather than samples, is necessary to support progressive JPEG.) The equivalent of one fully interleaved MCU row of subsampled data is processed per call, even when the source JPEG file is noninterleaved. * Entropy decoding: Read coded data from the data source module and perform Huffman or arithmetic entropy decoding. Works on one MCU per call. For progressive JPEG decoding, the coefficient controller supplies the prior coefficients of each MCU (initially all zeroes), which the entropy decoder modifies in each scan. * Dequantization and inverse DCT: like it says. Note that the coefficients buffered by the coefficient controller have NOT been dequantized; we merge dequantization and inverse DCT into a single step for speed reasons. When scaled-down output is asked for, simplified DCT algorithms may be used that emit only 1x1, 2x2, or 4x4 samples per DCT block, not the full 8x8. Works on one DCT block at a time. * Postprocessing controller: buffer controller for the color quantization input buffer, when quantization is in use. (Without quantization, this controller just calls the upsampler.) For two-pass quantization, this controller is responsible for buffering the full-image data. * Upsampling: restores chroma components to full size. (May support more general output rescaling, too. Note that if undersized DCT outputs have been emitted by the DCT module, this module must adjust so that properly sized outputs are created.) Works on one row group at a time. This module also calls the color conversion module, so its top level is effectively a buffer controller for the upsampling->color conversion buffer. However, in all but the highest-quality operating modes, upsampling and color conversion are likely to be merged into a single step. * Colorspace conversion: convert from JPEG color space to output color space, and change data layout from separate component planes to pixel-interleaved. Works on one pixel row at a time. * Color quantization: reduce the data to colormapped form, using either an externally specified colormap or an internally generated one. This module is not used for full-color output. Works on one pixel row at a time; may require two passes to generate a color map. Note that the output will always be a single component representing colormap indexes. In the current design, the output values are JSAMPLEs, so an 8-bit compilation cannot quantize to more than 256 colors. This is unlikely to be a problem in practice. * Color reduction: this module handles color precision reduction, e.g., generating 15-bit color (5 bits/primary) from JPEG's 24-bit output. Not quite clear yet how this should be handled... should we merge it with colorspace conversion??? Note that some high-speed operating modes might condense the entire postprocessing sequence to a single module (upsample, color convert, and quantize in one step). In addition to the above objects, the decompression library includes these objects: * Master control: determines the number of passes required, controls overall and per-pass initialization of the other modules. This is subdivided into input and output control: jdinput.c controls only input-side processing, while jdmaster.c handles overall initialization and output-side control. * Marker reading: decodes JPEG markers (except for RSTn). * Data source manager: supplies the input JPEG datastream. The source manager supplied with the library knows how to read from a stdio stream; for other behaviors, the surrounding application may provide its own source manager. * Memory manager: same as for compression library. * Error handler: same as for compression library. * Progress monitor: same as for compression library. As with compression, the data source manager, error handler, and progress monitor are candidates for replacement by a surrounding application. *** Decompression input and output separation *** To support efficient incremental display of progressive JPEG files, the decompressor is divided into two sections that can run independently: 1. Data input includes marker parsing, entropy decoding, and input into the coefficient controller's DCT coefficient buffer. Note that this processing is relatively cheap and fast. 2. Data output reads from the DCT coefficient buffer and performs the IDCT and all postprocessing steps. For a progressive JPEG file, the data input processing is allowed to get arbitrarily far ahead of the data output processing. (This occurs only if the application calls jpeg_consume_input(); otherwise input and output run in lockstep, since the input section is called only when the output section needs more data.) In this way the application can avoid making extra display passes when data is arriving faster than the display pass can run. Furthermore, it is possible to abort an output pass without losing anything, since the coefficient buffer is read-only as far as the output section is concerned. See libjpeg.doc for more detail. A full-image coefficient array is only created if the JPEG file has multiple scans (or if the application specifies buffered-image mode anyway). When reading a single-scan file, the coefficient controller normally creates only a one-MCU buffer, so input and output processing must run in lockstep in this case. jpeg_consume_input() is effectively a no-op in this situation. The main impact of dividing the decompressor in this fashion is that we must be very careful with shared variables in the cinfo data structure. Each variable that can change during the course of decompression must be classified as belonging to data input or data output, and each section must look only at its own variables. For example, the data output section may not depend on any of the variables that describe the current scan in the JPEG file, because these may change as the data input section advances into a new scan. The progress monitor is (somewhat arbitrarily) defined to treat input of the file as one pass when buffered-image mode is not used, and to ignore data input work completely when buffered-image mode is used. Note that the library has no reliable way to predict the number of passes when dealing with a progressive JPEG file, nor can it predict the number of output passes in buffered-image mode. So the work estimate is inherently bogus anyway. No comparable division is currently made in the compression library, because there isn't any real need for it. *** Data formats *** Arrays of pixel sample values use the following data structure: typedef something JSAMPLE; a pixel component value, 0..MAXJSAMPLE typedef JSAMPLE *JSAMPROW; ptr to a row of samples typedef JSAMPROW *JSAMPARRAY; ptr to a list of rows typedef JSAMPARRAY *JSAMPIMAGE; ptr to a list of color-component arrays The basic element type JSAMPLE will typically be one of unsigned char, (signed) char, or short. Short will be used if samples wider than 8 bits are to be supported (this is a compile-time option). Otherwise, unsigned char is used if possible. If the compiler only supports signed chars, then it is necessary to mask off the value when reading. Thus, all reads of JSAMPLE values must be coded as "GETJSAMPLE(value)", where the macro will be defined as "((value) & 0xFF)" on signed-char machines and "((int) (value))" elsewhere. With these conventions, JSAMPLE values can be assumed to be >= 0. This helps simplify correct rounding during downsampling, etc. The JPEG standard's specification that sample values run from -128..127 is accommodated by subtracting 128 just as the sample value is copied into the source array for the DCT step (this will be an array of signed ints). Similarly, during decompression the output of the IDCT step will be immediately shifted back to 0..255. (NB: different values are required when 12-bit samples are in use. The code is written in terms of MAXJSAMPLE and CENTERJSAMPLE, which will be defined as 255 and 128 respectively in an 8-bit implementation, and as 4095 and 2048 in a 12-bit implementation.) We use a pointer per row, rather than a two-dimensional JSAMPLE array. This choice costs only a small amount of memory and has several benefits: * Code using the data structure doesn't need to know the allocated width of the rows. This simplifies edge expansion/compression, since we can work in an array that's wider than the logical picture width. * Indexing doesn't require multiplication; this is a performance win on many machines. * Arrays with more than 64K total elements can be supported even on machines where malloc() cannot allocate chunks larger than 64K. * The rows forming a component array may be allocated at different times without extra copying. This trick allows some speedups in smoothing steps that need access to the previous and next rows. Note that each color component is stored in a separate array; we don't use the traditional layout in which the components of a pixel are stored together. This simplifies coding of modules that work on each component independently, because they don't need to know how many components there are. Furthermore, we can read or write each component to a temporary file independently, which is helpful when dealing with noninterleaved JPEG files. In general, a specific sample value is accessed by code such as GETJSAMPLE(image[colorcomponent][row][col]) where col is measured from the image left edge, but row is measured from the first sample row currently in memory. Either of the first two indexings can be precomputed by copying the relevant pointer. Since most image-processing applications prefer to work on images in which the components of a pixel are stored together, the data passed to or from the surrounding application uses the traditional convention: a single pixel is represented by N consecutive JSAMPLE values, and an image row is an array of (# of color components)*(image width) JSAMPLEs. One or more rows of data can be represented by a pointer of type JSAMPARRAY in this scheme. This scheme is converted to component-wise storage inside the JPEG library. (Applications that want to skip JPEG preprocessing or postprocessing will have to contend with component-wise storage.) Arrays of DCT-coefficient values use the following data structure: typedef short JCOEF; a 16-bit signed integer typedef JCOEF JBLOCK[DCTSIZE2]; an 8x8 block of coefficients typedef JBLOCK *JBLOCKROW; ptr to one horizontal row of 8x8 blocks typedef JBLOCKROW *JBLOCKARRAY; ptr to a list of such rows typedef JBLOCKARRAY *JBLOCKIMAGE; ptr to a list of color component arrays The underlying type is at least a 16-bit signed integer; while "short" is big enough on all machines of interest, on some machines it is preferable to use "int" for speed reasons, despite the storage cost. Coefficients are grouped into 8x8 blocks (but we always use #defines DCTSIZE and DCTSIZE2 rather than "8" and "64"). The contents of a coefficient block may be in either "natural" or zigzagged order, and may be true values or divided by the quantization coefficients, depending on where the block is in the processing pipeline. In the current library, coefficient blocks are kept in natural order everywhere; the entropy codecs zigzag or dezigzag the data as it is written or read. The blocks contain quantized coefficients everywhere outside the DCT/IDCT subsystems. (This latter decision may need to be revisited to support variable quantization a la JPEG Part 3.) Notice that the allocation unit is now a row of 8x8 blocks, corresponding to eight rows of samples. Otherwise the structure is much the same as for samples, and for the same reasons. On machines where malloc() can't handle a request bigger than 64Kb, this data structure limits us to rows of less than 512 JBLOCKs, or a picture width of 4000+ pixels. This seems an acceptable restriction. On 80x86 machines, the bottom-level pointer types (JSAMPROW and JBLOCKROW) must be declared as "far" pointers, but the upper levels can be "near" (implying that the pointer lists are allocated in the DS segment). We use a #define symbol FAR, which expands to the "far" keyword when compiling on 80x86 machines and to nothing elsewhere. *** Suspendable processing *** In some applications it is desirable to use the JPEG library as an incremental, memory-to-memory filter. In this situation the data source or destination may be a limited-size buffer, and we can't rely on being able to empty or refill the buffer at arbitrary times. Instead the application would like to have control return from the library at buffer overflow/underrun, and then resume compression or decompression at a later time. This scenario is supported for simple cases. (For anything more complex, we recommend that the application "bite the bullet" and develop real multitasking capability.) The libjpeg.doc file goes into more detail about the usage and limitations of this capability; here we address the implications for library structure. The essence of the problem is that the entropy codec (coder or decoder) must be prepared to stop at arbitrary times. In turn, the controllers that call the entropy codec must be able to stop before having produced or consumed all the data that they normally would handle in one call. That part is reasonably straightforward: we make the controller call interfaces include "progress counters" which indicate the number of data chunks successfully processed, and we require callers to test the counter rather than just assume all of the data was processed. Rather than trying to restart at an arbitrary point, the current Huffman codecs are designed to restart at the beginning of the current MCU after a suspension due to buffer overflow/underrun. At the start of each call, the codec's internal state is loaded from permanent storage (in the JPEG object structures) into local variables. On successful completion of the MCU, the permanent state is updated. (This copying is not very expensive, and may even lead to *improved* performance if the local variables can be registerized.) If a suspension occurs, the codec simply returns without updating the state, thus effectively reverting to the start of the MCU. Note that this implies leaving some data unprocessed in the source/destination buffer (ie, the compressed partial MCU). The data source/destination module interfaces are specified so as to make this possible. This also implies that the data buffer must be large enough to hold a worst-case compressed MCU; a couple thousand bytes should be enough. In a successive-approximation AC refinement scan, the progressive Huffman decoder has to be able to undo assignments of newly nonzero coefficients if it suspends before the MCU is complete, since decoding requires distinguishing previously-zero and previously-nonzero coefficients. This is a bit tedious but probably won't have much effect on performance. Other variants of Huffman decoding need not worry about this, since they will just store the same values again if forced to repeat the MCU. This approach would probably not work for an arithmetic codec, since its modifiable state is quite large and couldn't be copied cheaply. Instead it would have to suspend and resume exactly at the point of the buffer end. The JPEG marker reader is designed to cope with suspension at an arbitrary point. It does so by backing up to the start of the marker parameter segment, so the data buffer must be big enough to hold the largest marker of interest. Again, a couple KB should be adequate. (A special "skip" convention is used to bypass COM and APPn markers, so these can be larger than the buffer size without causing problems; otherwise a 64K buffer would be needed in the worst case.) The JPEG marker writer currently does *not* cope with suspension. I feel that this is not necessary; it is much easier simply to require the application to ensure there is enough buffer space before starting. (An empty 2K buffer is more than sufficient for the header markers; and ensuring there are a dozen or two bytes available before calling jpeg_finish_compress() will suffice for the trailer.) This would not work for writing multi-scan JPEG files, but we simply do not intend to support that capability with suspension. *** Memory manager services *** The JPEG library's memory manager controls allocation and deallocation of memory, and it manages large "virtual" data arrays on machines where the operating system does not provide virtual memory. Note that the same memory manager serves both compression and decompression operations. In all cases, allocated objects are tied to a particular compression or decompression master record, and they will be released when that master record is destroyed. The memory manager does not provide explicit deallocation of objects. Instead, objects are created in "pools" of free storage, and a whole pool can be freed at once. This approach helps prevent storage-leak bugs, and it speeds up operations whenever malloc/free are slow (as they often are). The pools can be regarded as lifetime identifiers for objects. Two pools/lifetimes are defined: * JPOOL_PERMANENT lasts until master record is destroyed * JPOOL_IMAGE lasts until done with image (JPEG datastream) Permanent lifetime is used for parameters and tables that should be carried across from one datastream to another; this includes all application-visible parameters. Image lifetime is used for everything else. (A third lifetime, JPOOL_PASS = one processing pass, was originally planned. However it was dropped as not being worthwhile. The actual usage patterns are such that the peak memory usage would be about the same anyway; and having per-pass storage substantially complicates the virtual memory allocation rules --- see below.) The memory manager deals with three kinds of object: 1. "Small" objects. Typically these require no more than 10K-20K total. 2. "Large" objects. These may require tens to hundreds of K depending on image size. Semantically they behave the same as small objects, but we distinguish them for two reasons: * On MS-DOS machines, large objects are referenced by FAR pointers, small objects by NEAR pointers. * Pool allocation heuristics may differ for large and small objects. Note that individual "large" objects cannot exceed the size allowed by type size_t, which may be 64K or less on some machines. 3. "Virtual" objects. These are large 2-D arrays of JSAMPLEs or JBLOCKs (typically large enough for the entire image being processed). The memory manager provides stripwise access to these arrays. On machines without virtual memory, the rest of the array may be swapped out to a temporary file. (Note: JSAMPARRAY and JBLOCKARRAY data structures are a combination of large objects for the data proper and small objects for the row pointers. For convenience and speed, the memory manager provides single routines to create these structures. Similarly, virtual arrays include a small control block and a JSAMPARRAY or JBLOCKARRAY working buffer, all created with one call.) In the present implementation, virtual arrays are only permitted to have image lifespan. (Permanent lifespan would not be reasonable, and pass lifespan is not very useful since a virtual array's raison d'etre is to store data for multiple passes through the image.) We also expect that only "small" objects will be given permanent lifespan, though this restriction is not required by the memory manager. In a non-virtual-memory machine, some performance benefit can be gained by making the in-memory buffers for virtual arrays be as large as possible. (For small images, the buffers might fit entirely in memory, so blind swapping would be very wasteful.) The memory manager will adjust the height of the buffers to fit within a prespecified maximum memory usage. In order to do this in a reasonably optimal fashion, the manager needs to allocate all of the virtual arrays at once. Therefore, there isn't a one-step allocation routine for virtual arrays; instead, there is a "request" routine that simply allocates the control block, and a "realize" routine (called just once) that determines space allocation and creates all of the actual buffers. The realize routine must allow for space occupied by non-virtual large objects. (We don't bother to factor in the space needed for small objects, on the grounds that it isn't worth the trouble.) To support all this, we establish the following protocol for doing business with the memory manager: 1. Modules must request virtual arrays (which may have only image lifespan) during the initial setup phase, i.e., in their jinit_xxx routines. 2. All "large" objects (including JSAMPARRAYs and JBLOCKARRAYs) must also be allocated during initial setup. 3. realize_virt_arrays will be called at the completion of initial setup. The above conventions ensure that sufficient information is available for it to choose a good size for virtual array buffers. Small objects of any lifespan may be allocated at any time. We expect that the total space used for small objects will be small enough to be negligible in the realize_virt_arrays computation. In a virtual-memory machine, we simply pretend that the available space is infinite, thus causing realize_virt_arrays to decide that it can allocate all the virtual arrays as full-size in-memory buffers. The overhead of the virtual-array access protocol is very small when no swapping occurs. A virtual array can be specified to be "pre-zeroed"; when this flag is set, never-yet-written sections of the array are set to zero before being made available to the caller. If this flag is not set, never-written sections of the array contain garbage. (This feature exists primarily because the equivalent logic would otherwise be needed in jdcoefct.c for progressive JPEG mode; we may as well make it available for possible other uses.) The first write pass on a virtual array is required to occur in top-to-bottom order; read passes, as well as any write passes after the first one, may access the array in any order. This restriction exists partly to simplify the virtual array control logic, and partly because some file systems may not support seeking beyond the current end-of-file in a temporary file. The main implication of this restriction is that rearrangement of rows (such as converting top-to-bottom data order to bottom-to-top) must be handled while reading data out of the virtual array, not while putting it in. *** Memory manager internal structure *** To isolate system dependencies as much as possible, we have broken the memory manager into two parts. There is a reasonably system-independent "front end" (jmemmgr.c) and a "back end" that contains only the code likely to change across systems. All of the memory management methods outlined above are implemented by the front end. The back end provides the following routines for use by the front end (none of these routines are known to the rest of the JPEG code): jpeg_mem_init, jpeg_mem_term system-dependent initialization/shutdown jpeg_get_small, jpeg_free_small interface to malloc and free library routines (or their equivalents) jpeg_get_large, jpeg_free_large interface to FAR malloc/free in MSDOS machines; else usually the same as jpeg_get_small/jpeg_free_small jpeg_mem_available estimate available memory jpeg_open_backing_store create a backing-store object read_backing_store, manipulate a backing-store object write_backing_store, close_backing_store On some systems there will be more than one type of backing-store object (specifically, in MS-DOS a backing store file might be an area of extended memory as well as a disk file). jpeg_open_backing_store is responsible for choosing how to implement a given object. The read/write/close routines are method pointers in the structure that describes a given object; this lets them be different for different object types. It may be necessary to ensure that backing store objects are explicitly released upon abnormal program termination. For example, MS-DOS won't free extended memory by itself. To support this, we will expect the main program or surrounding application to arrange to call self_destruct (typically via jpeg_destroy) upon abnormal termination. This may require a SIGINT signal handler or equivalent. We don't want to have the back end module install its own signal handler, because that would pre-empt the surrounding application's ability to control signal handling. The IJG distribution includes several memory manager back end implementations. Usually the same back end should be suitable for all applications on a given system, but it is possible for an application to supply its own back end at need. *** Implications of DNL marker *** Some JPEG files may use a DNL marker to postpone definition of the image height (this would be useful for a fax-like scanner's output, for instance). In these files the SOF marker claims the image height is 0, and you only find out the true image height at the end of the first scan. We could read these files as follows: 1. Upon seeing zero image height, replace it by 65535 (the maximum allowed). 2. When the DNL is found, update the image height in the global image descriptor. This implies that control modules must avoid making copies of the image height, and must re-test for termination after each MCU row. This would be easy enough to do. In cases where image-size data structures are allocated, this approach will result in very inefficient use of virtual memory or much-larger-than-necessary temporary files. This seems acceptable for something that probably won't be a mainstream usage. People might have to forgo use of memory-hogging options (such as two-pass color quantization or noninterleaved JPEG files) if they want efficient conversion of such files. (One could improve efficiency by demanding a user-supplied upper bound for the height, less than 65536; in most cases it could be much less.) The standard also permits the SOF marker to overestimate the image height, with a DNL to give the true, smaller height at the end of the first scan. This would solve the space problems if the overestimate wasn't too great. However, it implies that you don't even know whether DNL will be used. This leads to a couple of very serious objections: 1. Testing for a DNL marker must occur in the inner loop of the decompressor's Huffman decoder; this implies a speed penalty whether the feature is used or not. 2. There is no way to hide the last-minute change in image height from an application using the decoder. Thus *every* application using the IJG library would suffer a complexity penalty whether it cared about DNL or not. We currently do not support DNL because of these problems. A different approach is to insist that DNL-using files be preprocessed by a separate program that reads ahead to the DNL, then goes back and fixes the SOF marker. This is a much simpler solution and is probably far more efficient. Even if one wants piped input, buffering the first scan of the JPEG file needs a lot smaller temp file than is implied by the maximum-height method. For this approach we'd simply treat DNL as a no-op in the decompressor (at most, check that it matches the SOF image height). We will not worry about making the compressor capable of outputting DNL. Something similar to the first scheme above could be applied if anyone ever wants to make that work. Papyrus3/JpegDir/JpgLossy/makdjpeg.st0000755000175000017500000000342007535143454014770 0ustar ; Project file for Independent JPEG Group's software ; ; This project file is for Atari ST/STE/TT systems using Pure C or Turbo C. ; Thanks to Frank Moehle (Frank.Moehle@arbi.informatik.uni-oldenburg.de), ; Dr. B. Setzepfandt (bernd@gina.uni-muenster.de), ; and Guido Vollbeding (guivol@esc.de). ; ; To use this file, rename it to djpeg.prj. ; If you are using Turbo C, change filenames beginning with "pc..." to "tc..." ; Read installation instructions before trying to make the program! ; ; ; * * * Output file * * * djpeg.ttp ; ; * * * COMPILER OPTIONS * * * .C[-P] ; absolute calls .C[-M] ; and no string merging, folks .C[-w-cln] ; no "constant is long" warnings .C[-w-par] ; no "parameter xxxx unused" .C[-w-rch] ; no "unreachable code" .C[-wsig] ; warn if significant digits may be lost = ; * * * * List of modules * * * * pcstart.o djpeg.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h,jversion.h) cdjpeg.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) rdcolmap.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) wrppm.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) wrgif.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) wrtarga.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) wrbmp.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) wrrle.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) libjpeg.lib ; built by libjpeg.prj pcfltlib.lib ; floating point library ; the float library can be omitted if you've turned off DCT_FLOAT_SUPPORTED pcstdlib.lib ; standard library pcextlib.lib ; extended library Papyrus3/JpegDir/JpgLossy/JCHUFF.H0000755000175000017500000000312607535143454013717 0ustar /* * jchuff.h * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains declarations for Huffman entropy encoding routines * that are shared between the sequential encoder (jchuff.c) and the * progressive encoder (jcphuff.c). No other modules need to see these. */ /* The legal range of a DCT coefficient is * -1024 .. +1023 for 8-bit data; * -16384 .. +16383 for 12-bit data. * Hence the magnitude should always fit in 10 or 14 bits respectively. */ #if BITS_IN_JSAMPLE == 8 #define MAX_COEF_BITS 10 #else #define MAX_COEF_BITS 14 #endif /* Derived data constructed for each Huffman table */ typedef struct { unsigned int ehufco[256]; /* code for each symbol */ char ehufsi[256]; /* length of code for each symbol */ /* If no code has been allocated for a symbol S, ehufsi[S] contains 0 */ } c_derived_tbl; /* Short forms of external names for systems with brain-damaged linkers. */ #ifdef NEED_SHORT_EXTERNAL_NAMES #define jpeg_make_c_derived_tbl jMkCDerived #define jpeg_gen_optimal_table jGenOptTbl #endif /* NEED_SHORT_EXTERNAL_NAMES */ /* Expand a Huffman table definition into the derived format */ EXTERN(void) jpeg_make_c_derived_tbl JPP((j_compress_ptr cinfo, boolean isDC, int tblno, c_derived_tbl ** pdtbl)); /* Generate an optimal table definition given the specified counts */ EXTERN(void) jpeg_gen_optimal_table JPP((j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])); Papyrus3/JpegDir/JpgLossy/JCOMAPI.C0000755000175000017500000000622007535143454014025 0ustar /* * jcomapi.c * * Copyright (C) 1994-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains application interface routines that are used for both * compression and decompression. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* * Abort processing of a JPEG compression or decompression operation, * but don't destroy the object itself. * * For this, we merely clean up all the nonpermanent memory pools. * Note that temp files (virtual arrays) are not allowed to belong to * the permanent pool, so we will be able to close all temp files here. * Closing a data source or destination, if necessary, is the application's * responsibility. */ GLOBAL(void) jpeg_abort (j_common_ptr cinfo) { int pool; /* Do nothing if called on a not-initialized or destroyed JPEG object. */ if (cinfo->mem == NULL) return; /* Releasing pools in reverse order might help avoid fragmentation * with some (brain-damaged) malloc libraries. */ for (pool = JPOOL_NUMPOOLS-1; pool > JPOOL_PERMANENT; pool--) { (*cinfo->mem->free_pool) (cinfo, pool); } /* Reset overall state for possible reuse of object */ if (cinfo->is_decompressor) { cinfo->global_state = DSTATE_START; /* Try to keep application from accessing now-deleted marker list. * A bit kludgy to do it here, but this is the most central place. */ ((j_decompress_ptr) cinfo)->marker_list = NULL; } else { cinfo->global_state = CSTATE_START; } } /* * Destruction of a JPEG object. * * Everything gets deallocated except the master jpeg_compress_struct itself * and the error manager struct. Both of these are supplied by the application * and must be freed, if necessary, by the application. (Often they are on * the stack and so don't need to be freed anyway.) * Closing a data source or destination, if necessary, is the application's * responsibility. */ GLOBAL(void) jpeg_destroy (j_common_ptr cinfo) { /* We need only tell the memory manager to release everything. */ /* NB: mem pointer is NULL if memory mgr failed to initialize. */ if (cinfo->mem != NULL) (*cinfo->mem->self_destruct) (cinfo); cinfo->mem = NULL; /* be safe if jpeg_destroy is called twice */ cinfo->global_state = 0; /* mark it destroyed */ } /* * Convenience routines for allocating quantization and Huffman tables. * (Would jutils.c be a more reasonable place to put these?) */ GLOBAL(JQUANT_TBL *) jpeg_alloc_quant_table (j_common_ptr cinfo) { JQUANT_TBL *tbl; tbl = (JQUANT_TBL *) (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JQUANT_TBL)); tbl->sent_table = FALSE; /* make sure this is false in any new table */ return tbl; } GLOBAL(JHUFF_TBL *) jpeg_alloc_huff_table (j_common_ptr cinfo) { JHUFF_TBL *tbl; tbl = (JHUFF_TBL *) (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JHUFF_TBL)); tbl->sent_table = FALSE; /* make sure this is false in any new table */ return tbl; } Papyrus3/JpegDir/JpgLossy/JIDCTFLT.C0000755000175000017500000002076507535143454014160 0ustar /* * jidctflt.c * * Copyright (C) 1994-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains a floating-point implementation of the * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine * must also perform dequantization of the input coefficients. * * This implementation should be more accurate than either of the integer * IDCT implementations. However, it may not give the same results on all * machines because of differences in roundoff behavior. Speed will depend * on the hardware's floating point capacity. * * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT * on each row (or vice versa, but it's more convenient to emit a row at * a time). Direct algorithms are also available, but they are much more * complex and seem not to be any faster when reduced to code. * * This implementation is based on Arai, Agui, and Nakajima's algorithm for * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in * Japanese, but the algorithm is described in the Pennebaker & Mitchell * JPEG textbook (see REFERENCES section in file README). The following code * is based directly on figure 4-8 in P&M. * While an 8-point DCT cannot be done in less than 11 multiplies, it is * possible to arrange the computation so that many of the multiplies are * simple scalings of the final outputs. These multiplies can then be * folded into the multiplications or divisions by the JPEG quantization * table entries. The AA&N method leaves only 5 multiplies and 29 adds * to be done in the DCT itself. * The primary disadvantage of this method is that with a fixed-point * implementation, accuracy is lost due to imprecise representation of the * scaled quantization values. However, that problem does not arise if * we use floating point arithmetic. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jdct.h" /* Private declarations for DCT subsystem */ #ifdef DCT_FLOAT_SUPPORTED /* * This module is specialized to the case DCTSIZE = 8. */ #if DCTSIZE != 8 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ #endif /* Dequantize a coefficient by multiplying it by the multiplier-table * entry; produce a float result. */ #define DEQUANTIZE(coef,quantval) (((FAST_FLOAT) (coef)) * (quantval)) /* * Perform dequantization and inverse DCT on one block of coefficients. */ GLOBAL(void) jpeg_idct_float (j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col) { FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; FAST_FLOAT tmp10, tmp11, tmp12, tmp13; FAST_FLOAT z5, z10, z11, z12, z13; JCOEFPTR inptr; FLOAT_MULT_TYPE * quantptr; FAST_FLOAT * wsptr; JSAMPROW outptr; JSAMPLE *range_limit = IDCT_range_limit(cinfo); int ctr; FAST_FLOAT workspace[DCTSIZE2]; /* buffers data between passes */ SHIFT_TEMPS /* Pass 1: process columns from input, store into work array. */ inptr = coef_block; quantptr = (FLOAT_MULT_TYPE *) compptr->dct_table; wsptr = workspace; for (ctr = DCTSIZE; ctr > 0; ctr--) { /* Due to quantization, we will usually find that many of the input * coefficients are zero, especially the AC terms. We can exploit this * by short-circuiting the IDCT calculation for any column in which all * the AC terms are zero. In that case each output is equal to the * DC coefficient (with scale factor as needed). * With typical images and quantization tables, half or more of the * column DCT calculations can be simplified this way. */ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 && inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 && inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 && inptr[DCTSIZE*7] == 0) { /* AC terms all zero */ FAST_FLOAT dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); wsptr[DCTSIZE*0] = dcval; wsptr[DCTSIZE*1] = dcval; wsptr[DCTSIZE*2] = dcval; wsptr[DCTSIZE*3] = dcval; wsptr[DCTSIZE*4] = dcval; wsptr[DCTSIZE*5] = dcval; wsptr[DCTSIZE*6] = dcval; wsptr[DCTSIZE*7] = dcval; inptr++; /* advance pointers to next column */ quantptr++; wsptr++; continue; } /* Even part */ tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]); tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]); tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]); tmp10 = tmp0 + tmp2; /* phase 3 */ tmp11 = tmp0 - tmp2; tmp13 = tmp1 + tmp3; /* phases 5-3 */ tmp12 = (tmp1 - tmp3) * ((FAST_FLOAT) 1.414213562) - tmp13; /* 2*c4 */ tmp0 = tmp10 + tmp13; /* phase 2 */ tmp3 = tmp10 - tmp13; tmp1 = tmp11 + tmp12; tmp2 = tmp11 - tmp12; /* Odd part */ tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]); tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]); tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]); tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]); z13 = tmp6 + tmp5; /* phase 6 */ z10 = tmp6 - tmp5; z11 = tmp4 + tmp7; z12 = tmp4 - tmp7; tmp7 = z11 + z13; /* phase 5 */ tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562); /* 2*c4 */ z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */ tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */ tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */ tmp6 = tmp12 - tmp7; /* phase 2 */ tmp5 = tmp11 - tmp6; tmp4 = tmp10 + tmp5; wsptr[DCTSIZE*0] = tmp0 + tmp7; wsptr[DCTSIZE*7] = tmp0 - tmp7; wsptr[DCTSIZE*1] = tmp1 + tmp6; wsptr[DCTSIZE*6] = tmp1 - tmp6; wsptr[DCTSIZE*2] = tmp2 + tmp5; wsptr[DCTSIZE*5] = tmp2 - tmp5; wsptr[DCTSIZE*4] = tmp3 + tmp4; wsptr[DCTSIZE*3] = tmp3 - tmp4; inptr++; /* advance pointers to next column */ quantptr++; wsptr++; } /* Pass 2: process rows from work array, store into output array. */ /* Note that we must descale the results by a factor of 8 == 2**3. */ wsptr = workspace; for (ctr = 0; ctr < DCTSIZE; ctr++) { outptr = output_buf[ctr] + output_col; /* Rows of zeroes can be exploited in the same way as we did with columns. * However, the column calculation has created many nonzero AC terms, so * the simplification applies less often (typically 5% to 10% of the time). * And testing floats for zero is relatively expensive, so we don't bother. */ /* Even part */ tmp10 = wsptr[0] + wsptr[4]; tmp11 = wsptr[0] - wsptr[4]; tmp13 = wsptr[2] + wsptr[6]; tmp12 = (wsptr[2] - wsptr[6]) * ((FAST_FLOAT) 1.414213562) - tmp13; tmp0 = tmp10 + tmp13; tmp3 = tmp10 - tmp13; tmp1 = tmp11 + tmp12; tmp2 = tmp11 - tmp12; /* Odd part */ z13 = wsptr[5] + wsptr[3]; z10 = wsptr[5] - wsptr[3]; z11 = wsptr[1] + wsptr[7]; z12 = wsptr[1] - wsptr[7]; tmp7 = z11 + z13; tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562); z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */ tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */ tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */ tmp6 = tmp12 - tmp7; tmp5 = tmp11 - tmp6; tmp4 = tmp10 + tmp5; /* Final output stage: scale down by a factor of 8 and range-limit */ outptr[0] = range_limit[(int) DESCALE((INT32) (tmp0 + tmp7), 3) & RANGE_MASK]; outptr[7] = range_limit[(int) DESCALE((INT32) (tmp0 - tmp7), 3) & RANGE_MASK]; outptr[1] = range_limit[(int) DESCALE((INT32) (tmp1 + tmp6), 3) & RANGE_MASK]; outptr[6] = range_limit[(int) DESCALE((INT32) (tmp1 - tmp6), 3) & RANGE_MASK]; outptr[2] = range_limit[(int) DESCALE((INT32) (tmp2 + tmp5), 3) & RANGE_MASK]; outptr[5] = range_limit[(int) DESCALE((INT32) (tmp2 - tmp5), 3) & RANGE_MASK]; outptr[4] = range_limit[(int) DESCALE((INT32) (tmp3 + tmp4), 3) & RANGE_MASK]; outptr[3] = range_limit[(int) DESCALE((INT32) (tmp3 - tmp4), 3) & RANGE_MASK]; wsptr += DCTSIZE; /* advance pointer to next row */ } } #endif /* DCT_FLOAT_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/WRJPGCOM0000755000175000017500000007703407535143454014025 0ustar ELF T4y¼4 (44  Ô2222HÌ3L3L¨/usr/lib/ld.so.15DC!6&4>(*1<=-B?.79$"5A: +#/),'23%0;8@ÔèÔ , L p T-X -t -ˆ 2 24 3L3ô3ø445` Tt5ˆ8à7 @!*ÀH12 :2 P5 X30^2de2pj2¬r2Äy-X 3 …+H¡2ô¨3L±7 @·2è¾+Ð(Ð2|Ö5ˆ!Þ3$ã+P€û35\ 24 #2¸)3<02Ð72 >-ˆ K5 !Rˆ´W2ˆ`3g2Ün-t t2”_start_environ_end_iob__register_frame_info__flsbuf_GLOBAL_OFFSET_TABLE___ctypeabortatexitexittolowermalloc_init.umul__register_frame_info_tablefclose_DYNAMIC__iobstrcat__frame_state_for_exitenvironfree__deregister_frame_infostrcmp_edata_PROCEDURE_LINKAGE_TABLE_fopenmemsetstrcpy_etext_lib_version_ctypemain__filbufmemcpystrlen_finifprintflibc.so.1SYSVABI_1.3libc.so.1|7̳†5ˆ5#7 .2d%2p&2|12ˆ?2”C2 !2¬'2¸82Ä(2Ð:2ÜA2è/2ô,353 *3@3$330$3<9¼ à @¢ Dœ#  €€@I½K!t@I¹@t’•, ” ”@ –áˆÔ"À@¶@I®@I¯ã¿@/I®âH®À ÒÀÐ@Ѐ¢ €  Ð Ð$Ð?üŸÂÐЀ¢ 2¿ÿøÐ @ÇÐÀÇàèã¿Çàèã¿@/I®áÀ®À ÐÀ’` @’ÒÀ Çàèã¿Çàè㿈ÐaxÐaxÒ¡xÔ@’¿ÿ” Ô"€¢ €Ðax@Im€ Ôax’ Ô@Ö € àÿ” Ô"@Ð'¿ìп쀢?ÿ€ cÀK’¡K”á˜@IY @IMп찀Çàè㿈ÐaxÐaxÒ¡xÔ@’¿ÿ” Ô"€¢ €Ðax@I;€ Ôax’ Ô@Ö € àÿ” Ô"@Ð'¿ìп쀢?ÿ€ cÀK’¡K”á˜@I' @IÐaxÐaxÒ¡xÔ@’¿ÿ” Ô"€¢ €Ðax@I€ Ôax’ Ô@Ö € àÿ” Ô"@Ð'¿èп耢?ÿ€ cÀK’¡K”á˜@Hü @HðÒ¿ì‘*`Ò¿è °€Çàèã¿ð' DÐa|Ða|Ò¡|Ô@’¿ÿ” Ô"€¢ € РDÒa|@H߀ Ò!|`ÒÔ GÔ*@’`Ò"Çàèã¿ð' DÐa|Ða|Ò¡|Ô@’¿ÿ” Ô"€¢ € Ò D‘2`’ ÿ Ò¡|@H¼€ Ò!|`ÒÔ D—2 ” Ô*@’`Ò"Ða|Ða|Ò¡|Ô@’¿ÿ” Ô"€¢ € Ò D `ÿÒa|@H€ Ò!|`ÒÔ GÔ*@’`Ò"Çàèã¿ð' DÐa|Ða|Ò¡|Ô@’¿ÿ” Ô"€¢ €  ÿÒa|@H}€ Ò!|`Ò” ÿÔ*@’`Ò"Ða|Ða|Ò¡|Ô@’¿ÿ” Ô"€¢ € РDÒa|@Ha€ Ò!|`ÒÔ GÔ*@’`Ò"Çàè㿈ÐaxÐaxÒ¡xÔ@’¿ÿ” Ô"€¢ €Ðax@H<€ Ôax’ Ô@Ö € àÿ” Ô"@Ð'¿ì€¢?ÿ€€ Ða|Ða|Ò¡|Ô@’¿ÿ” Ô"€¢ € пìÒa|@H € Ò!|`ÒÔ¿ïÔ*@’`Ò"¿ÿÃÇàè㿈À'¿èÿþ‹Ð'¿ìп쀢 ÿ€€ Ð¿è’ Ò'¿èÿþÐ'¿ì¿ÿôÿþyÐ'¿ìп쀢 ÿ€€¿ÿ÷п耢 €cÀK’¡¸@Gæп찀Çàè㿈ÐaxÐaxÒ¡xÔ@’¿ÿ” Ô"€¢ €Ðax@GË€ Ôax’ Ô@Ö € àÿ” Ô"@Ð'¿ìÐaxÐaxÒ¡xÔ@’¿ÿ” Ô"€¢ €Ðax@G¯€ Ôax’ Ô@Ö € àÿ” Ô"@Ð'¿èп쀢 ÿ€Ð¿è€¢ Ø€€ cÀK’¡K”áè@G• @G‰Ð¿è°€Çàè㿈ÿþ;Ð'¿ìпìÿþ·Ð¿ì€¢ € cÀK’¡K”áø@Gy @Gmпì’?þÒ'¿ìп쀢 €€ ÿýë’ ÿþyпì’?ÿÒ'¿ì¿ÿñÇàè㿈ÿþÐ'¿ìп쀢 € cÀK’¡K”áø@GP @GDпì’?þÒ'¿ìп쀢 €€ ÿýÂпì’?ÿÒ'¿ì¿ÿõÇàè㿈ð' DÿÿY€¢ Ø€ cÀK’¡K”â@G, @G  ØÿþšÿÿÐ'¿ìÒ¿ì@€¢ >€l’‘*`E’¢@Ð Â<<<<Ì<<<Ì<<<Ì<<<ÌÌÌÌÌÌÌÌÌ€LÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌп찀+cÀK’¡K”â8@FÌ @FÀ€Ð¿ì°€Ð D€¢ € пìÿþ0ÿÿ0€ÿÿX€ пìÿþ%ÿÿ%€¿ÿ‡Çàèã¿cÀK’¢P@F¢cÀK’¢ˆ@FœcÀK’âÀÔ¡€@F”cÀK’¢Ø@FŽcÀK’¢è@FˆcÀK’£@F‚cÀK’£H@F|cÀK’£€@FvcÀK’£¸@FpcÀK’£ø@FjcÀL’ @FdcÀL’ X@F^cÀL’ ?”áè@FVcÀL’ È@FPcÀL’¡@FJ @F>Çàèã¿ð' Dò' Hô' L¤ РDÒ •*`¡: ’ Ð' D€¢`€€% HÒÔ @—* £:à”’`Ò"€¢ €° €!a‘Ò  `’ ÿ€¢`€@F! €¤€° €¤ ¿ÿÓРL€¤€€° €° €Çàèã¿hð' Dò' H Ð'¿äÀ'¿àÀ'¿ÜÀ'¿ØÒ HÔ@Ô"!€Ò!€€¢`€ Ða€Ò •*`‘: €¢ €€L’¡0Ò"!€ Ð'¿ìпìÒ D€¢ €€Üп쒑*`Ò H ÒÒ'¿èпèÒ •*`‘: €¢ -€€ÌÐ¿è’ Ò'¿èпèL’¡@” ÿÿ€€¢ €À'¿ä€¸Ð¿èL’¡H” ÿÿt€¢ €.Ð¿ì’  Ð'¿ìÒ D€¢ €ÿÿп쒑*`Ô H’ Ð@L’¡P@E©Ð'¿Üп܀¢ €Ð¿ì’‘*`Ò H– cÀL’!XÔ¡€ÖÀ@E @E€ƒÐ¿èL’¡p” ÿÿ?€¢ €xÐ¿ì’  Ð'¿ìÒ D€¢ €ÿþÎп쒑*`Ò H ÒÒ'¿àпàÒ •*`‘: €¢ "€Z?aè@EoÐ'¿àÐ¿à€¢ € cÀK’¡L”áx@EV @EJп쒑*`Ò H Ô’ Ð¿à@EXпà@EXÐ'¿Øп؀¢ €Ð¿ØÒ¿à Ò ?ÿ•*`‘: €¢ "€Ð¿ØÒ¿à À*?ÿ€%Ð¿ì’  Ð'¿ìÒ D€¢ € cÀK’¡L”á@E" @EпàL’¡°@E/п쒑*`Ô H’ пàÒ@@E&¿ÿÈпà@EÐ'¿Ø€ÿþ`Ð¿ì’ Ò'¿ì¿ÿ!Ð¿à€¢ €Ð¿Ü€¢ €ÿþQÐ¿à€¢ € п܀¢ € пìÒ D€¢ €ÿþBпìÒ D€¢ €%п쒑*`Ô H’ Ð@L’¡¸@DãÐ"axÐax€¢ €Ð¿ì’‘*`Ò H– cÀL’!XÔ¡€ÖÀ@DÆ @Dº€’£ Ò"!xÒ Dÿҿ쀢@€ cÀL’áÀÔ¡€@D¯ÿþ’£°Ò"!|Ð¿à€¢ €]?aè@D­Ð'¿àÐ¿à€¢ € cÀK’¡L”áx@D” @DˆÀ'¿ØпÜÒ¿Ü€¢`€c Ð'¿ÐÒ¿ÐпÐÒ¿ÐÔ@’¿ÿ” Ô"€¢ €Ð¿Ð@Dx€ Ô¿Ð’ Ô@Ö € àÿ” Ô"@Ð'¿Ì€¢?ÿ€€Ð¿Ø?’¡ç€¢ € cÀL’¡à?”áè@D^ @DR¿ØÒÖ¿à”@ Ö¿ÏÖ*€’`Ò"¿ÿËп܀¢ €Ð¿Ü@DbпäÿýÐ'¿Ôп؀¢ € þÿû³Ð¿Ø’  ÿûlп؀¢ €€¿àÒÔ @—* •:à’`Ò" ÿû<пؒ?ÿÒ'¿Ø¿ÿíпÔÿû–ÿûÐ @D° €Çàè” – Æ  „à…(€ €ˆà€€–À¿ÿù” ÃàÖ"@† ”Ö  „ à…(€”€€Šà€¿ÿú†à€ à€€Šà@€„?ÿ…(€”€ÃàÔ"@…*`€¢`€Ô"€ÖÔ?üÆàÄ € À€’‚ÿÔ"Ö"?ü¿ÿ÷?üÃàÄ’ € € €Ä €  "€ÄÄ €  2€’`Ä„Æ € à¿ÿô Ãà ã¿à€äÀЀ¢ €âÐ €¢ "€ÐÐ €¢ €’ÿÿÉ”Ò €¢@€  ¤ Ð @€¢8€¢ÐÒ €¢`¿ÿç° à&€ä&Àâ'Çàè㿀Р€¢ € À'¿ìЀ¢ €Ð¿ìÿÿºÐÒ¿ì  ’@Ò'¿ìЀ¢ ¿ÿøпì€Ð& ÿÿ®Ð Ð'¿ìпìÐ& @C™‘* ’?ÿÒ'¿èÀ'¿äÀ'¿ìÒ €¢`€¢  Ѐ¢ €Ò¿è’”¿ì–¿èÐÿÿ«˜¿ä  Ѐ¢ ¿ÿø’€ Ò¿èÐ ’”¿ì–¿èÿÿž˜¿äÒ¿èâ& пäÒ&Ð& Çàèã¿@/C®á ®À ÐÀà€¤ €¢Ð€¢ €€¤@ÿÿ¬Ð€¤@*€à Ð €¤@ €€¤ à €¤ 2¿ÿñЀ¤ €° Ø – €¢À €À Ú •2 ‘* ð@Ò €¤@ :€Ð €˜ @€¤@€– €¢À ¿ÿòÀ ° Çàè㿈@/C®à$®À ÒÀÔ "  @C9Ð&@€¢ €Ð@’`@C2ÒÀ €¢ €Ð@ÐJ€¢ z€-° @CÐ@Ô@’`ÒÀ  €° @C  €¢ 2€À&`Ð Ô Ò ‘* •* ”€“*`Ð ’@  Ð&`° ÿþÝ’`ÿþè’` °ÐÒ@Ð&`ÐJ@€¢ z€° ÿþÐ’¿ìÒ¿ì° Çàèã¿€Ô€Š @€ ° Ò @Bø  ?ÒÀ’@€ßÒ&À€Š €€  ?Ð'¿è€k€Š À€€¢ .Ð'¿è@€ÒÀ*!¬€Î“* @àÐ ÃÀ8Ðü8tÄ88ä°$Tt000000000000000000000000000000ÐÐÔ Ò ‘* •* ”€“*`Ð ’@ € ÒÐÀ Ð&À€‹° ÐÔ ÒÀ‘* ”€’@ Ò&À€‚° ÔÐ Ò •* ‘*  “*`Ô ’@ÐÀ”€  Ð&À€s° ÿþQ’¿èÿþO’¿ìÔ¿ì°Ò  @B~ Ð'¿ìÒ¿è ’@ Ð*a¬Ð¿è‘* @€_Ò" ÿþ=’¿èÒ¿è°’@ €WÀ*a¬ÿþ5’¿èÿþ3’¿äÒ¿è” ’@ Ô*a¬Ò¿è°Ð¿ä“*`’@ €GÐ"` ¿èÿþ$’ÿþ"’¿ìÒ °Ð¿ìÒ6a¨€;Ð&` ¿èÿþ’Ò °€3Ò6a¨ÿþ’¿ìÒ¿ì°€,Ò&`@B-" ’@B>”"€$à&bà"”"@B7’@B80€ Ð'¿è– пè@Ö*!¬Ô¿è“* ’@ ¿ð‘* Ð"`” €¢ ¿ÿõÔ'¿è0€ ÿýé’¿ìÒ¿ì°€Ò&` @B Çàèã¿@/A®ãP®Àð&`À&`À&@ ÒÀÀ&` Ð@À&`Ð&`ò"@Çàèã¿@/A®ã®Àð&`ð&` À&` ÒÀÀ&@Ð@À&`Ð&`ò"@Çàèã¿@/A®âÀ®À ÔÀЀ€¢ €Ò€Ð`€¢€ Ð`Ð"€Ð@€¢ € @AßÐ` 0€€¢ ¿ÿò”`@AÜÇàèã½XÿþL¤’ €ÿþ’¿Ø ’ €½À€=° ’ @AÍ”"пêÒ¿ÜÐ7¿jÒ'½ÄР?ü$€Ò ¢ €¤€ пؒ½À”¿Øÿþ±–  €¤ ¿ÿúпØÐJ€¢ z€  ÿýo’½¼Ò½¼  ЀҠ€¢ €¤€Ò'½¸Ð½¸€¢€ ’½À”¿Øÿþ”–½¸ €¤ ¿ÿ÷н¸’½À@A”"°Çàèã¿@/A®á®À ÐÀÒ?ü€¢ÿ€  ?üП ?üЀ¢?ÿ¿ÿûÇàèã¿Çàèã¿ ÿ÷½ÿÿåÇàèã¿ ÿ÷”Çàè%s Premature EOF in JPEG fileWarning: garbage data found in JPEG file Not a JPEG fileErroneous JPEG marker lengthExpected SOI marker firstSOS without prior SOFnwrjpgcom inserts a textual comment in a JPEG file. You can add to or replace any existing comment(s). Usage: %s [switches] [inputfile] Switches (names may be abbreviated): -replace Delete any existing comments -comment "text" Insert comment with given text -cfile name Read comment from named file Notice that you must put quotes around the comment text when you use -comment. If you do not give either -comment or -cfile on the command line, then the comment text is read from standard input. It can be multiple lines, up to %u characters total. You must specify an input JPEG file name when supplying comment text from standard input. wrjpgcomreplacecfiler%s: can't open %s commentInsufficient memoryMissing ending quote mark rb%s: only one input file Comment text may not exceed %u bytes eh3L3ô45`225„3ü00¿ÿó<0¿ÿðH0¿ÿíT0¿ÿê`0¿ÿçl0¿ÿäx0¿ÿá„0¿ÿÞ0¿ÿÛœ0¿ÿب0¿ÿÕ´0¿ÿÒÀ0¿ÿÏÌ0¿ÿÌØ0¿ÿÉä0¿ÿÆð0¿ÿÃü0¿ÿÀ0¿ÿ½’ -X -toÿÿþ ,oÿÿÿè Ô oÿýü24ä p L 4ÿÿÿÿÿÿÿÿ|e  e "<4 ("pL 8"¼H H#TX#Xœ - et#ô - e%è - e¬%ì( - eÈ'¬ - eä*ÀH - e+H - e+P€ - e8+Ð( - eÿñÔèÔ , L p T-X -t -ˆ 2 24 3L3ô3ø445`±Y8à ÿñÿñÿñ(3ô,3ø:4H È^ Èm4€3øŽ D™ ˆ¤5`­ P¹ÿñÄPÑ5€ÚÜ€çdðôøú” ”l°%5x,\:T L ”ÈX`¼dˆm \€z5|‚°H“ÿñ›2 ¡2 §"¼H²5„º"pLÉ"<4Ø'¬é%ì(ú4 #T#ô #Xœ)%è2ÿñ=5XK,øa,øp3ø~-L‰4–3ü£ÿñª Tt¹5ˆÂ8àÇ7 @!Ì*ÀHâ2 ë2 5  302d2p2¬#2Ä*-X 03 6+HR2ô_3Lh7 @n2èu+Ð(‡2|5ˆ!•3$š+P€²3¹5\À24 Ú2¸à3<ç2Ðî2 õ-ˆ 5 ! ˆ´2ˆ32Ü%-t +2”wrjpgcomcrti.svalues-Xa.ccrtstuff.cp.2__CTOR_LIST____DTOR_LIST____do_global_dtors_auxgcc2_compiled.__EH_FRAME_BEGIN__force_to_datafini_dummyinit_dummyobject.7frame_dummywrjpgcom.cfirst_markerprognamewrite_1_bytewrite_markerusageskip_variablegcc2_compiled.copy_variableinfilewrite_2_bytescopy_rest_of_fileread_1_bytenext_markerkeymatchread_2_bytesoutfilescan_JPEG_headerframe.c.LLC0.LLC1fde_insertobjectsdecode_sleb128decode_uleb128execute_cfa_insnextract_cie_info__FRAME_BEGIN__count_fdesframe_initadd_fdesfind_fdecrtstuff.c__FRAME_END____do_global_ctors_auxgcc2_compiled.force_to_datainit_dummy__DTOR_END____CTOR_END__crtn.s_start_START__environ_end_iob__register_frame_info__flsbuf_GLOBAL_OFFSET_TABLE___ctypeabortatexitexittolowermalloc_init.umul__register_frame_info_tablefclose_END__DYNAMIC__iobstrcat__frame_state_for_exitenvironfree__deregister_frame_infostrcmp_edata_PROCEDURE_LINKAGE_TABLE_fopenmemsetstrcpy_etext_lib_version_ctypemain__filbufmemcpystrlen_finifprintfas: WorkShop Compilers 4.X dev 18 Sep 1996 as: WorkShop Compilers 4.X dev 18 Sep 1996 @(#)SunOS 5.6 Generic August 1997as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 ld: Software Generation Utilities - Solaris/ELF (3.0); <I4œ,Ù d"<"d"<,<;€e€€®€Ï€õ€A€€³€Ý€€(€B€]€~€·€Ú€þ€(€<‚F‚]‚u‚z‚’‚¦‚»‚Ѐ€€Ž€.€¢„‚¢¢¢¢¢’‚¢¢¢¢£‚¢®‚¢º‚À .€ ƒ€ ý€-€z€Á€¶€”€€€‘€‚€<€†€å€?€¯€€n€ï€ ,€!€!ƒ€#q€$b€¢$÷‚%€v% €¨%5€ó%K€ ¢%`‚%h€&j€&…€¢'=€2'Q€3'e€4'y€5'€6'¢€( €(€L( €)&€)|$i"<)“@h)§@h )¸$4)¹$~"p)Ð@})Ü@} )í$L)î€*<$Â"¼*O@Á*m@Á *w@Á *ˆ$H*‰$Ï#*œ@Î*­$T*®$á#X*¿@ß*Ð@ß*Þ@ß*ô@à+ @à+$œ+$ÿ#ô+0@þ+<$+=$'%+N@&+Y$è+Z$R%ì+s@Q+}@Q+$(+$'+©@}+³@}+Á@~+Î@~+Ù$¬+Ú$ù*À+ø@ø,@ø,$H,$ +,7@ ,E@ ,Q$H,R$+P,r@,€$€,$4+Ð,£@3,µ@3,Æ$(,Ç(P5„,Ød,ø.interp.hash.dynsym.dynstr.SUNW_version.rela.bss.rela.plt.text.init.fini.rodata.got.plt.dynamic.data.ctors.dtors.eh_frame.bss.symtab.strtab.comment.stab.index.stab.shstrtab.stab.indexstr.stabstrvalues-Xa.cXt ; O ; V=3.1 ; R=WorkShop Compilers 4.2 30 Oct 1996 C 4.2/space/respin/usr/src/lib/libc; /ws/on297-tools/SUNWspro/SC4.2/bin/../SC4.2/bin/cc -xO3 -xcg89 -Wa,-cg92 -xspace -W0,-Lt -Xt -Iinc -DTEXT_DOMAIN='"SUNW_OST_OSLIB"' -I/space/respin/proto/root_sparc/usr/include -c port/gen/values-Xa.c -W0,-xpframe.c/ext1/SOURCES/gcc-2.8.1/./frame.cgcc2_compiled.int:t(0,1)=r(0,1);-2147483648;2147483647;char:t(0,2)=r(0,2);0;127;long int:t(0,3)=r(0,3);-2147483648;2147483647;unsigned int:t(0,4)=r(0,4);0;-1;long unsigned int:t(0,5)=r(0,5);0;-1;long long int:t(0,6)=r(0,1);01000000000000000000000;0777777777777777777777;long long unsigned int:t(0,7)=r(0,1);0000000000000;01777777777777777777777;short int:t(0,8)=r(0,8);-32768;32767;short unsigned int:t(0,9)=r(0,9);0;65535;signed char:t(0,10)=r(0,10);-128;127;unsigned char:t(0,11)=r(0,11);0;255;float:t(0,12)=r(0,1);4;0;double:t(0,13)=r(0,1);8;0;long double:t(0,14)=r(0,1);16;0;complex int:t(0,15)=s8real:(0,1),0,32;imag:(0,1),32,32;;complex float:t(0,16)=r(0,16);4;0;complex double:t(0,17)=r(0,17);8;0;complex long double:t(0,18)=r(0,18);16;0;void:t(0,19)=(0,19)tconfig.hconfig/sparc/xm-sol2.hconfig/sparc/xm-sysv4.htm.hconfig/sparc/sol2-sld.hconfig/sparc/sol2.hconfig/sparc/sysv4.hconfig/sparc/sparc.hcmodel:T(8,1)=eCM_32:0,CM_MEDLOW:1,CM_MEDMID:2,CM_MEDANY:3,CM_EMBMEDANY:4,;processor_type:T(8,2)=ePROCESSOR_V7:0,PROCESSOR_CYPRESS:1,PROCESSOR_V8:2,PROCESSOR_SUPERSPARC:3,PROCESSOR_SPARCLITE:4,PROCESSOR_F930:5,PROCESSOR_F934:6,PROCESSOR_SPARCLET:7,PROCESSOR_TSC701:8,PROCESSOR_V8PLUS:9,PROCESSOR_V9:10,PROCESSOR_ULTRASPARC:11,;sparc_cpu_select:T(8,3)=s16string:(8,4)=*(0,2),0,32;name:(8,4),32,32;set_tune_p:(0,1),64,32;set_arch_p:(0,1),96,32;;reg_class:T(8,5)=eNO_REGS:0,FPCC_REGS:1,GENERAL_REGS:2,FP_REGS:3,EXTRA_FP_REGS:4,GENERAL_OR_FP_REGS:5,GENERAL_OR_EXTRA_FP_REGS:6,ALL_REGS:7,LIM_REG_CLASSES:8,;sparc_args:T(8,6)=s12words:(0,1),0,32;prototype_p:(0,1),32,32;libcall_p:(0,1),64,32;;config/svr4.hconfig/xm-svr4.hdefaults.hgansidecl.hdwarf2.hdwarf_tag:T(13,1)=eDW_TAG_padding:0,DW_TAG_array_type:1,DW_TAG_class_type:2,DW_TAG_entry_point:3,DW_TAG_enumeration_type:4,DW_TAG_formal_parameter:5,DW_TAG_imported_declaration:8,DW_TAG_label:10,DW_TAG_lexical_block:11,DW_TAG_member:13,DW_TAG_pointer_type:15,DW_TAG_reference_type:16,DW_TAG_compile_unit:17,DW_TAG_string_type:18,DW_TAG_structure_type:19,DW_TAG_subroutine_type:21,DW_TAG_typedef:22,DW_TAG_union_type:23,DW_TAG_unspecified_parameters:24,DW_TAG_variant:25,DW_TAG_common_block:26,DW_TAG_common_inclusion:27,DW_TAG_inheritance:28,DW_TAG_inlined_subroutine:29,DW_TAG_module:30,DW_TAG_ptr_to_member_type:31,\DW_TAG_set_type:32,DW_TAG_subrange_type:33,DW_TAG_with_stmt:34,DW_TAG_access_declaration:35,DW_TAG_base_type:36,DW_TAG_catch_block:37,DW_TAG_const_type:38,DW_TAG_constant:39,DW_TAG_enumerator:40,DW_TAG_file_type:41,DW_TAG_friend:42,DW_TAG_namelist:43,DW_TAG_namelist_item:44,DW_TAG_packed_type:45,DW_TAG_subprogram:46,DW_TAG_template_type_param:47,DW_TAG_template_value_param:48,DW_TAG_thrown_type:49,DW_TAG_try_block:50,DW_TAG_variant_part:51,DW_TAG_variable:52,DW_TAG_volatile_type:53,DW_TAG_MIPS_loop:16513,DW_TAG_format_label:16641,DW_TAG_function_template:16642,DW_TAG_class_template:16643,;dwarf_form:T(13,2)=eDW_FORM_addr:1,DW_FORM_block2:3,DW_FORM_block4:4,DW_FORM_data2:5,DW_FORM_data4:6,DW_FORM_data8:7,DW_FORM_string:8,DW_FORM_block:9,DW_FORM_block1:10,DW_FORM_data1:11,DW_FORM_flag:12,DW_FORM_sdata:13,DW_FORM_strp:14,DW_FORM_udata:15,DW_FORM_ref_addr:16,DW_FORM_ref1:17,DW_FORM_ref2:18,DW_FORM_ref4:19,DW_FORM_ref8:20,DW_FORM_ref_udata:21,DW_FORM_indirect:22,;dwarf_attribute:T(13,3)=eDW_AT_sibling:1,DW_AT_location:2,DW_AT_name:3,DW_AT_ordering:9,DW_AT_subscr_data:10,DW_AT_byte_size:11,DW_AT_bit_offset:12,DW_AT_bit_size:13,DW_AT_element_list:15,DW_AT_stmt_list:16,DW_AT_low_pc:17,DW_AT_high_pc:18,DW_AT_language:19,DW_AT_member:20,DW_AT_discr:21,DW_AT_discr_value:22,DW_AT_visibility:23,DW_AT_import:24,DW_AT_string_length:25,DW_AT_common_reference:26,DW_AT_comp_dir:27,DW_AT_const_value:28,DW_AT_containing_type:29,DW_AT_default_value:30,DW_AT_inline:32,DW_AT_is_optional:33,DW_AT_lower_bound:34,DW_AT_producer:37,\DW_AT_prototyped:39,DW_AT_return_addr:42,DW_AT_start_scope:44,DW_AT_stride_size:46,DW_AT_upper_bound:47,DW_AT_abstract_origin:49,DW_AT_accessibility:50,DW_AT_address_class:51,DW_AT_artificial:52,DW_AT_base_types:53,DW_AT_calling_convention:54,DW_AT_count:55,DW_AT_data_member_location:56,DW_AT_decl_column:57,DW_AT_decl_file:58,DW_AT_decl_line:59,DW_AT_declaration:60,DW_AT_discr_list:61,DW_AT_encoding:62,DW_AT_external:63,DW_AT_frame_base:64,DW_AT_friend:65,DW_AT_identifier_case:66,DW_AT_macro_info:67,DW_AT_namelist_items:68,DW_AT_priority:69,DW_AT_segment:70,DW_AT_specification:71,\DW_AT_static_link:72,DW_AT_type:73,DW_AT_use_location:74,DW_AT_variable_parameter:75,DW_AT_virtuality:76,DW_AT_vtable_elem_location:77,DW_AT_MIPS_fde:8193,DW_AT_MIPS_loop_begin:8194,DW_AT_MIPS_tail_loop_begin:8195,DW_AT_MIPS_epilog_begin:8196,DW_AT_MIPS_loop_unroll_factor:8197,DW_AT_MIPS_software_pipeline_depth:8198,DW_AT_MIPS_linkage_name:8199,DW_AT_MIPS_stride:8200,DW_AT_MIPS_abstract_name:8201,DW_AT_MIPS_clone_origin:8202,DW_AT_MIPS_has_inlines:8203,DW_AT_sf_names:8449,DW_AT_src_info:8450,DW_AT_mac_info:8451,DW_AT_src_coords:8452,DW_AT_body_begin:8453,DW_AT_body_end:8454,;dwarf_location_atom:T(13,4)=eDW_OP_addr:3,DW_OP_deref:6,DW_OP_const1u:8,DW_OP_const1s:9,DW_OP_const2u:10,DW_OP_const2s:11,DW_OP_const4u:12,DW_OP_const4s:13,DW_OP_const8u:14,DW_OP_const8s:15,DW_OP_constu:16,DW_OP_consts:17,DW_OP_dup:18,DW_OP_drop:19,DW_OP_over:20,DW_OP_pick:21,DW_OP_swap:22,DW_OP_rot:23,DW_OP_xderef:24,DW_OP_abs:25,DW_OP_and:26,DW_OP_div:27,DW_OP_minus:28,DW_OP_mod:29,DW_OP_mul:30,DW_OP_neg:31,DW_OP_not:32,DW_OP_or:33,DW_OP_plus:34,DW_OP_plus_uconst:35,DW_OP_shl:36,DW_OP_shr:37,\DW_OP_shra:38,DW_OP_xor:39,DW_OP_bra:40,DW_OP_eq:41,DW_OP_ge:42,DW_OP_gt:43,DW_OP_le:44,DW_OP_lt:45,DW_OP_ne:46,DW_OP_skip:47,DW_OP_lit0:48,DW_OP_lit1:49,DW_OP_lit2:50,DW_OP_lit3:51,DW_OP_lit4:52,DW_OP_lit5:53,DW_OP_lit6:54,DW_OP_lit7:55,DW_OP_lit8:56,DW_OP_lit9:57,DW_OP_lit10:58,DW_OP_lit11:59,DW_OP_lit12:60,DW_OP_lit13:61,DW_OP_lit14:62,DW_OP_lit15:63,DW_OP_lit16:64,DW_OP_lit17:65,DW_OP_lit18:66,DW_OP_lit19:67,DW_OP_lit20:68,DW_OP_lit21:69,DW_OP_lit22:70,DW_OP_lit23:71,\DW_OP_lit24:72,DW_OP_lit25:73,DW_OP_lit26:74,DW_OP_lit27:75,DW_OP_lit28:76,DW_OP_lit29:77,DW_OP_lit30:78,DW_OP_lit31:79,DW_OP_reg0:80,DW_OP_reg1:81,DW_OP_reg2:82,DW_OP_reg3:83,DW_OP_reg4:84,DW_OP_reg5:85,DW_OP_reg6:86,DW_OP_reg7:87,DW_OP_reg8:88,DW_OP_reg9:89,DW_OP_reg10:90,DW_OP_reg11:91,DW_OP_reg12:92,DW_OP_reg13:93,DW_OP_reg14:94,DW_OP_reg15:95,DW_OP_reg16:96,DW_OP_reg17:97,DW_OP_reg18:98,DW_OP_reg19:99,DW_OP_reg20:100,DW_OP_reg21:101,DW_OP_reg22:102,DW_OP_reg23:103,DW_OP_reg24:104,\DW_OP_reg25:105,DW_OP_reg26:106,DW_OP_reg27:107,DW_OP_reg28:108,DW_OP_reg29:109,DW_OP_reg30:110,DW_OP_reg31:111,DW_OP_breg0:112,DW_OP_breg1:113,DW_OP_breg2:114,DW_OP_breg3:115,DW_OP_breg4:116,DW_OP_breg5:117,DW_OP_breg6:118,DW_OP_breg7:119,DW_OP_breg8:120,DW_OP_breg9:121,DW_OP_breg10:122,DW_OP_breg11:123,DW_OP_breg12:124,DW_OP_breg13:125,DW_OP_breg14:126,DW_OP_breg15:127,DW_OP_breg16:128,DW_OP_breg17:129,DW_OP_breg18:130,DW_OP_breg19:131,DW_OP_breg20:132,DW_OP_breg21:133,DW_OP_breg22:134,DW_OP_breg23:135,DW_OP_breg24:136,\DW_OP_breg25:137,DW_OP_breg26:138,DW_OP_breg27:139,DW_OP_breg28:140,DW_OP_breg29:141,DW_OP_breg30:142,DW_OP_breg31:143,DW_OP_regx:144,DW_OP_fbreg:145,DW_OP_bregx:146,DW_OP_piece:147,DW_OP_deref_size:148,DW_OP_xderef_size:149,DW_OP_nop:150,;dwarf_type:T(13,5)=eDW_ATE_void:0,DW_ATE_address:1,DW_ATE_boolean:2,DW_ATE_complex_float:3,DW_ATE_float:4,DW_ATE_signed:5,DW_ATE_signed_char:6,DW_ATE_unsigned:7,DW_ATE_unsigned_char:8,;dwarf_array_dim_ordering:T(13,6)=eDW_ORD_row_major:0,DW_ORD_col_major:1,;dwarf_access_attribute:T(13,7)=eDW_ACCESS_public:1,DW_ACCESS_protected:2,DW_ACCESS_private:3,;dwarf_visibility_attribute:T(13,8)=eDW_VIS_local:1,DW_VIS_exported:2,DW_VIS_qualified:3,;dwarf_virtuality_attribute:T(13,9)=eDW_VIRTUALITY_none:0,DW_VIRTUALITY_virtual:1,DW_VIRTUALITY_pure_virtual:2,;dwarf_id_case:T(13,10)=eDW_ID_case_sensitive:0,DW_ID_up_case:1,DW_ID_down_case:2,DW_ID_case_insensitive:3,;dwarf_calling_convention:T(13,11)=eDW_CC_normal:1,DW_CC_program:2,DW_CC_nocall:3,;dwarf_inline_attribute:T(13,12)=eDW_INL_not_inlined:0,DW_INL_inlined:1,DW_INL_declared_not_inlined:2,DW_INL_declared_inlined:3,;dwarf_discrim_list:T(13,13)=eDW_DSC_label:0,DW_DSC_range:1,;dwarf_line_number_ops:T(13,14)=eDW_LNS_extended_op:0,DW_LNS_copy:1,DW_LNS_advance_pc:2,DW_LNS_advance_line:3,DW_LNS_set_file:4,DW_LNS_set_column:5,DW_LNS_negate_stmt:6,DW_LNS_set_basic_block:7,DW_LNS_const_add_pc:8,DW_LNS_fixed_advance_pc:9,;dwarf_line_number_x_ops:T(13,15)=eDW_LNE_end_sequence:1,DW_LNE_set_address:2,DW_LNE_define_file:3,;dwarf_call_frame_info:T(13,16)=eDW_CFA_advance_loc:64,DW_CFA_offset:128,DW_CFA_restore:192,DW_CFA_nop:0,DW_CFA_set_loc:1,DW_CFA_advance_loc1:2,DW_CFA_advance_loc2:3,DW_CFA_advance_loc4:4,DW_CFA_offset_extended:5,DW_CFA_restore_extended:6,DW_CFA_undefined:7,DW_CFA_same_value:8,DW_CFA_register:9,DW_CFA_remember_state:10,DW_CFA_restore_state:11,DW_CFA_def_cfa:12,DW_CFA_def_cfa_register:13,DW_CFA_def_cfa_offset:14,DW_CFA_MIPS_advance_loc8:29,DW_CFA_GNU_window_save:45,DW_CFA_GNU_args_size:46,;dwarf_source_language:T(13,17)=eDW_LANG_C89:1,DW_LANG_C:2,DW_LANG_Ada83:3,DW_LANG_C_plus_plus:4,DW_LANG_Cobol74:5,DW_LANG_Cobol85:6,DW_LANG_Fortran77:7,DW_LANG_Fortran90:8,DW_LANG_Pascal83:9,DW_LANG_Modula2:10,DW_LANG_Mips_Assembler:32769,;dwarf_macinfo_record_type:T(13,18)=eDW_MACINFO_define:1,DW_MACINFO_undef:2,DW_MACINFO_start_file:3,DW_MACINFO_end_file:4,DW_MACINFO_vendor_ext:255,;include/stddef.hptrdiff_t:t(14,1)=(0,1)size_t:t(14,2)=(0,4)wchar_t:t(14,3)=(0,3)wint_t:t(14,4)=(0,4)frame.hframe_state:T(15,1)=s532cfa:(15,2)=*(0,19),0,32;eh_ptr:(15,2),32,32;cfa_offset:(0,3),64,32;args_size:(0,3),96,32;reg_or_offset:(15,3)=ar(0,0);0;101;(0,3),128,3264;cfa_reg:(0,9),3392,16;retaddr_column:(0,9),3408,16;saved:(15,4)=ar(0,0);0;101;(0,2),3424,816;;frame_state:t(15,5)=(15,1)object:T(15,6)=s24pc_begin:(15,2),0,32;pc_end:(15,2),32,32;fde_begin:(15,7)=*(15,8)=xsdwarf_fde:,64,32;fde_array:(15,9)=*(15,7),96,32;count:(14,2),128,32;next:(15,10)=*(15,6),160,32;;sword:t(0,20)=(0,1)uword:t(0,21)=(0,4)uaddr:t(0,22)=(0,4)saddr:t(0,23)=(0,1)ubyte:t(0,24)=(0,11)dwarf_cie:T(0,25)=s12length:(0,21),0,32;CIE_id:(0,20),32,32;version:(0,24),64,8;augmentation:(0,26)=ar(0,0);0;-1;(0,2),72,0;;dwarf_fde:T(15,8)=s16length:(0,21),0,32;CIE_delta:(0,20),32,32;pc_begin:(15,2),64,32;pc_range:(0,22),96,32;;fde:t(0,27)=(15,8)cie_info:T(0,28)=s20augmentation:(8,4),0,32;eh_ptr:(15,2),32,32;code_align:(0,1),64,32;data_align:(0,1),96,32;ra_regno:(0,4),128,32;;frame_state_internal:T(0,29)=s536s:(15,1),0,4256;saved_state:(0,30)=*(0,29),4256,32;;decode_uleb128:f(15,2)buf:P(0,31)=*(0,11)r:P(0,32)=*(0,4)decode_sleb128:f(15,2)buf:P(0,31)r:P(0,33)=*(0,1)unaligned:T(0,34)=u8p:(15,2),0,32;b2:(0,9),0,16;b4:(0,4),0,32;b8:(0,7),0,64;;fde_insert:f(0,19)array:P(0,35)=*(0,36)=*(0,27)i:P(14,2)this_fde:P(0,36)count_fdes:f(14,2)this_fde:P(0,36)add_fdes:f(0,19)this_fde:P(0,36)array:P(0,35)i_ptr:P(0,37)=*(14,2)beg_ptr:P(0,38)=*(15,2)end_ptr:P(0,38)frame_init:f(0,19)ob:P(15,10)find_fde:f(0,36)pc:P(15,2)extract_cie_info:f(15,2)f:P(0,36)c:P(0,39)=*(0,28)execute_cfa_insn:f(15,2)p:P(15,2)state:P(0,30)info:P(0,39)pc:P(0,38)__register_frame_info:F(0,19)begin:P(15,2)ob:P(15,10)__register_frame_info_table:F(0,19)begin:P(15,2)ob:P(15,10)__deregister_frame_info:F(0,19)begin:P(15,2)__frame_state_for:F(0,40)=*(15,1)pc_target:P(15,2)state_in:P(0,40)objects:S(15,10)ÔÔ èèì ÔÔ@oÿÿþ , , - L L$ 7 p pä  A T T"G-X-XM-t-tS-ˆ-ˆ‹[22 `2424 e3L3L¨n3ô3ôt3ø3ø{44‚44TŒ5`5`€‘5\àV™=<3¡AoتCH$ ¶Cl\ ¼JÈÞÆK¦;ÕLá,ÙPapyrus3/JpegDir/JpgLossy/JMEMMAC.C0000755000175000017500000002310407535143454014014 0ustar /* * jmemmac.c * * Copyright (C) 1992-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * jmemmac.c provides an Apple Macintosh implementation of the system- * dependent portion of the JPEG memory manager. * * If you use jmemmac.c, then you must define USE_MAC_MEMMGR in the * JPEG_INTERNALS part of jconfig.h. * * jmemmac.c uses the Macintosh toolbox routines NewPtr and DisposePtr * instead of malloc and free. It accurately determines the amount of * memory available by using CompactMem. Notice that if left to its * own devices, this code can chew up all available space in the * application's zone, with the exception of the rather small "slop" * factor computed in jpeg_mem_available(). The application can ensure * that more space is left over by reducing max_memory_to_use. * * Large images are swapped to disk using temporary files and System 7.0+'s * temporary folder functionality. * * Note that jmemmac.c depends on two features of MacOS that were first * introduced in System 7: FindFolder and the FSSpec-based calls. * If your application uses jmemmac.c and is run under System 6 or earlier, * and the jpeg library decides it needs a temporary file, it will abort, * printing error messages about requiring System 7. (If no temporary files * are created, it will run fine.) * * If you want to use jmemmac.c in an application that might be used with * System 6 or earlier, then you should remove dependencies on FindFolder * and the FSSpec calls. You will need to replace FindFolder with some * other mechanism for finding a place to put temporary files, and you * should replace the FSSpec calls with their HFS equivalents: * * FSpDelete -> HDelete * FSpGetFInfo -> HGetFInfo * FSpCreate -> HCreate * FSpOpenDF -> HOpen *** Note: not HOpenDF *** * FSMakeFSSpec -> (fill in spec by hand.) * * (Use HOpen instead of HOpenDF. HOpen is just a glue-interface to PBHOpen, * which is on all HFS macs. HOpenDF is a System 7 addition which avoids the * ages-old problem of names starting with a period.) * * Contributed by Sam Bushell (jsam@iagu.on.net) and * Dan Gildor (gyld@in-touch.com). */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jmemsys.h" /* import the system-dependent declarations */ #ifndef USE_MAC_MEMMGR /* make sure user got configuration right */ You forgot to define USE_MAC_MEMMGR in jconfig.h. /* deliberate syntax error */ #endif #include /* we use the MacOS memory manager */ #include /* we use the MacOS File stuff */ #include /* we use the MacOS HFS stuff */ #include /* for smSystemScript */ #include /* we use Gestalt to test for specific functionality */ #ifndef TEMP_FILE_NAME /* can override from jconfig.h or Makefile */ #define TEMP_FILE_NAME "JPG%03d.TMP" #endif static int next_file_num; /* to distinguish among several temp files */ /* * Memory allocation and freeing are controlled by the MacOS library * routines NewPtr() and DisposePtr(), which allocate fixed-address * storage. Unfortunately, the IJG library isn't smart enough to cope * with relocatable storage. */ GLOBAL(void *) jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject) { return (void *) NewPtr(sizeofobject); } GLOBAL(void) jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject) { DisposePtr((Ptr) object); } /* * "Large" objects are treated the same as "small" ones. * NB: we include FAR keywords in the routine declarations simply for * consistency with the rest of the IJG code; FAR should expand to empty * on rational architectures like the Mac. */ GLOBAL(void FAR *) jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject) { return (void FAR *) NewPtr(sizeofobject); } GLOBAL(void) jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject) { DisposePtr((Ptr) object); } /* * This routine computes the total memory space available for allocation. */ GLOBAL(long) jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed, long max_bytes_needed, long already_allocated) { long limit = cinfo->mem->max_memory_to_use - already_allocated; long slop, mem; /* Don't ask for more than what application has told us we may use */ if (max_bytes_needed > limit && limit > 0) max_bytes_needed = limit; /* Find whether there's a big enough free block in the heap. * CompactMem tries to create a contiguous block of the requested size, * and then returns the size of the largest free block (which could be * much more or much less than we asked for). * We add some slop to ensure we don't use up all available memory. */ slop = max_bytes_needed / 16 + 32768L; mem = CompactMem(max_bytes_needed + slop) - slop; if (mem < 0) mem = 0; /* sigh, couldn't even get the slop */ /* Don't take more than the application says we can have */ if (mem > limit && limit > 0) mem = limit; return mem; } /* * Backing store (temporary file) management. * Backing store objects are only used when the value returned by * jpeg_mem_available is less than the total space needed. You can dispense * with these routines if you have plenty of virtual memory; see jmemnobs.c. */ METHODDEF(void) read_backing_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { long bytes = byte_count; long retVal; if ( SetFPos ( info->temp_file, fsFromStart, file_offset ) != noErr ) ERREXIT(cinfo, JERR_TFILE_SEEK); retVal = FSRead ( info->temp_file, &bytes, (unsigned char *) buffer_address ); if ( retVal != noErr || bytes != byte_count ) ERREXIT(cinfo, JERR_TFILE_READ); } METHODDEF(void) write_backing_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { long bytes = byte_count; long retVal; if ( SetFPos ( info->temp_file, fsFromStart, file_offset ) != noErr ) ERREXIT(cinfo, JERR_TFILE_SEEK); retVal = FSWrite ( info->temp_file, &bytes, (unsigned char *) buffer_address ); if ( retVal != noErr || bytes != byte_count ) ERREXIT(cinfo, JERR_TFILE_WRITE); } METHODDEF(void) close_backing_store (j_common_ptr cinfo, backing_store_ptr info) { FSClose ( info->temp_file ); FSpDelete ( &(info->tempSpec) ); } /* * Initial opening of a backing-store object. * * This version uses FindFolder to find the Temporary Items folder, * and puts the temporary file in there. */ GLOBAL(void) jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed) { short tmpRef, vRefNum; long dirID; FInfo finderInfo; FSSpec theSpec; Str255 fName; OSErr osErr; long gestaltResponse = 0; /* Check that FSSpec calls are available. */ osErr = Gestalt( gestaltFSAttr, &gestaltResponse ); if ( ( osErr != noErr ) || !( gestaltResponse & (1<temp_name, TEMP_FILE_NAME, next_file_num); strcpy ( (Ptr)fName+1, info->temp_name ); *fName = strlen (info->temp_name); osErr = FSMakeFSSpec ( vRefNum, dirID, fName, &theSpec ); if ( (osErr = FSpGetFInfo ( &theSpec, &finderInfo ) ) != noErr ) break; } osErr = FSpCreate ( &theSpec, '????', '????', smSystemScript ); if ( osErr != noErr ) ERREXITS(cinfo, JERR_TFILE_CREATE, info->temp_name); osErr = FSpOpenDF ( &theSpec, fsRdWrPerm, &(info->temp_file) ); if ( osErr != noErr ) ERREXITS(cinfo, JERR_TFILE_CREATE, info->temp_name); info->tempSpec = theSpec; info->read_backing_store = read_backing_store; info->write_backing_store = write_backing_store; info->close_backing_store = close_backing_store; TRACEMSS(cinfo, 1, JTRC_TFILE_OPEN, info->temp_name); } /* * These routines take care of any system-dependent initialization and * cleanup required. */ GLOBAL(long) jpeg_mem_init (j_common_ptr cinfo) { next_file_num = 0; /* max_memory_to_use will be initialized to FreeMem()'s result; * the calling application might later reduce it, for example * to leave room to invoke multiple JPEG objects. * Note that FreeMem returns the total number of free bytes; * it may not be possible to allocate a single block of this size. */ return FreeMem(); } GLOBAL(void) jpeg_mem_term (j_common_ptr cinfo) { /* no work */ } Papyrus3/JpegDir/JpgLossy/CONFIG.LOG0000755000175000017500000000722307535143454014153 0ustar This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. configure:538: checking for gcc configure:615: checking whether the C compiler (gcc ) works configure:629: gcc -o conftest conftest.c 1>&5 configure:649: checking whether the C compiler (gcc ) is a cross-compiler configure:654: checking whether we are using GNU C configure:663: gcc -E conftest.c configure:681: checking how to run the C preprocessor configure:702: gcc -E conftest.c >/dev/null 2>conftest.out configure:742: checking for function prototypes configure:765: gcc -c -O2 conftest.c 1>&5 configure:792: checking for stddef.h configure:802: gcc -E conftest.c >/dev/null 2>conftest.out configure:828: checking for stdlib.h configure:838: gcc -E conftest.c >/dev/null 2>conftest.out configure:864: checking for string.h configure:874: gcc -E conftest.c >/dev/null 2>conftest.out configure:900: checking for size_t configure:923: gcc -c -O2 conftest.c 1>&5 configure:994: checking for type unsigned char configure:1003: gcc -c -O2 conftest.c 1>&5 configure:1018: checking for type unsigned short configure:1027: gcc -c -O2 conftest.c 1>&5 configure:1042: checking for type void configure:1072: gcc -c -O2 conftest.c 1>&5 configure:1088: checking for working const configure:1142: gcc -c -O2 conftest.c 1>&5 configure:1163: checking for inline configure:1174: gcc -c -O2 conftest.c 1>&5 configure:1224: checking for broken incomplete types configure:1233: gcc -c -O2 conftest.c 1>&5 configure:1248: checking for short external names configure:1260: gcc -o conftest -O2 conftest.c 1>&5 configure:1275: checking to see if char is signed configure:1306: gcc -o conftest -O2 conftest.c 1>&5 configure: failed program was: #line 1282 "configure" #include "confdefs.h" #ifdef HAVE_PROTOTYPES int is_char_signed (int arg) #else int is_char_signed (arg) int arg; #endif { if (arg == 189) { /* expected result for unsigned char */ return 0; /* type char is unsigned */ } else if (arg != -67) { /* expected result for signed char */ printf("Hmm, it seems 'char' is not eight bits wide on your machine.\n"); printf("I fear the JPEG software will not work at all.\n\n"); } return 1; /* assume char is signed otherwise */ } char signed_char_check = (char) (-67); main() { exit(is_char_signed((int) signed_char_check)); } configure:1323: checking to see if right shift is signed configure:1358: gcc -o conftest -O2 conftest.c 1>&5 configure: failed program was: #line 1328 "configure" #include "confdefs.h" #ifdef HAVE_PROTOTYPES int is_shifting_signed (long arg) #else int is_shifting_signed (arg) long arg; #endif /* See whether right-shift on a long is signed or not. */ { long res = arg >> 4; if (res == -0x7F7E80CL) { /* expected result for signed shift */ return 1; /* right shift is signed */ } /* see if unsigned-shift hack will fix it. */ /* we can't just test exact value since it depends on width of long... */ res |= (~0L) << (32-4); if (res == -0x7F7E80CL) { /* expected result now? */ return 0; /* right shift is unsigned */ } printf("Right shift isn't acting as I expect it to.\n"); printf("I fear the JPEG software will not work at all.\n\n"); return 0; /* try it with unsigned anyway */ } main() { exit(is_shifting_signed(-0x7F7E80B1L)); } configure:1375: checking to see if fopen accepts b spec configure:1390: gcc -o conftest -O2 conftest.c 1>&5 configure:1436: checking for a BSD compatible install configure:1488: checking for ranlib configure:1650: checking libjpeg version number Papyrus3/JpegDir/JpgLossy/jconfig.cfg0000755000175000017500000000230707535143454014741 0ustar /* jconfig.cfg --- source file edited by configure script */ /* see jconfig.doc for explanations */ #undef HAVE_PROTOTYPES #undef HAVE_UNSIGNED_CHAR #undef HAVE_UNSIGNED_SHORT #undef void #undef const #undef CHAR_IS_UNSIGNED #undef HAVE_STDDEF_H #undef HAVE_STDLIB_H #undef NEED_BSD_STRINGS #undef NEED_SYS_TYPES_H #undef NEED_FAR_POINTERS #undef NEED_SHORT_EXTERNAL_NAMES /* Define this if you get warnings about undefined structures. */ #undef INCOMPLETE_TYPES_BROKEN #ifdef JPEG_INTERNALS #undef RIGHT_SHIFT_IS_UNSIGNED #undef INLINE /* These are for configuring the JPEG memory manager. */ #undef DEFAULT_MAX_MEM #undef NO_MKTEMP #endif /* JPEG_INTERNALS */ #ifdef JPEG_CJPEG_DJPEG #define BMP_SUPPORTED /* BMP image file format */ #define GIF_SUPPORTED /* GIF image file format */ #define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ #undef RLE_SUPPORTED /* Utah RLE image file format */ #define TARGA_SUPPORTED /* Targa image file format */ #undef TWO_FILE_COMMANDLINE #undef NEED_SIGNAL_CATCHER #undef DONT_USE_B_MODE /* Define this if you want percent-done progress reports from cjpeg/djpeg. */ #undef PROGRESS_REPORT #endif /* JPEG_CJPEG_DJPEG */ Papyrus3/JpegDir/JpgLossy/JIDCTFST.C0000755000175000017500000003234207535143454014161 0ustar /* * jidctfst.c * * Copyright (C) 1994-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains a fast, not so accurate integer implementation of the * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine * must also perform dequantization of the input coefficients. * * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT * on each row (or vice versa, but it's more convenient to emit a row at * a time). Direct algorithms are also available, but they are much more * complex and seem not to be any faster when reduced to code. * * This implementation is based on Arai, Agui, and Nakajima's algorithm for * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in * Japanese, but the algorithm is described in the Pennebaker & Mitchell * JPEG textbook (see REFERENCES section in file README). The following code * is based directly on figure 4-8 in P&M. * While an 8-point DCT cannot be done in less than 11 multiplies, it is * possible to arrange the computation so that many of the multiplies are * simple scalings of the final outputs. These multiplies can then be * folded into the multiplications or divisions by the JPEG quantization * table entries. The AA&N method leaves only 5 multiplies and 29 adds * to be done in the DCT itself. * The primary disadvantage of this method is that with fixed-point math, * accuracy is lost due to imprecise representation of the scaled * quantization values. The smaller the quantization table entry, the less * precise the scaled value, so this implementation does worse with high- * quality-setting files than with low-quality ones. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jdct.h" /* Private declarations for DCT subsystem */ #ifdef DCT_IFAST_SUPPORTED /* * This module is specialized to the case DCTSIZE = 8. */ #if DCTSIZE != 8 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ #endif /* Scaling decisions are generally the same as in the LL&M algorithm; * see jidctint.c for more details. However, we choose to descale * (right shift) multiplication products as soon as they are formed, * rather than carrying additional fractional bits into subsequent additions. * This compromises accuracy slightly, but it lets us save a few shifts. * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples) * everywhere except in the multiplications proper; this saves a good deal * of work on 16-bit-int machines. * * The dequantized coefficients are not integers because the AA&N scaling * factors have been incorporated. We represent them scaled up by PASS1_BITS, * so that the first and second IDCT rounds have the same input scaling. * For 8-bit JSAMPLEs, we choose IFAST_SCALE_BITS = PASS1_BITS so as to * avoid a descaling shift; this compromises accuracy rather drastically * for small quantization table entries, but it saves a lot of shifts. * For 12-bit JSAMPLEs, there's no hope of using 16x16 multiplies anyway, * so we use a much larger scaling factor to preserve accuracy. * * A final compromise is to represent the multiplicative constants to only * 8 fractional bits, rather than 13. This saves some shifting work on some * machines, and may also reduce the cost of multiplication (since there * are fewer one-bits in the constants). */ #if BITS_IN_JSAMPLE == 8 #define CONST_BITS 8 #define PASS1_BITS 2 #else #define CONST_BITS 8 #define PASS1_BITS 1 /* lose a little precision to avoid overflow */ #endif /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus * causing a lot of useless floating-point operations at run time. * To get around this we use the following pre-calculated constants. * If you change CONST_BITS you may want to add appropriate values. * (With a reasonable C compiler, you can just rely on the FIX() macro...) */ #if CONST_BITS == 8 #define FIX_1_082392200 ((INT32) 277) /* FIX(1.082392200) */ #define FIX_1_414213562 ((INT32) 362) /* FIX(1.414213562) */ #define FIX_1_847759065 ((INT32) 473) /* FIX(1.847759065) */ #define FIX_2_613125930 ((INT32) 669) /* FIX(2.613125930) */ #else #define FIX_1_082392200 FIX(1.082392200) #define FIX_1_414213562 FIX(1.414213562) #define FIX_1_847759065 FIX(1.847759065) #define FIX_2_613125930 FIX(2.613125930) #endif /* We can gain a little more speed, with a further compromise in accuracy, * by omitting the addition in a descaling shift. This yields an incorrectly * rounded result half the time... */ #ifndef USE_ACCURATE_ROUNDING #undef DESCALE #define DESCALE(x,n) RIGHT_SHIFT(x, n) #endif /* Multiply a DCTELEM variable by an INT32 constant, and immediately * descale to yield a DCTELEM result. */ #define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS)) /* Dequantize a coefficient by multiplying it by the multiplier-table * entry; produce a DCTELEM result. For 8-bit data a 16x16->16 * multiplication will do. For 12-bit data, the multiplier table is * declared INT32, so a 32-bit multiply will be used. */ #if BITS_IN_JSAMPLE == 8 #define DEQUANTIZE(coef,quantval) (((IFAST_MULT_TYPE) (coef)) * (quantval)) #else #define DEQUANTIZE(coef,quantval) \ DESCALE((coef)*(quantval), IFAST_SCALE_BITS-PASS1_BITS) #endif /* Like DESCALE, but applies to a DCTELEM and produces an int. * We assume that int right shift is unsigned if INT32 right shift is. */ #ifdef RIGHT_SHIFT_IS_UNSIGNED #define ISHIFT_TEMPS DCTELEM ishift_temp; #if BITS_IN_JSAMPLE == 8 #define DCTELEMBITS 16 /* DCTELEM may be 16 or 32 bits */ #else #define DCTELEMBITS 32 /* DCTELEM must be 32 bits */ #endif #define IRIGHT_SHIFT(x,shft) \ ((ishift_temp = (x)) < 0 ? \ (ishift_temp >> (shft)) | ((~((DCTELEM) 0)) << (DCTELEMBITS-(shft))) : \ (ishift_temp >> (shft))) #else #define ISHIFT_TEMPS #define IRIGHT_SHIFT(x,shft) ((x) >> (shft)) #endif #ifdef USE_ACCURATE_ROUNDING #define IDESCALE(x,n) ((int) IRIGHT_SHIFT((x) + (1 << ((n)-1)), n)) #else #define IDESCALE(x,n) ((int) IRIGHT_SHIFT(x, n)) #endif /* * Perform dequantization and inverse DCT on one block of coefficients. */ GLOBAL(void) jpeg_idct_ifast (j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col) { DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; DCTELEM tmp10, tmp11, tmp12, tmp13; DCTELEM z5, z10, z11, z12, z13; JCOEFPTR inptr; IFAST_MULT_TYPE * quantptr; int * wsptr; JSAMPROW outptr; JSAMPLE *range_limit = IDCT_range_limit(cinfo); int ctr; int workspace[DCTSIZE2]; /* buffers data between passes */ SHIFT_TEMPS /* for DESCALE */ ISHIFT_TEMPS /* for IDESCALE */ /* Pass 1: process columns from input, store into work array. */ inptr = coef_block; quantptr = (IFAST_MULT_TYPE *) compptr->dct_table; wsptr = workspace; for (ctr = DCTSIZE; ctr > 0; ctr--) { /* Due to quantization, we will usually find that many of the input * coefficients are zero, especially the AC terms. We can exploit this * by short-circuiting the IDCT calculation for any column in which all * the AC terms are zero. In that case each output is equal to the * DC coefficient (with scale factor as needed). * With typical images and quantization tables, half or more of the * column DCT calculations can be simplified this way. */ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 && inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 && inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 && inptr[DCTSIZE*7] == 0) { /* AC terms all zero */ int dcval = (int) DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); wsptr[DCTSIZE*0] = dcval; wsptr[DCTSIZE*1] = dcval; wsptr[DCTSIZE*2] = dcval; wsptr[DCTSIZE*3] = dcval; wsptr[DCTSIZE*4] = dcval; wsptr[DCTSIZE*5] = dcval; wsptr[DCTSIZE*6] = dcval; wsptr[DCTSIZE*7] = dcval; inptr++; /* advance pointers to next column */ quantptr++; wsptr++; continue; } /* Even part */ tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]); tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]); tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]); tmp10 = tmp0 + tmp2; /* phase 3 */ tmp11 = tmp0 - tmp2; tmp13 = tmp1 + tmp3; /* phases 5-3 */ tmp12 = MULTIPLY(tmp1 - tmp3, FIX_1_414213562) - tmp13; /* 2*c4 */ tmp0 = tmp10 + tmp13; /* phase 2 */ tmp3 = tmp10 - tmp13; tmp1 = tmp11 + tmp12; tmp2 = tmp11 - tmp12; /* Odd part */ tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]); tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]); tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]); tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]); z13 = tmp6 + tmp5; /* phase 6 */ z10 = tmp6 - tmp5; z11 = tmp4 + tmp7; z12 = tmp4 - tmp7; tmp7 = z11 + z13; /* phase 5 */ tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */ z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */ tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */ tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5; /* -2*(c2+c6) */ tmp6 = tmp12 - tmp7; /* phase 2 */ tmp5 = tmp11 - tmp6; tmp4 = tmp10 + tmp5; wsptr[DCTSIZE*0] = (int) (tmp0 + tmp7); wsptr[DCTSIZE*7] = (int) (tmp0 - tmp7); wsptr[DCTSIZE*1] = (int) (tmp1 + tmp6); wsptr[DCTSIZE*6] = (int) (tmp1 - tmp6); wsptr[DCTSIZE*2] = (int) (tmp2 + tmp5); wsptr[DCTSIZE*5] = (int) (tmp2 - tmp5); wsptr[DCTSIZE*4] = (int) (tmp3 + tmp4); wsptr[DCTSIZE*3] = (int) (tmp3 - tmp4); inptr++; /* advance pointers to next column */ quantptr++; wsptr++; } /* Pass 2: process rows from work array, store into output array. */ /* Note that we must descale the results by a factor of 8 == 2**3, */ /* and also undo the PASS1_BITS scaling. */ wsptr = workspace; for (ctr = 0; ctr < DCTSIZE; ctr++) { outptr = output_buf[ctr] + output_col; /* Rows of zeroes can be exploited in the same way as we did with columns. * However, the column calculation has created many nonzero AC terms, so * the simplification applies less often (typically 5% to 10% of the time). * On machines with very fast multiplication, it's possible that the * test takes more time than it's worth. In that case this section * may be commented out. */ #ifndef NO_ZERO_ROW_TEST if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 && wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) { /* AC terms all zero */ JSAMPLE dcval = range_limit[IDESCALE(wsptr[0], PASS1_BITS+3) & RANGE_MASK]; outptr[0] = dcval; outptr[1] = dcval; outptr[2] = dcval; outptr[3] = dcval; outptr[4] = dcval; outptr[5] = dcval; outptr[6] = dcval; outptr[7] = dcval; wsptr += DCTSIZE; /* advance pointer to next row */ continue; } #endif /* Even part */ tmp10 = ((DCTELEM) wsptr[0] + (DCTELEM) wsptr[4]); tmp11 = ((DCTELEM) wsptr[0] - (DCTELEM) wsptr[4]); tmp13 = ((DCTELEM) wsptr[2] + (DCTELEM) wsptr[6]); tmp12 = MULTIPLY((DCTELEM) wsptr[2] - (DCTELEM) wsptr[6], FIX_1_414213562) - tmp13; tmp0 = tmp10 + tmp13; tmp3 = tmp10 - tmp13; tmp1 = tmp11 + tmp12; tmp2 = tmp11 - tmp12; /* Odd part */ z13 = (DCTELEM) wsptr[5] + (DCTELEM) wsptr[3]; z10 = (DCTELEM) wsptr[5] - (DCTELEM) wsptr[3]; z11 = (DCTELEM) wsptr[1] + (DCTELEM) wsptr[7]; z12 = (DCTELEM) wsptr[1] - (DCTELEM) wsptr[7]; tmp7 = z11 + z13; /* phase 5 */ tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */ z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */ tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */ tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5; /* -2*(c2+c6) */ tmp6 = tmp12 - tmp7; /* phase 2 */ tmp5 = tmp11 - tmp6; tmp4 = tmp10 + tmp5; /* Final output stage: scale down by a factor of 8 and range-limit */ outptr[0] = range_limit[IDESCALE(tmp0 + tmp7, PASS1_BITS+3) & RANGE_MASK]; outptr[7] = range_limit[IDESCALE(tmp0 - tmp7, PASS1_BITS+3) & RANGE_MASK]; outptr[1] = range_limit[IDESCALE(tmp1 + tmp6, PASS1_BITS+3) & RANGE_MASK]; outptr[6] = range_limit[IDESCALE(tmp1 - tmp6, PASS1_BITS+3) & RANGE_MASK]; outptr[2] = range_limit[IDESCALE(tmp2 + tmp5, PASS1_BITS+3) & RANGE_MASK]; outptr[5] = range_limit[IDESCALE(tmp2 - tmp5, PASS1_BITS+3) & RANGE_MASK]; outptr[4] = range_limit[IDESCALE(tmp3 + tmp4, PASS1_BITS+3) & RANGE_MASK]; outptr[3] = range_limit[IDESCALE(tmp3 - tmp4, PASS1_BITS+3) & RANGE_MASK]; wsptr += DCTSIZE; /* advance pointer to next row */ } } #endif /* DCT_IFAST_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/makefile.unix0000755000175000017500000003015707535143454015327 0ustar # Makefile for Independent JPEG Group's software # This makefile is suitable for Unix-like systems with non-ANSI compilers. # If you have an ANSI compiler, makefile.ansi is a better starting point. # Read installation instructions before saying "make" !! # The name of your C compiler: CC= cc # You may need to adjust these cc options: CFLAGS= -O # Generally, we recommend defining any configuration symbols in jconfig.h, # NOT via -D switches here. # However, any special defines for ansi2knr.c may be included here: ANSI2KNRFLAGS= # Link-time cc options: LDFLAGS= # To link any special libraries, add the necessary -l commands here. LDLIBS= # Put here the object file name for the correct system-dependent memory # manager file. For Unix this is usually jmemnobs.o, but you may want # to use jmemansi.o or jmemname.o if you have limited swap space. SYSDEPMEM= jmemnobs.o # miscellaneous OS-dependent stuff # linker LN= $(CC) # file deletion command RM= rm -f # file rename command MV= mv # library (.a) file creation command AR= ar rc # second step in .a creation (use "touch" if not needed) AR2= ranlib # End of configurable options. # source files: JPEG library proper LIBSOURCES= jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c \ jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c \ jcphuff.c jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c \ jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c \ jdinput.c jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c \ jdpostct.c jdsample.c jdtrans.c jerror.c jfdctflt.c jfdctfst.c \ jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c jquant1.c \ jquant2.c jutils.c jmemmgr.c # memmgr back ends: compile only one of these into a working library SYSDEPSOURCES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemmac.c # source files: cjpeg/djpeg/jpegtran applications, also rdjpgcom/wrjpgcom APPSOURCES= cjpeg.c djpeg.c jpegtran.c rdjpgcom.c wrjpgcom.c cdjpeg.c \ rdcolmap.c rdswitch.c transupp.c rdppm.c wrppm.c rdgif.c wrgif.c \ rdtarga.c wrtarga.c rdbmp.c wrbmp.c rdrle.c wrrle.c SOURCES= $(LIBSOURCES) $(SYSDEPSOURCES) $(APPSOURCES) # files included by source files INCLUDES= jchuff.h jdhuff.h jdct.h jerror.h jinclude.h jmemsys.h jmorecfg.h \ jpegint.h jpeglib.h jversion.h cdjpeg.h cderror.h transupp.h # documentation, test, and support files DOCS= README install.doc usage.doc cjpeg.1 djpeg.1 jpegtran.1 rdjpgcom.1 \ wrjpgcom.1 wizard.doc example.c libjpeg.doc structure.doc \ coderules.doc filelist.doc change.log MKFILES= configure makefile.cfg makefile.ansi makefile.unix makefile.bcc \ makefile.mc6 makefile.dj makefile.wat makefile.vc makelib.ds \ makeapps.ds makeproj.mac makcjpeg.st makdjpeg.st makljpeg.st \ maktjpeg.st makefile.manx makefile.sas makefile.mms makefile.vms \ makvms.opt CONFIGFILES= jconfig.cfg jconfig.bcc jconfig.mc6 jconfig.dj jconfig.wat \ jconfig.vc jconfig.mac jconfig.st jconfig.manx jconfig.sas \ jconfig.vms CONFIGUREFILES= config.guess config.sub install-sh ltconfig ltmain.sh OTHERFILES= jconfig.doc ckconfig.c ansi2knr.c ansi2knr.1 jmemdosa.asm TESTFILES= testorig.jpg testimg.ppm testimg.bmp testimg.jpg testprog.jpg \ testimgp.jpg DISTFILES= $(DOCS) $(MKFILES) $(CONFIGFILES) $(SOURCES) $(INCLUDES) \ $(CONFIGUREFILES) $(OTHERFILES) $(TESTFILES) # library object files common to compression and decompression COMOBJECTS= jcomapi.o jutils.o jerror.o jmemmgr.o $(SYSDEPMEM) # compression library object files CLIBOBJECTS= jcapimin.o jcapistd.o jctrans.o jcparam.o jdatadst.o jcinit.o \ jcmaster.o jcmarker.o jcmainct.o jcprepct.o jccoefct.o jccolor.o \ jcsample.o jchuff.o jcphuff.o jcdctmgr.o jfdctfst.o jfdctflt.o \ jfdctint.o # decompression library object files DLIBOBJECTS= jdapimin.o jdapistd.o jdtrans.o jdatasrc.o jdmaster.o \ jdinput.o jdmarker.o jdhuff.o jdphuff.o jdmainct.o jdcoefct.o \ jdpostct.o jddctmgr.o jidctfst.o jidctflt.o jidctint.o jidctred.o \ jdsample.o jdcolor.o jquant1.o jquant2.o jdmerge.o # These objectfiles are included in libjpeg.a LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS) # object files for sample applications (excluding library files) COBJECTS= cjpeg.o rdppm.o rdgif.o rdtarga.o rdrle.o rdbmp.o rdswitch.o \ cdjpeg.o DOBJECTS= djpeg.o wrppm.o wrgif.o wrtarga.o wrrle.o wrbmp.o rdcolmap.o \ cdjpeg.o TROBJECTS= jpegtran.o rdswitch.o cdjpeg.o transupp.o all: ansi2knr libjpeg.a cjpeg djpeg jpegtran rdjpgcom wrjpgcom # This rule causes ansi2knr to be invoked. .c.o: ./ansi2knr $*.c T$*.c $(CC) $(CFLAGS) -c T$*.c $(RM) T$*.c $*.o $(MV) T$*.o $*.o ansi2knr: ansi2knr.c $(CC) $(CFLAGS) $(ANSI2KNRFLAGS) -o ansi2knr ansi2knr.c libjpeg.a: ansi2knr $(LIBOBJECTS) $(RM) libjpeg.a $(AR) libjpeg.a $(LIBOBJECTS) $(AR2) libjpeg.a cjpeg: ansi2knr $(COBJECTS) libjpeg.a $(LN) $(LDFLAGS) -o cjpeg $(COBJECTS) libjpeg.a $(LDLIBS) djpeg: ansi2knr $(DOBJECTS) libjpeg.a $(LN) $(LDFLAGS) -o djpeg $(DOBJECTS) libjpeg.a $(LDLIBS) jpegtran: ansi2knr $(TROBJECTS) libjpeg.a $(LN) $(LDFLAGS) -o jpegtran $(TROBJECTS) libjpeg.a $(LDLIBS) rdjpgcom: rdjpgcom.o $(LN) $(LDFLAGS) -o rdjpgcom rdjpgcom.o $(LDLIBS) wrjpgcom: wrjpgcom.o $(LN) $(LDFLAGS) -o wrjpgcom wrjpgcom.o $(LDLIBS) jconfig.h: jconfig.doc echo You must prepare a system-dependent jconfig.h file. echo Please read the installation directions in install.doc. exit 1 clean: $(RM) *.o cjpeg djpeg jpegtran libjpeg.a rdjpgcom wrjpgcom $(RM) ansi2knr core testout* test: cjpeg djpeg jpegtran $(RM) testout* ./djpeg -dct int -ppm -outfile testout.ppm testorig.jpg ./djpeg -dct int -bmp -colors 256 -outfile testout.bmp testorig.jpg ./cjpeg -dct int -outfile testout.jpg testimg.ppm ./djpeg -dct int -ppm -outfile testoutp.ppm testprog.jpg ./cjpeg -dct int -progressive -opt -outfile testoutp.jpg testimg.ppm ./jpegtran -outfile testoutt.jpg testprog.jpg cmp testimg.ppm testout.ppm cmp testimg.bmp testout.bmp cmp testimg.jpg testout.jpg cmp testimg.ppm testoutp.ppm cmp testimgp.jpg testoutp.jpg cmp testorig.jpg testoutt.jpg jcapimin.o: jcapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcapistd.o: jcapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccoefct.o: jccoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccolor.o: jccolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcdctmgr.o: jcdctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jchuff.o: jchuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcinit.o: jcinit.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmainct.o: jcmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmarker.o: jcmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmaster.o: jcmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcomapi.o: jcomapi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcparam.o: jcparam.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcphuff.o: jcphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcprepct.o: jcprepct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcsample.o: jcsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jctrans.o: jctrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapimin.o: jdapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapistd.o: jdapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdatadst.o: jdatadst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdatasrc.o: jdatasrc.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdcoefct.o: jdcoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdcolor.o: jdcolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jddctmgr.o: jddctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jdhuff.o: jdhuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdinput.o: jdinput.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmainct.o: jdmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmarker.o: jdmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmaster.o: jdmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmerge.o: jdmerge.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdphuff.o: jdphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdpostct.o: jdpostct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdsample.o: jdsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdtrans.o: jdtrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jerror.o: jerror.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jversion.h jerror.h jfdctflt.o: jfdctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctfst.o: jfdctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctint.o: jfdctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctflt.o: jidctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctfst.o: jidctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctint.o: jidctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctred.o: jidctred.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jquant1.o: jquant1.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jquant2.o: jquant2.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jutils.o: jutils.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemmgr.o: jmemmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemansi.o: jmemansi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemname.o: jmemname.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemnobs.o: jmemnobs.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemdos.o: jmemdos.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemmac.o: jmemmac.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h cjpeg.o: cjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h djpeg.o: djpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h jpegtran.o: jpegtran.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.h jversion.h rdjpgcom.o: rdjpgcom.c jinclude.h jconfig.h wrjpgcom.o: wrjpgcom.c jinclude.h jconfig.h cdjpeg.o: cdjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdcolmap.o: rdcolmap.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdswitch.o: rdswitch.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.o: transupp.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h transupp.h rdppm.o: rdppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrppm.o: wrppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdgif.o: rdgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrgif.o: wrgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdtarga.o: rdtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrtarga.o: wrtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdbmp.o: rdbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrbmp.o: wrbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdrle.o: rdrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrrle.o: wrrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h Papyrus3/JpegDir/JpgLossy/TRANSUPP.C0000755000175000017500000010142607535143454014223 0ustar /* * transupp.c * * Copyright (C) 1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains image transformation routines and other utility code * used by the jpegtran sample application. These are NOT part of the core * JPEG library. But we keep these routines separate from jpegtran.c to * ease the task of maintaining jpegtran-like programs that have other user * interfaces. */ /* Although this file really shouldn't have access to the library internals, * it's helpful to let it call jround_up() and jcopy_block_row(). */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "transupp.h" /* My own external interface */ #if TRANSFORMS_SUPPORTED /* * Lossless image transformation routines. These routines work on DCT * coefficient arrays and thus do not require any lossy decompression * or recompression of the image. * Thanks to Guido Vollbeding for the initial design and code of this feature. * * Horizontal flipping is done in-place, using a single top-to-bottom * pass through the virtual source array. It will thus be much the * fastest option for images larger than main memory. * * The other routines require a set of destination virtual arrays, so they * need twice as much memory as jpegtran normally does. The destination * arrays are always written in normal scan order (top to bottom) because * the virtual array manager expects this. The source arrays will be scanned * in the corresponding order, which means multiple passes through the source * arrays for most of the transforms. That could result in much thrashing * if the image is larger than main memory. * * Some notes about the operating environment of the individual transform * routines: * 1. Both the source and destination virtual arrays are allocated from the * source JPEG object, and therefore should be manipulated by calling the * source's memory manager. * 2. The destination's component count should be used. It may be smaller * than the source's when forcing to grayscale. * 3. Likewise the destination's sampling factors should be used. When * forcing to grayscale the destination's sampling factors will be all 1, * and we may as well take that as the effective iMCU size. * 4. When "trim" is in effect, the destination's dimensions will be the * trimmed values but the source's will be untrimmed. * 5. All the routines assume that the source and destination buffers are * padded out to a full iMCU boundary. This is true, although for the * source buffer it is an undocumented property of jdcoefct.c. * Notes 2,3,4 boil down to this: generally we should use the destination's * dimensions and ignore the source's. */ LOCAL(void) do_flip_h (j_decompress_ptr srcinfo, j_compress_ptr dstinfo, jvirt_barray_ptr *src_coef_arrays) /* Horizontal flip; done in-place, so no separate dest array is required */ { JDIMENSION MCU_cols, comp_width, blk_x, blk_y; int ci, k, offset_y; JBLOCKARRAY buffer; JCOEFPTR ptr1, ptr2; JCOEF temp1, temp2; jpeg_component_info *compptr; /* Horizontal mirroring of DCT blocks is accomplished by swapping * pairs of blocks in-place. Within a DCT block, we perform horizontal * mirroring by changing the signs of odd-numbered columns. * Partial iMCUs at the right edge are left untouched. */ MCU_cols = dstinfo->image_width / (dstinfo->max_h_samp_factor * DCTSIZE); for (ci = 0; ci < dstinfo->num_components; ci++) { compptr = dstinfo->comp_info + ci; comp_width = MCU_cols * compptr->h_samp_factor; for (blk_y = 0; blk_y < compptr->height_in_blocks; blk_y += compptr->v_samp_factor) { buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, src_coef_arrays[ci], blk_y, (JDIMENSION) compptr->v_samp_factor, TRUE); for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) { for (blk_x = 0; blk_x * 2 < comp_width; blk_x++) { ptr1 = buffer[offset_y][blk_x]; ptr2 = buffer[offset_y][comp_width - blk_x - 1]; /* this unrolled loop doesn't need to know which row it's on... */ for (k = 0; k < DCTSIZE2; k += 2) { temp1 = *ptr1; /* swap even column */ temp2 = *ptr2; *ptr1++ = temp2; *ptr2++ = temp1; temp1 = *ptr1; /* swap odd column with sign change */ temp2 = *ptr2; *ptr1++ = -temp2; *ptr2++ = -temp1; } } } } } } LOCAL(void) do_flip_v (j_decompress_ptr srcinfo, j_compress_ptr dstinfo, jvirt_barray_ptr *src_coef_arrays, jvirt_barray_ptr *dst_coef_arrays) /* Vertical flip */ { JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y; int ci, i, j, offset_y; JBLOCKARRAY src_buffer, dst_buffer; JBLOCKROW src_row_ptr, dst_row_ptr; JCOEFPTR src_ptr, dst_ptr; jpeg_component_info *compptr; /* We output into a separate array because we can't touch different * rows of the source virtual array simultaneously. Otherwise, this * is a pretty straightforward analog of horizontal flip. * Within a DCT block, vertical mirroring is done by changing the signs * of odd-numbered rows. * Partial iMCUs at the bottom edge are copied verbatim. */ MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE); for (ci = 0; ci < dstinfo->num_components; ci++) { compptr = dstinfo->comp_info + ci; comp_height = MCU_rows * compptr->v_samp_factor; for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks; dst_blk_y += compptr->v_samp_factor) { dst_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y, (JDIMENSION) compptr->v_samp_factor, TRUE); if (dst_blk_y < comp_height) { /* Row is within the mirrorable area. */ src_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, src_coef_arrays[ci], comp_height - dst_blk_y - (JDIMENSION) compptr->v_samp_factor, (JDIMENSION) compptr->v_samp_factor, FALSE); } else { /* Bottom-edge blocks will be copied verbatim. */ src_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_y, (JDIMENSION) compptr->v_samp_factor, FALSE); } for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) { if (dst_blk_y < comp_height) { /* Row is within the mirrorable area. */ dst_row_ptr = dst_buffer[offset_y]; src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1]; for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) { dst_ptr = dst_row_ptr[dst_blk_x]; src_ptr = src_row_ptr[dst_blk_x]; for (i = 0; i < DCTSIZE; i += 2) { /* copy even row */ for (j = 0; j < DCTSIZE; j++) *dst_ptr++ = *src_ptr++; /* copy odd row with sign change */ for (j = 0; j < DCTSIZE; j++) *dst_ptr++ = - *src_ptr++; } } } else { /* Just copy row verbatim. */ jcopy_block_row(src_buffer[offset_y], dst_buffer[offset_y], compptr->width_in_blocks); } } } } } LOCAL(void) do_transpose (j_decompress_ptr srcinfo, j_compress_ptr dstinfo, jvirt_barray_ptr *src_coef_arrays, jvirt_barray_ptr *dst_coef_arrays) /* Transpose source into destination */ { JDIMENSION dst_blk_x, dst_blk_y; int ci, i, j, offset_x, offset_y; JBLOCKARRAY src_buffer, dst_buffer; JCOEFPTR src_ptr, dst_ptr; jpeg_component_info *compptr; /* Transposing pixels within a block just requires transposing the * DCT coefficients. * Partial iMCUs at the edges require no special treatment; we simply * process all the available DCT blocks for every component. */ for (ci = 0; ci < dstinfo->num_components; ci++) { compptr = dstinfo->comp_info + ci; for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks; dst_blk_y += compptr->v_samp_factor) { dst_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y, (JDIMENSION) compptr->v_samp_factor, TRUE); for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) { for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x += compptr->h_samp_factor) { src_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_x, (JDIMENSION) compptr->h_samp_factor, FALSE); for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) { src_ptr = src_buffer[offset_x][dst_blk_y + offset_y]; dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x]; for (i = 0; i < DCTSIZE; i++) for (j = 0; j < DCTSIZE; j++) dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j]; } } } } } } LOCAL(void) do_rot_90 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo, jvirt_barray_ptr *src_coef_arrays, jvirt_barray_ptr *dst_coef_arrays) /* 90 degree rotation is equivalent to * 1. Transposing the image; * 2. Horizontal mirroring. * These two steps are merged into a single processing routine. */ { JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y; int ci, i, j, offset_x, offset_y; JBLOCKARRAY src_buffer, dst_buffer; JCOEFPTR src_ptr, dst_ptr; jpeg_component_info *compptr; /* Because of the horizontal mirror step, we can't process partial iMCUs * at the (output) right edge properly. They just get transposed and * not mirrored. */ MCU_cols = dstinfo->image_width / (dstinfo->max_h_samp_factor * DCTSIZE); for (ci = 0; ci < dstinfo->num_components; ci++) { compptr = dstinfo->comp_info + ci; comp_width = MCU_cols * compptr->h_samp_factor; for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks; dst_blk_y += compptr->v_samp_factor) { dst_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y, (JDIMENSION) compptr->v_samp_factor, TRUE); for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) { for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x += compptr->h_samp_factor) { src_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_x, (JDIMENSION) compptr->h_samp_factor, FALSE); for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) { src_ptr = src_buffer[offset_x][dst_blk_y + offset_y]; if (dst_blk_x < comp_width) { /* Block is within the mirrorable area. */ dst_ptr = dst_buffer[offset_y] [comp_width - dst_blk_x - offset_x - 1]; for (i = 0; i < DCTSIZE; i++) { for (j = 0; j < DCTSIZE; j++) dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j]; i++; for (j = 0; j < DCTSIZE; j++) dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j]; } } else { /* Edge blocks are transposed but not mirrored. */ dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x]; for (i = 0; i < DCTSIZE; i++) for (j = 0; j < DCTSIZE; j++) dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j]; } } } } } } } LOCAL(void) do_rot_270 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo, jvirt_barray_ptr *src_coef_arrays, jvirt_barray_ptr *dst_coef_arrays) /* 270 degree rotation is equivalent to * 1. Horizontal mirroring; * 2. Transposing the image. * These two steps are merged into a single processing routine. */ { JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y; int ci, i, j, offset_x, offset_y; JBLOCKARRAY src_buffer, dst_buffer; JCOEFPTR src_ptr, dst_ptr; jpeg_component_info *compptr; /* Because of the horizontal mirror step, we can't process partial iMCUs * at the (output) bottom edge properly. They just get transposed and * not mirrored. */ MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE); for (ci = 0; ci < dstinfo->num_components; ci++) { compptr = dstinfo->comp_info + ci; comp_height = MCU_rows * compptr->v_samp_factor; for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks; dst_blk_y += compptr->v_samp_factor) { dst_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y, (JDIMENSION) compptr->v_samp_factor, TRUE); for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) { for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x += compptr->h_samp_factor) { src_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_x, (JDIMENSION) compptr->h_samp_factor, FALSE); for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) { dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x]; if (dst_blk_y < comp_height) { /* Block is within the mirrorable area. */ src_ptr = src_buffer[offset_x] [comp_height - dst_blk_y - offset_y - 1]; for (i = 0; i < DCTSIZE; i++) { for (j = 0; j < DCTSIZE; j++) { dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j]; j++; dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j]; } } } else { /* Edge blocks are transposed but not mirrored. */ src_ptr = src_buffer[offset_x][dst_blk_y + offset_y]; for (i = 0; i < DCTSIZE; i++) for (j = 0; j < DCTSIZE; j++) dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j]; } } } } } } } LOCAL(void) do_rot_180 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo, jvirt_barray_ptr *src_coef_arrays, jvirt_barray_ptr *dst_coef_arrays) /* 180 degree rotation is equivalent to * 1. Vertical mirroring; * 2. Horizontal mirroring. * These two steps are merged into a single processing routine. */ { JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y; int ci, i, j, offset_y; JBLOCKARRAY src_buffer, dst_buffer; JBLOCKROW src_row_ptr, dst_row_ptr; JCOEFPTR src_ptr, dst_ptr; jpeg_component_info *compptr; MCU_cols = dstinfo->image_width / (dstinfo->max_h_samp_factor * DCTSIZE); MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE); for (ci = 0; ci < dstinfo->num_components; ci++) { compptr = dstinfo->comp_info + ci; comp_width = MCU_cols * compptr->h_samp_factor; comp_height = MCU_rows * compptr->v_samp_factor; for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks; dst_blk_y += compptr->v_samp_factor) { dst_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y, (JDIMENSION) compptr->v_samp_factor, TRUE); if (dst_blk_y < comp_height) { /* Row is within the vertically mirrorable area. */ src_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, src_coef_arrays[ci], comp_height - dst_blk_y - (JDIMENSION) compptr->v_samp_factor, (JDIMENSION) compptr->v_samp_factor, FALSE); } else { /* Bottom-edge rows are only mirrored horizontally. */ src_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_y, (JDIMENSION) compptr->v_samp_factor, FALSE); } for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) { if (dst_blk_y < comp_height) { /* Row is within the mirrorable area. */ dst_row_ptr = dst_buffer[offset_y]; src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1]; /* Process the blocks that can be mirrored both ways. */ for (dst_blk_x = 0; dst_blk_x < comp_width; dst_blk_x++) { dst_ptr = dst_row_ptr[dst_blk_x]; src_ptr = src_row_ptr[comp_width - dst_blk_x - 1]; for (i = 0; i < DCTSIZE; i += 2) { /* For even row, negate every odd column. */ for (j = 0; j < DCTSIZE; j += 2) { *dst_ptr++ = *src_ptr++; *dst_ptr++ = - *src_ptr++; } /* For odd row, negate every even column. */ for (j = 0; j < DCTSIZE; j += 2) { *dst_ptr++ = - *src_ptr++; *dst_ptr++ = *src_ptr++; } } } /* Any remaining right-edge blocks are only mirrored vertically. */ for (; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) { dst_ptr = dst_row_ptr[dst_blk_x]; src_ptr = src_row_ptr[dst_blk_x]; for (i = 0; i < DCTSIZE; i += 2) { for (j = 0; j < DCTSIZE; j++) *dst_ptr++ = *src_ptr++; for (j = 0; j < DCTSIZE; j++) *dst_ptr++ = - *src_ptr++; } } } else { /* Remaining rows are just mirrored horizontally. */ dst_row_ptr = dst_buffer[offset_y]; src_row_ptr = src_buffer[offset_y]; /* Process the blocks that can be mirrored. */ for (dst_blk_x = 0; dst_blk_x < comp_width; dst_blk_x++) { dst_ptr = dst_row_ptr[dst_blk_x]; src_ptr = src_row_ptr[comp_width - dst_blk_x - 1]; for (i = 0; i < DCTSIZE2; i += 2) { *dst_ptr++ = *src_ptr++; *dst_ptr++ = - *src_ptr++; } } /* Any remaining right-edge blocks are only copied. */ for (; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) { dst_ptr = dst_row_ptr[dst_blk_x]; src_ptr = src_row_ptr[dst_blk_x]; for (i = 0; i < DCTSIZE2; i++) *dst_ptr++ = *src_ptr++; } } } } } } LOCAL(void) do_transverse (j_decompress_ptr srcinfo, j_compress_ptr dstinfo, jvirt_barray_ptr *src_coef_arrays, jvirt_barray_ptr *dst_coef_arrays) /* Transverse transpose is equivalent to * 1. 180 degree rotation; * 2. Transposition; * or * 1. Horizontal mirroring; * 2. Transposition; * 3. Horizontal mirroring. * These steps are merged into a single processing routine. */ { JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y; int ci, i, j, offset_x, offset_y; JBLOCKARRAY src_buffer, dst_buffer; JCOEFPTR src_ptr, dst_ptr; jpeg_component_info *compptr; MCU_cols = dstinfo->image_width / (dstinfo->max_h_samp_factor * DCTSIZE); MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE); for (ci = 0; ci < dstinfo->num_components; ci++) { compptr = dstinfo->comp_info + ci; comp_width = MCU_cols * compptr->h_samp_factor; comp_height = MCU_rows * compptr->v_samp_factor; for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks; dst_blk_y += compptr->v_samp_factor) { dst_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y, (JDIMENSION) compptr->v_samp_factor, TRUE); for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) { for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x += compptr->h_samp_factor) { src_buffer = (*srcinfo->mem->access_virt_barray) ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_x, (JDIMENSION) compptr->h_samp_factor, FALSE); for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) { if (dst_blk_y < comp_height) { src_ptr = src_buffer[offset_x] [comp_height - dst_blk_y - offset_y - 1]; if (dst_blk_x < comp_width) { /* Block is within the mirrorable area. */ dst_ptr = dst_buffer[offset_y] [comp_width - dst_blk_x - offset_x - 1]; for (i = 0; i < DCTSIZE; i++) { for (j = 0; j < DCTSIZE; j++) { dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j]; j++; dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j]; } i++; for (j = 0; j < DCTSIZE; j++) { dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j]; j++; dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j]; } } } else { /* Right-edge blocks are mirrored in y only */ dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x]; for (i = 0; i < DCTSIZE; i++) { for (j = 0; j < DCTSIZE; j++) { dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j]; j++; dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j]; } } } } else { src_ptr = src_buffer[offset_x][dst_blk_y + offset_y]; if (dst_blk_x < comp_width) { /* Bottom-edge blocks are mirrored in x only */ dst_ptr = dst_buffer[offset_y] [comp_width - dst_blk_x - offset_x - 1]; for (i = 0; i < DCTSIZE; i++) { for (j = 0; j < DCTSIZE; j++) dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j]; i++; for (j = 0; j < DCTSIZE; j++) dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j]; } } else { /* At lower right corner, just transpose, no mirroring */ dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x]; for (i = 0; i < DCTSIZE; i++) for (j = 0; j < DCTSIZE; j++) dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j]; } } } } } } } } /* Request any required workspace. * * We allocate the workspace virtual arrays from the source decompression * object, so that all the arrays (both the original data and the workspace) * will be taken into account while making memory management decisions. * Hence, this routine must be called after jpeg_read_header (which reads * the image dimensions) and before jpeg_read_coefficients (which realizes * the source's virtual arrays). */ GLOBAL(void) jtransform_request_workspace (j_decompress_ptr srcinfo, jpeg_transform_info *info) { jvirt_barray_ptr *coef_arrays = NULL; jpeg_component_info *compptr; int ci; if (info->force_grayscale && srcinfo->jpeg_color_space == JCS_YCbCr && srcinfo->num_components == 3) { /* We'll only process the first component */ info->num_components = 1; } else { /* Process all the components */ info->num_components = srcinfo->num_components; } switch (info->transform) { case JXFORM_NONE: case JXFORM_FLIP_H: /* Don't need a workspace array */ break; case JXFORM_FLIP_V: case JXFORM_ROT_180: /* Need workspace arrays having same dimensions as source image. * Note that we allocate arrays padded out to the next iMCU boundary, * so that transform routines need not worry about missing edge blocks. */ coef_arrays = (jvirt_barray_ptr *) (*srcinfo->mem->alloc_small) ((j_common_ptr) srcinfo, JPOOL_IMAGE, SIZEOF(jvirt_barray_ptr) * info->num_components); for (ci = 0; ci < info->num_components; ci++) { compptr = srcinfo->comp_info + ci; coef_arrays[ci] = (*srcinfo->mem->request_virt_barray) ((j_common_ptr) srcinfo, JPOOL_IMAGE, FALSE, (JDIMENSION) jround_up((long) compptr->width_in_blocks, (long) compptr->h_samp_factor), (JDIMENSION) jround_up((long) compptr->height_in_blocks, (long) compptr->v_samp_factor), (JDIMENSION) compptr->v_samp_factor); } break; case JXFORM_TRANSPOSE: case JXFORM_TRANSVERSE: case JXFORM_ROT_90: case JXFORM_ROT_270: /* Need workspace arrays having transposed dimensions. * Note that we allocate arrays padded out to the next iMCU boundary, * so that transform routines need not worry about missing edge blocks. */ coef_arrays = (jvirt_barray_ptr *) (*srcinfo->mem->alloc_small) ((j_common_ptr) srcinfo, JPOOL_IMAGE, SIZEOF(jvirt_barray_ptr) * info->num_components); for (ci = 0; ci < info->num_components; ci++) { compptr = srcinfo->comp_info + ci; coef_arrays[ci] = (*srcinfo->mem->request_virt_barray) ((j_common_ptr) srcinfo, JPOOL_IMAGE, FALSE, (JDIMENSION) jround_up((long) compptr->height_in_blocks, (long) compptr->v_samp_factor), (JDIMENSION) jround_up((long) compptr->width_in_blocks, (long) compptr->h_samp_factor), (JDIMENSION) compptr->h_samp_factor); } break; } info->workspace_coef_arrays = coef_arrays; } /* Transpose destination image parameters */ LOCAL(void) transpose_critical_parameters (j_compress_ptr dstinfo) { int tblno, i, j, ci, itemp; jpeg_component_info *compptr; JQUANT_TBL *qtblptr; JDIMENSION dtemp; UINT16 qtemp; /* Transpose basic image dimensions */ dtemp = dstinfo->image_width; dstinfo->image_width = dstinfo->image_height; dstinfo->image_height = dtemp; /* Transpose sampling factors */ for (ci = 0; ci < dstinfo->num_components; ci++) { compptr = dstinfo->comp_info + ci; itemp = compptr->h_samp_factor; compptr->h_samp_factor = compptr->v_samp_factor; compptr->v_samp_factor = itemp; } /* Transpose quantization tables */ for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) { qtblptr = dstinfo->quant_tbl_ptrs[tblno]; if (qtblptr != NULL) { for (i = 0; i < DCTSIZE; i++) { for (j = 0; j < i; j++) { qtemp = qtblptr->quantval[i*DCTSIZE+j]; qtblptr->quantval[i*DCTSIZE+j] = qtblptr->quantval[j*DCTSIZE+i]; qtblptr->quantval[j*DCTSIZE+i] = qtemp; } } } } } /* Trim off any partial iMCUs on the indicated destination edge */ LOCAL(void) trim_right_edge (j_compress_ptr dstinfo) { int ci, max_h_samp_factor; JDIMENSION MCU_cols; /* We have to compute max_h_samp_factor ourselves, * because it hasn't been set yet in the destination * (and we don't want to use the source's value). */ max_h_samp_factor = 1; for (ci = 0; ci < dstinfo->num_components; ci++) { int h_samp_factor = dstinfo->comp_info[ci].h_samp_factor; max_h_samp_factor = MAX(max_h_samp_factor, h_samp_factor); } MCU_cols = dstinfo->image_width / (max_h_samp_factor * DCTSIZE); if (MCU_cols > 0) /* can't trim to 0 pixels */ dstinfo->image_width = MCU_cols * (max_h_samp_factor * DCTSIZE); } LOCAL(void) trim_bottom_edge (j_compress_ptr dstinfo) { int ci, max_v_samp_factor; JDIMENSION MCU_rows; /* We have to compute max_v_samp_factor ourselves, * because it hasn't been set yet in the destination * (and we don't want to use the source's value). */ max_v_samp_factor = 1; for (ci = 0; ci < dstinfo->num_components; ci++) { int v_samp_factor = dstinfo->comp_info[ci].v_samp_factor; max_v_samp_factor = MAX(max_v_samp_factor, v_samp_factor); } MCU_rows = dstinfo->image_height / (max_v_samp_factor * DCTSIZE); if (MCU_rows > 0) /* can't trim to 0 pixels */ dstinfo->image_height = MCU_rows * (max_v_samp_factor * DCTSIZE); } /* Adjust output image parameters as needed. * * This must be called after jpeg_copy_critical_parameters() * and before jpeg_write_coefficients(). * * The return value is the set of virtual coefficient arrays to be written * (either the ones allocated by jtransform_request_workspace, or the * original source data arrays). The caller will need to pass this value * to jpeg_write_coefficients(). */ GLOBAL(jvirt_barray_ptr *) jtransform_adjust_parameters (j_decompress_ptr srcinfo, j_compress_ptr dstinfo, jvirt_barray_ptr *src_coef_arrays, jpeg_transform_info *info) { /* If force-to-grayscale is requested, adjust destination parameters */ if (info->force_grayscale) { /* We use jpeg_set_colorspace to make sure subsidiary settings get fixed * properly. Among other things, the target h_samp_factor & v_samp_factor * will get set to 1, which typically won't match the source. * In fact we do this even if the source is already grayscale; that * provides an easy way of coercing a grayscale JPEG with funny sampling * factors to the customary 1,1. (Some decoders fail on other factors.) */ if ((dstinfo->jpeg_color_space == JCS_YCbCr && dstinfo->num_components == 3) || (dstinfo->jpeg_color_space == JCS_GRAYSCALE && dstinfo->num_components == 1)) { /* We have to preserve the source's quantization table number. */ int sv_quant_tbl_no = dstinfo->comp_info[0].quant_tbl_no; jpeg_set_colorspace(dstinfo, JCS_GRAYSCALE); dstinfo->comp_info[0].quant_tbl_no = sv_quant_tbl_no; } else { /* Sorry, can't do it */ ERREXIT(dstinfo, JERR_CONVERSION_NOTIMPL); } } /* Correct the destination's image dimensions etc if necessary */ switch (info->transform) { case JXFORM_NONE: /* Nothing to do */ break; case JXFORM_FLIP_H: if (info->trim) trim_right_edge(dstinfo); break; case JXFORM_FLIP_V: if (info->trim) trim_bottom_edge(dstinfo); break; case JXFORM_TRANSPOSE: transpose_critical_parameters(dstinfo); /* transpose does NOT have to trim anything */ break; case JXFORM_TRANSVERSE: transpose_critical_parameters(dstinfo); if (info->trim) { trim_right_edge(dstinfo); trim_bottom_edge(dstinfo); } break; case JXFORM_ROT_90: transpose_critical_parameters(dstinfo); if (info->trim) trim_right_edge(dstinfo); break; case JXFORM_ROT_180: if (info->trim) { trim_right_edge(dstinfo); trim_bottom_edge(dstinfo); } break; case JXFORM_ROT_270: transpose_critical_parameters(dstinfo); if (info->trim) trim_bottom_edge(dstinfo); break; } /* Return the appropriate output data set */ if (info->workspace_coef_arrays != NULL) return info->workspace_coef_arrays; return src_coef_arrays; } /* Execute the actual transformation, if any. * * This must be called *after* jpeg_write_coefficients, because it depends * on jpeg_write_coefficients to have computed subsidiary values such as * the per-component width and height fields in the destination object. * * Note that some transformations will modify the source data arrays! */ GLOBAL(void) jtransform_execute_transformation (j_decompress_ptr srcinfo, j_compress_ptr dstinfo, jvirt_barray_ptr *src_coef_arrays, jpeg_transform_info *info) { jvirt_barray_ptr *dst_coef_arrays = info->workspace_coef_arrays; switch (info->transform) { case JXFORM_NONE: break; case JXFORM_FLIP_H: do_flip_h(srcinfo, dstinfo, src_coef_arrays); break; case JXFORM_FLIP_V: do_flip_v(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays); break; case JXFORM_TRANSPOSE: do_transpose(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays); break; case JXFORM_TRANSVERSE: do_transverse(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays); break; case JXFORM_ROT_90: do_rot_90(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays); break; case JXFORM_ROT_180: do_rot_180(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays); break; case JXFORM_ROT_270: do_rot_270(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays); break; } } #endif /* TRANSFORMS_SUPPORTED */ /* Setup decompression object to save desired markers in memory. * This must be called before jpeg_read_header() to have the desired effect. */ GLOBAL(void) jcopy_markers_setup (j_decompress_ptr srcinfo, JCOPY_OPTION option) { #ifdef SAVE_MARKERS_SUPPORTED int m; /* Save comments except under NONE option */ if (option != JCOPYOPT_NONE) { jpeg_save_markers(srcinfo, JPEG_COM, 0xFFFF); } /* Save all types of APPn markers iff ALL option */ if (option == JCOPYOPT_ALL) { for (m = 0; m < 16; m++) jpeg_save_markers(srcinfo, JPEG_APP0 + m, 0xFFFF); } #endif /* SAVE_MARKERS_SUPPORTED */ } /* Copy markers saved in the given source object to the destination object. * This should be called just after jpeg_start_compress() or * jpeg_write_coefficients(). * Note that those routines will have written the SOI, and also the * JFIF APP0 or Adobe APP14 markers if selected. */ GLOBAL(void) jcopy_markers_execute (j_decompress_ptr srcinfo, j_compress_ptr dstinfo, JCOPY_OPTION option) { jpeg_saved_marker_ptr marker; /* In the current implementation, we don't actually need to examine the * option flag here; we just copy everything that got saved. * But to avoid confusion, we do not output JFIF and Adobe APP14 markers * if the encoder library already wrote one. */ for (marker = srcinfo->marker_list; marker != NULL; marker = marker->next) { if (dstinfo->write_JFIF_header && marker->marker == JPEG_APP0 && marker->data_length >= 5 && GETJOCTET(marker->data[0]) == 0x4A && GETJOCTET(marker->data[1]) == 0x46 && GETJOCTET(marker->data[2]) == 0x49 && GETJOCTET(marker->data[3]) == 0x46 && GETJOCTET(marker->data[4]) == 0) continue; /* reject duplicate JFIF */ if (dstinfo->write_Adobe_marker && marker->marker == JPEG_APP0+14 && marker->data_length >= 5 && GETJOCTET(marker->data[0]) == 0x41 && GETJOCTET(marker->data[1]) == 0x64 && GETJOCTET(marker->data[2]) == 0x6F && GETJOCTET(marker->data[3]) == 0x62 && GETJOCTET(marker->data[4]) == 0x65) continue; /* reject duplicate Adobe */ #ifdef NEED_FAR_POINTERS /* We could use jpeg_write_marker if the data weren't FAR... */ { unsigned int i; jpeg_write_m_header(dstinfo, marker->marker, marker->data_length); for (i = 0; i < marker->data_length; i++) jpeg_write_m_byte(dstinfo, marker->data[i]); } #else jpeg_write_marker(dstinfo, marker->marker, marker->data, marker->data_length); #endif } } Papyrus3/JpegDir/JpgLossy/JDCOLOR.C0000755000175000017500000003205607535143454014045 0ustar /* * jdcolor.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains output colorspace conversion routines. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* Private subobject */ typedef struct { struct jpeg_color_deconverter pub; /* public fields */ /* Private state for YCC->RGB conversion */ int * Cr_r_tab; /* => table for Cr to R conversion */ int * Cb_b_tab; /* => table for Cb to B conversion */ INT32 * Cr_g_tab; /* => table for Cr to G conversion */ INT32 * Cb_g_tab; /* => table for Cb to G conversion */ } my_color_deconverter; typedef my_color_deconverter * my_cconvert_ptr; /**************** YCbCr -> RGB conversion: most common case **************/ /* * YCbCr is defined per CCIR 601-1, except that Cb and Cr are * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5. * The conversion equations to be implemented are therefore * R = Y + 1.40200 * Cr * G = Y - 0.34414 * Cb - 0.71414 * Cr * B = Y + 1.77200 * Cb * where Cb and Cr represent the incoming values less CENTERJSAMPLE. * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.) * * To avoid floating-point arithmetic, we represent the fractional constants * as integers scaled up by 2^16 (about 4 digits precision); we have to divide * the products by 2^16, with appropriate rounding, to get the correct answer. * Notice that Y, being an integral input, does not contribute any fraction * so it need not participate in the rounding. * * For even more speed, we avoid doing any multiplications in the inner loop * by precalculating the constants times Cb and Cr for all possible values. * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table); * for 12-bit samples it is still acceptable. It's not very reasonable for * 16-bit samples, but if you want lossless storage you shouldn't be changing * colorspace anyway. * The Cr=>R and Cb=>B values can be rounded to integers in advance; the * values for the G calculation are left scaled up, since we must add them * together before rounding. */ #define SCALEBITS 16 /* speediest right-shift on some machines */ #define ONE_HALF ((INT32) 1 << (SCALEBITS-1)) #define FIX(x) ((INT32) ((x) * (1L<RGB colorspace conversion. */ LOCAL(void) build_ycc_rgb_table (j_decompress_ptr cinfo) { my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; int i; INT32 x; SHIFT_TEMPS cconvert->Cr_r_tab = (int *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int)); cconvert->Cb_b_tab = (int *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int)); cconvert->Cr_g_tab = (INT32 *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32)); cconvert->Cb_g_tab = (INT32 *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32)); for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) { /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */ /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */ /* Cr=>R value is nearest int to 1.40200 * x */ cconvert->Cr_r_tab[i] = (int) RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS); /* Cb=>B value is nearest int to 1.77200 * x */ cconvert->Cb_b_tab[i] = (int) RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS); /* Cr=>G value is scaled-up -0.71414 * x */ cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x; /* Cb=>G value is scaled-up -0.34414 * x */ /* We also add in ONE_HALF so that need not do it in inner loop */ cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF; } } /* * Convert some rows of samples to the output colorspace. * * Note that we change from noninterleaved, one-plane-per-component format * to interleaved-pixel format. The output buffer is therefore three times * as wide as the input buffer. * A starting row offset is provided only for the input buffer. The caller * can easily adjust the passed output_buf value to accommodate any row * offset required on that side. */ METHODDEF(void) ycc_rgb_convert (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows) { my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; register int y, cb, cr; register JSAMPROW outptr; register JSAMPROW inptr0, inptr1, inptr2; register JDIMENSION col; JDIMENSION num_cols = cinfo->output_width; /* copy these pointers into registers if possible */ register JSAMPLE * range_limit = cinfo->sample_range_limit; register int * Crrtab = cconvert->Cr_r_tab; register int * Cbbtab = cconvert->Cb_b_tab; register INT32 * Crgtab = cconvert->Cr_g_tab; register INT32 * Cbgtab = cconvert->Cb_g_tab; SHIFT_TEMPS while (--num_rows >= 0) { inptr0 = input_buf[0][input_row]; inptr1 = input_buf[1][input_row]; inptr2 = input_buf[2][input_row]; input_row++; outptr = *output_buf++; for (col = 0; col < num_cols; col++) { y = GETJSAMPLE(inptr0[col]); cb = GETJSAMPLE(inptr1[col]); cr = GETJSAMPLE(inptr2[col]); /* Range-limiting is essential due to noise introduced by DCT losses. */ outptr[RGB_RED] = range_limit[y + Crrtab[cr]]; outptr[RGB_GREEN] = range_limit[y + ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS))]; outptr[RGB_BLUE] = range_limit[y + Cbbtab[cb]]; outptr += RGB_PIXELSIZE; } } } /**************** Cases other than YCbCr -> RGB **************/ /* * Color conversion for no colorspace change: just copy the data, * converting from separate-planes to interleaved representation. */ METHODDEF(void) null_convert (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows) { register JSAMPROW inptr, outptr; register JDIMENSION count; register int num_components = cinfo->num_components; JDIMENSION num_cols = cinfo->output_width; int ci; while (--num_rows >= 0) { for (ci = 0; ci < num_components; ci++) { inptr = input_buf[ci][input_row]; outptr = output_buf[0] + ci; for (count = num_cols; count > 0; count--) { *outptr = *inptr++; /* needn't bother with GETJSAMPLE() here */ outptr += num_components; } } input_row++; output_buf++; } } /* * Color conversion for grayscale: just copy the data. * This also works for YCbCr -> grayscale conversion, in which * we just copy the Y (luminance) component and ignore chrominance. */ METHODDEF(void) grayscale_convert (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows) { jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0, num_rows, cinfo->output_width); } /* * Convert grayscale to RGB: just duplicate the graylevel three times. * This is provided to support applications that don't want to cope * with grayscale as a separate case. */ METHODDEF(void) gray_rgb_convert (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows) { register JSAMPROW inptr, outptr; register JDIMENSION col; JDIMENSION num_cols = cinfo->output_width; while (--num_rows >= 0) { inptr = input_buf[0][input_row++]; outptr = *output_buf++; for (col = 0; col < num_cols; col++) { /* We can dispense with GETJSAMPLE() here */ outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col]; outptr += RGB_PIXELSIZE; } } } /* * Adobe-style YCCK->CMYK conversion. * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same * conversion as above, while passing K (black) unchanged. * We assume build_ycc_rgb_table has been called. */ METHODDEF(void) ycck_cmyk_convert (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows) { my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; register int y, cb, cr; register JSAMPROW outptr; register JSAMPROW inptr0, inptr1, inptr2, inptr3; register JDIMENSION col; JDIMENSION num_cols = cinfo->output_width; /* copy these pointers into registers if possible */ register JSAMPLE * range_limit = cinfo->sample_range_limit; register int * Crrtab = cconvert->Cr_r_tab; register int * Cbbtab = cconvert->Cb_b_tab; register INT32 * Crgtab = cconvert->Cr_g_tab; register INT32 * Cbgtab = cconvert->Cb_g_tab; SHIFT_TEMPS while (--num_rows >= 0) { inptr0 = input_buf[0][input_row]; inptr1 = input_buf[1][input_row]; inptr2 = input_buf[2][input_row]; inptr3 = input_buf[3][input_row]; input_row++; outptr = *output_buf++; for (col = 0; col < num_cols; col++) { y = GETJSAMPLE(inptr0[col]); cb = GETJSAMPLE(inptr1[col]); cr = GETJSAMPLE(inptr2[col]); /* Range-limiting is essential due to noise introduced by DCT losses. */ outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])]; /* red */ outptr[1] = range_limit[MAXJSAMPLE - (y + /* green */ ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS)))]; outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])]; /* blue */ /* K passes through unchanged */ outptr[3] = inptr3[col]; /* don't need GETJSAMPLE here */ outptr += 4; } } } /* * Empty method for start_pass. */ METHODDEF(void) start_pass_dcolor (j_decompress_ptr cinfo) { /* no work needed */ } /* * Module initialization routine for output colorspace conversion. */ GLOBAL(void) jinit_color_deconverter (j_decompress_ptr cinfo) { my_cconvert_ptr cconvert; int ci; cconvert = (my_cconvert_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_color_deconverter)); cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert; cconvert->pub.start_pass = start_pass_dcolor; /* Make sure num_components agrees with jpeg_color_space */ switch (cinfo->jpeg_color_space) { case JCS_GRAYSCALE: if (cinfo->num_components != 1) ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); break; case JCS_RGB: case JCS_YCbCr: if (cinfo->num_components != 3) ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); break; case JCS_CMYK: case JCS_YCCK: if (cinfo->num_components != 4) ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); break; default: /* JCS_UNKNOWN can be anything */ if (cinfo->num_components < 1) ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); break; } /* Set out_color_components and conversion method based on requested space. * Also clear the component_needed flags for any unused components, * so that earlier pipeline stages can avoid useless computation. */ switch (cinfo->out_color_space) { case JCS_GRAYSCALE: cinfo->out_color_components = 1; if (cinfo->jpeg_color_space == JCS_GRAYSCALE || cinfo->jpeg_color_space == JCS_YCbCr) { cconvert->pub.color_convert = grayscale_convert; /* For color->grayscale conversion, only the Y (0) component is needed */ for (ci = 1; ci < cinfo->num_components; ci++) cinfo->comp_info[ci].component_needed = FALSE; } else ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); break; case JCS_RGB: cinfo->out_color_components = RGB_PIXELSIZE; if (cinfo->jpeg_color_space == JCS_YCbCr) { cconvert->pub.color_convert = ycc_rgb_convert; build_ycc_rgb_table(cinfo); } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) { cconvert->pub.color_convert = gray_rgb_convert; } else if (cinfo->jpeg_color_space == JCS_RGB && RGB_PIXELSIZE == 3) { cconvert->pub.color_convert = null_convert; } else ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); break; case JCS_CMYK: cinfo->out_color_components = 4; if (cinfo->jpeg_color_space == JCS_YCCK) { cconvert->pub.color_convert = ycck_cmyk_convert; build_ycc_rgb_table(cinfo); } else if (cinfo->jpeg_color_space == JCS_CMYK) { cconvert->pub.color_convert = null_convert; } else ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); break; default: /* Permit null conversion to same output space */ if (cinfo->out_color_space == cinfo->jpeg_color_space) { cinfo->out_color_components = cinfo->num_components; cconvert->pub.color_convert = null_convert; } else /* unsupported non-null conversion */ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); break; } if (cinfo->quantize_colors) cinfo->output_components = 1; /* single colormapped output component */ else cinfo->output_components = cinfo->out_color_components; } Papyrus3/JpegDir/JpgLossy/djpeg.10000755000175000017500000001676507535143454014031 0ustar .TH DJPEG 1 "22 August 1997" .SH NAME djpeg \- decompress a JPEG file to an image file .SH SYNOPSIS .B djpeg [ .I options ] [ .I filename ] .LP .SH DESCRIPTION .LP .B djpeg decompresses the named JPEG file, or the standard input if no file is named, and produces an image file on the standard output. PBMPLUS (PPM/PGM), BMP, GIF, Targa, or RLE (Utah Raster Toolkit) output format can be selected. (RLE is supported only if the URT library is available.) .SH OPTIONS All switch names may be abbreviated; for example, .B \-grayscale may be written .B \-gray or .BR \-gr . Most of the "basic" switches can be abbreviated to as little as one letter. Upper and lower case are equivalent (thus .B \-BMP is the same as .BR \-bmp ). British spellings are also accepted (e.g., .BR \-greyscale ), though for brevity these are not mentioned below. .PP The basic switches are: .TP .BI \-colors " N" Reduce image to at most N colors. This reduces the number of colors used in the output image, so that it can be displayed on a colormapped display or stored in a colormapped file format. For example, if you have an 8-bit display, you'd need to reduce to 256 or fewer colors. .TP .BI \-quantize " N" Same as .BR \-colors . .B \-colors is the recommended name, .B \-quantize is provided only for backwards compatibility. .TP .B \-fast Select recommended processing options for fast, low quality output. (The default options are chosen for highest quality output.) Currently, this is equivalent to \fB\-dct fast \-nosmooth \-onepass \-dither ordered\fR. .TP .B \-grayscale Force gray-scale output even if JPEG file is color. Useful for viewing on monochrome displays; also, .B djpeg runs noticeably faster in this mode. .TP .BI \-scale " M/N" Scale the output image by a factor M/N. Currently the scale factor must be 1/1, 1/2, 1/4, or 1/8. Scaling is handy if the image is larger than your screen; also, .B djpeg runs much faster when scaling down the output. .TP .B \-bmp Select BMP output format (Windows flavor). 8-bit colormapped format is emitted if .B \-colors or .B \-grayscale is specified, or if the JPEG file is gray-scale; otherwise, 24-bit full-color format is emitted. .TP .B \-gif Select GIF output format. Since GIF does not support more than 256 colors, .B \-colors 256 is assumed (unless you specify a smaller number of colors). .TP .B \-os2 Select BMP output format (OS/2 1.x flavor). 8-bit colormapped format is emitted if .B \-colors or .B \-grayscale is specified, or if the JPEG file is gray-scale; otherwise, 24-bit full-color format is emitted. .TP .B \-pnm Select PBMPLUS (PPM/PGM) output format (this is the default format). PGM is emitted if the JPEG file is gray-scale or if .B \-grayscale is specified; otherwise PPM is emitted. .TP .B \-rle Select RLE output format. (Requires URT library.) .TP .B \-targa Select Targa output format. Gray-scale format is emitted if the JPEG file is gray-scale or if .B \-grayscale is specified; otherwise, colormapped format is emitted if .B \-colors is specified; otherwise, 24-bit full-color format is emitted. .PP Switches for advanced users: .TP .B \-dct int Use integer DCT method (default). .TP .B \-dct fast Use fast integer DCT (less accurate). .TP .B \-dct float Use floating-point DCT method. The float method is very slightly more accurate than the int method, but is much slower unless your machine has very fast floating-point hardware. Also note that results of the floating-point method may vary slightly across machines, while the integer methods should give the same results everywhere. The fast integer method is much less accurate than the other two. .TP .B \-dither fs Use Floyd-Steinberg dithering in color quantization. .TP .B \-dither ordered Use ordered dithering in color quantization. .TP .B \-dither none Do not use dithering in color quantization. By default, Floyd-Steinberg dithering is applied when quantizing colors; this is slow but usually produces the best results. Ordered dither is a compromise between speed and quality; no dithering is fast but usually looks awful. Note that these switches have no effect unless color quantization is being done. Ordered dither is only available in .B \-onepass mode. .TP .BI \-map " file" Quantize to the colors used in the specified image file. This is useful for producing multiple files with identical color maps, or for forcing a predefined set of colors to be used. The .I file must be a GIF or PPM file. This option overrides .B \-colors and .BR \-onepass . .TP .B \-nosmooth Use a faster, lower-quality upsampling routine. .TP .B \-onepass Use one-pass instead of two-pass color quantization. The one-pass method is faster and needs less memory, but it produces a lower-quality image. .B \-onepass is ignored unless you also say .B \-colors .IR N . Also, the one-pass method is always used for gray-scale output (the two-pass method is no improvement then). .TP .BI \-maxmemory " N" Set limit for amount of memory to use in processing large images. Value is in thousands of bytes, or millions of bytes if "M" is attached to the number. For example, .B \-max 4m selects 4000000 bytes. If more space is needed, temporary files will be used. .TP .BI \-outfile " name" Send output image to the named file, not to standard output. .TP .B \-verbose Enable debug printout. More .BR \-v 's give more output. Also, version information is printed at startup. .TP .B \-debug Same as .BR \-verbose . .SH EXAMPLES .LP This example decompresses the JPEG file foo.jpg, quantizes it to 256 colors, and saves the output in 8-bit BMP format in foo.bmp: .IP .B djpeg \-colors 256 \-bmp .I foo.jpg .B > .I foo.bmp .SH HINTS To get a quick preview of an image, use the .B \-grayscale and/or .B \-scale switches. .B \-grayscale \-scale 1/8 is the fastest case. .PP Several options are available that trade off image quality to gain speed. .B \-fast turns on the recommended settings. .PP .B \-dct fast and/or .B \-nosmooth gain speed at a small sacrifice in quality. When producing a color-quantized image, .B \-onepass \-dither ordered is fast but much lower quality than the default behavior. .B \-dither none may give acceptable results in two-pass mode, but is seldom tolerable in one-pass mode. .PP If you are fortunate enough to have very fast floating point hardware, \fB\-dct float\fR may be even faster than \fB\-dct fast\fR. But on most machines \fB\-dct float\fR is slower than \fB\-dct int\fR; in this case it is not worth using, because its theoretical accuracy advantage is too small to be significant in practice. .SH ENVIRONMENT .TP .B JPEGMEM If this environment variable is set, its value is the default memory limit. The value is specified as described for the .B \-maxmemory switch. .B JPEGMEM overrides the default value specified when the program was compiled, and itself is overridden by an explicit .BR \-maxmemory . .SH SEE ALSO .BR cjpeg (1), .BR jpegtran (1), .BR rdjpgcom (1), .BR wrjpgcom (1) .br .BR ppm (5), .BR pgm (5) .br Wallace, Gregory K. "The JPEG Still Picture Compression Standard", Communications of the ACM, April 1991 (vol. 34, no. 4), pp. 30-44. .SH AUTHOR Independent JPEG Group .SH BUGS Arithmetic coding is not supported for legal reasons. .PP To avoid the Unisys LZW patent, .B djpeg produces uncompressed GIF files. These are larger than they should be, but are readable by standard GIF decoders. .PP Still not as fast as we'd like. Papyrus3/JpegDir/JpgLossy/makeapps.ds0000755000175000017500000005321707535143454015000 0ustar # Microsoft Developer Studio Generated NMAKE File, Format Version 4.20 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 !IF "$(CFG)" == "" CFG=cjpeg - Win32 !MESSAGE No configuration specified. Defaulting to cjpeg - Win32. !ENDIF !IF "$(CFG)" != "cjpeg - Win32" && "$(CFG)" != "djpeg - Win32" &&\ "$(CFG)" != "jpegtran - Win32" && "$(CFG)" != "rdjpgcom - Win32" &&\ "$(CFG)" != "wrjpgcom - Win32" !MESSAGE Invalid configuration "$(CFG)" specified. !MESSAGE You can specify a configuration when running NMAKE on this makefile !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "apps.mak" CFG="cjpeg - Win32" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "cjpeg - Win32" (based on "Win32 (x86) Console Application") !MESSAGE "djpeg - Win32" (based on "Win32 (x86) Console Application") !MESSAGE "jpegtran - Win32" (based on "Win32 (x86) Console Application") !MESSAGE "rdjpgcom - Win32" (based on "Win32 (x86) Console Application") !MESSAGE "wrjpgcom - Win32" (based on "Win32 (x86) Console Application") !MESSAGE !ERROR An invalid configuration is specified. !ENDIF !IF "$(OS)" == "Windows_NT" NULL= !ELSE NULL=nul !ENDIF ################################################################################ # Begin Project # PROP Target_Last_Scanned "cjpeg - Win32" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "cjpeg - Win32" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "cjpeg\Release" # PROP BASE Intermediate_Dir "cjpeg\Release" # PROP BASE Target_Dir "cjpeg" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "cjpeg\Release" # PROP Intermediate_Dir "cjpeg\Release" # PROP Target_Dir "cjpeg" OUTDIR=.\cjpeg\Release INTDIR=.\cjpeg\Release ALL : "$(OUTDIR)\cjpeg.exe" CLEAN : -@erase "$(INTDIR)\cjpeg.obj" -@erase "$(INTDIR)\rdppm.obj" -@erase "$(INTDIR)\rdgif.obj" -@erase "$(INTDIR)\rdtarga.obj" -@erase "$(INTDIR)\rdrle.obj" -@erase "$(INTDIR)\rdbmp.obj" -@erase "$(INTDIR)\rdswitch.obj" -@erase "$(INTDIR)\cdjpeg.obj" -@erase "$(OUTDIR)\cjpeg.exe" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c # ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE"\ /Fp"$(INTDIR)/cjpeg.pch" /YX /Fo"$(INTDIR)/" /c CPP_OBJS=.\cjpeg\Release/ CPP_SBRS=.\. # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo BSC32_FLAGS=/nologo /o"$(OUTDIR)/cjpeg.bsc" BSC32_SBRS= \ LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 Release\jpeg.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 LINK32_FLAGS=Release\jpeg.lib kernel32.lib user32.lib gdi32.lib winspool.lib\ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib\ odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:no\ /pdb:"$(OUTDIR)/cjpeg.pdb" /machine:I386 /out:"$(OUTDIR)/cjpeg.exe" LINK32_OBJS= \ "$(INTDIR)\cjpeg.obj" \ "$(INTDIR)\rdppm.obj" \ "$(INTDIR)\rdgif.obj" \ "$(INTDIR)\rdtarga.obj" \ "$(INTDIR)\rdrle.obj" \ "$(INTDIR)\rdbmp.obj" \ "$(INTDIR)\rdswitch.obj" \ "$(INTDIR)\cdjpeg.obj" \ "$(OUTDIR)\cjpeg.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) $(LINK32) @<< $(LINK32_FLAGS) $(LINK32_OBJS) << !ELSEIF "$(CFG)" == "djpeg - Win32" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "djpeg\Release" # PROP BASE Intermediate_Dir "djpeg\Release" # PROP BASE Target_Dir "djpeg" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "djpeg\Release" # PROP Intermediate_Dir "djpeg\Release" # PROP Target_Dir "djpeg" OUTDIR=.\djpeg\Release INTDIR=.\djpeg\Release ALL : "$(OUTDIR)\djpeg.exe" CLEAN : -@erase "$(INTDIR)\djpeg.obj" -@erase "$(INTDIR)\wrppm.obj" -@erase "$(INTDIR)\wrgif.obj" -@erase "$(INTDIR)\wrtarga.obj" -@erase "$(INTDIR)\wrrle.obj" -@erase "$(INTDIR)\wrbmp.obj" -@erase "$(INTDIR)\rdcolmap.obj" -@erase "$(INTDIR)\cdjpeg.obj" -@erase "$(OUTDIR)\djpeg.exe" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c # ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE"\ /Fp"$(INTDIR)/djpeg.pch" /YX /Fo"$(INTDIR)/" /c CPP_OBJS=.\djpeg\Release/ CPP_SBRS=.\. # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo BSC32_FLAGS=/nologo /o"$(OUTDIR)/djpeg.bsc" BSC32_SBRS= \ LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 Release\jpeg.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 LINK32_FLAGS=Release\jpeg.lib kernel32.lib user32.lib gdi32.lib winspool.lib\ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib\ odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:no\ /pdb:"$(OUTDIR)/djpeg.pdb" /machine:I386 /out:"$(OUTDIR)/djpeg.exe" LINK32_OBJS= \ "$(INTDIR)\djpeg.obj" \ "$(INTDIR)\wrppm.obj" \ "$(INTDIR)\wrgif.obj" \ "$(INTDIR)\wrtarga.obj" \ "$(INTDIR)\wrrle.obj" \ "$(INTDIR)\wrbmp.obj" \ "$(INTDIR)\rdcolmap.obj" \ "$(INTDIR)\cdjpeg.obj" \ "$(OUTDIR)\djpeg.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) $(LINK32) @<< $(LINK32_FLAGS) $(LINK32_OBJS) << !ELSEIF "$(CFG)" == "jpegtran - Win32" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "jpegtran\Release" # PROP BASE Intermediate_Dir "jpegtran\Release" # PROP BASE Target_Dir "jpegtran" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "jpegtran\Release" # PROP Intermediate_Dir "jpegtran\Release" # PROP Target_Dir "jpegtran" OUTDIR=.\jpegtran\Release INTDIR=.\jpegtran\Release ALL : "$(OUTDIR)\jpegtran.exe" CLEAN : -@erase "$(INTDIR)\jpegtran.obj" -@erase "$(INTDIR)\rdswitch.obj" -@erase "$(INTDIR)\cdjpeg.obj" -@erase "$(INTDIR)\transupp.obj" -@erase "$(OUTDIR)\jpegtran.exe" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c # ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE"\ /Fp"$(INTDIR)/jpegtran.pch" /YX /Fo"$(INTDIR)/" /c CPP_OBJS=.\jpegtran\Release/ CPP_SBRS=.\. # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo BSC32_FLAGS=/nologo /o"$(OUTDIR)/jpegtran.bsc" BSC32_SBRS= \ LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 Release\jpeg.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 LINK32_FLAGS=Release\jpeg.lib kernel32.lib user32.lib gdi32.lib winspool.lib\ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib\ odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:no\ /pdb:"$(OUTDIR)/jpegtran.pdb" /machine:I386 /out:"$(OUTDIR)/jpegtran.exe" LINK32_OBJS= \ "$(INTDIR)\jpegtran.obj" \ "$(INTDIR)\rdswitch.obj" \ "$(INTDIR)\cdjpeg.obj" \ "$(INTDIR)\transupp.obj" \ "$(OUTDIR)\jpegtran.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) $(LINK32) @<< $(LINK32_FLAGS) $(LINK32_OBJS) << !ELSEIF "$(CFG)" == "rdjpgcom - Win32" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "rdjpgcom\Release" # PROP BASE Intermediate_Dir "rdjpgcom\Release" # PROP BASE Target_Dir "rdjpgcom" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "rdjpgcom\Release" # PROP Intermediate_Dir "rdjpgcom\Release" # PROP Target_Dir "rdjpgcom" OUTDIR=.\rdjpgcom\Release INTDIR=.\rdjpgcom\Release ALL : "$(OUTDIR)\rdjpgcom.exe" CLEAN : -@erase "$(INTDIR)\rdjpgcom.obj" -@erase "$(OUTDIR)\rdjpgcom.exe" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c # ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE"\ /Fp"$(INTDIR)/rdjpgcom.pch" /YX /Fo"$(INTDIR)/" /c CPP_OBJS=.\rdjpgcom\Release/ CPP_SBRS=.\. # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo BSC32_FLAGS=/nologo /o"$(OUTDIR)/rdjpgcom.bsc" BSC32_SBRS= \ LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 Release\jpeg.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 LINK32_FLAGS=Release\jpeg.lib kernel32.lib user32.lib gdi32.lib winspool.lib\ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib\ odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:no\ /pdb:"$(OUTDIR)/rdjpgcom.pdb" /machine:I386 /out:"$(OUTDIR)/rdjpgcom.exe" LINK32_OBJS= \ "$(INTDIR)\rdjpgcom.obj" "$(OUTDIR)\rdjpgcom.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) $(LINK32) @<< $(LINK32_FLAGS) $(LINK32_OBJS) << !ELSEIF "$(CFG)" == "wrjpgcom - Win32" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "wrjpgcom\Release" # PROP BASE Intermediate_Dir "wrjpgcom\Release" # PROP BASE Target_Dir "wrjpgcom" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "wrjpgcom\Release" # PROP Intermediate_Dir "wrjpgcom\Release" # PROP Target_Dir "wrjpgcom" OUTDIR=.\wrjpgcom\Release INTDIR=.\wrjpgcom\Release ALL : "$(OUTDIR)\wrjpgcom.exe" CLEAN : -@erase "$(INTDIR)\wrjpgcom.obj" -@erase "$(OUTDIR)\wrjpgcom.exe" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c # ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE"\ /Fp"$(INTDIR)/wrjpgcom.pch" /YX /Fo"$(INTDIR)/" /c CPP_OBJS=.\wrjpgcom\Release/ CPP_SBRS=.\. # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo BSC32_FLAGS=/nologo /o"$(OUTDIR)/wrjpgcom.bsc" BSC32_SBRS= \ LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 Release\jpeg.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 LINK32_FLAGS=Release\jpeg.lib kernel32.lib user32.lib gdi32.lib winspool.lib\ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib\ odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:no\ /pdb:"$(OUTDIR)/wrjpgcom.pdb" /machine:I386 /out:"$(OUTDIR)/wrjpgcom.exe" LINK32_OBJS= \ "$(INTDIR)\wrjpgcom.obj" "$(OUTDIR)\wrjpgcom.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) $(LINK32) @<< $(LINK32_FLAGS) $(LINK32_OBJS) << !ENDIF .c{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .c{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< ################################################################################ # Begin Target # Name "cjpeg - Win32" !IF "$(CFG)" == "cjpeg - Win32" !ENDIF ################################################################################ # Begin Source File SOURCE="cjpeg.c" DEP_CPP_CJPEG=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "jversion.h"\ "$(INTDIR)\cjpeg.obj" : $(SOURCE) $(DEP_CPP_CJPEG) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="cdjpeg.c" DEP_CPP_CDJPE=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\cdjpeg.obj" : $(SOURCE) $(DEP_CPP_CDJPE) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="rdswitch.c" DEP_CPP_RDSWI=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\rdswitch.obj" : $(SOURCE) $(DEP_CPP_RDSWI) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="rdppm.c" DEP_CPP_RDPPM=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\rdppm.obj" : $(SOURCE) $(DEP_CPP_RDPPM) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="rdgif.c" DEP_CPP_RDGIF=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\rdgif.obj" : $(SOURCE) $(DEP_CPP_RDGIF) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="rdtarga.c" DEP_CPP_RDTAR=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\rdtarga.obj" : $(SOURCE) $(DEP_CPP_RDTAR) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="rdbmp.c" DEP_CPP_RDBMP=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\rdbmp.obj" : $(SOURCE) $(DEP_CPP_RDBMP) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="rdrle.c" DEP_CPP_RDRLE=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\rdrle.obj" : $(SOURCE) $(DEP_CPP_RDRLE) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File # End Target ################################################################################ # Begin Target # Name "djpeg - Win32" !IF "$(CFG)" == "djpeg - Win32" !ENDIF ################################################################################ # Begin Source File SOURCE="djpeg.c" DEP_CPP_DJPEG=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "jversion.h"\ "$(INTDIR)\djpeg.obj" : $(SOURCE) $(DEP_CPP_DJPEG) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="cdjpeg.c" DEP_CPP_CDJPE=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\cdjpeg.obj" : $(SOURCE) $(DEP_CPP_CDJPE) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="rdcolmap.c" DEP_CPP_RDCOL=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\rdcolmap.obj" : $(SOURCE) $(DEP_CPP_RDCOL) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="wrppm.c" DEP_CPP_WRPPM=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\wrppm.obj" : $(SOURCE) $(DEP_CPP_WRPPM) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="wrgif.c" DEP_CPP_WRGIF=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\wrgif.obj" : $(SOURCE) $(DEP_CPP_WRGIF) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="wrtarga.c" DEP_CPP_WRTAR=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\wrtarga.obj" : $(SOURCE) $(DEP_CPP_WRTAR) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="wrbmp.c" DEP_CPP_WRBMP=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\wrbmp.obj" : $(SOURCE) $(DEP_CPP_WRBMP) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="wrrle.c" DEP_CPP_WRRLE=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\wrrle.obj" : $(SOURCE) $(DEP_CPP_WRRLE) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File # End Target ################################################################################ # Begin Target # Name "jpegtran - Win32" !IF "$(CFG)" == "jpegtran - Win32" !ENDIF ################################################################################ # Begin Source File SOURCE="jpegtran.c" DEP_CPP_JPEGT=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "transupp.h"\ "jversion.h"\ "$(INTDIR)\jpegtran.obj" : $(SOURCE) $(DEP_CPP_JPEGT) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="cdjpeg.c" DEP_CPP_CDJPE=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\cdjpeg.obj" : $(SOURCE) $(DEP_CPP_CDJPE) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="rdswitch.c" DEP_CPP_RDSWI=\ "cdjpeg.h"\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "cderror.h"\ "$(INTDIR)\rdswitch.obj" : $(SOURCE) $(DEP_CPP_RDSWI) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="transupp.c" DEP_CPP_TRANS=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "transupp.h"\ "$(INTDIR)\transupp.obj" : $(SOURCE) $(DEP_CPP_TRANS) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File # End Target ################################################################################ # Begin Target # Name "rdjpgcom - Win32" !IF "$(CFG)" == "rdjpgcom - Win32" !ENDIF ################################################################################ # Begin Source File SOURCE="rdjpgcom.c" DEP_CPP_RDJPG=\ "jinclude.h"\ "jconfig.h"\ "$(INTDIR)\rdjpgcom.obj" : $(SOURCE) $(DEP_CPP_RDJPG) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File # End Target ################################################################################ # Begin Target # Name "wrjpgcom - Win32" !IF "$(CFG)" == "wrjpgcom - Win32" !ENDIF ################################################################################ # Begin Source File SOURCE="wrjpgcom.c" DEP_CPP_WRJPG=\ "jinclude.h"\ "jconfig.h"\ "$(INTDIR)\wrjpgcom.obj" : $(SOURCE) $(DEP_CPP_WRJPG) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File # End Target # End Project ################################################################################ Papyrus3/JpegDir/JpgLossy/usage.doc0000755000175000017500000006612507535143454014444 0ustar USAGE instructions for the Independent JPEG Group's JPEG software ================================================================= This file describes usage of the JPEG conversion programs cjpeg and djpeg, as well as the utility programs jpegtran, rdjpgcom and wrjpgcom. (See the other documentation files if you wish to use the JPEG library within your own programs.) If you are on a Unix machine you may prefer to read the Unix-style manual pages in files cjpeg.1, djpeg.1, jpegtran.1, rdjpgcom.1, wrjpgcom.1. INTRODUCTION These programs implement JPEG image compression and decompression. JPEG (pronounced "jay-peg") is a standardized compression method for full-color and gray-scale images. JPEG is designed to handle "real-world" scenes, for example scanned photographs. Cartoons, line drawings, and other non-realistic images are not JPEG's strong suit; on that sort of material you may get poor image quality and/or little compression. JPEG is lossy, meaning that the output image is not necessarily identical to the input image. Hence you should not use JPEG if you have to have identical output bits. However, on typical real-world images, very good compression levels can be obtained with no visible change, and amazingly high compression is possible if you can tolerate a low-quality image. You can trade off image quality against file size by adjusting the compressor's "quality" setting. GENERAL USAGE We provide two programs, cjpeg to compress an image file into JPEG format, and djpeg to decompress a JPEG file back into a conventional image format. On Unix-like systems, you say: cjpeg [switches] [imagefile] >jpegfile or djpeg [switches] [jpegfile] >imagefile The programs read the specified input file, or standard input if none is named. They always write to standard output (with trace/error messages to standard error). These conventions are handy for piping images between programs. On most non-Unix systems, you say: cjpeg [switches] imagefile jpegfile or djpeg [switches] jpegfile imagefile i.e., both the input and output files are named on the command line. This style is a little more foolproof, and it loses no functionality if you don't have pipes. (You can get this style on Unix too, if you prefer, by defining TWO_FILE_COMMANDLINE when you compile the programs; see install.doc.) You can also say: cjpeg [switches] -outfile jpegfile imagefile or djpeg [switches] -outfile imagefile jpegfile This syntax works on all systems, so it is useful for scripts. The currently supported image file formats are: PPM (PBMPLUS color format), PGM (PBMPLUS gray-scale format), BMP, Targa, and RLE (Utah Raster Toolkit format). (RLE is supported only if the URT library is available.) cjpeg recognizes the input image format automatically, with the exception of some Targa-format files. You have to tell djpeg which format to generate. JPEG files are in the defacto standard JFIF file format. There are other, less widely used JPEG-based file formats, but we don't support them. All switch names may be abbreviated; for example, -grayscale may be written -gray or -gr. Most of the "basic" switches can be abbreviated to as little as one letter. Upper and lower case are equivalent (-BMP is the same as -bmp). British spellings are also accepted (e.g., -greyscale), though for brevity these are not mentioned below. CJPEG DETAILS The basic command line switches for cjpeg are: -quality N Scale quantization tables to adjust image quality. Quality is 0 (worst) to 100 (best); default is 75. (See below for more info.) -grayscale Create monochrome JPEG file from color input. Be sure to use this switch when compressing a grayscale BMP file, because cjpeg isn't bright enough to notice whether a BMP file uses only shades of gray. By saying -grayscale, you'll get a smaller JPEG file that takes less time to process. -optimize Perform optimization of entropy encoding parameters. Without this, default encoding parameters are used. -optimize usually makes the JPEG file a little smaller, but cjpeg runs somewhat slower and needs much more memory. Image quality and speed of decompression are unaffected by -optimize. -progressive Create progressive JPEG file (see below). -targa Input file is Targa format. Targa files that contain an "identification" field will not be automatically recognized by cjpeg; for such files you must specify -targa to make cjpeg treat the input as Targa format. For most Targa files, you won't need this switch. The -quality switch lets you trade off compressed file size against quality of the reconstructed image: the higher the quality setting, the larger the JPEG file, and the closer the output image will be to the original input. Normally you want to use the lowest quality setting (smallest file) that decompresses into something visually indistinguishable from the original image. For this purpose the quality setting should be between 50 and 95; the default of 75 is often about right. If you see defects at -quality 75, then go up 5 or 10 counts at a time until you are happy with the output image. (The optimal setting will vary from one image to another.) -quality 100 will generate a quantization table of all 1's, minimizing loss in the quantization step (but there is still information loss in subsampling, as well as roundoff error). This setting is mainly of interest for experimental purposes. Quality values above about 95 are NOT recommended for normal use; the compressed file size goes up dramatically for hardly any gain in output image quality. In the other direction, quality values below 50 will produce very small files of low image quality. Settings around 5 to 10 might be useful in preparing an index of a large image library, for example. Try -quality 2 (or so) for some amusing Cubist effects. (Note: quality values below about 25 generate 2-byte quantization tables, which are considered optional in the JPEG standard. cjpeg emits a warning message when you give such a quality value, because some other JPEG programs may be unable to decode the resulting file. Use -baseline if you need to ensure compatibility at low quality values.) The -progressive switch creates a "progressive JPEG" file. In this type of JPEG file, the data is stored in multiple scans of increasing quality. If the file is being transmitted over a slow communications link, the decoder can use the first scan to display a low-quality image very quickly, and can then improve the display with each subsequent scan. The final image is exactly equivalent to a standard JPEG file of the same quality setting, and the total file size is about the same --- often a little smaller. CAUTION: progressive JPEG is not yet widely implemented, so many decoders will be unable to view a progressive JPEG file at all. Switches for advanced users: -dct int Use integer DCT method (default). -dct fast Use fast integer DCT (less accurate). -dct float Use floating-point DCT method. The float method is very slightly more accurate than the int method, but is much slower unless your machine has very fast floating-point hardware. Also note that results of the floating-point method may vary slightly across machines, while the integer methods should give the same results everywhere. The fast integer method is much less accurate than the other two. -restart N Emit a JPEG restart marker every N MCU rows, or every N MCU blocks if "B" is attached to the number. -restart 0 (the default) means no restart markers. -smooth N Smooth the input image to eliminate dithering noise. N, ranging from 1 to 100, indicates the strength of smoothing. 0 (the default) means no smoothing. -maxmemory N Set limit for amount of memory to use in processing large images. Value is in thousands of bytes, or millions of bytes if "M" is attached to the number. For example, -max 4m selects 4000000 bytes. If more space is needed, temporary files will be used. -verbose Enable debug printout. More -v's give more printout. or -debug Also, version information is printed at startup. The -restart option inserts extra markers that allow a JPEG decoder to resynchronize after a transmission error. Without restart markers, any damage to a compressed file will usually ruin the image from the point of the error to the end of the image; with restart markers, the damage is usually confined to the portion of the image up to the next restart marker. Of course, the restart markers occupy extra space. We recommend -restart 1 for images that will be transmitted across unreliable networks such as Usenet. The -smooth option filters the input to eliminate fine-scale noise. This is often useful when converting dithered images to JPEG: a moderate smoothing factor of 10 to 50 gets rid of dithering patterns in the input file, resulting in a smaller JPEG file and a better-looking image. Too large a smoothing factor will visibly blur the image, however. Switches for wizards: -baseline Force baseline-compatible quantization tables to be generated. This clamps quantization values to 8 bits even at low quality settings. (This switch is poorly named, since it does not ensure that the output is actually baseline JPEG. For example, you can use -baseline and -progressive together.) -qtables file Use the quantization tables given in the specified text file. -qslots N[,...] Select which quantization table to use for each color component. -sample HxV[,...] Set JPEG sampling factors for each color component. -scans file Use the scan script given in the specified text file. The "wizard" switches are intended for experimentation with JPEG. If you don't know what you are doing, DON'T USE THEM. These switches are documented further in the file wizard.doc. DJPEG DETAILS The basic command line switches for djpeg are: -colors N Reduce image to at most N colors. This reduces the or -quantize N number of colors used in the output image, so that it can be displayed on a colormapped display or stored in a colormapped file format. For example, if you have an 8-bit display, you'd need to reduce to 256 or fewer colors. (-colors is the recommended name, -quantize is provided only for backwards compatibility.) -fast Select recommended processing options for fast, low quality output. (The default options are chosen for highest quality output.) Currently, this is equivalent to "-dct fast -nosmooth -onepass -dither ordered". -grayscale Force gray-scale output even if JPEG file is color. Useful for viewing on monochrome displays; also, djpeg runs noticeably faster in this mode. -scale M/N Scale the output image by a factor M/N. Currently the scale factor must be 1/1, 1/2, 1/4, or 1/8. Scaling is handy if the image is larger than your screen; also, djpeg runs much faster when scaling down the output. -bmp Select BMP output format (Windows flavor). 8-bit colormapped format is emitted if -colors or -grayscale is specified, or if the JPEG file is gray-scale; otherwise, 24-bit full-color format is emitted. -gif Select GIF output format. Since GIF does not support more than 256 colors, -colors 256 is assumed (unless you specify a smaller number of colors). If you specify -fast, the default number of colors is 216. -os2 Select BMP output format (OS/2 1.x flavor). 8-bit colormapped format is emitted if -colors or -grayscale is specified, or if the JPEG file is gray-scale; otherwise, 24-bit full-color format is emitted. -pnm Select PBMPLUS (PPM/PGM) output format (this is the default format). PGM is emitted if the JPEG file is gray-scale or if -grayscale is specified; otherwise PPM is emitted. -rle Select RLE output format. (Requires URT library.) -targa Select Targa output format. Gray-scale format is emitted if the JPEG file is gray-scale or if -grayscale is specified; otherwise, colormapped format is emitted if -colors is specified; otherwise, 24-bit full-color format is emitted. Switches for advanced users: -dct int Use integer DCT method (default). -dct fast Use fast integer DCT (less accurate). -dct float Use floating-point DCT method. The float method is very slightly more accurate than the int method, but is much slower unless your machine has very fast floating-point hardware. Also note that results of the floating-point method may vary slightly across machines, while the integer methods should give the same results everywhere. The fast integer method is much less accurate than the other two. -dither fs Use Floyd-Steinberg dithering in color quantization. -dither ordered Use ordered dithering in color quantization. -dither none Do not use dithering in color quantization. By default, Floyd-Steinberg dithering is applied when quantizing colors; this is slow but usually produces the best results. Ordered dither is a compromise between speed and quality; no dithering is fast but usually looks awful. Note that these switches have no effect unless color quantization is being done. Ordered dither is only available in -onepass mode. -map FILE Quantize to the colors used in the specified image file. This is useful for producing multiple files with identical color maps, or for forcing a predefined set of colors to be used. The FILE must be a GIF or PPM file. This option overrides -colors and -onepass. -nosmooth Use a faster, lower-quality upsampling routine. -onepass Use one-pass instead of two-pass color quantization. The one-pass method is faster and needs less memory, but it produces a lower-quality image. -onepass is ignored unless you also say -colors N. Also, the one-pass method is always used for gray-scale output (the two-pass method is no improvement then). -maxmemory N Set limit for amount of memory to use in processing large images. Value is in thousands of bytes, or millions of bytes if "M" is attached to the number. For example, -max 4m selects 4000000 bytes. If more space is needed, temporary files will be used. -verbose Enable debug printout. More -v's give more printout. or -debug Also, version information is printed at startup. HINTS FOR CJPEG Color GIF files are not the ideal input for JPEG; JPEG is really intended for compressing full-color (24-bit) images. In particular, don't try to convert cartoons, line drawings, and other images that have only a few distinct colors. GIF works great on these, JPEG does not. If you want to convert a GIF to JPEG, you should experiment with cjpeg's -quality and -smooth options to get a satisfactory conversion. -smooth 10 or so is often helpful. Avoid running an image through a series of JPEG compression/decompression cycles. Image quality loss will accumulate; after ten or so cycles the image may be noticeably worse than it was after one cycle. It's best to use a lossless format while manipulating an image, then convert to JPEG format when you are ready to file the image away. The -optimize option to cjpeg is worth using when you are making a "final" version for posting or archiving. It's also a win when you are using low quality settings to make very small JPEG files; the percentage improvement is often a lot more than it is on larger files. (At present, -optimize mode is always selected when generating progressive JPEG files.) GIF input files are no longer supported, to avoid the Unisys LZW patent. Use a Unisys-licensed program if you need to read a GIF file. (Conversion of GIF files to JPEG is usually a bad idea anyway.) HINTS FOR DJPEG To get a quick preview of an image, use the -grayscale and/or -scale switches. "-grayscale -scale 1/8" is the fastest case. Several options are available that trade off image quality to gain speed. "-fast" turns on the recommended settings. "-dct fast" and/or "-nosmooth" gain speed at a small sacrifice in quality. When producing a color-quantized image, "-onepass -dither ordered" is fast but much lower quality than the default behavior. "-dither none" may give acceptable results in two-pass mode, but is seldom tolerable in one-pass mode. If you are fortunate enough to have very fast floating point hardware, "-dct float" may be even faster than "-dct fast". But on most machines "-dct float" is slower than "-dct int"; in this case it is not worth using, because its theoretical accuracy advantage is too small to be significant in practice. Two-pass color quantization requires a good deal of memory; on MS-DOS machines it may run out of memory even with -maxmemory 0. In that case you can still decompress, with some loss of image quality, by specifying -onepass for one-pass quantization. To avoid the Unisys LZW patent, djpeg produces uncompressed GIF files. These are larger than they should be, but are readable by standard GIF decoders. HINTS FOR BOTH PROGRAMS If more space is needed than will fit in the available main memory (as determined by -maxmemory), temporary files will be used. (MS-DOS versions will try to get extended or expanded memory first.) The temporary files are often rather large: in typical cases they occupy three bytes per pixel, for example 3*800*600 = 1.44Mb for an 800x600 image. If you don't have enough free disk space, leave out -progressive and -optimize (for cjpeg) or specify -onepass (for djpeg). On MS-DOS, the temporary files are created in the directory named by the TMP or TEMP environment variable, or in the current directory if neither of those exist. Amiga implementations put the temp files in the directory named by JPEGTMP:, so be sure to assign JPEGTMP: to a disk partition with adequate free space. The default memory usage limit (-maxmemory) is set when the software is compiled. If you get an "insufficient memory" error, try specifying a smaller -maxmemory value, even -maxmemory 0 to use the absolute minimum space. You may want to recompile with a smaller default value if this happens often. On machines that have "environment" variables, you can define the environment variable JPEGMEM to set the default memory limit. The value is specified as described for the -maxmemory switch. JPEGMEM overrides the default value specified when the program was compiled, and itself is overridden by an explicit -maxmemory switch. On MS-DOS machines, -maxmemory is the amount of main (conventional) memory to use. (Extended or expanded memory is also used if available.) Most DOS-specific versions of this software do their own memory space estimation and do not need you to specify -maxmemory. JPEGTRAN jpegtran performs various useful transformations of JPEG files. It can translate the coded representation from one variant of JPEG to another, for example from baseline JPEG to progressive JPEG or vice versa. It can also perform some rearrangements of the image data, for example turning an image from landscape to portrait format by rotation. jpegtran works by rearranging the compressed data (DCT coefficients), without ever fully decoding the image. Therefore, its transformations are lossless: there is no image degradation at all, which would not be true if you used djpeg followed by cjpeg to accomplish the same conversion. But by the same token, jpegtran cannot perform lossy operations such as changing the image quality. jpegtran uses a command line syntax similar to cjpeg or djpeg. On Unix-like systems, you say: jpegtran [switches] [inputfile] >outputfile On most non-Unix systems, you say: jpegtran [switches] inputfile outputfile where both the input and output files are JPEG files. To specify the coded JPEG representation used in the output file, jpegtran accepts a subset of the switches recognized by cjpeg: -optimize Perform optimization of entropy encoding parameters. -progressive Create progressive JPEG file. -restart N Emit a JPEG restart marker every N MCU rows, or every N MCU blocks if "B" is attached to the number. -scans file Use the scan script given in the specified text file. See the previous discussion of cjpeg for more details about these switches. If you specify none of these switches, you get a plain baseline-JPEG output file. The quality setting and so forth are determined by the input file. The image can be losslessly transformed by giving one of these switches: -flip horizontal Mirror image horizontally (left-right). -flip vertical Mirror image vertically (top-bottom). -rotate 90 Rotate image 90 degrees clockwise. -rotate 180 Rotate image 180 degrees. -rotate 270 Rotate image 270 degrees clockwise (or 90 ccw). -transpose Transpose image (across UL-to-LR axis). -transverse Transverse transpose (across UR-to-LL axis). The transpose transformation has no restrictions regarding image dimensions. The other transformations operate rather oddly if the image dimensions are not a multiple of the iMCU size (usually 8 or 16 pixels), because they can only transform complete blocks of DCT coefficient data in the desired way. jpegtran's default behavior when transforming an odd-size image is designed to preserve exact reversibility and mathematical consistency of the transformation set. As stated, transpose is able to flip the entire image area. Horizontal mirroring leaves any partial iMCU column at the right edge untouched, but is able to flip all rows of the image. Similarly, vertical mirroring leaves any partial iMCU row at the bottom edge untouched, but is able to flip all columns. The other transforms can be built up as sequences of transpose and flip operations; for consistency, their actions on edge pixels are defined to be the same as the end result of the corresponding transpose-and-flip sequence. For practical use, you may prefer to discard any untransformable edge pixels rather than having a strange-looking strip along the right and/or bottom edges of a transformed image. To do this, add the -trim switch: -trim Drop non-transformable edge blocks. Obviously, a transformation with -trim is not reversible, so strictly speaking jpegtran with this switch is not lossless. Also, the expected mathematical equivalences between the transformations no longer hold. For example, "-rot 270 -trim" trims only the bottom edge, but "-rot 90 -trim" followed by "-rot 180 -trim" trims both edges. Another not-strictly-lossless transformation switch is: -grayscale Force grayscale output. This option discards the chrominance channels if the input image is YCbCr (ie, a standard color JPEG), resulting in a grayscale JPEG file. The luminance channel is preserved exactly, so this is a better method of reducing to grayscale than decompression, conversion, and recompression. This switch is particularly handy for fixing a monochrome picture that was mistakenly encoded as a color JPEG. (In such a case, the space savings from getting rid of the near-empty chroma channels won't be large; but the decoding time for a grayscale JPEG is substantially less than that for a color JPEG.) jpegtran also recognizes these switches that control what to do with "extra" markers, such as comment blocks: -copy none Copy no extra markers from source file. This setting suppresses all comments and other excess baggage present in the source file. -copy comments Copy only comment markers. This setting copies comments from the source file, but discards any other inessential data. -copy all Copy all extra markers. This setting preserves miscellaneous markers found in the source file, such as JFIF thumbnails and Photoshop settings. In some files these extra markers can be sizable. The default behavior is -copy comments. (Note: in IJG releases v6 and v6a, jpegtran always did the equivalent of -copy none.) Additional switches recognized by jpegtran are: -outfile filename -maxmemory N -verbose -debug These work the same as in cjpeg or djpeg. THE COMMENT UTILITIES The JPEG standard allows "comment" (COM) blocks to occur within a JPEG file. Although the standard doesn't actually define what COM blocks are for, they are widely used to hold user-supplied text strings. This lets you add annotations, titles, index terms, etc to your JPEG files, and later retrieve them as text. COM blocks do not interfere with the image stored in the JPEG file. The maximum size of a COM block is 64K, but you can have as many of them as you like in one JPEG file. We provide two utility programs to display COM block contents and add COM blocks to a JPEG file. rdjpgcom searches a JPEG file and prints the contents of any COM blocks on standard output. The command line syntax is rdjpgcom [-verbose] [inputfilename] The switch "-verbose" (or just "-v") causes rdjpgcom to also display the JPEG image dimensions. If you omit the input file name from the command line, the JPEG file is read from standard input. (This may not work on some operating systems, if binary data can't be read from stdin.) wrjpgcom adds a COM block, containing text you provide, to a JPEG file. Ordinarily, the COM block is added after any existing COM blocks, but you can delete the old COM blocks if you wish. wrjpgcom produces a new JPEG file; it does not modify the input file. DO NOT try to overwrite the input file by directing wrjpgcom's output back into it; on most systems this will just destroy your file. The command line syntax for wrjpgcom is similar to cjpeg's. On Unix-like systems, it is wrjpgcom [switches] [inputfilename] The output file is written to standard output. The input file comes from the named file, or from standard input if no input file is named. On most non-Unix systems, the syntax is wrjpgcom [switches] inputfilename outputfilename where both input and output file names must be given explicitly. wrjpgcom understands three switches: -replace Delete any existing COM blocks from the file. -comment "Comment text" Supply new COM text on command line. -cfile name Read text for new COM block from named file. (Switch names can be abbreviated.) If you have only one line of comment text to add, you can provide it on the command line with -comment. The comment text must be surrounded with quotes so that it is treated as a single argument. Longer comments can be read from a text file. If you give neither -comment nor -cfile, then wrjpgcom will read the comment text from standard input. (In this case an input image file name MUST be supplied, so that the source JPEG file comes from somewhere else.) You can enter multiple lines, up to 64KB worth. Type an end-of-file indicator (usually control-D or control-Z) to terminate the comment text entry. wrjpgcom will not add a COM block if the provided comment string is empty. Therefore -replace -comment "" can be used to delete all COM blocks from a file. These utility programs do not depend on the IJG JPEG library. In particular, the source code for rdjpgcom is intended as an illustration of the minimum amount of code required to parse a JPEG file header correctly. Papyrus3/JpegDir/JpgLossy/JFDCTFST.C0000755000175000017500000001717207535143454014162 0ustar /* * jfdctfst.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains a fast, not so accurate integer implementation of the * forward DCT (Discrete Cosine Transform). * * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT * on each column. Direct algorithms are also available, but they are * much more complex and seem not to be any faster when reduced to code. * * This implementation is based on Arai, Agui, and Nakajima's algorithm for * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in * Japanese, but the algorithm is described in the Pennebaker & Mitchell * JPEG textbook (see REFERENCES section in file README). The following code * is based directly on figure 4-8 in P&M. * While an 8-point DCT cannot be done in less than 11 multiplies, it is * possible to arrange the computation so that many of the multiplies are * simple scalings of the final outputs. These multiplies can then be * folded into the multiplications or divisions by the JPEG quantization * table entries. The AA&N method leaves only 5 multiplies and 29 adds * to be done in the DCT itself. * The primary disadvantage of this method is that with fixed-point math, * accuracy is lost due to imprecise representation of the scaled * quantization values. The smaller the quantization table entry, the less * precise the scaled value, so this implementation does worse with high- * quality-setting files than with low-quality ones. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jdct.h" /* Private declarations for DCT subsystem */ #ifdef DCT_IFAST_SUPPORTED /* * This module is specialized to the case DCTSIZE = 8. */ #if DCTSIZE != 8 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ #endif /* Scaling decisions are generally the same as in the LL&M algorithm; * see jfdctint.c for more details. However, we choose to descale * (right shift) multiplication products as soon as they are formed, * rather than carrying additional fractional bits into subsequent additions. * This compromises accuracy slightly, but it lets us save a few shifts. * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples) * everywhere except in the multiplications proper; this saves a good deal * of work on 16-bit-int machines. * * Again to save a few shifts, the intermediate results between pass 1 and * pass 2 are not upscaled, but are represented only to integral precision. * * A final compromise is to represent the multiplicative constants to only * 8 fractional bits, rather than 13. This saves some shifting work on some * machines, and may also reduce the cost of multiplication (since there * are fewer one-bits in the constants). */ #define CONST_BITS 8 /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus * causing a lot of useless floating-point operations at run time. * To get around this we use the following pre-calculated constants. * If you change CONST_BITS you may want to add appropriate values. * (With a reasonable C compiler, you can just rely on the FIX() macro...) */ #if CONST_BITS == 8 #define FIX_0_382683433 ((INT32) 98) /* FIX(0.382683433) */ #define FIX_0_541196100 ((INT32) 139) /* FIX(0.541196100) */ #define FIX_0_707106781 ((INT32) 181) /* FIX(0.707106781) */ #define FIX_1_306562965 ((INT32) 334) /* FIX(1.306562965) */ #else #define FIX_0_382683433 FIX(0.382683433) #define FIX_0_541196100 FIX(0.541196100) #define FIX_0_707106781 FIX(0.707106781) #define FIX_1_306562965 FIX(1.306562965) #endif /* We can gain a little more speed, with a further compromise in accuracy, * by omitting the addition in a descaling shift. This yields an incorrectly * rounded result half the time... */ #ifndef USE_ACCURATE_ROUNDING #undef DESCALE #define DESCALE(x,n) RIGHT_SHIFT(x, n) #endif /* Multiply a DCTELEM variable by an INT32 constant, and immediately * descale to yield a DCTELEM result. */ #define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS)) /* * Perform the forward DCT on one block of samples. */ GLOBAL(void) jpeg_fdct_ifast (DCTELEM * data) { DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; DCTELEM tmp10, tmp11, tmp12, tmp13; DCTELEM z1, z2, z3, z4, z5, z11, z13; DCTELEM *dataptr; int ctr; SHIFT_TEMPS /* Pass 1: process rows. */ dataptr = data; for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { tmp0 = dataptr[0] + dataptr[7]; tmp7 = dataptr[0] - dataptr[7]; tmp1 = dataptr[1] + dataptr[6]; tmp6 = dataptr[1] - dataptr[6]; tmp2 = dataptr[2] + dataptr[5]; tmp5 = dataptr[2] - dataptr[5]; tmp3 = dataptr[3] + dataptr[4]; tmp4 = dataptr[3] - dataptr[4]; /* Even part */ tmp10 = tmp0 + tmp3; /* phase 2 */ tmp13 = tmp0 - tmp3; tmp11 = tmp1 + tmp2; tmp12 = tmp1 - tmp2; dataptr[0] = tmp10 + tmp11; /* phase 3 */ dataptr[4] = tmp10 - tmp11; z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ dataptr[2] = tmp13 + z1; /* phase 5 */ dataptr[6] = tmp13 - z1; /* Odd part */ tmp10 = tmp4 + tmp5; /* phase 2 */ tmp11 = tmp5 + tmp6; tmp12 = tmp6 + tmp7; /* The rotator is modified from fig 4-8 to avoid extra negations. */ z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ z11 = tmp7 + z3; /* phase 5 */ z13 = tmp7 - z3; dataptr[5] = z13 + z2; /* phase 6 */ dataptr[3] = z13 - z2; dataptr[1] = z11 + z4; dataptr[7] = z11 - z4; dataptr += DCTSIZE; /* advance pointer to next row */ } /* Pass 2: process columns. */ dataptr = data; for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; /* Even part */ tmp10 = tmp0 + tmp3; /* phase 2 */ tmp13 = tmp0 - tmp3; tmp11 = tmp1 + tmp2; tmp12 = tmp1 - tmp2; dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */ dataptr[DCTSIZE*4] = tmp10 - tmp11; z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */ dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */ dataptr[DCTSIZE*6] = tmp13 - z1; /* Odd part */ tmp10 = tmp4 + tmp5; /* phase 2 */ tmp11 = tmp5 + tmp6; tmp12 = tmp6 + tmp7; /* The rotator is modified from fig 4-8 to avoid extra negations. */ z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */ z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */ z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */ z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */ z11 = tmp7 + z3; /* phase 5 */ z13 = tmp7 - z3; dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */ dataptr[DCTSIZE*3] = z13 - z2; dataptr[DCTSIZE*1] = z11 + z4; dataptr[DCTSIZE*7] = z11 - z4; dataptr++; /* advance pointer to next column */ } } #endif /* DCT_IFAST_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/jmemdosa.asm0000755000175000017500000002076507535143454015152 0ustar ; ; jmemdosa.asm ; ; Copyright (C) 1992, Thomas G. Lane. ; This file is part of the Independent JPEG Group's software. ; For conditions of distribution and use, see the accompanying README file. ; ; This file contains low-level interface routines to support the MS-DOS ; backing store manager (jmemdos.c). Routines are provided to access disk ; files through direct DOS calls, and to access XMS and EMS drivers. ; ; This file should assemble with Microsoft's MASM or any compatible ; assembler (including Borland's Turbo Assembler). If you haven't got ; a compatible assembler, better fall back to jmemansi.c or jmemname.c. ; ; To minimize dependence on the C compiler's register usage conventions, ; we save and restore all 8086 registers, even though most compilers only ; require SI,DI,DS to be preserved. Also, we use only 16-bit-wide return ; values, which everybody returns in AX. ; ; Based on code contributed by Ge' Weijers. ; JMEMDOSA_TXT segment byte public 'CODE' assume cs:JMEMDOSA_TXT public _jdos_open public _jdos_close public _jdos_seek public _jdos_read public _jdos_write public _jxms_getdriver public _jxms_calldriver public _jems_available public _jems_calldriver ; ; short far jdos_open (short far * handle, char far * filename) ; ; Create and open a temporary file ; _jdos_open proc far push bp ; linkage mov bp,sp push si ; save all registers for safety push di push bx push cx push dx push es push ds mov cx,0 ; normal file attributes lds dx,dword ptr [bp+10] ; get filename pointer mov ah,3ch ; create file int 21h jc open_err ; if failed, return error code lds bx,dword ptr [bp+6] ; get handle pointer mov word ptr [bx],ax ; save the handle xor ax,ax ; return zero for OK open_err: pop ds ; restore registers and exit pop es pop dx pop cx pop bx pop di pop si pop bp ret _jdos_open endp ; ; short far jdos_close (short handle) ; ; Close the file handle ; _jdos_close proc far push bp ; linkage mov bp,sp push si ; save all registers for safety push di push bx push cx push dx push es push ds mov bx,word ptr [bp+6] ; file handle mov ah,3eh ; close file int 21h jc close_err ; if failed, return error code xor ax,ax ; return zero for OK close_err: pop ds ; restore registers and exit pop es pop dx pop cx pop bx pop di pop si pop bp ret _jdos_close endp ; ; short far jdos_seek (short handle, long offset) ; ; Set file position ; _jdos_seek proc far push bp ; linkage mov bp,sp push si ; save all registers for safety push di push bx push cx push dx push es push ds mov bx,word ptr [bp+6] ; file handle mov dx,word ptr [bp+8] ; LS offset mov cx,word ptr [bp+10] ; MS offset mov ax,4200h ; absolute seek int 21h jc seek_err ; if failed, return error code xor ax,ax ; return zero for OK seek_err: pop ds ; restore registers and exit pop es pop dx pop cx pop bx pop di pop si pop bp ret _jdos_seek endp ; ; short far jdos_read (short handle, void far * buffer, unsigned short count) ; ; Read from file ; _jdos_read proc far push bp ; linkage mov bp,sp push si ; save all registers for safety push di push bx push cx push dx push es push ds mov bx,word ptr [bp+6] ; file handle lds dx,dword ptr [bp+8] ; buffer address mov cx,word ptr [bp+12] ; number of bytes mov ah,3fh ; read file int 21h jc read_err ; if failed, return error code cmp ax,word ptr [bp+12] ; make sure all bytes were read je read_ok mov ax,1 ; else return 1 for not OK jmp short read_err read_ok: xor ax,ax ; return zero for OK read_err: pop ds ; restore registers and exit pop es pop dx pop cx pop bx pop di pop si pop bp ret _jdos_read endp ; ; short far jdos_write (short handle, void far * buffer, unsigned short count) ; ; Write to file ; _jdos_write proc far push bp ; linkage mov bp,sp push si ; save all registers for safety push di push bx push cx push dx push es push ds mov bx,word ptr [bp+6] ; file handle lds dx,dword ptr [bp+8] ; buffer address mov cx,word ptr [bp+12] ; number of bytes mov ah,40h ; write file int 21h jc write_err ; if failed, return error code cmp ax,word ptr [bp+12] ; make sure all bytes written je write_ok mov ax,1 ; else return 1 for not OK jmp short write_err write_ok: xor ax,ax ; return zero for OK write_err: pop ds ; restore registers and exit pop es pop dx pop cx pop bx pop di pop si pop bp ret _jdos_write endp ; ; void far jxms_getdriver (XMSDRIVER far *) ; ; Get the address of the XMS driver, or NULL if not available ; _jxms_getdriver proc far push bp ; linkage mov bp,sp push si ; save all registers for safety push di push bx push cx push dx push es push ds mov ax,4300h ; call multiplex interrupt with int 2fh ; a magic cookie, hex 4300 cmp al,80h ; AL should contain hex 80 je xmsavail xor dx,dx ; no XMS driver available xor ax,ax ; return a nil pointer jmp short xmsavail_done xmsavail: mov ax,4310h ; fetch driver address with int 2fh ; another magic cookie mov dx,es ; copy address to dx:ax mov ax,bx xmsavail_done: les bx,dword ptr [bp+6] ; get pointer to return value mov word ptr es:[bx],ax mov word ptr es:[bx+2],dx pop ds ; restore registers and exit pop es pop dx pop cx pop bx pop di pop si pop bp ret _jxms_getdriver endp ; ; void far jxms_calldriver (XMSDRIVER, XMScontext far *) ; ; The XMScontext structure contains values for the AX,DX,BX,SI,DS registers. ; These are loaded, the XMS call is performed, and the new values of the ; AX,DX,BX registers are written back to the context structure. ; _jxms_calldriver proc far push bp ; linkage mov bp,sp push si ; save all registers for safety push di push bx push cx push dx push es push ds les bx,dword ptr [bp+10] ; get XMScontext pointer mov ax,word ptr es:[bx] ; load registers mov dx,word ptr es:[bx+2] mov si,word ptr es:[bx+6] mov ds,word ptr es:[bx+8] mov bx,word ptr es:[bx+4] call dword ptr [bp+6] ; call the driver mov cx,bx ; save returned BX for a sec les bx,dword ptr [bp+10] ; get XMScontext pointer mov word ptr es:[bx],ax ; put back ax,dx,bx mov word ptr es:[bx+2],dx mov word ptr es:[bx+4],cx pop ds ; restore registers and exit pop es pop dx pop cx pop bx pop di pop si pop bp ret _jxms_calldriver endp ; ; short far jems_available (void) ; ; Have we got an EMS driver? (this comes straight from the EMS 4.0 specs) ; _jems_available proc far push si ; save all registers for safety push di push bx push cx push dx push es push ds mov ax,3567h ; get interrupt vector 67h int 21h push cs pop ds mov di,000ah ; check offs 10 in returned seg lea si,ASCII_device_name ; against literal string mov cx,8 cld repe cmpsb jne no_ems mov ax,1 ; match, it's there jmp short avail_done no_ems: xor ax,ax ; it's not there avail_done: pop ds ; restore registers and exit pop es pop dx pop cx pop bx pop di pop si ret ASCII_device_name db "EMMXXXX0" _jems_available endp ; ; void far jems_calldriver (EMScontext far *) ; ; The EMScontext structure contains values for the AX,DX,BX,SI,DS registers. ; These are loaded, the EMS trap is performed, and the new values of the ; AX,DX,BX registers are written back to the context structure. ; _jems_calldriver proc far push bp ; linkage mov bp,sp push si ; save all registers for safety push di push bx push cx push dx push es push ds les bx,dword ptr [bp+6] ; get EMScontext pointer mov ax,word ptr es:[bx] ; load registers mov dx,word ptr es:[bx+2] mov si,word ptr es:[bx+6] mov ds,word ptr es:[bx+8] mov bx,word ptr es:[bx+4] int 67h ; call the EMS driver mov cx,bx ; save returned BX for a sec les bx,dword ptr [bp+6] ; get EMScontext pointer mov word ptr es:[bx],ax ; put back ax,dx,bx mov word ptr es:[bx+2],dx mov word ptr es:[bx+4],cx pop ds ; restore registers and exit pop es pop dx pop cx pop bx pop di pop si pop bp ret _jems_calldriver endp JMEMDOSA_TXT ends end Papyrus3/JpegDir/JpgLossy/.DS_Store0000777000175000017500000001400410047674414014322 0ustar Bud1%  @€ @€ @€ @ E%DSDB`€ @€ @€ @Papyrus3/JpegDir/JpgLossy/config.sub0000755000175000017500000005042407535143454014624 0ustar #! /bin/sh # Configuration validation subroutine script, version 1.1. # Copyright (C) 1991, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc. # This file is (in principle) common to ALL GNU software. # The presence of a machine in this file suggests that SOME GNU software # can handle that machine. It does not imply ALL GNU software can. # # This file is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, # Boston, MA 02111-1307, USA. # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. # If it is invalid, we print an error message on stderr and exit with code 1. # Otherwise, we print the canonical config type on stdout and succeed. # This file is supposed to be the same for all GNU packages # and recognize all the CPU types, system types and aliases # that are meaningful with *any* GNU software. # Each package is responsible for reporting which valid configurations # it does not support. The user should be able to distinguish # a failure to support a valid configuration from a meaningless # configuration. # The goal of this file is to map all the various variations of a given # machine specification into a single specification in the form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM # or in some cases, the newer four-part form: # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM # It is wrong to echo any other type of specification. if [ x$1 = x ] then echo Configuration name missing. 1>&2 echo "Usage: $0 CPU-MFR-OPSYS" 1>&2 echo "or $0 ALIAS" 1>&2 echo where ALIAS is a recognized configuration type. 1>&2 exit 1 fi # First pass through any local machine types. case $1 in *local*) echo $1 exit 0 ;; *) ;; esac # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). # Here we must recognize all the valid KERNEL-OS combinations. maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` case $maybe_os in linux-gnu*) os=-$maybe_os basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` ;; *) basic_machine=`echo $1 | sed 's/-[^-]*$//'` if [ $basic_machine != $1 ] then os=`echo $1 | sed 's/.*-/-/'` else os=; fi ;; esac ### Let's recognize common machines as not being operating systems so ### that things like config.sub decstation-3100 work. We also ### recognize some manufacturers as not being operating systems, so we ### can provide default operating systems below. case $os in -sun*os*) # Prevent following clause from handling this invalid input. ;; -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ -apple) os= basic_machine=$1 ;; -hiux*) os=-hiuxwe2 ;; -sco5) os=sco3.2v5 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco4) os=-sco3.2v4 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2.[4-9]*) os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2v[4-9]*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco*) os=-sco3.2v2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -isc) os=-isc2.2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -clix*) basic_machine=clipper-intergraph ;; -isc*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -lynx*) os=-lynxos ;; -ptx*) basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` ;; -windowsnt*) os=`echo $os | sed -e 's/windowsnt/winnt/'` ;; -psos*) os=-psos ;; esac # Decode aliases for certain CPU-COMPANY combinations. case $basic_machine in # Recognize the basic CPU types without company name. # Some are omitted here because they have special meanings below. tahoe | i860 | m32r | m68k | m68000 | m88k | ns32k | arc | arm \ | arme[lb] | pyramid | mn10200 | mn10300 \ | tron | a29k | 580 | i960 | h8300 | hppa | hppa1.0 | hppa1.1 \ | alpha | alphaev5 | alphaev56 | we32k | ns16k | clipper \ | i370 | sh | powerpc | powerpcle | 1750a | dsp16xx | pdp11 \ | mips64 | mipsel | mips64el | mips64orion | mips64orionel \ | mipstx39 | mipstx39el \ | sparc | sparclet | sparclite | sparc64 | v850) basic_machine=$basic_machine-unknown ;; # We use `pc' rather than `unknown' # because (1) that's what they normally are, and # (2) the word "unknown" tends to confuse beginning users. i[3456]86) basic_machine=$basic_machine-pc ;; # Object if more than one company name word. *-*-*) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; # Recognize the basic CPU types with company name. vax-* | tahoe-* | i[3456]86-* | i860-* | m32r-* | m68k-* | m68000-* \ | m88k-* | sparc-* | ns32k-* | fx80-* | arc-* | arm-* | c[123]* \ | mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* \ | power-* | none-* | 580-* | cray2-* | h8300-* | i960-* \ | xmp-* | ymp-* | hppa-* | hppa1.0-* | hppa1.1-* \ | alpha-* | alphaev5-* | alphaev56-* | we32k-* | cydra-* \ | ns16k-* | pn-* | np1-* | xps100-* | clipper-* | orion-* \ | sparclite-* | pdp11-* | sh-* | powerpc-* | powerpcle-* \ | sparc64-* | mips64-* | mipsel-* \ | mips64el-* | mips64orion-* | mips64orionel-* \ | mipstx39-* | mipstx39el-* \ | f301-*) ;; # Recognize the various machine names and aliases which stand # for a CPU type and a company and sometimes even an OS. 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) basic_machine=m68000-att ;; 3b*) basic_machine=we32k-att ;; alliant | fx80) basic_machine=fx80-alliant ;; altos | altos3068) basic_machine=m68k-altos ;; am29k) basic_machine=a29k-none os=-bsd ;; amdahl) basic_machine=580-amdahl os=-sysv ;; amiga | amiga-*) basic_machine=m68k-cbm ;; amigaos | amigados) basic_machine=m68k-cbm os=-amigaos ;; amigaunix | amix) basic_machine=m68k-cbm os=-sysv4 ;; apollo68) basic_machine=m68k-apollo os=-sysv ;; aux) basic_machine=m68k-apple os=-aux ;; balance) basic_machine=ns32k-sequent os=-dynix ;; convex-c1) basic_machine=c1-convex os=-bsd ;; convex-c2) basic_machine=c2-convex os=-bsd ;; convex-c32) basic_machine=c32-convex os=-bsd ;; convex-c34) basic_machine=c34-convex os=-bsd ;; convex-c38) basic_machine=c38-convex os=-bsd ;; cray | ymp) basic_machine=ymp-cray os=-unicos ;; cray2) basic_machine=cray2-cray os=-unicos ;; [ctj]90-cray) basic_machine=c90-cray os=-unicos ;; crds | unos) basic_machine=m68k-crds ;; da30 | da30-*) basic_machine=m68k-da30 ;; decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) basic_machine=mips-dec ;; delta | 3300 | motorola-3300 | motorola-delta \ | 3300-motorola | delta-motorola) basic_machine=m68k-motorola ;; delta88) basic_machine=m88k-motorola os=-sysv3 ;; dpx20 | dpx20-*) basic_machine=rs6000-bull os=-bosx ;; dpx2* | dpx2*-bull) basic_machine=m68k-bull os=-sysv3 ;; ebmon29k) basic_machine=a29k-amd os=-ebmon ;; elxsi) basic_machine=elxsi-elxsi os=-bsd ;; encore | umax | mmax) basic_machine=ns32k-encore ;; fx2800) basic_machine=i860-alliant ;; genix) basic_machine=ns32k-ns ;; gmicro) basic_machine=tron-gmicro os=-sysv ;; h3050r* | hiux*) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; h8300hms) basic_machine=h8300-hitachi os=-hms ;; harris) basic_machine=m88k-harris os=-sysv3 ;; hp300-*) basic_machine=m68k-hp ;; hp300bsd) basic_machine=m68k-hp os=-bsd ;; hp300hpux) basic_machine=m68k-hp os=-hpux ;; hp9k2[0-9][0-9] | hp9k31[0-9]) basic_machine=m68000-hp ;; hp9k3[2-9][0-9]) basic_machine=m68k-hp ;; hp9k7[0-9][0-9] | hp7[0-9][0-9] | hp9k8[0-9]7 | hp8[0-9]7) basic_machine=hppa1.1-hp ;; hp9k8[0-9][0-9] | hp8[0-9][0-9]) basic_machine=hppa1.0-hp ;; hppa-next) os=-nextstep3 ;; i370-ibm* | ibm*) basic_machine=i370-ibm os=-mvs ;; # I'm not sure what "Sysv32" means. Should this be sysv3.2? i[3456]86v32) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv32 ;; i[3456]86v4*) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv4 ;; i[3456]86v) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv ;; i[3456]86sol2) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-solaris2 ;; iris | iris4d) basic_machine=mips-sgi case $os in -irix*) ;; *) os=-irix4 ;; esac ;; isi68 | isi) basic_machine=m68k-isi os=-sysv ;; m88k-omron*) basic_machine=m88k-omron ;; magnum | m3230) basic_machine=mips-mips os=-sysv ;; merlin) basic_machine=ns32k-utek os=-sysv ;; miniframe) basic_machine=m68000-convergent ;; mipsel*-linux*) basic_machine=mipsel-unknown os=-linux-gnu ;; mips*-linux*) basic_machine=mips-unknown os=-linux-gnu ;; mips3*-*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` ;; mips3*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown ;; ncr3000) basic_machine=i486-ncr os=-sysv4 ;; news | news700 | news800 | news900) basic_machine=m68k-sony os=-newsos ;; news1000) basic_machine=m68030-sony os=-newsos ;; news-3600 | risc-news) basic_machine=mips-sony os=-newsos ;; next | m*-next ) basic_machine=m68k-next case $os in -nextstep* ) ;; -ns2*) os=-nextstep2 ;; *) os=-nextstep3 ;; esac ;; nh3000) basic_machine=m68k-harris os=-cxux ;; nh[45]000) basic_machine=m88k-harris os=-cxux ;; nindy960) basic_machine=i960-intel os=-nindy ;; np1) basic_machine=np1-gould ;; pa-hitachi) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; paragon) basic_machine=i860-intel os=-osf ;; pbd) basic_machine=sparc-tti ;; pbb) basic_machine=m68k-tti ;; pc532 | pc532-*) basic_machine=ns32k-pc532 ;; pentium | p5) basic_machine=i586-intel ;; pentiumpro | p6) basic_machine=i686-intel ;; pentium-* | p5-*) basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumpro-* | p6-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; k5) # We don't have specific support for AMD's K5 yet, so just call it a Pentium basic_machine=i586-amd ;; nexen) # We don't have specific support for Nexgen yet, so just call it a Pentium basic_machine=i586-nexgen ;; pn) basic_machine=pn-gould ;; power) basic_machine=rs6000-ibm ;; ppc) basic_machine=powerpc-unknown ;; ppc-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppcle | powerpclittle | ppc-le | powerpc-little) basic_machine=powerpcle-unknown ;; ppcle-* | powerpclittle-*) basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ps2) basic_machine=i386-ibm ;; rm[46]00) basic_machine=mips-siemens ;; rtpc | rtpc-*) basic_machine=romp-ibm ;; sequent) basic_machine=i386-sequent ;; sh) basic_machine=sh-hitachi os=-hms ;; sps7) basic_machine=m68k-bull os=-sysv2 ;; spur) basic_machine=spur-unknown ;; sun2) basic_machine=m68000-sun ;; sun2os3) basic_machine=m68000-sun os=-sunos3 ;; sun2os4) basic_machine=m68000-sun os=-sunos4 ;; sun3os3) basic_machine=m68k-sun os=-sunos3 ;; sun3os4) basic_machine=m68k-sun os=-sunos4 ;; sun4os3) basic_machine=sparc-sun os=-sunos3 ;; sun4os4) basic_machine=sparc-sun os=-sunos4 ;; sun4sol2) basic_machine=sparc-sun os=-solaris2 ;; sun3 | sun3-*) basic_machine=m68k-sun ;; sun4) basic_machine=sparc-sun ;; sun386 | sun386i | roadrunner) basic_machine=i386-sun ;; symmetry) basic_machine=i386-sequent os=-dynix ;; tx39) basic_machine=mipstx39-unknown ;; tx39el) basic_machine=mipstx39el-unknown ;; tower | tower-32) basic_machine=m68k-ncr ;; udi29k) basic_machine=a29k-amd os=-udi ;; ultra3) basic_machine=a29k-nyu os=-sym1 ;; vaxv) basic_machine=vax-dec os=-sysv ;; vms) basic_machine=vax-dec os=-vms ;; vpp*|vx|vx-*) basic_machine=f301-fujitsu ;; vxworks960) basic_machine=i960-wrs os=-vxworks ;; vxworks68) basic_machine=m68k-wrs os=-vxworks ;; vxworks29k) basic_machine=a29k-wrs os=-vxworks ;; xmp) basic_machine=xmp-cray os=-unicos ;; xps | xps100) basic_machine=xps100-honeywell ;; none) basic_machine=none-none os=-none ;; # Here we handle the default manufacturer of certain CPU types. It is in # some cases the only manufacturer, in others, it is the most popular. mips) if [ x$os = x-linux-gnu ]; then basic_machine=mips-unknown else basic_machine=mips-mips fi ;; romp) basic_machine=romp-ibm ;; rs6000) basic_machine=rs6000-ibm ;; vax) basic_machine=vax-dec ;; pdp11) basic_machine=pdp11-dec ;; we32k) basic_machine=we32k-att ;; sparc) basic_machine=sparc-sun ;; cydra) basic_machine=cydra-cydrome ;; orion) basic_machine=orion-highlevel ;; orion105) basic_machine=clipper-highlevel ;; *) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; esac # Here we canonicalize certain aliases for manufacturers. case $basic_machine in *-digital*) basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` ;; *-commodore*) basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` ;; *) ;; esac # Decode manufacturer-specific aliases for certain operating systems. if [ x"$os" != x"" ] then case $os in # First match some system type aliases # that might get confused with valid system types. # -solaris* is a basic system type, with this one exception. -solaris1 | -solaris1.*) os=`echo $os | sed -e 's|solaris1|sunos4|'` ;; -solaris) os=-solaris2 ;; -svr4*) os=-sysv4 ;; -unixware*) os=-sysv4.2uw ;; -gnu/linux*) os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` ;; # First accept the basic system types. # The portable systems comes first. # Each alternative MUST END IN A *, to match a version number. # -sysv* is not here because it comes later, after sysvr4. -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ | -aos* \ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -386bsd* | -netbsd* | -openbsd* | -freebsd* | -riscix* \ | -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* \ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ | -cygwin32* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ | -mingw32* | -linux-gnu* | -uxpv*) # Remember, each alternative MUST END IN *, to match a version number. ;; -linux*) os=`echo $os | sed -e 's|linux|linux-gnu|'` ;; -sunos5*) os=`echo $os | sed -e 's|sunos5|solaris2|'` ;; -sunos6*) os=`echo $os | sed -e 's|sunos6|solaris3|'` ;; -osfrose*) os=-osfrose ;; -osf*) os=-osf ;; -utek*) os=-bsd ;; -dynix*) os=-bsd ;; -acis*) os=-aos ;; -ctix* | -uts*) os=-sysv ;; -ns2 ) os=-nextstep2 ;; # Preserve the version number of sinix5. -sinix5.*) os=`echo $os | sed -e 's|sinix|sysv|'` ;; -sinix*) os=-sysv4 ;; -triton*) os=-sysv3 ;; -oss*) os=-sysv3 ;; -svr4) os=-sysv4 ;; -svr3) os=-sysv3 ;; -sysvr4) os=-sysv4 ;; # This must come after -sysvr4. -sysv*) ;; -xenix) os=-xenix ;; -none) ;; *) # Get rid of the `-' at the beginning of $os. os=`echo $os | sed 's/[^-]*-//'` echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 exit 1 ;; esac else # Here we handle the default operating systems that come with various machines. # The value should be what the vendor currently ships out the door with their # machine or put another way, the most popular os provided with the machine. # Note that if you're going to try to match "-MANUFACTURER" here (say, # "-sun"), then you have to tell the case statement up towards the top # that MANUFACTURER isn't an operating system. Otherwise, code above # will signal an error saying that MANUFACTURER isn't an operating # system, and we'll never get to this point. case $basic_machine in *-acorn) os=-riscix1.2 ;; arm*-semi) os=-aout ;; pdp11-*) os=-none ;; *-dec | vax-*) os=-ultrix4.2 ;; m68*-apollo) os=-domain ;; i386-sun) os=-sunos4.0.2 ;; m68000-sun) os=-sunos3 # This also exists in the configure program, but was not the # default. # os=-sunos4 ;; *-tti) # must be before sparc entry or we get the wrong os. os=-sysv3 ;; sparc-* | *-sun) os=-sunos4.1.1 ;; *-ibm) os=-aix ;; *-hp) os=-hpux ;; *-hitachi) os=-hiux ;; i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) os=-sysv ;; *-cbm) os=-amigaos ;; *-dg) os=-dgux ;; *-dolphin) os=-sysv3 ;; m68k-ccur) os=-rtu ;; m88k-omron*) os=-luna ;; *-next ) os=-nextstep ;; *-sequent) os=-ptx ;; *-crds) os=-unos ;; *-ns) os=-genix ;; i370-*) os=-mvs ;; *-next) os=-nextstep3 ;; *-gould) os=-sysv ;; *-highlevel) os=-bsd ;; *-encore) os=-bsd ;; *-sgi) os=-irix ;; *-siemens) os=-sysv4 ;; *-masscomp) os=-rtu ;; f301-fujitsu) os=-uxpv ;; *) os=-none ;; esac fi # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. vendor=unknown case $basic_machine in *-unknown) case $os in -riscix*) vendor=acorn ;; -sunos*) vendor=sun ;; -aix*) vendor=ibm ;; -hpux*) vendor=hp ;; -hiux*) vendor=hitachi ;; -unos*) vendor=crds ;; -dgux*) vendor=dg ;; -luna*) vendor=omron ;; -genix*) vendor=ns ;; -mvs*) vendor=ibm ;; -ptx*) vendor=sequent ;; -vxsim* | -vxworks*) vendor=wrs ;; -aux*) vendor=apple ;; esac basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` ;; esac echo $basic_machine$os Papyrus3/JpegDir/JpgLossy/JPEGTRAN.C0000755000175000017500000004053407535143454014163 0ustar /* * jpegtran.c * * Copyright (C) 1995-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains a command-line user interface for JPEG transcoding. * It is very similar to cjpeg.c, but provides lossless transcoding between * different JPEG file formats. It also provides some lossless and sort-of- * lossless transformations of JPEG data. */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ #include "transupp.h" /* Support routines for jpegtran */ #include "jversion.h" /* for version message */ #ifdef USE_CCOMMAND /* command-line reader for Macintosh */ #ifdef __MWERKS__ #include /* Metrowerks needs this */ #include /* ... and this */ #endif #ifdef THINK_C #include /* Think declares it here */ #endif #endif /* * Argument-parsing code. * The switch parser is designed to be useful with DOS-style command line * syntax, ie, intermixed switches and file names, where only the switches * to the left of a given file name affect processing of that file. * The main program in this file doesn't actually use this capability... */ static const char * progname; /* program name for error messages */ static char * outfilename; /* for -outfile switch */ static JCOPY_OPTION copyoption; /* -copy switch */ static jpeg_transform_info transformoption; /* image transformation options */ LOCAL(void) usage (void) /* complain about bad command line */ { fprintf(stderr, "usage: %s [switches] ", progname); #ifdef TWO_FILE_COMMANDLINE fprintf(stderr, "inputfile outputfile\n"); #else fprintf(stderr, "[inputfile]\n"); #endif fprintf(stderr, "Switches (names may be abbreviated):\n"); fprintf(stderr, " -copy none Copy no extra markers from source file\n"); fprintf(stderr, " -copy comments Copy only comment markers (default)\n"); fprintf(stderr, " -copy all Copy all extra markers\n"); #ifdef ENTROPY_OPT_SUPPORTED fprintf(stderr, " -optimize Optimize Huffman table (smaller file, but slow compression)\n"); #endif #ifdef C_PROGRESSIVE_SUPPORTED fprintf(stderr, " -progressive Create progressive JPEG file\n"); #endif #if TRANSFORMS_SUPPORTED fprintf(stderr, "Switches for modifying the image:\n"); fprintf(stderr, " -grayscale Reduce to grayscale (omit color data)\n"); fprintf(stderr, " -flip [horizontal|vertical] Mirror image (left-right or top-bottom)\n"); fprintf(stderr, " -rotate [90|180|270] Rotate image (degrees clockwise)\n"); fprintf(stderr, " -transpose Transpose image\n"); fprintf(stderr, " -transverse Transverse transpose image\n"); fprintf(stderr, " -trim Drop non-transformable edge blocks\n"); #endif /* TRANSFORMS_SUPPORTED */ fprintf(stderr, "Switches for advanced users:\n"); fprintf(stderr, " -restart N Set restart interval in rows, or in blocks with B\n"); fprintf(stderr, " -maxmemory N Maximum memory to use (in kbytes)\n"); fprintf(stderr, " -outfile name Specify name for output file\n"); fprintf(stderr, " -verbose or -debug Emit debug output\n"); fprintf(stderr, "Switches for wizards:\n"); #ifdef C_ARITH_CODING_SUPPORTED fprintf(stderr, " -arithmetic Use arithmetic coding\n"); #endif #ifdef C_MULTISCAN_FILES_SUPPORTED fprintf(stderr, " -scans file Create multi-scan JPEG per script file\n"); #endif exit(EXIT_FAILURE); } LOCAL(void) select_transform (JXFORM_CODE transform) /* Silly little routine to detect multiple transform options, * which we can't handle. */ { #if TRANSFORMS_SUPPORTED if (transformoption.transform == JXFORM_NONE || transformoption.transform == transform) { transformoption.transform = transform; } else { fprintf(stderr, "%s: can only do one image transformation at a time\n", progname); usage(); } #else fprintf(stderr, "%s: sorry, image transformation was not compiled\n", progname); exit(EXIT_FAILURE); #endif } LOCAL(int) parse_switches (j_compress_ptr cinfo, int argc, char **argv, int last_file_arg_seen, boolean for_real) /* Parse optional switches. * Returns argv[] index of first file-name argument (== argc if none). * Any file names with indexes <= last_file_arg_seen are ignored; * they have presumably been processed in a previous iteration. * (Pass 0 for last_file_arg_seen on the first or only iteration.) * for_real is FALSE on the first (dummy) pass; we may skip any expensive * processing. */ { int argn; char * arg; boolean simple_progressive; char * scansarg = NULL; /* saves -scans parm if any */ /* Set up default JPEG parameters. */ simple_progressive = FALSE; outfilename = NULL; copyoption = JCOPYOPT_DEFAULT; transformoption.transform = JXFORM_NONE; transformoption.trim = FALSE; transformoption.force_grayscale = FALSE; cinfo->err->trace_level = 0; /* Scan command line options, adjust parameters */ for (argn = 1; argn < argc; argn++) { arg = argv[argn]; if (*arg != '-') { /* Not a switch, must be a file name argument */ if (argn <= last_file_arg_seen) { outfilename = NULL; /* -outfile applies to just one input file */ continue; /* ignore this name if previously processed */ } break; /* else done parsing switches */ } arg++; /* advance past switch marker character */ if (keymatch(arg, "arithmetic", 1)) { /* Use arithmetic coding. */ #ifdef C_ARITH_CODING_SUPPORTED cinfo->arith_code = TRUE; #else fprintf(stderr, "%s: sorry, arithmetic coding not supported\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "copy", 1)) { /* Select which extra markers to copy. */ if (++argn >= argc) /* advance to next argument */ usage(); if (keymatch(argv[argn], "none", 1)) { copyoption = JCOPYOPT_NONE; } else if (keymatch(argv[argn], "comments", 1)) { copyoption = JCOPYOPT_COMMENTS; } else if (keymatch(argv[argn], "all", 1)) { copyoption = JCOPYOPT_ALL; } else usage(); } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) { /* Enable debug printouts. */ /* On first -d, print version identification */ static boolean printed_version = FALSE; if (! printed_version) { fprintf(stderr, "Independent JPEG Group's JPEGTRAN, version %s\n%s\n", JVERSION, JCOPYRIGHT); printed_version = TRUE; } cinfo->err->trace_level++; } else if (keymatch(arg, "flip", 1)) { /* Mirror left-right or top-bottom. */ if (++argn >= argc) /* advance to next argument */ usage(); if (keymatch(argv[argn], "horizontal", 1)) select_transform(JXFORM_FLIP_H); else if (keymatch(argv[argn], "vertical", 1)) select_transform(JXFORM_FLIP_V); else usage(); } else if (keymatch(arg, "grayscale", 1) || keymatch(arg, "greyscale",1)) { /* Force to grayscale. */ #if TRANSFORMS_SUPPORTED transformoption.force_grayscale = TRUE; #else select_transform(JXFORM_NONE); /* force an error */ #endif } else if (keymatch(arg, "maxmemory", 3)) { /* Maximum memory in Kb (or Mb with 'm'). */ long lval; char ch = 'x'; if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1) usage(); if (ch == 'm' || ch == 'M') lval *= 1000L; cinfo->mem->max_memory_to_use = lval * 1000L; } else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) { /* Enable entropy parm optimization. */ #ifdef ENTROPY_OPT_SUPPORTED cinfo->optimize_coding = TRUE; #else fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "outfile", 4)) { /* Set output file name. */ if (++argn >= argc) /* advance to next argument */ usage(); outfilename = argv[argn]; /* save it away for later use */ } else if (keymatch(arg, "progressive", 1)) { /* Select simple progressive mode. */ #ifdef C_PROGRESSIVE_SUPPORTED simple_progressive = TRUE; /* We must postpone execution until num_components is known. */ #else fprintf(stderr, "%s: sorry, progressive output was not compiled\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "restart", 1)) { /* Restart interval in MCU rows (or in MCUs with 'b'). */ long lval; char ch = 'x'; if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1) usage(); if (lval < 0 || lval > 65535L) usage(); if (ch == 'b' || ch == 'B') { cinfo->restart_interval = (unsigned int) lval; cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */ } else { cinfo->restart_in_rows = (int) lval; /* restart_interval will be computed during startup */ } } else if (keymatch(arg, "rotate", 2)) { /* Rotate 90, 180, or 270 degrees (measured clockwise). */ if (++argn >= argc) /* advance to next argument */ usage(); if (keymatch(argv[argn], "90", 2)) select_transform(JXFORM_ROT_90); else if (keymatch(argv[argn], "180", 3)) select_transform(JXFORM_ROT_180); else if (keymatch(argv[argn], "270", 3)) select_transform(JXFORM_ROT_270); else usage(); } else if (keymatch(arg, "scans", 1)) { /* Set scan script. */ #ifdef C_MULTISCAN_FILES_SUPPORTED if (++argn >= argc) /* advance to next argument */ usage(); scansarg = argv[argn]; /* We must postpone reading the file in case -progressive appears. */ #else fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "transpose", 1)) { /* Transpose (across UL-to-LR axis). */ select_transform(JXFORM_TRANSPOSE); } else if (keymatch(arg, "transverse", 6)) { /* Transverse transpose (across UR-to-LL axis). */ select_transform(JXFORM_TRANSVERSE); } else if (keymatch(arg, "trim", 3)) { /* Trim off any partial edge MCUs that the transform can't handle. */ transformoption.trim = TRUE; } else { usage(); /* bogus switch */ } } /* Post-switch-scanning cleanup */ if (for_real) { #ifdef C_PROGRESSIVE_SUPPORTED if (simple_progressive) /* process -progressive; -scans can override */ jpeg_simple_progression(cinfo); #endif #ifdef C_MULTISCAN_FILES_SUPPORTED if (scansarg != NULL) /* process -scans if it was present */ if (! read_scan_script(cinfo, scansarg)) usage(); #endif } return argn; /* return index of next arg (file name) */ } /* * The main program. */ int main (int argc, char **argv) { struct jpeg_decompress_struct srcinfo; struct jpeg_compress_struct dstinfo; struct jpeg_error_mgr jsrcerr, jdsterr; #ifdef PROGRESS_REPORT struct cdjpeg_progress_mgr progress; #endif jvirt_barray_ptr * src_coef_arrays; jvirt_barray_ptr * dst_coef_arrays; int file_index; FILE * input_file; FILE * output_file; /* On Mac, fetch a command line. */ #ifdef USE_CCOMMAND argc = ccommand(&argv); #endif progname = argv[0]; if (progname == NULL || progname[0] == 0) progname = "jpegtran"; /* in case C library doesn't provide it */ /* Initialize the JPEG decompression object with default error handling. */ srcinfo.err = jpeg_std_error(&jsrcerr); jpeg_create_decompress(&srcinfo); /* Initialize the JPEG compression object with default error handling. */ dstinfo.err = jpeg_std_error(&jdsterr); jpeg_create_compress(&dstinfo); /* Now safe to enable signal catcher. * Note: we assume only the decompression object will have virtual arrays. */ #ifdef NEED_SIGNAL_CATCHER enable_signal_catcher((j_common_ptr) &srcinfo); #endif /* Scan command line to find file names. * It is convenient to use just one switch-parsing routine, but the switch * values read here are mostly ignored; we will rescan the switches after * opening the input file. Also note that most of the switches affect the * destination JPEG object, so we parse into that and then copy over what * needs to affects the source too. */ file_index = parse_switches(&dstinfo, argc, argv, 0, FALSE); jsrcerr.trace_level = jdsterr.trace_level; srcinfo.mem->max_memory_to_use = dstinfo.mem->max_memory_to_use; #ifdef TWO_FILE_COMMANDLINE /* Must have either -outfile switch or explicit output file name */ if (outfilename == NULL) { if (file_index != argc-2) { fprintf(stderr, "%s: must name one input and one output file\n", progname); usage(); } outfilename = argv[file_index+1]; } else { if (file_index != argc-1) { fprintf(stderr, "%s: must name one input and one output file\n", progname); usage(); } } #else /* Unix style: expect zero or one file name */ if (file_index < argc-1) { fprintf(stderr, "%s: only one input file\n", progname); usage(); } #endif /* TWO_FILE_COMMANDLINE */ /* Open the input file. */ if (file_index < argc) { if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) { fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]); exit(EXIT_FAILURE); } } else { /* default input file is stdin */ input_file = read_stdin(); } /* Open the output file. */ if (outfilename != NULL) { if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) { fprintf(stderr, "%s: can't open %s\n", progname, outfilename); exit(EXIT_FAILURE); } } else { /* default output file is stdout */ output_file = write_stdout(); } #ifdef PROGRESS_REPORT start_progress_monitor((j_common_ptr) &dstinfo, &progress); #endif /* Specify data source for decompression */ jpeg_stdio_src(&srcinfo, input_file); /* Enable saving of extra markers that we want to copy */ jcopy_markers_setup(&srcinfo, copyoption); /* Read file header */ (void) jpeg_read_header(&srcinfo, TRUE); /* Any space needed by a transform option must be requested before * jpeg_read_coefficients so that memory allocation will be done right. */ #if TRANSFORMS_SUPPORTED jtransform_request_workspace(&srcinfo, &transformoption); #endif /* Read source file as DCT coefficients */ src_coef_arrays = jpeg_read_coefficients(&srcinfo); /* Initialize destination compression parameters from source values */ jpeg_copy_critical_parameters(&srcinfo, &dstinfo); /* Adjust destination parameters if required by transform options; * also find out which set of coefficient arrays will hold the output. */ #if TRANSFORMS_SUPPORTED dst_coef_arrays = jtransform_adjust_parameters(&srcinfo, &dstinfo, src_coef_arrays, &transformoption); #else dst_coef_arrays = src_coef_arrays; #endif /* Adjust default compression parameters by re-parsing the options */ file_index = parse_switches(&dstinfo, argc, argv, 0, TRUE); /* Specify data destination for compression */ jpeg_stdio_dest(&dstinfo, &output_file); /* Start compressor (note no image data is actually written here) */ jpeg_write_coefficients(&dstinfo, dst_coef_arrays); /* Copy to the output file any extra markers that we want to preserve */ jcopy_markers_execute(&srcinfo, &dstinfo, copyoption); /* Execute image transformation, if any */ #if TRANSFORMS_SUPPORTED jtransform_execute_transformation(&srcinfo, &dstinfo, src_coef_arrays, &transformoption); #endif /* Finish compression and release memory */ jpeg_finish_compress(&dstinfo); jpeg_destroy_compress(&dstinfo); (void) jpeg_finish_decompress(&srcinfo); jpeg_destroy_decompress(&srcinfo); /* Close files, if we opened them */ if (input_file != stdin) fclose(input_file); if (output_file != stdout) fclose(output_file); #ifdef PROGRESS_REPORT end_progress_monitor((j_common_ptr) &dstinfo); #endif /* All done. */ exit(jsrcerr.num_warnings + jdsterr.num_warnings ?EXIT_WARNING:EXIT_SUCCESS); return 0; /* suppress no-return-value warnings */ } Papyrus3/JpegDir/JpgLossy/makvms.opt0000755000175000017500000000032607535143454014662 0ustar ! A pointer to the VAX/VMS C Run-Time Shareable Library. ! This file is needed by makefile.mms and makefile.vms, ! but only for the older VAX C compiler. DEC C does not need it. Sys$Library:VAXCRTL.EXE /Share Papyrus3/JpegDir/JpgLossy/JIDCTRED.C0000755000175000017500000003314607535143454014142 0ustar /* * jidctred.c * * Copyright (C) 1994-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains inverse-DCT routines that produce reduced-size output: * either 4x4, 2x2, or 1x1 pixels from an 8x8 DCT block. * * The implementation is based on the Loeffler, Ligtenberg and Moschytz (LL&M) * algorithm used in jidctint.c. We simply replace each 8-to-8 1-D IDCT step * with an 8-to-4 step that produces the four averages of two adjacent outputs * (or an 8-to-2 step producing two averages of four outputs, for 2x2 output). * These steps were derived by computing the corresponding values at the end * of the normal LL&M code, then simplifying as much as possible. * * 1x1 is trivial: just take the DC coefficient divided by 8. * * See jidctint.c for additional comments. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jdct.h" /* Private declarations for DCT subsystem */ #ifdef IDCT_SCALING_SUPPORTED /* * This module is specialized to the case DCTSIZE = 8. */ #if DCTSIZE != 8 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ #endif /* Scaling is the same as in jidctint.c. */ #if BITS_IN_JSAMPLE == 8 #define CONST_BITS 13 #define PASS1_BITS 2 #else #define CONST_BITS 13 #define PASS1_BITS 1 /* lose a little precision to avoid overflow */ #endif /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus * causing a lot of useless floating-point operations at run time. * To get around this we use the following pre-calculated constants. * If you change CONST_BITS you may want to add appropriate values. * (With a reasonable C compiler, you can just rely on the FIX() macro...) */ #if CONST_BITS == 13 #define FIX_0_211164243 ((INT32) 1730) /* FIX(0.211164243) */ #define FIX_0_509795579 ((INT32) 4176) /* FIX(0.509795579) */ #define FIX_0_601344887 ((INT32) 4926) /* FIX(0.601344887) */ #define FIX_0_720959822 ((INT32) 5906) /* FIX(0.720959822) */ #define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */ #define FIX_0_850430095 ((INT32) 6967) /* FIX(0.850430095) */ #define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */ #define FIX_1_061594337 ((INT32) 8697) /* FIX(1.061594337) */ #define FIX_1_272758580 ((INT32) 10426) /* FIX(1.272758580) */ #define FIX_1_451774981 ((INT32) 11893) /* FIX(1.451774981) */ #define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */ #define FIX_2_172734803 ((INT32) 17799) /* FIX(2.172734803) */ #define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */ #define FIX_3_624509785 ((INT32) 29692) /* FIX(3.624509785) */ #else #define FIX_0_211164243 FIX(0.211164243) #define FIX_0_509795579 FIX(0.509795579) #define FIX_0_601344887 FIX(0.601344887) #define FIX_0_720959822 FIX(0.720959822) #define FIX_0_765366865 FIX(0.765366865) #define FIX_0_850430095 FIX(0.850430095) #define FIX_0_899976223 FIX(0.899976223) #define FIX_1_061594337 FIX(1.061594337) #define FIX_1_272758580 FIX(1.272758580) #define FIX_1_451774981 FIX(1.451774981) #define FIX_1_847759065 FIX(1.847759065) #define FIX_2_172734803 FIX(2.172734803) #define FIX_2_562915447 FIX(2.562915447) #define FIX_3_624509785 FIX(3.624509785) #endif /* Multiply an INT32 variable by an INT32 constant to yield an INT32 result. * For 8-bit samples with the recommended scaling, all the variable * and constant values involved are no more than 16 bits wide, so a * 16x16->32 bit multiply can be used instead of a full 32x32 multiply. * For 12-bit samples, a full 32-bit multiplication will be needed. */ #if BITS_IN_JSAMPLE == 8 #define MULTIPLY(var,const) MULTIPLY16C16(var,const) #else #define MULTIPLY(var,const) ((var) * (const)) #endif /* Dequantize a coefficient by multiplying it by the multiplier-table * entry; produce an int result. In this module, both inputs and result * are 16 bits or less, so either int or short multiply will work. */ #define DEQUANTIZE(coef,quantval) (((ISLOW_MULT_TYPE) (coef)) * (quantval)) /* * Perform dequantization and inverse DCT on one block of coefficients, * producing a reduced-size 4x4 output block. */ GLOBAL(void) jpeg_idct_4x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col) { INT32 tmp0, tmp2, tmp10, tmp12; INT32 z1, z2, z3, z4; JCOEFPTR inptr; ISLOW_MULT_TYPE * quantptr; int * wsptr; JSAMPROW outptr; JSAMPLE *range_limit = IDCT_range_limit(cinfo); int ctr; int workspace[DCTSIZE*4]; /* buffers data between passes */ SHIFT_TEMPS /* Pass 1: process columns from input, store into work array. */ inptr = coef_block; quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table; wsptr = workspace; for (ctr = DCTSIZE; ctr > 0; inptr++, quantptr++, wsptr++, ctr--) { /* Don't bother to process column 4, because second pass won't use it */ if (ctr == DCTSIZE-4) continue; if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 && inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 && inptr[DCTSIZE*7] == 0) { /* AC terms all zero; we need not examine term 4 for 4x4 output */ int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS; wsptr[DCTSIZE*0] = dcval; wsptr[DCTSIZE*1] = dcval; wsptr[DCTSIZE*2] = dcval; wsptr[DCTSIZE*3] = dcval; continue; } /* Even part */ tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); tmp0 <<= (CONST_BITS+1); z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]); z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]); tmp2 = MULTIPLY(z2, FIX_1_847759065) + MULTIPLY(z3, - FIX_0_765366865); tmp10 = tmp0 + tmp2; tmp12 = tmp0 - tmp2; /* Odd part */ z1 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]); z2 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]); z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]); z4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]); tmp0 = MULTIPLY(z1, - FIX_0_211164243) /* sqrt(2) * (c3-c1) */ + MULTIPLY(z2, FIX_1_451774981) /* sqrt(2) * (c3+c7) */ + MULTIPLY(z3, - FIX_2_172734803) /* sqrt(2) * (-c1-c5) */ + MULTIPLY(z4, FIX_1_061594337); /* sqrt(2) * (c5+c7) */ tmp2 = MULTIPLY(z1, - FIX_0_509795579) /* sqrt(2) * (c7-c5) */ + MULTIPLY(z2, - FIX_0_601344887) /* sqrt(2) * (c5-c1) */ + MULTIPLY(z3, FIX_0_899976223) /* sqrt(2) * (c3-c7) */ + MULTIPLY(z4, FIX_2_562915447); /* sqrt(2) * (c1+c3) */ /* Final output stage */ wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp2, CONST_BITS-PASS1_BITS+1); wsptr[DCTSIZE*3] = (int) DESCALE(tmp10 - tmp2, CONST_BITS-PASS1_BITS+1); wsptr[DCTSIZE*1] = (int) DESCALE(tmp12 + tmp0, CONST_BITS-PASS1_BITS+1); wsptr[DCTSIZE*2] = (int) DESCALE(tmp12 - tmp0, CONST_BITS-PASS1_BITS+1); } /* Pass 2: process 4 rows from work array, store into output array. */ wsptr = workspace; for (ctr = 0; ctr < 4; ctr++) { outptr = output_buf[ctr] + output_col; /* It's not clear whether a zero row test is worthwhile here ... */ #ifndef NO_ZERO_ROW_TEST if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) { /* AC terms all zero */ JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3) & RANGE_MASK]; outptr[0] = dcval; outptr[1] = dcval; outptr[2] = dcval; outptr[3] = dcval; wsptr += DCTSIZE; /* advance pointer to next row */ continue; } #endif /* Even part */ tmp0 = ((INT32) wsptr[0]) << (CONST_BITS+1); tmp2 = MULTIPLY((INT32) wsptr[2], FIX_1_847759065) + MULTIPLY((INT32) wsptr[6], - FIX_0_765366865); tmp10 = tmp0 + tmp2; tmp12 = tmp0 - tmp2; /* Odd part */ z1 = (INT32) wsptr[7]; z2 = (INT32) wsptr[5]; z3 = (INT32) wsptr[3]; z4 = (INT32) wsptr[1]; tmp0 = MULTIPLY(z1, - FIX_0_211164243) /* sqrt(2) * (c3-c1) */ + MULTIPLY(z2, FIX_1_451774981) /* sqrt(2) * (c3+c7) */ + MULTIPLY(z3, - FIX_2_172734803) /* sqrt(2) * (-c1-c5) */ + MULTIPLY(z4, FIX_1_061594337); /* sqrt(2) * (c5+c7) */ tmp2 = MULTIPLY(z1, - FIX_0_509795579) /* sqrt(2) * (c7-c5) */ + MULTIPLY(z2, - FIX_0_601344887) /* sqrt(2) * (c5-c1) */ + MULTIPLY(z3, FIX_0_899976223) /* sqrt(2) * (c3-c7) */ + MULTIPLY(z4, FIX_2_562915447); /* sqrt(2) * (c1+c3) */ /* Final output stage */ outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp2, CONST_BITS+PASS1_BITS+3+1) & RANGE_MASK]; outptr[3] = range_limit[(int) DESCALE(tmp10 - tmp2, CONST_BITS+PASS1_BITS+3+1) & RANGE_MASK]; outptr[1] = range_limit[(int) DESCALE(tmp12 + tmp0, CONST_BITS+PASS1_BITS+3+1) & RANGE_MASK]; outptr[2] = range_limit[(int) DESCALE(tmp12 - tmp0, CONST_BITS+PASS1_BITS+3+1) & RANGE_MASK]; wsptr += DCTSIZE; /* advance pointer to next row */ } } /* * Perform dequantization and inverse DCT on one block of coefficients, * producing a reduced-size 2x2 output block. */ GLOBAL(void) jpeg_idct_2x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col) { INT32 tmp0, tmp10, z1; JCOEFPTR inptr; ISLOW_MULT_TYPE * quantptr; int * wsptr; JSAMPROW outptr; JSAMPLE *range_limit = IDCT_range_limit(cinfo); int ctr; int workspace[DCTSIZE*2]; /* buffers data between passes */ SHIFT_TEMPS /* Pass 1: process columns from input, store into work array. */ inptr = coef_block; quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table; wsptr = workspace; for (ctr = DCTSIZE; ctr > 0; inptr++, quantptr++, wsptr++, ctr--) { /* Don't bother to process columns 2,4,6 */ if (ctr == DCTSIZE-2 || ctr == DCTSIZE-4 || ctr == DCTSIZE-6) continue; if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*7] == 0) { /* AC terms all zero; we need not examine terms 2,4,6 for 2x2 output */ int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS; wsptr[DCTSIZE*0] = dcval; wsptr[DCTSIZE*1] = dcval; continue; } /* Even part */ z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); tmp10 = z1 << (CONST_BITS+2); /* Odd part */ z1 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]); tmp0 = MULTIPLY(z1, - FIX_0_720959822); /* sqrt(2) * (c7-c5+c3-c1) */ z1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]); tmp0 += MULTIPLY(z1, FIX_0_850430095); /* sqrt(2) * (-c1+c3+c5+c7) */ z1 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]); tmp0 += MULTIPLY(z1, - FIX_1_272758580); /* sqrt(2) * (-c1+c3-c5-c7) */ z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]); tmp0 += MULTIPLY(z1, FIX_3_624509785); /* sqrt(2) * (c1+c3+c5+c7) */ /* Final output stage */ wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp0, CONST_BITS-PASS1_BITS+2); wsptr[DCTSIZE*1] = (int) DESCALE(tmp10 - tmp0, CONST_BITS-PASS1_BITS+2); } /* Pass 2: process 2 rows from work array, store into output array. */ wsptr = workspace; for (ctr = 0; ctr < 2; ctr++) { outptr = output_buf[ctr] + output_col; /* It's not clear whether a zero row test is worthwhile here ... */ #ifndef NO_ZERO_ROW_TEST if (wsptr[1] == 0 && wsptr[3] == 0 && wsptr[5] == 0 && wsptr[7] == 0) { /* AC terms all zero */ JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3) & RANGE_MASK]; outptr[0] = dcval; outptr[1] = dcval; wsptr += DCTSIZE; /* advance pointer to next row */ continue; } #endif /* Even part */ tmp10 = ((INT32) wsptr[0]) << (CONST_BITS+2); /* Odd part */ tmp0 = MULTIPLY((INT32) wsptr[7], - FIX_0_720959822) /* sqrt(2) * (c7-c5+c3-c1) */ + MULTIPLY((INT32) wsptr[5], FIX_0_850430095) /* sqrt(2) * (-c1+c3+c5+c7) */ + MULTIPLY((INT32) wsptr[3], - FIX_1_272758580) /* sqrt(2) * (-c1+c3-c5-c7) */ + MULTIPLY((INT32) wsptr[1], FIX_3_624509785); /* sqrt(2) * (c1+c3+c5+c7) */ /* Final output stage */ outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp0, CONST_BITS+PASS1_BITS+3+2) & RANGE_MASK]; outptr[1] = range_limit[(int) DESCALE(tmp10 - tmp0, CONST_BITS+PASS1_BITS+3+2) & RANGE_MASK]; wsptr += DCTSIZE; /* advance pointer to next row */ } } /* * Perform dequantization and inverse DCT on one block of coefficients, * producing a reduced-size 1x1 output block. */ GLOBAL(void) jpeg_idct_1x1 (j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col) { int dcval; ISLOW_MULT_TYPE * quantptr; JSAMPLE *range_limit = IDCT_range_limit(cinfo); SHIFT_TEMPS /* We hardly need an inverse DCT routine for this: just take the * average pixel value, which is one-eighth of the DC coefficient. */ quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table; dcval = DEQUANTIZE(coef_block[0], quantptr[0]); dcval = (int) DESCALE((INT32) dcval, 3); output_buf[0][output_col] = range_limit[dcval & RANGE_MASK]; } #endif /* IDCT_SCALING_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/JDAPISTD.C0000755000175000017500000002262707535143454014156 0ustar /* * jdapistd.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains application interface code for the decompression half * of the JPEG library. These are the "standard" API routines that are * used in the normal full-decompression case. They are not used by a * transcoding-only application. Note that if an application links in * jpeg_start_decompress, it will end up linking in the entire decompressor. * We thus must separate this file from jdapimin.c to avoid linking the * whole decompression library into a transcoder. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* Forward declarations */ LOCAL(boolean) output_pass_setup JPP((j_decompress_ptr cinfo)); /* * Decompression initialization. * jpeg_read_header must be completed before calling this. * * If a multipass operating mode was selected, this will do all but the * last pass, and thus may take a great deal of time. * * Returns FALSE if suspended. The return value need be inspected only if * a suspending data source is used. */ GLOBAL(boolean) jpeg_start_decompress (j_decompress_ptr cinfo) { if (cinfo->global_state == DSTATE_READY) { /* First call: initialize master control, select active modules */ jinit_master_decompress(cinfo); if (cinfo->buffered_image) { /* No more work here; expecting jpeg_start_output next */ cinfo->global_state = DSTATE_BUFIMAGE; return TRUE; } cinfo->global_state = DSTATE_PRELOAD; } if (cinfo->global_state == DSTATE_PRELOAD) { /* If file has multiple scans, absorb them all into the coef buffer */ if (cinfo->inputctl->has_multiple_scans) { #ifdef D_MULTISCAN_FILES_SUPPORTED for (;;) { int retcode; /* Call progress monitor hook if present */ if (cinfo->progress != NULL) (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); /* Absorb some more input */ retcode = (*cinfo->inputctl->consume_input) (cinfo); if (retcode == JPEG_SUSPENDED) return FALSE; if (retcode == JPEG_REACHED_EOI) break; /* Advance progress counter if appropriate */ if (cinfo->progress != NULL && (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) { if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) { /* jdmaster underestimated number of scans; ratchet up one scan */ cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows; } } } #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif /* D_MULTISCAN_FILES_SUPPORTED */ } cinfo->output_scan_number = cinfo->input_scan_number; } else if (cinfo->global_state != DSTATE_PRESCAN) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); /* Perform any dummy output passes, and set up for the final pass */ return output_pass_setup(cinfo); } /* * Set up for an output pass, and perform any dummy pass(es) needed. * Common subroutine for jpeg_start_decompress and jpeg_start_output. * Entry: global_state = DSTATE_PRESCAN only if previously suspended. * Exit: If done, returns TRUE and sets global_state for proper output mode. * If suspended, returns FALSE and sets global_state = DSTATE_PRESCAN. */ LOCAL(boolean) output_pass_setup (j_decompress_ptr cinfo) { if (cinfo->global_state != DSTATE_PRESCAN) { /* First call: do pass setup */ (*cinfo->master->prepare_for_output_pass) (cinfo); cinfo->output_scanline = 0; cinfo->global_state = DSTATE_PRESCAN; } /* Loop over any required dummy passes */ while (cinfo->master->is_dummy_pass) { #ifdef QUANT_2PASS_SUPPORTED /* Crank through the dummy pass */ while (cinfo->output_scanline < cinfo->output_height) { JDIMENSION last_scanline; /* Call progress monitor hook if present */ if (cinfo->progress != NULL) { cinfo->progress->pass_counter = (long) cinfo->output_scanline; cinfo->progress->pass_limit = (long) cinfo->output_height; (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); } /* Process some data */ last_scanline = cinfo->output_scanline; (*cinfo->main->process_data) (cinfo, (JSAMPARRAY) NULL, &cinfo->output_scanline, (JDIMENSION) 0); if (cinfo->output_scanline == last_scanline) return FALSE; /* No progress made, must suspend */ } /* Finish up dummy pass, and set up for another one */ (*cinfo->master->finish_output_pass) (cinfo); (*cinfo->master->prepare_for_output_pass) (cinfo); cinfo->output_scanline = 0; #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif /* QUANT_2PASS_SUPPORTED */ } /* Ready for application to drive output pass through * jpeg_read_scanlines or jpeg_read_raw_data. */ cinfo->global_state = cinfo->raw_data_out ? DSTATE_RAW_OK : DSTATE_SCANNING; return TRUE; } /* * Read some scanlines of data from the JPEG decompressor. * * The return value will be the number of lines actually read. * This may be less than the number requested in several cases, * including bottom of image, data source suspension, and operating * modes that emit multiple scanlines at a time. * * Note: we warn about excess calls to jpeg_read_scanlines() since * this likely signals an application programmer error. However, * an oversize buffer (max_lines > scanlines remaining) is not an error. */ GLOBAL(JDIMENSION) jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION max_lines) { JDIMENSION row_ctr; if (cinfo->global_state != DSTATE_SCANNING) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); if (cinfo->output_scanline >= cinfo->output_height) { WARNMS(cinfo, JWRN_TOO_MUCH_DATA); return 0; } /* Call progress monitor hook if present */ if (cinfo->progress != NULL) { cinfo->progress->pass_counter = (long) cinfo->output_scanline; cinfo->progress->pass_limit = (long) cinfo->output_height; (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); } /* Process some data */ row_ctr = 0; (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines); cinfo->output_scanline += row_ctr; return row_ctr; } /* * Alternate entry point to read raw data. * Processes exactly one iMCU row per call, unless suspended. */ GLOBAL(JDIMENSION) jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data, JDIMENSION max_lines) { JDIMENSION lines_per_iMCU_row; if (cinfo->global_state != DSTATE_RAW_OK) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); if (cinfo->output_scanline >= cinfo->output_height) { WARNMS(cinfo, JWRN_TOO_MUCH_DATA); return 0; } /* Call progress monitor hook if present */ if (cinfo->progress != NULL) { cinfo->progress->pass_counter = (long) cinfo->output_scanline; cinfo->progress->pass_limit = (long) cinfo->output_height; (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); } /* Verify that at least one iMCU row can be returned. */ lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size; if (max_lines < lines_per_iMCU_row) ERREXIT(cinfo, JERR_BUFFER_SIZE); /* Decompress directly into user's buffer. */ if (! (*cinfo->coef->decompress_data) (cinfo, data)) return 0; /* suspension forced, can do nothing more */ /* OK, we processed one iMCU row. */ cinfo->output_scanline += lines_per_iMCU_row; return lines_per_iMCU_row; } /* Additional entry points for buffered-image mode. */ #ifdef D_MULTISCAN_FILES_SUPPORTED /* * Initialize for an output pass in buffered-image mode. */ GLOBAL(boolean) jpeg_start_output (j_decompress_ptr cinfo, int scan_number) { if (cinfo->global_state != DSTATE_BUFIMAGE && cinfo->global_state != DSTATE_PRESCAN) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); /* Limit scan number to valid range */ if (scan_number <= 0) scan_number = 1; if (cinfo->inputctl->eoi_reached && scan_number > cinfo->input_scan_number) scan_number = cinfo->input_scan_number; cinfo->output_scan_number = scan_number; /* Perform any dummy output passes, and set up for the real pass */ return output_pass_setup(cinfo); } /* * Finish up after an output pass in buffered-image mode. * * Returns FALSE if suspended. The return value need be inspected only if * a suspending data source is used. */ GLOBAL(boolean) jpeg_finish_output (j_decompress_ptr cinfo) { if ((cinfo->global_state == DSTATE_SCANNING || cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) { /* Terminate this pass. */ /* We do not require the whole pass to have been completed. */ (*cinfo->master->finish_output_pass) (cinfo); cinfo->global_state = DSTATE_BUFPOST; } else if (cinfo->global_state != DSTATE_BUFPOST) { /* BUFPOST = repeat call after a suspension, anything else is error */ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); } /* Read markers looking for SOS or EOI */ while (cinfo->input_scan_number <= cinfo->output_scan_number && ! cinfo->inputctl->eoi_reached) { if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED) return FALSE; /* Suspend, come back later */ } cinfo->global_state = DSTATE_BUFIMAGE; return TRUE; } #endif /* D_MULTISCAN_FILES_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/CJPEG0000755000175000017500000044307007535143454013422 0ustar ELF|4AØ4 (44  ÔÏ3Ï3Ï4Ï4¬,ÐÌÐ̨/usr/lib/ld.so.1—‘G€wF4(}7`L3&i%ko„ˆ+Ra]u5Wb)mO‚lQq2ŠUdv=9"JYrN<PzDtŽsn0‡-~ƒMe‹6j‰|@Œy….{ !,:;B*$IT?V[/'KfX^1>_8HEh\gS#ZAcpCx†Ôè ô8|¤H ¤d ¤x Ï4 ÏT ÐÌÑtÑ|Ñ„ÑŒÒà|t.¸à¹˜ô 2Ïð8• àPÓYÖ`^vt(koL¼v‡<‡˜À@ŸFำuL¼Õ @!Á¡°H×Ï4 í˜p$ýÓ †X€d¸2м8›l˜H]lØXÏ„_Ïdpì@rCØ@r04‘}Ì¥õ8H»Ð,ÃÙ œÛpLèÐŒïUÌ ÿÐt¤H  X !ÐD(Ïü.dD >Ð\D|\4VŒ XjÐho„„rd(ŽpÄäžÏÌ¥i0·¡øHÓÏ´ÚÏäáЀè~\0úxÈÐÌ% .·<ŒEÊ$¸YÕ @_˜ $ox¬…¢À(—r¨¤ªÏœ°q,PºÓ!Âv4¼Ñ (Àãp Lù™И ÍT$Ctd3˜”,FpTL]‚ìqH°‰¢@€¡‰ä³ФºéhÀÒ~ŒÌä—ô,óÒàúÏT ÏØÐ8!T<3ŠøKœpaÏ3 h¤x u”Ä0†xä›ÐP¢fpp±vœÅÓ !Ì/ÑÐ×T pè™öÐûϨlpTÐ vL('а.¤d 4˜D,CyødXq|´j†p˜ÏÀ‡¸T@ _startjinit_huff_encoderjpeg_std_message_tablefreadjpeg_simple_progression_environ_endwrite_stdoutjpeg_abortjpeg_set_qualityjpeg_open_backing_storejinit_phuff_encoderkeymatch_iob__register_frame_info_GLOBAL_OFFSET_TABLE_jpeg_free_large__ctypejpeg_set_linear_qualityjpeg_write_scanlinesabortjpeg_stdio_destjpeg_fdct_floatatexitexitjdiv_round_upjinit_read_gifjcopy_block_rowjpeg_write_m_headerjinit_color_convertertolowerjinit_c_prep_controllerjpeg_destroymallocjpeg_fdct_ifastsprintf_initjpeg_start_compressfwrite.umuljpeg_fdct_islow.uremjpeg_write_markerjpeg_set_colorspace.remjpeg_add_quant_tablejzero_farset_quant_slotssscanfread_quant_tables__register_frame_info_tableungetcfclosegetenvjpeg_write_m_bytejpeg_abort_compress_DYNAMICjpeg_gen_optimal_tablejinit_c_master_controljinit_marker_writer__iobjpeg_free_smalljpeg_destroy_compress__frame_state_forset_sample_factors_exitjround_upenvironjpeg_std_errorjinit_downsamplerjpeg_alloc_huff_tablejpeg_mem_initfreejinit_c_main_controllerjinit_read_ppmjpeg_mem_availablejpeg_alloc_quant_tablejpeg_write_raw_datajpeg_make_c_derived_tbl__deregister_frame_infojpeg_set_defaultsstrcmpjinit_c_coef_controllerjpeg_write_tablesjpeg_get_small_edata_PROCEDURE_LINKAGE_TABLE_fopenmemsetjinit_forward_dctjpeg_default_colorspacejinit_compress_master_etext_lib_versionjinit_memory_mgrjpeg_suppress_tablesfflushjinit_read_bmpjpeg_CreateCompress_ctypemain.udivjinit_read_targajpeg_mem_term.div__filbufread_scan_scriptmemcpyread_stdinstrlen_finijpeg_get_largejpeg_finish_compressjcopy_sample_rowsjpeg_quality_scalingfprintfjpeg_natural_orderlibc.so.1SYSVABI_1.3libc.so.1š7̳¤Ó!Õ XÓ-Ï„3Ï4Ïœ]Ϩ…Ï´OÏÀÏÌLÏØsÏäPÏðÏüCÐЄР‡Ð,:Ð8tÐDBÐP|Ð\EÐhHÐt?ЀQÐŒ=ИdФmа‰м0¼ à @¢ Dœ#  €€@¬{© d@¬w@a¦’•, ” ”@ ô–ãÔ"À@Q@¬l@¬mã¿@/¬®á@®À ÒÀÐ@Ѐ¢ €  Ð Ð$Ð?üŸÂÐЀ¢ 2¿ÿøÐ @`ùÐÀÇàèã¿Çàèã¿@/¬®ฮÀ ÐÀ’` @`ÄÒÀ Çàèã¿Çàè㿈ð' Dò' HôÒ"ø€¢`€Ð D@ P°€rÒ HРHÒ HÔ@’¿ÿ” Ô"€¢ €Ð H@¬"€ Ô H’ Ô@Ö € àÿ” Ô"@Ð'¿ì€¢?ÿ€ РDÒ *Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ H@¬ €¢?ÿ€ РDÒ$Ð"`РDÒÔ@РDŸÂ€Ð¿ì€¢ G€€¢ G€ €¢ €€¢ B€ €€¢ P€€Ð D@•°€#РD@鰀РD@Ê°€Ð D@ ﰀРDÒ$Ð"`РDÒÔ@РDŸÂ€€° €Çàèã¿ôõa@ª’âèÔ¢ü@«ºõa@ª’£@«´õa@ª’£@«®õa@ª’£8@«¨õa@ª’£€@«¢õa@ª’£°@«œõa@«’ @«–õa@«’ 0@«õa@«’ x@«Šõa@«’ ˜«”àÈ@«‚õa@«’ Ø«”á@«zõa@«’¡ «”á@«rõa@«’¡X@«lõa@«’¡ @«fõa@«’¡à@«`õa@«’¢@«Zõa@«’¢H@«Tõa@«’¢x@«Nõa@«’¢@«Hõa@«’¢È@«Bõa@«’£@«<õa@«’£8@«6õa@«’£p@«0 @«!Çàèã¿Pð' Dò' Hô' Lö' Pø' TÀ'¿ÔÀ'¿ÐÀ'¿ÌÀ'¿È KÐ'¿ä dÐ'¿àÀ'¿ÜÀ'¿ØôÀ""øôÀ"#РDÒÀ"`h Ð'¿ìпìÒ H€¢ €€–п쒑*`Ò L ÒÒ'¿èпèÒ •*`‘: €¢ -€ пìÒ P€¢ €ôÀ"#€z€}Ð¿è’ Ò'¿èп諒£°” @L€¢ €ôõa@«’ãÀÔ¢ü@ªÞ @ªÏ€_п諒£ð” @6€¢ € Ð'¿Ü€Rп謒 ” @)€¢ €HÐ¿ì’  Ð'¿ìÒ H€¢ €ÿþøп쒑*`Ô L’ Ð@¬’ ” @€¢ €Ð DÀ" Ä€*п쒑*`Ô L’ Ð@¬’ ” @ÿ€¢ €Ð D’ Ò" Āп쒑*`Ô L’ Ð@¬’ ” @쀢 €Ð D’ Ò" Ä€ÿþ¾€Ð¿è¬’  ” @Ú€¢ € п謒 (” @Ñ€¢ €€ôÒ!x€¢`€õa@¬’ 0¬”à`¬– p@ªZô’ Ò"!xÒ DÐ@Ò DÐ@Ò DÔ@Ò h”`Ô" h€Òп謒 ˜” @©€¢ € п謒 ¨” @ €¢ €€Ð D’ @G€¸Ð¿è¬’ ¸” @€¢ €A xÐ/¿ÃÐ¿ì’  Ð'¿ìÒ H€¢ €ÿþ\п쒑*`Ò L ”¿Ä–¿ÃЬ’ È@ª€¢ €ÿþKпÓ* ‘:`€¢ m€ пÓ* ‘:`€¢ M€€ пĔ“* ’"@•*`”€‘* Ð'¿ÄÒ DÐ`Ò¿Ä– •*à”"€ —* –À “*àÒ" ,€pп謒 Ð” @G€¢ € п謒 à” @>€¢ €€Ð D’ Ò" ¸€Wп謒 ð” @.€¢ €Ð¿ì’  Ð'¿ìÒ H€¢ €ÿýýôÒ¿ì” “* Ô L’@ Ô@Ô"#€:п謒 ø” @€¢ € Ð'¿Ø€-п謒¡” @€¢ €"Ð¿ì’  Ð'¿ìÒ H€¢ €ÿýÓп쒑*`Ò L ”¿äЬ’á@©Œ€¢ €ÿýÃпä@-Ð'¿à€Ð¿è¬’¡” @Û€¢ €Ð¿ì’  Ð'¿ìÒ H€¢ €ÿýªÐ¿ì’‘*`Ò L ÒÒ'¿Ð€èп謒¡ ” @¿€¢ €Ð¿ì’  Ð'¿ìÒ H€¢ €ÿýŽÐ¿ì’‘*`Ò L ÒÒ'¿Ô€Ìп謒¡(” @£€¢ €G xÐ/¿»Ð¿ì’  Ð'¿ìÒ H€¢ €ÿýpп쒑*`Ò L ”¿¼–¿»Ð¬’ È@©(€¢ €ÿý_п¼€¢ € п¼?’£ÿ€¢ €€ÿýQп»“* ‘:`€¢ b€ п»“* ‘:`€¢ B€€ РDÒ¿¼Ò" ÈРDÀ" ̀РDÒ¿¼Ò" Ì€~п謒¡0” @U€¢ €Ð¿ì’  Ð'¿ìÒ H€¢ €ÿý$п쒑*`Ò L ÒÒ'¿Ì€bп謒¡8” @9€¢ €Ð¿ì’  Ð'¿ìÒ H€¢ €ÿýп쒑*`Ò L ÒÒ'¿È€Fп謒¡@” @€¢ €-Ð¿ì’  Ð'¿ìÒ H€¢ €ÿüìп쒑*`Ò L ”¿´Ð¬’á@¨¥€¢ €ÿüÜп´€¢ €Ð¿´€¢ d€€ÿüÐРDÒ¿´Ò" À€Ð¿è¬’¡H” @逢 €ô’ Ò""ø€ÿü»Ð¿ì’ Ò'¿ì¿ýgРT€¢ €DРDÒ¿äÔ¿Ü@@пԀ¢ € РDÒ¿ÔÔ¿àÖ¿Ü@À€¢ €ÿüžÐ¿Ð€¢ € РDÒ¿Ð@˜€¢ €ÿü‘п̀¢ € РDÒ¿Ì@€¢ €ÿü„п؀¢ €Ð D@¶Ð¿È€¢ € РDÒ¿È@b€¢ €ÿüpп찀Çàèã½xð' Dò' HôÒ HÔ@Ô""üôÒ"ü€¢`€ ôÐbüÒ •*`‘: €¢ €€ô¬’¡PÒ""ü’½ð @QªÐ'¾x’¾x ’ >”!x@½©`€Ð'¾h#èÐ'¾l$Ð'¾p Ð'¾ ’¾x @N’¾x Ò DÔ H– ˜ ÿüÈÐ'½ìÒ Dÿҽ쀢@€ ôõa@¬’áXÔ¢ü@§âÿüнìÒ D€¢ €$н쒑*`Ô H’ Ð@¬’¡x@§×Ð'½äн䀢 €ôн쒑*`Ò H– õa@¬’!€Ô¢üÖÀ@§¾ @§¯€@ZÐ'½äôÒ#€¢`€ôÐc¬’¡˜@§±Ð'½àÐ½à€¢ €ôôõa@¬’!€Ô¢üÖã@§œ @§€@BÐ'½à’¾x Ò½äÿûNÐ'½èнèÒ½äÒ" н蒾xÔ Ò½èŸÂ€’¾x @N’¾x Ò DÔ H– ˜ ÿüOÐ'½ì’¾x Ò½à@]’¾x ’ @SпXÒ¾˜€¢ €€Ð½è’¾xÔ  Ò½èŸÂ€Ð'½Ü¾xÒ½èÒ`Ô½Ü@¿ÿëн蒾xÔ  Ò½èŸÂ€’¾x @Ù’¾x @‚нäõ’¡ €¢ €Ð½ä@§Gнàõ’¡0€¢ €Ð½à@§>о\€¢ € € @§° €Çàèã¿ð' DÒ DРDÒ DÔ@’¿ÿ” Ô"€¢ €Ð D@§ € Ò D`ÒÔ @   ÿ’`Ò"€¤ #€%Ò DРDÒ DÔ@’¿ÿ” Ô"€¢ €Ð D@¦÷ € Ò D`ÒÔ @   ÿ’`Ò"€¤ €€¤?ÿ€€€¿ÿß°€Çàèã¿ð' Dò' HРHÿÿ¸ €¤?ÿ€ РDÒ +Ð"`РDÒÔ@РDŸÂ€€¤ € €¤ € €¤ €€¤ €€¿ÿဤ /€€¤ 9€€ РDÒ$Ð"`РDÒÔ@РDŸÂ€¢?ÐРHÿÿ„ €¢ /€€¤ 9€€€ ’‘*`“* ¢ ¢Т@¿ÿê°€Çàèã¿€ð' Dò' HРHÐ'¿ìпìÒ Ò'¿èпìâ $пìÒ à@РDÒ Ò'¿äп䀢 €€Ð DÒ¿èÿÿ”Ò @Ò,  пä’?ÿÒ'¿ä¿ÿð° €Çàèã¿€ð' Dò' HРHÐ'¿ìпìÒ Ò'¿èпìâ $пìÒ à@РDÒ Ò'¿äп䀢 €€Ð DÒ¿èÿÿmÒ @Ò,  РDÒ¿èÿÿfÒ @Ò,  РDÒ¿èÿÿ_Ò @Ò,  пä’?ÿÒ'¿ä¿ÿâ° €Çàè㿈ð' Dò' HРHÐ'¿ìпìä $пìÔ¿ìÖ¿ìÐ ’ Ô  Öà @¦.Ò¿ìÔ` €¢ € РDÒ +Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ à@пìâ РDÒ Ò'¿èп耢 €€ Ò @ `ÿÒ €Ò,¢`  пè’?ÿÒ'¿è¿ÿñ° €Çàè㿈ð' Dò' HРHÐ'¿ìпìä $пìÔ¿ìÖ¿ìÐ ’ Ô  Öà @¥ñÒ¿ìÔ` €¢ € РDÒ +Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ à@пìâ РDÒ Ò'¿èп耢 €€Ò @ `ÿÒ €Ò,¢`  Ò @ `ÿÒ €Ò,¢`  Ò @ `ÿÒ €Ò,¢`  пè’?ÿÒ'¿è¿ÿå° €Çàè㿈ð' Dò' HРHÐ'¿ìпìÔ¿ìÖ¿ìÐ ’ Ô  Öà @¥ªÒ¿ìÔ` €¢ € РDÒ +Ð"`РDÒÔ@РDŸÂ€° €Çàè㿈ð' Dò' HРHÐ'¿ìпìä $пìÔ¿ìÖ¿ìÐ ’ Ô  Öà @¥†Ò¿ìÔ` €¢ € РDÒ +Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ à@пìâ РDÒ Ò'¿èп耢 €€Ò @ `ÿ¢`Ô @’  ÿ•*` ¢`Ò €Ò,  пè’?ÿÒ'¿è¿ÿì° €Çàè㿈ð' Dò' HРHÐ'¿ìпìä $пìÔ¿ìÖ¿ìÐ ’ Ô  Öà @¥DÒ¿ìÔ` €¢ € РDÒ +Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ à@пìâ РDÒ Ò'¿èп耢 €€(Ò @ `ÿ¢`Ô @’  ÿ•*` ¢`Ò €Ò,  Ò @ `ÿ¢`Ô @’  ÿ•*` ¢`Ò €Ò,  Ò @ `ÿ¢`Ô @’  ÿ•*` ¢`Ò €Ò,  пè’?ÿÒ'¿è¿ÿÖ° €Çàèã¿hð' Dò' HРHÐ'¿ìÒ¿ìÐ` Ò¿ìÐ` Ò¿ìÔ` Ö€’ÿÿ” Ô"€¢ € Ò¿ìÐ` @¤Ô€¢ P€€Ð¿ìÒ `ÒÖ @” àÿ’`Ò"€¢ P€€ РDÒ$Ð"`РDÒÔ@РDŸÂ€Ò¿ìÐ` Ò¿ìÐ` Ò¿ìÔ` Ö€’ÿÿ” Ô"€¢ €Ò¿ìÐ` @¤§€ Ò¿ìÔ` ’ Ô@Ö € àÿ” Ô"@Ð'¿èп耢 2€€¢ 3€ €¢ 6€ €¢ 5€€€Ð DÒ$Ð"`РDÒÔ@РDŸÂ€€Ò¿ìРDÒ` ÿý Ð'¿äÒ¿ìРDÒ` ÿýšÐ'¿àÒ¿ìРDÒ` ÿý”Ð'¿Üп䀢 € Ð¿à€¢ €Ð¿Ü€¢ €€Ð DÒ$Ð"`РDÒÔ@РDŸÂ€Ð D’ Ò" 8РDÒ¿äÒ" РDÒ¿àÒ"  Ð'¿ØÀ'¿Ô Ð'¿Ðп耢 3€2€¢ 3€€¢ 2€ €¶€¢ 5€G€¢ 6€z€®Ð D’ Ò" $РD’ Ò" (РDÒ$Ð"`РDÒпäÐ"`РDÒпàÐ"`РDÒÔ`РD’ ŸÂ€Ð¿ìM’¡Ò" À'¿Ø€ŽÐ D’ Ò" $РD’ Ò" (РDÒ$Ð"`РDÒпäÐ"`РDÒпàÐ"`РDÒÔ`РD’ ŸÂ€Ð¿ìM’¢,Ò" À'¿Ø€nРD’ Ò" $РD’ Ò" (РDÒ$Ð"`РDÒпäÐ"`РDÒпàÐ"`РDÒÔ`РD’ ŸÂ€Ð¿Ü€¢ ÿ€Ð¿ìN’¡ Ò" €Ð¿Ü€¢ ÿ€ пìN’¡Ò"  Ð'¿ÔÀ'¿Ð€Ð¿ìM’£Ò" €8РD’ Ò" $РD’ Ò" (РDÒ$Ð"`РDÒпäÐ"`РDÒпàÐ"`РDÒÔ`РD’ ŸÂ€Ð¿Ü€¢ ÿ€Ð¿ìN’¢¨Ò" €Ð¿Ü€¢ ÿ€ пìN’¡Ò"  Ð'¿ÔÀ'¿Ð€Ð¿ìM’£ôÒ" €Ð¿Ø€¢ €â¿ìÒ DпäÒ`$@£’ Ò¿Ü€¢`ÿ€’•*` Ð$` РDÒ Ô¿ìÖ@РD’ Ô  ŸÂÀÒ¿ìÐ"`пԀ¢ €Ð¿ìÒ¿ìÔ`Ô" пìÒ¿ì”`Ô" Ð¿ì’ Ò" €Ð Dâ Ò DпäÒ`$@£e”Ø`РD’ – ŸÃÒ¿ìÐ"`Ð¿ì’ Ò" пЀ¢ €,Ò DÐ`Ò¿Ü”`ÖРD’ ŸÂÀÒ¿ìÐ"`$Ò¿Ü‘2`Ð'¿ÈÀ'¿ÌпÌÒ¿Ü€¢ €€Ð¿ìÒ $п̢@п̔“* ’"@пȒ@ Ò¿Ü@£4Ð,@п̒ Ò'¿Ì¿ÿçÇàèã¿ð' Dò' HÇàè㿈ð' DРDÒ Ö@РD’ ” (ŸÂÀÐ'¿ìпìO’ Ò"пìP’£`Ò" п찀Çàèã¿ð' Dõa@¬’¡ @¢ô @¢å° €Çàèã¿ð' DРDà Òÿ’Ò$€¢`€@¢Ø¢€ ÒÔ @¢  ÿ’`Ò"€¢?ÿ€Ð DÒ Ð@’ +Ò" РDÒ Ð@Ò DÔÐ`ŸÂ€°€Çàè㿈ð' Dò' Hô' LРL€¢ €Ð DÒ Ð@’$Ò" РDÒ Ð@Ò DÔÐ`ŸÂ€À'¿ìпìÒ H€¢ €€&РDÿÿ´Ò D” Ö`’€ Ô@Ö¿ì’€ Ð*@РDÿÿ©Ò D” Ö`’€ Ô@Ö¿ì’€ Ð*@РDÿÿžÒ DÔ`Ò€Ô¿ì’@ Ð*@Ð¿ì’ Ò'¿ì¿ÿ×Çàèã¿ð' DРDà ¢ РDÒ 0€¤@ €€Ð D¤Òÿ’Ò$€¢`€ @¢]’ €’ Ô@Ð €” Ô"@Ð, ,¢`¿ÿâÇàèã¿ð' DРDà РDÒ 8€¢`€ Ò DРDÒ DÔ`8’¿ÿÒ" 8€@Ò DРDÒ DÔ`4’¿ÿ” Ô" 4€¢ €Ð DÿÿL¢ `€€¢ € РD’ `Ò" 8РDÀ" 4€Ð D’ `Ò" 4¢ РDÒ 0€¤@ €€Ð D¤Òÿ’Ò$€¢`€ @¢ ’ €’ Ô@Ð €” Ô"@Ð, ,¢`¿ÿâÇàè㿈ð' Dò' HРHÐ'¿ìпìÒ à@РDâ €¤`€€Ð¿ìÒ (пìŸÂ@пìÒ ,Ò,  ¢ÿ¿ÿñ° €Çàè㿈ð' Dò' HРHÐ'¿ìпìæ пìÒ â@РDä €¤ €€Ð¿ìÒ (пìŸÂ@пìÒ ,  `ÿÒÀ Ò Ò,@¢`Òà Ò Ò,@¢`Òà Ò Ò,@¢`¤¿ÿ¿ÿã° €Çàè㿈ð' Dò' HРHÐ'¿ìпìÒ â@РDä €¤ €€'пìÒ (пìŸÂ@пìÒ ,  `ÿпìÒ - `ÿ“*   ¬’ ”!Ø@ Ò Ò,`¡< ¬’ ”!Ø@ Ò Ò,`¡< ¬’ ”!Ø@ Ò Ò,@¢`¤¿ÿ¿ÿØ° €Çàè㿈ð' Dò' HРHÐ'¿ìпìÒ à@РDâ €¤`€€Ð¿ìÒ (пìŸÂ@пìÒ .Ò,  пìÒ -Ò,  пìÒ ,Ò,  ¢ÿ¿ÿé° €Çàè㿈ð' Dò' HРHÐ'¿ìРDÒ¿ìÐ Ò`$" ’?ÿÒ'¿èРDÔ Ò¿ìڠРDÒ` Ô¿è– ˜ ŸÃ@Ò¿ìÐ"`Ò¿ìпìÒ¿ìÔ`$’ Ò" $° €Çàèã¿€ð' Dò' HРHÐ'¿ìРDÒ Ò'¿äÀ'¿èРDÒ¿èÐ €¢@ €€*п䀢 €Ð¿äÒ¿èÒ" пäÒ DÔ` Ô" пäÒРDŸÂ@РDÔ Ò¿ìڠРDÒ` Ô¿è– ˜ ŸÃ@Ò¿ìÐ"`пìÔ <РDÒ HŸÂ€Ð¿è’ Ò'¿è¿ÿÒп䀢 €Ò¿äпäÒ¿äÔ`’ Ò" пìR’¢€Ò" пìÀ" $РDÒ Hÿÿ‘°€Çàèã¿@ð' Dò' HРHÐ'¿ì¿ÐÖ¿ì’ ” Öà @ Ü€¢ € РDÒ +Ð"`РDÒÔ@РDŸÂ€Ò¿à `ÿ€¢ € Ð/¿àпВ ÿÒ'¿Ìпђ ÿÒ'¿ÈпҒ ÿÒ'¿ÄÒ¿Õ `ÿÔ¿Ö’  ÿ•*` Ð'¿¬Ò¿Ü `ÿÔ¿Ý’  ÿ•*` Ð'¿´Ò¿Þ `ÿÔ¿ß’  ÿ•*` Ð'¿°Ð¿ìÔ¿à’  ÿ•2`’  ÿÒ" 0пᒠÿÒ'¿ÀÒ¿À‘2`’  `Ð'¿¨Ð¿À“: Ò'¿¼Ð¿È€¢ €Ð¿ìÒ 0€¢`€Ð¿ìÒ 0€¢`€Ð¿à’  `ÿ€¢ €Ð¿¼€¢ €€ РDÒ$ Ð"`РDÒÔ@РDŸÂ€Ð¿Ä€¢ €Ð¿ìQ’¢xÒ" (пìÒ¿ìÀ"`8À" 4пĒ?øÒ'¿Ä€Ð¿ìQ’¡ÜÒ" ( Ð'¿¸Ð D’ Ò" (пĀ¢ €=€¢ €€¢ € €©€¢ €w€¤Ð¿ìÒ 0€¢`€ пȀ¢ €Ð¿ìR’ <Ò" <€ РDÒ$ Ð"`РDÒÔ@РDŸÂ€Ð DÒ$ Ð"`РDÒп´Ð"`РDÒп°Ð"`РDÒÔ`РD’ ŸÂ€€‚Ò¿ìÐ`0€¢ €€¢ €€¢ € €€¢ €€Ð¿ìR’ üÒ" <€Ð¿ìR’¡àÒ" <€Ð¿ìR’¡àÒ" <€Ð DÒ$ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ$ Ð"`РDÒп´Ð"`РDÒп°Ð"`РDÒÔ`РD’ ŸÂ€€= Ð'¿¸Ð D’ Ò" (пìÒ 0€¢`€Ð¿ìQ’£¼Ò" <€ РDÒ$ Ð"`РDÒÔ@РDŸÂ€Ð DÒ$ Ð"`РDÒп´Ð"`РDÒп°Ð"`РDÒÔ`РD’ ŸÂ€€Ð DÒ$ Ð"`РDÒÔ@РDŸÂ€€Ð¿¨€¢ €*РDà п´Ò¿¸@Ÿ•–Ä Ð D’ ” Ø¿°š ŸÀ€Ò¿ìÐ"` РDÒ €¢`€ РDÒ Ò'¿¤Ò¿¤Ð¿¤Ò¿¤Ô`’ Ò" Ð¿ì’ Ò" пìR’£Ò" €Ð¿ìÀ" РDà п´Ò¿¸@Ÿk”Ø Ð D’ – ŸÃÒ¿ìÐ"`Ð¿ì’ Ò" пìÒ¿ìÔ`<Ô" Ò¿Ìÿ’Ò'¿Ì€¢ÿ€€Ð¿ìÿüU¿ÿô﬈¢ €.﬈¢!€ Ò¿Ó `ÿÔ¿Ô’  ÿ•*` €¢ €€ РDÒ$Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ø`РD’ Ô¿¬– ŸÃÒ¿ìÐ"`пה ÿпìÒ¿¬ÿüR€Ð¿È€¢ € РDÒ$ Ð"`РDÒÔ@РDŸÂ€Ð¿ìÀ" РDÒ¿¸Ò" $РD’ Ò" 8РDÒ¿´Ò" РDÒ¿°Ò" Çàèã¿ð' Dò' HÇàè㿈ð' DРDÒ Ö@РD’ ” @ŸÂÀÐ'¿ìпìÒ DÒ" пìS’ XÒ"пìU’  Ò" п찀Çàèã¿ð' DРDà Òÿ’Ò$€¢`€@žº¢€ ÒÔ @¢  ÿ’`Ò"€¢?ÿ€Ð DÒ Ð@’ +Ò" РDÒ Ð@Ò DÔÐ`ŸÂ€°€Çàè㿈ð' Dò' Hô' LРL€¢ €€¢ €3€cÀ'¿ìпìÒ H€¢ €€&РDÿÿ¼Ò D” Ö`’€ Ô@Ö¿ì’€ Ð*@РDÿÿ±Ò D” Ö`’€ Ô@Ö¿ì’€ Ð*@РDÿÿ¦Ò DÔ`Ò€Ô¿ì’@ Ð*@Ð¿ì’ Ò'¿ì¿ÿ×€CÀ'¿ìпìÒ H€¢ €€)РDÿÿÒ D” Ö`’€ Ô@Ö¿ì’€ Ð*@РDÿÿ‚Ò D” Ö`’€ Ô@Ö¿ì’€ Ð*@РDÿÿwÒ DÔ`Ò€Ô¿ì’@ Ð*@РDÿÿnÐ¿ì’ Ò'¿ì¿ÿԀРDÒ Ð@’#éÒ" РDÒ Ð@Ò DÔÐ`ŸÂ€€Çàè㿈ð' Dò' HРHÐ'¿ìпìà Ò¿ìпìÒ¿ìÔ`$’¿ÿÒ" $Ò DÐ`Ò¿ìÔ¿ìÚ Ð DÒ` Ô $– ˜ ŸÃ@Ð'¿èпèäпìÒ æ@РDè €¥ €€Ð €¢ ÿ¤ Ò@ Ò Ò,À¦àÒ @ Ò Ò,À¦àÒ @ Ò Ò,À¦à¨?ÿ¿ÿè° €Çàè㿈ð' Dò' HРHÐ'¿ìÒ¿ìпìÒ¿ìÔ`$’¿ÿÒ" $Ò DÐ`Ò¿ìÔ¿ìÚ Ð DÒ` Ô $– ˜ ŸÃ@Ð'¿èпèàпìÒ â@РDä €¤ €€Ð Ð,`  Ð Ð,`  Ð Ð,@  ¢`¤¿ÿ¿ÿð° €Çàèã¿xð' Dò' HРHÐ'¿ìпìà РDÒ Ò'¿ÜÀ'¿äРDÒ¿äÐ €¢@ €€Wп܀¢ €Ð¿ÜÒ¿äÒ" пÜÒ DÔ` Ô" пÜÒРDŸÂ@РDÔ Ò¿ìڠРDÒ` Ô¿ä– ˜ ŸÃ@Ð'¿èпèäпìÒ (Ò'¿àÐ¿à€¢ €€+Òÿ’Ò$€¢`€@b¢€ ÒÔ @¢  ÿ’`Ò"€¢?ÿ€ РDÒ +Ð"`РDÒÔ@РDŸÂ€Ð,€¤ Ð¿à’?ÿÒ'¿à¿ÿÓÐ¿ä’ Ò'¿ä¿ÿ¥Ð¿Ü€¢ €Ò¿ÜпÜÒ¿ÜÔ`’ Ò" Ò¿ìÐ`,€¢ €€¢ € €Ð¿ìU’£@Ò" €Ð¿ìV’ @Ò" € РDÒ#êÐ"`РDÒÔ@РDŸÂ€Ð¿ìÒ DÔ` Ô" $пìÔ Ð DÒ HŸÂ€°€Çàèã¿ð' Dò' HРHÐ'¿ìÀ'¿ŒÀ'¿ˆÀ'¿tÀ'¿p¿ØÖ¿ì’ ” Öà @€¢ € РDÒ +Ð"`РDÒÔ@РDŸÂ€Ò¿Ø `ÿÔ¿Ù’  ÿ•*` ’¡B€¢ € РDÒ#ïÐ"`РDÒÔ@РDŸÂ€Ò¿â `ÿÔ¿ã’  ÿ•*` Ô¿ä’  ÿ•*` Ô¿å’  ÿ•*` Ð'¿”¿˜Ö¿ì’ ” Öà @œÏ€¢ € РDÒ +Ð"`РDÒÔ@РDŸÂ€Ò¿˜ `ÿÔ¿™’  ÿ•*` Ô¿š’  ÿ•*` Ô¿›’  ÿ•*` Ð'¿Ð¿€¢ €Ð¿€¢ @€€ РDÒ#ëÐ"`РDÒÔ@РDŸÂ€’¿˜`Ò¿”üÖ¿ì’ Öà @œ–Ô¿’¿ü€¢ € РDÒ +Ð"`РDÒÔ@РDŸÂ€Ð¿€¢ (€~€¢ (€€¢ € €X€¢ @€s€SÒ¿œ `ÿÔ¿’  ÿ•*` Ð'¿ŒÒ¿ž `ÿÔ¿Ÿ’  ÿ•*` Ð'¿ˆÒ¿  `ÿÔ¿¡’  ÿ•*` Ð'¿„пìÔ¿¢’  ÿÖ¿£” àÿ—* ’@ Ò" ,Ò¿ìÐ`,€¢ €€¢ €€. Ð'¿pРDÒ#óÐ"`РDÒпŒÐ"`РDÒпˆÐ"`РDÒÔ`РD’ ŸÂ€€#РDÒ#òÐ"`РDÒпŒÐ"`РDÒпˆÐ"`РDÒÔ`РD’ ŸÂ€€Ð DÒ#êÐ"`РDÒÔ@РDŸÂ€€Ð¿„€¢ € РDÒ#ìÐ"`РDÒÔ@РDŸÂ€€ðÒ¿œ `ÿÔ¿’  ÿ•*` Ô¿ž’  ÿ•*` Ô¿Ÿ’  ÿ•*` Ð'¿ŒÒ¿  `ÿÔ¿¡’  ÿ•*` Ô¿¢’  ÿ•*` Ô¿£’  ÿ•*` Ð'¿ˆÒ¿¤ `ÿÔ¿¥’  ÿ•*` Ð'¿„пìÔ¿¦’  ÿÖ¿§” àÿ—* ’@ Ò" ,Ò¿¨ `ÿÔ¿©’  ÿ•*` Ô¿ª’  ÿ•*` Ô¿«’  ÿ•*` Ð'¿€Ò¿° `ÿÔ¿±’  ÿ•*` Ô¿²’  ÿ•*` Ô¿³’  ÿ•*` Ð'¿|Ò¿´ `ÿÔ¿µ’  ÿ•*` Ô¿¶’  ÿ•*` Ô¿·’  ÿ•*` Ð'¿xÒ¿¸ `ÿÔ¿¹’  ÿ•*` Ô¿º’  ÿ•*` Ô¿»’  ÿ•*` Ð'¿tÒ¿ìÐ`,€¢ €€¢ €€. Ð'¿pРDÒ#ñÐ"`РDÒпŒÐ"`РDÒпˆÐ"`РDÒÔ`РD’ ŸÂ€€#РDÒ#ðÐ"`РDÒпŒÐ"`РDÒпˆÐ"`РDÒÔ`РD’ ŸÂ€€Ð DÒ#êÐ"`РDÒÔ@РDŸÂ€€Ð¿„€¢ € РDÒ#ìÐ"`РDÒÔ@РDŸÂ€Ð¿€€¢ € РDÒ#îÐ"`РDÒÔ@РDŸÂ€Ð¿|€¢ €Ð¿x€¢ €à DÒ¿| ’ d@›;Ð4 Øà DÒ¿x ’ d@›4Ð4 ÚРD’ Ò* րРDÒ#ëÐ"`РDÒÔ@РDŸÂ€€Ò¿”òÒ¿" Ð'¿lпp€¢ €/пt€¢ €!Ð'¿t€Ð¿t€¢!€ РDÒ#éÐ"`РDÒÔ@РDŸÂ€Ð DÒ Ø`РD’ Ô¿t– ŸÃÒ¿ìÐ"`пìÒ¿tÔ¿pÿü?пtÒ¿p@šéÒ¿l"@Ð'¿lпl€¢ € РDÒ#ëÐ"`РDÒÔ@РDŸÂ€Ò¿lÿ’Ò'¿l€¢`€€Ð¿ìÿûð¿ÿôпìÒ ,€¢`€ пŒ’•*`€Ð'¿h€Ð¿ŒÐ'¿hÒ¿h `€¢ €€Ð¿h’ Ò'¿h¿ÿöпìÒ¿hÒ" (РDÒ Ä`РD’ ” Ö¿hØ¿ˆš ŸÀ€Ò¿ìÐ"` пìV’¡Ò" РDÒ €¢`€ РDÒ Ò'¿dÒ¿dпdÒ¿dÔ`’ Ò" Ò DÐ`Ò¿Œ– •*à”€ Ø Ð D’ – ŸÃÒ¿ìÐ"`Ð¿ì’ Ò" РD’ Ò" (РD’ Ò" $РD’ Ò" 8РDÒ¿ŒÒ" РDÒ¿ˆÒ" Çàèã¿ð' Dò' HÇàè㿈ð' DРDÒ Ö@РD’ ” 0ŸÂÀÐ'¿ìпìÒ DÒ" пìV’£œÒ"пìY’¢\Ò" п찀Çàèã¿ð' DÒ DРDÒ DÔ@’¿ÿ” Ô"€¢ €Ð D@š% € Ò D`ÒÔ @   ÿ’`Ò"€¤ #€%Ò DРDÒ DÔ@’¿ÿ” Ô"€¢ €Ð D@š  € Ò D`ÒÔ @   ÿ’`Ò"€¤ €€¤?ÿ€€€¿ÿß°€Çàèã¿ð' Dò' Hô' LРDÿÿ· €¤?ÿ€Ð Là"° €@ôcÒ  `’ ÿ€¢`€€¿ÿêôcÒ  `’ ÿ€¢`€Ð Là"° €'¢?ÐРDÿÿ‘ €¢?ÿ€€ôcÒ  `’ ÿ€¢`€€ ’‘*`“* ¢ ¢Т@¿ÿåРHâ"РLà"° €Çàèã¾xð' Dò' Hô' Lö' PРH¬’¡ø@™¢Ð'¿ìп쀢 € õa@¬’¢Ô H@™° €kÀ'¿è’¿Ü”¿àпìÿÿ“€¢ €€Iп耢 €õa@¬’¢ Ô H@™wпì@™}° €OпÜÐ'¾Ø Ð'¿äп䀢 ?€€"’¿Ü”¿àпìÿÿn€¢ €õa@¬’¢@Ô H@™Xпì@™^° €0п䒑*`’¾ØÔ¿ÜÔ"@Ð¿ä’ Ò'¿ä¿ÿÜ”¾ØРDÒ¿èÖ LØ P@RÐ¿è’ Ò'¿è¿ÿ±Ð¿à€¢?ÿ€õa@¬’¢`Ô H@™0пì@™6° €Ð¿ì@™0° €Çàèã¿ð' Dò' Hô' LРDÒ HÔ Lÿÿ%€¢ €° €=РLà€¤?ÿ€ ôcÒ  `’ ÿ€¢`€€€Ð DÿþÇ ¿ÿíôcÒ  `’ ÿ€¢`€Ò D@˜í€¢?ÿ€° €  € €¤?ÿ€ €¤ ;€€¤ :€  РLà"° €Çàèã±hð' Dò' HРH¬’¡ø@˜ÔÐ'¿ìп쀢 € õa@¬’¢€Ô H@˜Â° €þ±ÈÐ'¿ØÀ'¿è’¿Ü”¿àпìÿÿ—€¢ €€ºÐ¿è€¢ c€õa@¬’¢¨Ô H@˜§Ð¿ì@˜­° €àпØÒ¿ÜÒ"  Ð'¿äÐ¿à€¢ €€)п䀢 €õa@¬’¢ÐÔ H@˜‹Ð¿ì@˜‘° €Ä’¿Ü”¿àпìÿÿ`€¢ €€nпØÒ¿ä” “*  Ò¿ÜÒ" Ð¿ä’ Ò'¿ä¿ÿÕпØÒ¿äÒ"Ð¿à€¢ :€J’¿Ü”¿àпìÿÿC€¢ €Ð¿à€¢ €€€KпØÒ¿ÜÒ" ’¿Ü”¿àпìÿÿ0€¢ €Ð¿à€¢ €€€8пØÒ¿ÜÒ" ’¿Ü”¿àпìÿÿ€¢ €Ð¿à€¢ €€€%пØÒ¿ÜÒ" ’¿Ü”¿àпìÿÿ €¢ €€Ð¿ØÒ¿ÜÒ" € пØÀ" пؒ ?Ò" пØÀ" пØÀ" Ð¿à€¢ ;€Ð¿à€¢?ÿ€õa@¬’£Ô H@˜Ð¿ì@˜° €Aпؒ $Ò'¿ØÐ¿è’ Ò'¿è¿ÿ@Ð¿à€¢?ÿ€õa@¬’¢`Ô H@—ïпì@—õ° €(п耢 €Ò DÐ`Ò¿è” —* –À •*àÖРD’ ŸÂÀÐ'¿Ø’±Èп蔗* –À•*àпØ@—çРDÒ¿ØÒ" ¬Ð DÒ¿èÒ" ¨Ð¿ì@—Ï° €Çàèã¿€ð' Dò' HÀ'¿ìÀ'¿èп耢 €€kРHÒ •*`‘: €¢ €S ,Ð/¿ç”¿ì–¿çРH¬’#(@—©€¢ €° €Xпç“* ‘:`€¢ ,€° €Oп쀢 €Ð¿ì€¢ €€ õa@¬’£0” @—†° €;РDÒ¿è– •*à”€ —* –À “*àÔ D@ Ò¿ìÒ" РHÒ •*`‘: €¢ € HÒÔ @—* •:à’`Ò"€¢ ,€€€¿ÿë€Ð DÒ¿è– •*à”€ —* –À “*àÔ D@ Ò¿ìÒ" Ð¿è’ Ò'¿è¿ÿ“° €Çàèã¿€ð' Dò' HÀ'¿ìп쀢 €€œÐ HÒ •*`‘: €¢ €x ,Ð/¿â”¿è–¿ã˜¿äš¿âРH¬’£`@—/€¢ €° €‡Ð¿ã“* ‘:`€¢ x€ пã“* ‘:`€¢ X€ €Ð¿â“* ‘:`€¢ ,€€° €nп耢 €Ð¿è€¢ € п䀢 €Ð¿ä€¢ €€ õa@¬’£p@–õ° €SРDÒ¿ì– •*à”€ —* –À “*àÔ D@ Ò¿èÒ" РDÒ¿ì– •*à”€ —* –À “*àÔ D@ Ò¿äÒ" РHÒ •*`‘: €¢ € HÒÔ @—* •:à’`Ò"€¢ ,€€€¿ÿë€Ð DÒ¿ì– •*à”€ —* –À “*àÔ D@ ’ Ò" РDÒ¿ì– •*à”€ —* –À “*àÔ D@ ’ Ò" Ð¿ì’ Ò'¿ì¿ÿb° €Çàèã¿ð' Dò' Hô' L¤ РDÒ •*`¡: ’ Ð' D€¢`€€% HÒÔ @—* £:à”’`Ò"€¢ €° €!ôcÒ  `’ ÿ€¢`€@– €¤€° €¤ ¿ÿÓРL€¤€€° €° €Çàè㿈õa Ð'¿ìп찀Çàè㿈õa0Ð'¿ìп찀Çàèã¿€ð' Dò' Hô' LРDÀ" РH€¢ >€Ð DÒ Ð"`РDÒ >Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð L€¢!x€Ð DÒ Ð"`РDÒ!xÐ"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð DÒÒ'¿èРDÒ Ò'¿äРD’ ”!x@–,РDÒ¿èÒ"РDÒ¿äÒ" РDÀ" РD@GDРDÀ" РDÀ" РDÀ" DÀ'¿ìп쀢 €€ РDÒ¿ì” “*  À" HÐ¿ì’ Ò'¿ì¿ÿñÀ'¿ìп쀢 €€Ð DÒ¿ì” “*  À" XРDÒ¿ì” “*  À" hÐ¿ì’ Ò'¿ì¿ÿëРDÀ"!pРD¬Ôc˜Ô: 0РD’ dÒ" Çàèã¿ð' DРD@=ÔÇàèã¿ð' DРD@=žÇàèã¿€ð' Dò' HÀ'¿ìп쀢 €€Ð DÒ¿ì” “*  Ò HÒ'¿è€¢`€Ð¿èÒ HÒ" €Ð¿ì’ Ò'¿ì¿ÿêÀ'¿ìп쀢 €€!РDÒ¿ì” “*  Ò XÒ'¿ä€¢`€Ð¿äÒ HÒ"!РDÒ¿ì” “*  Ò hÒ'¿ä€¢`€Ð¿äÒ HÒ"!Ð¿ì’ Ò'¿ì¿ÿÝÇàè㿈ð' DРDÒ €¢`e€ РDÒ €¢`f€€Ð DÒ DÐ àÒ` €¢ € РDÒ CÐ"`РDÒÔ@РDŸÂ€Ð DÒ!LÔ`РDŸÂ€€Ð DÒ €¢`g€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!LÐ`€¢ €€FРDÒ!LÔ@РDŸÂ€À'¿ìРDÒ¿ìÐ ð€¢@ €€/РDÒ €¢`€Ð DÒ Ð¿ìÐ"`Ò DÐ`Ò DÔ`ðÔ" РDÒ Ô@РDŸÂ€Ð DÒ!XÔ`РD’ ŸÂ€€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ì’ Ò'¿ì¿ÿÍРDÒ!LÔ`РDŸÂ€¿ÿ¶Ð DÒ!\Ô` РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð D@<ÀÇàè㿈ð' Dò' Hô' Lö' PРDÒ à€¢`€Ð DÒ €¢`e€Ð DÒ €¢`f€Ð DÒ €¢`g€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!\Ö`РDÒ HÔ PŸÂÀРDÒ!\Ð`Ð'¿ìÒ Pÿ’Ò' P€¢ÿ€€Ð LÔ ’  ÿÔ¿ìРDŸÂ€Ð L’ Ò' L¿ÿíÇàèã¿ð' Dò' Hô' LРDÒ à€¢`€Ð DÒ €¢`e€Ð DÒ €¢`f€Ð DÒ €¢`g€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!\Ö`РDÒ HÔ LŸÂÀÇàèã¿ð' Dò' HРDÒ!\Ô`РDÒ HŸÂ€Çàèã¿ð' DРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒÔ`РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð D@ÃРDÒ!\Ô`РDŸÂ€Ð DÒ Ô`РDŸÂ€Çàèã¿ð' Dò' HРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð H€¢ €Ð D’ ÿþFРDÒÔ`РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð D@ÿРDÒ!LÔ@РDŸÂ€Ð DÀ" àРDÒ DÔ`°€¢ €’ f€’ eÒ" Çàè㿈ð' Dò' Hô' LРDÒ €¢`e€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ DÐ àÒ` €¢ € РDÒ {Ð"`РDÒÔ`РD’?ÿŸÂ€Ð DÒ €¢`€Ò DÐ`Ò DÔ`àÔ" Ò DÐ`Ò DÔ` Ô" РDÒ Ô@РDŸÂ€Ð DÒ!LÐ` €¢ €Ð DÒ!LÔ`РDŸÂ€Ð DÒ DÐ Ò`à" Ð'¿èРLҿ耢 €Ð¿èÐ' LÀ'¿ìРDÒ!P”¿ìØ`РDÒ HÖ LŸÃРDÒ DÔ`àҿ씀 Ô" àп찀Çàè㿈ð' Dò' Hô' LРDÒ €¢`f€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ DÐ àÒ` €¢ €Ð DÒ {Ð"`РDÒÔ`РD’?ÿŸÂ€° €NРDÒ €¢`€Ò DÐ`Ò DÔ`àÔ" Ò DÐ`Ò DÔ` Ô" РDÒ Ô@РDŸÂ€Ð DÒ!LÐ` €¢ €Ð DÒ!LÔ`РDŸÂ€Ð DÒ ì “* Ò'¿ìРLҿ쀢 € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ!XÔ`РDÒ HŸÂ€€¢ €° € РDÒ DÔ`àҿ씀 Ô" àп찀Çàèã¿€ð' Dò' Hô' Lö' Pø' TРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð H€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð H’‘*`’ HРD’ Ò'¿ìпìÒ€¢`€Ð D@:ÔÒ¿ìÐ"@À'¿èп耢 ?€€6п蒑*`Ô L’ Ð@Ò P@’«’ 2 ’ d@’¬Ð'¿äп䀢 € Ð'¿äп䒣ÿ€¢ €cÿÐ'¿äРT€¢ €Ð¿ä€¢ ÿ€ ÿÐ'¿äÒ¿ìÐ@Ò¿è” “* Ô¿æÔ2 Ð¿è’ Ò'¿è¿ÿÈпìÒÀ"`€Çàèã¿ð' Dò' Hô' LРD’ ¬”ã Ö HØ LÿÿrРD’ ­”à Ö HØ LÿÿjÇàèã¿ð' DРD€¢ € Ð' DРD€¢ d€ dÐ' DРD€¢ 1€ cˆÒ D@’TÐ' D€Ð D’‘*`’ È"@Ð' DРD°€Çàèã¿ð' Dò' Hô' LРHÿÿÕÐ' HРDÒ HÔ Lÿÿ¹Çàè㿈ð' Dò' Hô' Lö' PРHÒ€¢`€Ð D@:LÒ HÐ"@Ò HÐ@Ò L” @’$À'¿ì Ð'¿èп耢 €€Ð LÒ¿è Ò `ÿÒ¿ì@Ð'¿ìÐ¿è’ Ò'¿è¿ÿïп쀢 €Ð¿ì€¢!€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð HÔ’  Ò PÔ¿ì@‘òРHÒÀ"aÇàèã¿ð' DРD’ XРD­”á ­–!¸ÿÿ«Ð D’ hРD­”áð­–"ÿÿ¢Ð D’ \РD­”áÈ­–!àÿÿ™Ð D’ lРD­”â°­–"ÈÿÿÇàè㿈ð' DРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ D€¢`€ РDÒ Ö@РD’ ”#HŸÂÀÒ DÐ"`DРD’ Ò" 8РD’ K” ÿÿRРDÿÿªÀ'¿ìп쀢 €€Ð DÒ¿ì À* xРDÒ¿ì ’ Ò* ˆÐ DÒ¿ì ’ Ò* ˜Ð¿ì’ Ò'¿ì¿ÿéРDÀ" ¬Ð DÀ" ¨Ð DÀ" °Ð DÀ" ´Ð DÀ" ¸Ð DÒ 8€¢`€Ð D’ Ò" ¸Ð DÀ" ¼Ð DÀ" ÀРDÀ" ÄРDÀ" ÈРDÀ" ÌРD’ Ò* ÔРD’ Ò* ÕРDÀ* ÖРD’ Ò2 ØРD’ Ò2 ÚРD@Çàèã¿ð' DРDÒ (€¢`€4Ð (’‘*`b’£4Р‹ċL‹d‹|‹”‹¬Ð D’ @.€*РD’ @(€$РD’ @"€Ð D’ @€Ð D’ @€Ð D’ @€ РDÒ Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' Dò' HРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ HÒ" @РDÀ" ÐРDÀ" ÜРH€¢ €ªÐ H’‘*`c’ ´Ð ‘üŒÌ4Ž4L˜Ð D’ Ò" ÐРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" €ŒÐ D’ Ò" ÜРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ RÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`TÐ'¿ìÐ¿ì’ GÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`¨Ð'¿ìÐ¿ì’ BÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" €LРD’ Ò" ÐРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`TÐ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" РDÒ D`¨Ð'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" €Ð D’ Ò" ÜРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ CÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`TÐ'¿ìÐ¿ì’ MÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`¨Ð'¿ìÐ¿ì’ YÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`üÐ'¿ìÐ¿ì’ KÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" €³Ð D’ Ò" ÜРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`TÐ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" РDÒ D`¨Ð'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" РDÒ D`üÐ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" €ZРDÒ DÔ`$Ô" <РDÒ <€¢`€ РDÒ <€¢` €€Ð DÒ Ð"`Ò DÐ@Ò DÔ`<Ô" РDÒ Ð"`РDÒÔ@РDŸÂ€À'¿èРDÒ¿èÐ <€¢@€€!РDÒ¿è– •*à”€ —* –À “*àÐ D’ Ò'¿ìпìÒ¿èÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" Ð¿è’ Ò'¿è¿ÿÛ€ РDÒ Ð"`РDÒÔ@РDŸÂ€Çàèã¿ð' Dò' Hô' Lö' Pø' Tú' XРD’ Ò"РDÒ HÒ" РDÒ LÒ" РDÒ PÒ" РDÒ TÒ" РDÒ XÒ" РD’ $Ò' DРD°€Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XÀ'¿ìпìÒ H€¢ €€Ð D’ Ò"РDÒ¿ìÒ" РDÒ LÒ" РDÒ PÒ" РDÒ TÒ" РDÒ XÒ" РD’ $Ò' DÐ¿ì’ Ò'¿ì¿ÿáРD°€Çàè㿈ð' Dò' Hô' Lö' PРH€¢ €(РDÒ HÒ"À'¿ìпìÒ H€¢ €€Ð DÒ¿ì” “*  Ò¿ìÒ" Ð¿ì’ Ò'¿ì¿ÿïРDÒ DÀ"`À" РDÒ LÒ" РDÒ PÒ" РD’ $Ò' D€ РDÒ H” – Ø LÚ PÿÿœÐ' DРD°€Çàèã¿€ð' DРDÒ <Ò'¿ìРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð¿ì€¢ € РDÒ @€¢`€ Ð'¿è€Ð¿ì€¢ € п씓* ’@‘*`Ð'¿è€Ð¿ì’‘*`’ Ò'¿èРDÒ!p€¢`€ РDÒ!tп耢@€€Ð Dҿ耢` €’ Ò"!tÒ DÐ`Ô DÒ¡t” —* –À •*àÖРD’ ŸÂÀÒ DÐ"apРDÒ!pÒ'¿äРDÒ¿äÒ" ¬Ð DÒ¿èÒ" ¨Ð¿ì€¢ €_РDÒ @€¢`€ZпäÒ¿ì” – ÿÿRÐ'¿äÐ¿ä’ ” – ˜ š ÿþøÐ'¿äÐ¿ä’ ” – ?˜ š ÿþïÐ'¿äÐ¿ä’ ” – ?˜ š ÿþæÐ'¿äÐ¿ä’ ” – ?˜ š ÿþÝÐ'¿äÐ¿ä’ ” – ?˜ š ÿþÔÐ'¿äпäÒ¿ì” – ÿÿÐ'¿äÐ¿ä’ ” – ?˜ š ÿþÄÐ'¿äÐ¿ä’ ” – ?˜ š ÿþ»Ð'¿äÐ¿ä’ ” – ?˜ š ÿþ²Ð'¿ä€4пäÒ¿ì” – ÿþúÐ'¿äпäÒ¿ì” – ˜ š ÿþÂÐ'¿äпäÒ¿ì” – ?˜ š ÿþ¹Ð'¿äпäÒ¿ì” – ?˜ š ÿþ°Ð'¿äпäÒ¿ì” – ÿþØÐ'¿äпäÒ¿ì” – ?˜ š ÿþ Ð'¿äÇàè㿈ð' DРDÒ Ò'¿ìРDÒ Ö@РD’ ŸÂÀÒ¿ìÐ"`пìÒ¿ìÔ`Ô"пìÒ" Çàè㿈ð' DРDÒ Ò'¿ìпìÖ¿ìÐ ’ Öà@Ž€¢ € РDÒ %Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿ìÔ`Ô"пìÒ" ° €Çàè㿈ð' DРDÒ Ò'¿ìпìÐ ’"@Ò'¿èп耢 €Ð¿ìÖ¿ìÐ ’ Ô¿èÖà@^ҿ耢 € РDÒ %Ð"`РDÒÔ@РDŸÂ€Ò¿ìÐ`@OпìÒ Ð ` ’ `ÿ€¢ € РDÒ %Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' Dò' HРDÒ €¢`€ РDÒ Ö@РD’ ” ŸÂÀÒ DÐ"`РDÒ Ò'¿ìпìf’¡€Ò" пìf’¡àÒ" пìf’¢|Ò" пìÒ HÒ" Çàèã¿ð' DРD’ @ÊРDÒ °€¢`€ РD@AРD@ºÐ D’ @4РD@-øРDÒ ´€¢`€Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ 䀢`€Ð D@*ˆ€Ð D@$y’ РDÔ ¨€¢ € РDÔ ¸€¢ €€’ РD@РD’ @ ýРD@ <РDÒ Ô`РDŸÂ€Ð DÒ!\Ô@РDŸÂ€Çàèã¿€ð' DРDÒ €¢`€Ð DÒ €¢`€Ð DÒ <€¢`€ РDÒ $€¢`€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ò DÐ` ?’£Ü€¢ € Ò DÐ`?’£Ü€¢ €€Ð DÒ )Ð"`Ò DÐ@?’£ÜÒ" РDÒÔ@РDŸÂ€Ð DÒ DÐ Ò`$@Œ]Ð'¿äпäÐ'¿àпàҿ䀢 € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð DÒ 8€¢`€Ð DÒ Ð"`Ò DÐ@Ò DÔ`8Ô" РDÒÔ@РDŸÂ€Ð DÒ <€¢` €Ð DÒ Ð"`Ò DÐ@Ò DÔ`<Ô" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð D’ Ò" èРD’ Ò" ìÀ'¿ìРDÒ DÒ'¿èРDÒ¿ìÐ <€¢@€€>пèÒ €¢`€Ð¿èÒ €¢`€Ð¿èÒ €¢`€ пèÒ €¢`€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÖ¿èÔàÖ`耢€ €Ô`èÔ" èРDÒ DÖ¿èÔà Ö`쀢€ €Ô`ìÔ" ìÐ¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ¾À'¿ìРDÒ DÒ'¿èРDÒ¿ìÐ <€¢@€€IпèÒ¿ìÒ" Ð¿è’ Ò" $РDÒ¿èÐ Ò`@‹¸Ò DÔ`è’ •*`’ @3íÒ¿èÐ"`РDÒ¿èÐ Ò` @‹©Ò DÔ`ì’ •*`’ @3ÞÒ¿èÐ"` РDÒ¿èÐ Ò`@‹šÒ DÒ`è@3ÒÒ¿èÐ"`(РDÒ¿èÐ Ò` @‹ŽÒ DÒ`ì@3ÆÒ¿èÐ"`,Ð¿è’ Ò" 0Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ³Ð DÒ DÔ`ì’ •*`Ð ’ @3°Ò DÐ"`ðÇàèãµ8ð' DРDÒ ¨€¢`€Ð DÒ Ð"`РDÒÀ"`РDÒÔ@РDŸÂ€Ð DÒ ¬Ò'¿ìпìÒ €¢`€ пìÒ €¢`?€€*РD’ Ò" 䵘Ð'¿œÀ'¿àРDÒ¿àÐ <€¢@€€À'¿Üп܀¢ ?€€ ¿œÒ”?ÿÔ"@’`Ò"пܒ Ò'¿Ü¿ÿñÐ¿à’ Ò'¿à¿ÿâ€Ð DÀ" äÀ'¿àРDÒ¿àÐ <€¢@€€ Ð¿à’‘*`’¿ À"@Ð¿à’ Ò'¿à¿ÿð Ð'¿èРDÒ¿èÐ ¨€¢@€€·Ð¿ìÒÒ'¿äп䀢 €Ð¿ä€¢ €€Ð DÒ Ð"`РDÒпäÐ"`РDÒ Ð"`РDÒÔ@РDŸÂ€À'¿àпàҿ䀢 €€EпìÒ¿à” “*  Ò Ò'¿Øп؀¢ € РDÒ¿ØÐ <€¢@€€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿à€¢ €Ð¿ìÔ¿à’¿ÿ” “*  Ò¿ØÐ €¢@€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿à’ Ò'¿à¿ÿ¸Ð¿ìÒ Ò'¿ÔпìÒ Ò'¿ÐпìÒ Ò'¿ÌпìÒ Ò'¿ÈРDÒ 䀢`€âпԀ¢ €!пԀ¢ ?€Ð¿ÐÒ¿Ô€¢ €Ð¿Ð€¢ ?€Ð¿Ì€¢ €Ð¿Ì€¢ € пȀ¢ €Ð¿È€¢ €€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿Ô€¢ €Ð¿Ð€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€€Ð¿ä€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€À'¿àпàҿ䀢 €€|µ˜Ò¿ìÔ¿à– •*à’@ Ô`’ •*` Ð'¿œÐ¿Ô€¢ €Ð¿œÒ€¢`€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿ÔÐ'¿ÜпÜҿЀ¢ €€Kпܒ‘*`Ò¿œ Ò€¢`€Ð¿Ì€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€€"пܒ‘*`Ò¿œ Ò¿ÌЀ¢@€ Ò¿ÌÿÒ¿È€¢@€€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿Ü’‘*`Ò¿œ Ò¿ÈÒ"пܒ Ò'¿Ü¿ÿ²Ð¿à’ Ò'¿à¿ÿ€SпԀ¢ €Ð¿Ð€¢ ?€ п̀¢ €Ð¿È€¢ €€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€À'¿àпàҿ䀢 €€*пìÒ¿à” “*  Ò Ò'¿Øпؒ‘*`’¿ Ð@€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿Ø’‘*`’¿ ” Ô"@Ð¿à’ Ò'¿à¿ÿÓÐ¿ì’ $Ò'¿ìÐ¿è’ Ò'¿è¿þEРDÒ 䀢`€$À'¿àРDÒ¿àÐ <€¢@€€Ð¿à’‘*`’µ˜Ð@€¢ € РDÒ -Ð"`РDÒÔ@РDŸÂ€Ð¿à’ Ò'¿à¿ÿã€"À'¿àРDÒ¿àÐ <€¢@€€Ð¿à’‘*`’¿ Ð@€¢ € РDÒ -Ð"`РDÒÔ@РDŸÂ€Ð¿à’ Ò'¿à¿ÿãÇàèã¿€ð' DРDÒ ¬€¢`€HРDÒ!LÒ'¿èРDÔ¿èÒ  – •*à”€ “* Ð ¬’ Ò'¿äРDÒ¿äÔ@Ô" ôÀ'¿ìпäÒ¿ìЀ¢@€€Ð DÒ¿ì” “*  Ò DÔ¿äÖ¿ì˜ —+ ˜€ Ô ˜ —+ –À ™*à˜ •+ Ò`D”@ Ô" øÐ¿ì’ Ò'¿ì¿ÿàРDÒ¿äÔ`Ô"!<РDÒ¿äÔ`Ô"!@РDÒ¿äÔ`Ô"!DРDÒ¿äÔ` Ô"!H€EРDÒ <€¢`€Ð DÒ Ð"`Ò DÐ@Ò DÔ`<Ô" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÔ`<Ô" ôÀ'¿ìРDÒ¿ìÐ <€¢@€€Ð DÒ¿ì” “*  Ò DÔ¿ì˜ —+ –À ™*à˜ •+ Ò`D”@ Ô" øÐ¿ì’ Ò'¿ì¿ÿåРDÀ"!<РD’ ?Ò"!@РDÀ"!DРDÀ"!HÇàèã¿xð' DРDÒ ô€¢`€5РDÒ øÒ'¿àРDÒ¿àÔ`Ô"!РDÒ¿àÔ` Ô"! Ð¿à’ Ò" 4Ð¿à’ Ò" 8Ð¿à’ Ò" <Ð¿à’ Ò" @Ð¿à’ Ò" DпàÒ¿àÔ  Ò` @ˆeÐ'¿äп䀢 €Ð¿àÒ Ò'¿äпàÒ¿äÒ" HРD’ Ò"!РDÀ"!€´Ð DÒ ô€¢`€ РDÒ ô€¢`€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`ôÔ" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÔ`è’ •*`Ð ’ @0OÒ DÐ"aРDÒ DÔ`ì’ •*`Ð ’ @0DÒ DÐ"a РDÀ"!À'¿ìРDÒ¿ìÐ ô€¢@€€tРDÒ¿ì” “*  Ò øÒ'¿àпàÒ¿àÔ`Ô" 4пàÒ¿àÔ` Ô" 8à¿àпàÒ¿àÐ 4Ò`8@‡åÐ$ <пàÒ¿àÔ`4’ •*`Ô" @пàÒ¿àÔ  Ò`4@‡ïÐ'¿äп䀢 €Ð¿àÒ 4Ò'¿äпàÒ¿äÒ" DпàÒ¿àÔ  Ò`8@‡ÝÐ'¿äп䀢 €Ð¿àÒ 8Ò'¿äпàÒ¿äÒ" HпàÒ <Ò'¿èРDÒ!Ô¿è@ €¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€¿èÒ” ’ÿÒ"€¢ €€Ô DÒ DaÒ– ™*à”€ Ö¿ìÖ"¡’`Ò"¿ÿëÐ¿ì’ Ò'¿ì¿ÿˆÐ DÒ Ì€¢`€Ð DÒ DÐ ÌÒa@‡~Ð'¿ÜРDÒ¿Ü?”ãÿ€¢@ €?’£ÿÒ" ÈÇàè㿈ð' DРDÒ!LÒ'¿ìÒ¿ìÐ`€¢ €Z€¢  €€¢ €†€²Ð DÿþWРDÿþæРDÒ °€¢`€Ð DÒ!`Ô@РDŸÂ€Ð DÒ!dÔ@РDŸÂ€Ð DÒ!TÔ@РD’ ŸÂ€Ð DÒ!hÔ@РDŸÂ€Ð DÔ!lÒ DԀРDÒ`¸ŸÂ€Ò DÐaXÒ¿ìÔ`€¢ €’ €’ ÔРDŸÂ€Ð DÒ!PÔ@РD’ ŸÂ€Ð DÒ ¸€¢`€Ð¿ìÀ" €Ð¿ì’ Ò" €lРDÿþРDÿþ–РDÒ!<€¢`€Ð DÒ!D€¢`€ РDÒ ´€¢`€€Ð DÒ!lÔ@РD’ ŸÂ€Ð DÒ!XÔ@РD’ ŸÂ€Ð¿ìÀ" €CÐ¿ì’ Ò" Ò¿ìпìÒ¿ìÔ`’ Ò" РDÒ ¸€¢`€Ð DÿýÐРDÿþ_РDÒ!lÔ@РD’ ŸÂ€Ð DÒ!XÔ@РD’ ŸÂ€Ð¿ìÒ €¢`€Ð DÒ!\Ô`РDŸÂ€Ð DÒ!\Ô`РDŸÂ€Ð¿ìÀ" € РDÒ 0Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿ìÔ¿ìÖ ”ÿÿÒ`”@ €  ’`?ÿÒ" РDÒ €¢`€ Ò DÐ`Ò¿ìÔ`Ô" Ò DÐ`Ò¿ìÔ`Ô" Çàèã¿ð' DРDÒ!LÀ"` РDÒ!\Ô`РDŸÂ€Ð DÒ!\Ô`РDŸÂ€Çàè㿈ð' DРDÒ!LÒ'¿ìРDÒ!lÔ`РDŸÂ€Ò¿ìÐ`€¢ €€¢  €€¢ €€'Ð¿ì’ Ò" РDÒ ¸€¢`€Ò¿ìпìÒ¿ìÔ` ’ Ò" €Ð¿ì’ Ò" €Ð DÒ ¸€¢`€Ð¿ì’ Ò" Ò¿ìпìÒ¿ìÔ` ’ Ò" €Ò¿ìпìÒ¿ìÔ`’ Ò" Çàè㿈ð' Dò' HРDÒ Ö@РD’ ” $ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Lпìl’¢@Ò"пìm’¡ÜÒ" пìm’¢(Ò" пìÀ" РDÿùpРDÒ ¬€¢`€Ð Dÿúœ€Ð DÀ" äРD’ Ò" ¨Ð DÒ 䀢`€Ð D’ Ò" ¸Ð H€¢ €Ð DÒ ¸€¢`€Ð¿ì’ Ò" €Ð¿ì’ Ò" €Ð¿ìÀ" пìÀ" пìÀ" РDÒ ¸€¢`€ пìÒ DÔ`¨’ •*`Ô" €Ð¿ìÒ DÔ`¨Ô" Çàè㿈ð' Dò' HРDÒ Ò'¿ìпìÒÔ KÔ*@’`Ò"Ò¿ìпìÒ¿ìÔ`’¿ÿ” Ô" €¢ €Ð¿ìÒ Ð DŸÂ@€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Çàèã¿ð' Dò' HРD’ ÿÿÿÑРDÒ HÿÿÍÇàèã¿ð' Dò' HÒ H‘:`’ ÿРDÿÿÂРH’ ÿРDÿÿ½Çàèã¿€ð' Dò' HРDÒ H” “*  Ò HÒ'¿ìп쀢 €Ð DÒ 4Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€À'¿èÀ'¿äп䀢 ?€€Ð¿ìÒ¿ä” “* Ð “* ‘2`€¢ ÿ€ Ð'¿èÐ¿ä’ Ò'¿ä¿ÿëпìÒ €€¢`€CРD’ Ûÿÿ§Ð¿è€¢ €’ ƒ€’ CРDÿÿ©Ò¿è‘*`Ô H’ РDÿÿkÀ'¿äп䀢 ?€€#пì®Ô¿ä– •*à–`T’€ Ô@’ •*`Ð “* ‘2`Ð'¿àп耢 €Ð¿à“2 РDÿÿMÐ¿à’ ÿРDÿÿHÐ¿ä’ Ò'¿ä¿ÿÛÐ¿ì’ Ò" €Ð¿è°€Çàèã¿€ð' Dò' Hô' LРL€¢ €Ð DÒ H” “*  Ò hÒ'¿ìРH’ Ò' H€ РDÒ H” “*  Ò XÒ'¿ìп쀢 €Ð DÒ 2Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð¿ìÒ!€¢`€QРD’ Äÿÿ.À'¿è Ð'¿äп䀢 €€Ð¿ìÒ¿äÔ  ÿÒ¿è@Ð'¿èÐ¿ä’ Ò'¿ä¿ÿðÐ¿è’ Ð Dÿÿ!РDÒ Hÿþæ Ð'¿äп䀢 €€Ð¿ìÒ¿äÐ ’ ÿРDÿþ×Ð¿ä’ Ò'¿ä¿ÿðÀ'¿äпäҿ耢 €€Ð¿ìÒ¿ä Ô ’  ÿРDÿþÁÐ¿ä’ Ò'¿ä¿ÿîÐ¿ì’ Ò"!Çàèã¿ð' DÇàèã¿ð' DРD’ Ýÿþ×РD’ ÿþàÒ DРDÒ`ÈÿþÛÇàè㿈ð' Dò' HРDÒ HÿþÅÒ DÐ`<”“* ’@”`РD’ ÿþÈÒ DÐ` ?’£ÿ€¢ € Ò DÐ`?’£ÿ€¢ €€Ð DÒ )Ð"`Ò DÐ@?’£ÿÒ" РDÒÔ@РDŸÂ€Ò DРDÒ`8ÿþmÒ DРDÒ` ÿþŸÒ DРDÒ`ÿþšÒ DРDÒ`<ÿþ^À'¿ìРDÒ DÒ'¿èРDÒ¿ìÐ <€¢@€€Ò¿èРDÒ@ÿþMпèÒ ‘*`Ò¿èÔ` ’ РDÿþDÒ¿èРDÒ`ÿþ?Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿßÇàèã¿€ð' DРD’ ÚÿþYРDÒ ô “* ”`РD’ ÿþ]Ò DРDÒ`ôÿþ!À'¿ìРDÒ¿ìÐ ô€¢@€€9РDÒ¿ì” “*  Ò øÒ'¿àÒ¿àРDÒ@ÿþ пàÒ Ò'¿èпàÒ Ò'¿äРDÒ 䀢`€Ð DÒ!<€¢`€À'¿äРDÒ!D€¢`€Ð DÒ ´€¢`€À'¿è€À'¿èÒ¿è‘*`Ô¿ä’ Ð DÿýæÐ¿ì’ Ò'¿ì¿ÿÃÒ DРDÒa<ÿýÜÒ DРDÒa@ÿý×РDÒ!D‘*`Ò DÔaH’ РDÿýÎÇàèã¿ð' DРD’ àÿýðРD’ ÿýùРD’ Jÿý¾Ð D’ FÿýºÐ D’ Iÿý¶Ð D’ Fÿý²Ð D’ ÿý®Ð DÔ Ô’  ÿРDÿý¨Ð DÔ Õ’  ÿРDÿý¢Ð DÔ Ö’  ÿРDÿýœÐ DÒ Ø‘*`“2 РDÿýÌРDÒ Ú‘*`“2 РDÿýÅРD’ ÿýŠÐ D’ ÿý†Çàèã¿ð' DРD’ îÿý¨Ð D’ ÿý±Ð D’ AÿývРD’ dÿýrРD’ oÿýnРD’ bÿýjРD’ eÿýfРD’ dÿý™Ð D’ ÿý•Ð D’ ÿý‘Ò DÐ`@€¢ €€¢ € €Ð D’ ÿýL€Ð D’ ÿýF€Ð D’ ÿý@€Çàèã¿ð' Dò' Hô' LРL?’£ý€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ HÿýNРL’ РDÿýVÇàèã¿ð' Dò' HРDÒ HÿýÇàè㿈ð' DРDÒ!\Ò'¿ìРD’ Øÿý5пìÀ" РDÒ Ѐ¢`€Ð Dÿÿ7РDÒ Ü€¢`€Ð DÿÿwÇàèã¿€ð' DÀ'¿èÀ'¿ìРDÒ DÒ'¿àРDÒ¿ìÐ <€¢@€€Ò¿àРDÒ`ÿý*Ò¿è@Ð'¿èÐ¿ì’ Ò'¿ìÐ¿à’ TÒ'¿à¿ÿêРDÒ ´€¢`€Ð DÒ 䀢`€ РDÒ 8€¢`€€À'¿ä€9 Ð'¿äÀ'¿ìРDÒ DÒ'¿àРDÒ¿ìÐ <€¢@€€Ð¿àÒ €¢`€ пàÒ €¢`€€À'¿äÐ¿ì’ Ò'¿ìÐ¿à’ TÒ'¿à¿ÿåп耢 €Ð¿ä€¢ €À'¿äРDÒ KÐ"`РDÒÔ`РD’ ŸÂ€Ð DÒ ´€¢`€Ð D’ Éÿýä€Ð DÒ 䀢`€Ð D’ Âÿýـп䀢 €Ð D’ ÀÿýπРD’ ÁÿýÉÇàèã¿€ð' DРDÒ!\Ò'¿ìРDÒ ´€¢`€Ð Dÿý¥€BÀ'¿èРDÒ¿èÐ ô€¢@€€9РDÒ¿è” “*  Ò øÒ'¿äРDÒ 䀢`€Ð DÒ!<€¢`€Ð DÒ!D€¢`€Ò¿äРDÒ`” ÿüû€Ò¿äРDÒ`” ÿüó€Ò¿äРDÒ`” ÿüëÒ¿äРDÒ`” ÿüåÐ¿è’ Ò'¿è¿ÿÃРDÒ¿ìÐ ÈÒ`€¢ € РDÿý]пìÒ DÔ`ÈÔ" РDÿýÔÇàèã¿ð' DРD’ Ùÿü)Çàè㿈ð' DРD’ Øÿü!À'¿ìп쀢 €€Ð DÒ¿ì” “*  Ò H€¢`€Ð DÒ¿ìÿü*Ð¿ì’ Ò'¿ì¿ÿêРDÒ ´€¢`€*À'¿ìп쀢 €€#РDÒ¿ì” “*  Ò X€¢`€Ð DÒ¿ì” ÿüŒÐ DÒ¿ì” “*  Ò h€¢`€Ð DÒ¿ì” ÿü~Ð¿ì’ Ò'¿ì¿ÿÛРD’ Ùÿû×Çàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!\пìq’ €Ò"пìq’ ôÒ" пìq’£4Ò" пìr’ ¼Ò" пìr’ ÜÒ" пìp’£àÒ" пìq’ \Ò" пìÀ" Çàè㿈ð' Dò' HРDÒ!PÒ'¿ìРDÒ °€¢`€€#пìÀ" пìÀ" пìÀ" пìÒ HÒ" РH€¢ €€Ð¿ìr’£œÒ" €Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Çàèã¿€ð' Dò' Hô' Lö' PРDÒ!PÒ'¿ìпìÒ DÐ Ò`ð€¢ €€OпìÒ €¢`€Ò DÐaTÒ¿ì˜`Ò¿ìš` ’ Ò# \Ä Ð DÒ HÔ LÖ PŸÀ€Ð¿ìÒ €¢`€€4Ò DÐaXÔ¿ì’ Ô Ð DŸÂ€€¢ €Ð¿ìÒ €¢`€ Ò LРLÒ LÔ@’¿ÿÒ"Ð¿ì’ Ò" €Ð¿ìÒ €¢`€ Ò LРLÒ LÔ@’ Ò"пìÀ" пìÀ" Ò¿ìпìÒ¿ìÔ`’ Ò" ¿ÿ¬Çàèã¿€ð' Dò' HРDÒ Ö@РD’ ” @ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Pпìr’¢ÜÒ"РDÒ °€¢`€€;РH€¢ €Ð DÒ Ð"`РDÒÔ@РDŸÂ€€+À'¿èРDÒ DÒ'¿äРDÒ¿èÐ <€¢@€€Ò DÐ`Ò¿äÔ`’ •*`Ò¿äÖ` ’ —*`Ø Ð D’ ŸÃÒ¿ìÔ¿è– •*à’@ Ð"`Ð¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÝÇàè㿈ð' Dò' HРDÒ!TÒ'¿ìРH€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ DÔ` Ô" 0пìÀ" 4пìÀ" 8пìÒ DÔ`ì’ •*`Ô" <Çàèã¿ð' Dò' Hô' Lö' Pà LРP€¤€€Ð L’?ÿРDÔ D–˜ Ú H@(Œ  ¿ÿðÇàèã¿xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!TÒ'¿ìРLÒРP€¢@€ РXÒР\€¢@ €€€ÂРLÒ PÐ’"@Ò'¿àРDÒ¿ìÐ ìÒ`4" Ð'¿èпèÒ¿à€¢ €Ð¿à€Ð¿èÐ'¿èÒ DÐa`Ò LÔ@’ •*`Ö H’€ Ö¿ì”àÖ¿ìÚ Ð DÖà4Ø¿èŸÃ@РLÒ LÔ@ҿ蔀 Ô"пìÒ¿ìÔ`4ҿ蔀 Ô" 4пìÒ¿ìÔ`0Ò¿è”"€ Ô" 0пìÒ 0€¢`€)пìÒ DÐ 4Ò`쀢 €"À'¿äРDÒ¿äÐ <€¢@€€Ð¿ìÒ¿ä” “*  Ò DÔ¿ìÖ DÐ Ò`Ô 4ÖàìÿÿsÐ¿ä’ Ò'¿ä¿ÿçпìÒ DÔ`ìÔ" 4пìÒ DÐ 4Ò`쀢 €Ò DÐadÔ¿ì’ Ø XÚ Ð D” Ö TØŸÃ@пìÀ" 4Ò XРXÒ XÔ@’ Ò"пìÒ 0€¢`€<РXÒР\€¢@€6À'¿äРDÒ DÒ'¿ÜРDÒ¿äÐ <€¢@€€%п䒑*`Ò T  пÜÒ  £* РXÒ¿ÜÐÒ` @h¤Ò¿ÜР\Ò` @b–Ð’”ÿÿÐ¿ä’ Ò'¿äпܒ TÒ'¿Ü¿ÿ×РXÒ \Ò"€¿ÿ2Çàèã¿xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!TÒ'¿ìÒ DÐ`ì’•*`€Ð'¿àРXÒР\€¢@ €€âРLÒРP€¢@€tРLÒ PÐ’"@Ò'¿ÜпìÒ¿ìÐ <Ò`4" Ð'¿èпèÒ¿Ü€¢ €Ð¿Ü€Ð¿èÐ'¿èÒ DÐa`Ò LÔ@’ •*`Ö H’€ Ö¿ì”àÖ¿ìÚ Ð DÖà4Ø¿èŸÃ@пìÒ DÐ 0Ò` €¢ €3À'¿äРDÒ¿äÐ <€¢@€€* Ð'¿ØРDÒ¿ØÐ 쀢@€€Ð¿ìÒ¿ä” “*  Ò¿ìÔ¿ä– ™*à”@ Ò¿Ø– Ú DÐ ’ Ô ˜ Ú`@'9пؒ Ò'¿Ø¿ÿáÐ¿ä’ Ò'¿ä¿ÿÒРLÒ LÔ@ҿ蔀 Ô"пìÒ¿ìÔ`4ҿ蔀 Ô" 4пìÒ¿ìÔ`0Ò¿è”"€ Ô" 0€0пìÒ 0€¢`€€cпìÒ¿ìÐ 4Ò`<€¢ €"À'¿äРDÒ¿äÐ <€¢@€€Ð¿ìÒ¿ä” “*  Ò DÔ¿ìÖ¿ìÐ Ò`Ô 4Öà<ÿþWÐ¿ä’ Ò'¿ä¿ÿçпìÒ¿ìÔ`<Ô" 4пìÒ¿ìÐ 4Ò`<€¢ €3Ò DÐadÔ¿ì’ Ô¿ìØ XÚ Ð DÔ 8Ö TØŸÃ@Ò XРXÒ XÔ@’ Ò"пìÒ¿ìÔ DÒ`8Ô ì’@ Ò" 8пìÒ 8Ð¿à€¢@€Ð¿ìÀ" 8пìÒ 4Ð¿à€¢@€Ð¿ìÀ" 4пìÒ¿ìÔ DÒ`4Ô ì’@ Ò" <¿ÿÇàèã¿pð' DРDÒ!TÒ'¿ìРDÒ ìÒ'¿èРDà Ò Dп薕*à”€ Ò`<@~>’•*`ÖРD’ ŸÂÀÐ'¿ÔÀ'¿äРDÒ DÒ'¿ÜРDÒ¿äÐ <€¢@€€qРDà Ò¿ÜРDÔ è •*  Ò`@~Ò¿ÜÒ`@~!”п蒗*`–ÀØ Ð D’ ŸÃÐ'¿Øп蒑*`Ò¿Ô Ò¿è” —* –À •*àÒ¿Ø@~ À'¿àпàҿ耢 €€'Ð¿à’‘*`Ò¿Ô Ò¿è” “* Ô¿à’@ ” “* Ô¿Ø’@ Ô@Ô"п蒑*`Ò¿à ’‘*`Ò¿Ô Ò¿à” “* Ô¿Ø’@ Ô@Ô"Ð¿à’ Ò'¿à¿ÿÖпìÒ¿ä” “*  Ò¿è” “* Ô¿Ô’€ Ò" п蔓* ’@‘*`Ò¿Ô@Ð'¿ÔÐ¿ä’ Ò'¿äпܒ TÒ'¿Ü¿ÿ‹Çàèã¿€ð' Dò' HРH€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ö@РD’ ” @ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Tпìs’¢pÒ"РDÒ!dÐ`€¢ € пìt’¢ØÒ" РDÿÿ<€7пìs’£hÒ" À'¿èРDÒ DÒ'¿äРDÒ¿èÐ <€¢@€€'РDà Ò¿äРDÔ è •*  Ò`@}nÒ¿äÒ`@}p”Ö DØ Ð D’ ÖàìŸÃÒ¿ìÔ¿è– •*à’@ Ð"`Ð¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÕÇàè㿈ð' DРDÒ!XÒ'¿ìРDÒ ô€¢`€Ð¿ì’ Ò" €Ð¿ìÒ DÔ`ð’¿ÿÐ €¢ € пìÒ DÔ`øÒ  Ò" €Ð¿ìÒ DÔ`øÒ HÒ" пìÀ" пìÀ" Çàè㿈ð' Dò' HРDÒ!XÒ'¿ìпìÀ" РDÿÿÎРH€¢ €9€¢ €€¢ € €F€¢ €€AпìÒ @€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ìw’¡Ò" €8пìÒ @€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ìx’¡ˆÒ" €#пìÒ @€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ìy’¢ Ò" €Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Çàèã¿Pð' Dò' HРDÒ!XÒ'¿ìРDÒ!ÿÐ'¿äРDÒ ðÿÐ'¿àпìÒ Ò'¿ÌпìÒ¿ÌÐ €¢@€€üпìÒ Ò'¿èпèҿ䀢 €€ëÀ'¿ÜÀ'¿ÔРDÒ¿ÔÐ ô€¢@€€ÈРDÒ¿Ô” “*  Ò øÒ'¿¼Ð¿èҿ䀢 €Ò¿¼Ð`4€Ò¿¼Ð`DÐ'¿ÈÒ¿¼Ð¿èÒ`@@|{Ð'¿Àп̒‘*`Ð'¿ÄÀ'¿Ðп¼Ò¿ÐÐ 8€¢@€€Ð¿ìÒ Ð¿à€¢@ € пÌÒ¿Ð Ò¿¼Ô`H€¢ €€TÒ DÐahÒ¿¼Ô`’ •*`Ò H”€ Ò¿ìֿܘ ›+ –@ Ò¿ÈÒ# \Ä Ð DÒ¿¼Ô€ÖàØ¿ÄÚ¿ÀŸÀ€Ð¿¼Ò¿ÈÐ 4€¢@€4пìÒ¿ÜÔ¿È’@ ” “*  Ò¿¼Ô`4Ö¿È’"€ ” “* Ð @$ÉпÈÐ'¿Øп¼Ò¿ØÐ 4€¢@€€Ð¿ìÒ¿ÜÔ¿Ø’@ ” “* ” РҿìÔ¿ÜÖ¿Ø”€ –¿ÿ” —* ”@ Ò Ô@Ô2пؒ Ò'¿Ø¿ÿâ€.пìÒ¿Ü” “*  Ò¿¼Ô`4’ •*`Ð ’ @$˜À'¿Øп¼Ò¿ØÐ 4€¢@€€Ð¿ìÒ¿ÜÔ¿Ø’@ ” “* ” РҿìÖ¿Ü”ÿÿ– •*à–@ ÒàÔ@Ô2пؒ Ò'¿Ø¿ÿäп¼Ò¿ÜÐ 4’@Ò'¿ÜпĒ Ò'¿ÄпВ Ò'¿Ð¿ÿ_пԒ Ò'¿Ô¿ÿ4Ò DÐalÔ¿ì’ Ô Ð DŸÂ€€¢ € пìÒ¿ÌÒ" пìÒ¿èÒ" ° €Ð¿è’ Ò'¿è¿ÿпìÀ" п̒ Ò'¿Ì¿ÿÒ¿ìпìÒ¿ìÔ`’ Ò" РDÿþT° €Çàèã¿Hð' Dò' HРDÒ!XÒ'¿ìРDÒ ðÿÐ'¿èÀ'¿ÔРDÒ DÒ'¿¼Ð DÒ¿ÔÐ <€¢@€€ РDà пìÒ¿Ô” “* ¢ пìÒ¿¼Ð Ò` @{|”Ö¿¼Ú РDÒ`@Öà ˜ ŸÃ@Ð'¿¸Ð¿ìÒ Ð¿è€¢@€Ð¿¼Ò Ò'¿È€Ð¿¼Ò¿¼Ô  Ò` @{xÐ'¿ÈпȀ¢ €Ð¿¼Ò Ò'¿Èп¼Ò Ò'¿äп¼Ò Ò'¿ÐÒ¿ä Ò¿Ð@{eÐ'¿ÄпĀ¢ €Ð¿ÐÒ¿Ä" Ð'¿ÄÀ'¿ÌпÌÒ¿È€¢ €€Lп̒‘*`Ò¿¸ ÒÒ'¿´Ò DÐahÒ¿Ô” “* Ö H”@ Ò¿Ì– ™*àÒ¿äÒ# \Ä Ð DÒ¿¼Ô€Ö¿´š ŸÀ€Ð¿Ä€¢ €(п䒑*`Ò¿´@Ð'¿´Ð¿Ä’•*`п´’ @#©?€Ò¿´ ÒÒ7¿ÂÀ'¿ØпØÒ¿Ä€¢ €€Ð¿Ø’‘*`Ò¿´ Ò¿ÂÒ2пؒ Ò'¿Ø¿ÿïп̒ Ò'¿Ì¿ÿ±Ð¿ìÒ Ð¿è€¢@€cпäÒ¿Ä Ð'¿äпäÒ¿Ð@zæÐ'¿àпÈÐ'¿Ìп¼Ò¿ÌÐ €¢@€€Pп̒‘*`Ò¿¸ ÒÒ'¿´Ð¿Ì’‘*`Ò¿¸ Ò?üÒ'¿°Ð¿ä’•*`п´’ @#]À'¿ÜпÜÒ¿à€¢ €€.пВ‘*`Ò¿° Ò?€Ò7¿ÂÀ'¿ØпØҿЀ¢ €€Ð¿Ø’‘*`Ò¿´ Ò¿ÂÒ2пؒ Ò'¿Ø¿ÿïпВ‘*`Ò¿´@Ð'¿´Ð¿Ð’‘*`Ò¿°@Ð'¿°Ð¿Ü’ Ò'¿Ü¿ÿÏп̒ Ò'¿Ì¿ÿ¬Ð¿Ô’ Ò'¿Ôп¼’ TÒ'¿¼¿þóРDÒ H@°€Çàèã¿Xð' Dò' HРDÒ!XÒ'¿ìÀ'¿àРDÒ¿àÐ ô€¢@€€*РDÒ¿à” “*  Ò øÒ'¿¸Ð Dà пìÒ¿¸Ô`’ •*`¢ пìÒ¿¸Ð Ò` @zU”Ö¿¸Ú РDÒ`@Öà ˜ ŸÃ@Ò¿à” “* ”¿ÀÐ"€ Ð¿à’ Ò'¿à¿ÿÒпìÒ Ò'¿ÔпìÒ¿ÔÐ €¢@€€ƒÐ¿ìÒ Ò'¿èРDÒ¿èÐ!€¢@ €€qÀ'¿äÀ'¿àРDÒ¿àÐ ô€¢@€€NРDÒ¿à” “*  Ò øÒ'¿¸Ò¿¸Ð¿èÒ`4@zÐ'¿ÐÀ'¿Øп¸Ò¿ØÐ 8€¢@€€3Ð¿à’‘*`’¿ÀÔ¿ØÖ¿Ô”€ – •*àÒ@€ ҿД “* Ð’ Ò'¿¼À'¿Üп¸Ò¿ÜÐ 4€¢@€€Ô¿ì¿äÒ– ›*à˜€ ”¿¼Ö€Ö# –à€Ö"€’`Ò"пܒ Ò'¿Ü¿ÿèпؒ Ò'¿Ø¿ÿÉÐ¿à’ Ò'¿à¿ÿ®Ò DÐalÔ¿ì’ Ô Ð DŸÂ€€¢ € пìÒ¿ÔÒ" пìÒ¿èÒ" ° €Ð¿è’ Ò'¿è¿ÿ‹Ð¿ìÀ" пԒ Ò'¿Ô¿ÿyÒ¿ìпìÒ¿ìÔ`’ Ò" РDÿü\° €Çàèã¿€ð' Dò' HРDÒ Ö@РD’ ” hŸÂÀÐ'¿ìРDÒ¿ìÒ"!Xпìv’£`Ò"РH€¢ €7À'¿èРDÒ DÒ'¿äРDÒ¿èÐ <€¢@€€)РDà пäÒ¿äÐ Ò`@!ȢпäÒ¿äÐ Ò` @!Á˜Ú¿äÄ Ð D’ ” –Ú` ŸÀ€Ò¿ìÔ¿è– •*à’@ Ð"`@Ð¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÓ€$РDÒ Ö`РD’ ”%ŸÂÀÐ'¿äÀ'¿èп耢 €€Ð¿ìÒ¿è” “*  Ò¿è” “* Ô¿ä’€ Ò" Ð¿è’ Ò'¿è¿ÿìпìÀ" @Çàèã¿€ð' DРDÒ!`Ò'¿ìРDÒ Ö@РD’ ŸÂÀ’пìÒ'¿èÒ" À'¿äп䀢 ÿ€€’п䒑*`Ò¿è Ò¿ä– •*à”€ —* ”€ —* –À •*à”"€ —* ’"À Ò"п䒑*`Ò¿è Ò¿ä– •*à”"€ —* –À •*à”"€ “* ”€ “* Ò"$п䒑*`Ò¿è Ò¿ä– •*à”"€ —* –À “*à’"@  ’@ Ò"(п䒑*`Ò¿è Ò¿ä– •*à”€ —* ”€ —* –"À •*à”"€ —* ’"À ” Ô",п䒑*`Ò¿è Ô¿ä˜ —+ –À ™*à˜# —+ –À •*à–À ” Ô" п䒑*`Ò¿è Ô¿ä– •*à –#ÿ”€ Ô" п䒑*`Ò¿è Ô¿ä– ™*à˜ —+ –À ™*à–À ™*à˜# —+ ”"À – Ö" п䒑*`Ò¿è Ô¿ä– ™*à˜ —+ –À ™*à–À ™*à” – Ö" Ð¿ä’ Ò'¿ä¿ÿlÇàè㿈ð' Dò' Hô' Lö' Pø' TРDÒ!`Ò'¿ìØ¿ìÖ à Dâ â'¿èâ T ÿ¢â' T€¤`€€j  HâØ@¢`â$à Lâ P¤£, ä @Ú  â L â P¤£, ä @Ä  â L â P¤£, ä @Æà P¢ â' Pž à¿è€£À €€@à ÿà ’ ÿà ” ÿ˜ ¢¡,`¢ ¥,`¢€ àÀâd ¢ ¥,`¢€ äh £< â+@ £,  @ ¢ ¥,`¢€ %à,â@ ¢ ¥,`¢€ %â@ £< â(€ £,  @ #¤ §, ¤À 'à†¢ ¥,`¢€ %â@ £< â(Àžà¿ÿ¾¿ÿ‘Çàè㿈ð' Dò' Hô' Lö' Pø' TРDÒ!`Ò'¿ìØ¿ìÖ Æ DÞàÞ'¿èÞ T†ÿÿžÞ' T€£à€€3† HÞÀØÀžàÞ ÀÆ LÞ P Ÿ, àÀ†ÀÚÀÆ PžàÞ' P„ ƿ耠€ €€Æ àÿÆ ’àÿÆ ”àÿ˜ ž‡+àž ¡+àž ÆÀÞä†Àž ¡+àž àè†ÀŸ8àÞ+@„ ¿ÿã¿ÿÈÇàè㿈ð' Dò' Hô' Lö' Pø' TРDÒ!`Ò'¿ìØ¿ìÖ â Dä`ä'¿èä T¢¿ÿ¤ä' T€¤ €€{¢ Hä@Ø€¤ ä$@â Lä P¦¥,àæ@¢€Ú@¢ ä L¢@ä P¦¥,àæ@¢€Ä@¢ ä L¢@ä P¦¥,àæ@¢€Æ@¢ ä L¢@ä P¦¥,àæ@¢€Þ@â P¤`ä' P  â¿è€¤ €€Hä ¢  ÿ¤ ÿ$€ä ¢  ÿ¤ ÿ’$€ä ¢  ÿ¤ ÿ”$€â â+À˜ ¤£, ¤ §, ¤À âÀ䤢@¤ §, ¤À 樢@¥<`ä+@¢¥,`¢€ ¤ §, ¤À 'âl䀢@¤ §, ¤À '䀢@¥<`ä(€¢¥,`¢€ %¦ ©,ঠ)â@äÀ¢@¤ §, ¤À '䀢@¥<`ä(À  ¿ÿ¶¿ÿ€Çàè㿈ð' Dò' Hô' Lö' Pø' TÖ DØàØ'¿ìÖ DØà$Ø'¿èØ T–?ÿ˜ Ø' T€£ €€!– HØÀИ Ø"ÀÖ LØ Pš ™+`ÚÀ– ÒÀÖ P˜àØ' P” ֿ쀢€ €€ Ö Ö*@ Ö¿è ” ¿ÿõ¿ÿÚÇàè㿈ð' Dò' Hô' Lö' Pø' TØ DÚ <Ú'¿ìØ DÚ Ú'¿èÚ T˜ÿš Ú' T€£`€€.– ؿ쀢À €€Ø HИ ›+ Ä L˜@Ú P„ ›( Ä˜@Ò” ؿ耢€ €€ Ø Ø*@ Ø¿ì ” ¿ÿõ–à¿ÿßØ Hš Ú' HØ Pš Ú' P¿ÿÍÇàèã¿ð' DÇàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!`пì}’¡(Ò"РDÒ (ÿ€¢ €A’‘*`}’¡´Ð ÂõÈö ö öPöPРDÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€5РDÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€$РDÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ @ÿ€¢ €’‘*`}’£ Ð Â÷ ø ø¸ùŒú$РDÒ <€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ (€¢`€Ð¿ì|’£DÒ" €&РDÒ (€¢`€ пìz’£(Ò"пì{’£ÔÒ" €Ð DÒ (€¢`€Ð¿ì|’£DÒ" € РDÒ Ð"`РDÒÔ@РDŸÂ€€ØРDÒ <€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ (€¢`€Ð¿ì}’ Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€²Ð DÒ <€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ (€¢`€ пìz’£(Ò"пì{’¡ÐÒ" €Ð DÒ (€¢`€Ð¿ì}’ Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€}РDÒ <€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ (€¢`€Ð¿ì}’ Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€WРDÒ <€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ (€¢`€ пìz’£(Ò"пì|’ üÒ" €Ð DÒ (€¢`€Ð¿ì}’ Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€"РDÒ DÐ @Ò`(€¢ € РDÒ DÐ <Ò`$€¢ €€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ì}’ Ò" €Çàèã¿ð' DÇàè㿈ð' Dò' Hô' Lö' PÖ PØ L–"À Ö'¿èֿ耢à€#À'¿ìÖ¿ìØ H€¢À €€Ö¿ì˜ —+ Ø D–À ØÀÖ L Ò ?ÿԿ耢 €€Ò* ”¿ÿ¿ÿøÖ¿ì˜àØ'¿ì¿ÿâÇàèã¿xð' Dò' Hô' Lö' Pø' TРDÒ!dÒ'¿ìÀ'¿èРDÒ DÒ'¿äРDÒ¿èÐ <€¢@€€0п蒑*`Ò H Ò L” “* Ð’ Ò'¿àп蒑*`Ò P  Ò¿äРTÒ` @tÃ’‘*`Ò@Ð'¿ÜпìÒ¿è” “*  Ø Ð DÒ¿äÔ¿àÖ¿ÜŸÃÐ¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÌÇàèã¿Xð' Dò' Hô' Lö' PРHÒ  “* Ò'¿ÄРDÒ HÐ èÒ`@tžÐ'¿äРDÒ HÐ ìÒ` @t—Ð'¿àпäÒ¿à@tŒÐ'¿Üпܓ: •2`’ ‘:`Ð'¿Øà Dâ DпÄÒ¿ä@t–РLÒ ìÔ`ÿÿ^À'¿ìÀ'¿èРHÒ¿èÐ €¢@€€aп蒑*`Ò P ÒÒ'¿¼À'¿ÌÀ'¿ÈпÌÒ¿Ä€¢ €€HÀ'¿¸À'¿ÐпÐÒ¿à€¢ €€(пìÒ¿Ð ’‘*`Ò L ÒпȒ@Ò'¿ÀÀ'¿ÔпÔҿ䀢 €€¿ÀÒÖ @” àÿÖ¿¸”À Ô'¿¸’`Ò"пԒ Ò'¿Ô¿ÿíпВ Ò'¿Ð¿ÿÕ ¿¼âп¸Ô¿Ø’  Ò¿Ü@t-’ Ð,@¢`â$п̒ Ò'¿ÌпÈÒ¿ä Ð'¿È¿ÿµÐ¿ìÒ¿à Ð'¿ìÐ¿è’ Ò'¿è¿ÿ›Çàèã¿ð' Dò' Hô' Lö' PØ DÚ DРL’ Ô P– Ø ìÚ`@_Ò DÔ DРHÖ  —* РPÒ`ìÔ ÿþÙÇàèã¿€ð' Dò' Hô' Lö' PРHÒ  “* Ò'¿äÒ DÔ Dп䘗+ РLÒ`ìÔ ÿþÃÀ'¿ìРHÒ¿ìÐ €¢@€€-п쒑*`Ò P âп쒑*`Ò L ठÀ'¿èпèҿ䀢 €€Ò `ÿÔ ’  ÿ ’•:` Ð,@¢`¤   Ð¿è’ Ò'¿è¿ÿêÐ¿ì’ Ò'¿ì¿ÿÏÇàèã¿€ð' Dò' Hô' Lö' PРHÒ  “* Ò'¿àÒ DÔ DÐ¿à˜—+ РLÒ`ìÔ ÿþyÀ'¿ìÀ'¿èРHÒ¿èÐ €¢@€€=п蒑*`Ò P äп쒑*`Ò L àп쒑*`Ò L â ¦ À'¿äпäÒ¿à€¢ €€Ò `ÿÔ ’  ÿ Ô @’  ÿ Ô `’  ÿ ’•:` Ð,€¤ ¦à  ¢`Ð¿ä’ Ò'¿ä¿ÿãÐ¿ì’ Ò'¿ìÐ¿è’ Ò'¿è¿ÿ¿Çàèã¿pð' Dò' Hô' Lö' PРHÒ  “* Ò'¿àÒ LüÒ DÔ`ì’ Ô DÖ¿à˜ —+ Ô ÿþÒ DÐ`À”“* ’@‘*`"@Ð'¿ÔРDÒ À “* Ò'¿ÐÀ'¿ìÀ'¿èРHÒ¿èÐ €¢@€€Ð¿è’‘*`Ò P èп쒑*`Ò L àп쒑*`Ò L â п쒑*`Ò L ä?üп쒑*`Ò L æ Ò `ÿÔ ’  ÿ Ô @’  ÿ Ô `’  ÿ Ð'¿ÜÒ € `ÿÔ  ’  ÿ Ô À’  ÿ Ô à’  ÿ Ô ’  ÿ Ô ’  ÿ Ô @’  ÿ Ô `’  ÿ Ð'¿ØпØÒ¿Ø Ð'¿ØÒ € `ÿÔ  ’  ÿ Ô À’  ÿ Ô à’  ÿ Ò¿Ø@Ð'¿ØпÜÒ¿Ô@rǪпØÒ¿Ð@rÂ’@Ò'¿ÜÐ¿Ü  “:  Ð-¨   ¢`¤ ¦àпà’?þÒ'¿äп䀢 €€SÒ `ÿÔ ’  ÿ Ô @’  ÿ Ô `’  ÿ Ð'¿ÜÒ € `ÿÔ  ’  ÿ Ô À’  ÿ Ô à’  ÿ Ô ?ÿ’  ÿ Ô ’  ÿ Ô ÿ’  ÿ Ô `’  ÿ Ð'¿ØпØÒ¿Ø Ð'¿ØÒ ¿ÿ `ÿÔ  ’  ÿ Ô ÿÿ’  ÿ Ô à’  ÿ Ò¿Ø@Ð'¿ØпÜÒ¿Ô@rrªÐ¿ØÒ¿Ð@rm’@Ò'¿ÜÐ¿Ü  “:  Ð-¨   ¢`¤ ¦àпä’?ÿÒ'¿ä¿ÿ«Ò `ÿÔ ’  ÿ Ô @’  ÿ Ô `’  ÿ Ð'¿ÜÒ € `ÿÔ  ’  ÿ Ô À’  ÿ Ô à’  ÿ Ô ?ÿ’  ÿ Ô ’  ÿ Ô ÿ’  ÿ Ô `’  ÿ Ð'¿ØпØÒ¿Ø Ð'¿ØÒ ¿ÿ `ÿÔ  ’  ÿ Ô ÿÿ’  ÿ Ô à’  ÿ Ò¿Ø@Ð'¿ØпÜÒ¿Ô@r!ªÐ¿ØÒ¿Ð@r’@Ò'¿ÜÐ¿Ü  “: Ò-Ð¿ì’ Ò'¿ìÐ¿è’ Ò'¿è¿þèÇàèã¿hð' Dò' Hô' Lö' PРHÒ  “* Ò'¿äÒ LüÒ DÔ`ì’ Ô DÔ Ö¿äÿüÜРDÒ À “* @’" Ò'¿ØРDÒ À “* Ò'¿ÔÀ'¿ìРHÒ¿ìÐ €¢@€€«Ð¿ì’‘*`Ò P æп쒑*`Ò L àп쒑*`Ò L â?üп쒑*`Ò L ä Ò @ `ÿÔ €’  ÿ Ô ’  ÿ Ð'¿Ð¤ ¢`Ð ’ ÿÒ'¿à  Ò @ `ÿÔ €’  ÿ Ô ’  ÿ Ð'¿ÈпÐÒ¿à" Ò¿Ð Ò¿È Ð'¿ÜпàÒ¿Ø@q¦¨Ð¿ÜÒ¿Ô@q¡’Ò'¿àÐ¿à  “:  Ð,À¦àпÐÐ'¿ÌпÈÐ'¿Ðпä’?þÒ'¿èп耢 €€4Ð ’ ÿÒ'¿à  ¢`¤ Ò @ `ÿÔ €’  ÿ Ô ’  ÿ Ð'¿ÈпÐÒ¿à" Ò¿Ì Ò¿È Ð'¿ÜпàÒ¿Ø@qp¨Ð¿ÜÒ¿Ô@qk’Ò'¿àÐ¿à  “:  Ð,À¦àпÐÐ'¿ÌпÈÐ'¿Ðпè’?ÿÒ'¿è¿ÿÊÐ ’ ÿÒ'¿àпÐÒ¿à" Ò¿Ì Ò¿Ð Ð'¿ÜпàÒ¿Ø@qJ¨Ð¿ÜÒ¿Ô@qE’Ò'¿àÐ¿à  “: Ò,ÀÐ¿ì’ Ò'¿ì¿ÿQÇàèã¿€ð' D Ð'¿àРDÒ Ö@РD’ ” 4ŸÂÀÐ'¿ìРDÒ¿ìÒ"!dпì~’£€Ò"п쒠PÒ" пìÀ" РDÒ ¼€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€À'¿èРDÒ DÒ'¿äРDÒ¿èÐ <€¢@€€¦Ð¿äÒ DÐ Ò`耢 €%пäÒ DÐ Ò`쀢 €Ð DÒ À€¢`€Ð¿ìÒ¿è” “*  ’£ØÒ" Ð¿ì’ Ò" € пìÒ¿è” “*  ’£ÌÒ" €tпäÒ ” ‘* Ò DÔ`耢 €Ð¿äÒ DÐ Ò`쀢 € À'¿àпìÒ¿è” “*  €’ <Ò" €YпäÒ ” ‘* Ò DÔ`耢 €'пäÒ ” ‘* Ò DÔ`쀢 €Ð DÒ À€¢`€Ð¿ìÒ¿è” “*  €’¢ÐÒ" Ð¿ì’ Ò" € пìÒ¿è” “*  €’¡dÒ" €+РDÒ¿äÔ è Ò`@p¢€¢ €Ð DÒ¿äÔ ì Ò` @p˜€¢ € À'¿àпìÒ¿è” “*  ’¡dÒ" € РDÒ &Ð"`РDÒÔ@РDŸÂ€Ð¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿVРDÒ À€¢`€Ð¿à€¢ € РDÒ cÐ"`РDÒÔ`РD’ ŸÂ€Çàèã¿xð' Dò' HРDÒ!lÒ'¿ìРH€¢ € п숒£0Ò" п싒 °Ò" € п쇒 ¤Ò" п쇒£ŒÒ" À'¿èРDÒ¿èÐ ô€¢@€€¨Ð DÒ¿è” “*  Ò øÒ'¿ÜпÜÒ Ò'¿äпÜÒ Ò'¿àРH€¢ €vп䀢 €Ð¿ä€¢ €€Ð DÒ 2Ð"`РDÒпäÐ"`РDÒÔ@РDŸÂ€Ð¿à€¢ €Ð¿à€¢ €€Ð DÒ 2Ð"`РDÒпàÐ"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿ä” “*  Ò L€¢`€Ð DÒ Ö@РD’ ”$ŸÂÀÒ¿ìÔ¿ä– •*à’@ Ð"`LпìÒ¿ä” “* ” РL’ ”$@oÎпìÒ¿à” “*  Ò \€¢`€Ð DÒ Ö@РD’ ”$ŸÂÀÒ¿ìÔ¿à– •*à’@ Ð"`\пìÒ¿à” “* ” Р\’ ”$@o­€Ð¿ä’‘*`’ ,пì–@РD’ Ô¿ä@$Ð¿à’‘*`’ <пì–@РD’ Ô¿à@пìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿTпìÀ" пìÀ" пìÒ DÔ`ÈÔ" $пìÀ" (ÇàèãºXð' Dò' Hô' Lö' PРL€¢ €Ð L€¢ €€Ð DÒ 2Ð"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð H€¢ € РDÒ L” “* ” РX€Ò DÔ L– •*à’@ Ð`hÐ'¿ìп쀢 €Ð DÒ 2Ð"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð PÒ€¢`€ РDÒ Ö@РD’ ”%ŸÂÀÒ PÐ"@РPÒÒ'¿èÀ'¿ä Ð'¿Üп܀¢ €€6пìÒ¿ÜÐ ’ ÿÒ'¿àÐ¿à€¢ € пäÒ¿à €¢!€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿àÿ’Ò'¿à€¢ÿ€€ ¿äÒ” –¾ÈØ¿ßØ*À ’`Ò"¿ÿïпܒ Ò'¿Ü¿ÿÈп䒾ÈÀ*@пäÐ'¿ØÀ'º¼Ð¾È“* ‘:`Ð'¿ÔÀ'¿äп䒾ÈÐ @“* ‘:`€¢ €€4п䒾ÈÐ @“* ‘:`Ò¿Ô€¢ €€¿äÒ– •*à–ºÀغ¼Ø"À ’`Ò"к¼’ Ò'º¼¿ÿé Ò¿Ô‘* Òº¼€¢@€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ðº¼“* Ò'º¼Ð¿Ô’ Ò'¿Ô¿ÿÆпè’$ ’ ”!@nŸÐ H€¢ € € ÿÐ'¿ÐÀ'¿äпäÒ¿Ø€¢ €€<пìÒ¿ä Ò  `ÿÐ'¿àÐ¿à€¢ €Ð¿àҿЀ¢ € пèÒ¿à Ò $•*`‘: €¢ €€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿èÒ¿à” “* Ô¿ä– •*à–ºÀÔÀ Ô" пèÒ¿à ҿ䔾ÈÒ € Ò*$Ð¿ä’ Ò'¿ä¿ÿÁÇàè㿈ð' DРDÒ Ð`Ð'¿ìпìÒ DÔ Ð` ŸÂ€€¢ €° € РDÒ¿ìÔ@Ô"РDÒ¿ìÔ`Ô" ° €Çàèã¿ð' DРD’ ” @€¢ €° € РDÀ" РDÀ" ° €Çàèã¿ð' Dò' Hô' Lö' Pø' TРHÒ‘*`£: РL¢$@ €¤ €  ¢ÿ¤ €¤ €€¤ ¡< ¿ÿù€¤  €Ð DÒ Ð@’ Ò" РDÒ Ð@Ò DÔÐ` ŸÂ€Ò P•* РP–Ð ä™* —; РDÒ@ ” @»€¢ €° €œ€¤ € РD’”@­€¢ €° €Ž¨ ¦ €¤à?€€r®’•*`’ T€ Ò “* Ô H@ Ò‘*`¡: €¢ €¨ €[€¥ €€Ò TРTÔ $ð‘* •: РDÒcÀ@~€¢ €° €_¨?ð¿ÿ뢀¤ €  ¢ÿ¤ ¡< €¢ €€¤ ¿ÿø€¤  €Ð DÒ Ð@’ Ò" РDÒ Ð@Ò DÔÐ` ŸÂ€«- ª@Ò T•* РT–Ð ä™* —; РDÒ@ ” @E€¢ €° €&РD’”@:€¢ €° €¨ ¦à¿ÿ€¥ €Ò TРTÔ $‘* •: РDÒ@@$€¢ €° €° €Çàè㿈ð' Dò' HРDÿÿ €¢ €° €NРDÒ” ÿÔ*@’`Ò"Ò DРDÒ DÔ`’¿ÿ” Ô" €¢ € РDÿþÒ€¢ €° €5РDÒÔ K–¿ÐÖ*@’`Ò"Ò DРDÒ DÔ`’¿ÿ” Ô" €¢ € РDÿþ¸€¢ €° €À'¿ìРDÒ Ð¿ìÒ`ô€¢ €€ РDÒ¿ì” “*  À" Ð¿ì’ Ò'¿ì¿ÿî° €Çàèã¿Pð' Dò' HРDÒ!lÒ'¿ìРDÒ Ð@Ð'¿ÀРDÒ Ð`Ð'¿ÄпìÒ Ò'¿ÈÒ Ò'¿ÌÒ Ò'¿ÐÒ Ò'¿ÔÒ Ò'¿ØÐ Ð'¿ÜРDÐ'¿àРDÒ È€¢`€Ð¿ìÒ $€¢`€ ¿ÀÒ¿ìÒ`(ÿÿ|€¢ €° €ˆÀ'¿¼Ð DÒ¿¼Ð!€¢@€€GРDÒ¿¼” “*  Ò!Ò'¿¸Ð DÒ¿¸” “*  Ò øÒ'¿´¿ÀÒ¿¼” “* Ô H’@ Ô¿¸– •*à–¿À”À Ö¿ìØ¿´Ú ˜ ›+ –À Ø¿ìÚ¿´Ä`š…+`˜Ò@Ô Öà,Ø <ÿþe€¢ €° €Mп¸’‘*`’¿À@Ò¿¼” “* Ô H’@ Ô@Ò€•*`“: Ò" п¼’ Ò'¿¼¿ÿµÐ DÒ Ð¿ÀÐ"@РDÒ Ð¿ÄÐ"`пìÒ¿ÈÒ" Ò¿ÌÒ" Ò¿ÐÒ" Ò¿ÔÒ" Ò¿ØÒ" Ò¿ÜÒ" РDÒ È€¢`€Ð¿ìÒ $€¢`€Ð¿ìÒ DÔ`ÈÔ" $Ò¿ìпìÒ¿ìÔ`(’ Ò" (пìÒ¿ìÔ`(’  Ò" (Ò¿ìпìÒ¿ìÔ`$’¿ÿÒ" $° €Çàèã¿`ð' DРDÒ!lÒ'¿ìРDÒ Ð@Ð'¿ÀРDÒ Ð`Ð'¿ÄпìÒ Ò'¿ÈÒ Ò'¿ÌÒ Ò'¿ÐÒ Ò'¿ÔÒ Ò'¿ØÐ Ð'¿ÜРDÐ'¿à’¿À ÿýÜ€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ð¿ÀÐ"@РDÒ Ð¿ÄÐ"`пìÒ¿ÈÒ" Ò¿ÌÒ" Ò¿ÐÒ" Ò¿ÔÒ" Ò¿ØÒ" Ò¿ÜÒ" Çàèã¿ð' Dò' Hô' Lö' Pø' TРHÒ‘*`¡: РL $€¤ €  ¢ €¤ €€¢`¡< ¿ÿù€¤` € РDÒ Ð"`РDÒÔ@РDŸÂ€“* Ô P@ ’‘*`Ò P ’•*`Ö P’€ Ô@’ Ò"¦ ¤ €¤ ?€€_®’•*`’ T€ Ò “* Ô H@ Ò‘*`¡: €¢ €¦à€H€¤à€€#ÀÒ T ’#ÀÔ T@ ’#ÀÔ T’@ Ô@’ Ò"¦ÿð¿ÿ €  ¢ ¡< €¢ €€¢`¿ÿø€¤` € РDÒ Ð"`РDÒÔ@РDŸÂ€‘,à’ “* Ô T@ “,à@’‘*`Ò T “,à”@’ •*`Ö T’€ Ô@’ Ò"¦ ¤ ¿ÿ €¤à€Ò TРTÒ TÔ@’ Ò"Çàèã¿€ð' Dò' HРDÒ!lÒ'¿ìРDÒ È€¢`€%пìÒ $€¢`€À'¿äРDÒ¿äÐ ô€¢@€€ пìÒ¿ä” “*  À" Ð¿ä’ Ò'¿ä¿ÿïпìÒ DÔ`ÈÔ" $Ò¿ìпìÒ¿ìÔ`$’¿ÿÒ" $À'¿èРDÒ¿èÐ!€¢@€€AРDÒ¿è” “*  Ò!Ò'¿äРDÒ¿ä” “*  Ò øÒ'¿àп蒑*`Ô H’ пìÔ¿ä– ™*à” Ð¿ìÖ¿àØà– ™*à– Ð¿ìØ¿àÚ ˜ ›+ ˜ РDÒ@Ô ÖàLØ \ÿþúпìÒ¿ä” “*  Ò¿è” “* Ô H’@ Ô@Ò€•*`“: Ò" Ð¿è’ Ò'¿è¿ÿ»° €Çàèã·@ð' Dò' Hô' L’¿È ’ ” !@j¾’»À ’ ”$@j¸À'·¨Ð·¨€¢!€€ з¨’‘*`’·¸”?ÿÔ"@з¨’ Ò'·¨¿ÿñ$Ò L ’ Ò"?ÿÐ'·´æ²bÐ'· À'·¨Ð·¨€¢!€€#з¨’‘*`Ò L Ò€¢`€Ð·¨’‘*`Ò L Òз €¢@€ з¨’‘*`Ò L ÒÒ'· Ð·¨Ð'·´Ð·¨’ Ò'·¨¿ÿÛ?ÿÐ'·°æ²bÐ'· À'·¨Ð·¨€¢!€€(з¨’‘*`Ò L Ò€¢`€Ð·¨’‘*`Ò L Òз €¢@€Ð·¨Ò·´€¢ € з¨’‘*`Ò L ÒÒ'· Ð·¨Ð'·°Ð·¨’ Ò'·¨¿ÿÖз°€¢ €€ƒÐ·´’‘*`Ò L Ò·´” “* Ô L’@ Ô·°– •*àÖ L”€ Ò@Ô€’@ Ò"з°’‘*`Ò L À"з´’‘*`’»Àз´’‘*`’»ÀÔ·´– •*à–»ÀÔÀ – Ö"@з´’‘*`’·¸Ð@€¢ €€Ð·´’‘*`’·¸Ð@Ð'·´Ð·´’‘*`’»Àз´’‘*`’»ÀÔ·´– •*à–»ÀÔÀ – Ö"@¿ÿáз´’‘*`’·¸Ô·°Ô"@з°’‘*`’»Àз°’‘*`’»ÀÔ·°– •*à–»ÀÔÀ – Ö"@з°’‘*`’·¸Ð@€¢ €€Ð·°’‘*`’·¸Ð@Ð'·°Ð·°’‘*`’»Àз°’‘*`’»ÀÔ·°– •*à–»ÀÔÀ – Ö"@¿ÿá¿ÿÀ'·¨Ð·¨€¢!€€6з¨’‘*`’»ÀÐ@€¢ €)з¨’‘*`’»ÀÐ@€¢ € РDÒ 'Ð"`РDÒÔ@РDŸÂ€Ð·¨’‘*`’»ÀÐ@’¿Èз¨’‘*`’»ÀÐ@’¿ÈÔ·¨– •*à–»ÀÔÀ –¿ÈÔ À – Ö*@з¨’ Ò'·¨¿ÿÈ Ð'·¨Ð·¨€¢ €€Hз¨’¿ÈÔ @  ÿ€¢ €€:з¨’?þÒ'·¤Ð·¤’¿ÈÔ @  ÿ€¢ €€Ð·¤’?ÿÒ'·¤¿ÿôз¨’¿ÈÔ·¨–¿ÈÔ À –¿þÖ*@Ò·¨ÿ’¿ÈÔ·¨¿ÿ’¿ÈÖ·¨”ÿÿ–¿ÈÔ À – Ö*@Ò·¤`’¿ÈÖ·¤”à–¿ÈÔ À – Ö*@з¤’¿Èз¤’¿ÈÔ·¤–¿ÈÔ À –¿ÿÖ*@¿ÿÁз¨’?ÿÒ'·¨¿ÿ¶Ð·¨’¿ÈÔ @  ÿ€¢ €€Ð·¨’?ÿÒ'·¨¿ÿôз¨’¿Èз¨’¿ÈÔ·¨–¿ÈÔ À –¿ÿÖ*@’¿ÈРH” @i À'·¬ Ð'·¨Ð·¨€¢ €€$À'·¤Ð·¤€¢ ÿ€€Ð·¤’‘*`’»ÀÐ@Ò·¨€¢ € РHÒ·¬ Ò·§Ò* з¬’ Ò'·¬Ð·¤’ Ò'·¤¿ÿæз¨’ Ò'·¨¿ÿÚРHÀ"!Çàèã¿Xð' DРDÒ!lÒ'¿ì’¿È ’ ” @hÙ’¿¸ ’ ” @hÓÀ'¿èРDÒ¿èÐ ô€¢@€€hРDÒ¿è” “*  Ò øÒ'¿ÜпÜÒ Ò'¿äпÜÒ Ò'¿àп䒑*`’¿ÈÐ@€¢ €$п䒑*`’ XРD’ Ò'¿ØпØÒ€¢`€Ð D@ÀÒ¿ØÐ"@Ò¿ØпìÔ¿ä– ™*à” Ð DÒ@Ô LÿýÓп䒑*`’¿È” Ô"@Ð¿à’‘*`’¿¸Ð@€¢ €$Ð¿à’‘*`’ hРD’ Ò'¿ØпØÒ€¢`€Ð D@–Ò¿ØÐ"@Ò¿ØпìÔ¿à– ™*à” Ð DÒ@Ô \ÿý©Ð¿à’‘*`’¿¸” Ô"@Ð¿è’ Ò'¿è¿ÿ”Çàè㿈ð' DРDÒ Ö@РD’ ” lŸÂÀÐ'¿ìРDÒ¿ìÒ"!lп샒¢èÒ"À'¿èп耢 €€Ð¿ìÒ¿è” “*  Ò¿ìÔ¿è– •*à’@ À"`<À" ,пìÒ¿è” “*  Ò¿ìÔ¿è– •*à’@ À"`\À" LÐ¿è’ Ò'¿è¿ÿßÇàè㿈¤ ¢¦è  €¤`€ Р Ò (Ð"`Р ÒÔ@Р ŸÂ€’ ‘*@’?ÿ¦ À ¨’ "@§,ÀР¦À€¥ €€6‘<à’ ÿÒ'¿ìЀҿïÒ* Ð$€Ò ÿ’Ò$ €¢`€ ÿù¦€¢ €° €#п쀢 ÿ€Ð€À* Ð$€Ò ÿ’Ò$ €¢`€ ÿùŽ€¢ €° € §,à¨?ø¿ÿÉæ$ è$  ° €Çàèã¿xð' Dò' HРDÒ!lÒ'¿ìпìÒ DÒ" пìÒ HÒ" РDÒ!<”`€  `?ÿÐ'¿èРDÒ!D€¢`€Ð¿è€¢ €Ð¿ìŽ’ DÒ" €Ð¿ìŽ’£ Ò" €Ð¿è€¢ €Ð¿ì’¢hÒ" €Ð¿ì’ (Ò" пìÒ @€¢`€ РDÒ Ö@РD’ ”#èŸÂÀÒ¿ìÐ"`@РH€¢ €Ð¿ì‘’¡ Ò" €Ð¿ì‘’ ˆÒ" À'¿äРDÒ¿äÐ ô€¢@€€sРDÒ¿ä” “*  Ò øÒ'¿ÜпìÒ¿ä” “*  À" $п耢 €Ð DÒ!D€¢`€€VпÜÒ Ò'¿à€Ð¿ìÒ¿ÜÔ`Ô'¿àÔ" 4РH€¢ €=Ð¿à€¢ €Ð¿à€¢ €€Ð DÒ 2Ð"`РDÒпàÐ"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿à” “*  Ò \€¢`€Ð DÒ Ö@РD’ ”$ŸÂÀÒ¿ìÔ¿à– •*à’@ Ð"`\пìÒ¿à” “* ” Р\’ ”$@g€ Ð¿à’‘*`’ Lпì–@РDÒ¿èÔ¿àÿ÷‰Ð¿ä’ Ò'¿ä¿ÿ‰Ð¿ìÀ" 8пìÀ" <пìÀ" пìÀ" пìÒ DÔ`ÈÔ" DпìÀ" HÇàè㿈ð' DРDÒ Ð`Ð'¿ìпìÒ DÔ Ð` ŸÂ€€¢ €Ð DÒ Ð@’ Ò" РDÒ Ð@Ò DÔÐ` ŸÂ€Ð DÒ¿ìÔ@Ô" РDÒ¿ìÔ`Ô" Çàèã¿ð' DРD’ ” @›Ð DÀ" РDÀ" Çàèã¿ð' Dò' Hô' LРDÒ €¢`€€Ð L€¢ €€Ð HÒ ‘*`“: РD” @{РH’ Ò' HРL’?ÿÒ' L¿ÿìÇàèã¿ð' DРDÒ 8€¢`€9РDà 8¢ ¡< €¢ €€¢`¿ÿø€¤`€Ð DÒ Ð@’ (Ò" РDÒ Ð@Ò DÔÐ` ŸÂ€Ò D•,`РDÒ`4@€¤`€Ò DРDÒ`8”@>РDÀ" 8Ò DÔ DРDÒ`@Ô <ÿÿ¢Ð DÀ" <Çàè㿈ð' Dò' HРDÿÿ¼Ð DÒ €¢`€.РDÿÿƒÒ D`Ò” ÿÔ*@’`Ò"Ò DРDÒ DÔ`’¿ÿ” Ô" €¢ €Ð DÿÿIÒ D`ÒÔ K–¿ÐÖ*@’`Ò"Ò DРDÒ DÔ`’¿ÿ” Ô" €¢ €Ð Dÿÿ4РDÒ Ða<€¢ €À'¿ìРDÒ Ð¿ìÒ`ô€¢ €€ РDÒ¿ì” “*  À" $Ð¿ì’ Ò'¿ì¿ÿî€Ð DÀ" 8РDÀ" <Çàèã¿xð' Dò' HРDÒ!lÒ'¿ìРDÒ!HÒ'¿àпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" РDÒ È€¢`€ пìÒ D€¢`€Ò¿ìпìÒ`Hÿÿ†À'¿èРDÒ¿èÐ!€¢@€€Zп蒑*`Ò H ÒÒ'¿ÜРDÒ¿è” “*  Ò!Ò'¿äРDÒ¿ä” “*  Ò øÒ'¿ØпÜÒ‘*`£: пà£<@пìÒ¿ä” “*  Ò $ $@ пìÒ¿ä” “*  â" $¢€¤ €  ¢ÿ¤ €¤ €€¤ ¡< ¿ÿù€¤  € РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿ØпìÒ`”@¶€¤ €Ð¿ì’”@XÐ¿è’ Ò'¿è¿ÿ¢Ò DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" РDÒ È€¢`€Ð¿ìÒ D€¢`€Ð¿ìÒ DÔ`ÈÔ" DÒ¿ìпìÒ¿ìÔ`H’ Ò" HпìÒ¿ìÔ`H’  Ò" HÒ¿ìпìÒ¿ìÔ`D’¿ÿÒ" D° €Çàèã¿€ð' Dò' HРDÒ!lÒ'¿ìРDÒ!@Ò'¿èРDÒ!HÒ'¿äпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" РDÒ È€¢`€ пìÒ D€¢`€Ò¿ìпìÒ`HÿþÑРHÒÒ'¿à¦ РDè!<п耥€€g®’•*`’ T€ Ò “* Ô¿à@ Ò‘*`¡: €¢ €¦à€P€¤ €  пä¡<¢< €Ð¿ä¡<¢€¤ €¦à€>пìÒ 8€¢`€Ð¿ìÿþW€¤à€€ Ò¿ìпìÒ`4” ð@¦ÿð¿ÿô¤ ¡< €¢ €€¤ ¿ÿø€¤  € РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿ì‘,à”пìÒ`4@îп쒔@“¦ ¨ ¿ÿ—€¤à€Ò¿ìпìÒ¿ìÔ`8’ Ò" 8Ò¿ìÐ`8’£ÿ€¢ €Ð¿ìÿþ Ò DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" РDÒ È€¢`€Ð¿ìÒ D€¢`€Ð¿ìÒ DÔ`ÈÔ" DÒ¿ìпìÒ¿ìÔ`H’ Ò" HпìÒ¿ìÔ`H’  Ò" HÒ¿ìпìÒ¿ìÔ`D’¿ÿÒ" D° €Çàèã¿€ð' Dò' HРDÒ!lÒ'¿ìРDÒ!HÒ'¿äпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" РDÒ È€¢`€ пìÒ D€¢`€Ò¿ìпìÒ`HÿýýÀ'¿èРDÒ¿èÐ!€¢@€€Ð¿è’‘*`Ò H ÒÒ'¿àпàÒ‘*`¡: пä“<Ð¿ì” @Ð¿è’ Ò'¿è¿ÿäÒ DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" РDÒ È€¢`€Ð¿ìÒ D€¢`€Ð¿ìÒ DÔ`ÈÔ" DÒ¿ìпìÒ¿ìÔ`H’ Ò" HпìÒ¿ìÔ`H’  Ò" HÒ¿ìпìÒ¿ìÔ`D’¿ÿÒ" D° €Çàèã¾pð' Dò' HРDÒ!lÒ'¿ìРDÒ!@Ò'¿ÜРDÒ!HÒ'¿ØпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" РDÒ È€¢`€ пìÒ D€¢`€Ò¿ìпìÒ`HÿýŠÐ HÒÒ'¿ÔÀ'¿èРDä!<п܀¤€€€ ®’•*`’ T€ Ò “* Ô¿Ô@ Ò‘*`¡: €¤ €  пء<“* ¾Ðà" €¤ €ä'¿è¤ ¿ÿÞ¢ À'¿àпìÒ¿ìÐ @Ò`< Ð'¿äРDä!<п܀¤€€€g“* ¾Ðà €¢ €¢`€Y€¤`€Ð¿è€¤€€€€Ð¿ìÿüöÒ¿ìпìÒ`4” ð@µ¢ðпìÒ¿äÔ¿àÿüÆпìÒ @Ò'¿äÀ'¿à¿ÿ․ € ¿àÒÖ¿ä”@ –˜ àØ*€’`Ò"€*пìÿüÓÒ¿ì‘,`” пìÒ`4@‘®’•*`’ T€ Ò “* Ô¿Ô@ Ò•*`‘: ’: ¡2`п쒔 @'пìÒ¿äÔ¿àÿüпìÒ @Ò'¿äÀ'¿à¢ ¤ ¿ÿ—€¤`€Ð¿à€¢ €€Ò¿ìпìÒ¿ìÔ`8’ Ò" 8пìÒ¿ìÔ`<Ò¿à”€ Ô" <Ò¿ìÐ`8’£ÿ€¢ € пìÒ <€¢c©€€Ð¿ìÿü…Ò DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" РDÒ È€¢`€Ð¿ìÒ D€¢`€Ð¿ìÒ DÔ`ÈÔ" DÒ¿ìпìÒ¿ìÔ`H’ Ò" HпìÒ¿ìÔ`H’  Ò" HÒ¿ìпìÒ¿ìÔ`D’¿ÿÒ" D° €Çàè㿈ð' DРDÒ!lÒ'¿ìпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" пìÿüEпìÿüÒ DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" Çàèã¿hð' DРDÒ!lÒ'¿ìпìÿü.РDÒ!<”`€  `?ÿÐ'¿è’¿È ’ ” @b¹À'¿äРDÒ¿äÐ ô€¢@€€XРDÒ¿ä” “*  Ò øÒ'¿Üп耢 €Ð DÒ!D€¢`€€AпÜÒ Ò'¿à€Ð¿ÜÒ Ò'¿àÐ¿à’‘*`’¿ÈÐ@€¢ €1п耢 € Ð¿à’‘*`’ XРD’ Ò'¿Ø€ Ð¿à’‘*`’ hРD’ Ò'¿ØпØÒ€¢`€Ð D@ ŒÒ¿ØÐ"@Ò¿ØпìÔ¿à– ™*à” Ð DÒ@Ô \ÿ÷ŸÐ¿à’‘*`’¿È” Ô"@Ð¿ä’ Ò'¿ä¿ÿ¤Çàè㿈ð' DРDÒ Ö@РD’ ” lŸÂÀÐ'¿ìРDÒ¿ìÒ"!lп쌒¡ Ò"À'¿èп耢 €€Ð¿ìÒ¿è” “*  À" LпìÒ¿è” “*  À" \Ð¿è’ Ò'¿è¿ÿëпìÀ" @Çàè㿈¤ ¢¦è €¤`€ Р Ò (Ð"`Р ÒÔ@Р ŸÂ€Ð  €¢ €€=’ ‘*@’?ÿ¦ À ¨’ "@§,ÀР¦À€¥ €€,‘<à’ ÿÒ'¿ì ÒÔ¿ïÔ*@’`Ò"Ò ÿ’Ò$ €¢`€ÿûп쀢 ÿ€ ÒÀ*@’`Ò"Ò ÿ’Ò$ €¢`€ÿúî§,à¨?ø¿ÿÓæ$ è$ Çàè㿈¤ ¢Ð  €¢ €’‘*`”“* €Ô \@ ’‘*`”“* €Ô \@ ”“* –•*à’€ Ö`\’€ Ô@’ Ò"€“* € Ò LÒ'¿ìÒ¿ì•* пì–Ð ä™* —; Ò@ ” ÿÿxÇàèã¿hð' DРDÒ!hÒ'¿ìÀ'¿èРDÒ DÒ'¿ÜРDÒ¿èÐ <€¢@€€1пÜÒ Ò'¿äп䀢 €Ð¿ä€¢ € РDÒ¿ä” “*  Ò H€¢`€€Ð DÒ 4Ð"`РDÒпäÐ"`РDÒÔ@РDŸÂ€Ð DÒ¿ä” “*  Ò HÒ'¿ØÒ DÐ`Ä€¢ €D€¢  €€¢ €„€åпìÒ¿ä” “*  Ò €¢`€Ð DÒ Ö@РD’ ”!ŸÂÀÒ¿ìÔ¿ä– •*à’@ Ð"` пìÒ¿ä” “*  Ò Ò'¿ÔÀ'¿àÐ¿à€¢ ?€€Ð¿à’‘*`Ò¿Ô Ò¿ØÔ¿à– •*àÒ@ •*`“2 •*`Ô"Ð¿à’ Ò'¿à¿ÿ逷пìÒ¿ä” “*  Ò €¢`€Ð DÒ Ö@РD’ ”!ŸÂÀÒ¿ìÔ¿ä– •*à’@ Ð"` пìÒ¿ä” “*  Ò Ò'¿ÔÀ'¿àÐ¿à€¢ ?€€!Ð¿à’‘*`Ò¿Ô  пØÒ¿à” “* Ð “* ‘2`­Ô¿à– •*à–cp’€ Ô@—* “:à@`Ð’$‘:` Ð$Ð¿à’ Ò'¿à¿ÿÝ€qпìÒ¿ä” “*  Ò €¢`€Ð DÒ Ö@РD’ ”!ŸÂÀÒ¿ìÔ¿ä– •*à’@ Ð"` пìÒ¿ä” “*  Ò Ò'¿ÐÀ'¿àÀ'¿Ìп̀¢ €€=À'¿ÈпȀ¢ €€1Ð¿à’‘*`Ò¿Ð Ò¿ØÔ¿à– •*àÒ@ •*`“2 Ò'¿ðÍ¿ð… ­Ô¿Ì– •*à–cð’€ É@… ‰D­Ô¿È– •*à–cð’€ É@… ‰D®É`0… ‰D®É`8…¡ ‰ ÂÉ"Ð¿à’ Ò'¿àпȒ Ò'¿È¿ÿÍп̒ Ò'¿Ì¿ÿÁ€Ð DÒ 0Ð"`РDÒÔ@РDŸÂ€€Ð¿è’ Ò'¿èпܒ TÒ'¿Ü¿þËÇàèã¾xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!hÒ'¿ìпìÒ Ò'¿èпìÒ HÔ`’ •*` Ò Ò'¿äРT’‘*`Ò L@Ð' LÀ'¾ÜоÜÒ \€¢ €€Š¾à” €¢ €€<– ™*àÚ L– ØÀÖ X’ Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` Ø @– ÿ–ÿ€Ö"’` ” ¿ÿþàÒ¿èŸÂ@оܒ‘*`Ò P¦ ¤ €¤ ?€€2“* Ô¿ä@ â“* ¾àà €¤ €  ‘<` €¤€ ’@_Ê €    €‘<` €¤€ ’@_º €  “* à4À ¤ ¿ÿÍоܒ Ò'¾ÜРX’ Ò' X¿ÿsÇàèã¾xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!hÒ'¿ìпìÒ Ò'¿èпìÒ HÔ`’ •*` Ò Ò'¿äРT’‘*`Ò L@Ð' LÀ'¾ÜоÜÒ \€¢ €€‹¾à” €¢ €€T– ™*àÚ L– ØÀÖ X’ Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` Ø @– ÿ˜ÿ€Ø'¿ðË¿ð… …Å"’` ” ¿ÿ«¾àÒ¿èŸÂ@Ծܖ •*àÖ P’€  €¢ ?€€–•*à–¾à˜›+ Ä¿ä˜@ÇÀ É… É$–•*à®Éà@‡ ˆ$‹ #Ë'¿ðÖ¿ð˜ ?ÿð– Ö2@  ¿ÿäоܒ Ò'¾ÜРX’ Ò' X¿ÿrÇàè㿈ð' DРDÒ Ö@РD’ ” 0ŸÂÀÐ'¿ìРDÒ¿ìÒ"!hп쒒¡ÈÒ"Ò DÐ`Ä€¢ €€¢  €€¢ €€ п쓒¢ÐÒ" п왒 DÒ" €"п쓒¢ÐÒ" п앒¡ÌÒ" €Ð¿ì”’¡„Ò" п엒¡lÒ" €Ð DÒ 0Ð"`РDÒÔ@РDŸÂ€€À'¿èп耢 €€Ð¿ìÒ¿è” “*  À" пìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿëÇàèã¿8ð' DРDÐ'¿  Ð'¿œÐ¿œ€¢ €€êп ’ Ô¿ ’@ ÐÒ@ Ð'¿ìп ’ Ô¿ ’@ ÐÒ@" Ð'¿Ð Ò¿  ’ Ô¿ ’@ ÐÒ@ Ð'¿è Ò¿  ’ Ô¿ ’@ ÐÒ@" Ð'¿Ô Ò¿  ’ Ô¿ ’@ ÐÒ@ Ð'¿ä Ò¿  ’ Ô¿ ’@ ÐÒ@" Ð'¿Ø Ò¿  ’ Ô¿ ’@ ÐÒ@ Ð'¿à Ò¿  ’ Ô¿ ’@ ÐÒ@" Ð'¿ÜпìÒ¿à Ð'¿ÌпìÒ¿à" Ð'¿ÀпèÒ¿ä Ð'¿ÈпèÒ¿ä" Ð'¿Äп Ò¿ÌÔ¿È’@ Ò" Ò¿  Ò¿ÌÔ¿È’"@ Ò"пÄÒ¿À ’•*`”€“* ’"@ •*`”€‘: Ð'¿¼ Ò¿  Ò¿ÀÔ¿¼’@ Ò" Ò¿  Ò¿ÀÔ¿¼’"@ Ò"пÜÒ¿Ø Ð'¿ÌпØÒ¿Ô Ð'¿ÈпÔÒ¿Ð Ð'¿ÄпÌÒ¿Ä" ”“* ’@•*`”€‘* “: Ò'¿¬Ð¿Ì”“* ’@•*`”"€“* ’"@‘:`Ò¿¬ Ð'¿¸Ð¿Ä”“* ’@•*`”€“* ’"@‘*`“: п¬’@Ò'¿°Ð¿È’•*`”€“* ’"@ •*`”€‘: Ð'¿´Ð¿ÐÒ¿´ Ð'¿¨Ð¿ÐÒ¿´" Ð'¿¤ Ò¿  Ò¿¤Ô¿¸’@ Ò" Ò¿  Ò¿¤Ô¿¸’"@ Ò" Ò¿  Ò¿¨Ô¿°’@ Ò" Ò¿  Ò¿¨Ô¿°’"@ Ò"п ’ Ò'¿ Ð¿œ’?ÿÒ'¿œ¿ÿРDÐ'¿  Ð'¿œÐ¿œ€¢ €€êп ’ àÔ¿ ’@ ÐÒ@ Ð'¿ìп ’ àÔ¿ ’@ ÐÒ@" Ð'¿Ð Ò¿  ’ ÀÔ¿ ’@ ÐÒ@ Ð'¿è Ò¿  ’ ÀÔ¿ ’@ ÐÒ@" Ð'¿Ô @Ò¿  ’  Ô¿ ’@ ÐÒ@ Ð'¿ä @Ò¿  ’  Ô¿ ’@ ÐÒ@" Ð'¿Ø `Ò¿  ’ €Ô¿ ’@ ÐÒ@ Ð'¿à `Ò¿  ’ €Ô¿ ’@ ÐÒ@" Ð'¿ÜпìÒ¿à Ð'¿ÌпìÒ¿à" Ð'¿ÀпèÒ¿ä Ð'¿ÈпèÒ¿ä" Ð'¿Äп Ò¿ÌÔ¿È’@ Ò" €Ò¿  Ò¿ÌÔ¿È’"@ Ò"пÄÒ¿À ’•*`”€“* ’"@ •*`”€‘: Ð'¿¼ @Ò¿  Ò¿ÀÔ¿¼’@ Ò" ÀÒ¿  Ò¿ÀÔ¿¼’"@ Ò"пÜÒ¿Ø Ð'¿ÌпØÒ¿Ô Ð'¿ÈпÔÒ¿Ð Ð'¿ÄпÌÒ¿Ä" ”“* ’@•*`”€‘* “: Ò'¿¬Ð¿Ì”“* ’@•*`”"€“* ’"@‘:`Ò¿¬ Ð'¿¸Ð¿Ä”“* ’@•*`”€“* ’"@‘*`“: п¬’@Ò'¿°Ð¿È’•*`”€“* ’"@ •*`”€‘: Ð'¿´Ð¿ÐÒ¿´ Ð'¿¨Ð¿ÐÒ¿´" Ð'¿¤  Ò¿  Ò¿¤Ô¿¸’@ Ò" `Ò¿  Ò¿¤Ô¿¸’"@ Ò" Ò¿  Ò¿¨Ô¿°’@ Ò" àÒ¿  Ò¿¨Ô¿°’"@ Ò"п ’ Ò'¿ Ð¿œ’?ÿÒ'¿œ¿ÿÇàèã¿8ð' DРDÐ'¿  Ð'¿œÐ¿œ€¢ €€Ñп ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿ìп ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿Ð Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿è Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿Ô Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿ä Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿Ø Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿à Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿ÜÅ¿ìÇ¿à… ˆ#Å'¿ÌÅ¿ìÇ¿à… ˆ£Å'¿ÀÅ¿èÇ¿ä… ˆ#Å'¿ÈÅ¿èÇ¿ä… ˆ£Å'¿Äп Å¿ÌÇ¿È… ˆ#Å" Ò¿  Å¿ÌÇ¿È… ˆ£Å"Å¿ÄÇ¿À… ˆ#®Ç D… ‰#Å'¿¼ Ò¿  Å¿ÀÇ¿¼… ˆ#Å" Ò¿  Å¿ÀÇ¿¼… ˆ£Å"Å¿ÜÇ¿Ø… ˆ#Å'¿ÌÅ¿ØÇ¿Ô… ˆ#Å'¿ÈÅ¿ÔÇ¿Ð… ˆ#Å'¿ÄÅ¿ÌÇ¿Ä… ˆ£®Ç H… ‰#Å'¿¬Å¿Ì®Ç L… ‰#Ç¿¬… ˆ#Å'¿¸Å¿Ä®Ç P… ‰#Ç¿¬… ˆ#Å'¿°Å¿È®Ç D… ‰#Å'¿´Å¿ÐÇ¿´… ˆ#Å'¿¨Å¿ÐÇ¿´… ˆ£Å'¿¤ Ò¿  Å¿¤Ç¿¸… ˆ#Å" Ò¿  Å¿¤Ç¿¸… ˆ£Å" Ò¿  Å¿¨Ç¿°… ˆ#Å" Ò¿  Å¿¨Ç¿°… ˆ£Å"п ’ Ò'¿ Ð¿œ’?ÿÒ'¿œ¿ÿ-РDÐ'¿  Ð'¿œÐ¿œ€¢ €€Ñп ’ àÔ¿ ’@ ÅÇ@… ˆ#Å'¿ìп ’ àÔ¿ ’@ ÅÇ@… ˆ£Å'¿Ð Ò¿  ’ ÀÔ¿ ’@ ÅÇ@… ˆ#Å'¿è Ò¿  ’ ÀÔ¿ ’@ ÅÇ@… ˆ£Å'¿Ô @Ò¿  ’  Ô¿ ’@ ÅÇ@… ˆ#Å'¿ä @Ò¿  ’  Ô¿ ’@ ÅÇ@… ˆ£Å'¿Ø `Ò¿  ’ €Ô¿ ’@ ÅÇ@… ˆ#Å'¿à `Ò¿  ’ €Ô¿ ’@ ÅÇ@… ˆ£Å'¿ÜÅ¿ìÇ¿à… ˆ#Å'¿ÌÅ¿ìÇ¿à… ˆ£Å'¿ÀÅ¿èÇ¿ä… ˆ#Å'¿ÈÅ¿èÇ¿ä… ˆ£Å'¿Äп Å¿ÌÇ¿È… ˆ#Å" €Ò¿  Å¿ÌÇ¿È… ˆ£Å"Å¿ÄÇ¿À… ˆ#®Ç D… ‰#Å'¿¼ @Ò¿  Å¿ÀÇ¿¼… ˆ#Å" ÀÒ¿  Å¿ÀÇ¿¼… ˆ£Å"Å¿ÜÇ¿Ø… ˆ#Å'¿ÌÅ¿ØÇ¿Ô… ˆ#Å'¿ÈÅ¿ÔÇ¿Ð… ˆ#Å'¿ÄÅ¿ÌÇ¿Ä… ˆ£®Ç H… ‰#Å'¿¬Å¿Ì®Ç L… ‰#Ç¿¬… ˆ#Å'¿¸Å¿Ä®Ç P… ‰#Ç¿¬… ˆ#Å'¿°Å¿È®Ç D… ‰#Å'¿´Å¿ÐÇ¿´… ˆ#Å'¿¨Å¿ÐÇ¿´… ˆ£Å'¿¤  Ò¿  Å¿¤Ç¿¸… ˆ#Å" `Ò¿  Å¿¤Ç¿¸… ˆ£Å" Ò¿  Å¿¨Ç¿°… ˆ#Å" àÒ¿  Å¿¨Ç¿°… ˆ£Å"п ’ Ò'¿ Ð¿œ’?ÿÒ'¿œ¿ÿ-Çàèã¿@ð' DРDÐ'¿¨ Ð'¿¤Ð¿¤€¢ €€Sп¨’ Ô¿¨’@ ÐÒ@ Ð'¿ìп¨’ Ô¿¨’@ ÐÒ@" Ð'¿Ð Ò¿¨ ’ Ô¿¨’@ ÐÒ@ Ð'¿è Ò¿¨ ’ Ô¿¨’@ ÐÒ@" Ð'¿Ô Ò¿¨ ’ Ô¿¨’@ ÐÒ@ Ð'¿ä Ò¿¨ ’ Ô¿¨’@ ÐÒ@" Ð'¿Ø Ò¿¨ ’ Ô¿¨’@ ÐÒ@ Ð'¿à Ò¿¨ ’ Ô¿¨’@ ÐÒ@" Ð'¿ÜпìÒ¿à Ð'¿ÌпìÒ¿à" Ð'¿ÀпèÒ¿ä Ð'¿ÈпèÒ¿ä" Ð'¿Äп¨Ò¿ÌÔ¿È’@ •*`Ô" Ò¿¨ Ò¿ÌÔ¿È’"@ •*`Ô"пÄÒ¿À ”“* ’@•*`”"€‘* ’" Ò'¿¼ Ò¿¨ Ò¿À– •*à”€ —* –À •*à”"€ “* Ô¿¼’@ ”d“:  Ò" Ò¿¨ Ò¿Ä– •*à”"€ —* –"À •*à”€ —* –À ’ Ô¿¼’@ ”d“:  Ò"пÜÒ¿Ð Ð'¿¼Ð¿ØÒ¿Ô Ð'¿¸Ð¿ÜÒ¿Ô Ð'¿´Ð¿ØÒ¿Ð Ð'¿°Ð¿´Ò¿° ’•*`”€“* ’"@ •*`”€“* @Ð'¿¬Ð¿Ü”“* ’@•*`’@ •*`”"€‘* Ð'¿Üпؔ“* ’@•*`”"€“* ’"@•*`”€“* "@Ð'¿ØпԔ“* ’@•*`’@ •*`”"€‘* " “* Ò'¿ÔпД“* ’@•*` ’@ •*`"€Ð'¿Ðп¼”“* ’"@•*`”€“* ’"@•*`”€“* ’"@•*`€’ Ò'¿¼Ð¿¸”“* ’@•*`”€“* ’@•*`"€’ Ò'¿¸Ð¿´”“* ’"@•*`”"€“* ’@•*`€’ Ò'¿´Ð¿°”“* ’@•*`”€“* ’"@‘*`’ Ò'¿°Ð¿´Ò¿¬ Ð'¿´Ð¿°Ò¿¬ Ð'¿° Ò¿¨ Ò¿ÜÔ¿¼’@ Ô¿´’@ ”d“:  Ò" Ò¿¨ Ò¿ØÔ¿¸’@ Ô¿°’@ ”d“:  Ò" Ò¿¨ Ò¿ÔÔ¿¸’@ Ô¿´’@ ”d“:  Ò" Ò¿¨ Ò¿ÐÔ¿¼’@ Ô¿°’@ ”d“:  Ò"п¨’ Ò'¿¨Ð¿¤’?ÿÒ'¿¤¿þ«Ð DÐ'¿¨ Ð'¿¤Ð¿¤€¢ €€[п¨’ àÔ¿¨’@ ÐÒ@ Ð'¿ìп¨’ àÔ¿¨’@ ÐÒ@" Ð'¿Ð Ò¿¨ ’ ÀÔ¿¨’@ ÐÒ@ Ð'¿è Ò¿¨ ’ ÀÔ¿¨’@ ÐÒ@" Ð'¿Ô @Ò¿¨ ’  Ô¿¨’@ ÐÒ@ Ð'¿ä @Ò¿¨ ’  Ô¿¨’@ ÐÒ@" Ð'¿Ø `Ò¿¨ ’ €Ô¿¨’@ ÐÒ@ Ð'¿à `Ò¿¨ ’ €Ô¿¨’@ ÐÒ@" Ð'¿ÜпìÒ¿à Ð'¿ÌпìÒ¿à" Ð'¿ÀпèÒ¿ä Ð'¿ÈпèÒ¿ä" Ð'¿Äп¨Ò¿ÌÔ¿È’@ ”`“: Ò" €Ò¿¨ Ò¿ÌÔ¿È’"@ ”`“: Ò"пÄÒ¿À ”“* ’@•*`”"€‘* ’" Ò'¿¼ @Ò¿¨ Ò¿À– •*à”€ —* –À •*à”"€ “* Ô¿¼’@ ’@ •:`Ô" ÀÒ¿¨ Ò¿Ä– •*à”"€ —* –"À •*à”€ —* –À ’ Ô¿¼’@ ’@ •:`Ô"пÜÒ¿Ð Ð'¿¼Ð¿ØÒ¿Ô Ð'¿¸Ð¿ÜÒ¿Ô Ð'¿´Ð¿ØÒ¿Ð Ð'¿°Ð¿´Ò¿° ’•*`”€“* ’"@ •*`”€“* @Ð'¿¬Ð¿Ü”“* ’@•*`’@ •*`”"€‘* Ð'¿Üпؔ“* ’@•*`”"€“* ’"@•*`”€“* "@Ð'¿ØпԔ“* ’@•*`’@ •*`”"€‘* " “* Ò'¿ÔпД“* ’@•*` ’@ •*`"€Ð'¿Ðп¼”“* ’"@•*`”€“* ’"@•*`”€“* ’"@•*`€’ Ò'¿¼Ð¿¸”“* ’@•*`”€“* ’@•*`"€’ Ò'¿¸Ð¿´”“* ’"@•*`”"€“* ’@•*`€’ Ò'¿´Ð¿°”“* ’@•*`”€“* ’"@‘*`’ Ò'¿°Ð¿´Ò¿¬ Ð'¿´Ð¿°Ò¿¬ Ð'¿° àÒ¿¨ Ò¿ÜÔ¿¼’@ Ô¿´’@ ’@ •:`Ô"  Ò¿¨ Ò¿ØÔ¿¸’@ Ô¿°’@ ’@ •:`Ô" `Ò¿¨ Ò¿ÔÔ¿¸’@ Ô¿´’@ ’@ •:`Ô" Ò¿¨ Ò¿ÐÔ¿¼’@ Ô¿°’@ ’@ •:`Ô"п¨’ Ò'¿¨Ð¿¤’?ÿÒ'¿¤¿þ£Çàè㿈ð' DРDÒ €¢`€€& Ð'¿ìп쀢 €€Ð DÒ Ô`$РDÒ¿ìŸÂ€Ð¿ì’?ÿÒ'¿ì¿ÿðРDÒ €¢`€ РD’ ÈÒ" РDÀ"!0€Ð D’ dÒ" Çàèã¿ð' DРDÒ €¢`€Ð DÒ Ô`(РDŸÂ€Ð DÀ" РDÀ" Çàè㿈ð' DРDÒ Ö@РD’ ” „ŸÂÀÐ'¿ìпìÀ" €Ð¿ì°€Çàè㿈ð' DРDÒ Ö@РD’ ”!ŸÂÀÐ'¿ìпìÀ"!п찀Çàèã¿ð' Dò' HРDÔ H’ ’ÿ Ò H@WÁ°€Çàèã¿ð' Dò' HÒ DÿÒ H Ð' DÒ D Ò H@WÄÒ D"@°€Çàèã¿ð' Dò' Hô' Lö' Pø' Tú' Xä XРH’‘*`Ò D@Ð' DРP’‘*`Ò L@Ð' Læ T€¤à€€Ð Dà Ð' D LÒâ@’`Ò"’”@Wƒ¦ÿÿ¿ÿìÇàèã¿ð' Dò' Hô' LРL’•*`РHÒ D@WsÇàèã¿ð' Dò' HРD’ Ô H@WoÇàèã¿ð' DРDÒÔ`РDŸÂ€Ð DÿÿV @W5Çàèã¾Èð' DРDÔ’¿(Ô  РDŸÂ€”¿(õa@³’ã@W/Çàè㿈ð' Dò' HРDÒÒ'¿ìРH€¢ €Ð¿ìÒ l€¢`€ пìÒ h€¢`€€Ð¿ìÒ Ð DŸÂ@Ò¿ìпìÒ¿ìÔ`l’ Ò" l€ пìÒ hРH€¢@€Ð¿ìÒ Ð DŸÂ@Çàèã¿hð' Dò' HРDÒÒ'¿ìпìÒ Ò'¿èÀ'¿äп耢 €Ð¿ìÒ¿èÐ t€¢@€ пìÒ¿è” “* Ô p@ ÒÒ'¿ä€Ð¿ìÒ x€¢`€Ð¿ìÒ¿èÐ |€¢@€Ð¿ìÒ¿èÐ €€¢@€ пìÒ¿ìÔ¿èÖ`|’"€ ” “* Ô x@ ÒÒ'¿äп䀢 € пìÒ¿èÒ" пìÒ pÐ@Ð'¿äÀ'¿ØпäÐ'¿à¿àÒÔ @Ô/¿ß—* •:à’`Ò"€¢ €€Ð¿ß“* ‘:`€¢ %€ пàÒ •*`‘: €¢ s€ Ð'¿Ø€¿ÿâп؀¢ € Ð¿ì” Ð HÒ¿ä@V¸€Ô¿ìÖ¿ìØ¿ìÚ¿ìпìÒ (Ò# \пìÒ ,Ò# `пìÒ 0Ò# dпìÒ 4Ò# hРHÒ¿äÔ ÖàØ Ú`$@VžÇàèã¿ð' DРDÒÀ"`lРDÒÀ"`Çàèã¿ð' DРDœ’¢ŒÒ"РDœ’£Ò" РDœ’¢ÌÒ" РDœ’£ÔÒ" РD’¢ Ò" РDÀ" hРDÀ" lРDÀ" РD®’¡˜Ò" pРD’ {Ò" tРDÀ" xРDÀ" |РDÀ" €Ð D°€Çàèã¿ð' Dò' HРDÒ 6Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Çàèã¿pð' Dò' Hô' LРDÒ Ò'¿ìРLæ²’¡ð€¢ €Ð D’ ÿÿÞРL’ Ò'¿Üп܀¢ €Ò L`Ò¿Ü" Ð' LРH€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€À'¿äпìÒ H” “*  Ò 4Ò'¿èп耢 €€Ð¿èÒ Ð L€¢@ €€ пèÐ'¿äпèÒÒ'¿è¿ÿíп耢 €dРL’ Ò'¿Øп䀢 € ³Ò H” “* ”#@ ÒÒ'¿Ô€ ³Ò H” “* ”#@ ÒÒ'¿Ôæ²bÒ¿Ø" Ò¿Ô€¢@€æ²bÒ¿Ø" Ð'¿ÔпØÔ¿Ô’ РD@­Ð'¿èп耢 €€Ò¿Ô‘2`Ð'¿ÔпԀ¢ 1€Ð D’ ÿÿZ¿ÿèпìÒ¿ìÔ¿ØÖ¿Ô”€ Ò`L”@ Ô" LпèÀ"пèÀ" пèÒ LÔ¿Ô’@ Ò" п䀢 € пìÒ H” “*  Ò¿èÒ" 4€Ð¿äÒ¿èÒ"Ð¿è’ Ò'¿àпèÒ¿àÐ ’@Ò'¿àпèÒ¿èÔ`Ò L”€ Ô" пèÒ¿èÔ`Ò L”"€ Ô" пఀÇàèã¿€ð' Dò' Hô' LРDÒ Ò'¿ìРLæ²’¡ð€¢ €Ð D’ ÿÿ РL’ Ò'¿äп䀢 €Ò L`Ò¿ä" Ð' LРH€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð L’ РD@8Ð'¿èп耢 €Ð D’ ÿþÚпìÒ¿ìÔ`L’ Ô L’@ Ò" LпèÒ¿ìÔ H– •*à’@ Ô`<Ô"пèÒ LÒ" пèÀ" пìÒ H” “*  Ò¿èÒ" <Ò¿è`°€Çàèã¿pð' Dò' Hô' Lö' PРDÒ Ò'¿ìæ²aðÒ L@TñÐ'¿ÔпԀ¢ € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð¿ÔÒ P€¢ €Ð¿ÔÐ'¿à€Ð PÐ'¿àпìÒ¿àÒ" PРP’•*`РDÒ HÿþšÐ'¿èÀ'¿ÜпÜÒ P€¢ €€3РPÒ¿Ü" Ò¿à€¢ €Ð¿àÐ'¿àпàÒ L@T´”РDÒ HÿÿQÐ'¿äпàÐ'¿Øп؀¢ €€¿ÜÒ” – •*àֿ蔀 Ö¿äÖ"€’`Ò"пäÒ L Ð'¿äпؒ?ÿÒ'¿Ø¿ÿè¿ÿÊп谀Çàèã¿pð' Dò' Hô' Lö' PРDÒ Ò'¿ìРL”“* æ²¡ð@T~Ð'¿ÔпԀ¢ € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð¿ÔÒ P€¢ €Ð¿ÔÐ'¿à€Ð PÐ'¿àпìÒ¿àÒ" PРP’•*`РDÒ Hÿþ'Ð'¿èÀ'¿ÜпÜÒ P€¢ €€6РPÒ¿Ü" Ò¿à€¢ €Ð¿àÐ'¿àпàÒ L@TA’•*`РDÒ HÿþÝÐ'¿äпàÐ'¿Øп؀¢ €€¿ÜÒ” – •*àֿ蔀 Ö¿äÖ"€’`Ò"РL’‘*`Ò¿ä@Ð'¿äпؒ?ÿÒ'¿Ø¿ÿæ¿ÿÇп谀Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XРDÒ Ò'¿ìРH€¢ €Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð DÒ H” €ÿýÃÐ'¿èпèÀ"пèÒ TÒ" пèÒ PÒ" пèÒ XÒ" пèÒ LÒ" пèÀ" (пèÒ¿ìÔ`DÔ" ,пìÒ¿èÒ" Dп谀Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XРDÒ Ò'¿ìРH€¢ €Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð DÒ H” €ÿý„Ð'¿èпèÀ"пèÒ TÒ" пèÒ PÒ" пèÒ XÒ" пèÒ LÒ" пèÀ" (пèÒ¿ìÔ`HÔ" ,пìÒ¿èÒ" Hп谀Çàèã¿pð' DРDÒ Ò'¿ìÀ'¿èÀ'¿äпìÒ DÒ'¿ÔпԀ¢ €€Ð¿ÔÒ€¢`€Ð¿ÔÒ¿ÔÐ Ò`@S{Ò¿è@Ð'¿èпÔÒ¿ÔÐ Ò`@SrÒ¿ä@Ð'¿äпÔÒ ,Ò'¿Ô¿ÿàпìÒ HÒ'¿ÐпЀ¢ €€"пÐÒ€¢`€Ð¿ÐÒ¿ÐÐ Ò`@SU’‘*`Ò¿è@Ð'¿èпÐÒ¿ÐÐ Ò`@SJ’‘*`Ò¿ä@Ð'¿äпÐÒ ,Ò'¿Ð¿ÿÜп耢 €€ÆÖ¿ìРDÒ¿èÔ¿äÖàL@YÐ'¿àпàҿ䀢 €æ²bÐ'¿Ø€ пàÒ¿è@S*Ð'¿Øп؀¢ € Ð'¿ØпìÒ DÒ'¿ÔпԀ¢ €€KпÔÒ€¢`€AпÔÒ ÿÒ¿ÔÒ` @S ’ Ò'¿ÜпÜÒ¿Ø€¢ €Ð¿ÔÒ¿ÔÔ`Ô" €à¿ÔÒ¿ÔпØÒ` @RôÐ$ пԠ 0пÔÒ¿ÔÐ Ò`@Rë”РD’@пԒ Ò" (Ô¿ÔÖ¿ÔРD’ Ô ÖàÿýâÒ¿ÔÐ"@пÔÒ¿ìÔ`PÔ" пÔÀ" пÔÀ" пÔÀ" $пÔÒ ,Ò'¿Ô¿ÿ³Ð¿ìÒ HÒ'¿ÐпЀ¢ €€LпÐÒ€¢`€BпÐÒ ÿÒ¿ÐÒ` @R·’ Ò'¿ÜпÜÒ¿Ø€¢ €Ð¿ÐÒ¿ÐÔ`Ô" €à¿ÐÒ¿ÐпØÒ` @R¡Ð$ пР 0пÐÒ¿ÐÐ Ò`@R˜’•*`РD’@ÃпВ Ò" (Ô¿ÐÖ¿ÐРD’ Ô ÖàÿýÿÒ¿ÐÐ"@пÐÒ¿ìÔ`PÔ" пÐÀ" пÐÀ" пÐÀ" $пÐÒ ,Ò'¿Ð¿ÿ²Çàèã¿xð' Dò' Hô' LРHÒ Ò'¿ìÒ HÐ`Ò¿ì@RhÐ'¿èÀ'¿ØРHÒ¿ØÐ €¢@€€iРHÒ HÔ`Ö¿Ø’"€ Ð €¢ €Ò HÐ`€Ò HÔ`Ò¿Ø"€ Ð'¿àРHÒ Ð¿Ø’@Ò'¿ÜРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àÐ¿à€¢ €€8пàÒ¿ì@R)Ð'¿äРL€¢ €Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 4РDÔ€Ö¿èØ¿äŸÃ@€Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 0РDÔ€Ö¿èØ¿äŸÃ@пèÒ¿ä Ð'¿èРHÒ¿ØÐ ’@Ò'¿Ø¿ÿ“Çàèã¿xð' Dò' Hô' LРHÒ  “* Ò'¿ìÒ HÐ`Ò¿ì@QçÐ'¿èÀ'¿ØРHÒ¿ØÐ €¢@€€iРHÒ HÔ`Ö¿Ø’"€ Ð €¢ €Ò HÐ`€Ò HÔ`Ò¿Ø"€ Ð'¿àРHÒ Ð¿Ø’@Ò'¿ÜРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àÐ¿à€¢ €€8пàÒ¿ì@Q¨Ð'¿äРL€¢ €Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 4РDÔ€Ö¿èØ¿äŸÃ@€Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 0РDÔ€Ö¿èØ¿äŸÃ@пèÒ¿ä Ð'¿èРHÒ¿ØÐ ’@Ò'¿Ø¿ÿ“Çàèã¿€ð' Dò' Hô' Lö' Pø' TРLÒ P Ð'¿ìРHÒ¿ìÐ €¢@€Ð HÒ PÐ €¢@€ РHÒ€¢`€€Ð DÒ Ð"`РDÒÔ@РDŸÂ€Ð HÒ LÐ €¢@ € РHÒ HÐ Ò` ҿ쀢@€€:РHÒ (€¢`€ РDÒ EÐ"`РDÒÔ@РDŸÂ€Ð HÒ $€¢`€ РDÒ H” ÿþ±Ð HÀ" $РHÒ LÐ €¢@€Ð HÒ LÒ" €Ð HÒ¿ìÐ ’"@Ò'¿äп䀢 €À'¿äРHÒ¿äÒ" РDÒ H” ÿþ’РHÒ Ð¿ì€¢@€\РHÒ Ð L€¢@€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð LÐ'¿è€Ð HÒ Ò'¿èРT€¢ €Ð HÒ¿ìÒ" РHÒ €¢`€'РHÒ Ò'¿äРHÒ¿èÐ ’"@Ò'¿èРHÒ¿ìÐ ’"@Ò'¿ìпèҿ쀢 €€Ð HÒ¿è” “* Ð’@Ð@Ò¿äÿùSÐ¿è’ Ò'¿è¿ÿì€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð T€¢ €Ð H’ Ò" $РHÒ HÔ LÖ`’"€ ” “* Ô@ °€Çàèã¿€ð' Dò' Hô' Lö' Pø' TРLÒ P Ð'¿ìРHÒ¿ìÐ €¢@€Ð HÒ PÐ €¢@€ РHÒ€¢`€€Ð DÒ Ð"`РDÒÔ@РDŸÂ€Ð HÒ LÐ €¢@ € РHÒ HÐ Ò` ҿ쀢@€€:РHÒ (€¢`€ РDÒ EÐ"`РDÒÔ@РDŸÂ€Ð HÒ $€¢`€ РDÒ H” ÿþKРHÀ" $РHÒ LÐ €¢@€Ð HÒ LÒ" €Ð HÒ¿ìÐ ’"@Ò'¿äп䀢 €À'¿äРHÒ¿äÒ" РDÒ H” ÿþ,РHÒ Ð¿ì€¢@€^РHÒ Ð L€¢@€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð LÐ'¿è€Ð HÒ Ò'¿èРT€¢ €Ð HÒ¿ìÒ" РHÒ €¢`€)РHÒ  “* Ò'¿äРHÒ¿èÐ ’"@Ò'¿èРHÒ¿ìÐ ’"@Ò'¿ìпèҿ쀢 €€Ð HÒ¿è” “* Ð’@Ð@Ò¿äÿølÐ¿è’ Ò'¿è¿ÿì€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð T€¢ €Ð H’ Ò" $РHÒ HÔ LÖ`’"€ ” “* Ô@ °€Çàèã¿xð' Dò' HРDÒ Ò'¿ìРH€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð H€¢ €>пìÒ DÒ'¿Üп܀¢ €€Ð¿ÜÒ (€¢`€ пÜÀ" (пÜÔ¿Ü’ 0Ô 8РDŸÂ€Ð¿ÜÒ ,Ò'¿Ü¿ÿéпìÀ" DпìÒ HÒ'¿Øп؀¢ €€Ð¿ØÒ (€¢`€ пØÀ" (пØÔ¿Ø’ 0Ô 8РDŸÂ€Ð¿ØÒ ,Ò'¿Ø¿ÿéпìÀ" HпìÒ H” “*  Ò <Ò'¿äпìÒ H” “*  À" <п䀢 €€Ð¿äÒÒ'¿ØпäÒ¿äÐ Ò` ’ Ò'¿àРDÒ¿äÔ¿à@EпìÒ¿ìÔ`LÒ¿à”"€ Ô" LпØÐ'¿ä¿ÿãпìÒ H” “*  Ò 4Ò'¿èпìÒ H” “*  À" 4п耢 €€Ð¿èÒÒ'¿ØпèÒ¿èÐ Ò` ’ Ò'¿àРDÒ¿èÔ¿à@пìÒ¿ìÔ`LÒ¿à”"€ Ô" LпØÐ'¿è¿ÿãÇàè㿈ð' D Ð'¿ìп쀢 €€ РDÒ¿ìÿÿ<пì’?ÿÒ'¿ì¿ÿóÒ DРDÒ`” T@àРDÀ" РD@Çàèã¿xð' DРDÀ" € РDÒ Ð"`РDÒÔ@РDŸÂ€æ²bÐ'¿àпàæ²’¢€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð D@ëÐ'¿èРD’ T@£Ð'¿ìп쀢 €Ð D@åРDÒ 6Ð"`РDÒÀ"`РDÒÔ@РDŸÂ€Ð¿ì’£<Ò"п잒¢„Ò" п쟒 Ò" п쟒¡ÜÒ" п쟒£´Ò" п젒 °Ò" п젒¡¬Ò" п좒¢4Ò" п죒¡ÈÒ" п줒¡dÒ" $п쥒 DÒ" (пìæ²’¢Ò" 0пìÒ¿èÒ" , Ð'¿äп䀢 €€Ð¿ìÒ¿ä” “*  À" 4пìÒ¿ä” “*  À" <пä’?ÿÒ'¿ä¿ÿëпìÀ" DпìÀ" HÐ¿ì’ TÒ" LРDÒ¿ìÒ" ³c@NWÐ'¿Üп܀¢ €- xÐ/¿Û”¿è–¿Ûпܳ’# @N€¢ €!пۓ* ‘:`€¢ m€ пۓ* ‘:`€¢ M€€ п蔓* ’"@•*`”€‘* Ð'¿èпìÒ¿è– •*à”"€ —* –À “*àÒ" ,Çàèã¿ð' Dò' HРH@N"°€Çàèã¿ð' Dò' Hô' LРH@NÇàèã¿ð' Dò' HРH@N°€Çàèã¿ð' Dò' Hô' LРH@NÇàèã¿ð' Dò' Hô' Lö' PРL°€Çàèã¿ð' Dò' Hô' LРDÒ 1Ð"`РDÒÔ@РDŸÂ€Çàèã¿ð' D° €Çàèã¿ð' DÇàè” – Æ  „à…(€ €ˆà€€–À¿ÿù” ÃàÖ"@† ”Ö  „ à…(€”€€Šà€¿ÿú†à€ à€€Šà@€„?ÿ…(€”€ÃàÔ"@…*`€¢`€Ô"€ÖÔ?üÆàÄ € À€’‚ÿÔ"Ö"?ü¿ÿ÷?üÃàÄ’ € € €Ä €  "€ÄÄ €  2€’`Ä„Æ € à¿ÿô Ãà ã¿à€äÀЀ¢ €âÐ €¢ "€ÐÐ €¢ €’ÿÿÉ”Ò €¢@€  ¤ Ð @€¢8€¢ÐÒ €¢`¿ÿç° à&€ä&Àâ'Çàè㿀Р€¢ € À'¿ìЀ¢ €Ð¿ìÿÿºÐÒ¿ì  ’@Ò'¿ìЀ¢ ¿ÿøпì€Ð& ÿÿ®Ð Ð'¿ìпìÐ& @MO‘* ’?ÿÒ'¿èÀ'¿äÀ'¿ìÒ €¢`€¢  Ѐ¢ €Ò¿è’”¿ì–¿èÐÿÿ«˜¿ä  Ѐ¢ ¿ÿø’€ Ò¿èÐ ’”¿ì–¿èÿÿž˜¿äÒ¿èâ& пäÒ&Ð& Çàèã¿@/L®ã<®À ÐÀà€¤ €¢Ð€¢ €€¤@ÿÿ¬Ð€¤@*€à Ð €¤@ €€¤ à €¤ 2¿ÿñЀ¤ €° Ø – €¢À €À Ú •2 ‘* ð@Ò €¤@ :€Ð €˜ @€¤@€– €¢À ¿ÿòÀ ° Çàè㿈@/L®âT®À ÒÀÔ "  @LæÐ&@€¢ €Ð@’`@LßÒÀ €¢ €Ð@ÐJ€¢ z€-° @LØÐ@Ô@’`ÒÀ  €° @LÍ €¢ 2€À&`Ð Ô Ò ‘* •* ”€“*`Ð ’@  Ð&`° ÿþÝ’`ÿþè’` °ÐÒ@Ð&`ÐJ@€¢ z€° ÿþÐ’¿ìÒ¿ì° Çàèã¿€Ô€Š @€ ° Ò @Lx  ?ÒÀ’@€ßÒ&À€Š €€  ?Ð'¿è€k€Š À€€¢ .Ð'¿è@€ÒÀ*!¬€Î“* @àÐ ÃÀ8Ðü8tÄ88ä°$Tt000000000000000000000000000000ÐÐÔ Ò ‘* •* ”€“*`Ð ’@ € ÒÐÀ Ð&À€‹° ÐÔ ÒÀ‘* ”€’@ Ò&À€‚° ÔÐ Ò •* ‘*  “*`Ô ’@ÐÀ”€  Ð&À€s° ÿþQ’¿èÿþO’¿ìÔ¿ì°Ò  @Kþ Ð'¿ìÒ¿è ’@ Ð*a¬Ð¿è‘* @€_Ò" ÿþ=’¿èÒ¿è°’@ €WÀ*a¬ÿþ5’¿èÿþ3’¿äÒ¿è” ’@ Ô*a¬Ò¿è°Ð¿ä“*`’@ €GÐ"` ¿èÿþ$’ÿþ"’¿ìÒ °Ð¿ìÒ6a¨€;Ð&` ¿èÿþ’Ò °€3Ò6a¨ÿþ’¿ìÒ¿ì°€,Ò&`@Kã" ’@KÄ”"€$à&bà"”"@K½’@KÙ0€ Ð'¿è– пè@Ö*!¬Ô¿è“* ’@ ¿ð‘* Ð"`” €¢ ¿ÿõÔ'¿è0€ ÿýé’¿ìÒ¿ì°€Ò&` @KÇÇàèã¿@/K®ီÀð&`À&`À&@ ÒÀÀ&` Ð@À&`Ð&`ò"@Çàèã¿@/K®á8®Àð&`ð&` À&` ÒÀÀ&@Ð@À&`Ð&`ò"@Çàèã¿@/K®àð®À ÔÀЀ€¢ €Ò€Ð`€¢€ Ð`Ð"€Ð@€¢ € @K€Ð` 0€€¢ ¿ÿò”`@KƒÇàèã½XÿþL¤’ €ÿþ’¿Ø ’ €½À€=° ’ @KP”"пêÒ¿ÜÐ7¿jÒ'½ÄР?ü$€Ò ¢ €¤€ пؒ½À”¿Øÿþ±–  €¤ ¿ÿúпØÐJ€¢ z€  ÿýo’½¼Ò½¼  ЀҠ€¢ €¤€Ò'½¸Ð½¸€¢€ ’½À”¿Øÿþ”–½¸ €¤ ¿ÿ÷н¸’½À@K”"°Çàèã¿@/J®ãH®À ÐÀÒ?ü€¢ÿ€  ?üП ?üЀ¢?ÿ¿ÿûÇàèã¿Çàèã¿ ÿž‹ÿÿåÇàèã¿ ÿžbÇàèªÈª˜ªpª@ª©è©À©¨©€©`©8© ©¨à¨À¨°¨˜¨h¨8¨§ð§È§¨§§h§H§0§ §¦ø¦à¦¸¦¦h¦P¦0¦¥Ø¥ ¥¥P¥0Unsupported output file formatUnrecognized input file format --- perhaps you need -targaungetc failedOutput file format cannot handle %d colormap entriesColor map file is invalid or of unsupported format%ux%u colormapped Targa image%ux%u grayscale Targa image%ux%u RGB Targa imageTarga output must be grayscale or RGBInvalid or unsupported Targa fileUnsupported Targa colormap format%ux%u text PPM image%ux%u PPM image%ux%u text PGM image%ux%u PGM imageNot a PPM/PGM fileNonnumeric data in PPM filePPM output must be grayscale or RGBRan out of GIF bitsPremature end of GIF imageBogus char 0x%02x in GIF file, ignoringCorrupt data in GIF fileCaution: nonsquare pixels in inputIgnoring GIF extension block of type 0x%02xWarning: unexpected GIF version number '%c%c%c'%ux%ux%d GIF imageNot a GIF fileToo few images in GIF fileGIF output must be grayscale or RGBBogus GIF codesize %dGIF output got confused%ux%u 8-bit colormapped OS2 BMP image%ux%u 24-bit OS2 BMP image%ux%u 8-bit colormapped BMP image%ux%u 24-bit BMP imageNot a BMP file - does not start with BMSorry, compressed BMPs not yet supportedBMP output must be grayscale or RGBInvalid BMP file: biPlanes not equal to 1Invalid BMP file: bad header lengthOnly 8- and 24-bit BMP files are supportedUnsupported BMP colormap formatusage: %s [switches] [inputfile] Switches (names may be abbreviated): -quality N Compression quality (0..100; 5-95 is useful range) -grayscale Create monochrome JPEG file -optimize Optimize Huffman table (smaller file, but slow compression) -progressive Create progressive JPEG file -targa Input file is Targa format (usually not needed) Switches for advanced users: -dct int Use integer DCT method%s (default) -dct fast Use fast integer DCT (less accurate)%s -dct float Use floating-point DCT method%s -restart N Set restart interval in rows, or in blocks with B -smooth N Smooth dithered input (N=1..100 is strength) -maxmemory N Maximum memory to use (in kbytes) -outfile name Specify name for output file -verbose or -debug Emit debug output Switches for wizards: -baseline Force baseline quantization tables -qtables file Use quantization tables given in file -qslots N[,...] Set component quantization tables -sample HxV[,...] Set component sampling factors -scans file Create multi-scan JPEG per script file arithmetic%s: sorry, arithmetic coding not supported baselinedctintfastfloatdebugverboseIndependent JPEG Group's CJPEG, version %s %s 6b 27-Mar-1998Copyright (C) 1998, Thomas G. Lanegrayscalegreyscalemaxmemory%ld%coptimizeoptimiseoutfileprogressivequality%dqslotsqtablesrestartsamplescanssmoothtargacjpeg%s: only one input file rb%s: can't open %s wbGIF input is unsupported for legal reasons. Sorry. !)1:BJRZcks{„Œ”œ¥­µ½ÅÎÖÞæï÷ÿrCan't open table file %s Too many tables in file %s Invalid table data in file %s Non-numeric data in file %s Can't open scan definition file %s Too many scans defined in file %s Too many components in one scan in file %s Invalid scan entry format in file %s %d%cJPEG quantization tables are numbered 0..%d %d%c%d%cJPEG sampling factors must be 1..4 ?ð (3= :<7 (9E83WP>%8DmgM#7@Qhq\1@NWgyxeH\_bpdgc/ccccBcccc8ccccc/Bcccccccccccccccccccccccccccccccccccccc  }!1AQa"q2‘¡#B±ÁRÑð$3br‚ %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚáâãäåæçèéêñòóôõö÷øùúw!1AQaq"2B‘¡±Á #3RðbrÑ $4á%ñ&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz‚ƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚâãäåæçèéêòóôõö÷øùú@XÅSŸKB@2I"£¨XÅ{!sühbXÅE¿0 ~SŸsümAbTSŸA³-AKBhbbTX~KB;!(ºÃ@XÅSŸKB@2I"£¨2IE¿A³;!2I'‚7 à"£0 -A(º"£7¿ Ž¨~è à Žß?ð?ö1P±Haï?ô箑MoÊ?òÐbïlª?ð?é$iÀ§¿;?áQz{Ç »?ѨUÞr«]@ ?ðF€?5ó>Ãï? ‹Ô?§=u     !(0)" #*1892+$%,3:;4-&'.5<=6/7>?????????????????ÎèΨΈÎ`Î@Î ÎÍØ͸Í ͈ÍpÍ0ÍÌà̸Ì€ÌHÌ0ÌËàËËpË@Ë ÊøÊÐʨÊÊxÊ`ÊHÊ ÊÉðÉÈÉ°É€ÉXÉ0ÉÈØÈÀÈ È`È8ÈÇøÇÈǨÇ€ÇXÇ(ÆøÆØƨÆ€ÆXÆ(ÅøÅÈŘÅhÅ@Å ÅÄÈĘÄxÄPÄ(ÄÃøÃÐÃÀÀÃ8ÃÂØ°ÂÂ`Â@Â(ÂÂÁØÁ Á`Á0ÁÀàÀÀÀ˜ÀpÀXÀ0ÀÀ¿À¿€¿`¿P¿0¿¾ð¾Ð¾°¾h¾(½ð½¸½ ½ˆ½`½¼Ø¼ ¼x¼H¼(»ð»À»Application transferred too many scanlinesInvalid SOS parameters for sequential JPEGCorrupt JPEG data: found marker 0x%02x instead of RST%dPremature end of JPEG fileWarning: unknown JFIF revision number %d.%02dCorrupt JPEG data: bad Huffman codeCorrupt JPEG data: premature end of data segmentCorrupt JPEG data: %u extraneous bytes before marker 0x%02xInconsistent progression sequence for component %d coefficient %dUnknown Adobe color transform code %dObtained XMS handle %uFreed XMS handle %uUnrecognized component IDs %d %d %d, assuming YCbCrJFIF extension marker: RGB thumbnail image, length %uJFIF extension marker: palette thumbnail image, length %uJFIF extension marker: JPEG-compressed thumbnail image, length %uOpened temporary file %sClosed temporary file %s Ss=%d, Se=%d, Ah=%d, Al=%d Component %d: dc=%d ac=%dStart Of Scan: %d componentsStart of Image Component %d: %dhx%dv q=%dStart Of Frame 0x%02x: width=%u, height=%u, components=%dSmoothing not supported with nonstandard sampling ratiosRST%dAt marker 0x%02x, recovery action %dSelected %d colors for quantizationQuantizing to %d colorsQuantizing to %d = %d*%d*%d colors %4u %4u %4u %4u %4u %4u %4u %4uUnexpected marker 0x%02xMiscellaneous marker 0x%02x, length %u with %d x %d thumbnail imageJFIF extension marker: type 0x%02x, length %uWarning: thumbnail image size does not match data length %uJFIF APP0 marker: version %d.%02d, density %dx%d %d %3d %3d %3d %3d %3d %3d %3d %3dEnd Of ImageObtained EMS handle %uFreed EMS handle %uDefine Restart Interval %uDefine Quantization Table %d precision %dDefine Huffman Table 0x%02xDefine Arithmetic Table 0x%02x: 0x%02xUnknown APP14 marker (not Adobe), length %uUnknown APP0 marker (not JFIF), length %uAdobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %dCaution: quantization tables are too coarse for baseline JPEG6b 27-Mar-1998Copyright (C) 1998, Thomas G. LaneWrite to XMS failedRead from XMS failedImage too wide for this implementationVirtual array controller messed upUnsupported marker type 0x%02xApplication transferred too few scanlinesWrite failed on temporary file --- out of disk space?Seek failed on temporary fileRead failed on temporary fileFailed to create temporary file %sInvalid JPEG file structure: SOS before SOFInvalid JPEG file structure: two SOI markersUnsupported JPEG process: SOF type 0x%02xInvalid JPEG file structure: missing SOS markerInvalid JPEG file structure: two SOF markersCannot quantize to more than %d colorsCannot quantize to fewer than %d colorsCannot quantize more than %d color componentsInsufficient memory (case %d)Not a JPEG file: starts with 0x%02x 0x%02xQuantization table 0x%02x was not definedJPEG datastream contains no imageHuffman table 0x%02x was not definedBacking store not supportedRequested feature was omitted at compile timeNot implemented yetInvalid color quantization mode changeScan script does not transmit all dataCannot transcode due to multiple use of quantization table %dPremature end of input fileEmpty input fileMaximum supported image dimension is %u pixelsMissing Huffman code table entryHuffman code size table overflowFractional sampling not implemented yetOutput file write error --- out of disk space?Input file read errorDidn't expect more than one scanWrite to EMS failedRead from EMS failedEmpty JPEG image (DNL not supported)Bogus DQT index %dBogus DHT index %dBogus DAC value 0x%xBogus DAC index %dUnsupported color conversion requestToo many color components: %d, max %dCCIR601 sampling not implemented yetSuspension not allowed hereBuffer passed to JPEG library is too smallBogus virtual array accessJPEG parameter struct mismatch: library thinks size is %u, caller expects %uImproper call to JPEG library in state %dInvalid scan script at entry %dBogus sampling factorsInvalid progressive parameters at scan script entry %dInvalid progressive parameters Ss=%d Se=%d Ah=%d Al=%dUnsupported JPEG data precision %dInvalid memory pool code %dSampling factors too large for interleaved scanWrong JPEG library version: library is %d, caller expects %dBogus marker lengthBogus JPEG colorspaceBogus input colorspaceBogus Huffman table definitionIDCT output block size %d not supportedDCT coefficient out of rangeInvalid component ID %d in SOSBogus buffer control modeMAX_ALLOC_CHUNK is wrong, please fixALIGN_TYPE is wrong, please fixSorry, there are legal restrictions on arithmetic codingBogus message code %d%s @>€ˆJPEGMEM%ld%cehÐÌÑtÑŒÒàÏ(Ï0ÓÑ€00¿ÿó<0¿ÿðH0¿ÿíT0¿ÿê`0¿ÿçl0¿ÿäx0¿ÿá„0¿ÿÞ0¿ÿÛœ0¿ÿب0¿ÿÕ´0¿ÿÒÀ0¿ÿÏÌ0¿ÿÌØ0¿ÿÉä0¿ÿÆð0¿ÿÃü0¿ÿÀ0¿ÿ½0¿ÿº 0¿ÿ·,0¿ÿ´80¿ÿ±D0¿ÿ®P0¿ÿ«\0¿ÿ¨h0¿ÿ¥° ¤H ¤doÿÿþôoÿÿÿè  S oÿýüÏTD8h шÿÿÿÿÿÿÿÿ|e  e ™,4 (™`L 8™¬H H™ôTXšHœ - etšä - e›ôè - e¬œÜ( - eÈž¬ - eä¡°H - e¡øH - e¢@€ - e8¢À( - eÿñÔè ô8|¤H ¤d ¤x Ï4 ÏT ÐÌÑtÑ|Ñ„ÑŒÒà)þÖ`ÿñÿñÿñ%Ñt)Ñ|7Ñ„Eð[ðjÑŒ}Ñx‹l–°¡Òàªx¶ÿñ¾¼ÏÓÛ¤€° ðÒüùÒø ¼`# ¼&Ñx8ÿñ@4@PQ:¨`b6,ÔsC`„<X”9 ¦5œ¸30Ç7ô$Ú9ˆæ30ï7ôÿñ CØÿñ$D´.T ?LX´ODÌ]Ià kHüäyG¼€‹DšFxD©J€¸KHÆEÜœÙ±Ø  ãH<ÀðÿñøTÿñT´f\*[œ À:UDüHX@ØVTeY„sW@€ÿñ‹fà•k@0§gð@¹fàÈÿñÑuLàÿñëvœúÿñXÿñˆt .µ  Cµð X”¨øf¶È |µà ’„¡‡D0°´  Ì“ì¼×“dˆãµ¸ ÷¶  ¶° "µÈ 9³  Sÿñ^š|ðo™àœƒ™€`”™€£ÿñ¬œ»ÿñƲ@œ×tætÐô®0¢D ¤¶(&«èH=µÜLJÿñU½ô^¾H´g¾Dp¿ü¤y»è ‚¹ä‹Ãà|ŸÂÀ °¸È¨º¸ÈÉÄ\$ÛÇ4ˆíÄ€tÿÈÜHÁ   ¹p4,¹¤@8ȼ KÄô@^ÿñiÊÜÀyÊ܈˜€¡ÿñ¬Ïh¿ÎpÏÒØèãÏhpôÎpÖÀ`ÿñ$æ H4መHÛ`¤XÚ¼gÝ„uÚ¼¤„ÿñŽõ(šïÔ(«ë(¨¹ô Æë(ÕðüHçóDØùíÐ ÿñ ØP /ÿÌp CÐ Zû€ idl y<( ‰üP ˜ýdh §ûÀ ¹û€ Ïÿñ Øø| ä<h ñŒ è`  œ” "Ìp 3/˜t =è L#0ð ^tX i,° |¤è Œÿñ –4€˜ ¢; \ ¶8DÈ Ê6Üh ×G˜X áE Ô ú@(` >hÀ $Dˆ„ 61  E1 t V54 a5L tHðØ €5Ü Œÿñ —IÈ ¦·p€ ²Q„¸ ÄNд зð@ áIÈ ôÿñ ÿUÌ ÿñ ]l (ÿñ 3dD Bÿñ LoL [ÿñ dpì sÿñ |sÀ ‰rŒ ˜rŒ@ £sÔ8 ²v ( ÂrÌH Ñÿñ Û}ÜØ è|Ä õˆ0 †4ü ”D€ Ï -vð <‘dà FÈœ YŠ4” lvðL zz„” †w<H ’Ï ¢¬ˆ ¶€°ü Ê´ü Þÿñ é—ô øÿñÏ( Ï0  ™¬HÓ™`L.™,4=ž¬NœÜ(_ÑŒo™ôTzšä…šHœŽ›ôè—ÿñ¢ÒÜ°£èÆ£èÕÑ|ã¤<îшûÑ€ÿñ|t.¸à1¹˜ô HÏðN• àfÓoÖ`tvt(oL¼Œ‡<˜À@µFà¸ÉuLÒÕ @!ס°HíÏ4 ˜p$Ó †X3€d¸HмN›l˜^]lØnÏ„uÏzpì@ˆCØ@—r04§}Ì»õ8HÑÐ,ÙÙ œñpLþÐŒUÌ Ðt¤H #X 7ÐD>ÏüDdD TÐ\Z|\4lŒ X€Ðh…„šrd(¤pÄä´ÏÌ»i0Í¡øHéÏ´ðÏä÷Ѐ~\0xÈ*ÐÌ3% J·<ŒaÊ$¸uÕ @{˜ $‹x¬¡¢À(³r¨¤ÆÏœÌq,PÖÓ!Þv4¼í (Àÿp L™#И(ÍT@CtdO˜”,bpTLy‚ìH°¥¢@€½‰äÏФÖéhÀî~ŒÌ—ô,ÒàÏT 0ÏØ6Ð8=T<OŠøgœp}Ï3 „¤x ‘”Ä0¢xä·ÐP¾fppÍvœáÓ !è/íÐóT p™ÐϨ lpT1Ð 8vL(CаJ¤d P˜D,_yødtq|´††p˜›ÏÀ£¸T@ cjpegcrti.svalues-Xa.ccrtstuff.cp.2__CTOR_LIST____DTOR_LIST____do_global_dtors_auxgcc2_compiled.__EH_FRAME_BEGIN__force_to_datafini_dummyinit_dummyobject.7frame_dummycjpeg.cselect_file_typeoutfilenamecdjpeg_message_tableprognameis_targausageparse_switchesgcc2_compiled.printed_version.6rdppm.cread_pbm_integerget_word_rgb_rowget_text_rgb_rowfinish_input_ppmstart_input_ppmget_word_gray_rowget_text_gray_rowgcc2_compiled.get_scaled_rgb_rowget_raw_rowpbm_getcget_scaled_gray_rowrdgif.cgcc2_compiled.rdtarga.cread_bytefinish_input_tgastart_input_tgaread_colormapget_24bit_rowget_16bit_rowget_8bit_gray_rowgcc2_compiled.read_rle_pixelget_memory_rowpreload_imageread_non_rle_pixelc5to8bitsget_8bit_rowrdrle.cgcc2_compiled.rdbmp.cread_bytefinish_input_bmpstart_input_bmpread_colormapget_24bit_rowgcc2_compiled.preload_imageget_8bit_rowrdswitch.ctext_getcread_scan_integerread_text_integergcc2_compiled.cdjpeg.cgcc2_compiled.jcapimin.cgcc2_compiled.jcapistd.cgcc2_compiled.jcparam.cstd_huff_tablesbits_dc_luminance.14bits_ac_luminance.18fill_dc_scansval_ac_chrominance.21val_dc_chrominance.17gcc2_compiled.add_huff_tablestd_chrominance_quant_tbl.5fill_scansfill_a_scanval_dc_luminance.15val_ac_luminance.19bits_ac_chrominance.20bits_dc_chrominance.16std_luminance_quant_tbl.4jdatadst.cterm_destinationempty_output_bufferinit_destinationgcc2_compiled.jcinit.cgcc2_compiled.jcmaster.cprepare_for_passgcc2_compiled.initial_setupper_scan_setupvalidate_scriptfinish_pass_masterselect_scan_parameterspass_startupjcmarker.cemit_dacemit_sofemit_driemit_sosemit_dhtemit_dqtwrite_marker_headeremit_adobe_app14emit_bytegcc2_compiled.write_marker_bytewrite_scan_headerwrite_file_headerwrite_tables_onlyemit_jfif_app0emit_markeremit_2byteswrite_file_trailerwrite_frame_headerjcmainct.cstart_pass_maingcc2_compiled.process_data_simple_mainjcprepct.cexpand_bottom_edgestart_pass_preppre_process_contextpre_process_datagcc2_compiled.create_context_bufferjccoefct.ccompress_outputcompress_first_passstart_pass_coefgcc2_compiled.compress_datastart_iMCU_rowjccolor.cnull_methodrgb_gray_convertrgb_ycc_startnull_convertgcc2_compiled.cmyk_ycck_convertgrayscale_convertrgb_ycc_convertjcsample.cfullsize_smooth_downsamplefullsize_downsampleh2v2_smooth_downsamplegcc2_compiled.h2v2_downsampleh2v1_downsamplesep_downsampleint_downsampleexpand_right_edgestart_pass_downsamplejchuff.cdump_bufferemit_restartfinish_pass_huffstart_pass_huffhtest_one_blockencode_one_blockemit_bitsgcc2_compiled.encode_mcu_gatherflush_bitsfinish_pass_gatherencode_mcu_huffjcphuff.cdump_bufferencode_mcu_AC_firstencode_mcu_DC_firstemit_restartemit_bitsfinish_pass_gather_phuffencode_mcu_AC_refineencode_mcu_DC_refinefinish_pass_phuffgcc2_compiled.start_pass_phuffflush_bitsemit_buffered_bitsemit_symbolemit_eobrunjcdctmgr.cgcc2_compiled.aanscales.2forward_DCT_floatforward_DCTaanscalefactor.3start_pass_fdctmgrjfdctfst.cgcc2_compiled.jfdctflt.cgcc2_compiled.jfdctint.cgcc2_compiled.jcomapi.cgcc2_compiled.jutils.cgcc2_compiled.jerror.cemit_messagegcc2_compiled.error_exitformat_messagereset_error_mgroutput_messagejmemmgr.calloc_barrayalloc_sarraydo_barray_iodo_sarray_ioself_destructextra_pool_slopgcc2_compiled.free_poolaccess_virt_barrayaccess_virt_sarrayout_of_memoryalloc_largealloc_smallfirst_pool_sloprealize_virt_arraysrequest_virt_barrayrequest_virt_sarrayjmemnobs.cgcc2_compiled.frame.c.LLC0.LLC1fde_insertobjectsdecode_sleb128decode_uleb128execute_cfa_insnextract_cie_info__FRAME_BEGIN__count_fdesframe_initadd_fdesfind_fdecrtstuff.c__FRAME_END____do_global_ctors_auxgcc2_compiled.force_to_datainit_dummy__DTOR_END____CTOR_END__crtn.s_startjinit_huff_encoder_START_jpeg_std_message_tablefreadjpeg_simple_progression_environ_endwrite_stdoutjpeg_abortjpeg_set_qualityjpeg_open_backing_storejinit_phuff_encoderkeymatch_iob__register_frame_info_GLOBAL_OFFSET_TABLE_jpeg_free_large__ctypejpeg_set_linear_qualityjpeg_write_scanlinesabortjpeg_stdio_destjpeg_fdct_floatatexitexitjdiv_round_upjinit_read_gifjcopy_block_rowjpeg_write_m_headerjinit_color_convertertolowerjinit_c_prep_controllerjpeg_destroymallocjpeg_fdct_ifastsprintf_initjpeg_start_compressfwrite.umuljpeg_fdct_islow.uremjpeg_write_markerjpeg_set_colorspace.remjpeg_add_quant_tablejzero_farset_quant_slotssscanfread_quant_tables__register_frame_info_tableungetcfclosegetenv_END_jpeg_write_m_bytejpeg_abort_compress_DYNAMICjpeg_gen_optimal_tablejinit_c_master_controljinit_marker_writer__iobjpeg_free_smalljpeg_destroy_compress__frame_state_forset_sample_factors_exitjround_upenvironjpeg_std_errorjinit_downsamplerjpeg_alloc_huff_tablejpeg_mem_initfreejinit_c_main_controllerjinit_read_ppmjpeg_mem_availablejpeg_alloc_quant_tablejpeg_write_raw_datajpeg_make_c_derived_tbl__deregister_frame_infojpeg_set_defaultsstrcmpjinit_c_coef_controllerjpeg_write_tablesjpeg_get_small_edata_PROCEDURE_LINKAGE_TABLE_fopenmemsetjinit_forward_dctjpeg_default_colorspacejinit_compress_master_etext_lib_versionjinit_memory_mgrjpeg_suppress_tablesfflushjinit_read_bmpjpeg_CreateCompress_ctypemain.udivjinit_read_targajpeg_mem_term.div__filbufread_scan_scriptmemcpyread_stdinstrlen_finijpeg_get_largejpeg_finish_compressjcopy_sample_rowsjpeg_quality_scalingfprintfjpeg_natural_orderas: WorkShop Compilers 4.X dev 18 Sep 1996 as: WorkShop Compilers 4.X dev 18 Sep 1996 @(#)SunOS 5.6 Generic August 1997as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 ld: Software Generation Utilities - Solaris/ELF (3.0); <I4œ,Ù d™,"d™,,<;€e€€®€Ï€õ€A€€³€Ý€€(€B€]€~€·€Ú€þ€(€<‚F‚]‚u‚z‚’‚¦‚»‚Ѐ€€Ž€.€¢„‚¢¢¢¢¢’‚¢¢¢¢£‚¢®‚¢º‚À .€ ƒ€ ý€-€z€Á€¶€”€€€‘€‚€<€†€å€?€¯€€n€ï€ ,€!€!ƒ€#q€$b€¢$÷‚%€v% €¨%5€ó%K€ ¢%`‚%h€&j€&…€¢'=€2'Q€3'e€4'y€5'€6'¢€( €(€L( €)&€)|$i™,)“@h)§@h )¸$4)¹$~™`)Ð@})Ü@} )í$L)î€*<$™¬*O@Á*m@Á *w@Á *ˆ$H*‰$Ï™ô*œ@Î*­$T*®$ášH*¿@ß*Ð@ß*Þ@ß*ô@à+ @à+$œ+$ÿšä+0@þ+<$+=$'›ô+N@&+Y$è+Z$RœÜ+s@Q+}@Q+$(+$ž+©@}+³@}+Á@~+Î@~+Ù$¬+Ú$ù¡°+ø@ø,@ø,$H,$ ¡ø,7@ ,E@ ,Q$H,R$¢@,r@,€$€,$4¢À,£@3,µ@3,Æ$(,Ç(PÓ,Ød£è.interp.hash.dynsym.dynstr.SUNW_version.rela.bss.rela.plt.text.init.fini.rodata.got.plt.dynamic.data.ctors.dtors.eh_frame.bss.symtab.strtab.comment.stab.index.stab.shstrtab.stab.indexstr.stabstrvalues-Xa.cXt ; O ; V=3.1 ; R=WorkShop Compilers 4.2 30 Oct 1996 C 4.2/space/respin/usr/src/lib/libc; /ws/on297-tools/SUNWspro/SC4.2/bin/../SC4.2/bin/cc -xO3 -xcg89 -Wa,-cg92 -xspace -W0,-Lt -Xt -Iinc -DTEXT_DOMAIN='"SUNW_OST_OSLIB"' -I/space/respin/proto/root_sparc/usr/include -c port/gen/values-Xa.c -W0,-xpframe.c/ext1/SOURCES/gcc-2.8.1/./frame.cgcc2_compiled.int:t(0,1)=r(0,1);-2147483648;2147483647;char:t(0,2)=r(0,2);0;127;long int:t(0,3)=r(0,3);-2147483648;2147483647;unsigned int:t(0,4)=r(0,4);0;-1;long unsigned int:t(0,5)=r(0,5);0;-1;long long int:t(0,6)=r(0,1);01000000000000000000000;0777777777777777777777;long long unsigned int:t(0,7)=r(0,1);0000000000000;01777777777777777777777;short int:t(0,8)=r(0,8);-32768;32767;short unsigned int:t(0,9)=r(0,9);0;65535;signed char:t(0,10)=r(0,10);-128;127;unsigned char:t(0,11)=r(0,11);0;255;float:t(0,12)=r(0,1);4;0;double:t(0,13)=r(0,1);8;0;long double:t(0,14)=r(0,1);16;0;complex int:t(0,15)=s8real:(0,1),0,32;imag:(0,1),32,32;;complex float:t(0,16)=r(0,16);4;0;complex double:t(0,17)=r(0,17);8;0;complex long double:t(0,18)=r(0,18);16;0;void:t(0,19)=(0,19)tconfig.hconfig/sparc/xm-sol2.hconfig/sparc/xm-sysv4.htm.hconfig/sparc/sol2-sld.hconfig/sparc/sol2.hconfig/sparc/sysv4.hconfig/sparc/sparc.hcmodel:T(8,1)=eCM_32:0,CM_MEDLOW:1,CM_MEDMID:2,CM_MEDANY:3,CM_EMBMEDANY:4,;processor_type:T(8,2)=ePROCESSOR_V7:0,PROCESSOR_CYPRESS:1,PROCESSOR_V8:2,PROCESSOR_SUPERSPARC:3,PROCESSOR_SPARCLITE:4,PROCESSOR_F930:5,PROCESSOR_F934:6,PROCESSOR_SPARCLET:7,PROCESSOR_TSC701:8,PROCESSOR_V8PLUS:9,PROCESSOR_V9:10,PROCESSOR_ULTRASPARC:11,;sparc_cpu_select:T(8,3)=s16string:(8,4)=*(0,2),0,32;name:(8,4),32,32;set_tune_p:(0,1),64,32;set_arch_p:(0,1),96,32;;reg_class:T(8,5)=eNO_REGS:0,FPCC_REGS:1,GENERAL_REGS:2,FP_REGS:3,EXTRA_FP_REGS:4,GENERAL_OR_FP_REGS:5,GENERAL_OR_EXTRA_FP_REGS:6,ALL_REGS:7,LIM_REG_CLASSES:8,;sparc_args:T(8,6)=s12words:(0,1),0,32;prototype_p:(0,1),32,32;libcall_p:(0,1),64,32;;config/svr4.hconfig/xm-svr4.hdefaults.hgansidecl.hdwarf2.hdwarf_tag:T(13,1)=eDW_TAG_padding:0,DW_TAG_array_type:1,DW_TAG_class_type:2,DW_TAG_entry_point:3,DW_TAG_enumeration_type:4,DW_TAG_formal_parameter:5,DW_TAG_imported_declaration:8,DW_TAG_label:10,DW_TAG_lexical_block:11,DW_TAG_member:13,DW_TAG_pointer_type:15,DW_TAG_reference_type:16,DW_TAG_compile_unit:17,DW_TAG_string_type:18,DW_TAG_structure_type:19,DW_TAG_subroutine_type:21,DW_TAG_typedef:22,DW_TAG_union_type:23,DW_TAG_unspecified_parameters:24,DW_TAG_variant:25,DW_TAG_common_block:26,DW_TAG_common_inclusion:27,DW_TAG_inheritance:28,DW_TAG_inlined_subroutine:29,DW_TAG_module:30,DW_TAG_ptr_to_member_type:31,\DW_TAG_set_type:32,DW_TAG_subrange_type:33,DW_TAG_with_stmt:34,DW_TAG_access_declaration:35,DW_TAG_base_type:36,DW_TAG_catch_block:37,DW_TAG_const_type:38,DW_TAG_constant:39,DW_TAG_enumerator:40,DW_TAG_file_type:41,DW_TAG_friend:42,DW_TAG_namelist:43,DW_TAG_namelist_item:44,DW_TAG_packed_type:45,DW_TAG_subprogram:46,DW_TAG_template_type_param:47,DW_TAG_template_value_param:48,DW_TAG_thrown_type:49,DW_TAG_try_block:50,DW_TAG_variant_part:51,DW_TAG_variable:52,DW_TAG_volatile_type:53,DW_TAG_MIPS_loop:16513,DW_TAG_format_label:16641,DW_TAG_function_template:16642,DW_TAG_class_template:16643,;dwarf_form:T(13,2)=eDW_FORM_addr:1,DW_FORM_block2:3,DW_FORM_block4:4,DW_FORM_data2:5,DW_FORM_data4:6,DW_FORM_data8:7,DW_FORM_string:8,DW_FORM_block:9,DW_FORM_block1:10,DW_FORM_data1:11,DW_FORM_flag:12,DW_FORM_sdata:13,DW_FORM_strp:14,DW_FORM_udata:15,DW_FORM_ref_addr:16,DW_FORM_ref1:17,DW_FORM_ref2:18,DW_FORM_ref4:19,DW_FORM_ref8:20,DW_FORM_ref_udata:21,DW_FORM_indirect:22,;dwarf_attribute:T(13,3)=eDW_AT_sibling:1,DW_AT_location:2,DW_AT_name:3,DW_AT_ordering:9,DW_AT_subscr_data:10,DW_AT_byte_size:11,DW_AT_bit_offset:12,DW_AT_bit_size:13,DW_AT_element_list:15,DW_AT_stmt_list:16,DW_AT_low_pc:17,DW_AT_high_pc:18,DW_AT_language:19,DW_AT_member:20,DW_AT_discr:21,DW_AT_discr_value:22,DW_AT_visibility:23,DW_AT_import:24,DW_AT_string_length:25,DW_AT_common_reference:26,DW_AT_comp_dir:27,DW_AT_const_value:28,DW_AT_containing_type:29,DW_AT_default_value:30,DW_AT_inline:32,DW_AT_is_optional:33,DW_AT_lower_bound:34,DW_AT_producer:37,\DW_AT_prototyped:39,DW_AT_return_addr:42,DW_AT_start_scope:44,DW_AT_stride_size:46,DW_AT_upper_bound:47,DW_AT_abstract_origin:49,DW_AT_accessibility:50,DW_AT_address_class:51,DW_AT_artificial:52,DW_AT_base_types:53,DW_AT_calling_convention:54,DW_AT_count:55,DW_AT_data_member_location:56,DW_AT_decl_column:57,DW_AT_decl_file:58,DW_AT_decl_line:59,DW_AT_declaration:60,DW_AT_discr_list:61,DW_AT_encoding:62,DW_AT_external:63,DW_AT_frame_base:64,DW_AT_friend:65,DW_AT_identifier_case:66,DW_AT_macro_info:67,DW_AT_namelist_items:68,DW_AT_priority:69,DW_AT_segment:70,DW_AT_specification:71,\DW_AT_static_link:72,DW_AT_type:73,DW_AT_use_location:74,DW_AT_variable_parameter:75,DW_AT_virtuality:76,DW_AT_vtable_elem_location:77,DW_AT_MIPS_fde:8193,DW_AT_MIPS_loop_begin:8194,DW_AT_MIPS_tail_loop_begin:8195,DW_AT_MIPS_epilog_begin:8196,DW_AT_MIPS_loop_unroll_factor:8197,DW_AT_MIPS_software_pipeline_depth:8198,DW_AT_MIPS_linkage_name:8199,DW_AT_MIPS_stride:8200,DW_AT_MIPS_abstract_name:8201,DW_AT_MIPS_clone_origin:8202,DW_AT_MIPS_has_inlines:8203,DW_AT_sf_names:8449,DW_AT_src_info:8450,DW_AT_mac_info:8451,DW_AT_src_coords:8452,DW_AT_body_begin:8453,DW_AT_body_end:8454,;dwarf_location_atom:T(13,4)=eDW_OP_addr:3,DW_OP_deref:6,DW_OP_const1u:8,DW_OP_const1s:9,DW_OP_const2u:10,DW_OP_const2s:11,DW_OP_const4u:12,DW_OP_const4s:13,DW_OP_const8u:14,DW_OP_const8s:15,DW_OP_constu:16,DW_OP_consts:17,DW_OP_dup:18,DW_OP_drop:19,DW_OP_over:20,DW_OP_pick:21,DW_OP_swap:22,DW_OP_rot:23,DW_OP_xderef:24,DW_OP_abs:25,DW_OP_and:26,DW_OP_div:27,DW_OP_minus:28,DW_OP_mod:29,DW_OP_mul:30,DW_OP_neg:31,DW_OP_not:32,DW_OP_or:33,DW_OP_plus:34,DW_OP_plus_uconst:35,DW_OP_shl:36,DW_OP_shr:37,\DW_OP_shra:38,DW_OP_xor:39,DW_OP_bra:40,DW_OP_eq:41,DW_OP_ge:42,DW_OP_gt:43,DW_OP_le:44,DW_OP_lt:45,DW_OP_ne:46,DW_OP_skip:47,DW_OP_lit0:48,DW_OP_lit1:49,DW_OP_lit2:50,DW_OP_lit3:51,DW_OP_lit4:52,DW_OP_lit5:53,DW_OP_lit6:54,DW_OP_lit7:55,DW_OP_lit8:56,DW_OP_lit9:57,DW_OP_lit10:58,DW_OP_lit11:59,DW_OP_lit12:60,DW_OP_lit13:61,DW_OP_lit14:62,DW_OP_lit15:63,DW_OP_lit16:64,DW_OP_lit17:65,DW_OP_lit18:66,DW_OP_lit19:67,DW_OP_lit20:68,DW_OP_lit21:69,DW_OP_lit22:70,DW_OP_lit23:71,\DW_OP_lit24:72,DW_OP_lit25:73,DW_OP_lit26:74,DW_OP_lit27:75,DW_OP_lit28:76,DW_OP_lit29:77,DW_OP_lit30:78,DW_OP_lit31:79,DW_OP_reg0:80,DW_OP_reg1:81,DW_OP_reg2:82,DW_OP_reg3:83,DW_OP_reg4:84,DW_OP_reg5:85,DW_OP_reg6:86,DW_OP_reg7:87,DW_OP_reg8:88,DW_OP_reg9:89,DW_OP_reg10:90,DW_OP_reg11:91,DW_OP_reg12:92,DW_OP_reg13:93,DW_OP_reg14:94,DW_OP_reg15:95,DW_OP_reg16:96,DW_OP_reg17:97,DW_OP_reg18:98,DW_OP_reg19:99,DW_OP_reg20:100,DW_OP_reg21:101,DW_OP_reg22:102,DW_OP_reg23:103,DW_OP_reg24:104,\DW_OP_reg25:105,DW_OP_reg26:106,DW_OP_reg27:107,DW_OP_reg28:108,DW_OP_reg29:109,DW_OP_reg30:110,DW_OP_reg31:111,DW_OP_breg0:112,DW_OP_breg1:113,DW_OP_breg2:114,DW_OP_breg3:115,DW_OP_breg4:116,DW_OP_breg5:117,DW_OP_breg6:118,DW_OP_breg7:119,DW_OP_breg8:120,DW_OP_breg9:121,DW_OP_breg10:122,DW_OP_breg11:123,DW_OP_breg12:124,DW_OP_breg13:125,DW_OP_breg14:126,DW_OP_breg15:127,DW_OP_breg16:128,DW_OP_breg17:129,DW_OP_breg18:130,DW_OP_breg19:131,DW_OP_breg20:132,DW_OP_breg21:133,DW_OP_breg22:134,DW_OP_breg23:135,DW_OP_breg24:136,\DW_OP_breg25:137,DW_OP_breg26:138,DW_OP_breg27:139,DW_OP_breg28:140,DW_OP_breg29:141,DW_OP_breg30:142,DW_OP_breg31:143,DW_OP_regx:144,DW_OP_fbreg:145,DW_OP_bregx:146,DW_OP_piece:147,DW_OP_deref_size:148,DW_OP_xderef_size:149,DW_OP_nop:150,;dwarf_type:T(13,5)=eDW_ATE_void:0,DW_ATE_address:1,DW_ATE_boolean:2,DW_ATE_complex_float:3,DW_ATE_float:4,DW_ATE_signed:5,DW_ATE_signed_char:6,DW_ATE_unsigned:7,DW_ATE_unsigned_char:8,;dwarf_array_dim_ordering:T(13,6)=eDW_ORD_row_major:0,DW_ORD_col_major:1,;dwarf_access_attribute:T(13,7)=eDW_ACCESS_public:1,DW_ACCESS_protected:2,DW_ACCESS_private:3,;dwarf_visibility_attribute:T(13,8)=eDW_VIS_local:1,DW_VIS_exported:2,DW_VIS_qualified:3,;dwarf_virtuality_attribute:T(13,9)=eDW_VIRTUALITY_none:0,DW_VIRTUALITY_virtual:1,DW_VIRTUALITY_pure_virtual:2,;dwarf_id_case:T(13,10)=eDW_ID_case_sensitive:0,DW_ID_up_case:1,DW_ID_down_case:2,DW_ID_case_insensitive:3,;dwarf_calling_convention:T(13,11)=eDW_CC_normal:1,DW_CC_program:2,DW_CC_nocall:3,;dwarf_inline_attribute:T(13,12)=eDW_INL_not_inlined:0,DW_INL_inlined:1,DW_INL_declared_not_inlined:2,DW_INL_declared_inlined:3,;dwarf_discrim_list:T(13,13)=eDW_DSC_label:0,DW_DSC_range:1,;dwarf_line_number_ops:T(13,14)=eDW_LNS_extended_op:0,DW_LNS_copy:1,DW_LNS_advance_pc:2,DW_LNS_advance_line:3,DW_LNS_set_file:4,DW_LNS_set_column:5,DW_LNS_negate_stmt:6,DW_LNS_set_basic_block:7,DW_LNS_const_add_pc:8,DW_LNS_fixed_advance_pc:9,;dwarf_line_number_x_ops:T(13,15)=eDW_LNE_end_sequence:1,DW_LNE_set_address:2,DW_LNE_define_file:3,;dwarf_call_frame_info:T(13,16)=eDW_CFA_advance_loc:64,DW_CFA_offset:128,DW_CFA_restore:192,DW_CFA_nop:0,DW_CFA_set_loc:1,DW_CFA_advance_loc1:2,DW_CFA_advance_loc2:3,DW_CFA_advance_loc4:4,DW_CFA_offset_extended:5,DW_CFA_restore_extended:6,DW_CFA_undefined:7,DW_CFA_same_value:8,DW_CFA_register:9,DW_CFA_remember_state:10,DW_CFA_restore_state:11,DW_CFA_def_cfa:12,DW_CFA_def_cfa_register:13,DW_CFA_def_cfa_offset:14,DW_CFA_MIPS_advance_loc8:29,DW_CFA_GNU_window_save:45,DW_CFA_GNU_args_size:46,;dwarf_source_language:T(13,17)=eDW_LANG_C89:1,DW_LANG_C:2,DW_LANG_Ada83:3,DW_LANG_C_plus_plus:4,DW_LANG_Cobol74:5,DW_LANG_Cobol85:6,DW_LANG_Fortran77:7,DW_LANG_Fortran90:8,DW_LANG_Pascal83:9,DW_LANG_Modula2:10,DW_LANG_Mips_Assembler:32769,;dwarf_macinfo_record_type:T(13,18)=eDW_MACINFO_define:1,DW_MACINFO_undef:2,DW_MACINFO_start_file:3,DW_MACINFO_end_file:4,DW_MACINFO_vendor_ext:255,;include/stddef.hptrdiff_t:t(14,1)=(0,1)size_t:t(14,2)=(0,4)wchar_t:t(14,3)=(0,3)wint_t:t(14,4)=(0,4)frame.hframe_state:T(15,1)=s532cfa:(15,2)=*(0,19),0,32;eh_ptr:(15,2),32,32;cfa_offset:(0,3),64,32;args_size:(0,3),96,32;reg_or_offset:(15,3)=ar(0,0);0;101;(0,3),128,3264;cfa_reg:(0,9),3392,16;retaddr_column:(0,9),3408,16;saved:(15,4)=ar(0,0);0;101;(0,2),3424,816;;frame_state:t(15,5)=(15,1)object:T(15,6)=s24pc_begin:(15,2),0,32;pc_end:(15,2),32,32;fde_begin:(15,7)=*(15,8)=xsdwarf_fde:,64,32;fde_array:(15,9)=*(15,7),96,32;count:(14,2),128,32;next:(15,10)=*(15,6),160,32;;sword:t(0,20)=(0,1)uword:t(0,21)=(0,4)uaddr:t(0,22)=(0,4)saddr:t(0,23)=(0,1)ubyte:t(0,24)=(0,11)dwarf_cie:T(0,25)=s12length:(0,21),0,32;CIE_id:(0,20),32,32;version:(0,24),64,8;augmentation:(0,26)=ar(0,0);0;-1;(0,2),72,0;;dwarf_fde:T(15,8)=s16length:(0,21),0,32;CIE_delta:(0,20),32,32;pc_begin:(15,2),64,32;pc_range:(0,22),96,32;;fde:t(0,27)=(15,8)cie_info:T(0,28)=s20augmentation:(8,4),0,32;eh_ptr:(15,2),32,32;code_align:(0,1),64,32;data_align:(0,1),96,32;ra_regno:(0,4),128,32;;frame_state_internal:T(0,29)=s536s:(15,1),0,4256;saved_state:(0,30)=*(0,29),4256,32;;decode_uleb128:f(15,2)buf:P(0,31)=*(0,11)r:P(0,32)=*(0,4)decode_sleb128:f(15,2)buf:P(0,31)r:P(0,33)=*(0,1)unaligned:T(0,34)=u8p:(15,2),0,32;b2:(0,9),0,16;b4:(0,4),0,32;b8:(0,7),0,64;;fde_insert:f(0,19)array:P(0,35)=*(0,36)=*(0,27)i:P(14,2)this_fde:P(0,36)count_fdes:f(14,2)this_fde:P(0,36)add_fdes:f(0,19)this_fde:P(0,36)array:P(0,35)i_ptr:P(0,37)=*(14,2)beg_ptr:P(0,38)=*(15,2)end_ptr:P(0,38)frame_init:f(0,19)ob:P(15,10)find_fde:f(0,36)pc:P(15,2)extract_cie_info:f(15,2)f:P(0,36)c:P(0,39)=*(0,28)execute_cfa_insn:f(15,2)p:P(15,2)state:P(0,30)info:P(0,39)pc:P(0,38)__register_frame_info:F(0,19)begin:P(15,2)ob:P(15,10)__register_frame_info_table:F(0,19)begin:P(15,2)ob:P(15,10)__deregister_frame_info:F(0,19)begin:P(15,2)__frame_state_for:F(0,40)=*(15,1)pc_target:P(15,2)state_in:P(0,40)objects:S(15,10)ÔÔ èè¨     Soÿÿþôô -$ 788D  A||†ÌG¤H¤HM¤d¤dS¤x¤x*»[Ï4Ï4 `ÏTÏTx eÐÌÐ̨nÑtÑttÑ|Ñ|{Ñ„Ñ„‚ььTŒÒàÒà€‘Òà°&™ì¶¡F ª d$ ¶ ˆ\ ¼äÞÆÂ;Õý,ÙPapyrus3/JpegDir/JpgLossy/Makefile0000755000175000017500000000267007535143454014304 0ustar # @(#)Makefile 1.3 5/3/91 ARCH= Solaris DSTDIR= .. MANDIR= $(DSTDIR)/man INCDIR= $(DSTDIR)/include BINDIR= $(DSTDIR)/test LIBDIR= ../$(DSTDIR)/$(ARCH)/lib LINTLIBDIR= $(LIBDIR)/lint CPPFLAGS= -I$(INCDIR) -I../.. -D_NO_LONGLONG CFLAGS= -g LINTFLAGS= -hb SOURCES= jcapimin.c \ jcapistd.c \ jccoefct.c \ jccolor.c \ jcdctmgr.c \ jchuff.c \ jcinit.c \ jcmainct.c \ jcmaster.c \ jcmarker.c \ jcomapi.c \ jcparam.c \ jcphuff.c \ jcprepct.c \ jcsample.c \ jdapimin.c \ jdapistd.c \ jdatadst.c \ jdatasrc.c \ jdcoefct.c \ jdcolor.c \ jddctmgr.c \ jdhuff.c \ jdinput.c \ jdmainct.c \ jdmarker.c \ jdmaster.c \ jdmerge.c \ jdphuff.c \ jdpostct.c \ jdsample.c \ jerror.c \ jfdctint.c \ jfdctflt.c \ jfdctfst.c \ jidctflt.c \ jidctfst.c \ jidctint.c \ jidctred.c \ jmemmgr.c \ jmemnobs.c \ jquant1.c \ jquant2.c \ jutils.c \ rdcolmap.c LIBRARY= libJpglossy.a OBJECTS= $(SOURCES:%.c=$(ARCH)/%.o) $(LIBDIR)/$(LIBRARY): createdir $(OBJECTS) ar rv $@ $(OBJECTS) lint: $(SOURCES) $(LINT.c) $(SOURCES) createdir: test -d $(ARCH) || mkdir -p $(ARCH) test -d $(DSTDIR)/$(ARCH)/lib || mkdir -p $(DSTDIR)/$(ARCH)/lib clean: -rm -Rf $(ARCH) .KEEP_STATE: .INIT: $(LIBDIR) $(ARCH) $(LIBDIR) $(ARCH) : test -d $@ || mkdir -p $@ $(ARCH)/%.o: %.c $(COMPILE.c) $< -o $@ Papyrus3/JpegDir/JpgLossy/JCAPIMIN.C0000755000175000017500000002227507535143454014145 0ustar /* * jcapimin.c * * Copyright (C) 1994-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains application interface code for the compression half * of the JPEG library. These are the "minimum" API routines that may be * needed in either the normal full-compression case or the transcoding-only * case. * * Most of the routines intended to be called directly by an application * are in this file or in jcapistd.c. But also see jcparam.c for * parameter-setup helper routines, jcomapi.c for routines shared by * compression and decompression, and jctrans.c for the transcoding case. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* * Initialization of a JPEG compression object. * The error manager must already be set up (in case memory manager fails). */ GLOBAL(void) jpeg_CreateCompress (j_compress_ptr cinfo, int version, size_t structsize) { int i; /* Guard against version mismatches between library and caller. */ cinfo->mem = NULL; /* so jpeg_destroy knows mem mgr not called */ if (version != JPEG_LIB_VERSION) ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version); if (structsize != SIZEOF(struct jpeg_compress_struct)) ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE, (int) SIZEOF(struct jpeg_compress_struct), (int) structsize); /* For debugging purposes, we zero the whole master structure. * But the application has already set the err pointer, and may have set * client_data, so we have to save and restore those fields. * Note: if application hasn't set client_data, tools like Purify may * complain here. */ { struct jpeg_error_mgr * err = cinfo->err; void * client_data = cinfo->client_data; /* ignore Purify complaint here */ MEMZERO(cinfo, SIZEOF(struct jpeg_compress_struct)); cinfo->err = err; cinfo->client_data = client_data; } cinfo->is_decompressor = FALSE; /* Initialize a memory manager instance for this object */ jinit_memory_mgr((j_common_ptr) cinfo); /* Zero out pointers to permanent structures. */ cinfo->progress = NULL; cinfo->dest = NULL; cinfo->comp_info = NULL; for (i = 0; i < NUM_QUANT_TBLS; i++) cinfo->quant_tbl_ptrs[i] = NULL; for (i = 0; i < NUM_HUFF_TBLS; i++) { cinfo->dc_huff_tbl_ptrs[i] = NULL; cinfo->ac_huff_tbl_ptrs[i] = NULL; } cinfo->script_space = NULL; cinfo->input_gamma = 1.0; /* in case application forgets */ /* OK, I'm ready */ cinfo->global_state = CSTATE_START; } /* * Destruction of a JPEG compression object */ GLOBAL(void) jpeg_destroy_compress (j_compress_ptr cinfo) { jpeg_destroy((j_common_ptr) cinfo); /* use common routine */ } /* * Abort processing of a JPEG compression operation, * but don't destroy the object itself. */ GLOBAL(void) jpeg_abort_compress (j_compress_ptr cinfo) { jpeg_abort((j_common_ptr) cinfo); /* use common routine */ } /* * Forcibly suppress or un-suppress all quantization and Huffman tables. * Marks all currently defined tables as already written (if suppress) * or not written (if !suppress). This will control whether they get emitted * by a subsequent jpeg_start_compress call. * * This routine is exported for use by applications that want to produce * abbreviated JPEG datastreams. It logically belongs in jcparam.c, but * since it is called by jpeg_start_compress, we put it here --- otherwise * jcparam.o would be linked whether the application used it or not. */ GLOBAL(void) jpeg_suppress_tables (j_compress_ptr cinfo, boolean suppress) { int i; JQUANT_TBL * qtbl; JHUFF_TBL * htbl; for (i = 0; i < NUM_QUANT_TBLS; i++) { if ((qtbl = cinfo->quant_tbl_ptrs[i]) != NULL) qtbl->sent_table = suppress; } for (i = 0; i < NUM_HUFF_TBLS; i++) { if ((htbl = cinfo->dc_huff_tbl_ptrs[i]) != NULL) htbl->sent_table = suppress; if ((htbl = cinfo->ac_huff_tbl_ptrs[i]) != NULL) htbl->sent_table = suppress; } } /* * Finish JPEG compression. * * If a multipass operating mode was selected, this may do a great deal of * work including most of the actual output. */ GLOBAL(void) jpeg_finish_compress (j_compress_ptr cinfo) { JDIMENSION iMCU_row; if (cinfo->global_state == CSTATE_SCANNING || cinfo->global_state == CSTATE_RAW_OK) { /* Terminate first pass */ if (cinfo->next_scanline < cinfo->image_height) ERREXIT(cinfo, JERR_TOO_LITTLE_DATA); (*cinfo->master->finish_pass) (cinfo); } else if (cinfo->global_state != CSTATE_WRCOEFS) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); /* Perform any remaining passes */ while (! cinfo->master->is_last_pass) { (*cinfo->master->prepare_for_pass) (cinfo); for (iMCU_row = 0; iMCU_row < cinfo->total_iMCU_rows; iMCU_row++) { if (cinfo->progress != NULL) { cinfo->progress->pass_counter = (long) iMCU_row; cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows; (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); } /* We bypass the main controller and invoke coef controller directly; * all work is being done from the coefficient buffer. */ if (! (*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE) NULL)) ERREXIT(cinfo, JERR_CANT_SUSPEND); } (*cinfo->master->finish_pass) (cinfo); } /* Write EOI, do final cleanup */ (*cinfo->marker->write_file_trailer) (cinfo); (*cinfo->dest->term_destination) (cinfo); /* We can use jpeg_abort to release memory and reset global_state */ /*jpeg_abort((j_common_ptr) cinfo);*/ } /* * Write a special marker. * This is only recommended for writing COM or APPn markers. * Must be called after jpeg_start_compress() and before * first call to jpeg_write_scanlines() or jpeg_write_raw_data(). */ GLOBAL(void) jpeg_write_marker (j_compress_ptr cinfo, int marker, const JOCTET *dataptr, unsigned int datalen) { JMETHOD(void, write_marker_byte, (j_compress_ptr info, int val)); if (cinfo->next_scanline != 0 || (cinfo->global_state != CSTATE_SCANNING && cinfo->global_state != CSTATE_RAW_OK && cinfo->global_state != CSTATE_WRCOEFS)) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); (*cinfo->marker->write_marker_header) (cinfo, marker, datalen); write_marker_byte = cinfo->marker->write_marker_byte; /* copy for speed */ while (datalen--) { (*write_marker_byte) (cinfo, *dataptr); dataptr++; } } /* Same, but piecemeal. */ GLOBAL(void) jpeg_write_m_header (j_compress_ptr cinfo, int marker, unsigned int datalen) { if (cinfo->next_scanline != 0 || (cinfo->global_state != CSTATE_SCANNING && cinfo->global_state != CSTATE_RAW_OK && cinfo->global_state != CSTATE_WRCOEFS)) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); (*cinfo->marker->write_marker_header) (cinfo, marker, datalen); } GLOBAL(void) jpeg_write_m_byte (j_compress_ptr cinfo, int val) { (*cinfo->marker->write_marker_byte) (cinfo, val); } /* * Alternate compression function: just write an abbreviated table file. * Before calling this, all parameters and a data destination must be set up. * * To produce a pair of files containing abbreviated tables and abbreviated * image data, one would proceed as follows: * * initialize JPEG object * set JPEG parameters * set destination to table file * jpeg_write_tables(cinfo); * set destination to image file * jpeg_start_compress(cinfo, FALSE); * write data... * jpeg_finish_compress(cinfo); * * jpeg_write_tables has the side effect of marking all tables written * (same as jpeg_suppress_tables(..., TRUE)). Thus a subsequent start_compress * will not re-emit the tables unless it is passed write_all_tables=TRUE. */ GLOBAL(void) jpeg_write_tables (j_compress_ptr cinfo) { if (cinfo->global_state != CSTATE_START) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); /* (Re)initialize error mgr and destination modules */ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo); (*cinfo->dest->init_destination) (cinfo); /* Initialize the marker writer ... bit of a crock to do it here. */ jinit_marker_writer(cinfo); /* Write them tables! */ (*cinfo->marker->write_tables_only) (cinfo); /* And clean up. */ (*cinfo->dest->term_destination) (cinfo); /* * In library releases up through v6a, we called jpeg_abort() here to free * any working memory allocated by the destination manager and marker * writer. Some applications had a problem with that: they allocated space * of their own from the library memory manager, and didn't want it to go * away during write_tables. So now we do nothing. This will cause a * memory leak if an app calls write_tables repeatedly without doing a full * compression cycle or otherwise resetting the JPEG object. However, that * seems less bad than unexpectedly freeing memory in the normal case. * An app that prefers the old behavior can call jpeg_abort for itself after * each call to jpeg_write_tables(). */ } Papyrus3/JpegDir/JpgLossy/makljpeg.st0000755000175000017500000001045707535143454015010 0ustar ; Project file for Independent JPEG Group's software ; ; This project file is for Atari ST/STE/TT systems using Pure C or Turbo C. ; Thanks to Frank Moehle (Frank.Moehle@arbi.informatik.uni-oldenburg.de), ; Dr. B. Setzepfandt (bernd@gina.uni-muenster.de), ; and Guido Vollbeding (guivol@esc.de). ; ; To use this file, rename it to libjpeg.prj. ; Read installation instructions before trying to make the program! ; ; ; * * * Output file * * * libjpeg.lib ; ; * * * COMPILER OPTIONS * * * .C[-P] ; absolute calls .C[-M] ; and no string merging, folks .C[-w-cln] ; no "constant is long" warnings .C[-w-par] ; no "parameter xxxx unused" .C[-w-rch] ; no "unreachable code" .C[-wsig] ; warn if significant digits may be lost .L[-J] ; link new Obj-format (so we get a library) = ; * * * * List of modules * * * * jcapimin.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jcapistd.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jccoefct.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jccolor.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jcdctmgr.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jdct.h) jchuff.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jchuff.h) jcinit.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jcmainct.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jcmarker.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jcmaster.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jcomapi.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jcparam.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jcphuff.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jchuff.h) jcprepct.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jcsample.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jctrans.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jdapimin.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jdapistd.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jdatadst.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h) jdatasrc.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h) jdcoefct.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jdcolor.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jddctmgr.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jdct.h) jdhuff.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jdhuff.h) jdinput.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jdmainct.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jdmarker.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jdmaster.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jdmerge.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jdphuff.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jdhuff.h) jdpostct.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jdsample.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jdtrans.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jerror.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jversion.h,jerror.h) jfdctflt.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jdct.h) jfdctfst.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jdct.h) jfdctint.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jdct.h) jidctflt.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jdct.h) jidctfst.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jdct.h) jidctint.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jdct.h) jidctred.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jdct.h) jquant1.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jquant2.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jutils.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h) jmemmgr.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jmemsys.h) jmemansi.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,jmemsys.h) Papyrus3/JpegDir/JpgLossy/jconfig.sas0000755000175000017500000000227507535143454014774 0ustar /* jconfig.sas --- jconfig.h for Amiga systems using SAS C 6.0 and up. */ /* see jconfig.doc for explanations */ #define HAVE_PROTOTYPES #define HAVE_UNSIGNED_CHAR #define HAVE_UNSIGNED_SHORT /* #define void char */ /* #define const */ #undef CHAR_IS_UNSIGNED #define HAVE_STDDEF_H #define HAVE_STDLIB_H #undef NEED_BSD_STRINGS #undef NEED_SYS_TYPES_H #undef NEED_FAR_POINTERS #undef NEED_SHORT_EXTERNAL_NAMES #undef INCOMPLETE_TYPES_BROKEN #ifdef JPEG_INTERNALS #undef RIGHT_SHIFT_IS_UNSIGNED #define TEMP_DIRECTORY "JPEGTMP:" /* recommended setting for Amiga */ #define NO_MKTEMP /* SAS C doesn't have mktemp() */ #define SHORTxSHORT_32 /* produces better DCT code with SAS C */ #endif /* JPEG_INTERNALS */ #ifdef JPEG_CJPEG_DJPEG #define BMP_SUPPORTED /* BMP image file format */ #define GIF_SUPPORTED /* GIF image file format */ #define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ #undef RLE_SUPPORTED /* Utah RLE image file format */ #define TARGA_SUPPORTED /* Targa image file format */ #define TWO_FILE_COMMANDLINE #define NEED_SIGNAL_CATCHER #undef DONT_USE_B_MODE #undef PROGRESS_REPORT /* optional */ #endif /* JPEG_CJPEG_DJPEG */ Papyrus3/JpegDir/JpgLossy/config.status0000755000175000017500000002077207535143454015361 0ustar #! /bin/sh # Generated automatically by configure. # Run this file to recreate the current configuration. # This directory was configured as follows, # on host cih_ws41: # # configure # # Compiler output produced by configure, useful for debugging # configure, is in ./config.log if it exists. ac_cs_usage="Usage: ./config.status [--recheck] [--version] [--help]" for ac_option do case "$ac_option" in -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) echo "running ${CONFIG_SHELL-/bin/sh} configure --no-create --no-recursion" exec ${CONFIG_SHELL-/bin/sh} configure --no-create --no-recursion ;; -version | --version | --versio | --versi | --vers | --ver | --ve | --v) echo "./config.status generated by autoconf version 2.12" exit 0 ;; -help | --help | --hel | --he | --h) echo "$ac_cs_usage"; exit 0 ;; *) echo "$ac_cs_usage"; exit 1 ;; esac done ac_given_srcdir=. ac_given_INSTALL="./install-sh -c" trap 'rm -fr Makefile jconfig.h conftest*; exit 1' 1 2 15 # Protect against being on the right side of a sed subst in config.status. sed 's/%@/@@/; s/@%/@@/; s/%g$/@g/; /@g$/s/[\\&%]/\\&/g; s/@@/%@/; s/@@/@%/; s/@g$/%g/' > conftest.subs <<\CEOF /^[ ]*VPATH[ ]*=[^:]*$/d s%@CFLAGS@%-O2%g s%@CPPFLAGS@%%g s%@CXXFLAGS@%%g s%@DEFS@%-DHAVE_CONFIG_H%g s%@LDFLAGS@%%g s%@LIBS@%%g s%@exec_prefix@%${prefix}%g s%@prefix@%/usr/local%g s%@program_transform_name@%s,x,x,%g s%@bindir@%${exec_prefix}/bin%g s%@sbindir@%${exec_prefix}/sbin%g s%@libexecdir@%${exec_prefix}/libexec%g s%@datadir@%${prefix}/share%g s%@sysconfdir@%${prefix}/etc%g s%@sharedstatedir@%${prefix}/com%g s%@localstatedir@%${prefix}/var%g s%@libdir@%${exec_prefix}/lib%g s%@includedir@%${prefix}/include%g s%@oldincludedir@%/usr/include%g s%@infodir@%${prefix}/info%g s%@mandir@%${prefix}/man%g s%@CC@%gcc%g s%@CPP@%gcc -E%g s%@INSTALL_PROGRAM@%${INSTALL}%g s%@INSTALL_DATA@%${INSTALL} -m 644%g s%@RANLIB@%ranlib%g s%@LIBTOOL@%%g s%@O@%o%g s%@A@%a%g s%@LN@%$(CC)%g s%@INSTALL_LIB@%${INSTALL} -m 644%g s%@MEMORYMGR@%jmemnobs.$(O)%g s%@JPEG_LIB_VERSION@%62%g s%@A2K_DEPS@%%g s%@COM_A2K@%# %g s%@ANSI2KNRFLAGS@%%g s%@COM_LT@%# %g s%@FORCE_INSTALL_LIB@%%g s%@INCLUDEFLAGS@%-I$(srcdir)%g CEOF # Split the substitutions into bite-sized pieces for seds with # small command number limits, like on Digital OSF/1 and HP-UX. ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script. ac_file=1 # Number of current file. ac_beg=1 # First line for current file. ac_end=$ac_max_sed_cmds # Line after last line for current file. ac_more_lines=: ac_sed_cmds="" while $ac_more_lines; do if test $ac_beg -gt 1; then sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file else sed "${ac_end}q" conftest.subs > conftest.s$ac_file fi if test ! -s conftest.s$ac_file; then ac_more_lines=false rm -f conftest.s$ac_file else if test -z "$ac_sed_cmds"; then ac_sed_cmds="sed -f conftest.s$ac_file" else ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file" fi ac_file=`expr $ac_file + 1` ac_beg=$ac_end ac_end=`expr $ac_end + $ac_max_sed_cmds` fi done if test -z "$ac_sed_cmds"; then ac_sed_cmds=cat fi CONFIG_FILES=${CONFIG_FILES-"Makefile:makefile.cfg"} for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". case "$ac_file" in *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'` ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; *) ac_file_in="${ac_file}.in" ;; esac # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories. # Remove last slash and all that follows it. Not all systems have dirname. ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then # The file is in a subdirectory. test ! -d "$ac_dir" && mkdir "$ac_dir" ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`" # A "../" for each directory in $ac_dir_suffix. ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'` else ac_dir_suffix= ac_dots= fi case "$ac_given_srcdir" in .) srcdir=. if test -z "$ac_dots"; then top_srcdir=. else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;; /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;; *) # Relative path. srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix" top_srcdir="$ac_dots$ac_given_srcdir" ;; esac case "$ac_given_INSTALL" in [/$]*) INSTALL="$ac_given_INSTALL" ;; *) INSTALL="$ac_dots$ac_given_INSTALL" ;; esac echo creating "$ac_file" rm -f "$ac_file" configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure." case "$ac_file" in *Makefile*) ac_comsub="1i\\ # $configure_input" ;; *) ac_comsub= ;; esac ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"` sed -e "$ac_comsub s%@configure_input@%$configure_input%g s%@srcdir@%$srcdir%g s%@top_srcdir@%$top_srcdir%g s%@INSTALL@%$INSTALL%g " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file fi; done rm -f conftest.s* # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where # NAME is the cpp macro being defined and VALUE is the value it is being given. # # ac_d sets the value in "#define NAME VALUE" lines. ac_dA='s%^\([ ]*\)#\([ ]*define[ ][ ]*\)' ac_dB='\([ ][ ]*\)[^ ]*%\1#\2' ac_dC='\3' ac_dD='%g' # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE". ac_uA='s%^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' ac_uB='\([ ]\)%\1#\2define\3' ac_uC=' ' ac_uD='\4%g' # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE". ac_eA='s%^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' ac_eB='$%\1#\2define\3' ac_eC=' ' ac_eD='%g' if test "${CONFIG_HEADERS+set}" != set; then CONFIG_HEADERS="jconfig.h:jconfig.cfg" fi for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". case "$ac_file" in *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'` ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; *) ac_file_in="${ac_file}.in" ;; esac echo creating $ac_file rm -f conftest.frag conftest.in conftest.out ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"` cat $ac_file_inputs > conftest.in cat > conftest.frag < conftest.out rm -f conftest.in mv conftest.out conftest.in cat > conftest.frag < conftest.out rm -f conftest.in mv conftest.out conftest.in rm -f conftest.frag conftest.h echo "/* $ac_file. Generated automatically by configure. */" > conftest.h cat conftest.in >> conftest.h rm -f conftest.in if cmp -s $ac_file conftest.h 2>/dev/null; then echo "$ac_file is unchanged" rm -f conftest.h else # Remove last slash and all that follows it. Not all systems have dirname. ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then # The file is in a subdirectory. test ! -d "$ac_dir" && mkdir "$ac_dir" fi rm -f $ac_file mv conftest.h $ac_file fi fi; done exit 0 Papyrus3/JpegDir/JpgLossy/CJPEG.C0000755000175000017500000004775307535143454013613 0ustar /* * cjpeg.c * * Copyright (C) 1991-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains a command-line user interface for the JPEG compressor. * It should work on any system with Unix- or MS-DOS-style command lines. * * Two different command line styles are permitted, depending on the * compile-time switch TWO_FILE_COMMANDLINE: * cjpeg [options] inputfile outputfile * cjpeg [options] [inputfile] * In the second style, output is always to standard output, which you'd * normally redirect to a file or pipe to some other program. Input is * either from a named file or from standard input (typically redirected). * The second style is convenient on Unix but is unhelpful on systems that * don't support pipes. Also, you MUST use the first style if your system * doesn't do binary I/O to stdin/stdout. * To simplify script writing, the "-outfile" switch is provided. The syntax * cjpeg [options] -outfile outputfile inputfile * works regardless of which command line style is used. */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ #include "jversion.h" /* for version message */ #ifdef USE_CCOMMAND /* command-line reader for Macintosh */ #ifdef __MWERKS__ #include /* Metrowerks needs this */ #include /* ... and this */ #endif #ifdef THINK_C #include /* Think declares it here */ #endif #endif /* Create the add-on message string table. */ #define JMESSAGE(code,string) string , static const char * const cdjpeg_message_table[] = { #include "cderror.h" NULL }; /* * This routine determines what format the input file is, * and selects the appropriate input-reading module. * * To determine which family of input formats the file belongs to, * we may look only at the first byte of the file, since C does not * guarantee that more than one character can be pushed back with ungetc. * Looking at additional bytes would require one of these approaches: * 1) assume we can fseek() the input file (fails for piped input); * 2) assume we can push back more than one character (works in * some C implementations, but unportable); * 3) provide our own buffering (breaks input readers that want to use * stdio directly, such as the RLE library); * or 4) don't put back the data, and modify the input_init methods to assume * they start reading after the start of file (also breaks RLE library). * #1 is attractive for MS-DOS but is untenable on Unix. * * The most portable solution for file types that can't be identified by their * first byte is to make the user tell us what they are. This is also the * only approach for "raw" file types that contain only arbitrary values. * We presently apply this method for Targa files. Most of the time Targa * files start with 0x00, so we recognize that case. Potentially, however, * a Targa file could start with any byte value (byte 0 is the length of the * seldom-used ID field), so we provide a switch to force Targa input mode. */ static boolean is_targa; /* records user -targa switch */ LOCAL(cjpeg_source_ptr) select_file_type (j_compress_ptr cinfo, FILE * infile) { int c; if (is_targa) { #ifdef TARGA_SUPPORTED return jinit_read_targa(cinfo); #else ERREXIT(cinfo, JERR_TGA_NOTCOMP); #endif } if ((c = getc(infile)) == EOF) ERREXIT(cinfo, JERR_INPUT_EMPTY); if (ungetc(c, infile) == EOF) ERREXIT(cinfo, JERR_UNGETC_FAILED); switch (c) { #ifdef BMP_SUPPORTED case 'B': return jinit_read_bmp(cinfo); #endif #ifdef GIF_SUPPORTED case 'G': return jinit_read_gif(cinfo); #endif #ifdef PPM_SUPPORTED case 'P': return jinit_read_ppm(cinfo); #endif #ifdef RLE_SUPPORTED case 'R': return jinit_read_rle(cinfo); #endif #ifdef TARGA_SUPPORTED case 0x00: return jinit_read_targa(cinfo); #endif default: ERREXIT(cinfo, JERR_UNKNOWN_FORMAT); break; } return NULL; /* suppress compiler warnings */ } /* * Argument-parsing code. * The switch parser is designed to be useful with DOS-style command line * syntax, ie, intermixed switches and file names, where only the switches * to the left of a given file name affect processing of that file. * The main program in this file doesn't actually use this capability... */ static const char * progname; /* program name for error messages */ static char * outfilename; /* for -outfile switch */ LOCAL(void) usage (void) /* complain about bad command line */ { fprintf(stderr, "usage: %s [switches] ", progname); #ifdef TWO_FILE_COMMANDLINE fprintf(stderr, "inputfile outputfile\n"); #else fprintf(stderr, "[inputfile]\n"); #endif fprintf(stderr, "Switches (names may be abbreviated):\n"); fprintf(stderr, " -quality N Compression quality (0..100; 5-95 is useful range)\n"); fprintf(stderr, " -grayscale Create monochrome JPEG file\n"); #ifdef ENTROPY_OPT_SUPPORTED fprintf(stderr, " -optimize Optimize Huffman table (smaller file, but slow compression)\n"); #endif #ifdef C_PROGRESSIVE_SUPPORTED fprintf(stderr, " -progressive Create progressive JPEG file\n"); #endif #ifdef TARGA_SUPPORTED fprintf(stderr, " -targa Input file is Targa format (usually not needed)\n"); #endif fprintf(stderr, "Switches for advanced users:\n"); #ifdef DCT_ISLOW_SUPPORTED fprintf(stderr, " -dct int Use integer DCT method%s\n", (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : "")); #endif #ifdef DCT_IFAST_SUPPORTED fprintf(stderr, " -dct fast Use fast integer DCT (less accurate)%s\n", (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : "")); #endif #ifdef DCT_FLOAT_SUPPORTED fprintf(stderr, " -dct float Use floating-point DCT method%s\n", (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : "")); #endif fprintf(stderr, " -restart N Set restart interval in rows, or in blocks with B\n"); #ifdef INPUT_SMOOTHING_SUPPORTED fprintf(stderr, " -smooth N Smooth dithered input (N=1..100 is strength)\n"); #endif fprintf(stderr, " -maxmemory N Maximum memory to use (in kbytes)\n"); fprintf(stderr, " -outfile name Specify name for output file\n"); fprintf(stderr, " -verbose or -debug Emit debug output\n"); fprintf(stderr, "Switches for wizards:\n"); #ifdef C_ARITH_CODING_SUPPORTED fprintf(stderr, " -arithmetic Use arithmetic coding\n"); #endif fprintf(stderr, " -baseline Force baseline quantization tables\n"); fprintf(stderr, " -qtables file Use quantization tables given in file\n"); fprintf(stderr, " -qslots N[,...] Set component quantization tables\n"); fprintf(stderr, " -sample HxV[,...] Set component sampling factors\n"); #ifdef C_MULTISCAN_FILES_SUPPORTED fprintf(stderr, " -scans file Create multi-scan JPEG per script file\n"); #endif exit(EXIT_FAILURE); } LOCAL(int) parse_switches (j_compress_ptr cinfo, int argc, char **argv, int last_file_arg_seen, boolean for_real) /* Parse optional switches. * Returns argv[] index of first file-name argument (== argc if none). * Any file names with indexes <= last_file_arg_seen are ignored; * they have presumably been processed in a previous iteration. * (Pass 0 for last_file_arg_seen on the first or only iteration.) * for_real is FALSE on the first (dummy) pass; we may skip any expensive * processing. */ { int argn; char * arg; int quality; /* -quality parameter */ int q_scale_factor; /* scaling percentage for -qtables */ boolean force_baseline; boolean simple_progressive; char * qtablefile = NULL; /* saves -qtables filename if any */ char * qslotsarg = NULL; /* saves -qslots parm if any */ char * samplearg = NULL; /* saves -sample parm if any */ char * scansarg = NULL; /* saves -scans parm if any */ /* Set up default JPEG parameters. */ /* Note that default -quality level need not, and does not, * match the default scaling for an explicit -qtables argument. */ quality = 75; /* default -quality value */ q_scale_factor = 100; /* default to no scaling for -qtables */ force_baseline = FALSE; /* by default, allow 16-bit quantizers */ simple_progressive = FALSE; is_targa = FALSE; outfilename = NULL; cinfo->err->trace_level = 0; /* Scan command line options, adjust parameters */ for (argn = 1; argn < argc; argn++) { arg = argv[argn]; if (*arg != '-') { /* Not a switch, must be a file name argument */ if (argn <= last_file_arg_seen) { outfilename = NULL; /* -outfile applies to just one input file */ continue; /* ignore this name if previously processed */ } break; /* else done parsing switches */ } arg++; /* advance past switch marker character */ if (keymatch(arg, "arithmetic", 1)) { /* Use arithmetic coding. */ #ifdef C_ARITH_CODING_SUPPORTED cinfo->arith_code = TRUE; #else fprintf(stderr, "%s: sorry, arithmetic coding not supported\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "baseline", 1)) { /* Force baseline-compatible output (8-bit quantizer values). */ force_baseline = TRUE; } else if (keymatch(arg, "dct", 2)) { /* Select DCT algorithm. */ if (++argn >= argc) /* advance to next argument */ usage(); if (keymatch(argv[argn], "int", 1)) { cinfo->dct_method = JDCT_ISLOW; } else if (keymatch(argv[argn], "fast", 2)) { cinfo->dct_method = JDCT_IFAST; } else if (keymatch(argv[argn], "float", 2)) { cinfo->dct_method = JDCT_FLOAT; } else usage(); } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) { /* Enable debug printouts. */ /* On first -d, print version identification */ static boolean printed_version = FALSE; if (! printed_version) { fprintf(stderr, "Independent JPEG Group's CJPEG, version %s\n%s\n", JVERSION, JCOPYRIGHT); printed_version = TRUE; } cinfo->err->trace_level++; } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) { /* Force a monochrome JPEG file to be generated. */ jpeg_set_colorspace(cinfo, JCS_GRAYSCALE); } else if (keymatch(arg, "maxmemory", 3)) { /* Maximum memory in Kb (or Mb with 'm'). */ long lval; char ch = 'x'; if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1) usage(); if (ch == 'm' || ch == 'M') lval *= 1000L; cinfo->mem->max_memory_to_use = lval * 1000L; } else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) { /* Enable entropy parm optimization. */ #ifdef ENTROPY_OPT_SUPPORTED cinfo->optimize_coding = TRUE; #else fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "outfile", 4)) { /* Set output file name. */ if (++argn >= argc) /* advance to next argument */ usage(); outfilename = argv[argn]; /* save it away for later use */ } else if (keymatch(arg, "progressive", 1)) { /* Select simple progressive mode. */ #ifdef C_PROGRESSIVE_SUPPORTED simple_progressive = TRUE; /* We must postpone execution until num_components is known. */ #else fprintf(stderr, "%s: sorry, progressive output was not compiled\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "quality", 1)) { /* Quality factor (quantization table scaling factor). */ if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%d", &quality) != 1) usage(); /* Change scale factor in case -qtables is present. */ q_scale_factor = jpeg_quality_scaling(quality); } else if (keymatch(arg, "qslots", 2)) { /* Quantization table slot numbers. */ if (++argn >= argc) /* advance to next argument */ usage(); qslotsarg = argv[argn]; /* Must delay setting qslots until after we have processed any * colorspace-determining switches, since jpeg_set_colorspace sets * default quant table numbers. */ } else if (keymatch(arg, "qtables", 2)) { /* Quantization tables fetched from file. */ if (++argn >= argc) /* advance to next argument */ usage(); qtablefile = argv[argn]; /* We postpone actually reading the file in case -quality comes later. */ } else if (keymatch(arg, "restart", 1)) { /* Restart interval in MCU rows (or in MCUs with 'b'). */ long lval; char ch = 'x'; if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1) usage(); if (lval < 0 || lval > 65535L) usage(); if (ch == 'b' || ch == 'B') { cinfo->restart_interval = (unsigned int) lval; cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */ } else { cinfo->restart_in_rows = (int) lval; /* restart_interval will be computed during startup */ } } else if (keymatch(arg, "sample", 2)) { /* Set sampling factors. */ if (++argn >= argc) /* advance to next argument */ usage(); samplearg = argv[argn]; /* Must delay setting sample factors until after we have processed any * colorspace-determining switches, since jpeg_set_colorspace sets * default sampling factors. */ } else if (keymatch(arg, "scans", 2)) { /* Set scan script. */ #ifdef C_MULTISCAN_FILES_SUPPORTED if (++argn >= argc) /* advance to next argument */ usage(); scansarg = argv[argn]; /* We must postpone reading the file in case -progressive appears. */ #else fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n", progname); exit(EXIT_FAILURE); #endif } else if (keymatch(arg, "smooth", 2)) { /* Set input smoothing factor. */ int val; if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%d", &val) != 1) usage(); if (val < 0 || val > 100) usage(); cinfo->smoothing_factor = val; } else if (keymatch(arg, "targa", 1)) { /* Input file is Targa format. */ is_targa = TRUE; } else { usage(); /* bogus switch */ } } /* Post-switch-scanning cleanup */ if (for_real) { /* Set quantization tables for selected quality. */ /* Some or all may be overridden if -qtables is present. */ jpeg_set_quality(cinfo, quality, force_baseline); if (qtablefile != NULL) /* process -qtables if it was present */ if (! read_quant_tables(cinfo, qtablefile, q_scale_factor, force_baseline)) usage(); if (qslotsarg != NULL) /* process -qslots if it was present */ if (! set_quant_slots(cinfo, qslotsarg)) usage(); if (samplearg != NULL) /* process -sample if it was present */ if (! set_sample_factors(cinfo, samplearg)) usage(); #ifdef C_PROGRESSIVE_SUPPORTED if (simple_progressive) /* process -progressive; -scans can override */ jpeg_simple_progression(cinfo); #endif #ifdef C_MULTISCAN_FILES_SUPPORTED if (scansarg != NULL) /* process -scans if it was present */ if (! read_scan_script(cinfo, scansarg)) usage(); #endif } return argn; /* return index of next arg (file name) */ } /* * The main program. */ int main (int argc, char **argv) { struct jpeg_compress_struct cinfo; struct jpeg_error_mgr jerr; #ifdef PROGRESS_REPORT struct cdjpeg_progress_mgr progress; #endif int file_index; cjpeg_source_ptr src_mgr; FILE * input_file; FILE * output_file; JDIMENSION num_scanlines; /* On Mac, fetch a command line. */ #ifdef USE_CCOMMAND argc = ccommand(&argv); #endif progname = argv[0]; if (progname == NULL || progname[0] == 0) progname = "cjpeg"; /* in case C library doesn't provide it */ /* Initialize the JPEG compression object with default error handling. */ cinfo.err = jpeg_std_error(&jerr); jpeg_create_compress(&cinfo); /* Add some application-specific error messages (from cderror.h) */ jerr.addon_message_table = cdjpeg_message_table; jerr.first_addon_message = JMSG_FIRSTADDONCODE; jerr.last_addon_message = JMSG_LASTADDONCODE; /* Now safe to enable signal catcher. */ #ifdef NEED_SIGNAL_CATCHER enable_signal_catcher((j_common_ptr) &cinfo); #endif /* Initialize JPEG parameters. * Much of this may be overridden later. * In particular, we don't yet know the input file's color space, * but we need to provide some value for jpeg_set_defaults() to work. */ cinfo.in_color_space = JCS_RGB; /* arbitrary guess */ jpeg_set_defaults(&cinfo); /* Scan command line to find file names. * It is convenient to use just one switch-parsing routine, but the switch * values read here are ignored; we will rescan the switches after opening * the input file. */ file_index = parse_switches(&cinfo, argc, argv, 0, FALSE); #ifdef TWO_FILE_COMMANDLINE /* Must have either -outfile switch or explicit output file name */ if (outfilename == NULL) { if (file_index != argc-2) { fprintf(stderr, "%s: must name one input and one output file\n", progname); usage(); } outfilename = argv[file_index+1]; } else { if (file_index != argc-1) { fprintf(stderr, "%s: must name one input and one output file\n", progname); usage(); } } #else /* Unix style: expect zero or one file name */ if (file_index < argc-1) { fprintf(stderr, "%s: only one input file\n", progname); usage(); } #endif /* TWO_FILE_COMMANDLINE */ /* Open the input file. */ if (file_index < argc) { if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) { fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]); exit(EXIT_FAILURE); } } else { /* default input file is stdin */ input_file = read_stdin(); } /* Open the output file. */ if (outfilename != NULL) { if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) { fprintf(stderr, "%s: can't open %s\n", progname, outfilename); exit(EXIT_FAILURE); } } else { /* default output file is stdout */ output_file = write_stdout(); } #ifdef PROGRESS_REPORT start_progress_monitor((j_common_ptr) &cinfo, &progress); #endif /* Figure out the input file format, and set up to read it. */ src_mgr = select_file_type(&cinfo, input_file); src_mgr->input_file = input_file; /* Read the input file header to obtain file size & colorspace. */ (*src_mgr->start_input) (&cinfo, src_mgr); /* Now that we know input colorspace, fix colorspace-dependent defaults */ jpeg_default_colorspace(&cinfo); /* Adjust default compression parameters by re-parsing the options */ file_index = parse_switches(&cinfo, argc, argv, 0, TRUE); /* Specify data destination for compression */ jpeg_stdio_dest(&cinfo, &output_file); /* Start compressor */ jpeg_start_compress(&cinfo, TRUE); /* Process data */ while (cinfo.next_scanline < cinfo.image_height) { num_scanlines = (*src_mgr->get_pixel_rows) (&cinfo, src_mgr); (void) jpeg_write_scanlines(&cinfo, src_mgr->buffer, num_scanlines); } /* Finish compression and release memory */ (*src_mgr->finish_input) (&cinfo, src_mgr); jpeg_finish_compress(&cinfo); jpeg_destroy_compress(&cinfo); /* Close files, if we opened them */ if (input_file != stdin) fclose(input_file); if (output_file != stdout) fclose(output_file); #ifdef PROGRESS_REPORT end_progress_monitor((j_common_ptr) &cinfo); #endif /* All done. */ exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS); return 0; /* suppress no-return-value warnings */ } Papyrus3/JpegDir/JpgLossy/JFDCTFLT.C0000755000175000017500000001302607535143454014145 0ustar /* * jfdctflt.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains a floating-point implementation of the * forward DCT (Discrete Cosine Transform). * * This implementation should be more accurate than either of the integer * DCT implementations. However, it may not give the same results on all * machines because of differences in roundoff behavior. Speed will depend * on the hardware's floating point capacity. * * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT * on each column. Direct algorithms are also available, but they are * much more complex and seem not to be any faster when reduced to code. * * This implementation is based on Arai, Agui, and Nakajima's algorithm for * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in * Japanese, but the algorithm is described in the Pennebaker & Mitchell * JPEG textbook (see REFERENCES section in file README). The following code * is based directly on figure 4-8 in P&M. * While an 8-point DCT cannot be done in less than 11 multiplies, it is * possible to arrange the computation so that many of the multiplies are * simple scalings of the final outputs. These multiplies can then be * folded into the multiplications or divisions by the JPEG quantization * table entries. The AA&N method leaves only 5 multiplies and 29 adds * to be done in the DCT itself. * The primary disadvantage of this method is that with a fixed-point * implementation, accuracy is lost due to imprecise representation of the * scaled quantization values. However, that problem does not arise if * we use floating point arithmetic. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jdct.h" /* Private declarations for DCT subsystem */ #ifdef DCT_FLOAT_SUPPORTED /* * This module is specialized to the case DCTSIZE = 8. */ #if DCTSIZE != 8 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ #endif /* * Perform the forward DCT on one block of samples. */ GLOBAL(void) jpeg_fdct_float (FAST_FLOAT * data) { FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7; FAST_FLOAT tmp10, tmp11, tmp12, tmp13; FAST_FLOAT z1, z2, z3, z4, z5, z11, z13; FAST_FLOAT *dataptr; int ctr; /* Pass 1: process rows. */ dataptr = data; for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { tmp0 = dataptr[0] + dataptr[7]; tmp7 = dataptr[0] - dataptr[7]; tmp1 = dataptr[1] + dataptr[6]; tmp6 = dataptr[1] - dataptr[6]; tmp2 = dataptr[2] + dataptr[5]; tmp5 = dataptr[2] - dataptr[5]; tmp3 = dataptr[3] + dataptr[4]; tmp4 = dataptr[3] - dataptr[4]; /* Even part */ tmp10 = tmp0 + tmp3; /* phase 2 */ tmp13 = tmp0 - tmp3; tmp11 = tmp1 + tmp2; tmp12 = tmp1 - tmp2; dataptr[0] = tmp10 + tmp11; /* phase 3 */ dataptr[4] = tmp10 - tmp11; z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */ dataptr[2] = tmp13 + z1; /* phase 5 */ dataptr[6] = tmp13 - z1; /* Odd part */ tmp10 = tmp4 + tmp5; /* phase 2 */ tmp11 = tmp5 + tmp6; tmp12 = tmp6 + tmp7; /* The rotator is modified from fig 4-8 to avoid extra negations. */ z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */ z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */ z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */ z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */ z11 = tmp7 + z3; /* phase 5 */ z13 = tmp7 - z3; dataptr[5] = z13 + z2; /* phase 6 */ dataptr[3] = z13 - z2; dataptr[1] = z11 + z4; dataptr[7] = z11 - z4; dataptr += DCTSIZE; /* advance pointer to next row */ } /* Pass 2: process columns. */ dataptr = data; for (ctr = DCTSIZE-1; ctr >= 0; ctr--) { tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]; tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]; tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]; tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]; tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]; tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]; tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]; tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]; /* Even part */ tmp10 = tmp0 + tmp3; /* phase 2 */ tmp13 = tmp0 - tmp3; tmp11 = tmp1 + tmp2; tmp12 = tmp1 - tmp2; dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */ dataptr[DCTSIZE*4] = tmp10 - tmp11; z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */ dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */ dataptr[DCTSIZE*6] = tmp13 - z1; /* Odd part */ tmp10 = tmp4 + tmp5; /* phase 2 */ tmp11 = tmp5 + tmp6; tmp12 = tmp6 + tmp7; /* The rotator is modified from fig 4-8 to avoid extra negations. */ z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */ z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */ z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */ z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */ z11 = tmp7 + z3; /* phase 5 */ z13 = tmp7 - z3; dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */ dataptr[DCTSIZE*3] = z13 - z2; dataptr[DCTSIZE*1] = z11 + z4; dataptr[DCTSIZE*7] = z11 - z4; dataptr++; /* advance pointer to next column */ } } #endif /* DCT_FLOAT_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/coderules.doc0000755000175000017500000001255207535143454015320 0ustar IJG JPEG LIBRARY: CODING RULES Copyright (C) 1991-1996, Thomas G. Lane. This file is part of the Independent JPEG Group's software. For conditions of distribution and use, see the accompanying README file. Since numerous people will be contributing code and bug fixes, it's important to establish a common coding style. The goal of using similar coding styles is much more important than the details of just what that style is. In general we follow the recommendations of "Recommended C Style and Coding Standards" revision 6.1 (Cannon et al. as modified by Spencer, Keppel and Brader). This document is available in the IJG FTP archive (see jpeg/doc/cstyle.ms.tbl.Z, or cstyle.txt.Z for those without nroff/tbl). Block comments should be laid out thusly: /* * Block comments in this style. */ We indent statements in K&R style, e.g., if (test) { then-part; } else { else-part; } with two spaces per indentation level. (This indentation convention is handled automatically by GNU Emacs and many other text editors.) Multi-word names should be written in lower case with underscores, e.g., multi_word_name (not multiWordName). Preprocessor symbols and enum constants are similar but upper case (MULTI_WORD_NAME). Names should be unique within the first fifteen characters. (On some older systems, global names must be unique within six characters. We accommodate this without cluttering the source code by using macros to substitute shorter names.) We use function prototypes everywhere; we rely on automatic source code transformation to feed prototype-less C compilers. Transformation is done by the simple and portable tool 'ansi2knr.c' (courtesy of Ghostscript). ansi2knr is not very bright, so it imposes a format requirement on function declarations: the function name MUST BEGIN IN COLUMN 1. Thus all functions should be written in the following style: LOCAL(int *) function_name (int a, char *b) { code... } Note that each function definition must begin with GLOBAL(type), LOCAL(type), or METHODDEF(type). These macros expand to "static type" or just "type" as appropriate. They provide a readable indication of the routine's usage and can readily be changed for special needs. (For instance, special linkage keywords can be inserted for use in Windows DLLs.) ansi2knr does not transform method declarations (function pointers in structs). We handle these with a macro JMETHOD, defined as #ifdef HAVE_PROTOTYPES #define JMETHOD(type,methodname,arglist) type (*methodname) arglist #else #define JMETHOD(type,methodname,arglist) type (*methodname) () #endif which is used like this: struct function_pointers { JMETHOD(void, init_entropy_encoder, (int somearg, jparms *jp)); JMETHOD(void, term_entropy_encoder, (void)); }; Note the set of parentheses surrounding the parameter list. A similar solution is used for forward and external function declarations (see the EXTERN and JPP macros). If the code is to work on non-ANSI compilers, we cannot rely on a prototype declaration to coerce actual parameters into the right types. Therefore, use explicit casts on actual parameters whenever the actual parameter type is not identical to the formal parameter. Beware of implicit conversions to "int". It seems there are some non-ANSI compilers in which the sizeof() operator is defined to return int, yet size_t is defined as long. Needless to say, this is brain-damaged. Always use the SIZEOF() macro in place of sizeof(), so that the result is guaranteed to be of type size_t. The JPEG library is intended to be used within larger programs. Furthermore, we want it to be reentrant so that it can be used by applications that process multiple images concurrently. The following rules support these requirements: 1. Avoid direct use of file I/O, "malloc", error report printouts, etc; pass these through the common routines provided. 2. Minimize global namespace pollution. Functions should be declared static wherever possible. (Note that our method-based calling conventions help this a lot: in many modules only the initialization function will ever need to be called directly, so only that function need be externally visible.) All global function names should begin with "jpeg_", and should have an abbreviated name (unique in the first six characters) substituted by macro when NEED_SHORT_EXTERNAL_NAMES is set. 3. Don't use global variables; anything that must be used in another module should be in the common data structures. 4. Don't use static variables except for read-only constant tables. Variables that should be private to a module can be placed into private structures (see the system architecture document, structure.doc). 5. Source file names should begin with "j" for files that are part of the library proper; source files that are not part of the library, such as cjpeg.c and djpeg.c, do not begin with "j". Keep source file names to eight characters (plus ".c" or ".h", etc) to make life easy for MS-DOSers. Keep compression and decompression code in separate source files --- some applications may want only one half of the library. Note: these rules (particularly #4) are not followed religiously in the modules that are used in cjpeg/djpeg but are not part of the JPEG library proper. Those modules are not really intended to be used in other applications. Papyrus3/JpegDir/JpgLossy/jconfig.st0000755000175000017500000000250607535143454014631 0ustar /* jconfig.st --- jconfig.h for Atari ST/STE/TT using Pure C or Turbo C. */ /* see jconfig.doc for explanations */ #define HAVE_PROTOTYPES #define HAVE_UNSIGNED_CHAR #define HAVE_UNSIGNED_SHORT /* #define void char */ /* #define const */ #undef CHAR_IS_UNSIGNED #define HAVE_STDDEF_H #define HAVE_STDLIB_H #undef NEED_BSD_STRINGS #undef NEED_SYS_TYPES_H #undef NEED_FAR_POINTERS #undef NEED_SHORT_EXTERNAL_NAMES #define INCOMPLETE_TYPES_BROKEN /* suppress undefined-structure warnings */ #ifdef JPEG_INTERNALS #undef RIGHT_SHIFT_IS_UNSIGNED #define ALIGN_TYPE long /* apparently double is a weird size? */ #endif /* JPEG_INTERNALS */ #ifdef JPEG_CJPEG_DJPEG #define BMP_SUPPORTED /* BMP image file format */ #define GIF_SUPPORTED /* GIF image file format */ #define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ #undef RLE_SUPPORTED /* Utah RLE image file format */ #define TARGA_SUPPORTED /* Targa image file format */ #define TWO_FILE_COMMANDLINE /* optional -- undef if you like Unix style */ /* Note: if you undef TWO_FILE_COMMANDLINE, you may need to define * USE_SETMODE. Some Atari compilers require it, some do not. */ #define NEED_SIGNAL_CATCHER /* needed if you use jmemname.c */ #undef DONT_USE_B_MODE #undef PROGRESS_REPORT /* optional */ #endif /* JPEG_CJPEG_DJPEG */ Papyrus3/JpegDir/JpgLossy/configure0000755000175000017500000017156007535143454014555 0ustar #! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated automatically using autoconf version 2.12 # Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc. # # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. # Defaults: ac_help= ac_default_prefix=/usr/local # Any additions from configure.in: ac_help="$ac_help --enable-shared build shared library using GNU libtool" ac_help="$ac_help --enable-static build static library using GNU libtool" ac_help="$ac_help --enable-maxmem[=N] enable use of temp files, set max mem usage to N MB" ac_help="$ac_help " # Initialize some variables set by options. # The variables have the same names as the options, with # dashes changed to underlines. build=NONE cache_file=./config.cache exec_prefix=NONE host=NONE no_create= nonopt=NONE no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= target=NONE verbose= x_includes=NONE x_libraries=NONE bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datadir='${prefix}/share' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' libdir='${exec_prefix}/lib' includedir='${prefix}/include' oldincludedir='/usr/include' infodir='${prefix}/info' mandir='${prefix}/man' # Initialize some other variables. subdirs= MFLAGS= MAKEFLAGS= # Maximum number of lines to put in a shell here document. ac_max_here_lines=12 ac_prev= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval "$ac_prev=\$ac_option" ac_prev= continue fi case "$ac_option" in -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;; *) ac_optarg= ;; esac # Accept the important Cygnus configure options, so we can diagnose typos. case "$ac_option" in -bindir | --bindir | --bindi | --bind | --bin | --bi) ac_prev=bindir ;; -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) bindir="$ac_optarg" ;; -build | --build | --buil | --bui | --bu) ac_prev=build ;; -build=* | --build=* | --buil=* | --bui=* | --bu=*) build="$ac_optarg" ;; -cache-file | --cache-file | --cache-fil | --cache-fi \ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ac_prev=cache_file ;; -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) cache_file="$ac_optarg" ;; -datadir | --datadir | --datadi | --datad | --data | --dat | --da) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \ | --da=*) datadir="$ac_optarg" ;; -disable-* | --disable-*) ac_feature=`echo $ac_option|sed -e 's/-*disable-//'` # Reject names that are not valid shell variable names. if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; } fi ac_feature=`echo $ac_feature| sed 's/-/_/g'` eval "enable_${ac_feature}=no" ;; -enable-* | --enable-*) ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'` # Reject names that are not valid shell variable names. if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; } fi ac_feature=`echo $ac_feature| sed 's/-/_/g'` case "$ac_option" in *=*) ;; *) ac_optarg=yes ;; esac eval "enable_${ac_feature}='$ac_optarg'" ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix="$ac_optarg" ;; -gas | --gas | --ga | --g) # Obsolete; use --with-gas. with_gas=yes ;; -help | --help | --hel | --he) # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat << EOF Usage: configure [options] [host] Options: [defaults in brackets after descriptions] Configuration: --cache-file=FILE cache test results in FILE --help print this message --no-create do not create output files --quiet, --silent do not print \`checking...' messages --version print the version of autoconf that created configure Directory and file names: --prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [same as prefix] --bindir=DIR user executables in DIR [EPREFIX/bin] --sbindir=DIR system admin executables in DIR [EPREFIX/sbin] --libexecdir=DIR program executables in DIR [EPREFIX/libexec] --datadir=DIR read-only architecture-independent data in DIR [PREFIX/share] --sysconfdir=DIR read-only single-machine data in DIR [PREFIX/etc] --sharedstatedir=DIR modifiable architecture-independent data in DIR [PREFIX/com] --localstatedir=DIR modifiable single-machine data in DIR [PREFIX/var] --libdir=DIR object code libraries in DIR [EPREFIX/lib] --includedir=DIR C header files in DIR [PREFIX/include] --oldincludedir=DIR C header files for non-gcc in DIR [/usr/include] --infodir=DIR info documentation in DIR [PREFIX/info] --mandir=DIR man documentation in DIR [PREFIX/man] --srcdir=DIR find the sources in DIR [configure dir or ..] --program-prefix=PREFIX prepend PREFIX to installed program names --program-suffix=SUFFIX append SUFFIX to installed program names --program-transform-name=PROGRAM run sed PROGRAM on installed program names EOF cat << EOF Host type: --build=BUILD configure for building on BUILD [BUILD=HOST] --host=HOST configure for HOST [guessed] --target=TARGET configure for TARGET [TARGET=HOST] Features and packages: --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --x-includes=DIR X include files are in DIR --x-libraries=DIR X library files are in DIR EOF if test -n "$ac_help"; then echo "--enable and --with options recognized:$ac_help" fi exit 0 ;; -host | --host | --hos | --ho) ac_prev=host ;; -host=* | --host=* | --hos=* | --ho=*) host="$ac_optarg" ;; -includedir | --includedir | --includedi | --included | --include \ | --includ | --inclu | --incl | --inc) ac_prev=includedir ;; -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ | --includ=* | --inclu=* | --incl=* | --inc=*) includedir="$ac_optarg" ;; -infodir | --infodir | --infodi | --infod | --info | --inf) ac_prev=infodir ;; -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) infodir="$ac_optarg" ;; -libdir | --libdir | --libdi | --libd) ac_prev=libdir ;; -libdir=* | --libdir=* | --libdi=* | --libd=*) libdir="$ac_optarg" ;; -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ | --libexe | --libex | --libe) ac_prev=libexecdir ;; -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ | --libexe=* | --libex=* | --libe=*) libexecdir="$ac_optarg" ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst \ | --locals | --local | --loca | --loc | --lo) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* \ | --locals=* | --local=* | --loca=* | --loc=* | --lo=*) localstatedir="$ac_optarg" ;; -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ac_prev=mandir ;; -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) mandir="$ac_optarg" ;; -nfp | --nfp | --nf) # Obsolete; use --without-fp. with_fp=no ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c) no_create=yes ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) no_recursion=yes ;; -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ | --oldin | --oldi | --old | --ol | --o) ac_prev=oldincludedir ;; -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) oldincludedir="$ac_optarg" ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix="$ac_optarg" ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix="$ac_optarg" ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix="$ac_optarg" ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name="$ac_optarg" ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ | --sbi=* | --sb=*) sbindir="$ac_optarg" ;; -sharedstatedir | --sharedstatedir | --sharedstatedi \ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ | --sharedst | --shareds | --shared | --share | --shar \ | --sha | --sh) ac_prev=sharedstatedir ;; -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ | --sha=* | --sh=*) sharedstatedir="$ac_optarg" ;; -site | --site | --sit) ac_prev=site ;; -site=* | --site=* | --sit=*) site="$ac_optarg" ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir="$ac_optarg" ;; -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ | --syscon | --sysco | --sysc | --sys | --sy) ac_prev=sysconfdir ;; -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) sysconfdir="$ac_optarg" ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target="$ac_optarg" ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers) echo "configure generated by autoconf version 2.12" exit 0 ;; -with-* | --with-*) ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'` # Reject names that are not valid shell variable names. if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; } fi ac_package=`echo $ac_package| sed 's/-/_/g'` case "$ac_option" in *=*) ;; *) ac_optarg=yes ;; esac eval "with_${ac_package}='$ac_optarg'" ;; -without-* | --without-*) ac_package=`echo $ac_option|sed -e 's/-*without-//'` # Reject names that are not valid shell variable names. if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; } fi ac_package=`echo $ac_package| sed 's/-/_/g'` eval "with_${ac_package}=no" ;; --x) # Obsolete; use --with-x. with_x=yes ;; -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes="$ac_optarg" ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries="$ac_optarg" ;; -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; } ;; *=*) varname=`echo "$ac_option"|sed -e 's/=.*//'` # Reject names that aren't valid shell variable names. if test -n "`echo $varname| sed 's/[a-zA-Z0-9_]//g'`"; then { echo "configure: error: $varname: invalid shell variable name" 1>&2; exit 1; } fi val="`echo "$ac_option"|sed 's/[^=]*=//'`" test -n "$verbose" && echo " setting shell variable $varname to $val" eval "$varname='$val'" eval "export $varname" ;; *) if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then echo "configure: warning: $ac_option: invalid host type" 1>&2 fi if test "x$nonopt" != xNONE; then { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } fi nonopt="$ac_option" ;; esac done if test -n "$ac_prev"; then { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; } fi trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15 # File descriptor usage: # 0 standard input # 1 file creation # 2 errors and warnings # 3 some systems may open it to /dev/tty # 4 used on the Kubota Titan # 6 checking for... messages and results # 5 compiler messages saved in config.log if test "$silent" = yes; then exec 6>/dev/null else exec 6>&1 fi exec 5>./config.log echo "\ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. " 1>&5 # Strip out --no-create and --no-recursion so they do not pile up. # Also quote any args containing shell metacharacters. ac_configure_args= for ac_arg do case "$ac_arg" in -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c) ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;; *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*) ac_configure_args="$ac_configure_args '$ac_arg'" ;; *) ac_configure_args="$ac_configure_args $ac_arg" ;; esac done # NLS nuisances. # Only set these to C if already set. These must not be set unconditionally # because not all systems understand e.g. LANG=C (notably SCO). # Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'! # Non-C LC_CTYPE values break the ctype check. if test "${LANG+set}" = set; then LANG=C; export LANG; fi if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi if test "${LC_CTYPE+set}" = set; then LC_CTYPE=C; export LC_CTYPE; fi # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -rf conftest* confdefs.h # AIX cpp loses on an empty file, so make sure it contains at least a newline. echo > confdefs.h # A filename unique to this package, relative to the directory that # configure is in, which we can look for to find out if srcdir is correct. ac_unique_file=jcmaster.c # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then its parent. ac_prog=$0 ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'` test "x$ac_confdir" = "x$ac_prog" && ac_confdir=. srcdir=$ac_confdir if test ! -r $srcdir/$ac_unique_file; then srcdir=.. fi else ac_srcdir_defaulted=no fi if test ! -r $srcdir/$ac_unique_file; then if test "$ac_srcdir_defaulted" = yes; then { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; } else { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; } fi fi srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'` # Prefer explicitly selected file to automatically selected ones. if test -z "$CONFIG_SITE"; then if test "x$prefix" != xNONE; then CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site" else CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" fi fi for ac_site_file in $CONFIG_SITE; do if test -r "$ac_site_file"; then echo "loading site script $ac_site_file" . "$ac_site_file" fi done ac_ext=c # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. ac_cpp='$CPP $CPPFLAGS' ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5' ac_link='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5' cross_compiling=$ac_cv_prog_cc_cross if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu. if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then ac_n= ac_c=' ' ac_t=' ' else ac_n=-n ac_c= ac_t= fi else ac_n= ac_c='\c' ac_t= fi # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 echo "configure:538: checking for $ac_word" >&5 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/$ac_word; then ac_cv_prog_CC="gcc" break fi done IFS="$ac_save_ifs" fi fi CC="$ac_cv_prog_CC" if test -n "$CC"; then echo "$ac_t""$CC" 1>&6 else echo "$ac_t""no" 1>&6 fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 echo "configure:567: checking for $ac_word" >&5 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" ac_prog_rejected=no for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/$ac_word; then if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" break fi done IFS="$ac_save_ifs" if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# -gt 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift set dummy "$ac_dir/$ac_word" "$@" shift ac_cv_prog_CC="$@" fi fi fi fi CC="$ac_cv_prog_CC" if test -n "$CC"; then echo "$ac_t""$CC" 1>&6 else echo "$ac_t""no" 1>&6 fi test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; } fi echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6 echo "configure:615: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5 ac_ext=c # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. ac_cpp='$CPP $CPPFLAGS' ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5' ac_link='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5' cross_compiling=$ac_cv_prog_cc_cross cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest; then ac_cv_prog_cc_works=yes # If we can't run a trivial program, we are probably using a cross compiler. if (./conftest; exit) 2>/dev/null; then ac_cv_prog_cc_cross=no else ac_cv_prog_cc_cross=yes fi else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 ac_cv_prog_cc_works=no fi rm -fr conftest* echo "$ac_t""$ac_cv_prog_cc_works" 1>&6 if test $ac_cv_prog_cc_works = no; then { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; } fi echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6 echo "configure:649: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5 echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6 cross_compiling=$ac_cv_prog_cc_cross echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6 echo "configure:654: checking whether we are using GNU C" >&5 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.c <&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then ac_cv_prog_gcc=yes else ac_cv_prog_gcc=no fi fi echo "$ac_t""$ac_cv_prog_gcc" 1>&6 if test $ac_cv_prog_gcc = yes; then GCC=yes test "${CFLAGS+set}" = set || CFLAGS="-O2" else GCC= test "${CFLAGS+set}" = set || CFLAGS="-O" fi echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6 echo "configure:681: checking how to run the C preprocessor" >&5 # On Suns, sometimes $CPP names a directory. if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else # This must be in double quotes, not single quotes, because CPP may get # substituted into the Makefile and "${CC-cc}" will confuse make. CPP="${CC-cc} -E" # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. cat > conftest.$ac_ext < Syntax Error EOF ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" { (eval echo configure:702: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } ac_err=`grep -v '^ *+' conftest.out` if test -z "$ac_err"; then : else echo "$ac_err" >&5 echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* CPP="${CC-cc} -E -traditional-cpp" cat > conftest.$ac_ext < Syntax Error EOF ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" { (eval echo configure:719: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } ac_err=`grep -v '^ *+' conftest.out` if test -z "$ac_err"; then : else echo "$ac_err" >&5 echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* CPP=/lib/cpp fi rm -f conftest* fi rm -f conftest* ac_cv_prog_CPP="$CPP" fi CPP="$ac_cv_prog_CPP" else ac_cv_prog_CPP="$CPP" fi echo "$ac_t""$CPP" 1>&6 echo $ac_n "checking for function prototypes""... $ac_c" 1>&6 echo "configure:742: checking for function prototypes" >&5 if eval "test \"`echo '$''{'ijg_cv_have_prototypes'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* ijg_cv_have_prototypes=yes else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* ijg_cv_have_prototypes=no fi rm -f conftest* fi echo "$ac_t""$ijg_cv_have_prototypes" 1>&6 if test $ijg_cv_have_prototypes = yes; then cat >> confdefs.h <<\EOF #define HAVE_PROTOTYPES EOF else echo Your compiler does not seem to know about function prototypes. echo Perhaps it needs a special switch to enable ANSI C mode. echo If so, we recommend running configure like this: echo " ./configure CC='cc -switch'" echo where -switch is the proper switch. fi ac_safe=`echo "stddef.h" | sed 'y%./+-%__p_%'` echo $ac_n "checking for stddef.h""... $ac_c" 1>&6 echo "configure:792: checking for stddef.h" >&5 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < EOF ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" { (eval echo configure:802: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } ac_err=`grep -v '^ *+' conftest.out` if test -z "$ac_err"; then rm -rf conftest* eval "ac_cv_header_$ac_safe=yes" else echo "$ac_err" >&5 echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* eval "ac_cv_header_$ac_safe=no" fi rm -f conftest* fi if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then echo "$ac_t""yes" 1>&6 cat >> confdefs.h <<\EOF #define HAVE_STDDEF_H EOF else echo "$ac_t""no" 1>&6 fi ac_safe=`echo "stdlib.h" | sed 'y%./+-%__p_%'` echo $ac_n "checking for stdlib.h""... $ac_c" 1>&6 echo "configure:828: checking for stdlib.h" >&5 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < EOF ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" { (eval echo configure:838: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } ac_err=`grep -v '^ *+' conftest.out` if test -z "$ac_err"; then rm -rf conftest* eval "ac_cv_header_$ac_safe=yes" else echo "$ac_err" >&5 echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* eval "ac_cv_header_$ac_safe=no" fi rm -f conftest* fi if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then echo "$ac_t""yes" 1>&6 cat >> confdefs.h <<\EOF #define HAVE_STDLIB_H EOF else echo "$ac_t""no" 1>&6 fi ac_safe=`echo "string.h" | sed 'y%./+-%__p_%'` echo $ac_n "checking for string.h""... $ac_c" 1>&6 echo "configure:864: checking for string.h" >&5 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < EOF ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" { (eval echo configure:874: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } ac_err=`grep -v '^ *+' conftest.out` if test -z "$ac_err"; then rm -rf conftest* eval "ac_cv_header_$ac_safe=yes" else echo "$ac_err" >&5 echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* eval "ac_cv_header_$ac_safe=no" fi rm -f conftest* fi if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then echo "$ac_t""yes" 1>&6 : else echo "$ac_t""no" 1>&6 cat >> confdefs.h <<\EOF #define NEED_BSD_STRINGS EOF fi echo $ac_n "checking for size_t""... $ac_c" 1>&6 echo "configure:900: checking for size_t" >&5 cat > conftest.$ac_ext < #endif #ifdef HAVE_STDLIB_H #include #endif #include #ifdef NEED_BSD_STRINGS #include #else #include #endif typedef size_t my_size_t; int main() { my_size_t foovar; ; return 0; } EOF if { (eval echo configure:923: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* ijg_size_t_ok=yes else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* ijg_size_t_ok="not ANSI, perhaps it is in sys/types.h" fi rm -f conftest* echo "$ac_t""$ijg_size_t_ok" 1>&6 if test "$ijg_size_t_ok" != yes; then ac_safe=`echo "sys/types.h" | sed 'y%./+-%__p_%'` echo $ac_n "checking for sys/types.h""... $ac_c" 1>&6 echo "configure:937: checking for sys/types.h" >&5 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < EOF ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" { (eval echo configure:947: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } ac_err=`grep -v '^ *+' conftest.out` if test -z "$ac_err"; then rm -rf conftest* eval "ac_cv_header_$ac_safe=yes" else echo "$ac_err" >&5 echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* eval "ac_cv_header_$ac_safe=no" fi rm -f conftest* fi if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then echo "$ac_t""yes" 1>&6 cat >> confdefs.h <<\EOF #define NEED_SYS_TYPES_H EOF cat > conftest.$ac_ext < EOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | egrep "size_t" >/dev/null 2>&1; then rm -rf conftest* ijg_size_t_ok="size_t is in sys/types.h" else rm -rf conftest* ijg_size_t_ok=no fi rm -f conftest* else echo "$ac_t""no" 1>&6 ijg_size_t_ok=no fi echo "$ac_t""$ijg_size_t_ok" 1>&6 if test "$ijg_size_t_ok" = no; then echo Type size_t is not defined in any of the usual places. echo Try putting '"typedef unsigned int size_t;"' in jconfig.h. fi fi echo $ac_n "checking for type unsigned char""... $ac_c" 1>&6 echo "configure:994: checking for type unsigned char" >&5 cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* echo "$ac_t""yes" 1>&6 cat >> confdefs.h <<\EOF #define HAVE_UNSIGNED_CHAR EOF else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* echo "$ac_t""no" 1>&6 fi rm -f conftest* echo $ac_n "checking for type unsigned short""... $ac_c" 1>&6 echo "configure:1018: checking for type unsigned short" >&5 cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* echo "$ac_t""yes" 1>&6 cat >> confdefs.h <<\EOF #define HAVE_UNSIGNED_SHORT EOF else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* echo "$ac_t""no" 1>&6 fi rm -f conftest* echo $ac_n "checking for type void""... $ac_c" 1>&6 echo "configure:1042: checking for type void" >&5 cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* echo "$ac_t""yes" 1>&6 else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* echo "$ac_t""no" 1>&6 cat >> confdefs.h <<\EOF #define void char EOF fi rm -f conftest* echo $ac_n "checking for working const""... $ac_c" 1>&6 echo "configure:1088: checking for working const" >&5 if eval "test \"`echo '$''{'ac_cv_c_const'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext <j = 5; } { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ const int foo = 10; } ; return 0; } EOF if { (eval echo configure:1142: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* ac_cv_c_const=yes else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* ac_cv_c_const=no fi rm -f conftest* fi echo "$ac_t""$ac_cv_c_const" 1>&6 if test $ac_cv_c_const = no; then cat >> confdefs.h <<\EOF #define const EOF fi echo $ac_n "checking for inline""... $ac_c" 1>&6 echo "configure:1163: checking for inline" >&5 ijg_cv_inline="" cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* ijg_cv_inline="__inline__" else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* ijg_cv_inline="__inline" else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* ijg_cv_inline="inline" else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* echo "$ac_t""$ijg_cv_inline" 1>&6 cat >> confdefs.h <&6 echo "configure:1224: checking for broken incomplete types" >&5 cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* echo "$ac_t""ok" 1>&6 else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* echo "$ac_t""broken" 1>&6 cat >> confdefs.h <<\EOF #define INCOMPLETE_TYPES_BROKEN EOF fi rm -f conftest* echo $ac_n "checking for short external names""... $ac_c" 1>&6 echo "configure:1248: checking for short external names" >&5 cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest; then rm -rf conftest* echo "$ac_t""ok" 1>&6 else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* echo "$ac_t""short" 1>&6 cat >> confdefs.h <<\EOF #define NEED_SHORT_EXTERNAL_NAMES EOF fi rm -f conftest* echo $ac_n "checking to see if char is signed""... $ac_c" 1>&6 echo "configure:1275: checking to see if char is signed" >&5 if test "$cross_compiling" = yes; then echo Assuming that char is signed on target machine. echo If it is unsigned, this will be a little bit inefficient. else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit) 2>/dev/null then echo "$ac_t""no" 1>&6 cat >> confdefs.h <<\EOF #define CHAR_IS_UNSIGNED EOF else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -fr conftest* echo "$ac_t""yes" 1>&6 fi rm -fr conftest* fi echo $ac_n "checking to see if right shift is signed""... $ac_c" 1>&6 echo "configure:1323: checking to see if right shift is signed" >&5 if test "$cross_compiling" = yes; then echo "$ac_t""Assuming that right shift is signed on target machine." 1>&6 else cat > conftest.$ac_ext <> 4; if (res == -0x7F7E80CL) { /* expected result for signed shift */ return 1; /* right shift is signed */ } /* see if unsigned-shift hack will fix it. */ /* we can't just test exact value since it depends on width of long... */ res |= (~0L) << (32-4); if (res == -0x7F7E80CL) { /* expected result now? */ return 0; /* right shift is unsigned */ } printf("Right shift isn't acting as I expect it to.\n"); printf("I fear the JPEG software will not work at all.\n\n"); return 0; /* try it with unsigned anyway */ } main() { exit(is_shifting_signed(-0x7F7E80B1L)); } EOF if { (eval echo configure:1358: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit) 2>/dev/null then echo "$ac_t""no" 1>&6 cat >> confdefs.h <<\EOF #define RIGHT_SHIFT_IS_UNSIGNED EOF else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -fr conftest* echo "$ac_t""yes" 1>&6 fi rm -fr conftest* fi echo $ac_n "checking to see if fopen accepts b spec""... $ac_c" 1>&6 echo "configure:1375: checking to see if fopen accepts b spec" >&5 if test "$cross_compiling" = yes; then echo "$ac_t""Assuming that it does." 1>&6 else cat > conftest.$ac_ext < main() { if (fopen("conftestdata", "wb") != NULL) exit(0); exit(1); } EOF if { (eval echo configure:1390: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit) 2>/dev/null then echo "$ac_t""yes" 1>&6 else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -fr conftest* echo "$ac_t""no" 1>&6 cat >> confdefs.h <<\EOF #define DONT_USE_B_MODE EOF fi rm -fr conftest* fi ac_aux_dir= for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do if test -f $ac_dir/install-sh; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install-sh -c" break elif test -f $ac_dir/install.sh; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install.sh -c" break fi done if test -z "$ac_aux_dir"; then { echo "configure: error: can not find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." 1>&2; exit 1; } fi ac_config_guess=$ac_aux_dir/config.guess ac_config_sub=$ac_aux_dir/config.sub ac_configure=$ac_aux_dir/configure # This should be Cygnus configure. # Find a good install program. We prefer a C program (faster), # so one script is as good as another. But avoid the broken or # incompatible versions: # SysV /etc/install, /usr/sbin/install # SunOS /usr/etc/install # IRIX /sbin/install # AIX /bin/install # AFS /usr/afsws/bin/install, which mishandles nonexistent args # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" # ./install, which can be erroneously created by make from ./install.sh. echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6 echo "configure:1436: checking for a BSD compatible install" >&5 if test -z "$INSTALL"; then if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do # Account for people who put trailing slashes in PATH elements. case "$ac_dir/" in /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;; *) # OSF1 and SCO ODT 3.0 have their own names for install. for ac_prog in ginstall installbsd scoinst install; do if test -f $ac_dir/$ac_prog; then if test $ac_prog = install && grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then # AIX install. It has an incompatible calling convention. # OSF/1 installbsd also uses dspmsg, but is usable. : else ac_cv_path_install="$ac_dir/$ac_prog -c" break 2 fi fi done ;; esac done IFS="$ac_save_IFS" fi if test "${ac_cv_path_install+set}" = set; then INSTALL="$ac_cv_path_install" else # As a last resort, use the slow shell script. We don't cache a # path for INSTALL within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the path is relative. INSTALL="$ac_install_sh" fi fi echo "$ac_t""$INSTALL" 1>&6 # Use test -z because SunOS4 sh mishandles braces in ${var-val}. # It thinks the first close brace ends the variable substitution. test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' # Extract the first word of "ranlib", so it can be a program name with args. set dummy ranlib; ac_word=$2 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 echo "configure:1488: checking for $ac_word" >&5 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else if test -n "$RANLIB"; then ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. else IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/$ac_word; then ac_cv_prog_RANLIB="ranlib" break fi done IFS="$ac_save_ifs" test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":" fi fi RANLIB="$ac_cv_prog_RANLIB" if test -n "$RANLIB"; then echo "$ac_t""$RANLIB" 1>&6 else echo "$ac_t""no" 1>&6 fi # Decide whether to use libtool, # and if so whether to build shared, static, or both flavors of library. LTSHARED="no" # Check whether --enable-shared or --disable-shared was given. if test "${enable_shared+set}" = set; then enableval="$enable_shared" LTSHARED="$enableval" fi LTSTATIC="no" # Check whether --enable-static or --disable-static was given. if test "${enable_static+set}" = set; then enableval="$enable_static" LTSTATIC="$enableval" fi if test "x$LTSHARED" != xno -o "x$LTSTATIC" != xno; then USELIBTOOL="yes" LIBTOOL="./libtool" O="lo" A="la" LN='$(LIBTOOL) --mode=link $(CC)' INSTALL_LIB='$(LIBTOOL) --mode=install ${INSTALL}' INSTALL_PROGRAM="\$(LIBTOOL) --mode=install $INSTALL_PROGRAM" else USELIBTOOL="no" LIBTOOL="" O="o" A="a" LN='$(CC)' INSTALL_LIB="$INSTALL_DATA" fi # Configure libtool if needed. if test $USELIBTOOL = yes; then disable_shared= disable_static= if test "x$LTSHARED" = xno; then disable_shared="--disable-shared" fi if test "x$LTSTATIC" = xno; then disable_static="--disable-static" fi $srcdir/ltconfig $disable_shared $disable_static $srcdir/ltmain.sh fi # Select memory manager depending on user input. # If no "-enable-maxmem", use jmemnobs MEMORYMGR='jmemnobs.$(O)' MAXMEM="no" # Check whether --enable-maxmem or --disable-maxmem was given. if test "${enable_maxmem+set}" = set; then enableval="$enable_maxmem" MAXMEM="$enableval" fi # support --with-maxmem for backwards compatibility with IJG V5. # Check whether --with-maxmem or --without-maxmem was given. if test "${with_maxmem+set}" = set; then withval="$with_maxmem" MAXMEM="$withval" fi if test "x$MAXMEM" = xyes; then MAXMEM=1 fi if test "x$MAXMEM" != xno; then if test -n "`echo $MAXMEM | sed 's/[0-9]//g'`"; then { echo "configure: error: non-numeric argument to --enable-maxmem" 1>&2; exit 1; } fi DEFAULTMAXMEM=`expr $MAXMEM \* 1048576` cat >> confdefs.h <&6 echo "configure:1596: checking for 'tmpfile()'" >&5 cat > conftest.$ac_ext < int main() { FILE * tfile = tmpfile(); ; return 0; } EOF if { (eval echo configure:1605: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then rm -rf conftest* echo "$ac_t""yes" 1>&6 MEMORYMGR='jmemansi.$(O)' else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* echo "$ac_t""no" 1>&6 MEMORYMGR='jmemname.$(O)' cat >> confdefs.h <<\EOF #define NEED_SIGNAL_CATCHER EOF echo $ac_n "checking for 'mktemp()'""... $ac_c" 1>&6 echo "configure:1620: checking for 'mktemp()'" >&5 cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest; then rm -rf conftest* echo "$ac_t""yes" 1>&6 else echo "configure: failed program was:" >&5 cat conftest.$ac_ext >&5 rm -rf conftest* echo "$ac_t""no" 1>&6 cat >> confdefs.h <<\EOF #define NO_MKTEMP EOF fi rm -f conftest* fi rm -f conftest* fi # Extract the library version ID from jpeglib.h. echo $ac_n "checking libjpeg version number""... $ac_c" 1>&6 echo "configure:1650: checking libjpeg version number" >&5 JPEG_LIB_VERSION=`sed -e '/^#define JPEG_LIB_VERSION/!d' -e 's/^[^0-9]*\([0-9][0-9]*\).*$/\1/' $srcdir/jpeglib.h` echo "$ac_t""$JPEG_LIB_VERSION" 1>&6 # Prepare to massage makefile.cfg correctly. if test $ijg_cv_have_prototypes = yes; then A2K_DEPS="" COM_A2K="# " else A2K_DEPS="ansi2knr" COM_A2K="" fi # ansi2knr needs -DBSD if string.h is missing if test $ac_cv_header_string_h = no; then ANSI2KNRFLAGS="-DBSD" else ANSI2KNRFLAGS="" fi # Substitutions to enable or disable libtool-related stuff if test $USELIBTOOL = yes -a $ijg_cv_have_prototypes = yes; then COM_LT="" else COM_LT="# " fi if test "x$LTSHARED" != xno; then FORCE_INSTALL_LIB="install-lib" else FORCE_INSTALL_LIB="" fi # Set up -I directives if test "x$srcdir" = x.; then INCLUDEFLAGS='-I$(srcdir)' else INCLUDEFLAGS='-I. -I$(srcdir)' fi trap '' 1 2 15 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15 test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' # Any assignment to VPATH causes Sun make to only execute # the first set of double-colon rules, so remove it if not needed. # If there is a colon in the path, we need to keep it. if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[^:]*$/d' fi trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15 DEFS=-DHAVE_CONFIG_H # Without the "./", some shells look in PATH for config.status. : ${CONFIG_STATUS=./config.status} echo creating $CONFIG_STATUS rm -f $CONFIG_STATUS cat > $CONFIG_STATUS </dev/null | sed 1q`: # # $0 $ac_configure_args # # Compiler output produced by configure, useful for debugging # configure, is in ./config.log if it exists. ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]" for ac_option do case "\$ac_option" in -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion" exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;; -version | --version | --versio | --versi | --vers | --ver | --ve | --v) echo "$CONFIG_STATUS generated by autoconf version 2.12" exit 0 ;; -help | --help | --hel | --he | --h) echo "\$ac_cs_usage"; exit 0 ;; *) echo "\$ac_cs_usage"; exit 1 ;; esac done ac_given_srcdir=$srcdir ac_given_INSTALL="$INSTALL" trap 'rm -fr `echo "Makefile:makefile.cfg jconfig.h:jconfig.cfg" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15 EOF cat >> $CONFIG_STATUS < conftest.subs <<\\CEOF $ac_vpsub $extrasub s%@CFLAGS@%$CFLAGS%g s%@CPPFLAGS@%$CPPFLAGS%g s%@CXXFLAGS@%$CXXFLAGS%g s%@DEFS@%$DEFS%g s%@LDFLAGS@%$LDFLAGS%g s%@LIBS@%$LIBS%g s%@exec_prefix@%$exec_prefix%g s%@prefix@%$prefix%g s%@program_transform_name@%$program_transform_name%g s%@bindir@%$bindir%g s%@sbindir@%$sbindir%g s%@libexecdir@%$libexecdir%g s%@datadir@%$datadir%g s%@sysconfdir@%$sysconfdir%g s%@sharedstatedir@%$sharedstatedir%g s%@localstatedir@%$localstatedir%g s%@libdir@%$libdir%g s%@includedir@%$includedir%g s%@oldincludedir@%$oldincludedir%g s%@infodir@%$infodir%g s%@mandir@%$mandir%g s%@CC@%$CC%g s%@CPP@%$CPP%g s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g s%@INSTALL_DATA@%$INSTALL_DATA%g s%@RANLIB@%$RANLIB%g s%@LIBTOOL@%$LIBTOOL%g s%@O@%$O%g s%@A@%$A%g s%@LN@%$LN%g s%@INSTALL_LIB@%$INSTALL_LIB%g s%@MEMORYMGR@%$MEMORYMGR%g s%@JPEG_LIB_VERSION@%$JPEG_LIB_VERSION%g s%@A2K_DEPS@%$A2K_DEPS%g s%@COM_A2K@%$COM_A2K%g s%@ANSI2KNRFLAGS@%$ANSI2KNRFLAGS%g s%@COM_LT@%$COM_LT%g s%@FORCE_INSTALL_LIB@%$FORCE_INSTALL_LIB%g s%@INCLUDEFLAGS@%$INCLUDEFLAGS%g CEOF EOF cat >> $CONFIG_STATUS <<\EOF # Split the substitutions into bite-sized pieces for seds with # small command number limits, like on Digital OSF/1 and HP-UX. ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script. ac_file=1 # Number of current file. ac_beg=1 # First line for current file. ac_end=$ac_max_sed_cmds # Line after last line for current file. ac_more_lines=: ac_sed_cmds="" while $ac_more_lines; do if test $ac_beg -gt 1; then sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file else sed "${ac_end}q" conftest.subs > conftest.s$ac_file fi if test ! -s conftest.s$ac_file; then ac_more_lines=false rm -f conftest.s$ac_file else if test -z "$ac_sed_cmds"; then ac_sed_cmds="sed -f conftest.s$ac_file" else ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file" fi ac_file=`expr $ac_file + 1` ac_beg=$ac_end ac_end=`expr $ac_end + $ac_max_sed_cmds` fi done if test -z "$ac_sed_cmds"; then ac_sed_cmds=cat fi EOF cat >> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". case "$ac_file" in *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'` ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; *) ac_file_in="${ac_file}.in" ;; esac # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories. # Remove last slash and all that follows it. Not all systems have dirname. ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then # The file is in a subdirectory. test ! -d "$ac_dir" && mkdir "$ac_dir" ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`" # A "../" for each directory in $ac_dir_suffix. ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'` else ac_dir_suffix= ac_dots= fi case "$ac_given_srcdir" in .) srcdir=. if test -z "$ac_dots"; then top_srcdir=. else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;; /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;; *) # Relative path. srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix" top_srcdir="$ac_dots$ac_given_srcdir" ;; esac case "$ac_given_INSTALL" in [/$]*) INSTALL="$ac_given_INSTALL" ;; *) INSTALL="$ac_dots$ac_given_INSTALL" ;; esac echo creating "$ac_file" rm -f "$ac_file" configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure." case "$ac_file" in *Makefile*) ac_comsub="1i\\ # $configure_input" ;; *) ac_comsub= ;; esac ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"` sed -e "$ac_comsub s%@configure_input@%$configure_input%g s%@srcdir@%$srcdir%g s%@top_srcdir@%$top_srcdir%g s%@INSTALL@%$INSTALL%g " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file fi; done rm -f conftest.s* # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where # NAME is the cpp macro being defined and VALUE is the value it is being given. # # ac_d sets the value in "#define NAME VALUE" lines. ac_dA='s%^\([ ]*\)#\([ ]*define[ ][ ]*\)' ac_dB='\([ ][ ]*\)[^ ]*%\1#\2' ac_dC='\3' ac_dD='%g' # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE". ac_uA='s%^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' ac_uB='\([ ]\)%\1#\2define\3' ac_uC=' ' ac_uD='\4%g' # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE". ac_eA='s%^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' ac_eB='$%\1#\2define\3' ac_eC=' ' ac_eD='%g' if test "${CONFIG_HEADERS+set}" != set; then EOF cat >> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF fi for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". case "$ac_file" in *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'` ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; *) ac_file_in="${ac_file}.in" ;; esac echo creating $ac_file rm -f conftest.frag conftest.in conftest.out ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"` cat $ac_file_inputs > conftest.in EOF # Transform confdefs.h into a sed script conftest.vals that substitutes # the proper values into config.h.in to produce config.h. And first: # Protect against being on the right side of a sed subst in config.status. # Protect against being in an unquoted here document in config.status. rm -f conftest.vals cat > conftest.hdr <<\EOF s/[\\&%]/\\&/g s%[\\$`]%\\&%g s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp s%ac_d%ac_u%gp s%ac_u%ac_e%gp EOF sed -n -f conftest.hdr confdefs.h > conftest.vals rm -f conftest.hdr # This sed command replaces #undef with comments. This is necessary, for # example, in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it. cat >> conftest.vals <<\EOF EOF # Break up conftest.vals because some shells have a limit on # the size of here documents, and old seds have small limits too. rm -f conftest.tail while : do ac_lines=`grep -c . conftest.vals` # grep -c gives empty output for an empty file on some AIX systems. if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi # Write a limited-size here document to conftest.frag. echo ' cat > conftest.frag <> $CONFIG_STATUS sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS echo 'CEOF sed -f conftest.frag conftest.in > conftest.out rm -f conftest.in mv conftest.out conftest.in ' >> $CONFIG_STATUS sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail rm -f conftest.vals mv conftest.tail conftest.vals done rm -f conftest.vals cat >> $CONFIG_STATUS <<\EOF rm -f conftest.frag conftest.h echo "/* $ac_file. Generated automatically by configure. */" > conftest.h cat conftest.in >> conftest.h rm -f conftest.in if cmp -s $ac_file conftest.h 2>/dev/null; then echo "$ac_file is unchanged" rm -f conftest.h else # Remove last slash and all that follows it. Not all systems have dirname. ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then # The file is in a subdirectory. test ! -d "$ac_dir" && mkdir "$ac_dir" fi rm -f $ac_file mv conftest.h $ac_file fi fi; done EOF cat >> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF exit 0 EOF chmod +x $CONFIG_STATUS rm -fr confdefs* $ac_clean_files test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1 Papyrus3/JpegDir/JpgLossy/JCPHUFF.C0000755000175000017500000006253407535143454014042 0ustar /* * jcphuff.c * * Copyright (C) 1995-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains Huffman entropy encoding routines for progressive JPEG. * * We do not support output suspension in this module, since the library * currently does not allow multiple-scan files to be written with output * suspension. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jchuff.h" /* Declarations shared with jchuff.c */ #ifdef C_PROGRESSIVE_SUPPORTED /* Expanded entropy encoder object for progressive Huffman encoding. */ typedef struct { struct jpeg_entropy_encoder pub; /* public fields */ /* Mode flag: TRUE for optimization, FALSE for actual data output */ boolean gather_statistics; /* Bit-level coding status. * next_output_byte/free_in_buffer are local copies of cinfo->dest fields. */ JOCTET * next_output_byte; /* => next byte to write in buffer */ size_t free_in_buffer; /* # of byte spaces remaining in buffer */ INT32 put_buffer; /* current bit-accumulation buffer */ int put_bits; /* # of bits now in it */ j_compress_ptr cinfo; /* link to cinfo (needed for dump_buffer) */ /* Coding status for DC components */ int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ /* Coding status for AC components */ int ac_tbl_no; /* the table number of the single component */ unsigned int EOBRUN; /* run length of EOBs */ unsigned int BE; /* # of buffered correction bits before MCU */ char * bit_buffer; /* buffer for correction bits (1 per char) */ /* packing correction bits tightly would save some space but cost time... */ unsigned int restarts_to_go; /* MCUs left in this restart interval */ int next_restart_num; /* next restart number to write (0-7) */ /* Pointers to derived tables (these workspaces have image lifespan). * Since any one scan codes only DC or only AC, we only need one set * of tables, not one for DC and one for AC. */ c_derived_tbl * derived_tbls[NUM_HUFF_TBLS]; /* Statistics tables for optimization; again, one set is enough */ long * count_ptrs[NUM_HUFF_TBLS]; } phuff_entropy_encoder; typedef phuff_entropy_encoder * phuff_entropy_ptr; /* MAX_CORR_BITS is the number of bits the AC refinement correction-bit * buffer can hold. Larger sizes may slightly improve compression, but * 1000 is already well into the realm of overkill. * The minimum safe size is 64 bits. */ #define MAX_CORR_BITS 1000 /* Max # of correction bits I can buffer */ /* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32. * We assume that int right shift is unsigned if INT32 right shift is, * which should be safe. */ #ifdef RIGHT_SHIFT_IS_UNSIGNED #define ISHIFT_TEMPS int ishift_temp; #define IRIGHT_SHIFT(x,shft) \ ((ishift_temp = (x)) < 0 ? \ (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \ (ishift_temp >> (shft))) #else #define ISHIFT_TEMPS #define IRIGHT_SHIFT(x,shft) ((x) >> (shft)) #endif /* Forward declarations */ METHODDEF(boolean) encode_mcu_DC_first JPP((j_compress_ptr cinfo, JBLOCKROW *MCU_data)); METHODDEF(boolean) encode_mcu_AC_first JPP((j_compress_ptr cinfo, JBLOCKROW *MCU_data)); METHODDEF(boolean) encode_mcu_DC_refine JPP((j_compress_ptr cinfo, JBLOCKROW *MCU_data)); METHODDEF(boolean) encode_mcu_AC_refine JPP((j_compress_ptr cinfo, JBLOCKROW *MCU_data)); METHODDEF(void) finish_pass_phuff JPP((j_compress_ptr cinfo)); METHODDEF(void) finish_pass_gather_phuff JPP((j_compress_ptr cinfo)); /* * Initialize for a Huffman-compressed scan using progressive JPEG. */ METHODDEF(void) start_pass_phuff (j_compress_ptr cinfo, boolean gather_statistics) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; boolean is_DC_band; int ci, tbl; jpeg_component_info * compptr; entropy->cinfo = cinfo; entropy->gather_statistics = gather_statistics; is_DC_band = (cinfo->Ss == 0); /* We assume jcmaster.c already validated the scan parameters. */ /* Select execution routines */ if (cinfo->Ah == 0) { if (is_DC_band) entropy->pub.encode_mcu = encode_mcu_DC_first; else entropy->pub.encode_mcu = encode_mcu_AC_first; } else { if (is_DC_band) entropy->pub.encode_mcu = encode_mcu_DC_refine; else { entropy->pub.encode_mcu = encode_mcu_AC_refine; /* AC refinement needs a correction bit buffer */ if (entropy->bit_buffer == NULL) entropy->bit_buffer = (char *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, MAX_CORR_BITS * SIZEOF(char)); } } if (gather_statistics) entropy->pub.finish_pass = finish_pass_gather_phuff; else entropy->pub.finish_pass = finish_pass_phuff; /* Only DC coefficients may be interleaved, so cinfo->comps_in_scan = 1 * for AC coefficients. */ for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; /* Initialize DC predictions to 0 */ entropy->last_dc_val[ci] = 0; /* Get table index */ if (is_DC_band) { if (cinfo->Ah != 0) /* DC refinement needs no table */ continue; tbl = compptr->dc_tbl_no; } else { entropy->ac_tbl_no = tbl = compptr->ac_tbl_no; } if (gather_statistics) { /* Check for invalid table index */ /* (make_c_derived_tbl does this in the other path) */ if (tbl < 0 || tbl >= NUM_HUFF_TBLS) ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tbl); /* Allocate and zero the statistics tables */ /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */ if (entropy->count_ptrs[tbl] == NULL) entropy->count_ptrs[tbl] = (long *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 257 * SIZEOF(long)); MEMZERO(entropy->count_ptrs[tbl], 257 * SIZEOF(long)); } else { /* Compute derived values for Huffman table */ /* We may do this more than once for a table, but it's not expensive */ jpeg_make_c_derived_tbl(cinfo, is_DC_band, tbl, & entropy->derived_tbls[tbl]); } } /* Initialize AC stuff */ entropy->EOBRUN = 0; entropy->BE = 0; /* Initialize bit buffer to empty */ entropy->put_buffer = 0; entropy->put_bits = 0; /* Initialize restart stuff */ entropy->restarts_to_go = cinfo->restart_interval; entropy->next_restart_num = 0; } /* Outputting bytes to the file. * NB: these must be called only when actually outputting, * that is, entropy->gather_statistics == FALSE. */ /* Emit a byte */ #define emit_byte(entropy,val) \ { *(entropy)->next_output_byte++ = (JOCTET) (val); \ if (--(entropy)->free_in_buffer == 0) \ dump_buffer(entropy); } LOCAL(void) dump_buffer (phuff_entropy_ptr entropy) /* Empty the output buffer; we do not support suspension in this module. */ { struct jpeg_destination_mgr * dest = entropy->cinfo->dest; if (! (*dest->empty_output_buffer) (entropy->cinfo)) ERREXIT(entropy->cinfo, JERR_CANT_SUSPEND); /* After a successful buffer dump, must reset buffer pointers */ entropy->next_output_byte = dest->next_output_byte; entropy->free_in_buffer = dest->free_in_buffer; } /* Outputting bits to the file */ /* Only the right 24 bits of put_buffer are used; the valid bits are * left-justified in this part. At most 16 bits can be passed to emit_bits * in one call, and we never retain more than 7 bits in put_buffer * between calls, so 24 bits are sufficient. */ INLINE LOCAL(void) emit_bits (phuff_entropy_ptr entropy, unsigned int code, int size) /* Emit some bits, unless we are in gather mode */ { /* This routine is heavily used, so it's worth coding tightly. */ register INT32 put_buffer = (INT32) code; register int put_bits = entropy->put_bits; /* if size is 0, caller used an invalid Huffman table entry */ if (size == 0) ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE); if (entropy->gather_statistics) return; /* do nothing if we're only getting stats */ put_buffer &= (((INT32) 1)<put_buffer; /* and merge with old buffer contents */ while (put_bits >= 8) { int c = (int) ((put_buffer >> 16) & 0xFF); emit_byte(entropy, c); if (c == 0xFF) { /* need to stuff a zero byte? */ emit_byte(entropy, 0); } put_buffer <<= 8; put_bits -= 8; } entropy->put_buffer = put_buffer; /* update variables */ entropy->put_bits = put_bits; } LOCAL(void) flush_bits (phuff_entropy_ptr entropy) { emit_bits(entropy, 0x7F, 7); /* fill any partial byte with ones */ entropy->put_buffer = 0; /* and reset bit-buffer to empty */ entropy->put_bits = 0; } /* * Emit (or just count) a Huffman symbol. */ INLINE LOCAL(void) emit_symbol (phuff_entropy_ptr entropy, int tbl_no, int symbol) { if (entropy->gather_statistics) entropy->count_ptrs[tbl_no][symbol]++; else { c_derived_tbl * tbl = entropy->derived_tbls[tbl_no]; emit_bits(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]); } } /* * Emit bits from a correction bit buffer. */ LOCAL(void) emit_buffered_bits (phuff_entropy_ptr entropy, char * bufstart, unsigned int nbits) { if (entropy->gather_statistics) return; /* no real work */ while (nbits > 0) { emit_bits(entropy, (unsigned int) (*bufstart), 1); bufstart++; nbits--; } } /* * Emit any pending EOBRUN symbol. */ LOCAL(void) emit_eobrun (phuff_entropy_ptr entropy) { register int temp, nbits; if (entropy->EOBRUN > 0) { /* if there is any pending EOBRUN */ temp = entropy->EOBRUN; nbits = 0; while ((temp >>= 1)) nbits++; /* safety check: shouldn't happen given limited correction-bit buffer */ if (nbits > 14) ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE); emit_symbol(entropy, entropy->ac_tbl_no, nbits << 4); if (nbits) emit_bits(entropy, entropy->EOBRUN, nbits); entropy->EOBRUN = 0; /* Emit any buffered correction bits */ emit_buffered_bits(entropy, entropy->bit_buffer, entropy->BE); entropy->BE = 0; } } /* * Emit a restart marker & resynchronize predictions. */ LOCAL(void) emit_restart (phuff_entropy_ptr entropy, int restart_num) { int ci; emit_eobrun(entropy); if (! entropy->gather_statistics) { flush_bits(entropy); emit_byte(entropy, 0xFF); emit_byte(entropy, JPEG_RST0 + restart_num); } if (entropy->cinfo->Ss == 0) { /* Re-initialize DC predictions to 0 */ for (ci = 0; ci < entropy->cinfo->comps_in_scan; ci++) entropy->last_dc_val[ci] = 0; } else { /* Re-initialize all AC-related fields to 0 */ entropy->EOBRUN = 0; entropy->BE = 0; } } /* * MCU encoding for DC initial scan (either spectral selection, * or first pass of successive approximation). */ METHODDEF(boolean) encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; register int temp, temp2; register int nbits; int blkn, ci; int Al = cinfo->Al; JBLOCKROW block; jpeg_component_info * compptr; ISHIFT_TEMPS entropy->next_output_byte = cinfo->dest->next_output_byte; entropy->free_in_buffer = cinfo->dest->free_in_buffer; /* Emit restart marker if needed */ if (cinfo->restart_interval) if (entropy->restarts_to_go == 0) emit_restart(entropy, entropy->next_restart_num); /* Encode the MCU data blocks */ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { block = MCU_data[blkn]; ci = cinfo->MCU_membership[blkn]; compptr = cinfo->cur_comp_info[ci]; /* Compute the DC value after the required point transform by Al. * This is simply an arithmetic right shift. */ temp2 = IRIGHT_SHIFT((int) ((*block)[0]), Al); /* DC differences are figured on the point-transformed values. */ temp = temp2 - entropy->last_dc_val[ci]; entropy->last_dc_val[ci] = temp2; /* Encode the DC coefficient difference per section G.1.2.1 */ temp2 = temp; if (temp < 0) { temp = -temp; /* temp is abs value of input */ /* For a negative input, want temp2 = bitwise complement of abs(input) */ /* This code assumes we are on a two's complement machine */ temp2--; } /* Find the number of bits needed for the magnitude of the coefficient */ nbits = 0; while (temp) { nbits++; temp >>= 1; } /* Check for out-of-range coefficient values. * Since we're encoding a difference, the range limit is twice as much. */ if (nbits > MAX_COEF_BITS+1) ERREXIT(cinfo, JERR_BAD_DCT_COEF); /* Count/emit the Huffman-coded symbol for the number of bits */ emit_symbol(entropy, compptr->dc_tbl_no, nbits); /* Emit that number of bits of the value, if positive, */ /* or the complement of its magnitude, if negative. */ if (nbits) /* emit_bits rejects calls with size 0 */ emit_bits(entropy, (unsigned int) temp2, nbits); } cinfo->dest->next_output_byte = entropy->next_output_byte; cinfo->dest->free_in_buffer = entropy->free_in_buffer; /* Update restart-interval state too */ if (cinfo->restart_interval) { if (entropy->restarts_to_go == 0) { entropy->restarts_to_go = cinfo->restart_interval; entropy->next_restart_num++; entropy->next_restart_num &= 7; } entropy->restarts_to_go--; } return TRUE; } /* * MCU encoding for AC initial scan (either spectral selection, * or first pass of successive approximation). */ METHODDEF(boolean) encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; register int temp, temp2; register int nbits; register int r, k; int Se = cinfo->Se; int Al = cinfo->Al; JBLOCKROW block; entropy->next_output_byte = cinfo->dest->next_output_byte; entropy->free_in_buffer = cinfo->dest->free_in_buffer; /* Emit restart marker if needed */ if (cinfo->restart_interval) if (entropy->restarts_to_go == 0) emit_restart(entropy, entropy->next_restart_num); /* Encode the MCU data block */ block = MCU_data[0]; /* Encode the AC coefficients per section G.1.2.2, fig. G.3 */ r = 0; /* r = run length of zeros */ for (k = cinfo->Ss; k <= Se; k++) { if ((temp = (*block)[jpeg_natural_order[k]]) == 0) { r++; continue; } /* We must apply the point transform by Al. For AC coefficients this * is an integer division with rounding towards 0. To do this portably * in C, we shift after obtaining the absolute value; so the code is * interwoven with finding the abs value (temp) and output bits (temp2). */ if (temp < 0) { temp = -temp; /* temp is abs value of input */ temp >>= Al; /* apply the point transform */ /* For a negative coef, want temp2 = bitwise complement of abs(coef) */ temp2 = ~temp; } else { temp >>= Al; /* apply the point transform */ temp2 = temp; } /* Watch out for case that nonzero coef is zero after point transform */ if (temp == 0) { r++; continue; } /* Emit any pending EOBRUN */ if (entropy->EOBRUN > 0) emit_eobrun(entropy); /* if run length > 15, must emit special run-length-16 codes (0xF0) */ while (r > 15) { emit_symbol(entropy, entropy->ac_tbl_no, 0xF0); r -= 16; } /* Find the number of bits needed for the magnitude of the coefficient */ nbits = 1; /* there must be at least one 1 bit */ while ((temp >>= 1)) nbits++; /* Check for out-of-range coefficient values */ if (nbits > MAX_COEF_BITS) ERREXIT(cinfo, JERR_BAD_DCT_COEF); /* Count/emit Huffman symbol for run length / number of bits */ emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + nbits); /* Emit that number of bits of the value, if positive, */ /* or the complement of its magnitude, if negative. */ emit_bits(entropy, (unsigned int) temp2, nbits); r = 0; /* reset zero run length */ } if (r > 0) { /* If there are trailing zeroes, */ entropy->EOBRUN++; /* count an EOB */ if (entropy->EOBRUN == 0x7FFF) emit_eobrun(entropy); /* force it out to avoid overflow */ } cinfo->dest->next_output_byte = entropy->next_output_byte; cinfo->dest->free_in_buffer = entropy->free_in_buffer; /* Update restart-interval state too */ if (cinfo->restart_interval) { if (entropy->restarts_to_go == 0) { entropy->restarts_to_go = cinfo->restart_interval; entropy->next_restart_num++; entropy->next_restart_num &= 7; } entropy->restarts_to_go--; } return TRUE; } /* * MCU encoding for DC successive approximation refinement scan. * Note: we assume such scans can be multi-component, although the spec * is not very clear on the point. */ METHODDEF(boolean) encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; register int temp; int blkn; int Al = cinfo->Al; JBLOCKROW block; entropy->next_output_byte = cinfo->dest->next_output_byte; entropy->free_in_buffer = cinfo->dest->free_in_buffer; /* Emit restart marker if needed */ if (cinfo->restart_interval) if (entropy->restarts_to_go == 0) emit_restart(entropy, entropy->next_restart_num); /* Encode the MCU data blocks */ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { block = MCU_data[blkn]; /* We simply emit the Al'th bit of the DC coefficient value. */ temp = (*block)[0]; emit_bits(entropy, (unsigned int) (temp >> Al), 1); } cinfo->dest->next_output_byte = entropy->next_output_byte; cinfo->dest->free_in_buffer = entropy->free_in_buffer; /* Update restart-interval state too */ if (cinfo->restart_interval) { if (entropy->restarts_to_go == 0) { entropy->restarts_to_go = cinfo->restart_interval; entropy->next_restart_num++; entropy->next_restart_num &= 7; } entropy->restarts_to_go--; } return TRUE; } /* * MCU encoding for AC successive approximation refinement scan. */ METHODDEF(boolean) encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; register int temp; register int r, k; int EOB; char *BR_buffer; unsigned int BR; int Se = cinfo->Se; int Al = cinfo->Al; JBLOCKROW block; int absvalues[DCTSIZE2]; entropy->next_output_byte = cinfo->dest->next_output_byte; entropy->free_in_buffer = cinfo->dest->free_in_buffer; /* Emit restart marker if needed */ if (cinfo->restart_interval) if (entropy->restarts_to_go == 0) emit_restart(entropy, entropy->next_restart_num); /* Encode the MCU data block */ block = MCU_data[0]; /* It is convenient to make a pre-pass to determine the transformed * coefficients' absolute values and the EOB position. */ EOB = 0; for (k = cinfo->Ss; k <= Se; k++) { temp = (*block)[jpeg_natural_order[k]]; /* We must apply the point transform by Al. For AC coefficients this * is an integer division with rounding towards 0. To do this portably * in C, we shift after obtaining the absolute value. */ if (temp < 0) temp = -temp; /* temp is abs value of input */ temp >>= Al; /* apply the point transform */ absvalues[k] = temp; /* save abs value for main pass */ if (temp == 1) EOB = k; /* EOB = index of last newly-nonzero coef */ } /* Encode the AC coefficients per section G.1.2.3, fig. G.7 */ r = 0; /* r = run length of zeros */ BR = 0; /* BR = count of buffered bits added now */ BR_buffer = entropy->bit_buffer + entropy->BE; /* Append bits to buffer */ for (k = cinfo->Ss; k <= Se; k++) { if ((temp = absvalues[k]) == 0) { r++; continue; } /* Emit any required ZRLs, but not if they can be folded into EOB */ while (r > 15 && k <= EOB) { /* emit any pending EOBRUN and the BE correction bits */ emit_eobrun(entropy); /* Emit ZRL */ emit_symbol(entropy, entropy->ac_tbl_no, 0xF0); r -= 16; /* Emit buffered correction bits that must be associated with ZRL */ emit_buffered_bits(entropy, BR_buffer, BR); BR_buffer = entropy->bit_buffer; /* BE bits are gone now */ BR = 0; } /* If the coef was previously nonzero, it only needs a correction bit. * NOTE: a straight translation of the spec's figure G.7 would suggest * that we also need to test r > 15. But if r > 15, we can only get here * if k > EOB, which implies that this coefficient is not 1. */ if (temp > 1) { /* The correction bit is the next bit of the absolute value. */ BR_buffer[BR++] = (char) (temp & 1); continue; } /* Emit any pending EOBRUN and the BE correction bits */ emit_eobrun(entropy); /* Count/emit Huffman symbol for run length / number of bits */ emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + 1); /* Emit output bit for newly-nonzero coef */ temp = ((*block)[jpeg_natural_order[k]] < 0) ? 0 : 1; emit_bits(entropy, (unsigned int) temp, 1); /* Emit buffered correction bits that must be associated with this code */ emit_buffered_bits(entropy, BR_buffer, BR); BR_buffer = entropy->bit_buffer; /* BE bits are gone now */ BR = 0; r = 0; /* reset zero run length */ } if (r > 0 || BR > 0) { /* If there are trailing zeroes, */ entropy->EOBRUN++; /* count an EOB */ entropy->BE += BR; /* concat my correction bits to older ones */ /* We force out the EOB if we risk either: * 1. overflow of the EOB counter; * 2. overflow of the correction bit buffer during the next MCU. */ if (entropy->EOBRUN == 0x7FFF || entropy->BE > (MAX_CORR_BITS-DCTSIZE2+1)) emit_eobrun(entropy); } cinfo->dest->next_output_byte = entropy->next_output_byte; cinfo->dest->free_in_buffer = entropy->free_in_buffer; /* Update restart-interval state too */ if (cinfo->restart_interval) { if (entropy->restarts_to_go == 0) { entropy->restarts_to_go = cinfo->restart_interval; entropy->next_restart_num++; entropy->next_restart_num &= 7; } entropy->restarts_to_go--; } return TRUE; } /* * Finish up at the end of a Huffman-compressed progressive scan. */ METHODDEF(void) finish_pass_phuff (j_compress_ptr cinfo) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; entropy->next_output_byte = cinfo->dest->next_output_byte; entropy->free_in_buffer = cinfo->dest->free_in_buffer; /* Flush out any buffered data */ emit_eobrun(entropy); flush_bits(entropy); cinfo->dest->next_output_byte = entropy->next_output_byte; cinfo->dest->free_in_buffer = entropy->free_in_buffer; } /* * Finish up a statistics-gathering pass and create the new Huffman tables. */ METHODDEF(void) finish_pass_gather_phuff (j_compress_ptr cinfo) { phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy; boolean is_DC_band; int ci, tbl; jpeg_component_info * compptr; JHUFF_TBL **htblptr; boolean did[NUM_HUFF_TBLS]; /* Flush out buffered data (all we care about is counting the EOB symbol) */ emit_eobrun(entropy); is_DC_band = (cinfo->Ss == 0); /* It's important not to apply jpeg_gen_optimal_table more than once * per table, because it clobbers the input frequency counts! */ MEMZERO(did, SIZEOF(did)); for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; if (is_DC_band) { if (cinfo->Ah != 0) /* DC refinement needs no table */ continue; tbl = compptr->dc_tbl_no; } else { tbl = compptr->ac_tbl_no; } if (! did[tbl]) { if (is_DC_band) htblptr = & cinfo->dc_huff_tbl_ptrs[tbl]; else htblptr = & cinfo->ac_huff_tbl_ptrs[tbl]; if (*htblptr == NULL) *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); jpeg_gen_optimal_table(cinfo, *htblptr, entropy->count_ptrs[tbl]); did[tbl] = TRUE; } } } /* * Module initialization routine for progressive Huffman entropy encoding. */ GLOBAL(void) jinit_phuff_encoder (j_compress_ptr cinfo) { phuff_entropy_ptr entropy; int i; entropy = (phuff_entropy_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(phuff_entropy_encoder)); cinfo->entropy = (struct jpeg_entropy_encoder *) entropy; entropy->pub.start_pass = start_pass_phuff; /* Mark tables unallocated */ for (i = 0; i < NUM_HUFF_TBLS; i++) { entropy->derived_tbls[i] = NULL; entropy->count_ptrs[i] = NULL; } entropy->bit_buffer = NULL; /* needed only in AC refinement scan */ } #endif /* C_PROGRESSIVE_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/JCHUFF.C0000755000175000017500000007071307535143454013720 0ustar /* * jchuff.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains Huffman entropy encoding routines. * * Much of the complexity here has to do with supporting output suspension. * If the data destination module demands suspension, we want to be able to * back up to the start of the current MCU. To do this, we copy state * variables into local working storage, and update them back to the * permanent JPEG objects only upon successful completion of an MCU. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jchuff.h" /* Declarations shared with jcphuff.c */ /* Expanded entropy encoder object for Huffman encoding. * * The savable_state subrecord contains fields that change within an MCU, * but must not be updated permanently until we complete the MCU. */ typedef struct { INT32 put_buffer; /* current bit-accumulation buffer */ int put_bits; /* # of bits now in it */ int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ } savable_state; /* This macro is to work around compilers with missing or broken * structure assignment. You'll need to fix this code if you have * such a compiler and you change MAX_COMPS_IN_SCAN. */ #ifndef NO_STRUCT_ASSIGN #define ASSIGN_STATE(dest,src) ((dest) = (src)) #else #if MAX_COMPS_IN_SCAN == 4 #define ASSIGN_STATE(dest,src) \ ((dest).put_buffer = (src).put_buffer, \ (dest).put_bits = (src).put_bits, \ (dest).last_dc_val[0] = (src).last_dc_val[0], \ (dest).last_dc_val[1] = (src).last_dc_val[1], \ (dest).last_dc_val[2] = (src).last_dc_val[2], \ (dest).last_dc_val[3] = (src).last_dc_val[3]) #endif #endif typedef struct { struct jpeg_entropy_encoder pub; /* public fields */ savable_state saved; /* Bit buffer & DC state at start of MCU */ /* These fields are NOT loaded into local working state. */ unsigned int restarts_to_go; /* MCUs left in this restart interval */ int next_restart_num; /* next restart number to write (0-7) */ /* Pointers to derived tables (these workspaces have image lifespan) */ c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS]; c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS]; #ifdef ENTROPY_OPT_SUPPORTED /* Statistics tables for optimization */ long * dc_count_ptrs[NUM_HUFF_TBLS]; long * ac_count_ptrs[NUM_HUFF_TBLS]; #endif } huff_entropy_encoder; typedef huff_entropy_encoder * huff_entropy_ptr; /* Working state while writing an MCU. * This struct contains all the fields that are needed by subroutines. */ typedef struct { JOCTET * next_output_byte; /* => next byte to write in buffer */ size_t free_in_buffer; /* # of byte spaces remaining in buffer */ savable_state cur; /* Current bit buffer & DC state */ j_compress_ptr cinfo; /* dump_buffer needs access to this */ } working_state; /* Forward declarations */ METHODDEF(boolean) encode_mcu_huff JPP((j_compress_ptr cinfo, JBLOCKROW *MCU_data)); METHODDEF(void) finish_pass_huff JPP((j_compress_ptr cinfo)); #ifdef ENTROPY_OPT_SUPPORTED METHODDEF(boolean) encode_mcu_gather JPP((j_compress_ptr cinfo, JBLOCKROW *MCU_data)); METHODDEF(void) finish_pass_gather JPP((j_compress_ptr cinfo)); #endif /* * Initialize for a Huffman-compressed scan. * If gather_statistics is TRUE, we do not output anything during the scan, * just count the Huffman symbols used and generate Huffman code tables. */ METHODDEF(void) start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics) { huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; int ci, dctbl, actbl; jpeg_component_info * compptr; if (gather_statistics) { #ifdef ENTROPY_OPT_SUPPORTED entropy->pub.encode_mcu = encode_mcu_gather; entropy->pub.finish_pass = finish_pass_gather; #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } else { entropy->pub.encode_mcu = encode_mcu_huff; entropy->pub.finish_pass = finish_pass_huff; } for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; dctbl = compptr->dc_tbl_no; actbl = compptr->ac_tbl_no; if (gather_statistics) { #ifdef ENTROPY_OPT_SUPPORTED /* Check for invalid table indexes */ /* (make_c_derived_tbl does this in the other path) */ if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS) ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl); if (actbl < 0 || actbl >= NUM_HUFF_TBLS) ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl); /* Allocate and zero the statistics tables */ /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */ if (entropy->dc_count_ptrs[dctbl] == NULL) entropy->dc_count_ptrs[dctbl] = (long *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 257 * SIZEOF(long)); MEMZERO(entropy->dc_count_ptrs[dctbl], 257 * SIZEOF(long)); if (entropy->ac_count_ptrs[actbl] == NULL) entropy->ac_count_ptrs[actbl] = (long *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 257 * SIZEOF(long)); MEMZERO(entropy->ac_count_ptrs[actbl], 257 * SIZEOF(long)); #endif } else { /* Compute derived values for Huffman tables */ /* We may do this more than once for a table, but it's not expensive */ jpeg_make_c_derived_tbl(cinfo, TRUE, dctbl, & entropy->dc_derived_tbls[dctbl]); jpeg_make_c_derived_tbl(cinfo, FALSE, actbl, & entropy->ac_derived_tbls[actbl]); } /* Initialize DC predictions to 0 */ entropy->saved.last_dc_val[ci] = 0; } /* Initialize bit buffer to empty */ entropy->saved.put_buffer = 0; entropy->saved.put_bits = 0; /* Initialize restart stuff */ entropy->restarts_to_go = cinfo->restart_interval; entropy->next_restart_num = 0; } /* * Compute the derived values for a Huffman table. * This routine also performs some validation checks on the table. * * Note this is also used by jcphuff.c. */ GLOBAL(void) jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno, c_derived_tbl ** pdtbl) { JHUFF_TBL *htbl; c_derived_tbl *dtbl; int p, i, l, lastp, si, maxsymbol; char huffsize[257]; unsigned int huffcode[257]; unsigned int code; /* Note that huffsize[] and huffcode[] are filled in code-length order, * paralleling the order of the symbols themselves in htbl->huffval[]. */ /* Find the input Huffman table */ if (tblno < 0 || tblno >= NUM_HUFF_TBLS) ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno); htbl = isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno]; if (htbl == NULL) ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno); /* Allocate a workspace if we haven't already done so. */ if (*pdtbl == NULL) *pdtbl = (c_derived_tbl *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(c_derived_tbl)); dtbl = *pdtbl; /* Figure C.1: make table of Huffman code length for each symbol */ p = 0; for (l = 1; l <= 16; l++) { i = (int) htbl->bits[l]; if (i < 0 || p + i > 256) /* protect against table overrun */ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); while (i--) huffsize[p++] = (char) l; } huffsize[p] = 0; lastp = p; /* Figure C.2: generate the codes themselves */ /* We also validate that the counts represent a legal Huffman code tree. */ code = 0; si = huffsize[0]; p = 0; while (huffsize[p]) { while (((int) huffsize[p]) == si) { huffcode[p++] = code; code++; } /* code is now 1 more than the last code used for codelength si; but * it must still fit in si bits, since no code is allowed to be all ones. */ if (((INT32) code) >= (((INT32) 1) << si)) ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); code <<= 1; si++; } /* Figure C.3: generate encoding tables */ /* These are code and size indexed by symbol value */ /* Set all codeless symbols to have code length 0; * this lets us detect duplicate VAL entries here, and later * allows emit_bits to detect any attempt to emit such symbols. */ MEMZERO(dtbl->ehufsi, SIZEOF(dtbl->ehufsi)); /* This is also a convenient place to check for out-of-range * and duplicated VAL entries. We allow 0..255 for AC symbols * but only 0..15 for DC. (We could constrain them further * based on data depth and mode, but this seems enough.) */ maxsymbol = isDC ? 15 : 255; for (p = 0; p < lastp; p++) { i = htbl->huffval[p]; if (i < 0 || i > maxsymbol || dtbl->ehufsi[i]) ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); dtbl->ehufco[i] = huffcode[p]; dtbl->ehufsi[i] = huffsize[p]; } } /* Outputting bytes to the file */ /* Emit a byte, taking 'action' if must suspend. */ #define emit_byte(state,val,action) \ { *(state)->next_output_byte++ = (JOCTET) (val); \ if (--(state)->free_in_buffer == 0) \ if (! dump_buffer(state)) \ { action; } } LOCAL(boolean) dump_buffer (working_state * state) /* Empty the output buffer; return TRUE if successful, FALSE if must suspend */ { struct jpeg_destination_mgr * dest = state->cinfo->dest; if (! (*dest->empty_output_buffer) (state->cinfo)) return FALSE; /* After a successful buffer dump, must reset buffer pointers */ state->next_output_byte = dest->next_output_byte; state->free_in_buffer = dest->free_in_buffer; return TRUE; } /* Outputting bits to the file */ /* Only the right 24 bits of put_buffer are used; the valid bits are * left-justified in this part. At most 16 bits can be passed to emit_bits * in one call, and we never retain more than 7 bits in put_buffer * between calls, so 24 bits are sufficient. */ INLINE LOCAL(boolean) emit_bits (working_state * state, unsigned int code, int size) /* Emit some bits; return TRUE if successful, FALSE if must suspend */ { /* This routine is heavily used, so it's worth coding tightly. */ register INT32 put_buffer = (INT32) code; register int put_bits = state->cur.put_bits; /* if size is 0, caller used an invalid Huffman table entry */ if (size == 0) ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE); put_buffer &= (((INT32) 1)<cur.put_buffer; /* and merge with old buffer contents */ while (put_bits >= 8) { int c = (int) ((put_buffer >> 16) & 0xFF); emit_byte(state, c, return FALSE); if (c == 0xFF) { /* need to stuff a zero byte? */ emit_byte(state, 0, return FALSE); } put_buffer <<= 8; put_bits -= 8; } state->cur.put_buffer = put_buffer; /* update state variables */ state->cur.put_bits = put_bits; return TRUE; } LOCAL(boolean) flush_bits (working_state * state) { if (! emit_bits(state, 0x7F, 7)) /* fill any partial byte with ones */ return FALSE; state->cur.put_buffer = 0; /* and reset bit-buffer to empty */ state->cur.put_bits = 0; return TRUE; } /* Encode a single block's worth of coefficients */ LOCAL(boolean) encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val, c_derived_tbl *dctbl, c_derived_tbl *actbl) { register int temp, temp2; register int nbits; register int k, r, i; /* Encode the DC coefficient difference per section F.1.2.1 */ temp = temp2 = block[0] - last_dc_val; if (temp < 0) { temp = -temp; /* temp is abs value of input */ /* For a negative input, want temp2 = bitwise complement of abs(input) */ /* This code assumes we are on a two's complement machine */ temp2--; } /* Find the number of bits needed for the magnitude of the coefficient */ nbits = 0; while (temp) { nbits++; temp >>= 1; } /* Check for out-of-range coefficient values. * Since we're encoding a difference, the range limit is twice as much. */ if (nbits > MAX_COEF_BITS+1) ERREXIT(state->cinfo, JERR_BAD_DCT_COEF); /* Emit the Huffman-coded symbol for the number of bits */ if (! emit_bits(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits])) return FALSE; /* Emit that number of bits of the value, if positive, */ /* or the complement of its magnitude, if negative. */ if (nbits) /* emit_bits rejects calls with size 0 */ if (! emit_bits(state, (unsigned int) temp2, nbits)) return FALSE; /* Encode the AC coefficients per section F.1.2.2 */ r = 0; /* r = run length of zeros */ for (k = 1; k < DCTSIZE2; k++) { if ((temp = block[jpeg_natural_order[k]]) == 0) { r++; } else { /* if run length > 15, must emit special run-length-16 codes (0xF0) */ while (r > 15) { if (! emit_bits(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0])) return FALSE; r -= 16; } temp2 = temp; if (temp < 0) { temp = -temp; /* temp is abs value of input */ /* This code assumes we are on a two's complement machine */ temp2--; } /* Find the number of bits needed for the magnitude of the coefficient */ nbits = 1; /* there must be at least one 1 bit */ while ((temp >>= 1)) nbits++; /* Check for out-of-range coefficient values */ if (nbits > MAX_COEF_BITS) ERREXIT(state->cinfo, JERR_BAD_DCT_COEF); /* Emit Huffman symbol for run length / number of bits */ i = (r << 4) + nbits; if (! emit_bits(state, actbl->ehufco[i], actbl->ehufsi[i])) return FALSE; /* Emit that number of bits of the value, if positive, */ /* or the complement of its magnitude, if negative. */ if (! emit_bits(state, (unsigned int) temp2, nbits)) return FALSE; r = 0; } } /* If the last coef(s) were zero, emit an end-of-block code */ if (r > 0) if (! emit_bits(state, actbl->ehufco[0], actbl->ehufsi[0])) return FALSE; return TRUE; } /* * Emit a restart marker & resynchronize predictions. */ LOCAL(boolean) emit_restart (working_state * state, int restart_num) { int ci; if (! flush_bits(state)) return FALSE; emit_byte(state, 0xFF, return FALSE); emit_byte(state, JPEG_RST0 + restart_num, return FALSE); /* Re-initialize DC predictions to 0 */ for (ci = 0; ci < state->cinfo->comps_in_scan; ci++) state->cur.last_dc_val[ci] = 0; /* The restart counter is not updated until we successfully write the MCU. */ return TRUE; } /* * Encode and output one MCU's worth of Huffman-compressed coefficients. */ METHODDEF(boolean) encode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data) { huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; working_state state; int blkn, ci; jpeg_component_info * compptr; /* Load up working state */ state.next_output_byte = cinfo->dest->next_output_byte; state.free_in_buffer = cinfo->dest->free_in_buffer; ASSIGN_STATE(state.cur, entropy->saved); state.cinfo = cinfo; /* Emit restart marker if needed */ if (cinfo->restart_interval) { if (entropy->restarts_to_go == 0) if (! emit_restart(&state, entropy->next_restart_num)) return FALSE; } /* Encode the MCU data blocks */ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { ci = cinfo->MCU_membership[blkn]; compptr = cinfo->cur_comp_info[ci]; if (! encode_one_block(&state, MCU_data[blkn][0], state.cur.last_dc_val[ci], entropy->dc_derived_tbls[compptr->dc_tbl_no], entropy->ac_derived_tbls[compptr->ac_tbl_no])) return FALSE; /* Update last_dc_val */ state.cur.last_dc_val[ci] = MCU_data[blkn][0][0]; } /* Completed MCU, so update state */ cinfo->dest->next_output_byte = state.next_output_byte; cinfo->dest->free_in_buffer = state.free_in_buffer; ASSIGN_STATE(entropy->saved, state.cur); /* Update restart-interval state too */ if (cinfo->restart_interval) { if (entropy->restarts_to_go == 0) { entropy->restarts_to_go = cinfo->restart_interval; entropy->next_restart_num++; entropy->next_restart_num &= 7; } entropy->restarts_to_go--; } return TRUE; } /* * Finish up at the end of a Huffman-compressed scan. */ METHODDEF(void) finish_pass_huff (j_compress_ptr cinfo) { huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; working_state state; /* Load up working state ... flush_bits needs it */ state.next_output_byte = cinfo->dest->next_output_byte; state.free_in_buffer = cinfo->dest->free_in_buffer; ASSIGN_STATE(state.cur, entropy->saved); state.cinfo = cinfo; /* Flush out the last data */ if (! flush_bits(&state)) ERREXIT(cinfo, JERR_CANT_SUSPEND); /* Update state */ cinfo->dest->next_output_byte = state.next_output_byte; cinfo->dest->free_in_buffer = state.free_in_buffer; ASSIGN_STATE(entropy->saved, state.cur); } /* * Huffman coding optimization. * * We first scan the supplied data and count the number of uses of each symbol * that is to be Huffman-coded. (This process MUST agree with the code above.) * Then we build a Huffman coding tree for the observed counts. * Symbols which are not needed at all for the particular image are not * assigned any code, which saves space in the DHT marker as well as in * the compressed data. */ #ifdef ENTROPY_OPT_SUPPORTED /* Process a single block's worth of coefficients */ LOCAL(void) htest_one_block (j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val, long dc_counts[], long ac_counts[]) { register int temp; register int nbits; register int k, r; /* Encode the DC coefficient difference per section F.1.2.1 */ temp = block[0] - last_dc_val; if (temp < 0) temp = -temp; /* Find the number of bits needed for the magnitude of the coefficient */ nbits = 0; while (temp) { nbits++; temp >>= 1; } /* Check for out-of-range coefficient values. * Since we're encoding a difference, the range limit is twice as much. */ if (nbits > MAX_COEF_BITS+1) ERREXIT(cinfo, JERR_BAD_DCT_COEF); /* Count the Huffman symbol for the number of bits */ dc_counts[nbits]++; /* Encode the AC coefficients per section F.1.2.2 */ r = 0; /* r = run length of zeros */ for (k = 1; k < DCTSIZE2; k++) { if ((temp = block[jpeg_natural_order[k]]) == 0) { r++; } else { /* if run length > 15, must emit special run-length-16 codes (0xF0) */ while (r > 15) { ac_counts[0xF0]++; r -= 16; } /* Find the number of bits needed for the magnitude of the coefficient */ if (temp < 0) temp = -temp; /* Find the number of bits needed for the magnitude of the coefficient */ nbits = 1; /* there must be at least one 1 bit */ while ((temp >>= 1)) nbits++; /* Check for out-of-range coefficient values */ if (nbits > MAX_COEF_BITS) ERREXIT(cinfo, JERR_BAD_DCT_COEF); /* Count Huffman symbol for run length / number of bits */ ac_counts[(r << 4) + nbits]++; r = 0; } } /* If the last coef(s) were zero, emit an end-of-block code */ if (r > 0) ac_counts[0]++; } /* * Trial-encode one MCU's worth of Huffman-compressed coefficients. * No data is actually output, so no suspension return is possible. */ METHODDEF(boolean) encode_mcu_gather (j_compress_ptr cinfo, JBLOCKROW *MCU_data) { huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; int blkn, ci; jpeg_component_info * compptr; /* Take care of restart intervals if needed */ if (cinfo->restart_interval) { if (entropy->restarts_to_go == 0) { /* Re-initialize DC predictions to 0 */ for (ci = 0; ci < cinfo->comps_in_scan; ci++) entropy->saved.last_dc_val[ci] = 0; /* Update restart state */ entropy->restarts_to_go = cinfo->restart_interval; } entropy->restarts_to_go--; } for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { ci = cinfo->MCU_membership[blkn]; compptr = cinfo->cur_comp_info[ci]; htest_one_block(cinfo, MCU_data[blkn][0], entropy->saved.last_dc_val[ci], entropy->dc_count_ptrs[compptr->dc_tbl_no], entropy->ac_count_ptrs[compptr->ac_tbl_no]); entropy->saved.last_dc_val[ci] = MCU_data[blkn][0][0]; } return TRUE; } /* * Generate the best Huffman code table for the given counts, fill htbl. * Note this is also used by jcphuff.c. * * The JPEG standard requires that no symbol be assigned a codeword of all * one bits (so that padding bits added at the end of a compressed segment * can't look like a valid code). Because of the canonical ordering of * codewords, this just means that there must be an unused slot in the * longest codeword length category. Section K.2 of the JPEG spec suggests * reserving such a slot by pretending that symbol 256 is a valid symbol * with count 1. In theory that's not optimal; giving it count zero but * including it in the symbol set anyway should give a better Huffman code. * But the theoretically better code actually seems to come out worse in * practice, because it produces more all-ones bytes (which incur stuffed * zero bytes in the final file). In any case the difference is tiny. * * The JPEG standard requires Huffman codes to be no more than 16 bits long. * If some symbols have a very small but nonzero probability, the Huffman tree * must be adjusted to meet the code length restriction. We currently use * the adjustment method suggested in JPEG section K.2. This method is *not* * optimal; it may not choose the best possible limited-length code. But * typically only very-low-frequency symbols will be given less-than-optimal * lengths, so the code is almost optimal. Experimental comparisons against * an optimal limited-length-code algorithm indicate that the difference is * microscopic --- usually less than a hundredth of a percent of total size. * So the extra complexity of an optimal algorithm doesn't seem worthwhile. */ GLOBAL(void) jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[]) { #define MAX_CLEN 32 /* assumed maximum initial code length */ UINT8 bits[MAX_CLEN+1]; /* bits[k] = # of symbols with code length k */ int codesize[257]; /* codesize[k] = code length of symbol k */ int others[257]; /* next symbol in current branch of tree */ int c1, c2; int p, i, j; long v; /* This algorithm is explained in section K.2 of the JPEG standard */ MEMZERO(bits, SIZEOF(bits)); MEMZERO(codesize, SIZEOF(codesize)); for (i = 0; i < 257; i++) others[i] = -1; /* init links to empty */ freq[256] = 1; /* make sure 256 has a nonzero count */ /* Including the pseudo-symbol 256 in the Huffman procedure guarantees * that no real symbol is given code-value of all ones, because 256 * will be placed last in the largest codeword category. */ /* Huffman's basic algorithm to assign optimal code lengths to symbols */ for (;;) { /* Find the smallest nonzero frequency, set c1 = its symbol */ /* In case of ties, take the larger symbol number */ c1 = -1; v = 1000000000L; for (i = 0; i <= 256; i++) { if (freq[i] && freq[i] <= v) { v = freq[i]; c1 = i; } } /* Find the next smallest nonzero frequency, set c2 = its symbol */ /* In case of ties, take the larger symbol number */ c2 = -1; v = 1000000000L; for (i = 0; i <= 256; i++) { if (freq[i] && freq[i] <= v && i != c1) { v = freq[i]; c2 = i; } } /* Done if we've merged everything into one frequency */ if (c2 < 0) break; /* Else merge the two counts/trees */ freq[c1] += freq[c2]; freq[c2] = 0; /* Increment the codesize of everything in c1's tree branch */ codesize[c1]++; while (others[c1] >= 0) { c1 = others[c1]; codesize[c1]++; } others[c1] = c2; /* chain c2 onto c1's tree branch */ /* Increment the codesize of everything in c2's tree branch */ codesize[c2]++; while (others[c2] >= 0) { c2 = others[c2]; codesize[c2]++; } } /* Now count the number of symbols of each code length */ for (i = 0; i <= 256; i++) { if (codesize[i]) { /* The JPEG standard seems to think that this can't happen, */ /* but I'm paranoid... */ if (codesize[i] > MAX_CLEN) ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW); bits[codesize[i]]++; } } /* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure * Huffman procedure assigned any such lengths, we must adjust the coding. * Here is what the JPEG spec says about how this next bit works: * Since symbols are paired for the longest Huffman code, the symbols are * removed from this length category two at a time. The prefix for the pair * (which is one bit shorter) is allocated to one of the pair; then, * skipping the BITS entry for that prefix length, a code word from the next * shortest nonzero BITS entry is converted into a prefix for two code words * one bit longer. */ for (i = MAX_CLEN; i > 16; i--) { while (bits[i] > 0) { j = i - 2; /* find length of new prefix to be used */ while (bits[j] == 0) j--; bits[i] -= 2; /* remove two symbols */ bits[i-1]++; /* one goes in this length */ bits[j+1] += 2; /* two new symbols in this length */ bits[j]--; /* symbol of this length is now a prefix */ } } /* Remove the count for the pseudo-symbol 256 from the largest codelength */ while (bits[i] == 0) /* find largest codelength still in use */ i--; bits[i]--; /* Return final symbol counts (only for lengths 0..16) */ MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits)); /* Return a list of the symbols sorted by code length */ /* It's not real clear to me why we don't need to consider the codelength * changes made above, but the JPEG spec seems to think this works. */ p = 0; for (i = 1; i <= MAX_CLEN; i++) { for (j = 0; j <= 255; j++) { if (codesize[j] == i) { htbl->huffval[p] = (UINT8) j; p++; } } } /* Set sent_table FALSE so updated table will be written to JPEG file. */ htbl->sent_table = FALSE; } /* * Finish up a statistics-gathering pass and create the new Huffman tables. */ METHODDEF(void) finish_pass_gather (j_compress_ptr cinfo) { huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; int ci, dctbl, actbl; jpeg_component_info * compptr; JHUFF_TBL **htblptr; boolean did_dc[NUM_HUFF_TBLS]; boolean did_ac[NUM_HUFF_TBLS]; /* It's important not to apply jpeg_gen_optimal_table more than once * per table, because it clobbers the input frequency counts! */ MEMZERO(did_dc, SIZEOF(did_dc)); MEMZERO(did_ac, SIZEOF(did_ac)); for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; dctbl = compptr->dc_tbl_no; actbl = compptr->ac_tbl_no; if (! did_dc[dctbl]) { htblptr = & cinfo->dc_huff_tbl_ptrs[dctbl]; if (*htblptr == NULL) *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); jpeg_gen_optimal_table(cinfo, *htblptr, entropy->dc_count_ptrs[dctbl]); did_dc[dctbl] = TRUE; } if (! did_ac[actbl]) { htblptr = & cinfo->ac_huff_tbl_ptrs[actbl]; if (*htblptr == NULL) *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); jpeg_gen_optimal_table(cinfo, *htblptr, entropy->ac_count_ptrs[actbl]); did_ac[actbl] = TRUE; } } } #endif /* ENTROPY_OPT_SUPPORTED */ /* * Module initialization routine for Huffman entropy encoding. */ GLOBAL(void) jinit_huff_encoder (j_compress_ptr cinfo) { huff_entropy_ptr entropy; int i; entropy = (huff_entropy_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(huff_entropy_encoder)); cinfo->entropy = (struct jpeg_entropy_encoder *) entropy; entropy->pub.start_pass = start_pass_huff; /* Mark tables unallocated */ for (i = 0; i < NUM_HUFF_TBLS; i++) { entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL; #ifdef ENTROPY_OPT_SUPPORTED entropy->dc_count_ptrs[i] = entropy->ac_count_ptrs[i] = NULL; #endif } } Papyrus3/JpegDir/JpgLossy/JCPARAM.C0000755000175000017500000005257507535143454014036 0ustar /* * jcparam.c * * Copyright (C) 1991-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains optional default-setting code for the JPEG compressor. * Applications do not have to use this file, but those that don't use it * must know a lot more about the innards of the JPEG code. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* * Quantization table setup routines */ GLOBAL(void) jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl, const unsigned int *basic_table, int scale_factor, boolean force_baseline) /* Define a quantization table equal to the basic_table times * a scale factor (given as a percentage). * If force_baseline is TRUE, the computed quantization table entries * are limited to 1..255 for JPEG baseline compatibility. */ { JQUANT_TBL ** qtblptr; int i; long temp; /* Safety check to ensure start_compress not called yet. */ if (cinfo->global_state != CSTATE_START) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS) ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl); qtblptr = & cinfo->quant_tbl_ptrs[which_tbl]; if (*qtblptr == NULL) *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo); for (i = 0; i < DCTSIZE2; i++) { temp = ((long) basic_table[i] * scale_factor + 50L) / 100L; /* limit the values to the valid range */ if (temp <= 0L) temp = 1L; if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */ if (force_baseline && temp > 255L) temp = 255L; /* limit to baseline range if requested */ (*qtblptr)->quantval[i] = (UINT16) temp; } /* Initialize sent_table FALSE so table will be written to JPEG file. */ (*qtblptr)->sent_table = FALSE; } GLOBAL(void) jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor, boolean force_baseline) /* Set or change the 'quality' (quantization) setting, using default tables * and a straight percentage-scaling quality scale. In most cases it's better * to use jpeg_set_quality (below); this entry point is provided for * applications that insist on a linear percentage scaling. */ { /* These are the sample quantization tables given in JPEG spec section K.1. * The spec says that the values given produce "good" quality, and * when divided by 2, "very good" quality. */ static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = { 16, 11, 10, 16, 24, 40, 51, 61, 12, 12, 14, 19, 26, 58, 60, 55, 14, 13, 16, 24, 40, 57, 69, 56, 14, 17, 22, 29, 51, 87, 80, 62, 18, 22, 37, 56, 68, 109, 103, 77, 24, 35, 55, 64, 81, 104, 113, 92, 49, 64, 78, 87, 103, 121, 120, 101, 72, 92, 95, 98, 112, 100, 103, 99 }; static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = { 17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66, 99, 99, 99, 99, 24, 26, 56, 99, 99, 99, 99, 99, 47, 66, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99 }; /* Set up two quantization tables using the specified scaling */ jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl, scale_factor, force_baseline); jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl, scale_factor, force_baseline); } GLOBAL(int) jpeg_quality_scaling (int quality) /* Convert a user-specified quality rating to a percentage scaling factor * for an underlying quantization table, using our recommended scaling curve. * The input 'quality' factor should be 0 (terrible) to 100 (very good). */ { /* Safety limit on quality factor. Convert 0 to 1 to avoid zero divide. */ if (quality <= 0) quality = 1; if (quality > 100) quality = 100; /* The basic table is used as-is (scaling 100) for a quality of 50. * Qualities 50..100 are converted to scaling percentage 200 - 2*Q; * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table * to make all the table entries 1 (hence, minimum quantization loss). * Qualities 1..50 are converted to scaling percentage 5000/Q. */ if (quality < 50) quality = 5000 / quality; else quality = 200 - quality*2; return quality; } GLOBAL(void) jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline) /* Set or change the 'quality' (quantization) setting, using default tables. * This is the standard quality-adjusting entry point for typical user * interfaces; only those who want detailed control over quantization tables * would use the preceding three routines directly. */ { /* Convert user 0-100 rating to percentage scaling */ quality = jpeg_quality_scaling(quality); /* Set up standard quality tables */ jpeg_set_linear_quality(cinfo, quality, force_baseline); } /* * Huffman table setup routines */ LOCAL(void) add_huff_table (j_compress_ptr cinfo, JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val) /* Define a Huffman table */ { int nsymbols, len; if (*htblptr == NULL) *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); /* Copy the number-of-symbols-of-each-code-length counts */ MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits)); /* Validate the counts. We do this here mainly so we can copy the right * number of symbols from the val[] array, without risking marching off * the end of memory. jchuff.c will do a more thorough test later. */ nsymbols = 0; for (len = 1; len <= 16; len++) nsymbols += bits[len]; if (nsymbols < 1 || nsymbols > 256) ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8)); /* Initialize sent_table FALSE so table will be written to JPEG file. */ (*htblptr)->sent_table = FALSE; } LOCAL(void) std_huff_tables (j_compress_ptr cinfo) /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */ /* IMPORTANT: these are only valid for 8-bit data precision! */ { static const UINT8 bits_dc_luminance[17] = { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 }; static const UINT8 val_dc_luminance[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; static const UINT8 bits_dc_chrominance[17] = { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }; static const UINT8 val_dc_chrominance[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; static const UINT8 bits_ac_luminance[17] = { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d }; static const UINT8 val_ac_luminance[] = { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa }; static const UINT8 bits_ac_chrominance[17] = { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 }; static const UINT8 val_ac_chrominance[] = { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa }; add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0], bits_dc_luminance, val_dc_luminance); add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0], bits_ac_luminance, val_ac_luminance); add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1], bits_dc_chrominance, val_dc_chrominance); add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1], bits_ac_chrominance, val_ac_chrominance); } /* * Default parameter setup for compression. * * Applications that don't choose to use this routine must do their * own setup of all these parameters. Alternately, you can call this * to establish defaults and then alter parameters selectively. This * is the recommended approach since, if we add any new parameters, * your code will still work (they'll be set to reasonable defaults). */ GLOBAL(void) jpeg_set_defaults (j_compress_ptr cinfo) { int i; /* Safety check to ensure start_compress not called yet. */ if (cinfo->global_state != CSTATE_START) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); /* Allocate comp_info array large enough for maximum component count. * Array is made permanent in case application wants to compress * multiple images at same param settings. */ if (cinfo->comp_info == NULL) cinfo->comp_info = (jpeg_component_info *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, MAX_COMPONENTS * SIZEOF(jpeg_component_info)); /* Initialize everything not dependent on the color space */ cinfo->data_precision = BITS_IN_JSAMPLE; /* Set up two quantization tables using default quality of 75 */ jpeg_set_quality(cinfo, 75, TRUE); /* Set up two Huffman tables */ std_huff_tables(cinfo); /* Initialize default arithmetic coding conditioning */ for (i = 0; i < NUM_ARITH_TBLS; i++) { cinfo->arith_dc_L[i] = 0; cinfo->arith_dc_U[i] = 1; cinfo->arith_ac_K[i] = 5; } /* Default is no multiple-scan output */ cinfo->scan_info = NULL; cinfo->num_scans = 0; /* Expect normal source image, not raw downsampled data */ cinfo->raw_data_in = FALSE; /* Use Huffman coding, not arithmetic coding, by default */ cinfo->arith_code = FALSE; /* By default, don't do extra passes to optimize entropy coding */ cinfo->optimize_coding = FALSE; /* The standard Huffman tables are only valid for 8-bit data precision. * If the precision is higher, force optimization on so that usable * tables will be computed. This test can be removed if default tables * are supplied that are valid for the desired precision. */ if (cinfo->data_precision > 8) cinfo->optimize_coding = TRUE; /* By default, use the simpler non-cosited sampling alignment */ cinfo->CCIR601_sampling = FALSE; /* No input smoothing */ cinfo->smoothing_factor = 0; /* DCT algorithm preference */ cinfo->dct_method = JDCT_DEFAULT; /* No restart markers */ cinfo->restart_interval = 0; cinfo->restart_in_rows = 0; /* Fill in default JFIF marker parameters. Note that whether the marker * will actually be written is determined by jpeg_set_colorspace. * * By default, the library emits JFIF version code 1.01. * An application that wants to emit JFIF 1.02 extension markers should set * JFIF_minor_version to 2. We could probably get away with just defaulting * to 1.02, but there may still be some decoders in use that will complain * about that; saying 1.01 should minimize compatibility problems. */ cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */ cinfo->JFIF_minor_version = 1; cinfo->density_unit = 0; /* Pixel size is unknown by default */ cinfo->X_density = 1; /* Pixel aspect ratio is square by default */ cinfo->Y_density = 1; /* Choose JPEG colorspace based on input space, set defaults accordingly */ jpeg_default_colorspace(cinfo); } /* * Select an appropriate JPEG colorspace for in_color_space. */ GLOBAL(void) jpeg_default_colorspace (j_compress_ptr cinfo) { switch (cinfo->in_color_space) { case JCS_GRAYSCALE: jpeg_set_colorspace(cinfo, JCS_GRAYSCALE); break; case JCS_RGB: jpeg_set_colorspace(cinfo, JCS_YCbCr); break; case JCS_YCbCr: jpeg_set_colorspace(cinfo, JCS_YCbCr); break; case JCS_CMYK: jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */ break; case JCS_YCCK: jpeg_set_colorspace(cinfo, JCS_YCCK); break; case JCS_UNKNOWN: jpeg_set_colorspace(cinfo, JCS_UNKNOWN); break; default: ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); } } /* * Set the JPEG colorspace, and choose colorspace-dependent default values. */ GLOBAL(void) jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace) { jpeg_component_info * compptr; int ci; #define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \ (compptr = &cinfo->comp_info[index], \ compptr->component_id = (id), \ compptr->h_samp_factor = (hsamp), \ compptr->v_samp_factor = (vsamp), \ compptr->quant_tbl_no = (quant), \ compptr->dc_tbl_no = (dctbl), \ compptr->ac_tbl_no = (actbl) ) /* Safety check to ensure start_compress not called yet. */ if (cinfo->global_state != CSTATE_START) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); /* For all colorspaces, we use Q and Huff tables 0 for luminance components, * tables 1 for chrominance components. */ cinfo->jpeg_color_space = colorspace; cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */ cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */ switch (colorspace) { case JCS_GRAYSCALE: cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */ cinfo->num_components = 1; /* JFIF specifies component ID 1 */ SET_COMP(0, 1, 1,1, 0, 0,0); break; case JCS_RGB: cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */ cinfo->num_components = 3; SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0); SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0); SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0); break; case JCS_YCbCr: cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */ cinfo->num_components = 3; /* JFIF specifies component IDs 1,2,3 */ /* We default to 2x2 subsamples of chrominance */ SET_COMP(0, 1, 2,2, 0, 0,0); SET_COMP(1, 2, 1,1, 1, 1,1); SET_COMP(2, 3, 1,1, 1, 1,1); break; case JCS_CMYK: cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */ cinfo->num_components = 4; SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0); SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0); SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0); SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0); break; case JCS_YCCK: cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */ cinfo->num_components = 4; SET_COMP(0, 1, 2,2, 0, 0,0); SET_COMP(1, 2, 1,1, 1, 1,1); SET_COMP(2, 3, 1,1, 1, 1,1); SET_COMP(3, 4, 2,2, 0, 0,0); break; case JCS_UNKNOWN: cinfo->num_components = cinfo->input_components; if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS) ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components, MAX_COMPONENTS); for (ci = 0; ci < cinfo->num_components; ci++) { SET_COMP(ci, ci, 1,1, 0, 0,0); } break; default: ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); } } #ifdef C_PROGRESSIVE_SUPPORTED LOCAL(jpeg_scan_info *) fill_a_scan (jpeg_scan_info * scanptr, int ci, int Ss, int Se, int Ah, int Al) /* Support routine: generate one scan for specified component */ { scanptr->comps_in_scan = 1; scanptr->component_index[0] = ci; scanptr->Ss = Ss; scanptr->Se = Se; scanptr->Ah = Ah; scanptr->Al = Al; scanptr++; return scanptr; } LOCAL(jpeg_scan_info *) fill_scans (jpeg_scan_info * scanptr, int ncomps, int Ss, int Se, int Ah, int Al) /* Support routine: generate one scan for each component */ { int ci; for (ci = 0; ci < ncomps; ci++) { scanptr->comps_in_scan = 1; scanptr->component_index[0] = ci; scanptr->Ss = Ss; scanptr->Se = Se; scanptr->Ah = Ah; scanptr->Al = Al; scanptr++; } return scanptr; } LOCAL(jpeg_scan_info *) fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al) /* Support routine: generate interleaved DC scan if possible, else N scans */ { int ci; if (ncomps <= MAX_COMPS_IN_SCAN) { /* Single interleaved DC scan */ scanptr->comps_in_scan = ncomps; for (ci = 0; ci < ncomps; ci++) scanptr->component_index[ci] = ci; scanptr->Ss = scanptr->Se = 0; scanptr->Ah = Ah; scanptr->Al = Al; scanptr++; } else { /* Noninterleaved DC scan for each component */ scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al); } return scanptr; } /* * Create a recommended progressive-JPEG script. * cinfo->num_components and cinfo->jpeg_color_space must be correct. */ GLOBAL(void) jpeg_simple_progression (j_compress_ptr cinfo) { int ncomps = cinfo->num_components; int nscans; jpeg_scan_info * scanptr; /* Safety check to ensure start_compress not called yet. */ if (cinfo->global_state != CSTATE_START) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); /* Figure space needed for script. Calculation must match code below! */ if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) { /* Custom script for YCbCr color images. */ nscans = 10; } else { /* All-purpose script for other color spaces. */ if (ncomps > MAX_COMPS_IN_SCAN) nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */ else nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */ } /* Allocate space for script. * We need to put it in the permanent pool in case the application performs * multiple compressions without changing the settings. To avoid a memory * leak if jpeg_simple_progression is called repeatedly for the same JPEG * object, we try to re-use previously allocated space, and we allocate * enough space to handle YCbCr even if initially asked for grayscale. */ if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) { cinfo->script_space_size = MAX(nscans, 10); cinfo->script_space = (jpeg_scan_info *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, cinfo->script_space_size * SIZEOF(jpeg_scan_info)); } scanptr = cinfo->script_space; cinfo->scan_info = scanptr; cinfo->num_scans = nscans; if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) { /* Custom script for YCbCr color images. */ /* Initial DC scan */ scanptr = fill_dc_scans(scanptr, ncomps, 0, 1); /* Initial AC scan: get some luma data out in a hurry */ scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2); /* Chroma data is too small to be worth expending many scans on */ scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1); scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1); /* Complete spectral selection for luma AC */ scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2); /* Refine next bit of luma AC */ scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1); /* Finish DC successive approximation */ scanptr = fill_dc_scans(scanptr, ncomps, 1, 0); /* Finish AC successive approximation */ scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0); scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0); /* Luma bottom bit comes last since it's usually largest scan */ scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0); } else { /* All-purpose script for other color spaces. */ /* Successive approximation first pass */ scanptr = fill_dc_scans(scanptr, ncomps, 0, 1); scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2); scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2); /* Successive approximation second pass */ scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1); /* Successive approximation final pass */ scanptr = fill_dc_scans(scanptr, ncomps, 1, 0); scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0); } } #endif /* C_PROGRESSIVE_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/JCMARKER.C0000755000175000017500000004276507535143454014157 0ustar /* * jcmarker.c * * Copyright (C) 1991-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to write JPEG datastream markers. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" typedef enum { /* JPEG marker codes */ M_SOF0 = 0xc0, M_SOF1 = 0xc1, M_SOF2 = 0xc2, M_SOF3 = 0xc3, M_SOF5 = 0xc5, M_SOF6 = 0xc6, M_SOF7 = 0xc7, M_JPG = 0xc8, M_SOF9 = 0xc9, M_SOF10 = 0xca, M_SOF11 = 0xcb, M_SOF13 = 0xcd, M_SOF14 = 0xce, M_SOF15 = 0xcf, M_DHT = 0xc4, M_DAC = 0xcc, M_RST0 = 0xd0, M_RST1 = 0xd1, M_RST2 = 0xd2, M_RST3 = 0xd3, M_RST4 = 0xd4, M_RST5 = 0xd5, M_RST6 = 0xd6, M_RST7 = 0xd7, M_SOI = 0xd8, M_EOI = 0xd9, M_SOS = 0xda, M_DQT = 0xdb, M_DNL = 0xdc, M_DRI = 0xdd, M_DHP = 0xde, M_EXP = 0xdf, M_APP0 = 0xe0, M_APP1 = 0xe1, M_APP2 = 0xe2, M_APP3 = 0xe3, M_APP4 = 0xe4, M_APP5 = 0xe5, M_APP6 = 0xe6, M_APP7 = 0xe7, M_APP8 = 0xe8, M_APP9 = 0xe9, M_APP10 = 0xea, M_APP11 = 0xeb, M_APP12 = 0xec, M_APP13 = 0xed, M_APP14 = 0xee, M_APP15 = 0xef, M_JPG0 = 0xf0, M_JPG13 = 0xfd, M_COM = 0xfe, M_TEM = 0x01, M_ERROR = 0x100 } JPEG_MARKER; /* Private state */ typedef struct { struct jpeg_marker_writer pub; /* public fields */ unsigned int last_restart_interval; /* last DRI value emitted; 0 after SOI */ } my_marker_writer; typedef my_marker_writer * my_marker_ptr; /* * Basic output routines. * * Note that we do not support suspension while writing a marker. * Therefore, an application using suspension must ensure that there is * enough buffer space for the initial markers (typ. 600-700 bytes) before * calling jpeg_start_compress, and enough space to write the trailing EOI * (a few bytes) before calling jpeg_finish_compress. Multipass compression * modes are not supported at all with suspension, so those two are the only * points where markers will be written. */ LOCAL(void) emit_byte (j_compress_ptr cinfo, int val) /* Emit a byte */ { struct jpeg_destination_mgr * dest = cinfo->dest; *(dest->next_output_byte)++ = (JOCTET) val; if (--dest->free_in_buffer == 0) { if (! (*dest->empty_output_buffer) (cinfo)) ERREXIT(cinfo, JERR_CANT_SUSPEND); } } LOCAL(void) emit_marker (j_compress_ptr cinfo, JPEG_MARKER mark) /* Emit a marker code */ { emit_byte(cinfo, 0xFF); emit_byte(cinfo, (int) mark); } LOCAL(void) emit_2bytes (j_compress_ptr cinfo, int value) /* Emit a 2-byte integer; these are always MSB first in JPEG files */ { emit_byte(cinfo, (value >> 8) & 0xFF); emit_byte(cinfo, value & 0xFF); } /* * Routines to write specific marker types. */ LOCAL(int) emit_dqt (j_compress_ptr cinfo, int index) /* Emit a DQT marker */ /* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */ { JQUANT_TBL * qtbl = cinfo->quant_tbl_ptrs[index]; int prec; int i; if (qtbl == NULL) ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, index); prec = 0; for (i = 0; i < DCTSIZE2; i++) { if (qtbl->quantval[i] > 255) prec = 1; } if (! qtbl->sent_table) { emit_marker(cinfo, M_DQT); emit_2bytes(cinfo, prec ? DCTSIZE2*2 + 1 + 2 : DCTSIZE2 + 1 + 2); emit_byte(cinfo, index + (prec<<4)); for (i = 0; i < DCTSIZE2; i++) { /* The table entries must be emitted in zigzag order. */ unsigned int qval = qtbl->quantval[jpeg_natural_order[i]]; if (prec) emit_byte(cinfo, (int) (qval >> 8)); emit_byte(cinfo, (int) (qval & 0xFF)); } qtbl->sent_table = TRUE; } return prec; } LOCAL(void) emit_dht (j_compress_ptr cinfo, int index, boolean is_ac) /* Emit a DHT marker */ { JHUFF_TBL * htbl; int length, i; if (is_ac) { htbl = cinfo->ac_huff_tbl_ptrs[index]; index += 0x10; /* output index has AC bit set */ } else { htbl = cinfo->dc_huff_tbl_ptrs[index]; } if (htbl == NULL) ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index); if (! htbl->sent_table) { emit_marker(cinfo, M_DHT); length = 0; for (i = 1; i <= 16; i++) length += htbl->bits[i]; emit_2bytes(cinfo, length + 2 + 1 + 16); emit_byte(cinfo, index); for (i = 1; i <= 16; i++) emit_byte(cinfo, htbl->bits[i]); for (i = 0; i < length; i++) emit_byte(cinfo, htbl->huffval[i]); htbl->sent_table = TRUE; } } LOCAL(void) emit_dac (j_compress_ptr cinfo) /* Emit a DAC marker */ /* Since the useful info is so small, we want to emit all the tables in */ /* one DAC marker. Therefore this routine does its own scan of the table. */ { #ifdef C_ARITH_CODING_SUPPORTED char dc_in_use[NUM_ARITH_TBLS]; char ac_in_use[NUM_ARITH_TBLS]; int length, i; jpeg_component_info *compptr; for (i = 0; i < NUM_ARITH_TBLS; i++) dc_in_use[i] = ac_in_use[i] = 0; for (i = 0; i < cinfo->comps_in_scan; i++) { compptr = cinfo->cur_comp_info[i]; dc_in_use[compptr->dc_tbl_no] = 1; ac_in_use[compptr->ac_tbl_no] = 1; } length = 0; for (i = 0; i < NUM_ARITH_TBLS; i++) length += dc_in_use[i] + ac_in_use[i]; emit_marker(cinfo, M_DAC); emit_2bytes(cinfo, length*2 + 2); for (i = 0; i < NUM_ARITH_TBLS; i++) { if (dc_in_use[i]) { emit_byte(cinfo, i); emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i]<<4)); } if (ac_in_use[i]) { emit_byte(cinfo, i + 0x10); emit_byte(cinfo, cinfo->arith_ac_K[i]); } } #endif /* C_ARITH_CODING_SUPPORTED */ } LOCAL(void) emit_dri (j_compress_ptr cinfo) /* Emit a DRI marker */ { emit_marker(cinfo, M_DRI); emit_2bytes(cinfo, 4); /* fixed length */ emit_2bytes(cinfo, (int) cinfo->restart_interval); } LOCAL(void) emit_sof (j_compress_ptr cinfo, JPEG_MARKER code) /* Emit a SOF marker */ { int ci; jpeg_component_info *compptr; emit_marker(cinfo, code); emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */ /* Make sure image isn't bigger than SOF field can handle */ if ((long) cinfo->image_height > 65535L || (long) cinfo->image_width > 65535L) ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) 65535); emit_byte(cinfo, cinfo->data_precision); emit_2bytes(cinfo, (int) cinfo->image_height); emit_2bytes(cinfo, (int) cinfo->image_width); emit_byte(cinfo, cinfo->num_components); for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { emit_byte(cinfo, compptr->component_id); emit_byte(cinfo, (compptr->h_samp_factor << 4) + compptr->v_samp_factor); emit_byte(cinfo, compptr->quant_tbl_no); } } LOCAL(void) emit_sos (j_compress_ptr cinfo) /* Emit a SOS marker */ { int i, td, ta; jpeg_component_info *compptr; emit_marker(cinfo, M_SOS); emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */ emit_byte(cinfo, cinfo->comps_in_scan); for (i = 0; i < cinfo->comps_in_scan; i++) { compptr = cinfo->cur_comp_info[i]; emit_byte(cinfo, compptr->component_id); td = compptr->dc_tbl_no; ta = compptr->ac_tbl_no; if (cinfo->progressive_mode) { /* Progressive mode: only DC or only AC tables are used in one scan; * furthermore, Huffman coding of DC refinement uses no table at all. * We emit 0 for unused field(s); this is recommended by the P&M text * but does not seem to be specified in the standard. */ if (cinfo->Ss == 0) { ta = 0; /* DC scan */ if (cinfo->Ah != 0 && !cinfo->arith_code) td = 0; /* no DC table either */ } else { td = 0; /* AC scan */ } } emit_byte(cinfo, (td << 4) + ta); } emit_byte(cinfo, cinfo->Ss); emit_byte(cinfo, cinfo->Se); emit_byte(cinfo, (cinfo->Ah << 4) + cinfo->Al); } LOCAL(void) emit_jfif_app0 (j_compress_ptr cinfo) /* Emit a JFIF-compliant APP0 marker */ { /* * Length of APP0 block (2 bytes) * Block ID (4 bytes - ASCII "JFIF") * Zero byte (1 byte to terminate the ID string) * Version Major, Minor (2 bytes - major first) * Units (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm) * Xdpu (2 bytes - dots per unit horizontal) * Ydpu (2 bytes - dots per unit vertical) * Thumbnail X size (1 byte) * Thumbnail Y size (1 byte) */ emit_marker(cinfo, M_APP0); emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */ emit_byte(cinfo, 0x4A); /* Identifier: ASCII "JFIF" */ emit_byte(cinfo, 0x46); emit_byte(cinfo, 0x49); emit_byte(cinfo, 0x46); emit_byte(cinfo, 0); emit_byte(cinfo, cinfo->JFIF_major_version); /* Version fields */ emit_byte(cinfo, cinfo->JFIF_minor_version); emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */ emit_2bytes(cinfo, (int) cinfo->X_density); emit_2bytes(cinfo, (int) cinfo->Y_density); emit_byte(cinfo, 0); /* No thumbnail image */ emit_byte(cinfo, 0); } LOCAL(void) emit_adobe_app14 (j_compress_ptr cinfo) /* Emit an Adobe APP14 marker */ { /* * Length of APP14 block (2 bytes) * Block ID (5 bytes - ASCII "Adobe") * Version Number (2 bytes - currently 100) * Flags0 (2 bytes - currently 0) * Flags1 (2 bytes - currently 0) * Color transform (1 byte) * * Although Adobe TN 5116 mentions Version = 101, all the Adobe files * now in circulation seem to use Version = 100, so that's what we write. * * We write the color transform byte as 1 if the JPEG color space is * YCbCr, 2 if it's YCCK, 0 otherwise. Adobe's definition has to do with * whether the encoder performed a transformation, which is pretty useless. */ emit_marker(cinfo, M_APP14); emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */ emit_byte(cinfo, 0x41); /* Identifier: ASCII "Adobe" */ emit_byte(cinfo, 0x64); emit_byte(cinfo, 0x6F); emit_byte(cinfo, 0x62); emit_byte(cinfo, 0x65); emit_2bytes(cinfo, 100); /* Version */ emit_2bytes(cinfo, 0); /* Flags0 */ emit_2bytes(cinfo, 0); /* Flags1 */ switch (cinfo->jpeg_color_space) { case JCS_YCbCr: emit_byte(cinfo, 1); /* Color transform = 1 */ break; case JCS_YCCK: emit_byte(cinfo, 2); /* Color transform = 2 */ break; default: emit_byte(cinfo, 0); /* Color transform = 0 */ break; } } /* * These routines allow writing an arbitrary marker with parameters. * The only intended use is to emit COM or APPn markers after calling * write_file_header and before calling write_frame_header. * Other uses are not guaranteed to produce desirable results. * Counting the parameter bytes properly is the caller's responsibility. */ METHODDEF(void) write_marker_header (j_compress_ptr cinfo, int marker, unsigned int datalen) /* Emit an arbitrary marker header */ { if (datalen > (unsigned int) 65533) /* safety check */ ERREXIT(cinfo, JERR_BAD_LENGTH); emit_marker(cinfo, (JPEG_MARKER) marker); emit_2bytes(cinfo, (int) (datalen + 2)); /* total length */ } METHODDEF(void) write_marker_byte (j_compress_ptr cinfo, int val) /* Emit one byte of marker parameters following write_marker_header */ { emit_byte(cinfo, val); } /* * Write datastream header. * This consists of an SOI and optional APPn markers. * We recommend use of the JFIF marker, but not the Adobe marker, * when using YCbCr or grayscale data. The JFIF marker should NOT * be used for any other JPEG colorspace. The Adobe marker is helpful * to distinguish RGB, CMYK, and YCCK colorspaces. * Note that an application can write additional header markers after * jpeg_start_compress returns. */ METHODDEF(void) write_file_header (j_compress_ptr cinfo) { my_marker_ptr marker = (my_marker_ptr) cinfo->marker; emit_marker(cinfo, M_SOI); /* first the SOI */ /* SOI is defined to reset restart interval to 0 */ marker->last_restart_interval = 0; if (cinfo->write_JFIF_header) /* next an optional JFIF APP0 */ emit_jfif_app0(cinfo); if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */ emit_adobe_app14(cinfo); } /* * Write frame header. * This consists of DQT and SOFn markers. * Note that we do not emit the SOF until we have emitted the DQT(s). * This avoids compatibility problems with incorrect implementations that * try to error-check the quant table numbers as soon as they see the SOF. */ METHODDEF(void) write_frame_header (j_compress_ptr cinfo) { int ci, prec; boolean is_baseline; jpeg_component_info *compptr; /* Emit DQT for each quantization table. * Note that emit_dqt() suppresses any duplicate tables. */ prec = 0; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { prec += emit_dqt(cinfo, compptr->quant_tbl_no); } /* now prec is nonzero iff there are any 16-bit quant tables. */ /* Check for a non-baseline specification. * Note we assume that Huffman table numbers won't be changed later. */ if (cinfo->arith_code || cinfo->progressive_mode || cinfo->data_precision != 8) { is_baseline = FALSE; } else { is_baseline = TRUE; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1) is_baseline = FALSE; } if (prec && is_baseline) { is_baseline = FALSE; /* If it's baseline except for quantizer size, warn the user */ TRACEMS(cinfo, 0, JTRC_16BIT_TABLES); } } /* Emit the proper SOF marker */ if (cinfo->arith_code) { emit_sof(cinfo, M_SOF9); /* SOF code for arithmetic coding */ } else { if (cinfo->progressive_mode) emit_sof(cinfo, M_SOF2); /* SOF code for progressive Huffman */ else if (is_baseline) emit_sof(cinfo, M_SOF0); /* SOF code for baseline implementation */ else emit_sof(cinfo, M_SOF1); /* SOF code for non-baseline Huffman file */ } } /* * Write scan header. * This consists of DHT or DAC markers, optional DRI, and SOS. * Compressed data will be written following the SOS. */ METHODDEF(void) write_scan_header (j_compress_ptr cinfo) { my_marker_ptr marker = (my_marker_ptr) cinfo->marker; int i; jpeg_component_info *compptr; if (cinfo->arith_code) { /* Emit arith conditioning info. We may have some duplication * if the file has multiple scans, but it's so small it's hardly * worth worrying about. */ emit_dac(cinfo); } else { /* Emit Huffman tables. * Note that emit_dht() suppresses any duplicate tables. */ for (i = 0; i < cinfo->comps_in_scan; i++) { compptr = cinfo->cur_comp_info[i]; if (cinfo->progressive_mode) { /* Progressive mode: only DC or only AC tables are used in one scan */ if (cinfo->Ss == 0) { if (cinfo->Ah == 0) /* DC needs no table for refinement scan */ emit_dht(cinfo, compptr->dc_tbl_no, FALSE); } else { emit_dht(cinfo, compptr->ac_tbl_no, TRUE); } } else { /* Sequential mode: need both DC and AC tables */ emit_dht(cinfo, compptr->dc_tbl_no, FALSE); emit_dht(cinfo, compptr->ac_tbl_no, TRUE); } } } /* Emit DRI if required --- note that DRI value could change for each scan. * We avoid wasting space with unnecessary DRIs, however. */ if (cinfo->restart_interval != marker->last_restart_interval) { emit_dri(cinfo); marker->last_restart_interval = cinfo->restart_interval; } emit_sos(cinfo); } /* * Write datastream trailer. */ METHODDEF(void) write_file_trailer (j_compress_ptr cinfo) { emit_marker(cinfo, M_EOI); } /* * Write an abbreviated table-specification datastream. * This consists of SOI, DQT and DHT tables, and EOI. * Any table that is defined and not marked sent_table = TRUE will be * emitted. Note that all tables will be marked sent_table = TRUE at exit. */ METHODDEF(void) write_tables_only (j_compress_ptr cinfo) { int i; emit_marker(cinfo, M_SOI); for (i = 0; i < NUM_QUANT_TBLS; i++) { if (cinfo->quant_tbl_ptrs[i] != NULL) (void) emit_dqt(cinfo, i); } if (! cinfo->arith_code) { for (i = 0; i < NUM_HUFF_TBLS; i++) { if (cinfo->dc_huff_tbl_ptrs[i] != NULL) emit_dht(cinfo, i, FALSE); if (cinfo->ac_huff_tbl_ptrs[i] != NULL) emit_dht(cinfo, i, TRUE); } } emit_marker(cinfo, M_EOI); } /* * Initialize the marker writer module. */ GLOBAL(void) jinit_marker_writer (j_compress_ptr cinfo) { my_marker_ptr marker; /* Create the subobject */ marker = (my_marker_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_marker_writer)); cinfo->marker = (struct jpeg_marker_writer *) marker; /* Initialize method pointers */ marker->pub.write_file_header = write_file_header; marker->pub.write_frame_header = write_frame_header; marker->pub.write_scan_header = write_scan_header; marker->pub.write_file_trailer = write_file_trailer; marker->pub.write_tables_only = write_tables_only; marker->pub.write_marker_header = write_marker_header; marker->pub.write_marker_byte = write_marker_byte; /* Initialize private state */ marker->last_restart_interval = 0; } Papyrus3/JpegDir/JpgLossy/ltmain.sh0000755000175000017500000021733007535143454014465 0ustar # ltmain.sh - Provide generalized library-building support services. # NOTE: Changing this file will not affect anything until you rerun ltconfig. # # Copyright (C) 1996-1998 Free Software Foundation, Inc. # Gordon Matzigkeit , 1996 # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # The name of this program. progname=`$echo "$0" | sed 's%^.*/%%'` modename="$progname" # Constants. PROGRAM=ltmain.sh PACKAGE=libtool VERSION=1.2 default_mode= help="Try \`$progname --help' for more information." magic="%%%MAGIC variable%%%" mkdir="mkdir" mv="mv -f" rm="rm -f" # Sed substitution that helps us do robust quoting. It backslashifies # metacharacters that are still active within double-quoted strings. Xsed='sed -e s/^X//' sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g' # NLS nuisances. # Only set LANG and LC_ALL to C if already set. # These must not be set unconditionally because not all systems understand # e.g. LANG=C (notably SCO). if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi if test "${LANG+set}" = set; then LANG=C; export LANG; fi if test "$LTCONFIG_VERSION" != "$VERSION"; then echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2 echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2 exit 1 fi if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then echo "$modename: not configured to build any kind of library" 1>&2 echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2 exit 1 fi # Global variables. mode=$default_mode nonopt= prev= prevopt= run= show="$echo" show_help= execute_dlfiles= # Parse our command line options once, thoroughly. while test $# -gt 0 do arg="$1" shift case "$arg" in -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;; *) optarg= ;; esac # If the previous option needs an argument, assign it. if test -n "$prev"; then case "$prev" in execute_dlfiles) eval "$prev=\"\$$prev \$arg\"" ;; *) eval "$prev=\$arg" ;; esac prev= prevopt= continue fi # Have we seen a non-optional argument yet? case "$arg" in --help) show_help=yes ;; --version) echo "$PROGRAM (GNU $PACKAGE) $VERSION" exit 0 ;; --dry-run | -n) run=: ;; --features) echo "host: $host" if test "$build_libtool_libs" = yes; then echo "enable shared libraries" else echo "disable shared libraries" fi if test "$build_old_libs" = yes; then echo "enable static libraries" else echo "disable static libraries" fi exit 0 ;; --finish) mode="finish" ;; --mode) prevopt="--mode" prev=mode ;; --mode=*) mode="$optarg" ;; --quiet | --silent) show=: ;; -dlopen) prevopt="-dlopen" prev=execute_dlfiles ;; -*) $echo "$modename: unrecognized option \`$arg'" 1>&2 $echo "$help" 1>&2 exit 1 ;; *) nonopt="$arg" break ;; esac done if test -n "$prevopt"; then $echo "$modename: option \`$prevopt' requires an argument" 1>&2 $echo "$help" 1>&2 exit 1 fi if test -z "$show_help"; then # Infer the operation mode. if test -z "$mode"; then case "$nonopt" in *cc | *++ | gcc* | *-gcc*) mode=link for arg do case "$arg" in -c) mode=compile break ;; esac done ;; *db | *dbx) mode=execute ;; *install*|cp|mv) mode=install ;; *rm) mode=uninstall ;; *) # If we have no mode, but dlfiles were specified, then do execute mode. test -n "$execute_dlfiles" && mode=execute # Just use the default operation mode. if test -z "$mode"; then if test -n "$nonopt"; then $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2 else $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2 fi fi ;; esac fi # Only execute mode is allowed to have -dlopen flags. if test -n "$execute_dlfiles" && test "$mode" != execute; then $echo "$modename: unrecognized option \`-dlopen'" 1>&2 $echo "$help" 1>&2 exit 1 fi # Change the help message to a mode-specific one. generic_help="$help" help="Try \`$modename --help --mode=$mode' for more information." # These modes are in order of execution frequency so that they run quickly. case "$mode" in # libtool compile mode compile) modename="$modename: compile" # Get the compilation command and the source file. base_compile= lastarg= srcfile="$nonopt" suppress_output= for arg do # Accept any command-line options. case "$arg" in -o) $echo "$modename: you cannot specify the output filename with \`-o'" 1>&2 $echo "$help" 1>&2 exit 1 ;; -static) build_libtool_libs=no build_old_libs=yes continue ;; esac # Accept the current argument as the source file. lastarg="$srcfile" srcfile="$arg" # Aesthetically quote the previous argument. # Backslashify any backslashes, double quotes, and dollar signs. # These are the only characters that are still specially # interpreted inside of double-quoted scrings. lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"` # Double-quote args containing other shell metacharacters. # Many Bourne shells cannot handle close brackets correctly in scan # sets, so we specify it separately. case "$lastarg" in *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*) lastarg="\"$lastarg\"" ;; esac # Add the previous argument to base_compile. if test -z "$base_compile"; then base_compile="$lastarg" else base_compile="$base_compile $lastarg" fi done # Get the name of the library object. libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'` # Recognize several different file suffixes. xform='[cCFSfms]' case "$libobj" in *.ada) xform=ada ;; *.adb) xform=adb ;; *.ads) xform=ads ;; *.asm) xform=asm ;; *.c++) xform=c++ ;; *.cc) xform=cc ;; *.cpp) xform=cpp ;; *.cxx) xform=cxx ;; *.f90) xform=f90 ;; *.for) xform=for ;; esac libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"` case "$libobj" in *.lo) obj=`$echo "X$libobj" | $Xsed -e 's/\.lo$/.o/'` ;; *) $echo "$modename: cannot determine name of library object from \`$srcfile'" 1>&2 exit 1 ;; esac if test -z "$base_compile"; then $echo "$modename: you must specify a compilation command" 1>&2 $echo "$help" 1>&2 exit 1 fi # Delete any leftover library objects. if test "$build_old_libs" = yes; then $run $rm $obj $libobj trap "$run $rm $obj $libobj; exit 1" 1 2 15 else $run $rm $libobj trap "$run $rm $libobj; exit 1" 1 2 15 fi # Only build a PIC object if we are building libtool libraries. if test "$build_libtool_libs" = yes; then # Without this assignment, base_compile gets emptied. fbsd_hideous_sh_bug=$base_compile # All platforms use -DPIC, to notify preprocessed assembler code. $show "$base_compile$pic_flag -DPIC $srcfile" if $run eval "$base_compile\$pic_flag -DPIC \$srcfile"; then : else test -n "$obj" && $run $rm $obj exit 1 fi # If we have no pic_flag, then copy the object into place and finish. if test -z "$pic_flag"; then $show "$LN_S $obj $libobj" $run $LN_S $obj $libobj exit $? fi # Just move the object, then go on to compile the next one $show "$mv $obj $libobj" $run $mv $obj $libobj || exit 1 # Allow error messages only from the first compilation. suppress_output=' >/dev/null 2>&1' fi # Only build a position-dependent object if we build old libraries. if test "$build_old_libs" = yes; then # Suppress compiler output if we already did a PIC compilation. $show "$base_compile $srcfile$suppress_output" if $run eval "$base_compile \$srcfile$suppress_output"; then : else $run $rm $obj $libobj exit 1 fi fi # Create an invalid libtool object if no PIC, so that we do not # accidentally link it into a program. if test "$build_libtool_libs" != yes; then $show "echo timestamp > $libobj" $run eval "echo timestamp > \$libobj" || exit $? fi exit 0 ;; # libtool link mode link) modename="$modename: link" CC="$nonopt" allow_undefined=yes compile_command="$CC" finalize_command="$CC" compile_shlibpath= finalize_shlibpath= deplibs= dlfiles= dlprefiles= export_dynamic=no hardcode_libdirs= libobjs= link_against_libtool_libs= ltlibs= objs= prev= prevarg= release= rpath= perm_rpath= temp_rpath= vinfo= # We need to know -static, to get the right output filenames. for arg do case "$arg" in -all-static | -static) if test "X$arg" = "X-all-static" && test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2 fi build_libtool_libs=no build_old_libs=yes break ;; esac done # See if our shared archives depend on static archives. test -n "$old_archive_from_new_cmds" && build_old_libs=yes # Go through the arguments, transforming them on the way. for arg do # If the previous option needs an argument, assign it. if test -n "$prev"; then case "$prev" in output) compile_command="$compile_command @OUTPUT@" finalize_command="$finalize_command @OUTPUT@" ;; esac case "$prev" in dlfiles|dlprefiles) case "$arg" in *.la | *.lo) ;; # We handle these cases below. *) dlprefiles="$dlprefiles $arg" test "$prev" = dlfiles && dlfiles="$dlfiles $arg" prev= ;; esac ;; release) release="-$arg" prev= continue ;; rpath) rpath="$rpath $arg" prev= continue ;; *) eval "$prev=\"\$arg\"" prev= continue ;; esac fi prevarg="$arg" case "$arg" in -all-static) if test -n "$link_static_flag"; then compile_command="$compile_command $link_static_flag" finalize_command="$finalize_command $link_static_flag" fi continue ;; -allow-undefined) # FIXME: remove this flag sometime in the future. $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2 continue ;; -dlopen) prev=dlfiles continue ;; -dlpreopen) prev=dlprefiles continue ;; -export-dynamic) if test "$export_dynamic" != yes; then export_dynamic=yes if test -n "$export_dynamic_flag_spec"; then eval arg=\"$export_dynamic_flag_spec\" else arg= fi # Add the symbol object into the linking commands. compile_command="$compile_command @SYMFILE@" finalize_command="$finalize_command @SYMFILE@" fi ;; -L*) dir=`$echo "X$arg" | $Xsed -e 's%^-L\(.*\)$%\1%'` case "$dir" in /* | [A-Za-z]:\\*) # Add the corresponding hardcode_libdir_flag, if it is not identical. ;; *) $echo "$modename: \`-L$dir' cannot specify a relative directory" 1>&2 exit 1 ;; esac deplibs="$deplibs $arg" ;; -l*) deplibs="$deplibs $arg" ;; -no-undefined) allow_undefined=no continue ;; -o) prev=output ;; -release) prev=release continue ;; -rpath) prev=rpath continue ;; -static) # If we have no pic_flag, then this is the same as -all-static. if test -z "$pic_flag" && test -n "$link_static_flag"; then compile_command="$compile_command $link_static_flag" finalize_command="$finalize_command $link_static_flag" fi continue ;; -version-info) prev=vinfo continue ;; # Some other compiler flag. -* | +*) # Unknown arguments in both finalize_command and compile_command need # to be aesthetically quoted because they are evaled later. arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` case "$arg" in *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*) arg="\"$arg\"" ;; esac ;; *.o | *.a) # A standard object. objs="$objs $arg" ;; *.lo) # A library object. if test "$prev" = dlfiles; then dlfiles="$dlfiles $arg" if test "$build_libtool_libs" = yes; then prev= continue else # If libtool objects are unsupported, then we need to preload. prev=dlprefiles fi fi if test "$prev" = dlprefiles; then # Preload the old-style object. dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e 's/\.lo$/\.o/'` prev= fi libobjs="$libobjs $arg" ;; *.la) # A libtool-controlled library. dlname= libdir= library_names= old_library= # Check to see that this really is a libtool archive. if (sed -e '2q' $arg | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then : else $echo "$modename: \`$arg' is not a valid libtool archive" 1>&2 exit 1 fi # If there is no directory component, then add one. case "$arg" in */* | *\\*) . $arg ;; *) . ./$arg ;; esac if test -z "$libdir"; then $echo "$modename: \`$arg' contains no -rpath information" 1>&2 exit 1 fi # Get the name of the library we link against. linklib= for l in $old_library $library_names; do linklib="$l" done if test -z "$linklib"; then $echo "$modename: cannot find name of link library for \`$arg'" 1>&2 exit 1 fi # Find the relevant object directory and library name. name=`$echo "X$arg" | $Xsed -e 's%^.*/%%' -e 's/\.la$//' -e 's/^lib//'` dir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'` if test "X$dir" = "X$arg"; then dir="$objdir" else dir="$dir/$objdir" fi # This library was specified with -dlopen. if test "$prev" = dlfiles; then dlfiles="$dlfiles $arg" if test -z "$dlname"; then # If there is no dlname, we need to preload. prev=dlprefiles else # We should not create a dependency on this library, but we # may need any libraries it requires. compile_command="$compile_command$dependency_libs" finalize_command="$finalize_command$dependency_libs" prev= continue fi fi # The library was specified with -dlpreopen. if test "$prev" = dlprefiles; then # Prefer using a static library (so that no silly _DYNAMIC symbols # are required to link). if test -n "$old_library"; then dlprefiles="$dlprefiles $dir/$old_library" else dlprefiles="$dlprefiles $dir/$linklib" fi prev= fi if test "$build_libtool_libs" = yes && test -n "$library_names"; then link_against_libtool_libs="$link_against_libtool_libs $arg" if test -n "$shlibpath_var"; then # Make sure the rpath contains only unique directories. case "$temp_rpath " in *" $dir "*) ;; *) temp_rpath="$temp_rpath $dir" ;; esac fi # This is the magic to use -rpath. if test -n "$hardcode_libdir_flag_spec"; then if test -n "$hardcode_libdir_separator"; then if test -z "$hardcode_libdirs"; then # Put the magic libdir with the hardcode flag. hardcode_libdirs="$libdir" libdir="@HARDCODE_LIBDIRS@" else # Just accumulate the unique libdirs. case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) ;; *) hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" ;; esac libdir= fi fi if test -n "$libdir"; then eval flag=\"$hardcode_libdir_flag_spec\" compile_command="$compile_command $flag" finalize_command="$finalize_command $flag" fi elif test -n "$runpath_var"; then # Do the same for the permanent run path. case "$perm_rpath " in *" $libdir "*) ;; *) perm_rpath="$perm_rpath $libdir" ;; esac fi case "$hardcode_action" in immediate) if test "$hardcode_direct" = no; then compile_command="$compile_command $dir/$linklib" elif test "$hardcode_minus_L" = no; then compile_command="$compile_command -L$dir -l$name" elif test "$hardcode_shlibpath_var" = no; then compile_shlibpath="$compile_shlibpath$dir:" compile_command="$compile_command -l$name" fi ;; relink) # We need an absolute path. case "$dir" in /* | [A-Za-z]:\\*) ;; *) absdir=`cd "$dir" && pwd` if test -z "$absdir"; then $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2 exit 1 fi dir="$absdir" ;; esac if test "$hardcode_direct" = yes; then compile_command="$compile_command $dir/$linklib" elif test "$hardcode_minus_L" = yes; then compile_command="$compile_command -L$dir -l$name" elif test "$hardcode_shlibpath_var" = yes; then compile_shlibpath="$compile_shlibpath$dir:" compile_command="$compile_command -l$name" fi ;; *) $echo "$modename: \`$hardcode_action' is an unknown hardcode action" 1>&2 exit 1 ;; esac # Finalize command for both is simple: just hardcode it. if test "$hardcode_direct" = yes; then finalize_command="$finalize_command $libdir/$linklib" elif test "$hardcode_minus_L" = yes; then finalize_command="$finalize_command -L$libdir -l$name" elif test "$hardcode_shlibpath_var" = yes; then finalize_shlibpath="$finalize_shlibpath$libdir:" finalize_command="$finalize_command -l$name" else # We cannot seem to hardcode it, guess we'll fake it. finalize_command="$finalize_command -L$libdir -l$name" fi else # Transform directly to old archives if we don't build new libraries. if test -n "$pic_flag" && test -z "$old_library"; then $echo "$modename: cannot find static library for \`$arg'" 1>&2 exit 1 fi # Here we assume that one of hardcode_direct or hardcode_minus_L # is not unsupported. This is valid on all known static and # shared platforms. if test "$hardcode_direct" != unsupported; then test -n "$old_library" && linklib="$old_library" compile_command="$compile_command $dir/$linklib" finalize_command="$finalize_command $dir/$linklib" else compile_command="$compile_command -L$dir -l$name" finalize_command="$finalize_command -L$dir -l$name" fi fi # Add in any libraries that this one depends upon. compile_command="$compile_command$dependency_libs" finalize_command="$finalize_command$dependency_libs" continue ;; # Some other compiler argument. *) # Unknown arguments in both finalize_command and compile_command need # to be aesthetically quoted because they are evaled later. arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` case "$arg" in *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*) arg="\"$arg\"" ;; esac ;; esac # Now actually substitute the argument into the commands. if test -n "$arg"; then compile_command="$compile_command $arg" finalize_command="$finalize_command $arg" fi done if test -n "$prev"; then $echo "$modename: the \`$prevarg' option requires an argument" 1>&2 $echo "$help" 1>&2 exit 1 fi if test -n "$vinfo" && test -n "$release"; then $echo "$modename: you cannot specify both \`-version-info' and \`-release'" 1>&2 $echo "$help" 1>&2 exit 1 fi oldlib= oldobjs= case "$output" in "") $echo "$modename: you must specify an output file" 1>&2 $echo "$help" 1>&2 exit 1 ;; */* | *\\*) $echo "$modename: output file \`$output' must have no directory components" 1>&2 exit 1 ;; *.a) # Now set the variables for building old libraries. build_libtool_libs=no build_old_libs=yes oldlib="$output" $show "$rm $oldlib" $run $rm $oldlib ;; *.la) # Make sure we only generate libraries of the form `libNAME.la'. case "$output" in lib*) ;; *) $echo "$modename: libtool library \`$arg' must begin with \`lib'" 1>&2 $echo "$help" 1>&2 exit 1 ;; esac name=`$echo "X$output" | $Xsed -e 's/\.la$//' -e 's/^lib//'` eval libname=\"$libname_spec\" # All the library-specific variables (install_libdir is set above). library_names= old_library= dlname= current=0 revision=0 age=0 if test -n "$objs"; then $echo "$modename: cannot build libtool library \`$output' from non-libtool objects:$objs" 2>&1 exit 1 fi # How the heck are we supposed to write a wrapper for a shared library? if test -n "$link_against_libtool_libs"; then $echo "$modename: libtool library \`$output' may not depend on uninstalled libraries:$link_against_libtool_libs" 1>&2 exit 1 fi if test -n "$dlfiles$dlprefiles"; then $echo "$modename: warning: \`-dlopen' is ignored while creating libtool libraries" 1>&2 # Nullify the symbol file. compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"` finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"` fi if test -z "$rpath"; then $echo "$modename: you must specify an installation directory with \`-rpath'" 1>&2 $echo "$help" 1>&2 exit 1 fi set dummy $rpath if test $# -gt 2; then $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2 fi install_libdir="$2" # Parse the version information argument. IFS="${IFS= }"; save_ifs="$IFS"; IFS=':' set dummy $vinfo IFS="$save_ifs" if test -n "$5"; then $echo "$modename: too many parameters to \`-version-info'" 1>&2 $echo "$help" 1>&2 exit 1 fi test -n "$2" && current="$2" test -n "$3" && revision="$3" test -n "$4" && age="$4" # Check that each of the things are valid numbers. case "$current" in 0 | [1-9] | [1-9][0-9]*) ;; *) $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2 $echo "$modename: \`$vinfo' is not valid version information" 1>&2 exit 1 ;; esac case "$revision" in 0 | [1-9] | [1-9][0-9]*) ;; *) $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2 $echo "$modename: \`$vinfo' is not valid version information" 1>&2 exit 1 ;; esac case "$age" in 0 | [1-9] | [1-9][0-9]*) ;; *) $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2 $echo "$modename: \`$vinfo' is not valid version information" 1>&2 exit 1 ;; esac if test $age -gt $current; then $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2 $echo "$modename: \`$vinfo' is not valid version information" 1>&2 exit 1 fi # Calculate the version variables. version_vars="version_type current age revision" case "$version_type" in none) ;; linux) version_vars="$version_vars major versuffix" major=`expr $current - $age` versuffix="$major.$age.$revision" ;; osf) version_vars="$version_vars versuffix verstring" major=`expr $current - $age` versuffix="$current.$age.$revision" verstring="$versuffix" # Add in all the interfaces that we are compatible with. loop=$age while test $loop != 0; do iface=`expr $current - $loop` loop=`expr $loop - 1` verstring="$verstring:${iface}.0" done # Make executables depend on our current version. verstring="$verstring:${current}.0" ;; sunos) version_vars="$version_vars major versuffix" major="$current" versuffix="$current.$revision" ;; *) $echo "$modename: unknown library version type \`$version_type'" 1>&2 echo "Fatal configuration error. See the $PACKAGE docs for more information." 1>&2 exit 1 ;; esac # Create the output directory, or remove our outputs if we need to. if test -d $objdir; then $show "$rm $objdir/$output $objdir/$libname.* $objdir/${libname}${release}.*" $run $rm $objdir/$output $objdir/$libname.* $objdir/${libname}${release}.* else $show "$mkdir $objdir" $run $mkdir $objdir status=$? if test $status -eq 0 || test -d $objdir; then : else exit $status fi fi # Check to see if the archive will have undefined symbols. if test "$allow_undefined" = yes; then if test "$allow_undefined_flag" = unsupported; then $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2 build_libtool_libs=no build_old_libs=yes fi else # Don't allow undefined symbols. allow_undefined_flag="$no_undefined_flag" fi # Add libc to deplibs on all systems. dependency_libs="$deplibs" deplibs="$deplibs -lc" if test "$build_libtool_libs" = yes; then # Get the real and link names of the library. eval library_names=\"$library_names_spec\" set dummy $library_names realname="$2" shift; shift if test -n "$soname_spec"; then eval soname=\"$soname_spec\" else soname="$realname" fi lib="$objdir/$realname" for link do linknames="$linknames $link" done # Use standard objects if they are PIC. test -z "$pic_flag" && libobjs=`$echo "X$libobjs " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//g'` # Do each of the archive commands. eval cmds=\"$archive_cmds\" IFS="${IFS= }"; save_ifs="$IFS"; IFS=';' for cmd in $cmds; do IFS="$save_ifs" $show "$cmd" $run eval "$cmd" || exit $? done IFS="$save_ifs" # Create links to the real library. for linkname in $linknames; do $show "(cd $objdir && $LN_S $realname $linkname)" $run eval '(cd $objdir && $LN_S $realname $linkname)' || exit $? done # If -export-dynamic was specified, set the dlname. if test "$export_dynamic" = yes; then # On all known operating systems, these are identical. dlname="$soname" fi fi # Now set the variables for building old libraries. oldlib="$objdir/$libname.a" ;; *.lo | *.o) if test -n "$link_against_libtool_libs"; then $echo "$modename: error: cannot link libtool libraries into reloadable objects" 1>&2 exit 1 fi if test -n "$deplibs"; then $echo "$modename: warning: \`-l' and \`-L' are ignored while creating objects" 1>&2 fi if test -n "$dlfiles$dlprefiles"; then $echo "$modename: warning: \`-dlopen' is ignored while creating objects" 1>&2 # Nullify the symbol file. compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"` finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"` fi if test -n "$rpath"; then $echo "$modename: warning: \`-rpath' is ignored while creating objects" 1>&2 fi if test -n "$vinfo"; then $echo "$modename: warning: \`-version-info' is ignored while creating objects" 1>&2 fi if test -n "$release"; then $echo "$modename: warning: \`-release' is ignored while creating objects" 1>&2 fi case "$output" in *.lo) if test -n "$objs"; then $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2 exit 1 fi libobj="$output" obj=`$echo "X$output" | $Xsed -e 's/\.lo$/.o/'` ;; *) libobj= obj="$output" ;; esac # Delete the old objects. $run $rm $obj $libobj # Create the old-style object. reload_objs="$objs"`$echo "X$libobjs " | $Xsed -e 's/[^ ]*\.a //g' -e 's/\.lo /.o /g' -e 's/ $//g'` output="$obj" eval cmds=\"$reload_cmds\" IFS="${IFS= }"; save_ifs="$IFS"; IFS=';' for cmd in $cmds; do IFS="$save_ifs" $show "$cmd" $run eval "$cmd" || exit $? done IFS="$save_ifs" # Exit if we aren't doing a library object file. test -z "$libobj" && exit 0 if test "$build_libtool_libs" != yes; then # Create an invalid libtool object if no PIC, so that we don't # accidentally link it into a program. $show "echo timestamp > $libobj" $run eval "echo timestamp > $libobj" || exit $? exit 0 fi if test -n "$pic_flag"; then # Only do commands if we really have different PIC objects. reload_objs="$libobjs" output="$libobj" eval cmds=\"$reload_cmds\" IFS="${IFS= }"; save_ifs="$IFS"; IFS=';' for cmd in $cmds; do IFS="$save_ifs" $show "$cmd" $run eval "$cmd" || exit $? done IFS="$save_ifs" else # Just create a symlink. $show "$LN_S $obj $libobj" $run $LN_S $obj $libobj || exit 1 fi exit 0 ;; *) if test -n "$vinfo"; then $echo "$modename: warning: \`-version-info' is ignored while linking programs" 1>&2 fi if test -n "$release"; then $echo "$modename: warning: \`-release' is ignored while creating objects" 1>&2 fi if test -n "$rpath"; then # If the user specified any rpath flags, then add them. for libdir in $rpath; do if test -n "$hardcode_libdir_flag_spec"; then if test -n "$hardcode_libdir_separator"; then if test -z "$hardcode_libdirs"; then # Put the magic libdir with the hardcode flag. hardcode_libdirs="$libdir" libdir="@HARDCODE_LIBDIRS@" else # Just accumulate the unique libdirs. case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) ;; *) hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir" ;; esac libdir= fi fi if test -n "$libdir"; then eval flag=\"$hardcode_libdir_flag_spec\" compile_command="$compile_command $flag" finalize_command="$finalize_command $flag" fi elif test -n "$runpath_var"; then case "$perm_rpath " in *" $libdir "*) ;; *) perm_rpath="$perm_rpath $libdir" ;; esac fi done fi # Substitute the hardcoded libdirs into the compile commands. if test -n "$hardcode_libdir_separator"; then compile_command=`$echo "X$compile_command" | $Xsed -e "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"` finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@HARDCODE_LIBDIRS@%$hardcode_libdirs%g"` fi if test -n "$libobjs" && test "$build_old_libs" = yes; then # Transform all the library objects into standard objects. compile_command=`$echo "X$compile_command " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//'` finalize_command=`$echo "X$finalize_command " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//'` fi if test "$export_dynamic" = yes && test -n "$NM" && test -n "$global_symbol_pipe"; then dlsyms="${output}S.c" else dlsyms= fi if test -n "$dlsyms"; then # Add our own program objects to the preloaded list. dlprefiles=`$echo "X$objs$dlprefiles " | $Xsed -e 's/\.lo /.o /g' -e 's/ $//'` # Discover the nlist of each of the dlfiles. nlist="$objdir/${output}.nm" if test -d $objdir; then $show "$rm $nlist ${nlist}T" $run $rm "$nlist" "${nlist}T" else $show "$mkdir $objdir" $run $mkdir $objdir status=$? if test $status -eq 0 || test -d $objdir; then : else exit $status fi fi for arg in $dlprefiles; do $show "extracting global C symbols from \`$arg'" $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'" done # Parse the name list into a source file. $show "creating $objdir/$dlsyms" if test -z "$run"; then # Make sure we at least have an empty file. test -f "$nlist" || : > "$nlist" # Try sorting and uniquifying the output. if sort "$nlist" | uniq > "$nlist"T; then mv -f "$nlist"T "$nlist" wcout=`wc "$nlist" 2>/dev/null` count=`echo "X$wcout" | $Xsed -e 's/^[ ]*\([0-9][0-9]*\).*$/\1/'` (test "$count" -ge 0) 2>/dev/null || count=-1 else $rm "$nlist"T count=-1 fi case "$dlsyms" in "") ;; *.c) $echo > "$objdir/$dlsyms" "\ /* $dlsyms - symbol resolution table for \`$output' dlsym emulation. */ /* Generated by $PROGRAM - GNU $PACKAGE $VERSION */ #ifdef __cplusplus extern \"C\" { #endif /* Prevent the only kind of declaration conflicts we can make. */ #define dld_preloaded_symbol_count some_other_symbol #define dld_preloaded_symbols some_other_symbol /* External symbol declarations for the compiler. */\ " if test -f "$nlist"; then sed -e 's/^.* \(.*\)$/extern char \1;/' < "$nlist" >> "$objdir/$dlsyms" else echo '/* NONE */' >> "$objdir/$dlsyms" fi $echo >> "$objdir/$dlsyms" "\ #undef dld_preloaded_symbol_count #undef dld_preloaded_symbols #if defined (__STDC__) && __STDC__ # define __ptr_t void * #else # define __ptr_t char * #endif /* The number of symbols in dld_preloaded_symbols, -1 if unsorted. */ int dld_preloaded_symbol_count = $count; /* The mapping between symbol names and symbols. */ struct { char *name; __ptr_t address; } dld_preloaded_symbols[] = {\ " if test -f "$nlist"; then sed 's/^\(.*\) \(.*\)$/ {"\1", (__ptr_t) \&\2},/' < "$nlist" >> "$objdir/$dlsyms" fi $echo >> "$objdir/$dlsyms" "\ {0, (__ptr_t) 0} }; #ifdef __cplusplus } #endif\ " ;; *) $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2 exit 1 ;; esac fi # Now compile the dynamic symbol file. $show "(cd $objdir && $CC -c$no_builtin_flag \"$dlsyms\")" $run eval '(cd $objdir && $CC -c$no_builtin_flag "$dlsyms")' || exit $? # Transform the symbol file into the correct name. compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.o%"` finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$objdir/${output}S.o%"` elif test "$export_dynamic" != yes; then test -n "$dlfiles$dlprefiles" && $echo "$modename: warning: \`-dlopen' and \`-dlpreopen' are ignored without \`-export-dynamic'" 1>&2 else # We keep going just in case the user didn't refer to # dld_preloaded_symbols. The linker will fail if global_symbol_pipe # really was required. $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2 # Nullify the symbol file. compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"` finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"` fi if test -z "$link_against_libtool_libs" || test "$build_libtool_libs" != yes; then # Replace the output file specification. compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'` finalize_command=`$echo "X$finalize_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'` # We have no uninstalled library dependencies, so finalize right now. $show "$compile_command" $run eval "$compile_command" exit $? fi # Replace the output file specification. compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$objdir/$output"'%g'` finalize_command=`$echo "X$finalize_command" | $Xsed -e 's%@OUTPUT@%'"$objdir/$output"'T%g'` # Create the binary in the object directory, then wrap it. if test -d $objdir; then : else $show "$mkdir $objdir" $run $mkdir $objdir status=$? if test $status -eq 0 || test -d $objdir; then : else exit $status fi fi if test -n "$shlibpath_var"; then # We should set the shlibpath_var rpath= for dir in $temp_rpath; do case "$dir" in /* | [A-Za-z]:\\*) # Absolute path. rpath="$rpath$dir:" ;; *) # Relative path: add a thisdir entry. rpath="$rpath\$thisdir/$dir:" ;; esac done temp_rpath="$rpath" fi # Delete the old output file. $run $rm $output if test -n "$compile_shlibpath"; then compile_command="$shlibpath_var=\"$compile_shlibpath\$$shlibpath_var\" $compile_command" fi if test -n "$finalize_shlibpath"; then finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command" fi if test -n "$runpath_var" && test -n "$perm_rpath"; then # We should set the runpath_var. rpath= for dir in $perm_rpath; do rpath="$rpath$dir:" done compile_command="$runpath_var=\"$rpath\$$runpath_var\" $compile_command" finalize_command="$runpath_var=\"$rpath\$$runpath_var\" $finalize_command" fi case "$hardcode_action" in relink) # AGH! Flame the AIX and HP-UX people for me, will ya? $echo "$modename: warning: using a buggy system linker" 1>&2 $echo "$modename: relinking will be required before \`$output' can be installed" 1>&2 ;; esac $show "$compile_command" $run eval "$compile_command" || exit $? # Now create the wrapper script. $show "creating $output" # Quote the finalize command for shipping. finalize_command=`$echo "X$finalize_command" | $Xsed -e "$sed_quote_subst"` # Quote $echo for shipping. qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"` # Only actually do things if our run command is non-null. if test -z "$run"; then $rm $output trap "$rm $output; exit 1" 1 2 15 $echo > $output "\ #! /bin/sh # $output - temporary wrapper script for $objdir/$output # Generated by ltmain.sh - GNU $PACKAGE $VERSION # # The $output program cannot be directly executed until all the libtool # libraries that it depends on are installed. # # This wrapper script should never be moved out of \``pwd`'. # If it is, it will not operate correctly. # Sed substitution that helps us do robust quoting. It backslashifies # metacharacters that are still active within double-quoted strings. Xsed='sed -e s/^X//' sed_quote_subst='$sed_quote_subst' # The HP-UX ksh and POSIX shell print the target directory to stdout # if CDPATH is set. if test \"\${CDPATH+set}\" = set; then CDPATH=; export CDPATH; fi # This environment variable determines our operation mode. if test \"\$libtool_install_magic\" = \"$magic\"; then # install mode needs the following variables: link_against_libtool_libs='$link_against_libtool_libs' finalize_command=\"$finalize_command\" else # When we are sourced in execute mode, \$file and \$echo are already set. if test \"\$libtool_execute_magic\" = \"$magic\"; then : else echo=\"$qecho\" file=\"\$0\" fi\ " $echo >> $output "\ # Find the directory that this script lives in. thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\` test \"x\$thisdir\" = \"x\$file\" && thisdir=. # Follow symbolic links until we get to the real thisdir. file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\` while test -n \"\$file\"; do destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\` # If there was a directory component, then change thisdir. if test \"x\$destdir\" != \"x\$file\"; then case \"\$destdir\" in /* | [A-Za-z]:\\*) thisdir=\"\$destdir\" ;; *) thisdir=\"\$thisdir/\$destdir\" ;; esac fi file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\` file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\` done # Try to get the absolute directory name. absdir=\`cd \"\$thisdir\" && pwd\` test -n \"\$absdir\" && thisdir=\"\$absdir\" progdir=\"\$thisdir/$objdir\" program='$output' if test -f \"\$progdir/\$program\"; then" # Export our shlibpath_var if we have one. if test -n "$shlibpath_var" && test -n "$temp_rpath"; then $echo >> $output "\ # Add our own library path to $shlibpath_var $shlibpath_var=\"$temp_rpath\$$shlibpath_var\" # Some systems cannot cope with colon-terminated $shlibpath_var $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/:*\$//'\` export $shlibpath_var " fi $echo >> $output "\ if test \"\$libtool_execute_magic\" != \"$magic\"; then # Run the actual program with our arguments. # Export the path to the program. PATH=\"\$progdir:\$PATH\" export PATH exec \$program \${1+\"\$@\"} \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\" exit 1 fi else # The program doesn't exist. \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2 \$echo \"This script is just a wrapper for \$program.\" 1>&2 echo \"See the $PACKAGE documentation for more information.\" 1>&2 exit 1 fi fi\ " chmod +x $output fi exit 0 ;; esac # See if we need to build an old-fashioned archive. if test "$build_old_libs" = "yes"; then # Transform .lo files to .o files. oldobjs="$objs"`$echo "X$libobjs " | $Xsed -e 's/[^ ]*\.a //g' -e 's/\.lo /.o /g' -e 's/ $//g'` # Do each command in the archive commands. if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then eval cmds=\"$old_archive_from_new_cmds\" else eval cmds=\"$old_archive_cmds\" fi IFS="${IFS= }"; save_ifs="$IFS"; IFS=';' for cmd in $cmds; do IFS="$save_ifs" $show "$cmd" $run eval "$cmd" || exit $? done IFS="$save_ifs" fi # Now create the libtool archive. case "$output" in *.la) old_library= test "$build_old_libs" = yes && old_library="$libname.a" $show "creating $output" # Only create the output if not a dry run. if test -z "$run"; then $echo > $output "\ # $output - a libtool library file # Generated by ltmain.sh - GNU $PACKAGE $VERSION # The name that we can dlopen(3). dlname='$dlname' # Names of this library. library_names='$library_names' # The name of the static archive. old_library='$old_library' # Libraries that this one depends upon. dependency_libs='$dependency_libs' # Version information for $libname. current=$current age=$age revision=$revision # Directory that this library needs to be installed in: libdir='$install_libdir'\ " fi # Do a symbolic link so that the libtool archive can be found in # LD_LIBRARY_PATH before the program is installed. $show "(cd $objdir && $LN_S ../$output $output)" $run eval "(cd $objdir && $LN_S ../$output $output)" || exit 1 ;; esac exit 0 ;; # libtool install mode install) modename="$modename: install" # There may be an optional /bin/sh argument at the beginning of # install_prog (especially on Windows NT). if test "$nonopt" = "$SHELL"; then # Aesthetically quote it. arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"` case "$arg" in *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*) arg="\"$arg\"" ;; esac install_prog="$arg " arg="$1" shift else install_prog= arg="$nonopt" fi # The real first argument should be the name of the installation program. # Aesthetically quote it. arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` case "$arg" in *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*) arg="\"$arg\"" ;; esac install_prog="$install_prog$arg" # We need to accept at least all the BSD install flags. dest= files= opts= prev= install_type= isdir= stripme= for arg do if test -n "$dest"; then files="$files $dest" dest="$arg" continue fi case "$arg" in -d) isdir=yes ;; -f) prev="-f" ;; -g) prev="-g" ;; -m) prev="-m" ;; -o) prev="-o" ;; -s) stripme=" -s" continue ;; -*) ;; *) # If the previous option needed an argument, then skip it. if test -n "$prev"; then prev= else dest="$arg" continue fi ;; esac # Aesthetically quote the argument. arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"` case "$arg" in *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*) arg="\"$arg\"" ;; esac install_prog="$install_prog $arg" done if test -z "$install_prog"; then $echo "$modename: you must specify an install program" 1>&2 $echo "$help" 1>&2 exit 1 fi if test -n "$prev"; then $echo "$modename: the \`$prev' option requires an argument" 1>&2 $echo "$help" 1>&2 exit 1 fi if test -z "$files"; then if test -z "$dest"; then $echo "$modename: no file or destination specified" 1>&2 else $echo "$modename: you must specify a destination" 1>&2 fi $echo "$help" 1>&2 exit 1 fi # Strip any trailing slash from the destination. dest=`$echo "X$dest" | $Xsed -e 's%/$%%'` # Check to see that the destination is a directory. test -d "$dest" && isdir=yes if test -n "$isdir"; then destdir="$dest" destname= else destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'` test "X$destdir" = "X$dest" && destdir=. destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'` # Not a directory, so check to see that there is only one file specified. set dummy $files if test $# -gt 2; then $echo "$modename: \`$dest' is not a directory" 1>&2 $echo "$help" 1>&2 exit 1 fi fi case "$destdir" in /* | [A-Za-z]:\\*) ;; *) for file in $files; do case "$file" in *.lo) ;; *) $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2 $echo "$help" 1>&2 exit 1 ;; esac done ;; esac # This variable tells wrapper scripts just to set variables rather # than running their programs. libtool_install_magic="$magic" staticlibs= future_libdirs= current_libdirs= for file in $files; do # Do each installation. case "$file" in *.a) # Do the static libraries later. staticlibs="$staticlibs $file" ;; *.la) # Check to see that this really is a libtool archive. if (sed -e '2q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then : else $echo "$modename: \`$file' is not a valid libtool archive" 1>&2 $echo "$help" 1>&2 exit 1 fi library_names= old_library= # If there is no directory component, then add one. case "$file" in */* | *\\*) . $file ;; *) . ./$file ;; esac # Add the libdir to current_libdirs if it is the destination. if test "X$destdir" = "X$libdir"; then case "$current_libdirs " in *" $libdir "*) ;; *) current_libdirs="$current_libdirs $libdir" ;; esac else # Note the libdir as a future libdir. case "$future_libdirs " in *" $libdir "*) ;; *) future_libdirs="$future_libdirs $libdir" ;; esac fi dir="`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/" test "X$dir" = "X$file/" && dir= dir="$dir$objdir" # See the names of the shared library. set dummy $library_names if test -n "$2"; then realname="$2" shift shift # Install the shared library and build the symlinks. $show "$install_prog $dir/$realname $destdir/$realname" $run eval "$install_prog $dir/$realname $destdir/$realname" || exit $? test "X$dlname" = "X$realname" && dlname= if test $# -gt 0; then # Delete the old symlinks. rmcmd="$rm" for linkname do rmcmd="$rmcmd $destdir/$linkname" done $show "$rmcmd" $run $rmcmd # ... and create new ones. for linkname do test "X$dlname" = "X$linkname" && dlname= $show "(cd $destdir && $LN_S $realname $linkname)" $run eval "(cd $destdir && $LN_S $realname $linkname)" done fi if test -n "$dlname"; then # Install the dynamically-loadable library. $show "$install_prog $dir/$dlname $destdir/$dlname" $run eval "$install_prog $dir/$dlname $destdir/$dlname" || exit $? fi # Do each command in the postinstall commands. lib="$destdir/$realname" eval cmds=\"$postinstall_cmds\" IFS="${IFS= }"; save_ifs="$IFS"; IFS=';' for cmd in $cmds; do IFS="$save_ifs" $show "$cmd" $run eval "$cmd" || exit $? done IFS="$save_ifs" fi # Install the pseudo-library for information purposes. name=`$echo "X$file" | $Xsed -e 's%^.*/%%'` $show "$install_prog $file $destdir/$name" $run eval "$install_prog $file $destdir/$name" || exit $? # Maybe install the static library, too. test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library" ;; *.lo) # Install (i.e. copy) a libtool object. # Figure out destination file name, if it wasn't already specified. if test -n "$destname"; then destfile="$destdir/$destname" else destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'` destfile="$destdir/$destfile" fi # Deduce the name of the destination old-style object file. case "$destfile" in *.lo) staticdest=`$echo "X$destfile" | $Xsed -e 's/\.lo$/\.o/'` ;; *.o) staticdest="$destfile" destfile= ;; *) $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2 $echo "$help" 1>&2 exit 1 ;; esac # Install the libtool object if requested. if test -n "$destfile"; then $show "$install_prog $file $destfile" $run eval "$install_prog $file $destfile" || exit $? fi # Install the old object if enabled. if test "$build_old_libs" = yes; then # Deduce the name of the old-style object file. staticobj=`$echo "X$file" | $Xsed -e 's/\.lo$/\.o/'` $show "$install_prog $staticobj $staticdest" $run eval "$install_prog \$staticobj \$staticdest" || exit $? fi exit 0 ;; *) # Do a test to see if this is really a libtool program. if (sed -e '4q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then link_against_libtool_libs= finalize_command= # If there is no directory component, then add one. case "$file" in */* | *\\*) . $file ;; *) . ./$file ;; esac # Check the variables that should have been set. if test -z "$link_against_libtool_libs" || test -z "$finalize_command"; then $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2 exit 1 fi finalize=yes for lib in $link_against_libtool_libs; do # Check to see that each library is installed. libdir= if test -f "$lib"; then # If there is no directory component, then add one. case "$lib" in */* | *\\*) . $lib ;; *) . ./$lib ;; esac fi libfile="$libdir/`$echo "X$lib" | $Xsed -e 's%^.*/%%g'`" if test -z "$libdir"; then $echo "$modename: warning: \`$lib' contains no -rpath information" 1>&2 elif test -f "$libfile"; then : else $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2 finalize=no fi done if test "$hardcode_action" = relink; then if test "$finalize" = yes; then $echo "$modename: warning: relinking \`$file' on behalf of your buggy system linker" 1>&2 $show "$finalize_command" if $run eval "$finalize_command"; then : else $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2 continue fi file="$objdir/$file"T else $echo "$modename: warning: cannot relink \`$file' on behalf of your buggy system linker" 1>&2 fi else # Install the binary that we compiled earlier. file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"` fi fi $show "$install_prog$stripme $file $dest" $run eval "$install_prog\$stripme \$file \$dest" || exit $? ;; esac done for file in $staticlibs; do name=`$echo "X$file" | $Xsed -e 's%^.*/%%'` # Set up the ranlib parameters. oldlib="$destdir/$name" $show "$install_prog $file $oldlib" $run eval "$install_prog \$file \$oldlib" || exit $? # Do each command in the postinstall commands. eval cmds=\"$old_postinstall_cmds\" IFS="${IFS= }"; save_ifs="$IFS"; IFS=';' for cmd in $cmds; do IFS="$save_ifs" $show "$cmd" $run eval "$cmd" || exit $? done IFS="$save_ifs" done if test -n "$future_libdirs"; then $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2 fi if test -n "$current_libdirs"; then # Maybe just do a dry run. test -n "$run" && current_libdirs=" -n$current_libdirs" exec $SHELL $0 --finish$current_libdirs exit 1 fi exit 0 ;; # libtool finish mode finish) modename="$modename: finish" libdirs="$nonopt" if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then for dir do libdirs="$libdirs $dir" done for libdir in $libdirs; do if test -n "$finish_cmds"; then # Do each command in the finish commands. eval cmds=\"$finish_cmds\" IFS="${IFS= }"; save_ifs="$IFS"; IFS=';' for cmd in $cmds; do IFS="$save_ifs" $show "$cmd" $run eval "$cmd" done IFS="$save_ifs" fi if test -n "$finish_eval"; then # Do the single finish_eval. eval cmds=\"$finish_eval\" $run eval "$cmds" fi done fi echo "------------------------------------------------------------------------------" echo "Libraries have been installed in:" for libdir in $libdirs; do echo " $libdir" done echo echo "To link against installed libraries in a given directory, LIBDIR," echo "you must use the \`-LLIBDIR' flag during linking." echo echo " You will also need to do one of the following:" if test -n "$shlibpath_var"; then echo " - add LIBDIR to the \`$shlibpath_var' environment variable" echo " during execution" fi if test -n "$runpath_var"; then echo " - add LIBDIR to the \`$runpath_var' environment variable" echo " during linking" fi if test -n "$hardcode_libdir_flag_spec"; then libdir=LIBDIR eval flag=\"$hardcode_libdir_flag_spec\" echo " - use the \`$flag' linker flag" fi if test -f /etc/ld.so.conf; then echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'" fi echo echo "See any operating system documentation about shared libraries for" echo "more information, such as the ld(1) and ld.so(8) manual pages." echo "------------------------------------------------------------------------------" exit 0 ;; # libtool execute mode execute) modename="$modename: execute" # The first argument is the command name. cmd="$nonopt" if test -z "$cmd"; then $echo "$modename: you must specify a COMMAND" 1>&2 $echo "$help" exit 1 fi # Handle -dlopen flags immediately. for file in $execute_dlfiles; do if test -f "$file"; then : else $echo "$modename: \`$file' is not a file" 1>&2 $echo "$help" 1>&2 exit 1 fi dir= case "$file" in *.la) # Check to see that this really is a libtool archive. if (sed -e '2q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then : else $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2 $echo "$help" 1>&2 exit 1 fi # Read the libtool library. dlname= library_names= # If there is no directory component, then add one. case "$file" in */* | *\\*) . $file ;; *) . ./$file ;; esac # Skip this library if it cannot be dlopened. if test -z "$dlname"; then # Warn if it was a shared library. test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'" continue fi dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'` test "X$dir" = "X$file" && dir=. if test -f "$dir/$objdir/$dlname"; then dir="$dir/$objdir" else $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2 exit 1 fi ;; *.lo) # Just add the directory containing the .lo file. dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'` test "X$dir" = "X$file" && dir=. ;; *) $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2 continue ;; esac # Get the absolute pathname. absdir=`cd "$dir" && pwd` test -n "$absdir" && dir="$absdir" # Now add the directory to shlibpath_var. if eval "test -z \"\$$shlibpath_var\""; then eval "$shlibpath_var=\"\$dir\"" else eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\"" fi done # This variable tells wrapper scripts just to set shlibpath_var # rather than running their programs. libtool_execute_magic="$magic" # Check if any of the arguments is a wrapper script. args= for file do case "$file" in -*) ;; *) # Do a test to see if this is really a libtool program. if (sed -e '4q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then # If there is no directory component, then add one. case "$file" in */* | *\\*) . $file ;; *) . ./$file ;; esac # Transform arg to wrapped name. file="$progdir/$program" fi ;; esac # Quote arguments (to preserve shell metacharacters). file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"` args="$args \"$file\"" done if test -z "$run"; then # Export the shlibpath_var. eval "export $shlibpath_var" # Now actually exec the command. eval "exec \$cmd$args" $echo "$modename: cannot exec \$cmd$args" exit 1 else # Display what would be done. eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\"" $echo "export $shlibpath_var" $echo "$cmd$args" exit 0 fi ;; # libtool uninstall mode uninstall) modename="$modename: uninstall" rm="$nonopt" files= for arg do case "$arg" in -*) rm="$rm $arg" ;; *) files="$files $arg" ;; esac done if test -z "$rm"; then $echo "$modename: you must specify an RM program" 1>&2 $echo "$help" 1>&2 exit 1 fi for file in $files; do dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'` test "X$dir" = "X$file" && dir=. name=`$echo "X$file" | $Xsed -e 's%^.*/%%'` rmfiles="$file" case "$name" in *.la) # Possibly a libtool archive, so verify it. if (sed -e '2q' $file | egrep '^# Generated by ltmain\.sh') >/dev/null 2>&1; then . $dir/$name # Delete the libtool libraries and symlinks. for n in $library_names; do rmfiles="$rmfiles $dir/$n" test "X$n" = "X$dlname" && dlname= done test -n "$dlname" && rmfiles="$rmfiles $dir/$dlname" test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library" $show "$rm $rmfiles" $run $rm $rmfiles if test -n "$library_names"; then # Do each command in the postuninstall commands. eval cmds=\"$postuninstall_cmds\" IFS="${IFS= }"; save_ifs="$IFS"; IFS=';' for cmd in $cmds; do IFS="$save_ifs" $show "$cmd" $run eval "$cmd" done IFS="$save_ifs" fi if test -n "$old_library"; then # Do each command in the old_postuninstall commands. eval cmds=\"$old_postuninstall_cmds\" IFS="${IFS= }"; save_ifs="$IFS"; IFS=';' for cmd in $cmds; do IFS="$save_ifs" $show "$cmd" $run eval "$cmd" done IFS="$save_ifs" fi # FIXME: should reinstall the best remaining shared library. fi ;; *.lo) if test "$build_old_libs" = yes; then oldobj=`$echo "X$name" | $Xsed -e 's/\.lo$/\.o/'` rmfiles="$rmfiles $dir/$oldobj" fi $show "$rm $rmfiles" $run $rm $rmfiles ;; *) $show "$rm $rmfiles" $run $rm $rmfiles ;; esac done exit 0 ;; "") $echo "$modename: you must specify a MODE" 1>&2 $echo "$generic_help" 1>&2 exit 1 ;; esac $echo "$modename: invalid operation mode \`$mode'" 1>&2 $echo "$generic_help" 1>&2 exit 1 fi # test -z "$show_help" # We need to display help for each of the modes. case "$mode" in "") $echo \ "Usage: $modename [OPTION]... [MODE-ARG]... Provide generalized library-building support services. -n, --dry-run display commands without modifying any files --features display configuration information and exit --finish same as \`--mode=finish' --help display this help message and exit --mode=MODE use operation mode MODE [default=inferred from MODE-ARGS] --quiet same as \`--silent' --silent don't print informational messages --version print version information MODE must be one of the following: compile compile a source file into a libtool object execute automatically set library path, then run a program finish complete the installation of libtool libraries install install libraries or executables link create a library or an executable uninstall remove libraries from an installed directory MODE-ARGS vary depending on the MODE. Try \`$modename --help --mode=MODE' for a more detailed description of MODE." exit 0 ;; compile) $echo \ "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE Compile a source file into a libtool library object. COMPILE-COMMAND is a command to be used in creating a \`standard' object file from the given SOURCEFILE. The output file name is determined by removing the directory component from SOURCEFILE, then substituting the C source code suffix \`.c' with the library object suffix, \`.lo'." ;; execute) $echo \ "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]... Automatically set library path, then run a program. This mode accepts the following additional options: -dlopen FILE add the directory containing FILE to the library path This mode sets the library path environment variable according to \`-dlopen' flags. If any of the ARGS are libtool executable wrappers, then they are translated into their corresponding uninstalled binary, and any of their required library directories are added to the library path. Then, COMMAND is executed, with ARGS as arguments." ;; finish) $echo \ "Usage: $modename [OPTION]... --mode=finish [LIBDIR]... Complete the installation of libtool libraries. Each LIBDIR is a directory that contains libtool libraries. The commands that this mode executes may require superuser privileges. Use the \`--dry-run' option if you just want to see what would be executed." ;; install) $echo \ "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND... Install executables or libraries. INSTALL-COMMAND is the installation command. The first component should be either the \`install' or \`cp' program. The rest of the components are interpreted as arguments to that command (only BSD-compatible install options are recognized)." ;; link) $echo \ "Usage: $modename [OPTION]... --mode=link LINK-COMMAND... Link object files or libraries together to form another library, or to create an executable program. LINK-COMMAND is a command using the C compiler that you would use to create a program from several object files. The following components of LINK-COMMAND are treated specially: -all-static do not do any dynamic linking at all -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime -dlpreopen FILE link in FILE and add its symbols to dld_preloaded_symbols -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3) -LLIBDIR search LIBDIR for required installed libraries -lNAME OUTPUT-FILE requires the installed library libNAME -no-undefined declare that a library does not refer to external symbols -o OUTPUT-FILE create OUTPUT-FILE from the specified objects -release RELEASE specify package release information -rpath LIBDIR the created library will eventually be installed in LIBDIR -static do not do any dynamic linking of libtool libraries -version-info CURRENT[:REVISION[:AGE]] specify library version info [each variable defaults to 0] All other options (arguments beginning with \`-') are ignored. Every other argument is treated as a filename. Files ending in \`.la' are treated as uninstalled libtool libraries, other files are standard or library object files. If the OUTPUT-FILE ends in \`.la', then a libtool library is created, only library objects (\`.lo' files) may be specified, and \`-rpath' is required. If OUTPUT-FILE ends in \`.a', then a standard library is created using \`ar' and \`ranlib'. If OUTPUT-FILE ends in \`.lo' or \`.o', then a reloadable object file is created, otherwise an executable program is created." ;; uninstall) $echo "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE... Remove libraries from an installation directory. RM is the name of the program to use to delete files associated with each FILE (typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed to RM. If FILE is a libtool library, all the files associated with it are deleted. Otherwise, only FILE itself is deleted using RM." ;; *) $echo "$modename: invalid operation mode \`$mode'" 1>&2 $echo "$help" 1>&2 exit 1 ;; esac echo $echo "Try \`$modename --help' for more information about other modes." exit 0 # Local Variables: # mode:shell-script # sh-indentation:2 # End: Papyrus3/JpegDir/JpgLossy/JDATASRC.C0000755000175000017500000001740307535143454014143 0ustar /* * jdatasrc.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains decompression data source routines for the case of * reading JPEG data from a file (or any stdio stream). While these routines * are sufficient for most applications, some will want to use a different * source manager. * IMPORTANT: we assume that fread() will correctly transcribe an array of * JOCTETs from 8-bit-wide elements on external storage. If char is wider * than 8 bits on your machine, you may need to do some tweaking. */ /* this is not a core library module, so it doesn't define JPEG_INTERNALS */ #include "jinclude.h" #include "jpeglib.h" #include "jerror.h" /* Expanded data source object for stdio input */ typedef struct { struct jpeg_source_mgr pub; /* public fields */ PAPY_FILE infile; /* source stream */ JOCTET * buffer; /* start of buffer */ boolean start_of_file; /* have we gotten any data yet? */ } my_source_mgr; typedef my_source_mgr * my_src_ptr; #define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */ /* * Initialize source --- called by jpeg_read_header * before any data is actually read. */ METHODDEF(void) init_source (j_decompress_ptr cinfo) { my_src_ptr src = (my_src_ptr) cinfo->src; /* We reset the empty-input-file flag for each image, * but we don't clear the input buffer. * This is correct behavior for reading a series of images from one source. */ src->start_of_file = TRUE; } /* * Fill the input buffer --- called whenever buffer is emptied. * * In typical applications, this should read fresh data into the buffer * (ignoring the current state of next_input_byte & bytes_in_buffer), * reset the pointer & count to the start of the buffer, and return TRUE * indicating that the buffer has been reloaded. It is not necessary to * fill the buffer entirely, only to obtain at least one more byte. * * There is no such thing as an EOF return. If the end of the file has been * reached, the routine has a choice of ERREXIT() or inserting fake data into * the buffer. In most cases, generating a warning message and inserting a * fake EOI marker is the best course of action --- this will allow the * decompressor to output however much of the image is there. However, * the resulting error message is misleading if the real problem is an empty * input file, so we handle that case specially. * * In applications that need to be able to suspend compression due to input * not being available yet, a FALSE return indicates that no more data can be * obtained right now, but more may be forthcoming later. In this situation, * the decompressor will return to its caller (with an indication of the * number of scanlines it has read, if any). The application should resume * decompression after it has loaded more data into the input buffer. Note * that there are substantial restrictions on the use of suspension --- see * the documentation. * * When suspending, the decompressor will back up to a convenient restart point * (typically the start of the current MCU). next_input_byte & bytes_in_buffer * indicate where the restart point will be if the current call returns FALSE. * Data beyond this point must be rescanned after resumption, so move it to * the front of the buffer rather than discarding it. */ METHODDEF(boolean) fill_input_buffer (j_decompress_ptr cinfo) { my_src_ptr src = (my_src_ptr) cinfo->src; size_t nbytes; PapyShort err; PapyULong bufSize = (PapyULong) INPUT_BUF_SIZE; err = JFREAD (src->infile, src->buffer, bufSize); if (err == 0) nbytes = bufSize; else nbytes = err; if (nbytes <= 0) { if (src->start_of_file) /* Treat empty input file as fatal error */ ERREXIT(cinfo, JERR_INPUT_EMPTY); WARNMS(cinfo, JWRN_JPEG_EOF); /* Insert a fake EOI marker */ src->buffer[0] = (JOCTET) 0xFF; src->buffer[1] = (JOCTET) JPEG_EOI; nbytes = 2; } src->pub.next_input_byte = src->buffer; src->pub.bytes_in_buffer = nbytes; src->start_of_file = FALSE; return TRUE; } /* * Skip data --- used to skip over a potentially large amount of * uninteresting data (such as an APPn marker). * * Writers of suspendable-input applications must note that skip_input_data * is not granted the right to give a suspension return. If the skip extends * beyond the data currently in the buffer, the buffer can be marked empty so * that the next read will cause a fill_input_buffer call that can suspend. * Arranging for additional bytes to be discarded before reloading the input * buffer is the application writer's problem. */ METHODDEF(void) skip_input_data (j_decompress_ptr cinfo, long num_bytes) { my_src_ptr src = (my_src_ptr) cinfo->src; /* Just a dumb implementation for now. Could use fseek() except * it doesn't work on pipes. Not clear that being smart is worth * any trouble anyway --- large skips are infrequent. */ if (num_bytes > 0) { while (num_bytes > (long) src->pub.bytes_in_buffer) { num_bytes -= (long) src->pub.bytes_in_buffer; (void) fill_input_buffer(cinfo); /* note we assume that fill_input_buffer will never return FALSE, * so suspension need not be handled. */ } src->pub.next_input_byte += (size_t) num_bytes; src->pub.bytes_in_buffer -= (size_t) num_bytes; } } /* * An additional method that can be provided by data source modules is the * resync_to_restart method for error recovery in the presence of RST markers. * For the moment, this source module just uses the default resync method * provided by the JPEG library. That method assumes that no backtracking * is possible. */ /* * Terminate source --- called by jpeg_finish_decompress * after all data has been read. Often a no-op. * * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding * application must deal with any cleanup that should happen even * for error exit. */ METHODDEF(void) term_source (j_decompress_ptr cinfo) { /* no work necessary here */ } /* * Prepare for input from a stdio stream. * The caller must have already opened the stream, and is responsible * for closing it after finishing decompression. */ GLOBAL(void) jpeg_stdio_src (j_decompress_ptr cinfo, PAPY_FILE infile) { my_src_ptr src; /* The source object and input buffer are made permanent so that a series * of JPEG images can be read from the same file by calling jpeg_stdio_src * only before the first one. (If we discarded the buffer at the end of * one image, we'd likely lose the start of the next one.) * This makes it unsafe to use this manager and a different source * manager serially with the same JPEG object. Caveat programmer. */ if (cinfo->src == NULL) { /* first time for this JPEG object? */ cinfo->src = (struct jpeg_source_mgr *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_source_mgr)); src = (my_src_ptr) cinfo->src; src->buffer = (JOCTET *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, INPUT_BUF_SIZE * SIZEOF(JOCTET)); } src = (my_src_ptr) cinfo->src; src->pub.init_source = init_source; src->pub.fill_input_buffer = fill_input_buffer; src->pub.skip_input_data = skip_input_data; src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */ src->pub.term_source = term_source; src->infile = infile; src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */ src->pub.next_input_byte = NULL; /* until buffer loaded */ } Papyrus3/JpegDir/JpgLossy/JDCOEFCT.C0000755000175000017500000006244307535143454014135 0ustar /* * jdcoefct.c * * Copyright (C) 1994-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains the coefficient buffer controller for decompression. * This controller is the top level of the JPEG decompressor proper. * The coefficient buffer lies between entropy decoding and inverse-DCT steps. * * In buffered-image mode, this controller is the interface between * input-oriented processing and output-oriented processing. * Also, the input side (only) is used when reading a file for transcoding. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* Block smoothing is only applicable for progressive JPEG, so: */ #ifndef D_PROGRESSIVE_SUPPORTED #undef BLOCK_SMOOTHING_SUPPORTED #endif /* Private buffer controller object */ typedef struct { struct jpeg_d_coef_controller pub; /* public fields */ /* These variables keep track of the current location of the input side. */ /* cinfo->input_iMCU_row is also used for this. */ JDIMENSION MCU_ctr; /* counts MCUs processed in current row */ int MCU_vert_offset; /* counts MCU rows within iMCU row */ int MCU_rows_per_iMCU_row; /* number of such rows needed */ /* The output side's location is represented by cinfo->output_iMCU_row. */ /* In single-pass modes, it's sufficient to buffer just one MCU. * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks, * and let the entropy decoder write into that workspace each time. * (On 80x86, the workspace is FAR even though it's not really very big; * this is to keep the module interfaces unchanged when a large coefficient * buffer is necessary.) * In multi-pass modes, this array points to the current MCU's blocks * within the virtual arrays; it is used only by the input side. */ JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU]; #ifdef D_MULTISCAN_FILES_SUPPORTED /* In multi-pass modes, we need a virtual block array for each component. */ jvirt_barray_ptr whole_image[MAX_COMPONENTS]; #endif #ifdef BLOCK_SMOOTHING_SUPPORTED /* When doing block smoothing, we latch coefficient Al values here */ int * coef_bits_latch; #define SAVED_COEFS 6 /* we save coef_bits[0..5] */ #endif } my_coef_controller; typedef my_coef_controller * my_coef_ptr; /* Forward declarations */ METHODDEF(int) decompress_onepass JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf)); #ifdef D_MULTISCAN_FILES_SUPPORTED METHODDEF(int) decompress_data JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf)); #endif #ifdef BLOCK_SMOOTHING_SUPPORTED LOCAL(boolean) smoothing_ok JPP((j_decompress_ptr cinfo)); METHODDEF(int) decompress_smooth_data JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf)); #endif LOCAL(void) start_iMCU_row (j_decompress_ptr cinfo) /* Reset within-iMCU-row counters for a new row (input side) */ { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; /* In an interleaved scan, an MCU row is the same as an iMCU row. * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows. * But at the bottom of the image, process only what's left. */ if (cinfo->comps_in_scan > 1) { coef->MCU_rows_per_iMCU_row = 1; } else { if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1)) coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor; else coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height; } coef->MCU_ctr = 0; coef->MCU_vert_offset = 0; } /* * Initialize for an input processing pass. */ METHODDEF(void) start_input_pass (j_decompress_ptr cinfo) { cinfo->input_iMCU_row = 0; start_iMCU_row(cinfo); } /* * Initialize for an output processing pass. */ METHODDEF(void) start_output_pass (j_decompress_ptr cinfo) { #ifdef BLOCK_SMOOTHING_SUPPORTED my_coef_ptr coef = (my_coef_ptr) cinfo->coef; /* If multipass, check to see whether to use block smoothing on this pass */ if (coef->pub.coef_arrays != NULL) { if (cinfo->do_block_smoothing && smoothing_ok(cinfo)) coef->pub.decompress_data = decompress_smooth_data; else coef->pub.decompress_data = decompress_data; } #endif cinfo->output_iMCU_row = 0; } /* * Decompress and return some data in the single-pass case. * Always attempts to emit one fully interleaved MCU row ("iMCU" row). * Input and output must run in lockstep since we have only a one-MCU buffer. * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. * * NB: output_buf contains a plane for each component in image, * which we index according to the component's SOF position. */ METHODDEF(int) decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf) { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; JDIMENSION MCU_col_num; /* index of current MCU within row */ JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1; JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; int blkn, ci, xindex, yindex, yoffset, useful_width; JSAMPARRAY output_ptr; JDIMENSION start_col, output_col; jpeg_component_info *compptr; inverse_DCT_method_ptr inverse_DCT; /* Loop to process as much as one whole iMCU row */ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; yoffset++) { for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col; MCU_col_num++) { /* Try to fetch an MCU. Entropy decoder expects buffer to be zeroed. */ jzero_far((void FAR *) coef->MCU_buffer[0], (size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK))); if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) { /* Suspension forced; update state counters and exit */ coef->MCU_vert_offset = yoffset; coef->MCU_ctr = MCU_col_num; return JPEG_SUSPENDED; } /* Determine where data should go in output_buf and do the IDCT thing. * We skip dummy blocks at the right and bottom edges (but blkn gets * incremented past them!). Note the inner loop relies on having * allocated the MCU_buffer[] blocks sequentially. */ blkn = 0; /* index of current DCT block within MCU */ for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; /* Don't bother to IDCT an uninteresting component. */ if (! compptr->component_needed) { blkn += compptr->MCU_blocks; continue; } inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index]; useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width : compptr->last_col_width; output_ptr = output_buf[compptr->component_index] + yoffset * compptr->DCT_scaled_size; start_col = MCU_col_num * compptr->MCU_sample_width; for (yindex = 0; yindex < compptr->MCU_height; yindex++) { if (cinfo->input_iMCU_row < last_iMCU_row || yoffset+yindex < compptr->last_row_height) { output_col = start_col; for (xindex = 0; xindex < useful_width; xindex++) { (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) coef->MCU_buffer[blkn+xindex], output_ptr, output_col); output_col += compptr->DCT_scaled_size; } } blkn += compptr->MCU_width; output_ptr += compptr->DCT_scaled_size; } } } /* Completed an MCU row, but perhaps not an iMCU row */ coef->MCU_ctr = 0; } /* Completed the iMCU row, advance counters for next one */ cinfo->output_iMCU_row++; if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) { start_iMCU_row(cinfo); return JPEG_ROW_COMPLETED; } /* Completed the scan */ (*cinfo->inputctl->finish_input_pass) (cinfo); return JPEG_SCAN_COMPLETED; } /* * Dummy consume-input routine for single-pass operation. */ METHODDEF(int) dummy_consume_data (j_decompress_ptr cinfo) { return JPEG_SUSPENDED; /* Always indicate nothing was done */ } #ifdef D_MULTISCAN_FILES_SUPPORTED /* * Consume input data and store it in the full-image coefficient buffer. * We read as much as one fully interleaved MCU row ("iMCU" row) per call, * ie, v_samp_factor block rows for each component in the scan. * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. */ METHODDEF(int) consume_data (j_decompress_ptr cinfo) { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; JDIMENSION MCU_col_num; /* index of current MCU within row */ int blkn, ci, xindex, yindex, yoffset; JDIMENSION start_col; JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN]; JBLOCKROW buffer_ptr; jpeg_component_info *compptr; /* Align the virtual buffers for the components used in this scan. */ for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; buffer[ci] = (*cinfo->mem->access_virt_barray) ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index], cinfo->input_iMCU_row * compptr->v_samp_factor, (JDIMENSION) compptr->v_samp_factor, TRUE); /* Note: entropy decoder expects buffer to be zeroed, * but this is handled automatically by the memory manager * because we requested a pre-zeroed array. */ } /* Loop to process one whole iMCU row */ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; yoffset++) { for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row; MCU_col_num++) { /* Construct list of pointers to DCT blocks belonging to this MCU */ blkn = 0; /* index of current DCT block within MCU */ for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; start_col = MCU_col_num * compptr->MCU_width; for (yindex = 0; yindex < compptr->MCU_height; yindex++) { buffer_ptr = buffer[ci][yindex+yoffset] + start_col; for (xindex = 0; xindex < compptr->MCU_width; xindex++) { coef->MCU_buffer[blkn++] = buffer_ptr++; } } } /* Try to fetch the MCU. */ if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) { /* Suspension forced; update state counters and exit */ coef->MCU_vert_offset = yoffset; coef->MCU_ctr = MCU_col_num; return JPEG_SUSPENDED; } } /* Completed an MCU row, but perhaps not an iMCU row */ coef->MCU_ctr = 0; } /* Completed the iMCU row, advance counters for next one */ if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) { start_iMCU_row(cinfo); return JPEG_ROW_COMPLETED; } /* Completed the scan */ (*cinfo->inputctl->finish_input_pass) (cinfo); return JPEG_SCAN_COMPLETED; } /* * Decompress and return some data in the multi-pass case. * Always attempts to emit one fully interleaved MCU row ("iMCU" row). * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED. * * NB: output_buf contains a plane for each component in image. */ METHODDEF(int) decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf) { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; JDIMENSION block_num; int ci, block_row, block_rows; JBLOCKARRAY buffer; JBLOCKROW buffer_ptr; JSAMPARRAY output_ptr; JDIMENSION output_col; jpeg_component_info *compptr; inverse_DCT_method_ptr inverse_DCT; /* Force some input to be done if we are getting ahead of the input. */ while (cinfo->input_scan_number < cinfo->output_scan_number || (cinfo->input_scan_number == cinfo->output_scan_number && cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) { if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED) return JPEG_SUSPENDED; } /* OK, output from the virtual arrays. */ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { /* Don't bother to IDCT an uninteresting component. */ if (! compptr->component_needed) continue; /* Align the virtual buffer for this component. */ buffer = (*cinfo->mem->access_virt_barray) ((j_common_ptr) cinfo, coef->whole_image[ci], cinfo->output_iMCU_row * compptr->v_samp_factor, (JDIMENSION) compptr->v_samp_factor, FALSE); /* Count non-dummy DCT block rows in this iMCU row. */ if (cinfo->output_iMCU_row < last_iMCU_row) block_rows = compptr->v_samp_factor; else { /* NB: can't use last_row_height here; it is input-side-dependent! */ block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor); if (block_rows == 0) block_rows = compptr->v_samp_factor; } inverse_DCT = cinfo->idct->inverse_DCT[ci]; output_ptr = output_buf[ci]; /* Loop over all DCT blocks to be processed. */ for (block_row = 0; block_row < block_rows; block_row++) { buffer_ptr = buffer[block_row]; output_col = 0; for (block_num = 0; block_num < compptr->width_in_blocks; block_num++) { (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr, output_ptr, output_col); buffer_ptr++; output_col += compptr->DCT_scaled_size; } output_ptr += compptr->DCT_scaled_size; } } if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows) return JPEG_ROW_COMPLETED; return JPEG_SCAN_COMPLETED; } #endif /* D_MULTISCAN_FILES_SUPPORTED */ #ifdef BLOCK_SMOOTHING_SUPPORTED /* * This code applies interblock smoothing as described by section K.8 * of the JPEG standard: the first 5 AC coefficients are estimated from * the DC values of a DCT block and its 8 neighboring blocks. * We apply smoothing only for progressive JPEG decoding, and only if * the coefficients it can estimate are not yet known to full precision. */ /* Natural-order array positions of the first 5 zigzag-order coefficients */ #define Q01_POS 1 #define Q10_POS 8 #define Q20_POS 16 #define Q11_POS 9 #define Q02_POS 2 /* * Determine whether block smoothing is applicable and safe. * We also latch the current states of the coef_bits[] entries for the * AC coefficients; otherwise, if the input side of the decompressor * advances into a new scan, we might think the coefficients are known * more accurately than they really are. */ LOCAL(boolean) smoothing_ok (j_decompress_ptr cinfo) { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; boolean smoothing_useful = FALSE; int ci, coefi; jpeg_component_info *compptr; JQUANT_TBL * qtable; int * coef_bits; int * coef_bits_latch; if (! cinfo->progressive_mode || cinfo->coef_bits == NULL) return FALSE; /* Allocate latch area if not already done */ if (coef->coef_bits_latch == NULL) coef->coef_bits_latch = (int *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, cinfo->num_components * (SAVED_COEFS * SIZEOF(int))); coef_bits_latch = coef->coef_bits_latch; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { /* All components' quantization values must already be latched. */ if ((qtable = compptr->quant_table) == NULL) return FALSE; /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */ if (qtable->quantval[0] == 0 || qtable->quantval[Q01_POS] == 0 || qtable->quantval[Q10_POS] == 0 || qtable->quantval[Q20_POS] == 0 || qtable->quantval[Q11_POS] == 0 || qtable->quantval[Q02_POS] == 0) return FALSE; /* DC values must be at least partly known for all components. */ coef_bits = cinfo->coef_bits[ci]; if (coef_bits[0] < 0) return FALSE; /* Block smoothing is helpful if some AC coefficients remain inaccurate. */ for (coefi = 1; coefi <= 5; coefi++) { coef_bits_latch[coefi] = coef_bits[coefi]; if (coef_bits[coefi] != 0) smoothing_useful = TRUE; } coef_bits_latch += SAVED_COEFS; } return smoothing_useful; } /* * Variant of decompress_data for use when doing block smoothing. */ METHODDEF(int) decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf) { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; JDIMENSION block_num, last_block_column; int ci, block_row, block_rows, access_rows; JBLOCKARRAY buffer; JBLOCKROW buffer_ptr, prev_block_row, next_block_row; JSAMPARRAY output_ptr; JDIMENSION output_col; jpeg_component_info *compptr; inverse_DCT_method_ptr inverse_DCT; boolean first_row, last_row; JBLOCK workspace; int *coef_bits; JQUANT_TBL *quanttbl; INT32 Q00,Q01,Q02,Q10,Q11,Q20, num; int DC1,DC2,DC3,DC4,DC5,DC6,DC7,DC8,DC9; int Al, pred; /* Force some input to be done if we are getting ahead of the input. */ while (cinfo->input_scan_number <= cinfo->output_scan_number && ! cinfo->inputctl->eoi_reached) { if (cinfo->input_scan_number == cinfo->output_scan_number) { /* If input is working on current scan, we ordinarily want it to * have completed the current row. But if input scan is DC, * we want it to keep one row ahead so that next block row's DC * values are up to date. */ JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0; if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta) break; } if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED) return JPEG_SUSPENDED; } /* OK, output from the virtual arrays. */ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { /* Don't bother to IDCT an uninteresting component. */ if (! compptr->component_needed) continue; /* Count non-dummy DCT block rows in this iMCU row. */ if (cinfo->output_iMCU_row < last_iMCU_row) { block_rows = compptr->v_samp_factor; access_rows = block_rows * 2; /* this and next iMCU row */ last_row = FALSE; } else { /* NB: can't use last_row_height here; it is input-side-dependent! */ block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor); if (block_rows == 0) block_rows = compptr->v_samp_factor; access_rows = block_rows; /* this iMCU row only */ last_row = TRUE; } /* Align the virtual buffer for this component. */ if (cinfo->output_iMCU_row > 0) { access_rows += compptr->v_samp_factor; /* prior iMCU row too */ buffer = (*cinfo->mem->access_virt_barray) ((j_common_ptr) cinfo, coef->whole_image[ci], (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor, (JDIMENSION) access_rows, FALSE); buffer += compptr->v_samp_factor; /* point to current iMCU row */ first_row = FALSE; } else { buffer = (*cinfo->mem->access_virt_barray) ((j_common_ptr) cinfo, coef->whole_image[ci], (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE); first_row = TRUE; } /* Fetch component-dependent info */ coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS); quanttbl = compptr->quant_table; Q00 = quanttbl->quantval[0]; Q01 = quanttbl->quantval[Q01_POS]; Q10 = quanttbl->quantval[Q10_POS]; Q20 = quanttbl->quantval[Q20_POS]; Q11 = quanttbl->quantval[Q11_POS]; Q02 = quanttbl->quantval[Q02_POS]; inverse_DCT = cinfo->idct->inverse_DCT[ci]; output_ptr = output_buf[ci]; /* Loop over all DCT blocks to be processed. */ for (block_row = 0; block_row < block_rows; block_row++) { buffer_ptr = buffer[block_row]; if (first_row && block_row == 0) prev_block_row = buffer_ptr; else prev_block_row = buffer[block_row-1]; if (last_row && block_row == block_rows-1) next_block_row = buffer_ptr; else next_block_row = buffer[block_row+1]; /* We fetch the surrounding DC values using a sliding-register approach. * Initialize all nine here so as to do the right thing on narrow pics. */ DC1 = DC2 = DC3 = (int) prev_block_row[0][0]; DC4 = DC5 = DC6 = (int) buffer_ptr[0][0]; DC7 = DC8 = DC9 = (int) next_block_row[0][0]; output_col = 0; last_block_column = compptr->width_in_blocks - 1; for (block_num = 0; block_num <= last_block_column; block_num++) { /* Fetch current DCT block into workspace so we can modify it. */ jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1); /* Update DC values */ if (block_num < last_block_column) { DC3 = (int) prev_block_row[1][0]; DC6 = (int) buffer_ptr[1][0]; DC9 = (int) next_block_row[1][0]; } /* Compute coefficient estimates per K.8. * An estimate is applied only if coefficient is still zero, * and is not known to be fully accurate. */ /* AC01 */ if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) { num = 36 * Q00 * (DC4 - DC6); if (num >= 0) { pred = (int) (((Q01<<7) + num) / (Q01<<8)); if (Al > 0 && pred >= (1< 0 && pred >= (1<= 0) { pred = (int) (((Q10<<7) + num) / (Q10<<8)); if (Al > 0 && pred >= (1< 0 && pred >= (1<= 0) { pred = (int) (((Q20<<7) + num) / (Q20<<8)); if (Al > 0 && pred >= (1< 0 && pred >= (1<= 0) { pred = (int) (((Q11<<7) + num) / (Q11<<8)); if (Al > 0 && pred >= (1< 0 && pred >= (1<= 0) { pred = (int) (((Q02<<7) + num) / (Q02<<8)); if (Al > 0 && pred >= (1< 0 && pred >= (1<DCT_scaled_size; } output_ptr += compptr->DCT_scaled_size; } } if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows) return JPEG_ROW_COMPLETED; return JPEG_SCAN_COMPLETED; } #endif /* BLOCK_SMOOTHING_SUPPORTED */ /* * Initialize coefficient buffer controller. */ GLOBAL(void) jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer) { my_coef_ptr coef; coef = (my_coef_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_coef_controller)); cinfo->coef = (struct jpeg_d_coef_controller *) coef; coef->pub.start_input_pass = start_input_pass; coef->pub.start_output_pass = start_output_pass; #ifdef BLOCK_SMOOTHING_SUPPORTED coef->coef_bits_latch = NULL; #endif /* Create the coefficient buffer. */ if (need_full_buffer) { #ifdef D_MULTISCAN_FILES_SUPPORTED /* Allocate a full-image virtual array for each component, */ /* padded to a multiple of samp_factor DCT blocks in each direction. */ /* Note we ask for a pre-zeroed array. */ int ci, access_rows; jpeg_component_info *compptr; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { access_rows = compptr->v_samp_factor; #ifdef BLOCK_SMOOTHING_SUPPORTED /* If block smoothing could be used, need a bigger window */ if (cinfo->progressive_mode) access_rows *= 3; #endif coef->whole_image[ci] = (*cinfo->mem->request_virt_barray) ((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE, (JDIMENSION) jround_up((long) compptr->width_in_blocks, (long) compptr->h_samp_factor), (JDIMENSION) jround_up((long) compptr->height_in_blocks, (long) compptr->v_samp_factor), (JDIMENSION) access_rows); } coef->pub.consume_data = consume_data; coef->pub.decompress_data = decompress_data; coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */ #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } else { /* We only need a single-MCU buffer. */ JBLOCKROW buffer; int i; buffer = (JBLOCKROW) (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK)); for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) { coef->MCU_buffer[i] = buffer + i; } coef->pub.consume_data = dummy_consume_data; coef->pub.decompress_data = decompress_onepass; coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */ } } Papyrus3/JpegDir/JpgLossy/JMEMNOBS.C0000755000175000017500000000655007535143454014163 0ustar /* * jmemnobs.c * * Copyright (C) 1992-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file provides a really simple implementation of the system- * dependent portion of the JPEG memory manager. This implementation * assumes that no backing-store files are needed: all required space * can be obtained from malloc(). * This is very portable in the sense that it'll compile on almost anything, * but you'd better have lots of main memory (or virtual memory) if you want * to process big images. * Note that the max_memory_to_use option is ignored by this implementation. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jmemsys.h" /* import the system-dependent declarations */ /* the PAPYRUS3 memory manager */ /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyEalloc3H #include "PapyEalloc3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyEalloc3H #include "Papaloc3.h" #endif #endif /*#ifndef HAVE_STDLIB_H /* should declare malloc(),free() */ /*extern void * malloc JPP((size_t size)); extern void free JPP((void *ptr)); #endif*/ /* * Memory allocation and freeing are controlled by the regular library * routines malloc() and free(). */ GLOBAL(void *) jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject) { /*return (void *) malloc(sizeofobject);*/ return (void *) emalloc3 ((PapyULong) sizeofobject); } GLOBAL(void) jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject) { /*free(object);*/ efree3 ((void **) &object); } /* * "Large" objects are treated the same as "small" ones. * NB: although we include FAR keywords in the routine declarations, * this file won't actually work in 80x86 small/medium model; at least, * you probably won't be able to process useful-size images in only 64KB. */ GLOBAL(void FAR *) jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject) { /*return (void FAR *) malloc(sizeofobject);*/ return (void FAR *) emalloc3 ((PapyULong) sizeofobject); } GLOBAL(void) jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject) { /*free(object);*/ efree3 ((void **) &object); } /* * This routine computes the total memory space available for allocation. * Here we always say, "we got all you want bud!" */ GLOBAL(long) jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed, long max_bytes_needed, long already_allocated) { return max_bytes_needed; } /* * Backing store (temporary file) management. * Since jpeg_mem_available always promised the moon, * this should never be called and we can just error out. */ GLOBAL(void) jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed) { ERREXIT(cinfo, JERR_NO_BACKING_STORE); } /* * These routines take care of any system-dependent initialization and * cleanup required. Here, there isn't any. */ GLOBAL(long) jpeg_mem_init (j_common_ptr cinfo) { /*return 0; /* just set max_memory_to_use to 0 */ return MAX_ALLOC_CHUNK; } GLOBAL(void) jpeg_mem_term (j_common_ptr cinfo) { /* no work */ } Papyrus3/JpegDir/JpgLossy/RDRLE.C0000755000175000017500000002743407535143454013625 0ustar /* * rdrle.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to read input images in Utah RLE format. * The Utah Raster Toolkit library is required (version 3.1 or later). * * These routines may need modification for non-Unix environments or * specialized applications. As they stand, they assume input from * an ordinary stdio stream. They further assume that reading begins * at the start of the file; start_input may need work if the * user interface has already read some data (e.g., to determine that * the file is indeed RLE format). * * Based on code contributed by Mike Lijewski, * with updates from Robert Hutchinson. */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ #ifdef RLE_SUPPORTED /* rle.h is provided by the Utah Raster Toolkit. */ #include /* * We assume that JSAMPLE has the same representation as rle_pixel, * to wit, "unsigned char". Hence we can't cope with 12- or 16-bit samples. */ #if BITS_IN_JSAMPLE != 8 Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */ #endif /* * We support the following types of RLE files: * * GRAYSCALE - 8 bits, no colormap * MAPPEDGRAY - 8 bits, 1 channel colomap * PSEUDOCOLOR - 8 bits, 3 channel colormap * TRUECOLOR - 24 bits, 3 channel colormap * DIRECTCOLOR - 24 bits, no colormap * * For now, we ignore any alpha channel in the image. */ typedef enum { GRAYSCALE, MAPPEDGRAY, PSEUDOCOLOR, TRUECOLOR, DIRECTCOLOR } rle_kind; /* * Since RLE stores scanlines bottom-to-top, we have to invert the image * to conform to JPEG's top-to-bottom order. To do this, we read the * incoming image into a virtual array on the first get_pixel_rows call, * then fetch the required row from the virtual array on subsequent calls. */ typedef struct _rle_source_struct * rle_source_ptr; typedef struct _rle_source_struct { struct cjpeg_source_struct pub; /* public fields */ rle_kind visual; /* actual type of input file */ jvirt_sarray_ptr image; /* virtual array to hold the image */ JDIMENSION row; /* current row # in the virtual array */ rle_hdr header; /* Input file information */ rle_pixel** rle_row; /* holds a row returned by rle_getrow() */ } rle_source_struct; /* * Read the file header; return image size and component count. */ METHODDEF(void) start_input_rle (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { rle_source_ptr source = (rle_source_ptr) sinfo; JDIMENSION width, height; #ifdef PROGRESS_REPORT cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; #endif /* Use RLE library routine to get the header info */ source->header = *rle_hdr_init(NULL); source->header.rle_file = source->pub.input_file; switch (rle_get_setup(&(source->header))) { case RLE_SUCCESS: /* A-OK */ break; case RLE_NOT_RLE: ERREXIT(cinfo, JERR_RLE_NOT); break; case RLE_NO_SPACE: ERREXIT(cinfo, JERR_RLE_MEM); break; case RLE_EMPTY: ERREXIT(cinfo, JERR_RLE_EMPTY); break; case RLE_EOF: ERREXIT(cinfo, JERR_RLE_EOF); break; default: ERREXIT(cinfo, JERR_RLE_BADERROR); break; } /* Figure out what we have, set private vars and return values accordingly */ width = source->header.xmax - source->header.xmin + 1; height = source->header.ymax - source->header.ymin + 1; source->header.xmin = 0; /* realign horizontally */ source->header.xmax = width-1; cinfo->image_width = width; cinfo->image_height = height; cinfo->data_precision = 8; /* we can only handle 8 bit data */ if (source->header.ncolors == 1 && source->header.ncmap == 0) { source->visual = GRAYSCALE; TRACEMS2(cinfo, 1, JTRC_RLE_GRAY, width, height); } else if (source->header.ncolors == 1 && source->header.ncmap == 1) { source->visual = MAPPEDGRAY; TRACEMS3(cinfo, 1, JTRC_RLE_MAPGRAY, width, height, 1 << source->header.cmaplen); } else if (source->header.ncolors == 1 && source->header.ncmap == 3) { source->visual = PSEUDOCOLOR; TRACEMS3(cinfo, 1, JTRC_RLE_MAPPED, width, height, 1 << source->header.cmaplen); } else if (source->header.ncolors == 3 && source->header.ncmap == 3) { source->visual = TRUECOLOR; TRACEMS3(cinfo, 1, JTRC_RLE_FULLMAP, width, height, 1 << source->header.cmaplen); } else if (source->header.ncolors == 3 && source->header.ncmap == 0) { source->visual = DIRECTCOLOR; TRACEMS2(cinfo, 1, JTRC_RLE, width, height); } else ERREXIT(cinfo, JERR_RLE_UNSUPPORTED); if (source->visual == GRAYSCALE || source->visual == MAPPEDGRAY) { cinfo->in_color_space = JCS_GRAYSCALE; cinfo->input_components = 1; } else { cinfo->in_color_space = JCS_RGB; cinfo->input_components = 3; } /* * A place to hold each scanline while it's converted. * (GRAYSCALE scanlines don't need converting) */ if (source->visual != GRAYSCALE) { source->rle_row = (rle_pixel**) (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) width, (JDIMENSION) cinfo->input_components); } /* request a virtual array to hold the image */ source->image = (*cinfo->mem->request_virt_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, (JDIMENSION) (width * source->header.ncolors), (JDIMENSION) height, (JDIMENSION) 1); #ifdef PROGRESS_REPORT if (progress != NULL) { /* count file input as separate pass */ progress->total_extra_passes++; } #endif source->pub.buffer_height = 1; } /* * Read one row of pixels. * Called only after load_image has read the image into the virtual array. * Used for GRAYSCALE, MAPPEDGRAY, TRUECOLOR, and DIRECTCOLOR images. */ METHODDEF(JDIMENSION) get_rle_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { rle_source_ptr source = (rle_source_ptr) sinfo; source->row--; source->pub.buffer = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->image, source->row, (JDIMENSION) 1, FALSE); return 1; } /* * Read one row of pixels. * Called only after load_image has read the image into the virtual array. * Used for PSEUDOCOLOR images. */ METHODDEF(JDIMENSION) get_pseudocolor_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { rle_source_ptr source = (rle_source_ptr) sinfo; JSAMPROW src_row, dest_row; JDIMENSION col; rle_map *colormap; int val; colormap = source->header.cmap; dest_row = source->pub.buffer[0]; source->row--; src_row = * (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->image, source->row, (JDIMENSION) 1, FALSE); for (col = cinfo->image_width; col > 0; col--) { val = GETJSAMPLE(*src_row++); *dest_row++ = (JSAMPLE) (colormap[val ] >> 8); *dest_row++ = (JSAMPLE) (colormap[val + 256] >> 8); *dest_row++ = (JSAMPLE) (colormap[val + 512] >> 8); } return 1; } /* * Load the image into a virtual array. We have to do this because RLE * files start at the lower left while the JPEG standard has them starting * in the upper left. This is called the first time we want to get a row * of input. What we do is load the RLE data into the array and then call * the appropriate routine to read one row from the array. Before returning, * we set source->pub.get_pixel_rows so that subsequent calls go straight to * the appropriate row-reading routine. */ METHODDEF(JDIMENSION) load_image (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { rle_source_ptr source = (rle_source_ptr) sinfo; JDIMENSION row, col; JSAMPROW scanline, red_ptr, green_ptr, blue_ptr; rle_pixel **rle_row; rle_map *colormap; char channel; #ifdef PROGRESS_REPORT cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; #endif colormap = source->header.cmap; rle_row = source->rle_row; /* Read the RLE data into our virtual array. * We assume here that (a) rle_pixel is represented the same as JSAMPLE, * and (b) we are not on a machine where FAR pointers differ from regular. */ RLE_CLR_BIT(source->header, RLE_ALPHA); /* don't read the alpha channel */ #ifdef PROGRESS_REPORT if (progress != NULL) { progress->pub.pass_limit = cinfo->image_height; progress->pub.pass_counter = 0; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } #endif switch (source->visual) { case GRAYSCALE: case PSEUDOCOLOR: for (row = 0; row < cinfo->image_height; row++) { rle_row = (rle_pixel **) (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE); rle_getrow(&source->header, rle_row); #ifdef PROGRESS_REPORT if (progress != NULL) { progress->pub.pass_counter++; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } #endif } break; case MAPPEDGRAY: case TRUECOLOR: for (row = 0; row < cinfo->image_height; row++) { scanline = * (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE); rle_row = source->rle_row; rle_getrow(&source->header, rle_row); for (col = 0; col < cinfo->image_width; col++) { for (channel = 0; channel < source->header.ncolors; channel++) { *scanline++ = (JSAMPLE) (colormap[GETJSAMPLE(rle_row[channel][col]) + 256 * channel] >> 8); } } #ifdef PROGRESS_REPORT if (progress != NULL) { progress->pub.pass_counter++; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } #endif } break; case DIRECTCOLOR: for (row = 0; row < cinfo->image_height; row++) { scanline = * (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE); rle_getrow(&source->header, rle_row); red_ptr = rle_row[0]; green_ptr = rle_row[1]; blue_ptr = rle_row[2]; for (col = cinfo->image_width; col > 0; col--) { *scanline++ = *red_ptr++; *scanline++ = *green_ptr++; *scanline++ = *blue_ptr++; } #ifdef PROGRESS_REPORT if (progress != NULL) { progress->pub.pass_counter++; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } #endif } } #ifdef PROGRESS_REPORT if (progress != NULL) progress->completed_extra_passes++; #endif /* Set up to call proper row-extraction routine in future */ if (source->visual == PSEUDOCOLOR) { source->pub.buffer = source->rle_row; source->pub.get_pixel_rows = get_pseudocolor_row; } else { source->pub.get_pixel_rows = get_rle_row; } source->row = cinfo->image_height; /* And fetch the topmost (bottommost) row */ return (*source->pub.get_pixel_rows) (cinfo, sinfo); } /* * Finish up at the end of the file. */ METHODDEF(void) finish_input_rle (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { /* no work */ } /* * The module selection routine for RLE format input. */ GLOBAL(cjpeg_source_ptr) jinit_read_rle (j_compress_ptr cinfo) { rle_source_ptr source; /* Create module interface object */ source = (rle_source_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(rle_source_struct)); /* Fill in method ptrs */ source->pub.start_input = start_input_rle; source->pub.finish_input = finish_input_rle; source->pub.get_pixel_rows = load_image; return (cjpeg_source_ptr) source; } #endif /* RLE_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/JCCOLOR.C0000755000175000017500000003571307535143454014047 0ustar /* * jccolor.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains input colorspace conversion routines. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* Private subobject */ typedef struct { struct jpeg_color_converter pub; /* public fields */ /* Private state for RGB->YCC conversion */ INT32 * rgb_ycc_tab; /* => table for RGB to YCbCr conversion */ } my_color_converter; typedef my_color_converter * my_cconvert_ptr; /**************** RGB -> YCbCr conversion: most common case **************/ /* * YCbCr is defined per CCIR 601-1, except that Cb and Cr are * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5. * The conversion equations to be implemented are therefore * Y = 0.29900 * R + 0.58700 * G + 0.11400 * B * Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE * Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.) * Note: older versions of the IJG code used a zero offset of MAXJSAMPLE/2, * rather than CENTERJSAMPLE, for Cb and Cr. This gave equal positive and * negative swings for Cb/Cr, but meant that grayscale values (Cb=Cr=0) * were not represented exactly. Now we sacrifice exact representation of * maximum red and maximum blue in order to get exact grayscales. * * To avoid floating-point arithmetic, we represent the fractional constants * as integers scaled up by 2^16 (about 4 digits precision); we have to divide * the products by 2^16, with appropriate rounding, to get the correct answer. * * For even more speed, we avoid doing any multiplications in the inner loop * by precalculating the constants times R,G,B for all possible values. * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table); * for 12-bit samples it is still acceptable. It's not very reasonable for * 16-bit samples, but if you want lossless storage you shouldn't be changing * colorspace anyway. * The CENTERJSAMPLE offsets and the rounding fudge-factor of 0.5 are included * in the tables to save adding them separately in the inner loop. */ #define SCALEBITS 16 /* speediest right-shift on some machines */ #define CBCR_OFFSET ((INT32) CENTERJSAMPLE << SCALEBITS) #define ONE_HALF ((INT32) 1 << (SCALEBITS-1)) #define FIX(x) ((INT32) ((x) * (1L< Y section */ #define G_Y_OFF (1*(MAXJSAMPLE+1)) /* offset to G => Y section */ #define B_Y_OFF (2*(MAXJSAMPLE+1)) /* etc. */ #define R_CB_OFF (3*(MAXJSAMPLE+1)) #define G_CB_OFF (4*(MAXJSAMPLE+1)) #define B_CB_OFF (5*(MAXJSAMPLE+1)) #define R_CR_OFF B_CB_OFF /* B=>Cb, R=>Cr are the same */ #define G_CR_OFF (6*(MAXJSAMPLE+1)) #define B_CR_OFF (7*(MAXJSAMPLE+1)) #define TABLE_SIZE (8*(MAXJSAMPLE+1)) /* * Initialize for RGB->YCC colorspace conversion. */ METHODDEF(void) rgb_ycc_start (j_compress_ptr cinfo) { my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; INT32 * rgb_ycc_tab; INT32 i; /* Allocate and fill in the conversion tables. */ cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (TABLE_SIZE * SIZEOF(INT32))); for (i = 0; i <= MAXJSAMPLE; i++) { rgb_ycc_tab[i+R_Y_OFF] = FIX(0.29900) * i; rgb_ycc_tab[i+G_Y_OFF] = FIX(0.58700) * i; rgb_ycc_tab[i+B_Y_OFF] = FIX(0.11400) * i + ONE_HALF; rgb_ycc_tab[i+R_CB_OFF] = (-FIX(0.16874)) * i; rgb_ycc_tab[i+G_CB_OFF] = (-FIX(0.33126)) * i; /* We use a rounding fudge-factor of 0.5-epsilon for Cb and Cr. * This ensures that the maximum output will round to MAXJSAMPLE * not MAXJSAMPLE+1, and thus that we don't have to range-limit. */ rgb_ycc_tab[i+B_CB_OFF] = FIX(0.50000) * i + CBCR_OFFSET + ONE_HALF-1; /* B=>Cb and R=>Cr tables are the same rgb_ycc_tab[i+R_CR_OFF] = FIX(0.50000) * i + CBCR_OFFSET + ONE_HALF-1; */ rgb_ycc_tab[i+G_CR_OFF] = (-FIX(0.41869)) * i; rgb_ycc_tab[i+B_CR_OFF] = (-FIX(0.08131)) * i; } } /* * Convert some rows of samples to the JPEG colorspace. * * Note that we change from the application's interleaved-pixel format * to our internal noninterleaved, one-plane-per-component format. * The input buffer is therefore three times as wide as the output buffer. * * A starting row offset is provided only for the output buffer. The caller * can easily adjust the passed input_buf value to accommodate any row * offset required on that side. */ METHODDEF(void) rgb_ycc_convert (j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows) { my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; register int r, g, b; register INT32 * ctab = cconvert->rgb_ycc_tab; register JSAMPROW inptr; register JSAMPROW outptr0, outptr1, outptr2; register JDIMENSION col; JDIMENSION num_cols = cinfo->image_width; while (--num_rows >= 0) { inptr = *input_buf++; outptr0 = output_buf[0][output_row]; outptr1 = output_buf[1][output_row]; outptr2 = output_buf[2][output_row]; output_row++; for (col = 0; col < num_cols; col++) { r = GETJSAMPLE(inptr[RGB_RED]); g = GETJSAMPLE(inptr[RGB_GREEN]); b = GETJSAMPLE(inptr[RGB_BLUE]); inptr += RGB_PIXELSIZE; /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations * must be too; we do not need an explicit range-limiting operation. * Hence the value being shifted is never negative, and we don't * need the general RIGHT_SHIFT macro. */ /* Y */ outptr0[col] = (JSAMPLE) ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF]) >> SCALEBITS); /* Cb */ outptr1[col] = (JSAMPLE) ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF]) >> SCALEBITS); /* Cr */ outptr2[col] = (JSAMPLE) ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF]) >> SCALEBITS); } } } /**************** Cases other than RGB -> YCbCr **************/ /* * Convert some rows of samples to the JPEG colorspace. * This version handles RGB->grayscale conversion, which is the same * as the RGB->Y portion of RGB->YCbCr. * We assume rgb_ycc_start has been called (we only use the Y tables). */ METHODDEF(void) rgb_gray_convert (j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows) { my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; register int r, g, b; register INT32 * ctab = cconvert->rgb_ycc_tab; register JSAMPROW inptr; register JSAMPROW outptr; register JDIMENSION col; JDIMENSION num_cols = cinfo->image_width; while (--num_rows >= 0) { inptr = *input_buf++; outptr = output_buf[0][output_row]; output_row++; for (col = 0; col < num_cols; col++) { r = GETJSAMPLE(inptr[RGB_RED]); g = GETJSAMPLE(inptr[RGB_GREEN]); b = GETJSAMPLE(inptr[RGB_BLUE]); inptr += RGB_PIXELSIZE; /* Y */ outptr[col] = (JSAMPLE) ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF]) >> SCALEBITS); } } } /* * Convert some rows of samples to the JPEG colorspace. * This version handles Adobe-style CMYK->YCCK conversion, * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the same * conversion as above, while passing K (black) unchanged. * We assume rgb_ycc_start has been called. */ METHODDEF(void) cmyk_ycck_convert (j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows) { my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; register int r, g, b; register INT32 * ctab = cconvert->rgb_ycc_tab; register JSAMPROW inptr; register JSAMPROW outptr0, outptr1, outptr2, outptr3; register JDIMENSION col; JDIMENSION num_cols = cinfo->image_width; while (--num_rows >= 0) { inptr = *input_buf++; outptr0 = output_buf[0][output_row]; outptr1 = output_buf[1][output_row]; outptr2 = output_buf[2][output_row]; outptr3 = output_buf[3][output_row]; output_row++; for (col = 0; col < num_cols; col++) { r = MAXJSAMPLE - GETJSAMPLE(inptr[0]); g = MAXJSAMPLE - GETJSAMPLE(inptr[1]); b = MAXJSAMPLE - GETJSAMPLE(inptr[2]); /* K passes through as-is */ outptr3[col] = inptr[3]; /* don't need GETJSAMPLE here */ inptr += 4; /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations * must be too; we do not need an explicit range-limiting operation. * Hence the value being shifted is never negative, and we don't * need the general RIGHT_SHIFT macro. */ /* Y */ outptr0[col] = (JSAMPLE) ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF]) >> SCALEBITS); /* Cb */ outptr1[col] = (JSAMPLE) ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF]) >> SCALEBITS); /* Cr */ outptr2[col] = (JSAMPLE) ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF]) >> SCALEBITS); } } } /* * Convert some rows of samples to the JPEG colorspace. * This version handles grayscale output with no conversion. * The source can be either plain grayscale or YCbCr (since Y == gray). */ METHODDEF(void) grayscale_convert (j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows) { register JSAMPROW inptr; register JSAMPROW outptr; register JDIMENSION col; JDIMENSION num_cols = cinfo->image_width; int instride = cinfo->input_components; while (--num_rows >= 0) { inptr = *input_buf++; outptr = output_buf[0][output_row]; output_row++; for (col = 0; col < num_cols; col++) { outptr[col] = inptr[0]; /* don't need GETJSAMPLE() here */ inptr += instride; } } } /* * Convert some rows of samples to the JPEG colorspace. * This version handles multi-component colorspaces without conversion. * We assume input_components == num_components. */ METHODDEF(void) null_convert (j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows) { register JSAMPROW inptr; register JSAMPROW outptr; register JDIMENSION col; register int ci; int nc = cinfo->num_components; JDIMENSION num_cols = cinfo->image_width; while (--num_rows >= 0) { /* It seems fastest to make a separate pass for each component. */ for (ci = 0; ci < nc; ci++) { inptr = *input_buf; outptr = output_buf[ci][output_row]; for (col = 0; col < num_cols; col++) { outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */ inptr += nc; } } input_buf++; output_row++; } } /* * Empty method for start_pass. */ METHODDEF(void) null_method (j_compress_ptr cinfo) { /* no work needed */ } /* * Module initialization routine for input colorspace conversion. */ GLOBAL(void) jinit_color_converter (j_compress_ptr cinfo) { my_cconvert_ptr cconvert; cconvert = (my_cconvert_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_color_converter)); cinfo->cconvert = (struct jpeg_color_converter *) cconvert; /* set start_pass to null method until we find out differently */ cconvert->pub.start_pass = null_method; /* Make sure input_components agrees with in_color_space */ switch (cinfo->in_color_space) { case JCS_GRAYSCALE: if (cinfo->input_components != 1) ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); break; case JCS_RGB: #if RGB_PIXELSIZE != 3 if (cinfo->input_components != RGB_PIXELSIZE) ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); break; #endif /* else share code with YCbCr */ case JCS_YCbCr: if (cinfo->input_components != 3) ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); break; case JCS_CMYK: case JCS_YCCK: if (cinfo->input_components != 4) ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); break; default: /* JCS_UNKNOWN can be anything */ if (cinfo->input_components < 1) ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); break; } /* Check num_components, set conversion method based on requested space */ switch (cinfo->jpeg_color_space) { case JCS_GRAYSCALE: if (cinfo->num_components != 1) ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); if (cinfo->in_color_space == JCS_GRAYSCALE) cconvert->pub.color_convert = grayscale_convert; else if (cinfo->in_color_space == JCS_RGB) { cconvert->pub.start_pass = rgb_ycc_start; cconvert->pub.color_convert = rgb_gray_convert; } else if (cinfo->in_color_space == JCS_YCbCr) cconvert->pub.color_convert = grayscale_convert; else ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); break; case JCS_RGB: if (cinfo->num_components != 3) ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); if (cinfo->in_color_space == JCS_RGB && RGB_PIXELSIZE == 3) cconvert->pub.color_convert = null_convert; else ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); break; case JCS_YCbCr: if (cinfo->num_components != 3) ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); if (cinfo->in_color_space == JCS_RGB) { cconvert->pub.start_pass = rgb_ycc_start; cconvert->pub.color_convert = rgb_ycc_convert; } else if (cinfo->in_color_space == JCS_YCbCr) cconvert->pub.color_convert = null_convert; else ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); break; case JCS_CMYK: if (cinfo->num_components != 4) ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); if (cinfo->in_color_space == JCS_CMYK) cconvert->pub.color_convert = null_convert; else ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); break; case JCS_YCCK: if (cinfo->num_components != 4) ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); if (cinfo->in_color_space == JCS_CMYK) { cconvert->pub.start_pass = rgb_ycc_start; cconvert->pub.color_convert = cmyk_ycck_convert; } else if (cinfo->in_color_space == JCS_YCCK) cconvert->pub.color_convert = null_convert; else ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); break; default: /* allow null conversion of JCS_UNKNOWN */ if (cinfo->jpeg_color_space != cinfo->in_color_space || cinfo->num_components != cinfo->input_components) ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); cconvert->pub.color_convert = null_convert; break; } } Papyrus3/JpegDir/JpgLossy/RDGIF.C0000755000175000017500000000243607535143454013603 0ustar /* * rdgif.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to read input images in GIF format. * ***************************************************************************** * NOTE: to avoid entanglements with Unisys' patent on LZW compression, * * the ability to read GIF files has been removed from the IJG distribution. * * Sorry about that. * ***************************************************************************** * * We are required to state that * "The Graphics Interchange Format(c) is the Copyright property of * CompuServe Incorporated. GIF(sm) is a Service Mark property of * CompuServe Incorporated." */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ #ifdef GIF_SUPPORTED /* * The module selection routine for GIF format input. */ GLOBAL(cjpeg_source_ptr) jinit_read_gif (j_compress_ptr cinfo) { fprintf(stderr, "GIF input is unsupported for legal reasons. Sorry.\n"); exit(EXIT_FAILURE); return NULL; /* keep compiler happy */ } #endif /* GIF_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/WRGIF.C0000755000175000017500000003174707535143454013635 0ustar /* * wrgif.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to write output images in GIF format. * ************************************************************************** * NOTE: to avoid entanglements with Unisys' patent on LZW compression, * * this code has been modified to output "uncompressed GIF" files. * * There is no trace of the LZW algorithm in this file. * ************************************************************************** * * These routines may need modification for non-Unix environments or * specialized applications. As they stand, they assume output to * an ordinary stdio stream. */ /* * This code is loosely based on ppmtogif from the PBMPLUS distribution * of Feb. 1991. That file contains the following copyright notice: * Based on GIFENCODE by David Rowley . * Lempel-Ziv compression based on "compress" by Spencer W. Thomas et al. * Copyright (C) 1989 by Jef Poskanzer. * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose and without fee is hereby granted, provided * that the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation. This software is provided "as is" without express or * implied warranty. * * We are also required to state that * "The Graphics Interchange Format(c) is the Copyright property of * CompuServe Incorporated. GIF(sm) is a Service Mark property of * CompuServe Incorporated." */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ #ifdef GIF_SUPPORTED /* Private version of data destination object */ typedef struct { struct djpeg_dest_struct pub; /* public fields */ j_decompress_ptr cinfo; /* back link saves passing separate parm */ /* State for packing variable-width codes into a bitstream */ int n_bits; /* current number of bits/code */ int maxcode; /* maximum code, given n_bits */ INT32 cur_accum; /* holds bits not yet output */ int cur_bits; /* # of bits in cur_accum */ /* State for GIF code assignment */ int ClearCode; /* clear code (doesn't change) */ int EOFCode; /* EOF code (ditto) */ int code_counter; /* counts output symbols */ /* GIF data packet construction buffer */ int bytesinpkt; /* # of bytes in current packet */ char packetbuf[256]; /* workspace for accumulating packet */ } gif_dest_struct; typedef gif_dest_struct * gif_dest_ptr; /* Largest value that will fit in N bits */ #define MAXCODE(n_bits) ((1 << (n_bits)) - 1) /* * Routines to package finished data bytes into GIF data blocks. * A data block consists of a count byte (1..255) and that many data bytes. */ LOCAL(void) flush_packet (gif_dest_ptr dinfo) /* flush any accumulated data */ { if (dinfo->bytesinpkt > 0) { /* never write zero-length packet */ dinfo->packetbuf[0] = (char) dinfo->bytesinpkt++; if (JFWRITE(dinfo->pub.output_file, dinfo->packetbuf, dinfo->bytesinpkt) != (size_t) dinfo->bytesinpkt) ERREXIT(dinfo->cinfo, JERR_FILE_WRITE); dinfo->bytesinpkt = 0; } } /* Add a character to current packet; flush to disk if necessary */ #define CHAR_OUT(dinfo,c) \ { (dinfo)->packetbuf[++(dinfo)->bytesinpkt] = (char) (c); \ if ((dinfo)->bytesinpkt >= 255) \ flush_packet(dinfo); \ } /* Routine to convert variable-width codes into a byte stream */ LOCAL(void) output (gif_dest_ptr dinfo, int code) /* Emit a code of n_bits bits */ /* Uses cur_accum and cur_bits to reblock into 8-bit bytes */ { dinfo->cur_accum |= ((INT32) code) << dinfo->cur_bits; dinfo->cur_bits += dinfo->n_bits; while (dinfo->cur_bits >= 8) { CHAR_OUT(dinfo, dinfo->cur_accum & 0xFF); dinfo->cur_accum >>= 8; dinfo->cur_bits -= 8; } } /* The pseudo-compression algorithm. * * In this module we simply output each pixel value as a separate symbol; * thus, no compression occurs. In fact, there is expansion of one bit per * pixel, because we use a symbol width one bit wider than the pixel width. * * GIF ordinarily uses variable-width symbols, and the decoder will expect * to ratchet up the symbol width after a fixed number of symbols. * To simplify the logic and keep the expansion penalty down, we emit a * GIF Clear code to reset the decoder just before the width would ratchet up. * Thus, all the symbols in the output file will have the same bit width. * Note that emitting the Clear codes at the right times is a mere matter of * counting output symbols and is in no way dependent on the LZW patent. * * With a small basic pixel width (low color count), Clear codes will be * needed very frequently, causing the file to expand even more. So this * simplistic approach wouldn't work too well on bilevel images, for example. * But for output of JPEG conversions the pixel width will usually be 8 bits * (129 to 256 colors), so the overhead added by Clear symbols is only about * one symbol in every 256. */ LOCAL(void) compress_init (gif_dest_ptr dinfo, int i_bits) /* Initialize pseudo-compressor */ { /* init all the state variables */ dinfo->n_bits = i_bits; dinfo->maxcode = MAXCODE(dinfo->n_bits); dinfo->ClearCode = (1 << (i_bits - 1)); dinfo->EOFCode = dinfo->ClearCode + 1; dinfo->code_counter = dinfo->ClearCode + 2; /* init output buffering vars */ dinfo->bytesinpkt = 0; dinfo->cur_accum = 0; dinfo->cur_bits = 0; /* GIF specifies an initial Clear code */ output(dinfo, dinfo->ClearCode); } LOCAL(void) compress_pixel (gif_dest_ptr dinfo, int c) /* Accept and "compress" one pixel value. * The given value must be less than n_bits wide. */ { /* Output the given pixel value as a symbol. */ output(dinfo, c); /* Issue Clear codes often enough to keep the reader from ratcheting up * its symbol size. */ if (dinfo->code_counter < dinfo->maxcode) { dinfo->code_counter++; } else { output(dinfo, dinfo->ClearCode); dinfo->code_counter = dinfo->ClearCode + 2; /* reset the counter */ } } LOCAL(void) compress_term (gif_dest_ptr dinfo) /* Clean up at end */ { /* Send an EOF code */ output(dinfo, dinfo->EOFCode); /* Flush the bit-packing buffer */ if (dinfo->cur_bits > 0) { CHAR_OUT(dinfo, dinfo->cur_accum & 0xFF); } /* Flush the packet buffer */ flush_packet(dinfo); } /* GIF header construction */ LOCAL(void) put_word (gif_dest_ptr dinfo, unsigned int w) /* Emit a 16-bit word, LSB first */ { putc(w & 0xFF, dinfo->pub.output_file); putc((w >> 8) & 0xFF, dinfo->pub.output_file); } LOCAL(void) put_3bytes (gif_dest_ptr dinfo, int val) /* Emit 3 copies of same byte value --- handy subr for colormap construction */ { putc(val, dinfo->pub.output_file); putc(val, dinfo->pub.output_file); putc(val, dinfo->pub.output_file); } LOCAL(void) emit_header (gif_dest_ptr dinfo, int num_colors, JSAMPARRAY colormap) /* Output the GIF file header, including color map */ /* If colormap==NULL, synthesize a gray-scale colormap */ { int BitsPerPixel, ColorMapSize, InitCodeSize, FlagByte; int cshift = dinfo->cinfo->data_precision - 8; int i; if (num_colors > 256) ERREXIT1(dinfo->cinfo, JERR_TOO_MANY_COLORS, num_colors); /* Compute bits/pixel and related values */ BitsPerPixel = 1; while (num_colors > (1 << BitsPerPixel)) BitsPerPixel++; ColorMapSize = 1 << BitsPerPixel; if (BitsPerPixel <= 1) InitCodeSize = 2; else InitCodeSize = BitsPerPixel; /* * Write the GIF header. * Note that we generate a plain GIF87 header for maximum compatibility. */ putc('G', dinfo->pub.output_file); putc('I', dinfo->pub.output_file); putc('F', dinfo->pub.output_file); putc('8', dinfo->pub.output_file); putc('7', dinfo->pub.output_file); putc('a', dinfo->pub.output_file); /* Write the Logical Screen Descriptor */ put_word(dinfo, (unsigned int) dinfo->cinfo->output_width); put_word(dinfo, (unsigned int) dinfo->cinfo->output_height); FlagByte = 0x80; /* Yes, there is a global color table */ FlagByte |= (BitsPerPixel-1) << 4; /* color resolution */ FlagByte |= (BitsPerPixel-1); /* size of global color table */ putc(FlagByte, dinfo->pub.output_file); putc(0, dinfo->pub.output_file); /* Background color index */ putc(0, dinfo->pub.output_file); /* Reserved (aspect ratio in GIF89) */ /* Write the Global Color Map */ /* If the color map is more than 8 bits precision, */ /* we reduce it to 8 bits by shifting */ for (i=0; i < ColorMapSize; i++) { if (i < num_colors) { if (colormap != NULL) { if (dinfo->cinfo->out_color_space == JCS_RGB) { /* Normal case: RGB color map */ putc(GETJSAMPLE(colormap[0][i]) >> cshift, dinfo->pub.output_file); putc(GETJSAMPLE(colormap[1][i]) >> cshift, dinfo->pub.output_file); putc(GETJSAMPLE(colormap[2][i]) >> cshift, dinfo->pub.output_file); } else { /* Grayscale "color map": possible if quantizing grayscale image */ put_3bytes(dinfo, GETJSAMPLE(colormap[0][i]) >> cshift); } } else { /* Create a gray-scale map of num_colors values, range 0..255 */ put_3bytes(dinfo, (i * 255 + (num_colors-1)/2) / (num_colors-1)); } } else { /* fill out the map to a power of 2 */ put_3bytes(dinfo, 0); } } /* Write image separator and Image Descriptor */ putc(',', dinfo->pub.output_file); /* separator */ put_word(dinfo, 0); /* left/top offset */ put_word(dinfo, 0); put_word(dinfo, (unsigned int) dinfo->cinfo->output_width); /* image size */ put_word(dinfo, (unsigned int) dinfo->cinfo->output_height); /* flag byte: not interlaced, no local color map */ putc(0x00, dinfo->pub.output_file); /* Write Initial Code Size byte */ putc(InitCodeSize, dinfo->pub.output_file); /* Initialize for "compression" of image data */ compress_init(dinfo, InitCodeSize+1); } /* * Startup: write the file header. */ METHODDEF(void) start_output_gif (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) { gif_dest_ptr dest = (gif_dest_ptr) dinfo; if (cinfo->quantize_colors) emit_header(dest, cinfo->actual_number_of_colors, cinfo->colormap); else emit_header(dest, 256, (JSAMPARRAY) NULL); } /* * Write some pixel data. * In this module rows_supplied will always be 1. */ METHODDEF(void) put_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied) { gif_dest_ptr dest = (gif_dest_ptr) dinfo; register JSAMPROW ptr; register JDIMENSION col; ptr = dest->pub.buffer[0]; for (col = cinfo->output_width; col > 0; col--) { compress_pixel(dest, GETJSAMPLE(*ptr++)); } } /* * Finish up at the end of the file. */ METHODDEF(void) finish_output_gif (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) { gif_dest_ptr dest = (gif_dest_ptr) dinfo; /* Flush "compression" mechanism */ compress_term(dest); /* Write a zero-length data block to end the series */ putc(0, dest->pub.output_file); /* Write the GIF terminator mark */ putc(';', dest->pub.output_file); /* Make sure we wrote the output file OK */ fflush(dest->pub.output_file); if (ferror(dest->pub.output_file)) ERREXIT(cinfo, JERR_FILE_WRITE); } /* * The module selection routine for GIF format output. */ GLOBAL(djpeg_dest_ptr) jinit_write_gif (j_decompress_ptr cinfo) { gif_dest_ptr dest; /* Create module interface object, fill in method pointers */ dest = (gif_dest_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(gif_dest_struct)); dest->cinfo = cinfo; /* make back link for subroutines */ dest->pub.start_output = start_output_gif; dest->pub.put_pixel_rows = put_pixel_rows; dest->pub.finish_output = finish_output_gif; if (cinfo->out_color_space != JCS_GRAYSCALE && cinfo->out_color_space != JCS_RGB) ERREXIT(cinfo, JERR_GIF_COLORSPACE); /* Force quantization if color or if > 8 bits input */ if (cinfo->out_color_space != JCS_GRAYSCALE || cinfo->data_precision > 8) { /* Force quantization to at most 256 colors */ cinfo->quantize_colors = TRUE; if (cinfo->desired_number_of_colors > 256) cinfo->desired_number_of_colors = 256; } /* Calculate output image dimensions so we can allocate space */ jpeg_calc_output_dimensions(cinfo); if (cinfo->output_components != 1) /* safety check: just one component? */ ERREXIT(cinfo, JERR_GIF_BUG); /* Create decompressor output buffer. */ dest->pub.buffer = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, cinfo->output_width, (JDIMENSION) 1); dest->pub.buffer_height = 1; return (djpeg_dest_ptr) dest; } #endif /* GIF_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/MAKEFILE.MMS0000755000175000017500000003223707535143454014401 0ustar # Makefile for Independent JPEG Group's software # This makefile is for use with MMS on Digital VMS systems. # Thanks to Rick Dyson (dyson@iowasp.physics.uiowa.edu) # and Tim Bell (tbell@netcom.com) for their help. # Read installation instructions before saying "MMS" !! # You may need to adjust these cc options: CFLAGS= $(CFLAGS) /NoDebug /Optimize # Generally, we recommend defining any configuration symbols in jconfig.h, # NOT via /Define switches here. .ifdef ALPHA OPT= .else OPT= ,Sys$Disk:[]MAKVMS.OPT/Option .endif # Put here the object file name for the correct system-dependent memory # manager file. For Unix this is usually jmemnobs.o, but you may want # to use jmemansi.o or jmemname.o if you have limited swap space. SYSDEPMEM= jmemnobs.obj # End of configurable options. # source files: JPEG library proper LIBSOURCES= jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c \ jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c \ jcphuff.c jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c \ jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c \ jdinput.c jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c \ jdpostct.c jdsample.c jdtrans.c jerror.c jfdctflt.c jfdctfst.c \ jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c jquant1.c \ jquant2.c jutils.c jmemmgr.c # memmgr back ends: compile only one of these into a working library SYSDEPSOURCES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemmac.c # source files: cjpeg/djpeg/jpegtran applications, also rdjpgcom/wrjpgcom APPSOURCES= cjpeg.c djpeg.c jpegtran.c rdjpgcom.c wrjpgcom.c cdjpeg.c \ rdcolmap.c rdswitch.c transupp.c rdppm.c wrppm.c rdgif.c wrgif.c \ rdtarga.c wrtarga.c rdbmp.c wrbmp.c rdrle.c wrrle.c SOURCES= $(LIBSOURCES) $(SYSDEPSOURCES) $(APPSOURCES) # files included by source files INCLUDES= jchuff.h jdhuff.h jdct.h jerror.h jinclude.h jmemsys.h jmorecfg.h \ jpegint.h jpeglib.h jversion.h cdjpeg.h cderror.h transupp.h # documentation, test, and support files DOCS= README install.doc usage.doc cjpeg.1 djpeg.1 jpegtran.1 rdjpgcom.1 \ wrjpgcom.1 wizard.doc example.c libjpeg.doc structure.doc \ coderules.doc filelist.doc change.log MKFILES= configure makefile.cfg makefile.ansi makefile.unix makefile.bcc \ makefile.mc6 makefile.dj makefile.wat makefile.vc makelib.ds \ makeapps.ds makeproj.mac makcjpeg.st makdjpeg.st makljpeg.st \ maktjpeg.st makefile.manx makefile.sas makefile.mms makefile.vms \ makvms.opt CONFIGFILES= jconfig.cfg jconfig.bcc jconfig.mc6 jconfig.dj jconfig.wat \ jconfig.vc jconfig.mac jconfig.st jconfig.manx jconfig.sas \ jconfig.vms CONFIGUREFILES= config.guess config.sub install-sh ltconfig ltmain.sh OTHERFILES= jconfig.doc ckconfig.c ansi2knr.c ansi2knr.1 jmemdosa.asm TESTFILES= testorig.jpg testimg.ppm testimg.bmp testimg.jpg testprog.jpg \ testimgp.jpg DISTFILES= $(DOCS) $(MKFILES) $(CONFIGFILES) $(SOURCES) $(INCLUDES) \ $(CONFIGUREFILES) $(OTHERFILES) $(TESTFILES) # library object files common to compression and decompression COMOBJECTS= jcomapi.obj jutils.obj jerror.obj jmemmgr.obj $(SYSDEPMEM) # compression library object files CLIBOBJECTS= jcapimin.obj jcapistd.obj jctrans.obj jcparam.obj jdatadst.obj \ jcinit.obj jcmaster.obj jcmarker.obj jcmainct.obj jcprepct.obj \ jccoefct.obj jccolor.obj jcsample.obj jchuff.obj jcphuff.obj \ jcdctmgr.obj jfdctfst.obj jfdctflt.obj jfdctint.obj # decompression library object files DLIBOBJECTS= jdapimin.obj jdapistd.obj jdtrans.obj jdatasrc.obj \ jdmaster.obj jdinput.obj jdmarker.obj jdhuff.obj jdphuff.obj \ jdmainct.obj jdcoefct.obj jdpostct.obj jddctmgr.obj jidctfst.obj \ jidctflt.obj jidctint.obj jidctred.obj jdsample.obj jdcolor.obj \ jquant1.obj jquant2.obj jdmerge.obj # These objectfiles are included in libjpeg.olb LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS) # object files for sample applications (excluding library files) COBJECTS= cjpeg.obj rdppm.obj rdgif.obj rdtarga.obj rdrle.obj rdbmp.obj \ rdswitch.obj cdjpeg.obj DOBJECTS= djpeg.obj wrppm.obj wrgif.obj wrtarga.obj wrrle.obj wrbmp.obj \ rdcolmap.obj cdjpeg.obj TROBJECTS= jpegtran.obj rdswitch.obj cdjpeg.obj transupp.obj # objectfile lists with commas --- what a crock COBJLIST= cjpeg.obj,rdppm.obj,rdgif.obj,rdtarga.obj,rdrle.obj,rdbmp.obj,\ rdswitch.obj,cdjpeg.obj DOBJLIST= djpeg.obj,wrppm.obj,wrgif.obj,wrtarga.obj,wrrle.obj,wrbmp.obj,\ rdcolmap.obj,cdjpeg.obj TROBJLIST= jpegtran.obj,rdswitch.obj,cdjpeg.obj,transupp.obj LIBOBJLIST= jcapimin.obj,jcapistd.obj,jctrans.obj,jcparam.obj,jdatadst.obj,\ jcinit.obj,jcmaster.obj,jcmarker.obj,jcmainct.obj,jcprepct.obj,\ jccoefct.obj,jccolor.obj,jcsample.obj,jchuff.obj,jcphuff.obj,\ jcdctmgr.obj,jfdctfst.obj,jfdctflt.obj,jfdctint.obj,jdapimin.obj,\ jdapistd.obj,jdtrans.obj,jdatasrc.obj,jdmaster.obj,jdinput.obj,\ jdmarker.obj,jdhuff.obj,jdphuff.obj,jdmainct.obj,jdcoefct.obj,\ jdpostct.obj,jddctmgr.obj,jidctfst.obj,jidctflt.obj,jidctint.obj,\ jidctred.obj,jdsample.obj,jdcolor.obj,jquant1.obj,jquant2.obj,\ jdmerge.obj,jcomapi.obj,jutils.obj,jerror.obj,jmemmgr.obj,$(SYSDEPMEM) .first @- Define /NoLog Sys Sys$Library ALL : libjpeg.olb cjpeg.exe djpeg.exe jpegtran.exe rdjpgcom.exe wrjpgcom.exe @ Continue libjpeg.olb : $(LIBOBJECTS) Library /Create libjpeg.olb $(LIBOBJLIST) cjpeg.exe : $(COBJECTS) libjpeg.olb $(LINK) $(LFLAGS) /Executable = cjpeg.exe $(COBJLIST),libjpeg.olb/Library$(OPT) djpeg.exe : $(DOBJECTS) libjpeg.olb $(LINK) $(LFLAGS) /Executable = djpeg.exe $(DOBJLIST),libjpeg.olb/Library$(OPT) jpegtran.exe : $(TROBJECTS) libjpeg.olb $(LINK) $(LFLAGS) /Executable = jpegtran.exe $(TROBJLIST),libjpeg.olb/Library$(OPT) rdjpgcom.exe : rdjpgcom.obj $(LINK) $(LFLAGS) /Executable = rdjpgcom.exe rdjpgcom.obj$(OPT) wrjpgcom.exe : wrjpgcom.obj $(LINK) $(LFLAGS) /Executable = wrjpgcom.exe wrjpgcom.obj$(OPT) jconfig.h : jconfig.vms @- Copy jconfig.vms jconfig.h clean : @- Set Protection = Owner:RWED *.*;-1 @- Set Protection = Owner:RWED *.OBJ - Purge /NoLog /NoConfirm *.* - Delete /NoLog /NoConfirm *.OBJ; test : cjpeg.exe djpeg.exe jpegtran.exe mcr sys$disk:[]djpeg -dct int -ppm -outfile testout.ppm testorig.jpg mcr sys$disk:[]djpeg -dct int -bmp -colors 256 -outfile testout.bmp testorig.jpg mcr sys$disk:[]cjpeg -dct int -outfile testout.jpg testimg.ppm mcr sys$disk:[]djpeg -dct int -ppm -outfile testoutp.ppm testprog.jpg mcr sys$disk:[]cjpeg -dct int -progressive -opt -outfile testoutp.jpg testimg.ppm mcr sys$disk:[]jpegtran -outfile testoutt.jpg testprog.jpg - Backup /Compare/Log testimg.ppm testout.ppm - Backup /Compare/Log testimg.bmp testout.bmp - Backup /Compare/Log testimg.jpg testout.jpg - Backup /Compare/Log testimg.ppm testoutp.ppm - Backup /Compare/Log testimgp.jpg testoutp.jpg - Backup /Compare/Log testorig.jpg testoutt.jpg jcapimin.obj : jcapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcapistd.obj : jcapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccoefct.obj : jccoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccolor.obj : jccolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcdctmgr.obj : jcdctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jchuff.obj : jchuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcinit.obj : jcinit.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmainct.obj : jcmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmarker.obj : jcmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmaster.obj : jcmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcomapi.obj : jcomapi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcparam.obj : jcparam.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcphuff.obj : jcphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcprepct.obj : jcprepct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcsample.obj : jcsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jctrans.obj : jctrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapimin.obj : jdapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapistd.obj : jdapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdatadst.obj : jdatadst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdatasrc.obj : jdatasrc.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdcoefct.obj : jdcoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdcolor.obj : jdcolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jddctmgr.obj : jddctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jdhuff.obj : jdhuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdinput.obj : jdinput.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmainct.obj : jdmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmarker.obj : jdmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmaster.obj : jdmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmerge.obj : jdmerge.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdphuff.obj : jdphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdpostct.obj : jdpostct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdsample.obj : jdsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdtrans.obj : jdtrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jerror.obj : jerror.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jversion.h jerror.h jfdctflt.obj : jfdctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctfst.obj : jfdctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctint.obj : jfdctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctflt.obj : jidctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctfst.obj : jidctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctint.obj : jidctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctred.obj : jidctred.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jquant1.obj : jquant1.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jquant2.obj : jquant2.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jutils.obj : jutils.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemmgr.obj : jmemmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemansi.obj : jmemansi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemname.obj : jmemname.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemnobs.obj : jmemnobs.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemdos.obj : jmemdos.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemmac.obj : jmemmac.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h cjpeg.obj : cjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h djpeg.obj : djpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h jpegtran.obj : jpegtran.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.h jversion.h rdjpgcom.obj : rdjpgcom.c jinclude.h jconfig.h wrjpgcom.obj : wrjpgcom.c jinclude.h jconfig.h cdjpeg.obj : cdjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdcolmap.obj : rdcolmap.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdswitch.obj : rdswitch.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.obj : transupp.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h transupp.h rdppm.obj : rdppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrppm.obj : wrppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdgif.obj : rdgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrgif.obj : wrgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdtarga.obj : rdtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrtarga.obj : wrtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdbmp.obj : rdbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrbmp.obj : wrbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdrle.obj : rdrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrrle.obj : wrrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h Papyrus3/JpegDir/JpgLossy/maktjpeg.st0000755000175000017500000000255107535143454015014 0ustar ; Project file for Independent JPEG Group's software ; ; This project file is for Atari ST/STE/TT systems using Pure C or Turbo C. ; Thanks to Frank Moehle (Frank.Moehle@arbi.informatik.uni-oldenburg.de), ; Dr. B. Setzepfandt (bernd@gina.uni-muenster.de), ; and Guido Vollbeding (guivol@esc.de). ; ; To use this file, rename it to jpegtran.prj. ; If you are using Turbo C, change filenames beginning with "pc..." to "tc..." ; Read installation instructions before trying to make the program! ; ; ; * * * Output file * * * jpegtran.ttp ; ; * * * COMPILER OPTIONS * * * .C[-P] ; absolute calls .C[-M] ; and no string merging, folks .C[-w-cln] ; no "constant is long" warnings .C[-w-par] ; no "parameter xxxx unused" .C[-w-rch] ; no "unreachable code" .C[-wsig] ; warn if significant digits may be lost = ; * * * * List of modules * * * * pcstart.o jpegtran.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h,transupp.h,jversion.h) cdjpeg.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) rdswitch.c (cdjpeg.h,jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jerror.h,cderror.h) transupp.c (jinclude.h,jconfig.h,jpeglib.h,jmorecfg.h,jpegint.h,jerror.h,transupp.h) libjpeg.lib ; built by libjpeg.prj pcstdlib.lib ; standard library pcextlib.lib ; extended library Papyrus3/JpegDir/JpgLossy/RDCOLMAP.C0000755000175000017500000002116507535143454014151 0ustar /* * rdcolmap.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file implements djpeg's "-map file" switch. It reads a source image * and constructs a colormap to be supplied to the JPEG decompressor. * * Currently, these file formats are supported for the map file: * GIF: the contents of the GIF's global colormap are used. * PPM (either text or raw flavor): the entire file is read and * each unique pixel value is entered in the map. * Note that reading a large PPM file will be horrendously slow. * Typically, a PPM-format map file should contain just one pixel * of each desired color. Such a file can be extracted from an * ordinary image PPM file with ppmtomap(1). * * Rescaling a PPM that has a maxval unequal to MAXJSAMPLE is not * currently implemented. */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif #ifdef QUANT_2PASS_SUPPORTED /* otherwise can't quantize to supplied map */ /* Portions of this code are based on the PBMPLUS library, which is: ** ** Copyright (C) 1988 by Jef Poskanzer. ** ** Permission to use, copy, modify, and distribute this software and its ** documentation for any purpose and without fee is hereby granted, provided ** that the above copyright notice appear in all copies and that both that ** copyright notice and this permission notice appear in supporting ** documentation. This software is provided "as is" without express or ** implied warranty. */ /* * Add a (potentially) new color to the color map. */ LOCAL(void) add_map_entry (j_decompress_ptr cinfo, int R, int G, int B) { JSAMPROW colormap0 = cinfo->colormap[0]; JSAMPROW colormap1 = cinfo->colormap[1]; JSAMPROW colormap2 = cinfo->colormap[2]; int ncolors = cinfo->actual_number_of_colors; int index; /* Check for duplicate color. */ for (index = 0; index < ncolors; index++) { if (GETJSAMPLE(colormap0[index]) == R && GETJSAMPLE(colormap1[index]) == G && GETJSAMPLE(colormap2[index]) == B) return; /* color is already in map */ } /* Check for map overflow. */ if (ncolors >= (MAXJSAMPLE+1)) ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, (MAXJSAMPLE+1)); /* OK, add color to map. */ colormap0[ncolors] = (JSAMPLE) R; colormap1[ncolors] = (JSAMPLE) G; colormap2[ncolors] = (JSAMPLE) B; cinfo->actual_number_of_colors++; } /* * Extract color map from a GIF file. */ LOCAL(void) read_gif_map (j_decompress_ptr cinfo, PAPY_FILE infile) { int header[13]; int i, colormaplen; int R, G, B; PapyShort err; PapyULong bytesToRead = 1L; /* Initial 'G' has already been read by read_color_map */ /* Read the rest of the GIF header and logical screen descriptor */ for (i = 1; i < 13; i++) { /*if ((header[i] = getc(infile)) == EOF)*/ if ((err = Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &header [i])) < 0) ERREXIT(cinfo, JERR_BAD_CMAP_FILE); } /* Verify GIF Header */ if (header[1] != 'I' || header[2] != 'F') ERREXIT(cinfo, JERR_BAD_CMAP_FILE); /* There must be a global color map. */ if ((header[10] & 0x80) == 0) ERREXIT(cinfo, JERR_BAD_CMAP_FILE); /* OK, fetch it. */ colormaplen = 2 << (header[10] & 0x07); for (i = 0; i < colormaplen; i++) { /*R = getc(infile); G = getc(infile); B = getc(infile); if (R == EOF || G == EOF || B == EOF) ERREXIT(cinfo, JERR_BAD_CMAP_FILE);*/ if ((err = Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &R)) < 0) ERREXIT(cinfo, JERR_BAD_CMAP_FILE); if ((err = Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &G)) < 0) ERREXIT(cinfo, JERR_BAD_CMAP_FILE); if ((err = Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &B)) < 0) ERREXIT(cinfo, JERR_BAD_CMAP_FILE); add_map_entry(cinfo, R << (BITS_IN_JSAMPLE-8), G << (BITS_IN_JSAMPLE-8), B << (BITS_IN_JSAMPLE-8)); } } /* Support routines for reading PPM */ LOCAL(int) pbm_getc (PAPY_FILE infile) /* Read next char, skipping over any comments */ /* A comment/newline sequence is returned as a newline */ { int ch; PapyULong bytesToRead = 1L; /*ch = getc(infile);*/ Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &ch); if (ch == '#') { do { /*ch = getc(infile);*/ Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &ch); } while (ch != '\n' && ch != EOF); } return ch; } LOCAL(unsigned int) read_pbm_integer (j_decompress_ptr cinfo, PAPY_FILE infile) /* Read an unsigned decimal integer from the PPM file */ /* Swallows one trailing character after the integer */ /* Note that on a 16-bit-int machine, only values up to 64k can be read. */ /* This should not be a problem in practice. */ { register int ch; register unsigned int val; /* Skip any leading whitespace */ do { ch = pbm_getc(infile); if (ch == EOF) ERREXIT(cinfo, JERR_BAD_CMAP_FILE); } while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'); if (ch < '0' || ch > '9') ERREXIT(cinfo, JERR_BAD_CMAP_FILE); val = ch - '0'; while ((ch = pbm_getc(infile)) >= '0' && ch <= '9') { val *= 10; val += ch - '0'; } return val; } /* * Extract color map from a PPM file. */ LOCAL(void) read_ppm_map (j_decompress_ptr cinfo, PAPY_FILE infile) { int c; unsigned int w, h, maxval, row, col; int R, G, B; PapyShort err; PapyULong bytesToRead = 1L; /* Initial 'P' has already been read by read_color_map */ /* c = getc(infile); /* save format discriminator for a sec */ Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &c); /* while we fetch the remaining header info */ w = read_pbm_integer(cinfo, infile); h = read_pbm_integer(cinfo, infile); maxval = read_pbm_integer(cinfo, infile); if (w <= 0 || h <= 0 || maxval <= 0) /* error check */ ERREXIT(cinfo, JERR_BAD_CMAP_FILE); /* For now, we don't support rescaling from an unusual maxval. */ if (maxval != (unsigned int) MAXJSAMPLE) ERREXIT(cinfo, JERR_BAD_CMAP_FILE); switch (c) { case '3': /* it's a text-format PPM file */ for (row = 0; row < h; row++) { for (col = 0; col < w; col++) { R = read_pbm_integer(cinfo, infile); G = read_pbm_integer(cinfo, infile); B = read_pbm_integer(cinfo, infile); add_map_entry(cinfo, R, G, B); } } break; case '6': /* it's a raw-format PPM file */ for (row = 0; row < h; row++) { for (col = 0; col < w; col++) { /*R = getc(infile); G = getc(infile); B = getc(infile); if (R == EOF || G == EOF || B == EOF) ERREXIT(cinfo, JERR_BAD_CMAP_FILE);*/ if ((err = Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &R)) < 0) ERREXIT(cinfo, JERR_BAD_CMAP_FILE); if ((err = Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &G)) < 0) ERREXIT(cinfo, JERR_BAD_CMAP_FILE); if ((err = Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &B)) < 0) ERREXIT(cinfo, JERR_BAD_CMAP_FILE); add_map_entry(cinfo, R, G, B); } } break; default: ERREXIT(cinfo, JERR_BAD_CMAP_FILE); break; } } /* * Main entry point from djpeg.c. * Input: opened input file (from file name argument on command line). * Output: colormap and actual_number_of_colors fields are set in cinfo. */ GLOBAL(void) read_color_map (j_decompress_ptr cinfo, PAPY_FILE infile) { PapyULong bytesToRead = 1L; char ch [10]; /* Allocate space for a color map of maximum supported size. */ cinfo->colormap = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) (MAXJSAMPLE+1), (JDIMENSION) 3); cinfo->actual_number_of_colors = 0; /* initialize map to empty */ /* Read first byte to determine file format */ /*switch (getc(infile)) {*/ switch (Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &ch)) { case 'G': read_gif_map(cinfo, infile); break; case 'P': read_ppm_map(cinfo, infile); break; default: ERREXIT(cinfo, JERR_BAD_CMAP_FILE); break; } } #endif /* QUANT_2PASS_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/JMEMSYS.H0000755000175000017500000002035707535143454014106 0ustar /* * jmemsys.h * * Copyright (C) 1992-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This include file defines the interface between the system-independent * and system-dependent portions of the JPEG memory manager. No other * modules need include it. (The system-independent portion is jmemmgr.c; * there are several different versions of the system-dependent portion.) * * This file works as-is for the system-dependent memory managers supplied * in the IJG distribution. You may need to modify it if you write a * custom memory manager. If system-dependent changes are needed in * this file, the best method is to #ifdef them based on a configuration * symbol supplied in jconfig.h, as we have done with USE_MSDOS_MEMMGR * and USE_MAC_MEMMGR. */ /* Short forms of external names for systems with brain-damaged linkers. */ #ifdef NEED_SHORT_EXTERNAL_NAMES #define jpeg_get_small jGetSmall #define jpeg_free_small jFreeSmall #define jpeg_get_large jGetLarge #define jpeg_free_large jFreeLarge #define jpeg_mem_available jMemAvail #define jpeg_open_backing_store jOpenBackStore #define jpeg_mem_init jMemInit #define jpeg_mem_term jMemTerm #endif /* NEED_SHORT_EXTERNAL_NAMES */ /* * These two functions are used to allocate and release small chunks of * memory. (Typically the total amount requested through jpeg_get_small is * no more than 20K or so; this will be requested in chunks of a few K each.) * Behavior should be the same as for the standard library functions malloc * and free; in particular, jpeg_get_small must return NULL on failure. * On most systems, these ARE malloc and free. jpeg_free_small is passed the * size of the object being freed, just in case it's needed. * On an 80x86 machine using small-data memory model, these manage near heap. */ EXTERN(void *) jpeg_get_small JPP((j_common_ptr cinfo, size_t sizeofobject)); EXTERN(void) jpeg_free_small JPP((j_common_ptr cinfo, void * object, size_t sizeofobject)); /* * These two functions are used to allocate and release large chunks of * memory (up to the total free space designated by jpeg_mem_available). * The interface is the same as above, except that on an 80x86 machine, * far pointers are used. On most other machines these are identical to * the jpeg_get/free_small routines; but we keep them separate anyway, * in case a different allocation strategy is desirable for large chunks. */ EXTERN(void FAR *) jpeg_get_large JPP((j_common_ptr cinfo, size_t sizeofobject)); EXTERN(void) jpeg_free_large JPP((j_common_ptr cinfo, void FAR * object, size_t sizeofobject)); /* * The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may * be requested in a single call to jpeg_get_large (and jpeg_get_small for that * matter, but that case should never come into play). This macro is needed * to model the 64Kb-segment-size limit of far addressing on 80x86 machines. * On those machines, we expect that jconfig.h will provide a proper value. * On machines with 32-bit flat address spaces, any large constant may be used. * * NB: jmemmgr.c expects that MAX_ALLOC_CHUNK will be representable as type * size_t and will be a multiple of sizeof(align_type). */ #ifndef MAX_ALLOC_CHUNK /* may be overridden in jconfig.h */ #define MAX_ALLOC_CHUNK 1000000000L #endif /* * This routine computes the total space still available for allocation by * jpeg_get_large. If more space than this is needed, backing store will be * used. NOTE: any memory already allocated must not be counted. * * There is a minimum space requirement, corresponding to the minimum * feasible buffer sizes; jmemmgr.c will request that much space even if * jpeg_mem_available returns zero. The maximum space needed, enough to hold * all working storage in memory, is also passed in case it is useful. * Finally, the total space already allocated is passed. If no better * method is available, cinfo->mem->max_memory_to_use - already_allocated * is often a suitable calculation. * * It is OK for jpeg_mem_available to underestimate the space available * (that'll just lead to more backing-store access than is really necessary). * However, an overestimate will lead to failure. Hence it's wise to subtract * a slop factor from the true available space. 5% should be enough. * * On machines with lots of virtual memory, any large constant may be returned. * Conversely, zero may be returned to always use the minimum amount of memory. */ EXTERN(long) jpeg_mem_available JPP((j_common_ptr cinfo, long min_bytes_needed, long max_bytes_needed, long already_allocated)); /* * This structure holds whatever state is needed to access a single * backing-store object. The read/write/close method pointers are called * by jmemmgr.c to manipulate the backing-store object; all other fields * are private to the system-dependent backing store routines. */ #define TEMP_NAME_LENGTH 64 /* max length of a temporary file's name */ #ifdef USE_MSDOS_MEMMGR /* DOS-specific junk */ typedef unsigned short XMSH; /* type of extended-memory handles */ typedef unsigned short EMSH; /* type of expanded-memory handles */ typedef union { short file_handle; /* DOS file handle if it's a temp file */ XMSH xms_handle; /* handle if it's a chunk of XMS */ EMSH ems_handle; /* handle if it's a chunk of EMS */ } handle_union; #endif /* USE_MSDOS_MEMMGR */ #ifdef USE_MAC_MEMMGR /* Mac-specific junk */ #include #endif /* USE_MAC_MEMMGR */ typedef struct backing_store_struct * backing_store_ptr; typedef struct backing_store_struct { /* Methods for reading/writing/closing this backing-store object */ JMETHOD(void, read_backing_store, (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count)); JMETHOD(void, write_backing_store, (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count)); JMETHOD(void, close_backing_store, (j_common_ptr cinfo, backing_store_ptr info)); /* Private fields for system-dependent backing-store management */ #ifdef USE_MSDOS_MEMMGR /* For the MS-DOS manager (jmemdos.c), we need: */ handle_union handle; /* reference to backing-store storage object */ char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */ #else #ifdef USE_MAC_MEMMGR /* For the Mac manager (jmemmac.c), we need: */ short temp_file; /* file reference number to temp file */ FSSpec tempSpec; /* the FSSpec for the temp file */ char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */ #else /* For a typical implementation with temp files, we need: */ PAPY_FILE temp_file; /* stdio reference to temp file */ char temp_name[TEMP_NAME_LENGTH]; /* name of temp file */ #endif #endif } backing_store_info; /* * Initial opening of a backing-store object. This must fill in the * read/write/close pointers in the object. The read/write routines * may take an error exit if the specified maximum file size is exceeded. * (If jpeg_mem_available always returns a large value, this routine can * just take an error exit.) */ EXTERN(void) jpeg_open_backing_store JPP((j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed)); /* * These routines take care of any system-dependent initialization and * cleanup required. jpeg_mem_init will be called before anything is * allocated (and, therefore, nothing in cinfo is of use except the error * manager pointer). It should return a suitable default value for * max_memory_to_use; this may subsequently be overridden by the surrounding * application. (Note that max_memory_to_use is only important if * jpeg_mem_available chooses to consult it ... no one else will.) * jpeg_mem_term may assume that all requested memory has been freed and that * all opened backing-store objects have been closed. */ EXTERN(long) jpeg_mem_init JPP((j_common_ptr cinfo)); EXTERN(void) jpeg_mem_term JPP((j_common_ptr cinfo)); Papyrus3/JpegDir/JpgLossy/RDTARGA.C0000755000175000017500000003767007535143454014044 0ustar /* * rdtarga.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to read input images in Targa format. * * These routines may need modification for non-Unix environments or * specialized applications. As they stand, they assume input from * an ordinary stdio stream. They further assume that reading begins * at the start of the file; start_input may need work if the * user interface has already read some data (e.g., to determine that * the file is indeed Targa format). * * Based on code contributed by Lee Daniel Crocker. */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif #ifdef TARGA_SUPPORTED /* Macros to deal with unsigned chars as efficiently as compiler allows */ #ifdef HAVE_UNSIGNED_CHAR typedef unsigned char U_CHAR; #define UCH(x) ((int) (x)) #else /* !HAVE_UNSIGNED_CHAR */ #ifdef CHAR_IS_UNSIGNED typedef char U_CHAR; #define UCH(x) ((int) (x)) #else typedef char U_CHAR; #define UCH(x) ((int) (x) & 0xFF) #endif #endif /* HAVE_UNSIGNED_CHAR */ /*#define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (len)))*/ #define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (0))) /* Private version of data source object */ typedef struct _tga_source_struct * tga_source_ptr; typedef struct _tga_source_struct { struct cjpeg_source_struct pub; /* public fields */ j_compress_ptr cinfo; /* back link saves passing separate parm */ JSAMPARRAY colormap; /* Targa colormap (converted to my format) */ jvirt_sarray_ptr whole_image; /* Needed if funny input row order */ JDIMENSION current_row; /* Current logical row number to read */ /* Pointer to routine to extract next Targa pixel from input file */ JMETHOD(void, read_pixel, (tga_source_ptr sinfo)); /* Result of read_pixel is delivered here: */ U_CHAR tga_pixel[4]; int pixel_size; /* Bytes per Targa pixel (1 to 4) */ /* State info for reading RLE-coded pixels; both counts must be init to 0 */ int block_count; /* # of pixels remaining in RLE block */ int dup_pixel_count; /* # of times to duplicate previous pixel */ /* This saves the correct pixel-row-expansion method for preload_image */ JMETHOD(JDIMENSION, get_pixel_rows, (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)); } tga_source_struct; /* For expanding 5-bit pixel values to 8-bit with best rounding */ static const UINT8 c5to8bits[32] = { 0, 8, 16, 25, 33, 41, 49, 58, 66, 74, 82, 90, 99, 107, 115, 123, 132, 140, 148, 156, 165, 173, 181, 189, 197, 206, 214, 222, 230, 239, 247, 255 }; LOCAL(int) read_byte (tga_source_ptr sinfo) /* Read next byte from Targa file */ { register PAPY_FILE infile = sinfo->pub.input_file; int c; PapyShort err; PapyULong bytesToRead = 1L; /*if ((c = getc(infile)) == EOF)*/ if ((err = Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &c)) <0) ERREXIT(sinfo->cinfo, JERR_INPUT_EOF); return c; } LOCAL(void) read_colormap (tga_source_ptr sinfo, int cmaplen, int mapentrysize) /* Read the colormap from a Targa file */ { int i; /* Presently only handles 24-bit BGR format */ if (mapentrysize != 24) ERREXIT(sinfo->cinfo, JERR_TGA_BADCMAP); for (i = 0; i < cmaplen; i++) { sinfo->colormap[2][i] = (JSAMPLE) read_byte(sinfo); sinfo->colormap[1][i] = (JSAMPLE) read_byte(sinfo); sinfo->colormap[0][i] = (JSAMPLE) read_byte(sinfo); } } /* * read_pixel methods: get a single pixel from Targa file into tga_pixel[] */ METHODDEF(void) read_non_rle_pixel (tga_source_ptr sinfo) /* Read one Targa pixel from the input file; no RLE expansion */ { register PAPY_FILE infile = sinfo->pub.input_file; register int i; PapyULong bytesToRead = 1L; for (i = 0; i < sinfo->pixel_size; i++) { /* sinfo->tga_pixel[i] = (U_CHAR) getc(infile);*/ Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &sinfo->tga_pixel [i]); } } METHODDEF(void) read_rle_pixel (tga_source_ptr sinfo) /* Read one Targa pixel from the input file, expanding RLE data as needed */ { register PAPY_FILE infile = sinfo->pub.input_file; register int i; PapyULong bytesToRead = 1L; /* Duplicate previously read pixel? */ if (sinfo->dup_pixel_count > 0) { sinfo->dup_pixel_count--; return; } /* Time to read RLE block header? */ if (--sinfo->block_count < 0) { /* decrement pixels remaining in block */ i = read_byte(sinfo); if (i & 0x80) { /* Start of duplicate-pixel block? */ sinfo->dup_pixel_count = i & 0x7F; /* number of dups after this one */ sinfo->block_count = 0; /* then read new block header */ } else { sinfo->block_count = i & 0x7F; /* number of pixels after this one */ } } /* Read next pixel */ for (i = 0; i < sinfo->pixel_size; i++) { /*sinfo->tga_pixel[i] = (U_CHAR) getc(infile);*/ Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &sinfo->tga_pixel [i]); } } /* * Read one row of pixels. * * We provide several different versions depending on input file format. */ METHODDEF(JDIMENSION) get_8bit_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading 8-bit grayscale pixels */ { tga_source_ptr source = (tga_source_ptr) sinfo; register JSAMPROW ptr; register JDIMENSION col; ptr = source->pub.buffer[0]; for (col = cinfo->image_width; col > 0; col--) { (*source->read_pixel) (source); /* Load next pixel into tga_pixel */ *ptr++ = (JSAMPLE) UCH(source->tga_pixel[0]); } return 1; } METHODDEF(JDIMENSION) get_8bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading 8-bit colormap indexes */ { tga_source_ptr source = (tga_source_ptr) sinfo; register int t; register JSAMPROW ptr; register JDIMENSION col; register JSAMPARRAY colormap = source->colormap; ptr = source->pub.buffer[0]; for (col = cinfo->image_width; col > 0; col--) { (*source->read_pixel) (source); /* Load next pixel into tga_pixel */ t = UCH(source->tga_pixel[0]); *ptr++ = colormap[0][t]; *ptr++ = colormap[1][t]; *ptr++ = colormap[2][t]; } return 1; } METHODDEF(JDIMENSION) get_16bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading 16-bit pixels */ { tga_source_ptr source = (tga_source_ptr) sinfo; register int t; register JSAMPROW ptr; register JDIMENSION col; ptr = source->pub.buffer[0]; for (col = cinfo->image_width; col > 0; col--) { (*source->read_pixel) (source); /* Load next pixel into tga_pixel */ t = UCH(source->tga_pixel[0]); t += UCH(source->tga_pixel[1]) << 8; /* We expand 5 bit data to 8 bit sample width. * The format of the 16-bit (LSB first) input word is * xRRRRRGGGGGBBBBB */ ptr[2] = (JSAMPLE) c5to8bits[t & 0x1F]; t >>= 5; ptr[1] = (JSAMPLE) c5to8bits[t & 0x1F]; t >>= 5; ptr[0] = (JSAMPLE) c5to8bits[t & 0x1F]; ptr += 3; } return 1; } METHODDEF(JDIMENSION) get_24bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading 24-bit pixels */ { tga_source_ptr source = (tga_source_ptr) sinfo; register JSAMPROW ptr; register JDIMENSION col; ptr = source->pub.buffer[0]; for (col = cinfo->image_width; col > 0; col--) { (*source->read_pixel) (source); /* Load next pixel into tga_pixel */ *ptr++ = (JSAMPLE) UCH(source->tga_pixel[2]); /* change BGR to RGB order */ *ptr++ = (JSAMPLE) UCH(source->tga_pixel[1]); *ptr++ = (JSAMPLE) UCH(source->tga_pixel[0]); } return 1; } /* * Targa also defines a 32-bit pixel format with order B,G,R,A. * We presently ignore the attribute byte, so the code for reading * these pixels is identical to the 24-bit routine above. * This works because the actual pixel length is only known to read_pixel. */ #define get_32bit_row get_24bit_row /* * This method is for re-reading the input data in standard top-down * row order. The entire image has already been read into whole_image * with proper conversion of pixel format, but it's in a funny row order. */ METHODDEF(JDIMENSION) get_memory_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { tga_source_ptr source = (tga_source_ptr) sinfo; JDIMENSION source_row; /* Compute row of source that maps to current_row of normal order */ /* For now, assume image is bottom-up and not interlaced. */ /* NEEDS WORK to support interlaced images! */ source_row = cinfo->image_height - source->current_row - 1; /* Fetch that row from virtual array */ source->pub.buffer = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->whole_image, source_row, (JDIMENSION) 1, FALSE); source->current_row++; return 1; } /* * This method loads the image into whole_image during the first call on * get_pixel_rows. The get_pixel_rows pointer is then adjusted to call * get_memory_row on subsequent calls. */ METHODDEF(JDIMENSION) preload_image (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { tga_source_ptr source = (tga_source_ptr) sinfo; JDIMENSION row; cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; /* Read the data into a virtual array in input-file row order. */ for (row = 0; row < cinfo->image_height; row++) { if (progress != NULL) { progress->pub.pass_counter = (long) row; progress->pub.pass_limit = (long) cinfo->image_height; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } source->pub.buffer = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->whole_image, row, (JDIMENSION) 1, TRUE); (*source->get_pixel_rows) (cinfo, sinfo); } if (progress != NULL) progress->completed_extra_passes++; /* Set up to read from the virtual array in unscrambled order */ source->pub.get_pixel_rows = get_memory_row; source->current_row = 0; /* And read the first row */ return get_memory_row(cinfo, sinfo); } /* * Read the file header; return image size and component count. */ METHODDEF(void) start_input_tga (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { tga_source_ptr source = (tga_source_ptr) sinfo; U_CHAR targaheader[18]; int idlen, cmaptype, subtype, flags, interlace_type, components; unsigned int width, height, maplen; boolean is_bottom_up; PapyULong myULong; #define GET_2B(offset) ((unsigned int) UCH(targaheader[offset]) + \ (((unsigned int) UCH(targaheader[offset+1])) << 8)) myULong = 18L; if (! ReadOK(source->pub.input_file, targaheader, myULong)) ERREXIT(cinfo, JERR_INPUT_EOF); /* Pretend "15-bit" pixels are 16-bit --- we ignore attribute bit anyway */ if (targaheader[16] == 15) targaheader[16] = 16; idlen = UCH(targaheader[0]); cmaptype = UCH(targaheader[1]); subtype = UCH(targaheader[2]); maplen = GET_2B(5); width = GET_2B(12); height = GET_2B(14); source->pixel_size = UCH(targaheader[16]) >> 3; flags = UCH(targaheader[17]); /* Image Descriptor byte */ is_bottom_up = ((flags & 0x20) == 0); /* bit 5 set => top-down */ interlace_type = flags >> 6; /* bits 6/7 are interlace code */ if (cmaptype > 1 || /* cmaptype must be 0 or 1 */ source->pixel_size < 1 || source->pixel_size > 4 || (UCH(targaheader[16]) & 7) != 0 || /* bits/pixel must be multiple of 8 */ interlace_type != 0) /* currently don't allow interlaced image */ ERREXIT(cinfo, JERR_TGA_BADPARMS); if (subtype > 8) { /* It's an RLE-coded file */ source->read_pixel = read_rle_pixel; source->block_count = source->dup_pixel_count = 0; subtype -= 8; } else { /* Non-RLE file */ source->read_pixel = read_non_rle_pixel; } /* Now should have subtype 1, 2, or 3 */ components = 3; /* until proven different */ cinfo->in_color_space = JCS_RGB; switch (subtype) { case 1: /* Colormapped image */ if (source->pixel_size == 1 && cmaptype == 1) source->get_pixel_rows = get_8bit_row; else ERREXIT(cinfo, JERR_TGA_BADPARMS); TRACEMS2(cinfo, 1, JTRC_TGA_MAPPED, width, height); break; case 2: /* RGB image */ switch (source->pixel_size) { case 2: source->get_pixel_rows = get_16bit_row; break; case 3: source->get_pixel_rows = get_24bit_row; break; case 4: source->get_pixel_rows = get_32bit_row; break; default: ERREXIT(cinfo, JERR_TGA_BADPARMS); break; } TRACEMS2(cinfo, 1, JTRC_TGA, width, height); break; case 3: /* Grayscale image */ components = 1; cinfo->in_color_space = JCS_GRAYSCALE; if (source->pixel_size == 1) source->get_pixel_rows = get_8bit_gray_row; else ERREXIT(cinfo, JERR_TGA_BADPARMS); TRACEMS2(cinfo, 1, JTRC_TGA_GRAY, width, height); break; default: ERREXIT(cinfo, JERR_TGA_BADPARMS); break; } if (is_bottom_up) { /* Create a virtual array to buffer the upside-down image. */ source->whole_image = (*cinfo->mem->request_virt_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, (JDIMENSION) width * components, (JDIMENSION) height, (JDIMENSION) 1); if (cinfo->progress != NULL) { cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; progress->total_extra_passes++; /* count file input as separate pass */ } /* source->pub.buffer will point to the virtual array. */ source->pub.buffer_height = 1; /* in case anyone looks at it */ source->pub.get_pixel_rows = preload_image; } else { /* Don't need a virtual array, but do need a one-row input buffer. */ source->whole_image = NULL; source->pub.buffer = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) width * components, (JDIMENSION) 1); source->pub.buffer_height = 1; source->pub.get_pixel_rows = source->get_pixel_rows; } while (idlen--) /* Throw away ID field */ (void) read_byte(source); if (maplen > 0) { if (maplen > 256 || GET_2B(3) != 0) ERREXIT(cinfo, JERR_TGA_BADCMAP); /* Allocate space to store the colormap */ source->colormap = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) maplen, (JDIMENSION) 3); /* and read it from the file */ read_colormap(source, (int) maplen, UCH(targaheader[7])); } else { if (cmaptype) /* but you promised a cmap! */ ERREXIT(cinfo, JERR_TGA_BADPARMS); source->colormap = NULL; } cinfo->input_components = components; cinfo->data_precision = 8; cinfo->image_width = width; cinfo->image_height = height; } /* * Finish up at the end of the file. */ METHODDEF(void) finish_input_tga (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { /* no work */ } /* * The module selection routine for Targa format input. */ GLOBAL(cjpeg_source_ptr) jinit_read_targa (j_compress_ptr cinfo) { tga_source_ptr source; /* Create module interface object */ source = (tga_source_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(tga_source_struct)); source->cinfo = cinfo; /* make back link for subroutines */ /* Fill in method ptrs, except get_pixel_rows which start_input sets */ source->pub.start_input = start_input_tga; source->pub.finish_input = finish_input_tga; return (cjpeg_source_ptr) source; } #endif /* TARGA_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/JQUANT1.C0000755000175000017500000007662607535143454014047 0ustar /* * jquant1.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains 1-pass color quantization (color mapping) routines. * These routines provide mapping to a fixed color map using equally spaced * color values. Optional Floyd-Steinberg or ordered dithering is available. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #ifdef QUANT_1PASS_SUPPORTED /* * The main purpose of 1-pass quantization is to provide a fast, if not very * high quality, colormapped output capability. A 2-pass quantizer usually * gives better visual quality; however, for quantized grayscale output this * quantizer is perfectly adequate. Dithering is highly recommended with this * quantizer, though you can turn it off if you really want to. * * In 1-pass quantization the colormap must be chosen in advance of seeing the * image. We use a map consisting of all combinations of Ncolors[i] color * values for the i'th component. The Ncolors[] values are chosen so that * their product, the total number of colors, is no more than that requested. * (In most cases, the product will be somewhat less.) * * Since the colormap is orthogonal, the representative value for each color * component can be determined without considering the other components; * then these indexes can be combined into a colormap index by a standard * N-dimensional-array-subscript calculation. Most of the arithmetic involved * can be precalculated and stored in the lookup table colorindex[]. * colorindex[i][j] maps pixel value j in component i to the nearest * representative value (grid plane) for that component; this index is * multiplied by the array stride for component i, so that the * index of the colormap entry closest to a given pixel value is just * sum( colorindex[component-number][pixel-component-value] ) * Aside from being fast, this scheme allows for variable spacing between * representative values with no additional lookup cost. * * If gamma correction has been applied in color conversion, it might be wise * to adjust the color grid spacing so that the representative colors are * equidistant in linear space. At this writing, gamma correction is not * implemented by jdcolor, so nothing is done here. */ /* Declarations for ordered dithering. * * We use a standard 16x16 ordered dither array. The basic concept of ordered * dithering is described in many references, for instance Dale Schumacher's * chapter II.2 of Graphics Gems II (James Arvo, ed. Academic Press, 1991). * In place of Schumacher's comparisons against a "threshold" value, we add a * "dither" value to the input pixel and then round the result to the nearest * output value. The dither value is equivalent to (0.5 - threshold) times * the distance between output values. For ordered dithering, we assume that * the output colors are equally spaced; if not, results will probably be * worse, since the dither may be too much or too little at a given point. * * The normal calculation would be to form pixel value + dither, range-limit * this to 0..MAXJSAMPLE, and then index into the colorindex table as usual. * We can skip the separate range-limiting step by extending the colorindex * table in both directions. */ #define ODITHER_SIZE 16 /* dimension of dither matrix */ /* NB: if ODITHER_SIZE is not a power of 2, ODITHER_MASK uses will break */ #define ODITHER_CELLS (ODITHER_SIZE*ODITHER_SIZE) /* # cells in matrix */ #define ODITHER_MASK (ODITHER_SIZE-1) /* mask for wrapping around counters */ typedef int ODITHER_MATRIX[ODITHER_SIZE][ODITHER_SIZE]; typedef int (*ODITHER_MATRIX_PTR)[ODITHER_SIZE]; static const UINT8 base_dither_matrix[ODITHER_SIZE][ODITHER_SIZE] = { /* Bayer's order-4 dither array. Generated by the code given in * Stephen Hawley's article "Ordered Dithering" in Graphics Gems I. * The values in this array must range from 0 to ODITHER_CELLS-1. */ { 0,192, 48,240, 12,204, 60,252, 3,195, 51,243, 15,207, 63,255 }, { 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 }, { 32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 }, { 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 }, { 8,200, 56,248, 4,196, 52,244, 11,203, 59,251, 7,199, 55,247 }, { 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 }, { 40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 }, { 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 }, { 2,194, 50,242, 14,206, 62,254, 1,193, 49,241, 13,205, 61,253 }, { 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 }, { 34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 }, { 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 }, { 10,202, 58,250, 6,198, 54,246, 9,201, 57,249, 5,197, 53,245 }, { 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 }, { 42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 }, { 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 } }; /* Declarations for Floyd-Steinberg dithering. * * Errors are accumulated into the array fserrors[], at a resolution of * 1/16th of a pixel count. The error at a given pixel is propagated * to its not-yet-processed neighbors using the standard F-S fractions, * ... (here) 7/16 * 3/16 5/16 1/16 * We work left-to-right on even rows, right-to-left on odd rows. * * We can get away with a single array (holding one row's worth of errors) * by using it to store the current row's errors at pixel columns not yet * processed, but the next row's errors at columns already processed. We * need only a few extra variables to hold the errors immediately around the * current column. (If we are lucky, those variables are in registers, but * even if not, they're probably cheaper to access than array elements are.) * * The fserrors[] array is indexed [component#][position]. * We provide (#columns + 2) entries per component; the extra entry at each * end saves us from special-casing the first and last pixels. * * Note: on a wide image, we might not have enough room in a PC's near data * segment to hold the error array; so it is allocated with alloc_large. */ #if BITS_IN_JSAMPLE == 8 typedef INT16 FSERROR; /* 16 bits should be enough */ typedef int LOCFSERROR; /* use 'int' for calculation temps */ #else typedef INT32 FSERROR; /* may need more than 16 bits */ typedef INT32 LOCFSERROR; /* be sure calculation temps are big enough */ #endif typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */ /* Private subobject */ #define MAX_Q_COMPS 4 /* max components I can handle */ typedef struct { struct jpeg_color_quantizer pub; /* public fields */ /* Initially allocated colormap is saved here */ JSAMPARRAY sv_colormap; /* The color map as a 2-D pixel array */ int sv_actual; /* number of entries in use */ JSAMPARRAY colorindex; /* Precomputed mapping for speed */ /* colorindex[i][j] = index of color closest to pixel value j in component i, * premultiplied as described above. Since colormap indexes must fit into * JSAMPLEs, the entries of this array will too. */ boolean is_padded; /* is the colorindex padded for odither? */ int Ncolors[MAX_Q_COMPS]; /* # of values alloced to each component */ /* Variables for ordered dithering */ int row_index; /* cur row's vertical index in dither matrix */ ODITHER_MATRIX_PTR odither[MAX_Q_COMPS]; /* one dither array per component */ /* Variables for Floyd-Steinberg dithering */ FSERRPTR fserrors[MAX_Q_COMPS]; /* accumulated errors */ boolean on_odd_row; /* flag to remember which row we are on */ } my_cquantizer; typedef my_cquantizer * my_cquantize_ptr; /* * Policy-making subroutines for create_colormap and create_colorindex. * These routines determine the colormap to be used. The rest of the module * only assumes that the colormap is orthogonal. * * * select_ncolors decides how to divvy up the available colors * among the components. * * output_value defines the set of representative values for a component. * * largest_input_value defines the mapping from input values to * representative values for a component. * Note that the latter two routines may impose different policies for * different components, though this is not currently done. */ LOCAL(int) select_ncolors (j_decompress_ptr cinfo, int Ncolors[]) /* Determine allocation of desired colors to components, */ /* and fill in Ncolors[] array to indicate choice. */ /* Return value is total number of colors (product of Ncolors[] values). */ { int nc = cinfo->out_color_components; /* number of color components */ int max_colors = cinfo->desired_number_of_colors; int total_colors, iroot, i, j; boolean changed; long temp; static const int RGB_order[3] = { RGB_GREEN, RGB_RED, RGB_BLUE }; /* We can allocate at least the nc'th root of max_colors per component. */ /* Compute floor(nc'th root of max_colors). */ iroot = 1; do { iroot++; temp = iroot; /* set temp = iroot ** nc */ for (i = 1; i < nc; i++) temp *= iroot; } while (temp <= (long) max_colors); /* repeat till iroot exceeds root */ iroot--; /* now iroot = floor(root) */ /* Must have at least 2 color values per component */ if (iroot < 2) ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, (int) temp); /* Initialize to iroot color values for each component */ total_colors = 1; for (i = 0; i < nc; i++) { Ncolors[i] = iroot; total_colors *= iroot; } /* We may be able to increment the count for one or more components without * exceeding max_colors, though we know not all can be incremented. * Sometimes, the first component can be incremented more than once! * (Example: for 16 colors, we start at 2*2*2, go to 3*2*2, then 4*2*2.) * In RGB colorspace, try to increment G first, then R, then B. */ do { changed = FALSE; for (i = 0; i < nc; i++) { j = (cinfo->out_color_space == JCS_RGB ? RGB_order[i] : i); /* calculate new total_colors if Ncolors[j] is incremented */ temp = total_colors / Ncolors[j]; temp *= Ncolors[j]+1; /* done in long arith to avoid oflo */ if (temp > (long) max_colors) break; /* won't fit, done with this pass */ Ncolors[j]++; /* OK, apply the increment */ total_colors = (int) temp; changed = TRUE; } } while (changed); return total_colors; } LOCAL(int) output_value (j_decompress_ptr cinfo, int ci, int j, int maxj) /* Return j'th output value, where j will range from 0 to maxj */ /* The output values must fall in 0..MAXJSAMPLE in increasing order */ { /* We always provide values 0 and MAXJSAMPLE for each component; * any additional values are equally spaced between these limits. * (Forcing the upper and lower values to the limits ensures that * dithering can't produce a color outside the selected gamut.) */ return (int) (((INT32) j * MAXJSAMPLE + maxj/2) / maxj); } LOCAL(int) largest_input_value (j_decompress_ptr cinfo, int ci, int j, int maxj) /* Return largest input value that should map to j'th output value */ /* Must have largest(j=0) >= 0, and largest(j=maxj) >= MAXJSAMPLE */ { /* Breakpoints are halfway between values returned by output_value */ return (int) (((INT32) (2*j + 1) * MAXJSAMPLE + maxj) / (2*maxj)); } /* * Create the colormap. */ LOCAL(void) create_colormap (j_decompress_ptr cinfo) { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; JSAMPARRAY colormap; /* Created colormap */ int total_colors; /* Number of distinct output colors */ int i,j,k, nci, blksize, blkdist, ptr, val; /* Select number of colors for each component */ total_colors = select_ncolors(cinfo, cquantize->Ncolors); /* Report selected color counts */ if (cinfo->out_color_components == 3) TRACEMS4(cinfo, 1, JTRC_QUANT_3_NCOLORS, total_colors, cquantize->Ncolors[0], cquantize->Ncolors[1], cquantize->Ncolors[2]); else TRACEMS1(cinfo, 1, JTRC_QUANT_NCOLORS, total_colors); /* Allocate and fill in the colormap. */ /* The colors are ordered in the map in standard row-major order, */ /* i.e. rightmost (highest-indexed) color changes most rapidly. */ colormap = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) total_colors, (JDIMENSION) cinfo->out_color_components); /* blksize is number of adjacent repeated entries for a component */ /* blkdist is distance between groups of identical entries for a component */ blkdist = total_colors; for (i = 0; i < cinfo->out_color_components; i++) { /* fill in colormap entries for i'th color component */ nci = cquantize->Ncolors[i]; /* # of distinct values for this color */ blksize = blkdist / nci; for (j = 0; j < nci; j++) { /* Compute j'th output value (out of nci) for component */ val = output_value(cinfo, i, j, nci-1); /* Fill in all colormap entries that have this value of this component */ for (ptr = j * blksize; ptr < total_colors; ptr += blkdist) { /* fill in blksize entries beginning at ptr */ for (k = 0; k < blksize; k++) colormap[i][ptr+k] = (JSAMPLE) val; } } blkdist = blksize; /* blksize of this color is blkdist of next */ } /* Save the colormap in private storage, * where it will survive color quantization mode changes. */ cquantize->sv_colormap = colormap; cquantize->sv_actual = total_colors; } /* * Create the color index table. */ LOCAL(void) create_colorindex (j_decompress_ptr cinfo) { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; JSAMPROW indexptr; int i,j,k, nci, blksize, val, pad; /* For ordered dither, we pad the color index tables by MAXJSAMPLE in * each direction (input index values can be -MAXJSAMPLE .. 2*MAXJSAMPLE). * This is not necessary in the other dithering modes. However, we * flag whether it was done in case user changes dithering mode. */ if (cinfo->dither_mode == JDITHER_ORDERED) { pad = MAXJSAMPLE*2; cquantize->is_padded = TRUE; } else { pad = 0; cquantize->is_padded = FALSE; } cquantize->colorindex = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) (MAXJSAMPLE+1 + pad), (JDIMENSION) cinfo->out_color_components); /* blksize is number of adjacent repeated entries for a component */ blksize = cquantize->sv_actual; for (i = 0; i < cinfo->out_color_components; i++) { /* fill in colorindex entries for i'th color component */ nci = cquantize->Ncolors[i]; /* # of distinct values for this color */ blksize = blksize / nci; /* adjust colorindex pointers to provide padding at negative indexes. */ if (pad) cquantize->colorindex[i] += MAXJSAMPLE; /* in loop, val = index of current output value, */ /* and k = largest j that maps to current val */ indexptr = cquantize->colorindex[i]; val = 0; k = largest_input_value(cinfo, i, 0, nci-1); for (j = 0; j <= MAXJSAMPLE; j++) { while (j > k) /* advance val if past boundary */ k = largest_input_value(cinfo, i, ++val, nci-1); /* premultiply so that no multiplication needed in main processing */ indexptr[j] = (JSAMPLE) (val * blksize); } /* Pad at both ends if necessary */ if (pad) for (j = 1; j <= MAXJSAMPLE; j++) { indexptr[-j] = indexptr[0]; indexptr[MAXJSAMPLE+j] = indexptr[MAXJSAMPLE]; } } } /* * Create an ordered-dither array for a component having ncolors * distinct output values. */ LOCAL(ODITHER_MATRIX_PTR) make_odither_array (j_decompress_ptr cinfo, int ncolors) { ODITHER_MATRIX_PTR odither; int j,k; INT32 num,den; odither = (ODITHER_MATRIX_PTR) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(ODITHER_MATRIX)); /* The inter-value distance for this color is MAXJSAMPLE/(ncolors-1). * Hence the dither value for the matrix cell with fill order f * (f=0..N-1) should be (N-1-2*f)/(2*N) * MAXJSAMPLE/(ncolors-1). * On 16-bit-int machine, be careful to avoid overflow. */ den = 2 * ODITHER_CELLS * ((INT32) (ncolors - 1)); for (j = 0; j < ODITHER_SIZE; j++) { for (k = 0; k < ODITHER_SIZE; k++) { num = ((INT32) (ODITHER_CELLS-1 - 2*((int)base_dither_matrix[j][k]))) * MAXJSAMPLE; /* Ensure round towards zero despite C's lack of consistency * about rounding negative values in integer division... */ odither[j][k] = (int) (num<0 ? -((-num)/den) : num/den); } } return odither; } /* * Create the ordered-dither tables. * Components having the same number of representative colors may * share a dither table. */ LOCAL(void) create_odither_tables (j_decompress_ptr cinfo) { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; ODITHER_MATRIX_PTR odither; int i, j, nci; for (i = 0; i < cinfo->out_color_components; i++) { nci = cquantize->Ncolors[i]; /* # of distinct values for this color */ odither = NULL; /* search for matching prior component */ for (j = 0; j < i; j++) { if (nci == cquantize->Ncolors[j]) { odither = cquantize->odither[j]; break; } } if (odither == NULL) /* need a new table? */ odither = make_odither_array(cinfo, nci); cquantize->odither[i] = odither; } } /* * Map some rows of pixels to the output colormapped representation. */ METHODDEF(void) color_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows) /* General case, no dithering */ { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; JSAMPARRAY colorindex = cquantize->colorindex; register int pixcode, ci; register JSAMPROW ptrin, ptrout; int row; JDIMENSION col; JDIMENSION width = cinfo->output_width; register int nc = cinfo->out_color_components; for (row = 0; row < num_rows; row++) { ptrin = input_buf[row]; ptrout = output_buf[row]; for (col = width; col > 0; col--) { pixcode = 0; for (ci = 0; ci < nc; ci++) { pixcode += GETJSAMPLE(colorindex[ci][GETJSAMPLE(*ptrin++)]); } *ptrout++ = (JSAMPLE) pixcode; } } } METHODDEF(void) color_quantize3 (j_decompress_ptr cinfo, JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows) /* Fast path for out_color_components==3, no dithering */ { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; register int pixcode; register JSAMPROW ptrin, ptrout; JSAMPROW colorindex0 = cquantize->colorindex[0]; JSAMPROW colorindex1 = cquantize->colorindex[1]; JSAMPROW colorindex2 = cquantize->colorindex[2]; int row; JDIMENSION col; JDIMENSION width = cinfo->output_width; for (row = 0; row < num_rows; row++) { ptrin = input_buf[row]; ptrout = output_buf[row]; for (col = width; col > 0; col--) { pixcode = GETJSAMPLE(colorindex0[GETJSAMPLE(*ptrin++)]); pixcode += GETJSAMPLE(colorindex1[GETJSAMPLE(*ptrin++)]); pixcode += GETJSAMPLE(colorindex2[GETJSAMPLE(*ptrin++)]); *ptrout++ = (JSAMPLE) pixcode; } } } METHODDEF(void) quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows) /* General case, with ordered dithering */ { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; register JSAMPROW input_ptr; register JSAMPROW output_ptr; JSAMPROW colorindex_ci; int * dither; /* points to active row of dither matrix */ int row_index, col_index; /* current indexes into dither matrix */ int nc = cinfo->out_color_components; int ci; int row; JDIMENSION col; JDIMENSION width = cinfo->output_width; for (row = 0; row < num_rows; row++) { /* Initialize output values to 0 so can process components separately */ jzero_far((void FAR *) output_buf[row], (size_t) (width * SIZEOF(JSAMPLE))); row_index = cquantize->row_index; for (ci = 0; ci < nc; ci++) { input_ptr = input_buf[row] + ci; output_ptr = output_buf[row]; colorindex_ci = cquantize->colorindex[ci]; dither = cquantize->odither[ci][row_index]; col_index = 0; for (col = width; col > 0; col--) { /* Form pixel value + dither, range-limit to 0..MAXJSAMPLE, * select output value, accumulate into output code for this pixel. * Range-limiting need not be done explicitly, as we have extended * the colorindex table to produce the right answers for out-of-range * inputs. The maximum dither is +- MAXJSAMPLE; this sets the * required amount of padding. */ *output_ptr += colorindex_ci[GETJSAMPLE(*input_ptr)+dither[col_index]]; input_ptr += nc; output_ptr++; col_index = (col_index + 1) & ODITHER_MASK; } } /* Advance row index for next row */ row_index = (row_index + 1) & ODITHER_MASK; cquantize->row_index = row_index; } } METHODDEF(void) quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows) /* Fast path for out_color_components==3, with ordered dithering */ { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; register int pixcode; register JSAMPROW input_ptr; register JSAMPROW output_ptr; JSAMPROW colorindex0 = cquantize->colorindex[0]; JSAMPROW colorindex1 = cquantize->colorindex[1]; JSAMPROW colorindex2 = cquantize->colorindex[2]; int * dither0; /* points to active row of dither matrix */ int * dither1; int * dither2; int row_index, col_index; /* current indexes into dither matrix */ int row; JDIMENSION col; JDIMENSION width = cinfo->output_width; for (row = 0; row < num_rows; row++) { row_index = cquantize->row_index; input_ptr = input_buf[row]; output_ptr = output_buf[row]; dither0 = cquantize->odither[0][row_index]; dither1 = cquantize->odither[1][row_index]; dither2 = cquantize->odither[2][row_index]; col_index = 0; for (col = width; col > 0; col--) { pixcode = GETJSAMPLE(colorindex0[GETJSAMPLE(*input_ptr++) + dither0[col_index]]); pixcode += GETJSAMPLE(colorindex1[GETJSAMPLE(*input_ptr++) + dither1[col_index]]); pixcode += GETJSAMPLE(colorindex2[GETJSAMPLE(*input_ptr++) + dither2[col_index]]); *output_ptr++ = (JSAMPLE) pixcode; col_index = (col_index + 1) & ODITHER_MASK; } row_index = (row_index + 1) & ODITHER_MASK; cquantize->row_index = row_index; } } METHODDEF(void) quantize_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows) /* General case, with Floyd-Steinberg dithering */ { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; register LOCFSERROR cur; /* current error or pixel value */ LOCFSERROR belowerr; /* error for pixel below cur */ LOCFSERROR bpreverr; /* error for below/prev col */ LOCFSERROR bnexterr; /* error for below/next col */ LOCFSERROR delta; register FSERRPTR errorptr; /* => fserrors[] at column before current */ register JSAMPROW input_ptr; register JSAMPROW output_ptr; JSAMPROW colorindex_ci; JSAMPROW colormap_ci; int pixcode; int nc = cinfo->out_color_components; int dir; /* 1 for left-to-right, -1 for right-to-left */ int dirnc; /* dir * nc */ int ci; int row; JDIMENSION col; JDIMENSION width = cinfo->output_width; JSAMPLE *range_limit = cinfo->sample_range_limit; SHIFT_TEMPS for (row = 0; row < num_rows; row++) { /* Initialize output values to 0 so can process components separately */ jzero_far((void FAR *) output_buf[row], (size_t) (width * SIZEOF(JSAMPLE))); for (ci = 0; ci < nc; ci++) { input_ptr = input_buf[row] + ci; output_ptr = output_buf[row]; if (cquantize->on_odd_row) { /* work right to left in this row */ input_ptr += (width-1) * nc; /* so point to rightmost pixel */ output_ptr += width-1; dir = -1; dirnc = -nc; errorptr = cquantize->fserrors[ci] + (width+1); /* => entry after last column */ } else { /* work left to right in this row */ dir = 1; dirnc = nc; errorptr = cquantize->fserrors[ci]; /* => entry before first column */ } colorindex_ci = cquantize->colorindex[ci]; colormap_ci = cquantize->sv_colormap[ci]; /* Preset error values: no error propagated to first pixel from left */ cur = 0; /* and no error propagated to row below yet */ belowerr = bpreverr = 0; for (col = width; col > 0; col--) { /* cur holds the error propagated from the previous pixel on the * current line. Add the error propagated from the previous line * to form the complete error correction term for this pixel, and * round the error term (which is expressed * 16) to an integer. * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct * for either sign of the error value. * Note: errorptr points to *previous* column's array entry. */ cur = RIGHT_SHIFT(cur + errorptr[dir] + 8, 4); /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE. * The maximum error is +- MAXJSAMPLE; this sets the required size * of the range_limit array. */ cur += GETJSAMPLE(*input_ptr); cur = GETJSAMPLE(range_limit[cur]); /* Select output value, accumulate into output code for this pixel */ pixcode = GETJSAMPLE(colorindex_ci[cur]); *output_ptr += (JSAMPLE) pixcode; /* Compute actual representation error at this pixel */ /* Note: we can do this even though we don't have the final */ /* pixel code, because the colormap is orthogonal. */ cur -= GETJSAMPLE(colormap_ci[pixcode]); /* Compute error fractions to be propagated to adjacent pixels. * Add these into the running sums, and simultaneously shift the * next-line error sums left by 1 column. */ bnexterr = cur; delta = cur * 2; cur += delta; /* form error * 3 */ errorptr[0] = (FSERROR) (bpreverr + cur); cur += delta; /* form error * 5 */ bpreverr = belowerr + cur; belowerr = bnexterr; cur += delta; /* form error * 7 */ /* At this point cur contains the 7/16 error value to be propagated * to the next pixel on the current line, and all the errors for the * next line have been shifted over. We are therefore ready to move on. */ input_ptr += dirnc; /* advance input ptr to next column */ output_ptr += dir; /* advance output ptr to next column */ errorptr += dir; /* advance errorptr to current column */ } /* Post-loop cleanup: we must unload the final error value into the * final fserrors[] entry. Note we need not unload belowerr because * it is for the dummy column before or after the actual array. */ errorptr[0] = (FSERROR) bpreverr; /* unload prev err into array */ } cquantize->on_odd_row = (cquantize->on_odd_row ? FALSE : TRUE); } } /* * Allocate workspace for Floyd-Steinberg errors. */ LOCAL(void) alloc_fs_workspace (j_decompress_ptr cinfo) { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; size_t arraysize; int i; arraysize = (size_t) ((cinfo->output_width + 2) * SIZEOF(FSERROR)); for (i = 0; i < cinfo->out_color_components; i++) { cquantize->fserrors[i] = (FSERRPTR) (*cinfo->mem->alloc_large)((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize); } } /* * Initialize for one-pass color quantization. */ METHODDEF(void) start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan) { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; size_t arraysize; int i; /* Install my colormap. */ cinfo->colormap = cquantize->sv_colormap; cinfo->actual_number_of_colors = cquantize->sv_actual; /* Initialize for desired dithering mode. */ switch (cinfo->dither_mode) { case JDITHER_NONE: if (cinfo->out_color_components == 3) cquantize->pub.color_quantize = color_quantize3; else cquantize->pub.color_quantize = color_quantize; break; case JDITHER_ORDERED: if (cinfo->out_color_components == 3) cquantize->pub.color_quantize = quantize3_ord_dither; else cquantize->pub.color_quantize = quantize_ord_dither; cquantize->row_index = 0; /* initialize state for ordered dither */ /* If user changed to ordered dither from another mode, * we must recreate the color index table with padding. * This will cost extra space, but probably isn't very likely. */ if (! cquantize->is_padded) create_colorindex(cinfo); /* Create ordered-dither tables if we didn't already. */ if (cquantize->odither[0] == NULL) create_odither_tables(cinfo); break; case JDITHER_FS: cquantize->pub.color_quantize = quantize_fs_dither; cquantize->on_odd_row = FALSE; /* initialize state for F-S dither */ /* Allocate Floyd-Steinberg workspace if didn't already. */ if (cquantize->fserrors[0] == NULL) alloc_fs_workspace(cinfo); /* Initialize the propagated errors to zero. */ arraysize = (size_t) ((cinfo->output_width + 2) * SIZEOF(FSERROR)); for (i = 0; i < cinfo->out_color_components; i++) jzero_far((void FAR *) cquantize->fserrors[i], arraysize); break; default: ERREXIT(cinfo, JERR_NOT_COMPILED); break; } } /* * Finish up at the end of the pass. */ METHODDEF(void) finish_pass_1_quant (j_decompress_ptr cinfo) { /* no work in 1-pass case */ } /* * Switch to a new external colormap between output passes. * Shouldn't get to this module! */ METHODDEF(void) new_color_map_1_quant (j_decompress_ptr cinfo) { ERREXIT(cinfo, JERR_MODE_CHANGE); } /* * Module initialization routine for 1-pass color quantization. */ GLOBAL(void) jinit_1pass_quantizer (j_decompress_ptr cinfo) { my_cquantize_ptr cquantize; cquantize = (my_cquantize_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_cquantizer)); cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize; cquantize->pub.start_pass = start_pass_1_quant; cquantize->pub.finish_pass = finish_pass_1_quant; cquantize->pub.new_color_map = new_color_map_1_quant; cquantize->fserrors[0] = NULL; /* Flag FS workspace not allocated */ cquantize->odither[0] = NULL; /* Also flag odither arrays not allocated */ /* Make sure my internal arrays won't overflow */ if (cinfo->out_color_components > MAX_Q_COMPS) ERREXIT1(cinfo, JERR_QUANT_COMPONENTS, MAX_Q_COMPS); /* Make sure colormap indexes can be represented by JSAMPLEs */ if (cinfo->desired_number_of_colors > (MAXJSAMPLE+1)) ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXJSAMPLE+1); /* Create the colormap and color index table. */ create_colormap(cinfo); create_colorindex(cinfo); /* Allocate Floyd-Steinberg workspace now if requested. * We do this now since it is FAR storage and may affect the memory * manager's space calculations. If the user changes to FS dither * mode in a later pass, we will allocate the space then, and will * possibly overrun the max_memory_to_use setting. */ if (cinfo->dither_mode == JDITHER_FS) alloc_fs_workspace(cinfo); } #endif /* QUANT_1PASS_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/testprog.jpg0000755000175000017500000001302707535143454015213 0ustar ÿØÿàJFIFÿÛC    $.' ",#(7),01444'9=82<.342ÿÛC  2!!22222222222222222222222222222222222222222222222222ÿ•ã"ÿÄÿÄÿÚ òÓ3bÂÎÌÕÎ×=2§Vž}óêê.v—¤© y¤GiÝV­¥<ÂëÅn ;«³›éh|SŸ$Ai‚fÂ)]1Ži¹vF›E²6Yè ×KÙ)zWT©´1ûy®^x½ÁçåKÌh¯~­ËÇ^.ï/7œËZ¶::|¾ÛŒüÏs‹¥|kõ³ò× z%ÙCKó÷VÎ @è/ÓiÐæzžt´-ÃKÑô|¯¬·†œžÅAx'pËóq(½2ãÒ§/wfLË>gº…W!ªFVƒuôáå=%¥)ëòú$h®þm«é|MçÀô×ù½;vÏ8^žXNºlÑÓ9Û»Ho3›dñ{8G„¤Ì ½‘:ÙsnÔ¨+0):s^Sg'oü»9úeàjl™6¬B̓w7SÓ¡ÐdzÐ[j¯š®‡>ï?»o5Ö™)f evcòoXN­@ºñkuÇ…»•ñ¢érJ;€¦$¼ôôĆÔãÃy›§/O43K»5­aš¢PÂ۱Ζآ±khUnMwÑcɹšòŸ=;þÐ(v3ÊtŠS é$¬êt=/Ëèú'€J[o¤½¾N-¢]ÔçÕ•¹b£ÁY€#}Y³·>Š«c½Àì ½sÙ4ÎsÊž¨Ƭڈ÷N¬ÂŽ7K ¬¶ƒ <µ¿1Ïïxèó˯1Dr²[¥Ï‹ %EŠqvvu˜ÙFÊÛÌlÞßc=@&`01²çBmz|°º‚†d ŒZ¯<oÿÄ* !1"23AB#04ÿÚþ‹—¨­. 2FóßÈQŸ7¸?®â˜3XÜLbæLc†D®/Ýà2¤Æ§0Pœ¥J•*VÕ*VÕh;ô{mÄL}¡ðØîeÃÆVÚu!Õç+™Ç¿Euª*¨©çn"}Q.ÈœŒ=áÂ!Á§n+¦yþ%MBq<6`À2.Mø™NÜLEØJéîï6aüzJ|4 Lºq•ŽY]„Ñ™s. ó&˜ÅÃD° ÂVüŒó¿ëU9v Ú»TâHôܤ´«ˆ*³+m;ñƒ$lõ1a?7ràÚ¡ÜÅL=¶^àü‰>œ¡26dX5"ÎIï¯N&Œ>5Pøý¨Eµ\öÀRgn~[»Pšca¼3ñˆXÀ°ˆ“ž[ŒF±c©MDƒ Q{y¬¥O¤33ObÇ°ˆ¿ÌÒýÜ2žéâåÂÔŸ!²%Anp¢¬É‘B¶@\ã "ʨ¯ÄrøçÜÞÂÚåmˆþš§ý¹?5ò[ÒÊ¿$‘µ£%àÜWMâ%}$ó™±#¼(ðò)äµÅÅ©óÇcEt¹Ëª¨Õ¤[y ¹=4üœ.rgö{¼.>Kj—ø9pVþ ­Šäâ÷Þ­X#˜¼ ¥Éê6J ›0qž –N²{*Ùû»:Neƒn ‰dß·¼¼“ž¬XÝ#¨¿ÕžáéžÎ“ÙÉ’1y'~Þ!v+×Á;%.4—nEd£á”õÓð]îÓ&K'ž’ñ¦4}•Û(x%tdnˆro¹"=dGÛÿÄ! 1!ABQÿÚ?éD¢QE_sÅ(Æ씓7x²Æðæ‹- › › 6kEã…'/¤¸áÉ }'8ÿ\^"Ë#àÙó–®ÇÌ’¶NnnÞR++ T)Y«Ç ús?šE‹CÂX±‘÷ ^ŸÈ*²Ž¶rr$‰±¾´A Ò%ÚebJ(DhäëX”?Ì.”Q5eazHK÷šµÚŠ/ Òbó ~‚óÿÄ* !01"AQa@#2bqr‘ÿÚ?ûÒn Ÿ¦*ìv5oÍY+4ÙåG•–Ál…ùW<©‡‹°²…'c-›zû6ðº–ØqàÜc²4¹Ú!x³*¡éK–›æÈPlÏ-ž\´4¶KD£›§L…†/–’ áuByY°†Ùƒþ+É^–Vö¦†”!ÊɼÕéµYÍ‘wêÝýÖ‘ÉB‡Ÿ •ÓþÛ %uF¤Ú>*z»•$ þ×7êð§»r¹Û’¦4…ŽTÝeFa½ïgtÈF…g•?MKMbÖ6 ‚P€úÔ6šÄ©Tyبî„.šz*]:jQòSÎXÀ¾EÁæmGñ²AÎÆÿÄ"!1AQa q‘¡±ÿÚ?!L¥/Á.ûb¡à£|Qt+Žj‚q(r“b|o\'Ë—FÊ%+ƒ=‡²”˜¢Q B„=EÑ<Œ¾)Á' aÚišÃux˜½é‘Z±ÍQHŒNeƒ}‹0òbb ćª+”…]ÁO!Vý{+¿ðÉ7ô‚m¬"áØÄÐZ(pÙB8݆6,ÇH— “…þ±$COØõ°­›ll¾1ý3i‘•â…á?ÁM< 9îøѱ°Ѧ6pÔÊ ŸV‹ƒ?ãÑäë\T5Jø£B¼^>˜ÎÏ ùoŽk…±ø`‹ÇCª´*ݾ.(oÀ_êL-a­Ðæ3Ø•p—i×”?wþåöh>â $ï‹áD‹¤'äßõ‰ ¦HÅ®>(e¼kø3Í^œ켬¦d„æöhdó½„Bpf4Pl6N‡Ž0™š…R×ãVáè@tlPSb…r†æh™„ŒhÉÿÚ Ü猿¡%á×pó[|·‹ Çž#å;;/±9ëKËZ1q =AN-‡}zW=Ì4QÏ×õ–H<[ÄmºýÒÂ_6Vpݵ ÄÈSÃàÃNç-w4ÿ6lˆ Y?~,ÍOaçß…ÿ À|€?ÿÄ#!1AQa q‘¡±ðÿÚ?L¥ð†t·^Ë!È´e¼C"ú%¼0D£B ØÒ¿ö%J5˜ýˆ(´Q0MâÏÉ·¥ô9¸Ž†Q R{"šÅ°ç®”u‹pÒ}‚²ñ‰¿˜' Ïpu®Yª‡³d™F»ö d^‡ìðBFëRr_À¦ßÈbDk^Má2zW±‰K…€Ðé-I!"„„ïø14¥r :9ˆÛÿ¡d›6›ô,%„`¢¼ÌC˜ß…ô_Ygè:¸;xO†lU¯ ˜fGCZÏaâ¾=!|m©! (†°‰Rcé‡9à…øx…Â)¾ë> UŒkò)Áo˜EáÎ x£¡tô>Œß|ßÏÿÄ!1QAaqÿÚ?K,²gí+b½L;Æ9ÍuÍÒíÀ1:“òþð¦ÅoȽ¾BbÝ°1?žÝ@1l³1o˜~ÙJÞ¤ô°8o "œuYY×Égvgwõ˜±Ó²‹f<9fÚÇj}½ v0zBzÎ¥ÀG-öµ v –=¿FѲÖ::½XºÇì6Ü-ãS¡½öõjHܨ{ÜQáÝùƒ{lå!Üâ_¬Ky–G݃Ë'\Ç„²Û·þ㢗\òêð/(ctâ}¡Œù-;¼qíxqÿÄ'!1AQaq‘¡Ñ±Á áðñÿÚ?ô;ÊŘ€JÈ‹8ÌEP©Ü4cè–MŒ(§L$eEX™\D(2ÂY«gpø¼¤¬¨Œl—0ƒs&á‚RÃ1^ñ*9ú 2Š`ÅÌ!šˆ±óQõèj &ˆŠërŒÊÂRæ™%KBFëÒ —¹dÄ6 Š§ÄµPLQV4©gRêíibCFIà•À¦¦]ŒUV§Á#Òw óêg:×g sÀSLÙP#k£† U€Ì·.ÆyælSúŽ—¼*¿qëamkõ”N^z!¥Œ°JQÛ†\§îA¦úD¦4âžIIr0,}ú–ì^AJ~#Ûu¨D0Ì·œ-§Ó6\|6±DÔ鉓PGÌ5)Ù]„CXºM±Ú°@Itð—)<¯ê #C\#vC66˜ãÄjèÂ÷# ÔŠ¢7Xy¿,ä[|ÄÛD¦»†iõ`TÃä™G¡åQôU9e_h#U€ù)Œ« 6&FÈ8q¥U­1é 6ÖÙNh¹™|_‹†rê®ñÄ¢;`…•‘°©X¬ÝÆ/´¤“E'¾(“'ØÌA­w gˆJ\Ë…yï 2Ëf ±Z=à×tqsþ¢à,²w›Ç_êòaúF`ß´¼^£Ü)ãPEV–Z«øŒn_àýC,r=â ~ƒUY€Ú8˓̸B%YˆÔ6ÑQ]@ªÁÎx‚ˆæ0%´Çì&€ñ(è•J·¯¦Gù˜äåÄlɸ|ÇWã\}‹!§ïú‰×Hå²T½Õ–÷„¦í‰f¸X–ÆT|Ì<ö"7猨0}ç*c^Šˆ „¯ˆWR¬<É·Á¯‘¨‘­qì©]>!b‚‘‹”oŸŽ¡4¥8ÅD¥Ÿ‹Ã˜£<¬pçñ÷¨€z— ǼÒ¤)Ï,© ††PrÛˆ$[cG-?ï™ân­ýÜÀœ.Ü¢³᛹d+[ÜA­XIW*êc˜V•ó6àð¢­Ë¨=ˆ±u½c2Ô™Bð¾&nã«Llåâê,•Ù'þÊFX«F=mmŠE4RìÙy¹NNcÏ0ÂF¬,_.?pÕ42¯P‘mqíĪ¶Iå„+ðaFR÷5[—–5”ü1Ð,$†AÜ2‹!¦!HEÿ¨²8Xû=KƒZ$½˜tÊÓ8jó¨¯x—Ëàšg/Ôè7 n‹ƒþî5×/ûB!Sàˆ¡äËóB(™Ü¤ÄJÈ¥A%Ê„° qFY]Ðp"µ¶Ǧ5<ÕIç˜"­~ÑÕ¬šZ¡²š;#Ï?±2¹Ì0GžcXáy{[–³<£r78¿¸Žâ—ÒDD¦W(ÐN~QÓˆ ”ûž($ ±¦^Ž¥ÂÔô ðR‹s×æ]ž•O",ŽL'¶¥dDZöØ(z•r„·ÝôŠV\¤}ýÁ¥_€Æ‹·¹÷Ù…€A§kD{*ïÒ¥J†ät‚ Ô°ú §*7ù´rn_Qi:ÍÛ–^í°Ä½Ä˜Šÿ‰J¬ùŽZ¹’-€æ`h¢]n2¬·Ó`+À„Ó¨¥³‚,¿ï¡þÖŸ€EQ²,˶4ÄsWšÀ`¶ÿÄÉ.¢æ`®;Žâú-Dz{ä [-Ž‡9Œr¦fha^%™pÐ:¥yõ \KóS˜¡…Ž¥¸ê4*°jTÊñ¥w篈5ß“±ä—ŒÄ`í›F(DeÄE´ÚÁ]òý7Ëí¶(Àð[‹3¾å«tD!«õ'8MJh­”"ÔÃvŽ½·Ä=óËKØñ-&hHþu –µ¸sâj$>žb˜uÁö§¸Ë›G0䊵 )¦_#”ŽÛ!ŸBfuw $¬D%ÈHdÿQs-²,Û|þ•¼+;éýÊý:3†R#³ÂǨq¤`ö—Ìs>XøʼDÅâ(ÍdzŽ Z`€ÔEêˆî¦ q¥š˜Å¡U`P‹EÁµ&ùæqZU“´qhp†íÛSE¥´ßˆ3NI°5+0fTÈA§Qm'P¢êŠüÏÿÙPapyrus3/JpegDir/JpgLossy/JPEGTRAN0000755000175000017500000051513407535143454014005 0ustar ELF Ä4•ü4 (44  Ô$$$$¬D%œ%œ¨/usr/lib/ld.so.1—œI‰GH[a,o!<:g0jO6*(ruŒ/U|f;8Zk-tˆ`sTw$”Xš™}?%M]xQ>S‚=z˜~y\4b2^’‡‹P…•“q—‘„D–d›3ƒ #)&1EB.'K7W@Yc_9+NChA5iJFpe{RVnlv€†LŽ"ŠmÔè¼|<\€ Äÿ´ ÿÐ ÿè $ $$ %œ&D&L&T&\'°rd`#,lœ: ÄtAh^ñÔàqhô ˆ%,Žž8à¦'ð¯+H´C´(Áʸ¼Ì <ÝsĘñô,@  ü¸BŒ&*@!+ýHA$ Wì|jóÜ$z'ø ‚Ž°Xš%Œ ¤˜°$T·$`¼ÌX@ÊøâÍœ4ò}°Ìü$ÌËtL*%\1%D9xÈQwtàct\`yÿ´ %†$äŒ% ’||4¤”¤X¸%8½Œ Òƒ°4çÍÐ(ñ>ä$„6pýdH6$´=$œD%PK~|0]xèq%œzè<‘¾dŒ¨ÑL¸¼ÈÓ*@ÙóŒ$évXý©à\xÌ'ü”?o Ä\þ,(n€@ÜŒ?褟$l¥st¼̘PÆ'ð!ÎÑ ¼ÝÌ Lóôl%h äô,/ËÀLFÕd°^ý¬€v‘¬äˆ%t~¬Ì¡ó`,°'°·$$ Ñ$×$ðÞyTÈøh” “$È`X<´ÀO$ Vÿè cð00ty‰%¦v¼º'ø !Á}8xÙ/ÐPÞ$Øäôˆò$ü÷$¨9°T$ÀCŒ(#%€*X$A¤HRÿÐ Xó°,gzd|Ìè´Ž˜£…临$x¼ (@ jtransform_execute_transformationjinit_input_controller_startjtransform_request_workspacejinit_huff_encoderjpeg_std_message_tablefreadjpeg_simple_progression_environ_endwrite_stdoutjpeg_abortjpeg_set_qualityjcopy_markers_setupjpeg_open_backing_storejinit_phuff_encoderkeymatch_iob__register_frame_info_GLOBAL_OFFSET_TABLE_jpeg_consume_inputjpeg_free_large__ctypejpeg_set_linear_qualityabortjpeg_stdio_destatexitexitjdiv_round_upjpeg_destroy_decompressjcopy_block_rowjpeg_write_m_headerjpeg_stdio_srctolowerjpeg_destroymallocsprintfjpeg_write_coefficientsjpeg_save_markersjcopy_markers_execute_initfwrite.umul.uremjpeg_write_markerjpeg_set_colorspace.remjpeg_add_quant_tablejpeg_fill_bit_bufferjzero_farset_quant_slotssscanfread_quant_tables__register_frame_info_tableungetcfclosegetenvjpeg_write_m_bytejpeg_abort_compress_DYNAMICjpeg_gen_optimal_tablejinit_c_master_controljinit_marker_writerjpeg_finish_decompress__iobjpeg_free_smalljinit_marker_readerjinit_phuff_decoderjpeg_destroy_compressjpeg_has_multiple_scansjtransform_adjust_parameters__frame_state_forjpeg_copy_critical_parametersset_sample_factors_exitjpeg_resync_to_restartjround_upenvironjpeg_std_errorjpeg_alloc_huff_tablejpeg_mem_initfreejpeg_CreateDecompressjpeg_mem_availablejpeg_alloc_quant_tablejpeg_make_c_derived_tbl__deregister_frame_infojpeg_set_defaultsstrcmpjpeg_write_tablesjpeg_get_small_edata_PROCEDURE_LINKAGE_TABLE_fopenmemsetjpeg_set_marker_processorjpeg_input_completejpeg_default_colorspacejinit_d_coef_controllerjinit_huff_decoder_etext_lib_versionjinit_memory_mgrjpeg_suppress_tablesfflushjpeg_abort_decompressjpeg_CreateCompress_ctypejpeg_make_d_derived_tblmain.udivjpeg_mem_term.div__filbufread_scan_scriptmemcpyread_stdinstrlenjpeg_read_coefficientsjpeg_read_header_finijpeg_get_largejpeg_finish_compressjcopy_sample_rowsjpeg_quality_scalingjpeg_huff_decodefprintfjpeg_natural_orderlibc.so.1SYSVABI_1.3libc.so.1Ï7̳Ù'ð$*\'ø2$T6$`7$lf$xš$„O$y$œS$¨$´R$À$Ì=$ØŠ$äF$ðz$üŒ%E%„% G%,"%8J%D@%PT%\?%hm%tt%€‘%Œ4¼ à @¢ Dœ#  €€@ÀÝ¿#Ð@ÀÙ@w¯’•, ” ”@  –ãðÔ"À@¬@ÀÎ@ÀÏã¿@/À®âÈ®À ÒÀÐ@Ѐ¢ €  Ð Ð$Ð?üŸÂÐЀ¢ 2¿ÿøÐ @wÐÀÇàèã¿Çàèã¿@/À®â@®À ÐÀ’` @vÍÒÀ Çàèã¿Çàèã¿  b(¿’ãðÔ£È@À– b(À’ @À b(À’ @ÀŠ b(À’ @@À„ b(À’ €@À~ b(À’ ¸@Àx b(À’ è@Àr b(À’¡8@Àl b(À’¡h@Àf b(À’¡@À` b(À’¡È@ÀZ b(À’¢@ÀT b(À’¢X@ÀN b(À’¢€@ÀH b(À’¢°@ÀB b(À’¢è@À< b(À’£@À6 b(À’£P@À0 b(À’£ˆ@À* b(À’£¸@À$ b(À’£è@À b(Á’ @À @ÀÇàèã¿ð' D Ò#Ô€¢`€  Ò#ÔРD€¢@€€ Ò DÒ"#Ô€   b(Á’à@Ô£È@¿÷ÿÿXÇàèã¿pð' Dò' Hô' Lö' Pø' TÀ'¿àÀ'¿ä À"#Ì ’ Ò"#Ð À"#Ô ’ ”#Ô@ À" ’ ”#Ô@ À"РDÒÀ"`h Ð'¿ìпìÒ H€¢ €€†Ð¿ì’‘*`Ò L ÒÒ'¿èпèÒ •*`‘: €¢ -€ пìÒ P€¢ € À"#Ì€j€mÐ¿è’ Ò'¿èпèÁ’ x” @1€¢ €  b(Á’àˆÔ£È@¿¡ @¿˜€OпèÁ’ ¸” @€¢ €HÐ¿ì’  Ð'¿ìÒ H€¢ €ÿþìп쒑*`Ô L’ Ð@Á’ À” @€¢ € À"#Ѐ*п쒑*`Ô L’ Ð@Á’ È” @ñ€¢ € ’ Ò"#Ѐп쒑*`Ô L’ Ð@Á’ Ø” @Þ€¢ € ’ Ò"#Ѐÿþ²€Ð¿èÁ’ à” @Ì€¢ € пèÁ’ è” @À¢ €€ Ò"H€¢`€ b(Á’ ðÁ”á(Á–!8@¿* ’ Ò""HÒ DÐ@Ò DÐ@Ò DÔ@Ò h”`Ô" h€ÏпèÁ’¡`” @›€¢ €6Ð¿ì’  Ð'¿ìÒ H€¢ €ÿþlп쒑*`Ô L’ Ð@Á’¡h” @ƒ€¢ € ÿþç€Ð¿ì’‘*`Ô L’ Ð@Á’¡x” @p€¢ € ÿþÔ€ÿþD€’пèÁ’¡ˆ” @^€¢ € пèÁ’¡˜” @U€¢ €€  ’ ”#Ô@ ’ Ò"€vпèÁ’¡¨” @B€¢ €A xÐ/¿ÛÐ¿ì’  Ð'¿ìÒ H€¢ €ÿþп쒑*`Ò L ”¿Ü–¿ÛÐÁ’!¸@¾¥€¢ €ÿþпۓ* ‘:`€¢ m€ пۓ* ‘:`€¢ M€€ пܔ“* ’"@•*`”€‘* Ð'¿ÜÒ DÐ`Ò¿Ü– •*à”"€ —* –À “*àÒ" ,€.пèÁ’¡À” @ú€¢ € пèÁ’¡Ð” @ñ€¢ €€Ð D’ Ò" ¸€Ð¿èÁ’¡à” @ဢ €Ð¿ì’  Ð'¿ìÒ H€¢ €ÿý² Ò¿ì” “* Ô L’@ Ô@Ô"#Ì€øпèÁ’¡è” @Ä€¢ € Ð'¿ä€ëпèÁ’¡ø” @·€¢ €G xÐ/¿ÓÐ¿ì’  Ð'¿ìÒ H€¢ €ÿý†Ð¿ì’‘*`Ò L ”¿Ô–¿ÓÐÁ’!¸@¾€¢ €ÿýuпԀ¢ € пÔ?’£ÿ€¢ €€ÿýgпӓ* ‘:`€¢ b€ пӓ* ‘:`€¢ B€€ РDÒ¿ÔÒ" ÈРDÀ" ̀РDÒ¿ÔÒ" ̀пèÁ’¢” @i€¢ €IÐ¿ì’  Ð'¿ìÒ H€¢ €ÿý:п쒑*`Ô L’ Ð@Á’¢” @Q€¢ € ÿýµ€*п쒑*`Ô L’ Ð@Á’¢” @>€¢ € ÿý¢€Ð¿ì’‘*`Ô L’ Ð@Á’¢” @+€¢ € ÿý€ÿüÿ€MпèÁ’¢ ” @€¢ €Ð¿ì’  Ð'¿ìÒ H€¢ €ÿüêп쒑*`Ò L ÒÒ'¿à€1пèÁ’¢(” @ý€¢ € ÿýa€#пèÁ’¢8” @ € ÿýS€Ð¿èÁ’¢H” @ဢ €  ’ ”#Ô@ ’ Ò"€ÿü²Ð¿ì’ Ò'¿ì¿ýwРT€¢ €Ð¿ä€¢ €Ð D@¯Ð¿à€¢ € РDÒ¿à@…€¢ €ÿü•Ð¿ì°€Çàèã» ð' Dò' H Ò HÔ@Ô"#È Ò#È€¢`€  ÐcÈÒ •*`‘: €¢ €€ Á’¢PÒ"#È’¼  @hXÐ'¾ ’¾  ’ >”!Ð@7"’»˜ @hMÐ'¼¨’¼¨ ’ >”!x@’¼¨ Ò DÔ H– ˜ ÿýÐ'»ŒÐ¼Ð'¼ˆÐ¾$Ò¼¬Ô`,Ô" ,Ò DÿÒ»Œ€¢@€   b(Á’â`Ô£È@¼ßÿü@лŒÒ D€¢ €$лŒ’‘*`Ô H’ Ð@Á’¢€@¼ÔÐ'»ˆÐ»ˆ€¢ € лŒ’‘*`Ò H–  b(Á’"ˆÔ£ÈÖÀ@¼» @¼²€@yÐ'»ˆ Ò#Ì€¢`€ ÐcÌÁ’¢ @¼®Ð'»„л„€¢ €   b(Á’"ˆÔ£ÈÖãÌ@¼™ @¼€@aÐ'»„’¾  Ò»ˆ@;2¾  ÒcÐ@Z’¾  ’ @8M’¾   ’£Ô@ ‚’¾  @9°Ð'»”¾ ’¼¨@e¾ ’¼¨Ô»” –#Ô@6Ð'»’¼¨ Ò DÔ H– ˜ ÿürÐ'»Œ’¼¨ Ò»„@@’¼¨ Ò»@¾ ’¼¨ Ô£Ð@K¾ ’¼¨Ô»” –#Ô@Æ’¼¨ @¯’¼¨ @X’¾  @9’¾  @6Ûлˆ ’¢€¢ €Ð»ˆ@¼;л„ ’¢€¢ €Ð»„@¼2мŒÒ¼ €¢ € € @¼° €Çàèã¿ð' DÒ DРDÒ DÔ@’¿ÿ” Ô"€¢ €Ð D@¼ € Ò D`ÒÔ @   ÿ’`Ò"€¤ #€%Ò DРDÒ DÔ@’¿ÿ” Ô"€¢ €Ð D@»û € Ò D`ÒÔ @   ÿ’`Ò"€¤ €€¤?ÿ€€€¿ÿß°€Çàèã¿ð' Dò' Hô' LРDÿÿ· €¤?ÿ€Ð Là"° €@ cùÒ  `’ ÿ€¢`€€¿ÿê cùÒ  `’ ÿ€¢`€Ð Là"° €'¢?ÐРDÿÿ‘ €¢?ÿ€€ cùÒ  `’ ÿ€¢`€€ ’‘*`“* ¢ ¢Т@¿ÿåРHâ"РLà"° €Çàèã¾xð' Dò' Hô' Lö' PРHÁ’¢¨@»€Ð'¿ìп쀢 €  b(Á’¢°Ô H@»n° €kÀ'¿è’¿Ü”¿àпìÿÿ“€¢ €€Iп耢 € b(Á’¢ÐÔ H@»Uпì@»[° €OпÜÐ'¾Ø Ð'¿äп䀢 ?€€"’¿Ü”¿àпìÿÿn€¢ € b(Á’¢ðÔ H@»6пì@»<° €0п䒑*`’¾ØÔ¿ÜÔ"@Ð¿ä’ Ò'¿ä¿ÿÜ”¾ØРDÒ¿èÖ LØ P@(Ð¿è’ Ò'¿è¿ÿ±Ð¿à€¢?ÿ€ b(Á’£Ô H@»Ð¿ì@»° €Ð¿ì@»° €Çàèã¿ð' Dò' Hô' LРDÒ HÔ Lÿÿ%€¢ €° €=РLà€¤?ÿ€  cùÒ  `’ ÿ€¢`€€€Ð DÿþÇ ¿ÿí cùÒ  `’ ÿ€¢`€Ò D@ºÝ€¢?ÿ€° €  € €¤?ÿ€ €¤ ;€€¤ :€  РLà"° €Çàèã±hð' Dò' HРHÁ’¢¨@º²Ð'¿ìп쀢 €  b(Á’£0Ô H@º ° €þ±ÈÐ'¿ØÀ'¿è’¿Ü”¿àпìÿÿ—€¢ €€ºÐ¿è€¢ c€ b(Á’£XÔ H@º…пì@º‹° €àпØÒ¿ÜÒ"  Ð'¿äÐ¿à€¢ €€)п䀢 € b(Á’£€Ô H@ºiпì@ºo° €Ä’¿Ü”¿àпìÿÿ`€¢ €€nпØÒ¿ä” “*  Ò¿ÜÒ" Ð¿ä’ Ò'¿ä¿ÿÕпØÒ¿äÒ"Ð¿à€¢ :€J’¿Ü”¿àпìÿÿC€¢ €Ð¿à€¢ €€€KпØÒ¿ÜÒ" ’¿Ü”¿àпìÿÿ0€¢ €Ð¿à€¢ €€€8пØÒ¿ÜÒ" ’¿Ü”¿àпìÿÿ€¢ €Ð¿à€¢ €€€%пØÒ¿ÜÒ" ’¿Ü”¿àпìÿÿ €¢ €€Ð¿ØÒ¿ÜÒ" € пØÀ" пؒ ?Ò" пØÀ" пØÀ" Ð¿à€¢ ;€Ð¿à€¢?ÿ€ b(Á’£°Ô H@¹æпì@¹ì° €Aпؒ $Ò'¿ØÐ¿è’ Ò'¿è¿ÿ@Ð¿à€¢?ÿ€ b(Á’£Ô H@¹Íпì@¹Ó° €(п耢 €Ò DÐ`Ò¿è” —* –À •*àÖРD’ ŸÂÀÐ'¿Ø’±Èп蔗* –À•*àпØ@¹¿Ð DÒ¿ØÒ" ¬Ð DÒ¿èÒ" ¨Ð¿ì@¹­° €Çàèã¿€ð' Dò' HÀ'¿ìÀ'¿èп耢 €€kРHÒ •*`‘: €¢ €S ,Ð/¿ç”¿ì–¿çРHÁ’#Ø@¹‡€¢ €° €Xпç“* ‘:`€¢ ,€° €Oп쀢 €Ð¿ì€¢ €€  b(Á’£à” @¹d° €;РDÒ¿è– •*à”€ —* –À “*àÔ D@ Ò¿ìÒ" РHÒ •*`‘: €¢ € HÒÔ @—* •:à’`Ò"€¢ ,€€€¿ÿë€Ð DÒ¿è– •*à”€ —* –À “*àÔ D@ Ò¿ìÒ" Ð¿è’ Ò'¿è¿ÿ“° €Çàèã¿€ð' Dò' HÀ'¿ìп쀢 €€œÐ HÒ •*`‘: €¢ €x ,Ð/¿â”¿è–¿ã˜¿äš¿âРHÂ’ @¹ €¢ €° €‡Ð¿ã“* ‘:`€¢ x€ пã“* ‘:`€¢ X€ €Ð¿â“* ‘:`€¢ ,€€° €nп耢 €Ð¿è€¢ € п䀢 €Ð¿ä€¢ €€  b(Â’  @¸Ó° €SРDÒ¿ì– •*à”€ —* –À “*àÔ D@ Ò¿èÒ" РDÒ¿ì– •*à”€ —* –À “*àÔ D@ Ò¿äÒ" РHÒ •*`‘: €¢ € HÒÔ @—* •:à’`Ò"€¢ ,€€€¿ÿë€Ð DÒ¿ì– •*à”€ —* –À “*àÔ D@ ’ Ò" РDÒ¿ì– •*à”€ —* –À “*àÔ D@ ’ Ò" Ð¿ì’ Ò'¿ì¿ÿb° €Çàèã¿ð' Dò' Hô' L¤ РDÒ •*`¡: ’ Ð' D€¢`€€% HÒÔ @—* £:à”’`Ò"€¢ €° €! cùÒ  `’ ÿ€¢`€@¸h €¤€° €¤ ¿ÿÓРL€¤€€° €° €Çàè㿈 bÐ'¿ìп찀Çàè㿈 bÐ'¿ìп찀Çàèã¿`ð' Dò' Hô' LРHÒ HÔ`è’ •*`Ð ’ @¸4Ð'¿ìÀ'¿ÜРHÒ¿ÜÐ <€¢@€€¡Ð HÒ¿Ü– •*à”€ —* –À “*àÐ D’ Ò'¿ÀÒ¿ÀпìÒ`@¸Ð'¿èÀ'¿àпÀÒ¿àÐ €¢@ €€‚Ò DÐ`Ò¿Ü” “* Ô L’@ Ö¿ÀÚ Ð DÒ@Ô¿àÖà ˜ ŸÃ@Ð'¿ÐÀ'¿ÔпÀÒ¿ÔÐ €¢@€€aÀ'¿äп䒑*`ҿ耢 €€RпԒ‘*`Ò¿Ð Ò¿ä” “* Ð’ Ò'¿ÌпԒ‘*`Ò¿Ð Ò¿èÔ¿ä’"@ ” “* ”€Ð’ Ò'¿ÈÀ'¿Øп؀¢ ?€€-пÌÒÒ7¿ÆпÈÒÒ7¿Ä¿ÌÒÔ¿ÄÔ2@’`Ò"¿ÈÒÔ¿ÆÔ2@’`Ò"пÌÒÒ7¿ÆпÈÒÒ7¿Ä¿ÌÒÔ¿Ä– Ö2@’`Ò"¿ÈÒÔ¿Æ– Ö2@’`Ò"пؒ Ò'¿Ø¿ÿÑÐ¿ä’ Ò'¿ä¿ÿ©Ð¿Ô’ Ò'¿Ô¿ÿ›Ð¿ÀÒ¿àÐ ’@Ò'¿à¿ÿzпܒ Ò'¿Ü¿ÿ[Çàèã¿Pð' Dò' Hô' Lö' PРHÒ HÔ`ì’ •*`Ð ’ @·{Ð'¿ìÀ'¿ÜРHÒ¿ÜÐ <€¢@€€òРHÒ¿Ü– •*à”€ —* –À “*àÐ D’ Ò'¿´Ò¿´Ð¿ìÒ` @·dÐ'¿èÀ'¿àп´Ò¿àÐ €¢@ €€ÓÒ DÐ`Ò¿Ü” “* Ô P’@ Ö¿´Ú РDÒ@Ô¿àÖà ˜ ŸÃ@Ð'¿Èпàҿ耢 €Ò DÐ`Ò¿Ü” “* Ô L’@ Ô¿èÖ¿à”"€ Ö¿´Øà ”"€ Ö¿´Ú РDÒ@Öà ˜ ŸÃ@Ð'¿Ì€Ò DÐ`Ò¿Ü” “* Ô L’@ Ö¿´Ú РDÒ@Ô¿àÖà ˜ ŸÃ@Ð'¿ÌÀ'¿Ðп´Ò¿ÐÐ €¢@€€ƒÐ¿àҿ耢 €iпВ‘*`Ò¿È ÒÒ'¿Àп´Ò Ô¿Ð"@ ’‘*`Ò¿Ì Ò?üÒ'¿ÄÀ'¿äп´Ò¿äÐ €¢@ €€Mп䒑*`Ò¿À@Ð'¿¸Ð¿ä’‘*`Ò¿Ä@Ð'¿¼À'¿Øп؀¢ €€5À'¿ÔпԀ¢ €€¿¸Ò”¿¼Ö€ØÀØ2@–àÖ"€’`Ò"пԒ Ò'¿Ô¿ÿíÀ'¿ÔпԀ¢ €€¿¸Ò”¿¼Ö€ØÀš Ú2@–àÖ"€’`Ò"пԒ Ò'¿Ô¿ÿìпؒ Ò'¿Ø¿ÿÉÐ¿ä’ Ò'¿ä¿ÿ¯€Ð¿Ð’‘*`Ò¿Ì Ò¿Ð” “* Ô¿È’@ Ô¿´ÐÒ@Ô @`ÃпВ Ò'¿Ð¿ÿyп´Ò¿àÐ ’@Ò'¿à¿ÿ)пܒ Ò'¿Ü¿ÿ Çàèã¿`ð' Dò' Hô' Lö' PÀ'¿äРHÒ¿äÐ <€¢@€€·Ð HÒ¿ä– •*à”€ —* –À “*àÐ D’ Ò'¿ÀÀ'¿èпÀÒ¿èÐ €¢@ €€žÒ DÐ`Ò¿ä” “* Ô P’@ Ö¿ÀÚ Ð DÒ@Ô¿èÖà ˜ ŸÃ@Ð'¿ÌÀ'¿ÔпÀÒ¿ÔÐ €¢@€€}À'¿ìпÀÒ¿ìÐ €¢@ €€oÒ DÐ`Ò¿ä” “* Ô L’@ Ö¿ÀÚ Ð DÒ@Ô¿ìÖà˜ ŸÃ@Ð'¿ÐÀ'¿ØпÀÒ¿ØÐ €¢@€€Nпؒ‘*`Ò¿Ð Ò¿èÔ¿Ô’@ ” “* Ð’ Ò'¿ÈпԒ‘*`Ò¿Ì Ò¿ìÔ¿Ø’@ ” “* Ð’ Ò'¿ÄÀ'¿àÐ¿à€¢ €€(À'¿Üп܀¢ €€Ð¿Ü’‘*`Ò¿à ’‘*`Ò¿Ä Ò¿à” “* Ô¿Ü’@ ” “* Ô¿È’@ Ô@Ô2пܒ Ò'¿Ü¿ÿãÐ¿à’ Ò'¿à¿ÿÖпؒ Ò'¿Ø¿ÿ®Ð¿ÀÒ¿ìÐ ’@Ò'¿ì¿ÿпԒ Ò'¿Ô¿ÿпÀÒ¿èÐ ’@Ò'¿è¿ÿ^Ð¿ä’ Ò'¿ä¿ÿEÇàèã¿Xð' Dò' Hô' Lö' PРHÒ HÔ`è’ •*`Ð ’ @µ¬Ð'¿ìÀ'¿ÜРHÒ¿ÜÐ <€¢@€€$РHÒ¿Ü– •*à”€ —* –À “*àÐ D’ Ò'¿¸Ò¿¸Ð¿ìÒ`@µ•Ð'¿èÀ'¿àп¸Ò¿àÐ €¢@ €€Ò DÐ`Ò¿Ü” “* Ô P’@ Ö¿¸Ú РDÒ@Ô¿àÖà ˜ ŸÃ@Ð'¿ÄÀ'¿Ìп¸Ò¿ÌÐ €¢@€€äÀ'¿äп¸Ò¿äÐ €¢@ €€ÖÒ DÐ`Ò¿Ü” “* Ô L’@ Ö¿¸Ú РDÒ@Ô¿äÖà˜ ŸÃ@Ð'¿ÈÀ'¿Ðп¸Ò¿ÐÐ €¢@€€µÐ¿Ð’‘*`Ò¿È Ò¿àÔ¿Ì’@ ” “* Ð’ Ò'¿Àпäҿ耢 €dп̒‘*`Ò¿Ä Ò¿èÔ¿ä’"@ Ô¿Ð’"@ ” “* ”€Ð’ Ò'¿¼À'¿Øп؀¢ €€KÀ'¿ÔпԀ¢ €€Ð¿Ô’‘*`Ò¿Ø ’‘*`Ò¿¼ Ò¿Ø” “* Ô¿Ô’@ ” “* Ô¿À’@ Ô@Ô2пԒ Ò'¿Ô¿ÿãпؒ Ò'¿ØÀ'¿ÔпԀ¢ €€Ð¿Ô’‘*`Ò¿Ø ’‘*`Ò¿¼ Ò¿Ø” “* Ô¿Ô’@ ” “* Ô¿À’@ Ô@’ Ò2пԒ Ò'¿Ô¿ÿâпؒ Ò'¿Ø¿ÿ³€<п̒‘*`Ò¿Ä Ò¿äÔ¿Ð’@ ” “* Ð’ Ò'¿¼À'¿Øп؀¢ €€(À'¿ÔпԀ¢ €€Ð¿Ô’‘*`Ò¿Ø ’‘*`Ò¿¼ Ò¿Ø” “* Ô¿Ô’@ ” “* Ô¿À’@ Ô@Ô2пԒ Ò'¿Ô¿ÿãпؒ Ò'¿Ø¿ÿÖпВ Ò'¿Ð¿ÿGп¸Ò¿äÐ ’@Ò'¿ä¿ÿ&п̒ Ò'¿Ì¿ÿп¸Ò¿àÐ ’@Ò'¿à¿þ÷пܒ Ò'¿Ü¿þØÇàèã¿Xð' Dò' Hô' Lö' PРHÒ HÔ`ì’ •*`Ð ’ @´pÐ'¿ìÀ'¿ÜРHÒ¿ÜÐ <€¢@€€Ð HÒ¿Ü– •*à”€ —* –À “*àÐ D’ Ò'¿¸Ò¿¸Ð¿ìÒ` @´YÐ'¿èÀ'¿àп¸Ò¿àÐ €¢@ €€ùÒ DÐ`Ò¿Ü” “* Ô P’@ Ö¿¸Ú РDÒ@Ô¿àÖà ˜ ŸÃ@Ð'¿ÄÀ'¿Ìп¸Ò¿ÌÐ €¢@€€ØÀ'¿äп¸Ò¿äÐ €¢@ €€ÊÒ DÐ`Ò¿Ü” “* Ô L’@ Ö¿¸Ú РDÒ@Ô¿äÖà˜ ŸÃ@Ð'¿ÈÀ'¿Ðп¸Ò¿ÐÐ €¢@€€©Ð¿Ì’‘*`Ò¿Ä Ò¿äÔ¿Ð’@ ” “* Ð’ Ò'¿¼Ð¿àҿ耢 €XпВ‘*`Ò¿È Ò¿èÔ¿à’"@ Ô¿Ì’"@ ” “* ”€Ð’ Ò'¿ÀÀ'¿Øп؀¢ €€?À'¿ÔпԀ¢ €€3пԒ‘*`Ò¿Ø ’‘*`Ò¿¼ Ò¿Ø” “* Ô¿Ô’@ ” “* Ô¿À’@ Ô@Ô2пԒ Ò'¿ÔпԒ‘*`Ò¿Ø ’‘*`Ò¿¼ Ò¿Ø” “* Ô¿Ô’@ ” “* Ô¿À’@ Ô@’ Ò2пԒ Ò'¿Ô¿ÿËпؒ Ò'¿Ø¿ÿ¿€<пВ‘*`Ò¿È Ò¿àÔ¿Ì’@ ” “* Ð’ Ò'¿ÀÀ'¿Øп؀¢ €€(À'¿ÔпԀ¢ €€Ð¿Ô’‘*`Ò¿Ø ’‘*`Ò¿¼ Ò¿Ø” “* Ô¿Ô’@ ” “* Ô¿À’@ Ô@Ô2пԒ Ò'¿Ô¿ÿãпؒ Ò'¿Ø¿ÿÖпВ Ò'¿Ð¿ÿSп¸Ò¿äÐ ’@Ò'¿ä¿ÿ2п̒ Ò'¿Ì¿ÿ$п¸Ò¿àÐ ’@Ò'¿à¿ÿпܒ Ò'¿Ü¿þäÇàèã¿Hð' Dò' Hô' Lö' PРHÒ HÔ`è’ •*`Ð ’ @³@Ð'¿ìРHÒ HÔ`ì’ •*`Ð ’ @³6Ð'¿èÀ'¿ÔРHÒ¿ÔÐ <€¢@€€ÎРHÒ¿Ô– •*à”€ —* –À “*àÐ D’ Ò'¿¬Ò¿¬Ð¿ìÒ`@³Ð'¿äÒ¿¬Ð¿èÒ` @³Ð'¿àÀ'¿Øп¬Ò¿ØÐ €¢@ €€©Ò DÐ`Ò¿Ô” “* Ô P’@ Ö¿¬Ú РDÒ@Ô¿ØÖà ˜ ŸÃ@Ð'¿ÀпØÒ¿à€¢ €Ò DÐ`Ò¿Ô” “* Ô L’@ Ô¿àÖ¿Ø”"€ Ö¿¬Øà ”"€ Ö¿¬Ú РDÒ@Öà ˜ ŸÃ@Ð'¿Ä€Ò DÐ`Ò¿Ô” “* Ô L’@ Ö¿¬Ú РDÒ@Ô¿ØÖà ˜ ŸÃ@Ð'¿ÄÀ'¿Èп¬Ò¿ÈÐ €¢@€€YпØÒ¿à€¢ €ÔпȒ‘*`Ò¿À ÒÒ'¿¸Ð¿¬Ò Ô¿È"@ ’‘*`Ò¿Ä Ò?üÒ'¿¼À'¿ÜпÜҿ䀢 €€eпܒ‘*`Ò¿¸@Ð'¿°Ð¿äÒ¿Ü" ’‘*`’?€Ð¿¼’ Ò'¿´À'¿ÐпЀ¢ €€JÀ'¿Ìп̀¢ €€¿°Ò”¿´Ö€ØÀØ2@–àÖ"€’`Ò"¿°Ò”¿´Ö€ØÀš Ú2@–àÖ"€’`Ò"п̒ Ò'¿Ì¿ÿâÀ'¿Ìп̀¢ €€¿°Ò”¿´Ö€ØÀš Ú2@–àÖ"€’`Ò"¿°Ò”¿´Ö€ØÀØ2@–àÖ"€’`Ò"п̒ Ò'¿Ì¿ÿâпВ Ò'¿Ð¿ÿ´Ð¿Ü’ Ò'¿Ü¿ÿ˜Ð¿¬Ò¿ÜÐ €¢@ €€Mпܒ‘*`Ò¿¸@Ð'¿°Ð¿Ü’‘*`Ò¿¼@Ð'¿´À'¿ÐпЀ¢ €€5À'¿Ìп̀¢ €€¿°Ò”¿´Ö€ØÀØ2@–àÖ"€’`Ò"п̒ Ò'¿Ì¿ÿíÀ'¿Ìп̀¢ €€¿°Ò”¿´Ö€ØÀš Ú2@–àÖ"€’`Ò"п̒ Ò'¿Ì¿ÿìпВ Ò'¿Ð¿ÿÉпܒ Ò'¿Ü¿ÿ¯€}пȒ‘*`Ò¿À ÒÒ'¿¸Ð¿È’‘*`Ò¿Ä ÒÒ'¿¼À'¿ÜпÜҿ䀢 €€7пܒ‘*`Ò¿¸@Ð'¿°Ð¿äÒ¿Ü" ’‘*`’?€Ð¿¼’ Ò'¿´À'¿ÐпЀ¢ ?€€¿°Ò”¿´Ö€ØÀØ2@–àÖ"€’`Ò"¿°Ò”¿´Ö€ØÀš Ú2@–àÖ"€’`Ò"пВ Ò'¿Ð¿ÿâпܒ Ò'¿Ü¿ÿÆп¬Ò¿ÜÐ €¢@ €€)пܒ‘*`Ò¿¸@Ð'¿°Ð¿Ü’‘*`Ò¿¼@Ð'¿´À'¿ÐпЀ¢ ?€€¿°Ò”¿´Ö€ØÀØ2@–àÖ"€’`Ò"пВ Ò'¿Ð¿ÿíпܒ Ò'¿Ü¿ÿÓпȒ Ò'¿È¿þ£Ð¿¬Ò¿ØÐ ’@Ò'¿Ø¿þSпԒ Ò'¿Ô¿þ.Çàèã¿Pð' Dò' Hô' Lö' PРHÒ HÔ`è’ •*`Ð ’ @±PÐ'¿ìРHÒ HÔ`ì’ •*`Ð ’ @±FÐ'¿èÀ'¿ÔРHÒ¿ÔÐ <€¢@€€(РHÒ¿Ô– •*à”€ —* –À “*àÐ D’ Ò'¿°Ò¿°Ð¿ìÒ`@±/Ð'¿äÒ¿°Ð¿èÒ` @±)Ð'¿àÀ'¿Øп°Ò¿ØÐ €¢@ €€Ò DÐ`Ò¿Ô” “* Ô P’@ Ö¿°Ú РDÒ@Ô¿ØÖà ˜ ŸÃ@Ð'¿¼À'¿Äп°Ò¿ÄÐ €¢@€€âÀ'¿Üп°Ò¿ÜÐ €¢@ €€ÔÒ DÐ`Ò¿Ô” “* Ô L’@ Ö¿°Ú РDÒ@Ô¿ÜÖà˜ ŸÃ@Ð'¿ÀÀ'¿Èп°Ò¿ÈÐ €¢@€€³Ð¿ØÒ¿à€¢ €ûпȒ‘*`Ò¿À Ò¿àÔ¿Ø’"@ Ô¿Ä’"@ ” “* ”€Ð’ Ò'¿¸Ð¿Üҿ䀢 €“пĒ‘*`Ò¿¼ Ò¿äÔ¿Ü’"@ Ô¿È’"@ ” “* ”€Ð’ Ò'¿´À'¿ÐпЀ¢ €€zÀ'¿Ìп̀¢ €€3п̒‘*`Ò¿Ð ’‘*`Ò¿´ ҿД “* Ô¿Ì’@ ” “* Ô¿¸’@ Ô@Ô2п̒ Ò'¿Ìп̒‘*`Ò¿Ð ’‘*`Ò¿´ ҿД “* Ô¿Ì’@ ” “* Ô¿¸’@ Ô@’ Ò2п̒ Ò'¿Ì¿ÿËпВ Ò'¿ÐÀ'¿Ìп̀¢ €€3п̒‘*`Ò¿Ð ’‘*`Ò¿´ ҿД “* Ô¿Ì’@ ” “* Ô¿¸’@ Ô@’ Ò2п̒ Ò'¿Ìп̒‘*`Ò¿Ð ’‘*`Ò¿´ ҿД “* Ô¿Ì’@ ” “* Ô¿¸’@ Ô@Ô2п̒ Ò'¿Ì¿ÿËпВ Ò'¿Ð¿ÿ„€SпĒ‘*`Ò¿¼ Ò¿ÜÔ¿È’@ ” “* Ð’ Ò'¿´À'¿ÐпЀ¢ €€?À'¿Ìп̀¢ €€3п̒‘*`Ò¿Ð ’‘*`Ò¿´ ҿД “* Ô¿Ì’@ ” “* Ô¿¸’@ Ô@Ô2п̒ Ò'¿Ìп̒‘*`Ò¿Ð ’‘*`Ò¿´ ҿД “* Ô¿Ì’@ ” “* Ô¿¸’@ Ô@’ Ò2п̒ Ò'¿Ì¿ÿËпВ Ò'¿Ð¿ÿ¿€°Ð¿È’‘*`Ò¿À Ò¿ØÔ¿Ä’@ ” “* Ð’ Ò'¿¸Ð¿Üҿ䀢 €dпĒ‘*`Ò¿¼ Ò¿äÔ¿Ü’"@ Ô¿È’"@ ” “* ”€Ð’ Ò'¿´À'¿ÐпЀ¢ €€KÀ'¿Ìп̀¢ €€Ð¿Ì’‘*`Ò¿Ð ’‘*`Ò¿´ ҿД “* Ô¿Ì’@ ” “* Ô¿¸’@ Ô@Ô2п̒ Ò'¿Ì¿ÿãпВ Ò'¿ÐÀ'¿Ìп̀¢ €€Ð¿Ì’‘*`Ò¿Ð ’‘*`Ò¿´ ҿД “* Ô¿Ì’@ ” “* Ô¿¸’@ Ô@’ Ò2п̒ Ò'¿Ì¿ÿâпВ Ò'¿Ð¿ÿ³€<пĒ‘*`Ò¿¼ Ò¿ÜÔ¿È’@ ” “* Ð’ Ò'¿´À'¿ÐпЀ¢ €€(À'¿Ìп̀¢ €€Ð¿Ì’‘*`Ò¿Ð ’‘*`Ò¿´ ҿД “* Ô¿Ì’@ ” “* Ô¿¸’@ Ô@Ô2п̒ Ò'¿Ì¿ÿãпВ Ò'¿Ð¿ÿÖпȒ Ò'¿È¿þIп°Ò¿ÜÐ ’@Ò'¿Ü¿þ(пĒ Ò'¿Ä¿þп°Ò¿ØÐ ’@Ò'¿Ø¿ýùпԒ Ò'¿Ô¿ýÔÇàèã¿€ð' Dò' HÀ'¿ìРHÒ €¢`€Ð DÒ (€¢`€ РDÒ $€¢`€Ð H’ Ò" €Ð HÒ DÔ`$Ô" РHÒ€¢`€ Ð’‘*`Z’¡4Ð ÂiTiTi\jtjtjti\jt€ŽÒ DÐ`Ò HÔ` ’ •*`ÖРD’ ŸÂÀÐ'¿ìÀ'¿äРHÒ¿äÐ €¢@€€1РDÒ¿ä– •*à”€ —* –À “*àÐ Ø’ Ò'¿èРDà пèÒ¿èÐ Ò`@X©¢Ð¿èÒ¿èÐ Ò` @X¢˜Ú¿èÄ Ð D’ ” –Ú` ŸÀ€Ò¿ä” “* Ô¿ì’@ Ð"@Ð¿ä’ Ò'¿ä¿ÿË€HÒ DÐ`Ò HÔ` ’ •*`ÖРD’ ŸÂÀÐ'¿ìÀ'¿äРHÒ¿äÐ €¢@€€1РDÒ¿ä– •*à”€ —* –À “*àÐ Ø’ Ò'¿èРDà пèÒ¿èÐ Ò` @Xc¢Ð¿èÒ¿èÐ Ò`@X\˜Ú¿èÄ Ð D’ ” –Ú`ŸÀ€Ò¿ä” “* Ô¿ì’@ Ð"@Ð¿ä’ Ò'¿ä¿ÿˀРHÒ¿ìÒ" Çàèã¿hð' DРDÒ Ò'¿ÐРDÒ DÔ` Ô" РDÒ¿ÐÒ" À'¿àРDÒ¿àÐ <€¢@€€Ð DÒ¿à– •*à”€ —* –À “*àÐ D’ Ò'¿ØпØÒ Ò'¿ÜпØÒ¿ØÔ` Ô" пØÒ¿ÜÒ" Ð¿à’ Ò'¿à¿ÿàÀ'¿ìп쀢 €€QРDÒ¿ì” “*  Ò HÒ'¿ÔпԀ¢ €AÀ'¿èп耢 €€:À'¿äпäҿ耢 €€-пÔÒ¿è” “* Ô¿ä’@ ” “* Ð Ð7¿ÎпÔÒ¿è” “* Ô¿ä’@ ” “* Ô¿ÔÖ¿ä˜ —+ Ø¿è–À ˜ —+ Ô€ Ô2 пÔÒ¿ä” “* Ô¿è’@ ” “* Ô¿ÎÔ2 Ð¿ä’ Ò'¿ä¿ÿÐÐ¿è’ Ò'¿è¿ÿÄÐ¿ì’ Ò'¿ì¿ÿ­Çàèã¿€ð' D Ð'¿èÀ'¿ìРDÒ¿ìÐ <€¢@€€Ð DÒ¿ì– •*à”€ —* –À “*àÔ D@ Ò Ò'¿àпàҿ耢 €Ð¿èÐ'¿èÐ¿ì’ Ò'¿ì¿ÿâРDÒ¿è” “* Ð @­œÐ'¿äп䀢 € à Dп䒕*` Ò¿è@­’Ð$ Çàèã¿€ð' D Ð'¿èÀ'¿ìРDÒ¿ìÐ <€¢@€€Ð DÒ¿ì– •*à”€ —* –À “*àÔ D@ Ò Ò'¿àпàҿ耢 €Ð¿èÐ'¿èÐ¿ì’ Ò'¿ì¿ÿâРDÒ¿è” “* Ð @­`Ð'¿äп䀢 € à Dп䒕*` Ò¿è@­VÐ$ Çàè㿈ð' Dò' Hô' Lö' PРPÒ €¢`€2РHÒ @€¢`€ РHÒ <€¢`€€Ð HÒ @€¢`€Ð HÒ <€¢`€€Ð HÒ DÐ`Ð'¿ìРH’ @ РHÒ DпìÐ"`€ РHÒ Ð"`РHÒÔ@РHŸÂ€Ð PÒ€¢`€dÐ’‘*`\’ ¼Ð ÂpÜpäq q4qHqˆq¼qð€RРPÒ €¢`€Ð Hÿÿ1€HРPÒ €¢`€Ð Hÿÿc€>РHÿþš€9РHÿþ•Ð PÒ €¢`€Ð HÿÿРHÿÿN€)РHÿþ…РPÒ €¢`€Ð Hÿÿ€Ð PÒ €¢`€Ð HÿþûРHÿÿ4€Ð HÿþkРPÒ €¢`€Ð Hÿÿ'€Ð PÒ €¢`€Ð PÒ ° €Ð L°€Çàè㿈ð' Dò' Hô' Lö' PРPÒ Ò'¿ìРPÒ€¢`€KÐ’‘*`\’¢¸Ð ÂrØràrüss<s\s|sœ€9РDÒ HÔ Lÿô<€2РDÒ HÔ LÖ¿ìÿôì€*РDÒ HÔ LÖ¿ìÿõî€"РDÒ HÔ LÖ¿ìÿû€Ð DÒ HÔ LÖ¿ìÿö£€Ð DÒ HÔ LÖ¿ìÿù€ РDÒ HÔ LÖ¿ìÿ÷Ï€Çàè㿈ð' Dò' HРH€¢ €Ð D’ þ?”ãÿ@@áРH€¢ €À'¿ìп쀢 €€Ð¿ì’ àРD?”ãÿ@@ÏÐ¿ì’ Ò'¿ì¿ÿðÇàè㿈ð' Dò' Hô' LРDÒ!0Ò'¿ìп쀢 €€‹Ð HÒ Ѐ¢`€:пìÒ  `ÿ€¢ à€4пìÒ €¢`€/пìÒ Ô @  ÿ€¢ J€(Ð¿ì’ Ô @ Ò `ÿ€¢ F€Ð¿ì’ Ô @ Ò `ÿ€¢ I€Ð¿ì’ Ô @ Ò `ÿ€¢ F€ Ð¿ì’ Ô @ Ò `ÿ€¢ €€IРHÒ Ü€¢`€:пìÒ  `ÿ€¢ î€4пìÒ €¢`€/пìÒ Ô @  ÿ€¢ A€(Ð¿ì’ Ô @ Ò `ÿ€¢ d€Ð¿ì’ Ô @ Ò `ÿ€¢ o€Ð¿ì’ Ô @ Ò `ÿ€¢ b€ Ð¿ì’ Ô @ Ò `ÿ€¢ e€€ пìÔ ’  ÿÔ¿ìÖ¿ìРHÔ Öà @yпìÒÒ'¿ì¿ÿsÇàèã¿€ð' Dò' Hô' LРDÀ" РH€¢ >€Ð DÒ Ð"`РDÒ >Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð L€¢!x€Ð DÒ Ð"`РDÒ!xÐ"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð DÒÒ'¿èРDÒ Ò'¿äРD’ ”!x@«RРDÒ¿èÒ"РDÒ¿äÒ" РDÀ" РD@^РDÀ" РDÀ" РDÀ" DÀ'¿ìп쀢 €€ РDÒ¿ì” “*  À" HÐ¿ì’ Ò'¿ì¿ÿñÀ'¿ìп쀢 €€Ð DÒ¿ì” “*  À" XРDÒ¿ì” “*  À" hÐ¿ì’ Ò'¿ì¿ÿëРDÀ"!pРDÂÔ`HÔ: 0РD’ dÒ" Çàèã¿ð' DРD@T§Çàèã¿ð' DРD@TqÇàèã¿€ð' Dò' HÀ'¿ìп쀢 €€Ð DÒ¿ì” “*  Ò HÒ'¿è€¢`€Ð¿èÒ HÒ" €Ð¿ì’ Ò'¿ì¿ÿêÀ'¿ìп쀢 €€!РDÒ¿ì” “*  Ò XÒ'¿ä€¢`€Ð¿äÒ HÒ"!РDÒ¿ì” “*  Ò hÒ'¿ä€¢`€Ð¿äÒ HÒ"!Ð¿ì’ Ò'¿ì¿ÿÝÇàè㿈ð' DРDÒ €¢`e€ РDÒ €¢`f€€Ð DÒ DÐ àÒ` €¢ € РDÒ CÐ"`РDÒÔ@РDŸÂ€Ð DÒ!LÔ`РDŸÂ€€Ð DÒ €¢`g€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!LÐ`€¢ €€FРDÒ!LÔ@РDŸÂ€À'¿ìРDÒ¿ìÐ ð€¢@ €€/РDÒ €¢`€Ð DÒ Ð¿ìÐ"`Ò DÐ`Ò DÔ`ðÔ" РDÒ Ô@РDŸÂ€Ð DÒ!XÔ`РD’ ŸÂ€€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ì’ Ò'¿ì¿ÿÍРDÒ!LÔ`РDŸÂ€¿ÿ¶Ð DÒ!\Ô` РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð D@S“Çàè㿈ð' Dò' Hô' Lö' PРDÒ à€¢`€Ð DÒ €¢`e€Ð DÒ €¢`f€Ð DÒ €¢`g€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!\Ö`РDÒ HÔ PŸÂÀРDÒ!\Ð`Ð'¿ìÒ Pÿ’Ò' P€¢ÿ€€Ð LÔ ’  ÿÔ¿ìРDŸÂ€Ð L’ Ò' L¿ÿíÇàèã¿ð' Dò' Hô' LРDÒ à€¢`€Ð DÒ €¢`e€Ð DÒ €¢`f€Ð DÒ €¢`g€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!\Ö`РDÒ HÔ LŸÂÀÇàèã¿ð' Dò' HРDÒ!\Ô`РDÒ HŸÂ€Çàèã¿ð' DРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒÔ`РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð D@…РDÒ!\Ô`РDŸÂ€Ð DÒ Ô`РDŸÂ€Çàèã¿ð' Dò' HРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð D’ ÿþJРDÒÔ`РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð DÒ H@@РDÀ" àРD’ gÒ" Çàèã¿pð' Dò' HРHÒ €¢`d€Ð HÒ Ð"`Ò HÐ@Ò HÔ`Ô" РHÒÔ@РHŸÂ€Ð HÒ DÔ`Ô" РHÒ DÔ` Ô" РHÒ DÔ`$Ô" $РHÒ DÔ`(Ô" (РH@3Ò DРHÒ`(@ìРHÒ DÔ`ÔÔ" 8РHÒ DÔa,Ô" ¼À'¿Øп؀¢ €€/РDÒ¿Ø” “*  Ò ¤€¢`€!пؒ‘*`’ HРH’ Ò'¿ìпìÒ€¢`€Ð H@RŒÒ¿ìÐ"@пìÒ DÔ¿Ø– •*à’@ ÐÒ`¤” €@¨¿Ð¿ìÒÀ"`€Ð¿Ø’ Ò'¿Ø¿ÿÏРHÒ DÔ`$Ô" <РHÒ <€¢`€ РHÒ <€¢` €€Ð HÒ Ð"`Ò HÐ@Ò HÔ`<Ô" РHÒ Ð"`РHÒÔ@РHŸÂ€À'¿ÔРDÒ ØÒ'¿èРHÒ DÒ'¿äРHÒ¿ÔÐ <€¢@€€zпäÒ¿èÔ@Ô"пäÒ¿èÔ`Ô" пäÒ¿èÔ` Ô" пäÒ¿èÔ`Ô" пäÒ Ò'¿Øп؀¢ €Ð¿Ø€¢ € РDÒ¿Ø” “*  Ò ¤€¢`€€Ð HÒ 4Ð"`РHÒпØÐ"`РHÒÔ@РHŸÂ€Ð DÒ¿Ø” “*  Ò ¤Ò'¿ÜпèÒ LÒ'¿àÐ¿à€¢ €-À'¿ÐпЀ¢ ?€€&пàҿЖ •*àÒ¿ÜֿИ —+ Ð •* ‘2 Ò@ •*`“2 €¢ €Ð HÒ ,Ð"`РHÒпØÐ"`РHÒÔ@РHŸÂ€Ð¿Ð’ Ò'¿Ð¿ÿØпԒ Ò'¿ÔÐ¿è’ TÒ'¿èÐ¿ä’ TÒ'¿ä¿ÿ‚РDÒ!€¢`€Ð DÒ ! `ÿ€¢ € РHÒ DÔ aÔ* ÔРHÒ DÔ aÔ* ÕРHÒ DÔ aÔ* ÖРHÒ DÔa Ô2 ØРHÒ DÔa"Ô2 ÚÇàèã¿ð' Dò' HРD’ Ò" $РD’ @JРDÒ ´€¢`€Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ 䀢`€Ð D@!€Ð D@РDÒ H@wРD@ßРDÒ Ô`РDŸÂ€Ð DÒ!\Ô@РDŸÂ€Çàè㿈ð' DРDÒ!XÒ'¿ìРDÒ ô€¢`€Ð¿ì’ Ò" €Ð¿ìÒ DÔ`ð’¿ÿÐ €¢ € пìÒ DÔ`øÒ  Ò" €Ð¿ìÒ DÔ`øÒ HÒ" пìÀ" пìÀ" Çàè㿈ð' Dò' HРDÒ!XÒ'¿ìРH€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ìÀ" РDÿÿÀÇàèã¿ ð' Dò' HРDÒ!XÒ'¿ìРDÒ!ÿÐ'¿äРDÒ ðÿÐ'¿àÀ'¿ØРDÒ¿ØÐ ô€¢@€€+РDÒ¿Ø” “*  Ò øÒ'¿€Ð Dà пìÒ¿€Ô`’ •*`Ð ¢€Ð¿ìÒ¿€Ð Ò` @§F”Ö¿€Ú РDÒ@Öà ˜ ŸÃ@Ò¿Ø” “* ”¿°Ð"€ пؒ Ò'¿Ø¿ÿÑпìÒ Ò'¿ÌпìÒ¿ÌÐ €¢@€€ÈпìÒ Ò'¿èРDÒ¿èÐ!€¢@ €€¶À'¿ÜÀ'¿ØРDÒ¿ØÐ ô€¢@€€”РDÒ¿Ø” “*  Ò øÒ'¿€Ò¿€Ð¿èÒ`4@§Ð'¿Äпèҿ䀢 €Ò¿€Ð`4€Ò¿€Ð`DÐ'¿ÈÀ'¿Ðп€Ò¿ÐÐ 8€¢@€€mпìÒ Ð¿à€¢@ € пÐÒ¿Ì Ò¿€Ô`H€¢ €€.пؒ‘*`’¿°Ô¿ÐÖ¿Ì”€ – •*àÒ@€ Ò¿Ä” “* Ð’ Ò'¿„À'¿ÔпÔÒ¿È€¢ €€¿ÜÒ– •*àš¿ˆ–¿„ØÀØ#@ ˜ €Ø"À’`Ò"пԒ Ò'¿Ô¿ÿê€À'¿Ôп€Ò¿ÔÐ 4€¢@€€"пܒ‘*`’¿ˆÔ¿ìֿܘ —+ ”€ Ö Ö"@пܒ‘*`’¿ˆÐ@Ô¿Ü’¿ÿ” “* ”¿ˆÒ€ Ô@Ô2пܒ Ò'¿ÜпԒ Ò'¿Ô¿ÿÚпВ Ò'¿Ð¿ÿпؒ Ò'¿Ø¿ÿhРDÔ!l’¿ˆÔ Ð DŸÂ€€¢ € пìÒ¿ÌÒ" пìÒ¿èÒ" ° €Ð¿è’ Ò'¿è¿ÿFпìÀ" п̒ Ò'¿Ì¿ÿ4Ò¿ìпìÒ¿ìÔ`’ Ò" РDÿþ£° €Çàèã¿€ð' Dò' HРDÒ Ö@РD’ ” DŸÂÀÐ'¿ìРDÒ¿ìÒ"!Xпìa’¢´Ò"пìa’£ Ò" пìÒ HÒ" РDÒ Ö`РD’ ”%ŸÂÀÐ'¿èпè’%@PgÀ'¿äп䀢 €€Ð¿ìÒ¿ä” “*  Ò¿ä” “* Ô¿è’€ Ò" Ð¿ä’ Ò'¿ä¿ÿìÇàèã¿€ð' Dò' Hô' Lö' Pø' TРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð H€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð H’‘*`’ HРD’ Ò'¿ìпìÒ€¢`€Ð D@O‰Ò¿ìÐ"@À'¿èп耢 ?€€6п蒑*`Ô L’ Ð@Ò P@¥¿’ 2 ’ d@¥ÀÐ'¿äп䀢 € Ð'¿äп䒣ÿ€¢ €cÿÐ'¿äРT€¢ €Ð¿ä€¢ ÿ€ ÿÐ'¿äÒ¿ìÐ@Ò¿è” “* Ô¿æÔ2 Ð¿è’ Ò'¿è¿ÿÈпìÒÀ"`€Çàèã¿ð' Dò' Hô' LРD’ ”àPÖ HØ LÿÿrРD’ ”áPÖ HØ LÿÿjÇàèã¿ð' DРD€¢ € Ð' DРD€¢ d€ dÐ' DРD€¢ 1€ cˆÒ D@¥hÐ' D€Ð D’‘*`’ È"@Ð' DРD°€Çàèã¿ð' Dò' Hô' LРHÿÿÕÐ' HРDÒ HÔ Lÿÿ¹Çàè㿈ð' Dò' Hô' Lö' PРHÒ€¢`€Ð D@OÒ HÐ"@Ò HÐ@Ò L” @¥&À'¿ì Ð'¿èп耢 €€Ð LÒ¿è Ò `ÿÒ¿ì@Ð'¿ìÐ¿è’ Ò'¿è¿ÿïп쀢 €Ð¿ì€¢!€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð HÔ’  Ò PÔ¿ì@¤ôРHÒÀ"aÇàèã¿ð' DРD’ XРD”âP–"hÿÿ«Ð D’ hРD”â –"¸ÿÿ¢Ð D’ \РD”âx–"ÿÿ™Ð D’ lРD”ã`–#xÿÿÇàè㿈ð' DРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ D€¢`€ РDÒ Ö@РD’ ”#HŸÂÀÒ DÐ"`DРD’ Ò" 8РD’ K” ÿÿRРDÿÿªÀ'¿ìп쀢 €€Ð DÒ¿ì À* xРDÒ¿ì ’ Ò* ˆÐ DÒ¿ì ’ Ò* ˜Ð¿ì’ Ò'¿ì¿ÿéРDÀ" ¬Ð DÀ" ¨Ð DÀ" °Ð DÀ" ´Ð DÀ" ¸Ð DÒ 8€¢`€Ð D’ Ò" ¸Ð DÀ" ¼Ð DÀ" ÀРDÀ" ÄРDÀ" ÈРDÀ" ÌРD’ Ò* ÔРD’ Ò* ÕРDÀ* ÖРD’ Ò2 ØРD’ Ò2 ÚРD@Çàèã¿ð' DРDÒ (€¢`€4Ð (’‘*`d’£ÌР”\“ä“ü””,”DРD’ @.€*РD’ @(€$РD’ @"€Ð D’ @€Ð D’ @€Ð D’ @€ РDÒ Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' Dò' HРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ HÒ" @РDÀ" ÐРDÀ" ÜРH€¢ €ªÐ H’‘*`e’¡LРš”•d•Ì–Ì—ä™0РD’ Ò" ÐРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" €ŒÐ D’ Ò" ÜРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ RÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`TÐ'¿ìÐ¿ì’ GÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`¨Ð'¿ìÐ¿ì’ BÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" €LРD’ Ò" ÐРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`TÐ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" РDÒ D`¨Ð'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" €Ð D’ Ò" ÜРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ CÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`TÐ'¿ìÐ¿ì’ MÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`¨Ð'¿ìÐ¿ì’ YÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`üÐ'¿ìÐ¿ì’ KÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" €³Ð D’ Ò" ÜРD’ Ò" <РDÒ DÒ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" РDÒ D`TÐ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" РDÒ D`¨Ð'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" Ð¿ì’ Ò" РDÒ D`üÐ'¿ìÐ¿ì’ Ò"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" €ZРDÒ DÔ`$Ô" <РDÒ <€¢`€ РDÒ <€¢` €€Ð DÒ Ð"`Ò DÐ@Ò DÔ`<Ô" РDÒ Ð"`РDÒÔ@РDŸÂ€À'¿èРDÒ¿èÐ <€¢@€€!РDÒ¿è– •*à”€ —* –À “*àÐ D’ Ò'¿ìпìÒ¿èÒ"Ð¿ì’ Ò" Ð¿ì’ Ò" пìÀ" пìÀ" пìÀ" Ð¿è’ Ò'¿è¿ÿÛ€ РDÒ Ð"`РDÒÔ@РDŸÂ€Çàèã¿ð' Dò' Hô' Lö' Pø' Tú' XРD’ Ò"РDÒ HÒ" РDÒ LÒ" РDÒ PÒ" РDÒ TÒ" РDÒ XÒ" РD’ $Ò' DРD°€Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XÀ'¿ìпìÒ H€¢ €€Ð D’ Ò"РDÒ¿ìÒ" РDÒ LÒ" РDÒ PÒ" РDÒ TÒ" РDÒ XÒ" РD’ $Ò' DÐ¿ì’ Ò'¿ì¿ÿáРD°€Çàè㿈ð' Dò' Hô' Lö' PРH€¢ €(РDÒ HÒ"À'¿ìпìÒ H€¢ €€Ð DÒ¿ì” “*  Ò¿ìÒ" Ð¿ì’ Ò'¿ì¿ÿïРDÒ DÀ"`À" РDÒ LÒ" РDÒ PÒ" РD’ $Ò' D€ РDÒ H” – Ø LÚ PÿÿœÐ' DРD°€Çàèã¿€ð' DРDÒ <Ò'¿ìРDÒ €¢`d€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð¿ì€¢ € РDÒ @€¢`€ Ð'¿è€Ð¿ì€¢ € п씓* ’@‘*`Ð'¿è€Ð¿ì’‘*`’ Ò'¿èРDÒ!p€¢`€ РDÒ!tп耢@€€Ð Dҿ耢` €’ Ò"!tÒ DÐ`Ô DÒ¡t” —* –À •*àÖРD’ ŸÂÀÒ DÐ"apРDÒ!pÒ'¿äРDÒ¿äÒ" ¬Ð DÒ¿èÒ" ¨Ð¿ì€¢ €_РDÒ @€¢`€ZпäÒ¿ì” – ÿÿRÐ'¿äÐ¿ä’ ” – ˜ š ÿþøÐ'¿äÐ¿ä’ ” – ?˜ š ÿþïÐ'¿äÐ¿ä’ ” – ?˜ š ÿþæÐ'¿äÐ¿ä’ ” – ?˜ š ÿþÝÐ'¿äÐ¿ä’ ” – ?˜ š ÿþÔÐ'¿äпäÒ¿ì” – ÿÿÐ'¿äÐ¿ä’ ” – ?˜ š ÿþÄÐ'¿äÐ¿ä’ ” – ?˜ š ÿþ»Ð'¿äÐ¿ä’ ” – ?˜ š ÿþ²Ð'¿ä€4пäÒ¿ì” – ÿþúÐ'¿äпäÒ¿ì” – ˜ š ÿþÂÐ'¿äпäÒ¿ì” – ?˜ š ÿþ¹Ð'¿äпäÒ¿ì” – ?˜ š ÿþ°Ð'¿äпäÒ¿ì” – ÿþØÐ'¿äпäÒ¿ì” – ?˜ š ÿþ Ð'¿äÇàè㿈ð' DРDÒ Ò'¿ìРDÒ Ö@РD’ ŸÂÀÒ¿ìÐ"`пìÒ¿ìÔ`Ô"пìÒ" Çàè㿈ð' DРDÒ Ò'¿ìпìÖ¿ìÐ ’ Öà@ ™€¢ € РDÒ %Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿ìÔ`Ô"пìÒ" ° €Çàè㿈ð' DРDÒ Ò'¿ìпìÐ ’"@Ò'¿èп耢 €Ð¿ìÖ¿ìÐ ’ Ô¿èÖà@ iҿ耢 € РDÒ %Ð"`РDÒÔ@РDŸÂ€Ò¿ìÐ`@ ZпìÒ Ð ` ’ `ÿ€¢ € РDÒ %Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' Dò' HРDÒ €¢`€ РDÒ Ö@РD’ ” ŸÂÀÒ DÐ"`РDÒ Ò'¿ìпìh’¢Ò" пìh’¢xÒ" пìh’£Ò" пìÒ HÒ" Çàèã¿€ð' DРDÒ €¢`€Ð DÒ €¢`€Ð DÒ <€¢`€ РDÒ $€¢`€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ò DÐ` ?’£Ü€¢ € Ò DÐ`?’£Ü€¢ €€Ð DÒ )Ð"`Ò DÐ@?’£ÜÒ" РDÒÔ@РDŸÂ€Ð DÒ DÐ Ò`$@ŸÍÐ'¿äпäÐ'¿àпàҿ䀢 € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð DÒ 8€¢`€Ð DÒ Ð"`Ò DÐ@Ò DÔ`8Ô" РDÒÔ@РDŸÂ€Ð DÒ <€¢` €Ð DÒ Ð"`Ò DÐ@Ò DÔ`<Ô" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð D’ Ò" èРD’ Ò" ìÀ'¿ìРDÒ DÒ'¿èРDÒ¿ìÐ <€¢@€€>пèÒ €¢`€Ð¿èÒ €¢`€Ð¿èÒ €¢`€ пèÒ €¢`€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÖ¿èÔàÖ`耢€ €Ô`èÔ" èРDÒ DÖ¿èÔà Ö`쀢€ €Ô`ìÔ" ìÐ¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ¾À'¿ìРDÒ DÒ'¿èРDÒ¿ìÐ <€¢@€€IпèÒ¿ìÒ" Ð¿è’ Ò" $РDÒ¿èÐ Ò`@Ÿ(Ò DÔ`è’ •*`’ @HþÒ¿èÐ"`РDÒ¿èÐ Ò` @ŸÒ DÔ`ì’ •*`’ @HïÒ¿èÐ"` РDÒ¿èÐ Ò`@Ÿ Ò DÒ`è@HãÒ¿èÐ"`(РDÒ¿èÐ Ò` @žþÒ DÒ`ì@H×Ò¿èÐ"`,Ð¿è’ Ò" 0Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ³Ð DÒ DÔ`ì’ •*`Ð ’ @HÁÒ DÐ"`ðÇàèãµ8ð' DРDÒ ¨€¢`€Ð DÒ Ð"`РDÒÀ"`РDÒÔ@РDŸÂ€Ð DÒ ¬Ò'¿ìпìÒ €¢`€ пìÒ €¢`?€€*РD’ Ò" 䵘Ð'¿œÀ'¿àРDÒ¿àÐ <€¢@€€À'¿Üп܀¢ ?€€ ¿œÒ”?ÿÔ"@’`Ò"пܒ Ò'¿Ü¿ÿñÐ¿à’ Ò'¿à¿ÿâ€Ð DÀ" äÀ'¿àРDÒ¿àÐ <€¢@€€ Ð¿à’‘*`’¿ À"@Ð¿à’ Ò'¿à¿ÿð Ð'¿èРDÒ¿èÐ ¨€¢@€€·Ð¿ìÒÒ'¿äп䀢 €Ð¿ä€¢ €€Ð DÒ Ð"`РDÒпäÐ"`РDÒ Ð"`РDÒÔ@РDŸÂ€À'¿àпàҿ䀢 €€EпìÒ¿à” “*  Ò Ò'¿Øп؀¢ € РDÒ¿ØÐ <€¢@€€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿à€¢ €Ð¿ìÔ¿à’¿ÿ” “*  Ò¿ØÐ €¢@€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿à’ Ò'¿à¿ÿ¸Ð¿ìÒ Ò'¿ÔпìÒ Ò'¿ÐпìÒ Ò'¿ÌпìÒ Ò'¿ÈРDÒ 䀢`€âпԀ¢ €!пԀ¢ ?€Ð¿ÐÒ¿Ô€¢ €Ð¿Ð€¢ ?€Ð¿Ì€¢ €Ð¿Ì€¢ € пȀ¢ €Ð¿È€¢ €€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿Ô€¢ €Ð¿Ð€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€€Ð¿ä€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€À'¿àпàҿ䀢 €€|µ˜Ò¿ìÔ¿à– •*à’@ Ô`’ •*` Ð'¿œÐ¿Ô€¢ €Ð¿œÒ€¢`€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿ÔÐ'¿ÜпÜҿЀ¢ €€Kпܒ‘*`Ò¿œ Ò€¢`€Ð¿Ì€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€€"пܒ‘*`Ò¿œ Ò¿ÌЀ¢@€ Ò¿ÌÿÒ¿È€¢@€€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿Ü’‘*`Ò¿œ Ò¿ÈÒ"пܒ Ò'¿Ü¿ÿ²Ð¿à’ Ò'¿à¿ÿ€SпԀ¢ €Ð¿Ð€¢ ?€ п̀¢ €Ð¿È€¢ €€Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€À'¿àпàҿ䀢 €€*пìÒ¿à” “*  Ò Ò'¿Øпؒ‘*`’¿ Ð@€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð¿Ø’‘*`’¿ ” Ô"@Ð¿à’ Ò'¿à¿ÿÓÐ¿ì’ $Ò'¿ìÐ¿è’ Ò'¿è¿þEРDÒ 䀢`€$À'¿àРDÒ¿àÐ <€¢@€€Ð¿à’‘*`’µ˜Ð@€¢ € РDÒ -Ð"`РDÒÔ@РDŸÂ€Ð¿à’ Ò'¿à¿ÿã€"À'¿àРDÒ¿àÐ <€¢@€€Ð¿à’‘*`’¿ Ð@€¢ € РDÒ -Ð"`РDÒÔ@РDŸÂ€Ð¿à’ Ò'¿à¿ÿãÇàèã¿€ð' DРDÒ ¬€¢`€HРDÒ!LÒ'¿èРDÔ¿èÒ  – •*à”€ “* Ð ¬’ Ò'¿äРDÒ¿äÔ@Ô" ôÀ'¿ìпäÒ¿ìЀ¢@€€Ð DÒ¿ì” “*  Ò DÔ¿äÖ¿ì˜ —+ ˜€ Ô ˜ —+ –À ™*à˜ •+ Ò`D”@ Ô" øÐ¿ì’ Ò'¿ì¿ÿàРDÒ¿äÔ`Ô"!<РDÒ¿äÔ`Ô"!@РDÒ¿äÔ`Ô"!DРDÒ¿äÔ` Ô"!H€EРDÒ <€¢`€Ð DÒ Ð"`Ò DÐ@Ò DÔ`<Ô" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÔ`<Ô" ôÀ'¿ìРDÒ¿ìÐ <€¢@€€Ð DÒ¿ì” “*  Ò DÔ¿ì˜ —+ –À ™*à˜ •+ Ò`D”@ Ô" øÐ¿ì’ Ò'¿ì¿ÿåРDÀ"!<РD’ ?Ò"!@РDÀ"!DРDÀ"!HÇàèã¿xð' DРDÒ ô€¢`€5РDÒ øÒ'¿àРDÒ¿àÔ`Ô"!РDÒ¿àÔ` Ô"! Ð¿à’ Ò" 4Ð¿à’ Ò" 8Ð¿à’ Ò" <Ð¿à’ Ò" @Ð¿à’ Ò" DпàÒ¿àÔ  Ò` @›ÌÐ'¿äп䀢 €Ð¿àÒ Ò'¿äпàÒ¿äÒ" HРD’ Ò"!РDÀ"!€´Ð DÒ ô€¢`€ РDÒ ô€¢`€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`ôÔ" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÔ`è’ •*`Ð ’ @E`Ò DÐ"aРDÒ DÔ`ì’ •*`Ð ’ @EUÒ DÐ"a РDÀ"!À'¿ìРDÒ¿ìÐ ô€¢@€€tРDÒ¿ì” “*  Ò øÒ'¿àпàÒ¿àÔ`Ô" 4пàÒ¿àÔ` Ô" 8à¿àпàÒ¿àÐ 4Ò`8@›UÐ$ <пàÒ¿àÔ`4’ •*`Ô" @пàÒ¿àÔ  Ò`4@›VÐ'¿äп䀢 €Ð¿àÒ 4Ò'¿äпàÒ¿äÒ" DпàÒ¿àÔ  Ò`8@›DÐ'¿äп䀢 €Ð¿àÒ 8Ò'¿äпàÒ¿äÒ" HпàÒ <Ò'¿èРDÒ!Ô¿è@ €¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€¿èÒ” ’ÿÒ"€¢ €€Ô DÒ DaÒ– ™*à”€ Ö¿ìÖ"¡’`Ò"¿ÿëÐ¿ì’ Ò'¿ì¿ÿˆÐ DÒ Ì€¢`€Ð DÒ DÐ ÌÒa@šîÐ'¿ÜРDÒ¿Ü?”ãÿ€¢@ €?’£ÿÒ" ÈÇàè㿈ð' DРDÒ!LÒ'¿ìÒ¿ìÐ`€¢ €Z€¢  €€¢ €†€²Ð DÿþWРDÿþæРDÒ °€¢`€Ð DÒ!`Ô@РDŸÂ€Ð DÒ!dÔ@РDŸÂ€Ð DÒ!TÔ@РD’ ŸÂ€Ð DÒ!hÔ@РDŸÂ€Ð DÔ!lÒ DԀРDÒ`¸ŸÂ€Ò DÐaXÒ¿ìÔ`€¢ €’ €’ ÔРDŸÂ€Ð DÒ!PÔ@РD’ ŸÂ€Ð DÒ ¸€¢`€Ð¿ìÀ" €Ð¿ì’ Ò" €lРDÿþРDÿþ–РDÒ!<€¢`€Ð DÒ!D€¢`€ РDÒ ´€¢`€€Ð DÒ!lÔ@РD’ ŸÂ€Ð DÒ!XÔ@РD’ ŸÂ€Ð¿ìÀ" €CÐ¿ì’ Ò" Ò¿ìпìÒ¿ìÔ`’ Ò" РDÒ ¸€¢`€Ð DÿýÐРDÿþ_РDÒ!lÔ@РD’ ŸÂ€Ð DÒ!XÔ@РD’ ŸÂ€Ð¿ìÒ €¢`€Ð DÒ!\Ô`РDŸÂ€Ð DÒ!\Ô`РDŸÂ€Ð¿ìÀ" € РDÒ 0Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿ìÔ¿ìÖ ”ÿÿÒ`”@ €  ’`?ÿÒ" РDÒ €¢`€ Ò DÐ`Ò¿ìÔ`Ô" Ò DÐ`Ò¿ìÔ`Ô" Çàèã¿ð' DРDÒ!LÀ"` РDÒ!\Ô`РDŸÂ€Ð DÒ!\Ô`РDŸÂ€Çàè㿈ð' DРDÒ!LÒ'¿ìРDÒ!lÔ`РDŸÂ€Ò¿ìÐ`€¢ €€¢  €€¢ €€'Ð¿ì’ Ò" РDÒ ¸€¢`€Ò¿ìпìÒ¿ìÔ` ’ Ò" €Ð¿ì’ Ò" €Ð DÒ ¸€¢`€Ð¿ì’ Ò" Ò¿ìпìÒ¿ìÔ` ’ Ò" €Ò¿ìпìÒ¿ìÔ`’ Ò" Çàè㿈ð' Dò' HРDÒ Ö@РD’ ” $ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Lпìn’¡hÒ"пìo’¡Ò" пìo’¡PÒ" пìÀ" РDÿùpРDÒ ¬€¢`€Ð Dÿúœ€Ð DÀ" äРD’ Ò" ¨Ð DÒ 䀢`€Ð D’ Ò" ¸Ð H€¢ €Ð DÒ ¸€¢`€Ð¿ì’ Ò" €Ð¿ì’ Ò" €Ð¿ìÀ" пìÀ" пìÀ" РDÒ ¸€¢`€ пìÒ DÔ`¨’ •*`Ô" €Ð¿ìÒ DÔ`¨Ô" Çàè㿈ð' Dò' HРDÒ Ò'¿ìпìÒÔ KÔ*@’`Ò"Ò¿ìпìÒ¿ìÔ`’¿ÿ” Ô" €¢ €Ð¿ìÒ Ð DŸÂ@€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Çàèã¿ð' Dò' HРD’ ÿÿÿÑРDÒ HÿÿÍÇàèã¿ð' Dò' HÒ H‘:`’ ÿРDÿÿÂРH’ ÿРDÿÿ½Çàèã¿€ð' Dò' HРDÒ H” “*  Ò HÒ'¿ìп쀢 €Ð DÒ 4Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€À'¿èÀ'¿äп䀢 ?€€Ð¿ìÒ¿ä” “* Ð “* ‘2`€¢ ÿ€ Ð'¿èÐ¿ä’ Ò'¿ä¿ÿëпìÒ €€¢`€CРD’ Ûÿÿ§Ð¿è€¢ €’ ƒ€’ CРDÿÿ©Ò¿è‘*`Ô H’ РDÿÿkÀ'¿äп䀢 ?€€#пìÃÔ¿ä– •*à–a(’€ Ô@’ •*`Ð “* ‘2`Ð'¿àп耢 €Ð¿à“2 РDÿÿMÐ¿à’ ÿРDÿÿHÐ¿ä’ Ò'¿ä¿ÿÛÐ¿ì’ Ò" €Ð¿è°€Çàèã¿€ð' Dò' Hô' LРL€¢ €Ð DÒ H” “*  Ò hÒ'¿ìРH’ Ò' H€ РDÒ H” “*  Ò XÒ'¿ìп쀢 €Ð DÒ 2Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð¿ìÒ!€¢`€QРD’ Äÿÿ.À'¿è Ð'¿äп䀢 €€Ð¿ìÒ¿äÔ  ÿÒ¿è@Ð'¿èÐ¿ä’ Ò'¿ä¿ÿðÐ¿è’ Ð Dÿÿ!РDÒ Hÿþæ Ð'¿äп䀢 €€Ð¿ìÒ¿äÐ ’ ÿРDÿþ×Ð¿ä’ Ò'¿ä¿ÿðÀ'¿äпäҿ耢 €€Ð¿ìÒ¿ä Ô ’  ÿРDÿþÁÐ¿ä’ Ò'¿ä¿ÿîÐ¿ì’ Ò"!Çàèã¿ð' DÇàèã¿ð' DРD’ Ýÿþ×РD’ ÿþàÒ DРDÒ`ÈÿþÛÇàè㿈ð' Dò' HРDÒ HÿþÅÒ DÐ`<”“* ’@”`РD’ ÿþÈÒ DÐ` ?’£ÿ€¢ € Ò DÐ`?’£ÿ€¢ €€Ð DÒ )Ð"`Ò DÐ@?’£ÿÒ" РDÒÔ@РDŸÂ€Ò DРDÒ`8ÿþmÒ DРDÒ` ÿþŸÒ DРDÒ`ÿþšÒ DРDÒ`<ÿþ^À'¿ìРDÒ DÒ'¿èРDÒ¿ìÐ <€¢@€€Ò¿èРDÒ@ÿþMпèÒ ‘*`Ò¿èÔ` ’ РDÿþDÒ¿èРDÒ`ÿþ?Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿßÇàèã¿€ð' DРD’ ÚÿþYРDÒ ô “* ”`РD’ ÿþ]Ò DРDÒ`ôÿþ!À'¿ìРDÒ¿ìÐ ô€¢@€€9РDÒ¿ì” “*  Ò øÒ'¿àÒ¿àРDÒ@ÿþ пàÒ Ò'¿èпàÒ Ò'¿äРDÒ 䀢`€Ð DÒ!<€¢`€À'¿äРDÒ!D€¢`€Ð DÒ ´€¢`€À'¿è€À'¿èÒ¿è‘*`Ô¿ä’ Ð DÿýæÐ¿ì’ Ò'¿ì¿ÿÃÒ DРDÒa<ÿýÜÒ DРDÒa@ÿý×РDÒ!D‘*`Ò DÔaH’ РDÿýÎÇàèã¿ð' DРD’ àÿýðРD’ ÿýùРD’ Jÿý¾Ð D’ FÿýºÐ D’ Iÿý¶Ð D’ Fÿý²Ð D’ ÿý®Ð DÔ Ô’  ÿРDÿý¨Ð DÔ Õ’  ÿРDÿý¢Ð DÔ Ö’  ÿРDÿýœÐ DÒ Ø‘*`“2 РDÿýÌРDÒ Ú‘*`“2 РDÿýÅРD’ ÿýŠÐ D’ ÿý†Çàèã¿ð' DРD’ îÿý¨Ð D’ ÿý±Ð D’ AÿývРD’ dÿýrРD’ oÿýnРD’ bÿýjРD’ eÿýfРD’ dÿý™Ð D’ ÿý•Ð D’ ÿý‘Ò DÐ`@€¢ €€¢ € €Ð D’ ÿýL€Ð D’ ÿýF€Ð D’ ÿý@€Çàèã¿ð' Dò' Hô' LРL?’£ý€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ HÿýNРL’ РDÿýVÇàèã¿ð' Dò' HРDÒ HÿýÇàè㿈ð' DРDÒ!\Ò'¿ìРD’ Øÿý5пìÀ" РDÒ Ѐ¢`€Ð Dÿÿ7РDÒ Ü€¢`€Ð DÿÿwÇàèã¿€ð' DÀ'¿èÀ'¿ìРDÒ DÒ'¿àРDÒ¿ìÐ <€¢@€€Ò¿àРDÒ`ÿý*Ò¿è@Ð'¿èÐ¿ì’ Ò'¿ìÐ¿à’ TÒ'¿à¿ÿêРDÒ ´€¢`€Ð DÒ 䀢`€ РDÒ 8€¢`€€À'¿ä€9 Ð'¿äÀ'¿ìРDÒ DÒ'¿àРDÒ¿ìÐ <€¢@€€Ð¿àÒ €¢`€ пàÒ €¢`€€À'¿äÐ¿ì’ Ò'¿ìÐ¿à’ TÒ'¿à¿ÿåп耢 €Ð¿ä€¢ €À'¿äРDÒ KÐ"`РDÒÔ`РD’ ŸÂ€Ð DÒ ´€¢`€Ð D’ Éÿýä€Ð DÒ 䀢`€Ð D’ Âÿýـп䀢 €Ð D’ ÀÿýπРD’ ÁÿýÉÇàèã¿€ð' DРDÒ!\Ò'¿ìРDÒ ´€¢`€Ð Dÿý¥€BÀ'¿èРDÒ¿èÐ ô€¢@€€9РDÒ¿è” “*  Ò øÒ'¿äРDÒ 䀢`€Ð DÒ!<€¢`€Ð DÒ!D€¢`€Ò¿äРDÒ`” ÿüû€Ò¿äРDÒ`” ÿüó€Ò¿äРDÒ`” ÿüëÒ¿äРDÒ`” ÿüåÐ¿è’ Ò'¿è¿ÿÃРDÒ¿ìÐ ÈÒ`€¢ € РDÿý]пìÒ DÔ`ÈÔ" РDÿýÔÇàèã¿ð' DРD’ Ùÿü)Çàè㿈ð' DРD’ Øÿü!À'¿ìп쀢 €€Ð DÒ¿ì” “*  Ò H€¢`€Ð DÒ¿ìÿü*Ð¿ì’ Ò'¿ì¿ÿêРDÒ ´€¢`€*À'¿ìп쀢 €€#РDÒ¿ì” “*  Ò X€¢`€Ð DÒ¿ì” ÿüŒÐ DÒ¿ì” “*  Ò h€¢`€Ð DÒ¿ì” ÿü~Ð¿ì’ Ò'¿ì¿ÿÛРD’ Ùÿû×Çàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!\пìr’£¨Ò"пìs’ Ò" пìs’¢\Ò" пìs’£äÒ" пìt’ Ò" пìr’£Ò" пìr’£„Ò" пìÀ" Çàèã¿xð' Dò' HРDÒ!lÒ'¿ìРH€¢ € пìy’¢LÒ" пì{’£ÌÒ" € пìw’£ÀÒ" пìx’¢¨Ò" À'¿èРDÒ¿èÐ ô€¢@€€¨Ð DÒ¿è” “*  Ò øÒ'¿ÜпÜÒ Ò'¿äпÜÒ Ò'¿àРH€¢ €vп䀢 €Ð¿ä€¢ €€Ð DÒ 2Ð"`РDÒпäÐ"`РDÒÔ@РDŸÂ€Ð¿à€¢ €Ð¿à€¢ €€Ð DÒ 2Ð"`РDÒпàÐ"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿ä” “*  Ò L€¢`€Ð DÒ Ö@РD’ ”$ŸÂÀÒ¿ìÔ¿ä– •*à’@ Ð"`LпìÒ¿ä” “* ” РL’ ”$@”5пìÒ¿à” “*  Ò \€¢`€Ð DÒ Ö@РD’ ”$ŸÂÀÒ¿ìÔ¿à– •*à’@ Ð"`\пìÒ¿à” “* ” Р\’ ”$@”€Ð¿ä’‘*`’ ,пì–@РD’ Ô¿ä@$Ð¿à’‘*`’ <пì–@РD’ Ô¿à@пìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿTпìÀ" пìÀ" пìÒ DÔ`ÈÔ" $пìÀ" (ÇàèãºXð' Dò' Hô' Lö' PРL€¢ €Ð L€¢ €€Ð DÒ 2Ð"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð H€¢ € РDÒ L” “* ” РX€Ò DÔ L– •*à’@ Ð`hÐ'¿ìп쀢 €Ð DÒ 2Ð"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð PÒ€¢`€ РDÒ Ö@РD’ ”%ŸÂÀÒ PÐ"@РPÒÒ'¿èÀ'¿ä Ð'¿Üп܀¢ €€6пìÒ¿ÜÐ ’ ÿÒ'¿àÐ¿à€¢ € пäÒ¿à €¢!€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿àÿ’Ò'¿à€¢ÿ€€ ¿äÒ” –¾ÈØ¿ßØ*À ’`Ò"¿ÿïпܒ Ò'¿Ü¿ÿÈп䒾ÈÀ*@пäÐ'¿ØÀ'º¼Ð¾È“* ‘:`Ð'¿ÔÀ'¿äп䒾ÈÐ @“* ‘:`€¢ €€4п䒾ÈÐ @“* ‘:`Ò¿Ô€¢ €€¿äÒ– •*à–ºÀغ¼Ø"À ’`Ò"к¼’ Ò'º¼¿ÿé Ò¿Ô‘* Òº¼€¢@€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ðº¼“* Ò'º¼Ð¿Ô’ Ò'¿Ô¿ÿÆпè’$ ’ ”!@“РH€¢ € € ÿÐ'¿ÐÀ'¿äпäÒ¿Ø€¢ €€<пìÒ¿ä Ò  `ÿÐ'¿àÐ¿à€¢ €Ð¿àҿЀ¢ € пèÒ¿à Ò $•*`‘: €¢ €€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿èÒ¿à” “* Ô¿ä– •*à–ºÀÔÀ Ô" пèÒ¿à ҿ䔾ÈÒ € Ò*$Ð¿ä’ Ò'¿ä¿ÿÁÇàè㿈ð' DРDÒ Ð`Ð'¿ìпìÒ DÔ Ð` ŸÂ€€¢ €° € РDÒ¿ìÔ@Ô"РDÒ¿ìÔ`Ô" ° €Çàèã¿ð' DРD’ ” @€¢ €° € РDÀ" РDÀ" ° €Çàèã¿ð' Dò' Hô' Lö' Pø' TРHÒ‘*`£: РL¢$@ €¤ €  ¢ÿ¤ €¤ €€¤ ¡< ¿ÿù€¤  €Ð DÒ Ð@’ Ò" РDÒ Ð@Ò DÔÐ` ŸÂ€Ò P•* РP–Ð ä™* —; РDÒ@ ” @»€¢ €° €œ€¤ € РD’”@­€¢ €° €Ž¨ ¦ €¤à?€€rÃ’•*`’!(€ Ò “* Ô H@ Ò‘*`¡: €¢ €¨ €[€¥ €€Ò TРTÔ $ð‘* •: РDÒcÀ@~€¢ €° €_¨?ð¿ÿ뢀¤ €  ¢ÿ¤ ¡< €¢ €€¤ ¿ÿø€¤  €Ð DÒ Ð@’ Ò" РDÒ Ð@Ò DÔÐ` ŸÂ€«- ª@Ò T•* РT–Ð ä™* —; РDÒ@ ” @E€¢ €° €&РD’”@:€¢ €° €¨ ¦à¿ÿ€¥ €Ò TРTÔ $‘* •: РDÒ@@$€¢ €° €° €Çàè㿈ð' Dò' HРDÿÿ €¢ €° €NРDÒ” ÿÔ*@’`Ò"Ò DРDÒ DÔ`’¿ÿ” Ô" €¢ € РDÿþÒ€¢ €° €5РDÒÔ K–¿ÐÖ*@’`Ò"Ò DРDÒ DÔ`’¿ÿ” Ô" €¢ € РDÿþ¸€¢ €° €À'¿ìРDÒ Ð¿ìÒ`ô€¢ €€ РDÒ¿ì” “*  À" Ð¿ì’ Ò'¿ì¿ÿî° €Çàèã¿Pð' Dò' HРDÒ!lÒ'¿ìРDÒ Ð@Ð'¿ÀРDÒ Ð`Ð'¿ÄпìÒ Ò'¿ÈÒ Ò'¿ÌÒ Ò'¿ÐÒ Ò'¿ÔÒ Ò'¿ØÐ Ð'¿ÜРDÐ'¿àРDÒ È€¢`€Ð¿ìÒ $€¢`€ ¿ÀÒ¿ìÒ`(ÿÿ|€¢ €° €ˆÀ'¿¼Ð DÒ¿¼Ð!€¢@€€GРDÒ¿¼” “*  Ò!Ò'¿¸Ð DÒ¿¸” “*  Ò øÒ'¿´¿ÀÒ¿¼” “* Ô H’@ Ô¿¸– •*à–¿À”À Ö¿ìØ¿´Ú ˜ ›+ –À Ø¿ìÚ¿´Ä`š…+`˜Ò@Ô Öà,Ø <ÿþe€¢ €° €Mп¸’‘*`’¿À@Ò¿¼” “* Ô H’@ Ô@Ò€•*`“: Ò" п¼’ Ò'¿¼¿ÿµÐ DÒ Ð¿ÀÐ"@РDÒ Ð¿ÄÐ"`пìÒ¿ÈÒ" Ò¿ÌÒ" Ò¿ÐÒ" Ò¿ÔÒ" Ò¿ØÒ" Ò¿ÜÒ" РDÒ È€¢`€Ð¿ìÒ $€¢`€Ð¿ìÒ DÔ`ÈÔ" $Ò¿ìпìÒ¿ìÔ`(’ Ò" (пìÒ¿ìÔ`(’  Ò" (Ò¿ìпìÒ¿ìÔ`$’¿ÿÒ" $° €Çàèã¿`ð' DРDÒ!lÒ'¿ìРDÒ Ð@Ð'¿ÀРDÒ Ð`Ð'¿ÄпìÒ Ò'¿ÈÒ Ò'¿ÌÒ Ò'¿ÐÒ Ò'¿ÔÒ Ò'¿ØÐ Ð'¿ÜРDÐ'¿à’¿À ÿýÜ€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ð¿ÀÐ"@РDÒ Ð¿ÄÐ"`пìÒ¿ÈÒ" Ò¿ÌÒ" Ò¿ÐÒ" Ò¿ÔÒ" Ò¿ØÒ" Ò¿ÜÒ" Çàèã¿ð' Dò' Hô' Lö' Pø' TРHÒ‘*`¡: РL $€¤ €  ¢ €¤ €€¢`¡< ¿ÿù€¤` € РDÒ Ð"`РDÒÔ@РDŸÂ€“* Ô P@ ’‘*`Ò P ’•*`Ö P’€ Ô@’ Ò"¦ ¤ €¤ ?€€_Ã’•*`’!(€ Ò “* Ô H@ Ò‘*`¡: €¢ €¦à€H€¤à€€#ÀÒ T ’#ÀÔ T@ ’#ÀÔ T’@ Ô@’ Ò"¦ÿð¿ÿ €  ¢ ¡< €¢ €€¢`¿ÿø€¤` € РDÒ Ð"`РDÒÔ@РDŸÂ€‘,à’ “* Ô T@ “,à@’‘*`Ò T “,à”@’ •*`Ö T’€ Ô@’ Ò"¦ ¤ ¿ÿ €¤à€Ò TРTÒ TÔ@’ Ò"Çàèã¿€ð' Dò' HРDÒ!lÒ'¿ìРDÒ È€¢`€%пìÒ $€¢`€À'¿äРDÒ¿äÐ ô€¢@€€ пìÒ¿ä” “*  À" Ð¿ä’ Ò'¿ä¿ÿïпìÒ DÔ`ÈÔ" $Ò¿ìпìÒ¿ìÔ`$’¿ÿÒ" $À'¿èРDÒ¿èÐ!€¢@€€AРDÒ¿è” “*  Ò!Ò'¿äРDÒ¿ä” “*  Ò øÒ'¿àп蒑*`Ô H’ пìÔ¿ä– ™*à” Ð¿ìÖ¿àØà– ™*à– Ð¿ìØ¿àÚ ˜ ›+ ˜ РDÒ@Ô ÖàLØ \ÿþúпìÒ¿ä” “*  Ò¿è” “* Ô H’@ Ô@Ò€•*`“: Ò" Ð¿è’ Ò'¿è¿ÿ»° €Çàèã·@ð' Dò' Hô' L’¿È ’ ” !@%’»À ’ ”$@À'·¨Ð·¨€¢!€€ з¨’‘*`’·¸”?ÿÔ"@з¨’ Ò'·¨¿ÿñ$Ò L ’ Ò"?ÿÐ'·´æ²bÐ'· À'·¨Ð·¨€¢!€€#з¨’‘*`Ò L Ò€¢`€Ð·¨’‘*`Ò L Òз €¢@€ з¨’‘*`Ò L ÒÒ'· Ð·¨Ð'·´Ð·¨’ Ò'·¨¿ÿÛ?ÿÐ'·°æ²bÐ'· À'·¨Ð·¨€¢!€€(з¨’‘*`Ò L Ò€¢`€Ð·¨’‘*`Ò L Òз €¢@€Ð·¨Ò·´€¢ € з¨’‘*`Ò L ÒÒ'· Ð·¨Ð'·°Ð·¨’ Ò'·¨¿ÿÖз°€¢ €€ƒÐ·´’‘*`Ò L Ò·´” “* Ô L’@ Ô·°– •*àÖ L”€ Ò@Ô€’@ Ò"з°’‘*`Ò L À"з´’‘*`’»Àз´’‘*`’»ÀÔ·´– •*à–»ÀÔÀ – Ö"@з´’‘*`’·¸Ð@€¢ €€Ð·´’‘*`’·¸Ð@Ð'·´Ð·´’‘*`’»Àз´’‘*`’»ÀÔ·´– •*à–»ÀÔÀ – Ö"@¿ÿáз´’‘*`’·¸Ô·°Ô"@з°’‘*`’»Àз°’‘*`’»ÀÔ·°– •*à–»ÀÔÀ – Ö"@з°’‘*`’·¸Ð@€¢ €€Ð·°’‘*`’·¸Ð@Ð'·°Ð·°’‘*`’»Àз°’‘*`’»ÀÔ·°– •*à–»ÀÔÀ – Ö"@¿ÿá¿ÿÀ'·¨Ð·¨€¢!€€6з¨’‘*`’»ÀÐ@€¢ €)з¨’‘*`’»ÀÐ@€¢ € РDÒ 'Ð"`РDÒÔ@РDŸÂ€Ð·¨’‘*`’»ÀÐ@’¿Èз¨’‘*`’»ÀÐ@’¿ÈÔ·¨– •*à–»ÀÔÀ –¿ÈÔ À – Ö*@з¨’ Ò'·¨¿ÿÈ Ð'·¨Ð·¨€¢ €€Hз¨’¿ÈÔ @  ÿ€¢ €€:з¨’?þÒ'·¤Ð·¤’¿ÈÔ @  ÿ€¢ €€Ð·¤’?ÿÒ'·¤¿ÿôз¨’¿ÈÔ·¨–¿ÈÔ À –¿þÖ*@Ò·¨ÿ’¿ÈÔ·¨¿ÿ’¿ÈÖ·¨”ÿÿ–¿ÈÔ À – Ö*@Ò·¤`’¿ÈÖ·¤”à–¿ÈÔ À – Ö*@з¤’¿Èз¤’¿ÈÔ·¤–¿ÈÔ À –¿ÿÖ*@¿ÿÁз¨’?ÿÒ'·¨¿ÿ¶Ð·¨’¿ÈÔ @  ÿ€¢ €€Ð·¨’?ÿÒ'·¨¿ÿôз¨’¿Èз¨’¿ÈÔ·¨–¿ÈÔ À –¿ÿÖ*@’¿ÈРH” @nÀ'·¬ Ð'·¨Ð·¨€¢ €€$À'·¤Ð·¤€¢ ÿ€€Ð·¤’‘*`’»ÀÐ@Ò·¨€¢ € РHÒ·¬ Ò·§Ò* з¬’ Ò'·¬Ð·¤’ Ò'·¤¿ÿæз¨’ Ò'·¨¿ÿÚРHÀ"!Çàèã¿Xð' DРDÒ!lÒ'¿ì’¿È ’ ” @@’¿¸ ’ ” @:À'¿èРDÒ¿èÐ ô€¢@€€hРDÒ¿è” “*  Ò øÒ'¿ÜпÜÒ Ò'¿äпÜÒ Ò'¿àп䒑*`’¿ÈÐ@€¢ €$п䒑*`’ XРD’ Ò'¿ØпØÒ€¢`€Ð D@6ÔÒ¿ØÐ"@Ò¿ØпìÔ¿ä– ™*à” Ð DÒ@Ô LÿýÓп䒑*`’¿È” Ô"@Ð¿à’‘*`’¿¸Ð@€¢ €$Ð¿à’‘*`’ hРD’ Ò'¿ØпØÒ€¢`€Ð D@6ªÒ¿ØÐ"@Ò¿ØпìÔ¿à– ™*à” Ð DÒ@Ô \ÿý©Ð¿à’‘*`’¿¸” Ô"@Ð¿è’ Ò'¿è¿ÿ”Çàè㿈ð' DРDÒ Ö@РD’ ” lŸÂÀÐ'¿ìРDÒ¿ìÒ"!lпìt’¢Ò"À'¿èп耢 €€Ð¿ìÒ¿è” “*  Ò¿ìÔ¿è– •*à’@ À"`<À" ,пìÒ¿è” “*  Ò¿ìÔ¿è– •*à’@ À"`\À" LÐ¿è’ Ò'¿è¿ÿßÇàè㿈¤ ¢¦è  €¤`€ Р Ò (Ð"`Р ÒÔ@Р ŸÂ€’ ‘*@’?ÿ¦ À ¨’ "@§,ÀР¦À€¥ €€6‘<à’ ÿÒ'¿ìЀҿïÒ* Ð$€Ò ÿ’Ò$ €¢`€ ÿù¦€¢ €° €#п쀢 ÿ€Ð€À* Ð$€Ò ÿ’Ò$ €¢`€ ÿùŽ€¢ €° € §,à¨?ø¿ÿÉæ$ è$  ° €Çàèã¿xð' Dò' HРDÒ!lÒ'¿ìпìÒ DÒ" пìÒ HÒ" РDÒ!<”`€  `?ÿÐ'¿èРDÒ!D€¢`€Ð¿è€¢ €Ð¿ì~’£`Ò" €Ð¿ì’¢(Ò" €Ð¿è€¢ €Ð¿ì€’¡„Ò" €Ð¿ì€’£DÒ" пìÒ @€¢`€ РDÒ Ö@РD’ ”#èŸÂÀÒ¿ìÐ"`@РH€¢ €Ð¿ì‚’ (Ò" €Ð¿ì’£¤Ò" À'¿äРDÒ¿äÐ ô€¢@€€sРDÒ¿ä” “*  Ò øÒ'¿ÜпìÒ¿ä” “*  À" $п耢 €Ð DÒ!D€¢`€€VпÜÒ Ò'¿à€Ð¿ìÒ¿ÜÔ`Ô'¿àÔ" 4РH€¢ €=Ð¿à€¢ €Ð¿à€¢ €€Ð DÒ 2Ð"`РDÒпàÐ"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿à” “*  Ò \€¢`€Ð DÒ Ö@РD’ ”$ŸÂÀÒ¿ìÔ¿à– •*à’@ Ð"`\пìÒ¿à” “* ” Р\’ ”$@‹y€ Ð¿à’‘*`’ Lпì–@РDÒ¿èÔ¿àÿ÷‰Ð¿ä’ Ò'¿ä¿ÿ‰Ð¿ìÀ" 8пìÀ" <пìÀ" пìÀ" пìÒ DÔ`ÈÔ" DпìÀ" HÇàè㿈ð' DРDÒ Ð`Ð'¿ìпìÒ DÔ Ð` ŸÂ€€¢ €Ð DÒ Ð@’ Ò" РDÒ Ð@Ò DÔÐ` ŸÂ€Ð DÒ¿ìÔ@Ô" РDÒ¿ìÔ`Ô" Çàèã¿ð' DРD’ ” @›Ð DÀ" РDÀ" Çàèã¿ð' Dò' Hô' LРDÒ €¢`€€Ð L€¢ €€Ð HÒ ‘*`“: РD” @{РH’ Ò' HРL’?ÿÒ' L¿ÿìÇàèã¿ð' DРDÒ 8€¢`€9РDà 8¢ ¡< €¢ €€¢`¿ÿø€¤`€Ð DÒ Ð@’ (Ò" РDÒ Ð@Ò DÔÐ` ŸÂ€Ò D•,`РDÒ`4@€¤`€Ò DРDÒ`8”@>РDÀ" 8Ò DÔ DРDÒ`@Ô <ÿÿ¢Ð DÀ" <Çàè㿈ð' Dò' HРDÿÿ¼Ð DÒ €¢`€.РDÿÿƒÒ D`Ò” ÿÔ*@’`Ò"Ò DРDÒ DÔ`’¿ÿ” Ô" €¢ €Ð DÿÿIÒ D`ÒÔ K–¿ÐÖ*@’`Ò"Ò DРDÒ DÔ`’¿ÿ” Ô" €¢ €Ð Dÿÿ4РDÒ Ða<€¢ €À'¿ìРDÒ Ð¿ìÒ`ô€¢ €€ РDÒ¿ì” “*  À" $Ð¿ì’ Ò'¿ì¿ÿî€Ð DÀ" 8РDÀ" <Çàèã¿xð' Dò' HРDÒ!lÒ'¿ìРDÒ!HÒ'¿àпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" РDÒ È€¢`€ пìÒ D€¢`€Ò¿ìпìÒ`Hÿÿ†À'¿èРDÒ¿èÐ!€¢@€€Zп蒑*`Ò H ÒÒ'¿ÜРDÒ¿è” “*  Ò!Ò'¿äРDÒ¿ä” “*  Ò øÒ'¿ØпÜÒ‘*`£: пà£<@пìÒ¿ä” “*  Ò $ $@ пìÒ¿ä” “*  â" $¢€¤ €  ¢ÿ¤ €¤ €€¤ ¡< ¿ÿù€¤  € РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿ØпìÒ`”@¶€¤ €Ð¿ì’”@XÐ¿è’ Ò'¿è¿ÿ¢Ò DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" РDÒ È€¢`€Ð¿ìÒ D€¢`€Ð¿ìÒ DÔ`ÈÔ" DÒ¿ìпìÒ¿ìÔ`H’ Ò" HпìÒ¿ìÔ`H’  Ò" HÒ¿ìпìÒ¿ìÔ`D’¿ÿÒ" D° €Çàèã¿€ð' Dò' HРDÒ!lÒ'¿ìРDÒ!@Ò'¿èРDÒ!HÒ'¿äпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" РDÒ È€¢`€ пìÒ D€¢`€Ò¿ìпìÒ`HÿþÑРHÒÒ'¿à¦ РDè!<п耥€€gÃ’•*`’!(€ Ò “* Ô¿à@ Ò‘*`¡: €¢ €¦à€P€¤ €  пä¡<¢< €Ð¿ä¡<¢€¤ €¦à€>пìÒ 8€¢`€Ð¿ìÿþW€¤à€€ Ò¿ìпìÒ`4” ð@¦ÿð¿ÿô¤ ¡< €¢ €€¤ ¿ÿø€¤  € РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿ì‘,à”пìÒ`4@îп쒔@“¦ ¨ ¿ÿ—€¤à€Ò¿ìпìÒ¿ìÔ`8’ Ò" 8Ò¿ìÐ`8’£ÿ€¢ €Ð¿ìÿþ Ò DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" РDÒ È€¢`€Ð¿ìÒ D€¢`€Ð¿ìÒ DÔ`ÈÔ" DÒ¿ìпìÒ¿ìÔ`H’ Ò" HпìÒ¿ìÔ`H’  Ò" HÒ¿ìпìÒ¿ìÔ`D’¿ÿÒ" D° €Çàèã¿€ð' Dò' HРDÒ!lÒ'¿ìРDÒ!HÒ'¿äпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" РDÒ È€¢`€ пìÒ D€¢`€Ò¿ìпìÒ`HÿýýÀ'¿èРDÒ¿èÐ!€¢@€€Ð¿è’‘*`Ò H ÒÒ'¿àпàÒ‘*`¡: пä“<Ð¿ì” @Ð¿è’ Ò'¿è¿ÿäÒ DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" РDÒ È€¢`€Ð¿ìÒ D€¢`€Ð¿ìÒ DÔ`ÈÔ" DÒ¿ìпìÒ¿ìÔ`H’ Ò" HпìÒ¿ìÔ`H’  Ò" HÒ¿ìпìÒ¿ìÔ`D’¿ÿÒ" D° €Çàèã¾pð' Dò' HРDÒ!lÒ'¿ìРDÒ!@Ò'¿ÜРDÒ!HÒ'¿ØпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" РDÒ È€¢`€ пìÒ D€¢`€Ò¿ìпìÒ`HÿýŠÐ HÒÒ'¿ÔÀ'¿èРDä!<п܀¤€€€ Ã’•*`’!(€ Ò “* Ô¿Ô@ Ò‘*`¡: €¤ €  пء<“* ¾Ðà" €¤ €ä'¿è¤ ¿ÿÞ¢ À'¿àпìÒ¿ìÐ @Ò`< Ð'¿äРDä!<п܀¤€€€g“* ¾Ðà €¢ €¢`€Y€¤`€Ð¿è€¤€€€€Ð¿ìÿüöÒ¿ìпìÒ`4” ð@µ¢ðпìÒ¿äÔ¿àÿüÆпìÒ @Ò'¿äÀ'¿à¿ÿ․ € ¿àÒÖ¿ä”@ –˜ àØ*€’`Ò"€*пìÿüÓÒ¿ì‘,`” пìÒ`4@‘Ã’•*`’!(€ Ò “* Ô¿Ô@ Ò•*`‘: ’: ¡2`п쒔 @'пìÒ¿äÔ¿àÿüпìÒ @Ò'¿äÀ'¿à¢ ¤ ¿ÿ—€¤`€Ð¿à€¢ €€Ò¿ìпìÒ¿ìÔ`8’ Ò" 8пìÒ¿ìÔ`<Ò¿à”€ Ô" <Ò¿ìÐ`8’£ÿ€¢ € пìÒ <€¢c©€€Ð¿ìÿü…Ò DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" РDÒ È€¢`€Ð¿ìÒ D€¢`€Ð¿ìÒ DÔ`ÈÔ" DÒ¿ìпìÒ¿ìÔ`H’ Ò" HпìÒ¿ìÔ`H’  Ò" HÒ¿ìпìÒ¿ìÔ`D’¿ÿÒ" D° €Çàè㿈ð' DРDÒ!lÒ'¿ìпìÒ DÔ`Ò€Ò" пìÒ DÔ`Ò Ò" пìÿüEпìÿüÒ DÐ`Ò¿ìÔ`Ô"Ò DÐ`Ò¿ìÔ`Ô" Çàèã¿hð' DРDÒ!lÒ'¿ìпìÿü.РDÒ!<”`€  `?ÿÐ'¿è’¿È ’ ” @‡ À'¿äРDÒ¿äÐ ô€¢@€€XРDÒ¿ä” “*  Ò øÒ'¿Üп耢 €Ð DÒ!D€¢`€€AпÜÒ Ò'¿à€Ð¿ÜÒ Ò'¿àÐ¿à’‘*`’¿ÈÐ@€¢ €1п耢 € Ð¿à’‘*`’ XРD’ Ò'¿Ø€ Ð¿à’‘*`’ hРD’ Ò'¿ØпØÒ€¢`€Ð D@0 Ò¿ØÐ"@Ò¿ØпìÔ¿à– ™*à” Ð DÒ@Ô \ÿ÷ŸÐ¿à’‘*`’¿È” Ô"@Ð¿ä’ Ò'¿ä¿ÿ¤Çàè㿈ð' DРDÒ Ö@РD’ ” lŸÂÀÐ'¿ìРDÒ¿ìÒ"!lпì}’ (Ò"À'¿èп耢 €€Ð¿ìÒ¿è” “*  À" LпìÒ¿è” “*  À" \Ð¿è’ Ò'¿è¿ÿëпìÀ" @Çàè㿈¤ ¢¦è €¤`€ Р Ò (Ð"`Р ÒÔ@Р ŸÂ€Ð  €¢ €€=’ ‘*@’?ÿ¦ À ¨’ "@§,ÀР¦À€¥ €€,‘<à’ ÿÒ'¿ì ÒÔ¿ïÔ*@’`Ò"Ò ÿ’Ò$ €¢`€ÿûп쀢 ÿ€ ÒÀ*@’`Ò"Ò ÿ’Ò$ €¢`€ÿúî§,à¨?ø¿ÿÓæ$ è$ Çàè㿈¤ ¢Ð  €¢ €’‘*`”“* €Ô \@ ’‘*`”“* €Ô \@ ”“* –•*à’€ Ö`\’€ Ô@’ Ò"€“* € Ò LÒ'¿ìÒ¿ì•* пì–Ð ä™* —; Ò@ ” ÿÿxÇàèã¿€ð' Dò' Hô' LРDÀ" РH€¢ >€Ð DÒ Ð"`РDÒ >Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð L€¢!ЀРDÒ Ð"`РDÒ!ÐÐ"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð DÒÒ'¿èРDÒ Ò'¿äРD’ ”!Ð@…ÈРDÒ¿èÒ"РDÒ¿äÒ" РD’ Ò" РD@8ŒÐ DÀ" РDÀ" À'¿ìп쀢 €€ РDÒ¿ì” “*  À" ¤Ð¿ì’ Ò'¿ì¿ÿñÀ'¿ìп쀢 €€Ð DÒ¿ì” “*  À" ´Ð DÒ¿ì” “*  À" ÄÐ¿ì’ Ò'¿ì¿ÿëРDÀ"!0РD@âРD@dРD’ ÈÒ" Çàèã¿ð' DРD@/Çàèã¿ð' DРD@.æÇàèã¿€ð' DÒ DÐ`$€¢ €€¢ €€¢ € €ß€¢ €¢€ÚРD’ Ò" (РD’ Ò" ,€ØРDÒ!€¢`€Ð D’ Ò" (€‰Ð DÒ!$€¢`€/РDÒ !( `ÿ€¢ €€¢ € € РD’ Ò" (€Ð D’ Ò" (€Ð DÒ rÐ"`Ò DÐ@Ò DÔ a(’  ÿÒ" РDÒÔ`РD’?ÿŸÂ€Ð D’ Ò" (€€WРDÒ ØÐ@Ð'¿ìРD’ TÔ Ø@ ÒÒ'¿èРD’ ¨Ô Ø@ ÒÒ'¿äп쀢 €Ð¿è€¢ € п䀢 €Ð D’ Ò" (€6п쀢 R€Ð¿è€¢ G€ п䀢 B€Ð D’ Ò" (€%РDÒ`Ð'¿àпàÒ¿ìÒ" Ò¿à Ò¿èÒ" Ò¿à Ò¿äÒ"РDÒ oÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿâРD’ Ò" (РD’ Ò" ,€BРDÒ!$€¢`€/РDÒ !( `ÿ€¢ €€¢ € € РD’ Ò" (€Ð D’ Ò" (€Ð DÒ rÐ"`Ò DÐ@Ò DÔ a(’  ÿÒ" РDÒÔ`РD’?ÿŸÂ€Ð D’ Ò" (€€Ð D’ Ò" (РD’ Ò" ,€Ð DÀ" (РDÀ" ,€Ð D’ Ò" 0РD’ Ò" 4РDÃÔ` Ô: 8РDÀ" @РDÀ" DРDÀ" HРD’ Ò" LРD’ Ò" PРDÀ" TРD’ Ò" XРD’ Ò" \РD’!Ò" `РDÀ" ˆÐ DÀ" dРDÀ" hРDÀ" lÇàè㿈ð' Dò' HРDÒ €¢`ȀРDÒ €¢`ɀРDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð D@5Ð'¿ìп쀢 €€¢ €€¢ €"€"€¢ €€ Ð'¿ì€Ð H€¢ € РDÒ 3Ð"`РDÒÔ@РDŸÂ€Ð D@- Ð'¿ì€€Ð¿ì°€Çàè㿈ð' DÀ'¿ìРDÒ 8€¢ €C’‘*`…’¡,Ð ÂX”àðððððððРDÒ!´Ô`РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð D’ ÉÒ" РDÒ!´Ô@РDŸÂ€Ð'¿ìп쀢 €Ð Dÿþ[РD’ ÊÒ" € Ð'¿ì€Ð DÒ!´Ô@РDŸÂ€Ð'¿ì€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð¿ì°€Çàèã¿ð' DРDÒ €¢`Ç€ РDÒ €¢`Ò€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!´Ð`°€Çàèã¿ð' DРDÒ €¢`É€ РDÒ €¢`Ò€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!´Ð`°€Çàèã¿ð' DРDÒ €¢`Í€ РDÒ €¢`΀€#РDÒ @€¢`€Ð DÒ DÐ ŒÒ`t€¢ € РDÒ CÐ"`РDÒÔ@РDŸÂ€Ð DÒ!¤Ô`РDŸÂ€Ð D’ ÒÒ" € РDÒ €¢`πРD’ ÒÒ" €Ð DÒ €¢`ҀРDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!´Ð`€¢ €€Ð DÒ!´Ô@РDŸÂ€€¢ €° €¿ÿìРDÒ Ô`РDŸÂ€Ð D@,_° €Çàè㿈ð' DРDÒ €¢`ʀРD@РD’ ÑÒ" РDÒ €¢`Ñ€NРDÒ €¢`€Ð DÒ Ô@РDŸÂ€Ð DÒ!´Ô@РDŸÂ€Ð'¿ìп쀢 €° €^п쀢 €€,РDÒ €¢`€%п쀢 €Ð¿ì€¢ €€Ò DÐ`Ò DÐ`Ò DÔ`Ò ”`’ Ò" РDÔ Ð €¢@€ Ò DÐ`Ò DÔ`Ò DÔ Òa@”€ Ô" ¿ÿ¹Ð D’ ÒÒ" РDÒ €¢`Ò€ РDÒ €¢`Ï€€ РDÒ @€¢`€Ð DÒ!¬Ð`°€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€° €Çàè㿈ð' DРD’ Ò" @РDÒ à€¢`€Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ Ü€¢`€Ð D@#}€Ð D@-РD’ @+РDÒ Ô`РDŸÂ€Ð DÒ!´Ô`РDŸÂ€Ð DÒ €¢`€/РDÒ Ü€¢`€ Ò DÐ`$”“* ’@`Ð'¿ì€Ð DÒ!´Ð`€¢ €Ð DÒ $Ò'¿ì€ Ð'¿ìРDÒ À"`РDà Ò DÐa@Ò¿ì@ÿÐ$ РDÒ À"` РDÒ  Ð"`Çàè㿈ð' DРDÒ Ò'¿ìÐ¿ì’ Ò" $Çàè㿈ð' DРDÒ Ò'¿ìпìÖ¿ìÐ ’ Öà@ðÐ'¿èп耢 €(пìÒ $€¢`€ РDÒ *Ð"`РDÒÔ@РDŸÂ€Ð DÒ xÐ"`РDÒÔ`РD’?ÿŸÂ€Ð¿ìÒ  ÿÐ*@Ð¿ì’ Ô @ ’ ÙÒ* Ð'¿èпìÒ¿ìÔ` Ô"пìÒ¿èÒ" пìÀ" $° €Çàè㿈ð' Dò' HРDÒ Ò'¿ìРH€¢ € пìÒ HÐ €¢@€€ пìÒ HÐ ’"@Ò' HРDÿÿ¢¿ÿðпìÒ¿ìÔ@Ò H”€ Ô"пìÒ¿ìÔ`Ò H”"€ Ô" Çàèã¿ð' DÇàè㿈ð' Dò' HРDÒ €¢`€Ð DÒ Ö@РD’ ” (ŸÂÀÒ DÐ"`РDÒ Ò'¿ìРDÒ Ö@РD’ ŸÂÀÒ¿ìÐ"` РDÒ Ò'¿ìп쇒¡Ò" п쇒¡@Ò" п쇒¢XÒ" п윒£Ò" п쇒£Ò" пìÒ HÒ" пìÀ" пìÀ"Çàè㿈ð' DÒ DÐ` ?’£Ü€¢ € Ò DÐ`?’£Ü€¢ €€Ð DÒ )Ð"`Ò DÐ@?’£ÜÒ" РDÒÔ@РDŸÂ€Ð DÒ Ô€¢`€Ð DÒ Ð"`Ò DÐ@Ò DÔ`ÔÔ" РDÒÔ@РDŸÂ€Ð DÒ $€¢` €Ð DÒ Ð"`Ò DÐ@Ò DÔ`$Ô" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð D’ Ò"!4РD’ Ò"!8À'¿ìРDÒ ØÒ'¿èРDÒ¿ìÐ $€¢@€€>пèÒ €¢`€Ð¿èÒ €¢`€Ð¿èÒ €¢`€ пèÒ €¢`€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÖ¿èÔàÖa4€¢€ €Ôa4Ô"!4РDÒ DÖ¿èÔà Öa8€¢€ €Ôa8Ô"!8Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ¾Ð D’ Ò"!<À'¿ìРDÒ ØÒ'¿èРDÒ¿ìÐ $€¢@€€HÐ¿è’ Ò" $РDÒ¿èÐ Ò`@€…Ò DÔa4’ •*`’ @*[Ò¿èÐ"`РDÒ¿èÐ Ò` @€vÒ DÔa8’ •*`’ @*LÒ¿èÐ"` РDÒ¿èÐ Ò`@€gÒ DÒa4@*@Ò¿èÐ"`(РDÒ¿èÐ Ò` @€[Ò DÒa8@*4Ò¿èÐ"`,Ð¿è’ Ò" 0пèÀ" LÐ¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ´Ð DÒ DÔa8’ •*`Ð ’ @*Ò DÐ"a@РDÒ DÐ!HÒ`$€¢ € РDÒ Ü€¢`€€Ð DÒ!´ Ð"`€Ð DÒ!´À"`Çàèã¿€ð' DРDÒ!H€¢`€6РDÒ!LÒ'¿àРDÒ¿àÔ`Ô"!\РDÒ¿àÔ` Ô"!`Ð¿à’ Ò" 4Ð¿à’ Ò" 8Ð¿à’ Ò" <пàÒ¿àÔ`$Ô" @Ð¿à’ Ò" DпàÒ¿àÔ  Ò` @€ Ð'¿äп䀢 €Ð¿àÒ Ò'¿äпàÒ¿äÒ" HРD’ Ò"!dРDÀ"!h€¶Ð DÒ!H€¢`€ РDÒ!H€¢`€€Ð DÒ Ð"`Ò DÐ@Ò DÔaHÔ" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÔa4’ •*`Ð ’ @)žÒ DÐ"a\РDÒ DÔa8’ •*`Ð ’ @)“Ò DÐ"a`РDÀ"!dÀ'¿ìРDÒ¿ìÐ!H€¢@€€vРDÒ¿ì” “*  Ò!LÒ'¿àпàÒ¿àÔ`Ô" 4пàÒ¿àÔ` Ô" 8à¿àпàÒ¿àÐ 4Ò`8@“Ð$ <à¿àпàÒ¿àÐ 4Ò`$@‹Ð$ @пàÒ¿àÔ  Ò`4@’Ð'¿äп䀢 €Ð¿àÒ 4Ò'¿äпàÒ¿äÒ" DпàÒ¿àÔ  Ò`8@€Ð'¿äп䀢 €Ð¿àÒ 8Ò'¿äпàÒ¿äÒ" HпàÒ <Ò'¿èРDÒ!dÔ¿è@ €¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€¿èÒ” ’ÿÒ"€¢ €€Ô DÒ DadÒ– ™*à”€ Ö¿ìÖ"¡h’`Ò"¿ÿëÐ¿ì’ Ò'¿ì¿ÿ†Çàèã¿€ð' DÀ'¿ìРDÒ¿ìÐ!H€¢@€€OРDÒ¿ì” “*  Ò!LÒ'¿äпäÒ L€¢`€€<пäÒ Ò'¿èп耢 €Ð¿è€¢ € РDÒ¿è” “*  Ò ¤€¢`€€Ð DÒ 4Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð DÒ Ö@РD’ ” „ŸÂÀÐ'¿àРDÒ¿è” “* ” пàÒ ¤” „@~ÚпäÒ¿àÒ" LÐ¿ì’ Ò'¿ì¿ÿ­Çàèã¿ð' DРDÿþ²Ð Dÿÿ Ð DÒ!¼Ô@РDŸÂ€Ð DÒ!¬Ô@РDŸÂ€Ò DÐa´Ò DÔa¬Ò Ò"Çàèã¿ð' DÒ DÐa´Š’¢Ò"Çàè㿈ð' DРDÒ!´Ò'¿ìпìÒ €¢`€° €gРDÒ!¸Ô`РDŸÂ€Ð'¿èп耢 €€¢ €€¢ €P€P€¢ €$€KпìÒ €¢`€ РDÿýQпìÀ" €Ð¿ìÒ €¢`€ РDÒ #Ð"`РDÒÔ@РDŸÂ€Ð Dÿÿš€+Ð¿ì’ Ò" пìÒ €¢`€Ð DÒ!¸Ð`€¢ € РDÒ ;Ð"`РDÒÔ@РDŸÂ€€ РDÒ DÐ ˜Ò`€¢ €Ð DÒ DÔ`Ô" ˜€€Ð¿è°€Çàè㿈ð' DРDÒ!´Ò'¿ìп슒¢Ò"пìÀ" пìÀ" Ð¿ì’ Ò" РDÒÔ`РDŸÂ€Ð DÒ!¸Ô@РDŸÂ€Ð DÀ"  Çàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!´Ð¿ìŠ’¢Ò"п슒£ìÒ" п슒¡ˆÒ" п슒¡øÒ" пìÀ" пìÀ" Ð¿ì’ Ò" Çàè㿈ð' DРDÒ fÐ"`РDÒÔ`РD’ ŸÂ€Ð DÒ!¸Ð` €¢ € РDÒ =Ð"`РDÒÔ@РDŸÂ€À'¿ìп쀢 €€Ð DÒ¿ì À* äРDÒ¿ì ’ Ò* ôРDÒ¿ì ’ Ò*!Ð¿ì’ Ò'¿ì¿ÿéРDÀ"!РDÀ" (РDÀ"!,РDÀ"!РD’ Ò*!РD’ Ò*!РDÀ*!РD’ Ò2! РD’ Ò2!"РDÀ"!$РDÀ*!(РDÒ!¸ Ð"` ° €Çàèã¿pð' Dò' Hô' LРDÒ Ò'¿ÜпÜÒÒ'¿ØпÜÒ Ò'¿ÔРDÒ HÒ" ÜРDÒ LÒ" àпԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €XпÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿Ô¿ØÒÖ @” àÿ—* Ö'¿ì’`Ò"пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €8пÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿Ô¿ØÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿Ô€¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €Ð¿ÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ D¿ØÒÖ @˜ àÿØ" Ô’`Ò"€¿ÿÞпԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €íпÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ D¿ØÒØ @– ÿ™*àØ"  ’`Ò"пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €ÌпÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔРDÖ D’¿ØÔ@Ú €˜ `ÿÖà ˜À Ø" ” Ô"@€¿ÿºÐ¿Ô€¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €¤Ð¿ÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ D¿ØÒØ @– ÿ™*àØ" ’`Ò"пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €ƒÐ¿ÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔРDÖ D’¿ØÔ@Ú €˜ `ÿÖà˜À Ø" ” Ô"@€¿ÿºÐ¿Ô€¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €[пÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ D¿ØÒÖ @˜ àÿØ" $’`Ò"€¿ÿÞпì’?øÒ'¿ìРDÒ`Ð'¿ÐпÐÒ DÔa Ô" Ò¿Ð Ò DÔ`Ô" Ò¿Ð Ò DÔ` Ô" Ò¿Ð Ò DÔ`$Ô"РDÒ dÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÙРDÒ!¸Ð`€¢ € РDÒ :Ð"`РDÒÔ@РDŸÂ€Ð DÒ €¢`€Ð DÒ €¢`€ РDÒ $€¢`€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ò DÐ`$”“* ’@п쀢 € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ø€¢`€Ò DÐ`Ô DÒ $– •*à”€ —* –À •*àÖРD’ ŸÂÀÒ DÐ"`ØÀ'¿äРDÒ ØÒ'¿àРDÒ¿äÐ $€¢@€€¬Ð¿àÒ¿äÒ" пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €§Ð¿ÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ¿à¿ØÒÖ @˜ àÿØ"€’`Ò"€¿ÿÞпԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €‚пÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿Ô¿ØÒÔ @–  ÿÖ'¿è’`Ò"€¿ÿßпàÔ¿è“: ” `Ô" пàÒ¿è” `Ô" пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €VпÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ¿à¿ØÒÖ @˜ àÿØ" ’`Ò"€¿ÿÞРDÒ`Ð'¿ÐпÐÒ¿àÔ@Ô" Ò¿Ð Ò¿àÔ`Ô" Ò¿Ð Ò¿àÔ` Ô" Ò¿Ð Ò¿àÔ`Ô"РDÒ eÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÙÐ¿ä’ Ò'¿äÐ¿à’ TÒ'¿à¿ÿPРDÒ!¸ Ð"`пÜÒ¿ØÒ"пÜÒ¿ÔÒ" ° €Çàèã¿`ð' DРDÒ Ò'¿ÐпÐÒÒ'¿ÌпÐÒ Ò'¿ÈРDÒ!¸Ð`€¢ € РDÒ >Ð"`РDÒÔ@РDŸÂ€Ð¿È€¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €ïпÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÖ @” àÿ—* Ö'¿ì’`Ò"пȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €ÏпÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿È€¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €©Ð¿ÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿à’`Ò"€¿ÿßРDÒ gÐ"`РDÒпàÐ"`РDÒÔ`РD’ ŸÂ€Ð¿à’‘*`’ п쀢 € Ð¿à€¢ €Ð¿à€¢ €€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ¿àÒ"!HÀ'¿èпèÒ¿à€¢ €€«Ð¿È€¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €PпÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ø’`Ò"€¿ÿßпȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €,пÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßÀ'¿äРDÒ ØÒ'¿ÔРDÒ¿äÐ $€¢@€€Ð¿ÔÒ¿ØЀ¢@€€Ð¿ä’ Ò'¿äпԒ TÒ'¿Ô¿ÿêРDÒ Ð"`РDÒпØÐ"`РDÒÔ@РDŸÂ€Ð DÒ¿è” “*  Ò¿ÔÒ"!LпÔÔ¿Ü“: ” `Ô" пÔÒ¿Ü” `Ô" РDÒ`Ð'¿ÄпÄÒ¿ØÒ" Ò¿Ä Ò¿ÔÔ`Ô" Ò¿Ä Ò¿ÔÔ`Ô"РDÒ hÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿàÐ¿è’ Ò'¿è¿ÿRпȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €¦Ð¿ÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßРDÒ¿ÜÒ"!пȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €€Ð¿ÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßРDÒ¿ÜÒ"!”пȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €ZпÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßРDÔ¿Ü“: ” `Ô"!˜Ð DÒ¿Ü” `Ô"!œÐ DÒ`Ð'¿ÄпÄÒ DÔaÔ" Ò¿Ä Ò DÔa”Ô" Ò¿Ä Ò DÔa˜Ô" Ò¿Ä Ò DÔaœÔ"РDÒ iÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÙРDÒ!¸À"`Ò DРDÒ DÔ`’ Ò" пÐÒ¿ÌÒ"пÐÒ¿ÈÒ" ° €Çàèã¾Pð' DРDÒ Ò'¾¼Ð¾¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €ßо¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´¾¸ÒÖ @” àÿ—* Ö'¿ì’`Ò"о´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €¿Ð¾¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´¾¸ÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì’?þÒ'¿ìп쀢 €€‰Ð¾´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €‘о¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´¾¸ÒÔ @–  ÿÖ'¾È’`Ò"€¿ÿßРDÒ PÐ"`РDÒоÈÐ"`РDÒÔ`РD’ ŸÂ€À/¿ÐÀ'¾Ä Ð'¾Ìо̀¢ €€2о´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €Uо¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´Ð¾Ì–¿Ð’¾¸Ô@Ø €Ø*À” Ô"@€¿ÿÞо̒¿ÐÔ @  ÿÒ¾Ä@Ð'¾Äо̒ Ò'¾Ì¿ÿÌпì’?ïÒ'¿ìРDÒ`Ð'¾°Ð¾°Ò¿Ñ” `ÿÔ" Ò¾° Ò¿Ò” `ÿÔ" Ò¾° Ò¿Ó” `ÿÔ" Ò¾° Ò¿Ô” `ÿÔ" Ò¾° Ò¿Õ” `ÿÔ" Ò¾° Ò¿Ö” `ÿÔ" Ò¾° Ò¿×” `ÿÔ" Ò¾° Ò¿Ø” `ÿÔ"РDÒ VÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÁРDÒ`Ð'¾°Ð¾°Ò¿Ù” `ÿÔ" Ò¾° Ò¿Ú” `ÿÔ" Ò¾° Ò¿Û” `ÿÔ" Ò¾° Ò¿Ü” `ÿÔ" Ò¾° Ò¿Ý” `ÿÔ" Ò¾° Ò¿Þ” `ÿÔ" Ò¾° Ò¿ß” `ÿÔ" Ò¾° Ò¿à” `ÿÔ"РDÒ VÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÁоĀ¢!€ оÄҿ쀢 €€ РDÒ Ð"`РDÒÔ@РDŸÂ€À'¾ÌоÌҾĀ¢ €€,о´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €€Ð¾¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´Ð¾Ì–¾Ð’¾¸Ô@Ø €Ø*À” Ô"@€¿ÿÞо̒ Ò'¾Ì¿ÿÑпìÒ¾Ä" Ð'¿ìÒ¾È `€¢ €Ð¾È’?ðÒ'¾ÈоȒ‘*`’ ÄРD’ Ò'¾À€ оȒ‘*`’ ´Ð D’ Ò'¾ÀоȀ¢ €Ð¾È€¢ €€Ð DÒ Ð"`РDÒоÈÐ"`РDÒÔ@РDŸÂ€Ð¾ÀÒ€¢`€Ð D@!Ò¾ÀÐ"@оÀ’¿ÐД @w*оÀÒ`’¾Ð”!@w#¿þuп쀢 € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¾¼Ò¾¸Ò"о¼Ò¾´Ò" ° €Çàèã¿hð' DРDÒ Ò'¿ÔпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €ÔпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿ—* Ö'¿ì’`Ò"п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €´Ð¿ÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì’?þÒ'¿ìп쀢 €€~п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €†Ð¿ÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÔ @–  ÿÖ'¿è’`Ò"€¿ÿßпè“: Ò'¿àÐ¿è’ Ò'¿èРDÒ QÐ"`РDÒпèÐ"`РDÒпàÐ"`РDÒÔ`РD’ ŸÂ€Ð¿è€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð DÒ¿è” “*  Ò ¤€¢`€ РD@ Ò DÔ¿è– •*à’@ Ð"`¤Ð DÒ¿è” “*  Ò ¤Ò'¿ØÀ'¿äп䀢 ?€€‚Ð¿à€¢ €Iп̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €Ð¿ÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿ—* Ö'¿Ü’`Ò"п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €ôпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿÖ¿Ü”À Ô'¿Ü’`Ò"€¿ÿ½€&п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €ÌпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßпØÃÔ¿ä– •*à–a(’€ Ô@’ •*`Ò¿ÞÒ2 Ð¿ä’ Ò'¿ä¿ÿ|РDÒÐ`h€¢ €~À'¿äп䀢 ?€€wРDÒ`Ð'¿ÈпÈÒ¿ØÔ¿ä– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò"РDÒ ]Ð"`РDÒÔ`РD’ ŸÂ€€¿ÿ’Ð¿ä’ Ò'¿ä¿ÿ‡Ð¿ì’?¿Ò'¿ìÐ¿à€¢ €Ð¿ì’?ÀÒ'¿ì¿þ€Ð¿ì€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ÔÒ¿ÐÒ"пÔÒ¿ÌÒ" ° €Çàèã¿xð' DРDÒ Ò'¿äпäÒÒ'¿àпäÒ Ò'¿Üп܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €§Ð¿äÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÖ @” àÿ—* Ö'¿ì’`Ò"п܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €‡Ð¿äÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿Ü€¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €SпäÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÖ @” àÿ—* Ö'¿è’`Ò"п܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €3пäÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÖ @” àÿÖ¿è”À Ô'¿è’`Ò"€¿ÿ½Ð DÒ RÐ"`РDÒпèÐ"`РDÒÔ`РD’ ŸÂ€Ð DÒ¿èÒ"!пäÒ¿àÒ"пäÒ¿ÜÒ" ° €Çàè㿈ð' Dò' Hô' Lö' PРLÒ P Ð'¿ìРL€¢ €þРHÒ `ÿ€¢ J€ø Ò H Ò `ÿ€¢ F€ð Ò H Ò `ÿ€¢ I€è Ò H Ò `ÿ€¢ F€à Ò H Ò `ÿ€¢ €ØРD’ Ò"!РD’ Ô H’@ Ô @Ô*!РD’ Ô H’@ Ô @Ô*!РD’ Ô H’@ Ô @Ô*!РD’ Ô H’@ Ö @” àÿ“* ” Ö H”€ Ö €” àÿ’ ”@ Ô2! РD’ Ô H’@ Ö @” àÿ“* ” Ö H”€ Ö €” àÿ’ ”@ Ô2!"РDÒ ! `ÿ€¢ €Ð DÒ wÐ"`Ò DÐ@Ò DÔ a’  ÿÒ" Ò DÐ@Ò DÔ a’  ÿÒ" РDÒÔ`РD’?ÿŸÂ€Ð DÒ`Ð'¿èпèÒ DÔ a’  ÿÒ" Ò¿è Ò DÔ a’  ÿÒ" Ò¿è Ò DÔa —* “2àÒ" Ò¿è Ò DÔa"—* “2àÒ" Ò¿è Ò DÔ a’  ÿÒ"РDÒ WÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÌ Ò H ’ Ô H’@ Ð Ò @ ’ ÿ€¢`€Ð DÒ ZÐ"`Ò DÐ@’ Ô H’@ Ô @’  ÿÒ" Ò DÐ@’ Ô H’@ Ô @’  ÿÒ" РDÒÔ`РD’ ŸÂ€Ð¿ì’?òÒ'¿ì Ò H Ò `ÿ’ Ô H’@ Ô @’  ÿ@sq”“* ’@п쀢 €Ð DÒ XÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€žÐ L€¢ €‹Ð HÒ `ÿ€¢ J€… Ò H Ò `ÿ€¢ F€} Ò H Ò `ÿ€¢ X€u Ò H Ò `ÿ€¢ X€m Ò H Ò `ÿ€¢ €e Ò H Ò `ÿ€¢ € €¢ €€¢ € €:€¢ €&€5РDÒ lÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€=РDÒ mÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€,РDÒ nÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€Ð DÒ YÐ"`Ò DÐ@’ Ô H’@ Ô @’  ÿÒ" РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€€Ð DÒ MÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€Çàèã¿xð' Dò' Hô' Lö' PРL€¢ €‚РHÒ `ÿ€¢ A€| Ò H Ò `ÿ€¢ d€t Ò H Ò `ÿ€¢ o€l Ò H Ò `ÿ€¢ b€d Ò H Ò `ÿ€¢ e€\ Ò H Ô ’  ÿ‘*`’ Ô H’@ Ô @’  ÿ Ð'¿ì Ò H Ô ’  ÿ‘*`’ Ô H’@ Ô @’  ÿ Ð'¿è Ò H Ô ’  ÿ‘*`’ Ô H’@ Ô @’  ÿ Ð'¿ä Ò H Ò `ÿÐ'¿àРDÒ`Ð'¿ÜпÜÒ¿ìÒ" Ò¿Ü Ò¿èÒ" Ò¿Ü Ò¿äÒ" Ò¿Ü Ò¿àÒ"РDÒ LÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÝРD’ Ò"!$РDÒ¿ãÒ*!(€Ð DÒ NÐ"`Ò DÐ@Ò LÔ P’@ Ò" РDÒÔ`РD’ ŸÂ€Çàèã¿`ð' DРDÒ Ò'¿ÌпÌÒÒ'¿ÈпÌÒ Ò'¿ÄпĀ¢ €Ð¿ÌÒ Ð DŸÂ@€¢ €° €ÂпÌÒÒ'¿ÈпÌÒ Ò'¿ÄпĒ?ÿÒ'¿Ä¿ÈÒÖ @” àÿ—* Ö'¿ì’`Ò"пĀ¢ €Ð¿ÌÒ Ð DŸÂ@€¢ €° €¢Ð¿ÌÒÒ'¿ÈпÌÒ Ò'¿ÄпĒ?ÿÒ'¿Ä¿ÈÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì’?þÒ'¿ìп쀢 € Ð'¿Ð€ п쀢 €Ð¿ìÐ'¿Ð€À'¿ÐÀ'¿ÔпÔҿЀ¢ €€,пĀ¢ €Ð¿ÌÒ Ð DŸÂ@€¢ €° €_пÌÒÒ'¿ÈпÌÒ Ò'¿ÄпĒ?ÿÒ'¿ÄпԖ¿Ø’¿ÈÔ@Ø €Ø*À” Ô"@€¿ÿÞпԒ Ò'¿Ô¿ÿÑпìÒ¿Ð" Ð'¿ìÒ DÐa €¢ à€€¢ î€ €’¿ØРDÔ¿ÐÖ¿ìÿý€’¿ØРDÔ¿ÐÖ¿ìÿþ³€Ð DÒ DÐ"`Ò DÐ@Ò DÔa Ô" РDÒÔ@РDŸÂ€€Ð¿ÌÒ¿ÈÒ"пÌÒ¿ÄÒ" п쀢 € РDÒ Ô`РDÒ¿ìŸÂ€° €Çàèã¿hð' DРDÒ!¸Ò'¿ìпìÒ ¤Ò'¿èÀ'¿ØРDÒ Ò'¿ÔпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп耢 €“п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €GпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿ—* Ö'¿Ø’`Ò"п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €'пÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿÖ¿Ø”À Ô'¿Ø’`Ò"€¿ÿ½Ð¿Ø’?þÒ'¿Øп؀¢ €BРDÒ! €¢`þ€Ð¿ìÒ `Ò'¿È€ пìÒ DÔa ’¿ ” “*  Ò dÒ'¿ÈпØÒ¿È€¢ €Ð¿ØÐ'¿ÈÒ DÐ`Ò¿È”`Ö Ð D’ ŸÂÀÐ'¿èпèÀ"пèÒ DÔ a£Ô* пèÒ¿ØÒ" пèÒ¿ÈÒ" пèÔ¿è’ ” Ô" Ô'¿ÜпìÒ¿èÒ" ¤Ð¿ìÀ" ¨À'¿äпÈÐ'¿à€À'¿àÀ'¿äÀ'¿Ü€ пìÒ ¨Ò'¿äпèÒ Ò'¿àпèÒ Ð¿ä’@Ò'¿ÜпäÒ¿à€¢ €€BпÔÒ¿ÐÒ"пÔÒ¿ÌÒ" пìÒ¿äÒ" ¨Ð¿Ì€¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €šÐ¿ÔÒÒ'¿ÐпÔÒ Ò'¿ÌпäÒ¿à€¢ €Ð¿Ì€¢ €€€¿ÜÒ”¿ÐÖ€Ø ÀØ*@–àÖ"€’`Ò"п̒?ÿÒ'¿ÌÐ¿ä’ Ò'¿ä¿ÿã¿ÿ»Ð¿è€¢ €&РDÒ!0€¢`€Ð DÒ¿èÒ"!0€Ð DÒ!0Ò'¿ÈпÈÒ€¢`€€Ð¿ÈÒÒ'¿È¿ÿöпÈÒ¿èÒ"пèÒ Ò'¿ÜпèÒ Ð¿à’"@Ò'¿ØпìÀ" ¤Ò DÐa €¢ à€€¢ î€ €Ð DÒ¿ÜÔ¿àÖ¿Øÿû¯€"РDÒ¿ÜÔ¿àÖ¿ØÿýN€Ð DÒ [Ð"`Ò DÐ@Ò DÔa Ô" Ò DÐ@Ò¿àÔ¿Ø’@ Ò" РDÒÔ`РD’ ŸÂ€€Ð¿ÔÒ¿ÐÒ"пÔÒ¿ÌÒ" п؀¢ € РDÒ Ô`РDҿ؟€° €Çàèã¿€ð' DРDÒ Ò'¿èпèÒÒ'¿äпèÒ Ò'¿àÐ¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €cпèÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÖ @” àÿ—* Ö'¿ì’`Ò"Ð¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €CпèÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì’?þÒ'¿ìРDÒ [Ð"`Ò DÐ@Ò DÔa Ô" РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€Ð¿èÒ¿äÒ"пèÒ¿àÒ" п쀢 € РDÒ Ô`РDÒ¿ìŸÂ€° €Çàèã¿€ð' DРDÒ Ò'¿èпèÒÒ'¿äпèÒ Ò'¿àÐ¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €¼Ð¿èÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÔ @–  ÿÖ'¿ì’`Ò"€¿ÿßп쀢 ÿ€€6Ò DÐa¸Ò DÐa¸Ò DÔa¸Ò ”`Ô" пèÒ¿äÒ"пèÒ¿àÒ" Ð¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €ƒÐ¿èÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÔ @–  ÿÖ'¿ì’`Ò"€¿ÿß¿ÿÈÐ¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €]пèÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÔ @–  ÿÖ'¿ì’`Ò"€¿ÿßп쀢 ÿ€€¿ÿ×п쀢 €€Ò DÐa¸Ò DÔa¸Ò ”`Ô" пèÒ¿äÒ"пèÒ¿àÒ" ¿ÿcРDÒ!¸Ð`€¢ €Ð DÒ tÐ"`Ò DÐ@Ò DÔa¸Ò Ò" РDÒпìÐ"`РDÒÔ`РD’?ÿŸÂ€Ð DÒ!¸À"`РDÒ¿ìÒ"! Ð¿èÒ¿äÒ"пèÒ¿àÒ" ° €Çàèã¿xð' DРDÒ Ò'¿äпäÒÒ'¿àпäÒ Ò'¿Üп܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €bпäÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÔ @–  ÿÖ'¿ì’`Ò"€¿ÿßп܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €>пäÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÔ @–  ÿÖ'¿è’`Ò"€¿ÿßп쀢 ÿ€Ð¿è€¢ Ø€€Ð DÒ 5Ð"`РDÒпìÐ"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð DÒ¿èÒ"! Ð¿äÒ¿àÒ"пäÒ¿ÜÒ" ° €Çàèã¿ð' DРDÒ! €¢`€Ð DÒ!¸Ð` €¢ € РDÿÿv€¢ €° €Q€ РDÿþ•€¢ €° €FÒ DÐa €¢ Ï€,€¢ Í€€¢ Āƀ¢ Ä€€¢ Á€ €¢ À€O€¢ €ý€€¢ €T€¢ Àx€€¢ É€Y€¢ É€p€¢ Ë€m€¢ Ë€™€[€¢ Û€ª€¢ Û€€¢ Ø€ €¢ ؀ـ¢ Ù€x€¢ Ú€g€î€¢ ï€ €¢ à€©€¢ Ü€Ú€¢ Ý€˜€à€¢ þ€²€ÛРDÿï—€¢ €° €ç€áРD’ ” ÿï倢 €° €Ú€ÔРD’ ” ÿïØ€¢ €° €Í€ÇРD’ ” ÿïË€¢ €° €À€ºÐ D’ ” ÿï¾€¢ €° €³€­Ð DÒ <Ð"`Ò DÐ@Ò DÔa Ô" РDÒÔ@РDŸÂ€€œÐ Dÿò€¢ €° €—РDÀ"! ° €’РDÒ UÐ"`РDÒÔ`РD’ ŸÂ€Ð DÀ"! ° €‚РDÿýK€¢ €° €y€sРDÿô €¢ €° €n€hРDÿõû€¢ €° €c€]РDÿ÷Þ€¢ €° €X€RÒ DÐa¸Ò DÔa ’¿ ” “*  Ò Ð DŸÂ@€¢ €° €D€>РDÒ!¸Ô`РDŸÂ€€¢ €° €6€0РDÒ \Ð"`Ò DÐ@Ò DÔa Ô" РDÒÔ`РD’ ŸÂ€€Ð Dÿü뀢 €° €€Ð DÒ DÐ"`Ò DÐ@Ò DÔa Ô" РDÒÔ@РDŸÂ€€Ð DÀ"! ¿þŸÇàèã¿ð' DРDÒ! €¢`€ РDÿý?€¢ €° €:РDÒ DÔa¸Ö ’àÐÐ! €¢ €Ð DÒ bÐ"`Ò DÐ@Ò DÔa¸Ò Ò" РDÒÔ`РD’ ŸÂ€Ð DÀ"! €Ò DÐ`Ô DÒ¡¸Ô РDÒ`ŸÂ€€¢ €° € Ò DÐa¸Ò DÔa¸Ö ’à” `Ô" ° €Çàè㿈ð' Dò' HРDÒ! Ò'¿ì Ð'¿èРDÒ yÐ"`РDÒпìÐ"`РDÒРHÐ"`РDÒÔ`РD’?ÿŸÂ€Ð¿ì€¢ ¿€ Ð'¿è€>п쀢 πп쀢 ×€€ Ð'¿è€0Ò H`’ `Ðҿ쀢@€ Ò H`’ `Ðҿ쀢@€€ Ð'¿è€Ò Hÿ’ `Ðҿ쀢@€ Ò Hþ’ `Ðҿ쀢@€€ Ð'¿è€ Ð'¿èРDÒ aÐ"`РDÒпìÐ"`РDÒпèÐ"`РDÒÔ`РD’ ŸÂ€Ð¿è€¢ €€¢ €€¢ € €€¢ €€Ð DÀ"! ° €Ð Dÿüt€¢ €° € РDÒ! Ò'¿ì€° €¿ÿ‚Çàè㿈ð' DРDÒ!¸Ò'¿ìРDÀ" ØРDÀ" РDÀ"! Ð¿ìÀ" пìÀ" пìÀ" пìÀ" ¤Çàè㿈ð' DРDÒ Ö@РD’ ” ¬ŸÂÀÐ'¿ìРDÒ¿ìÒ"!¸Ð¿ì’¢Ò"п웒 ÌÒ" п윒¢hÒ" п왒¡Ò" пìÀ" `À'¿èп耢 €€Ð¿ìÒ¿è” “*  ™’¡Ò" пìÒ¿è” “*  À" dÐ¿è’ Ò'¿è¿ÿéп엒 pÒ" п엒 pÒ" XРDÿÿ¨Çàèã¿€ð' Dò' Hô' LРDÒ!¸Ò'¿ìРDÒ Ð`0’?ìÒ'¿èРLҿ耢 €Ð¿èÐ' LРL€¢ €—càÐ'¿äРH€¢ à€ Ð L€¢ € Ð' L€ РH€¢ î€Ð L€¢ € Ð' L€™aÐ'¿äРH€¢ à€Ð H€¢ —`pÐ'¿äРH€¢ þ€ пìÒ¿äÒ" пìÒ LÒ" `€*РH€¢ ߀РH€¢ ï€Ð¿ìÔ H’¿ ” “*  Ò¿äÒ" пìÔ H’¿ ” “*  Ò LÒ" d€Ð DÒ DÐ"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Çàè㿈ð' Dò' Hô' LРDÒ!¸Ò'¿ìРH€¢ þ€Ð¿ìÒ LÒ" €"РH€¢ ߀РH€¢ ï€ Ð¿ìÔ H’¿ ” “*  Ò LÒ" €Ð DÒ DÐ"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Çàèã¿xð' DРDÒ!¼Ò'¿ìРDÒ!€¢`€Ð DÒ!”€¢`?€Ð DÒ!˜€¢`€ РDÒ!œ€¢`€€ РDÒ zÐ"`РDÒÔ`РD’?ÿŸÂ€À'¿èРDÒ¿èÐ!H€¢@€€0РDÒ¿è” “*  Ò!LÒ'¿ØпØÒ Ò'¿àпØÒ Ò'¿ÜÐ¿à’‘*`’ (пì–@РD’ Ô¿à@пܒ‘*`’ 8пì–@РD’ Ô¿Ü@vпìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿÌÀ'¿äРDÒ¿äÐ!d€¢@€€UРDÒ¿ä” “*  Ò!hÒ'¿èРDÒ¿è” “*  Ò!LÒ'¿ØпìÒ¿ä” “*  Ò¿ìÔ¿ØÖ ” —* ’@ Ô`(Ô" HпìÒ¿ä” “*  Ò¿ìÔ¿ØÖ ” —* ’@ Ô`8Ô" pпØÒ 0€¢`€Ð¿ìÒ¿ä” “*  ’ Ò" ˜Ð¿ìÒ¿ä” “*  Ò¿ØÔ`$€¢ 4€’ ’ Ò" À€Ð¿ìÒ¿ä” “*  Ò¿ìÔ¿ä– •*à’@ À"`ÀÀ" ˜Ð¿ä’ Ò'¿ä¿ÿ§Ð¿ìÀ" пìÀ" пìÀ" пìÒ DÔaÔ" $ÇàèãºPð' Dò' Hô' Lö' PРL€¢ €Ð L€¢ €€Ð DÒ 2Ð"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð H€¢ € РDÒ L” “* ” Р´€Ò DÔ L– •*à’@ Ð`ÄÐ'¿ìп쀢 €Ð DÒ 2Ð"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð PÒ€¢`€ РDÒ Ö@РD’ ”%ŸÂÀÒ PÐ"@РPÒÒ'¿èпèÒ¿ìÒ" ŒÀ'¿ä Ð'¿Üп܀¢ €€6пìÒ¿ÜÐ ’ ÿÒ'¿àÐ¿à€¢ € пäÒ¿à €¢!€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿àÿ’Ò'¿à€¢ÿ€€ ¿äÒ” –¾ÀØ¿ßØ*À ’`Ò"¿ÿïпܒ Ò'¿Ü¿ÿÈп䒾ÀÀ*@пäÐ'¿ÔÀ'º´Ð¾À“* ‘:`Ð'¿ØÀ'¿äп䒾ÀÐ @“* ‘:`€¢ €€4п䒾ÀÐ @“* ‘:`Ò¿Ø€¢ €€¿äÒ– •*à–º¸Øº´Ø"À ’`Ò"к´’ Ò'º´¿ÿé Ò¿Ø‘* Òº´€¢@€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ðº´“* Ò'º´Ð¿Ø’ Ò'¿Ø¿ÿÆÀ'¿ä Ð'¿Üп܀¢ €€5пìÒ¿ÜÔ  ÿ€¢ €#пèÒ¿Ü” “*  Ò¿ä” “* ”º¸Ö¿äÒ€ ”"À Ô" HпìÒ¿ÜÔ  ÿÒ¿ä@Ð'¿äпèÒ¿Ü” “* Ö¿ä”ÿÿ– •*à–º¸ÔÀ Ô" €Ð¿èÒ¿Ü” “* ”?ÿÔ" пܒ Ò'¿Ü¿ÿÉпèÿ’£ÿÒ" DÐ¿è’  ’ ”$@hÎÀ'¿ä Ð'¿Üп܀¢ €€H Ð'¿àпìÒ¿ÜÔ  ÿÒ¿à€¢@€€7п䒑*`’º¸” Ö¿Ü”"€ Ð@“* Ò'¿Ð Ò¿Ü" ’ ‘*@Ð'¿Ìп̀¢ €€Ð¿èҿД “*  Ò¿ÜÒ" пèÒ¿Ð Ò¿ìÔ¿ä’@ Ô `Ô*$пВ Ò'¿Ðп̒?ÿÒ'¿Ì¿ÿåÐ¿à’ Ò'¿àÐ¿ä’ Ò'¿ä¿ÿÃпܒ Ò'¿Ü¿ÿ¶Ð H€¢ €)À'¿àпàÒ¿Ô€¢ €€!пìÒ¿à Ò  `ÿÐ'º°Ðº°€¢ €Ðº°€¢ €€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿à’ Ò'¿à¿ÿÜÇàè㿈ð' D ¢ö' PРDäРDæ РDÒ Ò'¿ìпìÒ! €¢`€T€¤`€€M€¤à€Ð¿ìÒ Ô` пìŸÂ€€¢ €° €hпìÒ ä@пìÒ æ`¦ÿÿÐ €¨ ÿ¤ €¥ ÿ€,€¤à€Ð¿ìÒ Ô` пìŸÂ€€¢ €° €LпìÒ ä@пìÒ æ`¦ÿÿÐ €¨ ÿ¤ €¥ ÿ€€¿ÿ‥ €¨ ÿ€Ð¿ìè"! € ¡,  ¢`¿ÿ²€Ð P€¢€Ð¿ìÒ!¼Ð`€¢ €Ð¿ìÒ uÐ"`пìÒÔ`пì’?ÿŸÂ€Ð¿ìÒ!¼ Ð"`’ "@¡,¢ РDä"РDæ" РDà" РDâ" ° €Çàèã¿ð' D ¢ö' Pø' Tä T€¤@€Ð D’”–ÿÿe€¢ €°?ÿ€XРDà РDâ ¢$@§<’ ‘*@’?ÿ¦ À РP’•*`Ð €¤À€€§,à€¤`€Ð D’”– ÿÿA€¢ €°?ÿ€4РDà РDâ ¢ÿ“< `¦À¤ ¿ÿÝРDà" РDâ" €¤ €Ð DÒ Ð@’ vÒ" РDÒ Ð@Ò DÔ Ð`’?ÿŸÂ€° €Ò PÐ`ŒÒ P”—* ’@ Ô`H’À  Ò  `ÿ°€Çàè㿈ð' DРDÒ!¼Ò'¿ìÒ DÐa¸Ô DÒ¡¸Ô¿ìÖ ” €¢ €” •: Ò`”@ Ô" пìÀ" РDÒ!¸Ô`РDŸÂ€€¢ €° €%À'¿èРDÒ¿èÐ!H€¢@€€ пìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿïпìÒ DÔaÔ" $РDÒ! €¢`€Ð¿ìÀ" ° €Çàèã¿Pð' Dò' HРDÒ!¼Ò'¿ìРDÒ!€¢`€Ð¿ìÒ $€¢`€ РDÿÿ¨€¢ €° €æпìÒ €¢`€ØРDÐ'¿àРDÒ Ð@Ð'¿ÐРDÒ Ð`Ð'¿Ôпìà пìâ пìÒ Ò'¿ÀÒ Ò'¿ÄÒ Ò'¿ÈÐ Ð'¿ÌÀ'¿èРDÒ¿èÐ!d€¢@€€£Ð¿è’‘*`Ò H ÒÒ'¿¼Ð¿ìÒ¿è” “*  Ò HÒ'¿¸Ð¿ìÒ¿è” “*  Ò pÒ'¿´€¤`€’¿Ð ’”– ÿþc€¢ €° €œà¿Øâ¿Ü€¤`€ª €ø­<¬  ÿп¸’•*` ê €¢ € ¢$@п¸’Ð d¤ ÿ€ª ’¿Ð ’”Ö¿¸˜ÿþƤ€¢ €° €pà¿Øâ¿Ü€¤ €-€¤@€’¿Ð ’”–ÿþ"€¢ €° €[à¿Øâ¿Ü¢$@©<’ ‘*@’?ÿ¨ Ô—* ”`(’À Ô@€¥ € Ô—* ”`h’À Ô@ ¤Ð¿ìÒ¿è” “*  Ò ˜€¢`€Ð DÒ¿è” “*  Ò!hÒ'¿°Ð¿°’‘*`’¿ÀÐ@¤€Ð¿°’‘*`’¿Àä"@п¼ä2пìÒ¿è” “*  Ò À€¢`€¦ €¤à?€€‡€¤`€’¿Ð ’”– ÿýË€¢ €° €à¿Øâ¿Ü€¤`€ª €ø­<¬  ÿп´’•*` ê €¢ € ¢$@п´’Ð d¤ ÿ€ª ’¿Ð ’”Ö¿´˜ÿþ.¤€¢ €° €Øà¿Øâ¿Ü©< ¤  €¤ €;¦À€¤@€’¿Ð ’”–ÿý‡€¢ €° €Àà¿Øâ¿Ü¢$@©<’ ‘*@’?ÿ¨ Ô—* ”`(’À Ô@€¥ € Ô—* ”`h’À Ô@ ¤Ã’•*`’!(€ Ò “* Ô¿¼@ ä2€€¥ €€¦à¦à¿ÿx€j¦ €¤à?€€d€¤`€’¿Ð ’”– ÿý>€¢ €° €wà¿Øâ¿Ü€¤`€ª €ø­<¬  ÿп´’•*` ê €¢ € ¢$@п´’Ð d¤ ÿ€ª ’¿Ð ’”Ö¿´˜ÿý¡¤€¢ €° €Kà¿Øâ¿Ü©< ¤  €¤ €¦À€¤@€’¿Ð ’”–ÿüú€¢ €° €3à¿Øâ¿Ü¢$@€€¥ €€¦à¦à¿ÿ›Ð¿è’ Ò'¿è¿þYРDÒ Ð¿ÐÐ"@РDÒ Ð¿ÔÐ"`пìà" пìâ" пìÒ¿ÀÒ" Ò¿ÄÒ" Ò¿ÈÒ" Ò¿ÌÒ" Ò¿ìпìÒ¿ìÔ`$’¿ÿÒ" $° €Çàè㿈ð' DРDÒ Ö@РD’ ” èŸÂÀÐ'¿ìРDÒ¿ìÒ"!¼Ð¿ìž’¢Ò"п좒 ¸Ò" À'¿èп耢 €€Ð¿ìÒ¿è” “*  Ò¿ìÔ¿è– •*à’@ À"`8À" (Ð¿è’ Ò'¿è¿ÿëÇàèã¿hð' DРDÒ!¼Ò'¿ìРDÒ!”`€  `?ÿÐ'¿èÀ'¿äп耢 € РDÒ!”€¢`€ Ð'¿ä€Ð DÒ DÐ!Òa”€¢ € РDÒ!”€¢`?€€ Ð'¿äРDÒ!H€¢`€ Ð'¿äРDÒ!˜€¢`€ РDÒ DÔa˜’¿ÿÐ!œ€¢ € Ð'¿äРDÒ!œ€¢` € Ð'¿äп䀢 € РDÒ Ð"`Ò DÐ@Ò DÔaÔ" Ò DÐ@Ò DÔa”Ô" Ò DÐ@Ò DÔa˜Ô" Ò DÐ@Ò DÔaœÔ" $РDÒÔ@РDŸÂ€À'¿àРDÒ¿àÐ!H€¢@€€tРDÒ¿à” “* ” СLÒ Ò'¿ÌРDÒ¿Ì” “* Ð  ’ Ò'¿Ôп耢 €Ð¿ÔÒ€¢`€Ð DÒ sÐ"`РDÒпÌÐ"`РDÒÀ"`РDÒÔ`РD’?ÿŸÂ€Ð DÒ!Ò'¿ÜРDÒ¿ÜÐ!”€¢@€€9пܒ‘*`Ô¿Ô’ Ð@Ò¿Ü” “* Ô¿Ô’@ Ô@€¢ € Ð'¿ÈРDÒ!˜Ð¿È€¢@€Ð DÒ sÐ"`РDÒпÌÐ"`РDÒпÜÐ"`РDÒÔ`РD’?ÿŸÂ€Ð¿Ü’‘*`Ò¿Ô Ò DÔaœÔ"пܒ Ò'¿Ü¿ÿÃÐ¿à’ Ò'¿à¿ÿˆÐ DÒ!˜€¢`€Ð¿è€¢ €Ð¿ì¦’ Ò" €Ð¿ì§’ (Ò" €Ð¿è€¢ €Ð¿ì¨’ xÒ" €Ð¿ì¨’¢TÒ" À'¿àРDÒ¿àÐ!H€¢@€€CРDÒ¿à” “*  Ò!LÒ'¿Ðп耢 €Ð DÒ!˜€¢`€Ð¿ÐÒ Ò'¿Øпؒ‘*`’ ,пì–@РD’ Ô¿ØÿùĀпÐÒ Ò'¿Øпؒ‘*`’ ,пì–@РD’ Ô¿Øÿù´Ð¿ìÒ¿ìÔ¿Ø– •*à’@ Ô`,Ô" <пìÒ¿à” “*  À" Ð¿à’ Ò'¿à¿ÿ¹Ð¿ìÀ" пìÀ" пìÀ" пìÀ" пìÒ DÔaÔ" (Çàè㿈ð' DРDÒ!¼Ò'¿ìÒ DÐa¸Ô DÒ¡¸Ô¿ìÖ ” €¢ €” •: Ò`”@ Ô" пìÀ" РDÒ!¸Ô`РDŸÂ€€¢ €° €'À'¿èРDÒ¿èÐ!H€¢@€€ пìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿïпìÀ" пìÒ DÔaÔ" (РDÒ! €¢`€Ð¿ìÀ" ° €Çàèã¿@ð' Dò' HРDÒ!¼Ò'¿ìРDÒ!œÒ'¿èРDÒ!€¢`€Ð¿ìÒ (€¢`€ РDÿÿ£€¢ €° €èпìÒ €¢`€ÚРDÐ'¿ÐРDÒ Ð@Ð'¿ÀРDÒ Ð`Ð'¿Äпìä пìæ пìÒ Ò'¿¨Ò Ò'¿¬Ò Ò'¿°Ò Ò'¿´Ð $Ð'¿¸À'¿äРDÒ¿äÐ!d€¢@€€¡Ð¿ä’‘*`Ò H ÒÒ'¿ÜРDÒ¿ä” “*  Ò!hÒ'¿àРDÒ¿à” “*  Ò!LÒ'¿ Ð¿ìÒ¿ Ô`’ •*` Ò ,Ò'¿¤€¤à€’¿À ’”– ÿú~€¢ €° €”ä¿Èæ¿Ì€¤à€¨ €ÿø«<€ª `ÿп¤’•*` è €¢ € ¦$Àп¤’Ð d  ÿ€¨ ’¿À ’”Ö¿¤˜ÿúá €¢ €° €hä¿Èæ¿Ì€¤ €-€¤À€’¿À ’”–ÿú=€¢ €° €Sä¿Èæ¿Ì¦$À£<€’ ‘*@’?ÿ¢ @ Ô—* ”`¨’À Ô@€¤@ € Ô—* ”`è’À Ô@  Ð¿à’‘*`’¿¨@Ò   Ð¿à’‘*`’¿¨@à" пÜÔ¿è“, Ò2Ð¿ä’ Ò'¿ä¿ÿ[РDÒ Ð¿ÀÐ"@РDÒ Ð¿ÄÐ"`пìä" пìæ" пìÒ¿¨Ò" Ò¿¬Ò" Ò¿°Ò" Ò¿´Ò" Ò¿¸Ò" $Ò¿ìпìÒ¿ìÔ`(’¿ÿÒ" (° €Çàèã¿Xð' Dò' HРDÒ!¼Ò'¿ìРDÒ!”Ò'¿èРDÒ!œÒ'¿äРDÒ!€¢`€Ð¿ìÒ (€¢`€ РDÿþœ€¢ €° €õпìÒ €¢`€çпìÒ Ò'¿àÐ¿à€¢ €Ð¿à’?ÿÒ'¿à€ØРDÐ'¿ÐРDÒ Ð@Ð'¿ÀРDÒ Ð`Ð'¿Äпìæ пìè РHÒÒ'¿ÜпìÒ <Ò'¿¼Ð Dâ!п耤@€€°€¥ €’¿À ’”– ÿùŽ€¢ €° €¸æ¿Èè¿Ì€¥ €ª €?ø­<À¬  ÿп¼’•*` ê €¢ € ¨%п¼’Ð d  ÿ€ª ’¿À ’”Ö¿¼˜ÿùñ €¢ €° €Œæ¿Èè¿Ì¥<   €¤ €=¢@€¥€’¿À ’”–ÿùJ€¢ €° €tæ¿Èè¿Ì¨%¥<À’ ‘*@’?ÿ¤ € Ô—* ”`¨’À Ô@€¤€ € Ô—* ”`è’À Ô@  Ã’•*`’!(€ Ò “* Ô¿Ü@ Ô¿ä“, Ò2€/€¤ €¢`€) “*Ò'¿à€¤ €€¥€’¿À ’”–ÿù€¢ €° €.æ¿Èè¿Ì¨%’‘<À ” “*€”ÿ¤ пà’Ò'¿àпà’?ÿÒ'¿à€¢`¿ÿNРDÒ Ð¿ÀÐ"@РDÒ Ð¿ÄÐ"`пìæ" пìè" пìÒ¿àÒ" Ò¿ìпìÒ¿ìÔ`(’¿ÿÒ" (° €Çàèã¿hð' Dò' HРDÒ!¼Ò'¿ìРD’ Ð!œ“*@Ò'¿èРDÒ!€¢`€Ð¿ìÒ (€¢`€ РDÿý‰€¢ €° €YРDÐ'¿ØРDÒ Ð@Ð'¿ÈРDÒ Ð`Ð'¿Ìпìà пìâ À'¿äРDÒ¿äÐ!d€¢@€€-п䒑*`Ò H ÒÒ'¿à€¤`€’¿È ’”– ÿøŠ€¢ €° €+à¿Ðâ¿Ô¢ÿ“< `€¢ €Ð¿àÒ¿àÔ@ҿꔀ Ô2Ð¿ä’ Ò'¿ä¿ÿÏРDÒ Ð¿ÈÐ"@РDÒ Ð¿ÌÐ"`пìà" пìâ" Ò¿ìпìÒ¿ìÔ`(’¿ÿÒ" (° €Çàèã¾Hð' Dò' HРDÒ!¼Ò'¿ìРDÒ!”Ò'¿èРD’ Ð!œ“*@Ò'¿äРD’?ÿÐ!œ“*@Ò'¿àРDÒ!€¢`€Ð¿ìÒ (€¢`€ РDÿý €¢ €° €½Ð¿ìÒ €¢`€–РDÐ'¿ÈРDÒ Ð@Ð'¿¸Ð DÒ Ð`Ð'¿¼Ð¿ìæ пìè пìÒ Ò'¿ÜРHÒÒ'¿ØпìÒ <Ò'¿´À'¿°Ð Dâ!п܀¢ €Ð¿è€¤@€€ €¥ €’¿¸ ’”– ÿø€¢ €€læ¿Àè¿Ä€¥ €ª €?ø­<À¬  ÿп´’•*` ê €¢ € ¨%п´’Ð d  ÿ€ª ’¿¸ ’”Ö¿´˜ÿød €¢ €€Aæ¿Àè¿Ä¥<   €¤ €.€¤ € РDÒ vÐ"`РDÒÔ`РD’?ÿŸÂ€€¥ €’¿¸ ’”– ÿ÷±€¢ €€æ¿Àè¿Ä¨?ÿ“<À `€¢ €à¿ä€à¿à€(€¤ €% “*Ò'¿Ü€¤ €€¥€’¿¸ ’”–ÿ÷Š€¢ €€öæ¿Àè¿Ä¨%’‘<À ” “*€”ÿ¤ пܒÒ'¿Ü€xÃ’•*`’!(€ Ò “* пؒ Ò'¿ÔпÔÒ•*`‘: €¢ €:€¥ €’¿¸ ’”– ÿ÷Z€¢ €€Ææ¿Àè¿Ä¨?ÿ“<À `€¢ € пÔÒ•*`‘: Ò¿ä €¢ €Ð¿ÔÒ•*`‘: €¢ € пÔÒ¿ÔÔ@ҿ攀 Ô2€Ð¿ÔÒ¿ÔÔ@ҿ─ Ô2€¤¿ÿ€¤ €€ ¢`п耤@€€¿ÿ©€¤ €Ã’•*`’!(€ ÒÒ'¾¬Ð¾¬’‘*`Ò¿Ø à2¿°Ò– •*à–¾°Ø¾¬Ø"À ’`Ò"¢`¿þóп܀¢ €Vп耤@€€MÃ’•*`’!(€ Ò “* пؒ Ò'¿ÔпÔÒ•*`‘: €¢ €8€¥ €’¿¸ ’”– ÿöÛ€¢ €€Gæ¿Àè¿Ä¨?ÿ“<À `€¢ € пÔÒ•*`‘: Ò¿ä €¢ €Ð¿ÔÒ•*`‘: €¢ € пÔÒ¿ÔÔ@ҿ攀 Ô2€Ð¿ÔÒ¿ÔÔ@ҿ─ Ô2¢`¿ÿ±Ð¿Ü’?ÿÒ'¿ÜРDÒ Ð¿¸Ð"@РDÒ Ð¿¼Ð"`пìæ" пìè" пìÒ¿ÜÒ" Ò¿ìпìÒ¿ìÔ`(’¿ÿÒ" (° €Ð¿°€¢ €€Ò¿°ÿ’Ò'¿° “* ¾°Ò  “* Ô¿Ø@ À2¿ÿí° €Çàèã¿€ð' DРDÒ Ö@РD’ ” @ŸÂÀÐ'¿ìРDÒ¿ìÒ"!¼Ð¿ì¤’¡tÒ"À'¿àÐ¿à€¢ €€ пìÒ¿à” “*  À" ,Ð¿à’ Ò'¿à¿ÿñÒ DÐ`Ò DÔ`$’ •*`ÖРD’ ŸÂÀÒ DÐ"` Ð DÒ  Ò'¿èÀ'¿äРDÒ¿äÐ $€¢@€€À'¿àÐ¿à€¢ ?€€ ¿èÒ”?ÿÔ"@’`Ò"Ð¿à’ Ò'¿à¿ÿñÐ¿ä’ Ò'¿ä¿ÿâÇàè㿈ð' DРDÒ!¬Ò'¿ìРDÒ!H€¢`€Ð¿ì’ Ò" €Ð DÒ DÔa@’¿ÿÐ ”€¢ € пìÒ DÔaLÒ  Ò" €Ð¿ìÒ DÔaLÒ HÒ" пìÀ" пìÀ" Çàèã¿ð' DРDÀ" ”РDÿÿÒÇàè㿈ð' DРDÒ!¬Ò'¿ìпìÒ €¢`€Ð DÒ P€¢`€Ð D@Þ€¢ €Ð¿ì®’¢Ò" €Ð¿ì­’ PÒ" РDÀ" œÇàèã¿Pð' Dò' HРDÒ!¬Ò'¿ìРDÒ!\ÿÐ'¿äРDÒ!@ÿÐ'¿àпìÒ Ò'¿ÌпìÒ¿ÌÐ €¢@€€ÏпìÒ Ò'¿èпèҿ䀢 €€¾Ð¿ìÒ DÔad’ •*`Ð ’ @&Ò DÐa¼Ô¿ì’  Ô Ð DŸÂ€€¢ € пìÒ¿ÌÒ" пìÒ¿èÒ" ° €ÉÀ'¿ÜÀ'¿ØРDÒ¿ØÐ!H€¢@€€’РDÒ¿Ø” “*  Ò!LÒ'¿¸Ð¿¸Ò 0€¢`€ п¸Ò¿ÜÐ <’@Ò'¿Ü€zÒ DÐaÀÒ¿¸Ô`’ •*` Ò Ò'¿´Ð¿èҿ䀢 €Ò¿¸Ð`4€Ò¿¸Ð`DÐ'¿Èп¸Ò  “* РH @Ò¿¸Ð¿ÌÒ`$@]š’‘*`Ò@Ð'¿ÄÒ¿¸Ð¿èÒ`@@]Ð'¿ÀÀ'¿Ðп¸Ò¿ÐÐ 8€¢@€€FРDÒ ”Ð¿à€¢@ € пÌÒ¿Ð Ò¿¸Ô`H€¢ €€%пÀÐ'¿¼À'¿ÔпÔÒ¿È€¢ €€Ð¿ìÒ¿ÜÔ¿Ô’@ ” “* ” Ú¿´Ð DÒ¿¸Ô  Ö¿ÄØ¿¼ŸÃ@п¸Ò¿¼Ð $’@Ò'¿¼Ð¿Ô’ Ò'¿Ô¿ÿâп¸Ò¿ÜÐ 4’@Ò'¿Üп¸Ò $ “* пĒ Ò'¿ÄпВ Ò'¿Ð¿ÿ¶Ð¿Ø’ Ò'¿Ø¿ÿjÐ¿è’ Ò'¿è¿ÿ?пìÀ" п̒ Ò'¿Ì¿ÿ-Ò DРDÒ DÔ`œ’ Ò" œÒ DРDÒ DÖ`””à’ Ò" ”РDÔ!@€¢@ €Ð Dÿþ²° € РDÒ!´Ô` РDŸÂ€° €Çàèã¿ð' D° €Çàèã¿Xð' DРDÒ!¬Ò'¿ìÀ'¿àРDÒ¿àÐ!H€¢@€€*РDÒ¿à” “*  Ò!LÒ'¿¸Ð Dà пìÒ¿¸Ô`’ •*`¢ РDÒ¿¸Ð ”Ò` @\ä”Ö¿¸Ú РDÒ`HÖà ˜ ŸÃ@Ò¿à” “* ”¿ÀÐ"€ Ð¿à’ Ò'¿à¿ÿÒпìÒ Ò'¿ÔпìÒ¿ÔÐ €¢@€€ƒÐ¿ìÒ Ò'¿èРDÒ¿èÐ!\€¢@ €€qÀ'¿äÀ'¿àРDÒ¿àÐ!H€¢@€€NРDÒ¿à” “*  Ò!LÒ'¿¸Ò¿¸Ð¿èÒ`4@\¤Ð'¿ÐÀ'¿Øп¸Ò¿ØÐ 8€¢@€€3Ð¿à’‘*`’¿ÀÔ¿ØÖ¿Ô”€ – •*àÒ@€ ҿД “* Ð’ Ò'¿¼À'¿Üп¸Ò¿ÜÐ 4€¢@€€Ô¿ì¿äÒ– ›*à˜€ ”¿¼Ö€Ö# –à€Ö"€’`Ò"пܒ Ò'¿Ü¿ÿèпؒ Ò'¿Ø¿ÿÉÐ¿à’ Ò'¿à¿ÿ®Ò DÐa¼Ô¿ì’  Ô Ð DŸÂ€€¢ € пìÒ¿ÔÒ" пìÒ¿èÒ" ° €)Ð¿è’ Ò'¿è¿ÿ‹Ð¿ìÀ" пԒ Ò'¿Ô¿ÿyÒ DРDÒ DÖ`””à’ Ò" ”РDÔ!@€¢@ €Ð DÿýË° € РDÒ!´Ô` РDŸÂ€° €Çàèã¿`ð' Dò' HРDÒ!¬Ò'¿ìРDÒ!@ÿÐ'¿èРDÒ DÐ Ò`˜€¢ €Ð DÒ DÐ Ò`˜€¢ € РDÒ DÐ ”Ò`œ€¢ €€€Ð DÒ!´Ô@РDŸÂ€€¢ €° €¬¿ÿÛÀ'¿àРDÒ ØÒ'¿ÄРDÒ¿àÐ $€¢@€€‹Ð¿ÄÒ 0€¢`€€|РDà пìÒ¿à” “* ¢ РDÒ¿ÄÐ œÒ` @[Õ”Ö¿ÄÚ Ð DÒ`HÖà ˜ ŸÃ@Ð'¿ÔРDÒ œÐ¿è€¢@€Ð¿ÄÒ Ò'¿Ø€Ð¿ÄÒ¿ÄÔ  Ò` @[ÈÐ'¿Øп؀¢ €Ð¿ÄÒ Ò'¿ØÒ DÐaÀÒ¿à” “*  Ò Ò'¿ÀÐ¿à’‘*`Ò H ÒÒ'¿ÌÀ'¿ÜпÜÒ¿Ø€¢ €€4пܒ‘*`Ò¿Ô ÒÒ'¿ÐÀ'¿ÈÀ'¿äпÄÒ¿äÐ €¢@ €€Ú¿ÀРDÒ¿ÄÔ¿ÐÖ¿ÌØ¿ÈŸÃ@пВ €Ò'¿ÐпÄÒ¿ÈÐ $’@Ò'¿ÈÐ¿ä’ Ò'¿ä¿ÿåпÄÒ $ “* п̒ Ò'¿Ìпܒ Ò'¿Ü¿ÿÉÐ¿à’ Ò'¿àпĒ TÒ'¿Ä¿ÿqÒ DРDÒ DÖ`œ”à’ Ò" œÐ DÔ!@€¢@ €° €° €Çàèã¿pð' DРDÒ!¬Ò'¿ìÀ'¿èРDÒ Ü€¢`€ РDÒ  €¢`€€° € Ð¿ìÒ p€¢`€Ò DÐ`Ô DÒ $” —* –À •*àÖРD’ ŸÂÀÒ¿ìÐ"`pпìÒ pÒ'¿ÐÀ'¿äРDÒ ØÒ'¿ÜРDÒ¿äÐ $€¢@€€yпÜÒ LÒ'¿Ø€¢`€° €tпØÒ•*`‘2 €¢ €'пØÒ •*`‘2 €¢ € пØÒ •*`‘2 €¢ €Ð¿ØÒ •*`‘2 €¢ €Ð¿ØÒ •*`‘2 €¢ € пØÒ •*`‘2 €¢ €€° €EРDÒ¿ä” “* Ð  ’ Ò'¿ÔпÔÒ€¢`€° €6 Ð'¿àÐ¿à€¢ €€Ð¿à’‘*`Ò¿Ð Ò¿à” “* Ô¿Ô’@ Ô@Ô"Ð¿à’‘*`Ò¿Ô Ò€¢`€ Ð'¿èÐ¿à’ Ò'¿à¿ÿàпВ Ò'¿ÐÐ¿ä’ Ò'¿äпܒ TÒ'¿Ü¿ÿƒÐ¿è°€Çàèã¾pð' Dò' HРDÒ!¬Ò'¿ìРDÒ!@ÿÐ'¿èРDÒ DÐ Ò`˜€¢ € РDÒ!´Ð`€¢ €€€(РDÒ DÐ Ò`˜€¢ €Ð DÒ!”`€  `?ÿÐ'¾ÔРDÒ DÔ`œÖ¾Ô’€ Ð ”€¢ €€Ð DÒ!´Ô@РDŸÂ€€¢ €° €5¿ÿËÀ'¿ÜРDÒ ØÒ'¿´Ð DÒ¿ÜÐ $€¢@€€Ð¿´Ò 0€¢`€€Ð DÒ œÐ¿è€¢@€ п´Ò Ò'¿ÔпԒ‘*`Ð'¿ÐÀ'¿¨€Ð¿´Ò¿´Ô  Ò` @Z:Ð'¿ÔпԀ¢ €Ð¿´Ò Ò'¿ÔпÔÐ'¿Ð Ð'¿¨Ð DÒ œ€¢`€(п´Ò¿ÐÐ ’@Ò'¿ÐРDà пìÒ¿Ü” “* ¢ РDÒ œÿÒ¿´Ò` @Z”Ú Ð DÒ`HֿИ ŸÃ@Ð'¿Ìп´Ò  “* п̒ Ò'¿ÌÀ'¿¬€Ò DÐ`Ò¿ìÔ¿Ü– •*à’@ Ú Ð DÒ`H” ֿИ ŸÃ@Ð'¿Ì Ð'¿¬Ð¿ìÒ¿Ü– •*à”€ “* Ð p’ Ò'¿$п´Ò LÒ'¿ п Ò•*`‘2 Ð'¿Ð¿ Ò •*`‘2 Ð'¿Ð¿ Ò •*`‘2 Ð'¿Ð¿ Ò •*`‘2 Ð'¿Ð¿ Ò •*`‘2 Ð'¿ п Ò •*`‘2 Ð'¿Ò DÐaÀÒ¿Ü” “*  Ò Ò'¿°Ð¿Ü’‘*`Ò H ÒÒ'¿¼À'¿ØпØÒ¿Ô€¢ €€dпؒ‘*`Ò¿Ì ÒÒ'¿È﬈¢ € п؀¢ €Ð¿ÈÐ'¿Ä€ пؒ‘*`Ò¿Ì Ò?üÒ'¿Äп¨€¢ € Ò¿ÔÿÒ¿Ø€¢@€Ð¿ÈÐ'¿À€ пؒ‘*`Ò¿Ì Ò Ò'¿ÀпÄÒ•*`‘: ’Ò'¾ø Ð'¾üÐ'¿Ð¿ÈÒ•*`‘: ’Ò'¾ì Ð'¾ðÐ'¾ôпÀÒ•*`‘: ’Ò'¾à Ð'¾äÐ'¾èÀ'¿¸Ð¿´Ò ÿÐ'¿àÀ'¿äпäÒ¿à€¢ €€’¿(пȔ @sпäÒ¿à€¢ € €Ò¿Ä Ò•*`‘: Ð'¾ø €Ò¿È Ò•*`‘: Ð'¾ì €Ò¿À Ò•*`‘: Ð'¾à Ò¿$ ÒÒ'¾Ü€¢`€Qп*“* ‘:`€¢ €KоôÒ¾ì" ”“* ’@•*`п’ @YÐ'¿Ð¿€¢ €Ò¿‘*`Ò¿ Ô¿“* @Y Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿‘*`Ò¿" Ô¿“* @XðÐ'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿* Ò¿$ ÒÒ'¾Ü€¢`€Qп8“* ‘:`€¢ €KоüÒ¾ä" ”“* ’@•*`п’ @X»Ð'¿Ð¿€¢ €Ò¿‘*`Ò¿ Ô¿“* @X´Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿‘*`Ò¿" Ô¿“* @X™Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿8 Ò¿$ ÒÒ'¾Ü€¢`€SпH“* ‘:`€¢ €MоüÒ¾ä Ҿ𔠓* " ”“* ’@п@XbÐ'¿Ð¿€¢ €Ò¿‘*`Ò¿ Ô¿“* @X[Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿‘*`Ò¿" Ô¿“* @X@Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿H Ò¿$ ÒÒ'¾Ü€¢`€Sп:“* ‘:`€¢ €MпҾø" Ò¾è" Ò¾à ”“* ’@п@X Ð'¿Ð¿€¢ €Ò¿ ‘*`Ò¿ Ô¿ “* @XÐ'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿ ‘*`Ò¿" Ô¿ “* @WçÐ'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿: Ò¿$ ÒÒ'¾Ü€¢`€Sп,“* ‘:`€¢ €MоôÒ¾ì Ҿ𔠓* " ”“* ’@п@W°Ð'¿Ð¿€¢ €Ò¿‘*`Ò¿ Ô¿“* @W©Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿‘*`Ò¿" Ô¿“* @WŽÐ'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿,”¿(Ú¿°Ð DÒ¿´Ö¿¼Ø¿¸ŸÃ@оüÐ'¿Ð¾øÐ'¾üоðÐ'¾ôоìÐ'¾ðоäÐ'¾èоàÐ'¾äпȒ €Ò'¿ÈпĒ €Ò'¿ÄпÀ’ €Ò'¿Àп´Ò¿¸Ð $’@Ò'¿¸Ð¿ä’ Ò'¿ä¿ýüп´Ò $ “* п¼’ Ò'¿¼Ð¿Ø’ Ò'¿Ø¿ý™Ð¿Ü’ Ò'¿Üп´’ TÒ'¿´¿üèÒ DРDÒ DÖ`œ”à’ Ò" œÐ DÔ!@€¢@ €° €° €Çàèã¿€ð' Dò' HРDÒ Ö@РD’ ” tŸÂÀÐ'¿ìРDÒ¿ìÒ"!¬Ð¿ìª’£àÒ"п쫒 Ò" пìÀ" pРH€¢ €OÀ'¿èРDÒ ØÒ'¿àРDÒ¿èÐ $€¢@€€5пàÒ Ò'¿äРDÒ Ü€¢`€Ð¿ä’•*`€Ð'¿äРDà пàÒ¿àÐ Ò`@ҢпàÒ¿àÐ Ò` @Ë˜Ä Ð D’ ” –Ú¿äŸÀ€Ò¿ìÔ¿è– •*à’@ Ð"`HÐ¿è’ Ò'¿èÐ¿à’ TÒ'¿à¿ÿÇп쬒 ÐÒ" п쭒 PÒ" пìÒ¿ì”`HÔ" €,РDÒ Ö`РD’ ”%ŸÂÀÐ'¿àÀ'¿äп䀢 €€Ð¿ìÒ¿ä” “*  Ò¿ä” “* Ô¿à’€ Ò" Ð¿ä’ Ò'¿ä¿ÿìп쬒 ´Ò" п쫒 Ò" пìÀ" Çàè㿈ð' DРDÒ €¢`€€& Ð'¿ìп쀢 €€Ð DÒ Ô`$РDÒ¿ìŸÂ€Ð¿ì’?ÿÒ'¿ì¿ÿðРDÒ €¢`€ РD’ ÈÒ" РDÀ"!0€Ð D’ dÒ" Çàèã¿ð' DРDÒ €¢`€Ð DÒ Ô`(РDŸÂ€Ð DÀ" РDÀ" Çàè㿈ð' DРDÒ Ö@РD’ ” „ŸÂÀÐ'¿ìпìÀ" €Ð¿ì°€Çàè㿈ð' DРDÒ Ö@РD’ ”!ŸÂÀÐ'¿ìпìÀ"!п찀Çàèã¿ð' Dò' HРDÔ H’ ’ÿ Ò H@V °€Çàèã¿ð' Dò' HÒ DÿÒ H Ð' DÒ D Ò H@VÒ D"@°€Çàèã¿ð' Dò' Hô' Lö' Pø' Tú' Xä XРH’‘*`Ò D@Ð' DРP’‘*`Ò L@Ð' Læ T€¤à€€Ð Dà Ð' D LÒâ@’`Ò"’”@UЦÿÿ¿ÿìÇàèã¿ð' Dò' Hô' LРL’•*`РHÒ D@UÀÇàèã¿ð' Dò' HРD’ Ô H@UÂÇàèã¿ð' DРDÒÔ`РDŸÂ€Ð DÿÿV @UŽÇàèã¾Èð' DРDÔ’¿(Ô  РDŸÂ€”¿( b(È’ãÐ@U‚Çàè㿈ð' Dò' HРDÒÒ'¿ìРH€¢ €Ð¿ìÒ l€¢`€ пìÒ h€¢`€€Ð¿ìÒ Ð DŸÂ@Ò¿ìпìÒ¿ìÔ`l’ Ò" l€ пìÒ hРH€¢@€Ð¿ìÒ Ð DŸÂ@Çàèã¿hð' Dò' HРDÒÒ'¿ìпìÒ Ò'¿èÀ'¿äп耢 €Ð¿ìÒ¿èÐ t€¢@€ пìÒ¿è” “* Ô p@ ÒÒ'¿ä€Ð¿ìÒ x€¢`€Ð¿ìÒ¿èÐ |€¢@€Ð¿ìÒ¿èÐ €€¢@€ пìÒ¿ìÔ¿èÖ`|’"€ ” “* Ô x@ ÒÒ'¿äп䀢 € пìÒ¿èÒ" пìÒ pÐ@Ð'¿äÀ'¿ØпäÐ'¿à¿àÒÔ @Ô/¿ß—* •:à’`Ò"€¢ €€Ð¿ß“* ‘:`€¢ %€ пàÒ •*`‘: €¢ s€ Ð'¿Ø€¿ÿâп؀¢ € Ð¿ì” Ð HÒ¿ä@U€Ô¿ìÖ¿ìØ¿ìÚ¿ìпìÒ (Ò# \пìÒ ,Ò# `пìÒ 0Ò# dпìÒ 4Ò# hРHÒ¿äÔ ÖàØ Ú`$@T÷Çàèã¿ð' DРDÒÀ"`lРDÒÀ"`Çàèã¿ð' DРD³’¡øÒ"РD³’¢€Ò" РD³’¢8Ò" РD³’£@Ò" РD´’¡xÒ" РDÀ" hРDÀ" lРDÀ" РDÃ’¢hÒ" pРD’ {Ò" tРDÀ" xРDÀ" |РDÀ" €Ð D°€Çàèã¿ð' Dò' HРDÒ 6Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Çàèã¿pð' Dò' Hô' LРDÒ Ò'¿ìРLæ²’¡ð€¢ €Ð D’ ÿÿÞРL’ Ò'¿Üп܀¢ €Ò L`Ò¿Ü" Ð' LРH€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€À'¿äпìÒ H” “*  Ò 4Ò'¿èп耢 €€Ð¿èÒ Ð L€¢@ €€ пèÐ'¿äпèÒÒ'¿è¿ÿíп耢 €dРL’ Ò'¿Øп䀢 € ÈÒ H” “* ”#Ø@ ÒÒ'¿Ô€ ÈÒ H” “* ”#à@ ÒÒ'¿Ôæ²bÒ¿Ø" Ò¿Ô€¢@€æ²bÒ¿Ø" Ð'¿ÔпØÔ¿Ô’ РD@­Ð'¿èп耢 €€Ò¿Ô‘2`Ð'¿ÔпԀ¢ 1€Ð D’ ÿÿZ¿ÿèпìÒ¿ìÔ¿ØÖ¿Ô”€ Ò`L”@ Ô" LпèÀ"пèÀ" пèÒ LÔ¿Ô’@ Ò" п䀢 € пìÒ H” “*  Ò¿èÒ" 4€Ð¿äÒ¿èÒ"Ð¿è’ Ò'¿àпèÒ¿àÐ ’@Ò'¿àпèÒ¿èÔ`Ò L”€ Ô" пèÒ¿èÔ`Ò L”"€ Ô" пఀÇàèã¿€ð' Dò' Hô' LРDÒ Ò'¿ìРLæ²’¡ð€¢ €Ð D’ ÿÿ РL’ Ò'¿äп䀢 €Ò L`Ò¿ä" Ð' LРH€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð L’ РD@8Ð'¿èп耢 €Ð D’ ÿþÚпìÒ¿ìÔ`L’ Ô L’@ Ò" LпèÒ¿ìÔ H– •*à’@ Ô`<Ô"пèÒ LÒ" пèÀ" пìÒ H” “*  Ò¿èÒ" <Ò¿è`°€Çàèã¿pð' Dò' Hô' Lö' PРDÒ Ò'¿ìæ²aðÒ L@SJÐ'¿ÔпԀ¢ € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð¿ÔÒ P€¢ €Ð¿ÔÐ'¿à€Ð PÐ'¿àпìÒ¿àÒ" PРP’•*`РDÒ HÿþšÐ'¿èÀ'¿ÜпÜÒ P€¢ €€3РPÒ¿Ü" Ò¿à€¢ €Ð¿àÐ'¿àпàÒ L@S”РDÒ HÿÿQÐ'¿äпàÐ'¿Øп؀¢ €€¿ÜÒ” – •*àֿ蔀 Ö¿äÖ"€’`Ò"пäÒ L Ð'¿äпؒ?ÿÒ'¿Ø¿ÿè¿ÿÊп谀Çàèã¿pð' Dò' Hô' Lö' PРDÒ Ò'¿ìРL”“* æ²¡ð@R×Ð'¿ÔпԀ¢ € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð¿ÔÒ P€¢ €Ð¿ÔÐ'¿à€Ð PÐ'¿àпìÒ¿àÒ" PРP’•*`РDÒ Hÿþ'Ð'¿èÀ'¿ÜпÜÒ P€¢ €€6РPÒ¿Ü" Ò¿à€¢ €Ð¿àÐ'¿àпàÒ L@R ’•*`РDÒ HÿþÝÐ'¿äпàÐ'¿Øп؀¢ €€¿ÜÒ” – •*àֿ蔀 Ö¿äÖ"€’`Ò"РL’‘*`Ò¿ä@Ð'¿äпؒ?ÿÒ'¿Ø¿ÿæ¿ÿÇп谀Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XРDÒ Ò'¿ìРH€¢ €Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð DÒ H” €ÿýÃÐ'¿èпèÀ"пèÒ TÒ" пèÒ PÒ" пèÒ XÒ" пèÒ LÒ" пèÀ" (пèÒ¿ìÔ`DÔ" ,пìÒ¿èÒ" Dп谀Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XРDÒ Ò'¿ìРH€¢ €Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð DÒ H” €ÿý„Ð'¿èпèÀ"пèÒ TÒ" пèÒ PÒ" пèÒ XÒ" пèÒ LÒ" пèÀ" (пèÒ¿ìÔ`HÔ" ,пìÒ¿èÒ" Hп谀Çàèã¿pð' DРDÒ Ò'¿ìÀ'¿èÀ'¿äпìÒ DÒ'¿ÔпԀ¢ €€Ð¿ÔÒ€¢`€Ð¿ÔÒ¿ÔÐ Ò`@QÚÒ¿è@Ð'¿èпÔÒ¿ÔÐ Ò`@QÑÒ¿ä@Ð'¿äпÔÒ ,Ò'¿Ô¿ÿàпìÒ HÒ'¿ÐпЀ¢ €€"пÐÒ€¢`€Ð¿ÐÒ¿ÐÐ Ò`@Q´’‘*`Ò¿è@Ð'¿èпÐÒ¿ÐÐ Ò`@Q©’‘*`Ò¿ä@Ð'¿äпÐÒ ,Ò'¿Ð¿ÿÜп耢 €€ÆÖ¿ìРDÒ¿èÔ¿äÖàL@YÐ'¿àпàҿ䀢 €æ²bÐ'¿Ø€ пàÒ¿è@Q‰Ð'¿Øп؀¢ € Ð'¿ØпìÒ DÒ'¿ÔпԀ¢ €€KпÔÒ€¢`€AпÔÒ ÿÒ¿ÔÒ` @Qc’ Ò'¿ÜпÜÒ¿Ø€¢ €Ð¿ÔÒ¿ÔÔ`Ô" €à¿ÔÒ¿ÔпØÒ` @QSÐ$ пԠ 0пÔÒ¿ÔÐ Ò`@QJ”РD’@пԒ Ò" (Ô¿ÔÖ¿ÔРD’ Ô ÖàÿýâÒ¿ÔÐ"@пÔÒ¿ìÔ`PÔ" пÔÀ" пÔÀ" пÔÀ" $пÔÒ ,Ò'¿Ô¿ÿ³Ð¿ìÒ HÒ'¿ÐпЀ¢ €€LпÐÒ€¢`€BпÐÒ ÿÒ¿ÐÒ` @Q’ Ò'¿ÜпÜÒ¿Ø€¢ €Ð¿ÐÒ¿ÐÔ`Ô" €à¿ÐÒ¿ÐпØÒ` @QÐ$ пР 0пÐÒ¿ÐÐ Ò`@P÷’•*`РD’@ÃпВ Ò" (Ô¿ÐÖ¿ÐРD’ Ô ÖàÿýÿÒ¿ÐÐ"@пÐÒ¿ìÔ`PÔ" пÐÀ" пÐÀ" пÐÀ" $пÐÒ ,Ò'¿Ð¿ÿ²Çàèã¿xð' Dò' Hô' LРHÒ Ò'¿ìÒ HÐ`Ò¿ì@PÇÐ'¿èÀ'¿ØРHÒ¿ØÐ €¢@€€iРHÒ HÔ`Ö¿Ø’"€ Ð €¢ €Ò HÐ`€Ò HÔ`Ò¿Ø"€ Ð'¿àРHÒ Ð¿Ø’@Ò'¿ÜРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àÐ¿à€¢ €€8пàÒ¿ì@PˆÐ'¿äРL€¢ €Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 4РDÔ€Ö¿èØ¿äŸÃ@€Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 0РDÔ€Ö¿èØ¿äŸÃ@пèÒ¿ä Ð'¿èРHÒ¿ØÐ ’@Ò'¿Ø¿ÿ“Çàèã¿xð' Dò' Hô' LРHÒ  “* Ò'¿ìÒ HÐ`Ò¿ì@PFÐ'¿èÀ'¿ØРHÒ¿ØÐ €¢@€€iРHÒ HÔ`Ö¿Ø’"€ Ð €¢ €Ò HÐ`€Ò HÔ`Ò¿Ø"€ Ð'¿àРHÒ Ð¿Ø’@Ò'¿ÜРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àÐ¿à€¢ €€8пàÒ¿ì@PÐ'¿äРL€¢ €Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 4РDÔ€Ö¿èØ¿äŸÃ@€Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 0РDÔ€Ö¿èØ¿äŸÃ@пèÒ¿ä Ð'¿èРHÒ¿ØÐ ’@Ò'¿Ø¿ÿ“Çàèã¿€ð' Dò' Hô' Lö' Pø' TРLÒ P Ð'¿ìРHÒ¿ìÐ €¢@€Ð HÒ PÐ €¢@€ РHÒ€¢`€€Ð DÒ Ð"`РDÒÔ@РDŸÂ€Ð HÒ LÐ €¢@ € РHÒ HÐ Ò` ҿ쀢@€€:РHÒ (€¢`€ РDÒ EÐ"`РDÒÔ@РDŸÂ€Ð HÒ $€¢`€ РDÒ H” ÿþ±Ð HÀ" $РHÒ LÐ €¢@€Ð HÒ LÒ" €Ð HÒ¿ìÐ ’"@Ò'¿äп䀢 €À'¿äРHÒ¿äÒ" РDÒ H” ÿþ’РHÒ Ð¿ì€¢@€\РHÒ Ð L€¢@€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð LÐ'¿è€Ð HÒ Ò'¿èРT€¢ €Ð HÒ¿ìÒ" РHÒ €¢`€'РHÒ Ò'¿äРHÒ¿èÐ ’"@Ò'¿èРHÒ¿ìÐ ’"@Ò'¿ìпèҿ쀢 €€Ð HÒ¿è” “* Ð’@Ð@Ò¿äÿùSÐ¿è’ Ò'¿è¿ÿì€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð T€¢ €Ð H’ Ò" $РHÒ HÔ LÖ`’"€ ” “* Ô@ °€Çàèã¿€ð' Dò' Hô' Lö' Pø' TРLÒ P Ð'¿ìРHÒ¿ìÐ €¢@€Ð HÒ PÐ €¢@€ РHÒ€¢`€€Ð DÒ Ð"`РDÒÔ@РDŸÂ€Ð HÒ LÐ €¢@ € РHÒ HÐ Ò` ҿ쀢@€€:РHÒ (€¢`€ РDÒ EÐ"`РDÒÔ@РDŸÂ€Ð HÒ $€¢`€ РDÒ H” ÿþKРHÀ" $РHÒ LÐ €¢@€Ð HÒ LÒ" €Ð HÒ¿ìÐ ’"@Ò'¿äп䀢 €À'¿äРHÒ¿äÒ" РDÒ H” ÿþ,РHÒ Ð¿ì€¢@€^РHÒ Ð L€¢@€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð LÐ'¿è€Ð HÒ Ò'¿èРT€¢ €Ð HÒ¿ìÒ" РHÒ €¢`€)РHÒ  “* Ò'¿äРHÒ¿èÐ ’"@Ò'¿èРHÒ¿ìÐ ’"@Ò'¿ìпèҿ쀢 €€Ð HÒ¿è” “* Ð’@Ð@Ò¿äÿølÐ¿è’ Ò'¿è¿ÿì€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð T€¢ €Ð H’ Ò" $РHÒ HÔ LÖ`’"€ ” “* Ô@ °€Çàèã¿xð' Dò' HРDÒ Ò'¿ìРH€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð H€¢ €>пìÒ DÒ'¿Üп܀¢ €€Ð¿ÜÒ (€¢`€ пÜÀ" (пÜÔ¿Ü’ 0Ô 8РDŸÂ€Ð¿ÜÒ ,Ò'¿Ü¿ÿéпìÀ" DпìÒ HÒ'¿Øп؀¢ €€Ð¿ØÒ (€¢`€ пØÀ" (пØÔ¿Ø’ 0Ô 8РDŸÂ€Ð¿ØÒ ,Ò'¿Ø¿ÿéпìÀ" HпìÒ H” “*  Ò <Ò'¿äпìÒ H” “*  À" <п䀢 €€Ð¿äÒÒ'¿ØпäÒ¿äÐ Ò` ’ Ò'¿àРDÒ¿äÔ¿à@EпìÒ¿ìÔ`LÒ¿à”"€ Ô" LпØÐ'¿ä¿ÿãпìÒ H” “*  Ò 4Ò'¿èпìÒ H” “*  À" 4п耢 €€Ð¿èÒÒ'¿ØпèÒ¿èÐ Ò` ’ Ò'¿àРDÒ¿èÔ¿à@пìÒ¿ìÔ`LÒ¿à”"€ Ô" LпØÐ'¿è¿ÿãÇàè㿈ð' D Ð'¿ìп쀢 €€ РDÒ¿ìÿÿ<пì’?ÿÒ'¿ì¿ÿóÒ DРDÒ`” T@àРDÀ" РD@Çàèã¿xð' DРDÀ" € РDÒ Ð"`РDÒÔ@РDŸÂ€æ²bÐ'¿àпàæ²’¢€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð D@ëÐ'¿èРD’ T@£Ð'¿ìп쀢 €Ð D@åРDÒ 6Ð"`РDÒÀ"`РDÒÔ@РDŸÂ€Ð¿ì´’¢¨Ò"п쵒¡ðÒ" п쵒£„Ò" п춒¡HÒ" п춒£ Ò" п췒 Ò" п췒¡Ò" п칒¡ Ò" п캒¡4Ò" п컒 ÐÒ" $п컒£°Ò" (пìæ²’¢Ò" 0пìÒ¿èÒ" , Ð'¿äп䀢 €€Ð¿ìÒ¿ä” “*  À" 4пìÒ¿ä” “*  À" <пä’?ÿÒ'¿ä¿ÿëпìÀ" DпìÀ" HÐ¿ì’ TÒ" LРDÒ¿ìÒ" Ècè@L°Ð'¿Üп܀¢ €- xÐ/¿Û”¿è–¿ÛпÜÈ’#ð@Lo€¢ €!пۓ* ‘:`€¢ m€ пۓ* ‘:`€¢ M€€ п蔓* ’"@•*`”€‘* Ð'¿èпìÒ¿è– •*à”"€ —* –À “*àÒ" ,Çàèã¿ð' Dò' HРH@L{°€Çàèã¿ð' Dò' Hô' LРH@LrÇàèã¿ð' Dò' HРH@Lg°€Çàèã¿ð' Dò' Hô' LРH@L^Çàèã¿ð' Dò' Hô' Lö' PРL°€Çàèã¿ð' Dò' Hô' LРDÒ 1Ð"`РDÒÔ@РDŸÂ€Çàèã¿ð' D° €Çàèã¿ð' DÇàè” – Æ  „à…(€ €ˆà€€–À¿ÿù” ÃàÖ"@† ”Ö  „ à…(€”€€Šà€¿ÿú†à€ à€€Šà@€„?ÿ…(€”€ÃàÔ"@…*`€¢`€Ô"€ÖÔ?üÆàÄ € À€’‚ÿÔ"Ö"?ü¿ÿ÷?üÃàÄ’ € € €Ä €  "€ÄÄ €  2€’`Ä„Æ € à¿ÿô Ãà ã¿à€äÀЀ¢ €âÐ €¢ "€ÐÐ €¢ €’ÿÿÉ”Ò €¢@€  ¤ Ð @€¢8€¢ÐÒ €¢`¿ÿç° à&€ä&Àâ'Çàè㿀Р€¢ € À'¿ìЀ¢ €Ð¿ìÿÿºÐÒ¿ì  ’@Ò'¿ìЀ¢ ¿ÿøпì€Ð& ÿÿ®Ð Ð'¿ìпìÐ& @K¨‘* ’?ÿÒ'¿èÀ'¿äÀ'¿ìÒ €¢`€¢  Ѐ¢ €Ò¿è’”¿ì–¿èÐÿÿ«˜¿ä  Ѐ¢ ¿ÿø’€ Ò¿èÐ ’”¿ì–¿èÿÿž˜¿äÒ¿èâ& пäÒ&Ð& Çàèã¿@/K®à ®À ÐÀà€¤ €¢Ð€¢ €€¤@ÿÿ¬Ð€¤@*€à Ð €¤@ €€¤ à €¤ 2¿ÿñЀ¤ €° Ø – €¢À €À Ú •2 ‘* ð@Ò €¤@ :€Ð €˜ @€¤@€– €¢À ¿ÿòÀ ° Çàè㿈@/J®㸮À ÒÀÔ "  @K?Ð&@€¢ €Ð@’`@K8ÒÀ €¢ €Ð@ÐJ€¢ z€-° @K1Ð@Ô@’`ÒÀ  €° @K& €¢ 2€À&`Ð Ô Ò ‘* •* ”€“*`Ð ’@  Ð&`° ÿþÝ’`ÿþè’` °ÐÒ@Ð&`ÐJ@€¢ z€° ÿþÐ’¿ìÒ¿ì° Çàèã¿€Ô€Š @€ ° Ò @J×  ?ÒÀ’@€ßÒ&À€Š €€  ?Ð'¿è€k€Š À€€¢ .Ð'¿è@€ÒÀ*!¬€Î“* @àÐ ÃÀ8Ðü8tÄ88ä°$Tt000000000000000000000000000000ÐÐÔ Ò ‘* •* ”€“*`Ð ’@ € ÒÐÀ Ð&À€‹° ÐÔ ÒÀ‘* ”€’@ Ò&À€‚° ÔÐ Ò •* ‘*  “*`Ô ’@ÐÀ”€  Ð&À€s° ÿþQ’¿èÿþO’¿ìÔ¿ì°Ò  @J] Ð'¿ìÒ¿è ’@ Ð*a¬Ð¿è‘* @€_Ò" ÿþ=’¿èÒ¿è°’@ €WÀ*a¬ÿþ5’¿èÿþ3’¿äÒ¿è” ’@ Ô*a¬Ò¿è°Ð¿ä“*`’@ €GÐ"` ¿èÿþ$’ÿþ"’¿ìÒ °Ð¿ìÒ6a¨€;Ð&` ¿èÿþ’Ò °€3Ò6a¨ÿþ’¿ìÒ¿ì°€,Ò&`@J<" ’@J”"€$à&bà"”"@J ’@J20€ Ð'¿è– пè@Ö*!¬Ô¿è“* ’@ ¿ð‘* Ð"`” €¢ ¿ÿõÔ'¿è0€ ÿýé’¿ìÒ¿ì°€Ò&` @J Çàèã¿@/I®âä®Àð&`À&`À&@ ÒÀÀ&` Ð@À&`Ð&`ò"@Çàèã¿@/I®✮Àð&`ð&` À&` ÒÀÀ&@Ð@À&`Ð&`ò"@Çàèã¿@/I®âT®À ÔÀЀ€¢ €Ò€Ð`€¢€ Ð`Ð"€Ð@€¢ € @IÙÐ` 0€€¢ ¿ÿò”`@IÜÇàèã½XÿþL¤’ €ÿþ’¿Ø ’ €½À€=° ’ @I£”"пêÒ¿ÜÐ7¿jÒ'½ÄР?ü$€Ò ¢ €¤€ пؒ½À”¿Øÿþ±–  €¤ ¿ÿúпØÐJ€¢ z€  ÿýo’½¼Ò½¼  ЀҠ€¢ €¤€Ò'½¸Ð½¸€¢€ ’½À”¿Øÿþ”–½¸ €¤ ¿ÿ÷н¸’½À@I`”"°Çàèã¿@/I®ମÀ ÐÀÒ?ü€¢ÿ€  ?üП ?üЀ¢?ÿ¿ÿûÇàèã¿Çàèã¿ ÿˆ‚ÿÿåÇàèã¿ ÿˆYÇàèusage: %s [switches] [inputfile] Switches (names may be abbreviated): -copy none Copy no extra markers from source file -copy comments Copy only comment markers (default) -copy all Copy all extra markers -optimize Optimize Huffman table (smaller file, but slow compression) -progressive Create progressive JPEG file Switches for modifying the image: -grayscale Reduce to grayscale (omit color data) -flip [horizontal|vertical] Mirror image (left-right or top-bottom) -rotate [90|180|270] Rotate image (degrees clockwise) -transpose Transpose image -transverse Transverse transpose image -trim Drop non-transformable edge blocks Switches for advanced users: -restart N Set restart interval in rows, or in blocks with B -maxmemory N Maximum memory to use (in kbytes) -outfile name Specify name for output file -verbose or -debug Emit debug output Switches for wizards: -scans file Create multi-scan JPEG per script file %s: can only do one image transformation at a time arithmetic%s: sorry, arithmetic coding not supported copynonecommentsalldebugverboseIndependent JPEG Group's JPEGTRAN, version %s %s 6b 27-Mar-1998Copyright (C) 1998, Thomas G. Lanefliphorizontalverticalgrayscalegreyscalemaxmemory%ld%coptimizeoptimiseoutfileprogressiverestartrotate90180270scanstransposetransversetrimjpegtran%s: only one input file rb%s: can't open %s wbrCan't open table file %s Too many tables in file %s Invalid table data in file %s Non-numeric data in file %s Can't open scan definition file %s Too many scans defined in file %s Too many components in one scan in file %s Invalid scan entry format in file %s %d%cJPEG quantization tables are numbered 0..%d %d%c%d%cJPEG sampling factors must be 1..4 ?ð (3= :<7 (9E83WP>%8DmgM#7@Qhq\1@NWgyxeH\_bpdgc/ccccBcccc8ccccc/Bcccccccccccccccccccccccccccccccccccccc  }!1AQa"q2‘¡#B±ÁRÑð$3br‚ %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚáâãäåæçèéêñòóôõö÷øùúw!1AQaq"2B‘¡±Á #3RðbrÑ $4á%ñ&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz‚ƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚâãäåæçèéêòóôõö÷øùú?ð @€ @ÿÿÿÿÿÿÿýÿÿÿùÿÿÿñÿÿÿáÿÿÿÁÿÿÿÿÿÿÿÿþÿÿüÿÿøÿÿðÿÿàÿÿÀÿÿ€ @€ @ÿÿÿÿÿÿÿýÿÿÿùÿÿÿñÿÿÿáÿÿÿÁÿÿÿÿÿÿÿÿþÿÿüÿÿøÿÿðÿÿàÿÿÀÿÿ€     !(0)" #*1892+$%,3:;4-&'.5<=6/7>?????????????????#¸#x#X#0#"ð"Ð"¨"ˆ"p"X"@"!Ð!°!ˆ!P!! à ° ` @ ðÈ x`H0ðØÀ˜€P(بp0àȘxP(øȨxP(øȘh8ðИhH øàÈ Pب€`0øàШp0Ø°h@(ØÐP0 àÀ €8øÀˆpX0è¨pHøÀ`Application transferred too many scanlinesInvalid SOS parameters for sequential JPEGCorrupt JPEG data: found marker 0x%02x instead of RST%dPremature end of JPEG fileWarning: unknown JFIF revision number %d.%02dCorrupt JPEG data: bad Huffman codeCorrupt JPEG data: premature end of data segmentCorrupt JPEG data: %u extraneous bytes before marker 0x%02xInconsistent progression sequence for component %d coefficient %dUnknown Adobe color transform code %dObtained XMS handle %uFreed XMS handle %uUnrecognized component IDs %d %d %d, assuming YCbCrJFIF extension marker: RGB thumbnail image, length %uJFIF extension marker: palette thumbnail image, length %uJFIF extension marker: JPEG-compressed thumbnail image, length %uOpened temporary file %sClosed temporary file %s Ss=%d, Se=%d, Ah=%d, Al=%d Component %d: dc=%d ac=%dStart Of Scan: %d componentsStart of Image Component %d: %dhx%dv q=%dStart Of Frame 0x%02x: width=%u, height=%u, components=%dSmoothing not supported with nonstandard sampling ratiosRST%dAt marker 0x%02x, recovery action %dSelected %d colors for quantizationQuantizing to %d colorsQuantizing to %d = %d*%d*%d colors %4u %4u %4u %4u %4u %4u %4u %4uUnexpected marker 0x%02xMiscellaneous marker 0x%02x, length %u with %d x %d thumbnail imageJFIF extension marker: type 0x%02x, length %uWarning: thumbnail image size does not match data length %uJFIF APP0 marker: version %d.%02d, density %dx%d %d %3d %3d %3d %3d %3d %3d %3d %3dEnd Of ImageObtained EMS handle %uFreed EMS handle %uDefine Restart Interval %uDefine Quantization Table %d precision %dDefine Huffman Table 0x%02xDefine Arithmetic Table 0x%02x: 0x%02xUnknown APP14 marker (not Adobe), length %uUnknown APP0 marker (not JFIF), length %uAdobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %dCaution: quantization tables are too coarse for baseline JPEG6b 27-Mar-1998Copyright (C) 1998, Thomas G. LaneWrite to XMS failedRead from XMS failedImage too wide for this implementationVirtual array controller messed upUnsupported marker type 0x%02xApplication transferred too few scanlinesWrite failed on temporary file --- out of disk space?Seek failed on temporary fileRead failed on temporary fileFailed to create temporary file %sInvalid JPEG file structure: SOS before SOFInvalid JPEG file structure: two SOI markersUnsupported JPEG process: SOF type 0x%02xInvalid JPEG file structure: missing SOS markerInvalid JPEG file structure: two SOF markersCannot quantize to more than %d colorsCannot quantize to fewer than %d colorsCannot quantize more than %d color componentsInsufficient memory (case %d)Not a JPEG file: starts with 0x%02x 0x%02xQuantization table 0x%02x was not definedJPEG datastream contains no imageHuffman table 0x%02x was not definedBacking store not supportedRequested feature was omitted at compile timeNot implemented yetInvalid color quantization mode changeScan script does not transmit all dataCannot transcode due to multiple use of quantization table %dPremature end of input fileEmpty input fileMaximum supported image dimension is %u pixelsMissing Huffman code table entryHuffman code size table overflowFractional sampling not implemented yetOutput file write error --- out of disk space?Input file read errorDidn't expect more than one scanWrite to EMS failedRead from EMS failedEmpty JPEG image (DNL not supported)Bogus DQT index %dBogus DHT index %dBogus DAC value 0x%xBogus DAC index %dUnsupported color conversion requestToo many color components: %d, max %dCCIR601 sampling not implemented yetSuspension not allowed hereBuffer passed to JPEG library is too smallBogus virtual array accessJPEG parameter struct mismatch: library thinks size is %u, caller expects %uImproper call to JPEG library in state %dInvalid scan script at entry %dBogus sampling factorsInvalid progressive parameters at scan script entry %dInvalid progressive parameters Ss=%d Se=%d Ah=%d Al=%dUnsupported JPEG data precision %dInvalid memory pool code %dSampling factors too large for interleaved scanWrong JPEG library version: library is %d, caller expects %dBogus marker lengthBogus JPEG colorspaceBogus input colorspaceBogus Huffman table definitionIDCT output block size %d not supportedDCT coefficient out of rangeInvalid component ID %d in SOSBogus buffer control modeMAX_ALLOC_CHUNK is wrong, please fixALIGN_TYPE is wrong, please fixSorry, there are legal restrictions on arithmetic codingBogus message code %d%s @>€ˆJPEGMEM%ld%ceh%œ&D&\'°#ø$'è&P00¿ÿó<0¿ÿðH0¿ÿíT0¿ÿê`0¿ÿçl0¿ÿäx0¿ÿá„0¿ÿÞ0¿ÿÛœ0¿ÿب0¿ÿÕ´0¿ÿÒÀ0¿ÿÏÌ0¿ÿÌØ0¿ÿÉä0¿ÿÆð0¿ÿÃü0¿ÿÀ0¿ÿ½0¿ÿº 0¿ÿ·,0¿ÿ´80¿ÿ±D0¿ÿ®P0¿ÿ«\0¿ÿ¨h0¿ÿ¥å ÿ´ ÿÐoÿÿþäš$„¡6p³ýdHÏ$´Ö$œÝ%Pê~|0üxè%œè<0¾dŒGÑL¸[Èr*@xóŒ$ˆvXœ©à\°xÌÆü”Þo Äûþ,( €@Ü+?è¤>$lDst[̘Pe'ð!mÑ ¼|Ì L’ôl %h¥ ä»ô,ÎËÀLåÕd°ýý¬€‘¬ä'%t.~¬Ì@ó`,O'°V$$ p$v$ð}yTÈ—h”«“ÃÈ`XÛ´Àî$ õÿè ð00y(%/Ev¼Y'ø !`}8xx/ÐP}$؃ôˆ‘$ü–$¨Ÿ9°T°$À·CŒ(Â%€ÉX$à¤HñÿÐ ÷ó°,zdÌè´-˜B…ä¸S$x[ (@ jpegtrancrti.svalues-Xa.ccrtstuff.cp.2__CTOR_LIST____DTOR_LIST____do_global_dtors_auxgcc2_compiled.__EH_FRAME_BEGIN__force_to_datafini_dummyinit_dummyobject.7frame_dummyjpegtran.cselect_transformoutfilenametransformoptionprognameusageparse_switchesgcc2_compiled.copyoptionprinted_version.6rdswitch.ctext_getcread_scan_integerread_text_integergcc2_compiled.cdjpeg.cgcc2_compiled.transupp.ctrim_right_edgedo_transposedo_rot_90do_flip_hdo_flip_vtrim_bottom_edgegcc2_compiled.do_transversedo_rot_180do_rot_270transpose_critical_parametersjcapimin.cgcc2_compiled.jctrans.ccompress_outputstart_pass_coefgcc2_compiled.transencode_coef_controllertransencode_master_selectionstart_iMCU_rowjcparam.cstd_huff_tablesbits_dc_luminance.14bits_ac_luminance.18fill_dc_scansval_ac_chrominance.21val_dc_chrominance.17gcc2_compiled.add_huff_tablestd_chrominance_quant_tbl.5fill_scansfill_a_scanval_dc_luminance.15val_ac_luminance.19bits_ac_chrominance.20bits_dc_chrominance.16std_luminance_quant_tbl.4jdatadst.cterm_destinationempty_output_bufferinit_destinationgcc2_compiled.jcmaster.cprepare_for_passgcc2_compiled.initial_setupper_scan_setupvalidate_scriptfinish_pass_masterselect_scan_parameterspass_startupjcmarker.cemit_dacemit_sofemit_driemit_sosemit_dhtemit_dqtwrite_marker_headeremit_adobe_app14emit_bytegcc2_compiled.write_marker_bytewrite_scan_headerwrite_file_headerwrite_tables_onlyemit_jfif_app0emit_markeremit_2byteswrite_file_trailerwrite_frame_headerjchuff.cdump_bufferemit_restartfinish_pass_huffstart_pass_huffhtest_one_blockencode_one_blockemit_bitsgcc2_compiled.encode_mcu_gatherflush_bitsfinish_pass_gatherencode_mcu_huffjcphuff.cdump_bufferencode_mcu_AC_firstencode_mcu_DC_firstemit_restartemit_bitsfinish_pass_gather_phuffencode_mcu_AC_refineencode_mcu_DC_refinefinish_pass_phuffgcc2_compiled.start_pass_phuffflush_bitsemit_buffered_bitsemit_symbolemit_eobrunjdapimin.cdefault_decompress_parmsgcc2_compiled.jdtrans.cgcc2_compiled.transdecode_master_selectionjdatasrc.cfill_input_buffergcc2_compiled.term_sourceinit_sourceskip_input_datajdinput.cconsume_markersfinish_input_passgcc2_compiled.start_input_passinitial_setupper_scan_setuplatch_quant_tablesreset_input_controllerjdmarker.cfirst_markerget_interesting_appnskip_variableexamine_app0gcc2_compiled.get_sofget_driget_soiget_sosget_dqtget_dhtsave_markernext_markerexamine_app14reset_marker_readerread_restart_markerread_markersjdhuff.cprocess_restartextend_teststart_pass_huff_decoderdecode_mcugcc2_compiled.extend_offsetjdphuff.cprocess_restartextend_testdecode_mcu_AC_refinedecode_mcu_DC_refinegcc2_compiled.start_pass_phuff_decoderextend_offsetdecode_mcu_AC_firstdecode_mcu_DC_firstjdcoefct.cdummy_consume_datasmoothing_okconsume_datagcc2_compiled.start_input_passdecompress_onepassdecompress_smooth_datastart_output_passdecompress_datastart_iMCU_rowjcomapi.cgcc2_compiled.jutils.cgcc2_compiled.jerror.cemit_messagegcc2_compiled.error_exitformat_messagereset_error_mgroutput_messagejmemmgr.calloc_barrayalloc_sarraydo_barray_iodo_sarray_ioself_destructextra_pool_slopgcc2_compiled.free_poolaccess_virt_barrayaccess_virt_sarrayout_of_memoryalloc_largealloc_smallfirst_pool_sloprealize_virt_arraysrequest_virt_barrayrequest_virt_sarrayjmemnobs.cgcc2_compiled.frame.c.LLC0.LLC1fde_insertobjectsdecode_sleb128decode_uleb128execute_cfa_insnextract_cie_info__FRAME_BEGIN__count_fdesframe_initadd_fdesfind_fdecrtstuff.c__FRAME_END____do_global_ctors_auxgcc2_compiled.force_to_datainit_dummy__DTOR_END____CTOR_END__crtn.sjtransform_execute_transformationjinit_input_controller_startjtransform_request_workspacejinit_huff_encoder_START_jpeg_std_message_tablefreadjpeg_simple_progression_environ_endwrite_stdoutjpeg_abortjpeg_set_qualityjcopy_markers_setupjpeg_open_backing_storejinit_phuff_encoderkeymatch_iob__register_frame_info_GLOBAL_OFFSET_TABLE_jpeg_consume_inputjpeg_free_large__ctypejpeg_set_linear_qualityabortjpeg_stdio_destatexitexitjdiv_round_upjpeg_destroy_decompressjcopy_block_rowjpeg_write_m_headerjpeg_stdio_srctolowerjpeg_destroymallocsprintfjpeg_write_coefficientsjpeg_save_markersjcopy_markers_execute_initfwrite.umul.uremjpeg_write_markerjpeg_set_colorspace.remjpeg_add_quant_tablejpeg_fill_bit_bufferjzero_farset_quant_slotssscanfread_quant_tables__register_frame_info_tableungetcfclosegetenv_END_jpeg_write_m_bytejpeg_abort_compress_DYNAMICjpeg_gen_optimal_tablejinit_c_master_controljinit_marker_writerjpeg_finish_decompress__iobjpeg_free_smalljinit_marker_readerjinit_phuff_decoderjpeg_destroy_compressjpeg_has_multiple_scansjtransform_adjust_parameters__frame_state_forjpeg_copy_critical_parametersset_sample_factors_exitjpeg_resync_to_restartjround_upenvironjpeg_std_errorjpeg_alloc_huff_tablejpeg_mem_initfreejpeg_CreateDecompressjpeg_mem_availablejpeg_alloc_quant_tablejpeg_make_c_derived_tbl__deregister_frame_infojpeg_set_defaultsstrcmpjpeg_write_tablesjpeg_get_small_edata_PROCEDURE_LINKAGE_TABLE_fopenmemsetjpeg_set_marker_processorjpeg_input_completejpeg_default_colorspacejinit_d_coef_controllerjinit_huff_decoder_etext_lib_versionjinit_memory_mgrjpeg_suppress_tablesfflushjpeg_abort_decompressjpeg_CreateCompress_ctypejpeg_make_d_derived_tblmain.udivjpeg_mem_term.div__filbufread_scan_scriptmemcpyread_stdinstrlenjpeg_read_coefficientsjpeg_read_header_finijpeg_get_largejpeg_finish_compressjcopy_sample_rowsjpeg_quality_scalingjpeg_huff_decodefprintfjpeg_natural_orderas: WorkShop Compilers 4.X dev 18 Sep 1996 as: WorkShop Compilers 4.X dev 18 Sep 1996 @(#)SunOS 5.6 Generic August 1997as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 ld: Software Generation Utilities - Solaris/ELF (3.0); <I4œ,Ù dô˜"dô˜,<;€e€€®€Ï€õ€A€€³€Ý€€(€B€]€~€·€Ú€þ€(€<‚F‚]‚u‚z‚’‚¦‚»‚Ѐ€€Ž€.€¢„‚¢¢¢¢¢’‚¢¢¢¢£‚¢®‚¢º‚À .€ ƒ€ ý€-€z€Á€¶€”€€€‘€‚€<€†€å€?€¯€€n€ï€ ,€!€!ƒ€#q€$b€¢$÷‚%€v% €¨%5€ó%K€ ¢%`‚%h€&j€&…€¢'=€2'Q€3'e€4'y€5'€6'¢€( €(€L( €)&€)|$iô˜)“@h)§@h )¸$4)¹$~ôÌ)Ð@})Ü@} )í$L)î€*<$Âõ*O@Á*m@Á *w@Á *ˆ$H*‰$Ïõ`*œ@Î*­$T*®$áõ´*¿@ß*Ð@ß*Þ@ß*ô@à+ @à+$œ+$ÿöP+0@þ+<$+=$'÷`+N@&+Y$è+Z$RøH+s@Q+}@Q+$(+$ùp+©@}+³@}+Á@~+Î@~+Ù$¬+Ú$ùý+ø@ø,@ø,$H,$ ýd,7@ ,E@ ,Q$H,R$ý¬,r@,€$€,$4þ,,£@3,µ@3,Æ$(,Ç(P'è,ØdÿT.interp.hash.dynsym.dynstr.SUNW_version.rela.bss.rela.plt.text.init.fini.rodata.got.plt.dynamic.data.ctors.dtors.eh_frame.bss.symtab.strtab.comment.stab.index.stab.shstrtab.stab.indexstr.stabstrvalues-Xa.cXt ; O ; V=3.1 ; R=WorkShop Compilers 4.2 30 Oct 1996 C 4.2/space/respin/usr/src/lib/libc; /ws/on297-tools/SUNWspro/SC4.2/bin/../SC4.2/bin/cc -xO3 -xcg89 -Wa,-cg92 -xspace -W0,-Lt -Xt -Iinc -DTEXT_DOMAIN='"SUNW_OST_OSLIB"' -I/space/respin/proto/root_sparc/usr/include -c port/gen/values-Xa.c -W0,-xpframe.c/ext1/SOURCES/gcc-2.8.1/./frame.cgcc2_compiled.int:t(0,1)=r(0,1);-2147483648;2147483647;char:t(0,2)=r(0,2);0;127;long int:t(0,3)=r(0,3);-2147483648;2147483647;unsigned int:t(0,4)=r(0,4);0;-1;long unsigned int:t(0,5)=r(0,5);0;-1;long long int:t(0,6)=r(0,1);01000000000000000000000;0777777777777777777777;long long unsigned int:t(0,7)=r(0,1);0000000000000;01777777777777777777777;short int:t(0,8)=r(0,8);-32768;32767;short unsigned int:t(0,9)=r(0,9);0;65535;signed char:t(0,10)=r(0,10);-128;127;unsigned char:t(0,11)=r(0,11);0;255;float:t(0,12)=r(0,1);4;0;double:t(0,13)=r(0,1);8;0;long double:t(0,14)=r(0,1);16;0;complex int:t(0,15)=s8real:(0,1),0,32;imag:(0,1),32,32;;complex float:t(0,16)=r(0,16);4;0;complex double:t(0,17)=r(0,17);8;0;complex long double:t(0,18)=r(0,18);16;0;void:t(0,19)=(0,19)tconfig.hconfig/sparc/xm-sol2.hconfig/sparc/xm-sysv4.htm.hconfig/sparc/sol2-sld.hconfig/sparc/sol2.hconfig/sparc/sysv4.hconfig/sparc/sparc.hcmodel:T(8,1)=eCM_32:0,CM_MEDLOW:1,CM_MEDMID:2,CM_MEDANY:3,CM_EMBMEDANY:4,;processor_type:T(8,2)=ePROCESSOR_V7:0,PROCESSOR_CYPRESS:1,PROCESSOR_V8:2,PROCESSOR_SUPERSPARC:3,PROCESSOR_SPARCLITE:4,PROCESSOR_F930:5,PROCESSOR_F934:6,PROCESSOR_SPARCLET:7,PROCESSOR_TSC701:8,PROCESSOR_V8PLUS:9,PROCESSOR_V9:10,PROCESSOR_ULTRASPARC:11,;sparc_cpu_select:T(8,3)=s16string:(8,4)=*(0,2),0,32;name:(8,4),32,32;set_tune_p:(0,1),64,32;set_arch_p:(0,1),96,32;;reg_class:T(8,5)=eNO_REGS:0,FPCC_REGS:1,GENERAL_REGS:2,FP_REGS:3,EXTRA_FP_REGS:4,GENERAL_OR_FP_REGS:5,GENERAL_OR_EXTRA_FP_REGS:6,ALL_REGS:7,LIM_REG_CLASSES:8,;sparc_args:T(8,6)=s12words:(0,1),0,32;prototype_p:(0,1),32,32;libcall_p:(0,1),64,32;;config/svr4.hconfig/xm-svr4.hdefaults.hgansidecl.hdwarf2.hdwarf_tag:T(13,1)=eDW_TAG_padding:0,DW_TAG_array_type:1,DW_TAG_class_type:2,DW_TAG_entry_point:3,DW_TAG_enumeration_type:4,DW_TAG_formal_parameter:5,DW_TAG_imported_declaration:8,DW_TAG_label:10,DW_TAG_lexical_block:11,DW_TAG_member:13,DW_TAG_pointer_type:15,DW_TAG_reference_type:16,DW_TAG_compile_unit:17,DW_TAG_string_type:18,DW_TAG_structure_type:19,DW_TAG_subroutine_type:21,DW_TAG_typedef:22,DW_TAG_union_type:23,DW_TAG_unspecified_parameters:24,DW_TAG_variant:25,DW_TAG_common_block:26,DW_TAG_common_inclusion:27,DW_TAG_inheritance:28,DW_TAG_inlined_subroutine:29,DW_TAG_module:30,DW_TAG_ptr_to_member_type:31,\DW_TAG_set_type:32,DW_TAG_subrange_type:33,DW_TAG_with_stmt:34,DW_TAG_access_declaration:35,DW_TAG_base_type:36,DW_TAG_catch_block:37,DW_TAG_const_type:38,DW_TAG_constant:39,DW_TAG_enumerator:40,DW_TAG_file_type:41,DW_TAG_friend:42,DW_TAG_namelist:43,DW_TAG_namelist_item:44,DW_TAG_packed_type:45,DW_TAG_subprogram:46,DW_TAG_template_type_param:47,DW_TAG_template_value_param:48,DW_TAG_thrown_type:49,DW_TAG_try_block:50,DW_TAG_variant_part:51,DW_TAG_variable:52,DW_TAG_volatile_type:53,DW_TAG_MIPS_loop:16513,DW_TAG_format_label:16641,DW_TAG_function_template:16642,DW_TAG_class_template:16643,;dwarf_form:T(13,2)=eDW_FORM_addr:1,DW_FORM_block2:3,DW_FORM_block4:4,DW_FORM_data2:5,DW_FORM_data4:6,DW_FORM_data8:7,DW_FORM_string:8,DW_FORM_block:9,DW_FORM_block1:10,DW_FORM_data1:11,DW_FORM_flag:12,DW_FORM_sdata:13,DW_FORM_strp:14,DW_FORM_udata:15,DW_FORM_ref_addr:16,DW_FORM_ref1:17,DW_FORM_ref2:18,DW_FORM_ref4:19,DW_FORM_ref8:20,DW_FORM_ref_udata:21,DW_FORM_indirect:22,;dwarf_attribute:T(13,3)=eDW_AT_sibling:1,DW_AT_location:2,DW_AT_name:3,DW_AT_ordering:9,DW_AT_subscr_data:10,DW_AT_byte_size:11,DW_AT_bit_offset:12,DW_AT_bit_size:13,DW_AT_element_list:15,DW_AT_stmt_list:16,DW_AT_low_pc:17,DW_AT_high_pc:18,DW_AT_language:19,DW_AT_member:20,DW_AT_discr:21,DW_AT_discr_value:22,DW_AT_visibility:23,DW_AT_import:24,DW_AT_string_length:25,DW_AT_common_reference:26,DW_AT_comp_dir:27,DW_AT_const_value:28,DW_AT_containing_type:29,DW_AT_default_value:30,DW_AT_inline:32,DW_AT_is_optional:33,DW_AT_lower_bound:34,DW_AT_producer:37,\DW_AT_prototyped:39,DW_AT_return_addr:42,DW_AT_start_scope:44,DW_AT_stride_size:46,DW_AT_upper_bound:47,DW_AT_abstract_origin:49,DW_AT_accessibility:50,DW_AT_address_class:51,DW_AT_artificial:52,DW_AT_base_types:53,DW_AT_calling_convention:54,DW_AT_count:55,DW_AT_data_member_location:56,DW_AT_decl_column:57,DW_AT_decl_file:58,DW_AT_decl_line:59,DW_AT_declaration:60,DW_AT_discr_list:61,DW_AT_encoding:62,DW_AT_external:63,DW_AT_frame_base:64,DW_AT_friend:65,DW_AT_identifier_case:66,DW_AT_macro_info:67,DW_AT_namelist_items:68,DW_AT_priority:69,DW_AT_segment:70,DW_AT_specification:71,\DW_AT_static_link:72,DW_AT_type:73,DW_AT_use_location:74,DW_AT_variable_parameter:75,DW_AT_virtuality:76,DW_AT_vtable_elem_location:77,DW_AT_MIPS_fde:8193,DW_AT_MIPS_loop_begin:8194,DW_AT_MIPS_tail_loop_begin:8195,DW_AT_MIPS_epilog_begin:8196,DW_AT_MIPS_loop_unroll_factor:8197,DW_AT_MIPS_software_pipeline_depth:8198,DW_AT_MIPS_linkage_name:8199,DW_AT_MIPS_stride:8200,DW_AT_MIPS_abstract_name:8201,DW_AT_MIPS_clone_origin:8202,DW_AT_MIPS_has_inlines:8203,DW_AT_sf_names:8449,DW_AT_src_info:8450,DW_AT_mac_info:8451,DW_AT_src_coords:8452,DW_AT_body_begin:8453,DW_AT_body_end:8454,;dwarf_location_atom:T(13,4)=eDW_OP_addr:3,DW_OP_deref:6,DW_OP_const1u:8,DW_OP_const1s:9,DW_OP_const2u:10,DW_OP_const2s:11,DW_OP_const4u:12,DW_OP_const4s:13,DW_OP_const8u:14,DW_OP_const8s:15,DW_OP_constu:16,DW_OP_consts:17,DW_OP_dup:18,DW_OP_drop:19,DW_OP_over:20,DW_OP_pick:21,DW_OP_swap:22,DW_OP_rot:23,DW_OP_xderef:24,DW_OP_abs:25,DW_OP_and:26,DW_OP_div:27,DW_OP_minus:28,DW_OP_mod:29,DW_OP_mul:30,DW_OP_neg:31,DW_OP_not:32,DW_OP_or:33,DW_OP_plus:34,DW_OP_plus_uconst:35,DW_OP_shl:36,DW_OP_shr:37,\DW_OP_shra:38,DW_OP_xor:39,DW_OP_bra:40,DW_OP_eq:41,DW_OP_ge:42,DW_OP_gt:43,DW_OP_le:44,DW_OP_lt:45,DW_OP_ne:46,DW_OP_skip:47,DW_OP_lit0:48,DW_OP_lit1:49,DW_OP_lit2:50,DW_OP_lit3:51,DW_OP_lit4:52,DW_OP_lit5:53,DW_OP_lit6:54,DW_OP_lit7:55,DW_OP_lit8:56,DW_OP_lit9:57,DW_OP_lit10:58,DW_OP_lit11:59,DW_OP_lit12:60,DW_OP_lit13:61,DW_OP_lit14:62,DW_OP_lit15:63,DW_OP_lit16:64,DW_OP_lit17:65,DW_OP_lit18:66,DW_OP_lit19:67,DW_OP_lit20:68,DW_OP_lit21:69,DW_OP_lit22:70,DW_OP_lit23:71,\DW_OP_lit24:72,DW_OP_lit25:73,DW_OP_lit26:74,DW_OP_lit27:75,DW_OP_lit28:76,DW_OP_lit29:77,DW_OP_lit30:78,DW_OP_lit31:79,DW_OP_reg0:80,DW_OP_reg1:81,DW_OP_reg2:82,DW_OP_reg3:83,DW_OP_reg4:84,DW_OP_reg5:85,DW_OP_reg6:86,DW_OP_reg7:87,DW_OP_reg8:88,DW_OP_reg9:89,DW_OP_reg10:90,DW_OP_reg11:91,DW_OP_reg12:92,DW_OP_reg13:93,DW_OP_reg14:94,DW_OP_reg15:95,DW_OP_reg16:96,DW_OP_reg17:97,DW_OP_reg18:98,DW_OP_reg19:99,DW_OP_reg20:100,DW_OP_reg21:101,DW_OP_reg22:102,DW_OP_reg23:103,DW_OP_reg24:104,\DW_OP_reg25:105,DW_OP_reg26:106,DW_OP_reg27:107,DW_OP_reg28:108,DW_OP_reg29:109,DW_OP_reg30:110,DW_OP_reg31:111,DW_OP_breg0:112,DW_OP_breg1:113,DW_OP_breg2:114,DW_OP_breg3:115,DW_OP_breg4:116,DW_OP_breg5:117,DW_OP_breg6:118,DW_OP_breg7:119,DW_OP_breg8:120,DW_OP_breg9:121,DW_OP_breg10:122,DW_OP_breg11:123,DW_OP_breg12:124,DW_OP_breg13:125,DW_OP_breg14:126,DW_OP_breg15:127,DW_OP_breg16:128,DW_OP_breg17:129,DW_OP_breg18:130,DW_OP_breg19:131,DW_OP_breg20:132,DW_OP_breg21:133,DW_OP_breg22:134,DW_OP_breg23:135,DW_OP_breg24:136,\DW_OP_breg25:137,DW_OP_breg26:138,DW_OP_breg27:139,DW_OP_breg28:140,DW_OP_breg29:141,DW_OP_breg30:142,DW_OP_breg31:143,DW_OP_regx:144,DW_OP_fbreg:145,DW_OP_bregx:146,DW_OP_piece:147,DW_OP_deref_size:148,DW_OP_xderef_size:149,DW_OP_nop:150,;dwarf_type:T(13,5)=eDW_ATE_void:0,DW_ATE_address:1,DW_ATE_boolean:2,DW_ATE_complex_float:3,DW_ATE_float:4,DW_ATE_signed:5,DW_ATE_signed_char:6,DW_ATE_unsigned:7,DW_ATE_unsigned_char:8,;dwarf_array_dim_ordering:T(13,6)=eDW_ORD_row_major:0,DW_ORD_col_major:1,;dwarf_access_attribute:T(13,7)=eDW_ACCESS_public:1,DW_ACCESS_protected:2,DW_ACCESS_private:3,;dwarf_visibility_attribute:T(13,8)=eDW_VIS_local:1,DW_VIS_exported:2,DW_VIS_qualified:3,;dwarf_virtuality_attribute:T(13,9)=eDW_VIRTUALITY_none:0,DW_VIRTUALITY_virtual:1,DW_VIRTUALITY_pure_virtual:2,;dwarf_id_case:T(13,10)=eDW_ID_case_sensitive:0,DW_ID_up_case:1,DW_ID_down_case:2,DW_ID_case_insensitive:3,;dwarf_calling_convention:T(13,11)=eDW_CC_normal:1,DW_CC_program:2,DW_CC_nocall:3,;dwarf_inline_attribute:T(13,12)=eDW_INL_not_inlined:0,DW_INL_inlined:1,DW_INL_declared_not_inlined:2,DW_INL_declared_inlined:3,;dwarf_discrim_list:T(13,13)=eDW_DSC_label:0,DW_DSC_range:1,;dwarf_line_number_ops:T(13,14)=eDW_LNS_extended_op:0,DW_LNS_copy:1,DW_LNS_advance_pc:2,DW_LNS_advance_line:3,DW_LNS_set_file:4,DW_LNS_set_column:5,DW_LNS_negate_stmt:6,DW_LNS_set_basic_block:7,DW_LNS_const_add_pc:8,DW_LNS_fixed_advance_pc:9,;dwarf_line_number_x_ops:T(13,15)=eDW_LNE_end_sequence:1,DW_LNE_set_address:2,DW_LNE_define_file:3,;dwarf_call_frame_info:T(13,16)=eDW_CFA_advance_loc:64,DW_CFA_offset:128,DW_CFA_restore:192,DW_CFA_nop:0,DW_CFA_set_loc:1,DW_CFA_advance_loc1:2,DW_CFA_advance_loc2:3,DW_CFA_advance_loc4:4,DW_CFA_offset_extended:5,DW_CFA_restore_extended:6,DW_CFA_undefined:7,DW_CFA_same_value:8,DW_CFA_register:9,DW_CFA_remember_state:10,DW_CFA_restore_state:11,DW_CFA_def_cfa:12,DW_CFA_def_cfa_register:13,DW_CFA_def_cfa_offset:14,DW_CFA_MIPS_advance_loc8:29,DW_CFA_GNU_window_save:45,DW_CFA_GNU_args_size:46,;dwarf_source_language:T(13,17)=eDW_LANG_C89:1,DW_LANG_C:2,DW_LANG_Ada83:3,DW_LANG_C_plus_plus:4,DW_LANG_Cobol74:5,DW_LANG_Cobol85:6,DW_LANG_Fortran77:7,DW_LANG_Fortran90:8,DW_LANG_Pascal83:9,DW_LANG_Modula2:10,DW_LANG_Mips_Assembler:32769,;dwarf_macinfo_record_type:T(13,18)=eDW_MACINFO_define:1,DW_MACINFO_undef:2,DW_MACINFO_start_file:3,DW_MACINFO_end_file:4,DW_MACINFO_vendor_ext:255,;include/stddef.hptrdiff_t:t(14,1)=(0,1)size_t:t(14,2)=(0,4)wchar_t:t(14,3)=(0,3)wint_t:t(14,4)=(0,4)frame.hframe_state:T(15,1)=s532cfa:(15,2)=*(0,19),0,32;eh_ptr:(15,2),32,32;cfa_offset:(0,3),64,32;args_size:(0,3),96,32;reg_or_offset:(15,3)=ar(0,0);0;101;(0,3),128,3264;cfa_reg:(0,9),3392,16;retaddr_column:(0,9),3408,16;saved:(15,4)=ar(0,0);0;101;(0,2),3424,816;;frame_state:t(15,5)=(15,1)object:T(15,6)=s24pc_begin:(15,2),0,32;pc_end:(15,2),32,32;fde_begin:(15,7)=*(15,8)=xsdwarf_fde:,64,32;fde_array:(15,9)=*(15,7),96,32;count:(14,2),128,32;next:(15,10)=*(15,6),160,32;;sword:t(0,20)=(0,1)uword:t(0,21)=(0,4)uaddr:t(0,22)=(0,4)saddr:t(0,23)=(0,1)ubyte:t(0,24)=(0,11)dwarf_cie:T(0,25)=s12length:(0,21),0,32;CIE_id:(0,20),32,32;version:(0,24),64,8;augmentation:(0,26)=ar(0,0);0;-1;(0,2),72,0;;dwarf_fde:T(15,8)=s16length:(0,21),0,32;CIE_delta:(0,20),32,32;pc_begin:(15,2),64,32;pc_range:(0,22),96,32;;fde:t(0,27)=(15,8)cie_info:T(0,28)=s20augmentation:(8,4),0,32;eh_ptr:(15,2),32,32;code_align:(0,1),64,32;data_align:(0,1),96,32;ra_regno:(0,4),128,32;;frame_state_internal:T(0,29)=s536s:(15,1),0,4256;saved_state:(0,30)=*(0,29),4256,32;;decode_uleb128:f(15,2)buf:P(0,31)=*(0,11)r:P(0,32)=*(0,4)decode_sleb128:f(15,2)buf:P(0,31)r:P(0,33)=*(0,1)unaligned:T(0,34)=u8p:(15,2),0,32;b2:(0,9),0,16;b4:(0,4),0,32;b8:(0,7),0,64;;fde_insert:f(0,19)array:P(0,35)=*(0,36)=*(0,27)i:P(14,2)this_fde:P(0,36)count_fdes:f(14,2)this_fde:P(0,36)add_fdes:f(0,19)this_fde:P(0,36)array:P(0,35)i_ptr:P(0,37)=*(14,2)beg_ptr:P(0,38)=*(15,2)end_ptr:P(0,38)frame_init:f(0,19)ob:P(15,10)find_fde:f(0,36)pc:P(15,2)extract_cie_info:f(15,2)f:P(0,36)c:P(0,39)=*(0,28)execute_cfa_insn:f(15,2)p:P(15,2)state:P(0,30)info:P(0,39)pc:P(0,38)__register_frame_info:F(0,19)begin:P(15,2)ob:P(15,10)__register_frame_info_table:F(0,19)begin:P(15,2)ob:P(15,10)__deregister_frame_info:F(0,19)begin:P(15,2)__frame_state_for:F(0,40)=*(15,1)pc_target:P(15,2)state_in:P(0,40)objects:S(15,10)ÔÔ èèÔ ¼¼ À||½oÿÿþ<< -\\$ 7€€D  A Ä ÄÞðGÿ´ÿ´MÿÐÿÐSÿèÿè$[$$ `$$$$x e%œ%œ¨n&D&Dt&L&L{&T&T‚&\&\TŒ'°'°˜‘'°À™Apn¡WÞ¨ª_ˆ$ ¶_¬\ ¼gÞÆgæ;Õi!,ÙPapyrus3/JpegDir/JpgLossy/JMORECFG.H0000755000175000017500000003102507535143454014145 0ustar /* * jmorecfg.h * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains additional configuration options that customize the * JPEG software for special applications or support machine-dependent * optimizations. Most users will not need to touch this file. */ /* * Define BITS_IN_JSAMPLE as either * 8 for 8-bit sample values (the usual setting) * 12 for 12-bit sample values * Only 8 and 12 are legal data precisions for lossy JPEG according to the * JPEG standard, and the IJG code does not support anything else! * We do not support run-time selection of data precision, sorry. */ #define BITS_IN_JSAMPLE 8 /* use 8 or 12 */ /* * Maximum number of components (color channels) allowed in JPEG image. * To meet the letter of the JPEG spec, set this to 255. However, darn * few applications need more than 4 channels (maybe 5 for CMYK + alpha * mask). We recommend 10 as a reasonable compromise; use 4 if you are * really short on memory. (Each allowed component costs a hundred or so * bytes of storage, whether actually used in an image or not.) */ #define MAX_COMPONENTS 10 /* maximum number of image components */ /* * Basic data types. * You may need to change these if you have a machine with unusual data * type sizes; for example, "char" not 8 bits, "short" not 16 bits, * or "long" not 32 bits. We don't care whether "int" is 16 or 32 bits, * but it had better be at least 16. */ /* Representation of a single sample (pixel element value). * We frequently allocate large arrays of these, so it's important to keep * them small. But if you have memory to burn and access to char or short * arrays is very slow on your hardware, you might want to change these. */ #if BITS_IN_JSAMPLE == 8 /* JSAMPLE should be the smallest type that will hold the values 0..255. * You can use a signed char by having GETJSAMPLE mask it with 0xFF. */ #ifdef HAVE_UNSIGNED_CHAR typedef unsigned char JSAMPLE; #define GETJSAMPLE(value) ((int) (value)) #else /* not HAVE_UNSIGNED_CHAR */ typedef char JSAMPLE; #ifdef CHAR_IS_UNSIGNED #define GETJSAMPLE(value) ((int) (value)) #else #define GETJSAMPLE(value) ((int) (value) & 0xFF) #endif /* CHAR_IS_UNSIGNED */ #endif /* HAVE_UNSIGNED_CHAR */ #define MAXJSAMPLE 255 #define CENTERJSAMPLE 128 #endif /* BITS_IN_JSAMPLE == 8 */ #if BITS_IN_JSAMPLE == 12 /* JSAMPLE should be the smallest type that will hold the values 0..4095. * On nearly all machines "short" will do nicely. */ typedef short JSAMPLE; #define GETJSAMPLE(value) ((int) (value)) #define MAXJSAMPLE 4095 #define CENTERJSAMPLE 2048 #endif /* BITS_IN_JSAMPLE == 12 */ /* Representation of a DCT frequency coefficient. * This should be a signed value of at least 16 bits; "short" is usually OK. * Again, we allocate large arrays of these, but you can change to int * if you have memory to burn and "short" is really slow. */ typedef short JCOEF; /* Compressed datastreams are represented as arrays of JOCTET. * These must be EXACTLY 8 bits wide, at least once they are written to * external storage. Note that when using the stdio data source/destination * managers, this is also the data type passed to fread/fwrite. */ #ifdef HAVE_UNSIGNED_CHAR typedef unsigned char JOCTET; #define GETJOCTET(value) (value) #else /* not HAVE_UNSIGNED_CHAR */ typedef char JOCTET; #ifdef CHAR_IS_UNSIGNED #define GETJOCTET(value) (value) #else #define GETJOCTET(value) ((value) & 0xFF) #endif /* CHAR_IS_UNSIGNED */ #endif /* HAVE_UNSIGNED_CHAR */ /* These typedefs are used for various table entries and so forth. * They must be at least as wide as specified; but making them too big * won't cost a huge amount of memory, so we don't provide special * extraction code like we did for JSAMPLE. (In other words, these * typedefs live at a different point on the speed/space tradeoff curve.) */ /* UINT8 must hold at least the values 0..255. */ #ifdef HAVE_UNSIGNED_CHAR typedef unsigned char UINT8; #else /* not HAVE_UNSIGNED_CHAR */ #ifdef CHAR_IS_UNSIGNED typedef char UINT8; #else /* not CHAR_IS_UNSIGNED */ typedef short UINT8; #endif /* CHAR_IS_UNSIGNED */ #endif /* HAVE_UNSIGNED_CHAR */ /* UINT16 must hold at least the values 0..65535. */ #ifdef HAVE_UNSIGNED_SHORT typedef unsigned short UINT16; #else /* not HAVE_UNSIGNED_SHORT */ typedef unsigned int UINT16; #endif /* HAVE_UNSIGNED_SHORT */ /* INT16 must hold at least the values -32768..32767. */ #ifndef XMD_H /* X11/xmd.h correctly defines INT16 */ typedef short INT16; #endif /* INT32 must hold at least signed 32-bit values. */ #ifndef XMD_H /* X11/xmd.h correctly defines INT32 */ typedef long INT32; #endif /* Datatype used for image dimensions. The JPEG standard only supports * images up to 64K*64K due to 16-bit fields in SOF markers. Therefore * "unsigned int" is sufficient on all machines. However, if you need to * handle larger images and you don't mind deviating from the spec, you * can change this datatype. */ typedef unsigned int JDIMENSION; #define JPEG_MAX_DIMENSION 65500L /* a tad under 64K to prevent overflows */ /* These macros are used in all function definitions and extern declarations. * You could modify them if you need to change function linkage conventions; * in particular, you'll need to do that to make the library a Windows DLL. * Another application is to make all functions global for use with debuggers * or code profilers that require it. */ /* a function called through method pointers: */ #define METHODDEF(type) static type /* a function used only in its module: */ #define LOCAL(type) static type /* a function referenced thru EXTERNs: */ #define GLOBAL(type) type /* a reference to a GLOBAL function: */ #define EXTERN(type) extern type /* This macro is used to declare a "method", that is, a function pointer. * We want to supply prototype parameters if the compiler can cope. * Note that the arglist parameter must be parenthesized! * Again, you can customize this if you need special linkage keywords. */ #ifdef HAVE_PROTOTYPES #define JMETHOD(type,methodname,arglist) type (*methodname) arglist #else #define JMETHOD(type,methodname,arglist) type (*methodname) () #endif /* Here is the pseudo-keyword for declaring pointers that must be "far" * on 80x86 machines. Most of the specialized coding for 80x86 is handled * by just saying "FAR *" where such a pointer is needed. In a few places * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol. */ #ifdef NEED_FAR_POINTERS #define FAR far #else #define FAR #endif /* * On a few systems, type boolean and/or its values FALSE, TRUE may appear * in standard header files. Or you may have conflicts with application- * specific header files that you want to include together with these files. * Defining HAVE_BOOLEAN before including jpeglib.h should make it work. */ #ifndef HAVE_BOOLEAN typedef int boolean; #endif #ifndef FALSE /* in case these macros already exist */ #define FALSE 0 /* values of boolean */ #endif #ifndef TRUE #define TRUE 1 #endif /* * The remaining options affect code selection within the JPEG library, * but they don't need to be visible to most applications using the library. * To minimize application namespace pollution, the symbols won't be * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined. */ #ifdef JPEG_INTERNALS #define JPEG_INTERNAL_OPTIONS #endif #ifdef JPEG_INTERNAL_OPTIONS /* * These defines indicate whether to include various optional functions. * Undefining some of these symbols will produce a smaller but less capable * library. Note that you can leave certain source files out of the * compilation/linking process if you've #undef'd the corresponding symbols. * (You may HAVE to do that if your compiler doesn't like null source files.) */ /* Arithmetic coding is unsupported for legal reasons. Complaints to IBM. */ /* Capability options common to encoder and decoder: */ #define DCT_ISLOW_SUPPORTED /* slow but accurate integer algorithm */ #define DCT_IFAST_SUPPORTED /* faster, less accurate integer method */ #define DCT_FLOAT_SUPPORTED /* floating-point: accurate, fast on fast HW */ /* Encoder capability options: */ #undef C_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */ #define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */ #define C_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/ #define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */ /* Note: if you selected 12-bit data precision, it is dangerous to turn off * ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit * precision, so jchuff.c normally uses entropy optimization to compute * usable tables for higher precision. If you don't want to do optimization, * you'll have to supply different default Huffman tables. * The exact same statements apply for progressive JPEG: the default tables * don't work for progressive mode. (This may get fixed, however.) */ #define INPUT_SMOOTHING_SUPPORTED /* Input image smoothing option? */ /* Decoder capability options: */ #undef D_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */ #define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */ #define D_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/ #define SAVE_MARKERS_SUPPORTED /* jpeg_save_markers() needed? */ #define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing? (Progressive only) */ #define IDCT_SCALING_SUPPORTED /* Output rescaling via IDCT? */ #undef UPSAMPLE_SCALING_SUPPORTED /* Output rescaling at upsample stage? */ #define UPSAMPLE_MERGING_SUPPORTED /* Fast path for sloppy upsampling? */ #define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */ #define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */ /* more capability options later, no doubt */ /* * Ordering of RGB data in scanlines passed to or from the application. * If your application wants to deal with data in the order B,G,R, just * change these macros. You can also deal with formats such as R,G,B,X * (one extra byte per pixel) by changing RGB_PIXELSIZE. Note that changing * the offsets will also change the order in which colormap data is organized. * RESTRICTIONS: * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats. * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not * useful if you are using JPEG color spaces other than YCbCr or grayscale. * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE * is not 3 (they don't understand about dummy color components!). So you * can't use color quantization if you change that value. */ #define RGB_RED 0 /* Offset of Red in an RGB scanline element */ #define RGB_GREEN 1 /* Offset of Green */ #define RGB_BLUE 2 /* Offset of Blue */ #define RGB_PIXELSIZE 3 /* JSAMPLEs per RGB scanline element */ /* Definitions for speed-related optimizations. */ /* If your compiler supports inline functions, define INLINE * as the inline keyword; otherwise define it as empty. */ #ifndef INLINE #ifdef __GNUC__ /* for instance, GNU C knows about inline */ #define INLINE __inline__ #endif #ifndef INLINE #define INLINE /* default is to define it as empty */ #endif #endif /* On some machines (notably 68000 series) "int" is 32 bits, but multiplying * two 16-bit shorts is faster than multiplying two ints. Define MULTIPLIER * as short on such a machine. MULTIPLIER must be at least 16 bits wide. */ #ifndef MULTIPLIER #define MULTIPLIER int /* type for fastest integer multiply */ #endif /* FAST_FLOAT should be either float or double, whichever is done faster * by your compiler. (Note that this type is only used in the floating point * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.) * Typically, float is faster in ANSI C compilers, while double is faster in * pre-ANSI compilers (because they insist on converting to double anyway). * The code below therefore chooses float if we have ANSI-style prototypes. */ #ifndef FAST_FLOAT #ifdef HAVE_PROTOTYPES #define FAST_FLOAT float #else #define FAST_FLOAT double #endif #endif #endif /* JPEG_INTERNAL_OPTIONS */ Papyrus3/JpegDir/JpgLossy/wizard.doc0000755000175000017500000002336207535143454014634 0ustar Advanced usage instructions for the Independent JPEG Group's JPEG software ========================================================================== This file describes cjpeg's "switches for wizards". The "wizard" switches are intended for experimentation with JPEG by persons who are reasonably knowledgeable about the JPEG standard. If you don't know what you are doing, DON'T USE THESE SWITCHES. You'll likely produce files with worse image quality and/or poorer compression than you'd get from the default settings. Furthermore, these switches must be used with caution when making files intended for general use, because not all JPEG decoders will support unusual JPEG parameter settings. Quantization Table Adjustment ----------------------------- Ordinarily, cjpeg starts with a default set of tables (the same ones given as examples in the JPEG standard) and scales them up or down according to the -quality setting. The details of the scaling algorithm can be found in jcparam.c. At very low quality settings, some quantization table entries can get scaled up to values exceeding 255. Although 2-byte quantization values are supported by the IJG software, this feature is not in baseline JPEG and is not supported by all implementations. If you need to ensure wide compatibility of low-quality files, you can constrain the scaled quantization values to no more than 255 by giving the -baseline switch. Note that use of -baseline will result in poorer quality for the same file size, since more bits than necessary are expended on higher AC coefficients. You can substitute a different set of quantization values by using the -qtables switch: -qtables file Use the quantization tables given in the named file. The specified file should be a text file containing decimal quantization values. The file should contain one to four tables, each of 64 elements. The tables are implicitly numbered 0,1,etc. in order of appearance. Table entries appear in normal array order (NOT in the zigzag order in which they will be stored in the JPEG file). Quantization table files are free format, in that arbitrary whitespace can appear between numbers. Also, comments can be included: a comment starts with '#' and extends to the end of the line. Here is an example file that duplicates the default quantization tables: # Quantization tables given in JPEG spec, section K.1 # This is table 0 (the luminance table): 16 11 10 16 24 40 51 61 12 12 14 19 26 58 60 55 14 13 16 24 40 57 69 56 14 17 22 29 51 87 80 62 18 22 37 56 68 109 103 77 24 35 55 64 81 104 113 92 49 64 78 87 103 121 120 101 72 92 95 98 112 100 103 99 # This is table 1 (the chrominance table): 17 18 24 47 99 99 99 99 18 21 26 66 99 99 99 99 24 26 56 99 99 99 99 99 47 66 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 99 If the -qtables switch is used without -quality, then the specified tables are used exactly as-is. If both -qtables and -quality are used, then the tables taken from the file are scaled in the same fashion that the default tables would be scaled for that quality setting. If -baseline appears, then the quantization values are constrained to the range 1-255. By default, cjpeg will use quantization table 0 for luminance components and table 1 for chrominance components. To override this choice, use the -qslots switch: -qslots N[,...] Select which quantization table to use for each color component. The -qslots switch specifies a quantization table number for each color component, in the order in which the components appear in the JPEG SOF marker. For example, to create a separate table for each of Y,Cb,Cr, you could provide a -qtables file that defines three quantization tables and say "-qslots 0,1,2". If -qslots gives fewer table numbers than there are color components, then the last table number is repeated as necessary. Sampling Factor Adjustment -------------------------- By default, cjpeg uses 2:1 horizontal and vertical downsampling when compressing YCbCr data, and no downsampling for all other color spaces. You can override this default with the -sample switch: -sample HxV[,...] Set JPEG sampling factors for each color component. The -sample switch specifies the JPEG sampling factors for each color component, in the order in which they appear in the JPEG SOF marker. If you specify fewer HxV pairs than there are components, the remaining components are set to 1x1 sampling. For example, the default YCbCr setting is equivalent to "-sample 2x2,1x1,1x1", which can be abbreviated to "-sample 2x2". There are still some JPEG decoders in existence that support only 2x1 sampling (also called 4:2:2 sampling). Compatibility with such decoders can be achieved by specifying "-sample 2x1". This is not recommended unless really necessary, since it increases file size and encoding/decoding time with very little quality gain. Multiple Scan / Progression Control ----------------------------------- By default, cjpeg emits a single-scan sequential JPEG file. The -progressive switch generates a progressive JPEG file using a default series of progression parameters. You can create multiple-scan sequential JPEG files or progressive JPEG files with custom progression parameters by using the -scans switch: -scans file Use the scan sequence given in the named file. The specified file should be a text file containing a "scan script". The script specifies the contents and ordering of the scans to be emitted. Each entry in the script defines one scan. A scan definition specifies the components to be included in the scan, and for progressive JPEG it also specifies the progression parameters Ss,Se,Ah,Al for the scan. Scan definitions are separated by semicolons (';'). A semicolon after the last scan definition is optional. Each scan definition contains one to four component indexes, optionally followed by a colon (':') and the four progressive-JPEG parameters. The component indexes denote which color component(s) are to be transmitted in the scan. Components are numbered in the order in which they appear in the JPEG SOF marker, with the first component being numbered 0. (Note that these indexes are not the "component ID" codes assigned to the components, just positional indexes.) The progression parameters for each scan are: Ss Zigzag index of first coefficient included in scan Se Zigzag index of last coefficient included in scan Ah Zero for first scan of a coefficient, else Al of prior scan Al Successive approximation low bit position for scan If the progression parameters are omitted, the values 0,63,0,0 are used, producing a sequential JPEG file. cjpeg automatically determines whether the script represents a progressive or sequential file, by observing whether Ss and Se values other than 0 and 63 appear. (The -progressive switch is not needed to specify this; in fact, it is ignored when -scans appears.) The scan script must meet the JPEG restrictions on progression sequences. (cjpeg checks that the spec's requirements are obeyed.) Scan script files are free format, in that arbitrary whitespace can appear between numbers and around punctuation. Also, comments can be included: a comment starts with '#' and extends to the end of the line. For additional legibility, commas or dashes can be placed between values. (Actually, any single punctuation character other than ':' or ';' can be inserted.) For example, the following two scan definitions are equivalent: 0 1 2: 0 63 0 0; 0,1,2 : 0-63, 0,0 ; Here is an example of a scan script that generates a partially interleaved sequential JPEG file: 0; # Y only in first scan 1 2; # Cb and Cr in second scan Here is an example of a progressive scan script using only spectral selection (no successive approximation): # Interleaved DC scan for Y,Cb,Cr: 0,1,2: 0-0, 0, 0 ; # AC scans: 0: 1-2, 0, 0 ; # First two Y AC coefficients 0: 3-5, 0, 0 ; # Three more 1: 1-63, 0, 0 ; # All AC coefficients for Cb 2: 1-63, 0, 0 ; # All AC coefficients for Cr 0: 6-9, 0, 0 ; # More Y coefficients 0: 10-63, 0, 0 ; # Remaining Y coefficients Here is an example of a successive-approximation script. This is equivalent to the default script used by "cjpeg -progressive" for YCbCr images: # Initial DC scan for Y,Cb,Cr (lowest bit not sent) 0,1,2: 0-0, 0, 1 ; # First AC scan: send first 5 Y AC coefficients, minus 2 lowest bits: 0: 1-5, 0, 2 ; # Send all Cr,Cb AC coefficients, minus lowest bit: # (chroma data is usually too small to be worth subdividing further; # but note we send Cr first since eye is least sensitive to Cb) 2: 1-63, 0, 1 ; 1: 1-63, 0, 1 ; # Send remaining Y AC coefficients, minus 2 lowest bits: 0: 6-63, 0, 2 ; # Send next-to-lowest bit of all Y AC coefficients: 0: 1-63, 2, 1 ; # At this point we've sent all but the lowest bit of all coefficients. # Send lowest bit of DC coefficients 0,1,2: 0-0, 1, 0 ; # Send lowest bit of AC coefficients 2: 1-63, 1, 0 ; 1: 1-63, 1, 0 ; # Y AC lowest bit scan is last; it's usually the largest scan 0: 1-63, 1, 0 ; It may be worth pointing out that this script is tuned for quality settings of around 50 to 75. For lower quality settings, you'd probably want to use a script with fewer stages of successive approximation (otherwise the initial scans will be really bad). For higher quality settings, you might want to use more stages of successive approximation (so that the initial scans are not too large). Papyrus3/JpegDir/JpgLossy/MAKEFILE.WAT0000755000175000017500000003055607535143454014402 0ustar # Makefile for Independent JPEG Group's software # This makefile is suitable for Watcom C/C++ 10.0 on MS-DOS (using # dos4g extender), OS/2, and Windows NT console mode. # Thanks to Janos Haide, jhaide@btrvtech.com. # Read installation instructions before saying "wmake" !! # Uncomment line for desired system SYSTEM=DOS #SYSTEM=OS2 #SYSTEM=NT # The name of your C compiler: CC= wcl386 # You may need to adjust these cc options: CFLAGS= -4r -ort -wx -zq -bt=$(SYSTEM) # Caution: avoid -ol or -ox; these generate bad code with 10.0 or 10.0a. # Generally, we recommend defining any configuration symbols in jconfig.h, # NOT via -D switches here. # Link-time cc options: !ifeq SYSTEM DOS LDFLAGS= -zq -l=dos4g !else ifeq SYSTEM OS2 LDFLAGS= -zq -l=os2v2 !else ifeq SYSTEM NT LDFLAGS= -zq -l=nt !endif # Put here the object file name for the correct system-dependent memory # manager file. jmemnobs should work fine for dos4g or OS/2 environment. SYSDEPMEM= jmemnobs.obj # End of configurable options. # source files: JPEG library proper LIBSOURCES= jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c & jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c & jcphuff.c jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c & jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c & jdinput.c jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c & jdpostct.c jdsample.c jdtrans.c jerror.c jfdctflt.c jfdctfst.c & jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c jquant1.c & jquant2.c jutils.c jmemmgr.c # memmgr back ends: compile only one of these into a working library SYSDEPSOURCES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemmac.c # source files: cjpeg/djpeg/jpegtran applications, also rdjpgcom/wrjpgcom APPSOURCES= cjpeg.c djpeg.c jpegtran.c rdjpgcom.c wrjpgcom.c cdjpeg.c & rdcolmap.c rdswitch.c transupp.c rdppm.c wrppm.c rdgif.c wrgif.c & rdtarga.c wrtarga.c rdbmp.c wrbmp.c rdrle.c wrrle.c SOURCES= $(LIBSOURCES) $(SYSDEPSOURCES) $(APPSOURCES) # files included by source files INCLUDES= jchuff.h jdhuff.h jdct.h jerror.h jinclude.h jmemsys.h jmorecfg.h & jpegint.h jpeglib.h jversion.h cdjpeg.h cderror.h transupp.h # documentation, test, and support files DOCS= README install.doc usage.doc cjpeg.1 djpeg.1 jpegtran.1 rdjpgcom.1 & wrjpgcom.1 wizard.doc example.c libjpeg.doc structure.doc & coderules.doc filelist.doc change.log MKFILES= configure makefile.cfg makefile.ansi makefile.unix makefile.bcc & makefile.mc6 makefile.dj makefile.wat makefile.vc makelib.ds & makeapps.ds makeproj.mac makcjpeg.st makdjpeg.st makljpeg.st & maktjpeg.st makefile.manx makefile.sas makefile.mms makefile.vms & makvms.opt CONFIGFILES= jconfig.cfg jconfig.bcc jconfig.mc6 jconfig.dj jconfig.wat & jconfig.vc jconfig.mac jconfig.st jconfig.manx jconfig.sas & jconfig.vms CONFIGUREFILES= config.guess config.sub install-sh ltconfig ltmain.sh OTHERFILES= jconfig.doc ckconfig.c ansi2knr.c ansi2knr.1 jmemdosa.asm TESTFILES= testorig.jpg testimg.ppm testimg.bmp testimg.jpg testprog.jpg & testimgp.jpg DISTFILES= $(DOCS) $(MKFILES) $(CONFIGFILES) $(SOURCES) $(INCLUDES) & $(CONFIGUREFILES) $(OTHERFILES) $(TESTFILES) # library object files common to compression and decompression COMOBJECTS= jcomapi.obj jutils.obj jerror.obj jmemmgr.obj $(SYSDEPMEM) # compression library object files CLIBOBJECTS= jcapimin.obj jcapistd.obj jctrans.obj jcparam.obj jdatadst.obj & jcinit.obj jcmaster.obj jcmarker.obj jcmainct.obj jcprepct.obj & jccoefct.obj jccolor.obj jcsample.obj jchuff.obj jcphuff.obj & jcdctmgr.obj jfdctfst.obj jfdctflt.obj jfdctint.obj # decompression library object files DLIBOBJECTS= jdapimin.obj jdapistd.obj jdtrans.obj jdatasrc.obj & jdmaster.obj jdinput.obj jdmarker.obj jdhuff.obj jdphuff.obj & jdmainct.obj jdcoefct.obj jdpostct.obj jddctmgr.obj jidctfst.obj & jidctflt.obj jidctint.obj jidctred.obj jdsample.obj jdcolor.obj & jquant1.obj jquant2.obj jdmerge.obj # These objectfiles are included in libjpeg.lib LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS) # object files for sample applications (excluding library files) COBJECTS= cjpeg.obj rdppm.obj rdgif.obj rdtarga.obj rdrle.obj rdbmp.obj & rdswitch.obj cdjpeg.obj DOBJECTS= djpeg.obj wrppm.obj wrgif.obj wrtarga.obj wrrle.obj wrbmp.obj & rdcolmap.obj cdjpeg.obj TROBJECTS= jpegtran.obj rdswitch.obj cdjpeg.obj transupp.obj all: libjpeg.lib cjpeg.exe djpeg.exe jpegtran.exe rdjpgcom.exe wrjpgcom.exe libjpeg.lib: $(LIBOBJECTS) - del libjpeg.lib * wlib -n libjpeg.lib $(LIBOBJECTS) cjpeg.exe: $(COBJECTS) libjpeg.lib $(CC) $(LDFLAGS) $(COBJECTS) libjpeg.lib djpeg.exe: $(DOBJECTS) libjpeg.lib $(CC) $(LDFLAGS) $(DOBJECTS) libjpeg.lib jpegtran.exe: $(TROBJECTS) libjpeg.lib $(CC) $(LDFLAGS) $(TROBJECTS) libjpeg.lib rdjpgcom.exe: rdjpgcom.c $(CC) $(CFLAGS) $(LDFLAGS) rdjpgcom.c wrjpgcom.exe: wrjpgcom.c $(CC) $(CFLAGS) $(LDFLAGS) wrjpgcom.c .c.obj: $(CC) $(CFLAGS) -c $< jconfig.h: jconfig.doc echo You must prepare a system-dependent jconfig.h file. echo Please read the installation directions in install.doc. exit 1 clean: .SYMBOLIC - del *.obj - del libjpeg.lib - del cjpeg.exe - del djpeg.exe - del jpegtran.exe - del rdjpgcom.exe - del wrjpgcom.exe - del testout*.* test: cjpeg.exe djpeg.exe jpegtran.exe .SYMBOLIC - del testout*.* djpeg -dct int -ppm -outfile testout.ppm testorig.jpg djpeg -dct int -bmp -colors 256 -outfile testout.bmp testorig.jpg cjpeg -dct int -outfile testout.jpg testimg.ppm djpeg -dct int -ppm -outfile testoutp.ppm testprog.jpg cjpeg -dct int -progressive -opt -outfile testoutp.jpg testimg.ppm jpegtran -outfile testoutt.jpg testprog.jpg !ifeq SYSTEM DOS fc /b testimg.ppm testout.ppm fc /b testimg.bmp testout.bmp fc /b testimg.jpg testout.jpg fc /b testimg.ppm testoutp.ppm fc /b testimgp.jpg testoutp.jpg fc /b testorig.jpg testoutt.jpg !else echo n > n.tmp comp testimg.ppm testout.ppm < n.tmp comp testimg.bmp testout.bmp < n.tmp comp testimg.jpg testout.jpg < n.tmp comp testimg.ppm testoutp.ppm < n.tmp comp testimgp.jpg testoutp.jpg < n.tmp comp testorig.jpg testoutt.jpg < n.tmp del n.tmp !endif jcapimin.obj: jcapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcapistd.obj: jcapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccoefct.obj: jccoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccolor.obj: jccolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcdctmgr.obj: jcdctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jchuff.obj: jchuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcinit.obj: jcinit.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmainct.obj: jcmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmarker.obj: jcmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmaster.obj: jcmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcomapi.obj: jcomapi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcparam.obj: jcparam.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcphuff.obj: jcphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcprepct.obj: jcprepct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcsample.obj: jcsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jctrans.obj: jctrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapimin.obj: jdapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapistd.obj: jdapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdatadst.obj: jdatadst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdatasrc.obj: jdatasrc.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdcoefct.obj: jdcoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdcolor.obj: jdcolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jddctmgr.obj: jddctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jdhuff.obj: jdhuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdinput.obj: jdinput.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmainct.obj: jdmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmarker.obj: jdmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmaster.obj: jdmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmerge.obj: jdmerge.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdphuff.obj: jdphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdpostct.obj: jdpostct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdsample.obj: jdsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdtrans.obj: jdtrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jerror.obj: jerror.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jversion.h jerror.h jfdctflt.obj: jfdctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctfst.obj: jfdctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctint.obj: jfdctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctflt.obj: jidctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctfst.obj: jidctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctint.obj: jidctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctred.obj: jidctred.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jquant1.obj: jquant1.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jquant2.obj: jquant2.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jutils.obj: jutils.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemmgr.obj: jmemmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemansi.obj: jmemansi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemname.obj: jmemname.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemnobs.obj: jmemnobs.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemdos.obj: jmemdos.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemmac.obj: jmemmac.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h cjpeg.obj: cjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h djpeg.obj: djpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h jpegtran.obj: jpegtran.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.h jversion.h rdjpgcom.obj: rdjpgcom.c jinclude.h jconfig.h wrjpgcom.obj: wrjpgcom.c jinclude.h jconfig.h cdjpeg.obj: cdjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdcolmap.obj: rdcolmap.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdswitch.obj: rdswitch.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.obj: transupp.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h transupp.h rdppm.obj: rdppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrppm.obj: wrppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdgif.obj: rdgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrgif.obj: wrgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdtarga.obj: rdtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrtarga.obj: wrtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdbmp.obj: rdbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrbmp.obj: wrbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdrle.obj: rdrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrrle.obj: wrrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h Papyrus3/JpegDir/JpgLossy/change.log0000755000175000017500000002243507535143454014575 0ustar CHANGE LOG for Independent JPEG Group's JPEG software Version 6b 27-Mar-1998 ----------------------- jpegtran has new features for lossless image transformations (rotation and flipping) as well as "lossless" reduction to grayscale. jpegtran now copies comments by default; it has a -copy switch to enable copying all APPn blocks as well, or to suppress comments. (Formerly it always suppressed comments and APPn blocks.) jpegtran now also preserves JFIF version and resolution information. New decompressor library feature: COM and APPn markers found in the input file can be saved in memory for later use by the application. (Before, you had to code this up yourself with a custom marker processor.) There is an unused field "void * client_data" now in compress and decompress parameter structs; this may be useful in some applications. JFIF version number information is now saved by the decoder and accepted by the encoder. jpegtran uses this to copy the source file's version number, to ensure "jpegtran -copy all" won't create bogus files that contain JFXX extensions but claim to be version 1.01. Applications that generate their own JFXX extension markers also (finally) have a supported way to cause the encoder to emit JFIF version number 1.02. djpeg's trace mode reports JFIF 1.02 thumbnail images as such, rather than as unknown APP0 markers. In -verbose mode, djpeg and rdjpgcom will try to print the contents of APP12 markers as text. Some digital cameras store useful text information in APP12 markers. Handling of truncated data streams is more robust: blocks beyond the one in which the error occurs will be output as uniform gray, or left unchanged if decoding a progressive JPEG. The appearance no longer depends on the Huffman tables being used. Huffman tables are checked for validity much more carefully than before. To avoid the Unisys LZW patent, djpeg's GIF output capability has been changed to produce "uncompressed GIFs", and cjpeg's GIF input capability has been removed altogether. We're not happy about it either, but there seems to be no good alternative. The configure script now supports building libjpeg as a shared library on many flavors of Unix (all the ones that GNU libtool knows how to build shared libraries for). Use "./configure --enable-shared" to try this out. New jconfig file and makefiles for Microsoft Visual C++ and Developer Studio. Also, a jconfig file and a build script for Metrowerks CodeWarrior on Apple Macintosh. makefile.dj has been updated for DJGPP v2, and there are miscellaneous other minor improvements in the makefiles. jmemmac.c now knows how to create temporary files following Mac System 7 conventions. djpeg's -map switch is now able to read raw-format PPM files reliably. cjpeg -progressive -restart no longer generates any unnecessary DRI markers. Multiple calls to jpeg_simple_progression for a single JPEG object no longer leak memory. Version 6a 7-Feb-96 -------------------- Library initialization sequence modified to detect version mismatches and struct field packing mismatches between library and calling application. This change requires applications to be recompiled, but does not require any application source code change. All routine declarations changed to the style "GLOBAL(type) name ...", that is, GLOBAL, LOCAL, METHODDEF, EXTERN are now macros taking the routine's return type as an argument. This makes it possible to add Microsoft-style linkage keywords to all the routines by changing just these macros. Note that any application code that was using these macros will have to be changed. DCT coefficient quantization tables are now stored in normal array order rather than zigzag order. Application code that calls jpeg_add_quant_table, or otherwise manipulates quantization tables directly, will need to be changed. If you need to make such code work with either older or newer versions of the library, a test like "#if JPEG_LIB_VERSION >= 61" is recommended. djpeg's trace capability now dumps DQT tables in natural order, not zigzag order. This allows the trace output to be made into a "-qtables" file more easily. New system-dependent memory manager module for use on Apple Macintosh. Fix bug in cjpeg's -smooth option: last one or two scanlines would be duplicates of the prior line unless the image height mod 16 was 1 or 2. Repair minor problems in VMS, BCC, MC6 makefiles. New configure script based on latest GNU Autoconf. Correct the list of include files needed by MetroWerks C for ccommand(). Numerous small documentation updates. Version 6 2-Aug-95 ------------------- Progressive JPEG support: library can read and write full progressive JPEG files. A "buffered image" mode supports incremental decoding for on-the-fly display of progressive images. Simply recompiling an existing IJG-v5-based decoder with v6 should allow it to read progressive files, though of course without any special progressive display. New "jpegtran" application performs lossless transcoding between different JPEG formats; primarily, it can be used to convert baseline to progressive JPEG and vice versa. In support of jpegtran, the library now allows lossless reading and writing of JPEG files as DCT coefficient arrays. This ability may be of use in other applications. Notes for programmers: * We changed jpeg_start_decompress() to be able to suspend; this makes all decoding modes available to suspending-input applications. However, existing applications that use suspending input will need to be changed to check the return value from jpeg_start_decompress(). You don't need to do anything if you don't use a suspending data source. * We changed the interface to the virtual array routines: access_virt_array routines now take a count of the number of rows to access this time. The last parameter to request_virt_array routines is now interpreted as the maximum number of rows that may be accessed at once, but not necessarily the height of every access. Version 5b 15-Mar-95 --------------------- Correct bugs with grayscale images having v_samp_factor > 1. jpeg_write_raw_data() now supports output suspension. Correct bugs in "configure" script for case of compiling in a directory other than the one containing the source files. Repair bug in jquant1.c: sometimes didn't use as many colors as it could. Borland C makefile and jconfig file work under either MS-DOS or OS/2. Miscellaneous improvements to documentation. Version 5a 7-Dec-94 -------------------- Changed color conversion roundoff behavior so that grayscale values are represented exactly. (This causes test image files to change.) Make ordered dither use 16x16 instead of 4x4 pattern for a small quality improvement. New configure script based on latest GNU Autoconf. Fix configure script to handle CFLAGS correctly. Rename *.auto files to *.cfg, so that configure script still works if file names have been truncated for DOS. Fix bug in rdbmp.c: didn't allow for extra data between header and image. Modify rdppm.c/wrppm.c to handle 2-byte raw PPM/PGM formats for 12-bit data. Fix several bugs in rdrle.c. NEED_SHORT_EXTERNAL_NAMES option was broken. Revise jerror.h/jerror.c for more flexibility in message table. Repair oversight in jmemname.c NO_MKTEMP case: file could be there but unreadable. Version 5 24-Sep-94 -------------------- Version 5 represents a nearly complete redesign and rewrite of the IJG software. Major user-visible changes include: * Automatic configuration simplifies installation for most Unix systems. * A range of speed vs. image quality tradeoffs are supported. This includes resizing of an image during decompression: scaling down by a factor of 1/2, 1/4, or 1/8 is handled very efficiently. * New programs rdjpgcom and wrjpgcom allow insertion and extraction of text comments in a JPEG file. The application programmer's interface to the library has changed completely. Notable improvements include: * We have eliminated the use of callback routines for handling the uncompressed image data. The application now sees the library as a set of routines that it calls to read or write image data on a scanline-by-scanline basis. * The application image data is represented in a conventional interleaved- pixel format, rather than as a separate array for each color channel. This can save a copying step in many programs. * The handling of compressed data has been cleaned up: the application can supply routines to source or sink the compressed data. It is possible to suspend processing on source/sink buffer overrun, although this is not supported in all operating modes. * All static state has been eliminated from the library, so that multiple instances of compression or decompression can be active concurrently. * JPEG abbreviated datastream formats are supported, ie, quantization and Huffman tables can be stored separately from the image data. * And not only that, but the documentation of the library has improved considerably! The last widely used release before the version 5 rewrite was version 4A of 18-Feb-93. Change logs before that point have been discarded, since they are not of much interest after the rewrite. Papyrus3/JpegDir/JpgLossy/testimg.bmp0000755000175000017500000010435207535143454015020 0ustar BMêˆ6(ã•,*,Li%.™8[GLT—˜É zŒ¼™[ZMRÑ¿Œƒ)ÝLXr',]a«|.9ÐmsϬÎÚ+;6t‘‘[uqft™15ïÉèâDuSXPó-<—5Bb_@C ur¯®™fYS¤²ºt“t2?HLS¼-;¾Vgm½‹¢ØÓÚ2@…=DÐ]bÑÄvs[5ûdw‡:ZYt¡ßè⦫æfbö~°˜Ýìóžv˜Vsë´´7MNqröxX¤4úswu*(LVa–7E˜¥½¼÷üûÂáàwl`oªÛálTÐbR^Mi]¨ž*1ƒ³ÈÉF=Ó`uc>N]G?¾Ø“dŒyGEð›luyZ¹’¡§Vi‰†¾˜ir¼rTú1L;dFø2+õwœsÚÞð_`ÀQHÑÜNZˆfib28à}§DN‡ª„$#½>BHweùdÍ,1,—ijH‚` “ñï÷ƒù‰äOSàI+ù7D¾zjpÌ„‡IS¨J\_ƒ‚Íݯ«5?:YƒpHOO²ÀÎL<F\K—˯—`fÅÎÙ±°¨¸´¹`U½acáe¢}‚vÀ6@p?No¾¨¹¿ï--á~e¨`a.:GH¾¬Ó¯&1©rsádsªjUâE=ávdâŠtàk†cjuúÆÛÞÌš”òáñø®¨Å ¦ñ£ Jw_½¾¾²jfüº´A1Á--o”±—‘“¥aU«¨ŠÈ-*4o®†+;©@Dߤx¦PGáq©/8oˆ•¹Sam*D8[XôÅ”_<úÞï⧳ç\•wbh¼GGGGG$G$u$$$$$$$$G÷b$b$GbL; H‰®š@@oü3Þ­JJ?~~Ã]]oo@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@333o@@@@@@@@@@@@@@@3@@±¦7M7M7M7M7M7777777777---G$þ.2T.G7777777M7M777hhh{{{øøøø{{¿{ø{¿{{{¿{{{¿{¿¿{¿{¿{{{{{{{ø¿økøøYGÀ¿kkkGGGbGLbb$$$$$u$$bCb÷$$GbGb´ H’®Ÿü@@š@ü3üÞÃJJ~?‘~Ã&Ÿooo@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@]Ž]o@@@@@@@@@@@@@@@@@@±¦77M77M7-M7-7777Y77777Y---ä|.þ-777777M--M777¿h{{{{{ø{ø{¿{{{{{{¿{{{¿{¿{¿¿¿¿{¿{{¿{{øY¿¿øY¿øøGGGGG$G$$$$$$$$$$$$bCG$$GL´³“®/@@@@@@ü3±ÞÃ?‘~Ã&ào@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@o]&Ž3@@@@@@@@@@@@@@@@@@D¦777M7M77777777-77Y77YY7Y7---ä¦-777777-7-MM777!!{¿{{{ø{{øø{¿{{ø{¿{{¿{{{¿¿{¿¿{¿¿¿{¿{¿{øYYmm¿Yø¿ÀÀ¿kkkGGGbGGbb$$G$b$$$$$b$$$$bG$bLL´‰®üo@@@@@@3@3ÞJ~Å~&ào@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@o3ào@@@@@@@@@@@@@@@@3@D77777M77-M7-77M777Y77Y7Y777--G--M---M--}-777!hh{{{{{{{¿øø{{ø{{{{¿{{{¿{{{¿{¿¿¿ø{ø{{{{øY¿¿Y¿ÀÀYYkkkGGGGbG$$$G÷÷÷$÷$$$$$$÷b$$LGu¾Š®/š@@@@@@@33±üÃÃ~å~&ào@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@±¦7MM77M7M77777777777Y7YYøY77Y--7Y-xG----x-M-7hh!{{{{{{{{{ø{ø{¿{{{{{{{{¿{{¿{¿¿{¿{{økkkøøøYYYY¿¿Y¿¿¿kkkxG÷G÷$$÷G$b$b÷b$÷b$CGu$$G$bLLLH’®/@@@@@@@@@@@±ÞJ~å~ßo@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@o3ŽdË!7MMM7MMMMM7M7777777À-YøYY7Y7777-$$x-xx-77{¿{¿{ø{{{{{{{ø{¿{{{{{{{{{{{{{{{{{{kkkkkkkkkkkkøY¿YYYYYY¿Y¿øk÷÷G÷b$G$b÷$÷$b$÷÷$÷$C$$$$LLLLH’‰¶o@@@@@@@@@@ü­JJÃÃ]oo@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@333±3ˆ ËMMMMMMMM7M7M77777-G$-YYYø7Y7Y!7-$$ --77!ø{{{{{{{{{{{{{{{{{{{{{{{{{{{{{kkkkkkkkkkkkkkøY¿Y¿YYøY¿¿¿økkk÷b÷$÷b$$÷b$G$$÷G$÷$C$$$GbbLL³®Ÿü@@@@@@@@@@@üÞ­JJÃ&ào@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@o@@@@@3ŽD‘ô÷ –!!MMMMM7MM7777$|-7!Yøø777Y7G7h7h{{{{{{{{{{{{{{{{{{{{{{{{{{økkkkkkkkkkkkkkkkøY¿¿YYøøY¿¿¿¿økkG÷÷G÷$÷b÷$÷b÷G÷$$÷÷$C$$$GLL;³’“®o@@@@@@@@@@š±Þ­ÃÃß]3o@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@o@@@@@@@3@@@@@±ˆ‘ ËËËËÊÊÊËÊËË}}7777÷,-7Yøø7øø!7-,-!ø{{{{{{{{{{{{{{{{{{k{kkkkkkkkkkkkkkkkk¿¿¿¿¿øøøøø¿¿¿¿kkkk÷G÷b÷G$$G$$$$b$b÷b$C$C$$$L$L;LH®®ü@@@@@@@@3@3üDÞ­ÞÞß]ooo@o@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@33ˆöËËË'ËeËÊ–eËÊÊË–––ÊÊ–!M!-$x7Y7!Yøøø7-$xøøø{{{{{{{{{{{{{{{{{{kkkkkkkkkkkkkkkkk{{¿¿¿¿øø¿¿ÀÀ¿ø{kkb÷$$$÷b÷$b÷G÷$$÷$÷$÷$$$b$$LL;Hĉ®@@@@@@@@@@ü3üüÞÞÞÞ&]]ào@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@±Íôae=e'ÊÊÊÊÊÊõõÊ'ÊÊeõÊÊ–Ê–ÊÊÊM!-7›!!øY!ø!7G$xYøø{{{{{{k{kkkkkkkkkkkkkkkkkkkk{{¿¿¿¿ø{øø¿ÀÀÀÀ¿kkkk÷G÷G÷b÷G$÷b$$÷G$b$÷b$C$$$bL´ ‰Ÿü@@@@@@@@@@@3ü±±±&Þ&&]3oo@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@33ýÖa=e>'eÊ'ÊÊ'ÊÑÊÊÊÊÊÊÊÊÊÊÊÊ–Ê–ÊõMÊ!››77Y!7--x-$xYkø{{{kkkkkkkkkkkkkkkkkkkkkk{{¿¿øøøøY¿ÀÀbÀ}¿kkkk$÷b÷G÷$÷b$$$G$÷b÷$÷C$÷$$$L;³“®ü@@@@@@@@@3šüü@üü±3ÞÞÃÞŽàoo@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@3±”µ>www>wI''Ñ'ÊÊÊõÊÊÊÑÊÊÊÊÊÊÊÊÊÊÊõõõõÊõM!›–»M777-÷x---|$øøk{k{kkkkkkkkkkkkkkkkkkkkkkø{ø¿¿¿{øø7ÀxGG¿kkk÷G÷b÷G÷G$÷G÷b÷b$÷÷b$$C$$$$bb;nz®/@@@@@@@@@ü3/3ü±3]ÞÃÃ&]oooo@@@@@@@@@@@@@@@@@@@@@@@@@@@@@3±ýÖwwwww"¨¨''''ÊÊËÊÊ'ÊÊÊÊÊÊÊÊÊÊ–ÊÊõõõõõ––õ–!-x --M---´k{{k{kkkkkkkkkkkkkkkkkkkkkkkkkk{{ø{økø{øYY}ÀÀGLb¿kkkb$÷$÷b÷b÷G÷b÷$÷G÷$÷÷÷$$$$$bBn’Ÿš@@@@@@@@@oüŸüü3±ü±ÞÃÞÃÃ]/3o@@@@@@@@@@@@@@@@@@@@@@š@š@@@@ˆÖew"tÒÒºº¨¨'¨'ÊÊÊËÊÊÊõÊÊÊÊÊÊÊÊ–ÊõÊõõõõõõõ––Ê–7MË -ËMM--$|$ø{k{kkkkkkkkkkkkkkkkkkkkkkkkkkøkkø{øøøøø¿YÀÀGLG¿økk÷$÷G$$÷G÷b÷$÷G÷b÷$b÷b÷$$G$b;´‹“®@@@@@@@@@@oü/Ÿüü±3ÞJJJ‰ÃŸ/oo@@@@@@@@@@@@@@@@@@@@@@@@@3ÖwwwttÒtN𨨨'''eÊÊÊÊÊÊÊÊÊõÊÊÊÊÊ–Êõõéõõéõ–õ–––Ê–ÊÊMMMMMMM-$¦´¿økkkkkkkkkkkkkkkkkkkkkkkkkkkkkkøøøøøYYÀÀGGLLøkG÷b÷G÷b÷$÷bG÷$b÷G÷÷C$C$$$$;¦“®ü@@@@@@@@@@3ü33üü±ÞJ~剮&/o@@@@@@@@@@@@@@@@@@@@@@@±=>wwtttttt¨¨¨''ÊÊ'ËÊÊÊÊÊÊÊÊÊÊÊõõ––Êõõõõõõ–õõõ––––ÊMMMË÷$¦¦Àkkkkkkkkkkkkkkkkkkkkkkkkkø{ø{øø¿ÀÀÀLLLGÀ¿kk$$÷b÷b$÷G÷$÷G÷$$÷b÷b÷$$$$$$$B‹å‰/@@@@@@@@@@@3üüü@ü@3üDJªTnªåJŸ/@@@@@@@@@@@@@@@@@oo@@3†”>wµ"ttt(Òtºð¨¨''Ê'ÊÊ'ÊÑÊÑÊÑõÊõõõõõõõõ–õõõõ–õõ–Ê–õ––õ––Ê–ÊMË-÷$¦{kkkkkkkkkkkkkkkkkkkkkkkkkk{{øø¿øøø¿ÀÀÀGLb¿kkG÷G÷$÷G$b÷b÷b÷G÷b÷÷$÷C$$$$$b;¯Ä“Ao@@@@@@@@@@@ü@ü@@3@±ÞJÌ´³TÄ­Ÿ3@@@@@@@@@@@@@@@@@@@ˆƒ>wwðtt(ttº>>'''''ÑÑÑõÊõÑõõõÑõÑõõõõõõõõ–õõ–õ–é–õ–õ–Êõõ–ÊÊÊM $¦¦hkkkkkkkkkkkkkkkkkkkk{{{øø{¿}øøYÀGäLÀ¿økk÷b÷G÷b÷$÷G÷$÷G÷$÷G÷$C$C$$$$$$u´°Ä“®/o@@@@@@@@@@@@@3@@3Þ­LxG´¯å&/o@@@@@@@@@@@@@@@@3Í”>wÒÒtttÒtt"ºº>>'e''ÑÑÑÑÑÑÑÑõÑõÑõõõõÑõõõéõ–õõ–õ–õ–––õ–õ–õõõõõÊÊËMU;‡¦¿k{k{kkkkkkkkkkkkkkkkkk{ø{øøÀÀ¿¿ÀLLYk$÷b÷b÷G÷G÷bG÷b÷b÷÷b÷$$$$x$$CG;¦¯HĉŸü@@@@@@@@@@@@@@@@±D?.UGG;³nʼn/oo@@@@@@@@@@@@@@3ƒµ>"Òtt(_((t(tÒ"º¨''''''Ñ'ÑÑÑÑõÑéÑõIõÑõõÑõéõõ–õ–õ–õ––õ–õ–õ––é–õõõõË÷U,¦kkk»k»kkkkkøkkkkkk{øøøøøYGGÀ¿-GäLÀ¿kk÷G÷÷G÷G÷÷b÷÷G÷G÷G÷÷÷÷÷÷$÷$÷$$u$bu;f‰¶ü@@@@@@@@@@@@@@3Ž,xG;´Ä?&]o@oo@@@@@@@@@3ˆ”wwtÒÒ(t(t(t(_tNð¨''ÑÑÑÑÑÑÑÑÑÑÑõÑõÑõÑõéÑõõõ–õ–õõ–õ––õ–õ––õõõ–ÊÊÊÊ– = M{»k{kkkkkkkkkkkkkkøk{{¿{{kk}LLÐäääkG÷÷G÷÷b÷G÷G÷÷b÷÷÷÷b÷$$÷$÷$$$$$UCb;³Ä“®ü@š@@@@@@3@š3@33D~‘d-}-Gb¯ÅÃ]à3o@@@@@@@@@±ÿww""Òt(Ò(Ò(tK(((t#¨¨ÑÑ''ÑÊÑ'õÑÑõÑõÑÑÑÊÑõÑõõõõõõ–õ–õ–––õ––––õ––õõ–ÊÊ–Ê––ÊËÊË!»k{{»k»kkkkkøkøkkkøk{ø{ø»kL|ÐÐäääÐ{k÷G÷÷b÷÷G÷÷÷G÷G÷÷G÷÷÷÷÷$÷$÷$÷$$$$u´°’‰/@š@@@@@@@ü@@@@@DJªG77}¿}´ë~&&Ÿ3@3@@@@o3Žqµº""t#_tt(K((((K((ÒNº¨''Ñ'ÑÑÑÑÑÑÑÑÑÑõÑõ'õ'õÑõõõ–õ–õ–õ–õ––õ––õ–õé––õ–é –– ––Ê h›»k{kkk{kkøkkkøkø{¿øk»kL ÐämäпkG÷bG÷GG÷Gb÷G÷÷b÷÷÷÷$÷$÷$÷$÷$$$$$;³Äå®ü@@@@@@@@@@@š@š±­?T|x7Yhhhœ¦‹Å~&]3@o3o@3©Ww""^"tt((K((((((((((tðÑÑ'ÑÊÑ'ÊÑõÑÑõÑéÑÑÑ'õÑõÑõõõõõõ–õ–õ–õ–õ––õ––õ–––––– –<é Mh››{{kkk{køkøø¿{ø{kkk7äPÈþmääämä¿øk÷÷÷÷÷÷÷÷÷÷÷÷÷G÷÷G÷÷÷$÷÷$÷$$÷$÷$$$f‹å&/š@@@@@@@@@@@3ü­?2PG7Y77hhhC¦ë‰&33@@]q^NÒ"Ò(_KK(ñ(((c(((tN¨'Ñ''ÑÑÑÑÑÑÑÑÑÑõÑõÑÑÊÑõ'õõõõõ–é–õ–õ–õ–õ–Ê–õ–õõé–é– – –Ë£ Ëh›!k{k»{»kkkøøøø¿¿{kk»»øYäP\\mÐÐÀ¿øG÷G÷G÷b÷G÷÷b÷÷÷G÷÷G÷÷$$÷$÷÷$$$÷$b;nÅ®/@@@@@@@@@@@@±DÁTG-Y!!hhh!} ;ëß3o3©ÿtÒr×(((ñ(ñK(Ø(ñ(ññ((ttÑ''Ñ'ÊÑ'ÑÑÑõÑõÑÑÑÑÑõÑÑÊõÑÊõõõõõõ–õ–õ–õ–õõõõõõ–––– –– –Êe a M!!»{{{k{k{kø{øø¿ø{kkkkYG|þ5ÜmmmmmmÀø÷÷÷÷÷÷÷÷÷G÷÷÷G÷÷÷÷÷÷$÷÷$÷$$÷÷÷$÷bu¦‹åŸü@@@@@@@@@33±?T¦G77!!!!›!»}Fu둈ˆýy^Eóñ((_ó(KKñcKØ((ñ((ñctÒð'Ñ'ÑÑÑÑÑÑÑÑÑIÑõÑÑõÑÑÊÑÑÊõÑõõõõõõõõõõ–õõõõõõ–õ–é – – Êee£e M7!øø{»{»{»kkkø{ø¿ø{kkk»»G|þÈ5mmmmmmmmп÷$G÷G÷G÷÷÷÷G÷÷÷b÷÷÷G÷$$÷$÷÷$$$$÷÷b;¯ÅåŸ3o@@@@@@o]Ž†‘T¦x7YhhY!››!{h»›Ë™í0¢^"ñóQóóKKØóñKKñ(ñ((((ññ((#tÑ''Ñ'ÑÑ'ÑÑÑIÑõÑÑÑõÑÑõÑõÑÊÑÊõõÑõéõõõõõõõééõõõé–é––õ– –Ñee £x7hhøø{»»kkø¿¿øøøkkkk{øYGmþ5þmmmmmmmmYGx÷÷÷÷÷÷÷G÷÷÷G÷÷÷÷÷÷÷÷÷÷÷÷G÷÷÷÷C$$$u¦‹å‰®Ÿoo@o3àˆ†d;-7YhYøh!!!»{{››–eÿW^^róQØññóKóKññññ(ñ((((ññ(tºðI'Ñ'ÑÑ'ÑÑÑÑÑÑÑÑõÑÑõÑÑÑÑÑÊÑõÑõõõõõõõõõõõõõõõõõõ–é––é––––Êeea ÷ -høhøk{kkkø{¿¿¿øøøkkk»!øGmþ555mmmmmmmmmmmmm÷÷xb÷÷G÷$÷xG÷÷xG÷÷G÷÷G÷÷$÷÷$÷$÷÷÷b÷b¦‹å&Ÿ3/ŸÞÃ~Ux7høY¿¿{{{!!›–eì^E_óóññññññññññ(ññ((((((ñ(((tðÑ'Ñ'ÑÑ'ÑÑÑÑÑÑÑÑÑÑÑÑÑõÑÑõÑõÑõÑõõõÑõõõÑõõõõéõéõé–é–õ––é –'e>aaa ÷-}7Yøkkkk{{Yø¿øøkk{Y-mþ555mmmmmmmmmmmmx÷÷÷÷÷÷bx÷÷÷÷÷÷$÷÷÷÷÷÷÷$÷÷$÷÷÷$÷÷÷$C$u¦¯‹å‰~ååë¦$7YhøY{ø{{øhøh»!'w^Nó(ñ_ññ(ñóKóñó(ññ(r(ñ(((((c(tt¨''Ñ'ÑÑ'IÑÑÑÑÑÑÑÑõÑÑõÑÑÊÑÑÑõÑõÑéÑõõÑõõõõõõõõõõéõõé–õé–é––'eeea a÷ x}}}øøk{øøYhYøøø{k{»!øY-ä|5 55mmmmmmmmmmmm÷÷G÷G÷G÷÷÷÷b÷G÷xG÷÷÷÷÷÷x$$÷÷G÷÷÷$$U÷÷$u;¦¯ë‹ªTën,G77Y!Yh77!!»››› ÊewºÒ_(Kññññññññóñññññ(ñ(((((ñ(ñ((tððÑ'''ÑÑÑ''ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑõÑÑÑõÑõÑõÑÊÑõÑõõÑõéõõõééõéõ–é––õ'eeaa£ ----YøøøøøYY7YYhø{{{k{ø7äþ5È55Ümmmmmmmmmmmm÷x÷x÷÷÷÷÷÷Gx÷÷÷÷÷÷÷÷÷G÷÷÷÷$÷÷$÷÷U÷÷÷÷÷Cb÷;¦¯d¦|x-Y!ø›!!››–––Êew"ÒN(ñ(((ñ(ñ_ññññññóñóñññ(ñ(ñ(((tNðÑ'''ÑÑÑÑIÑÑÑÑÑÑÑÑÑÑõÑÑõÑÑõÑõÑõÑÑõÑõÑÊÑõÑõÑõõõéõõõ–õé–õéõ'eeeaaaU÷ ÷GG7YYYY777øø{{{!ø7Gäm55 55mmmmmmmmmmm÷÷÷÷÷÷÷÷÷÷÷÷÷x÷÷÷÷÷G÷÷÷$$÷÷$÷÷$÷$ ÷÷$$$÷÷;,;Ux-!!!–!õõõÑ'>ìw^"ÒtÒ(ñ((((r(óñññØññññññññññññññ(t#¨ÑÑ''Ê'ÑÑÑÑÑÑÑÑ'ÑÑõÑÑÑÑÑÑÑÑÑÑÑÑõõÑõÑÑõÑõÑõõõÑéõõéõéõõ–é–õËeeeeaaa÷$äYYø{{{{ø!Gm|555 5Ümmmmmmmmmmm÷÷x÷÷G÷$x÷÷x÷÷÷÷G÷÷÷÷÷$x÷÷$÷$÷÷÷÷÷÷÷$$÷Gb$$$÷xM77!! e'>ì"""""Ò"ÒNK(((t((t((ñKñØóñóññóñññØñcñØñ(tNÔ'Ñ'ÑÑÑÑÑÑÑÑÑ'ÑÑÑÑÑÑÑÑÊÑÑõÑÑÑõÑÑÑÑÑÑõÑõÑõÑõÑõõõIõõéõéõõéõ' eaeeeaa$$$ääG-Yøø{!{{!ø-G|5555 5mmmmmmmm÷x÷÷÷÷÷xb÷÷÷÷÷÷÷÷÷$÷÷÷÷÷÷$x$÷$÷÷÷÷$÷÷÷÷÷x÷x-M77!7!UWWÆ"tNÒ_(__((((((((t(((((ñØññññóññQñññññØññ(K#¨ð'''''Ñ'IÑÑ'ÑÑÑÑÑÑÑÑÑÑÑÑÑÑõÑÑÑÑIÑÑÑÑÑÑÑõÑõõÑõõõõõéõõéõõõeeaeeeea= }-|ääGøkøøh{»{{øø-ä|þþ5555 5mmmmmmmmm÷÷÷÷x÷÷÷÷$÷÷÷G÷÷÷÷÷÷÷$÷$$÷÷$÷÷÷$÷÷÷÷$÷÷÷ xMM77!!ø!aìºÔ_NN#t)Çr((((((((((ñ(ñ(ñØØñññññØñ€ñc€ñññ(èð#º''ÑIIÑÑÑÑÑÑÑÑÑÑõõÑÊÑõÑõÑ'IÑIIÑÑIÑÑ'ÑÑÑÑÑÑõIõIõéIõõéõÊÊaeeeaeee Ux7YäGøøø!{{!!øGäPþ55555 55mmmmm÷x÷÷÷÷x÷÷xG÷÷÷÷÷G÷÷b÷G÷÷÷$$$÷G÷÷÷÷÷÷$÷÷xxx}77!7!YøÊwÒðèNN_Ç88Çrr(((((((((((ñññññññrññr€Q€Qñcc(ñ#ðð>>Ñ''ÑÑÑÑ'Ñ'ÑÑ'ÑÑÑÑ'ÑÑÑÑÑÑÑIÑÑÑÑÑÑÑÑIÑÑIõIõIõõÑõéõÑÑeeeËaaa=U 77Y-GääGøøøhø{{{øøømþ55555 555mmmmmm÷÷÷÷x÷÷÷÷÷÷÷÷÷$÷C÷÷÷÷÷÷G$÷÷÷÷÷÷÷$÷÷$÷$÷xxMM77YhøøY!'wÒ#t88Çù1rr((((ñ(r(ñrñrñróñrñ(r(ññññQØQññótNðº>''>'''ÑÑ'Ñ'ÑÑÑÑÑ'Ñ'ÑÑ'ÑÑÑÑIðIÑÑÑ'IÑIIõIõIõÑõõõõÊe'eeea== xxYYYämäG-Yøøøø›»{{Y-Gmþ555555 5mmÐ÷÷x÷÷÷x÷÷÷÷÷÷÷÷œ÷÷C÷÷÷÷÷÷G÷÷÷÷÷÷$÷÷÷$xxxM}7hhhø!Yh7!õ=µðt8Çñrñ((((((rñrññrññrùrrrrrrñññññññ_(tð>>>''''''ÊÑÑÑÑÑÑÑ'ÑIÑÑÑIѨÔÔÔðIÑÑÑÑÑÑÑÑIÊÑõÑõõéõIeeeeeeaUU,GGä|Yø!øø!øøäþþ55555 5mmmmx÷÷÷x÷÷÷÷÷÷÷÷÷÷÷÷œ÷÷œ÷÷÷÷÷÷$÷÷$x÷÷÷$x -x77YhYh!{YøhY–Ë=µ>ÇùùQñ##(((((((((tt"(rrQrññññÒ#ðð>>>e''''Ê'Ñ'IÑÑÑÑÑ'IððÔ#ð#ð#ðÔÔIÑ'ÑÑÑIÊÑÑÑÊÑõõõõe>>'ee==U‡|GYYÀäLG-YY!ø!»{»{{øY-ämþ5þ5555555 55mmmmmm÷÷x÷÷÷x÷x÷÷x÷÷x÷÷÷C÷C÷÷÷÷x÷x÷÷÷÷÷÷÷x÷x-M7hhYhø¿¿ø{Y7›!=Ö")ÇùñQñc#####žžžÔÔð#(ñrñQññ((Nð¨¨>>>'>'''''ÑÑÑ'''Ôðð###tt#t#ðÔð¨I'ÑÑÑÑÑÑÑõÑõÑõõIÑ>e'>a=9aU¦PPøYbbGÀhøø!YäPþ55555555 mmmmm÷x÷÷÷x÷÷÷÷x÷x÷÷x÷œ÷x÷x÷÷÷÷÷÷÷÷x÷÷÷x÷xx}77YYhøYhøhøø77ËW)ÇùQcñ(#ttððÔ#(ññQñó(##ð¨¨ð¨Ñ'''>ððð###tñ(ñ(((t#ððð'Ñ'ÑÑÑõÑõõIõÑ>eae=a=--G-ø¿ÀGG-7ø!!!øY-mmþþ5555555555 5mmÜm÷÷x÷x÷÷x÷÷÷÷÷÷x÷÷÷÷÷÷÷÷÷x$÷x$$÷$x÷x÷xx77YhhhøhY{}7hYMeÿÇróññ(žc##ððð#ð˜ñQóóñ#ððÔ¨ððѺ>ºððÔðÔ##cññcñññ(ñ((#ÔÔÔ¨IIÑÑÑÑÑÑÑÑÑÑõIé'>a>a=aUMY7Yø¿œ-}ø!ø{{Y-äþþ55555555 mmx÷÷÷÷x÷÷x÷÷x÷x÷÷÷$x÷x÷x÷÷x÷÷÷x÷x÷x x-M77h7Yh¿¿7¿7}7MMÊ"ñcc#ð##ððð#t#ñ€€ØóKžžž#è##Ôððººðððð#ž#ññ€cQcñccñ(((N##ðÔÑI'ÑÑÑÑõIõIÑe>e=a====-7øøøøkk{¿7Yh!»!{»{Yä|þ5555555555 55mmmmm÷xx÷x÷x÷x÷x÷÷÷x÷÷÷$÷÷÷÷x$÷x$÷÷$÷x÷x-}77h7hY777¿}}MM aw×óØccttðc#ðððI>º##žž˜cØ€QØñØؘèKK##žð#ðººððððÔ#žñc€cØ€cQññññ(KNtððÑÑÑÑIÑIõé'e==a=U÷-øøøø{h¿!{{!Y-ämþ5þ555555555 55mmxx x xx x÷xx÷x÷÷÷x÷x÷G÷÷÷x÷xx÷x÷xxxMM7!7h777}}---xM µÿ"r(Øcðtð#ccccct#ðððt###žc€c€ØØØccØØcKžÔððð#ððððÔ##(cØcØ€€ñcñcñ(ñ(Kt##ðÔ'ÑÑÑÑIÑõÑewaa====,||-ø{h{!»!{øY-äþ55555555555 5mmmx xxx xxx x x÷xxx÷÷÷÷÷x÷÷÷÷÷÷x÷÷xxM}7}77}}}M--xxG÷ aµ^"Nc###tcc#tððºð###(€ccÎccÎccc€Øc˜ž#ððððððÔ##ñccØ€ccñccñcKØKKK(t#ðÔÑIIÑ'II>wºwa=a==U.TPG7økø{{»!{{øYä|þþ555555555555 5mmFxxxFxMxxFMxFx x x÷xx œxœ÷xœ x xxxM}77M}MM--xxxx$$ aµµÒN###ž##t#ccccct#ðÔðº####žcÎÎcc؀؀Îccž#Ôððððð##((ñØc€€c€Ø€cccccØccKK(N#ðÔI'ÑõI>wwww===U‡2ÌÌ.P-øøøø!{!{{{{øY-ä|þ55555555555 5 5m-MxMMxMxM--xxMxxx÷xx œ÷ œ÷C÷÷œxMFx}}}}M}x-x x÷÷÷x$÷aµ"ºttt#ðž#ccccÎcct#ðÔÔð##tž(rñcÎccñ€cÎØcØñž#ÔÔÔð##(((cc€c€ccccc€ØcØcccØcK((#ðÔIIIÑѺ"""ºw====UP.ÌÌ2þGYYYø»{!ø!{Yämþ555555555 55MMM7MMM7MMMMM-Mx Mx x÷÷C$Û$uCCœœxÀx}x}xxx x- x÷x÷$÷ew""ººð##cccccccc##ðÔÔðt##žñrrrññ(ñccc€ñc(###Ô#t#t(Øcc€cØc€cØccØc€ØcØcØcØt#ððº'ÑÑI"Ç)"ww===U-äþ2Ì2.mäG7Y!{{øøY-ä|þ55555555 m777M7}7M7M7M-xMxxxxxœCuuRR··;ÛCœœœœxFxFxxx ÷ ÷ ÷G$ ea=µwwºððžÎÎcccccc##ðÔÔ##žññ(tÔr(((ñññcc€cccñ((#žÔž#t#(ØØ€c€c€cØcc€ÎcÎccc€c€cØØ((#tÔð'I"ÕÙE"Òww==U-øø-2ÌVÈmGG-7øø!ø{!øYGm5þþ555555 5h!hYh7hø77777}M--x-œœuBB4ffBRlullluuu$÷ ÷x ÷÷ ÷ ÷ ÷aaºðžcÎccÎcÎc#(tððÔ###ñùñ((Ô#(((((ñññcccccc€ññcñžg#((cc€cccØc€c€c€€c€c€c€cc(##ðððððIpr×E_Æw=UU-7!-äÈVÈm,P|xøøøøYGä|5þP555555 5 5!hhh!{h{hY777}-}-xxGuRBfvvvfBRRRRRRBuuu$÷ x ÷ ÷ ÷ ÷÷÷÷aµwº##˜cccÎccc#c#ðÔÔ##Qùñt#Ô####žžñññ€Qcccc€Q111(#ž#ññccØccØc€c€c€€c€Î€ccØØ#t#ðððððð"Ù1óó_ììUUY¿!››!ï.þP.|G7YøøYGämþ5555555 !{{{{{!øhY7}}}x-œbRBfv`v`v¬BBB*BfBfB·;uC÷ ÷ x ÷xx÷ ÷a =wttÎÎcccÎcÎcc##ðÔ##ñùñ(#Ôð##ž##cñccñ€ccØ€c€18irž(cccccccccc€c€c€c€€cØc(#žððððððððððð#riZó×Ò"9=h77!Y|þþ...22þ|-YYY-ämmm5555 »»»{{øh¿}}}Fœu*v``O`vvvB*ffvf•fB·Û;u÷ x x÷x÷x ÷ aaew"(cÎcÎcÎccccccc##Ô####ù(ž#####˜˜ÎccQcc€€€ccûQÝ81ñ˜cñccccÎØc€c€€c€c€€cØ(###ðð#ðððððððÔÔKiZQó×ÆÒË7h7ø!øøG|.ï2VV.P-YGmmmþþ5555 5kkkk»k»»{hh}}……œÂRBvv````v*v*fvvv°°•ffBBu$C÷ xxG- x Ëaw^ùQQ˜ccccÎccΞ##t##ù(######ž˜˜cccQ€c€csÎcØù181ùQcÎcccccccccØc€Ø€cñž###ð#ð#ðð#ðÔ#Ô#1ZûØó×EìËhh!ø››7$22Ì2.|ämmmmþ55 kkkkkk»k{{{¿…}œll*v```v`vv*¬¬v `vvvv•v4BÛu$÷x÷xx÷ ÷÷$ ewr€cccccccccÎc˜####t##žññ(##ž##žc˜Îccc€€c€ØÎØrXùQccccccØØc؀؀ccc#########tð#ðžž1Zû+QZóEÑhh{»»›<777M7!7øY-äämmmmmmmmmmämmäää!77MMMxËxMxM x uRBB¾*ææææ*¬`âz6“““‰‰“åÅÅ¥â¯f;Û$uÛU==ÿ8p81ùùQñcñÇ##ž#((ñ(ññcccccQc((((Ôž(#žèèóó×11ù_KØQQQ€QcÎØ€€[[[ÎÎÎñcñccÎÎcccccÎ[[cžù8iùóZû++Z×ìéM}M!!!Y-Gä|mÜmmmmmmääääää77MMMMMMxM MMxxFu;BB**æææ¬v`Œã6ç“®Ã&&ÞÃÃ~Åë;;$,U==Wpp81QQQcñ(r####((ñ(˜Q1ùñccccccžÔ#_ñ#Kó×ùX1ñØQ€QZùXc˜Î€€€€cccñcccccc€c€ccÎcccÎÎ[cccè(8iiXZû++û×EeÊM-M77!Yäm|m555mmmmGäää7MMxMxMxMxMMxMM…FuBB¾*æææ*¬`ãz“‰&ŸÞ±D±ªë¦,ÖW¼p8ÇùQñcØññt#ÔÔ(Ç(˜cù8ùñccccÎÎΘ˜žžžž(óØKóùù1iùó€€€€Zù€ccQZZ€c€Q€cc(ccccØc€c€cccccccÎ[[[[cñžžèiÝiiZZûû+ó×ìÊMx777ø7Gä|5Ü5mmmG7MMMMMMMM Mx MMMMFœCuB¾¾**ææ**``ã6“ÃD±±±±DJT.‡=µ¤8ùóQñ€€cØñ(ž#ðÔ"ÇǘùQc˜ccÎÎÎÎÎccž##ññóóùXùi8ùØÎ[[ [€ù€QQùùQccc€€Q€ØcccccccØcØ€Øcc˜cccÎ[[[[ccñžž1ÝiiXZZû+Ø×ÆeÊM7!7!-ä|P5þ5555mäMMMxM-ËxxM-MxMxMxMFFuuB¾¾¾*æ**¬vOzʼnÞD±±±±DDJd‡ôÖ^Õ8ùrñQ€ØÎØ(ž##ºtÇÇÇ(ž˜ÎcQQñ˜ÎÎÎÎccñž˜óù1ùùQQ188ù€[[€[s[+ZQù111QcccØcÎcccccØ€cØccc˜ccc[[[[cñ#žÔÇpiiXXZZ+ûZE¨–!ø!7G|P5Ü5þþ555555mMMMMMMM-ËMMËMxËM MM-œbu¾¬**æ**¬vßzÅJJDDDDDD†~ôy")8ùr€Ø€ØccK##t"t"Õ)tžžcÎcccccÎccÎÎÎccc(Q11X1X1i1ù[[s[Î +ù11iiXùñccccccc(cccc€€ÎÎccccÎ[[[[[cñ#ž#פÝiiXXZZûû×ÒÑ››øhxä|PþþÜþ5þþ5þ555555555mäYYMMË-ËMMËMMMMMË-M-ËMMFFbRBBff¾**æ*¬¬°ßâÅ?J”µÒ1QñcØcccèt#t"")))t#ccÎÎccññcccÎÎ[Îccóùcùpp8iii1ùùùQ+€s[[QX1ii111XùñcΘÎñcñccc€€[€€€ÎcccÎ[[[[cžÔ#E©ÝÝiXZûûûZE' ›ø7-Gä|þþþþ555555555555555 È5þ|mäYMMMMMMMMMMMMMMMMËMMxMMœœ;fff*B*¾¬¬ ßââÅ~‘~Öw>ðÒrùñ€Øñcc###tÒ^)))t#˜ccÎccñcÎÎ[[Qùù8óóØX8ØÝ8K˜KQ€€+Îû18i11Xi1ùùró˜c˜cñrññ˜cc[[€[€€€ÎcÎcÎ[[[[c(Ô#ð8ppÝiÙXXZûûû×ì 7h-ämP þÈ55ÜÜ5þ55È5 5 5 5 È ÈÈÈþPÐäGGMMMMMMMMMMMMMMMMMËMMM-FxbBffBBB¾¾¬ v``O%⥑ô=>ttt(QØ€ØØcñ(####ðÔÒ)))"###cÎÎcccñQcccÎ[€QQùQùÎQcQc˜˜óègØKØ€cÎÎÎØZ1i81ùX11ùr(˜ñórññccc[ss[sQQQÎcccÎ[[[[ÎccÔÔ#Õ¤pÝiiXXû++û×ÒÑ!-Gä|þþÈ55555\55\55È 55 5 ï..ȸP´ÐLMMMMMMMMMMMMMMMMMMMMM}FxœCu;BR;¾¾¬vvv`%•½½ôÖ"rrù€c€cØctt#ðtÔÔt)Ç"##žcÎccccñcññcÎ[[[Q11cÎQc˜˜˜˜ùØØèggØØØÎΘ˜˜r1i11i1_rrùñ˜crrñ(c΀[[[[[€ÎcÎcÎ[[[[cñÔðt8¤¤pÝiiXZû++ZEº–-Gm|þþþ\ÈÈ55555È5ÈÈÈÈ 5 ïïïï.¸³ |LMMMMMMMMMMMMMMMMMMMMM}FFCCuu£lu¾¾¬```O•òÏ¡W8811Q€€cccK((t#ð#¨ð)##ž(cccÎccQñññcÎcÎ[€1ùÎÎÎQÎÎØÎiؘ˜gKØc˜Øؘè_r1111NÒÇ18ir(ñÎ[[[[ÎcÎc[[[[cc#ž#Òp¤¤ÝÝiiXZûû+ZóSé-G|mþþ55È\5\55È5ÈÈÈ È ïïÈ.þ LbMMMMMMMMMMMMMMMMMMË-MM}MMFxFœ œCCCu¬ v``%%½Éy¼p81XQZQ€cccKt#tðº#tÒžž#ccccÎcùññcQ[s€€ [Î Î΀QùØñØØcc##t_#Ôžórùù#(((ñññ€Ø€cQcc˜c[[[[Îcñ#Ôðp¤¤pÝÝiXXZûûû××ÑõMäþþ5\ÈÈÈ5ÈÈ5\5ÈÈ\ \ ïï.¸Pп¿MMMMMMMMMMMMMMMMMMMMMxMMMFMF FËFCl¬ `°%½¹y¼p81QQZQQ€ØcK(#t#ðððtt#ž˜cccccccñrñžññQ€€Qs[ [[[[:Î[ÎÎX€X1ùQcK##tðÔÔt#è˜(1(ñññcññQccQñccÎÎ[[[[cž##)Õ©pppÝiXXXZûûZE¨Ê7-ämþ5þÈÈÈÈÈ\ÈÈÈÈÈÈÈ 2¸¸ ´G¿¿MMMMMMMMMMM7MMMMMMMM-MMMËMFËËFœR¾f â%½‚p811QZQ€€Øcc(t##ðððð#K#K˜cccQrñcQ€s€[:[[[[[[[:[ + +ûÎiiùùóK#ttð#_#èKù(ñ(#ž##žžžññññÎ[[[[Îcñž##)Õ¤p¤pÝiiXXZûØûó"Ñ7äþþ5ÈÈÈÈÈ ÈÈÈÈÈÈ ï ïïïȧ§ê¸³bMMMM7MMMMMMMMMMMMMMMM-MMËMxMËMËFËÂuf f½íyÚ881QQ€€Qó€ØØcØK##ðð#ðttccccccccrù(#(˜QÎ[Q[[:[::[[: s sÎ XsX1ùùQØK##ðððÔt#ž#èñr(ž˜###ÔÔg#(ñrñcÎÎ[[[[ccž##)8¤p¤pÝiiXXXZ+ûØj'ämþÈ.þÈïÈÈÈÈÈÈÈÈȸ ï ï2êÌÌåH´7MMMMM7MMMMMMMMMMË-M MËMMËËFFu;BB4½íyÝiùQs+ûû€óñKKññØ((t#ððð##((cÎccÎr8ù(#˜cccc[€[s[:[::::: s ss+Zi1XØKKèèÔÔð>ðð#tžž(róž#žððÔ#ÔÔ#rñccc[[[[[[Î(ž#ÒÇÝp¤pppÝiiùXóZ€+rºM-GmPþþ...ï§§È ÈÈ ¸ï ï §2Ì?J‰åHM7M77MM7MMMMMMMMMMMM-MMMMxMMËFFFÂBB··½y¼ÝiZûs€û€ØK(ññØØññ(t##ðððð##(ccÎÎcr18#cccÎ[[€ss[s::ssssss+ûûiiXZQÎûK˜gÔððð##rÇ((##r(####ðððºðÔ#ññc˜[[[[cñž#ÇݤpÝpÝpiiiXZûûÒ-ääPPP...ÈÈï¸ïÈïÈï§ï ïï.2?JÃÓÄßMM7MMM7MMM7MMMMMMMMMMMMMMMMËFËFFÂRBB·¹íÚÚÙ×ûsûQQ((((ñQQQQñKt#ðÔððð#QQ€ccñù8r#ž#˜ccÎÎ[€[€[[€s€[€+€s+û€1iXQØûØc˜˜####žr1rrr(ž##ðð##Ô#(((cc€Î[[[ccc(žžtrÇpppÝpÝÝÝiiXZûû" -äm|,PPþ¸È¸ï Èï §ïï §.2~Ã&“Ä‹M7M7M7M7MM7MMMMMMMMMMMMMMFMFFFCÂRBB•½ííÚÚ×KZûñ(((ñQ€QQQñ(#t#ððÔ###ñØQ€cñù(#ž###˜cQÎÎÎÎ[[Î[[[sss+€cû1iXZû€Øc˜ž˜žùùùñññž#ðð##Ô##rñ˜ñ€ccccc###ÒÇÇpppÝÝpÝÝii1XQ+û" Gä||¦|Pþ\ÈÈï§ï¸ïï2.nª?~ÃÅÄúMM}MMM7M7MMMMMMMMMMMMMMMFMMMFFœÂR·¬·•½ò‚  SE_ñK((((ñQ€€Q€óKNNð#ððð#(Kcññrr#####(˜ccQÎcccÎÎÎ[[Î[[s:::+Î[1€€Î[[€[ÎΘc˜Q8ññccc˜žž#ž####rržñcØñ€€ñ(ž##ÒÇ8pppÝÝÝÝÝÝi1XZûûQ^Uääää||||||Ü\Èȧ §22..‘Åâ¯MMM7MMMMMMMMMMMMMMMMFM}MFFFœÂÂR*•v••4òò‚—Sèè##((ñQQ€€QØØ(##ðððð#((cccñr(Ô#####˜˜cQccÎÎ[[[[[[:[:::::[€€€QcÎ[s[[Îñcc8Q˜˜ññccž####Çrž(ñ(####tÕ8ÝppÝpÝÝÝii1XZûûQ)‡||||||P||ämÐÜÈȸïV22nå~‘Å‹ë7M7MMMM}7M}M7M}MMMMMMMMMMMMFFFœœÂlRR·vv4v4·4ò·9¨Ôð#(c€Q€€€€QØóØK##ðððt_ñØ((#Ô#####˜ccc[[[[[[[[[[:::::[Î ÎÎ΀€[[[ccññ˜gññc˜cc˜##(#1r(ž##ž#žžž#žÔÔÔ#tÇÕÝpÝpÝÝÝ8Ý8i1ûûQÇdþþPþ..|ÜÜÜÜþ\Èï VVVV2Ì?J††“‘ÅMMMM7MMM77MMMM}MMMMMM7M7M…Fœœul*¬vvvv·B···£e¨N(ØØ€QQ€€Q€QØóK#N#ð#t#˜˜(t#######c˜ÎÎ[[[:[[:::[s:::[:ÎÎΘ˜ÎcÎùgžñ˜˜cQcÎÎcñ˜ž#ÇÇ(Ô#ðÔ#ÔÔÔÔ#ð#ððt)88ÝÝÝpÝÝÝÝ8ii1Zûûójö..þþ.Tª...¸\\¸È¸§VVVVÌÄ??JÞ&†~~ÅMM7MM}7MMMM7MMM}7MMMMMMM}FœœC;BffvvvvBBRRl££>N_Qû€€€QññóØQØK_(tð##žžž((########žcc΀[[[[[[[[[s:::[[ΘccQccñr(žž˜ñccgc˜˜žrrtt####ððtð#ðððtÇÕ88ÝÝÝpÝiiÝÝ81û+óÕn¸ÈP.ªÌJAD­ÁÌVêꧧVVÌÁÓ­ÞŽ]ˆ&†~~‘MMMMMMMMM7M7}}7}}MMM7M}FFbCBBff¬v v v¬*læ£ì_Ø+sû€QrñóQ€ûñ((Ò#ð(˜(tt#########cccÎ[[[[€[€€€€€€û€s[Îccñccññ(t###ñQÎÎcccc#((t#ÔðÔðð#ððððº#")Ç88Ù8ÝÙ88i8ÝÝi1XZûö.þ³È.ªJ±±šüü¶A­ŠŠVÁÁÁ­­Þ]Ž&ˆÃÃ~MM}MM7MM}}7M}}7M77MM}M…œuB¾f v°°````` ¾¾¾ælR™9EØ+€û€ñ(óñóQ€ó(t(NÔ(_(ØcØ((((##ž######cccÎ[c˜˜c˜˜K€[Îc˜##cñññ(#####˜ñÎQÎΘcž((#ð#ðððððºðºð#ºÇÇÇÇÇiiÝÝ8118Ý8iùûû×pëPÜ|?D3@@@@@š¶ŸAÓÓÓÓÓ­¶±33]]Þ]ŽŽÞMxMM}MM}}77}77777MM7}FuB °°°````° ¬fB·ÏjEó+ØØóóñóQ€€óØK_##trññØcØ(((########ccccccÎÎΘ˜##žžñcccž##˜(žž##ññ˜cÎccñrrrrt###º#ºðð#ð#ðtttÇÇ88ÇÇÇiÝiÇ1ipÝ8ùZû×¼d|ää¦o@@@@@@šš¶¶AAAA±@33ŽŽŽ]333MMMMMM}777h77hh7M77M7M}œbBf ß```ãããßO``v••‚jE_KóññØñØØ€ØKK((žNùØñØØcK((#ž#(t#ð##ccñc˜Îcccñ######QQñ#˜˜˜˜#(1ñ˜ñù881ùrñžžž#ð##ð#ððððð#ttÇÇ88ÇÇù_Çiii88Ý8iQשLG|ªŽo@@@@@@@@šš¶¶¶¶üü@3@33±ŽŽ±o@@MMM}M7M}7h!7!!h7!7M7}MFl¾ °`OOããããáããããŒOOú„¹ ENØØØcØØØØØK(t##ùñ€ØØc˜K_#ž((t##Ô#˜cc€cÎcccžž#ž##žgññ#žÎÎÎÎÎÎÎÎcc˜žrññQùrrñ(#####ð#º#ð#ðtðtttrÇÇ88ùÇ8rùiÙ118888XשTÐÀxÞo@@@@@@@@@ššššš@@@@@@3333@@@@M}MM}7!7!h!!h!h!7!7777M}Fbf `ãããããããáãzãã¥ãããáããâú„—Æ_Ø€€€ØØ(ØØ(((žrñØ€cccK(ttt###žž˜cccccccccÎ##˜ž˜˜ÎÎÎÎÎÎÎ[Î[cÎcccž(ñrñ(ùrr((#####t#º#ð####t(Ç8ù88ÇiÝÝÝi1r18pÝÝXXÇ©‹Üä-T~ào@@@@@@@@@ššš@@@@@@3@3333@@@}M}7M777h!h!!h!!hh7777MM²Fu¾ ããããããááããázãázáããz¥¹—Ò_ØØØØññØcñ(t(žrQñQ€ØØK(t(((###ž#ž˜˜ÎcñcÎcccc˜žž˜˜˜˜ÎccÎ[Î[[[[Îcžžrù#rèñró(#########ð##ttttt18Çi81Ù8iiiÇÙi88ÝpXiÙ³ä}둈oo@@@@@@@@ššš@@@@@@@@@@@@@@@MM7h7hh!!!{›!›{hhh!77h7}}u¾ßãããáááááááããáãáããßúë½Ï9E_óØ€€€ññ((tt#rñcØQñc(((((#žžž˜cc˜cñccccc˜˜˜#(#cc€€QQØ€cÎ[[[cc˜ž1ùK(rrñž#####t##ð###ÔttÒÒÒ(ÇÇi8i11XiiÙÙp¤q8ÝÝiפ‘TG¿}÷d†]]@@@@@@@@@@@@@@@@@@3@@@@@@@@77}77!hh!!»!»!»h{hh7!M7}Fl¾ áãááá6áááãáãããããŒ` ¬fBÛ™9Ò_óØQØØñ_(tt(rñcc#######ž˜Θccñccc˜cž#€Q[ΘÎccc€[ÎΘ˜ž8rKróñž####t######ttt(_1Çi8iXXXiXiÙ¼pÕÇÙiiÙ¤©öd$7-$½†àào@@@@@@@@@@@@@@@@33@@@@@@@@}77hhh!!!»!›{›{!!77!7!7}u¾ßãááááááááááããããŒ``v¬*u££eìÆEóØØØØ_KKèóóØK((ttttt(((ñ(ÎcccccccÎc˜ccg(€Q€[[ÎΘ˜cc€cc8ó(Kù((##(####ttt##tt(×1i8iXXXXXXi8Ý8×11ÙÝqyÖ7F,놈à@@@@@@@@@@@@@@@@o]Ž3@@@@@oü7h7hh!!!»!›»!»!›!h!hMM…Fl¾°ãááçáçá66áááãŒ``vv*RÂÂ……²ÊeìSE××××_KèèØóóc(t#####(((ññcc˜˜cccccc˜˜˜cQQ[[[cÎΘc˜ccñcc(cr1rñr#######t(tttt((r_óÇ1iiiXZXXXXXiiii11ÙÕÿµ£7x‡†]oo@@@@@@@@@@@@@@@3ÞÞ33@@@@3/hhh!!!»»»»{»!!!77hM}…œ¬ãááááççççááããOvv*·ÂÂ…›²Êe=Ï—‚ —jS_NèØóKžt##ðÔ#Ôð##(ñ(cccc˜˜˜ccccc˜˜cñc˜QQ[[[[[ÎÎΘÎññcñcrññùrñ####ž#ttttt(((ró_ùùiiXZXZXXXXX1iiii1iÙ)ÿaa½‘†]o@@@@@@@@@@@@@@oo]Ž&±@@@@@ü/!!!{!»!»»»»»!{!!h7h7}MFœ ááççççççç6áãO`v*R«F…{»{hhhMF£44½‚‚É—ÆÒE_###ððððð#####ñññcccÎcñQQc€Î˜˜QQ€[[[[[[Îc˜˜c˜cù(ž#####ž##((r(tÒññrrórùùXXXXZXZXXiXXX1Xù11ùiÇ)=eö͈à@@@@@@@@@@o@@@@o]&&Ã33@@@@o/!{!»!»»»»»{»›!!!h7}M}…C`ááççáççç6áጌv¬ÂÂœ«…h{hhhh}l¾f•4¡Ïìì"Òº#ðððÔððððžðžžccccØcØØØQØñcQñcccQùQÎ[[[[[[ccÎ##˜(rrrÔ########t(rÒt(rórrùùXXXXXXXXXXiXXXXX1ùXXr^=”ƒˆ]à@@@@@@@@o@@@o@ooŽŽÃÃ33@@@@šŸ!{!{»»»»»»»»!{!hh77}MM}Fl¾°ãáááçáááázŒß°fRl…«F…²{›{!{!Yh{{¿bæLBÛ££9wððºð#º#º#ž#žccKccccñccñù8ùQÎ[[[[[[ÎΘ˜cñ1r(t#ð######((r#t_ññQZXXZXZXXXXXiXiXXXiX1XQZXÿÏ¢ýˆoo@@@@@@@@o@@@o@oà]&Ã&3o@@@@üŸ!{»»k»»»»»{»!!!!7}}²œufßááááãããŒOßßf¾bÂ………!!!ø!øY!¿¿{…bÂbœ MÊe=>º#º#ºt#Ô###žc˜Kñ˜cccÎ[[[[[[[ccc˜r1Çrt###ðð#Ô###t(_((_óñQZZZZZXXXX×XiXZX1XiZXXX×^Wƒˆ3oo@@@@@@@@@o@o@@ooà]]ŸŽ3o@@@üŸ{»»»»»»»»{»»!{!hh7!M7M7}Fuf°Œãá㌌ß`°°¾BC«}²h{»!!!!!!!hhhh¿¿¿{!Êee'¨ðºðººðððž##Kè(ccÎÎ[[[[[Θrrù(tt####Ô###t(t((ó_óóñQQZZZZZXXZXXXXXiXXZXXóió×Eÿy0ˆoo@@@@@@@@o@@@@@ooooà]&Ÿ]/33šŸ®»»»»k»k»»»{{{!hh7}77}}uf°ßŒßOvvfBllœ……h{{»{»»»!!!!!!!7!!!!!›{»{k{î›–Ê>¨Ôðððºððº#ðð###t###ž##žž((˜g˜cÎÎÎ[[[cÎc˜c˜c(ùr((t((########tt##_ñrQQQQQZZZûZûXZXXZXXXXXXXZXXi¤¤pSwÿ¢Í]o@@@@@@@@@@@@@@@@@oooà]Þ&ÞŸ/®­»kîkîk»»»{{»h{!{hh777M77Fbf°°°°f*RÂœF²²h{»»»»»»{»{»!!!!!!!!!!!!!›»{{»{!›–õ¨¨¨ððºðºððððð#####(##Ô######(#žžÎccccÎ[[Îc˜Î˜cc(ñ((((r(#t####ð####((ññQ€Q€QZZZûZZXZZXZXXZZXXXóóש©eéÏ¢ˆào@@@o@@@@@@@@@@o@oo@o3ŸÃ‰J‰­‰J’îkk»k»»»{»»{{!¿hh7h7777}h}œu´ffBBuCF…²{›»›{»!{»{!{›{!!!!!!!!!!{»!{»!›<éI¨¨ðÔðºððððððt##(#t##ð#ð#ð##t((žžÎcccÎ[[[cÎΘñ(ž#(rrñc(K#ð#ð#Ôt((ñQQ€QQZZûûûûZZXZXXZZZXZXXXZZZKÙ©¢–Ëôˆ3o@@@ooooo@@@@@@@@o@o3à&‰?Äå?Äkîk»k{»»{{!{{h{hh7h7777777…œuuluœF²h!›!»{»{»!»»»!»{{!»h!!!!!!!!›!›»»»h›› éÑ>ðÔðððððtº####ððððððððtÔtÒ(#žcccÎ[[Îccccñ#(((QQQQQØ((##ððððtññ€QQQûQZQûZZZûZZXZXZZZXXXiXZZXó_ ”,‘]oo@ooàoào@o@@@@@o@oooà/ÃåÄ‹‹nÄn‹k»k»»»»{»»{{!¿hh7h¿h7h7777}}Fœ……}h!!!h!»!»›{›{»»»»»{›{{{!!!!!!!!!!››››{{{{!›ewðÔÔðððt##Ô#ðððððºtðºð#ttt#žccc[[ccc##((QQ€€Qññ(##ðððtÒñ€QQQQQûQQQûûZZûûûZZZZXZX×iXXZZZóSWM‡T‘Ãà/ààààààà@o@@@@@o3oà]&‰Ä‹¯³³¯»k»»{»{»h{{!{hh¿¿7h7h777hhhh²}²hh7!!h!!›!»!»›»!»!›!{!»{›!!!!!!!!!!!››››!h»{{{!ÿÒÔððÔÔðððººðððÔÔÔ𺨺ºððð#tttž#cÎ[[[[ccc˜žžt(ÇÇQ€QññN#ðNð_ññ€€€ûQQQZûûûZZZûûûZZXZXZX×ZXiiûXÙSy£‡dÃ&ŸŸŸŸŸàààààoo@oooàà]]&‰Å‹¯´´;P´´k{k{»»{»{»{h{hhhhh7h77h7777h7hhh!!!!!{›{›{›{»››»»!!!!!!!!!–!!›!›!!»!!{–Ñ^EÔÔÔÔÔÔºººð>ðÔð¨ÔðttºððððtÒtž#cÎ[[[[[[ccÎccct#ÿww)ÇrQQ€Ø(##ž#ó€€û€ûQ€Z€û€û+ûûûûûûûZûZZXXZûXiiiiÙÕɵa ‡ë哉‰‰‰‰‰&&Ÿàà/à3àà]à&‰åį³LLLbLG»»»{»{»{h{hhhhhhhhh¿h7hhh!h!!!!!!!!›!!›!{›{›{»{»!!»!!!!!!!!!!!–!›!›»!»!!{!!éìÆNèèèžÔððððððNtðtºð#ttt#c [:[[[ÎcÎÎc[ÎΘžN)yµeewÿÇñQQØ(t(rQQ+€€s€€û++++ûûûûûZZZûZûZûZZXXiXiÕ ^'õÊ U¦ëÅÅÄÅå“哉Ã&Ÿ]]Ÿ&]&&‰Åª¯´LLGGG»»{»{!{{h{h{hh¿hhhhhh7hhhh!!!!!!{!!{›{!»!»!»»»››»!!!!!!!!–!!!!!›!›!{›{!{h›õ>Æ×ØؘžÔÔ##èðððððºttºðððÔ#t(#(ñQ€€Îcñrؘ΀c˜žðÿÿaaewÇrQ€ØKK(ùQ€€s€s+€+€ûûûûZûûûûûûûûZûZZZX×1Új>õ–!!7M$,nTTHn‹ÄĪ‹‰J‰®Ã&‰Ã‰åÅH³ÐLGGÀxÀ»{»{{h!h!hhh!hhhhhhhhhh!!!!›!{›!›!›!›!»!»!»!»»!»!!!›!!!!!!!–!!›!›{!›{!»h{!–Iì××ØKgÔttKðºððtNÒ"ðºðððð##N(K#KØrrt_óØcΘc˜K#t"aËUUa=µÕQ€€€QQQQQQ€+ss++û+ûûûûZûZûZZZZûZZûZXZ××jÆ' !M7!7 $¦nn¯³³n¯³¯nT?åJåJ‰åĪ¯´LLGÀÀx»{»{»{{!{!{h!hh!hh!h!h!hh!!!!›{›!{›{!!»!»»»»»›»!»!!!!!!!!!!›!h›!›!{›{!{!!› ÑÆE×Æ'>ºÒ(KtººººðtºtºðððððÔNèNèN_ÆÆIIÒEØcؘ#("µ $UUUÖQû€ûQû+û€+s+ss€+++++ûûZZZûûûZZZXXXX×1jÆIé ›!!øY7-÷$,PPP³³ PP³.nªêªÄ’ÅÄÄH³´´GÀÀ-x»{»{{{h{!{h!!{h!{hh!!h!!h!!!›{›!›!!›!!!››»!»»»»{»››!»!!!!!!!!!›!!›{›!{›{!{›é¨ìES)¨>>""Òº>¨ðððÔðºððºtºÔ¨NÒ"º>ÑÑéIIN_óóž")>aU $UUUÿÇQ€ssss++s€€s€+ûóûZ××××××ó×ZXXii×EE—ìé !!!›{77 -$¦PPPP|PPP³ ³¸nnnnêHn³³´ÐL}xM{»{{»{»{!{h{!h!!{!{›!!!{›{!»!›!»!»»»»»»»!»!!!›!!!!!!h!!!›{!!»!»!»!›!›› õõÑ'e'eee>w'>>º¨¨¨>ºººÒìÒ¨¨¨''ÑÊËe'IN_óóKt)w'e÷--$$$$=ÿ)róssssssQQr×rÇÇÉW—^^^"ì>>'é< <›››!!M- $ä¦P||ÜPÜ þþþÜ \³¸H¸¸³Ü|ÐLGÀ}M}{{»{{{{{»!{!!h!!{!h!!!{!›{›!!›»›››»›»»»»»»{»{»›!!!!!!!!!–h!›!›!›!»!»!»!»hh›h–›–––– õõÊe>>¨¨¨>wwììw¨¨'ÑI''ÊÊÊÊÑÑI(ÇÒ¼"eaË÷÷$ ÷UU=ÿrñ[s€û×8¼¼¼q””””ddd‡‡‡U=eeÊÊé –<<¨¨w>ÑÑI''Ñ'ÑÑ'Ê'ÊÊÊÑÑÑIºp¤ÿ>eÊËËM- aU,ÿ^ErÕÕ¢ödd‡d³³´P÷x7! ››<»»îî»î›î<<<'>'''''''ÑÑÑÑÑÑ'ÑÊÑÊ'ÊÑÑ'ee'eee>™,¦³¸¸§§§§H¸¸ ÜÜÐÐÐÐGÀ¿økîîîk»k7PPþȸ¸È¸ï§§ § ¸§\ ¸\³´LbÀ¿!kkk»k»k»»»»»»»»»î»î»îîîkîîîkkîkîkkîkk»î»î»»»›»!»›{›»»»›»î»›î›»<››»{»»›»<›< ––ÊÊ'''Ñ'''''''''Ñ''''Ñ'ÑÑÑõÑõõÊÑõõÊ'''eeeee=,¦³¸¸§n§n§¸\\ÜÜÐÐLGÀ}¿!›îîîîîîîîîkîîk-P³¸.Èï§êVê§ï¸ ¸§¸¸ ÜÐGÀYh{»kîkkîk»k»»»»»î»»»»îkîkkkkîkkîîîkî»»»»»»›»›»»›»»»›»î›î›»›»›»»»»<<< –ÊÑ'''Ñ>>'Ñ''Ñ''ÑÑÑÑÑÑÊõÊÊõ'Ñ'eeeeee>=Û‡¦.¸n§n§H¸\ ÜÐLGGÀ7!»îîîîîîîîîîîîîkî-|P....§¸VV§§§§§¸§¸³PLGÀ7Y!kkk»kîk»kîkîkîkîîîkîkkîîîîîîî»»»»»»›»»›»î›»î›»›»!»»{»{»›› ––õõÑ'''>''ºº>>''''ÑÑ'IÑÑÑÑÑÑÑÑ'õ''Ê'e'eeee==‡‡ënn§¸¸¸³´ÐÐGGÀ}Y{»îîîîîîîîîîîîkîkîîîîîY-|P³.n¸§§§§§§\Ü´GÀY7hkkkkkkkîîkkîkkîkkîkîîîîkîk»î»›»›»›»»»›»<»»›»»»{{»!››››––õÑÑÑ''>>>𺺺>>''''ÑÑÑÑÑÑÑÑÑIÑÑÑ''eeee>e>ììµôdn2§§¸³³´LGÀÀ7{{»»îîîîîîîîîîkîîîîîîø-|³.n¸¸nVÓÓÓV§§§§§§¸³ÜLÀ7Y7kkkkkkîkkkîkîkîkîîîîkîkî»î»»»»»»›»›»î›»›»›»!»›!›!››––õõÑ'''>>>>ººº"ººº''ÑÑÑÑÑÑÑÑÑÑÑÑ'Ê'e'ee>¨wµÖô.n§¸\´´bG-}¿ø{{»kîkîkîîkîîîkîk»îîkkkîîîî»7G|³nnHH§ŠŠŠŠ§§ê§§³ L-7-7kkkkîkîkkkkkîkîkîkîîîkî»î»›»›»›»»»›»›»›»!››!!›!››–––õÑ'>¨>ººtttttºº>>''''Ñ'IÑÑÑÑÑÑÑ'Ñ'''ee>e>wwìµÖën.n³´LGxÀYhø»k»îîîîkîîkîkîkîkîk»kî»îîb¦³¯HH³H§’Vêꧧ§êê길³L-7-kkkkkîkîîîîkîkîkîkîkîkîkîkîkî»»»»»»»›»›»›»›»››!››!›!››––õÑÑÑ'>>ººttt("tºº>>º'ÑÑÑÑÑÑÑÑÑ'Ñ''e'e>ºwºwìµôd.¯¸´´bÀ}}¿h{k»kkkkkîkkkîkîkîkkîkîkîîî»»7G´ ¯HH HHHH¸H³\HêêêH¸³´-M-kkkkkîkkkkkkîkkîkîîîkîîkîkîkî»î»»»›»›»»»!»›»!›!›!!!–!!––––éÑI>ºººtt((ñ(tt>>º'''Ñ'ÑÑÑÑ'ÑÑ'''>'>>wÒw"µÖôd¯´´bG}¿7h{»k»k»kkîk»k»k»kkkkk»kkîkk»îî»›hœ;¯H°ß ¬ ¾³ ´´¾Ð´³¸H§H¸³³LG--xkkkkîkîkîîîîîîîîkîkîîkîîkîkîîkîîkîkîk»»kîkîîkî»»»»»»»»››»›»››››!!!!!!–!–õõÑÑÑ'ðººtt((ññññ(tººº>ººº'''Ñ'Ñ'ÑÑ'Ñ'''''>>ºwºt"wÿÖ‡‡,GÀ}7h{!»kkkkkkkkkkkkkk»k»k»k»k»»îî»»!F;fú° ¬**æ«……bL´¾³³³´´Gxxxkkkkkkîkkkîkîîkîîîîkkîkîîîkîîkîîîkîkî»î»k»»»»»»»»›»»›»›»››!!!!h!!–––õõÑÑ>ººtttñññQñññ(#º>ººðð'''''ÑÑÑ'Ñ'''>>ºÒÒtÒÒìµÖ,;$}}hh»»»»»k»»kkkkkkkk»kkk»kk»kk»î›››!FÛ¯°ß``*æ櫲²ÀL´´´´LbÀxx kk»kîî»îîîkîîîîkîîkîîîkîîîîîîîkîkîîkîk»»îî»k»k»»»»»»»»»›»›»!››!!!!!!!!!õõÑIÑ>>ººtÒ_(ññQQñ(tºðººðººººº>'''ÑÑ'Ñ'ÑÑÑ'''>ººNtNÒÒµµ= x}¿»!»{»{»»»kkkkkkkkkkk»kk»»k»î»îî››hCB•`v¬*æ²²¿¿}ÀÀx-xxkîkîkîkkîkîî»kîkîkîî»îîkîkîîkîîkîîîîîîî»kî»»k»kî»kî»»»»»»»›»!»!»›››!!!!7!7!õ'ÑѺºtÒ((ññ€Q€€€ñ((#ºðººððððððº>''''Ñ'Ñ'''>>ºttttÒ"wa {{!»›»»»»»»kk»kkkkkkk»k»k»kkkî»»››!–MC·ff¬*æ櫲²›²{¿¿À¿ÀÀxxxkîkkîk»î»î»î»îî»îîîîîîî»îîî»îî»îkîîkîkîk»îk»îk»»î»k»»»k»»»»»»»›»»›»»!›!›!–!!!!77ÊÊÑÑÑ>>º"Ò(((ñØQ€€€Q€ñ(#º#ðºðººðººº>''''Ñ'ÑÑ'''>ðºtt(NtºweË!!»{›{›{»»»»»»k»kkkkkkkk»kk»k»»îîî››––Ê£R·¬¾*櫲²²²²h¿¿}}}}}-Fxœkkk»î»kî»î»î»»îîî»î»»î»î»»îî»îîî»îkîkî»»»î»î»î»k»»»k»»»»»»»»»»!»!!!›!›››!!!!77!MËÊ'ÑѺºÒt_(ñññQ€€€€€Qñ(t#ººðºð#ºððºð>'''''''>>ðtt#tttw'Ê›»{›»»›»»»»»k»k»k»kkkk»kkî»»»îîîî› !õÊÊË£ÛRB*æ櫲²²²²²h¿…œbbbx-xFxîkkk»îk»»»»»»»»»î›î»î»î»»»»î›»»»»îî»î»îîî»î»î»îk»»»k»»»»»»»»»»!»!!!!!!!!!!!!!h!MÊ''IðººÒÒ(KññQ€Q€Q€€€ññt##º#ºðºðºð>ð>>''Ñ'Ñ''>>¨ºtttt"º'!››{{›{»»»»»»»»k»kkk»kk»k»»»»îîî»›!–ÊÊee=ÛBB¾¾l«²²²²……œ;;;´;G-FxFkkî»î»»»»»»»»»»»»»î»î»î›î»î»î»î»î»îîîîîî»îî»î»î»îkî»î»k»»»»»»!»»!!!!!!!!!!!!!7!!Ê''>ððttttóñØQñQQ€€€Q€Qñ(##º#º#ðº#ººðº>''''>¨ðttttttº'Ê!›»›»»»»»»»»»»»»k»kkkîkkîkî»îîî›»›–ÊÊe9™™Bf¬¾æ²²²²…²}œ;f³¯¦;$x}FF»kîkk»»»»»»»›»»›»»»»»»»»»»»»»»»»»»îî»î»î»î»î»î»îîkîk»»k»»»»»»!»{!!hh!7!!!!!!!ÊË'>>ººttt(Ò(ó€óóQ€QQ€€€€Øñ(ðtðtðtðººðºº>>'''''>>¨ººttttºw'Ê››!»{»»»»»»»»»î»»»k»kkkîk»îîîîîî››Êe9Ö44ff¬²²²}²…œu³¯nTn¦GF-FF…îk»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»îî»îîîîîîîîîîîîîkîkîkî»»»»»»»»!!!!!!hhh7!!7!7!!ÊÊ'e>ººÒtt(Ò((óQQQQQ€€€€€€QØK(#t#º#tðt𺺺>>''>>>ºttt#tº>eÊ!›»»»»»»î»»»»»»»î»kkîkîkî»îîîîî»›!ÊeeÏ¡¡•fv Â…²…²……b;¯‹Tn¯´$-}……FPapyrus3/JpegDir/JpgLossy/Makefile.sun40000755000175000017500000000202607535143454015167 0ustar # @(#)Makefile 1.3 16/11/94 DSTDIR= ../.. MANDIR= $(DSTDIR)/man INCDIR= $(DSTDIR)/include BINDIR= $(DSTDIR)/test LIBDIR= $(DSTDIR)/$(ARCH)/lib CPPFLAGS= -I$(INCDIR) -DXTFUNCPROTO -g CFLAGS= -g LINTFLAGS= -hb SOURCES= jcmainct.c \ jcomapi.c \ jcparam.c \ jdapimin.c \ jdapistd.c \ jdatasrc.c \ jdcoefct.c \ jdcolor.c \ jddctmgr.c \ jdhuff.c \ jdinput.c \ jdmainct.c \ jdmarker.c \ jdmaster.c \ jdmerge.c \ jdphuff.c \ jdpostct.c \ jdsample.c \ jerror.c \ jidctflt.c \ jidctfst.c \ jidctint.c \ jidctred.c \ jmemmgr.c \ jmemnobs.c \ jquant1.c \ jquant2.c \ jutils.c \ rdcolmap.c LIBRARY= libJpglossy.a OBJECTS= $(SOURCES:%.c=$(ARCH)/%.o) $(LIBDIR)/$(LIBRARY): $(OBJECTS) ar rv $@ $? ranlib $@ lint: $(SOURCES) $(LINT.c) $(SOURCES) .KEEP_STATE: .INIT: $(LIBDIR) $(ARCH) $(LIBDIR) $(ARCH) : test -d $@ || mkdir -p $@ $(ARCH)/%.o: %.c $(COMPILE.cc) $< -o $@ clean: -rm -Rf $(ARCH) *.BAK .emacs_* Papyrus3/JpegDir/JpgLossy/makelib.ds0000755000175000017500000005374007535143454014604 0ustar # Microsoft Developer Studio Generated NMAKE File, Format Version 4.20 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 !IF "$(CFG)" == "" CFG=jpeg - Win32 !MESSAGE No configuration specified. Defaulting to jpeg - Win32. !ENDIF !IF "$(CFG)" != "jpeg - Win32" !MESSAGE Invalid configuration "$(CFG)" specified. !MESSAGE You can specify a configuration when running NMAKE on this makefile !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "jpeg.mak" CFG="jpeg - Win32" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "jpeg - Win32" (based on "Win32 (x86) Static Library") !MESSAGE !ERROR An invalid configuration is specified. !ENDIF !IF "$(OS)" == "Windows_NT" NULL= !ELSE NULL=nul !ENDIF ################################################################################ # Begin Project # PROP Target_Last_Scanned "jpeg - Win32" CPP=cl.exe !IF "$(CFG)" == "jpeg - Win32" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Target_Dir "" OUTDIR=.\Release INTDIR=.\Release ALL : "$(OUTDIR)\jpeg.lib" CLEAN : -@erase "$(INTDIR)\jcapimin.obj" -@erase "$(INTDIR)\jcapistd.obj" -@erase "$(INTDIR)\jctrans.obj" -@erase "$(INTDIR)\jcparam.obj" -@erase "$(INTDIR)\jdatadst.obj" -@erase "$(INTDIR)\jcinit.obj" -@erase "$(INTDIR)\jcmaster.obj" -@erase "$(INTDIR)\jcmarker.obj" -@erase "$(INTDIR)\jcmainct.obj" -@erase "$(INTDIR)\jcprepct.obj" -@erase "$(INTDIR)\jccoefct.obj" -@erase "$(INTDIR)\jccolor.obj" -@erase "$(INTDIR)\jcsample.obj" -@erase "$(INTDIR)\jchuff.obj" -@erase "$(INTDIR)\jcphuff.obj" -@erase "$(INTDIR)\jcdctmgr.obj" -@erase "$(INTDIR)\jfdctfst.obj" -@erase "$(INTDIR)\jfdctflt.obj" -@erase "$(INTDIR)\jfdctint.obj" -@erase "$(INTDIR)\jdapimin.obj" -@erase "$(INTDIR)\jdapistd.obj" -@erase "$(INTDIR)\jdtrans.obj" -@erase "$(INTDIR)\jdatasrc.obj" -@erase "$(INTDIR)\jdmaster.obj" -@erase "$(INTDIR)\jdinput.obj" -@erase "$(INTDIR)\jdmarker.obj" -@erase "$(INTDIR)\jdhuff.obj" -@erase "$(INTDIR)\jdphuff.obj" -@erase "$(INTDIR)\jdmainct.obj" -@erase "$(INTDIR)\jdcoefct.obj" -@erase "$(INTDIR)\jdpostct.obj" -@erase "$(INTDIR)\jddctmgr.obj" -@erase "$(INTDIR)\jidctfst.obj" -@erase "$(INTDIR)\jidctflt.obj" -@erase "$(INTDIR)\jidctint.obj" -@erase "$(INTDIR)\jidctred.obj" -@erase "$(INTDIR)\jdsample.obj" -@erase "$(INTDIR)\jdcolor.obj" -@erase "$(INTDIR)\jquant1.obj" -@erase "$(INTDIR)\jquant2.obj" -@erase "$(INTDIR)\jdmerge.obj" -@erase "$(INTDIR)\jcomapi.obj" -@erase "$(INTDIR)\jutils.obj" -@erase "$(INTDIR)\jerror.obj" -@erase "$(INTDIR)\jmemmgr.obj" -@erase "$(INTDIR)\jmemnobs.obj" -@erase "$(OUTDIR)\jpeg.lib" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c # ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS"\ /Fp"$(INTDIR)/jpeg.pch" /YX /Fo"$(INTDIR)/" /c CPP_OBJS=.\Release/ CPP_SBRS=.\. BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo BSC32_FLAGS=/nologo /o"$(OUTDIR)/jpeg.bsc" BSC32_SBRS= \ LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo LIB32_FLAGS=/nologo /out:"$(OUTDIR)/jpeg.lib" LIB32_OBJS= \ "$(INTDIR)\jcapimin.obj" \ "$(INTDIR)\jcapistd.obj" \ "$(INTDIR)\jctrans.obj" \ "$(INTDIR)\jcparam.obj" \ "$(INTDIR)\jdatadst.obj" \ "$(INTDIR)\jcinit.obj" \ "$(INTDIR)\jcmaster.obj" \ "$(INTDIR)\jcmarker.obj" \ "$(INTDIR)\jcmainct.obj" \ "$(INTDIR)\jcprepct.obj" \ "$(INTDIR)\jccoefct.obj" \ "$(INTDIR)\jccolor.obj" \ "$(INTDIR)\jcsample.obj" \ "$(INTDIR)\jchuff.obj" \ "$(INTDIR)\jcphuff.obj" \ "$(INTDIR)\jcdctmgr.obj" \ "$(INTDIR)\jfdctfst.obj" \ "$(INTDIR)\jfdctflt.obj" \ "$(INTDIR)\jfdctint.obj" \ "$(INTDIR)\jdapimin.obj" \ "$(INTDIR)\jdapistd.obj" \ "$(INTDIR)\jdtrans.obj" \ "$(INTDIR)\jdatasrc.obj" \ "$(INTDIR)\jdmaster.obj" \ "$(INTDIR)\jdinput.obj" \ "$(INTDIR)\jdmarker.obj" \ "$(INTDIR)\jdhuff.obj" \ "$(INTDIR)\jdphuff.obj" \ "$(INTDIR)\jdmainct.obj" \ "$(INTDIR)\jdcoefct.obj" \ "$(INTDIR)\jdpostct.obj" \ "$(INTDIR)\jddctmgr.obj" \ "$(INTDIR)\jidctfst.obj" \ "$(INTDIR)\jidctflt.obj" \ "$(INTDIR)\jidctint.obj" \ "$(INTDIR)\jidctred.obj" \ "$(INTDIR)\jdsample.obj" \ "$(INTDIR)\jdcolor.obj" \ "$(INTDIR)\jquant1.obj" \ "$(INTDIR)\jquant2.obj" \ "$(INTDIR)\jdmerge.obj" \ "$(INTDIR)\jcomapi.obj" \ "$(INTDIR)\jutils.obj" \ "$(INTDIR)\jerror.obj" \ "$(INTDIR)\jmemmgr.obj" \ "$(INTDIR)\jmemnobs.obj" "$(OUTDIR)\jpeg.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS) $(LIB32) @<< $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS) << !ENDIF .c{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_OBJS)}.obj: $(CPP) $(CPP_PROJ) $< .c{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cpp{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< .cxx{$(CPP_SBRS)}.sbr: $(CPP) $(CPP_PROJ) $< ################################################################################ # Begin Target # Name "jpeg - Win32" !IF "$(CFG)" == "jpeg - Win32" !ENDIF ################################################################################ # Begin Source File SOURCE="jcapimin.c" DEP_CPP_JCAPI=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jcapimin.obj" : $(SOURCE) $(DEP_CPP_JCAPI) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jcapistd.c" DEP_CPP_JCAPIS=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jcapistd.obj" : $(SOURCE) $(DEP_CPP_JCAPIS) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jccoefct.c" DEP_CPP_JCCOE=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jccoefct.obj" : $(SOURCE) $(DEP_CPP_JCCOE) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jccolor.c" DEP_CPP_JCCOL=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jccolor.obj" : $(SOURCE) $(DEP_CPP_JCCOL) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jcdctmgr.c" DEP_CPP_JCDCT=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jdct.h"\ "$(INTDIR)\jcdctmgr.obj" : $(SOURCE) $(DEP_CPP_JCDCT) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jchuff.c" DEP_CPP_JCHUF=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jchuff.h"\ "$(INTDIR)\jchuff.obj" : $(SOURCE) $(DEP_CPP_JCHUF) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jcinit.c" DEP_CPP_JCINI=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jcinit.obj" : $(SOURCE) $(DEP_CPP_JCINI) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jcmainct.c" DEP_CPP_JCMAI=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jcmainct.obj" : $(SOURCE) $(DEP_CPP_JCMAI) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jcmarker.c" DEP_CPP_JCMAR=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jcmarker.obj" : $(SOURCE) $(DEP_CPP_JCMAR) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jcmaster.c" DEP_CPP_JCMAS=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jcmaster.obj" : $(SOURCE) $(DEP_CPP_JCMAS) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jcomapi.c" DEP_CPP_JCOMA=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jcomapi.obj" : $(SOURCE) $(DEP_CPP_JCOMA) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jcparam.c" DEP_CPP_JCPAR=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jcparam.obj" : $(SOURCE) $(DEP_CPP_JCPAR) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jcphuff.c" DEP_CPP_JCPHU=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jchuff.h"\ "$(INTDIR)\jcphuff.obj" : $(SOURCE) $(DEP_CPP_JCPHU) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jcprepct.c" DEP_CPP_JCPRE=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jcprepct.obj" : $(SOURCE) $(DEP_CPP_JCPRE) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jcsample.c" DEP_CPP_JCSAM=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jcsample.obj" : $(SOURCE) $(DEP_CPP_JCSAM) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jctrans.c" DEP_CPP_JCTRA=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jctrans.obj" : $(SOURCE) $(DEP_CPP_JCTRA) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdapimin.c" DEP_CPP_JDAPI=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jdapimin.obj" : $(SOURCE) $(DEP_CPP_JDAPI) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdapistd.c" DEP_CPP_JDAPIS=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jdapistd.obj" : $(SOURCE) $(DEP_CPP_JDAPIS) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdatadst.c" DEP_CPP_JDATA=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "$(INTDIR)\jdatadst.obj" : $(SOURCE) $(DEP_CPP_JDATA) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdatasrc.c" DEP_CPP_JDATAS=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jerror.h"\ "$(INTDIR)\jdatasrc.obj" : $(SOURCE) $(DEP_CPP_JDATAS) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdcoefct.c" DEP_CPP_JDCOE=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jdcoefct.obj" : $(SOURCE) $(DEP_CPP_JDCOE) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdcolor.c" DEP_CPP_JDCOL=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jdcolor.obj" : $(SOURCE) $(DEP_CPP_JDCOL) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jddctmgr.c" DEP_CPP_JDDCT=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jdct.h"\ "$(INTDIR)\jddctmgr.obj" : $(SOURCE) $(DEP_CPP_JDDCT) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdhuff.c" DEP_CPP_JDHUF=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jdhuff.h"\ "$(INTDIR)\jdhuff.obj" : $(SOURCE) $(DEP_CPP_JDHUF) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdinput.c" DEP_CPP_JDINP=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jdinput.obj" : $(SOURCE) $(DEP_CPP_JDINP) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdmainct.c" DEP_CPP_JDMAI=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jdmainct.obj" : $(SOURCE) $(DEP_CPP_JDMAI) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdmarker.c" DEP_CPP_JDMAR=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jdmarker.obj" : $(SOURCE) $(DEP_CPP_JDMAR) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdmaster.c" DEP_CPP_JDMAS=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jdmaster.obj" : $(SOURCE) $(DEP_CPP_JDMAS) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdmerge.c" DEP_CPP_JDMER=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jdmerge.obj" : $(SOURCE) $(DEP_CPP_JDMER) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdphuff.c" DEP_CPP_JDPHU=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jdhuff.h"\ "$(INTDIR)\jdphuff.obj" : $(SOURCE) $(DEP_CPP_JDPHU) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdpostct.c" DEP_CPP_JDPOS=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jdpostct.obj" : $(SOURCE) $(DEP_CPP_JDPOS) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdsample.c" DEP_CPP_JDSAM=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jdsample.obj" : $(SOURCE) $(DEP_CPP_JDSAM) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jdtrans.c" DEP_CPP_JDTRA=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jdtrans.obj" : $(SOURCE) $(DEP_CPP_JDTRA) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jerror.c" DEP_CPP_JERRO=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jversion.h"\ "jerror.h"\ "$(INTDIR)\jerror.obj" : $(SOURCE) $(DEP_CPP_JERRO) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jfdctflt.c" DEP_CPP_JFDCT=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jdct.h"\ "$(INTDIR)\jfdctflt.obj" : $(SOURCE) $(DEP_CPP_JFDCT) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jfdctfst.c" DEP_CPP_JFDCTF=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jdct.h"\ "$(INTDIR)\jfdctfst.obj" : $(SOURCE) $(DEP_CPP_JFDCTF) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jfdctint.c" DEP_CPP_JFDCTI=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jdct.h"\ "$(INTDIR)\jfdctint.obj" : $(SOURCE) $(DEP_CPP_JFDCTI) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jidctflt.c" DEP_CPP_JIDCT=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jdct.h"\ "$(INTDIR)\jidctflt.obj" : $(SOURCE) $(DEP_CPP_JIDCT) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jidctfst.c" DEP_CPP_JIDCTF=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jdct.h"\ "$(INTDIR)\jidctfst.obj" : $(SOURCE) $(DEP_CPP_JIDCTF) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jidctint.c" DEP_CPP_JIDCTI=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jdct.h"\ "$(INTDIR)\jidctint.obj" : $(SOURCE) $(DEP_CPP_JIDCTI) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jidctred.c" DEP_CPP_JIDCTR=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jdct.h"\ "$(INTDIR)\jidctred.obj" : $(SOURCE) $(DEP_CPP_JIDCTR) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jquant1.c" DEP_CPP_JQUAN=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jquant1.obj" : $(SOURCE) $(DEP_CPP_JQUAN) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jquant2.c" DEP_CPP_JQUANT=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jquant2.obj" : $(SOURCE) $(DEP_CPP_JQUANT) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jutils.c" DEP_CPP_JUTIL=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "$(INTDIR)\jutils.obj" : $(SOURCE) $(DEP_CPP_JUTIL) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jmemmgr.c" DEP_CPP_JMEMM=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jmemsys.h"\ "$(INTDIR)\jmemmgr.obj" : $(SOURCE) $(DEP_CPP_JMEMM) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File ################################################################################ # Begin Source File SOURCE="jmemnobs.c" DEP_CPP_JMEMN=\ "jinclude.h"\ "jconfig.h"\ "jpeglib.h"\ "jmorecfg.h"\ "jpegint.h"\ "jerror.h"\ "jmemsys.h"\ "$(INTDIR)\jmemnobs.obj" : $(SOURCE) $(DEP_CPP_JMEMN) "$(INTDIR)" $(CPP) $(CPP_PROJ) $(SOURCE) # End Source File # End Target # End Project ################################################################################ Papyrus3/JpegDir/JpgLossy/Jlossy.dsp0000755000175000017500000001613407535143454014637 0ustar # Microsoft Developer Studio Project File - Name="Jpglossy" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=Jpglossy - Win32 Release !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "Jlossy.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "Jlossy.mak" CFG="Jpglossy - Win32 Release" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "Jpglossy - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "Jpglossy - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName ""$/osiris/Papyrus3/JpegDir/JpgLossy", JAHAAAAA" # PROP Scc_LocalPath "." CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "Jpglossy - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir ".\Release" # PROP BASE Intermediate_Dir ".\Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir ".\Release" # PROP Intermediate_Dir ".\Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /G3 /Zp1 /W3 /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "STRICT" /D "_WIN16_" /D "FILENAME83" /YX /c # ADD CPP /nologo /Zp1 /W3 /O2 /I "..\.." /I ".." /D "NDEBUG" /D "STRICT" /D "WIN32" /D "_WINDOWS" /YX /FD /c # ADD BASE RSC /l 0x40c # ADD RSC /l 0x40c BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ELSEIF "$(CFG)" == "Jpglossy - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir ".\Debug" # PROP BASE Intermediate_Dir ".\Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir ".\Debug" # PROP Intermediate_Dir ".\Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /Zp1 /W3 /Gm /Zi /Od /Gf /Gy /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "_WIN16_" /D "FILENAME83" /YX /Fd"PAPYRUS3.PDB" /c # ADD CPP /nologo /Zp1 /W3 /Gm /Zi /Od /I "..\.." /I ".." /D "_DEBUG" /D "STRICT" /D "WIN32" /D "_WINDOWS" /FR /YX /Fd".\PAPYRUS3.PDB" /FD /c # ADD BASE RSC /l 0x40c # ADD RSC /l 0x40c BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ENDIF # Begin Target # Name "Jpglossy - Win32 Release" # Name "Jpglossy - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90" # Begin Source File SOURCE=.\jcapimin.c # End Source File # Begin Source File SOURCE=.\jcapistd.c # End Source File # Begin Source File SOURCE=.\jccoefct.c # End Source File # Begin Source File SOURCE=.\jccolor.c # End Source File # Begin Source File SOURCE=.\jcdctmgr.c # End Source File # Begin Source File SOURCE=.\jchuff.c # End Source File # Begin Source File SOURCE=.\jcinit.c # End Source File # Begin Source File SOURCE=.\jcmainct.c # End Source File # Begin Source File SOURCE=.\jcmarker.c # End Source File # Begin Source File SOURCE=.\jcmaster.c # End Source File # Begin Source File SOURCE=.\jcomapi.c # End Source File # Begin Source File SOURCE=.\jcparam.c # End Source File # Begin Source File SOURCE=.\jcphuff.c # End Source File # Begin Source File SOURCE=.\jcprepct.c # End Source File # Begin Source File SOURCE=.\jcsample.c # End Source File # Begin Source File SOURCE=.\jctrans.c # End Source File # Begin Source File SOURCE=.\jdapimin.c # End Source File # Begin Source File SOURCE=.\jdapistd.c # End Source File # Begin Source File SOURCE=.\jdatadst.c # End Source File # Begin Source File SOURCE=.\jdatasrc.c # End Source File # Begin Source File SOURCE=.\jdcoefct.c # End Source File # Begin Source File SOURCE=.\jdcolor.c # End Source File # Begin Source File SOURCE=.\jddctmgr.c # End Source File # Begin Source File SOURCE=.\jdhuff.c # End Source File # Begin Source File SOURCE=.\jdinput.c # End Source File # Begin Source File SOURCE=.\jdmainct.c # End Source File # Begin Source File SOURCE=.\jdmarker.c # End Source File # Begin Source File SOURCE=.\jdmaster.c # End Source File # Begin Source File SOURCE=.\jdmerge.c # End Source File # Begin Source File SOURCE=.\jdphuff.c # End Source File # Begin Source File SOURCE=.\jdpostct.c # End Source File # Begin Source File SOURCE=.\jdsample.c # End Source File # Begin Source File SOURCE=.\jdtrans.c # End Source File # Begin Source File SOURCE=.\jerror.c # End Source File # Begin Source File SOURCE=.\jfdctflt.c # End Source File # Begin Source File SOURCE=.\jfdctfst.c # End Source File # Begin Source File SOURCE=.\jfdctint.c # End Source File # Begin Source File SOURCE=.\jidctflt.c # End Source File # Begin Source File SOURCE=.\jidctfst.c # End Source File # Begin Source File SOURCE=.\jidctint.c # End Source File # Begin Source File SOURCE=.\jidctred.c # End Source File # Begin Source File SOURCE=.\jmemmgr.c # End Source File # Begin Source File SOURCE=.\jmemnobs.c # End Source File # Begin Source File SOURCE=.\jquant1.c # End Source File # Begin Source File SOURCE=.\jquant2.c # End Source File # Begin Source File SOURCE=.\jutils.c # End Source File # Begin Source File SOURCE=.\rdbmp.c # End Source File # Begin Source File SOURCE=.\rdcolmap.c # End Source File # Begin Source File SOURCE=.\rdgif.c # End Source File # Begin Source File SOURCE=.\rdppm.c # End Source File # Begin Source File SOURCE=.\rdrle.c # End Source File # Begin Source File SOURCE=.\rdswitch.c # End Source File # Begin Source File SOURCE=.\rdtarga.c # End Source File # Begin Source File SOURCE=.\wrrle.c # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd" # Begin Source File SOURCE=.\cderror.h # End Source File # Begin Source File SOURCE=.\cdjpeg.h # End Source File # Begin Source File SOURCE=.\jchuff.h # End Source File # Begin Source File SOURCE=.\jconfig.h # End Source File # Begin Source File SOURCE=.\jdct.h # End Source File # Begin Source File SOURCE=.\jdhuff.h # End Source File # Begin Source File SOURCE=.\jerror.h # End Source File # Begin Source File SOURCE=.\jinclude.h # End Source File # Begin Source File SOURCE=.\jmemsys.h # End Source File # Begin Source File SOURCE=.\jmorecfg.h # End Source File # Begin Source File SOURCE=.\jpegint.h # End Source File # Begin Source File SOURCE=.\jpeglib.h # End Source File # Begin Source File SOURCE=.\jversion.h # End Source File # End Group # Begin Group "Resource Files" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe" # End Group # End Target # End Project Papyrus3/JpegDir/JpgLossy/jconfig.doc0000755000175000017500000001262707535143454014755 0ustar /* * jconfig.doc * * Copyright (C) 1991-1994, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file documents the configuration options that are required to * customize the JPEG software for a particular system. * * The actual configuration options for a particular installation are stored * in jconfig.h. On many machines, jconfig.h can be generated automatically * or copied from one of the "canned" jconfig files that we supply. But if * you need to generate a jconfig.h file by hand, this file tells you how. * * DO NOT EDIT THIS FILE --- IT WON'T ACCOMPLISH ANYTHING. * EDIT A COPY NAMED JCONFIG.H. */ /* * These symbols indicate the properties of your machine or compiler. * #define the symbol if yes, #undef it if no. */ /* Does your compiler support function prototypes? * (If not, you also need to use ansi2knr, see install.doc) */ #define HAVE_PROTOTYPES /* Does your compiler support the declaration "unsigned char" ? * How about "unsigned short" ? */ #define HAVE_UNSIGNED_CHAR #define HAVE_UNSIGNED_SHORT /* Define "void" as "char" if your compiler doesn't know about type void. * NOTE: be sure to define void such that "void *" represents the most general * pointer type, e.g., that returned by malloc(). */ /* #define void char */ /* Define "const" as empty if your compiler doesn't know the "const" keyword. */ /* #define const */ /* Define this if an ordinary "char" type is unsigned. * If you're not sure, leaving it undefined will work at some cost in speed. * If you defined HAVE_UNSIGNED_CHAR then the speed difference is minimal. */ #undef CHAR_IS_UNSIGNED /* Define this if your system has an ANSI-conforming file. */ #define HAVE_STDDEF_H /* Define this if your system has an ANSI-conforming file. */ #define HAVE_STDLIB_H /* Define this if your system does not have an ANSI/SysV , * but does have a BSD-style . */ #undef NEED_BSD_STRINGS /* Define this if your system does not provide typedef size_t in any of the * ANSI-standard places (stddef.h, stdlib.h, or stdio.h), but places it in * instead. */ #undef NEED_SYS_TYPES_H /* For 80x86 machines, you need to define NEED_FAR_POINTERS, * unless you are using a large-data memory model or 80386 flat-memory mode. * On less brain-damaged CPUs this symbol must not be defined. * (Defining this symbol causes large data structures to be referenced through * "far" pointers and to be allocated with a special version of malloc.) */ #undef NEED_FAR_POINTERS /* Define this if your linker needs global names to be unique in less * than the first 15 characters. */ #undef NEED_SHORT_EXTERNAL_NAMES /* Although a real ANSI C compiler can deal perfectly well with pointers to * unspecified structures (see "incomplete types" in the spec), a few pre-ANSI * and pseudo-ANSI compilers get confused. To keep one of these bozos happy, * define INCOMPLETE_TYPES_BROKEN. This is not recommended unless you * actually get "missing structure definition" warnings or errors while * compiling the JPEG code. */ #undef INCOMPLETE_TYPES_BROKEN /* * The following options affect code selection within the JPEG library, * but they don't need to be visible to applications using the library. * To minimize application namespace pollution, the symbols won't be * defined unless JPEG_INTERNALS has been defined. */ #ifdef JPEG_INTERNALS /* Define this if your compiler implements ">>" on signed values as a logical * (unsigned) shift; leave it undefined if ">>" is a signed (arithmetic) shift, * which is the normal and rational definition. */ #undef RIGHT_SHIFT_IS_UNSIGNED #endif /* JPEG_INTERNALS */ /* * The remaining options do not affect the JPEG library proper, * but only the sample applications cjpeg/djpeg (see cjpeg.c, djpeg.c). * Other applications can ignore these. */ #ifdef JPEG_CJPEG_DJPEG /* These defines indicate which image (non-JPEG) file formats are allowed. */ #define BMP_SUPPORTED /* BMP image file format */ #define GIF_SUPPORTED /* GIF image file format */ #define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ #undef RLE_SUPPORTED /* Utah RLE image file format */ #define TARGA_SUPPORTED /* Targa image file format */ /* Define this if you want to name both input and output files on the command * line, rather than using stdout and optionally stdin. You MUST do this if * your system can't cope with binary I/O to stdin/stdout. See comments at * head of cjpeg.c or djpeg.c. */ #undef TWO_FILE_COMMANDLINE /* Define this if your system needs explicit cleanup of temporary files. * This is crucial under MS-DOS, where the temporary "files" may be areas * of extended memory; on most other systems it's not as important. */ #undef NEED_SIGNAL_CATCHER /* By default, we open image files with fopen(...,"rb") or fopen(...,"wb"). * This is necessary on systems that distinguish text files from binary files, * and is harmless on most systems that don't. If you have one of the rare * systems that complains about the "b" spec, define this symbol. */ #undef DONT_USE_B_MODE /* Define this if you want percent-done progress reports from cjpeg/djpeg. */ #undef PROGRESS_REPORT #endif /* JPEG_CJPEG_DJPEG */ Papyrus3/JpegDir/JpgLossy/JDCT.H0000755000175000017500000001606107535143454013500 0ustar /* * jdct.h * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This include file contains common declarations for the forward and * inverse DCT modules. These declarations are private to the DCT managers * (jcdctmgr.c, jddctmgr.c) and the individual DCT algorithms. * The individual DCT algorithms are kept in separate files to ease * machine-dependent tuning (e.g., assembly coding). */ /* * A forward DCT routine is given a pointer to a work area of type DCTELEM[]; * the DCT is to be performed in-place in that buffer. Type DCTELEM is int * for 8-bit samples, INT32 for 12-bit samples. (NOTE: Floating-point DCT * implementations use an array of type FAST_FLOAT, instead.) * The DCT inputs are expected to be signed (range +-CENTERJSAMPLE). * The DCT outputs are returned scaled up by a factor of 8; they therefore * have a range of +-8K for 8-bit data, +-128K for 12-bit data. This * convention improves accuracy in integer implementations and saves some * work in floating-point ones. * Quantization of the output coefficients is done by jcdctmgr.c. */ #if BITS_IN_JSAMPLE == 8 typedef int DCTELEM; /* 16 or 32 bits is fine */ #else typedef INT32 DCTELEM; /* must have 32 bits */ #endif typedef JMETHOD(void, forward_DCT_method_ptr, (DCTELEM * data)); typedef JMETHOD(void, float_DCT_method_ptr, (FAST_FLOAT * data)); /* * An inverse DCT routine is given a pointer to the input JBLOCK and a pointer * to an output sample array. The routine must dequantize the input data as * well as perform the IDCT; for dequantization, it uses the multiplier table * pointed to by compptr->dct_table. The output data is to be placed into the * sample array starting at a specified column. (Any row offset needed will * be applied to the array pointer before it is passed to the IDCT code.) * Note that the number of samples emitted by the IDCT routine is * DCT_scaled_size * DCT_scaled_size. */ /* typedef inverse_DCT_method_ptr is declared in jpegint.h */ /* * Each IDCT routine has its own ideas about the best dct_table element type. */ typedef MULTIPLIER ISLOW_MULT_TYPE; /* short or int, whichever is faster */ #if BITS_IN_JSAMPLE == 8 typedef MULTIPLIER IFAST_MULT_TYPE; /* 16 bits is OK, use short if faster */ #define IFAST_SCALE_BITS 2 /* fractional bits in scale factors */ #else typedef INT32 IFAST_MULT_TYPE; /* need 32 bits for scaled quantizers */ #define IFAST_SCALE_BITS 13 /* fractional bits in scale factors */ #endif typedef FAST_FLOAT FLOAT_MULT_TYPE; /* preferred floating type */ /* * Each IDCT routine is responsible for range-limiting its results and * converting them to unsigned form (0..MAXJSAMPLE). The raw outputs could * be quite far out of range if the input data is corrupt, so a bulletproof * range-limiting step is required. We use a mask-and-table-lookup method * to do the combined operations quickly. See the comments with * prepare_range_limit_table (in jdmaster.c) for more info. */ #define IDCT_range_limit(cinfo) ((cinfo)->sample_range_limit + CENTERJSAMPLE) #define RANGE_MASK (MAXJSAMPLE * 4 + 3) /* 2 bits wider than legal samples */ /* Short forms of external names for systems with brain-damaged linkers. */ #ifdef NEED_SHORT_EXTERNAL_NAMES #define jpeg_fdct_islow jFDislow #define jpeg_fdct_ifast jFDifast #define jpeg_fdct_float jFDfloat #define jpeg_idct_islow jRDislow #define jpeg_idct_ifast jRDifast #define jpeg_idct_float jRDfloat #define jpeg_idct_4x4 jRD4x4 #define jpeg_idct_2x2 jRD2x2 #define jpeg_idct_1x1 jRD1x1 #endif /* NEED_SHORT_EXTERNAL_NAMES */ /* Extern declarations for the forward and inverse DCT routines. */ EXTERN(void) jpeg_fdct_islow JPP((DCTELEM * data)); EXTERN(void) jpeg_fdct_ifast JPP((DCTELEM * data)); EXTERN(void) jpeg_fdct_float JPP((FAST_FLOAT * data)); EXTERN(void) jpeg_idct_islow JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); EXTERN(void) jpeg_idct_ifast JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); EXTERN(void) jpeg_idct_float JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); EXTERN(void) jpeg_idct_4x4 JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); EXTERN(void) jpeg_idct_2x2 JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); EXTERN(void) jpeg_idct_1x1 JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col)); /* * Macros for handling fixed-point arithmetic; these are used by many * but not all of the DCT/IDCT modules. * * All values are expected to be of type INT32. * Fractional constants are scaled left by CONST_BITS bits. * CONST_BITS is defined within each module using these macros, * and may differ from one module to the next. */ #define ONE ((INT32) 1) #define CONST_SCALE (ONE << CONST_BITS) /* Convert a positive real constant to an integer scaled by CONST_SCALE. * Caution: some C compilers fail to reduce "FIX(constant)" at compile time, * thus causing a lot of useless floating-point operations at run time. */ #define FIX(x) ((INT32) ((x) * CONST_SCALE + 0.5)) /* Descale and correctly round an INT32 value that's scaled by N bits. * We assume RIGHT_SHIFT rounds towards minus infinity, so adding * the fudge factor is correct for either sign of X. */ #define DESCALE(x,n) RIGHT_SHIFT((x) + (ONE << ((n)-1)), n) /* Multiply an INT32 variable by an INT32 constant to yield an INT32 result. * This macro is used only when the two inputs will actually be no more than * 16 bits wide, so that a 16x16->32 bit multiply can be used instead of a * full 32x32 multiply. This provides a useful speedup on many machines. * Unfortunately there is no way to specify a 16x16->32 multiply portably * in C, but some C compilers will do the right thing if you provide the * correct combination of casts. */ #ifdef SHORTxSHORT_32 /* may work if 'int' is 32 bits */ #define MULTIPLY16C16(var,const) (((INT16) (var)) * ((INT16) (const))) #endif #ifdef SHORTxLCONST_32 /* known to work with Microsoft C 6.0 */ #define MULTIPLY16C16(var,const) (((INT16) (var)) * ((INT32) (const))) #endif #ifndef MULTIPLY16C16 /* default definition */ #define MULTIPLY16C16(var,const) ((var) * (const)) #endif /* Same except both inputs are variables. */ #ifdef SHORTxSHORT_32 /* may work if 'int' is 32 bits */ #define MULTIPLY16V16(var1,var2) (((INT16) (var1)) * ((INT16) (var2))) #endif #ifndef MULTIPLY16V16 /* default definition */ #define MULTIPLY16V16(var1,var2) ((var1) * (var2)) #endif Papyrus3/JpegDir/JpgLossy/jmemmgr.c0000755000175000017500000012217207535143454014446 0ustar /* * jmemmgr.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains the JPEG system-independent memory management * routines. This code is usable across a wide variety of machines; most * of the system dependencies have been isolated in a separate file. * The major functions provided here are: * * pool-based allocation and freeing of memory; * * policy decisions about how to divide available memory among the * virtual arrays; * * control logic for swapping virtual arrays between main memory and * backing storage. * The separate system-dependent file provides the actual backing-storage * access code, and it contains the policy decision about how much total * main memory to use. * This file is system-dependent in the sense that some of its functions * are unnecessary in some systems. For example, if there is enough virtual * memory so that backing storage will never be used, much of the virtual * array control logic could be removed. (Of course, if you have that much * memory then you shouldn't care about a little bit of unused code...) */ #define JPEG_INTERNALS #define AM_MEMORY_MANAGER /* we define jvirt_Xarray_control structs */ #include "jinclude.h" #include "jpeglib.h" #include "jmemsys.h" /* import the system-dependent declarations */ #ifndef NO_GETENV #ifndef HAVE_STDLIB_H /* should declare getenv() */ extern char * getenv JPP((const char * name)); #endif #endif /* * Some important notes: * The allocation routines provided here must never return NULL. * They should exit to error_exit if unsuccessful. * * It's not a good idea to try to merge the sarray and barray routines, * even though they are textually almost the same, because samples are * usually stored as bytes while coefficients are shorts or ints. Thus, * in machines where byte pointers have a different representation from * word pointers, the resulting machine code could not be the same. */ /* * Many machines require storage alignment: longs must start on 4-byte * boundaries, doubles on 8-byte boundaries, etc. On such machines, malloc() * always returns pointers that are multiples of the worst-case alignment * requirement, and we had better do so too. * There isn't any really portable way to determine the worst-case alignment * requirement. This module assumes that the alignment requirement is * multiples of sizeof(ALIGN_TYPE). * By default, we define ALIGN_TYPE as double. This is necessary on some * workstations (where doubles really do need 8-byte alignment) and will work * fine on nearly everything. If your machine has lesser alignment needs, * you can save a few bytes by making ALIGN_TYPE smaller. * The only place I know of where this will NOT work is certain Macintosh * 680x0 compilers that define double as a 10-byte IEEE extended float. * Doing 10-byte alignment is counterproductive because longwords won't be * aligned well. Put "#define ALIGN_TYPE long" in jconfig.h if you have * such a compiler. */ #ifndef ALIGN_TYPE /* so can override from jconfig.h */ #define ALIGN_TYPE double #endif /* * We allocate objects from "pools", where each pool is gotten with a single * request to jpeg_get_small() or jpeg_get_large(). There is no per-object * overhead within a pool, except for alignment padding. Each pool has a * header with a link to the next pool of the same class. * Small and large pool headers are identical except that the latter's * link pointer must be FAR on 80x86 machines. * Notice that the "real" header fields are union'ed with a dummy ALIGN_TYPE * field. This forces the compiler to make SIZEOF(small_pool_hdr) a multiple * of the alignment requirement of ALIGN_TYPE. */ typedef union small_pool_struct * small_pool_ptr; typedef union small_pool_struct { struct { small_pool_ptr next; /* next in list of pools */ size_t bytes_used; /* how many bytes already used within pool */ size_t bytes_left; /* bytes still available in this pool */ } hdr; ALIGN_TYPE dummy; /* included in union to ensure alignment */ } small_pool_hdr; typedef union large_pool_struct FAR * large_pool_ptr; typedef union large_pool_struct { struct { large_pool_ptr next; /* next in list of pools */ size_t bytes_used; /* how many bytes already used within pool */ size_t bytes_left; /* bytes still available in this pool */ } hdr; ALIGN_TYPE dummy; /* included in union to ensure alignment */ } large_pool_hdr; /* * Here is the full definition of a memory manager object. */ typedef struct { struct jpeg_memory_mgr pub; /* public fields */ /* Each pool identifier (lifetime class) names a linked list of pools. */ small_pool_ptr small_list[JPOOL_NUMPOOLS]; large_pool_ptr large_list[JPOOL_NUMPOOLS]; /* Since we only have one lifetime class of virtual arrays, only one * linked list is necessary (for each datatype). Note that the virtual * array control blocks being linked together are actually stored somewhere * in the small-pool list. */ jvirt_sarray_ptr virt_sarray_list; jvirt_barray_ptr virt_barray_list; /* This counts total space obtained from jpeg_get_small/large */ long total_space_allocated; /* alloc_sarray and alloc_barray set this value for use by virtual * array routines. */ JDIMENSION last_rowsperchunk; /* from most recent alloc_sarray/barray */ } my_memory_mgr; typedef my_memory_mgr * my_mem_ptr; /* * The control blocks for virtual arrays. * Note that these blocks are allocated in the "small" pool area. * System-dependent info for the associated backing store (if any) is hidden * inside the backing_store_info struct. */ struct jvirt_sarray_control { JSAMPARRAY mem_buffer; /* => the in-memory buffer */ JDIMENSION rows_in_array; /* total virtual array height */ JDIMENSION samplesperrow; /* width of array (and of memory buffer) */ JDIMENSION maxaccess; /* max rows accessed by access_virt_sarray */ JDIMENSION rows_in_mem; /* height of memory buffer */ JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */ JDIMENSION cur_start_row; /* first logical row # in the buffer */ JDIMENSION first_undef_row; /* row # of first uninitialized row */ boolean pre_zero; /* pre-zero mode requested? */ boolean dirty; /* do current buffer contents need written? */ boolean b_s_open; /* is backing-store data valid? */ jvirt_sarray_ptr next; /* link to next virtual sarray control block */ backing_store_info b_s_info; /* System-dependent control info */ }; struct jvirt_barray_control { JBLOCKARRAY mem_buffer; /* => the in-memory buffer */ JDIMENSION rows_in_array; /* total virtual array height */ JDIMENSION blocksperrow; /* width of array (and of memory buffer) */ JDIMENSION maxaccess; /* max rows accessed by access_virt_barray */ JDIMENSION rows_in_mem; /* height of memory buffer */ JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */ JDIMENSION cur_start_row; /* first logical row # in the buffer */ JDIMENSION first_undef_row; /* row # of first uninitialized row */ boolean pre_zero; /* pre-zero mode requested? */ boolean dirty; /* do current buffer contents need written? */ boolean b_s_open; /* is backing-store data valid? */ jvirt_barray_ptr next; /* link to next virtual barray control block */ backing_store_info b_s_info; /* System-dependent control info */ }; #ifdef MEM_STATS /* optional extra stuff for statistics */ LOCAL(void) print_mem_stats (j_common_ptr cinfo, int pool_id) { my_mem_ptr mem = (my_mem_ptr) cinfo->mem; small_pool_ptr shdr_ptr; large_pool_ptr lhdr_ptr; /* Since this is only a debugging stub, we can cheat a little by using * fprintf directly rather than going through the trace message code. * This is helpful because message parm array can't handle longs. */ fprintf(stderr, "Freeing pool %d, total space = %ld\n", pool_id, mem->total_space_allocated); for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL; lhdr_ptr = lhdr_ptr->hdr.next) { fprintf(stderr, " Large chunk used %ld\n", (long) lhdr_ptr->hdr.bytes_used); } for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL; shdr_ptr = shdr_ptr->hdr.next) { fprintf(stderr, " Small chunk used %ld free %ld\n", (long) shdr_ptr->hdr.bytes_used, (long) shdr_ptr->hdr.bytes_left); } } #endif /* MEM_STATS */ LOCAL(void) out_of_memory (j_common_ptr cinfo, int which) /* Report an out-of-memory error and stop execution */ /* If we compiled MEM_STATS support, report alloc requests before dying */ { #ifdef MEM_STATS cinfo->err->trace_level = 2; /* force self_destruct to report stats */ #endif ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which); } /* * Allocation of "small" objects. * * For these, we use pooled storage. When a new pool must be created, * we try to get enough space for the current request plus a "slop" factor, * where the slop will be the amount of leftover space in the new pool. * The speed vs. space tradeoff is largely determined by the slop values. * A different slop value is provided for each pool class (lifetime), * and we also distinguish the first pool of a class from later ones. * NOTE: the values given work fairly well on both 16- and 32-bit-int * machines, but may be too small if longs are 64 bits or more. */ static const size_t first_pool_slop[JPOOL_NUMPOOLS] = { 1600, /* first PERMANENT pool */ 16000 /* first IMAGE pool */ }; static const size_t extra_pool_slop[JPOOL_NUMPOOLS] = { 0, /* additional PERMANENT pools */ 5000 /* additional IMAGE pools */ }; #define MIN_SLOP 50 /* greater than 0 to avoid futile looping */ METHODDEF(void *) alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject) /* Allocate a "small" object */ { my_mem_ptr mem = (my_mem_ptr) cinfo->mem; small_pool_ptr hdr_ptr, prev_hdr_ptr; char * data_ptr; size_t odd_bytes, min_request, slop; /* Check for unsatisfiable request (do now to ensure no overflow below) */ if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr))) out_of_memory(cinfo, 1); /* request exceeds malloc's ability */ /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */ odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE); if (odd_bytes > 0) sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes; /* See if space is available in any existing pool */ if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ prev_hdr_ptr = NULL; hdr_ptr = mem->small_list[pool_id]; while (hdr_ptr != NULL) { if (hdr_ptr->hdr.bytes_left >= sizeofobject) break; /* found pool with enough space */ prev_hdr_ptr = hdr_ptr; hdr_ptr = hdr_ptr->hdr.next; } /* Time to make a new pool? */ if (hdr_ptr == NULL) { /* min_request is what we need now, slop is what will be leftover */ min_request = sizeofobject + SIZEOF(small_pool_hdr); if (prev_hdr_ptr == NULL) /* first pool in class? */ slop = first_pool_slop[pool_id]; else slop = extra_pool_slop[pool_id]; /* Don't ask for more than MAX_ALLOC_CHUNK */ if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request)) slop = (size_t) (MAX_ALLOC_CHUNK-min_request); /* Try to get space, if fail reduce slop and try again */ for (;;) { hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop); if (hdr_ptr != NULL) break; slop /= 2; if (slop < MIN_SLOP) /* give up when it gets real small */ out_of_memory(cinfo, 2); /* jpeg_get_small failed */ } mem->total_space_allocated += min_request + slop; /* Success, initialize the new pool header and add to end of list */ hdr_ptr->hdr.next = NULL; hdr_ptr->hdr.bytes_used = 0; hdr_ptr->hdr.bytes_left = sizeofobject + slop; if (prev_hdr_ptr == NULL) /* first pool in class? */ mem->small_list[pool_id] = hdr_ptr; else prev_hdr_ptr->hdr.next = hdr_ptr; } /* OK, allocate the object from the current pool */ data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */ data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */ hdr_ptr->hdr.bytes_used += sizeofobject; hdr_ptr->hdr.bytes_left -= sizeofobject; return (void *) data_ptr; } /* * Allocation of "large" objects. * * The external semantics of these are the same as "small" objects, * except that FAR pointers are used on 80x86. However the pool * management heuristics are quite different. We assume that each * request is large enough that it may as well be passed directly to * jpeg_get_large; the pool management just links everything together * so that we can free it all on demand. * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY * structures. The routines that create these structures (see below) * deliberately bunch rows together to ensure a large request size. */ METHODDEF(void FAR *) alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject) /* Allocate a "large" object */ { my_mem_ptr mem = (my_mem_ptr) cinfo->mem; large_pool_ptr hdr_ptr; size_t odd_bytes; /* Check for unsatisfiable request (do now to ensure no overflow below) */ if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr))) out_of_memory(cinfo, 3); /* request exceeds malloc's ability */ /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */ odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE); if (odd_bytes > 0) sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes; /* Always make a new pool */ if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject + SIZEOF(large_pool_hdr)); if (hdr_ptr == NULL) out_of_memory(cinfo, 4); /* jpeg_get_large failed */ mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr); /* Success, initialize the new pool header and add to list */ hdr_ptr->hdr.next = mem->large_list[pool_id]; /* We maintain space counts in each pool header for statistical purposes, * even though they are not needed for allocation. */ hdr_ptr->hdr.bytes_used = sizeofobject; hdr_ptr->hdr.bytes_left = 0; mem->large_list[pool_id] = hdr_ptr; return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */ } /* * Creation of 2-D sample arrays. * The pointers are in near heap, the samples themselves in FAR heap. * * To minimize allocation overhead and to allow I/O of large contiguous * blocks, we allocate the sample rows in groups of as many rows as possible * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request. * NB: the virtual array control routines, later in this file, know about * this chunking of rows. The rowsperchunk value is left in the mem manager * object so that it can be saved away if this sarray is the workspace for * a virtual array. */ METHODDEF(JSAMPARRAY) alloc_sarray (j_common_ptr cinfo, int pool_id, JDIMENSION samplesperrow, JDIMENSION numrows) /* Allocate a 2-D sample array */ { my_mem_ptr mem = (my_mem_ptr) cinfo->mem; JSAMPARRAY result; JSAMPROW workspace; JDIMENSION rowsperchunk, currow, i; long ltemp; /* Calculate max # of rows allowed in one allocation chunk */ ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) / ((long) samplesperrow * SIZEOF(JSAMPLE)); if (ltemp <= 0) ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); if (ltemp < (long) numrows) rowsperchunk = (JDIMENSION) ltemp; else rowsperchunk = numrows; mem->last_rowsperchunk = rowsperchunk; /* Get space for row pointers (small object) */ result = (JSAMPARRAY) alloc_small(cinfo, pool_id, (size_t) (numrows * SIZEOF(JSAMPROW))); /* Get the rows themselves (large objects) */ currow = 0; while (currow < numrows) { rowsperchunk = MIN(rowsperchunk, numrows - currow); workspace = (JSAMPROW) alloc_large(cinfo, pool_id, (size_t) ((size_t) rowsperchunk * (size_t) samplesperrow * SIZEOF(JSAMPLE))); for (i = rowsperchunk; i > 0; i--) { result[currow++] = workspace; workspace += samplesperrow; } } return result; } /* * Creation of 2-D coefficient-block arrays. * This is essentially the same as the code for sample arrays, above. */ METHODDEF(JBLOCKARRAY) alloc_barray (j_common_ptr cinfo, int pool_id, JDIMENSION blocksperrow, JDIMENSION numrows) /* Allocate a 2-D coefficient-block array */ { my_mem_ptr mem = (my_mem_ptr) cinfo->mem; JBLOCKARRAY result; JBLOCKROW workspace; JDIMENSION rowsperchunk, currow, i; long ltemp; /* Calculate max # of rows allowed in one allocation chunk */ ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) / ((long) blocksperrow * SIZEOF(JBLOCK)); if (ltemp <= 0) ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); if (ltemp < (long) numrows) rowsperchunk = (JDIMENSION) ltemp; else rowsperchunk = numrows; mem->last_rowsperchunk = rowsperchunk; /* Get space for row pointers (small object) */ result = (JBLOCKARRAY) alloc_small(cinfo, pool_id, (size_t) (numrows * SIZEOF(JBLOCKROW))); /* Get the rows themselves (large objects) */ currow = 0; while (currow < numrows) { rowsperchunk = MIN(rowsperchunk, numrows - currow); workspace = (JBLOCKROW) alloc_large(cinfo, pool_id, (size_t) ((size_t) rowsperchunk * (size_t) blocksperrow * SIZEOF(JBLOCK))); for (i = rowsperchunk; i > 0; i--) { result[currow++] = workspace; workspace += blocksperrow; } } return result; } /* * About virtual array management: * * The above "normal" array routines are only used to allocate strip buffers * (as wide as the image, but just a few rows high). Full-image-sized buffers * are handled as "virtual" arrays. The array is still accessed a strip at a * time, but the memory manager must save the whole array for repeated * accesses. The intended implementation is that there is a strip buffer in * memory (as high as is possible given the desired memory limit), plus a * backing file that holds the rest of the array. * * The request_virt_array routines are told the total size of the image and * the maximum number of rows that will be accessed at once. The in-memory * buffer must be at least as large as the maxaccess value. * * The request routines create control blocks but not the in-memory buffers. * That is postponed until realize_virt_arrays is called. At that time the * total amount of space needed is known (approximately, anyway), so free * memory can be divided up fairly. * * The access_virt_array routines are responsible for making a specific strip * area accessible (after reading or writing the backing file, if necessary). * Note that the access routines are told whether the caller intends to modify * the accessed strip; during a read-only pass this saves having to rewrite * data to disk. The access routines are also responsible for pre-zeroing * any newly accessed rows, if pre-zeroing was requested. * * In current usage, the access requests are usually for nonoverlapping * strips; that is, successive access start_row numbers differ by exactly * num_rows = maxaccess. This means we can get good performance with simple * buffer dump/reload logic, by making the in-memory buffer be a multiple * of the access height; then there will never be accesses across bufferload * boundaries. The code will still work with overlapping access requests, * but it doesn't handle bufferload overlaps very efficiently. */ METHODDEF(jvirt_sarray_ptr) request_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero, JDIMENSION samplesperrow, JDIMENSION numrows, JDIMENSION maxaccess) /* Request a virtual 2-D sample array */ { my_mem_ptr mem = (my_mem_ptr) cinfo->mem; jvirt_sarray_ptr result; /* Only IMAGE-lifetime virtual arrays are currently supported */ if (pool_id != JPOOL_IMAGE) ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ /* get control block */ result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id, SIZEOF(struct jvirt_sarray_control)); result->mem_buffer = NULL; /* marks array not yet realized */ result->rows_in_array = numrows; result->samplesperrow = samplesperrow; result->maxaccess = maxaccess; result->pre_zero = pre_zero; result->b_s_open = FALSE; /* no associated backing-store object */ result->next = mem->virt_sarray_list; /* add to list of virtual arrays */ mem->virt_sarray_list = result; return result; } METHODDEF(jvirt_barray_ptr) request_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero, JDIMENSION blocksperrow, JDIMENSION numrows, JDIMENSION maxaccess) /* Request a virtual 2-D coefficient-block array */ { my_mem_ptr mem = (my_mem_ptr) cinfo->mem; jvirt_barray_ptr result; /* Only IMAGE-lifetime virtual arrays are currently supported */ if (pool_id != JPOOL_IMAGE) ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ /* get control block */ result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id, SIZEOF(struct jvirt_barray_control)); result->mem_buffer = NULL; /* marks array not yet realized */ result->rows_in_array = numrows; result->blocksperrow = blocksperrow; result->maxaccess = maxaccess; result->pre_zero = pre_zero; result->b_s_open = FALSE; /* no associated backing-store object */ result->next = mem->virt_barray_list; /* add to list of virtual arrays */ mem->virt_barray_list = result; return result; } METHODDEF(void) realize_virt_arrays (j_common_ptr cinfo) /* Allocate the in-memory buffers for any unrealized virtual arrays */ { my_mem_ptr mem = (my_mem_ptr) cinfo->mem; long space_per_minheight, maximum_space, avail_mem; long minheights, max_minheights; jvirt_sarray_ptr sptr; jvirt_barray_ptr bptr; /* Compute the minimum space needed (maxaccess rows in each buffer) * and the maximum space needed (full image height in each buffer). * These may be of use to the system-dependent jpeg_mem_available routine. */ space_per_minheight = 0; maximum_space = 0; for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { if (sptr->mem_buffer == NULL) { /* if not realized yet */ space_per_minheight += (long) sptr->maxaccess * (long) sptr->samplesperrow * SIZEOF(JSAMPLE); maximum_space += (long) sptr->rows_in_array * (long) sptr->samplesperrow * SIZEOF(JSAMPLE); } } for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { if (bptr->mem_buffer == NULL) { /* if not realized yet */ space_per_minheight += (long) bptr->maxaccess * (long) bptr->blocksperrow * SIZEOF(JBLOCK); maximum_space += (long) bptr->rows_in_array * (long) bptr->blocksperrow * SIZEOF(JBLOCK); } } if (space_per_minheight <= 0) return; /* no unrealized arrays, no work */ /* Determine amount of memory to actually use; this is system-dependent. */ avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space, mem->total_space_allocated); /* If the maximum space needed is available, make all the buffers full * height; otherwise parcel it out with the same number of minheights * in each buffer. */ if (avail_mem >= maximum_space) max_minheights = 1000000000L; else { max_minheights = avail_mem / space_per_minheight; /* If there doesn't seem to be enough space, try to get the minimum * anyway. This allows a "stub" implementation of jpeg_mem_available(). */ if (max_minheights <= 0) max_minheights = 1; } /* Allocate the in-memory buffers and initialize backing store as needed. */ for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { if (sptr->mem_buffer == NULL) { /* if not realized yet */ minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L; if (minheights <= max_minheights) { /* This buffer fits in memory */ sptr->rows_in_mem = sptr->rows_in_array; } else { /* It doesn't fit in memory, create backing store. */ sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess); jpeg_open_backing_store(cinfo, & sptr->b_s_info, (long) sptr->rows_in_array * (long) sptr->samplesperrow * (long) SIZEOF(JSAMPLE)); sptr->b_s_open = TRUE; } sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE, sptr->samplesperrow, sptr->rows_in_mem); sptr->rowsperchunk = mem->last_rowsperchunk; sptr->cur_start_row = 0; sptr->first_undef_row = 0; sptr->dirty = FALSE; } } for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { if (bptr->mem_buffer == NULL) { /* if not realized yet */ minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L; if (minheights <= max_minheights) { /* This buffer fits in memory */ bptr->rows_in_mem = bptr->rows_in_array; } else { /* It doesn't fit in memory, create backing store. */ bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess); jpeg_open_backing_store(cinfo, & bptr->b_s_info, (long) bptr->rows_in_array * (long) bptr->blocksperrow * (long) SIZEOF(JBLOCK)); bptr->b_s_open = TRUE; } bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE, bptr->blocksperrow, bptr->rows_in_mem); bptr->rowsperchunk = mem->last_rowsperchunk; bptr->cur_start_row = 0; bptr->first_undef_row = 0; bptr->dirty = FALSE; } } } LOCAL(void) do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing) /* Do backing store read or write of a virtual sample array */ { long bytesperrow, file_offset, byte_count, rows, thisrow, i; bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE); file_offset = ptr->cur_start_row * bytesperrow; /* Loop to read or write each allocation chunk in mem_buffer */ for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) { /* One chunk, but check for short chunk at end of buffer */ rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i); /* Transfer no more than is currently defined */ thisrow = (long) ptr->cur_start_row + i; rows = MIN(rows, (long) ptr->first_undef_row - thisrow); /* Transfer no more than fits in file */ rows = MIN(rows, (long) ptr->rows_in_array - thisrow); if (rows <= 0) /* this chunk might be past end of file! */ break; byte_count = rows * bytesperrow; if (writing) (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info, (void FAR *) ptr->mem_buffer[i], file_offset, byte_count); else (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info, (void FAR *) ptr->mem_buffer[i], file_offset, byte_count); file_offset += byte_count; } } LOCAL(void) do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing) /* Do backing store read or write of a virtual coefficient-block array */ { long bytesperrow, file_offset, byte_count, rows, thisrow, i; bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK); file_offset = ptr->cur_start_row * bytesperrow; /* Loop to read or write each allocation chunk in mem_buffer */ for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) { /* One chunk, but check for short chunk at end of buffer */ rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i); /* Transfer no more than is currently defined */ thisrow = (long) ptr->cur_start_row + i; rows = MIN(rows, (long) ptr->first_undef_row - thisrow); /* Transfer no more than fits in file */ rows = MIN(rows, (long) ptr->rows_in_array - thisrow); if (rows <= 0) /* this chunk might be past end of file! */ break; byte_count = rows * bytesperrow; if (writing) (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info, (void FAR *) ptr->mem_buffer[i], file_offset, byte_count); else (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info, (void FAR *) ptr->mem_buffer[i], file_offset, byte_count); file_offset += byte_count; } } METHODDEF(JSAMPARRAY) access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr, JDIMENSION start_row, JDIMENSION num_rows, boolean writable) /* Access the part of a virtual sample array starting at start_row */ /* and extending for num_rows rows. writable is true if */ /* caller intends to modify the accessed area. */ { JDIMENSION end_row = start_row + num_rows; JDIMENSION undef_row; /* debugging check */ if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess || ptr->mem_buffer == NULL) ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); /* Make the desired part of the virtual array accessible */ if (start_row < ptr->cur_start_row || end_row > ptr->cur_start_row+ptr->rows_in_mem) { if (! ptr->b_s_open) ERREXIT(cinfo, JERR_VIRTUAL_BUG); /* Flush old buffer contents if necessary */ if (ptr->dirty) { do_sarray_io(cinfo, ptr, TRUE); ptr->dirty = FALSE; } /* Decide what part of virtual array to access. * Algorithm: if target address > current window, assume forward scan, * load starting at target address. If target address < current window, * assume backward scan, load so that target area is top of window. * Note that when switching from forward write to forward read, will have * start_row = 0, so the limiting case applies and we load from 0 anyway. */ if (start_row > ptr->cur_start_row) { ptr->cur_start_row = start_row; } else { /* use long arithmetic here to avoid overflow & unsigned problems */ long ltemp; ltemp = (long) end_row - (long) ptr->rows_in_mem; if (ltemp < 0) ltemp = 0; /* don't fall off front end of file */ ptr->cur_start_row = (JDIMENSION) ltemp; } /* Read in the selected part of the array. * During the initial write pass, we will do no actual read * because the selected part is all undefined. */ do_sarray_io(cinfo, ptr, FALSE); } /* Ensure the accessed part of the array is defined; prezero if needed. * To improve locality of access, we only prezero the part of the array * that the caller is about to access, not the entire in-memory array. */ if (ptr->first_undef_row < end_row) { if (ptr->first_undef_row < start_row) { if (writable) /* writer skipped over a section of array */ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); undef_row = start_row; /* but reader is allowed to read ahead */ } else { undef_row = ptr->first_undef_row; } if (writable) ptr->first_undef_row = end_row; if (ptr->pre_zero) { size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE); undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */ end_row -= ptr->cur_start_row; while (undef_row < end_row) { jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow); undef_row++; } } else { if (! writable) /* reader looking at undefined data */ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); } } /* Flag the buffer dirty if caller will write in it */ if (writable) ptr->dirty = TRUE; /* Return address of proper part of the buffer */ return ptr->mem_buffer + (start_row - ptr->cur_start_row); } METHODDEF(JBLOCKARRAY) access_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr, JDIMENSION start_row, JDIMENSION num_rows, boolean writable) /* Access the part of a virtual block array starting at start_row */ /* and extending for num_rows rows. writable is true if */ /* caller intends to modify the accessed area. */ { JDIMENSION end_row = start_row + num_rows; JDIMENSION undef_row; /* debugging check */ if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess || ptr->mem_buffer == NULL) ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); /* Make the desired part of the virtual array accessible */ if (start_row < ptr->cur_start_row || end_row > ptr->cur_start_row+ptr->rows_in_mem) { if (! ptr->b_s_open) ERREXIT(cinfo, JERR_VIRTUAL_BUG); /* Flush old buffer contents if necessary */ if (ptr->dirty) { do_barray_io(cinfo, ptr, TRUE); ptr->dirty = FALSE; } /* Decide what part of virtual array to access. * Algorithm: if target address > current window, assume forward scan, * load starting at target address. If target address < current window, * assume backward scan, load so that target area is top of window. * Note that when switching from forward write to forward read, will have * start_row = 0, so the limiting case applies and we load from 0 anyway. */ if (start_row > ptr->cur_start_row) { ptr->cur_start_row = start_row; } else { /* use long arithmetic here to avoid overflow & unsigned problems */ long ltemp; ltemp = (long) end_row - (long) ptr->rows_in_mem; if (ltemp < 0) ltemp = 0; /* don't fall off front end of file */ ptr->cur_start_row = (JDIMENSION) ltemp; } /* Read in the selected part of the array. * During the initial write pass, we will do no actual read * because the selected part is all undefined. */ do_barray_io(cinfo, ptr, FALSE); } /* Ensure the accessed part of the array is defined; prezero if needed. * To improve locality of access, we only prezero the part of the array * that the caller is about to access, not the entire in-memory array. */ if (ptr->first_undef_row < end_row) { if (ptr->first_undef_row < start_row) { if (writable) /* writer skipped over a section of array */ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); undef_row = start_row; /* but reader is allowed to read ahead */ } else { undef_row = ptr->first_undef_row; } if (writable) ptr->first_undef_row = end_row; if (ptr->pre_zero) { size_t bytesperrow = (size_t) ptr->blocksperrow * SIZEOF(JBLOCK); undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */ end_row -= ptr->cur_start_row; while (undef_row < end_row) { jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow); undef_row++; } } else { if (! writable) /* reader looking at undefined data */ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS); } } /* Flag the buffer dirty if caller will write in it */ if (writable) ptr->dirty = TRUE; /* Return address of proper part of the buffer */ return ptr->mem_buffer + (start_row - ptr->cur_start_row); } /* * Release all objects belonging to a specified pool. */ METHODDEF(void) free_pool (j_common_ptr cinfo, int pool_id) { my_mem_ptr mem = (my_mem_ptr) cinfo->mem; small_pool_ptr shdr_ptr; large_pool_ptr lhdr_ptr; size_t space_freed; if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS) ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */ #ifdef MEM_STATS if (cinfo->err->trace_level > 1) print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */ #endif /* If freeing IMAGE pool, close any virtual arrays first */ if (pool_id == JPOOL_IMAGE) { jvirt_sarray_ptr sptr; jvirt_barray_ptr bptr; for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) { if (sptr->b_s_open) { /* there may be no backing store */ sptr->b_s_open = FALSE; /* prevent recursive close if error */ (*sptr->b_s_info.close_backing_store) (cinfo, & sptr->b_s_info); } } mem->virt_sarray_list = NULL; for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) { if (bptr->b_s_open) { /* there may be no backing store */ bptr->b_s_open = FALSE; /* prevent recursive close if error */ (*bptr->b_s_info.close_backing_store) (cinfo, & bptr->b_s_info); } } mem->virt_barray_list = NULL; } /* Release large objects */ lhdr_ptr = mem->large_list[pool_id]; mem->large_list[pool_id] = NULL; while (lhdr_ptr != NULL) { large_pool_ptr next_lhdr_ptr = lhdr_ptr->hdr.next; space_freed = lhdr_ptr->hdr.bytes_used + lhdr_ptr->hdr.bytes_left + SIZEOF(large_pool_hdr); jpeg_free_large(cinfo, (void FAR *) lhdr_ptr, space_freed); mem->total_space_allocated -= space_freed; lhdr_ptr = next_lhdr_ptr; } /* Release small objects */ shdr_ptr = mem->small_list[pool_id]; mem->small_list[pool_id] = NULL; while (shdr_ptr != NULL) { small_pool_ptr next_shdr_ptr = shdr_ptr->hdr.next; space_freed = shdr_ptr->hdr.bytes_used + shdr_ptr->hdr.bytes_left + SIZEOF(small_pool_hdr); jpeg_free_small(cinfo, (void *) shdr_ptr, space_freed); mem->total_space_allocated -= space_freed; shdr_ptr = next_shdr_ptr; } } /* * Close up shop entirely. * Note that this cannot be called unless cinfo->mem is non-NULL. */ METHODDEF(void) self_destruct (j_common_ptr cinfo) { int pool; /* Close all backing store, release all memory. * Releasing pools in reverse order might help avoid fragmentation * with some (brain-damaged) malloc libraries. */ for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) { free_pool(cinfo, pool); } /* Release the memory manager control block too. */ jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr)); cinfo->mem = NULL; /* ensures I will be called only once */ jpeg_mem_term(cinfo); /* system-dependent cleanup */ } /* * Memory manager initialization. * When this is called, only the error manager pointer is valid in cinfo! */ GLOBAL(void) jinit_memory_mgr (j_common_ptr cinfo) { my_mem_ptr mem; long max_to_use; int pool; size_t test_mac; cinfo->mem = NULL; /* for safety if init fails */ /* Check for configuration errors. * SIZEOF(ALIGN_TYPE) should be a power of 2; otherwise, it probably * doesn't reflect any real hardware alignment requirement. * The test is a little tricky: for X>0, X and X-1 have no one-bits * in common if and only if X is a power of 2, ie has only one one-bit. * Some compilers may give an "unreachable code" warning here; ignore it. */ if ((SIZEOF(ALIGN_TYPE) & (SIZEOF(ALIGN_TYPE)-1)) != 0) ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE); /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be * a multiple of SIZEOF(ALIGN_TYPE). * Again, an "unreachable code" warning may be ignored here. * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK. */ test_mac = (size_t) MAX_ALLOC_CHUNK; if ((long) test_mac != MAX_ALLOC_CHUNK || (MAX_ALLOC_CHUNK % SIZEOF(ALIGN_TYPE)) != 0) ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK); max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */ /* Attempt to allocate memory manager's control block */ mem = (my_mem_ptr) jpeg_get_small(cinfo, SIZEOF(my_memory_mgr)); if (mem == NULL) { jpeg_mem_term(cinfo); /* system-dependent cleanup */ ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0); } /* OK, fill in the method pointers */ mem->pub.alloc_small = alloc_small; mem->pub.alloc_large = alloc_large; mem->pub.alloc_sarray = alloc_sarray; mem->pub.alloc_barray = alloc_barray; mem->pub.request_virt_sarray = request_virt_sarray; mem->pub.request_virt_barray = request_virt_barray; mem->pub.realize_virt_arrays = realize_virt_arrays; mem->pub.access_virt_sarray = access_virt_sarray; mem->pub.access_virt_barray = access_virt_barray; mem->pub.free_pool = free_pool; mem->pub.self_destruct = self_destruct; /* Make MAX_ALLOC_CHUNK accessible to other modules */ mem->pub.max_alloc_chunk = MAX_ALLOC_CHUNK; /* Initialize working state */ mem->pub.max_memory_to_use = max_to_use; for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) { mem->small_list[pool] = NULL; mem->large_list[pool] = NULL; } mem->virt_sarray_list = NULL; mem->virt_barray_list = NULL; mem->total_space_allocated = SIZEOF(my_memory_mgr); /* Declare ourselves open for business */ cinfo->mem = & mem->pub; /* Check for an environment variable JPEGMEM; if found, override the * default max_memory setting from jpeg_mem_init. Note that the * surrounding application may again override this value. * If your system doesn't support getenv(), define NO_GETENV to disable * this feature. */ #ifndef NO_GETENV { char * memenv; if ((memenv = getenv("JPEGMEM")) != NULL) { char ch = 'x'; if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) { if (ch == 'm' || ch == 'M') max_to_use *= 1000L; mem->pub.max_memory_to_use = max_to_use * 1000L; } } } #endif } Papyrus3/JpegDir/JpgLossy/testimg.jpg0000755000175000017500000001317407535143454015023 0ustar ÿØÿàJFIFÿÛC    $.' ",#(7),01444'9=82<.342ÿÛC  2!!22222222222222222222222222222222222222222222222222ÿÀ•ã"ÿÄ ÿĵ}!1AQa"q2‘¡#B±ÁRÑð$3br‚ %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚáâãäåæçèéêñòóôõö÷øùúÿÄ ÿĵw!1AQaq"2B‘¡±Á #3RðbrÑ $4á%ñ&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz‚ƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚâãäåæçèéêòóôõö÷øùúÿÚ ?òåjvúf)4šc÷óFñQŠ3E‡qäÒñQîÅ8Ñ`¸ð©Ô°)ÊNiX ‰.J²j àS•ðjKF¤ù} iZÝ8f®|KÅ]µ˜õÏVŸSÓÀâ}ÛBI¸zÔs¸XɬønJ¼T·HÆ+•ÅÜúEN“]H‹TNÔÒüÔlÔÔO:u.…&€ÜÔEªX”±­ns¹Ø¹n½MVÕãqn0‡µ4ø î3[Z†YíÇ8«§zìËŒ(ªkvyƒQšÖÔ¬Z&<~5ŒÄ†Á®Äîx—¾Ââ•NÇ )›©wUº:Pf™#^Iâ¶uŘـFä×7áR§T]ݺW¥-Œz„‹¤mÅo…«J—2›"³•¯Ðó«-JK ,|ã¨õ­Kýeõ8•Z&äWS/„ôûYV@ªI=:Õ]jh,Ûb…â°«Rz{TÞ‡%°QP‹¥ÑY{y":•‘NFæ§PJ²QM¡4Æ„â´¶fšÑú 9¬U®fyfœ®”ÇQQ2ÑÍph„DOJ•!§ æ¬(À©”‡@ÑàT{jËš`šÐË$qNˆ4m‘]­•¥½¢ÉrždÎ7*@µ,I’Ý:pvÖ3­¡êÃ/«hÉ´¯ýjTžDáXþ.J¬>†¬ Y2Ài˽܌åG?7 Vk±Ý<¬•ÊLi„“Z‚Ú?qÕFøSb²†"ÛÍ=”®úúÒç‡so¨Wmi£êT:}ÂÚÅtɈe$+gÒ¥s… Ž÷`cÄ„c'Óü*K;e,LŠUPüÇßÐUFi«œxœ=JuU:j÷.鿹 »zšÚ—燥s’ËÈÈP8^x*Ï4M¶9\.{j©´ør5•ý§¿×MÝi«:¶GZâõ}íܲŽ+¸K©³‚ÿ˜¤“l¿ëcG…Em >‡:áªÐzM[æyq”ò(ÚÞ•é3h–›”Zª3‚œî+š¼Ð.¬gÁÌ?,Š2×ÒµUNL^YW¬µ^D~´žŸeÂã¥w¶÷­ÁÈ5WCðõÛÚù¯^+vßÃÎÊp_jÊPœõ±ãÕ‹nȬ×m)%JÅÖ¤ßnßJîÓÂF4ËäœWâ;µ•£ƒMSqW2örŽ¬ó© žcpzÑ[Ÿd=Óš*®Ž›Äæ†ä85f'©e·ªê…®÷®—BÐ"ÔmË8É5ÌDÄ]·ƒç 2Ž€Öø8ÆUm!TÒ7Fv¡àˈË #Ð×3y¥ÝÚHVH{’ÈŒ¼€kTÒâ½3^L ᚨúž8”áÞ¦+¬Ô¼39Ï–€ã¡¬ëMË–/aÞ¼ÌEdýç¡Õ‡¥R¼¹i+³ìó¸ÊFì=@«v¬\É*¨zÔ×]-Ä1[ì†cš¥sîðŽp8ÍrV­M+AÜõðÙMe.j–Ó¦åVv.ÌK’MIP§,A~ûà} J¥a}Íyíží7wdQRvô©6»÷cý*`ÅÜŸ§JD¹••r3ԇ؎ôœÕGQ`PäÅK„”nƒÝOô¨¶ •Çv¨³gsQTýÞ£TÀž9È«®òCóeêŒ:¨UTrIúU ªm£BÅ£™r÷[85pìrMJ.û2„®fqÚ¯[1Âù¸'Ö©be «“¦§œæ¡¹×v‚~•ËéWNXƒ“[—!´i@$²ôô¯bxÈÆ Ra‡ÁνNHîCq¬Éu*`nà‘Y»=ê5„A‚ŒÄyíO‘ÂÆH<×ÍW¯:Óæ‘÷8L-<-.D¬Öþd$<`ò7dý44‹!8~j¢3€FN ]H¢•ÌE€/Àn€ÕƒeS”¤¤ÑU¤,¬¤pNGµ:%Q‚y¢H^ Z) §øÆÕÎ2秵fÛ4¡ Êâìb =ýxÍD!lò@ÎG)åœ:/7|ǵT ÛØït!+s]È#`ÀúÒª; ç¶jûéñEl^bD@‡¿½P–uF)X{qCƒZœï’-ËšÈGܵ¿ýu4rHÆܯ?)=yÏŸýjU5Že?¼fù6ž@è?éQLJ>ÎN+[S$ÝäîMs5¼ãr£ÆßPßáTåV‰Ê°9úR#—/VcŠ·p×2;Ž¸À§æÌmítMié]u³¼Ð#©‰=ºW.ÐG”m?Zè|5 ’&„õ\ñW›"t§IÚF„q0”H\“Œgð¨âI'»Ìñ_Óü*åÃlŒ“Á5ÎÜ^]ó©³øÖëGsµé7:ÕªœÎ…½¯³–îTܯÝÅ^†ÝæY]›ÜÕÆ«Š> UŠG¦ÁâHžCŒm&¯I¨U‘mï^mÛ@Öž—4ò»Åæa=è…Ngf'¯+;_íëeàžG½çW2È—2/œ8>”Wo³‘¿4,ÛF(ÃS$àMrØÚäj¤æ´âÒdhùÆ{TöV+ÍÝqéZ /&œF?ZôðØ.ey˜N­žƒ´­<@ÙÁ$ÖÛÁr‘´‹jòF!zþ¶ôK;Kt . ÷­-CS´‚ݼ½¹£&£ìiÂ빦¬©ÏÚ'©ærÉÅü€Ûº”eÁ*§5¯w¨Å-áa‰7äô§M§Åv=›CÎÞâ¼Z”åϲÁãኇ+јv¼ÄSµÀÐûP2 V08 ÔÒA,,JŒ “žœsMšU¹e•Wc‘†àŸjÆVh覥N|¯aÄù‘.ârý½)в4€Iò¡$vã’¬^T^[øù× Bw)þíœTê™Û F7‘bk7È\º¸ØûÝ8ýiŠm–X$ä”U ®{OÏ¥>ÖýíãBê7©ùI2ÿ…jý¤›)™‹‘XäƒZÆ+tCÄJKs6âêâä*´3 Žþ”¿ØhÃ\HѾ8 Ô}i‘–EygAÉÉ95mu9 »)\7E4&·aR‚’Ô¦¶ðZ$bgg™: žæ£–<i0ÌG@h}§–ÉsÎhÁÝ“ÍC•ÉTyl…†üàÁî[=©‹HXõ4ç?!æ˜8"¦LèJ*K•Xq­? ¸´ÑžèHÿ?fš»¢š”·…Hˆ'Üñþ5Tþ#ly’±¯©Ü|Çö®SV˜ ¶Î2w¿ôþµ·s8‘Ë…’}+Ž½\]5Ú¹É<};WrGœVö8eIo/Èí¬[l ƒÀ`K¸õ¬ *û͵ žEiG/½sKGcàä¬Í5“椚å㈴RùmŽ¹¬™nJðµ“xn.›i‘‚ûP¿5Å©À¿{‡cªNzÑP =;‚h®Ï¬3[˜6×]2kwN•K=«›[WS‘Zveã­â⤛:.íc Wšî-AØ+ ³O³ ìkE¸_kbîâ5Ãâ½úiº|É™4î[7’tÕ[Û¦6æªí¨B±äšÇ¼½k‚U~írâqŒl·4„[*;°õ®‡J” VS´:ç•I5rÚçìÀ¯Þ`x ¯Ÿ­.¬÷r”åQÆÚ?ÀÛפ¶k6¹l¸ÏÿZ¹¥ŠžIG.ç,zšŒW ¥v}2¥ËdØ…¸È?CéNumªÇ£t"¡VÉdô«*cŠ,r›F÷ëúÑbyî›èEŸ—iù‡¡©ü×”Rvã¦y¨³m9úTè…NXò:iÝ•)ˆvÃZR3üGðÒã÷“7c\ÕÍõÝâ™'•˜ž§=kV{{{²²>ÏóÉË=eÞ\$¤¤J4àUMElµ>}Zä6Íþ‘ÔW}n€Û§Ò¼þÜâd'³ ôFn„zVxž„U%å€$Ò‹TÇYAJdX#27^³˴ŒÒ9ùé\©_VsîS–iŒ¬L‡9¢¢•ÿzßZ+¢Ã±¢–Šê=…-œhbÊÂ{ùÄ0!b}ºWR>ÜObDˆê+áÜV¢Beû’;ף𹕫‚KS>{³æ SNÔü?3ÀÆDˆ¶xèjŠëQv0÷\*úÄÞµÕ,dó"JðWE{]RKX”¾ËX$›³FðÄU§ðI¤[°½]AŠ¨Û&2S?ʯÊŽEvÞð4v‹äÈR9'µtZÿ€íµ3X¶¹ÇÝþ>þŸ…EJb{X<Ù+F·ÞyFqM'šµ©é÷zUÓ[Þ@ÑJ;„zƒÜUñÍr´{°­«Å”ï£ãxãÖ³ÏZÔ¼#ËÁêk-ºÖ½/’©t4šJCA V‰mˆN) c14ÜÕXÉÌVjHÛ§ÔPAa€>”Co#ÌÓµH,};äo.ɪ—Œ0äWÇ@yæ³®õ6“)U:g¹¬òùêrkEç"¿?»‹ïª4Î|ÌàÕg]¹eèj¹ Ô‘ÈÚÝ*¹RØãÛ`Fâ»ÍO6ÑI<\¡·/Ý®ËI¸K]9?;e^<ËBj|%ë«Ÿ:bùWL/òⳄüçÖ¬4»b.OA\ü¦63ç—÷ÏÏz+ãS&áñëEtûW#:š(ÒÕ€+SD‚µ(Ro»ž•˜+SFçS€c9j¨üH™»#Üô› k;(ü˜Ð¹$ ±u9‹FMG¥)[ÁâŸxBÆ[p«¨ìJØ¥{;=£¨à‘\e§‚šçT{×rwºXî>Õqå3w­ø XP¬áûÌ»+j2ÎÑmmÖ0: ³E©&v­£XëV†Þú‘?„ÿŸP{W’ø—Á7Ú´Ðoº²=$æO÷€þ}+ÚN´„Sžõ•ZJ~§VRƒ÷^™®A(:u¬ç×¼ëô½P<¶¹²¸nrƒ(Oºÿ†+‚Ô~k°¹6¯kr½¶¾Óùñ®uNPѣЩ§W]™ç¤f˜ÊzV¶³¡j:é£oä»Ê7«d~³0Æ«C'Uw!"€¿—½JWµ:x!6Hí'ï zS1ž"+`XHPØàô­E•-4K™v/ÔñYÏ*Ì ௭[ÕòñÇ \Å'Üз9gVSG>sM5`§µ&À{VælÒn欘…FÐÕ@ )E\[¹ h£î/jÎ*ÊyÍI¦6ÏoJN7È®–P0pjΧ?•¦’$V0€’#ƒRÝNÓZ…aÒ²QW"ÈÃ9É⊜¨ÏJ+£˜³µˆfžTE΋€Óé[mº’>*x¢ŠÒMp³˜=â±5MFo™FéEUÜpGÓÒY|ç‘‹k¨^€QE\>æ:š(¡’€æ«Üïó#ÚåFy½R–ÃŽåžÔŒxÍQ?…’·fdct; int ci, qtblno, i; jpeg_component_info *compptr; JQUANT_TBL * qtbl; DCTELEM * dtbl; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { qtblno = compptr->quant_tbl_no; /* Make sure specified quantization table is present */ if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS || cinfo->quant_tbl_ptrs[qtblno] == NULL) ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno); qtbl = cinfo->quant_tbl_ptrs[qtblno]; /* Compute divisors for this quant table */ /* We may do this more than once for same table, but it's not a big deal */ switch (cinfo->dct_method) { #ifdef DCT_ISLOW_SUPPORTED case JDCT_ISLOW: /* For LL&M IDCT method, divisors are equal to raw quantization * coefficients multiplied by 8 (to counteract scaling). */ if (fdct->divisors[qtblno] == NULL) { fdct->divisors[qtblno] = (DCTELEM *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, DCTSIZE2 * SIZEOF(DCTELEM)); } dtbl = fdct->divisors[qtblno]; for (i = 0; i < DCTSIZE2; i++) { dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3; } break; #endif #ifdef DCT_IFAST_SUPPORTED case JDCT_IFAST: { /* For AA&N IDCT method, divisors are equal to quantization * coefficients scaled by scalefactor[row]*scalefactor[col], where * scalefactor[0] = 1 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7 * We apply a further scale factor of 8. */ #define CONST_BITS 14 static const INT16 aanscales[DCTSIZE2] = { /* precomputed values scaled up by 14 bits */ 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270, 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906, 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315, 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552, 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446, 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247 }; SHIFT_TEMPS if (fdct->divisors[qtblno] == NULL) { fdct->divisors[qtblno] = (DCTELEM *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, DCTSIZE2 * SIZEOF(DCTELEM)); } dtbl = fdct->divisors[qtblno]; for (i = 0; i < DCTSIZE2; i++) { dtbl[i] = (DCTELEM) DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i], (INT32) aanscales[i]), CONST_BITS-3); } } break; #endif #ifdef DCT_FLOAT_SUPPORTED case JDCT_FLOAT: { /* For float AA&N IDCT method, divisors are equal to quantization * coefficients scaled by scalefactor[row]*scalefactor[col], where * scalefactor[0] = 1 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7 * We apply a further scale factor of 8. * What's actually stored is 1/divisor so that the inner loop can * use a multiplication rather than a division. */ FAST_FLOAT * fdtbl; int row, col; static const double aanscalefactor[DCTSIZE] = { 1.0, 1.387039845, 1.306562965, 1.175875602, 1.0, 0.785694958, 0.541196100, 0.275899379 }; if (fdct->float_divisors[qtblno] == NULL) { fdct->float_divisors[qtblno] = (FAST_FLOAT *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, DCTSIZE2 * SIZEOF(FAST_FLOAT)); } fdtbl = fdct->float_divisors[qtblno]; i = 0; for (row = 0; row < DCTSIZE; row++) { for (col = 0; col < DCTSIZE; col++) { fdtbl[i] = (FAST_FLOAT) (1.0 / (((double) qtbl->quantval[i] * aanscalefactor[row] * aanscalefactor[col] * 8.0))); i++; } } } break; #endif default: ERREXIT(cinfo, JERR_NOT_COMPILED); break; } } } /* * Perform forward DCT on one or more blocks of a component. * * The input samples are taken from the sample_data[] array starting at * position start_row/start_col, and moving to the right for any additional * blocks. The quantized coefficients are returned in coef_blocks[]. */ METHODDEF(void) forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY sample_data, JBLOCKROW coef_blocks, JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks) /* This version is used for integer DCT implementations. */ { /* This routine is heavily used, so it's worth coding it tightly. */ my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct; forward_DCT_method_ptr do_dct = fdct->do_dct; DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no]; DCTELEM workspace[DCTSIZE2]; /* work area for FDCT subroutine */ JDIMENSION bi; sample_data += start_row; /* fold in the vertical offset once */ for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) { /* Load data into workspace, applying unsigned->signed conversion */ { register DCTELEM *workspaceptr; register JSAMPROW elemptr; register int elemr; workspaceptr = workspace; for (elemr = 0; elemr < DCTSIZE; elemr++) { elemptr = sample_data[elemr] + start_col; #if DCTSIZE == 8 /* unroll the inner loop */ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; #else { register int elemc; for (elemc = DCTSIZE; elemc > 0; elemc--) { *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE; } } #endif } } /* Perform the DCT */ (*do_dct) (workspace); /* Quantize/descale the coefficients, and store into coef_blocks[] */ { register DCTELEM temp, qval; register int i; register JCOEFPTR output_ptr = coef_blocks[bi]; for (i = 0; i < DCTSIZE2; i++) { qval = divisors[i]; temp = workspace[i]; /* Divide the coefficient value by qval, ensuring proper rounding. * Since C does not specify the direction of rounding for negative * quotients, we have to force the dividend positive for portability. * * In most files, at least half of the output values will be zero * (at default quantization settings, more like three-quarters...) * so we should ensure that this case is fast. On many machines, * a comparison is enough cheaper than a divide to make a special test * a win. Since both inputs will be nonnegative, we need only test * for a < b to discover whether a/b is 0. * If your machine's division is fast enough, define FAST_DIVIDE. */ #ifdef FAST_DIVIDE #define DIVIDE_BY(a,b) a /= b #else #define DIVIDE_BY(a,b) if (a >= b) a /= b; else a = 0 #endif if (temp < 0) { temp = -temp; temp += qval>>1; /* for rounding */ DIVIDE_BY(temp, qval); temp = -temp; } else { temp += qval>>1; /* for rounding */ DIVIDE_BY(temp, qval); } output_ptr[i] = (JCOEF) temp; } } } } #ifdef DCT_FLOAT_SUPPORTED METHODDEF(void) forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY sample_data, JBLOCKROW coef_blocks, JDIMENSION start_row, JDIMENSION start_col, JDIMENSION num_blocks) /* This version is used for floating-point DCT implementations. */ { /* This routine is heavily used, so it's worth coding it tightly. */ my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct; float_DCT_method_ptr do_dct = fdct->do_float_dct; FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no]; FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */ JDIMENSION bi; sample_data += start_row; /* fold in the vertical offset once */ for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) { /* Load data into workspace, applying unsigned->signed conversion */ { register FAST_FLOAT *workspaceptr; register JSAMPROW elemptr; register int elemr; workspaceptr = workspace; for (elemr = 0; elemr < DCTSIZE; elemr++) { elemptr = sample_data[elemr] + start_col; #if DCTSIZE == 8 /* unroll the inner loop */ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); #else { register int elemc; for (elemc = DCTSIZE; elemc > 0; elemc--) { *workspaceptr++ = (FAST_FLOAT) (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE); } } #endif } } /* Perform the DCT */ (*do_dct) (workspace); /* Quantize/descale the coefficients, and store into coef_blocks[] */ { register FAST_FLOAT temp; register int i; register JCOEFPTR output_ptr = coef_blocks[bi]; for (i = 0; i < DCTSIZE2; i++) { /* Apply the quantization and scaling factor */ temp = workspace[i] * divisors[i]; /* Round to nearest integer. * Since C does not specify the direction of rounding for negative * quotients, we have to force the dividend positive for portability. * The maximum coefficient size is +-16K (for 12-bit data), so this * code should work for either 16-bit or 32-bit ints. */ output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384); } } } } #endif /* DCT_FLOAT_SUPPORTED */ /* * Initialize FDCT manager. */ GLOBAL(void) jinit_forward_dct (j_compress_ptr cinfo) { my_fdct_ptr fdct; int i; fdct = (my_fdct_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_fdct_controller)); cinfo->fdct = (struct jpeg_forward_dct *) fdct; fdct->pub.start_pass = start_pass_fdctmgr; switch (cinfo->dct_method) { #ifdef DCT_ISLOW_SUPPORTED case JDCT_ISLOW: fdct->pub.forward_DCT = forward_DCT; fdct->do_dct = jpeg_fdct_islow; break; #endif #ifdef DCT_IFAST_SUPPORTED case JDCT_IFAST: fdct->pub.forward_DCT = forward_DCT; fdct->do_dct = jpeg_fdct_ifast; break; #endif #ifdef DCT_FLOAT_SUPPORTED case JDCT_FLOAT: fdct->pub.forward_DCT = forward_DCT_float; fdct->do_float_dct = jpeg_fdct_float; break; #endif default: ERREXIT(cinfo, JERR_NOT_COMPILED); break; } /* Mark divisor tables unallocated */ for (i = 0; i < NUM_QUANT_TBLS; i++) { fdct->divisors[i] = NULL; #ifdef DCT_FLOAT_SUPPORTED fdct->float_divisors[i] = NULL; #endif } } Papyrus3/JpegDir/JpgLossy/JQUANT2.C0000755000175000017500000014111307535143454014030 0ustar /* * jquant2.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains 2-pass color quantization (color mapping) routines. * These routines provide selection of a custom color map for an image, * followed by mapping of the image to that color map, with optional * Floyd-Steinberg dithering. * It is also possible to use just the second pass to map to an arbitrary * externally-given color map. * * Note: ordered dithering is not supported, since there isn't any fast * way to compute intercolor distances; it's unclear that ordered dither's * fundamental assumptions even hold with an irregularly spaced color map. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #ifdef QUANT_2PASS_SUPPORTED /* * This module implements the well-known Heckbert paradigm for color * quantization. Most of the ideas used here can be traced back to * Heckbert's seminal paper * Heckbert, Paul. "Color Image Quantization for Frame Buffer Display", * Proc. SIGGRAPH '82, Computer Graphics v.16 #3 (July 1982), pp 297-304. * * In the first pass over the image, we accumulate a histogram showing the * usage count of each possible color. To keep the histogram to a reasonable * size, we reduce the precision of the input; typical practice is to retain * 5 or 6 bits per color, so that 8 or 4 different input values are counted * in the same histogram cell. * * Next, the color-selection step begins with a box representing the whole * color space, and repeatedly splits the "largest" remaining box until we * have as many boxes as desired colors. Then the mean color in each * remaining box becomes one of the possible output colors. * * The second pass over the image maps each input pixel to the closest output * color (optionally after applying a Floyd-Steinberg dithering correction). * This mapping is logically trivial, but making it go fast enough requires * considerable care. * * Heckbert-style quantizers vary a good deal in their policies for choosing * the "largest" box and deciding where to cut it. The particular policies * used here have proved out well in experimental comparisons, but better ones * may yet be found. * * In earlier versions of the IJG code, this module quantized in YCbCr color * space, processing the raw upsampled data without a color conversion step. * This allowed the color conversion math to be done only once per colormap * entry, not once per pixel. However, that optimization precluded other * useful optimizations (such as merging color conversion with upsampling) * and it also interfered with desired capabilities such as quantizing to an * externally-supplied colormap. We have therefore abandoned that approach. * The present code works in the post-conversion color space, typically RGB. * * To improve the visual quality of the results, we actually work in scaled * RGB space, giving G distances more weight than R, and R in turn more than * B. To do everything in integer math, we must use integer scale factors. * The 2/3/1 scale factors used here correspond loosely to the relative * weights of the colors in the NTSC grayscale equation. * If you want to use this code to quantize a non-RGB color space, you'll * probably need to change these scale factors. */ #define R_SCALE 2 /* scale R distances by this much */ #define G_SCALE 3 /* scale G distances by this much */ #define B_SCALE 1 /* and B by this much */ /* Relabel R/G/B as components 0/1/2, respecting the RGB ordering defined * in jmorecfg.h. As the code stands, it will do the right thing for R,G,B * and B,G,R orders. If you define some other weird order in jmorecfg.h, * you'll get compile errors until you extend this logic. In that case * you'll probably want to tweak the histogram sizes too. */ #if RGB_RED == 0 #define C0_SCALE R_SCALE #endif #if RGB_BLUE == 0 #define C0_SCALE B_SCALE #endif #if RGB_GREEN == 1 #define C1_SCALE G_SCALE #endif #if RGB_RED == 2 #define C2_SCALE R_SCALE #endif #if RGB_BLUE == 2 #define C2_SCALE B_SCALE #endif /* * First we have the histogram data structure and routines for creating it. * * The number of bits of precision can be adjusted by changing these symbols. * We recommend keeping 6 bits for G and 5 each for R and B. * If you have plenty of memory and cycles, 6 bits all around gives marginally * better results; if you are short of memory, 5 bits all around will save * some space but degrade the results. * To maintain a fully accurate histogram, we'd need to allocate a "long" * (preferably unsigned long) for each cell. In practice this is overkill; * we can get by with 16 bits per cell. Few of the cell counts will overflow, * and clamping those that do overflow to the maximum value will give close- * enough results. This reduces the recommended histogram size from 256Kb * to 128Kb, which is a useful savings on PC-class machines. * (In the second pass the histogram space is re-used for pixel mapping data; * in that capacity, each cell must be able to store zero to the number of * desired colors. 16 bits/cell is plenty for that too.) * Since the JPEG code is intended to run in small memory model on 80x86 * machines, we can't just allocate the histogram in one chunk. Instead * of a true 3-D array, we use a row of pointers to 2-D arrays. Each * pointer corresponds to a C0 value (typically 2^5 = 32 pointers) and * each 2-D array has 2^6*2^5 = 2048 or 2^6*2^6 = 4096 entries. Note that * on 80x86 machines, the pointer row is in near memory but the actual * arrays are in far memory (same arrangement as we use for image arrays). */ #define MAXNUMCOLORS (MAXJSAMPLE+1) /* maximum size of colormap */ /* These will do the right thing for either R,G,B or B,G,R color order, * but you may not like the results for other color orders. */ #define HIST_C0_BITS 5 /* bits of precision in R/B histogram */ #define HIST_C1_BITS 6 /* bits of precision in G histogram */ #define HIST_C2_BITS 5 /* bits of precision in B/R histogram */ /* Number of elements along histogram axes. */ #define HIST_C0_ELEMS (1<cquantize; register JSAMPROW ptr; register histptr histp; register hist3d histogram = cquantize->histogram; int row; JDIMENSION col; JDIMENSION width = cinfo->output_width; for (row = 0; row < num_rows; row++) { ptr = input_buf[row]; for (col = width; col > 0; col--) { /* get pixel value and index into the histogram */ histp = & histogram[GETJSAMPLE(ptr[0]) >> C0_SHIFT] [GETJSAMPLE(ptr[1]) >> C1_SHIFT] [GETJSAMPLE(ptr[2]) >> C2_SHIFT]; /* increment, check for overflow and undo increment if so. */ if (++(*histp) <= 0) (*histp)--; ptr += 3; } } } /* * Next we have the really interesting routines: selection of a colormap * given the completed histogram. * These routines work with a list of "boxes", each representing a rectangular * subset of the input color space (to histogram precision). */ typedef struct { /* The bounds of the box (inclusive); expressed as histogram indexes */ int c0min, c0max; int c1min, c1max; int c2min, c2max; /* The volume (actually 2-norm) of the box */ INT32 volume; /* The number of nonzero histogram cells within this box */ long colorcount; } box; typedef box * boxptr; LOCAL(boxptr) find_biggest_color_pop (boxptr boxlist, int numboxes) /* Find the splittable box with the largest color population */ /* Returns NULL if no splittable boxes remain */ { register boxptr boxp; register int i; register long maxc = 0; boxptr which = NULL; for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) { if (boxp->colorcount > maxc && boxp->volume > 0) { which = boxp; maxc = boxp->colorcount; } } return which; } LOCAL(boxptr) find_biggest_volume (boxptr boxlist, int numboxes) /* Find the splittable box with the largest (scaled) volume */ /* Returns NULL if no splittable boxes remain */ { register boxptr boxp; register int i; register INT32 maxv = 0; boxptr which = NULL; for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) { if (boxp->volume > maxv) { which = boxp; maxv = boxp->volume; } } return which; } LOCAL(void) update_box (j_decompress_ptr cinfo, boxptr boxp) /* Shrink the min/max bounds of a box to enclose only nonzero elements, */ /* and recompute its volume and population */ { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; hist3d histogram = cquantize->histogram; histptr histp; int c0,c1,c2; int c0min,c0max,c1min,c1max,c2min,c2max; INT32 dist0,dist1,dist2; long ccount; c0min = boxp->c0min; c0max = boxp->c0max; c1min = boxp->c1min; c1max = boxp->c1max; c2min = boxp->c2min; c2max = boxp->c2max; if (c0max > c0min) for (c0 = c0min; c0 <= c0max; c0++) for (c1 = c1min; c1 <= c1max; c1++) { histp = & histogram[c0][c1][c2min]; for (c2 = c2min; c2 <= c2max; c2++) if (*histp++ != 0) { boxp->c0min = c0min = c0; goto have_c0min; } } have_c0min: if (c0max > c0min) for (c0 = c0max; c0 >= c0min; c0--) for (c1 = c1min; c1 <= c1max; c1++) { histp = & histogram[c0][c1][c2min]; for (c2 = c2min; c2 <= c2max; c2++) if (*histp++ != 0) { boxp->c0max = c0max = c0; goto have_c0max; } } have_c0max: if (c1max > c1min) for (c1 = c1min; c1 <= c1max; c1++) for (c0 = c0min; c0 <= c0max; c0++) { histp = & histogram[c0][c1][c2min]; for (c2 = c2min; c2 <= c2max; c2++) if (*histp++ != 0) { boxp->c1min = c1min = c1; goto have_c1min; } } have_c1min: if (c1max > c1min) for (c1 = c1max; c1 >= c1min; c1--) for (c0 = c0min; c0 <= c0max; c0++) { histp = & histogram[c0][c1][c2min]; for (c2 = c2min; c2 <= c2max; c2++) if (*histp++ != 0) { boxp->c1max = c1max = c1; goto have_c1max; } } have_c1max: if (c2max > c2min) for (c2 = c2min; c2 <= c2max; c2++) for (c0 = c0min; c0 <= c0max; c0++) { histp = & histogram[c0][c1min][c2]; for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS) if (*histp != 0) { boxp->c2min = c2min = c2; goto have_c2min; } } have_c2min: if (c2max > c2min) for (c2 = c2max; c2 >= c2min; c2--) for (c0 = c0min; c0 <= c0max; c0++) { histp = & histogram[c0][c1min][c2]; for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS) if (*histp != 0) { boxp->c2max = c2max = c2; goto have_c2max; } } have_c2max: /* Update box volume. * We use 2-norm rather than real volume here; this biases the method * against making long narrow boxes, and it has the side benefit that * a box is splittable iff norm > 0. * Since the differences are expressed in histogram-cell units, * we have to shift back to JSAMPLE units to get consistent distances; * after which, we scale according to the selected distance scale factors. */ dist0 = ((c0max - c0min) << C0_SHIFT) * C0_SCALE; dist1 = ((c1max - c1min) << C1_SHIFT) * C1_SCALE; dist2 = ((c2max - c2min) << C2_SHIFT) * C2_SCALE; boxp->volume = dist0*dist0 + dist1*dist1 + dist2*dist2; /* Now scan remaining volume of box and compute population */ ccount = 0; for (c0 = c0min; c0 <= c0max; c0++) for (c1 = c1min; c1 <= c1max; c1++) { histp = & histogram[c0][c1][c2min]; for (c2 = c2min; c2 <= c2max; c2++, histp++) if (*histp != 0) { ccount++; } } boxp->colorcount = ccount; } LOCAL(int) median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes, int desired_colors) /* Repeatedly select and split the largest box until we have enough boxes */ { int n,lb; int c0,c1,c2,cmax; register boxptr b1,b2; while (numboxes < desired_colors) { /* Select box to split. * Current algorithm: by population for first half, then by volume. */ if (numboxes*2 <= desired_colors) { b1 = find_biggest_color_pop(boxlist, numboxes); } else { b1 = find_biggest_volume(boxlist, numboxes); } if (b1 == NULL) /* no splittable boxes left! */ break; b2 = &boxlist[numboxes]; /* where new box will go */ /* Copy the color bounds to the new box. */ b2->c0max = b1->c0max; b2->c1max = b1->c1max; b2->c2max = b1->c2max; b2->c0min = b1->c0min; b2->c1min = b1->c1min; b2->c2min = b1->c2min; /* Choose which axis to split the box on. * Current algorithm: longest scaled axis. * See notes in update_box about scaling distances. */ c0 = ((b1->c0max - b1->c0min) << C0_SHIFT) * C0_SCALE; c1 = ((b1->c1max - b1->c1min) << C1_SHIFT) * C1_SCALE; c2 = ((b1->c2max - b1->c2min) << C2_SHIFT) * C2_SCALE; /* We want to break any ties in favor of green, then red, blue last. * This code does the right thing for R,G,B or B,G,R color orders only. */ #if RGB_RED == 0 cmax = c1; n = 1; if (c0 > cmax) { cmax = c0; n = 0; } if (c2 > cmax) { n = 2; } #else cmax = c1; n = 1; if (c2 > cmax) { cmax = c2; n = 2; } if (c0 > cmax) { n = 0; } #endif /* Choose split point along selected axis, and update box bounds. * Current algorithm: split at halfway point. * (Since the box has been shrunk to minimum volume, * any split will produce two nonempty subboxes.) * Note that lb value is max for lower box, so must be < old max. */ switch (n) { case 0: lb = (b1->c0max + b1->c0min) / 2; b1->c0max = lb; b2->c0min = lb+1; break; case 1: lb = (b1->c1max + b1->c1min) / 2; b1->c1max = lb; b2->c1min = lb+1; break; case 2: lb = (b1->c2max + b1->c2min) / 2; b1->c2max = lb; b2->c2min = lb+1; break; } /* Update stats for boxes */ update_box(cinfo, b1); update_box(cinfo, b2); numboxes++; } return numboxes; } LOCAL(void) compute_color (j_decompress_ptr cinfo, boxptr boxp, int icolor) /* Compute representative color for a box, put it in colormap[icolor] */ { /* Current algorithm: mean weighted by pixels (not colors) */ /* Note it is important to get the rounding correct! */ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; hist3d histogram = cquantize->histogram; histptr histp; int c0,c1,c2; int c0min,c0max,c1min,c1max,c2min,c2max; long count; long total = 0; long c0total = 0; long c1total = 0; long c2total = 0; c0min = boxp->c0min; c0max = boxp->c0max; c1min = boxp->c1min; c1max = boxp->c1max; c2min = boxp->c2min; c2max = boxp->c2max; for (c0 = c0min; c0 <= c0max; c0++) for (c1 = c1min; c1 <= c1max; c1++) { histp = & histogram[c0][c1][c2min]; for (c2 = c2min; c2 <= c2max; c2++) { if ((count = *histp++) != 0) { total += count; c0total += ((c0 << C0_SHIFT) + ((1<>1)) * count; c1total += ((c1 << C1_SHIFT) + ((1<>1)) * count; c2total += ((c2 << C2_SHIFT) + ((1<>1)) * count; } } } cinfo->colormap[0][icolor] = (JSAMPLE) ((c0total + (total>>1)) / total); cinfo->colormap[1][icolor] = (JSAMPLE) ((c1total + (total>>1)) / total); cinfo->colormap[2][icolor] = (JSAMPLE) ((c2total + (total>>1)) / total); } LOCAL(void) select_colors (j_decompress_ptr cinfo, int desired_colors) /* Master routine for color selection */ { boxptr boxlist; int numboxes; int i; /* Allocate workspace for box list */ boxlist = (boxptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, desired_colors * SIZEOF(box)); /* Initialize one box containing whole space */ numboxes = 1; boxlist[0].c0min = 0; boxlist[0].c0max = MAXJSAMPLE >> C0_SHIFT; boxlist[0].c1min = 0; boxlist[0].c1max = MAXJSAMPLE >> C1_SHIFT; boxlist[0].c2min = 0; boxlist[0].c2max = MAXJSAMPLE >> C2_SHIFT; /* Shrink it to actually-used volume and set its statistics */ update_box(cinfo, & boxlist[0]); /* Perform median-cut to produce final box list */ numboxes = median_cut(cinfo, boxlist, numboxes, desired_colors); /* Compute the representative color for each box, fill colormap */ for (i = 0; i < numboxes; i++) compute_color(cinfo, & boxlist[i], i); cinfo->actual_number_of_colors = numboxes; TRACEMS1(cinfo, 1, JTRC_QUANT_SELECTED, numboxes); } /* * These routines are concerned with the time-critical task of mapping input * colors to the nearest color in the selected colormap. * * We re-use the histogram space as an "inverse color map", essentially a * cache for the results of nearest-color searches. All colors within a * histogram cell will be mapped to the same colormap entry, namely the one * closest to the cell's center. This may not be quite the closest entry to * the actual input color, but it's almost as good. A zero in the cache * indicates we haven't found the nearest color for that cell yet; the array * is cleared to zeroes before starting the mapping pass. When we find the * nearest color for a cell, its colormap index plus one is recorded in the * cache for future use. The pass2 scanning routines call fill_inverse_cmap * when they need to use an unfilled entry in the cache. * * Our method of efficiently finding nearest colors is based on the "locally * sorted search" idea described by Heckbert and on the incremental distance * calculation described by Spencer W. Thomas in chapter III.1 of Graphics * Gems II (James Arvo, ed. Academic Press, 1991). Thomas points out that * the distances from a given colormap entry to each cell of the histogram can * be computed quickly using an incremental method: the differences between * distances to adjacent cells themselves differ by a constant. This allows a * fairly fast implementation of the "brute force" approach of computing the * distance from every colormap entry to every histogram cell. Unfortunately, * it needs a work array to hold the best-distance-so-far for each histogram * cell (because the inner loop has to be over cells, not colormap entries). * The work array elements have to be INT32s, so the work array would need * 256Kb at our recommended precision. This is not feasible in DOS machines. * * To get around these problems, we apply Thomas' method to compute the * nearest colors for only the cells within a small subbox of the histogram. * The work array need be only as big as the subbox, so the memory usage * problem is solved. Furthermore, we need not fill subboxes that are never * referenced in pass2; many images use only part of the color gamut, so a * fair amount of work is saved. An additional advantage of this * approach is that we can apply Heckbert's locality criterion to quickly * eliminate colormap entries that are far away from the subbox; typically * three-fourths of the colormap entries are rejected by Heckbert's criterion, * and we need not compute their distances to individual cells in the subbox. * The speed of this approach is heavily influenced by the subbox size: too * small means too much overhead, too big loses because Heckbert's criterion * can't eliminate as many colormap entries. Empirically the best subbox * size seems to be about 1/512th of the histogram (1/8th in each direction). * * Thomas' article also describes a refined method which is asymptotically * faster than the brute-force method, but it is also far more complex and * cannot efficiently be applied to small subboxes. It is therefore not * useful for programs intended to be portable to DOS machines. On machines * with plenty of memory, filling the whole histogram in one shot with Thomas' * refined method might be faster than the present code --- but then again, * it might not be any faster, and it's certainly more complicated. */ /* log2(histogram cells in update box) for each axis; this can be adjusted */ #define BOX_C0_LOG (HIST_C0_BITS-3) #define BOX_C1_LOG (HIST_C1_BITS-3) #define BOX_C2_LOG (HIST_C2_BITS-3) #define BOX_C0_ELEMS (1<actual_number_of_colors; int maxc0, maxc1, maxc2; int centerc0, centerc1, centerc2; int i, x, ncolors; INT32 minmaxdist, min_dist, max_dist, tdist; INT32 mindist[MAXNUMCOLORS]; /* min distance to colormap entry i */ /* Compute true coordinates of update box's upper corner and center. * Actually we compute the coordinates of the center of the upper-corner * histogram cell, which are the upper bounds of the volume we care about. * Note that since ">>" rounds down, the "center" values may be closer to * min than to max; hence comparisons to them must be "<=", not "<". */ maxc0 = minc0 + ((1 << BOX_C0_SHIFT) - (1 << C0_SHIFT)); centerc0 = (minc0 + maxc0) >> 1; maxc1 = minc1 + ((1 << BOX_C1_SHIFT) - (1 << C1_SHIFT)); centerc1 = (minc1 + maxc1) >> 1; maxc2 = minc2 + ((1 << BOX_C2_SHIFT) - (1 << C2_SHIFT)); centerc2 = (minc2 + maxc2) >> 1; /* For each color in colormap, find: * 1. its minimum squared-distance to any point in the update box * (zero if color is within update box); * 2. its maximum squared-distance to any point in the update box. * Both of these can be found by considering only the corners of the box. * We save the minimum distance for each color in mindist[]; * only the smallest maximum distance is of interest. */ minmaxdist = 0x7FFFFFFFL; for (i = 0; i < numcolors; i++) { /* We compute the squared-c0-distance term, then add in the other two. */ x = GETJSAMPLE(cinfo->colormap[0][i]); if (x < minc0) { tdist = (x - minc0) * C0_SCALE; min_dist = tdist*tdist; tdist = (x - maxc0) * C0_SCALE; max_dist = tdist*tdist; } else if (x > maxc0) { tdist = (x - maxc0) * C0_SCALE; min_dist = tdist*tdist; tdist = (x - minc0) * C0_SCALE; max_dist = tdist*tdist; } else { /* within cell range so no contribution to min_dist */ min_dist = 0; if (x <= centerc0) { tdist = (x - maxc0) * C0_SCALE; max_dist = tdist*tdist; } else { tdist = (x - minc0) * C0_SCALE; max_dist = tdist*tdist; } } x = GETJSAMPLE(cinfo->colormap[1][i]); if (x < minc1) { tdist = (x - minc1) * C1_SCALE; min_dist += tdist*tdist; tdist = (x - maxc1) * C1_SCALE; max_dist += tdist*tdist; } else if (x > maxc1) { tdist = (x - maxc1) * C1_SCALE; min_dist += tdist*tdist; tdist = (x - minc1) * C1_SCALE; max_dist += tdist*tdist; } else { /* within cell range so no contribution to min_dist */ if (x <= centerc1) { tdist = (x - maxc1) * C1_SCALE; max_dist += tdist*tdist; } else { tdist = (x - minc1) * C1_SCALE; max_dist += tdist*tdist; } } x = GETJSAMPLE(cinfo->colormap[2][i]); if (x < minc2) { tdist = (x - minc2) * C2_SCALE; min_dist += tdist*tdist; tdist = (x - maxc2) * C2_SCALE; max_dist += tdist*tdist; } else if (x > maxc2) { tdist = (x - maxc2) * C2_SCALE; min_dist += tdist*tdist; tdist = (x - minc2) * C2_SCALE; max_dist += tdist*tdist; } else { /* within cell range so no contribution to min_dist */ if (x <= centerc2) { tdist = (x - maxc2) * C2_SCALE; max_dist += tdist*tdist; } else { tdist = (x - minc2) * C2_SCALE; max_dist += tdist*tdist; } } mindist[i] = min_dist; /* save away the results */ if (max_dist < minmaxdist) minmaxdist = max_dist; } /* Now we know that no cell in the update box is more than minmaxdist * away from some colormap entry. Therefore, only colors that are * within minmaxdist of some part of the box need be considered. */ ncolors = 0; for (i = 0; i < numcolors; i++) { if (mindist[i] <= minmaxdist) colorlist[ncolors++] = (JSAMPLE) i; } return ncolors; } LOCAL(void) find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2, int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[]) /* Find the closest colormap entry for each cell in the update box, * given the list of candidate colors prepared by find_nearby_colors. * Return the indexes of the closest entries in the bestcolor[] array. * This routine uses Thomas' incremental distance calculation method to * find the distance from a colormap entry to successive cells in the box. */ { int ic0, ic1, ic2; int i, icolor; register INT32 * bptr; /* pointer into bestdist[] array */ JSAMPLE * cptr; /* pointer into bestcolor[] array */ INT32 dist0, dist1; /* initial distance values */ register INT32 dist2; /* current distance in inner loop */ INT32 xx0, xx1; /* distance increments */ register INT32 xx2; INT32 inc0, inc1, inc2; /* initial values for increments */ /* This array holds the distance to the nearest-so-far color for each cell */ INT32 bestdist[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS]; /* Initialize best-distance for each cell of the update box */ bptr = bestdist; for (i = BOX_C0_ELEMS*BOX_C1_ELEMS*BOX_C2_ELEMS-1; i >= 0; i--) *bptr++ = 0x7FFFFFFFL; /* For each color selected by find_nearby_colors, * compute its distance to the center of each cell in the box. * If that's less than best-so-far, update best distance and color number. */ /* Nominal steps between cell centers ("x" in Thomas article) */ #define STEP_C0 ((1 << C0_SHIFT) * C0_SCALE) #define STEP_C1 ((1 << C1_SHIFT) * C1_SCALE) #define STEP_C2 ((1 << C2_SHIFT) * C2_SCALE) for (i = 0; i < numcolors; i++) { icolor = GETJSAMPLE(colorlist[i]); /* Compute (square of) distance from minc0/c1/c2 to this color */ inc0 = (minc0 - GETJSAMPLE(cinfo->colormap[0][icolor])) * C0_SCALE; dist0 = inc0*inc0; inc1 = (minc1 - GETJSAMPLE(cinfo->colormap[1][icolor])) * C1_SCALE; dist0 += inc1*inc1; inc2 = (minc2 - GETJSAMPLE(cinfo->colormap[2][icolor])) * C2_SCALE; dist0 += inc2*inc2; /* Form the initial difference increments */ inc0 = inc0 * (2 * STEP_C0) + STEP_C0 * STEP_C0; inc1 = inc1 * (2 * STEP_C1) + STEP_C1 * STEP_C1; inc2 = inc2 * (2 * STEP_C2) + STEP_C2 * STEP_C2; /* Now loop over all cells in box, updating distance per Thomas method */ bptr = bestdist; cptr = bestcolor; xx0 = inc0; for (ic0 = BOX_C0_ELEMS-1; ic0 >= 0; ic0--) { dist1 = dist0; xx1 = inc1; for (ic1 = BOX_C1_ELEMS-1; ic1 >= 0; ic1--) { dist2 = dist1; xx2 = inc2; for (ic2 = BOX_C2_ELEMS-1; ic2 >= 0; ic2--) { if (dist2 < *bptr) { *bptr = dist2; *cptr = (JSAMPLE) icolor; } dist2 += xx2; xx2 += 2 * STEP_C2 * STEP_C2; bptr++; cptr++; } dist1 += xx1; xx1 += 2 * STEP_C1 * STEP_C1; } dist0 += xx0; xx0 += 2 * STEP_C0 * STEP_C0; } } } LOCAL(void) fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2) /* Fill the inverse-colormap entries in the update box that contains */ /* histogram cell c0/c1/c2. (Only that one cell MUST be filled, but */ /* we can fill as many others as we wish.) */ { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; hist3d histogram = cquantize->histogram; int minc0, minc1, minc2; /* lower left corner of update box */ int ic0, ic1, ic2; register JSAMPLE * cptr; /* pointer into bestcolor[] array */ register histptr cachep; /* pointer into main cache array */ /* This array lists the candidate colormap indexes. */ JSAMPLE colorlist[MAXNUMCOLORS]; int numcolors; /* number of candidate colors */ /* This array holds the actually closest colormap index for each cell. */ JSAMPLE bestcolor[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS]; /* Convert cell coordinates to update box ID */ c0 >>= BOX_C0_LOG; c1 >>= BOX_C1_LOG; c2 >>= BOX_C2_LOG; /* Compute true coordinates of update box's origin corner. * Actually we compute the coordinates of the center of the corner * histogram cell, which are the lower bounds of the volume we care about. */ minc0 = (c0 << BOX_C0_SHIFT) + ((1 << C0_SHIFT) >> 1); minc1 = (c1 << BOX_C1_SHIFT) + ((1 << C1_SHIFT) >> 1); minc2 = (c2 << BOX_C2_SHIFT) + ((1 << C2_SHIFT) >> 1); /* Determine which colormap entries are close enough to be candidates * for the nearest entry to some cell in the update box. */ numcolors = find_nearby_colors(cinfo, minc0, minc1, minc2, colorlist); /* Determine the actually nearest colors. */ find_best_colors(cinfo, minc0, minc1, minc2, numcolors, colorlist, bestcolor); /* Save the best color numbers (plus 1) in the main cache array */ c0 <<= BOX_C0_LOG; /* convert ID back to base cell indexes */ c1 <<= BOX_C1_LOG; c2 <<= BOX_C2_LOG; cptr = bestcolor; for (ic0 = 0; ic0 < BOX_C0_ELEMS; ic0++) { for (ic1 = 0; ic1 < BOX_C1_ELEMS; ic1++) { cachep = & histogram[c0+ic0][c1+ic1][c2]; for (ic2 = 0; ic2 < BOX_C2_ELEMS; ic2++) { *cachep++ = (histcell) (GETJSAMPLE(*cptr++) + 1); } } } } /* * Map some rows of pixels to the output colormapped representation. */ METHODDEF(void) pass2_no_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows) /* This version performs no dithering */ { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; hist3d histogram = cquantize->histogram; register JSAMPROW inptr, outptr; register histptr cachep; register int c0, c1, c2; int row; JDIMENSION col; JDIMENSION width = cinfo->output_width; for (row = 0; row < num_rows; row++) { inptr = input_buf[row]; outptr = output_buf[row]; for (col = width; col > 0; col--) { /* get pixel value and index into the cache */ c0 = GETJSAMPLE(*inptr++) >> C0_SHIFT; c1 = GETJSAMPLE(*inptr++) >> C1_SHIFT; c2 = GETJSAMPLE(*inptr++) >> C2_SHIFT; cachep = & histogram[c0][c1][c2]; /* If we have not seen this color before, find nearest colormap entry */ /* and update the cache */ if (*cachep == 0) fill_inverse_cmap(cinfo, c0,c1,c2); /* Now emit the colormap index for this cell */ *outptr++ = (JSAMPLE) (*cachep - 1); } } } METHODDEF(void) pass2_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows) /* This version performs Floyd-Steinberg dithering */ { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; hist3d histogram = cquantize->histogram; register LOCFSERROR cur0, cur1, cur2; /* current error or pixel value */ LOCFSERROR belowerr0, belowerr1, belowerr2; /* error for pixel below cur */ LOCFSERROR bpreverr0, bpreverr1, bpreverr2; /* error for below/prev col */ register FSERRPTR errorptr; /* => fserrors[] at column before current */ JSAMPROW inptr; /* => current input pixel */ JSAMPROW outptr; /* => current output pixel */ histptr cachep; int dir; /* +1 or -1 depending on direction */ int dir3; /* 3*dir, for advancing inptr & errorptr */ int row; JDIMENSION col; JDIMENSION width = cinfo->output_width; JSAMPLE *range_limit = cinfo->sample_range_limit; int *error_limit = cquantize->error_limiter; JSAMPROW colormap0 = cinfo->colormap[0]; JSAMPROW colormap1 = cinfo->colormap[1]; JSAMPROW colormap2 = cinfo->colormap[2]; SHIFT_TEMPS for (row = 0; row < num_rows; row++) { inptr = input_buf[row]; outptr = output_buf[row]; if (cquantize->on_odd_row) { /* work right to left in this row */ inptr += (width-1) * 3; /* so point to rightmost pixel */ outptr += width-1; dir = -1; dir3 = -3; errorptr = cquantize->fserrors + (width+1)*3; /* => entry after last column */ cquantize->on_odd_row = FALSE; /* flip for next time */ } else { /* work left to right in this row */ dir = 1; dir3 = 3; errorptr = cquantize->fserrors; /* => entry before first real column */ cquantize->on_odd_row = TRUE; /* flip for next time */ } /* Preset error values: no error propagated to first pixel from left */ cur0 = cur1 = cur2 = 0; /* and no error propagated to row below yet */ belowerr0 = belowerr1 = belowerr2 = 0; bpreverr0 = bpreverr1 = bpreverr2 = 0; for (col = width; col > 0; col--) { /* curN holds the error propagated from the previous pixel on the * current line. Add the error propagated from the previous line * to form the complete error correction term for this pixel, and * round the error term (which is expressed * 16) to an integer. * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct * for either sign of the error value. * Note: errorptr points to *previous* column's array entry. */ cur0 = RIGHT_SHIFT(cur0 + errorptr[dir3+0] + 8, 4); cur1 = RIGHT_SHIFT(cur1 + errorptr[dir3+1] + 8, 4); cur2 = RIGHT_SHIFT(cur2 + errorptr[dir3+2] + 8, 4); /* Limit the error using transfer function set by init_error_limit. * See comments with init_error_limit for rationale. */ cur0 = error_limit[cur0]; cur1 = error_limit[cur1]; cur2 = error_limit[cur2]; /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE. * The maximum error is +- MAXJSAMPLE (or less with error limiting); * this sets the required size of the range_limit array. */ cur0 += GETJSAMPLE(inptr[0]); cur1 += GETJSAMPLE(inptr[1]); cur2 += GETJSAMPLE(inptr[2]); cur0 = GETJSAMPLE(range_limit[cur0]); cur1 = GETJSAMPLE(range_limit[cur1]); cur2 = GETJSAMPLE(range_limit[cur2]); /* Index into the cache with adjusted pixel value */ cachep = & histogram[cur0>>C0_SHIFT][cur1>>C1_SHIFT][cur2>>C2_SHIFT]; /* If we have not seen this color before, find nearest colormap */ /* entry and update the cache */ if (*cachep == 0) fill_inverse_cmap(cinfo, cur0>>C0_SHIFT,cur1>>C1_SHIFT,cur2>>C2_SHIFT); /* Now emit the colormap index for this cell */ { register int pixcode = *cachep - 1; *outptr = (JSAMPLE) pixcode; /* Compute representation error for this pixel */ cur0 -= GETJSAMPLE(colormap0[pixcode]); cur1 -= GETJSAMPLE(colormap1[pixcode]); cur2 -= GETJSAMPLE(colormap2[pixcode]); } /* Compute error fractions to be propagated to adjacent pixels. * Add these into the running sums, and simultaneously shift the * next-line error sums left by 1 column. */ { register LOCFSERROR bnexterr, delta; bnexterr = cur0; /* Process component 0 */ delta = cur0 * 2; cur0 += delta; /* form error * 3 */ errorptr[0] = (FSERROR) (bpreverr0 + cur0); cur0 += delta; /* form error * 5 */ bpreverr0 = belowerr0 + cur0; belowerr0 = bnexterr; cur0 += delta; /* form error * 7 */ bnexterr = cur1; /* Process component 1 */ delta = cur1 * 2; cur1 += delta; /* form error * 3 */ errorptr[1] = (FSERROR) (bpreverr1 + cur1); cur1 += delta; /* form error * 5 */ bpreverr1 = belowerr1 + cur1; belowerr1 = bnexterr; cur1 += delta; /* form error * 7 */ bnexterr = cur2; /* Process component 2 */ delta = cur2 * 2; cur2 += delta; /* form error * 3 */ errorptr[2] = (FSERROR) (bpreverr2 + cur2); cur2 += delta; /* form error * 5 */ bpreverr2 = belowerr2 + cur2; belowerr2 = bnexterr; cur2 += delta; /* form error * 7 */ } /* At this point curN contains the 7/16 error value to be propagated * to the next pixel on the current line, and all the errors for the * next line have been shifted over. We are therefore ready to move on. */ inptr += dir3; /* Advance pixel pointers to next column */ outptr += dir; errorptr += dir3; /* advance errorptr to current column */ } /* Post-loop cleanup: we must unload the final error values into the * final fserrors[] entry. Note we need not unload belowerrN because * it is for the dummy column before or after the actual array. */ errorptr[0] = (FSERROR) bpreverr0; /* unload prev errs into array */ errorptr[1] = (FSERROR) bpreverr1; errorptr[2] = (FSERROR) bpreverr2; } } /* * Initialize the error-limiting transfer function (lookup table). * The raw F-S error computation can potentially compute error values of up to * +- MAXJSAMPLE. But we want the maximum correction applied to a pixel to be * much less, otherwise obviously wrong pixels will be created. (Typical * effects include weird fringes at color-area boundaries, isolated bright * pixels in a dark area, etc.) The standard advice for avoiding this problem * is to ensure that the "corners" of the color cube are allocated as output * colors; then repeated errors in the same direction cannot cause cascading * error buildup. However, that only prevents the error from getting * completely out of hand; Aaron Giles reports that error limiting improves * the results even with corner colors allocated. * A simple clamping of the error values to about +- MAXJSAMPLE/8 works pretty * well, but the smoother transfer function used below is even better. Thanks * to Aaron Giles for this idea. */ LOCAL(void) init_error_limit (j_decompress_ptr cinfo) /* Allocate and fill in the error_limiter table */ { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; int * table; int in, out; table = (int *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE*2+1) * SIZEOF(int)); table += MAXJSAMPLE; /* so can index -MAXJSAMPLE .. +MAXJSAMPLE */ cquantize->error_limiter = table; #define STEPSIZE ((MAXJSAMPLE+1)/16) /* Map errors 1:1 up to +- MAXJSAMPLE/16 */ out = 0; for (in = 0; in < STEPSIZE; in++, out++) { table[in] = out; table[-in] = -out; } /* Map errors 1:2 up to +- 3*MAXJSAMPLE/16 */ for (; in < STEPSIZE*3; in++, out += (in&1) ? 0 : 1) { table[in] = out; table[-in] = -out; } /* Clamp the rest to final out value (which is (MAXJSAMPLE+1)/8) */ for (; in <= MAXJSAMPLE; in++) { table[in] = out; table[-in] = -out; } #undef STEPSIZE } /* * Finish up at the end of each pass. */ METHODDEF(void) finish_pass1 (j_decompress_ptr cinfo) { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; /* Select the representative colors and fill in cinfo->colormap */ cinfo->colormap = cquantize->sv_colormap; select_colors(cinfo, cquantize->desired); /* Force next pass to zero the color index table */ cquantize->needs_zeroed = TRUE; } METHODDEF(void) finish_pass2 (j_decompress_ptr cinfo) { /* no work */ } /* * Initialize for each processing pass. */ METHODDEF(void) start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan) { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; hist3d histogram = cquantize->histogram; int i; /* Only F-S dithering or no dithering is supported. */ /* If user asks for ordered dither, give him F-S. */ if (cinfo->dither_mode != JDITHER_NONE) cinfo->dither_mode = JDITHER_FS; if (is_pre_scan) { /* Set up method pointers */ cquantize->pub.color_quantize = prescan_quantize; cquantize->pub.finish_pass = finish_pass1; cquantize->needs_zeroed = TRUE; /* Always zero histogram */ } else { /* Set up method pointers */ if (cinfo->dither_mode == JDITHER_FS) cquantize->pub.color_quantize = pass2_fs_dither; else cquantize->pub.color_quantize = pass2_no_dither; cquantize->pub.finish_pass = finish_pass2; /* Make sure color count is acceptable */ i = cinfo->actual_number_of_colors; if (i < 1) ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, 1); if (i > MAXNUMCOLORS) ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS); if (cinfo->dither_mode == JDITHER_FS) { size_t arraysize = (size_t) ((cinfo->output_width + 2) * (3 * SIZEOF(FSERROR))); /* Allocate Floyd-Steinberg workspace if we didn't already. */ if (cquantize->fserrors == NULL) cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize); /* Initialize the propagated errors to zero. */ jzero_far((void FAR *) cquantize->fserrors, arraysize); /* Make the error-limit table if we didn't already. */ if (cquantize->error_limiter == NULL) init_error_limit(cinfo); cquantize->on_odd_row = FALSE; } } /* Zero the histogram or inverse color map, if necessary */ if (cquantize->needs_zeroed) { for (i = 0; i < HIST_C0_ELEMS; i++) { jzero_far((void FAR *) histogram[i], HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell)); } cquantize->needs_zeroed = FALSE; } } /* * Switch to a new external colormap between output passes. */ METHODDEF(void) new_color_map_2_quant (j_decompress_ptr cinfo) { my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize; /* Reset the inverse color map */ cquantize->needs_zeroed = TRUE; } /* * Module initialization routine for 2-pass color quantization. */ GLOBAL(void) jinit_2pass_quantizer (j_decompress_ptr cinfo) { my_cquantize_ptr cquantize; int i; cquantize = (my_cquantize_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_cquantizer)); cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize; cquantize->pub.start_pass = start_pass_2_quant; cquantize->pub.new_color_map = new_color_map_2_quant; cquantize->fserrors = NULL; /* flag optional arrays not allocated */ cquantize->error_limiter = NULL; /* Make sure jdmaster didn't give me a case I can't handle */ if (cinfo->out_color_components != 3) ERREXIT(cinfo, JERR_NOTIMPL); /* Allocate the histogram/inverse colormap storage */ cquantize->histogram = (hist3d) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, HIST_C0_ELEMS * SIZEOF(hist2d)); for (i = 0; i < HIST_C0_ELEMS; i++) { cquantize->histogram[i] = (hist2d) (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell)); } cquantize->needs_zeroed = TRUE; /* histogram is garbage now */ /* Allocate storage for the completed colormap, if required. * We do this now since it is FAR storage and may affect * the memory manager's space calculations. */ if (cinfo->enable_2pass_quant) { /* Make sure color count is acceptable */ int desired = cinfo->desired_number_of_colors; /* Lower bound on # of colors ... somewhat arbitrary as long as > 0 */ if (desired < 8) ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, 8); /* Make sure colormap indexes can be represented by JSAMPLEs */ if (desired > MAXNUMCOLORS) ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS); cquantize->sv_colormap = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo,JPOOL_IMAGE, (JDIMENSION) desired, (JDIMENSION) 3); cquantize->desired = desired; } else cquantize->sv_colormap = NULL; /* Only F-S dithering or no dithering is supported. */ /* If user asks for ordered dither, give him F-S. */ if (cinfo->dither_mode != JDITHER_NONE) cinfo->dither_mode = JDITHER_FS; /* Allocate Floyd-Steinberg workspace if necessary. * This isn't really needed until pass 2, but again it is FAR storage. * Although we will cope with a later change in dither_mode, * we do not promise to honor max_memory_to_use if dither_mode changes. */ if (cinfo->dither_mode == JDITHER_FS) { cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, (size_t) ((cinfo->output_width + 2) * (3 * SIZEOF(FSERROR)))); /* Might as well create the error-limiting table too. */ init_error_limit(cinfo); } } #endif /* QUANT_2PASS_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/makefile.vc0000755000175000017500000003014307535143454014747 0ustar # Makefile for Independent JPEG Group's software # This makefile is for Microsoft Visual C++ on Windows NT (and 95?). # It builds the IJG library as a statically linkable library (.LIB), # and builds the sample applications as console-mode apps. # Thanks to Xingong Chang, Raymond Everly and others. # Read installation instructions before saying "nmake" !! # To build an optimized library without debug info, say "nmake nodebug=1". # Pull in standard variable definitions !include # You may want to adjust these compiler options: CFLAGS= $(cflags) $(cdebug) $(cvars) -I. # Generally, we recommend defining any configuration symbols in jconfig.h, # NOT via -D switches here. # Link-time options: LDFLAGS= $(ldebug) $(conlflags) # To link any special libraries, add the necessary commands here. LDLIBS= $(conlibs) # Put here the object file name for the correct system-dependent memory # manager file. For NT we suggest jmemnobs.obj, which expects the OS to # provide adequate virtual memory. SYSDEPMEM= jmemnobs.obj # miscellaneous OS-dependent stuff # file deletion command RM= del # End of configurable options. # source files: JPEG library proper LIBSOURCES= jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c \ jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c \ jcphuff.c jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c \ jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c \ jdinput.c jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c \ jdpostct.c jdsample.c jdtrans.c jerror.c jfdctflt.c jfdctfst.c \ jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c jquant1.c \ jquant2.c jutils.c jmemmgr.c # memmgr back ends: compile only one of these into a working library SYSDEPSOURCES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemmac.c # source files: cjpeg/djpeg/jpegtran applications, also rdjpgcom/wrjpgcom APPSOURCES= cjpeg.c djpeg.c jpegtran.c rdjpgcom.c wrjpgcom.c cdjpeg.c \ rdcolmap.c rdswitch.c transupp.c rdppm.c wrppm.c rdgif.c wrgif.c \ rdtarga.c wrtarga.c rdbmp.c wrbmp.c rdrle.c wrrle.c SOURCES= $(LIBSOURCES) $(SYSDEPSOURCES) $(APPSOURCES) # files included by source files INCLUDES= jchuff.h jdhuff.h jdct.h jerror.h jinclude.h jmemsys.h jmorecfg.h \ jpegint.h jpeglib.h jversion.h cdjpeg.h cderror.h transupp.h # documentation, test, and support files DOCS= README install.doc usage.doc cjpeg.1 djpeg.1 jpegtran.1 rdjpgcom.1 \ wrjpgcom.1 wizard.doc example.c libjpeg.doc structure.doc \ coderules.doc filelist.doc change.log MKFILES= configure makefile.cfg makefile.ansi makefile.unix makefile.bcc \ makefile.mc6 makefile.dj makefile.wat makefile.vc makelib.ds \ makeapps.ds makeproj.mac makcjpeg.st makdjpeg.st makljpeg.st \ maktjpeg.st makefile.manx makefile.sas makefile.mms makefile.vms \ makvms.opt CONFIGFILES= jconfig.cfg jconfig.bcc jconfig.mc6 jconfig.dj jconfig.wat \ jconfig.vc jconfig.mac jconfig.st jconfig.manx jconfig.sas \ jconfig.vms CONFIGUREFILES= config.guess config.sub install-sh ltconfig ltmain.sh OTHERFILES= jconfig.doc ckconfig.c ansi2knr.c ansi2knr.1 jmemdosa.asm TESTFILES= testorig.jpg testimg.ppm testimg.bmp testimg.jpg testprog.jpg \ testimgp.jpg DISTFILES= $(DOCS) $(MKFILES) $(CONFIGFILES) $(SOURCES) $(INCLUDES) \ $(CONFIGUREFILES) $(OTHERFILES) $(TESTFILES) # library object files common to compression and decompression COMOBJECTS= jcomapi.obj jutils.obj jerror.obj jmemmgr.obj $(SYSDEPMEM) # compression library object files CLIBOBJECTS= jcapimin.obj jcapistd.obj jctrans.obj jcparam.obj jdatadst.obj \ jcinit.obj jcmaster.obj jcmarker.obj jcmainct.obj jcprepct.obj \ jccoefct.obj jccolor.obj jcsample.obj jchuff.obj jcphuff.obj \ jcdctmgr.obj jfdctfst.obj jfdctflt.obj jfdctint.obj # decompression library object files DLIBOBJECTS= jdapimin.obj jdapistd.obj jdtrans.obj jdatasrc.obj \ jdmaster.obj jdinput.obj jdmarker.obj jdhuff.obj jdphuff.obj \ jdmainct.obj jdcoefct.obj jdpostct.obj jddctmgr.obj jidctfst.obj \ jidctflt.obj jidctint.obj jidctred.obj jdsample.obj jdcolor.obj \ jquant1.obj jquant2.obj jdmerge.obj # These objectfiles are included in libjpeg.lib LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS) # object files for sample applications (excluding library files) COBJECTS= cjpeg.obj rdppm.obj rdgif.obj rdtarga.obj rdrle.obj rdbmp.obj \ rdswitch.obj cdjpeg.obj DOBJECTS= djpeg.obj wrppm.obj wrgif.obj wrtarga.obj wrrle.obj wrbmp.obj \ rdcolmap.obj cdjpeg.obj TROBJECTS= jpegtran.obj rdswitch.obj cdjpeg.obj transupp.obj # Template command for compiling .c to .obj .c.obj: $(cc) $(CFLAGS) $*.c all: libjpeg.lib cjpeg.exe djpeg.exe jpegtran.exe rdjpgcom.exe wrjpgcom.exe libjpeg.lib: $(LIBOBJECTS) $(RM) libjpeg.lib lib -out:libjpeg.lib $(LIBOBJECTS) cjpeg.exe: $(COBJECTS) libjpeg.lib $(link) $(LDFLAGS) -out:cjpeg.exe $(COBJECTS) libjpeg.lib $(LDLIBS) djpeg.exe: $(DOBJECTS) libjpeg.lib $(link) $(LDFLAGS) -out:djpeg.exe $(DOBJECTS) libjpeg.lib $(LDLIBS) jpegtran.exe: $(TROBJECTS) libjpeg.lib $(link) $(LDFLAGS) -out:jpegtran.exe $(TROBJECTS) libjpeg.lib $(LDLIBS) rdjpgcom.exe: rdjpgcom.obj $(link) $(LDFLAGS) -out:rdjpgcom.exe rdjpgcom.obj $(LDLIBS) wrjpgcom.exe: wrjpgcom.obj $(link) $(LDFLAGS) -out:wrjpgcom.exe wrjpgcom.obj $(LDLIBS) clean: $(RM) *.obj *.exe libjpeg.lib $(RM) testout* test: cjpeg.exe djpeg.exe jpegtran.exe $(RM) testout* .\djpeg -dct int -ppm -outfile testout.ppm testorig.jpg .\djpeg -dct int -bmp -colors 256 -outfile testout.bmp testorig.jpg .\cjpeg -dct int -outfile testout.jpg testimg.ppm .\djpeg -dct int -ppm -outfile testoutp.ppm testprog.jpg .\cjpeg -dct int -progressive -opt -outfile testoutp.jpg testimg.ppm .\jpegtran -outfile testoutt.jpg testprog.jpg fc /b testimg.ppm testout.ppm fc /b testimg.bmp testout.bmp fc /b testimg.jpg testout.jpg fc /b testimg.ppm testoutp.ppm fc /b testimgp.jpg testoutp.jpg fc /b testorig.jpg testoutt.jpg jcapimin.obj: jcapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcapistd.obj: jcapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccoefct.obj: jccoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccolor.obj: jccolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcdctmgr.obj: jcdctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jchuff.obj: jchuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcinit.obj: jcinit.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmainct.obj: jcmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmarker.obj: jcmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmaster.obj: jcmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcomapi.obj: jcomapi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcparam.obj: jcparam.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcphuff.obj: jcphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcprepct.obj: jcprepct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcsample.obj: jcsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jctrans.obj: jctrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapimin.obj: jdapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapistd.obj: jdapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdatadst.obj: jdatadst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdatasrc.obj: jdatasrc.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdcoefct.obj: jdcoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdcolor.obj: jdcolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jddctmgr.obj: jddctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jdhuff.obj: jdhuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdinput.obj: jdinput.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmainct.obj: jdmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmarker.obj: jdmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmaster.obj: jdmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmerge.obj: jdmerge.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdphuff.obj: jdphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdpostct.obj: jdpostct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdsample.obj: jdsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdtrans.obj: jdtrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jerror.obj: jerror.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jversion.h jerror.h jfdctflt.obj: jfdctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctfst.obj: jfdctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctint.obj: jfdctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctflt.obj: jidctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctfst.obj: jidctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctint.obj: jidctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctred.obj: jidctred.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jquant1.obj: jquant1.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jquant2.obj: jquant2.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jutils.obj: jutils.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemmgr.obj: jmemmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemansi.obj: jmemansi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemname.obj: jmemname.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemnobs.obj: jmemnobs.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemdos.obj: jmemdos.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemmac.obj: jmemmac.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h cjpeg.obj: cjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h djpeg.obj: djpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h jpegtran.obj: jpegtran.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.h jversion.h rdjpgcom.obj: rdjpgcom.c jinclude.h jconfig.h wrjpgcom.obj: wrjpgcom.c jinclude.h jconfig.h cdjpeg.obj: cdjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdcolmap.obj: rdcolmap.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdswitch.obj: rdswitch.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.obj: transupp.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h transupp.h rdppm.obj: rdppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrppm.obj: wrppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdgif.obj: rdgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrgif.obj: wrgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdtarga.obj: rdtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrtarga.obj: wrtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdbmp.obj: rdbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrbmp.obj: wrbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdrle.obj: rdrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrrle.obj: wrrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h Papyrus3/JpegDir/JpgLossy/Jlossy.plg0000755000175000017500000001341207535143454014627 0ustar 
Build Log



--------------------Configuration: Jpglossy - Win32 Debug--------------------



Command Lines

Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP7D.tmp" with contents
[
/nologo /Zp1 /MLd /W3 /Gm /Zi /Od /I "..\.." /D "_DEBUG" /D "STRICT" /D "WIN32" /D "_WINDOWS" /D "DICOMDIR_FLAG" /FR".\Debug/" /Fp".\Debug/Jlossy.pch" /YX /Fo".\Debug/" /Fd".\PAPYRUS3.PDB" /FD /c 
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcapimin.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcapistd.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jccoefct.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jccolor.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcdctmgr.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jchuff.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcinit.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcmainct.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcmarker.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcmaster.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcomapi.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcparam.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcphuff.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcprepct.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcsample.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jctrans.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdapimin.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdapistd.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdatadst.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdatasrc.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdcoefct.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdcolor.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jddctmgr.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdhuff.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdinput.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdmainct.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdmarker.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdmaster.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdmerge.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdphuff.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdpostct.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdsample.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdtrans.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jerror.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jfdctflt.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jfdctfst.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jfdctint.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jidctflt.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jidctfst.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jidctint.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jidctred.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jmemmgr.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jmemnobs.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jquant1.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jquant2.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jutils.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdbmp.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdcolmap.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdgif.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdppm.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdrle.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdswitch.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdtarga.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\wrrle.c"
]
Creating command line "cl.exe @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP7D.tmp" 
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP7E.tmp" with contents
[
/nologo /out:".\Debug\Jlossy.lib" 
.\Debug\jcapimin.obj
.\Debug\jcapistd.obj
.\Debug\jccoefct.obj
.\Debug\jccolor.obj
.\Debug\jcdctmgr.obj
.\Debug\jchuff.obj
.\Debug\jcinit.obj
.\Debug\jcmainct.obj
.\Debug\jcmarker.obj
.\Debug\jcmaster.obj
.\Debug\jcomapi.obj
.\Debug\jcparam.obj
.\Debug\jcphuff.obj
.\Debug\jcprepct.obj
.\Debug\jcsample.obj
.\Debug\jctrans.obj
.\Debug\jdapimin.obj
.\Debug\jdapistd.obj
.\Debug\jdatadst.obj
.\Debug\jdatasrc.obj
.\Debug\jdcoefct.obj
.\Debug\jdcolor.obj
.\Debug\jddctmgr.obj
.\Debug\jdhuff.obj
.\Debug\jdinput.obj
.\Debug\jdmainct.obj
.\Debug\jdmarker.obj
.\Debug\jdmaster.obj
.\Debug\jdmerge.obj
.\Debug\jdphuff.obj
.\Debug\jdpostct.obj
.\Debug\jdsample.obj
.\Debug\jdtrans.obj
.\Debug\jerror.obj
.\Debug\jfdctflt.obj
.\Debug\jfdctfst.obj
.\Debug\jfdctint.obj
.\Debug\jidctflt.obj
.\Debug\jidctfst.obj
.\Debug\jidctint.obj
.\Debug\jidctred.obj
.\Debug\jmemmgr.obj
.\Debug\jmemnobs.obj
.\Debug\jquant1.obj
.\Debug\jquant2.obj
.\Debug\jutils.obj
.\Debug\rdbmp.obj
.\Debug\rdcolmap.obj
.\Debug\rdgif.obj
.\Debug\rdppm.obj
.\Debug\rdrle.obj
.\Debug\rdswitch.obj
.\Debug\rdtarga.obj
.\Debug\wrrle.obj
]
Creating command line "link.exe -lib @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP7E.tmp"

Output Window

Compiling...
jcapimin.c
jcapistd.c
jccoefct.c
jccolor.c
jcdctmgr.c
jchuff.c
jcinit.c
jcmainct.c
jcmarker.c
jcmaster.c
jcomapi.c
jcparam.c
jcphuff.c
jcprepct.c
jcsample.c
jctrans.c
jdapimin.c
jdapistd.c
jdatadst.c
jdatasrc.c
jdcoefct.c
jdcolor.c
jddctmgr.c
jdhuff.c
jdinput.c
jdmainct.c
jdmarker.c
jdmaster.c
jdmerge.c
jdphuff.c
jdpostct.c
jdsample.c
jdtrans.c
jerror.c
jfdctflt.c
jfdctfst.c
jfdctint.c
jidctflt.c
jidctfst.c
jidctint.c
jidctred.c
jmemmgr.c
jmemnobs.c
jquant1.c
jquant2.c
jutils.c
rdbmp.c
rdcolmap.c
rdgif.c
rdppm.c
rdrle.c
rdswitch.c
rdtarga.c
wrrle.c
Creating library...




Results

Jlossy.lib - 0 error(s), 0 warning(s)
Papyrus3/JpegDir/JpgLossy/jpegtran.10000755000175000017500000001702407535143454014537 0ustar .TH JPEGTRAN 1 "3 August 1997" .SH NAME jpegtran \- lossless transformation of JPEG files .SH SYNOPSIS .B jpegtran [ .I options ] [ .I filename ] .LP .SH DESCRIPTION .LP .B jpegtran performs various useful transformations of JPEG files. It can translate the coded representation from one variant of JPEG to another, for example from baseline JPEG to progressive JPEG or vice versa. It can also perform some rearrangements of the image data, for example turning an image from landscape to portrait format by rotation. .PP .B jpegtran works by rearranging the compressed data (DCT coefficients), without ever fully decoding the image. Therefore, its transformations are lossless: there is no image degradation at all, which would not be true if you used .B djpeg followed by .B cjpeg to accomplish the same conversion. But by the same token, .B jpegtran cannot perform lossy operations such as changing the image quality. .PP .B jpegtran reads the named JPEG/JFIF file, or the standard input if no file is named, and produces a JPEG/JFIF file on the standard output. .SH OPTIONS All switch names may be abbreviated; for example, .B \-optimize may be written .B \-opt or .BR \-o . Upper and lower case are equivalent. British spellings are also accepted (e.g., .BR \-optimise ), though for brevity these are not mentioned below. .PP To specify the coded JPEG representation used in the output file, .B jpegtran accepts a subset of the switches recognized by .BR cjpeg : .TP .B \-optimize Perform optimization of entropy encoding parameters. .TP .B \-progressive Create progressive JPEG file. .TP .BI \-restart " N" Emit a JPEG restart marker every N MCU rows, or every N MCU blocks if "B" is attached to the number. .TP .BI \-scans " file" Use the scan script given in the specified text file. .PP See .BR cjpeg (1) for more details about these switches. If you specify none of these switches, you get a plain baseline-JPEG output file. The quality setting and so forth are determined by the input file. .PP The image can be losslessly transformed by giving one of these switches: .TP .B \-flip horizontal Mirror image horizontally (left-right). .TP .B \-flip vertical Mirror image vertically (top-bottom). .TP .B \-rotate 90 Rotate image 90 degrees clockwise. .TP .B \-rotate 180 Rotate image 180 degrees. .TP .B \-rotate 270 Rotate image 270 degrees clockwise (or 90 ccw). .TP .B \-transpose Transpose image (across UL-to-LR axis). .TP .B \-transverse Transverse transpose (across UR-to-LL axis). .PP The transpose transformation has no restrictions regarding image dimensions. The other transformations operate rather oddly if the image dimensions are not a multiple of the iMCU size (usually 8 or 16 pixels), because they can only transform complete blocks of DCT coefficient data in the desired way. .PP .BR jpegtran 's default behavior when transforming an odd-size image is designed to preserve exact reversibility and mathematical consistency of the transformation set. As stated, transpose is able to flip the entire image area. Horizontal mirroring leaves any partial iMCU column at the right edge untouched, but is able to flip all rows of the image. Similarly, vertical mirroring leaves any partial iMCU row at the bottom edge untouched, but is able to flip all columns. The other transforms can be built up as sequences of transpose and flip operations; for consistency, their actions on edge pixels are defined to be the same as the end result of the corresponding transpose-and-flip sequence. .PP For practical use, you may prefer to discard any untransformable edge pixels rather than having a strange-looking strip along the right and/or bottom edges of a transformed image. To do this, add the .B \-trim switch: .TP .B \-trim Drop non-transformable edge blocks. .PP Obviously, a transformation with .B \-trim is not reversible, so strictly speaking .B jpegtran with this switch is not lossless. Also, the expected mathematical equivalences between the transformations no longer hold. For example, .B \-rot 270 -trim trims only the bottom edge, but .B \-rot 90 -trim followed by .B \-rot 180 -trim trims both edges. .PP Another not-strictly-lossless transformation switch is: .TP .B \-grayscale Force grayscale output. .PP This option discards the chrominance channels if the input image is YCbCr (ie, a standard color JPEG), resulting in a grayscale JPEG file. The luminance channel is preserved exactly, so this is a better method of reducing to grayscale than decompression, conversion, and recompression. This switch is particularly handy for fixing a monochrome picture that was mistakenly encoded as a color JPEG. (In such a case, the space savings from getting rid of the near-empty chroma channels won't be large; but the decoding time for a grayscale JPEG is substantially less than that for a color JPEG.) .PP .B jpegtran also recognizes these switches that control what to do with "extra" markers, such as comment blocks: .TP .B \-copy none Copy no extra markers from source file. This setting suppresses all comments and other excess baggage present in the source file. .TP .B \-copy comments Copy only comment markers. This setting copies comments from the source file, but discards any other inessential data. .TP .B \-copy all Copy all extra markers. This setting preserves miscellaneous markers found in the source file, such as JFIF thumbnails and Photoshop settings. In some files these extra markers can be sizable. .PP The default behavior is .BR "\-copy comments" . (Note: in IJG releases v6 and v6a, .B jpegtran always did the equivalent of .BR "\-copy none" .) .PP Additional switches recognized by jpegtran are: .TP .BI \-maxmemory " N" Set limit for amount of memory to use in processing large images. Value is in thousands of bytes, or millions of bytes if "M" is attached to the number. For example, .B \-max 4m selects 4000000 bytes. If more space is needed, temporary files will be used. .TP .BI \-outfile " name" Send output image to the named file, not to standard output. .TP .B \-verbose Enable debug printout. More .BR \-v 's give more output. Also, version information is printed at startup. .TP .B \-debug Same as .BR \-verbose . .SH EXAMPLES .LP This example converts a baseline JPEG file to progressive form: .IP .B jpegtran \-progressive .I foo.jpg .B > .I fooprog.jpg .PP This example rotates an image 90 degrees clockwise, discarding any unrotatable edge pixels: .IP .B jpegtran \-rot 90 -trim .I foo.jpg .B > .I foo90.jpg .SH ENVIRONMENT .TP .B JPEGMEM If this environment variable is set, its value is the default memory limit. The value is specified as described for the .B \-maxmemory switch. .B JPEGMEM overrides the default value specified when the program was compiled, and itself is overridden by an explicit .BR \-maxmemory . .SH SEE ALSO .BR cjpeg (1), .BR djpeg (1), .BR rdjpgcom (1), .BR wrjpgcom (1) .br Wallace, Gregory K. "The JPEG Still Picture Compression Standard", Communications of the ACM, April 1991 (vol. 34, no. 4), pp. 30-44. .SH AUTHOR Independent JPEG Group .SH BUGS Arithmetic coding is not supported for legal reasons. .PP The transform options can't transform odd-size images perfectly. Use .B \-trim if you don't like the results without it. .PP The entire image is read into memory and then written out again, even in cases where this isn't really necessary. Expect swapping on large images, especially when using the more complex transform options. Papyrus3/JpegDir/JpgLossy/JCINIT.C0000755000175000017500000000456507535143454013735 0ustar /* * jcinit.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains initialization logic for the JPEG compressor. * This routine is in charge of selecting the modules to be executed and * making an initialization call to each one. * * Logically, this code belongs in jcmaster.c. It's split out because * linking this routine implies linking the entire compression library. * For a transcoding-only application, we want to be able to use jcmaster.c * without linking in the whole library. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* * Master selection of compression modules. * This is done once at the start of processing an image. We determine * which modules will be used and give them appropriate initialization calls. */ GLOBAL(void) jinit_compress_master (j_compress_ptr cinfo) { /* Initialize master control (includes parameter checking/processing) */ jinit_c_master_control(cinfo, FALSE /* full compression */); /* Preprocessing */ if (! cinfo->raw_data_in) { jinit_color_converter(cinfo); jinit_downsampler(cinfo); jinit_c_prep_controller(cinfo, FALSE /* never need full buffer here */); } /* Forward DCT */ jinit_forward_dct(cinfo); /* Entropy encoding: either Huffman or arithmetic coding. */ if (cinfo->arith_code) { ERREXIT(cinfo, JERR_ARITH_NOTIMPL); } else { if (cinfo->progressive_mode) { #ifdef C_PROGRESSIVE_SUPPORTED jinit_phuff_encoder(cinfo); #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } else jinit_huff_encoder(cinfo); } /* Need a full-image coefficient buffer in any multi-pass mode. */ jinit_c_coef_controller(cinfo, (boolean) (cinfo->num_scans > 1 || cinfo->optimize_coding)); jinit_c_main_controller(cinfo, FALSE /* never need full buffer here */); jinit_marker_writer(cinfo); /* We can now tell the memory manager to allocate virtual arrays. */ (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo); /* Write the datastream header (SOI) immediately. * Frame and scan headers are postponed till later. * This lets application insert special markers after the SOI. */ (*cinfo->marker->write_file_header) (cinfo); } Papyrus3/JpegDir/JpgLossy/RDJPGCOM0000755000175000017500000007317007535143454013777 0ustar ELF ø4r4 (44  Ô+++++,+,0´,L,L¨/usr/lib/ld.so.15BA!5&3<(*0:;,@=.68$"4?2-+# )'1%/97>ÔèÌì è  , ø&è ' ' +, +L ,L,ô,ø--.` øt.ˆ1à0 @!$PH1+Ä:+, P. X,0^+|e+ˆj+Ðr+èy&è , …$˜H¡,Lª+¸±0 @·%`(É+”Ï.ˆ!×,$Ü$à€ô+ôû.\+L +Ü",<)++ 0' =. !D|PI+ R,Y,`' f+¬_start_environ_end_iob__register_frame_info__flsbuf_GLOBAL_OFFSET_TABLE___ctypeabortatexitexittolowermalloc_init.umul__register_frame_info_table_DYNAMICprintf__iob__frame_state_for_exitenvironfree__deregister_frame_infostrcmp_edata_PROCEDURE_LINKAGE_TABLE_fopenmemset_etext_lib_version_ctypemain__filbufmemcpystrlen_finifprintflibc.so.1SYSVABI_1.3libc.so.1n7̳x.ˆ.#0 .+|%+ˆ&+”0+ =+¬A+¸-+Ä!+Ð'+Ü7+è(+ô4,?, *,>,$2,0$,<8¼ à @¢ Dœ#  €€@HI#@H@ï’•, ” ”@ ‹–âˆÔ"À@Š@H @H ã¿@/G®ã¼®À ÒÀÐ@Ѐ¢ €  Ð Ð$Ð?üŸÂÐЀ¢ 2¿ÿøÐ @BÐÀÇàèã¿Çàèã¿@/G®ã4®À ÐÀ’` @ ÒÀ Çàèã¿Çàè㿈‹Ðbx‹Ðbx‹Ò¢xÔ@’¿ÿ” Ô"€¢ €‹Ðbx@GÊ€ ‹Ôbx’ Ô@Ö € àÿ” Ô"@Ð'¿ìп쀢?ÿ€ Œ`ÀI’£ I”ã(@G¶ @GªÐ¿ì°€Çàè㿈‹Ðbx‹Ðbx‹Ò¢xÔ@’¿ÿ” Ô"€¢ €‹Ðbx@G˜€ ‹Ôbx’ Ô@Ö € àÿ” Ô"@Ð'¿ìп쀢?ÿ€ Œ`ÀI’£ I”ã(@G„ @Gx‹Ðbx‹Ðbx‹Ò¢xÔ@’¿ÿ” Ô"€¢ €‹Ðbx@Gm€ ‹Ôbx’ Ô@Ö € àÿ” Ô"@Ð'¿èп耢?ÿ€ Œ`ÀI’£ I”ã(@GY @GMÒ¿ì‘*`Ò¿è °€Çàè㿈À'¿èÿÿlÐ'¿ìп쀢 ÿ€€ Ð¿è’ Ò'¿èÿÿ`Ð'¿ì¿ÿôÿÿZÐ'¿ìп쀢 ÿ€€¿ÿ÷п耢 €Œ`ÀI’£H@G$п찀Çàè㿈‹Ðbx‹Ðbx‹Ò¢xÔ@’¿ÿ” Ô"€¢ €‹Ðbx@G € ‹Ôbx’ Ô@Ö € àÿ” Ô"@Ð'¿ì‹Ðbx‹Ðbx‹Ò¢xÔ@’¿ÿ” Ô"€¢ €‹Ðbx@Fí€ ‹Ôbx’ Ô@Ö € àÿ” Ô"@Ð'¿èп쀢 ÿ€Ð¿è€¢ Ø€€ Œ`ÀI’£ I”ãx@FÓ @FÇп谀Çàè㿈ÿÿÐ'¿ìп쀢 € Œ`ÀI’£ I”ãˆ@Fº @F®Ð¿ì’?þÒ'¿ìп쀢 €€ ÿþÏпì’?ÿÒ'¿ì¿ÿõÇàèã¿€À'¿äÿþöÐ'¿ìп쀢 € Œ`ÀI’£ I”ãˆ@F” @FˆÐ¿ì’?þÒ'¿ìп쀢 €€Zÿþ©Ð'¿èп耢 €Ic¨@F€€Fп耢 € п䀢 €Ic¨@Fr€8п耢 \€Ic°@Fh€.‹b‘Ò¿è Ò `W’ ÿ€¢`€ŒŒ`°ŒÔ`°’¿ÿ” Ô"€¢ € п茒 °@FO€ Œ’ ” °@ ÒÔ¿ëÔ*@’`Ò"€Ic¸Ò¿è@F:пèÐ'¿äпì’?ÿÒ'¿ì¿ÿ¤Ic¨@F/Çàèã¿pð' Dÿþ{Ð'¿ìÿþFÐ'¿àÿþuÐ'¿èÿþrÐ'¿äÿþ=Ð'¿ÜÒ D@€¢ €Z’‘*`D’£€Ð ÂÀÔèüÄ$8ÄL`tĈœ°IcÀÐ'¿Ø€CIcÐÐ'¿Ø€>IcèÐ'¿Ø€9IcøÐ'¿Ø€4J`Ð'¿Ø€/J` Ð'¿Ø€*J`@Ð'¿Ø€%J`XÐ'¿Ø€ J`€Ð'¿Ø€J` Ð'¿Ø€J`ÀÐ'¿Ø€J`ðÐ'¿Ø€ Ja Ð'¿Ø€JaPÐ'¿Ø€JaXÒ¿äÔ¿èÖ¿ÜØ¿à@E²Ja Ò¿Ø@E­Ð¿Ü”“* ’@`ҿ쀢@€ Œ`ÀI’£ J”á¸@E™ @EÀ'¿ÔпÔÒ¿Ü€¢ €€ ÿý®ÿý¬ÿýªÐ¿Ô’ Ò'¿Ô¿ÿðÇàè㿈ð' Dÿþ`€¢ Ø€ Œ`ÀI’£ J”áÐ@Eq @Eeÿþ Ð'¿ìÒ¿ì@€¢ >€q’‘*`E’¢<Ð Â8888Ü888Ü888Ü888ÜÜÜÜÜÜÜÜÜ|lÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜœÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ܌РD€¢ €Ð¿ìÿþð€ÿþL€"п찀 п찀ÿþe€Ð D€¢ € Jað@EÿþY€ÿþ0€ÿþ,€¿ÿ…Çàèã¿Œ`ÀJ’¢@Dç‹Œ`ÀJ’â@Ô¢|@Dߌ`ÀJ’¢h@DÙŒ`ÀJ’¢@DÓ @DÇÇàèã¿ð' Dò' Hô' L¤ РDÒ •*`¡: ’ Ð' D€¢`€€% HÒÔ @—* £:à”’`Ò"€¢ €° €!‹b‘Ò  `’ ÿ€¢`€@D­ €¤€° €¤ ¿ÿÓРL€¤€€° €° €Çàèã¿€ð' Dò' HÀ'¿ä‹Ò HÔ@Ô""|‹Ò"|€¢`€ ‹Ðb|Ò •*`‘: €¢ €€‹J’¢ÈÒ""| Ð'¿ìпìÒ D€¢ €€*п쒑*`Ò H ÒÒ'¿èпèÒ •*`‘: €¢ -€€Ð¿è’ Ò'¿èпèJ’¢Ø” ÿÿ„€¢ €Ð¿ä’ Ò'¿ä€ÿÿZÐ¿ì’ Ò'¿ì¿ÿÓÒ Dÿҿ쀢@€ ‹Œ`ÀJ’âàÔ¢|@D3ÿÿEпìÒ D€¢ €%п쒑*`Ô H’ Ð@J’£@D.‹Ð"bxÐbx€¢ €‹Ð¿ì’‘*`Ò H– Œ`ÀJ’#Ô¢|ÖÀ@D @D€‹Œ’  Ò""xпäÿþ„ @Cö° €Çàè” – Æ  „à…(€ €ˆà€€–À¿ÿù” ÃàÖ"@† ”Ö  „ à…(€”€€Šà€¿ÿú†à€ à€€Šà@€„?ÿ…(€”€ÃàÔ"@…*`€¢`€Ô"€ÖÔ?üÆàÄ € À€’‚ÿÔ"Ö"?ü¿ÿ÷?üÃàÄ’ € € €Ä €  "€ÄÄ €  2€’`Ä„Æ € à¿ÿô Ãà ã¿à€äÀЀ¢ €âÐ €¢ "€ÐÐ €¢ €’ÿÿÉ”Ò €¢@€  ¤ Ð @€¢8€¢ÐÒ €¢`¿ÿç° à&€ä&Àâ'Çàè㿀Р€¢ € À'¿ìЀ¢ €Ð¿ìÿÿºÐÒ¿ì  ’@Ò'¿ìЀ¢ ¿ÿøпì€Ð& ÿÿ®Ð Ð'¿ìпìÐ& @C~‘* ’?ÿÒ'¿èÀ'¿äÀ'¿ìÒ €¢`€¢  Ѐ¢ €Ò¿è’”¿ì–¿èÐÿÿ«˜¿ä  Ѐ¢ ¿ÿø’€ Ò¿èÐ ’”¿ì–¿èÿÿž˜¿äÒ¿èâ& пäÒ&Ð& Çàèã¿@/C®à”®À ÐÀà€¤ €¢Ð€¢ €€¤@ÿÿ¬Ð€¤@*€à Ð €¤@ €€¤ à €¤ 2¿ÿñЀ¤ €° Ø – €¢À €À Ú •2 ‘* ð@Ò €¤@ :€Ð €˜ @€¤@€– €¢À ¿ÿòÀ ° Çàè㿈@/B®㬮À ÒÀÔ "  @CÐ&@€¢ €Ð@’`@C ÒÀ €¢ €Ð@ÐJ€¢ z€-° @CÐ@Ô@’`ÒÀ  €° @Bù €¢ 2€À&`Ð Ô Ò ‘* •* ”€“*`Ð ’@  Ð&`° ÿþÝ’`ÿþè’` °ÐÒ@Ð&`ÐJ@€¢ z€° ÿþÐ’¿ìÒ¿ì° Çàèã¿€Ô€Š @€ ° Ò @BÔ  ?ÒÀ’@€ßÒ&À€Š €€  ?Ð'¿è€k€Š À€€¢ .Ð'¿è@€ÒÀ*!¬€Î“* @àÐ ÃÀ8Ðü8tÄ88ä°$Tt000000000000000000000000000000ÐÐÔ Ò ‘* •* ”€“*`Ð ’@ € ÒÐÀ Ð&À€‹° ÐÔ ÒÀ‘* ”€’@ Ò&À€‚° ÔÐ Ò •* ‘*  “*`Ô ’@ÐÀ”€  Ð&À€s° ÿþQ’¿èÿþO’¿ìÔ¿ì°Ò  @BZ Ð'¿ìÒ¿è ’@ Ð*a¬Ð¿è‘* @€_Ò" ÿþ=’¿èÒ¿è°’@ €WÀ*a¬ÿþ5’¿èÿþ3’¿äÒ¿è” ’@ Ô*a¬Ò¿è°Ð¿ä“*`’@ €GÐ"` ¿èÿþ$’ÿþ"’¿ìÒ °Ð¿ìÒ6a¨€;Ð&` ¿èÿþ’Ò °€3Ò6a¨ÿþ’¿ìÒ¿ì°€,Ò&`@B" ’@B”"€$à&bà"”"@B’@B0€ Ð'¿è– пè@Ö*!¬Ô¿è“* ’@ ¿ð‘* Ð"`” €¢ ¿ÿõÔ'¿è0€ ÿýé’¿ìÒ¿ì°€Ò&` @AüÇàèã¿@/A®âØ®Àð&`À&`À&@ ÒÀÀ&` Ð@À&`Ð&`ò"@Çàèã¿@/A®â®Àð&`ð&` À&` ÒÀÀ&@Ð@À&`Ð&`ò"@Çàèã¿@/A®âH®À ÔÀЀ€¢ €Ò€Ð`€¢€ Ð`Ð"€Ð@€¢ € @A»Ð` 0€€¢ ¿ÿò”`@A¸Çàèã½XÿþL¤’ €ÿþ’¿Ø ’ €½À€=° ’ @A©”"пêÒ¿ÜÐ7¿jÒ'½ÄР?ü$€Ò ¢ €¤€ пؒ½À”¿Øÿþ±–  €¤ ¿ÿúпØÐJ€¢ z€  ÿýo’½¼Ò½¼  ЀҠ€¢ €¤€Ò'½¸Ð½¸€¢€ ’½À”¿Øÿþ”–½¸ €¤ ¿ÿ÷н¸’½À@Ai”"°Çàèã¿@/A®à ®À ÐÀÒ?ü€¢ÿ€  ?üП ?üЀ¢?ÿ¿ÿûÇàèã¿Çàèã¿ ÿùBÿÿåÇàèã¿ ÿùÇàè%s Premature EOF in JPEG fileWarning: garbage data found in JPEG file Not a JPEG fileErroneous JPEG marker length \\\%03oBaselineExtended sequentialProgressiveLosslessDifferential sequentialDifferential progressiveDifferential losslessExtended sequential, arithmetic codingProgressive, arithmetic codingLossless, arithmetic codingDifferential sequential, arithmetic codingDifferential progressive, arithmetic codingDifferential lossless, arithmetic codingUnknownJPEG image is %uw * %uh, %d color components, %d bits per sample JPEG process: %s Bogus SOF marker lengthExpected SOI marker firstAPP12 contains: rdjpgcom displays any textual comments in a JPEG file. Usage: %s [switches] [inputfile] Switches (names may be abbreviated): -verbose Also display dimensions of JPEG image rdjpgcomverbose%s: only one input file rb%s: can't open %s eh,L,ô-.`+ +(.€,ü00¿ÿó<0¿ÿðH0¿ÿíT0¿ÿê`0¿ÿçl0¿ÿäx0¿ÿá„0¿ÿÞ0¿ÿÛœ0¿ÿب0¿ÿÕ´0¿ÿÒÀ0¿ÿÏÌ0¿ÿÌØ0¿ÿÉä0¿ÿÆð0¿ÿÄ &è 'oÿÿþ èoÿÿÿèì ûÌ oÿýü+LÌ , ð -ÿÿÿÿÿÿÿÿ|e  e Ì4 (L 8LH H”TXèœ - et„ - e”è - e¬|( - eÈ ¤¬ - eä$PH - e$˜H - e$à€ - e8%`( - eÿñÔèÌì è  , ø&è ' ' +, +L ,L,ô,ø--.`z1à ÿñÿñÿñ(,ô,,ø:-H l^ lm-€,øŽ è™ ,¤.`­ ô¹ÿñÄ<PÑ.|Ú ¨çü€íŒ”û 8 .x 8È€¼)|2 €? ìK´H\ÿñd+ j+( pLH{.€ƒL’Ì4¡ ¤¬²|(Ã-Ó”TÞ„éèœò”èûÿñ.X&ˆ*&ˆ9,øG&ÜR-_,ülÿñs øt‚.ˆ‹1à0 @!•$PH«+Ä´+, Ê. Ò,0Ø+|ß+ˆä+Ðì+èó&è ù, ÿ$˜H!,L*+¸10 @7%`(I+”O.ˆ!W,$\$à€t+ô{.\‚+L œ+Ü¢,<©++ °' ½. !Ä|PÉ+ Ò,Ù,à' æ+¬rdjpgcomcrti.svalues-Xa.ccrtstuff.cp.2__CTOR_LIST____DTOR_LIST____do_global_dtors_auxgcc2_compiled.__EH_FRAME_BEGIN__force_to_datafini_dummyinit_dummyobject.7frame_dummyrdjpgcom.cfirst_markerprognameprocess_SOFnusageskip_variablegcc2_compiled.infileread_1_bytenext_markerkeymatchread_2_bytesprocess_COMscan_JPEG_headerframe.c.LLC0.LLC1fde_insertobjectsdecode_sleb128decode_uleb128execute_cfa_insnextract_cie_info__FRAME_BEGIN__count_fdesframe_initadd_fdesfind_fdecrtstuff.c__FRAME_END____do_global_ctors_auxgcc2_compiled.force_to_datainit_dummy__DTOR_END____CTOR_END__crtn.s_start_START__environ_end_iob__register_frame_info__flsbuf_GLOBAL_OFFSET_TABLE___ctypeabortatexitexittolowermalloc_init.umul__register_frame_info_table_END__DYNAMICprintf__iob__frame_state_for_exitenvironfree__deregister_frame_infostrcmp_edata_PROCEDURE_LINKAGE_TABLE_fopenmemset_etext_lib_version_ctypemain__filbufmemcpystrlen_finifprintfas: WorkShop Compilers 4.X dev 18 Sep 1996 as: WorkShop Compilers 4.X dev 18 Sep 1996 @(#)SunOS 5.6 Generic August 1997as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 ld: Software Generation Utilities - Solaris/ELF (3.0); <I4œ,Ù dÌ"dÌ,<;€e€€®€Ï€õ€A€€³€Ý€€(€B€]€~€·€Ú€þ€(€<‚F‚]‚u‚z‚’‚¦‚»‚Ѐ€€Ž€.€¢„‚¢¢¢¢¢’‚¢¢¢¢£‚¢®‚¢º‚À .€ ƒ€ ý€-€z€Á€¶€”€€€‘€‚€<€†€å€?€¯€€n€ï€ ,€!€!ƒ€#q€$b€¢$÷‚%€v% €¨%5€ó%K€ ¢%`‚%h€&j€&…€¢'=€2'Q€3'e€4'y€5'€6'¢€( €(€L( €)&€)|$iÌ)“@h)§@h )¸$4)¹$~)Ð@})Ü@} )í$L)î€*<$ÂL*O@Á*m@Á *w@Á *ˆ$H*‰$Ï”*œ@Î*­$T*®$áè*¿@ß*Ð@ß*Þ@ß*ô@à+ @à+$œ+$ÿ„+0@þ+<$+=$'”+N@&+Y$è+Z$R|+s@Q+}@Q+$(+$ ¤+©@}+³@}+Á@~+Î@~+Ù$¬+Ú$ù$P+ø@ø,@ø,$H,$ $˜,7@ ,E@ ,Q$H,R$$à,r@,€$€,$4%`,£@3,µ@3,Æ$(,Ç(P.€,Ød&ˆ.interp.hash.dynsym.dynstr.SUNW_version.rela.bss.rela.plt.text.init.fini.rodata.got.plt.dynamic.data.ctors.dtors.eh_frame.bss.symtab.strtab.comment.stab.index.stab.shstrtab.stab.indexstr.stabstrvalues-Xa.cXt ; O ; V=3.1 ; R=WorkShop Compilers 4.2 30 Oct 1996 C 4.2/space/respin/usr/src/lib/libc; /ws/on297-tools/SUNWspro/SC4.2/bin/../SC4.2/bin/cc -xO3 -xcg89 -Wa,-cg92 -xspace -W0,-Lt -Xt -Iinc -DTEXT_DOMAIN='"SUNW_OST_OSLIB"' -I/space/respin/proto/root_sparc/usr/include -c port/gen/values-Xa.c -W0,-xpframe.c/ext1/SOURCES/gcc-2.8.1/./frame.cgcc2_compiled.int:t(0,1)=r(0,1);-2147483648;2147483647;char:t(0,2)=r(0,2);0;127;long int:t(0,3)=r(0,3);-2147483648;2147483647;unsigned int:t(0,4)=r(0,4);0;-1;long unsigned int:t(0,5)=r(0,5);0;-1;long long int:t(0,6)=r(0,1);01000000000000000000000;0777777777777777777777;long long unsigned int:t(0,7)=r(0,1);0000000000000;01777777777777777777777;short int:t(0,8)=r(0,8);-32768;32767;short unsigned int:t(0,9)=r(0,9);0;65535;signed char:t(0,10)=r(0,10);-128;127;unsigned char:t(0,11)=r(0,11);0;255;float:t(0,12)=r(0,1);4;0;double:t(0,13)=r(0,1);8;0;long double:t(0,14)=r(0,1);16;0;complex int:t(0,15)=s8real:(0,1),0,32;imag:(0,1),32,32;;complex float:t(0,16)=r(0,16);4;0;complex double:t(0,17)=r(0,17);8;0;complex long double:t(0,18)=r(0,18);16;0;void:t(0,19)=(0,19)tconfig.hconfig/sparc/xm-sol2.hconfig/sparc/xm-sysv4.htm.hconfig/sparc/sol2-sld.hconfig/sparc/sol2.hconfig/sparc/sysv4.hconfig/sparc/sparc.hcmodel:T(8,1)=eCM_32:0,CM_MEDLOW:1,CM_MEDMID:2,CM_MEDANY:3,CM_EMBMEDANY:4,;processor_type:T(8,2)=ePROCESSOR_V7:0,PROCESSOR_CYPRESS:1,PROCESSOR_V8:2,PROCESSOR_SUPERSPARC:3,PROCESSOR_SPARCLITE:4,PROCESSOR_F930:5,PROCESSOR_F934:6,PROCESSOR_SPARCLET:7,PROCESSOR_TSC701:8,PROCESSOR_V8PLUS:9,PROCESSOR_V9:10,PROCESSOR_ULTRASPARC:11,;sparc_cpu_select:T(8,3)=s16string:(8,4)=*(0,2),0,32;name:(8,4),32,32;set_tune_p:(0,1),64,32;set_arch_p:(0,1),96,32;;reg_class:T(8,5)=eNO_REGS:0,FPCC_REGS:1,GENERAL_REGS:2,FP_REGS:3,EXTRA_FP_REGS:4,GENERAL_OR_FP_REGS:5,GENERAL_OR_EXTRA_FP_REGS:6,ALL_REGS:7,LIM_REG_CLASSES:8,;sparc_args:T(8,6)=s12words:(0,1),0,32;prototype_p:(0,1),32,32;libcall_p:(0,1),64,32;;config/svr4.hconfig/xm-svr4.hdefaults.hgansidecl.hdwarf2.hdwarf_tag:T(13,1)=eDW_TAG_padding:0,DW_TAG_array_type:1,DW_TAG_class_type:2,DW_TAG_entry_point:3,DW_TAG_enumeration_type:4,DW_TAG_formal_parameter:5,DW_TAG_imported_declaration:8,DW_TAG_label:10,DW_TAG_lexical_block:11,DW_TAG_member:13,DW_TAG_pointer_type:15,DW_TAG_reference_type:16,DW_TAG_compile_unit:17,DW_TAG_string_type:18,DW_TAG_structure_type:19,DW_TAG_subroutine_type:21,DW_TAG_typedef:22,DW_TAG_union_type:23,DW_TAG_unspecified_parameters:24,DW_TAG_variant:25,DW_TAG_common_block:26,DW_TAG_common_inclusion:27,DW_TAG_inheritance:28,DW_TAG_inlined_subroutine:29,DW_TAG_module:30,DW_TAG_ptr_to_member_type:31,\DW_TAG_set_type:32,DW_TAG_subrange_type:33,DW_TAG_with_stmt:34,DW_TAG_access_declaration:35,DW_TAG_base_type:36,DW_TAG_catch_block:37,DW_TAG_const_type:38,DW_TAG_constant:39,DW_TAG_enumerator:40,DW_TAG_file_type:41,DW_TAG_friend:42,DW_TAG_namelist:43,DW_TAG_namelist_item:44,DW_TAG_packed_type:45,DW_TAG_subprogram:46,DW_TAG_template_type_param:47,DW_TAG_template_value_param:48,DW_TAG_thrown_type:49,DW_TAG_try_block:50,DW_TAG_variant_part:51,DW_TAG_variable:52,DW_TAG_volatile_type:53,DW_TAG_MIPS_loop:16513,DW_TAG_format_label:16641,DW_TAG_function_template:16642,DW_TAG_class_template:16643,;dwarf_form:T(13,2)=eDW_FORM_addr:1,DW_FORM_block2:3,DW_FORM_block4:4,DW_FORM_data2:5,DW_FORM_data4:6,DW_FORM_data8:7,DW_FORM_string:8,DW_FORM_block:9,DW_FORM_block1:10,DW_FORM_data1:11,DW_FORM_flag:12,DW_FORM_sdata:13,DW_FORM_strp:14,DW_FORM_udata:15,DW_FORM_ref_addr:16,DW_FORM_ref1:17,DW_FORM_ref2:18,DW_FORM_ref4:19,DW_FORM_ref8:20,DW_FORM_ref_udata:21,DW_FORM_indirect:22,;dwarf_attribute:T(13,3)=eDW_AT_sibling:1,DW_AT_location:2,DW_AT_name:3,DW_AT_ordering:9,DW_AT_subscr_data:10,DW_AT_byte_size:11,DW_AT_bit_offset:12,DW_AT_bit_size:13,DW_AT_element_list:15,DW_AT_stmt_list:16,DW_AT_low_pc:17,DW_AT_high_pc:18,DW_AT_language:19,DW_AT_member:20,DW_AT_discr:21,DW_AT_discr_value:22,DW_AT_visibility:23,DW_AT_import:24,DW_AT_string_length:25,DW_AT_common_reference:26,DW_AT_comp_dir:27,DW_AT_const_value:28,DW_AT_containing_type:29,DW_AT_default_value:30,DW_AT_inline:32,DW_AT_is_optional:33,DW_AT_lower_bound:34,DW_AT_producer:37,\DW_AT_prototyped:39,DW_AT_return_addr:42,DW_AT_start_scope:44,DW_AT_stride_size:46,DW_AT_upper_bound:47,DW_AT_abstract_origin:49,DW_AT_accessibility:50,DW_AT_address_class:51,DW_AT_artificial:52,DW_AT_base_types:53,DW_AT_calling_convention:54,DW_AT_count:55,DW_AT_data_member_location:56,DW_AT_decl_column:57,DW_AT_decl_file:58,DW_AT_decl_line:59,DW_AT_declaration:60,DW_AT_discr_list:61,DW_AT_encoding:62,DW_AT_external:63,DW_AT_frame_base:64,DW_AT_friend:65,DW_AT_identifier_case:66,DW_AT_macro_info:67,DW_AT_namelist_items:68,DW_AT_priority:69,DW_AT_segment:70,DW_AT_specification:71,\DW_AT_static_link:72,DW_AT_type:73,DW_AT_use_location:74,DW_AT_variable_parameter:75,DW_AT_virtuality:76,DW_AT_vtable_elem_location:77,DW_AT_MIPS_fde:8193,DW_AT_MIPS_loop_begin:8194,DW_AT_MIPS_tail_loop_begin:8195,DW_AT_MIPS_epilog_begin:8196,DW_AT_MIPS_loop_unroll_factor:8197,DW_AT_MIPS_software_pipeline_depth:8198,DW_AT_MIPS_linkage_name:8199,DW_AT_MIPS_stride:8200,DW_AT_MIPS_abstract_name:8201,DW_AT_MIPS_clone_origin:8202,DW_AT_MIPS_has_inlines:8203,DW_AT_sf_names:8449,DW_AT_src_info:8450,DW_AT_mac_info:8451,DW_AT_src_coords:8452,DW_AT_body_begin:8453,DW_AT_body_end:8454,;dwarf_location_atom:T(13,4)=eDW_OP_addr:3,DW_OP_deref:6,DW_OP_const1u:8,DW_OP_const1s:9,DW_OP_const2u:10,DW_OP_const2s:11,DW_OP_const4u:12,DW_OP_const4s:13,DW_OP_const8u:14,DW_OP_const8s:15,DW_OP_constu:16,DW_OP_consts:17,DW_OP_dup:18,DW_OP_drop:19,DW_OP_over:20,DW_OP_pick:21,DW_OP_swap:22,DW_OP_rot:23,DW_OP_xderef:24,DW_OP_abs:25,DW_OP_and:26,DW_OP_div:27,DW_OP_minus:28,DW_OP_mod:29,DW_OP_mul:30,DW_OP_neg:31,DW_OP_not:32,DW_OP_or:33,DW_OP_plus:34,DW_OP_plus_uconst:35,DW_OP_shl:36,DW_OP_shr:37,\DW_OP_shra:38,DW_OP_xor:39,DW_OP_bra:40,DW_OP_eq:41,DW_OP_ge:42,DW_OP_gt:43,DW_OP_le:44,DW_OP_lt:45,DW_OP_ne:46,DW_OP_skip:47,DW_OP_lit0:48,DW_OP_lit1:49,DW_OP_lit2:50,DW_OP_lit3:51,DW_OP_lit4:52,DW_OP_lit5:53,DW_OP_lit6:54,DW_OP_lit7:55,DW_OP_lit8:56,DW_OP_lit9:57,DW_OP_lit10:58,DW_OP_lit11:59,DW_OP_lit12:60,DW_OP_lit13:61,DW_OP_lit14:62,DW_OP_lit15:63,DW_OP_lit16:64,DW_OP_lit17:65,DW_OP_lit18:66,DW_OP_lit19:67,DW_OP_lit20:68,DW_OP_lit21:69,DW_OP_lit22:70,DW_OP_lit23:71,\DW_OP_lit24:72,DW_OP_lit25:73,DW_OP_lit26:74,DW_OP_lit27:75,DW_OP_lit28:76,DW_OP_lit29:77,DW_OP_lit30:78,DW_OP_lit31:79,DW_OP_reg0:80,DW_OP_reg1:81,DW_OP_reg2:82,DW_OP_reg3:83,DW_OP_reg4:84,DW_OP_reg5:85,DW_OP_reg6:86,DW_OP_reg7:87,DW_OP_reg8:88,DW_OP_reg9:89,DW_OP_reg10:90,DW_OP_reg11:91,DW_OP_reg12:92,DW_OP_reg13:93,DW_OP_reg14:94,DW_OP_reg15:95,DW_OP_reg16:96,DW_OP_reg17:97,DW_OP_reg18:98,DW_OP_reg19:99,DW_OP_reg20:100,DW_OP_reg21:101,DW_OP_reg22:102,DW_OP_reg23:103,DW_OP_reg24:104,\DW_OP_reg25:105,DW_OP_reg26:106,DW_OP_reg27:107,DW_OP_reg28:108,DW_OP_reg29:109,DW_OP_reg30:110,DW_OP_reg31:111,DW_OP_breg0:112,DW_OP_breg1:113,DW_OP_breg2:114,DW_OP_breg3:115,DW_OP_breg4:116,DW_OP_breg5:117,DW_OP_breg6:118,DW_OP_breg7:119,DW_OP_breg8:120,DW_OP_breg9:121,DW_OP_breg10:122,DW_OP_breg11:123,DW_OP_breg12:124,DW_OP_breg13:125,DW_OP_breg14:126,DW_OP_breg15:127,DW_OP_breg16:128,DW_OP_breg17:129,DW_OP_breg18:130,DW_OP_breg19:131,DW_OP_breg20:132,DW_OP_breg21:133,DW_OP_breg22:134,DW_OP_breg23:135,DW_OP_breg24:136,\DW_OP_breg25:137,DW_OP_breg26:138,DW_OP_breg27:139,DW_OP_breg28:140,DW_OP_breg29:141,DW_OP_breg30:142,DW_OP_breg31:143,DW_OP_regx:144,DW_OP_fbreg:145,DW_OP_bregx:146,DW_OP_piece:147,DW_OP_deref_size:148,DW_OP_xderef_size:149,DW_OP_nop:150,;dwarf_type:T(13,5)=eDW_ATE_void:0,DW_ATE_address:1,DW_ATE_boolean:2,DW_ATE_complex_float:3,DW_ATE_float:4,DW_ATE_signed:5,DW_ATE_signed_char:6,DW_ATE_unsigned:7,DW_ATE_unsigned_char:8,;dwarf_array_dim_ordering:T(13,6)=eDW_ORD_row_major:0,DW_ORD_col_major:1,;dwarf_access_attribute:T(13,7)=eDW_ACCESS_public:1,DW_ACCESS_protected:2,DW_ACCESS_private:3,;dwarf_visibility_attribute:T(13,8)=eDW_VIS_local:1,DW_VIS_exported:2,DW_VIS_qualified:3,;dwarf_virtuality_attribute:T(13,9)=eDW_VIRTUALITY_none:0,DW_VIRTUALITY_virtual:1,DW_VIRTUALITY_pure_virtual:2,;dwarf_id_case:T(13,10)=eDW_ID_case_sensitive:0,DW_ID_up_case:1,DW_ID_down_case:2,DW_ID_case_insensitive:3,;dwarf_calling_convention:T(13,11)=eDW_CC_normal:1,DW_CC_program:2,DW_CC_nocall:3,;dwarf_inline_attribute:T(13,12)=eDW_INL_not_inlined:0,DW_INL_inlined:1,DW_INL_declared_not_inlined:2,DW_INL_declared_inlined:3,;dwarf_discrim_list:T(13,13)=eDW_DSC_label:0,DW_DSC_range:1,;dwarf_line_number_ops:T(13,14)=eDW_LNS_extended_op:0,DW_LNS_copy:1,DW_LNS_advance_pc:2,DW_LNS_advance_line:3,DW_LNS_set_file:4,DW_LNS_set_column:5,DW_LNS_negate_stmt:6,DW_LNS_set_basic_block:7,DW_LNS_const_add_pc:8,DW_LNS_fixed_advance_pc:9,;dwarf_line_number_x_ops:T(13,15)=eDW_LNE_end_sequence:1,DW_LNE_set_address:2,DW_LNE_define_file:3,;dwarf_call_frame_info:T(13,16)=eDW_CFA_advance_loc:64,DW_CFA_offset:128,DW_CFA_restore:192,DW_CFA_nop:0,DW_CFA_set_loc:1,DW_CFA_advance_loc1:2,DW_CFA_advance_loc2:3,DW_CFA_advance_loc4:4,DW_CFA_offset_extended:5,DW_CFA_restore_extended:6,DW_CFA_undefined:7,DW_CFA_same_value:8,DW_CFA_register:9,DW_CFA_remember_state:10,DW_CFA_restore_state:11,DW_CFA_def_cfa:12,DW_CFA_def_cfa_register:13,DW_CFA_def_cfa_offset:14,DW_CFA_MIPS_advance_loc8:29,DW_CFA_GNU_window_save:45,DW_CFA_GNU_args_size:46,;dwarf_source_language:T(13,17)=eDW_LANG_C89:1,DW_LANG_C:2,DW_LANG_Ada83:3,DW_LANG_C_plus_plus:4,DW_LANG_Cobol74:5,DW_LANG_Cobol85:6,DW_LANG_Fortran77:7,DW_LANG_Fortran90:8,DW_LANG_Pascal83:9,DW_LANG_Modula2:10,DW_LANG_Mips_Assembler:32769,;dwarf_macinfo_record_type:T(13,18)=eDW_MACINFO_define:1,DW_MACINFO_undef:2,DW_MACINFO_start_file:3,DW_MACINFO_end_file:4,DW_MACINFO_vendor_ext:255,;include/stddef.hptrdiff_t:t(14,1)=(0,1)size_t:t(14,2)=(0,4)wchar_t:t(14,3)=(0,3)wint_t:t(14,4)=(0,4)frame.hframe_state:T(15,1)=s532cfa:(15,2)=*(0,19),0,32;eh_ptr:(15,2),32,32;cfa_offset:(0,3),64,32;args_size:(0,3),96,32;reg_or_offset:(15,3)=ar(0,0);0;101;(0,3),128,3264;cfa_reg:(0,9),3392,16;retaddr_column:(0,9),3408,16;saved:(15,4)=ar(0,0);0;101;(0,2),3424,816;;frame_state:t(15,5)=(15,1)object:T(15,6)=s24pc_begin:(15,2),0,32;pc_end:(15,2),32,32;fde_begin:(15,7)=*(15,8)=xsdwarf_fde:,64,32;fde_array:(15,9)=*(15,7),96,32;count:(14,2),128,32;next:(15,10)=*(15,6),160,32;;sword:t(0,20)=(0,1)uword:t(0,21)=(0,4)uaddr:t(0,22)=(0,4)saddr:t(0,23)=(0,1)ubyte:t(0,24)=(0,11)dwarf_cie:T(0,25)=s12length:(0,21),0,32;CIE_id:(0,20),32,32;version:(0,24),64,8;augmentation:(0,26)=ar(0,0);0;-1;(0,2),72,0;;dwarf_fde:T(15,8)=s16length:(0,21),0,32;CIE_delta:(0,20),32,32;pc_begin:(15,2),64,32;pc_range:(0,22),96,32;;fde:t(0,27)=(15,8)cie_info:T(0,28)=s20augmentation:(8,4),0,32;eh_ptr:(15,2),32,32;code_align:(0,1),64,32;data_align:(0,1),96,32;ra_regno:(0,4),128,32;;frame_state_internal:T(0,29)=s536s:(15,1),0,4256;saved_state:(0,30)=*(0,29),4256,32;;decode_uleb128:f(15,2)buf:P(0,31)=*(0,11)r:P(0,32)=*(0,4)decode_sleb128:f(15,2)buf:P(0,31)r:P(0,33)=*(0,1)unaligned:T(0,34)=u8p:(15,2),0,32;b2:(0,9),0,16;b4:(0,4),0,32;b8:(0,7),0,64;;fde_insert:f(0,19)array:P(0,35)=*(0,36)=*(0,27)i:P(14,2)this_fde:P(0,36)count_fdes:f(14,2)this_fde:P(0,36)add_fdes:f(0,19)this_fde:P(0,36)array:P(0,35)i_ptr:P(0,37)=*(14,2)beg_ptr:P(0,38)=*(15,2)end_ptr:P(0,38)frame_init:f(0,19)ob:P(15,10)find_fde:f(0,36)pc:P(15,2)extract_cie_info:f(15,2)f:P(0,36)c:P(0,39)=*(0,28)execute_cfa_insn:f(15,2)p:P(15,2)state:P(0,30)info:P(0,39)pc:P(0,38)__register_frame_info:F(0,19)begin:P(15,2)ob:P(15,10)__register_frame_info_table:F(0,19)begin:P(15,2)ob:P(15,10)__deregister_frame_info:F(0,19)begin:P(15,2)__frame_state_for:F(0,40)=*(15,1)pc_target:P(15,2)state_in:P(0,40)objects:S(15,10)ÔÔ èèä ÌÌ ììûoÿÿþ è è -  $ 7 , ,Ì  A ø øðG&è&èM''S''[+,+, `+L+L e,L,L¨n,ô,ôt,ø,ø{--‚--TŒ.`.`€‘.\€R™5Üî¡9Êت;¤$ ¶;È\ ¼C$ÞÆD;ÕE=,ÙPapyrus3/JpegDir/JpgLossy/JDSAMPLE.C0000755000175000017500000004073307535143454014151 0ustar /* * jdsample.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains upsampling routines. * * Upsampling input data is counted in "row groups". A row group * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size) * sample rows of each component. Upsampling will normally produce * max_v_samp_factor pixel rows from each row group (but this could vary * if the upsampler is applying a scale factor of its own). * * An excellent reference for image resampling is * Digital Image Warping, George Wolberg, 1990. * Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* Pointer to routine to upsample a single component */ typedef JMETHOD(void, upsample1_ptr, (j_decompress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); /* Private subobject */ typedef struct { struct jpeg_upsampler pub; /* public fields */ /* Color conversion buffer. When using separate upsampling and color * conversion steps, this buffer holds one upsampled row group until it * has been color converted and output. * Note: we do not allocate any storage for component(s) which are full-size, * ie do not need rescaling. The corresponding entry of color_buf[] is * simply set to point to the input data array, thereby avoiding copying. */ JSAMPARRAY color_buf[MAX_COMPONENTS]; /* Per-component upsampling method pointers */ upsample1_ptr methods[MAX_COMPONENTS]; int next_row_out; /* counts rows emitted from color_buf */ JDIMENSION rows_to_go; /* counts rows remaining in image */ /* Height of an input row group for each component. */ int rowgroup_height[MAX_COMPONENTS]; /* These arrays save pixel expansion factors so that int_expand need not * recompute them each time. They are unused for other upsampling methods. */ UINT8 h_expand[MAX_COMPONENTS]; UINT8 v_expand[MAX_COMPONENTS]; } my_upsampler; typedef my_upsampler * my_upsample_ptr; /* * Initialize for an upsampling pass. */ METHODDEF(void) start_pass_upsample (j_decompress_ptr cinfo) { my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; /* Mark the conversion buffer empty */ upsample->next_row_out = cinfo->max_v_samp_factor; /* Initialize total-height counter for detecting bottom of image */ upsample->rows_to_go = cinfo->output_height; } /* * Control routine to do upsampling (and color conversion). * * In this version we upsample each component independently. * We upsample one row group into the conversion buffer, then apply * color conversion a row at a time. */ METHODDEF(void) sep_upsample (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail) { my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; int ci; jpeg_component_info * compptr; JDIMENSION num_rows; /* Fill the conversion buffer, if it's empty */ if (upsample->next_row_out >= cinfo->max_v_samp_factor) { for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { /* Invoke per-component upsample method. Notice we pass a POINTER * to color_buf[ci], so that fullsize_upsample can change it. */ (*upsample->methods[ci]) (cinfo, compptr, input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]), upsample->color_buf + ci); } upsample->next_row_out = 0; } /* Color-convert and emit rows */ /* How many we have in the buffer: */ num_rows = (JDIMENSION) (cinfo->max_v_samp_factor - upsample->next_row_out); /* Not more than the distance to the end of the image. Need this test * in case the image height is not a multiple of max_v_samp_factor: */ if (num_rows > upsample->rows_to_go) num_rows = upsample->rows_to_go; /* And not more than what the client can accept: */ out_rows_avail -= *out_row_ctr; if (num_rows > out_rows_avail) num_rows = out_rows_avail; (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf, (JDIMENSION) upsample->next_row_out, output_buf + *out_row_ctr, (int) num_rows); /* Adjust counts */ *out_row_ctr += num_rows; upsample->rows_to_go -= num_rows; upsample->next_row_out += num_rows; /* When the buffer is emptied, declare this input row group consumed */ if (upsample->next_row_out >= cinfo->max_v_samp_factor) (*in_row_group_ctr)++; } /* * These are the routines invoked by sep_upsample to upsample pixel values * of a single component. One row group is processed per call. */ /* * For full-size components, we just make color_buf[ci] point at the * input buffer, and thus avoid copying any data. Note that this is * safe only because sep_upsample doesn't declare the input row group * "consumed" until we are done color converting and emitting it. */ METHODDEF(void) fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) { *output_data_ptr = input_data; } /* * This is a no-op version used for "uninteresting" components. * These components will not be referenced by color conversion. */ METHODDEF(void) noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) { *output_data_ptr = NULL; /* safety check */ } /* * This version handles any integral sampling ratios. * This is not used for typical JPEG files, so it need not be fast. * Nor, for that matter, is it particularly accurate: the algorithm is * simple replication of the input pixel onto the corresponding output * pixels. The hi-falutin sampling literature refers to this as a * "box filter". A box filter tends to introduce visible artifacts, * so if you are actually going to use 3:1 or 4:1 sampling ratios * you would be well advised to improve this code. */ METHODDEF(void) int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) { my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; JSAMPARRAY output_data = *output_data_ptr; register JSAMPROW inptr, outptr; register JSAMPLE invalue; register int h; JSAMPROW outend; int h_expand, v_expand; int inrow, outrow; h_expand = upsample->h_expand[compptr->component_index]; v_expand = upsample->v_expand[compptr->component_index]; inrow = outrow = 0; while (outrow < cinfo->max_v_samp_factor) { /* Generate one output row with proper horizontal expansion */ inptr = input_data[inrow]; outptr = output_data[outrow]; outend = outptr + cinfo->output_width; while (outptr < outend) { invalue = *inptr++; /* don't need GETJSAMPLE() here */ for (h = h_expand; h > 0; h--) { *outptr++ = invalue; } } /* Generate any additional output rows by duplicating the first one */ if (v_expand > 1) { jcopy_sample_rows(output_data, outrow, output_data, outrow+1, v_expand-1, cinfo->output_width); } inrow++; outrow += v_expand; } } /* * Fast processing for the common case of 2:1 horizontal and 1:1 vertical. * It's still a box filter. */ METHODDEF(void) h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) { JSAMPARRAY output_data = *output_data_ptr; register JSAMPROW inptr, outptr; register JSAMPLE invalue; JSAMPROW outend; int inrow; for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) { inptr = input_data[inrow]; outptr = output_data[inrow]; outend = outptr + cinfo->output_width; while (outptr < outend) { invalue = *inptr++; /* don't need GETJSAMPLE() here */ *outptr++ = invalue; *outptr++ = invalue; } } } /* * Fast processing for the common case of 2:1 horizontal and 2:1 vertical. * It's still a box filter. */ METHODDEF(void) h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) { JSAMPARRAY output_data = *output_data_ptr; register JSAMPROW inptr, outptr; register JSAMPLE invalue; JSAMPROW outend; int inrow, outrow; inrow = outrow = 0; while (outrow < cinfo->max_v_samp_factor) { inptr = input_data[inrow]; outptr = output_data[outrow]; outend = outptr + cinfo->output_width; while (outptr < outend) { invalue = *inptr++; /* don't need GETJSAMPLE() here */ *outptr++ = invalue; *outptr++ = invalue; } jcopy_sample_rows(output_data, outrow, output_data, outrow+1, 1, cinfo->output_width); inrow++; outrow += 2; } } /* * Fancy processing for the common case of 2:1 horizontal and 1:1 vertical. * * The upsampling algorithm is linear interpolation between pixel centers, * also known as a "triangle filter". This is a good compromise between * speed and visual quality. The centers of the output pixels are 1/4 and 3/4 * of the way between input pixel centers. * * A note about the "bias" calculations: when rounding fractional values to * integer, we do not want to always round 0.5 up to the next integer. * If we did that, we'd introduce a noticeable bias towards larger values. * Instead, this code is arranged so that 0.5 will be rounded up or down at * alternate pixel locations (a simple ordered dither pattern). */ METHODDEF(void) h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) { JSAMPARRAY output_data = *output_data_ptr; register JSAMPROW inptr, outptr; register int invalue; register JDIMENSION colctr; int inrow; for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) { inptr = input_data[inrow]; outptr = output_data[inrow]; /* Special case for first column */ invalue = GETJSAMPLE(*inptr++); *outptr++ = (JSAMPLE) invalue; *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(*inptr) + 2) >> 2); for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) { /* General case: 3/4 * nearer pixel + 1/4 * further pixel */ invalue = GETJSAMPLE(*inptr++) * 3; *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(inptr[-2]) + 1) >> 2); *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(*inptr) + 2) >> 2); } /* Special case for last column */ invalue = GETJSAMPLE(*inptr); *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(inptr[-1]) + 1) >> 2); *outptr++ = (JSAMPLE) invalue; } } /* * Fancy processing for the common case of 2:1 horizontal and 2:1 vertical. * Again a triangle filter; see comments for h2v1 case, above. * * It is OK for us to reference the adjacent input rows because we demanded * context from the main buffer controller (see initialization code). */ METHODDEF(void) h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) { JSAMPARRAY output_data = *output_data_ptr; register JSAMPROW inptr0, inptr1, outptr; #if BITS_IN_JSAMPLE == 8 register int thiscolsum, lastcolsum, nextcolsum; #else register INT32 thiscolsum, lastcolsum, nextcolsum; #endif register JDIMENSION colctr; int inrow, outrow, v; inrow = outrow = 0; while (outrow < cinfo->max_v_samp_factor) { for (v = 0; v < 2; v++) { /* inptr0 points to nearest input row, inptr1 points to next nearest */ inptr0 = input_data[inrow]; if (v == 0) /* next nearest is row above */ inptr1 = input_data[inrow-1]; else /* next nearest is row below */ inptr1 = input_data[inrow+1]; outptr = output_data[outrow++]; /* Special case for first column */ thiscolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++); nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++); *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 8) >> 4); *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4); lastcolsum = thiscolsum; thiscolsum = nextcolsum; for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) { /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */ /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */ nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++); *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4); *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4); lastcolsum = thiscolsum; thiscolsum = nextcolsum; } /* Special case for last column */ *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4); *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 7) >> 4); } inrow++; } } /* * Module initialization routine for upsampling. */ GLOBAL(void) jinit_upsampler (j_decompress_ptr cinfo) { my_upsample_ptr upsample; int ci; jpeg_component_info * compptr; boolean need_buffer, do_fancy; int h_in_group, v_in_group, h_out_group, v_out_group; upsample = (my_upsample_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_upsampler)); cinfo->upsample = (struct jpeg_upsampler *) upsample; upsample->pub.start_pass = start_pass_upsample; upsample->pub.upsample = sep_upsample; upsample->pub.need_context_rows = FALSE; /* until we find out differently */ if (cinfo->CCIR601_sampling) /* this isn't supported */ ERREXIT(cinfo, JERR_CCIR601_NOTIMPL); /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1, * so don't ask for it. */ do_fancy = cinfo->do_fancy_upsampling && cinfo->min_DCT_scaled_size > 1; /* Verify we can handle the sampling factors, select per-component methods, * and create storage as needed. */ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { /* Compute size of an "input group" after IDCT scaling. This many samples * are to be converted to max_h_samp_factor * max_v_samp_factor pixels. */ h_in_group = (compptr->h_samp_factor * compptr->DCT_scaled_size) / cinfo->min_DCT_scaled_size; v_in_group = (compptr->v_samp_factor * compptr->DCT_scaled_size) / cinfo->min_DCT_scaled_size; h_out_group = cinfo->max_h_samp_factor; v_out_group = cinfo->max_v_samp_factor; upsample->rowgroup_height[ci] = v_in_group; /* save for use later */ need_buffer = TRUE; if (! compptr->component_needed) { /* Don't bother to upsample an uninteresting component. */ upsample->methods[ci] = noop_upsample; need_buffer = FALSE; } else if (h_in_group == h_out_group && v_in_group == v_out_group) { /* Fullsize components can be processed without any work. */ upsample->methods[ci] = fullsize_upsample; need_buffer = FALSE; } else if (h_in_group * 2 == h_out_group && v_in_group == v_out_group) { /* Special cases for 2h1v upsampling */ if (do_fancy && compptr->downsampled_width > 2) upsample->methods[ci] = h2v1_fancy_upsample; else upsample->methods[ci] = h2v1_upsample; } else if (h_in_group * 2 == h_out_group && v_in_group * 2 == v_out_group) { /* Special cases for 2h2v upsampling */ if (do_fancy && compptr->downsampled_width > 2) { upsample->methods[ci] = h2v2_fancy_upsample; upsample->pub.need_context_rows = TRUE; } else upsample->methods[ci] = h2v2_upsample; } else if ((h_out_group % h_in_group) == 0 && (v_out_group % v_in_group) == 0) { /* Generic integral-factors upsampling method */ upsample->methods[ci] = int_upsample; upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group); upsample->v_expand[ci] = (UINT8) (v_out_group / v_in_group); } else ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL); if (need_buffer) { upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) jround_up((long) cinfo->output_width, (long) cinfo->max_h_samp_factor), (JDIMENSION) cinfo->max_v_samp_factor); } } } Papyrus3/JpegDir/JpgLossy/JDHUFF.H0000755000175000017500000002022307535143454013715 0ustar /* * jdhuff.h * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains declarations for Huffman entropy decoding routines * that are shared between the sequential decoder (jdhuff.c) and the * progressive decoder (jdphuff.c). No other modules need to see these. */ /* Short forms of external names for systems with brain-damaged linkers. */ #ifdef NEED_SHORT_EXTERNAL_NAMES #define jpeg_make_d_derived_tbl jMkDDerived #define jpeg_fill_bit_buffer jFilBitBuf #define jpeg_huff_decode jHufDecode #endif /* NEED_SHORT_EXTERNAL_NAMES */ /* Derived data constructed for each Huffman table */ #define HUFF_LOOKAHEAD 8 /* # of bits of lookahead */ typedef struct { /* Basic tables: (element [0] of each array is unused) */ INT32 maxcode[18]; /* largest code of length k (-1 if none) */ /* (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) */ INT32 valoffset[17]; /* huffval[] offset for codes of length k */ /* valoffset[k] = huffval[] index of 1st symbol of code length k, less * the smallest code of length k; so given a code of length k, the * corresponding symbol is huffval[code + valoffset[k]] */ /* Link to public Huffman table (needed only in jpeg_huff_decode) */ JHUFF_TBL *pub; /* Lookahead tables: indexed by the next HUFF_LOOKAHEAD bits of * the input data stream. If the next Huffman code is no more * than HUFF_LOOKAHEAD bits long, we can obtain its length and * the corresponding symbol directly from these tables. */ int look_nbits[1< 32 bits on your machine, and shifting/masking longs is * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE * appropriately should be a win. Unfortunately we can't define the size * with something like #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8) * because not all machines measure sizeof in 8-bit bytes. */ typedef struct { /* Bitreading state saved across MCUs */ bit_buf_type get_buffer; /* current bit-extraction buffer */ int bits_left; /* # of unused bits in it */ } bitread_perm_state; typedef struct { /* Bitreading working state within an MCU */ /* Current data source location */ /* We need a copy, rather than munging the original, in case of suspension */ const JOCTET * next_input_byte; /* => next byte to read from source */ size_t bytes_in_buffer; /* # of bytes remaining in source buffer */ /* Bit input buffer --- note these values are kept in register variables, * not in this struct, inside the inner loops. */ bit_buf_type get_buffer; /* current bit-extraction buffer */ int bits_left; /* # of unused bits in it */ /* Pointer needed by jpeg_fill_bit_buffer. */ j_decompress_ptr cinfo; /* back link to decompress master record */ } bitread_working_state; /* Macros to declare and load/save bitread local variables. */ #define BITREAD_STATE_VARS \ register bit_buf_type get_buffer; \ register int bits_left; \ bitread_working_state br_state #define BITREAD_LOAD_STATE(cinfop,permstate) \ br_state.cinfo = cinfop; \ br_state.next_input_byte = cinfop->src->next_input_byte; \ br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \ get_buffer = permstate.get_buffer; \ bits_left = permstate.bits_left; #define BITREAD_SAVE_STATE(cinfop,permstate) \ cinfop->src->next_input_byte = br_state.next_input_byte; \ cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \ permstate.get_buffer = get_buffer; \ permstate.bits_left = bits_left /* * These macros provide the in-line portion of bit fetching. * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer * before using GET_BITS, PEEK_BITS, or DROP_BITS. * The variables get_buffer and bits_left are assumed to be locals, * but the state struct might not be (jpeg_huff_decode needs this). * CHECK_BIT_BUFFER(state,n,action); * Ensure there are N bits in get_buffer; if suspend, take action. * val = GET_BITS(n); * Fetch next N bits. * val = PEEK_BITS(n); * Fetch next N bits without removing them from the buffer. * DROP_BITS(n); * Discard next N bits. * The value N should be a simple variable, not an expression, because it * is evaluated multiple times. */ #define CHECK_BIT_BUFFER(state,nbits,action) \ { if (bits_left < (nbits)) { \ if (! jpeg_fill_bit_buffer(&(state),get_buffer,bits_left,nbits)) \ { action; } \ get_buffer = (state).get_buffer; bits_left = (state).bits_left; } } #define GET_BITS(nbits) \ (((int) (get_buffer >> (bits_left -= (nbits)))) & ((1<<(nbits))-1)) #define PEEK_BITS(nbits) \ (((int) (get_buffer >> (bits_left - (nbits)))) & ((1<<(nbits))-1)) #define DROP_BITS(nbits) \ (bits_left -= (nbits)) /* Load up the bit buffer to a depth of at least nbits */ EXTERN(boolean) jpeg_fill_bit_buffer JPP((bitread_working_state * state, register bit_buf_type get_buffer, register int bits_left, int nbits)); /* * Code for extracting next Huffman-coded symbol from input bit stream. * Again, this is time-critical and we make the main paths be macros. * * We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits * without looping. Usually, more than 95% of the Huffman codes will be 8 * or fewer bits long. The few overlength codes are handled with a loop, * which need not be inline code. * * Notes about the HUFF_DECODE macro: * 1. Near the end of the data segment, we may fail to get enough bits * for a lookahead. In that case, we do it the hard way. * 2. If the lookahead table contains no entry, the next code must be * more than HUFF_LOOKAHEAD bits long. * 3. jpeg_huff_decode returns -1 if forced to suspend. */ #define HUFF_DECODE(result,state,htbl,failaction,slowlabel) \ { register int nb, look; \ if (bits_left < HUFF_LOOKAHEAD) { \ if (! jpeg_fill_bit_buffer(&state,get_buffer,bits_left, 0)) {failaction;} \ get_buffer = state.get_buffer; bits_left = state.bits_left; \ if (bits_left < HUFF_LOOKAHEAD) { \ nb = 1; goto slowlabel; \ } \ } \ look = PEEK_BITS(HUFF_LOOKAHEAD); \ if ((nb = htbl->look_nbits[look]) != 0) { \ DROP_BITS(nb); \ result = htbl->look_sym[look]; \ } else { \ nb = HUFF_LOOKAHEAD+1; \ slowlabel: \ if ((result=jpeg_huff_decode(&state,get_buffer,bits_left,htbl,nb)) < 0) \ { failaction; } \ get_buffer = state.get_buffer; bits_left = state.bits_left; \ } \ } /* Out-of-line case for Huffman code fetching */ EXTERN(int) jpeg_huff_decode JPP((bitread_working_state * state, register bit_buf_type get_buffer, register int bits_left, d_derived_tbl * htbl, int min_bits)); Papyrus3/JpegDir/JpgLossy/cjpeg.10000755000175000017500000002426207535143454014017 0ustar .TH CJPEG 1 "20 March 1998" .SH NAME cjpeg \- compress an image file to a JPEG file .SH SYNOPSIS .B cjpeg [ .I options ] [ .I filename ] .LP .SH DESCRIPTION .LP .B cjpeg compresses the named image file, or the standard input if no file is named, and produces a JPEG/JFIF file on the standard output. The currently supported input file formats are: PPM (PBMPLUS color format), PGM (PBMPLUS gray-scale format), BMP, Targa, and RLE (Utah Raster Toolkit format). (RLE is supported only if the URT library is available.) .SH OPTIONS All switch names may be abbreviated; for example, .B \-grayscale may be written .B \-gray or .BR \-gr . Most of the "basic" switches can be abbreviated to as little as one letter. Upper and lower case are equivalent (thus .B \-BMP is the same as .BR \-bmp ). British spellings are also accepted (e.g., .BR \-greyscale ), though for brevity these are not mentioned below. .PP The basic switches are: .TP .BI \-quality " N" Scale quantization tables to adjust image quality. Quality is 0 (worst) to 100 (best); default is 75. (See below for more info.) .TP .B \-grayscale Create monochrome JPEG file from color input. Be sure to use this switch when compressing a grayscale BMP file, because .B cjpeg isn't bright enough to notice whether a BMP file uses only shades of gray. By saying .BR \-grayscale , you'll get a smaller JPEG file that takes less time to process. .TP .B \-optimize Perform optimization of entropy encoding parameters. Without this, default encoding parameters are used. .B \-optimize usually makes the JPEG file a little smaller, but .B cjpeg runs somewhat slower and needs much more memory. Image quality and speed of decompression are unaffected by .BR \-optimize . .TP .B \-progressive Create progressive JPEG file (see below). .TP .B \-targa Input file is Targa format. Targa files that contain an "identification" field will not be automatically recognized by .BR cjpeg ; for such files you must specify .B \-targa to make .B cjpeg treat the input as Targa format. For most Targa files, you won't need this switch. .PP The .B \-quality switch lets you trade off compressed file size against quality of the reconstructed image: the higher the quality setting, the larger the JPEG file, and the closer the output image will be to the original input. Normally you want to use the lowest quality setting (smallest file) that decompresses into something visually indistinguishable from the original image. For this purpose the quality setting should be between 50 and 95; the default of 75 is often about right. If you see defects at .B \-quality 75, then go up 5 or 10 counts at a time until you are happy with the output image. (The optimal setting will vary from one image to another.) .PP .B \-quality 100 will generate a quantization table of all 1's, minimizing loss in the quantization step (but there is still information loss in subsampling, as well as roundoff error). This setting is mainly of interest for experimental purposes. Quality values above about 95 are .B not recommended for normal use; the compressed file size goes up dramatically for hardly any gain in output image quality. .PP In the other direction, quality values below 50 will produce very small files of low image quality. Settings around 5 to 10 might be useful in preparing an index of a large image library, for example. Try .B \-quality 2 (or so) for some amusing Cubist effects. (Note: quality values below about 25 generate 2-byte quantization tables, which are considered optional in the JPEG standard. .B cjpeg emits a warning message when you give such a quality value, because some other JPEG programs may be unable to decode the resulting file. Use .B \-baseline if you need to ensure compatibility at low quality values.) .PP The .B \-progressive switch creates a "progressive JPEG" file. In this type of JPEG file, the data is stored in multiple scans of increasing quality. If the file is being transmitted over a slow communications link, the decoder can use the first scan to display a low-quality image very quickly, and can then improve the display with each subsequent scan. The final image is exactly equivalent to a standard JPEG file of the same quality setting, and the total file size is about the same --- often a little smaller. .B Caution: progressive JPEG is not yet widely implemented, so many decoders will be unable to view a progressive JPEG file at all. .PP Switches for advanced users: .TP .B \-dct int Use integer DCT method (default). .TP .B \-dct fast Use fast integer DCT (less accurate). .TP .B \-dct float Use floating-point DCT method. The float method is very slightly more accurate than the int method, but is much slower unless your machine has very fast floating-point hardware. Also note that results of the floating-point method may vary slightly across machines, while the integer methods should give the same results everywhere. The fast integer method is much less accurate than the other two. .TP .BI \-restart " N" Emit a JPEG restart marker every N MCU rows, or every N MCU blocks if "B" is attached to the number. .B \-restart 0 (the default) means no restart markers. .TP .BI \-smooth " N" Smooth the input image to eliminate dithering noise. N, ranging from 1 to 100, indicates the strength of smoothing. 0 (the default) means no smoothing. .TP .BI \-maxmemory " N" Set limit for amount of memory to use in processing large images. Value is in thousands of bytes, or millions of bytes if "M" is attached to the number. For example, .B \-max 4m selects 4000000 bytes. If more space is needed, temporary files will be used. .TP .BI \-outfile " name" Send output image to the named file, not to standard output. .TP .B \-verbose Enable debug printout. More .BR \-v 's give more output. Also, version information is printed at startup. .TP .B \-debug Same as .BR \-verbose . .PP The .B \-restart option inserts extra markers that allow a JPEG decoder to resynchronize after a transmission error. Without restart markers, any damage to a compressed file will usually ruin the image from the point of the error to the end of the image; with restart markers, the damage is usually confined to the portion of the image up to the next restart marker. Of course, the restart markers occupy extra space. We recommend .B \-restart 1 for images that will be transmitted across unreliable networks such as Usenet. .PP The .B \-smooth option filters the input to eliminate fine-scale noise. This is often useful when converting dithered images to JPEG: a moderate smoothing factor of 10 to 50 gets rid of dithering patterns in the input file, resulting in a smaller JPEG file and a better-looking image. Too large a smoothing factor will visibly blur the image, however. .PP Switches for wizards: .TP .B \-baseline Force baseline-compatible quantization tables to be generated. This clamps quantization values to 8 bits even at low quality settings. (This switch is poorly named, since it does not ensure that the output is actually baseline JPEG. For example, you can use .B \-baseline and .B \-progressive together.) .TP .BI \-qtables " file" Use the quantization tables given in the specified text file. .TP .BI \-qslots " N[,...]" Select which quantization table to use for each color component. .TP .BI \-sample " HxV[,...]" Set JPEG sampling factors for each color component. .TP .BI \-scans " file" Use the scan script given in the specified text file. .PP The "wizard" switches are intended for experimentation with JPEG. If you don't know what you are doing, \fBdon't use them\fR. These switches are documented further in the file wizard.doc. .SH EXAMPLES .LP This example compresses the PPM file foo.ppm with a quality factor of 60 and saves the output as foo.jpg: .IP .B cjpeg \-quality .I 60 foo.ppm .B > .I foo.jpg .SH HINTS Color GIF files are not the ideal input for JPEG; JPEG is really intended for compressing full-color (24-bit) images. In particular, don't try to convert cartoons, line drawings, and other images that have only a few distinct colors. GIF works great on these, JPEG does not. If you want to convert a GIF to JPEG, you should experiment with .BR cjpeg 's .B \-quality and .B \-smooth options to get a satisfactory conversion. .B \-smooth 10 or so is often helpful. .PP Avoid running an image through a series of JPEG compression/decompression cycles. Image quality loss will accumulate; after ten or so cycles the image may be noticeably worse than it was after one cycle. It's best to use a lossless format while manipulating an image, then convert to JPEG format when you are ready to file the image away. .PP The .B \-optimize option to .B cjpeg is worth using when you are making a "final" version for posting or archiving. It's also a win when you are using low quality settings to make very small JPEG files; the percentage improvement is often a lot more than it is on larger files. (At present, .B \-optimize mode is always selected when generating progressive JPEG files.) .SH ENVIRONMENT .TP .B JPEGMEM If this environment variable is set, its value is the default memory limit. The value is specified as described for the .B \-maxmemory switch. .B JPEGMEM overrides the default value specified when the program was compiled, and itself is overridden by an explicit .BR \-maxmemory . .SH SEE ALSO .BR djpeg (1), .BR jpegtran (1), .BR rdjpgcom (1), .BR wrjpgcom (1) .br .BR ppm (5), .BR pgm (5) .br Wallace, Gregory K. "The JPEG Still Picture Compression Standard", Communications of the ACM, April 1991 (vol. 34, no. 4), pp. 30-44. .SH AUTHOR Independent JPEG Group .SH BUGS Arithmetic coding is not supported for legal reasons. .PP GIF input files are no longer supported, to avoid the Unisys LZW patent. Use a Unisys-licensed program if you need to read a GIF file. (Conversion of GIF files to JPEG is usually a bad idea anyway.) .PP Not all variants of BMP and Targa file formats are supported. .PP The .B \-targa switch is not a bug, it's a feature. (It would be a bug if the Targa format designers had not been clueless.) .PP Still not as fast as we'd like. Papyrus3/JpegDir/JpgLossy/JPEGLIB.H0000755000175000017500000013631207535143454014032 0ustar /* * jpeglib.h * * Copyright (C) 1991-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file defines the application interface for the JPEG library. * Most applications using the library need only include this file, * and perhaps jerror.h if they want to know the exact error codes. */ #ifndef JPEGLIB_H #define JPEGLIB_H /* * First we include the configuration files that record how this * installation of the JPEG library is set up. jconfig.h can be * generated automatically for many systems. jmorecfg.h contains * manual configuration options that most people need not worry about. */ #ifndef JCONFIG_INCLUDED /* in case jinclude.h already did */ #include "jconfig.h" /* widely used configuration options */ #endif #include "jmorecfg.h" /* seldom changed options */ /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PapyDef3.h" #endif #endif /* Version ID for the JPEG library. * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60". */ #define JPEG_LIB_VERSION 62 /* Version 6b */ /* Various constants determining the sizes of things. * All of these are specified by the JPEG standard, so don't change them * if you want to be compatible. */ #define DCTSIZE 8 /* The basic DCT block is 8x8 samples */ #define DCTSIZE2 64 /* DCTSIZE squared; # of elements in a block */ #define NUM_QUANT_TBLS 4 /* Quantization tables are numbered 0..3 */ #define NUM_HUFF_TBLS 4 /* Huffman tables are numbered 0..3 */ #define NUM_ARITH_TBLS 16 /* Arith-coding tables are numbered 0..15 */ #define MAX_COMPS_IN_SCAN 4 /* JPEG limit on # of components in one scan */ #define MAX_SAMP_FACTOR 4 /* JPEG limit on sampling factors */ /* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard; * the PostScript DCT filter can emit files with many more than 10 blocks/MCU. * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU * to handle it. We even let you do this from the jconfig.h file. However, * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe * sometimes emits noncompliant files doesn't mean you should too. */ #define C_MAX_BLOCKS_IN_MCU 10 /* compressor's limit on blocks per MCU */ #ifndef D_MAX_BLOCKS_IN_MCU #define D_MAX_BLOCKS_IN_MCU 10 /* decompressor's limit on blocks per MCU */ #endif /* Data structures for images (arrays of samples and of DCT coefficients). * On 80x86 machines, the image arrays are too big for near pointers, * but the pointer arrays can fit in near memory. */ typedef JSAMPLE FAR *JSAMPROW; /* ptr to one image row of pixel samples. */ typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */ typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */ typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */ typedef JBLOCK FAR *JBLOCKROW; /* pointer to one row of coefficient blocks */ typedef JBLOCKROW *JBLOCKARRAY; /* a 2-D array of coefficient blocks */ typedef JBLOCKARRAY *JBLOCKIMAGE; /* a 3-D array of coefficient blocks */ typedef JCOEF FAR *JCOEFPTR; /* useful in a couple of places */ /* Types for JPEG compression parameters and working tables. */ /* DCT coefficient quantization tables. */ typedef struct { /* This array gives the coefficient quantizers in natural array order * (not the zigzag order in which they are stored in a JPEG DQT marker). * CAUTION: IJG versions prior to v6a kept this array in zigzag order. */ UINT16 quantval[DCTSIZE2]; /* quantization step for each coefficient */ /* This field is used only during compression. It's initialized FALSE when * the table is created, and set TRUE when it's been output to the file. * You could suppress output of a table by setting this to TRUE. * (See jpeg_suppress_tables for an example.) */ boolean sent_table; /* TRUE when table has been output */ } JQUANT_TBL; /* Huffman coding tables. */ typedef struct { /* These two fields directly represent the contents of a JPEG DHT marker */ UINT8 bits[17]; /* bits[k] = # of symbols with codes of */ /* length k bits; bits[0] is unused */ UINT8 huffval[256]; /* The symbols, in order of incr code length */ /* This field is used only during compression. It's initialized FALSE when * the table is created, and set TRUE when it's been output to the file. * You could suppress output of a table by setting this to TRUE. * (See jpeg_suppress_tables for an example.) */ boolean sent_table; /* TRUE when table has been output */ } JHUFF_TBL; /* Basic info about one component (color channel). */ typedef struct { /* These values are fixed over the whole image. */ /* For compression, they must be supplied by parameter setup; */ /* for decompression, they are read from the SOF marker. */ int component_id; /* identifier for this component (0..255) */ int component_index; /* its index in SOF or cinfo->comp_info[] */ int h_samp_factor; /* horizontal sampling factor (1..4) */ int v_samp_factor; /* vertical sampling factor (1..4) */ int quant_tbl_no; /* quantization table selector (0..3) */ /* These values may vary between scans. */ /* For compression, they must be supplied by parameter setup; */ /* for decompression, they are read from the SOS marker. */ /* The decompressor output side may not use these variables. */ int dc_tbl_no; /* DC entropy table selector (0..3) */ int ac_tbl_no; /* AC entropy table selector (0..3) */ /* Remaining fields should be treated as private by applications. */ /* These values are computed during compression or decompression startup: */ /* Component's size in DCT blocks. * Any dummy blocks added to complete an MCU are not counted; therefore * these values do not depend on whether a scan is interleaved or not. */ JDIMENSION width_in_blocks; JDIMENSION height_in_blocks; /* Size of a DCT block in samples. Always DCTSIZE for compression. * For decompression this is the size of the output from one DCT block, * reflecting any scaling we choose to apply during the IDCT step. * Values of 1,2,4,8 are likely to be supported. Note that different * components may receive different IDCT scalings. */ int DCT_scaled_size; /* The downsampled dimensions are the component's actual, unpadded number * of samples at the main buffer (preprocessing/compression interface), thus * downsampled_width = ceil(image_width * Hi/Hmax) * and similarly for height. For decompression, IDCT scaling is included, so * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE) */ JDIMENSION downsampled_width; /* actual width in samples */ JDIMENSION downsampled_height; /* actual height in samples */ /* This flag is used only for decompression. In cases where some of the * components will be ignored (eg grayscale output from YCbCr image), * we can skip most computations for the unused components. */ boolean component_needed; /* do we need the value of this component? */ /* These values are computed before starting a scan of the component. */ /* The decompressor output side may not use these variables. */ int MCU_width; /* number of blocks per MCU, horizontally */ int MCU_height; /* number of blocks per MCU, vertically */ int MCU_blocks; /* MCU_width * MCU_height */ int MCU_sample_width; /* MCU width in samples, MCU_width*DCT_scaled_size */ int last_col_width; /* # of non-dummy blocks across in last MCU */ int last_row_height; /* # of non-dummy blocks down in last MCU */ /* Saved quantization table for component; NULL if none yet saved. * See jdinput.c comments about the need for this information. * This field is currently used only for decompression. */ JQUANT_TBL * quant_table; /* Private per-component storage for DCT or IDCT subsystem. */ void * dct_table; } jpeg_component_info; /* The script for encoding a multiple-scan file is an array of these: */ typedef struct { int comps_in_scan; /* number of components encoded in this scan */ int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */ int Ss, Se; /* progressive JPEG spectral selection parms */ int Ah, Al; /* progressive JPEG successive approx. parms */ } jpeg_scan_info; /* The decompressor can save APPn and COM markers in a list of these: */ typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr; struct jpeg_marker_struct { jpeg_saved_marker_ptr next; /* next in list, or NULL */ UINT8 marker; /* marker code: JPEG_COM, or JPEG_APP0+n */ unsigned int original_length; /* # bytes of data in the file */ unsigned int data_length; /* # bytes of data saved at data[] */ JOCTET FAR * data; /* the data contained in the marker */ /* the marker length word is not counted in data_length or original_length */ }; /* Known color spaces. */ typedef enum { JCS_UNKNOWN, /* error/unspecified */ JCS_GRAYSCALE, /* monochrome */ JCS_RGB, /* red/green/blue */ JCS_YCbCr, /* Y/Cb/Cr (also known as YUV) */ JCS_CMYK, /* C/M/Y/K */ JCS_YCCK /* Y/Cb/Cr/K */ } J_COLOR_SPACE; /* DCT/IDCT algorithm options. */ typedef enum { JDCT_ISLOW, /* slow but accurate integer algorithm */ JDCT_IFAST, /* faster, less accurate integer method */ JDCT_FLOAT /* floating-point: accurate, fast on fast HW */ } J_DCT_METHOD; #ifndef JDCT_DEFAULT /* may be overridden in jconfig.h */ #define JDCT_DEFAULT JDCT_ISLOW #endif #ifndef JDCT_FASTEST /* may be overridden in jconfig.h */ #define JDCT_FASTEST JDCT_IFAST #endif /* Dithering options for decompression. */ typedef enum { JDITHER_NONE, /* no dithering */ JDITHER_ORDERED, /* simple ordered dither */ JDITHER_FS /* Floyd-Steinberg error diffusion dither */ } J_DITHER_MODE; /* Common fields between JPEG compression and decompression master structs. */ #define jpeg_common_fields \ struct jpeg_error_mgr * err; /* Error handler module */\ struct jpeg_memory_mgr * mem; /* Memory manager module */\ struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\ void * client_data; /* Available for use by application */\ boolean is_decompressor; /* So common code can tell which is which */\ int global_state /* For checking call sequence validity */ /* Routines that are to be used by both halves of the library are declared * to receive a pointer to this structure. There are no actual instances of * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct. */ struct jpeg_common_struct { jpeg_common_fields; /* Fields common to both master struct types */ /* Additional fields follow in an actual jpeg_compress_struct or * jpeg_decompress_struct. All three structs must agree on these * initial fields! (This would be a lot cleaner in C++.) */ }; typedef struct jpeg_common_struct * j_common_ptr; typedef struct jpeg_compress_struct * j_compress_ptr; typedef struct jpeg_decompress_struct * j_decompress_ptr; /* Master record for a compression instance */ struct jpeg_compress_struct { jpeg_common_fields; /* Fields shared with jpeg_decompress_struct */ /* Destination for compressed data */ struct jpeg_destination_mgr * dest; /* Description of source image --- these fields must be filled in by * outer application before starting compression. in_color_space must * be correct before you can even call jpeg_set_defaults(). */ JDIMENSION image_width; /* input image width */ JDIMENSION image_height; /* input image height */ int input_components; /* # of color components in input image */ J_COLOR_SPACE in_color_space; /* colorspace of input image */ double input_gamma; /* image gamma of input image */ /* Compression parameters --- these fields must be set before calling * jpeg_start_compress(). We recommend calling jpeg_set_defaults() to * initialize everything to reasonable defaults, then changing anything * the application specifically wants to change. That way you won't get * burnt when new parameters are added. Also note that there are several * helper routines to simplify changing parameters. */ int data_precision; /* bits of precision in image data */ int num_components; /* # of color components in JPEG image */ J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */ jpeg_component_info * comp_info; /* comp_info[i] describes component that appears i'th in SOF */ JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS]; /* ptrs to coefficient quantization tables, or NULL if not defined */ JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; /* ptrs to Huffman coding tables, or NULL if not defined */ UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ int num_scans; /* # of entries in scan_info array */ const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */ /* The default value of scan_info is NULL, which causes a single-scan * sequential JPEG file to be emitted. To create a multi-scan file, * set num_scans and scan_info to point to an array of scan definitions. */ boolean raw_data_in; /* TRUE=caller supplies downsampled data */ boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ boolean optimize_coding; /* TRUE=optimize entropy encoding parms */ boolean CCIR601_sampling; /* TRUE=first samples are cosited */ int smoothing_factor; /* 1..100, or 0 for no input smoothing */ J_DCT_METHOD dct_method; /* DCT algorithm selector */ /* The restart interval can be specified in absolute MCUs by setting * restart_interval, or in MCU rows by setting restart_in_rows * (in which case the correct restart_interval will be figured * for each scan). */ unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */ int restart_in_rows; /* if > 0, MCU rows per restart interval */ /* Parameters controlling emission of special markers. */ boolean write_JFIF_header; /* should a JFIF marker be written? */ UINT8 JFIF_major_version; /* What to write for the JFIF version number */ UINT8 JFIF_minor_version; /* These three values are not used by the JPEG code, merely copied */ /* into the JFIF APP0 marker. density_unit can be 0 for unknown, */ /* 1 for dots/inch, or 2 for dots/cm. Note that the pixel aspect */ /* ratio is defined by X_density/Y_density even when density_unit=0. */ UINT8 density_unit; /* JFIF code for pixel size units */ UINT16 X_density; /* Horizontal pixel density */ UINT16 Y_density; /* Vertical pixel density */ boolean write_Adobe_marker; /* should an Adobe marker be written? */ /* State variable: index of next scanline to be written to * jpeg_write_scanlines(). Application may use this to control its * processing loop, e.g., "while (next_scanline < image_height)". */ JDIMENSION next_scanline; /* 0 .. image_height-1 */ /* Remaining fields are known throughout compressor, but generally * should not be touched by a surrounding application. */ /* * These fields are computed during compression startup */ boolean progressive_mode; /* TRUE if scan script uses progressive mode */ int max_h_samp_factor; /* largest h_samp_factor */ int max_v_samp_factor; /* largest v_samp_factor */ JDIMENSION total_iMCU_rows; /* # of iMCU rows to be input to coef ctlr */ /* The coefficient controller receives data in units of MCU rows as defined * for fully interleaved scans (whether the JPEG file is interleaved or not). * There are v_samp_factor * DCTSIZE sample rows of each component in an * "iMCU" (interleaved MCU) row. */ /* * These fields are valid during any one scan. * They describe the components and MCUs actually appearing in the scan. */ int comps_in_scan; /* # of JPEG components in this scan */ jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]; /* *cur_comp_info[i] describes component that appears i'th in SOS */ JDIMENSION MCUs_per_row; /* # of MCUs across the image */ JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */ int blocks_in_MCU; /* # of DCT blocks per MCU */ int MCU_membership[C_MAX_BLOCKS_IN_MCU]; /* MCU_membership[i] is index in cur_comp_info of component owning */ /* i'th block in an MCU */ int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */ /* * Links to compression subobjects (methods and private variables of modules) */ struct jpeg_comp_master * master; struct jpeg_c_main_controller * main; struct jpeg_c_prep_controller * prep; struct jpeg_c_coef_controller * coef; struct jpeg_marker_writer * marker; struct jpeg_color_converter * cconvert; struct jpeg_downsampler * downsample; struct jpeg_forward_dct * fdct; struct jpeg_entropy_encoder * entropy; jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */ int script_space_size; }; /* Master record for a decompression instance */ struct jpeg_decompress_struct { jpeg_common_fields; /* Fields shared with jpeg_compress_struct */ /* Source of compressed data */ struct jpeg_source_mgr * src; /* Basic description of image --- filled in by jpeg_read_header(). */ /* Application may inspect these values to decide how to process image. */ JDIMENSION image_width; /* nominal image width (from SOF marker) */ JDIMENSION image_height; /* nominal image height */ int num_components; /* # of color components in JPEG image */ J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */ /* Decompression processing parameters --- these fields must be set before * calling jpeg_start_decompress(). Note that jpeg_read_header() initializes * them to default values. */ J_COLOR_SPACE out_color_space; /* colorspace for output */ unsigned int scale_num, scale_denom; /* fraction by which to scale image */ double output_gamma; /* image gamma wanted in output */ boolean buffered_image; /* TRUE=multiple output passes */ boolean raw_data_out; /* TRUE=downsampled data wanted */ J_DCT_METHOD dct_method; /* IDCT algorithm selector */ boolean do_fancy_upsampling; /* TRUE=apply fancy upsampling */ boolean do_block_smoothing; /* TRUE=apply interblock smoothing */ boolean quantize_colors; /* TRUE=colormapped output wanted */ /* the following are ignored if not quantize_colors: */ J_DITHER_MODE dither_mode; /* type of color dithering to use */ boolean two_pass_quantize; /* TRUE=use two-pass color quantization */ int desired_number_of_colors; /* max # colors to use in created colormap */ /* these are significant only in buffered-image mode: */ boolean enable_1pass_quant; /* enable future use of 1-pass quantizer */ boolean enable_external_quant;/* enable future use of external colormap */ boolean enable_2pass_quant; /* enable future use of 2-pass quantizer */ /* Description of actual output image that will be returned to application. * These fields are computed by jpeg_start_decompress(). * You can also use jpeg_calc_output_dimensions() to determine these values * in advance of calling jpeg_start_decompress(). */ JDIMENSION output_width; /* scaled image width */ JDIMENSION output_height; /* scaled image height */ int out_color_components; /* # of color components in out_color_space */ int output_components; /* # of color components returned */ /* output_components is 1 (a colormap index) when quantizing colors; * otherwise it equals out_color_components. */ int rec_outbuf_height; /* min recommended height of scanline buffer */ /* If the buffer passed to jpeg_read_scanlines() is less than this many rows * high, space and time will be wasted due to unnecessary data copying. * Usually rec_outbuf_height will be 1 or 2, at most 4. */ /* When quantizing colors, the output colormap is described by these fields. * The application can supply a colormap by setting colormap non-NULL before * calling jpeg_start_decompress; otherwise a colormap is created during * jpeg_start_decompress or jpeg_start_output. * The map has out_color_components rows and actual_number_of_colors columns. */ int actual_number_of_colors; /* number of entries in use */ JSAMPARRAY colormap; /* The color map as a 2-D pixel array */ /* State variables: these variables indicate the progress of decompression. * The application may examine these but must not modify them. */ /* Row index of next scanline to be read from jpeg_read_scanlines(). * Application may use this to control its processing loop, e.g., * "while (output_scanline < output_height)". */ JDIMENSION output_scanline; /* 0 .. output_height-1 */ /* Current input scan number and number of iMCU rows completed in scan. * These indicate the progress of the decompressor input side. */ int input_scan_number; /* Number of SOS markers seen so far */ JDIMENSION input_iMCU_row; /* Number of iMCU rows completed */ /* The "output scan number" is the notional scan being displayed by the * output side. The decompressor will not allow output scan/row number * to get ahead of input scan/row, but it can fall arbitrarily far behind. */ int output_scan_number; /* Nominal scan number being displayed */ JDIMENSION output_iMCU_row; /* Number of iMCU rows read */ /* Current progression status. coef_bits[c][i] indicates the precision * with which component c's DCT coefficient i (in zigzag order) is known. * It is -1 when no data has yet been received, otherwise it is the point * transform (shift) value for the most recent scan of the coefficient * (thus, 0 at completion of the progression). * This pointer is NULL when reading a non-progressive file. */ int (*coef_bits)[DCTSIZE2]; /* -1 or current Al value for each coef */ /* Internal JPEG parameters --- the application usually need not look at * these fields. Note that the decompressor output side may not use * any parameters that can change between scans. */ /* Quantization and Huffman tables are carried forward across input * datastreams when processing abbreviated JPEG datastreams. */ JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS]; /* ptrs to coefficient quantization tables, or NULL if not defined */ JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; /* ptrs to Huffman coding tables, or NULL if not defined */ /* These parameters are never carried across datastreams, since they * are given in SOF/SOS markers or defined to be reset by SOI. */ int data_precision; /* bits of precision in image data */ jpeg_component_info * comp_info; /* comp_info[i] describes component that appears i'th in SOF */ boolean progressive_mode; /* TRUE if SOFn specifies progressive mode */ boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */ /* These fields record data obtained from optional markers recognized by * the JPEG library. */ boolean saw_JFIF_marker; /* TRUE iff a JFIF APP0 marker was found */ /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */ UINT8 JFIF_major_version; /* JFIF version number */ UINT8 JFIF_minor_version; UINT8 density_unit; /* JFIF code for pixel size units */ UINT16 X_density; /* Horizontal pixel density */ UINT16 Y_density; /* Vertical pixel density */ boolean saw_Adobe_marker; /* TRUE iff an Adobe APP14 marker was found */ UINT8 Adobe_transform; /* Color transform code from Adobe marker */ boolean CCIR601_sampling; /* TRUE=first samples are cosited */ /* Aside from the specific data retained from APPn markers known to the * library, the uninterpreted contents of any or all APPn and COM markers * can be saved in a list for examination by the application. */ jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */ /* Remaining fields are known throughout decompressor, but generally * should not be touched by a surrounding application. */ /* * These fields are computed during decompression startup */ int max_h_samp_factor; /* largest h_samp_factor */ int max_v_samp_factor; /* largest v_samp_factor */ int min_DCT_scaled_size; /* smallest DCT_scaled_size of any component */ JDIMENSION total_iMCU_rows; /* # of iMCU rows in image */ /* The coefficient controller's input and output progress is measured in * units of "iMCU" (interleaved MCU) rows. These are the same as MCU rows * in fully interleaved JPEG scans, but are used whether the scan is * interleaved or not. We define an iMCU row as v_samp_factor DCT block * rows of each component. Therefore, the IDCT output contains * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row. */ JSAMPLE * sample_range_limit; /* table for fast range-limiting */ /* * These fields are valid during any one scan. * They describe the components and MCUs actually appearing in the scan. * Note that the decompressor output side must not use these fields. */ int comps_in_scan; /* # of JPEG components in this scan */ jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]; /* *cur_comp_info[i] describes component that appears i'th in SOS */ JDIMENSION MCUs_per_row; /* # of MCUs across the image */ JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */ int blocks_in_MCU; /* # of DCT blocks per MCU */ int MCU_membership[D_MAX_BLOCKS_IN_MCU]; /* MCU_membership[i] is index in cur_comp_info of component owning */ /* i'th block in an MCU */ int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */ /* This field is shared between entropy decoder and marker parser. * It is either zero or the code of a JPEG marker that has been * read from the data source, but has not yet been processed. */ int unread_marker; /* * Links to decompression subobjects (methods, private variables of modules) */ struct jpeg_decomp_master * master; struct jpeg_d_main_controller * main; struct jpeg_d_coef_controller * coef; struct jpeg_d_post_controller * post; struct jpeg_input_controller * inputctl; struct jpeg_marker_reader * marker; struct jpeg_entropy_decoder * entropy; struct jpeg_inverse_dct * idct; struct jpeg_upsampler * upsample; struct jpeg_color_deconverter * cconvert; struct jpeg_color_quantizer * cquantize; }; /* "Object" declarations for JPEG modules that may be supplied or called * directly by the surrounding application. * As with all objects in the JPEG library, these structs only define the * publicly visible methods and state variables of a module. Additional * private fields may exist after the public ones. */ /* Error handler object */ struct jpeg_error_mgr { /* Error exit handler: does not return to caller */ JMETHOD(void, error_exit, (j_common_ptr cinfo)); /* Conditionally emit a trace or warning message */ JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level)); /* Routine that actually outputs a trace or error message */ JMETHOD(void, output_message, (j_common_ptr cinfo)); /* Format a message string for the most recent JPEG error or message */ JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer)); #define JMSG_LENGTH_MAX 200 /* recommended size of format_message buffer */ /* Reset error state variables at start of a new image */ JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo)); /* The message ID code and any parameters are saved here. * A message can have one string parameter or up to 8 int parameters. */ int msg_code; #define JMSG_STR_PARM_MAX 80 union { int i[8]; char s[JMSG_STR_PARM_MAX]; } msg_parm; /* Standard state variables for error facility */ int trace_level; /* max msg_level that will be displayed */ /* For recoverable corrupt-data errors, we emit a warning message, * but keep going unless emit_message chooses to abort. emit_message * should count warnings in num_warnings. The surrounding application * can check for bad data by seeing if num_warnings is nonzero at the * end of processing. */ long num_warnings; /* number of corrupt-data warnings */ /* These fields point to the table(s) of error message strings. * An application can change the table pointer to switch to a different * message list (typically, to change the language in which errors are * reported). Some applications may wish to add additional error codes * that will be handled by the JPEG library error mechanism; the second * table pointer is used for this purpose. * * First table includes all errors generated by JPEG library itself. * Error code 0 is reserved for a "no such error string" message. */ const char * const * jpeg_message_table; /* Library errors */ int last_jpeg_message; /* Table contains strings 0..last_jpeg_message */ /* Second table can be added by application (see cjpeg/djpeg for example). * It contains strings numbered first_addon_message..last_addon_message. */ const char * const * addon_message_table; /* Non-library errors */ int first_addon_message; /* code for first string in addon table */ int last_addon_message; /* code for last string in addon table */ }; /* Progress monitor object */ struct jpeg_progress_mgr { JMETHOD(void, progress_monitor, (j_common_ptr cinfo)); long pass_counter; /* work units completed in this pass */ long pass_limit; /* total number of work units in this pass */ int completed_passes; /* passes completed so far */ int total_passes; /* total number of passes expected */ }; /* Data destination object for compression */ struct jpeg_destination_mgr { JOCTET * next_output_byte; /* => next byte to write in buffer */ size_t free_in_buffer; /* # of byte spaces remaining in buffer */ JMETHOD(void, init_destination, (j_compress_ptr cinfo)); JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo)); JMETHOD(void, term_destination, (j_compress_ptr cinfo)); }; /* ADD FROM DAB */ typedef struct { struct jpeg_destination_mgr pub; /*public fields */ PAPY_FILE outfile; /* target stream */ JOCTET * buffer; /* start of buffer */ } my_destination_mgr; typedef my_destination_mgr * my_dest_ptr; /* Data source object for decompression */ struct jpeg_source_mgr { const JOCTET * next_input_byte; /* => next byte to read from buffer */ size_t bytes_in_buffer; /* # of bytes remaining in buffer */ JMETHOD(void, init_source, (j_decompress_ptr cinfo)); JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo)); JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes)); JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired)); JMETHOD(void, term_source, (j_decompress_ptr cinfo)); }; /* Memory manager object. * Allocates "small" objects (a few K total), "large" objects (tens of K), * and "really big" objects (virtual arrays with backing store if needed). * The memory manager does not allow individual objects to be freed; rather, * each created object is assigned to a pool, and whole pools can be freed * at once. This is faster and more convenient than remembering exactly what * to free, especially where malloc()/free() are not too speedy. * NB: alloc routines never return NULL. They exit to error_exit if not * successful. */ #define JPOOL_PERMANENT 0 /* lasts until master record is destroyed */ #define JPOOL_IMAGE 1 /* lasts until done with image/datastream */ #define JPOOL_NUMPOOLS 2 typedef struct jvirt_sarray_control * jvirt_sarray_ptr; typedef struct jvirt_barray_control * jvirt_barray_ptr; struct jpeg_memory_mgr { /* Method pointers */ JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id, size_t sizeofobject)); JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id, size_t sizeofobject)); JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id, JDIMENSION samplesperrow, JDIMENSION numrows)); JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id, JDIMENSION blocksperrow, JDIMENSION numrows)); JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo, int pool_id, boolean pre_zero, JDIMENSION samplesperrow, JDIMENSION numrows, JDIMENSION maxaccess)); JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo, int pool_id, boolean pre_zero, JDIMENSION blocksperrow, JDIMENSION numrows, JDIMENSION maxaccess)); JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo)); JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo, jvirt_sarray_ptr ptr, JDIMENSION start_row, JDIMENSION num_rows, boolean writable)); JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo, jvirt_barray_ptr ptr, JDIMENSION start_row, JDIMENSION num_rows, boolean writable)); JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id)); JMETHOD(void, self_destruct, (j_common_ptr cinfo)); /* Limit on memory allocation for this JPEG object. (Note that this is * merely advisory, not a guaranteed maximum; it only affects the space * used for virtual-array buffers.) May be changed by outer application * after creating the JPEG object. */ long max_memory_to_use; /* Maximum allocation request accepted by alloc_large. */ long max_alloc_chunk; }; /* Routine signature for application-supplied marker processing methods. * Need not pass marker code since it is stored in cinfo->unread_marker. */ typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo)); /* Declarations for routines called by application. * The JPP macro hides prototype parameters from compilers that can't cope. * Note JPP requires double parentheses. */ #ifdef HAVE_PROTOTYPES #define JPP(arglist) arglist #else #define JPP(arglist) () #endif /* Short forms of external names for systems with brain-damaged linkers. * We shorten external names to be unique in the first six letters, which * is good enough for all known systems. * (If your compiler itself needs names to be unique in less than 15 * characters, you are out of luck. Get a better compiler.) */ #ifdef NEED_SHORT_EXTERNAL_NAMES #define jpeg_std_error jStdError #define jpeg_CreateCompress jCreaCompress #define jpeg_CreateDecompress jCreaDecompress #define jpeg_destroy_compress jDestCompress #define jpeg_destroy_decompress jDestDecompress #define jpeg_stdio_dest jStdDest #define jpeg_stdio_src jStdSrc #define jpeg_set_defaults jSetDefaults #define jpeg_set_colorspace jSetColorspace #define jpeg_default_colorspace jDefColorspace #define jpeg_set_quality jSetQuality #define jpeg_set_linear_quality jSetLQuality #define jpeg_add_quant_table jAddQuantTable #define jpeg_quality_scaling jQualityScaling #define jpeg_simple_progression jSimProgress #define jpeg_suppress_tables jSuppressTables #define jpeg_alloc_quant_table jAlcQTable #define jpeg_alloc_huff_table jAlcHTable #define jpeg_start_compress jStrtCompress #define jpeg_write_scanlines jWrtScanlines #define jpeg_finish_compress jFinCompress #define jpeg_write_raw_data jWrtRawData #define jpeg_write_marker jWrtMarker #define jpeg_write_m_header jWrtMHeader #define jpeg_write_m_byte jWrtMByte #define jpeg_write_tables jWrtTables #define jpeg_read_header jReadHeader #define jpeg_start_decompress jStrtDecompress #define jpeg_read_scanlines jReadScanlines #define jpeg_finish_decompress jFinDecompress #define jpeg_read_raw_data jReadRawData #define jpeg_has_multiple_scans jHasMultScn #define jpeg_start_output jStrtOutput #define jpeg_finish_output jFinOutput #define jpeg_input_complete jInComplete #define jpeg_new_colormap jNewCMap #define jpeg_consume_input jConsumeInput #define jpeg_calc_output_dimensions jCalcDimensions #define jpeg_save_markers jSaveMarkers #define jpeg_set_marker_processor jSetMarker #define jpeg_read_coefficients jReadCoefs #define jpeg_write_coefficients jWrtCoefs #define jpeg_copy_critical_parameters jCopyCrit #define jpeg_abort_compress jAbrtCompress #define jpeg_abort_decompress jAbrtDecompress #define jpeg_abort jAbort #define jpeg_destroy jDestroy #define jpeg_resync_to_restart jResyncRestart #endif /* NEED_SHORT_EXTERNAL_NAMES */ /* Default error-management setup */ EXTERN(struct jpeg_error_mgr *) jpeg_std_error JPP((struct jpeg_error_mgr * err)); /* Initialization of JPEG compression objects. * jpeg_create_compress() and jpeg_create_decompress() are the exported * names that applications should call. These expand to calls on * jpeg_CreateCompress and jpeg_CreateDecompress with additional information * passed for version mismatch checking. * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx. */ #define jpeg_create_compress(cinfo) \ jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \ (size_t) sizeof(struct jpeg_compress_struct)) #define jpeg_create_decompress(cinfo) \ jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \ (size_t) sizeof(struct jpeg_decompress_struct)) EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo, int version, size_t structsize)); EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo, int version, size_t structsize)); /* Destruction of JPEG compression objects */ EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo)); EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo)); /* Standard data source and destination managers: stdio streams. */ /* Caller is responsible for opening the file before and closing after. */ EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, PAPY_FILE *outfile)); EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, PAPY_FILE infile)); /* Default parameter setup for compression */ EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo)); /* Compression parameter setup aids */ EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo, J_COLOR_SPACE colorspace)); EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo)); EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality, boolean force_baseline)); EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo, int scale_factor, boolean force_baseline)); EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl, const unsigned int *basic_table, int scale_factor, boolean force_baseline)); EXTERN(int) jpeg_quality_scaling JPP((int quality)); EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo)); EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo, boolean suppress)); EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo)); EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo)); /* Main entry points for compression */ EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo, boolean write_all_tables)); EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION num_lines)); EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo)); EXTERN(PapyUShort) Seek_Max_Image( PapyUShort *image, int image_height, int image_width); EXTERN(PapyUShort) Adapt_Image_Compression( PapyUShort **image, PapyUShort Maximum, int image_height, int image_width ); EXTERN(PapyUShort) Extend_Char2Short( PapyUChar *imageChar, PapyUShort **imageShort, int image_height, int image_width ); /* Replaces jpeg_write_scanlines when writing raw downsampled data. */ EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo, JSAMPIMAGE data, JDIMENSION num_lines)); /* Write a special marker. See libjpeg.doc concerning safe usage. */ EXTERN(void) jpeg_write_marker JPP((j_compress_ptr cinfo, int marker, const JOCTET * dataptr, unsigned int datalen)); /* Same, but piecemeal. */ EXTERN(void) jpeg_write_m_header JPP((j_compress_ptr cinfo, int marker, unsigned int datalen)); EXTERN(void) jpeg_write_m_byte JPP((j_compress_ptr cinfo, int val)); /* Alternate compression function: just write an abbreviated table file */ EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo)); /* Decompression startup: read start of JPEG datastream to see what's there */ EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo, boolean require_image)); /* Return value is one of: */ #define JPEG_SUSPENDED 0 /* Suspended due to lack of input data */ #define JPEG_HEADER_OK 1 /* Found valid image datastream */ #define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */ /* If you pass require_image = TRUE (normal case), you need not check for * a TABLES_ONLY return code; an abbreviated file will cause an error exit. * JPEG_SUSPENDED is only possible if you use a data source module that can * give a suspension return (the stdio source module doesn't). */ /* Main entry points for decompression */ EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo)); EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION max_lines)); EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo)); /* Replaces jpeg_read_scanlines when reading raw downsampled data. */ EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo, JSAMPIMAGE data, JDIMENSION max_lines)); /* Additional entry points for buffered-image mode. */ EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo)); EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo, int scan_number)); EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo)); EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo)); EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo)); EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo)); /* Return value is one of: */ /* #define JPEG_SUSPENDED 0 Suspended due to lack of input data */ #define JPEG_REACHED_SOS 1 /* Reached start of new scan */ #define JPEG_REACHED_EOI 2 /* Reached end of image */ #define JPEG_ROW_COMPLETED 3 /* Completed one iMCU row */ #define JPEG_SCAN_COMPLETED 4 /* Completed last iMCU row of a scan */ /* Precalculate output dimensions for current decompression parameters. */ EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo)); /* Control saving of COM and APPn markers into marker_list. */ EXTERN(void) jpeg_save_markers JPP((j_decompress_ptr cinfo, int marker_code, unsigned int length_limit)); /* Install a special processing method for COM or APPn markers. */ EXTERN(void) jpeg_set_marker_processor JPP((j_decompress_ptr cinfo, int marker_code, jpeg_marker_parser_method routine)); /* Read or write raw DCT coefficients --- useful for lossless transcoding. */ EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo)); EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)); EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo)); /* If you choose to abort compression or decompression before completing * jpeg_finish_(de)compress, then you need to clean up to release memory, * temporary files, etc. You can just call jpeg_destroy_(de)compress * if you're done with the JPEG object, but if you want to clean it up and * reuse it, call this: */ EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo)); EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo)); /* Generic versions of jpeg_abort and jpeg_destroy that work on either * flavor of JPEG object. These may be more convenient in some places. */ EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo)); EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo)); /* Default restart-marker-resync procedure for use by data source modules */ EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo, int desired)); /* These marker codes are exported since applications and data source modules * are likely to want to use them. */ #define JPEG_RST0 0xD0 /* RST0 marker code */ #define JPEG_EOI 0xD9 /* EOI marker code */ #define JPEG_APP0 0xE0 /* APP0 marker code */ #define JPEG_COM 0xFE /* COM marker code */ /* If we have a brain-damaged compiler that emits warnings (or worse, errors) * for structure definitions that are never filled in, keep it quiet by * supplying dummy definitions for the various substructures. */ #ifdef INCOMPLETE_TYPES_BROKEN #ifndef JPEG_INTERNALS /* will be defined in jpegint.h */ struct jvirt_sarray_control { long dummy; }; struct jvirt_barray_control { long dummy; }; struct jpeg_comp_master { long dummy; }; struct jpeg_c_main_controller { long dummy; }; struct jpeg_c_prep_controller { long dummy; }; struct jpeg_c_coef_controller { long dummy; }; struct jpeg_marker_writer { long dummy; }; struct jpeg_color_converter { long dummy; }; struct jpeg_downsampler { long dummy; }; struct jpeg_forward_dct { long dummy; }; struct jpeg_entropy_encoder { long dummy; }; struct jpeg_decomp_master { long dummy; }; struct jpeg_d_main_controller { long dummy; }; struct jpeg_d_coef_controller { long dummy; }; struct jpeg_d_post_controller { long dummy; }; struct jpeg_input_controller { long dummy; }; struct jpeg_marker_reader { long dummy; }; struct jpeg_entropy_decoder { long dummy; }; struct jpeg_inverse_dct { long dummy; }; struct jpeg_upsampler { long dummy; }; struct jpeg_color_deconverter { long dummy; }; struct jpeg_color_quantizer { long dummy; }; #endif /* JPEG_INTERNALS */ #endif /* INCOMPLETE_TYPES_BROKEN */ /* * The JPEG library modules define JPEG_INTERNALS before including this file. * The internal structure declarations are read only when that is true. * Applications using the library should not include jpegint.h, but may wish * to include jerror.h. */ #ifdef JPEG_INTERNALS #include "jpegint.h" /* fetch private declarations */ #include "jerror.h" /* fetch error codes too */ #endif #endif /* JPEGLIB_H */ Papyrus3/JpegDir/JpgLossy/install-sh0000755000175000017500000001331207535143454014640 0ustar #!/bin/sh # # install - install a program, script, or datafile # This comes from X11R5 (mit/util/scripts/install.sh). # # Copyright 1991 by the Massachusetts Institute of Technology # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that # copyright notice and this permission notice appear in supporting # documentation, and that the name of M.I.T. not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. M.I.T. makes no representations about the # suitability of this software for any purpose. It is provided "as is" # without express or implied warranty. # # Calling this script install-sh is preferred over install.sh, to prevent # `make' implicit rules from creating a file called install from it # when there is no Makefile. # # This script is compatible with the BSD install script, but was written # from scratch. It can only install one file at a time, a restriction # shared with many OS's install programs. # set DOITPROG to echo to test this script # Don't use :- since 4.3BSD and earlier shells don't like it. doit="${DOITPROG-}" # put in absolute paths if you don't have them in your path; or use env. vars. mvprog="${MVPROG-mv}" cpprog="${CPPROG-cp}" chmodprog="${CHMODPROG-chmod}" chownprog="${CHOWNPROG-chown}" chgrpprog="${CHGRPPROG-chgrp}" stripprog="${STRIPPROG-strip}" rmprog="${RMPROG-rm}" mkdirprog="${MKDIRPROG-mkdir}" transformbasename="" transform_arg="" instcmd="$mvprog" chmodcmd="$chmodprog 0755" chowncmd="" chgrpcmd="" stripcmd="" rmcmd="$rmprog -f" mvcmd="$mvprog" src="" dst="" dir_arg="" while [ x"$1" != x ]; do case $1 in -c) instcmd="$cpprog" shift continue;; -d) dir_arg=true shift continue;; -m) chmodcmd="$chmodprog $2" shift shift continue;; -o) chowncmd="$chownprog $2" shift shift continue;; -g) chgrpcmd="$chgrpprog $2" shift shift continue;; -s) stripcmd="$stripprog" shift continue;; -t=*) transformarg=`echo $1 | sed 's/-t=//'` shift continue;; -b=*) transformbasename=`echo $1 | sed 's/-b=//'` shift continue;; *) if [ x"$src" = x ] then src=$1 else # this colon is to work around a 386BSD /bin/sh bug : dst=$1 fi shift continue;; esac done if [ x"$src" = x ] then echo "install: no input file specified" exit 1 else true fi if [ x"$dir_arg" != x ]; then dst=$src src="" if [ -d $dst ]; then instcmd=: else instcmd=mkdir fi else # Waiting for this to be detected by the "$instcmd $src $dsttmp" command # might cause directories to be created, which would be especially bad # if $src (and thus $dsttmp) contains '*'. if [ -f $src -o -d $src ] then true else echo "install: $src does not exist" exit 1 fi if [ x"$dst" = x ] then echo "install: no destination specified" exit 1 else true fi # If destination is a directory, append the input filename; if your system # does not like double slashes in filenames, you may need to add some logic if [ -d $dst ] then dst="$dst"/`basename $src` else true fi fi ## this sed command emulates the dirname command dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'` # Make sure that the destination directory exists. # this part is taken from Noah Friedman's mkinstalldirs script # Skip lots of stat calls in the usual case. if [ ! -d "$dstdir" ]; then defaultIFS=' ' IFS="${IFS-${defaultIFS}}" oIFS="${IFS}" # Some sh's can't handle IFS=/ for some reason. IFS='%' set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'` IFS="${oIFS}" pathcomp='' while [ $# -ne 0 ] ; do pathcomp="${pathcomp}${1}" shift if [ ! -d "${pathcomp}" ] ; then $mkdirprog "${pathcomp}" else true fi pathcomp="${pathcomp}/" done fi if [ x"$dir_arg" != x ] then $doit $instcmd $dst && if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi && if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi && if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi && if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi else # If we're going to rename the final executable, determine the name now. if [ x"$transformarg" = x ] then dstfile=`basename $dst` else dstfile=`basename $dst $transformbasename | sed $transformarg`$transformbasename fi # don't allow the sed command to completely eliminate the filename if [ x"$dstfile" = x ] then dstfile=`basename $dst` else true fi # Make a temp file name in the proper directory. dsttmp=$dstdir/#inst.$$# # Move or copy the file name to the temp name $doit $instcmd $src $dsttmp && trap "rm -f ${dsttmp}" 0 && # and set any options; do chmod last to preserve setuid bits # If any of these fail, we abort the whole thing. If we want to # ignore errors from any of these, just make sure not to ignore # errors from the above "$doit $instcmd $src $dsttmp" command. if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi && if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi && if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi && if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi && # Now rename the file to the real destination. $doit $rmcmd -f $dstdir/$dstfile && $doit $mvcmd $dsttmp $dstdir/$dstfile fi && exit 0 Papyrus3/JpegDir/JpgLossy/JDMERGE.C0000755000175000017500000003375407535143454014034 0ustar /* * jdmerge.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains code for merged upsampling/color conversion. * * This file combines functions from jdsample.c and jdcolor.c; * read those files first to understand what's going on. * * When the chroma components are to be upsampled by simple replication * (ie, box filtering), we can save some work in color conversion by * calculating all the output pixels corresponding to a pair of chroma * samples at one time. In the conversion equations * R = Y + K1 * Cr * G = Y + K2 * Cb + K3 * Cr * B = Y + K4 * Cb * only the Y term varies among the group of pixels corresponding to a pair * of chroma samples, so the rest of the terms can be calculated just once. * At typical sampling ratios, this eliminates half or three-quarters of the * multiplications needed for color conversion. * * This file currently provides implementations for the following cases: * YCbCr => RGB color conversion only. * Sampling ratios of 2h1v or 2h2v. * No scaling needed at upsample time. * Corner-aligned (non-CCIR601) sampling alignment. * Other special cases could be added, but in most applications these are * the only common cases. (For uncommon cases we fall back on the more * general code in jdsample.c and jdcolor.c.) */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #ifdef UPSAMPLE_MERGING_SUPPORTED /* Private subobject */ typedef struct { struct jpeg_upsampler pub; /* public fields */ /* Pointer to routine to do actual upsampling/conversion of one row group */ JMETHOD(void, upmethod, (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)); /* Private state for YCC->RGB conversion */ int * Cr_r_tab; /* => table for Cr to R conversion */ int * Cb_b_tab; /* => table for Cb to B conversion */ INT32 * Cr_g_tab; /* => table for Cr to G conversion */ INT32 * Cb_g_tab; /* => table for Cb to G conversion */ /* For 2:1 vertical sampling, we produce two output rows at a time. * We need a "spare" row buffer to hold the second output row if the * application provides just a one-row buffer; we also use the spare * to discard the dummy last row if the image height is odd. */ JSAMPROW spare_row; boolean spare_full; /* T if spare buffer is occupied */ JDIMENSION out_row_width; /* samples per output row */ JDIMENSION rows_to_go; /* counts rows remaining in image */ } my_upsampler; typedef my_upsampler * my_upsample_ptr; #define SCALEBITS 16 /* speediest right-shift on some machines */ #define ONE_HALF ((INT32) 1 << (SCALEBITS-1)) #define FIX(x) ((INT32) ((x) * (1L<RGB colorspace conversion. * This is taken directly from jdcolor.c; see that file for more info. */ LOCAL(void) build_ycc_rgb_table (j_decompress_ptr cinfo) { my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; int i; INT32 x; SHIFT_TEMPS upsample->Cr_r_tab = (int *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int)); upsample->Cb_b_tab = (int *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int)); upsample->Cr_g_tab = (INT32 *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32)); upsample->Cb_g_tab = (INT32 *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32)); for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) { /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */ /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */ /* Cr=>R value is nearest int to 1.40200 * x */ upsample->Cr_r_tab[i] = (int) RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS); /* Cb=>B value is nearest int to 1.77200 * x */ upsample->Cb_b_tab[i] = (int) RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS); /* Cr=>G value is scaled-up -0.71414 * x */ upsample->Cr_g_tab[i] = (- FIX(0.71414)) * x; /* Cb=>G value is scaled-up -0.34414 * x */ /* We also add in ONE_HALF so that need not do it in inner loop */ upsample->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF; } } /* * Initialize for an upsampling pass. */ METHODDEF(void) start_pass_merged_upsample (j_decompress_ptr cinfo) { my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; /* Mark the spare buffer empty */ upsample->spare_full = FALSE; /* Initialize total-height counter for detecting bottom of image */ upsample->rows_to_go = cinfo->output_height; } /* * Control routine to do upsampling (and color conversion). * * The control routine just handles the row buffering considerations. */ METHODDEF(void) merged_2v_upsample (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail) /* 2:1 vertical sampling case: may need a spare row. */ { my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; JSAMPROW work_ptrs[2]; JDIMENSION num_rows; /* number of rows returned to caller */ if (upsample->spare_full) { /* If we have a spare row saved from a previous cycle, just return it. */ jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0, 1, upsample->out_row_width); num_rows = 1; upsample->spare_full = FALSE; } else { /* Figure number of rows to return to caller. */ num_rows = 2; /* Not more than the distance to the end of the image. */ if (num_rows > upsample->rows_to_go) num_rows = upsample->rows_to_go; /* And not more than what the client can accept: */ out_rows_avail -= *out_row_ctr; if (num_rows > out_rows_avail) num_rows = out_rows_avail; /* Create output pointer array for upsampler. */ work_ptrs[0] = output_buf[*out_row_ctr]; if (num_rows > 1) { work_ptrs[1] = output_buf[*out_row_ctr + 1]; } else { work_ptrs[1] = upsample->spare_row; upsample->spare_full = TRUE; } /* Now do the upsampling. */ (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, work_ptrs); } /* Adjust counts */ *out_row_ctr += num_rows; upsample->rows_to_go -= num_rows; /* When the buffer is emptied, declare this input row group consumed */ if (! upsample->spare_full) (*in_row_group_ctr)++; } METHODDEF(void) merged_1v_upsample (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail) /* 1:1 vertical sampling case: much easier, never need a spare row. */ { my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; /* Just do the upsampling. */ (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, output_buf + *out_row_ctr); /* Adjust counts */ (*out_row_ctr)++; (*in_row_group_ctr)++; } /* * These are the routines invoked by the control routines to do * the actual upsampling/conversion. One row group is processed per call. * * Note: since we may be writing directly into application-supplied buffers, * we have to be honest about the output width; we can't assume the buffer * has been rounded up to an even width. */ /* * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical. */ METHODDEF(void) h2v1_merged_upsample (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf) { my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; register int y, cred, cgreen, cblue; int cb, cr; register JSAMPROW outptr; JSAMPROW inptr0, inptr1, inptr2; JDIMENSION col; /* copy these pointers into registers if possible */ register JSAMPLE * range_limit = cinfo->sample_range_limit; int * Crrtab = upsample->Cr_r_tab; int * Cbbtab = upsample->Cb_b_tab; INT32 * Crgtab = upsample->Cr_g_tab; INT32 * Cbgtab = upsample->Cb_g_tab; SHIFT_TEMPS inptr0 = input_buf[0][in_row_group_ctr]; inptr1 = input_buf[1][in_row_group_ctr]; inptr2 = input_buf[2][in_row_group_ctr]; outptr = output_buf[0]; /* Loop for each pair of output pixels */ for (col = cinfo->output_width >> 1; col > 0; col--) { /* Do the chroma part of the calculation */ cb = GETJSAMPLE(*inptr1++); cr = GETJSAMPLE(*inptr2++); cred = Crrtab[cr]; cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); cblue = Cbbtab[cb]; /* Fetch 2 Y values and emit 2 pixels */ y = GETJSAMPLE(*inptr0++); outptr[RGB_RED] = range_limit[y + cred]; outptr[RGB_GREEN] = range_limit[y + cgreen]; outptr[RGB_BLUE] = range_limit[y + cblue]; outptr += RGB_PIXELSIZE; y = GETJSAMPLE(*inptr0++); outptr[RGB_RED] = range_limit[y + cred]; outptr[RGB_GREEN] = range_limit[y + cgreen]; outptr[RGB_BLUE] = range_limit[y + cblue]; outptr += RGB_PIXELSIZE; } /* If image width is odd, do the last output column separately */ if (cinfo->output_width & 1) { cb = GETJSAMPLE(*inptr1); cr = GETJSAMPLE(*inptr2); cred = Crrtab[cr]; cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); cblue = Cbbtab[cb]; y = GETJSAMPLE(*inptr0); outptr[RGB_RED] = range_limit[y + cred]; outptr[RGB_GREEN] = range_limit[y + cgreen]; outptr[RGB_BLUE] = range_limit[y + cblue]; } } /* * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical. */ METHODDEF(void) h2v2_merged_upsample (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf) { my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; register int y, cred, cgreen, cblue; int cb, cr; register JSAMPROW outptr0, outptr1; JSAMPROW inptr00, inptr01, inptr1, inptr2; JDIMENSION col; /* copy these pointers into registers if possible */ register JSAMPLE * range_limit = cinfo->sample_range_limit; int * Crrtab = upsample->Cr_r_tab; int * Cbbtab = upsample->Cb_b_tab; INT32 * Crgtab = upsample->Cr_g_tab; INT32 * Cbgtab = upsample->Cb_g_tab; SHIFT_TEMPS inptr00 = input_buf[0][in_row_group_ctr*2]; inptr01 = input_buf[0][in_row_group_ctr*2 + 1]; inptr1 = input_buf[1][in_row_group_ctr]; inptr2 = input_buf[2][in_row_group_ctr]; outptr0 = output_buf[0]; outptr1 = output_buf[1]; /* Loop for each group of output pixels */ for (col = cinfo->output_width >> 1; col > 0; col--) { /* Do the chroma part of the calculation */ cb = GETJSAMPLE(*inptr1++); cr = GETJSAMPLE(*inptr2++); cred = Crrtab[cr]; cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); cblue = Cbbtab[cb]; /* Fetch 4 Y values and emit 4 pixels */ y = GETJSAMPLE(*inptr00++); outptr0[RGB_RED] = range_limit[y + cred]; outptr0[RGB_GREEN] = range_limit[y + cgreen]; outptr0[RGB_BLUE] = range_limit[y + cblue]; outptr0 += RGB_PIXELSIZE; y = GETJSAMPLE(*inptr00++); outptr0[RGB_RED] = range_limit[y + cred]; outptr0[RGB_GREEN] = range_limit[y + cgreen]; outptr0[RGB_BLUE] = range_limit[y + cblue]; outptr0 += RGB_PIXELSIZE; y = GETJSAMPLE(*inptr01++); outptr1[RGB_RED] = range_limit[y + cred]; outptr1[RGB_GREEN] = range_limit[y + cgreen]; outptr1[RGB_BLUE] = range_limit[y + cblue]; outptr1 += RGB_PIXELSIZE; y = GETJSAMPLE(*inptr01++); outptr1[RGB_RED] = range_limit[y + cred]; outptr1[RGB_GREEN] = range_limit[y + cgreen]; outptr1[RGB_BLUE] = range_limit[y + cblue]; outptr1 += RGB_PIXELSIZE; } /* If image width is odd, do the last output column separately */ if (cinfo->output_width & 1) { cb = GETJSAMPLE(*inptr1); cr = GETJSAMPLE(*inptr2); cred = Crrtab[cr]; cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); cblue = Cbbtab[cb]; y = GETJSAMPLE(*inptr00); outptr0[RGB_RED] = range_limit[y + cred]; outptr0[RGB_GREEN] = range_limit[y + cgreen]; outptr0[RGB_BLUE] = range_limit[y + cblue]; y = GETJSAMPLE(*inptr01); outptr1[RGB_RED] = range_limit[y + cred]; outptr1[RGB_GREEN] = range_limit[y + cgreen]; outptr1[RGB_BLUE] = range_limit[y + cblue]; } } /* * Module initialization routine for merged upsampling/color conversion. * * NB: this is called under the conditions determined by use_merged_upsample() * in jdmaster.c. That routine MUST correspond to the actual capabilities * of this module; no safety checks are made here. */ GLOBAL(void) jinit_merged_upsampler (j_decompress_ptr cinfo) { my_upsample_ptr upsample; upsample = (my_upsample_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_upsampler)); cinfo->upsample = (struct jpeg_upsampler *) upsample; upsample->pub.start_pass = start_pass_merged_upsample; upsample->pub.need_context_rows = FALSE; upsample->out_row_width = cinfo->output_width * cinfo->out_color_components; if (cinfo->max_v_samp_factor == 2) { upsample->pub.upsample = merged_2v_upsample; upsample->upmethod = h2v2_merged_upsample; /* Allocate a spare row buffer */ upsample->spare_row = (JSAMPROW) (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, (size_t) (upsample->out_row_width * SIZEOF(JSAMPLE))); } else { upsample->pub.upsample = merged_1v_upsample; upsample->upmethod = h2v1_merged_upsample; /* No spare row needed */ upsample->spare_row = NULL; } build_ycc_rgb_table(cinfo); } #endif /* UPSAMPLE_MERGING_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/MAKEFILE.VMS0000755000175000017500000001072507535143454014410 0ustar $! Makefile for Independent JPEG Group's software $! $! This is a command procedure for Digital VMS systems that do not have MMS. $! It builds the JPEG software by brute force, recompiling everything whether $! or not it is necessary. It then runs the basic self-test. $! Thanks to Rick Dyson (dyson@iowasp.physics.uiowa.edu) $! and Tim Bell (tbell@netcom.com) for their help. $! $! Read installation instructions before running this!! $! $ If F$Mode () .eqs. "INTERACTIVE" $ Then $ VERIFY = F$Verify (0) $ Else $ VERIFY = F$Verify (1) $ EndIf $ On Control_Y Then GoTo End $ On Error Then GoTo End $ $ If F$GetSyi ("HW_MODEL") .gt. 1023 $ Then $ OPT = "" $ Else $ OPT = ",Sys$Disk:[]makvms.opt/Option" $ EndIf $ $ DoCompile := CC /NoDebug /Optimize /NoList $! $ DoCompile jcapimin.c $ DoCompile jcapistd.c $ DoCompile jctrans.c $ DoCompile jcparam.c $ DoCompile jdatadst.c $ DoCompile jcinit.c $ DoCompile jcmaster.c $ DoCompile jcmarker.c $ DoCompile jcmainct.c $ DoCompile jcprepct.c $ DoCompile jccoefct.c $ DoCompile jccolor.c $ DoCompile jcsample.c $ DoCompile jchuff.c $ DoCompile jcphuff.c $ DoCompile jcdctmgr.c $ DoCompile jfdctfst.c $ DoCompile jfdctflt.c $ DoCompile jfdctint.c $ DoCompile jdapimin.c $ DoCompile jdapistd.c $ DoCompile jdtrans.c $ DoCompile jdatasrc.c $ DoCompile jdmaster.c $ DoCompile jdinput.c $ DoCompile jdmarker.c $ DoCompile jdhuff.c $ DoCompile jdphuff.c $ DoCompile jdmainct.c $ DoCompile jdcoefct.c $ DoCompile jdpostct.c $ DoCompile jddctmgr.c $ DoCompile jidctfst.c $ DoCompile jidctflt.c $ DoCompile jidctint.c $ DoCompile jidctred.c $ DoCompile jdsample.c $ DoCompile jdcolor.c $ DoCompile jquant1.c $ DoCompile jquant2.c $ DoCompile jdmerge.c $ DoCompile jcomapi.c $ DoCompile jutils.c $ DoCompile jerror.c $ DoCompile jmemmgr.c $ DoCompile jmemnobs.c $! $ Library /Create libjpeg.olb jcapimin.obj,jcapistd.obj,jctrans.obj, - jcparam.obj,jdatadst.obj,jcinit.obj,jcmaster.obj,jcmarker.obj, - jcmainct.obj,jcprepct.obj,jccoefct.obj,jccolor.obj,jcsample.obj, - jchuff.obj,jcphuff.obj,jcdctmgr.obj,jfdctfst.obj,jfdctflt.obj, - jfdctint.obj,jdapimin.obj,jdapistd.obj,jdtrans.obj,jdatasrc.obj, - jdmaster.obj,jdinput.obj,jdmarker.obj,jdhuff.obj,jdphuff.obj, - jdmainct.obj,jdcoefct.obj,jdpostct.obj,jddctmgr.obj,jidctfst.obj, - jidctflt.obj,jidctint.obj,jidctred.obj,jdsample.obj,jdcolor.obj, - jquant1.obj,jquant2.obj,jdmerge.obj,jcomapi.obj,jutils.obj, - jerror.obj,jmemmgr.obj,jmemnobs.obj $! $ DoCompile cjpeg.c $ DoCompile rdppm.c $ DoCompile rdgif.c $ DoCompile rdtarga.c $ DoCompile rdrle.c $ DoCompile rdbmp.c $ DoCompile rdswitch.c $ DoCompile cdjpeg.c $! $ Link /NoMap /Executable = cjpeg.exe cjpeg.obj,rdppm.obj,rdgif.obj, - rdtarga.obj,rdrle.obj,rdbmp.obj,rdswitch.obj,cdjpeg.obj,libjpeg.olb/Library'OPT' $! $ DoCompile djpeg.c $ DoCompile wrppm.c $ DoCompile wrgif.c $ DoCompile wrtarga.c $ DoCompile wrrle.c $ DoCompile wrbmp.c $ DoCompile rdcolmap.c $ DoCompile cdjpeg.c $! $ Link /NoMap /Executable = djpeg.exe djpeg.obj,wrppm.obj,wrgif.obj, - wrtarga.obj,wrrle.obj,wrbmp.obj,rdcolmap.obj,cdjpeg.obj,libjpeg.olb/Library'OPT' $! $ DoCompile jpegtran.c $ DoCompile rdswitch.c $ DoCompile cdjpeg.c $ DoCompile transupp.c $! $ Link /NoMap /Executable = jpegtran.exe jpegtran.obj,rdswitch.obj, - cdjpeg.obj,transupp.obj,libjpeg.olb/Library'OPT' $! $ DoCompile rdjpgcom.c $ Link /NoMap /Executable = rdjpgcom.exe rdjpgcom.obj'OPT' $! $ DoCompile wrjpgcom.c $ Link /NoMap /Executable = wrjpgcom.exe wrjpgcom.obj'OPT' $! $! Run the self-test $! $ mcr sys$disk:[]djpeg -dct int -ppm -outfile testout.ppm testorig.jpg $ mcr sys$disk:[]djpeg -dct int -bmp -colors 256 -outfile testout.bmp testorig.jpg $ mcr sys$disk:[]cjpeg -dct int -outfile testout.jpg testimg.ppm $ mcr sys$disk:[]djpeg -dct int -ppm -outfile testoutp.ppm testprog.jpg $ mcr sys$disk:[]cjpeg -dct int -progressive -opt -outfile testoutp.jpg testimg.ppm $ mcr sys$disk:[]jpegtran -outfile testoutt.jpg testprog.jpg $ Backup /Compare/Log testimg.ppm testout.ppm $ Backup /Compare/Log testimg.bmp testout.bmp $ Backup /Compare/Log testimg.jpg testout.jpg $ Backup /Compare/Log testimg.ppm testoutp.ppm $ Backup /Compare/Log testimgp.jpg testoutp.jpg $ Backup /Compare/Log testorig.jpg testoutt.jpg $! $End: $ If Verify Then Set Verify $ Exit Papyrus3/JpegDir/JpgLossy/JDINPUT.C0000755000175000017500000003307107535143454014064 0ustar /* * jdinput.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains input control logic for the JPEG decompressor. * These routines are concerned with controlling the decompressor's input * processing (marker reading and coefficient decoding). The actual input * reading is done in jdmarker.c, jdhuff.c, and jdphuff.c. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* Private state */ typedef struct { struct jpeg_input_controller pub; /* public fields */ boolean inheaders; /* TRUE until first SOS is reached */ } my_input_controller; typedef my_input_controller * my_inputctl_ptr; /* Forward declarations */ METHODDEF(int) consume_markers JPP((j_decompress_ptr cinfo)); /* * Routines to calculate various quantities related to the size of the image. */ LOCAL(void) initial_setup (j_decompress_ptr cinfo) /* Called once, when first SOS marker is reached */ { int ci; jpeg_component_info *compptr; /* Make sure image isn't bigger than I can handle */ if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION || (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION) ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION); /* For now, precision must match compiled-in value... */ if (cinfo->data_precision != BITS_IN_JSAMPLE) ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision); /* Check that number of components won't exceed internal array sizes */ if (cinfo->num_components > MAX_COMPONENTS) ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components, MAX_COMPONENTS); /* Compute maximum sampling factors; check factor validity */ cinfo->max_h_samp_factor = 1; cinfo->max_v_samp_factor = 1; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR || compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR) ERREXIT(cinfo, JERR_BAD_SAMPLING); cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor, compptr->h_samp_factor); cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor, compptr->v_samp_factor); } /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE. * In the full decompressor, this will be overridden by jdmaster.c; * but in the transcoder, jdmaster.c is not used, so we must do it here. */ cinfo->min_DCT_scaled_size = DCTSIZE; /* Compute dimensions of components */ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { compptr->DCT_scaled_size = DCTSIZE; /* Size in DCT blocks */ compptr->width_in_blocks = (JDIMENSION) jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor, (long) (cinfo->max_h_samp_factor * DCTSIZE)); compptr->height_in_blocks = (JDIMENSION) jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor, (long) (cinfo->max_v_samp_factor * DCTSIZE)); /* downsampled_width and downsampled_height will also be overridden by * jdmaster.c if we are doing full decompression. The transcoder library * doesn't use these values, but the calling application might. */ /* Size in samples */ compptr->downsampled_width = (JDIMENSION) jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor, (long) cinfo->max_h_samp_factor); compptr->downsampled_height = (JDIMENSION) jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor, (long) cinfo->max_v_samp_factor); /* Mark component needed, until color conversion says otherwise */ compptr->component_needed = TRUE; /* Mark no quantization table yet saved for component */ compptr->quant_table = NULL; } /* Compute number of fully interleaved MCU rows. */ cinfo->total_iMCU_rows = (JDIMENSION) jdiv_round_up((long) cinfo->image_height, (long) (cinfo->max_v_samp_factor*DCTSIZE)); /* Decide whether file contains multiple scans */ if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode) cinfo->inputctl->has_multiple_scans = TRUE; else cinfo->inputctl->has_multiple_scans = FALSE; } LOCAL(void) per_scan_setup (j_decompress_ptr cinfo) /* Do computations that are needed before processing a JPEG scan */ /* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */ { int ci, mcublks, tmp; jpeg_component_info *compptr; if (cinfo->comps_in_scan == 1) { /* Noninterleaved (single-component) scan */ compptr = cinfo->cur_comp_info[0]; /* Overall image size in MCUs */ cinfo->MCUs_per_row = compptr->width_in_blocks; cinfo->MCU_rows_in_scan = compptr->height_in_blocks; /* For noninterleaved scan, always one block per MCU */ compptr->MCU_width = 1; compptr->MCU_height = 1; compptr->MCU_blocks = 1; compptr->MCU_sample_width = compptr->DCT_scaled_size; compptr->last_col_width = 1; /* For noninterleaved scans, it is convenient to define last_row_height * as the number of block rows present in the last iMCU row. */ tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor); if (tmp == 0) tmp = compptr->v_samp_factor; compptr->last_row_height = tmp; /* Prepare array describing MCU composition */ cinfo->blocks_in_MCU = 1; cinfo->MCU_membership[0] = 0; } else { /* Interleaved (multi-component) scan */ if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN) ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan, MAX_COMPS_IN_SCAN); /* Overall image size in MCUs */ cinfo->MCUs_per_row = (JDIMENSION) jdiv_round_up((long) cinfo->image_width, (long) (cinfo->max_h_samp_factor*DCTSIZE)); cinfo->MCU_rows_in_scan = (JDIMENSION) jdiv_round_up((long) cinfo->image_height, (long) (cinfo->max_v_samp_factor*DCTSIZE)); cinfo->blocks_in_MCU = 0; for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; /* Sampling factors give # of blocks of component in each MCU */ compptr->MCU_width = compptr->h_samp_factor; compptr->MCU_height = compptr->v_samp_factor; compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height; compptr->MCU_sample_width = compptr->MCU_width * compptr->DCT_scaled_size; /* Figure number of non-dummy blocks in last MCU column & row */ tmp = (int) (compptr->width_in_blocks % compptr->MCU_width); if (tmp == 0) tmp = compptr->MCU_width; compptr->last_col_width = tmp; tmp = (int) (compptr->height_in_blocks % compptr->MCU_height); if (tmp == 0) tmp = compptr->MCU_height; compptr->last_row_height = tmp; /* Prepare array describing MCU composition */ mcublks = compptr->MCU_blocks; if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU) ERREXIT(cinfo, JERR_BAD_MCU_SIZE); while (mcublks-- > 0) { cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci; } } } } /* * Save away a copy of the Q-table referenced by each component present * in the current scan, unless already saved during a prior scan. * * In a multiple-scan JPEG file, the encoder could assign different components * the same Q-table slot number, but change table definitions between scans * so that each component uses a different Q-table. (The IJG encoder is not * currently capable of doing this, but other encoders might.) Since we want * to be able to dequantize all the components at the end of the file, this * means that we have to save away the table actually used for each component. * We do this by copying the table at the start of the first scan containing * the component. * The JPEG spec prohibits the encoder from changing the contents of a Q-table * slot between scans of a component using that slot. If the encoder does so * anyway, this decoder will simply use the Q-table values that were current * at the start of the first scan for the component. * * The decompressor output side looks only at the saved quant tables, * not at the current Q-table slots. */ LOCAL(void) latch_quant_tables (j_decompress_ptr cinfo) { int ci, qtblno; jpeg_component_info *compptr; JQUANT_TBL * qtbl; for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; /* No work if we already saved Q-table for this component */ if (compptr->quant_table != NULL) continue; /* Make sure specified quantization table is present */ qtblno = compptr->quant_tbl_no; if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS || cinfo->quant_tbl_ptrs[qtblno] == NULL) ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno); /* OK, save away the quantization table */ qtbl = (JQUANT_TBL *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(JQUANT_TBL)); MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL)); compptr->quant_table = qtbl; } } /* * Initialize the input modules to read a scan of compressed data. * The first call to this is done by jdmaster.c after initializing * the entire decompressor (during jpeg_start_decompress). * Subsequent calls come from consume_markers, below. */ METHODDEF(void) start_input_pass (j_decompress_ptr cinfo) { per_scan_setup(cinfo); latch_quant_tables(cinfo); (*cinfo->entropy->start_pass) (cinfo); (*cinfo->coef->start_input_pass) (cinfo); cinfo->inputctl->consume_input = cinfo->coef->consume_data; } /* * Finish up after inputting a compressed-data scan. * This is called by the coefficient controller after it's read all * the expected data of the scan. */ METHODDEF(void) finish_input_pass (j_decompress_ptr cinfo) { cinfo->inputctl->consume_input = consume_markers; } /* * Read JPEG markers before, between, or after compressed-data scans. * Change state as necessary when a new scan is reached. * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. * * The consume_input method pointer points either here or to the * coefficient controller's consume_data routine, depending on whether * we are reading a compressed data segment or inter-segment markers. */ METHODDEF(int) consume_markers (j_decompress_ptr cinfo) { my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl; int val; if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */ return JPEG_REACHED_EOI; val = (*cinfo->marker->read_markers) (cinfo); switch (val) { case JPEG_REACHED_SOS: /* Found SOS */ if (inputctl->inheaders) { /* 1st SOS */ initial_setup(cinfo); inputctl->inheaders = FALSE; /* Note: start_input_pass must be called by jdmaster.c * before any more input can be consumed. jdapimin.c is * responsible for enforcing this sequencing. */ } else { /* 2nd or later SOS marker */ if (! inputctl->pub.has_multiple_scans) ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */ start_input_pass(cinfo); } break; case JPEG_REACHED_EOI: /* Found EOI */ inputctl->pub.eoi_reached = TRUE; if (inputctl->inheaders) { /* Tables-only datastream, apparently */ if (cinfo->marker->saw_SOF) ERREXIT(cinfo, JERR_SOF_NO_SOS); } else { /* Prevent infinite loop in coef ctlr's decompress_data routine * if user set output_scan_number larger than number of scans. */ if (cinfo->output_scan_number > cinfo->input_scan_number) cinfo->output_scan_number = cinfo->input_scan_number; } break; case JPEG_SUSPENDED: break; } return val; } /* * Reset state to begin a fresh datastream. */ METHODDEF(void) reset_input_controller (j_decompress_ptr cinfo) { my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl; inputctl->pub.consume_input = consume_markers; inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */ inputctl->pub.eoi_reached = FALSE; inputctl->inheaders = TRUE; /* Reset other modules */ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo); (*cinfo->marker->reset_marker_reader) (cinfo); /* Reset progression state -- would be cleaner if entropy decoder did this */ cinfo->coef_bits = NULL; } /* * Initialize the input controller module. * This is called only once, when the decompression object is created. */ GLOBAL(void) jinit_input_controller (j_decompress_ptr cinfo) { my_inputctl_ptr inputctl; /* Create subobject in permanent pool */ inputctl = (my_inputctl_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_input_controller)); cinfo->inputctl = (struct jpeg_input_controller *) inputctl; /* Initialize method pointers */ inputctl->pub.consume_input = consume_markers; inputctl->pub.reset_input_controller = reset_input_controller; inputctl->pub.start_input_pass = start_input_pass; inputctl->pub.finish_input_pass = finish_input_pass; /* Initialize state: can't use reset_input_controller since we don't * want to try to reset other modules yet. */ inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */ inputctl->pub.eoi_reached = FALSE; inputctl->inheaders = TRUE; } Papyrus3/JpegDir/JpgLossy/EXAMPLE.C0000755000175000017500000004216507535143454014046 0ustar /* * example.c * * This file illustrates how to use the IJG code as a subroutine library * to read or write JPEG image files. You should look at this code in * conjunction with the documentation file libjpeg.doc. * * This code will not do anything useful as-is, but it may be helpful as a * skeleton for constructing routines that call the JPEG library. * * We present these routines in the same coding style used in the JPEG code * (ANSI function definitions, etc); but you are of course free to code your * routines in a different style if you prefer. */ #include /* * Include file for users of JPEG library. * You will need to have included system headers that define at least * the typedefs FILE and size_t before you can include jpeglib.h. * (stdio.h is sufficient on ANSI-conforming systems.) * You may also wish to include "jerror.h". */ #include "jpeglib.h" /* * is used for the optional error recovery mechanism shown in * the second part of the example. */ #include /******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/ /* This half of the example shows how to feed data into the JPEG compressor. * We present a minimal version that does not worry about refinements such * as error recovery (the JPEG code will just exit() if it gets an error). */ /* * IMAGE DATA FORMATS: * * The standard input image format is a rectangular array of pixels, with * each pixel having the same number of "component" values (color channels). * Each pixel row is an array of JSAMPLEs (which typically are unsigned chars). * If you are working with color data, then the color values for each pixel * must be adjacent in the row; for example, R,G,B,R,G,B,R,G,B,... for 24-bit * RGB color. * * For this example, we'll assume that this data structure matches the way * our application has stored the image in memory, so we can just pass a * pointer to our image buffer. In particular, let's say that the image is * RGB color and is described by: */ extern JSAMPLE * image_buffer; /* Points to large array of R,G,B-order data */ extern int image_height; /* Number of rows in image */ extern int image_width; /* Number of columns in image */ /* * Sample routine for JPEG compression. We assume that the target file name * and a compression quality factor are passed in. */ GLOBAL(void) write_JPEG_file (char * filename, int quality) { /* This struct contains the JPEG compression parameters and pointers to * working space (which is allocated as needed by the JPEG library). * It is possible to have several such structures, representing multiple * compression/decompression processes, in existence at once. We refer * to any one struct (and its associated working data) as a "JPEG object". */ struct jpeg_compress_struct cinfo; /* This struct represents a JPEG error handler. It is declared separately * because applications often want to supply a specialized error handler * (see the second half of this file for an example). But here we just * take the easy way out and use the standard error handler, which will * print a message on stderr and call exit() if compression fails. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ struct jpeg_error_mgr jerr; /* More stuff */ FILE * outfile; /* target file */ JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */ int row_stride; /* physical row width in image buffer */ /* Step 1: allocate and initialize JPEG compression object */ /* We have to set up the error handler first, in case the initialization * step fails. (Unlikely, but it could happen if you are out of memory.) * This routine fills in the contents of struct jerr, and returns jerr's * address which we place into the link field in cinfo. */ cinfo.err = jpeg_std_error(&jerr); /* Now we can initialize the JPEG compression object. */ jpeg_create_compress(&cinfo); /* Step 2: specify data destination (eg, a file) */ /* Note: steps 2 and 3 can be done in either order. */ /* Here we use the library-supplied code to send compressed data to a * stdio stream. You can also write your own code to do something else. * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that * requires it in order to write binary files. */ if ((outfile = fopen(filename, "wb")) == NULL) { fprintf(stderr, "can't open %s\n", filename); exit(1); } jpeg_stdio_dest(&cinfo, &outfile); /* Step 3: set parameters for compression */ /* First we supply a description of the input image. * Four fields of the cinfo struct must be filled in: */ cinfo.image_width = image_width; /* image width and height, in pixels */ cinfo.image_height = image_height; cinfo.input_components = 3; /* # of color components per pixel */ cinfo.in_color_space = JCS_RGB; /* colorspace of input image */ /* Now use the library's routine to set default compression parameters. * (You must set at least cinfo.in_color_space before calling this, * since the defaults depend on the source color space.) */ jpeg_set_defaults(&cinfo); /* Now you can set any non-default parameters you wish to. * Here we just illustrate the use of quality (quantization table) scaling: */ jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */); /* Step 4: Start compressor */ /* TRUE ensures that we will write a complete interchange-JPEG file. * Pass TRUE unless you are very sure of what you're doing. */ jpeg_start_compress(&cinfo, TRUE); /* Step 5: while (scan lines remain to be written) */ /* jpeg_write_scanlines(...); */ /* Here we use the library's state variable cinfo.next_scanline as the * loop counter, so that we don't have to keep track ourselves. * To keep things simple, we pass one scanline per call; you can pass * more if you wish, though. */ row_stride = image_width * 3; /* JSAMPLEs per row in image_buffer */ while (cinfo.next_scanline < cinfo.image_height) { /* jpeg_write_scanlines expects an array of pointers to scanlines. * Here the array is only one element long, but you could pass * more than one scanline at a time if that's more convenient. */ row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride]; (void) jpeg_write_scanlines(&cinfo, row_pointer, 1); } /* Step 6: Finish compression */ jpeg_finish_compress(&cinfo); /* After finish_compress, we can close the output file. */ fclose(outfile); /* Step 7: release JPEG compression object */ /* This is an important step since it will release a good deal of memory. */ jpeg_destroy_compress(&cinfo); /* And we're done! */ } /* * SOME FINE POINTS: * * In the above loop, we ignored the return value of jpeg_write_scanlines, * which is the number of scanlines actually written. We could get away * with this because we were only relying on the value of cinfo.next_scanline, * which will be incremented correctly. If you maintain additional loop * variables then you should be careful to increment them properly. * Actually, for output to a stdio stream you needn't worry, because * then jpeg_write_scanlines will write all the lines passed (or else exit * with a fatal error). Partial writes can only occur if you use a data * destination module that can demand suspension of the compressor. * (If you don't know what that's for, you don't need it.) * * If the compressor requires full-image buffers (for entropy-coding * optimization or a multi-scan JPEG file), it will create temporary * files for anything that doesn't fit within the maximum-memory setting. * (Note that temp files are NOT needed if you use the default parameters.) * On some systems you may need to set up a signal handler to ensure that * temporary files are deleted if the program is interrupted. See libjpeg.doc. * * Scanlines MUST be supplied in top-to-bottom order if you want your JPEG * files to be compatible with everyone else's. If you cannot readily read * your data in that order, you'll need an intermediate array to hold the * image. See rdtarga.c or rdbmp.c for examples of handling bottom-to-top * source data using the JPEG code's internal virtual-array mechanisms. */ /******************** JPEG DECOMPRESSION SAMPLE INTERFACE *******************/ /* This half of the example shows how to read data from the JPEG decompressor. * It's a bit more refined than the above, in that we show: * (a) how to modify the JPEG library's standard error-reporting behavior; * (b) how to allocate workspace using the library's memory manager. * * Just to make this example a little different from the first one, we'll * assume that we do not intend to put the whole image into an in-memory * buffer, but to send it line-by-line someplace else. We need a one- * scanline-high JSAMPLE array as a work buffer, and we will let the JPEG * memory manager allocate it for us. This approach is actually quite useful * because we don't need to remember to deallocate the buffer separately: it * will go away automatically when the JPEG object is cleaned up. */ /* * ERROR HANDLING: * * The JPEG library's standard error handler (jerror.c) is divided into * several "methods" which you can override individually. This lets you * adjust the behavior without duplicating a lot of code, which you might * have to update with each future release. * * Our example here shows how to override the "error_exit" method so that * control is returned to the library's caller when a fatal error occurs, * rather than calling exit() as the standard error_exit method does. * * We use C's setjmp/longjmp facility to return control. This means that the * routine which calls the JPEG library must first execute a setjmp() call to * establish the return point. We want the replacement error_exit to do a * longjmp(). But we need to make the setjmp buffer accessible to the * error_exit routine. To do this, we make a private extension of the * standard JPEG error handler object. (If we were using C++, we'd say we * were making a subclass of the regular error handler.) * * Here's the extended error handler struct: */ struct my_error_mgr { struct jpeg_error_mgr pub; /* "public" fields */ jmp_buf setjmp_buffer; /* for return to caller */ }; typedef struct my_error_mgr * my_error_ptr; /* * Here's the routine that will replace the standard error_exit method: */ METHODDEF(void) my_error_exit (j_common_ptr cinfo) { /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */ my_error_ptr myerr = (my_error_ptr) cinfo->err; /* Always display the message. */ /* We could postpone this until after returning, if we chose. */ (*cinfo->err->output_message) (cinfo); /* Return control to the setjmp point */ longjmp(myerr->setjmp_buffer, 1); } /* * Sample routine for JPEG decompression. We assume that the source file name * is passed in. We want to return 1 on success, 0 on error. */ GLOBAL(int) read_JPEG_file (char * filename) { /* This struct contains the JPEG decompression parameters and pointers to * working space (which is allocated as needed by the JPEG library). */ struct jpeg_decompress_struct cinfo; /* We use our private extension JPEG error handler. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ struct my_error_mgr jerr; /* More stuff */ FILE * infile; /* source file */ JSAMPARRAY buffer; /* Output row buffer */ int row_stride; /* physical row width in output buffer */ /* In this example we want to open the input file before doing anything else, * so that the setjmp() error recovery below can assume the file is open. * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that * requires it in order to read binary files. */ if ((infile = fopen(filename, "rb")) == NULL) { fprintf(stderr, "can't open %s\n", filename); return 0; } /* Step 1: allocate and initialize JPEG decompression object */ /* We set up the normal JPEG error routines, then override error_exit. */ cinfo.err = jpeg_std_error(&jerr.pub); jerr.pub.error_exit = my_error_exit; /* Establish the setjmp return context for my_error_exit to use. */ if (setjmp(jerr.setjmp_buffer)) { /* If we get here, the JPEG code has signaled an error. * We need to clean up the JPEG object, close the input file, and return. */ jpeg_destroy_decompress(&cinfo); fclose(infile); return 0; } /* Now we can initialize the JPEG decompression object. */ jpeg_create_decompress(&cinfo); /* Step 2: specify data source (eg, a file) */ jpeg_stdio_src(&cinfo, infile); /* Step 3: read file parameters with jpeg_read_header() */ (void) jpeg_read_header(&cinfo, TRUE); /* We can ignore the return value from jpeg_read_header since * (a) suspension is not possible with the stdio data source, and * (b) we passed TRUE to reject a tables-only JPEG file as an error. * See libjpeg.doc for more info. */ /* Step 4: set parameters for decompression */ /* In this example, we don't need to change any of the defaults set by * jpeg_read_header(), so we do nothing here. */ /* Step 5: Start decompressor */ (void) jpeg_start_decompress(&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* We may need to do some setup of our own at this point before reading * the data. After jpeg_start_decompress() we have the correct scaled * output image dimensions available, as well as the output colormap * if we asked for color quantization. * In this example, we need to make an output work buffer of the right size. */ /* JSAMPLEs per row in output buffer */ row_stride = cinfo.output_width * cinfo.output_components; /* Make a one-row-high sample array that will go away when done with image */ buffer = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); /* Step 6: while (scan lines remain to be read) */ /* jpeg_read_scanlines(...); */ /* Here we use the library's state variable cinfo.output_scanline as the * loop counter, so that we don't have to keep track ourselves. */ while (cinfo.output_scanline < cinfo.output_height) { /* jpeg_read_scanlines expects an array of pointers to scanlines. * Here the array is only one element long, but you could ask for * more than one scanline at a time if that's more convenient. */ (void) jpeg_read_scanlines(&cinfo, buffer, 1); /* Assume put_scanline_someplace wants a pointer and sample count. */ put_scanline_someplace(buffer[0], row_stride); } /* Step 7: Finish decompression */ (void) jpeg_finish_decompress(&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* Step 8: Release JPEG decompression object */ /* This is an important step since it will release a good deal of memory. */ jpeg_destroy_decompress(&cinfo); /* After finish_decompress, we can close the input file. * Here we postpone it until after no more JPEG errors are possible, * so as to simplify the setjmp error logic above. (Actually, I don't * think that jpeg_destroy can do an error exit, but why assume anything...) */ fclose(infile); /* At this point you may want to check to see whether any corrupt-data * warnings occurred (test whether jerr.pub.num_warnings is nonzero). */ /* And we're done! */ return 1; } /* * SOME FINE POINTS: * * In the above code, we ignored the return value of jpeg_read_scanlines, * which is the number of scanlines actually read. We could get away with * this because we asked for only one line at a time and we weren't using * a suspending data source. See libjpeg.doc for more info. * * We cheated a bit by calling alloc_sarray() after jpeg_start_decompress(); * we should have done it beforehand to ensure that the space would be * counted against the JPEG max_memory setting. In some systems the above * code would risk an out-of-memory error. However, in general we don't * know the output image dimensions before jpeg_start_decompress(), unless we * call jpeg_calc_output_dimensions(). See libjpeg.doc for more about this. * * Scanlines are returned in the same order as they appear in the JPEG file, * which is standardly top-to-bottom. If you must emit data bottom-to-top, * you can use one of the virtual arrays provided by the JPEG memory manager * to invert the data. See wrbmp.c for an example. * * As with compression, some operating modes may require temporary files. * On some systems you may need to set up a signal handler to ensure that * temporary files are deleted if the program is interrupted. See libjpeg.doc. */ Papyrus3/JpegDir/JpgLossy/filelist.doc0000755000175000017500000002060207535143454015141 0ustar IJG JPEG LIBRARY: FILE LIST Copyright (C) 1994-1998, Thomas G. Lane. This file is part of the Independent JPEG Group's software. For conditions of distribution and use, see the accompanying README file. Here is a road map to the files in the IJG JPEG distribution. The distribution includes the JPEG library proper, plus two application programs ("cjpeg" and "djpeg") which use the library to convert JPEG files to and from some other popular image formats. A third application "jpegtran" uses the library to do lossless conversion between different variants of JPEG. There are also two stand-alone applications, "rdjpgcom" and "wrjpgcom". THE JPEG LIBRARY ================ Include files: jpeglib.h JPEG library's exported data and function declarations. jconfig.h Configuration declarations. Note: this file is not present in the distribution; it is generated during installation. jmorecfg.h Additional configuration declarations; need not be changed for a standard installation. jerror.h Declares JPEG library's error and trace message codes. jinclude.h Central include file used by all IJG .c files to reference system include files. jpegint.h JPEG library's internal data structures. jchuff.h Private declarations for Huffman encoder modules. jdhuff.h Private declarations for Huffman decoder modules. jdct.h Private declarations for forward & reverse DCT subsystems. jmemsys.h Private declarations for memory management subsystem. jversion.h Version information. Applications using the library should include jpeglib.h (which in turn includes jconfig.h and jmorecfg.h). Optionally, jerror.h may be included if the application needs to reference individual JPEG error codes. The other include files are intended for internal use and would not normally be included by an application program. (cjpeg/djpeg/etc do use jinclude.h, since its function is to improve portability of the whole IJG distribution. Most other applications will directly include the system include files they want, and hence won't need jinclude.h.) C source code files: These files contain most of the functions intended to be called directly by an application program: jcapimin.c Application program interface: core routines for compression. jcapistd.c Application program interface: standard compression. jdapimin.c Application program interface: core routines for decompression. jdapistd.c Application program interface: standard decompression. jcomapi.c Application program interface routines common to compression and decompression. jcparam.c Compression parameter setting helper routines. jctrans.c API and library routines for transcoding compression. jdtrans.c API and library routines for transcoding decompression. Compression side of the library: jcinit.c Initialization: determines which other modules to use. jcmaster.c Master control: setup and inter-pass sequencing logic. jcmainct.c Main buffer controller (preprocessor => JPEG compressor). jcprepct.c Preprocessor buffer controller. jccoefct.c Buffer controller for DCT coefficient buffer. jccolor.c Color space conversion. jcsample.c Downsampling. jcdctmgr.c DCT manager (DCT implementation selection & control). jfdctint.c Forward DCT using slow-but-accurate integer method. jfdctfst.c Forward DCT using faster, less accurate integer method. jfdctflt.c Forward DCT using floating-point arithmetic. jchuff.c Huffman entropy coding for sequential JPEG. jcphuff.c Huffman entropy coding for progressive JPEG. jcmarker.c JPEG marker writing. jdatadst.c Data destination manager for stdio output. Decompression side of the library: jdmaster.c Master control: determines which other modules to use. jdinput.c Input controller: controls input processing modules. jdmainct.c Main buffer controller (JPEG decompressor => postprocessor). jdcoefct.c Buffer controller for DCT coefficient buffer. jdpostct.c Postprocessor buffer controller. jdmarker.c JPEG marker reading. jdhuff.c Huffman entropy decoding for sequential JPEG. jdphuff.c Huffman entropy decoding for progressive JPEG. jddctmgr.c IDCT manager (IDCT implementation selection & control). jidctint.c Inverse DCT using slow-but-accurate integer method. jidctfst.c Inverse DCT using faster, less accurate integer method. jidctflt.c Inverse DCT using floating-point arithmetic. jidctred.c Inverse DCTs with reduced-size outputs. jdsample.c Upsampling. jdcolor.c Color space conversion. jdmerge.c Merged upsampling/color conversion (faster, lower quality). jquant1.c One-pass color quantization using a fixed-spacing colormap. jquant2.c Two-pass color quantization using a custom-generated colormap. Also handles one-pass quantization to an externally given map. jdatasrc.c Data source manager for stdio input. Support files for both compression and decompression: jerror.c Standard error handling routines (application replaceable). jmemmgr.c System-independent (more or less) memory management code. jutils.c Miscellaneous utility routines. jmemmgr.c relies on a system-dependent memory management module. The IJG distribution includes the following implementations of the system-dependent module: jmemnobs.c "No backing store": assumes adequate virtual memory exists. jmemansi.c Makes temporary files with ANSI-standard routine tmpfile(). jmemname.c Makes temporary files with program-generated file names. jmemdos.c Custom implementation for MS-DOS (16-bit environment only): can use extended and expanded memory as well as temp files. jmemmac.c Custom implementation for Apple Macintosh. Exactly one of the system-dependent modules should be configured into an installed JPEG library (see install.doc for hints about which one to use). On unusual systems you may find it worthwhile to make a special system-dependent memory manager. Non-C source code files: jmemdosa.asm 80x86 assembly code support for jmemdos.c; used only in MS-DOS-specific configurations of the JPEG library. CJPEG/DJPEG/JPEGTRAN ==================== Include files: cdjpeg.h Declarations shared by cjpeg/djpeg/jpegtran modules. cderror.h Additional error and trace message codes for cjpeg et al. transupp.h Declarations for jpegtran support routines in transupp.c. C source code files: cjpeg.c Main program for cjpeg. djpeg.c Main program for djpeg. jpegtran.c Main program for jpegtran. cdjpeg.c Utility routines used by all three programs. rdcolmap.c Code to read a colormap file for djpeg's "-map" switch. rdswitch.c Code to process some of cjpeg's more complex switches. Also used by jpegtran. transupp.c Support code for jpegtran: lossless image manipulations. Image file reader modules for cjpeg: rdbmp.c BMP file input. rdgif.c GIF file input (now just a stub). rdppm.c PPM/PGM file input. rdrle.c Utah RLE file input. rdtarga.c Targa file input. Image file writer modules for djpeg: wrbmp.c BMP file output. wrgif.c GIF file output (a mere shadow of its former self). wrppm.c PPM/PGM file output. wrrle.c Utah RLE file output. wrtarga.c Targa file output. RDJPGCOM/WRJPGCOM ================= C source code files: rdjpgcom.c Stand-alone rdjpgcom application. wrjpgcom.c Stand-alone wrjpgcom application. These programs do not depend on the IJG library. They do use jconfig.h and jinclude.h, only to improve portability. ADDITIONAL FILES ================ Documentation (see README for a guide to the documentation files): README Master documentation file. *.doc Other documentation files. *.1 Documentation in Unix man page format. change.log Version-to-version change highlights. example.c Sample code for calling JPEG library. Configuration/installation files and programs (see install.doc for more info): configure Unix shell script to perform automatic configuration. ltconfig Support scripts for configure (from GNU libtool). ltmain.sh config.guess config.sub install-sh Install shell script for those Unix systems lacking one. ckconfig.c Program to generate jconfig.h on non-Unix systems. jconfig.doc Template for making jconfig.h by hand. makefile.* Sample makefiles for particular systems. jconfig.* Sample jconfig.h for particular systems. ansi2knr.c De-ANSIfier for pre-ANSI C compilers (courtesy of L. Peter Deutsch and Aladdin Enterprises). Test files (see install.doc for test procedure): test*.* Source and comparison files for confidence test. These are binary image files, NOT text files. Papyrus3/JpegDir/JpgLossy/JDTRANS.C0000755000175000017500000001216107535143454014051 0ustar /* * jdtrans.c * * Copyright (C) 1995-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains library routines for transcoding decompression, * that is, reading raw DCT coefficient arrays from an input JPEG file. * The routines in jdapimin.c will also be needed by a transcoder. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* Forward declarations */ LOCAL(void) transdecode_master_selection JPP((j_decompress_ptr cinfo)); /* * Read the coefficient arrays from a JPEG file. * jpeg_read_header must be completed before calling this. * * The entire image is read into a set of virtual coefficient-block arrays, * one per component. The return value is a pointer to the array of * virtual-array descriptors. These can be manipulated directly via the * JPEG memory manager, or handed off to jpeg_write_coefficients(). * To release the memory occupied by the virtual arrays, call * jpeg_finish_decompress() when done with the data. * * An alternative usage is to simply obtain access to the coefficient arrays * during a buffered-image-mode decompression operation. This is allowed * after any jpeg_finish_output() call. The arrays can be accessed until * jpeg_finish_decompress() is called. (Note that any call to the library * may reposition the arrays, so don't rely on access_virt_barray() results * to stay valid across library calls.) * * Returns NULL if suspended. This case need be checked only if * a suspending data source is used. */ GLOBAL(jvirt_barray_ptr *) jpeg_read_coefficients (j_decompress_ptr cinfo) { if (cinfo->global_state == DSTATE_READY) { /* First call: initialize active modules */ transdecode_master_selection(cinfo); cinfo->global_state = DSTATE_RDCOEFS; } if (cinfo->global_state == DSTATE_RDCOEFS) { /* Absorb whole file into the coef buffer */ for (;;) { int retcode; /* Call progress monitor hook if present */ if (cinfo->progress != NULL) (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); /* Absorb some more input */ retcode = (*cinfo->inputctl->consume_input) (cinfo); if (retcode == JPEG_SUSPENDED) return NULL; if (retcode == JPEG_REACHED_EOI) break; /* Advance progress counter if appropriate */ if (cinfo->progress != NULL && (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) { if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) { /* startup underestimated number of scans; ratchet up one scan */ cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows; } } } /* Set state so that jpeg_finish_decompress does the right thing */ cinfo->global_state = DSTATE_STOPPING; } /* At this point we should be in state DSTATE_STOPPING if being used * standalone, or in state DSTATE_BUFIMAGE if being invoked to get access * to the coefficients during a full buffered-image-mode decompression. */ if ((cinfo->global_state == DSTATE_STOPPING || cinfo->global_state == DSTATE_BUFIMAGE) && cinfo->buffered_image) { return cinfo->coef->coef_arrays; } /* Oops, improper usage */ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); return NULL; /* keep compiler happy */ } /* * Master selection of decompression modules for transcoding. * This substitutes for jdmaster.c's initialization of the full decompressor. */ LOCAL(void) transdecode_master_selection (j_decompress_ptr cinfo) { /* This is effectively a buffered-image operation. */ cinfo->buffered_image = TRUE; /* Entropy decoding: either Huffman or arithmetic coding. */ if (cinfo->arith_code) { ERREXIT(cinfo, JERR_ARITH_NOTIMPL); } else { if (cinfo->progressive_mode) { #ifdef D_PROGRESSIVE_SUPPORTED jinit_phuff_decoder(cinfo); #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } else jinit_huff_decoder(cinfo); } /* Always get a full-image coefficient buffer. */ jinit_d_coef_controller(cinfo, TRUE); /* We can now tell the memory manager to allocate virtual arrays. */ (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo); /* Initialize input side of decompressor to consume first scan. */ (*cinfo->inputctl->start_input_pass) (cinfo); /* Initialize progress monitoring. */ if (cinfo->progress != NULL) { int nscans; /* Estimate number of scans to set pass_limit. */ if (cinfo->progressive_mode) { /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */ nscans = 2 + 3 * cinfo->num_components; } else if (cinfo->inputctl->has_multiple_scans) { /* For a nonprogressive multiscan file, estimate 1 scan per component. */ nscans = cinfo->num_components; } else { nscans = 1; } cinfo->progress->pass_counter = 0L; cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans; cinfo->progress->completed_passes = 0; cinfo->progress->total_passes = 1; } } Papyrus3/JpegDir/JpgLossy/JCCOEFCT.C0000755000175000017500000004072107535143454014127 0ustar /* * jccoefct.c * * Copyright (C) 1994-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains the coefficient buffer controller for compression. * This controller is the top level of the JPEG compressor proper. * The coefficient buffer lies between forward-DCT and entropy encoding steps. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* We use a full-image coefficient buffer when doing Huffman optimization, * and also for writing multiple-scan JPEG files. In all cases, the DCT * step is run during the first pass, and subsequent passes need only read * the buffered coefficients. */ #ifdef ENTROPY_OPT_SUPPORTED #define FULL_COEF_BUFFER_SUPPORTED #else #ifdef C_MULTISCAN_FILES_SUPPORTED #define FULL_COEF_BUFFER_SUPPORTED #endif #endif /* Private buffer controller object */ typedef struct { struct jpeg_c_coef_controller pub; /* public fields */ JDIMENSION iMCU_row_num; /* iMCU row # within image */ JDIMENSION mcu_ctr; /* counts MCUs processed in current row */ int MCU_vert_offset; /* counts MCU rows within iMCU row */ int MCU_rows_per_iMCU_row; /* number of such rows needed */ /* For single-pass compression, it's sufficient to buffer just one MCU * (although this may prove a bit slow in practice). We allocate a * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each * MCU constructed and sent. (On 80x86, the workspace is FAR even though * it's not really very big; this is to keep the module interfaces unchanged * when a large coefficient buffer is necessary.) * In multi-pass modes, this array points to the current MCU's blocks * within the virtual arrays. */ JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU]; /* In multi-pass modes, we need a virtual block array for each component. */ jvirt_barray_ptr whole_image[MAX_COMPONENTS]; } my_coef_controller; typedef my_coef_controller * my_coef_ptr; /* Forward declarations */ METHODDEF(boolean) compress_data JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf)); #ifdef FULL_COEF_BUFFER_SUPPORTED METHODDEF(boolean) compress_first_pass JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf)); METHODDEF(boolean) compress_output JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf)); #endif LOCAL(void) start_iMCU_row (j_compress_ptr cinfo) /* Reset within-iMCU-row counters for a new row */ { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; /* In an interleaved scan, an MCU row is the same as an iMCU row. * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows. * But at the bottom of the image, process only what's left. */ if (cinfo->comps_in_scan > 1) { coef->MCU_rows_per_iMCU_row = 1; } else { if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1)) coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor; else coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height; } coef->mcu_ctr = 0; coef->MCU_vert_offset = 0; } /* * Initialize for a processing pass. */ METHODDEF(void) start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode) { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; coef->iMCU_row_num = 0; start_iMCU_row(cinfo); switch (pass_mode) { case JBUF_PASS_THRU: if (coef->whole_image[0] != NULL) ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); coef->pub.compress_data = compress_data; break; #ifdef FULL_COEF_BUFFER_SUPPORTED case JBUF_SAVE_AND_PASS: if (coef->whole_image[0] == NULL) ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); coef->pub.compress_data = compress_first_pass; break; case JBUF_CRANK_DEST: if (coef->whole_image[0] == NULL) ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); coef->pub.compress_data = compress_output; break; #endif default: ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); break; } } /* * Process some data in the single-pass case. * We process the equivalent of one fully interleaved MCU row ("iMCU" row) * per call, ie, v_samp_factor block rows for each component in the image. * Returns TRUE if the iMCU row is completed, FALSE if suspended. * * NB: input_buf contains a plane for each component in image, * which we index according to the component's SOF position. */ METHODDEF(boolean) compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf) { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; JDIMENSION MCU_col_num; /* index of current MCU within row */ JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1; JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; int blkn, bi, ci, yindex, yoffset, blockcnt; JDIMENSION ypos, xpos; jpeg_component_info *compptr; /* Loop to write as much as one whole iMCU row */ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; yoffset++) { for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col; MCU_col_num++) { /* Determine where data comes from in input_buf and do the DCT thing. * Each call on forward_DCT processes a horizontal row of DCT blocks * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks * sequentially. Dummy blocks at the right or bottom edge are filled in * specially. The data in them does not matter for image reconstruction, * so we fill them with values that will encode to the smallest amount of * data, viz: all zeroes in the AC entries, DC entries equal to previous * block's DC value. (Thanks to Thomas Kinsman for this idea.) */ blkn = 0; for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width : compptr->last_col_width; xpos = MCU_col_num * compptr->MCU_sample_width; ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */ for (yindex = 0; yindex < compptr->MCU_height; yindex++) { if (coef->iMCU_row_num < last_iMCU_row || yoffset+yindex < compptr->last_row_height) { (*cinfo->fdct->forward_DCT) (cinfo, compptr, input_buf[compptr->component_index], coef->MCU_buffer[blkn], ypos, xpos, (JDIMENSION) blockcnt); if (blockcnt < compptr->MCU_width) { /* Create some dummy blocks at the right edge of the image. */ jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt], (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK)); for (bi = blockcnt; bi < compptr->MCU_width; bi++) { coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0]; } } } else { /* Create a row of dummy blocks at the bottom of the image. */ jzero_far((void FAR *) coef->MCU_buffer[blkn], compptr->MCU_width * SIZEOF(JBLOCK)); for (bi = 0; bi < compptr->MCU_width; bi++) { coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0]; } } blkn += compptr->MCU_width; ypos += DCTSIZE; } } /* Try to write the MCU. In event of a suspension failure, we will * re-DCT the MCU on restart (a bit inefficient, could be fixed...) */ if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) { /* Suspension forced; update state counters and exit */ coef->MCU_vert_offset = yoffset; coef->mcu_ctr = MCU_col_num; return FALSE; } } /* Completed an MCU row, but perhaps not an iMCU row */ coef->mcu_ctr = 0; } /* Completed the iMCU row, advance counters for next one */ coef->iMCU_row_num++; start_iMCU_row(cinfo); return TRUE; } #ifdef FULL_COEF_BUFFER_SUPPORTED /* * Process some data in the first pass of a multi-pass case. * We process the equivalent of one fully interleaved MCU row ("iMCU" row) * per call, ie, v_samp_factor block rows for each component in the image. * This amount of data is read from the source buffer, DCT'd and quantized, * and saved into the virtual arrays. We also generate suitable dummy blocks * as needed at the right and lower edges. (The dummy blocks are constructed * in the virtual arrays, which have been padded appropriately.) This makes * it possible for subsequent passes not to worry about real vs. dummy blocks. * * We must also emit the data to the entropy encoder. This is conveniently * done by calling compress_output() after we've loaded the current strip * of the virtual arrays. * * NB: input_buf contains a plane for each component in image. All * components are DCT'd and loaded into the virtual arrays in this pass. * However, it may be that only a subset of the components are emitted to * the entropy encoder during this first pass; be careful about looking * at the scan-dependent variables (MCU dimensions, etc). */ METHODDEF(boolean) compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf) { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; JDIMENSION blocks_across, MCUs_across, MCUindex; int bi, ci, h_samp_factor, block_row, block_rows, ndummy; JCOEF lastDC; jpeg_component_info *compptr; JBLOCKARRAY buffer; JBLOCKROW thisblockrow, lastblockrow; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { /* Align the virtual buffer for this component. */ buffer = (*cinfo->mem->access_virt_barray) ((j_common_ptr) cinfo, coef->whole_image[ci], coef->iMCU_row_num * compptr->v_samp_factor, (JDIMENSION) compptr->v_samp_factor, TRUE); /* Count non-dummy DCT block rows in this iMCU row. */ if (coef->iMCU_row_num < last_iMCU_row) block_rows = compptr->v_samp_factor; else { /* NB: can't use last_row_height here, since may not be set! */ block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor); if (block_rows == 0) block_rows = compptr->v_samp_factor; } blocks_across = compptr->width_in_blocks; h_samp_factor = compptr->h_samp_factor; /* Count number of dummy blocks to be added at the right margin. */ ndummy = (int) (blocks_across % h_samp_factor); if (ndummy > 0) ndummy = h_samp_factor - ndummy; /* Perform DCT for all non-dummy blocks in this iMCU row. Each call * on forward_DCT processes a complete horizontal row of DCT blocks. */ for (block_row = 0; block_row < block_rows; block_row++) { thisblockrow = buffer[block_row]; (*cinfo->fdct->forward_DCT) (cinfo, compptr, input_buf[ci], thisblockrow, (JDIMENSION) (block_row * DCTSIZE), (JDIMENSION) 0, blocks_across); if (ndummy > 0) { /* Create dummy blocks at the right edge of the image. */ thisblockrow += blocks_across; /* => first dummy block */ jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK)); lastDC = thisblockrow[-1][0]; for (bi = 0; bi < ndummy; bi++) { thisblockrow[bi][0] = lastDC; } } } /* If at end of image, create dummy block rows as needed. * The tricky part here is that within each MCU, we want the DC values * of the dummy blocks to match the last real block's DC value. * This squeezes a few more bytes out of the resulting file... */ if (coef->iMCU_row_num == last_iMCU_row) { blocks_across += ndummy; /* include lower right corner */ MCUs_across = blocks_across / h_samp_factor; for (block_row = block_rows; block_row < compptr->v_samp_factor; block_row++) { thisblockrow = buffer[block_row]; lastblockrow = buffer[block_row-1]; jzero_far((void FAR *) thisblockrow, (size_t) (blocks_across * SIZEOF(JBLOCK))); for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) { lastDC = lastblockrow[h_samp_factor-1][0]; for (bi = 0; bi < h_samp_factor; bi++) { thisblockrow[bi][0] = lastDC; } thisblockrow += h_samp_factor; /* advance to next MCU in row */ lastblockrow += h_samp_factor; } } } } /* NB: compress_output will increment iMCU_row_num if successful. * A suspension return will result in redoing all the work above next time. */ /* Emit data to the entropy encoder, sharing code with subsequent passes */ return compress_output(cinfo, input_buf); } /* * Process some data in subsequent passes of a multi-pass case. * We process the equivalent of one fully interleaved MCU row ("iMCU" row) * per call, ie, v_samp_factor block rows for each component in the scan. * The data is obtained from the virtual arrays and fed to the entropy coder. * Returns TRUE if the iMCU row is completed, FALSE if suspended. * * NB: input_buf is ignored; it is likely to be a NULL pointer. */ METHODDEF(boolean) compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf) { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; JDIMENSION MCU_col_num; /* index of current MCU within row */ int blkn, ci, xindex, yindex, yoffset; JDIMENSION start_col; JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN]; JBLOCKROW buffer_ptr; jpeg_component_info *compptr; /* Align the virtual buffers for the components used in this scan. * NB: during first pass, this is safe only because the buffers will * already be aligned properly, so jmemmgr.c won't need to do any I/O. */ for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; buffer[ci] = (*cinfo->mem->access_virt_barray) ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index], coef->iMCU_row_num * compptr->v_samp_factor, (JDIMENSION) compptr->v_samp_factor, FALSE); } /* Loop to process one whole iMCU row */ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; yoffset++) { for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row; MCU_col_num++) { /* Construct list of pointers to DCT blocks belonging to this MCU */ blkn = 0; /* index of current DCT block within MCU */ for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; start_col = MCU_col_num * compptr->MCU_width; for (yindex = 0; yindex < compptr->MCU_height; yindex++) { buffer_ptr = buffer[ci][yindex+yoffset] + start_col; for (xindex = 0; xindex < compptr->MCU_width; xindex++) { coef->MCU_buffer[blkn++] = buffer_ptr++; } } } /* Try to write the MCU. */ if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) { /* Suspension forced; update state counters and exit */ coef->MCU_vert_offset = yoffset; coef->mcu_ctr = MCU_col_num; return FALSE; } } /* Completed an MCU row, but perhaps not an iMCU row */ coef->mcu_ctr = 0; } /* Completed the iMCU row, advance counters for next one */ coef->iMCU_row_num++; start_iMCU_row(cinfo); return TRUE; } #endif /* FULL_COEF_BUFFER_SUPPORTED */ /* * Initialize coefficient buffer controller. */ GLOBAL(void) jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer) { my_coef_ptr coef; coef = (my_coef_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_coef_controller)); cinfo->coef = (struct jpeg_c_coef_controller *) coef; coef->pub.start_pass = start_pass_coef; /* Create the coefficient buffer. */ if (need_full_buffer) { #ifdef FULL_COEF_BUFFER_SUPPORTED /* Allocate a full-image virtual array for each component, */ /* padded to a multiple of samp_factor DCT blocks in each direction. */ int ci; jpeg_component_info *compptr; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { coef->whole_image[ci] = (*cinfo->mem->request_virt_barray) ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, (JDIMENSION) jround_up((long) compptr->width_in_blocks, (long) compptr->h_samp_factor), (JDIMENSION) jround_up((long) compptr->height_in_blocks, (long) compptr->v_samp_factor), (JDIMENSION) compptr->v_samp_factor); } #else ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); #endif } else { /* We only need a single-MCU buffer. */ JBLOCKROW buffer; int i; buffer = (JBLOCKROW) (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK)); for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) { coef->MCU_buffer[i] = buffer + i; } coef->whole_image[0] = NULL; /* flag for no virtual arrays */ } } Papyrus3/JpegDir/JpgLossy/JIDCTINT.C0000755000175000017500000003554407535143454014166 0ustar /* * jidctint.c * * Copyright (C) 1991-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains a slow-but-accurate integer implementation of the * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine * must also perform dequantization of the input coefficients. * * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT * on each row (or vice versa, but it's more convenient to emit a row at * a time). Direct algorithms are also available, but they are much more * complex and seem not to be any faster when reduced to code. * * This implementation is based on an algorithm described in * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics, * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991. * The primary algorithm described there uses 11 multiplies and 29 adds. * We use their alternate method with 12 multiplies and 32 adds. * The advantage of this method is that no data path contains more than one * multiplication; this allows a very simple and accurate implementation in * scaled fixed-point arithmetic, with a minimal number of shifts. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jdct.h" /* Private declarations for DCT subsystem */ #ifdef DCT_ISLOW_SUPPORTED /* * This module is specialized to the case DCTSIZE = 8. */ #if DCTSIZE != 8 Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */ #endif /* * The poop on this scaling stuff is as follows: * * Each 1-D IDCT step produces outputs which are a factor of sqrt(N) * larger than the true IDCT outputs. The final outputs are therefore * a factor of N larger than desired; since N=8 this can be cured by * a simple right shift at the end of the algorithm. The advantage of * this arrangement is that we save two multiplications per 1-D IDCT, * because the y0 and y4 inputs need not be divided by sqrt(N). * * We have to do addition and subtraction of the integer inputs, which * is no problem, and multiplication by fractional constants, which is * a problem to do in integer arithmetic. We multiply all the constants * by CONST_SCALE and convert them to integer constants (thus retaining * CONST_BITS bits of precision in the constants). After doing a * multiplication we have to divide the product by CONST_SCALE, with proper * rounding, to produce the correct output. This division can be done * cheaply as a right shift of CONST_BITS bits. We postpone shifting * as long as possible so that partial sums can be added together with * full fractional precision. * * The outputs of the first pass are scaled up by PASS1_BITS bits so that * they are represented to better-than-integral precision. These outputs * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word * with the recommended scaling. (To scale up 12-bit sample data further, an * intermediate INT32 array would be needed.) * * To avoid overflow of the 32-bit intermediate results in pass 2, we must * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26. Error analysis * shows that the values given below are the most effective. */ #if BITS_IN_JSAMPLE == 8 #define CONST_BITS 13 #define PASS1_BITS 2 #else #define CONST_BITS 13 #define PASS1_BITS 1 /* lose a little precision to avoid overflow */ #endif /* Some C compilers fail to reduce "FIX(constant)" at compile time, thus * causing a lot of useless floating-point operations at run time. * To get around this we use the following pre-calculated constants. * If you change CONST_BITS you may want to add appropriate values. * (With a reasonable C compiler, you can just rely on the FIX() macro...) */ #if CONST_BITS == 13 #define FIX_0_298631336 ((INT32) 2446) /* FIX(0.298631336) */ #define FIX_0_390180644 ((INT32) 3196) /* FIX(0.390180644) */ #define FIX_0_541196100 ((INT32) 4433) /* FIX(0.541196100) */ #define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */ #define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */ #define FIX_1_175875602 ((INT32) 9633) /* FIX(1.175875602) */ #define FIX_1_501321110 ((INT32) 12299) /* FIX(1.501321110) */ #define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */ #define FIX_1_961570560 ((INT32) 16069) /* FIX(1.961570560) */ #define FIX_2_053119869 ((INT32) 16819) /* FIX(2.053119869) */ #define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */ #define FIX_3_072711026 ((INT32) 25172) /* FIX(3.072711026) */ #else #define FIX_0_298631336 FIX(0.298631336) #define FIX_0_390180644 FIX(0.390180644) #define FIX_0_541196100 FIX(0.541196100) #define FIX_0_765366865 FIX(0.765366865) #define FIX_0_899976223 FIX(0.899976223) #define FIX_1_175875602 FIX(1.175875602) #define FIX_1_501321110 FIX(1.501321110) #define FIX_1_847759065 FIX(1.847759065) #define FIX_1_961570560 FIX(1.961570560) #define FIX_2_053119869 FIX(2.053119869) #define FIX_2_562915447 FIX(2.562915447) #define FIX_3_072711026 FIX(3.072711026) #endif /* Multiply an INT32 variable by an INT32 constant to yield an INT32 result. * For 8-bit samples with the recommended scaling, all the variable * and constant values involved are no more than 16 bits wide, so a * 16x16->32 bit multiply can be used instead of a full 32x32 multiply. * For 12-bit samples, a full 32-bit multiplication will be needed. */ #if BITS_IN_JSAMPLE == 8 #define MULTIPLY(var,const) MULTIPLY16C16(var,const) #else #define MULTIPLY(var,const) ((var) * (const)) #endif /* Dequantize a coefficient by multiplying it by the multiplier-table * entry; produce an int result. In this module, both inputs and result * are 16 bits or less, so either int or short multiply will work. */ #define DEQUANTIZE(coef,quantval) (((ISLOW_MULT_TYPE) (coef)) * (quantval)) /* * Perform dequantization and inverse DCT on one block of coefficients. */ GLOBAL(void) jpeg_idct_islow (j_decompress_ptr cinfo, jpeg_component_info * compptr, JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col) { INT32 tmp0, tmp1, tmp2, tmp3; INT32 tmp10, tmp11, tmp12, tmp13; INT32 z1, z2, z3, z4, z5; JCOEFPTR inptr; ISLOW_MULT_TYPE * quantptr; int * wsptr; JSAMPROW outptr; JSAMPLE *range_limit = IDCT_range_limit(cinfo); int ctr; int workspace[DCTSIZE2]; /* buffers data between passes */ SHIFT_TEMPS /* Pass 1: process columns from input, store into work array. */ /* Note results are scaled up by sqrt(8) compared to a true IDCT; */ /* furthermore, we scale the results by 2**PASS1_BITS. */ inptr = coef_block; quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table; wsptr = workspace; for (ctr = DCTSIZE; ctr > 0; ctr--) { /* Due to quantization, we will usually find that many of the input * coefficients are zero, especially the AC terms. We can exploit this * by short-circuiting the IDCT calculation for any column in which all * the AC terms are zero. In that case each output is equal to the * DC coefficient (with scale factor as needed). * With typical images and quantization tables, half or more of the * column DCT calculations can be simplified this way. */ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 && inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 && inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 && inptr[DCTSIZE*7] == 0) { /* AC terms all zero */ int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS; wsptr[DCTSIZE*0] = dcval; wsptr[DCTSIZE*1] = dcval; wsptr[DCTSIZE*2] = dcval; wsptr[DCTSIZE*3] = dcval; wsptr[DCTSIZE*4] = dcval; wsptr[DCTSIZE*5] = dcval; wsptr[DCTSIZE*6] = dcval; wsptr[DCTSIZE*7] = dcval; inptr++; /* advance pointers to next column */ quantptr++; wsptr++; continue; } /* Even part: reverse the even part of the forward DCT. */ /* The rotator is sqrt(2)*c(-6). */ z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]); z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]); z1 = MULTIPLY(z2 + z3, FIX_0_541196100); tmp2 = z1 + MULTIPLY(z3, - FIX_1_847759065); tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865); z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]); z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]); tmp0 = (z2 + z3) << CONST_BITS; tmp1 = (z2 - z3) << CONST_BITS; tmp10 = tmp0 + tmp3; tmp13 = tmp0 - tmp3; tmp11 = tmp1 + tmp2; tmp12 = tmp1 - tmp2; /* Odd part per figure 8; the matrix is unitary and hence its * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively. */ tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]); tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]); tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]); tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]); z1 = tmp0 + tmp3; z2 = tmp1 + tmp2; z3 = tmp0 + tmp2; z4 = tmp1 + tmp3; z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */ tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */ tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */ tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */ tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */ z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */ z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */ z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */ z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */ z3 += z5; z4 += z5; tmp0 += z1 + z3; tmp1 += z2 + z4; tmp2 += z2 + z3; tmp3 += z1 + z4; /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */ wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS); wsptr[DCTSIZE*7] = (int) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS); wsptr[DCTSIZE*1] = (int) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS); wsptr[DCTSIZE*6] = (int) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS); wsptr[DCTSIZE*2] = (int) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS); wsptr[DCTSIZE*5] = (int) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS); wsptr[DCTSIZE*3] = (int) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS); wsptr[DCTSIZE*4] = (int) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS); inptr++; /* advance pointers to next column */ quantptr++; wsptr++; } /* Pass 2: process rows from work array, store into output array. */ /* Note that we must descale the results by a factor of 8 == 2**3, */ /* and also undo the PASS1_BITS scaling. */ wsptr = workspace; for (ctr = 0; ctr < DCTSIZE; ctr++) { outptr = output_buf[ctr] + output_col; /* Rows of zeroes can be exploited in the same way as we did with columns. * However, the column calculation has created many nonzero AC terms, so * the simplification applies less often (typically 5% to 10% of the time). * On machines with very fast multiplication, it's possible that the * test takes more time than it's worth. In that case this section * may be commented out. */ #ifndef NO_ZERO_ROW_TEST if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 && wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) { /* AC terms all zero */ JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3) & RANGE_MASK]; outptr[0] = dcval; outptr[1] = dcval; outptr[2] = dcval; outptr[3] = dcval; outptr[4] = dcval; outptr[5] = dcval; outptr[6] = dcval; outptr[7] = dcval; wsptr += DCTSIZE; /* advance pointer to next row */ continue; } #endif /* Even part: reverse the even part of the forward DCT. */ /* The rotator is sqrt(2)*c(-6). */ z2 = (INT32) wsptr[2]; z3 = (INT32) wsptr[6]; z1 = MULTIPLY(z2 + z3, FIX_0_541196100); tmp2 = z1 + MULTIPLY(z3, - FIX_1_847759065); tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865); tmp0 = ((INT32) wsptr[0] + (INT32) wsptr[4]) << CONST_BITS; tmp1 = ((INT32) wsptr[0] - (INT32) wsptr[4]) << CONST_BITS; tmp10 = tmp0 + tmp3; tmp13 = tmp0 - tmp3; tmp11 = tmp1 + tmp2; tmp12 = tmp1 - tmp2; /* Odd part per figure 8; the matrix is unitary and hence its * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively. */ tmp0 = (INT32) wsptr[7]; tmp1 = (INT32) wsptr[5]; tmp2 = (INT32) wsptr[3]; tmp3 = (INT32) wsptr[1]; z1 = tmp0 + tmp3; z2 = tmp1 + tmp2; z3 = tmp0 + tmp2; z4 = tmp1 + tmp3; z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */ tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */ tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */ tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */ tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */ z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */ z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */ z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */ z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */ z3 += z5; z4 += z5; tmp0 += z1 + z3; tmp1 += z2 + z4; tmp2 += z2 + z3; tmp3 += z1 + z4; /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */ outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp3, CONST_BITS+PASS1_BITS+3) & RANGE_MASK]; outptr[7] = range_limit[(int) DESCALE(tmp10 - tmp3, CONST_BITS+PASS1_BITS+3) & RANGE_MASK]; outptr[1] = range_limit[(int) DESCALE(tmp11 + tmp2, CONST_BITS+PASS1_BITS+3) & RANGE_MASK]; outptr[6] = range_limit[(int) DESCALE(tmp11 - tmp2, CONST_BITS+PASS1_BITS+3) & RANGE_MASK]; outptr[2] = range_limit[(int) DESCALE(tmp12 + tmp1, CONST_BITS+PASS1_BITS+3) & RANGE_MASK]; outptr[5] = range_limit[(int) DESCALE(tmp12 - tmp1, CONST_BITS+PASS1_BITS+3) & RANGE_MASK]; outptr[3] = range_limit[(int) DESCALE(tmp13 + tmp0, CONST_BITS+PASS1_BITS+3) & RANGE_MASK]; outptr[4] = range_limit[(int) DESCALE(tmp13 - tmp0, CONST_BITS+PASS1_BITS+3) & RANGE_MASK]; wsptr += DCTSIZE; /* advance pointer to next row */ } } #endif /* DCT_ISLOW_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/jconfig.vms0000755000175000017500000000177007535143454015012 0ustar /* jconfig.vms --- jconfig.h for use on Digital VMS. */ /* see jconfig.doc for explanations */ #define HAVE_PROTOTYPES #define HAVE_UNSIGNED_CHAR #define HAVE_UNSIGNED_SHORT /* #define void char */ /* #define const */ #undef CHAR_IS_UNSIGNED #define HAVE_STDDEF_H #define HAVE_STDLIB_H #undef NEED_BSD_STRINGS #undef NEED_SYS_TYPES_H #undef NEED_FAR_POINTERS #undef NEED_SHORT_EXTERNAL_NAMES #undef INCOMPLETE_TYPES_BROKEN #ifdef JPEG_INTERNALS #undef RIGHT_SHIFT_IS_UNSIGNED #endif /* JPEG_INTERNALS */ #ifdef JPEG_CJPEG_DJPEG #define BMP_SUPPORTED /* BMP image file format */ #define GIF_SUPPORTED /* GIF image file format */ #define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ #undef RLE_SUPPORTED /* Utah RLE image file format */ #define TARGA_SUPPORTED /* Targa image file format */ #define TWO_FILE_COMMANDLINE /* Needed on VMS */ #undef NEED_SIGNAL_CATCHER #undef DONT_USE_B_MODE #undef PROGRESS_REPORT /* optional */ #endif /* JPEG_CJPEG_DJPEG */ Papyrus3/JpegDir/JpgLossy/WRJPGCOM.C0000755000175000017500000004137207535143454014202 0ustar /* * wrjpgcom.c * * Copyright (C) 1994-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains a very simple stand-alone application that inserts * user-supplied text as a COM (comment) marker in a JFIF file. * This may be useful as an example of the minimum logic needed to parse * JPEG markers. */ #define JPEG_CJPEG_DJPEG /* to get the command-line config symbols */ #include "jinclude.h" /* get auto-config symbols, */ #ifndef HAVE_STDLIB_H /* should declare malloc() */ extern void * malloc (); #endif #include /* to declare isupper(), tolower() */ #ifdef USE_SETMODE #include /* to declare setmode()'s parameter macros */ /* If you have setmode() but not , just delete this line: */ #include /* to declare setmode() */ #endif #ifdef USE_CCOMMAND /* command-line reader for Macintosh */ #ifdef __MWERKS__ #include /* Metrowerks needs this */ #include /* ... and this */ #endif #ifdef THINK_C #include /* Think declares it here */ #endif #endif #ifdef DONT_USE_B_MODE /* define mode parameters for fopen() */ #define READ_BINARY "r" #define WRITE_BINARY "w" #else #ifdef VMS /* VMS is very nonstandard */ #define READ_BINARY "rb", "ctx=stm" #define WRITE_BINARY "wb", "ctx=stm" #else /* standard ANSI-compliant case */ #define READ_BINARY "rb" #define WRITE_BINARY "wb" #endif #endif #ifndef EXIT_FAILURE /* define exit() codes if not provided */ #define EXIT_FAILURE 1 #endif #ifndef EXIT_SUCCESS #ifdef VMS #define EXIT_SUCCESS 1 /* VMS is very nonstandard */ #else #define EXIT_SUCCESS 0 #endif #endif /* Reduce this value if your malloc() can't allocate blocks up to 64K. * On DOS, compiling in large model is usually a better solution. */ #ifndef MAX_COM_LENGTH #define MAX_COM_LENGTH 65000L /* must be <= 65533 in any case */ #endif /* * These macros are used to read the input file and write the output file. * To reuse this code in another application, you might need to change these. */ static FILE * infile; /* input JPEG file */ /* Return next input byte, or EOF if no more */ #define NEXTBYTE() getc(infile) static FILE * outfile; /* output JPEG file */ /* Emit an output byte */ #define PUTBYTE(x) putc((x), outfile) /* Error exit handler */ #define ERREXIT(msg) (fprintf(stderr, "%s\n", msg), exit(EXIT_FAILURE)) /* Read one byte, testing for EOF */ static int read_1_byte (void) { int c; c = NEXTBYTE(); if (c == EOF) ERREXIT("Premature EOF in JPEG file"); return c; } /* Read 2 bytes, convert to unsigned int */ /* All 2-byte quantities in JPEG markers are MSB first */ static unsigned int read_2_bytes (void) { int c1, c2; c1 = NEXTBYTE(); if (c1 == EOF) ERREXIT("Premature EOF in JPEG file"); c2 = NEXTBYTE(); if (c2 == EOF) ERREXIT("Premature EOF in JPEG file"); return (((unsigned int) c1) << 8) + ((unsigned int) c2); } /* Routines to write data to output file */ static void write_1_byte (int c) { PUTBYTE(c); } static void write_2_bytes (unsigned int val) { PUTBYTE((val >> 8) & 0xFF); PUTBYTE(val & 0xFF); } static void write_marker (int marker) { PUTBYTE(0xFF); PUTBYTE(marker); } static void copy_rest_of_file (void) { int c; while ((c = NEXTBYTE()) != EOF) PUTBYTE(c); } /* * JPEG markers consist of one or more 0xFF bytes, followed by a marker * code byte (which is not an FF). Here are the marker codes of interest * in this program. (See jdmarker.c for a more complete list.) */ #define M_SOF0 0xC0 /* Start Of Frame N */ #define M_SOF1 0xC1 /* N indicates which compression process */ #define M_SOF2 0xC2 /* Only SOF0-SOF2 are now in common use */ #define M_SOF3 0xC3 #define M_SOF5 0xC5 /* NB: codes C4 and CC are NOT SOF markers */ #define M_SOF6 0xC6 #define M_SOF7 0xC7 #define M_SOF9 0xC9 #define M_SOF10 0xCA #define M_SOF11 0xCB #define M_SOF13 0xCD #define M_SOF14 0xCE #define M_SOF15 0xCF #define M_SOI 0xD8 /* Start Of Image (beginning of datastream) */ #define M_EOI 0xD9 /* End Of Image (end of datastream) */ #define M_SOS 0xDA /* Start Of Scan (begins compressed data) */ #define M_COM 0xFE /* COMment */ /* * Find the next JPEG marker and return its marker code. * We expect at least one FF byte, possibly more if the compressor used FFs * to pad the file. (Padding FFs will NOT be replicated in the output file.) * There could also be non-FF garbage between markers. The treatment of such * garbage is unspecified; we choose to skip over it but emit a warning msg. * NB: this routine must not be used after seeing SOS marker, since it will * not deal correctly with FF/00 sequences in the compressed image data... */ static int next_marker (void) { int c; int discarded_bytes = 0; /* Find 0xFF byte; count and skip any non-FFs. */ c = read_1_byte(); while (c != 0xFF) { discarded_bytes++; c = read_1_byte(); } /* Get marker code byte, swallowing any duplicate FF bytes. Extra FFs * are legal as pad bytes, so don't count them in discarded_bytes. */ do { c = read_1_byte(); } while (c == 0xFF); if (discarded_bytes != 0) { fprintf(stderr, "Warning: garbage data found in JPEG file\n"); } return c; } /* * Read the initial marker, which should be SOI. * For a JFIF file, the first two bytes of the file should be literally * 0xFF M_SOI. To be more general, we could use next_marker, but if the * input file weren't actually JPEG at all, next_marker might read the whole * file and then return a misleading error message... */ static int first_marker (void) { int c1, c2; c1 = NEXTBYTE(); c2 = NEXTBYTE(); if (c1 != 0xFF || c2 != M_SOI) ERREXIT("Not a JPEG file"); return c2; } /* * Most types of marker are followed by a variable-length parameter segment. * This routine skips over the parameters for any marker we don't otherwise * want to process. * Note that we MUST skip the parameter segment explicitly in order not to * be fooled by 0xFF bytes that might appear within the parameter segment; * such bytes do NOT introduce new markers. */ static void copy_variable (void) /* Copy an unknown or uninteresting variable-length marker */ { unsigned int length; /* Get the marker parameter length count */ length = read_2_bytes(); write_2_bytes(length); /* Length includes itself, so must be at least 2 */ if (length < 2) ERREXIT("Erroneous JPEG marker length"); length -= 2; /* Skip over the remaining bytes */ while (length > 0) { write_1_byte(read_1_byte()); length--; } } static void skip_variable (void) /* Skip over an unknown or uninteresting variable-length marker */ { unsigned int length; /* Get the marker parameter length count */ length = read_2_bytes(); /* Length includes itself, so must be at least 2 */ if (length < 2) ERREXIT("Erroneous JPEG marker length"); length -= 2; /* Skip over the remaining bytes */ while (length > 0) { (void) read_1_byte(); length--; } } /* * Parse the marker stream until SOFn or EOI is seen; * copy data to output, but discard COM markers unless keep_COM is true. */ static int scan_JPEG_header (int keep_COM) { int marker; /* Expect SOI at start of file */ if (first_marker() != M_SOI) ERREXIT("Expected SOI marker first"); write_marker(M_SOI); /* Scan miscellaneous markers until we reach SOFn. */ for (;;) { marker = next_marker(); switch (marker) { /* Note that marker codes 0xC4, 0xC8, 0xCC are not, and must not be, * treated as SOFn. C4 in particular is actually DHT. */ case M_SOF0: /* Baseline */ case M_SOF1: /* Extended sequential, Huffman */ case M_SOF2: /* Progressive, Huffman */ case M_SOF3: /* Lossless, Huffman */ case M_SOF5: /* Differential sequential, Huffman */ case M_SOF6: /* Differential progressive, Huffman */ case M_SOF7: /* Differential lossless, Huffman */ case M_SOF9: /* Extended sequential, arithmetic */ case M_SOF10: /* Progressive, arithmetic */ case M_SOF11: /* Lossless, arithmetic */ case M_SOF13: /* Differential sequential, arithmetic */ case M_SOF14: /* Differential progressive, arithmetic */ case M_SOF15: /* Differential lossless, arithmetic */ return marker; case M_SOS: /* should not see compressed data before SOF */ ERREXIT("SOS without prior SOFn"); break; case M_EOI: /* in case it's a tables-only JPEG stream */ return marker; case M_COM: /* Existing COM: conditionally discard */ if (keep_COM) { write_marker(marker); copy_variable(); } else { skip_variable(); } break; default: /* Anything else just gets copied */ write_marker(marker); copy_variable(); /* we assume it has a parameter count... */ break; } } /* end loop */ } /* Command line parsing code */ static const char * progname; /* program name for error messages */ static void usage (void) /* complain about bad command line */ { fprintf(stderr, "wrjpgcom inserts a textual comment in a JPEG file.\n"); fprintf(stderr, "You can add to or replace any existing comment(s).\n"); fprintf(stderr, "Usage: %s [switches] ", progname); #ifdef TWO_FILE_COMMANDLINE fprintf(stderr, "inputfile outputfile\n"); #else fprintf(stderr, "[inputfile]\n"); #endif fprintf(stderr, "Switches (names may be abbreviated):\n"); fprintf(stderr, " -replace Delete any existing comments\n"); fprintf(stderr, " -comment \"text\" Insert comment with given text\n"); fprintf(stderr, " -cfile name Read comment from named file\n"); fprintf(stderr, "Notice that you must put quotes around the comment text\n"); fprintf(stderr, "when you use -comment.\n"); fprintf(stderr, "If you do not give either -comment or -cfile on the command line,\n"); fprintf(stderr, "then the comment text is read from standard input.\n"); fprintf(stderr, "It can be multiple lines, up to %u characters total.\n", (unsigned int) MAX_COM_LENGTH); #ifndef TWO_FILE_COMMANDLINE fprintf(stderr, "You must specify an input JPEG file name when supplying\n"); fprintf(stderr, "comment text from standard input.\n"); #endif exit(EXIT_FAILURE); } static int keymatch (char * arg, const char * keyword, int minchars) /* Case-insensitive matching of (possibly abbreviated) keyword switches. */ /* keyword is the constant keyword (must be lower case already), */ /* minchars is length of minimum legal abbreviation. */ { register int ca, ck; register int nmatched = 0; while ((ca = *arg++) != '\0') { if ((ck = *keyword++) == '\0') return 0; /* arg longer than keyword, no good */ if (isupper(ca)) /* force arg to lcase (assume ck is already) */ ca = tolower(ca); if (ca != ck) return 0; /* no good */ nmatched++; /* count matched characters */ } /* reached end of argument; fail if it's too short for unique abbrev */ if (nmatched < minchars) return 0; return 1; /* A-OK */ } /* * The main program. */ int main (int argc, char **argv) { int argn; char * arg; int keep_COM = 1; char * comment_arg = NULL; FILE * comment_file = NULL; unsigned int comment_length = 0; int marker; /* On Mac, fetch a command line. */ #ifdef USE_CCOMMAND argc = ccommand(&argv); #endif progname = argv[0]; if (progname == NULL || progname[0] == 0) progname = "wrjpgcom"; /* in case C library doesn't provide it */ /* Parse switches, if any */ for (argn = 1; argn < argc; argn++) { arg = argv[argn]; if (arg[0] != '-') break; /* not switch, must be file name */ arg++; /* advance over '-' */ if (keymatch(arg, "replace", 1)) { keep_COM = 0; } else if (keymatch(arg, "cfile", 2)) { if (++argn >= argc) usage(); if ((comment_file = fopen(argv[argn], "r")) == NULL) { fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]); exit(EXIT_FAILURE); } } else if (keymatch(arg, "comment", 1)) { if (++argn >= argc) usage(); comment_arg = argv[argn]; /* If the comment text starts with '"', then we are probably running * under MS-DOG and must parse out the quoted string ourselves. Sigh. */ if (comment_arg[0] == '"') { comment_arg = (char *) malloc((size_t) MAX_COM_LENGTH); if (comment_arg == NULL) ERREXIT("Insufficient memory"); strcpy(comment_arg, argv[argn]+1); for (;;) { comment_length = (unsigned int) strlen(comment_arg); if (comment_length > 0 && comment_arg[comment_length-1] == '"') { comment_arg[comment_length-1] = '\0'; /* zap terminating quote */ break; } if (++argn >= argc) ERREXIT("Missing ending quote mark"); strcat(comment_arg, " "); strcat(comment_arg, argv[argn]); } } comment_length = (unsigned int) strlen(comment_arg); } else usage(); } /* Cannot use both -comment and -cfile. */ if (comment_arg != NULL && comment_file != NULL) usage(); /* If there is neither -comment nor -cfile, we will read the comment text * from stdin; in this case there MUST be an input JPEG file name. */ if (comment_arg == NULL && comment_file == NULL && argn >= argc) usage(); /* Open the input file. */ if (argn < argc) { if ((infile = fopen(argv[argn], READ_BINARY)) == NULL) { fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]); exit(EXIT_FAILURE); } } else { /* default input file is stdin */ #ifdef USE_SETMODE /* need to hack file mode? */ setmode(fileno(stdin), O_BINARY); #endif #ifdef USE_FDOPEN /* need to re-open in binary mode? */ if ((infile = fdopen(fileno(stdin), READ_BINARY)) == NULL) { fprintf(stderr, "%s: can't open stdin\n", progname); exit(EXIT_FAILURE); } #else infile = stdin; #endif } /* Open the output file. */ #ifdef TWO_FILE_COMMANDLINE /* Must have explicit output file name */ if (argn != argc-2) { fprintf(stderr, "%s: must name one input and one output file\n", progname); usage(); } if ((outfile = fopen(argv[argn+1], WRITE_BINARY)) == NULL) { fprintf(stderr, "%s: can't open %s\n", progname, argv[argn+1]); exit(EXIT_FAILURE); } #else /* Unix style: expect zero or one file name */ if (argn < argc-1) { fprintf(stderr, "%s: only one input file\n", progname); usage(); } /* default output file is stdout */ #ifdef USE_SETMODE /* need to hack file mode? */ setmode(fileno(stdout), O_BINARY); #endif #ifdef USE_FDOPEN /* need to re-open in binary mode? */ if ((outfile = fdopen(fileno(stdout), WRITE_BINARY)) == NULL) { fprintf(stderr, "%s: can't open stdout\n", progname); exit(EXIT_FAILURE); } #else outfile = stdout; #endif #endif /* TWO_FILE_COMMANDLINE */ /* Collect comment text from comment_file or stdin, if necessary */ if (comment_arg == NULL) { FILE * src_file; int c; comment_arg = (char *) malloc((size_t) MAX_COM_LENGTH); if (comment_arg == NULL) ERREXIT("Insufficient memory"); comment_length = 0; src_file = (comment_file != NULL ? comment_file : stdin); while ((c = getc(src_file)) != EOF) { if (comment_length >= (unsigned int) MAX_COM_LENGTH) { fprintf(stderr, "Comment text may not exceed %u bytes\n", (unsigned int) MAX_COM_LENGTH); exit(EXIT_FAILURE); } comment_arg[comment_length++] = (char) c; } if (comment_file != NULL) fclose(comment_file); } /* Copy JPEG headers until SOFn marker; * we will insert the new comment marker just before SOFn. * This (a) causes the new comment to appear after, rather than before, * existing comments; and (b) ensures that comments come after any JFIF * or JFXX markers, as required by the JFIF specification. */ marker = scan_JPEG_header(keep_COM); /* Insert the new COM marker, but only if nonempty text has been supplied */ if (comment_length > 0) { write_marker(M_COM); write_2_bytes(comment_length + 2); while (comment_length > 0) { write_1_byte(*comment_arg++); comment_length--; } } /* Duplicate the remainder of the source file. * Note that any COM markers occuring after SOF will not be touched. */ write_marker(marker); copy_rest_of_file(); /* All done. */ exit(EXIT_SUCCESS); return 0; /* suppress no-return-value warnings */ } Papyrus3/JpegDir/JpgLossy/WRPPM.C0000755000175000017500000002062707535143454013657 0ustar /* * wrppm.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to write output images in PPM/PGM format. * The extended 2-byte-per-sample raw PPM/PGM formats are supported. * The PBMPLUS library is NOT required to compile this software * (but it is highly useful as a set of PPM image manipulation programs). * * These routines may need modification for non-Unix environments or * specialized applications. As they stand, they assume output to * an ordinary stdio stream. */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ #ifdef PPM_SUPPORTED /* * For 12-bit JPEG data, we either downscale the values to 8 bits * (to write standard byte-per-sample PPM/PGM files), or output * nonstandard word-per-sample PPM/PGM files. Downscaling is done * if PPM_NORAWWORD is defined (this can be done in the Makefile * or in jconfig.h). * (When the core library supports data precision reduction, a cleaner * implementation will be to ask for that instead.) */ #if BITS_IN_JSAMPLE == 8 #define PUTPPMSAMPLE(ptr,v) *ptr++ = (char) (v) #define BYTESPERSAMPLE 1 #define PPM_MAXVAL 255 #else #ifdef PPM_NORAWWORD #define PUTPPMSAMPLE(ptr,v) *ptr++ = (char) ((v) >> (BITS_IN_JSAMPLE-8)) #define BYTESPERSAMPLE 1 #define PPM_MAXVAL 255 #else /* The word-per-sample format always puts the LSB first. */ #define PUTPPMSAMPLE(ptr,v) \ { register int val_ = v; \ *ptr++ = (char) (val_ & 0xFF); \ *ptr++ = (char) ((val_ >> 8) & 0xFF); \ } #define BYTESPERSAMPLE 2 #define PPM_MAXVAL ((1<pub.output_file, dest->iobuffer, dest->buffer_width); } /* * This code is used when we have to copy the data and apply a pixel * format translation. Typically this only happens in 12-bit mode. */ METHODDEF(void) copy_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied) { ppm_dest_ptr dest = (ppm_dest_ptr) dinfo; register char * bufferptr; register JSAMPROW ptr; register JDIMENSION col; ptr = dest->pub.buffer[0]; bufferptr = dest->iobuffer; for (col = dest->samples_per_row; col > 0; col--) { PUTPPMSAMPLE(bufferptr, GETJSAMPLE(*ptr++)); } (void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width); } /* * Write some pixel data when color quantization is in effect. * We have to demap the color index values to straight data. */ METHODDEF(void) put_demapped_rgb (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied) { ppm_dest_ptr dest = (ppm_dest_ptr) dinfo; register char * bufferptr; register int pixval; register JSAMPROW ptr; register JSAMPROW color_map0 = cinfo->colormap[0]; register JSAMPROW color_map1 = cinfo->colormap[1]; register JSAMPROW color_map2 = cinfo->colormap[2]; register JDIMENSION col; ptr = dest->pub.buffer[0]; bufferptr = dest->iobuffer; for (col = cinfo->output_width; col > 0; col--) { pixval = GETJSAMPLE(*ptr++); PUTPPMSAMPLE(bufferptr, GETJSAMPLE(color_map0[pixval])); PUTPPMSAMPLE(bufferptr, GETJSAMPLE(color_map1[pixval])); PUTPPMSAMPLE(bufferptr, GETJSAMPLE(color_map2[pixval])); } (void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width); } METHODDEF(void) put_demapped_gray (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied) { ppm_dest_ptr dest = (ppm_dest_ptr) dinfo; register char * bufferptr; register JSAMPROW ptr; register JSAMPROW color_map = cinfo->colormap[0]; register JDIMENSION col; ptr = dest->pub.buffer[0]; bufferptr = dest->iobuffer; for (col = cinfo->output_width; col > 0; col--) { PUTPPMSAMPLE(bufferptr, GETJSAMPLE(color_map[GETJSAMPLE(*ptr++)])); } (void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width); } /* * Startup: write the file header. */ METHODDEF(void) start_output_ppm (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) { ppm_dest_ptr dest = (ppm_dest_ptr) dinfo; /* Emit file header */ switch (cinfo->out_color_space) { case JCS_GRAYSCALE: /* emit header for raw PGM format */ fprintf(dest->pub.output_file, "P5\n%ld %ld\n%d\n", (long) cinfo->output_width, (long) cinfo->output_height, PPM_MAXVAL); break; case JCS_RGB: /* emit header for raw PPM format */ fprintf(dest->pub.output_file, "P6\n%ld %ld\n%d\n", (long) cinfo->output_width, (long) cinfo->output_height, PPM_MAXVAL); break; default: ERREXIT(cinfo, JERR_PPM_COLORSPACE); } } /* * Finish up at the end of the file. */ METHODDEF(void) finish_output_ppm (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) { /* Make sure we wrote the output file OK */ fflush(dinfo->output_file); if (ferror(dinfo->output_file)) ERREXIT(cinfo, JERR_FILE_WRITE); } /* * The module selection routine for PPM format output. */ GLOBAL(djpeg_dest_ptr) jinit_write_ppm (j_decompress_ptr cinfo) { ppm_dest_ptr dest; /* Create module interface object, fill in method pointers */ dest = (ppm_dest_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(ppm_dest_struct)); dest->pub.start_output = start_output_ppm; dest->pub.finish_output = finish_output_ppm; /* Calculate output image dimensions so we can allocate space */ jpeg_calc_output_dimensions(cinfo); /* Create physical I/O buffer. Note we make this near on a PC. */ dest->samples_per_row = cinfo->output_width * cinfo->out_color_components; dest->buffer_width = dest->samples_per_row * (BYTESPERSAMPLE * SIZEOF(char)); dest->iobuffer = (char *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, dest->buffer_width); if (cinfo->quantize_colors || BITS_IN_JSAMPLE != 8 || SIZEOF(JSAMPLE) != SIZEOF(char)) { /* When quantizing, we need an output buffer for colormap indexes * that's separate from the physical I/O buffer. We also need a * separate buffer if pixel format translation must take place. */ dest->pub.buffer = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, cinfo->output_width * cinfo->output_components, (JDIMENSION) 1); dest->pub.buffer_height = 1; if (! cinfo->quantize_colors) dest->pub.put_pixel_rows = copy_pixel_rows; else if (cinfo->out_color_space == JCS_GRAYSCALE) dest->pub.put_pixel_rows = put_demapped_gray; else dest->pub.put_pixel_rows = put_demapped_rgb; } else { /* We will fwrite() directly from decompressor output buffer. */ /* Synthesize a JSAMPARRAY pointer structure */ /* Cast here implies near->far pointer conversion on PCs */ dest->pixrow = (JSAMPROW) dest->iobuffer; dest->pub.buffer = & dest->pixrow; dest->pub.buffer_height = 1; dest->pub.put_pixel_rows = put_pixel_rows; } return (djpeg_dest_ptr) dest; } #endif /* PPM_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/RDSWITCH.C0000755000175000017500000002544207535143454014201 0ustar /* * rdswitch.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to process some of cjpeg's more complicated * command-line switches. Switches processed here are: * -qtables file Read quantization tables from text file * -scans file Read scan script from text file * -qslots N[,N,...] Set component quantization table selectors * -sample HxV[,HxV,...] Set component sampling factors */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif #include /* to declare isdigit(), isspace() */ LOCAL(int) text_getc (PAPY_FILE file) /* Read next char, skipping over any comments (# to end of line) */ /* A comment/newline sequence is returned as a newline */ { int ch; PapyULong bytesToRead = 1L; /*ch = getc(file);*/ Papy3FRead (file, &bytesToRead, (PapyULong) 1L, (void *) &ch); if (ch == '#') { do { /*ch = getc(file);*/ Papy3FRead (file, &bytesToRead, (PapyULong) 1L, (void *) &ch); } while (ch != '\n' && ch != EOF); } return ch; } LOCAL(boolean) read_text_integer (PAPY_FILE file, long * result, int * termchar) /* Read an unsigned decimal integer from a file, store it in result */ /* Reads one trailing character after the integer; returns it in termchar */ { register int ch; register long val; /* Skip any leading whitespace, detect EOF */ do { ch = text_getc(file); if (ch == EOF) { *termchar = ch; return FALSE; } } while (isspace(ch)); if (! isdigit(ch)) { *termchar = ch; return FALSE; } val = ch - '0'; while ((ch = text_getc(file)) != EOF) { if (! isdigit(ch)) break; val *= 10; val += ch - '0'; } *result = val; *termchar = ch; return TRUE; } GLOBAL(boolean) read_quant_tables (j_compress_ptr cinfo, char * filename, int scale_factor, boolean force_baseline) /* Read a set of quantization tables from the specified file. * The file is plain ASCII text: decimal numbers with whitespace between. * Comments preceded by '#' may be included in the file. * There may be one to NUM_QUANT_TBLS tables in the file, each of 64 values. * The tables are implicitly numbered 0,1,etc. * NOTE: does not affect the qslots mapping, which will default to selecting * table 0 for luminance (or primary) components, 1 for chrominance components. * You must use -qslots if you want a different component->table mapping. */ { PAPY_FILE fp; PapyShort err; int tblno, i, termchar; long val; unsigned int table[DCTSIZE2]; /*if ((fp = fopen(filename, "r")) == NULL) {*/ if ((err = Papy3FOpen (filename, 'r', 0, &fp, NULL)) < 0) { fprintf(stderr, "Can't open table file %s\n", filename); return FALSE; } tblno = 0; while (read_text_integer(fp, &val, &termchar)) { /* read 1st element of table */ if (tblno >= NUM_QUANT_TBLS) { fprintf(stderr, "Too many tables in file %s\n", filename); /*fclose(fp);*/ Papy3FClose (&fp); return FALSE; } table[0] = (unsigned int) val; for (i = 1; i < DCTSIZE2; i++) { if (! read_text_integer(fp, &val, &termchar)) { fprintf(stderr, "Invalid table data in file %s\n", filename); /*fclose(fp);*/ Papy3FClose (&fp); return FALSE; } table[i] = (unsigned int) val; } jpeg_add_quant_table(cinfo, tblno, table, scale_factor, force_baseline); tblno++; } if (termchar != EOF) { fprintf(stderr, "Non-numeric data in file %s\n", filename); /*fclose(fp);*/ Papy3FClose (&fp); return FALSE; } /*fclose(fp);*/ Papy3FClose (&fp); return TRUE; } #ifdef C_MULTISCAN_FILES_SUPPORTED LOCAL(boolean) read_scan_integer (PAPY_FILE file, long * result, int * termchar) /* Variant of read_text_integer that always looks for a non-space termchar; * this simplifies parsing of punctuation in scan scripts. */ { register int ch; if (! read_text_integer(file, result, termchar)) return FALSE; ch = *termchar; while (ch != EOF && isspace(ch)) ch = text_getc(file); if (isdigit(ch)) { /* oops, put it back */ /*if (ungetc(ch, file) == EOF)*/ if (Papy3FSeek (file, SEEK_CUR, -1L) < 0) return FALSE; ch = ' '; } else { /* Any separators other than ';' and ':' are ignored; * this allows user to insert commas, etc, if desired. */ if (ch != EOF && ch != ';' && ch != ':') ch = ' '; } *termchar = ch; return TRUE; } GLOBAL(boolean) read_scan_script (j_compress_ptr cinfo, char * filename) /* Read a scan script from the specified text file. * Each entry in the file defines one scan to be emitted. * Entries are separated by semicolons ';'. * An entry contains one to four component indexes, * optionally followed by a colon ':' and four progressive-JPEG parameters. * The component indexes denote which component(s) are to be transmitted * in the current scan. The first component has index 0. * Sequential JPEG is used if the progressive-JPEG parameters are omitted. * The file is free format text: any whitespace may appear between numbers * and the ':' and ';' punctuation marks. Also, other punctuation (such * as commas or dashes) can be placed between numbers if desired. * Comments preceded by '#' may be included in the file. * Note: we do very little validity checking here; * jcmaster.c will validate the script parameters. */ { PAPY_FILE fp; PapyShort err; int scanno, ncomps, termchar; long val; jpeg_scan_info * scanptr; #define MAX_SCANS 100 /* quite arbitrary limit */ jpeg_scan_info scans[MAX_SCANS]; /*if ((fp = fopen(filename, "r")) == NULL) {*/ if ((err = Papy3FOpen (filename, 'r', (PAPY_FILE) 0, &fp, NULL)) < 0) { fprintf(stderr, "Can't open scan definition file %s\n", filename); return FALSE; } scanptr = scans; scanno = 0; while (read_scan_integer(fp, &val, &termchar)) { if (scanno >= MAX_SCANS) { fprintf(stderr, "Too many scans defined in file %s\n", filename); /*fclose(fp);*/ Papy3FClose (&fp); return FALSE; } scanptr->component_index[0] = (int) val; ncomps = 1; while (termchar == ' ') { if (ncomps >= MAX_COMPS_IN_SCAN) { fprintf(stderr, "Too many components in one scan in file %s\n", filename); /*fclose(fp);*/ Papy3FClose (&fp); return FALSE; } if (! read_scan_integer(fp, &val, &termchar)) goto bogus; scanptr->component_index[ncomps] = (int) val; ncomps++; } scanptr->comps_in_scan = ncomps; if (termchar == ':') { if (! read_scan_integer(fp, &val, &termchar) || termchar != ' ') goto bogus; scanptr->Ss = (int) val; if (! read_scan_integer(fp, &val, &termchar) || termchar != ' ') goto bogus; scanptr->Se = (int) val; if (! read_scan_integer(fp, &val, &termchar) || termchar != ' ') goto bogus; scanptr->Ah = (int) val; if (! read_scan_integer(fp, &val, &termchar)) goto bogus; scanptr->Al = (int) val; } else { /* set non-progressive parameters */ scanptr->Ss = 0; scanptr->Se = DCTSIZE2-1; scanptr->Ah = 0; scanptr->Al = 0; } if (termchar != ';' && termchar != EOF) { bogus: fprintf(stderr, "Invalid scan entry format in file %s\n", filename); /*fclose(fp);*/ Papy3FClose (&fp); return FALSE; } scanptr++, scanno++; } if (termchar != EOF) { fprintf(stderr, "Non-numeric data in file %s\n", filename); /*fclose(fp);*/ Papy3FClose (&fp); return FALSE; } if (scanno > 0) { /* Stash completed scan list in cinfo structure. * NOTE: for cjpeg's use, JPOOL_IMAGE is the right lifetime for this data, * but if you want to compress multiple images you'd want JPOOL_PERMANENT. */ scanptr = (jpeg_scan_info *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, scanno * SIZEOF(jpeg_scan_info)); MEMCOPY(scanptr, scans, scanno * SIZEOF(jpeg_scan_info)); cinfo->scan_info = scanptr; cinfo->num_scans = scanno; } /*fclose(fp);*/ Papy3FClose (&fp); return TRUE; } #endif /* C_MULTISCAN_FILES_SUPPORTED */ GLOBAL(boolean) set_quant_slots (j_compress_ptr cinfo, char *arg) /* Process a quantization-table-selectors parameter string, of the form * N[,N,...] * If there are more components than parameters, the last value is replicated. */ { int val = 0; /* default table # */ int ci; char ch; for (ci = 0; ci < MAX_COMPONENTS; ci++) { if (*arg) { ch = ','; /* if not set by sscanf, will be ',' */ if (sscanf(arg, "%d%c", &val, &ch) < 1) return FALSE; if (ch != ',') /* syntax check */ return FALSE; if (val < 0 || val >= NUM_QUANT_TBLS) { fprintf(stderr, "JPEG quantization tables are numbered 0..%d\n", NUM_QUANT_TBLS-1); return FALSE; } cinfo->comp_info[ci].quant_tbl_no = val; while (*arg && *arg++ != ',') /* advance to next segment of arg string */ ; } else { /* reached end of parameter, set remaining components to last table */ cinfo->comp_info[ci].quant_tbl_no = val; } } return TRUE; } GLOBAL(boolean) set_sample_factors (j_compress_ptr cinfo, char *arg) /* Process a sample-factors parameter string, of the form * HxV[,HxV,...] * If there are more components than parameters, "1x1" is assumed for the rest. */ { int ci, val1, val2; char ch1, ch2; for (ci = 0; ci < MAX_COMPONENTS; ci++) { if (*arg) { ch2 = ','; /* if not set by sscanf, will be ',' */ if (sscanf(arg, "%d%c%d%c", &val1, &ch1, &val2, &ch2) < 3) return FALSE; if ((ch1 != 'x' && ch1 != 'X') || ch2 != ',') /* syntax check */ return FALSE; if (val1 <= 0 || val1 > 4 || val2 <= 0 || val2 > 4) { fprintf(stderr, "JPEG sampling factors must be 1..4\n"); return FALSE; } cinfo->comp_info[ci].h_samp_factor = val1; cinfo->comp_info[ci].v_samp_factor = val2; while (*arg && *arg++ != ',') /* advance to next segment of arg string */ ; } else { /* reached end of parameter, set remaining components to 1x1 sampling */ cinfo->comp_info[ci].h_samp_factor = 1; cinfo->comp_info[ci].v_samp_factor = 1; } } return TRUE; } Papyrus3/JpegDir/JpgLossy/jconfig.bcc0000755000175000017500000000267007535143454014734 0ustar /* jconfig.bcc --- jconfig.h for Borland C (Turbo C) on MS-DOS or OS/2. */ /* see jconfig.doc for explanations */ #define HAVE_PROTOTYPES #define HAVE_UNSIGNED_CHAR #define HAVE_UNSIGNED_SHORT /* #define void char */ /* #define const */ #undef CHAR_IS_UNSIGNED #define HAVE_STDDEF_H #define HAVE_STDLIB_H #undef NEED_BSD_STRINGS #undef NEED_SYS_TYPES_H #ifdef __MSDOS__ #define NEED_FAR_POINTERS /* for small or medium memory model */ #endif #undef NEED_SHORT_EXTERNAL_NAMES #undef INCOMPLETE_TYPES_BROKEN /* this assumes you have -w-stu in CFLAGS */ #ifdef JPEG_INTERNALS #undef RIGHT_SHIFT_IS_UNSIGNED #ifdef __MSDOS__ #define USE_MSDOS_MEMMGR /* Define this if you use jmemdos.c */ #define MAX_ALLOC_CHUNK 65520L /* Maximum request to malloc() */ #define USE_FMEM /* Borland has _fmemcpy() and _fmemset() */ #endif #endif /* JPEG_INTERNALS */ #ifdef JPEG_CJPEG_DJPEG #define BMP_SUPPORTED /* BMP image file format */ #define GIF_SUPPORTED /* GIF image file format */ #define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ #undef RLE_SUPPORTED /* Utah RLE image file format */ #define TARGA_SUPPORTED /* Targa image file format */ #define TWO_FILE_COMMANDLINE #define USE_SETMODE /* Borland has setmode() */ #ifdef __MSDOS__ #define NEED_SIGNAL_CATCHER /* Define this if you use jmemdos.c */ #endif #undef DONT_USE_B_MODE #undef PROGRESS_REPORT /* optional */ #endif /* JPEG_CJPEG_DJPEG */ Papyrus3/JpegDir/JpgLossy/RDBMP.C0000755000175000017500000003532407535143454013616 0ustar /* * rdbmp.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to read input images in Microsoft "BMP" * format (MS Windows 3.x, OS/2 1.x, and OS/2 2.x flavors). * Currently, only 8-bit and 24-bit images are supported, not 1-bit or * 4-bit (feeding such low-depth images into JPEG would be silly anyway). * Also, we don't support RLE-compressed files. * * These routines may need modification for non-Unix environments or * specialized applications. As they stand, they assume input from * an ordinary stdio stream. They further assume that reading begins * at the start of the file; start_input may need work if the * user interface has already read some data (e.g., to determine that * the file is indeed BMP format). * * This code contributed by James Arthur Boucher. */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif #ifdef BMP_SUPPORTED /* Macros to deal with unsigned chars as efficiently as compiler allows */ #ifdef HAVE_UNSIGNED_CHAR typedef unsigned char U_CHAR; #define UCH(x) ((int) (x)) #else /* !HAVE_UNSIGNED_CHAR */ #ifdef CHAR_IS_UNSIGNED typedef char U_CHAR; #define UCH(x) ((int) (x)) #else typedef char U_CHAR; #define UCH(x) ((int) (x) & 0xFF) #endif #endif /* HAVE_UNSIGNED_CHAR */ /*#define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (len)))*/ #define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) 0)) /* Private version of data source object */ typedef struct _bmp_source_struct * bmp_source_ptr; typedef struct _bmp_source_struct { struct cjpeg_source_struct pub; /* public fields */ j_compress_ptr cinfo; /* back link saves passing separate parm */ JSAMPARRAY colormap; /* BMP colormap (converted to my format) */ jvirt_sarray_ptr whole_image; /* Needed to reverse row order */ JDIMENSION source_row; /* Current source row number */ JDIMENSION row_width; /* Physical width of scanlines in file */ int bits_per_pixel; /* remembers 8- or 24-bit format */ } bmp_source_struct; LOCAL(int) read_byte (bmp_source_ptr sinfo) /* Read next byte from BMP file */ { register PAPY_FILE infile = sinfo->pub.input_file; int c; PapyShort err; PapyULong bytesToRead = 1L; /*if ((c = getc(infile)) == EOF)*/ if ((err = Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &c)) < 0) ERREXIT(sinfo->cinfo, JERR_INPUT_EOF); return c; } LOCAL(void) read_colormap (bmp_source_ptr sinfo, int cmaplen, int mapentrysize) /* Read the colormap from a BMP file */ { int i; switch (mapentrysize) { case 3: /* BGR format (occurs in OS/2 files) */ for (i = 0; i < cmaplen; i++) { sinfo->colormap[2][i] = (JSAMPLE) read_byte(sinfo); sinfo->colormap[1][i] = (JSAMPLE) read_byte(sinfo); sinfo->colormap[0][i] = (JSAMPLE) read_byte(sinfo); } break; case 4: /* BGR0 format (occurs in MS Windows files) */ for (i = 0; i < cmaplen; i++) { sinfo->colormap[2][i] = (JSAMPLE) read_byte(sinfo); sinfo->colormap[1][i] = (JSAMPLE) read_byte(sinfo); sinfo->colormap[0][i] = (JSAMPLE) read_byte(sinfo); (void) read_byte(sinfo); } break; default: ERREXIT(sinfo->cinfo, JERR_BMP_BADCMAP); break; } } /* * Read one row of pixels. * The image has been read into the whole_image array, but is otherwise * unprocessed. We must read it out in top-to-bottom row order, and if * it is an 8-bit image, we must expand colormapped pixels to 24bit format. */ METHODDEF(JDIMENSION) get_8bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading 8-bit colormap indexes */ { bmp_source_ptr source = (bmp_source_ptr) sinfo; register JSAMPARRAY colormap = source->colormap; JSAMPARRAY image_ptr; register int t; register JSAMPROW inptr, outptr; register JDIMENSION col; /* Fetch next row from virtual array */ source->source_row--; image_ptr = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->whole_image, source->source_row, (JDIMENSION) 1, FALSE); /* Expand the colormap indexes to real data */ inptr = image_ptr[0]; outptr = source->pub.buffer[0]; for (col = cinfo->image_width; col > 0; col--) { t = GETJSAMPLE(*inptr++); *outptr++ = colormap[0][t]; /* can omit GETJSAMPLE() safely */ *outptr++ = colormap[1][t]; *outptr++ = colormap[2][t]; } return 1; } METHODDEF(JDIMENSION) get_24bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading 24-bit pixels */ { bmp_source_ptr source = (bmp_source_ptr) sinfo; JSAMPARRAY image_ptr; register JSAMPROW inptr, outptr; register JDIMENSION col; /* Fetch next row from virtual array */ source->source_row--; image_ptr = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->whole_image, source->source_row, (JDIMENSION) 1, FALSE); /* Transfer data. Note source values are in BGR order * (even though Microsoft's own documents say the opposite). */ inptr = image_ptr[0]; outptr = source->pub.buffer[0]; for (col = cinfo->image_width; col > 0; col--) { outptr[2] = *inptr++; /* can omit GETJSAMPLE() safely */ outptr[1] = *inptr++; outptr[0] = *inptr++; outptr += 3; } return 1; } /* * This method loads the image into whole_image during the first call on * get_pixel_rows. The get_pixel_rows pointer is then adjusted to call * get_8bit_row or get_24bit_row on subsequent calls. */ METHODDEF(JDIMENSION) preload_image (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { bmp_source_ptr source = (bmp_source_ptr) sinfo; register PAPY_FILE infile = source->pub.input_file; int c; register JSAMPROW out_ptr; JSAMPARRAY image_ptr; JDIMENSION row, col; cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; PapyShort err; PapyULong bytesToRead = 1L; /* Read the data into a virtual array in input-file row order. */ for (row = 0; row < cinfo->image_height; row++) { if (progress != NULL) { progress->pub.pass_counter = (long) row; progress->pub.pass_limit = (long) cinfo->image_height; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } image_ptr = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, source->whole_image, row, (JDIMENSION) 1, TRUE); out_ptr = image_ptr[0]; for (col = source->row_width; col > 0; col--) { /* inline copy of read_byte() for speed */ /*if ((c = getc(infile)) == EOF)*/ if ((err = Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &c)) < 0) ERREXIT(cinfo, JERR_INPUT_EOF); *out_ptr++ = (JSAMPLE) c; } } if (progress != NULL) progress->completed_extra_passes++; /* Set up to read from the virtual array in top-to-bottom order */ switch (source->bits_per_pixel) { case 8: source->pub.get_pixel_rows = get_8bit_row; break; case 24: source->pub.get_pixel_rows = get_24bit_row; break; default: ERREXIT(cinfo, JERR_BMP_BADDEPTH); } source->source_row = cinfo->image_height; /* And read the first row */ return (*source->pub.get_pixel_rows) (cinfo, sinfo); } /* * Read the file header; return image size and component count. */ METHODDEF(void) start_input_bmp (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { bmp_source_ptr source = (bmp_source_ptr) sinfo; U_CHAR bmpfileheader[14]; U_CHAR bmpinfoheader[64]; #define GET_2B(array,offset) ((unsigned int) UCH(array[offset]) + \ (((unsigned int) UCH(array[offset+1])) << 8)) #define GET_4B(array,offset) ((INT32) UCH(array[offset]) + \ (((INT32) UCH(array[offset+1])) << 8) + \ (((INT32) UCH(array[offset+2])) << 16) + \ (((INT32) UCH(array[offset+3])) << 24)) INT32 bfOffBits; INT32 headerSize; INT32 biWidth = 0; /* initialize to avoid compiler warning */ INT32 biHeight = 0; unsigned int biPlanes; INT32 biCompression; INT32 biXPelsPerMeter,biYPelsPerMeter; INT32 biClrUsed = 0; int mapentrysize = 0; /* 0 indicates no colormap */ INT32 bPad; JDIMENSION row_width; PapyULong myULong = 14L; /* Read and verify the bitmap file header */ if (! ReadOK(source->pub.input_file, bmpfileheader, myULong)) ERREXIT(cinfo, JERR_INPUT_EOF); if (GET_2B(bmpfileheader,0) != 0x4D42) /* 'BM' */ ERREXIT(cinfo, JERR_BMP_NOT); bfOffBits = (INT32) GET_4B(bmpfileheader,10); /* We ignore the remaining fileheader fields */ /* The infoheader might be 12 bytes (OS/2 1.x), 40 bytes (Windows), * or 64 bytes (OS/2 2.x). Check the first 4 bytes to find out which. */ myULong = 4L; if (! ReadOK(source->pub.input_file, bmpinfoheader, myULong)) ERREXIT(cinfo, JERR_INPUT_EOF); headerSize = (INT32) GET_4B(bmpinfoheader,0); if (headerSize < 12 || headerSize > 64) ERREXIT(cinfo, JERR_BMP_BADHEADER); myULong = (PapyULong) (headerSize-4); if (! ReadOK(source->pub.input_file, (bmpinfoheader+4), myULong)) ERREXIT(cinfo, JERR_INPUT_EOF); switch ((int) headerSize) { case 12: /* Decode OS/2 1.x header (Microsoft calls this a BITMAPCOREHEADER) */ biWidth = (INT32) GET_2B(bmpinfoheader,4); biHeight = (INT32) GET_2B(bmpinfoheader,6); biPlanes = GET_2B(bmpinfoheader,8); source->bits_per_pixel = (int) GET_2B(bmpinfoheader,10); switch (source->bits_per_pixel) { case 8: /* colormapped image */ mapentrysize = 3; /* OS/2 uses RGBTRIPLE colormap */ TRACEMS2(cinfo, 1, JTRC_BMP_OS2_MAPPED, (int) biWidth, (int) biHeight); break; case 24: /* RGB image */ TRACEMS2(cinfo, 1, JTRC_BMP_OS2, (int) biWidth, (int) biHeight); break; default: ERREXIT(cinfo, JERR_BMP_BADDEPTH); break; } if (biPlanes != 1) ERREXIT(cinfo, JERR_BMP_BADPLANES); break; case 40: case 64: /* Decode Windows 3.x header (Microsoft calls this a BITMAPINFOHEADER) */ /* or OS/2 2.x header, which has additional fields that we ignore */ biWidth = GET_4B(bmpinfoheader,4); biHeight = GET_4B(bmpinfoheader,8); biPlanes = GET_2B(bmpinfoheader,12); source->bits_per_pixel = (int) GET_2B(bmpinfoheader,14); biCompression = GET_4B(bmpinfoheader,16); biXPelsPerMeter = GET_4B(bmpinfoheader,24); biYPelsPerMeter = GET_4B(bmpinfoheader,28); biClrUsed = GET_4B(bmpinfoheader,32); /* biSizeImage, biClrImportant fields are ignored */ switch (source->bits_per_pixel) { case 8: /* colormapped image */ mapentrysize = 4; /* Windows uses RGBQUAD colormap */ TRACEMS2(cinfo, 1, JTRC_BMP_MAPPED, (int) biWidth, (int) biHeight); break; case 24: /* RGB image */ TRACEMS2(cinfo, 1, JTRC_BMP, (int) biWidth, (int) biHeight); break; default: ERREXIT(cinfo, JERR_BMP_BADDEPTH); break; } if (biPlanes != 1) ERREXIT(cinfo, JERR_BMP_BADPLANES); if (biCompression != 0) ERREXIT(cinfo, JERR_BMP_COMPRESSED); if (biXPelsPerMeter > 0 && biYPelsPerMeter > 0) { /* Set JFIF density parameters from the BMP data */ cinfo->X_density = (UINT16) (biXPelsPerMeter/100); /* 100 cm per meter */ cinfo->Y_density = (UINT16) (biYPelsPerMeter/100); cinfo->density_unit = 2; /* dots/cm */ } break; default: ERREXIT(cinfo, JERR_BMP_BADHEADER); break; } /* Compute distance to bitmap data --- will adjust for colormap below */ bPad = bfOffBits - (headerSize + 14); /* Read the colormap, if any */ if (mapentrysize > 0) { if (biClrUsed <= 0) biClrUsed = 256; /* assume it's 256 */ else if (biClrUsed > 256) ERREXIT(cinfo, JERR_BMP_BADCMAP); /* Allocate space to store the colormap */ source->colormap = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) biClrUsed, (JDIMENSION) 3); /* and read it from the file */ read_colormap(source, (int) biClrUsed, mapentrysize); /* account for size of colormap */ bPad -= biClrUsed * mapentrysize; } /* Skip any remaining pad bytes */ if (bPad < 0) /* incorrect bfOffBits value? */ ERREXIT(cinfo, JERR_BMP_BADHEADER); while (--bPad >= 0) { (void) read_byte(source); } /* Compute row width in file, including padding to 4-byte boundary */ if (source->bits_per_pixel == 24) row_width = (JDIMENSION) (biWidth * 3); else row_width = (JDIMENSION) biWidth; while ((row_width & 3) != 0) row_width++; source->row_width = row_width; /* Allocate space for inversion array, prepare for preload pass */ source->whole_image = (*cinfo->mem->request_virt_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, row_width, (JDIMENSION) biHeight, (JDIMENSION) 1); source->pub.get_pixel_rows = preload_image; if (cinfo->progress != NULL) { cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; progress->total_extra_passes++; /* count file input as separate pass */ } /* Allocate one-row buffer for returned data */ source->pub.buffer = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) (biWidth * 3), (JDIMENSION) 1); source->pub.buffer_height = 1; cinfo->in_color_space = JCS_RGB; cinfo->input_components = 3; cinfo->data_precision = 8; cinfo->image_width = (JDIMENSION) biWidth; cinfo->image_height = (JDIMENSION) biHeight; } /* * Finish up at the end of the file. */ METHODDEF(void) finish_input_bmp (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { /* no work */ } /* * The module selection routine for BMP format input. */ GLOBAL(cjpeg_source_ptr) jinit_read_bmp (j_compress_ptr cinfo) { bmp_source_ptr source; /* Create module interface object */ source = (bmp_source_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(bmp_source_struct)); source->cinfo = cinfo; /* make back link for subroutines */ /* Fill in method ptrs, except get_pixel_rows which start_input sets */ source->pub.start_input = start_input_bmp; source->pub.finish_input = finish_input_bmp; return (cjpeg_source_ptr) source; } #endif /* BMP_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/wrjpgcom.10000755000175000017500000000525207535143454014555 0ustar .TH WRJPGCOM 1 "15 June 1995" .SH NAME wrjpgcom \- insert text comments into a JPEG file .SH SYNOPSIS .B wrjpgcom [ .B \-replace ] [ .BI \-comment " text" ] [ .BI \-cfile " name" ] [ .I filename ] .LP .SH DESCRIPTION .LP .B wrjpgcom reads the named JPEG/JFIF file, or the standard input if no file is named, and generates a new JPEG/JFIF file on standard output. A comment block is added to the file. .PP The JPEG standard allows "comment" (COM) blocks to occur within a JPEG file. Although the standard doesn't actually define what COM blocks are for, they are widely used to hold user-supplied text strings. This lets you add annotations, titles, index terms, etc to your JPEG files, and later retrieve them as text. COM blocks do not interfere with the image stored in the JPEG file. The maximum size of a COM block is 64K, but you can have as many of them as you like in one JPEG file. .PP .B wrjpgcom adds a COM block, containing text you provide, to a JPEG file. Ordinarily, the COM block is added after any existing COM blocks; but you can delete the old COM blocks if you wish. .SH OPTIONS Switch names may be abbreviated, and are not case sensitive. .TP .B \-replace Delete any existing COM blocks from the file. .TP .BI \-comment " text" Supply text for new COM block on command line. .TP .BI \-cfile " name" Read text for new COM block from named file. .PP If you have only one line of comment text to add, you can provide it on the command line with .BR \-comment . The comment text must be surrounded with quotes so that it is treated as a single argument. Longer comments can be read from a text file. .PP If you give neither .B \-comment nor .BR \-cfile , then .B wrjpgcom will read the comment text from standard input. (In this case an input image file name MUST be supplied, so that the source JPEG file comes from somewhere else.) You can enter multiple lines, up to 64KB worth. Type an end-of-file indicator (usually control-D) to terminate the comment text entry. .PP .B wrjpgcom will not add a COM block if the provided comment string is empty. Therefore \fB\-replace \-comment ""\fR can be used to delete all COM blocks from a file. .SH EXAMPLES .LP Add a short comment to in.jpg, producing out.jpg: .IP .B wrjpgcom \-c \fI"View of my back yard" in.jpg .B > .I out.jpg .PP Attach a long comment previously stored in comment.txt: .IP .B wrjpgcom .I in.jpg .B < .I comment.txt .B > .I out.jpg .PP or equivalently .IP .B wrjpgcom .B -cfile .I comment.txt .B < .I in.jpg .B > .I out.jpg .SH SEE ALSO .BR cjpeg (1), .BR djpeg (1), .BR jpegtran (1), .BR rdjpgcom (1) .SH AUTHOR Independent JPEG Group Papyrus3/JpegDir/JpgLossy/makefile.ansi0000755000175000017500000002735307535143454015302 0ustar # Makefile for Independent JPEG Group's software # This makefile is suitable for Unix-like systems with ANSI-capable compilers. # If you have a non-ANSI compiler, makefile.unix is a better starting point. # Read installation instructions before saying "make" !! # The name of your C compiler: CC= cc # You may need to adjust these cc options: CFLAGS= -O # Generally, we recommend defining any configuration symbols in jconfig.h, # NOT via -D switches here. # Link-time cc options: LDFLAGS= # To link any special libraries, add the necessary -l commands here. LDLIBS= # Put here the object file name for the correct system-dependent memory # manager file. For Unix this is usually jmemnobs.o, but you may want # to use jmemansi.o or jmemname.o if you have limited swap space. SYSDEPMEM= jmemnobs.o # miscellaneous OS-dependent stuff # linker LN= $(CC) # file deletion command RM= rm -f # library (.a) file creation command AR= ar rc # second step in .a creation (use "touch" if not needed) AR2= ranlib # End of configurable options. # source files: JPEG library proper LIBSOURCES= jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c \ jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c \ jcphuff.c jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c \ jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c \ jdinput.c jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c \ jdpostct.c jdsample.c jdtrans.c jerror.c jfdctflt.c jfdctfst.c \ jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c jquant1.c \ jquant2.c jutils.c jmemmgr.c # memmgr back ends: compile only one of these into a working library SYSDEPSOURCES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemmac.c # source files: cjpeg/djpeg/jpegtran applications, also rdjpgcom/wrjpgcom APPSOURCES= cjpeg.c djpeg.c jpegtran.c rdjpgcom.c wrjpgcom.c cdjpeg.c \ rdcolmap.c rdswitch.c transupp.c rdppm.c wrppm.c rdgif.c wrgif.c \ rdtarga.c wrtarga.c rdbmp.c wrbmp.c rdrle.c wrrle.c SOURCES= $(LIBSOURCES) $(SYSDEPSOURCES) $(APPSOURCES) # files included by source files INCLUDES= jchuff.h jdhuff.h jdct.h jerror.h jinclude.h jmemsys.h jmorecfg.h \ jpegint.h jpeglib.h jversion.h cdjpeg.h cderror.h transupp.h # documentation, test, and support files DOCS= README install.doc usage.doc cjpeg.1 djpeg.1 jpegtran.1 rdjpgcom.1 \ wrjpgcom.1 wizard.doc example.c libjpeg.doc structure.doc \ coderules.doc filelist.doc change.log MKFILES= configure makefile.cfg makefile.ansi makefile.unix makefile.bcc \ makefile.mc6 makefile.dj makefile.wat makefile.vc makelib.ds \ makeapps.ds makeproj.mac makcjpeg.st makdjpeg.st makljpeg.st \ maktjpeg.st makefile.manx makefile.sas makefile.mms makefile.vms \ makvms.opt CONFIGFILES= jconfig.cfg jconfig.bcc jconfig.mc6 jconfig.dj jconfig.wat \ jconfig.vc jconfig.mac jconfig.st jconfig.manx jconfig.sas \ jconfig.vms CONFIGUREFILES= config.guess config.sub install-sh ltconfig ltmain.sh OTHERFILES= jconfig.doc ckconfig.c ansi2knr.c ansi2knr.1 jmemdosa.asm TESTFILES= testorig.jpg testimg.ppm testimg.bmp testimg.jpg testprog.jpg \ testimgp.jpg DISTFILES= $(DOCS) $(MKFILES) $(CONFIGFILES) $(SOURCES) $(INCLUDES) \ $(CONFIGUREFILES) $(OTHERFILES) $(TESTFILES) # library object files common to compression and decompression COMOBJECTS= jcomapi.o jutils.o jerror.o jmemmgr.o $(SYSDEPMEM) # compression library object files CLIBOBJECTS= jcapimin.o jcapistd.o jctrans.o jcparam.o jdatadst.o jcinit.o \ jcmaster.o jcmarker.o jcmainct.o jcprepct.o jccoefct.o jccolor.o \ jcsample.o jchuff.o jcphuff.o jcdctmgr.o jfdctfst.o jfdctflt.o \ jfdctint.o # decompression library object files DLIBOBJECTS= jdapimin.o jdapistd.o jdtrans.o jdatasrc.o jdmaster.o \ jdinput.o jdmarker.o jdhuff.o jdphuff.o jdmainct.o jdcoefct.o \ jdpostct.o jddctmgr.o jidctfst.o jidctflt.o jidctint.o jidctred.o \ jdsample.o jdcolor.o jquant1.o jquant2.o jdmerge.o # These objectfiles are included in libjpeg.a LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS) # object files for sample applications (excluding library files) COBJECTS= cjpeg.o rdppm.o rdgif.o rdtarga.o rdrle.o rdbmp.o rdswitch.o \ cdjpeg.o DOBJECTS= djpeg.o wrppm.o wrgif.o wrtarga.o wrrle.o wrbmp.o rdcolmap.o \ cdjpeg.o TROBJECTS= jpegtran.o rdswitch.o cdjpeg.o transupp.o all: libjpeg.a cjpeg djpeg jpegtran rdjpgcom wrjpgcom libjpeg.a: $(LIBOBJECTS) $(RM) libjpeg.a $(AR) libjpeg.a $(LIBOBJECTS) $(AR2) libjpeg.a cjpeg: $(COBJECTS) libjpeg.a $(LN) $(LDFLAGS) -o cjpeg $(COBJECTS) libjpeg.a $(LDLIBS) djpeg: $(DOBJECTS) libjpeg.a $(LN) $(LDFLAGS) -o djpeg $(DOBJECTS) libjpeg.a $(LDLIBS) jpegtran: $(TROBJECTS) libjpeg.a $(LN) $(LDFLAGS) -o jpegtran $(TROBJECTS) libjpeg.a $(LDLIBS) rdjpgcom: rdjpgcom.o $(LN) $(LDFLAGS) -o rdjpgcom rdjpgcom.o $(LDLIBS) wrjpgcom: wrjpgcom.o $(LN) $(LDFLAGS) -o wrjpgcom wrjpgcom.o $(LDLIBS) jconfig.h: jconfig.doc echo You must prepare a system-dependent jconfig.h file. echo Please read the installation directions in install.doc. exit 1 clean: $(RM) *.o cjpeg djpeg jpegtran libjpeg.a rdjpgcom wrjpgcom $(RM) core testout* test: cjpeg djpeg jpegtran $(RM) testout* ./djpeg -dct int -ppm -outfile testout.ppm testorig.jpg ./djpeg -dct int -bmp -colors 256 -outfile testout.bmp testorig.jpg ./cjpeg -dct int -outfile testout.jpg testimg.ppm ./djpeg -dct int -ppm -outfile testoutp.ppm testprog.jpg ./cjpeg -dct int -progressive -opt -outfile testoutp.jpg testimg.ppm ./jpegtran -outfile testoutt.jpg testprog.jpg cmp testimg.ppm testout.ppm cmp testimg.bmp testout.bmp cmp testimg.jpg testout.jpg cmp testimg.ppm testoutp.ppm cmp testimgp.jpg testoutp.jpg cmp testorig.jpg testoutt.jpg jcapimin.o: jcapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcapistd.o: jcapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccoefct.o: jccoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccolor.o: jccolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcdctmgr.o: jcdctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jchuff.o: jchuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcinit.o: jcinit.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmainct.o: jcmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmarker.o: jcmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmaster.o: jcmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcomapi.o: jcomapi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcparam.o: jcparam.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcphuff.o: jcphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcprepct.o: jcprepct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcsample.o: jcsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jctrans.o: jctrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapimin.o: jdapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapistd.o: jdapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdatadst.o: jdatadst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdatasrc.o: jdatasrc.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdcoefct.o: jdcoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdcolor.o: jdcolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jddctmgr.o: jddctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jdhuff.o: jdhuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdinput.o: jdinput.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmainct.o: jdmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmarker.o: jdmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmaster.o: jdmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmerge.o: jdmerge.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdphuff.o: jdphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdpostct.o: jdpostct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdsample.o: jdsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdtrans.o: jdtrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jerror.o: jerror.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jversion.h jerror.h jfdctflt.o: jfdctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctfst.o: jfdctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctint.o: jfdctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctflt.o: jidctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctfst.o: jidctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctint.o: jidctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctred.o: jidctred.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jquant1.o: jquant1.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jquant2.o: jquant2.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jutils.o: jutils.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemmgr.o: jmemmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemansi.o: jmemansi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemname.o: jmemname.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemnobs.o: jmemnobs.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemdos.o: jmemdos.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemmac.o: jmemmac.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h cjpeg.o: cjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h djpeg.o: djpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h jpegtran.o: jpegtran.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.h jversion.h rdjpgcom.o: rdjpgcom.c jinclude.h jconfig.h wrjpgcom.o: wrjpgcom.c jinclude.h jconfig.h cdjpeg.o: cdjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdcolmap.o: rdcolmap.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdswitch.o: rdswitch.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.o: transupp.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h transupp.h rdppm.o: rdppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrppm.o: wrppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdgif.o: rdgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrgif.o: wrgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdtarga.o: rdtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrtarga.o: wrtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdbmp.o: rdbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrbmp.o: wrbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdrle.o: rdrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrrle.o: wrrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h Papyrus3/JpegDir/JpgLossy/testimg.ppm0000755000175000017500000030615707535143454015045 0ustar P6 227 149 255 0/-0/-10.21/51.51.62/62/83/83/:3-:3-:3-:3-:3-:3-:2/91.91.80-80-91.91.:2/80-80-80-80-80-80-80-80-6.+6.+6.+5-*5-*4,)4,)4,)4,)4,)4,)4,)4,)4,)4,)2-)/*$/,%/,%0-&1.'2/(30)30)63,63,74-85.85.96/:70:7.A:0B<0D>2F@4IA4JB5KC6KC6MD5MD5OC3NB2OC3OC3PD4RE5R?1Y?2b@4nB5}E6‹H8™G9£F7¯G:¸G9¾E:ÅG;ÇG>ÊG?ËH@ÐE@çFLíCLëDKëEIîCIïBDñ>Bô=Aø;A÷:@ô:?ð×?<ËA7»=/µ@.µ@.´?-´?-³@-²?-¯@-­@,ªA,¦A-¢B,Ÿ@*›A)˜@*–A,”>-’?/’?/‘>.‘>,=+’<+’<+”?+”?+”=*”=*”=*•>+–?,–@/–?6•>5—=2Ÿ?1©B3³D3¼D4¿D4¹?0µA2¬F8žH;‡H9oA2T8*C3&=5295495473271160050-50-72/72/72/61.61-50,50,41,//-.0-//-//-0/-0/-2.-2.-5,-4+,4*+3)*7(+=.1E69P:0U?1^A3jC4xD6„E4’E5œC3§C4¯A4µA4¼B7ÀD:ÄE<ÅF=ÍC@áEIçBIèCIêDHíDGïBDó@Cö?Cø;A÷:@ô:?ðÕ@<Ê@6¹>/µ@.´?-´?-´?-²?,°?-¯@-­@,©@+¦A-¡A+Ÿ@*›A)˜@*–A,”>-’?/‘>.‘>.‘>,=+’<+’<+”?+“>*”=*”=*”=*•>+–?,–@/”@5•>5˜>3 >1«A3µD4½C4¿D5»A2·C6¬F8œI;…G:l@3S9*B4)>63:6595484382271161.61.72/72/72/61.61-50,50,41,//-.0-//-//-0/-0/-2.-2.-3--5,-4*+3)*5)+<-0C47N8:d>=vEA†JINLšTV¤aj¥l}rŽ‘{¢†€®…¹{„»ou©[[QHuOCiOFeOG_PH_RN_[Yfnotƒ‡ˆ”™•™ž—š ”™‘ƒ~ojkY][LVSJXSZVRaXQa/.,/.,0/-10.40-40-51.51.72.72.72.72.92,92,92,92,91.80.7/-7/-7/-7/-80.91/80.80.80.80.80.80.80.80.6.,5-+5-+5-+4,*4,*4,*4,*5-+5-+5-+5-+5-+5-+5-+3.*2-'1.'2/(30)30)41*41*52+63,63,63,74-85.96/96/:7.?8.@:.B<0D>2G?4H@5H@3H@3I@1I@1K?1K?1K?/L@0MA1NB2MA1QA1YB2dC2qC3|C2‡B2’A0˜<- :+§;.¯=2µ@6ºD:¿F=ÅD>ÙCEá@FãBGçBFêDFðCEôADø?Dú;@ù:?õ;@ð=@è@@ÜA=Ñ@;Æ@5·=.³@-³@-²?,²?-°?-¯>,­@,ª?-§@-¥@,¡A+A,š?*˜@*•@+”>-‘>.‘>.‘>.=+=+=+=+‘>,‘>,’<+’<+“=,“=,”?+•?.•A6–?5š>3£>2¯A4¹C5¿D5ÁC5ÀD8¸F;®I=™J=G;h@4Q:,B5,?74=77<66:4494183072/72/62/62/62/51.52-41,41,21,.0-,1-.0-.0-//-//-0/-2.-5//4..5,-4*+4*+9-/>24I56[97l?9|E@†IDOM˜[`›fv”mˆŒwžƒ}­}‚¹u~·fm¤TV‰MEvLAkMAeOFcQHcMH^NK\[[eqty…‰ˆ‡Œ†Šˆ…†Š|xzlfiXZ[MVSLZU[ZT`[S`.-+/.,/.,0/-3/,40-40-40-61-61-61-61-81+81+81+81+7/-7/-6.,6.,6.,6.,7/-7/-80.80.80.80.80.80.80.80.5-+5-+5-+4,*4,*4,*3+)3+)6.,6.,6.,6.,6.,6.,6.,4/,30+30)30)41*41*52+52+52+52+52+63,74-85.85.96/96->7-?9-@:.B<0E=2E=2F>1F>1G=1G>/H<.I=/I=/J>.L@0JA0KD2NE4UD4^D3iD2sB1~A/†?-Œ9)”9'9*£<-¬@3³E8¸H<ÁF>ÒDCÚACÞBCâDCçCDìBCó@C÷?Aú;@ù:?õ;@î>@åA@ÚB=Í@9Â@3µ=-°@,°@,°@,¯>,®?,®?,¬?+©@-¦?,£@+ @*œ@+˜@*–@)”?*‘>,‘>.‘>.=-=+=+<*<*=+=+<*<*’<+‘>,”>-’?-•A6–?5œ>2¦@4²B6¼C8ÁC7ÂB7ÂF<ºJ?¬L@—K>|F:b@4L:.A7-@85>96=77<74:5294183083062/62/62/32.52-21,21,12--2.-2./1./1.00.00.10.10.5106005//5,-4+,6,-:01D22T71c;3qA7{E;‚HD‰RU_l‹i‚ƒs˜}y«x}µowµ`f¢QR‹LEyL@pL@hPEgQFfLC^GBVMLZ^^fjnquyxx}wz€vwzokoa`bTWYLTTL]WY]V]]V^------.-+/.,0/-10.3/,40-3/,3/,4/+4/+4/+4/+6/)6/)4/,4/,3.+3.+3.+3.+4/,4/,50-50-50-50-50-50-50-50-3.+3.+2-*2-*2-*1,)1,)1,)4/,4/,4/,4/,4/,4/,4/,4/,41,41,41,41,41,52-52-52-52-52-63.63.74/85096196/<5-=6,?8.@9/B:/C;0C;0C;.D:.D:.F:.G;-H<.I=/J>0I@1JG6MH5RG5YF5bE3jD1uB/}>,‚;)‹:)“:*š=,£B2¬F8²J=»I?ÌGBÔDCØDBÝEBâBBéAAð=@ô<>ù:?ø:<ô<>í?>áB>ÓC:ÅA5¹?0²?-®?,®?,®?,­>-¬>-¬>-ª?-¨>.¤?- ?,ž?+š?,—?+•>*“>*‘>,?.>->->-Ž=,Ž=,Ž=,Ž=,Ž=,Ž=,Ž=,<,>-‘>.?.”B4—A4@1¨@3¶A7¿C9ÅB8ÄA7¾C;·H?¦LCJ@tE;Z>2E9-<5+@93@85?75>63=52<4194083/62/43/43/23.32.12-12-02--2.,2.-2.-2./1./1.00.10.3205105104..2,,4+,7./=/.N5.Y9.e=1n@3sB;yKK€Zeƒg€p—zxªu{·ks´_d¦TT”OGƒLBwNAmNBhMAeJA`GBYGFXKKWMPU]cc`fbbia`f\Z`TW[MUXMXXP^YV`WX`WZ,,,,,,.-+.-+/.,0/-3/,3/,2.+2.+3.*3.*3.*3.*5.(5-*3.+3.+2-*1,)1,)2-*3.+3.+3.+3.+3.+3.+3.+3.+3.+3.+2-*2-*2-*2-*1,)1,)1,)0+(3.+3.+3.+3.+3.+3.+3.+3.+41,41,41,41,41,41,41,41,41,52-52-63.74/85085085.;4,<5+=6,>7-@7.A9.A9.A9.C9/C9-E9-F:.G;/H<.J>0HA1JG6IH6NG5VF6\E3dC2n@0v>-{<+‚;)Œ;*”=,œ@1£F5ªJ:´J=ÄH@ÌEAÑFAÖE@ÞCAä@>ì>?ñ:<÷;<ô:;ð<=é@=ÜC=ÍC8¾@2±>,®?,«@,ª?+ª?+ª?-©>,©>,¨?,¥>-¢?, ?,›>,—?+•>*“>)‘?*>+>->->-Ž=,Ž=,Ž=,<+Ž=,‹<+<+‹<+‹<-Œ=,>/Ž?.”B4—A2 @2¬B5¹C9ÂC:ÅB:ÂA;ºA9±I@£NGNEoG=S?4A;/96-@93A75?74>63<4194083/74/43/43/34/23.23.02-02-.3--3/-3/.3/.3/02/02/11/11/21/32032040/2.-1-,4..8.,G4-O4)X8+`<0e?6mGFyYd‚k…€uŸ||²w|¼nu»dh¯[[¡RMLB~OArL@hI=cH>`HB^ECX@BO;@FBGJDMJJQJJQIIQFKQEOUIVWO^YS`YS`XU++++++,,,---/.,/.,0/-0/-1-*1-*1-*1-*2-)2-)2-)2-)2-*2,,1++1++1++1++2,,2,,1++1++1++1++1++1++1++1++2,,2,,2,,1++1++1++0**0**3--3--3--3--3--3--3--3.+41,41,41,30+30+30+30+30+41,41,52-63.74/74/85085.:3+;4,<5-=6.?6/?6-?6-?7,B8.B8.E8/E9-G;/H<0J>2H@3HE6GF4KE5QD4XC2_B2f?.n=,v=,|:*…9)Œ;*“=.›B2¢F7¬F8»F<ÂF>ÉF>ÐE>ÙD@âC?ê@@ð>>ò::ñ;:ì<<äA<ÖC;ÆD6µ@/ª=)ª?-©@-©@-¨?,¨>.¨>.§=-¥>-£=. ?.ž?-š?-–?,“>*‘?*>)>+>->-Œ=,Œ=.Œ=.‹<-‹<-‹<-Š=-Š;,‰<,Š.‹=0Œ?/’C2˜B1¡A1®B6¼C:ÂC<ÄC=ÀC=¹FA²QJ¥XRXQsRIWI>CC793@72>71=60:5/94.83/63.43.43.34/13.13..3-.3-.3--3/-3/-3/-3/.3/.3/02/02/00.11/22021/0/-/.,2.-4/,?0+D0)K3)T8-Z<4dFFu]jƒs‰€«…„¾~ƒÇtzÆmp½ce¯VSšLC‚K?qI_FB]DBW?AN;?H:BE>HGDMHGQIGQHJRGNVKUXM^ZOaYNaXO++++++,,,,,,.,-/.,0/-0/-1-*1-*1-*1-*2-)2-)2-)2-*2,,1++1++0**0**1++1++2,,0**0**0**0**0**0**0**0**2,,2,,2,,1++1++0**0**0**2,,2,,2,,2,,2,,2,,2,,2,,3/,30+30+30+30+30+30+30+41,41,52-63.63.74/85085092,:3+;4,<5->5.>5.>5.>5,B8/B8.E8/E8/G:1I=1J>2I?3FC4FC4JB5OA4TA2\@2b>0j<-q<.w9*}8)…8(Œ:,•=/›B4¤B5²F:ºE;ÁF>ÊG?ÔG@ÞFAçCAîB@í;;ë;;ç>;ßB;ÑD:¿D4¯@-¤>(¦A-¦A-¥@,¥@.¥@.¤?-¤?-¤>/¢>.Ÿ@.œ?.˜?-•>+‘?*>)>+>->->-Œ=,Œ=.‹<-‹<-Š=-Š=-ˆ<.ˆ<.ˆ<.ˆ/ˆ>1‹?1‘D2–C1¢B4­C6ºC;ÁD>ÁD>»EA¹PL²[T¥e\‘f]u_T[UIGMACI?<92?82>71;6094.74-63.43.43.34.24/13./4..3-.3-.3--3/-3/-3/-3/.3/.3/02/02///-00.22022010.0/-0/-3/,8,,;,)C0*K70S<6^IHtbn‡z”Š¶ŒÆ„ˆÏz€ÌrxÆik¶WWŸID„E=nG^CAY@CV@DP>EKGQRKWUQ^WU`XS_UR^TT^SY_S^[LaZJaZJ,-/,-/,-/,.-------.-+.-+/.,/.,1-*0,)0,)0,)/+(/+(/+*/+*/+*/+*/+*/+*/+*0,+/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*0,+0,+1-,1-,2.-1-,1-,1-,1-,1-,1-,1-,1-,0,)1-*2.+3/,3/,3/,3/,3/,3/,3/,3/,3/,40-51.62/74/80-92,:3-;4.=4/>5.>5.>5.?4.?5,B5-C6.D7/F90G:1F<2G?4H@5J@6P?5T>3X<1^90b6+m9.t8-|8+ƒ9,;/“=0˜?1ž>0§A3­A4µC8¾E:ÊG=ÔG>ÞE?åC@è@?êBAæDAÚE>ÈD8·B1ªA.¢B,¢A.¡@-¢?,¢>.¡=-¡=-¢>. ?/œ<,š=,˜<-•>-“=,=+Ž=*Œ>*‹<+‹<+Š=-‰<,‰<,‰<,ˆ:-‡;-‰=/†3ˆ@2‰A5‹A4‘E5—D4£E9±I>ºG@»D>»EA¸MG´ZR¯f_£qf‘sh~rdjj^V^SIQFLLBJF=B>5<8/95,74+63,33+43.34.14-14-02-/1,,1+,1+-2.-2.-2.-2./1./1./1./1.02/02/11/11/11/11/11/40/4+0;/3A32C4/J;6]OOymy‹…Ÿ“»”–Ï•Ùƒ‰ÓtzÆjn·_b§Z[”LItHBdA>]>>X?BUAIVLU\U`bbqnn}xv†|rulyoguh_k_W_P]\Hb\Fc]G,-/,-/,-/,-/------.,-.-+/.,.-+0,)0,)/+(/+(/+(/+(.*).*).*).*)/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*/+*0,+0,+0,+1-,1-,1-,1-,1-,1-,1-,1-,1-,1-,0,+0,)1-*2.+3/,3/,2.+2.+2.+2.+2.+2.+3/,40-51.62/80.91.:2/;4.=4/>50>50=4-?4.?4.A4.B5-C6.E80G:2H;3H>5H>5L=6O>6Q=4V;2Z90_7/h70p7.w7-9-‰9.<1–<1›=1¢@3§A3¬B5´D8¾E:ÉF<ÔE=ÛD=ßD@àE@ÞFAÔG>ÄF8²C2¥B-žB-ŸC.žB-Ÿ@.ž?-ž?-ž?-ž>.ž>.š=,™>,–=-”=,=+>+Œ>*Œ=,‹<+Š=+‰<,‰<,‰<,‡;+‡;-…<-†2†@6‡A7ˆB6“G9—E7£G<¯J@¸IB¸GA·LF³TN±d\ªqfŸ~oo|mmseZfZNXMLNAKI=EC7@=4=:188.44,11)23-23-03,/2+/1,.0+.0+.0+/1.-2./1./1./1./1./1./1.02/02/11/11/11/11/11/2015+49-7<23?53H?:^VTxr|Šˆž““¹”—Ê–Ô„‹ÏyÂqy¸kt­hnž\_€XZqSUjRWjT^hZgmfvvr‚tˆ~’‡ƒ•‰~Žv†yr€qfteZeT[ZE`Z@b\D,-/,-/,-/,-/,-/,.-------.-+.-+.-+-,*/+(.*'.*'.*',+),*+,*+,*++)*+)*+)*+)*-+,-+,-+,-+,-+,-+,-+,-+,,*+,*+-+,-+,-+,.,-.,-.,-.,-.,-.,-/-./-./-./-./.,0,+0,+1-,2.-2.-2.-2.-1-,1-,1-,1-,1-,2.-3/.40/51.80.91.:2/;30=31=4/=4/=4/?40?4.A4.A4.C60D71F93G:4H;5J;6K<7N=6P;6S:5V72[6.c60k6.t5,}7/‡9/;0”<0–<1?3 @4¢@3¨@3±C6ºD8ÅE:ÍD:ÕF@×H@ÔIBÌI?¾E:®C3¡B.œA.B/œA.œ?.›>-›>-›>-›>/›?0˜<-–=-”<.“=.>-Œ=,‹<+Š=+‰<*‰<*‰<,‡;+‡;-…<-„:-ƒ;-„<0‚<0‚<2‚>3ƒ?4…A8‡C:ˆD9”J=—H; H>¬KD²KF³LG²SM®`V­sg¦qŒz‘Ž{‚‰ws€ocqbXcUNRDMN@HI;DD8@@49;.46+/1&01)01)/0*/0*./*./*//-//-//-.0-//-//-//-//-//-//-00.00.00.00.00.00.00.1/26+97+98/4;63HE>_^Yzz|‹š”±’—¿•Ç„ŽÃ}‰»{‰¶|‹²}Œ«}ˆšwƒq~‡n}‚n~~o‚~yŽ…ƒ™‹¡”‘¨˜¥”ˆŠƒ–ƒ|{j{i\hTXX@]Y<_[@-.0-.0-.0-.0-.0-.0.......-+.-+-,*-,*.*'.*'.*'.*),*++)*+)*+)*+)**()*()*(),*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+-+,-+,-+,-+,.,-.,-.,-.,-/-./-./-./+*0,+1-,1-,1-,1-,0,+0,+0,+0,+0,+0,+1-,2.-3/.40/91/:20;31<41=31=31=31=4/>3/>3/@2/@3-A4.C60D71E82F93H94I:5J;6L:6N94Q83T50^72e60o6/x8/‚90Š:/<1”>1™?4›?4›?2Ÿ?1¥A2®B5¸D7¿E:ÇG>ËH@ÊJAÃI>¶F:ªB5žA0™@.™A-™A-˜?-—>,—>,™>,™=.—>.•<,”=,“=.=-Ž=,Š=+Š=-‰<,ˆ;)ˆ;)‡;+‡;+„;,„;,ƒ;-€;,;/€<1€<1>5ƒ@7ƒC:‡D<ˆE<”L@–H<žG>§JC®LI®QL­]Vªj^§€o¡yšš‚›ƒ†•€z‹xm{jbm]SZJQUFKO@EI:@D6;=057,13(01)/0(./).-(.-).-)/.,0/-/.,/.,/.,/.,/.,..,/.,..,0/-//-0/-//-//-//-//-2-17,:6*83-1961HJ?bfX{€z‹““£–°Œ•¶ƒ²¯…™²¤¶’¨³“¨«¤£Œ ž‡ž˜‚™}˜‰œ‹ˆ£”°š˜±›”­—‹£…›„’|k|iXfOSV;ZV9^Z=+/2+/2+/2+/2-.0-.0......------.-+-,*-,*,+),+),+),*+,*+,*++)*+)**()*()*(),*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*+,*++)*+)*+)*,*+-+,-+,.,-.,-/-./-./-./+*0,+0,+0,+0,+0,+/+*.*)/+*/+*/+*/+*0,+1-,3/.40/901:20;31<42=32=31<20<20=20=2.?1.?1.@2/A30B5/C60D63C84D95E:6G96H94K84N50X72_60i70r7/}:1†<1Œ>2>2—@6—?5—?5—?3œ@3£C5«C6³E8ºE;½G=¾H>¹G=°D8¦A5›?0—@/—@-—@-–?.•>-”=,•<,–=/–=/•<.“;-’0->0-?1.@2/A4.?4.@51@72@93A:4B94C84F74H5/Q51X5/a6/l8-u9.€0‹=1“?5•>5“?5“?4•B4šB4 C4¥D4¬B5°D8´E:±E;ªB7¡?4š>1–>0•?.”?+“=,“=,“<+“<+”<.”<.“;-’<-<.;-Š;,‰<,‡;+‡;+†:*†:*…9)ƒ:)ƒ:+9*9-9-€<1<3?6€A8‚C<…F?ˆIBŠICŽJAG>—HCŸNJ§VR§`Z©pe¤ƒrœ”}–¡ƒ¨Šˆ§ˆƒ „~–~yˆup{jdp\]iSR^JJS@BK:>E5:@29<134,22*1.)/,'/))0**1++2,,1++1++1++1++1++0,+0,+0,+1-,1-,1-,1-,/.,/.,/.,2,.8*75(13+(56&EK1\gGu‚d†“yŽ›Š‘ž”Ÿš‹ž˜¥——´ž¢Å¥©Î­¥É­¦Ê°§Ë±¤È¬—¾Ÿ‹³‘ˆ°²Ž²Ž²¬Š„¡‚€™{wŽrdx]Q_ENR7QQ5SR6,03,03,03,03./1./1./1./1/////////////.,/.,.-+.-+/-..,-.,--+,,*++)*+)**()+)*+)*+)*+)*+)*+)*+)*+)*+)*+)*+)**()*()*())'()'(+)*+)*,*+-+,.,-.,-/-./-./+*/+*/+*/+*/+*.*)-)(,('0,+0,+0,+0,+1-,2.-40/40/:12;23;23<34=32<21<21;10<1/<1/>0/=/.>0->0-?1.>3/=60;60;83<94=:5>93@72C60G4.O4+Y4+d5+n8,x:-;.…;.<4‘<5>3@3A2“B1—A2™@0 >1¦@4ªB7ªB9¥@6Ÿ>5—=2•?2’?-’?-‘>,=+‘;*‘;*’<-’<-‘;.‘;.Ž;-;-Š;.ˆ:-†:,„;,…9)…9)ƒ:)‚9(‚9*9*~8,~8,€<1€=4€@7B9„E>…IAˆKFŒMFŒIAŽH@˜JF¡SO¨]X©hb©{n¤Žy™œ’§†‰¬‹‚ªˆ€¡„™€~‹wxnjxadr[ZhQQ]IITCCL;>D60-?1.=2.=4-=6.;819919:29:2;81?6/C2+J1,T2)^3*g7+o9-u=.z2¢B6¡C7žB7™?4–>2”>1”>/“=.=-<,Ž=,Œ=,Œ=.>/Ž<.Ž<.‹2>5€@6‚C:ƒG=…JB‡NE‹OGŒICŽID“PJ˜\Tžg`uiž‡už˜€”¡…ª‰‰¬‹ƒ¨‡€¡„~›zytˆoi}bby]\pUUgOO\HGRAAH8=A388.85.7/,3+)2()2()3)*4*+0*,/+*0*,0**0*,0*,2),2),3*-1+-1+-1+-0,-0,-0,-1+/4)/4*+4-%46!?F%T`8m|Qg‰™tžz¡~ˆ¡zŠ§{‘¶‚›ÄˆŸËŸÉ™žÇÆš˜Á•Œ·Š‚­€…®‚Œµ‰„«‰®…‰©‚~œxvolƒfZnSJZ?GM3FJ1DF./0+.0+/0+01,01,01,12-21-32.43/43/62/51.41,3/,4/,50-50-4/,3.+2,,1-,0,+0,+.,-.,---/--/,,.++-*).))+.)/.)-/(/.)-/)-.)-.*+.*+/+*/+*-,*.-)--+-.)./*./*------.,-/-./.,0/-2.+2.+2-*4,)5-*6.+8/*:1,:1*;2+=4-=4->50>50>50=4/<3.;2-=2.<1-<1/;0.=/.>0/>0/@1.A0)@2);4*77-39-28.56.:3-?-)F*'L)'S*&Z/(`5,d<0k@0yA0@/†A1‹B3@3“=0“;/’8-“;/“=.”A1•B2”C2’A0‘>.‘;,—;0—:2’;1Œ=0ˆ?0„?/‚?.ƒ>.ˆ@1ˆ?0Š>1Š<0‰;/ˆ:.†:-ƒ;-{9+~@3w<.q7)w>-w>-v;-}?2{;/‚@4‡E9‰I?ˆLA†MB„PC‡NE‘KI—SP”bY‘paŒ}j‰‰q‰–|Šž‚¤‡¦‰Ž§Š§Œ‡¤ˆ~Ÿ‚uš{o—uiib„_[zXZsUZnSWeNPWEJK=C?6@93;0.6**3')3'+3'+1&*,*-)+***,*(),'+.(,1(-2'-3(.3(.3(02(00)10)1/*1/*0/)-1++0-(//#5,>5,>5.>5.>5.=4-<3.<3.=2.<1-;0.;0.=/.=/.>0/@1.C0*C0)A2+>4+:6-95,:3-<1-?-+D*)I*(N+'T/)Z5-_:1e>/pA/xA-€A0ˆ@2?4‘=3“:2“;19.‹.Œ@0A1A1ŽA/‘?1•;2•;2<2‹=0†>0ƒ@/?/‚?.…@1†>/‰=0ˆ<.‡;.„;,‚:,€;,x8,x<1s9-n9+s>.s>.r8*u:,}=1ƒA5‰E:‹I=‰K@†NA„PC‡NE‘JH—SR’f]Œwf„†p€“wž„¥†ˆ§ˆ§Š§§Š¤‰Ÿƒwœ}o˜ve’i`‹`Y‚ZY{X\wXZnSSaJNUCFH;C@7<737/-3*+2)*1(+.(*,*+**,+),+),-(,/)-2(02(02(02(02(10)1/*1-*3-*3-*12-12.-0,)--%8:,SXBox]€‹i‡–o†™l†žnˆ£p†¤p„¥pŠ­w“¶€™¹‡–¶„“³Œ®{†«x‚¨w‚¨yƒ¨|ƒ¦|‚¤{x’uqˆnh{eYjWMZHEL<@D5;=/12,12,12,12,23-23-43.43.54/54/85085085074/72.61-80-80-7/,6.+4/,3.+2,,1-,1-./-.0.1/-0--/,,.+*/+)./(/1'//)-/)-/)-/)-.*+.*+0,+0,+/.*/.*/.)0/*0/*0/+//-///0./0./0/-/.,1-*2-*6.+70*90+:1*<1+=3*>4+?5,?6-?6-@7.@7.?6/>5.=4-=4-=2.<1-;0.;0.;0.;0.<1/?1.C2+E0+H/+K--L,/K+.I*/E+.A-,@.*A.(E.(M.)X1*b3-g5,j:,o;-w;0=4‡<6Œ<5:4:4Š<2‡=2†>2…?3†A2‰A3ŒB5C5Ž?2=/Œ>1Š>.‡>/…>,†=.ˆ<,‰;.‰<,ˆ:-†:*ƒ;,<)~=+{<+}=1z<1v:/u;/x@1x@1v<.v;-?5‚B8‰F=‹H?‰JA‡KA‡NCŠNF‘JH˜TQ–f\ve‡…n‚‘t{¤ƒ…¨‡ˆª‰ªŒ©ŒŽ¥‰ˆŸƒš}y˜xi–ma’e\‹a\†`]‚`[|]UrVPhPFYEBP?:D93:2.3,*/)*,)**(0'(1&*1&*1&*0'*1(+0*.0+//*.-+.,+0+,0)-0(-1(-1)-01/23/..*'**"57*PUAmv[|Ši€k~“j™jƒŸn€ n~ m€¥q‡¬x¯|‹­zˆªx„©v§v§u¦w¦y¤y€¢}}›yw‘tp‡mh|cYkUMZHDH9=?299-23-23-34.34.34.45/54/54/650761961:72:72961940940:2/91.91.80-50-4/,4..4..3/03/01/01/20.1..0--/-+.0)02).0*.0*.0*.0*,/+,/+*1-,1-,0/+0/+10+10+10+10,11/1111/010.10.2.+3.+3.*92,92,;2+<3,>4+@6-@6-A7.B8/A8/B90A8/A81@70>5.>5.=2.=2.<1/;0.;0.<1/=20=2.B3.E2.L..R+0V'/U&.P'/I).C/.<1+;2)?2)G0(R/)_.*d/)i9/k;/u<3}<6…;8‰;9Š;7ˆ:6‰>8†@8†B9…B9…C7†B7‡A7‰A5ˆ@1ˆA/‡@.‡@.‡>-ˆ<,ˆ;+‰:+Š8*ˆ9*‡:*ƒ:)<){=(x>(x>*‚>1{7.z7.z<1v;-w=/|A3{@2€B7ƒE:†H=ˆJ?†J@‡MBˆODŠQHŒSJŽ\QŽh[‹tb…g€‹m~–vž|ƒ§ƒ„©‡‡ª‰‹ªŠ‹¦‡‡ ‚ƒš~}˜yq•oi”ifgfŒeg‹gd†e_~_Zw[PhPK^JBP?8D62:/.4*,/(+*%2&&5%(4%(2&(1'(/)+/+,.,-+++*+-*+-(,-(,/',/',/*+-.*+1++0+'.+"88,PUAiqYv„c{Œhyh|–iœl}Ÿmyžkz m¥r‚§t€¥q}£p}£p}¥s~¥v~¥x}¤x|¡x}Ÿzz™wuqn‡je|bWkRN[GDF9?=1:8,45/45/45/560560560761761872872;83<94<94<94<73<73<41<41;30;3083072/61.61.5106216213122011/00./1-.2,04+.4+.4+.2,.2,,2,,2,,3/.3/,3/,3/,21,21,32-32.32032032032051051.61.61-;4.<5/=4-?6-A7.B8/E8/C9/D:1D:1E;2D:1C90B8/@5/@5/>3/>3/=2.=2.=20=20>31>31@51E31M02T,4X)3W(2R)1K,1B30:6-77+:6*B4)M2)X/)^/)f:1j;3s<7z=:‚<:†<;‡;;†::‚;7>8A8B9ƒC:ƒC:…@9„@7‚C2‚C1ƒB0„?/†=.ˆ<.‰:-‹9-‰7+‡8+…9+‚:+~=+x>*v?*x>*9-|/'‚8/„>4w4+s5*}A6}C7E:€G<‚I>ƒJ?„KB†MD‡QG…WJ|aNzjQ€pYu]‚|bƒ†i†“uˆ|ƒ£~§‚‚ª…‚¬†©„¥€{ž}z™wz’pzlxlwŒkumr‰lm„gkd`rX[iRR[HHL=@@4;7,70&5*$6('5''3''1'&.)&+*(++)+-*',('+*)+*)+***,+),+),-)*,#$2*'50*86*BC5UZFfpWn}^tˆeqŠbuex˜iw›ks™htšiwŸkz¢nx lwŸmx ny£s{¥u{¥w|£wyžuzœww–tsŽom†hd{_WkPN[GCC7>:195,560560671671782782872872983:94=:5>;6>;6>;6>95>95?74?74>63=52;63:5294194184184395484373243151240/6-06-.6-06-.4..4..4..4/,40-40-40-51.32-32-43.43.43/431542540841850940:5/=60>7/@7.A8/C90D:0G:1H;2F<3F<3F<3F<3E;2C90B71A60@51@51?40>3/>31?42@53?53@72C52I35P16T/6S.5P05J22C52=90<:-=:+C7)I6(Q3)W2)]2+d3,l50v64}77‚87ƒ77‚66~75}:4}<6}>5€?9ƒ@8†?9…A8€B3€C1B1ƒ@0…=/‡;.ˆ:.‡9-…9,ƒ9,‚:,<,|=,y>,x?,|=,‡5*‹2,¡LE§XQ‹A8|90‚F;€K=yH:zJ<{M>|N?}OBQE‡UJ‚_LrkOosR|uX‡w]yb˜iŸ‹s ”z––z|‹£ˆ¨…§‚€¤~{Ÿy~™vƒ‘p…ŽoƒŽp€pp{ŽpwŒms‡kj~bfv\_hSV[GOM>GA3@6*=0';,'9+(6+'3+(/,',-'+.').().(+-(-,*/+*3)*4(*7'*7'(3($<3,E>4IG8QR@]bKgqVjyZn‚]k„\l‰]p‘bq•eo•do—eršfuŸmrœjq›itžnx¢rz¤vy¢vyŸvvštw™vu”rokj…fc|^UlON\ECC7@91;4,671782782782893893983:94:94;:5>;6?<7?<7?<7@;7@;7B:7B:7A96@85=84=84<73<73<73<74<74<74;639529338308/09/.8/080.80.80.61.61-61-61-52-52-63.63.74/74/540540841952:63<94=84@93@70A8/C90D:0G:1H<0I=1I=1J=4J=4J=4I<3F<3D:1B8/A7.A81@70@72?61?61@72@72A83?74@85B86D97G96H96H96H94E80E8/E9-E9+G9,I9*K9+Q7*Z/&d/'n3-z63ƒ98‰;9‹;:‹=;‹A>‡@:‚=6<3:3‚<4ˆ=7‰@7ƒA5B3‚@2ƒ?2ƒ=1„<0;/€/|>/}>/=/†9/1+¢<8ÍlfÙ~y­ZTŒC<ˆLAN@tJ(+C&+E$+C&(F5-LC4VQ>[YD`bJgmQiwVj{Wl‚[g‚Wf†WlŽ\o”an”an–bršfsko›jo™irœnw ty¢xxžwu›vs—su—vs’rn‹li„cb{[TmMM]CGH:E<5@707827828938938939:4:94:94;:5<;6?<7@=8@=8@=8A<8A<8C;8C;8C;8B:7?:6>95>95=84>95>95>95>95=85<73:51;30:0.:0.91.91.91/91.91.72.61-61-63.63.63.74/74/74/540651952;83<94?:4B;5B;3A8/B:/C9/E;/H<0I=1J>2J>2K>5K>5J=4J=4F<3E;2C90B8/B92B92A83@72@72A83B94A:4?82@93B;5D=7F=6G<6K<5N;4M6.N6,Q6+Q6+Q7*P9+P9)V6'f6*r6,~;3‰@9•D@›HDŸJGŸLF QJ™LDŽD;…;0„7-…7-Œ91=4ˆ>5‡>7†=6…<5…<5=4}=3z>3x@3vA3x@3z>3<3ƒ:3ˆ73‘31˜(&³=;ì|zý•’Åhc–G@‰K@xH:nMhV>lX@t[E`L€hPysQ„wUžt\´l^É__ÓV\ÙQ[×T\äouÙzx̆|À~µ•€«•}£’xŸvœŠrœŠt™u•u‘‘u‹’s†‘s‚‘r|‹ny†ju{amoWgbN_TBUE5R/(9/&7.'6/'81):/)=.+A,+F)+H(+K'+H)'TB4YQ9B?:D?;D?;E@8E>8D=7B;5B;5B;5B;5B:7B;5A:4A:4A83A83A83@72@64>71>71>71<71<71;60:5/85.85.74/74/961961961:70<71=82A:2B;1C:1D<1F<2J>2K?3L@2N@3N@5N@7N@7L?6K>5I<3H;2E;2E;2B90A8/@91?80?80?80@93@93<5/MD=M@:K:3T@9R62O0+a<6\3-`5.`4+^/'^/%f6,m=1q=0‰I=G;—I?ŸKAŸF>›>7š=6žD;¦ND¤PE¨VJ«YK¥OB™A5—;0›>6“98‘98Œ65†52†84„?8|@6r>1rB4oA2q=0v:0‚72Œ43’-1š',ÈHIèbaÅEDÍWUáyv«VO†F<„VFmR=i[AibFjeHj`En^D|dLjT’bL²m]ÑnhÛX]à;Lç-Eò+Hõ0Lö@YìI\ä[eånrâ{|Û€}Ûƒ؉‚Ãv½wº„x¶†x²ˆx­Šw¨‹y¥Œxš€o™~m˜xi“oabY„UM{IBxA>u:9:49:49:49:4:;5;<6>=8?>9>=8>=8A>9A>9B?:C@;D?;D?;FA=E@8E>8E>8E>8E>8D=5C<6C<4D;4C:1B92B92B92B92A83A83@93@93>71<71;60;6096/85.74/74/96196/96/:70<71>:1A:0B<0C;0E;/I=1J>0L@2L@2N@3N@3N@5N@7M?6J=4I<3H;2E;2E;2C:1B90@91@91@91@91A:4B92D93I81L/+V.,j76u99{;;…ECƒD?„H@…IA†G>ŽIB™NH¡PL¢OG“D7”B4šB6ŸC8 >3œ7-œ7-Ÿ=0£C5›?0™@0 E3¤G6§F6®H:¶NE´LM¯HL¥@D™9;‘98>:ƒ@8x>3o>0zI;…LA„?8„,+’).³9DÒLWÜKNßMMÊ>=À@?Ð`\³YQ„@5‚TDyaIe[@^]?ihIslOvgJ~dK–cN¼dXÖ_[æUZëANò,Eþ%Dÿ&Hÿ'Iÿ.Nù3Nò6UE8[O5cZ9gaAifEnrOz‚]z‰bt†^r‰_p‰_p‹`qŽ`u’dw”dw”dw”fs’ix–rz—xy–x~˜}ƒ„…‡ƒ›…™ƒz’zr‰om„hhd`y[TmMNaERSAVPBUOC8938938939:4;<6<=7?>9@?:@?:@?:C@;C@;C@;C@;D?;D?;FA;FA;FA;E@:E@:E@:G@8F?7JA:I@9H?8G>5F=6E<3F<3E;1D:1D:1D:1D:1D;4D;4D;4C<4?80?80<71;60:5/:5/94.94.96/96/:5/;7.>7/@9/B90C;0E;1F<0I=1K?1M?2M@0NA1M@0P?5M?4L>3K=2I<3H;2E;1D:0C:1C:1A:0A:0?;2@<3@<3D;4UD—I?–LAœNB¬RJ¾URÌOSÄLK¥@4B0 @0¥?1¥;.£7+¤8+§=/«E6¡>+˜7$:'¥>-¬A/²C2¶D:§02¯:B¹DL½LRºMR­KL–A>‚71{8/v6,x2*„1-œ37¹=GÕGWèM[âFIÏ53Ð:9½31ÈNKÆc]”J?Œ[J}cLj_CgdEtoOpQhJhN°hYäbbõQZôDQö7Iý1Jÿ2Nÿ/Mÿ*Hÿ2Oü0K÷1Jõ5Lò4Mð2Kó3Ló7Pò@XïC[îF]íIaëNcêQeèUhèVkåSjäRiãOiäNiçNlëPoòSsóVuþh…ña|å[tÕUlÍYlÉdr¨R]r-2^&'Y0,W:4Q?5B:-:8)>B1LN9VO3aV6e_?heDquT†e~ŒiwˆdxŒiu‹er‹dr‹cvŒeyhzizj€•v„›~Šž… Š’£—¨–˜©™–¦™‘¢’‡˜†zypƒmg~b^wYTmMPcGSXDXUDYVG7827828939:4;<6=>8@?:A@;BA5G=3F<2E;1D:0D:0E;1E;2D;2E<3E<5E<5@91?80=82<71;60:5/:5/:5/96/96-;7.;7,?8.@:.C;0D0K?/M@0M@0M@/M@0O?2O>4L>3K=2J<3G:1E;1D:0D;2D;2B;1@<1@<3A=4B>5F<3S81[*&‰:?¾T`ÙTeæUfãUcËJOŸ30–:/‘>0™A3®F=ÅIGÕBHÍ>@±B7§F5©B3¬@3¯?3°>3³B4´D6²G5©B/£<)¤;(©<(«:(®6&­3(¶97º9=½7>¼7<¿^õ@aøCfö@fõ?eõ?gø?hüCmÿErÿIsÿOuÿQuþUvòSqçTnåaxÖfv·Wb}15j0/X1*P8,G>/>A.;D/?G/PK._T8g`CokN||`ˆŽr‡‘v}‹qzq|s|szozŠm}Œoƒ’uˆ—z•£Šœ©•£®¦±¡¬´§±¹®°·°«µ­¡«¢” ”ƒ‘‚s„qh|c]tXSlNPdHRZCWYDYZH671671782893:;5<=7?>9@?:BA/K?1M@0M@0NA0O?/O?0O?2N=3N=3J<1I;0G;/D:0D:0D<1D<1B;1@<1A=2A?3B?6K=4\5.w32­LSÛ]iæM_å@Q×6E·&+¨1)7(’:&—<)¬@3ÃD=Ô>?Í;;±?5¨B4ª@2­?2²@5¸C9¼H;»J<¬>/ª?/¨=+¦;)ª9)°:,·;/¼<1ÊFAÎDAÐ>?Ð79Ö7<ÞBEâLNÝROÄC>ÆKCÍTLÔSMÙKJÛ?Bà5>á27Û4.Ú7.Ð1+Ï:4¿84³@9µ[P–UC{N9‚bI†kP„`F’[F­fTËrdçmhêEKò:Dê9Cç=8@?:@?:C@;DAGB>GD=GD=HC=ID>IE2I=1G=1G=1F<0F<0E;1E;1D;2C:1A:0A:0@91@91=82<71;60;60;7.;7.;7,<8-?9-A;/D0L?/M@0NA0NA0O?/O?/O?2N=3M<2L;1I;0G;/F90C9/C;0B<0B;1@<1@>2A?3B?6N;4m84—FEÄY_ÛWbßCQÞ8FÔ3;½++­1'¡8%˜:!—9 ¤;&¶>.Ã:2¾71§7,¢:-¥9-§7,¯:1¸B8ºE;·E:®>2­?0§<,¤6'ª6)¶>0ÃD;ÊG=¾8-Î@6áD?ìBBô=Aó9>ë27Þ.0Û75âGBèSLåNGÜ=9Ù10ã/2ê67Ù1(ÞÒA>ÒGBÝOMëWWíNRïDMð:Gö5F÷2Fø.Dû1Gþ7Nþ8Sý8Tý8Vþ9Wÿ;\ÿ>aÿAeÿCkþ;eýjý?mú>nø>oô=mö:jÿHrÿ;aÿ?dÿKnÿKn÷NmïUoãZnèr‚Âaj˜ILt:8\6-P9+PC2UM:^QAreUˆ|n•‚Ÿ‘¦§Ÿ¡¦Ÿ–œ˜•ž›ž§¤¦¯¬¦¬¨¢§£¦¨£µ´°ÂÁ¼ÌÉÀÑÎÅÕÐÌÕÐÍÔÎÎÕÏÑÑËÏËÆÊ¿½À°²¯˜Ÿ˜€Œ~m~k`t[WnRVjNS`FV`EX`H560560560560671893:94;:5=<7>=8A>9C@;DAHC?HC?GD=HE>ID>ID>JF=JF=MF2@@4P91r1/¨JKÁSV»>D½06Â03Á//º1)©1!£9#œ=!™;›< ¡=#¥;%¤6%ž6) 8-¢6,¥4,­81·@:¸C<²@6±B7­A4¨-Ï>-Ù5+á*&í"%ú%+ÿ*1ÿ.4í)*ç.+á3,ß4,à3,ã2,é0-ç2+Ú2%Ö6&Ð2&Ï7,Å6.½>7È`UÒq¦eSVBŠM:£WIÈf[ßd_çRTèCIõFMí@Dß??Ô@<É@8Æ@7ÑFAãMLïJNô@Kù9Hý7Hü5Hø3E÷6Gú;Mú8Pü7Rû6Rý6Uÿ6Xÿ9]ÿ;aÿkÿ?mÿ@qÿBtÿBuþBuüBtùBpÿFmúAaþEeÿKjþKkÿVtÿ_zõ]tòj~æp~Óow®^aƒCAg6/hB7sUJye\Œ}v£–­£¡²®«¶¶¶²¶¹ª¯³°·½¶½Å½ÁÊÀÃÊÃÂÊÉÆÍÕÎÖÝ×ÛâÚØçÝÛéÝÝæÚÜåØßä×ààÔÞÙÏØÊÅ˺ºº¢§£ˆ’‡t‚qexb\sW[oS[jM\iK]gL561561561560561671872983<;6=<7@=8B?:DAHE>HE>HE2G=1E=2D;2C:1C:3A:2A:4@93?74<73<71>7/>7/<8/=90>:1A:2C<2D=3H@5I?3L@2MA1NA0P@0O@-O@-L?/L>1M=0L;1J91I81E80C90@9/>:/;;/<<0=>0>?1A?0S8-‡<7Ä\[ÊZY®86«.*²1+®.%­2#¬9&¬B*ªF,¦D'£A&£A&¢<#Ÿ9# 9*£;0¦:0¦7.­<4¶C<·E;°@5«=0¨Dá;=Ö<<Í@9Á>4¶8,¹6.Ä94âHHé@Eð;Dö:Hú:Iø8G÷;Iû?NþAUÿ?Vþiÿ>lÿ>oÿ>pý>qú@rø@t÷Aq÷CjÿMmÿSs÷Jhë@`ýTsÿg…ÿe‚÷]wï_xçh{Üp}Æqx§gg^X{ZQ—~wª™’¾°­Ä¼ºÆÂÃÈÇÌÇÇÏÃÃÏËÊØÌÊØÑÊÚ×ÎßßÔäæÛéêàëíãëïåæòèæôèèðäæîáèíàéêÝçäØâÑÊÑÁ¿Â««©‘–z†xl{hbu_`rXbpVboScmT21/320431651875984984984;:5<;6==5??7AA9CC9EE;EE;HH@HH>HHLC4J@4KA5MC9LB8F=4B90E<5C:5@93?74@85?75<74<42C:5B94A96>95?:7>:7?;8@<9B?:D@7G@6J@4L@0O@-O@+L?,G@.F?/I;0K81M53K65J88F;9B?:6904,«=,­<,³=/½C4ÄF8À>1º2&Ç9+Ì8*Ð8+Ö8-Û7-â5.é3/î1-ñ.,ô.-ó0,ñ1,ê5*ã7)Ý:)Û:(Ü9&Ô3Ð3 Ï8'Æ7'¾6(ÂB5ÏSIÈNCÏSKá\Wî]ZðPRí>Cò9?÷?GêAFßCDÕAAÈ?9»<3±;/°?ëHH>HH9H?:F=8B;5D:8A96?74?74@85@85=85;62=4/=4/=52<74=96>:9=<:>=9B?:D?9G@6J@4M@0O@-P?+L@*B?,B?.F<0H:1J65I56F35@65@<9:=6;>5@@4E<-J9)^B4€L>®QB«;- 2#¡6&£:'ž7$ž9%£>*¡;%§<(®?+³@-¶=,·9*¸6(µ7)ª9)¥:*¤9)¥;+¨>.«A1«B/«@.®?,«:(±<+¿E6ÆH9Á?1¼8+À6)Ë7+Ï7,Ð9.Ñ;-Ô8·;1®:-ª<-«=.¶E5ÆL?ÔNEÜGCã?>ï?Bú?Fþ@JøCJ÷CLúDPÿFTýBSù>Sü>XÿBaÿFhÿCiü?iù@jùBpüFvþJzÿK{ÿJzÿHtõKpñQsõ\zù_{ûXwüNqýEkúDlïEiÚKgÈ_p±nukLI~t°–‰Ì²¥äÓÉìãÜëçæêéîêçòíâóöãùûáúÿâýÿçÿÿìÿÿòþÿöþÿùûþú÷ýúõü÷ôúõòøïðôëîñèíïæëæÝàÜÖØÊÆų²®ž¡šŽ“Œ‰…ˆƒ•‡‰€†Œ~/.,0/-10.21/43/540762761:94::2<<4>>6@@6BB8CC9DD:IF=IG;JH;LI8MJ7NL7NL7OL9KI:NKBTRS_^fihxmm…lkŠkhƒ`YiYQ\OGRH@KH>GG=EE93>:1=9083-94.;60<92=:3>;4?<5@<3E>4G?4I?3L@0O?0P?/P?-L?,<;&:=(?<+A;-B71A62>42;30=84B;5H94N2.Y,)l/.‡;= FE£;0¢2$Ÿ1 ¤9'¥<)ž7$ž8"¢<&¤;&ª=)±A-¶A/¹>.»<-¾:-¾-­>-­<,²?-°8(¹>.ËL=ËG:¼6*º2&É9.Ð6,Ô6+Ô8,Ö:.Ø:/Ü8.ã6/è3,ð0-ô.+ô.+ð1)ç2'Ý6&Ô8"Ò7!Ý8$Ü5#Ú9'Ú>/Ó=.È6)Å9,ËA7É<5Í>8ÙEAåKIêJJéCCì?AëCCÞCAÕD?ÍB=Â=4¶:.®8*«:*¬;+¬8)ÀD8ÔNEÝIEà@@è>A÷BIÿHPôAGô@IùCOýGTþEUú@Uû?XþA_ÿDfÿCiÿCkÿFpÿIwÿK{ÿL|ÿJzÿFxÿHwÿKtúNtÿZ|ÿa€ýUvñCdûIkÿTvÜ?\ÍI`Ø{…¸||aC;|n®ŽÕ³§óÛÑûìåúòðù÷ú÷ôýôìûúëÿÿêÿÿìÿÿîÿÿóÿÿ÷ÿÿûÿÿýüÿþûÿýùÿúøÿøöÿõöýóôûðôùðóðçêåßáÓÏξ½¹­®¨¢¥ž£™£—£«žž¦—›£–/.,/.,0/-10,21-32.54/650880991;;3==5??5AA7BB8CC9HEQPL^]bmlzzz’‚¡€‚¨€€¦{u—rkŠe_{YSmTLdMEZG@PB;2?=1@<1?;/A;-F?/H?.K?/M@/O?0O?/P>0L?/@=*?>,@=.?;/?;2>93=:5:94<94D95M51V-+j)-„28ž8C«>C¦7.¥7(¥:(ª?-¨?, 9&¡8#¤;&¥:&«<)³>,¹@/½>/Á=0Å=1Ä>2½?3¶=2²9.®8*¯9+°:,²:,³9*¶;,¹;-ÄB4ËE9È>3¾1'À2(Í9/Ö5+Ø4*Ú6-Û7-Þ7.á6,æ3,ì1*ó0,ô.+ô/)ï0(ä2&Û4$Ò6 Ð5×2Ú0Ú4$Ü<.Ö=/Ð9.Í=2ÒD:Ä5-Å60Ê;5ØD@âMIåKIÞC?Ö=8Ó@9ÎA8Ç>4¾VádtþŸ§ÓŽd92lJ>¥ynÐ¥œõÔËÿéãÿôòÿýÿÿüÿùóÿüïÿÿïÿÿðÿÿòÿÿôÿÿ÷ÿÿûýÿüûÿýúÿüøÿúøÿù÷ÿö÷ÿõöÿôøþó÷öëïìãäÚÕÒÉÆÁº¹´³´¬±´©°¶ª¶¾³°¸­¬´©10,10,0/+0/+10,21,43.54/77/880991;;3==3??5AA7DA8IE:LF:NH:PJ:RK9RM:SL:QK=OJDVTUfdqwx††¨¹“ÃÆŽ‹À‡ƒ¶{w©pmšid_[~UPnNJaKGXEBM?=B;7895296/85,85,671783891;;1>5L?6K>5F<3B92=82:946;47<59<5>:1H4-Y2-w78”?D¦>E§9<ª;0ª<+«@.¬A/©@-¥<)¦;'«>*§8$­:'µ<+¼=.Á<-Å;.Ê<0Ê=3Å?6¾>3º:/·7,·7,¸8+º8+º8+»7+ÇA5ÍC8Å8.Á1&Æ3)Ë7-Ï5+Û4+ß3)á4-â6,ã5,ç5+ì1*ð/*õ/,ö/*ò/)ì0'â2#Ù4!Ð5Ï4Ö1Ù/Ø2"Ø6)×9-Ô:0Ö?6ØE=ÖF>Í@7É<5Ë@9ÖKDÙNGÒE>Å;1Å=1Â<0ÀCòBLûIUÿJYýFXúCYûC]û@_ûBdÿElÿJsÿNzÿO|ÿLyþIvÿJwÿTÿT}ýJqùImÿStÿVtøNiëD^äF]êXkÿ–¢ÿµ¼óžŽHFk.)¦kcÍ–óÈÁÿãÞÿñðÿüýÿýÿü÷þþöÿÿöÿÿ÷ÿÿøÿÿúÿÿüÿÿýýÿýúÿüøÿûøÿùøÿø÷ÿöøÿõ÷ÿôøÿôøýñóóéêäÜÚÖÑÍÍÊÃÉÉ¿ÊÊÀÊÍÂÉÐȾȿ·Á¸65143.32.10+10+21,32-43.66.77/880::2<<2>>4@@6B@4JD8ME8OH8RK;TK:TM;SL*F@*G?*H@+IA,IB0IA4HB6HA9G@:K=?ž51§;/ª<+ª?-ª?-©>,©>*¬?+°?-«8%²9(¹:+¿9-Ã9,È:.Í:0Ï<4Ë>5Æ;4Â91Á8.Á8.Â9/Â8.Ã6,Å7-ÑC9Ð@7Ã0&Ã,#Ð7/Ö<4Ó2*à3,ä2(ç2+è3*ê3+í2+ð/*ó-*ö/*õ.)ñ0)ì1(á4$Ú5"Ñ6 Ð5Ø7#Ù3#Ö3$Õ3&Õ5)Ô8,Ô<1Ö?6ìYQáRJÓHAÌC;ÊE<ÌI?ÈE;À>1¼:*¼;(¼:*¹:)·:(¸:+¼>0¿A3ÁA6Á<3Å<6ÏA=×EEÝGHäIMëLPèBFê@CðCIùKTþNYüJZüF\üF_øA_ùBaýEiÿJpÿNwÿOzÿNxÿLvÿQ{ÿRyþOvýOtÿVyÿ]{ÿSoîD^úTlîQd÷dtÿ’žÿ‹•ôƒ‰Ç`d§MMµjgΊＸÿÞÙÿïîÿúùÿüþýûÿýúÿþûÿÿûÿÿûÿÿüÿÿûýÿûûÿûøÿûøÿüùÿûúÿûúÿøúÿöøÿó÷ýñóùíïòææçÝÛßØÒÛ×ÎÝÛÏàÞÒßáÖÜãÛÏØÓÅÎÉ<94;8185052+41*41*52+63,74-85.96/;81=:1?<3A>5C?4JB7MC7PG8SJ;WK;UL=UK?SJCSJK]Wcnl‚‚‚¦‘•Åš ÚŸ¦ê¢©ñ¡¥ïž ë™›å•˜Ý”•Ö‘ʉ‰½‚ƒ±zy¡rq‘fc~XVkPN\IGRFCLCBJ??K==G;:@;9:<94?;/C=-E@,F@*FA+EB/EC4CC7BC;AC>@ACBLCANEEOCHNAIL>HI>GDCHAA=2L:.gF7ƒOAI<Ž?2”8)¥>/©>,«>*¬?+­@,¯@-°?-±<*±8'¶8)½9*Ã9,È8-Ì8.Ò91Ô;5Ï:4Í:3Ë81Ë81Ì92Í:2Ì70Ë6/Ó<5Õ>5Ò91Ì2(Î4*Ø;2Ú<3×3*ä1*é1'ì1*î2)ð1)ò/)ô-(ö,(÷-)ô/)ð1)é3(â5'Ù6%Ò7!Ï7 Ô9%Õ8%Ó6%Ñ4%Ò4(Ó7+Ò8.Ð7/ãNGèXPçZSÚQIÌG>ÄD9¿@7¹>/¹<*¹<&¹<(¹:'¸9(º;*À>0ÃA4ÉD;Æ@7É@:ÑFCÕIHÖHGØGJßIKæFHèBDíDIõLSüQZûO]ûL]ûK`öD^÷DaùFfýIlÿNuÿOxÿOxÿPw÷VxóUvôTvüYxÿ]{ÿZwûQkòI`ýWköUgêM^ö^mâKZæTaåTa×XaÁefȃ~嫧ÿÔÑÿëèÿóòÿøùÿþÿûüÿûüÿûüÿüüþüúýýùúý÷÷ü÷ôÿú÷ÿûøÿüûÿûúÿøøÿóóýîñúëîðáäéÝÝäÙÕâÙÒæßÕëçÛñíáññåìóìÛæâÎÙÕ@=6=:3:7074-52+52+52+63,74-74-96/;81=:1?<3@=4B>3JB7MC7RF8VJ:WK;XL?:6@<1A>/C@/CB0BC3BD7?D=>D@CVCIaLRhU\o\br`dobbjd`afXWaJDlG>ƒSE•XF“J7‘@+™>+¨A.®@/®A-¯@-°A.´A/²=+°7&µ7(¼8+Â8+È8-Í6-Ñ7/Õ81Ø;4Ò72Ð72Ð72Ñ82Ô94Ô94Ó83Ó6/ÞA:Õ8/Ñ3*Ö8/Þ=5Þ=5Ú91Ü5,ç2)ë0'ï0(ñ0)ô/)÷-)÷,(÷,(÷-)ô/)î2)é4)á5'Ú7&Ô7$Ï8#Î7"Ï8%Î7$Ï6&Ð7)Ò9+Ñ7+Î4*Ë4+ãNGód\ë`YÕOFÄA7º;2µ9-¸>)¸>'¹<&¹;%º9&½9*À2ÊD9ÊA9ÎE?ÕKHÓLIÎGDÍEEÖHGãIIæCDèEHòMSøSZùR\÷O^úOaôH^õG`øGdûIiÿNrÿQxÿRyÿTzðUuïZwù^}ý^|ùUpõMgùOiÿYnÿ[mÿctðM^÷TeôO`üUgõL_äR_À^_»vqל˜úÉÅÿåãÿíëÿôôÿÿýüÿÿûÿÿûÿÿûÿþýýýýüúþùöýøõÿøõÿùöÿúùÿúùÿööüððøéìôææëÝÝèÚÙäÙÓèÞÕðèÝùóåÿúìþþòôúöáëêÓÝÜB>5A=4@<3>:1<8/:6-84+73*62)62)73*84+;60>93A<6E>6I@7MC7RF8UI9WJ:XK;ZLA[NHTIMXR`gd|~§’Ê— ãžªö¥°ÿª³ÿ«²ÿ¬´ÿ¬²üª±ùª¯ó¨¬ì©«èŸ¡Ú™šÒÁ±tr¡he’]Z‡XR~XQzYQvVOnMH_C?M?:@?;:B?8>>4@B5BE:?D=:CB>FH?LUDVnQfƒarŽisŽtvx„o€€^lŠ[c’WYžWU¦VM¦M?Ÿ@.œ9$ :$§<(¬=*®?,±@.³@-´?-¶=,¹;,º6'¾6(Ä6*Ë7-Ñ7-Ö8/Ú91Ú83×84Ø95Ù:6Ø93Ø61Ø61Ú83Ý:3æC<à=6Ú70ã@7þ[Rÿlcÿ]Tç?6å3)í2)ñ2*ô/)ô*&õ(%ø(&ø+(÷-+ó0,í2+ã1'Ú0#Ô1"Ô4$Ó:(Ì;&Ê<(Í<)Ï<*Ò:,Ò9+Ò8,Ñ7-Ú@8Ï81ÜGAôc^åXQËB<Å@;·4*·:&¶<$¹<&º<&½:(¿:+Ä<0Æ>2Ç>4ÌC;ÙPJßXRÔOJÃ?:À?:ÏHDÞHGâGEæJKïPTñRWïNVíKXñL\ùRføOf÷Ke÷JfüMlÿQsÿRvýRvôWvîXuõXuû[wÿ\xÿZsÿWnÿVkÿbuýVgÿ\mÿ[lñFXôDXÿQeîVeÆfgªieʋ網øÒÏÿëçýïîüø÷ùýüùÿÿùÿÿúÿþüþýÿþüÿûøþöôþùõÿû÷ÿùöÿöôÿööÿõõöèèæØØãÕÔÞÐÍáÖÐñçÞüôçþøèÿüéÿÿóúÿùèñðØáàC?6B>3A=4?;2=90;7.:6-95,73*73*73*84+:5/=82@;5D=5H?6LB6QE7TH8VI8WJ9YK>ZMEUJNWQ_eby{¤ŠÉ”⛦õ£®þ«´ÿ¬µÿ®¶ÿ¯·ÿ°·ÿ¯¶ü¯´ø¯²õ©ªë¢£ã˜˜ØŒŠÉ€»uq®ie c^˜`WŽ`Vˆ]TVPtMIbFCTBAIAAC<<:AB=FEACD?A?@DBEOMRWVdch†quš}¢‡}Ÿ’}œ {š¥pŠ¤`u¬Yi¶VaºQU¸HF°@4¬;)¬<&­='¨8$¨7%«8&®9(°8'²9(µ7(¸6(»3%Â4(Ê7-Ó:2Ù<3Þ=5ß<5ß<5á>9ß<7ß<7á>9åB=èC=çB<æA;å@:æB9ä@7Ü8/Õ1(Ø6+ëI>ÿ[Oñ@6î6,ê+#î)#ø-)ÿ/-þ,+ö((ú0.õ4/ï61ç6.Þ3)Ö2&Ô2%Ï6&Ë:'È;'Ê<(Í:(Ï9*Ð7)Ñ5)Ð4(Ó9/Ï5-Ô=6åPJåTQÛLHÍB?·1(¼;(»=&½<'¾;'¾9(À8(Â:,Ä:/È>4ËB8ÕOFÜWPÒRIÃD=¿C;ÌHCÛLHßJFåMLëSRíTWëPVéNVìOZ÷VføUhùSiúRküRmÿSqÿStÿRuòMmøUtÿ\zÿ_{ÿ\vÿUoûRiûReüUf÷RbÿZhÿZhóN^øScþYißS^¶`_—^W¶}Ù©¥îÈÅýáÞùééýøõúüùùÿÿøÿÿ÷ÿýúþýÿÿýÿûûÿ÷õýøôþùõþùõþöóÿ÷öÿõõöêêêÜÛäÖÓÝÐÊßÕÌïåÛüõåÿùçÿýéÿÿïúÿøèñîÛáßEA6EA5C?4A=2?;0=9.<8-;7,84+84+73*84+:5/=82?:4C<4G>5JB7ND8RF6TG6WG7YIBZEJpW]‚cs˜r—¥z§®«²{£¸vœÀp“ÂcƒÀTnÂG\ÐK\ÑHPÄ<<º5.¸9*µ<'°<%°;'°;)²:)´;*·<,»<-À<-Ä<.Ä6*Ë8.Ó<1Ù?5ßA8á>7à<3ß:4Ü71Ù4.Ø3-Þ93æA;ìE?éB<ä=5ã<4Û4,Ø4+Û7-Ô2'Ì, Ö6*éG:õK>ò@6ï4-ð-)ö,*ú,,ü,,ø*,ð*)ì/+è2.ã5.Ü4+Ø1(Õ1'Ñ3'Í7(Ë:)Í:(Ð:)Ò;*Ó:*Ô8+Ô8,Ñ4+Ö<4Õ:5Õ<7åONíYWÙEEÂ3/À;,¿<(À;*¿:)Á9)À8(À8*À8,Æ=3ÇA6ÏJAØUKÒRGÆG>ÀD:ÇG>ÖKDØICÝLIäSPåSTâPSâMSåNWòXdöZhý[pþZrüVnúRlûQlÿQpýGmÿPvÿZ}ÿ[{ÿVrýTkþWkÿ\mûYhøZhûamö`kí]gïfnìfmÉ\_ ]W{OF˜mfÁ˜”ݺ¶ðÔÑôàßÿõôùù÷ùÿýùÿÿ÷ÿýúþýÿÿÿÿýÿÿøùüùôüùòüùôýøôÿùöÿøöùîìïäâåÚÖÛÐÊÜÒÈîäØýöäÿûèÿýçÿÿíúýôêðìÞãßIE9HD8FB6D@4B>3@<1?;0>:/:6-95,95,95,:5/<71>93@;5E>6I@7LD7OF5RE4UE5WG8WI>XMKXNW^Zqpp–€†ºŒ–Ô•¡é©õ¨°ù©±ù­³ý°·ÿ±·ÿ²¹ÿ´¸ÿ´¸ÿ¯±ü«­ø¥§òŸžê—–⌋ׂÍ}yÅum¶pgªf`ž_ZYX„QQuGGcA>Q=5DH8BT=C`@EnCJ€OU–]d«fx¿kÉnšËo˜ÉiÈ`ƒÉWxÆIgÄ;UÆ2HÙAPàEMÑ;<Æ71Ä?0½@,±:$­6"­5$®5$³5&¶7(¼8+Ã;-È/Û?0Ü@3Ü@3Ò6*æLBåJEÎ50ßGFóZ\ßIKÕA?È2ÈF9ÏOBÎPDÆH<¿C7ÁC7ÎH?ÑF?ÕJEÛPKÝROÙMLÚKMÜKPëX`ó[güaqÿauúXmõOgõMgÿNkÿOuÿRyÿUwÿTqüTmý[pÿcuÿjxÿguúboõamídlãflÙhjÎghµfa^TeG<^U©ˆÍ«©åÇÅïÚÙÿóóùøöùýüøÿÿ÷ÿÿûÿÿÿþÿÿüÿÿùúþûöûûóûúõþûöÿýùÿûøþôòøíéêßÙÞÔËÝÓÉíæÖÿøåÿþèÿÿæÿÿëøúïêïèãæßNH:MG9LF8JD6HB6F@4D=3C<2?80>7/=6.=6.=60>71@93?:4C>8EA8KC8NE6QD3RE2VF6VH;ZMGVMR[Whlk‹~‚±Š“Î’Ÿãš¦î¦®÷©¯ù­°ý¯³ý°³ÿ°´þ°³ÿ¯³ý«®û¨«ø¤§ô ¢ïšœé“•âŠŒÙ†…уÉ{u»mk¬dež_a’Y[„RQsNHbWFY_CQmBLEM˜MT¬U]¼[bÊZhÙRpâRußTuÙPlÒJbÍBWÇ8JÅ.?Ô8EãCKæGKØ>>Í>6ÌF:ÃH6¶?+·>-¸=-º<-½>/Ã?0ÊB4ÐD7ÕE:ÙE9ÚB7Û>5Ù;2Ù6-Ù5,Ú3+×3*Ô1*×4-Ú7.Ý90ß80Þ7/Ý6.Ü5,Ö/&Ù5+×7+Ï2#Í1"Ò9)Õ>-Ô;)Ø<-æD7øJAýD?ù64õ*-ö*-÷/2÷67í55â30Ú1,×0*×/,Ù0-Ù0+ã81ä91â:1â;2à<0ß=0Ü?0Ú>1Ñ7+ïWLøaZÓ;6Ñ;:æPQÜFHæPQÏ<4Ê:/Æ8,Å9,Ä:-Ä<.Ã;-À;,¾:-¾<.ÃA3ÇH9ÇI;ÂD6¾@2¼>0ÉF<ÊE<ÎIBÕPI×RMÕNKÓKK×LOéZ`ð^hüfrÿhxü]qòPeóMeýNkÿVzÿTxÿRrøTmö]qûhxûjw÷erüetó_mì`kêkrßruÃjfªd\žla}fVXH9kXJ”|r½ œÞÂÁîÖÖþîïûõõûûûûÿÿùÿÿýþÿÿþÿÿûÿÿúýÿþùûþõûüöÿþùÿÿúÿþúÿûõÿ÷òñèáäÜÑáÙÌðé×ÿúäÿÿæÿþåÿÿê÷ùëíðçèéáQK=PJ1ÃE6ÃE6ÅF7ÉE8ÎF8ÑG:×G<ÚG=Ö>3Õ;1Ö8/Õ4,Ö3*Ø4+Û4,Ú6-Û81Ý<4à=4ß<3Ý90Ü5-Ü5,Û7-Ò.$Ý;0Ú=.Í1"Æ-Î7&Ò=)Í:&Ì9'Ô8)â:/ó=9ÿ@@ÿ<>þ37ó,/ê,.á+*Ø*)Ô+(×/,Þ44ä88é99ï75ð74î73è71ã7-Ü6*×5(Ñ5&Í5(çPEÿmcÛHAÈ42×CCÓ>BêVVÙA<Ò>4Ë8.Æ6+Æ:-Æ/Á=.»9+»<-¾?0ÀA2¿A2½@.¼=.»<-ÃC6ÄD9ÈH?ÐPGÓRLÐOIÒNLÕONé^cîagûitÿnzÿduõVjõQiÿUoÿWvÿVtúXpñ^pônyöw€íksÞXañ`mñ`mìboïs}숊Ì|ªth™yjskXON:_VGƒqg¯–’ÜÀ¿ïÕØüéëþôõýûüýþÿúþÿþýÿÿýÿÿûÿÿùþÿÿûùÿõúýöÿÿúÿÿúÿÿøÿý÷ÿþöùðçíåÚéáÔôïÜÿûåÿþåÿÿãÿÿèùúêòôçîðåSM=RL4D=3B;3A:2@93A:4A96@;7A@;CC;IE9MG7OG2RF0UF1UH5WK?RHFXR^jg‚}§‰“Ä’žÚ˜¢ç¤§ö¦§ú«©ü«¬þ¬­ÿ­®þ¬®û¬®û¨¬ö¦ªô¤¨ñ£§ð¡¨î §í¤è›¢æ™žâ’šÛ‹“҆ʃ„ˆ·ƒ¨ˆyšmˆšcz©Xi»Q_ÏMYàIRèAIê=Aé=;ã>8ÝC9ÖH:ÎI8ÅF3ÂC0Å@1äTIàG?Ú;7Ø64Ø88Ø:;Ñ98È74À:/¾<.¿;.À:.Â8+Ã7*Æ4'Æ2&Î4*Ð3*Ñ3(Ô3)Ö3*Ù5,Ý6.Ü8/Þ=3Û=2Ü;1Û8/Û7-Ú6,Ø4*×3)Õ3&Ó3%Ð4%Ï6&Ò=)Ñ>*Ê9$À2È:&Ê4%Õ1'ç51ú<<ÿ=@ÿ7=÷37ê-1á-.Ù--×/.Ü43ã9:é;=ð9=ö26ø03ô01í1/ä1*Þ2(Õ1%Ï3$É1$Ñ=1új_äTLÈ95Ð@?Ë:=äRSäJHÜC=Ñ:3É6.Æ8.Å;0Â<0¿=/º;*¼?-½@.¼?-º;*º;(½;+¾<,¼>0¼>2ÀD8ÈLBÌPHÊNFÌLIÐNLèaeìaføhrÿo{ÿhx÷Zk÷UjþZrÿYsû]tîaræjtë}€ñ‡‰èwyÚ_dñgtþm|óeuëlwö‘•ì¢ŸÄ”Š¢|hjUHQSK>PJFë>êDFå@DÙ8=Î65ÍB;ÈD8ÉC8ÇA5Æ>2Ã9,Â6)Â2'Æ2(Ë3(Î4*Ó5,Ø5.Ù4.Û4.Û4,äB7Ý=1Ù7,Ú6,ß9-ß9-Û5)Õ1%Ø8(Í2 Ê1!Ï9(Î8'Ç4"Ê7%ÔC0È7&Î8*×6,Þ5.æ3/î53ö:9û?>ÿLKúHFòBBì>=ê<=ç7:å26æ,1ô+1ø)/ô,.ï/.è1+à4*Ù5)Ó7(Æ0!À.ôdYë]SÏ@:ÔDCË;;ßMMêRQàHEÓ;6É6/Æ8.Æ9/Ã;-¾:+¾<,Á@-ÀA.»<)·8%¸9&½<)¾?.µ7)³7+¸>1ÁG:ÅK@ÅIAÈIBËJEåa_æ^`ñdjþnwþkuó]iðXeø]mú^sõbtèdoãlrì~ù‹ö†…éqsøryÿy†õaqàXföˆ‘ÿ´´Ð®¢ ›‡]jPDR9QT?jbU›ˆÚÀ¿òØÙöàãÿô÷ÿúýÿþÿýüÿþüÿÿýÿÿûÿþùýûÿúôÿòòþòùÿôüÿöûýòÿýôÿÿôÿÿóûõç÷ñáþùåÿýçþüãþýáÿÿêÿÿñýýóüüòXO@WP@WN?UN>TK2G?2H>2F@4GC:GE9JG8NI6RJ5UJ4UJ4VK9XNDULMZTbkhƒ{~§‰Ã‘™×˜Ÿç£¤ö¥¢ù¢¢ü¡¢ü ¤ÿ¢¨ÿ£«ÿ¤­ü¡ªõ¡©ñ¡¨ì¥¨íª©ï­©ó±©ö¬©ø ©ø—§ò’¡â–ŸÖ¦£Î¶ž¾¹…œ¸gz¿L]ÑERß>Mç;Gç?ß<=ÝEBÉ:4ÊD9ÊF:º1)ÛJEèJIéCEë>Bè;?æÚ<=Ô<;ÏB;È?7ÊD;ÑMAÍK>¿=0¸6)½9,¿7+Ã6,È5-Ë2*Ñ/*Ô/+Û2/Þ5.çA5ß9+Ù1$Ý3&å9+ç;-ß8&Õ2Ï2Ì4Ê5!Ç4"Ç4"Ê4%Í5'Ï5)Ê0&Ï2)Ñ5)Ò6*Ò4(Õ3&×3'Ü4)à2)æ3.ë52ë33é/2ç-2è-4í.5ö-3ö+/ï+,ì/-ê5.ã9,Ù7(Ð4%Ã-Ä3"çXHéYNË;3ßNIÅ41ÚHHáOPÜJJÔC@Ì;6È80Æ8,Ç9+È<+Å<*Â;(¾9&¼;(»<)º=)º=+·<,´8,µ;0¹=1»?3»?3¾@4À@5ÄA7ïjaõpiêc_ômjûqqìadôgmÿpyÿlzûhxðdoébiëdjîlnîqoîqoûy{ÿ}…ùZlücwßbpû¬¯¶ªš}‘u]rQJY:LR8snZ¥•ˆË·°íÕÓÿîðÿö÷ÿ÷ûýøüüüþþÿÿþÿÿÿþÿûÿþðÿôåþéæûêïÿîøÿöüÿôþÿóÿþñÿýñÿûîÿúêÿùæÿùãÿùáÿùáüúåÿÿõÿÿûÿÿûYPAXO@XO@VM>UL=TKÌLAÁC5¸:,·9+¹7*¿7+Æ6-Ë4-Ñ2.Ø3/á53ä84ä>2á;-Þ6)ß5&á5'á5'Ú5"Ó4Ñ9$Ë9"Ç9%Ç:&É<+Ë<,Ì8,Î4*Õ3.Ö5-Ó7+Ï7)É6&Ç4"Ë4!Ï4"Ø2$Þ2&ã0+æ.,æ,-æ,/æ-2è.3ì+.í,-ì0.è2.à4*Û5'Õ8'Ò9'Õ?.»*ÖD5Ð>1ÙF>ëVPÚB?ØBAçUVâRRÜKHÔC>Í=5É9.È9+Ç8(È;*Ä;(¿:'½<)½>+º?-¹@/¶>.²:,´;0·=0¸>1º?0½?1ÁB3ÅC5ëi\òmdçb[ðkfõolèbañklütxÿq~ÿo|öirí]fêY`ñbf÷qpþzxûvwÿx~ùRdþ[pä]nö¦©©¦“jŒkZtON_;SZ;us\©ÖĸöáÜÿõñÿúúÿúûÿûüüüüúþýûÿþúþÿõÿúíÿóáÿéáýæéÿëóÿñøÿòýÿòÿÿñÿýïÿýíÿúéÿöåûóàúòÝüôßü÷äýúóüüúÿÿý\PB[OA[OAYM?XL>WK=VJDã=?å==åAá>CàBè;?ã9<Ü68Ö66Ñ96Ì;6ÕHAÄ;1¾5+ÅA5ÍK>ÆH:»=/·8)º6)¿7)Ç7,Ï6.×50Þ71æ95é=9×3*×5*Ú6*Ü6*Ý5*Ý7)Ú:*×>,Å4!¿4¹4!¹6"¼8)½8)½3(À-%ã@;å>8Þ=3Õ<.Ì9)È7$È7"Ì7#Ò7%Õ3$×/&Ù.'Û.*Ü.-Û//Ü./Û,)ß0+à5-Ü5,Õ3&Ð4%Ð9&Ñ>*ÔA/Â1 çSEÒ;0ÚA;ÞC?èJIðTUíUTçSQãOMÝJCÖC;Ï<2Ê8+Å6&Ä7&À7%¼7&¹:'¹<*·>-µ=,²=,°:,±;/´<.µ=/·=.¹?0¾C4ÃE7Ü\Qêg]äaYðlgöpmça`ìfgójqàR^ï^kõhqòemñ`gôeiùqqþxwútuÿnuóJ]øRhä[mñœ¡£œŠa€`UoHOd=W`Aww]­¥’áÑÂÿîæÿøñÿüøÿþúþÿúûÿüûÿýûÿýùÿûóÿöèÿîÜþãÚøÞáùáèûåïüèöýëýþìýúéÿúêÿ÷æúñàôèØòçÕöëÙøñáþúñýüøÿþû\PB\PB[OAZN@YM?YM?XL>XL>UI;TH:SG9RF8RF8RF8RF8PF:LE;KGEç=Fã?FÖ:>Ñ?@ÑEDÆA<º61Å>:êZYÝABã@Cæ=@ã:=Û89Ó97Ð<8ÎA8ÏE;Â:.»2(À/¸9(½8)Â9)Ë8.Ò:/Ù80à91è;7ë>8Ø1+Ù2*Ü3,Ý5,à5-ß7.Û9.Ö=/É7(Æ:)Á<+¾<,¿;.Á;0Å<6Î95ëC@í@<ä@7Ù=1Ï9*Ç9%È:&É;%Ï<(Ð7'Ï1%Ñ1%Ô1(Ö3,Ô1,Ñ/*Ó2*Ó5,Ó7+Ð7)Í5'Ê7%Ì;(Ì>*Ì;(Ï<,ô^PàF<Ò3/Ò.,æ@@ûWXÿusÿroÿjgö^YçPGÕA7Ç5(½. Ä8'À8(»8&¸;)·<,µ=-²=,°<-¯;.­<.°.¼B3ÀF7ËMAß`Wâa[ôpløtræ`aä]aæ]dÖHTçYeógrôgoöelükpþsvþvvûpsûenñDXôKbåXkë’– •ƒ_zYQlCSh?\gEy|_°ª”çÜÊÿõèÿùðÿûñþþôýÿ÷ûÿúùÿúöÿøòüóêûëÚøÞÎóÒÊëÌÏìÎ×îÒàðÖéóÛò÷áöõáûöãüõãõìÛíáÑéÝÍíáÑñèÙüõíü÷ñþùó\PB\PB[OA[OAZN@YM?YM?YM?WK=VJ@Ð@?ÐIE¿>8³2,ÈC<àUPÜDCáACã?@á>?Ú?=Ô@<ÑD;ÏF<Ç=2À8*½5)½9*¿=-¿=-½;+½<)Â:*Ç;*Ï;/Õ;/Û8/à8/ç83é:5æ95ä52ä20æ21ç32æ40Ý2+Ô0'Ë1'Ë7-È:0Ä7.Á4-Ã40Ì:;Ý?@ë8;í76ä71Ø5,Ì4&Æ5"Ä7#Å:%Ë=)Ë8&Ì4&Î5'Ô8,Ô:0Ó9/Ð8-Ð>1Ê;-Å8'Ä7%Æ9'Ç<)Ç<)Ç:(Í>-Í:*Ø>2áC:Ô/-ä::à24ß56×53Ö;6ÞC>åKCêQIêSHèTHäUGË?0Ä?.¾<,¸=-·>-´?.°?/®>0¬<.¬<.¬<.¬=,­<,±=.·A3ºD6ÆLAÞbXâc]ðnlôrrå`cå`eç`g÷kvûoz÷kví`hð_fýlqÿx{ÿy|úmsø^jóAWôC]èUh懣“ƒg]YtI^uIhwPˆf³²–èâÌÿúéÿýíÿþïýÿòûÿôøÿôôÿñíûêäòáØî×Åèǻ伺޺¿Þ¼ÇàÀÍâÃØæÌãëÓìîØôñÞ÷òßóêÙìàÒèÚÍêÜÏïáÖòèßñèáòéâ[OA[OA[OAZN@ZN@YM?YM?YM?XL>XL>WK=VJQI>QI>SK>UL;XM9XM7YL9XM;WK?ULGYSWe^nnjƒut–~}¥„…±†‰´‡‰¹Š‹Á‹ÈŽÏŽŽÔÕӔӋʃˆÀ|¸u|²ov­io«ljœ€lˆ“cy®YvËPoãBdð7Vö4L÷8Hï@EåFBÝJCÛJEáGGèCJò=Nð>LäCI×CCÌA>ÎIDº;4°4,ÉI@ÕLFØBAÚ?=Û;;Ú<;Ø@=ÔE?ÍG<ËG:À8*Á8(À8*¾9(¼9'»8&½:(À;(Ä;)Ê=,Ò<.×;.Ü8.á6.ä6/è50é32è./é,0î02õ47õ77î45æ21Ú.*×4/Õ62Ñ32Ï/1Ò/4Û6=ê:Dí06î02æ3/Ü3,Ñ5)Ê7'È9(É<(Æ8$É6$Î6(Ó:,Ú>2ÝA5ÝA5ØA6ÓG8ÉA1Â;(À9&Ã<)Æ=*Å<*Å8&Ì:+Í7)Í0'æC<Û2/ï?Aã/2Ú*,Õ1/Ò5.Õ81Ö90Ò8.Ì5*Æ2&À1#ÎE5ÆA2¼=.µ:*±9)¯9+«:,ª:,«;/«=0¬>/¬<.«<+­<,²>/µA2ÉSGàg^àc_êjiînoæchðjqõoxúq{ýt~ömuîbködnÿrzÿx~ÿquúipøWfùAYô@[êQfá~ƒ¬—†ykmˆ]o‰ZyŠ`—r¶·˜ßÞÂùôÞüúåÿÿïûÿïõÿïïÿëçúäÜïÙÐãÍÅÞÁ°Ö­¨Ó¦ªÐ§°Ó«¶Ô®¼Ö±ÇÚºÒßÁàæÌèêÔòíÚòéØîâÔìÛÑêÙÏìÛÓéÚÓæÙÑåØÐ[N>[N>[N>[N>ZM=ZM=ZM=ZM=YLUL=XLNÝAEÔFDÈA=ÉHB´:/±7,ÎOFÉB<Î=8Ð64Ï10Ð51Ó>8ÏE;ÈF9ÃD5¾9(Ã:(Â:*¿:'½8%¾9&¿:'Á:&Ä9&Ë:)Ó:,Ù9+Ý7+á5+ä3+ê3-ë*+ñ*-ø-3ü/4ÿ17ÿ37ÿ38ý58ù8;õ8<ò9>ò9Aô9D÷7Fû6Hþ5Eô+5ô-2í12ã4/Ù6-Ð8*Î;+Î=,Ë5&Ñ8*Ù;/ß=2â>4ä=4å>5ßA6ÙJ<ÏG7ÉA1Ä<,Â9)Â9'Æ8*È9)É2'Ó9/á@8ëD>Þ0/à..ë46è66Ø3-Õ7.×90×:1Õ;1Ò;0Í:0É;/ÖL?ÌF:¿@1´9*°6)¬6(«7*©8*¬;-­=/®>0­=/«<+«<+­<.±=0ÀKAÚdZÞc^èkiðosêinõrzüvîfp÷oyùryöjsþlvÿwÿv}ùhoùcn÷RbþB[÷ZM=ZM=ZM=ZM=ZM=YLVJ>XL>YN5É83Ç/,Å*&È/*Í:3ÌC9ÃC6¼>/À;*Ä;)Ã<)Á:'Â;(Ã<)Â;'Ã8%Ä5$Ê7%Ô8)Ù7*Ý5*á3*å3)ê2*õ33ÿ58ÿ8<ÿ4:ÿ-2ÿ(-ÿ(-þ+1ü-3ö)0ò&1÷)6ÿ,?ÿ*Aü 9ó/ö"0ó(.í,1æ0/Ú1,Ô3+Ñ5)Ð6*Ô6+Ý90æ=6ë>7ë:4è71è50â92ßH=×K<ÓE7Ë=/Ä6(Â3%È6)Ï8-Î4*Ô6-æC<ß82à21Ò ì89å63Õ1(Ò4)Ò4)Ï5)Î6+Ê6*È5+Å7+ãYNØRFÊH;¾@2·;/µ;.µ<1µ<1¯9-±;/±=0±=.¯;,­9*­9,®:-±<2ÐYQÜb]ìppôvyîmrõq|ör}ÿzƒÿ‰ÿy€ôhq÷epÿq|ÿuÿktø^jöOaÿA^÷8WéG^Ûntº‹™©„‚žn~šg—hœq¡©‚´º–ÈÍ­ÕܽÌÙ»ÁÔ´²Ì©§ÂŸž¼˜š¶–²Œ±†‰³†µ~¹„•À‹œÂŸÄ‘¨Å™²È¡¾ÎªÉÒµÚÙÄæßÍêÞÒéÖÏáÌÉÛÆÃÔÁ»Î½µÈ·°ZM=ZM=ZM=ZM=ZM=ZM=ZM=ZM=XK;XK;XK;YLYM=WMCWLHXNOZPX]Ub`Yia\rjfokŽsp›vq§{u³ƒ~ÁŠƒÉŠƒÇˆÀŠ~¼ˆy²ƒr¨†r§t«‡l£†\„HL¤B9¶A:ÍC@Þ@?è:;ô<>ÿDE÷><ó=<ì>=ê@AëBIêCMëANãALÐ>>Å@9¾?6·>3°,º7%Á:'Ã<)Â;(À9%Â9&Å:'Ç:(Ë:'Ð9(Ö6(Ø2$Ú."à/%ì7.õ=5õ82÷40÷0-ø**û&(û%'û%'û%'û&*÷!)ø".ÿ'7ÿ(>ÿ!;ÿ6ý1ÿ'8ï#,æ#+ã+-Ý--Ô+(Ò-)Ü41â62è64î66ò65ò12ï./î,,å/,Ü92Ñ:1Ò91ìSK»"Ä+#ßF>È.&Í.(Þ<7èE@â:7Ø/*Ú.*â51å<7ß>4Õ<.Ï5)Ë3&Ì5*Í;.Ë;0Å8.ìbXàZOÈC:¹6,º:/¸8-±3'´6*°0%°2&®2&¯4%°6'²:*´<.³=1°:0ºC;Ö\Wìppñsvöx|ûyƒõq|ÿ|„ýw€út}üs{ÿr~ÿr}ÿmxÿgsü`nôI\ÿ>\ÿ>[äAVÔek´•€’¡zƒm}™f~”c‡—j”Ÿwž¦ ¨ƒœ¨„’£Š£|€Ÿvzšqyšo|r vƒ¤u‚­wƒ³y‹¸‘¼„“¾†—¾‡œ¾Œ¢½§¼“¯½š¾Â§Ï̹ßÓÇãÒÊÜÇÄÔ¿¼Ìº¶Á²«¹ª¥ZM=ZM=ZM=ZM=ZM=ZM=ZM=ZM=XK;XK;XK;YL]P@[OC[NFYNJZPQ\SX_U^_Wfd\tibƒng‘qjxp¬€y¼‡€ÄŠÄ€Á~ºt«Œn¢—q¤¡u¨šjž™W{=Aª5+±5+Â<3Ó@8Ý>8è?:óA=õ=;õ;<ô;@ñ>Bî@IèAIâ@KÚAFÇ<9½=4¶<1±;/«:,®:+½A5ÐJAÚG@ÜA=Ô63Ð51Õ@9ÍC8»9+²5#½8'Â;(Ä=*Ä=*Ä;(Æ;(Ç:(Ê9(Ï9(Ï6&Ô2%Ú2%ã5*ê8.ï80ð91ç1&ç/%ê.%ï,&ö+'û+)þ,+ÿ-.ü*-ú%+ú$.ÿ'7ÿ$;ÿ7ÿ3ü0õ0ö.9õ3<å*1Û(,Ü.0Þ02Û+.ñ:>ô7=÷4:ö26ö/4ø03ù25ô87Û2-Ú;5×82äE?äE?Î/+Ñ2.Á"Ô51á?:èE@à=8Ø3-Ù2,Ý60Ý:1Ô:.Ï9*É5'Ç5(È9+Ê<0Ê<2Æ9/ícYáXNÉ@8º4+Â91Ã:0¿6,Â9/¿5+¾4*½4*»5)¸6)µ5(´6(°6)´;0»B9ÓYTèljïqtöx|þ|„øv€þ|„üyùv~þuÿsÿp}ÿkwüdqý_nöI]ÿ>\ÿ>\éCYÓeh®Žw‰˜oz•bu’\xŽ]cŠ•k˜p‹•p…”mp‡]l‰]h‰\g^k_q•ey›izŸk¬t„±vŠ·|»}¼“¼‚–½†›»‰›µ†¡³‹­¶—¾½¨ÏÆ·ØÇ¿ÖÁ¼Ï¼¸Æ·´º¬©²¤£\L<\L<\L<\L<\L<\L<\L<\Lù:Aö=Eï@GæAHÙ@EÏ@BÀ;6¸90±9+­9*©8(­9*»?3ÏF<ÙD>×96Ù74Ú;7ÜC=ÝOEÎH<µ3#¾9(Á:'Ä;)Æ=+É=,È<+É:)Ì9)Ï7)Ï2#Ó/#ß4*î=3ô?6ñ91é4+à4&ß5&â2%å/$ë,$î+%ñ+(ò+(ó+-ð(+ò&/ø(6þ%:ý7ü3ø3ô%7ò0;ó5Aò8Cð;Dðä,6ð2<ó/;ö.9ö-7õ.3õ.1ó/1í42Ü0,â=9Ú64ß;9ÿmjåCAÑ/-Î/,Ù:7ß@<àA;Û<6Õ7.Ö5-Ö5+Ò6*È6'Ã6%Â6'Ä8)Å;.Æ<1Æ<1Å;1ë`YáTMÉ<3¿0(Ë;3Ñ>6Î;3Ò=6Ø=8×<7Ô=6Ï<2É;1Ã9.¼6*¶6)¹;/¼@6ÏTMãgeíorøz~ÿˆû|ƒû|ƒûyûx€ÿwÿsÿn}ÿgvû`pü[mõG^ÿ\ìFZÎ`až~ev…Zi„Qh…OmƒRt…X{ˆ]}ˆ^x„\q‚X`zM_Pa…UeYn•`uœg} j~£mƒ¬r„²tˆ¶x‹¹y‹¹y¹z‘º~”º“±•¬€›©†©­’ºµ¢Ç¹®Ë¸²È¶´¸¬¬ª¡¢ —š[K;[K;[K;[K;[K;[K;[K;[K;ZJ:ZJ:ZJ:[K;[K;\L<\L<\L<]K=]K=]L<^M=^M;^O<^O<^O<^Q@^Q@]OB[OC\NE[NF\OI]OO^P_bTmdY{i^‰pgœ|t­…{·ˆ{³™…º¥…´¯€ª¸z¡ÆxŸÑuœÌcŒÈMlÜFRßA@ÕA=ÏE;ÌH;ÍG;ÓE9ÞA:î@Aõ0ÎD:Õ<7Õ31à;9åA?áD?èSLßUJ¿:+Á9)¾7$À7%Ä;)É=,Ê=,Ë9*Î8)Í4&Ò2&Ù2)å9/ñ>7õ>6ð5.ä/&à6)Þ6)à4*ã1'ç.)ê-)ì*(ì**ê),è',ë'1ò)9ö&<÷!;û=û%Aû6Hä(6ç.<ÿP\ÿ`lÿP\ò;åGDÛ=:Ú<9Õ:5Ò80Ñ7-Ð6*Í4&Æ3#¾5#¹6$»8&¿;,À9é=9æ?9á@8Ù?5Ð<2È:.Á9-»9,»=1ËNHàc_ìnoú|ÿ„ˆý~…øy€øy€üyÿx‚ÿt‚ÿn}ýetù^n÷VhóE\ý8Vÿ^N>\O?^NA]OB^PE^OJbNYbQdcTqdZ}le‘xr¢w¨ƒv¤”}§¬†«Â‰©Î‚žÚw”ál‰ÛXwÚD_óBTúDPïJPáIHÐE>ËE<ÐF<ÙD>èBBð@Cõ@GõBHíDGßCDÏA=Â?7¿@7µ=/®:+«:*ª9)®8*»;.Ì?6áFAâ=;îBBëAAÞ;6ãJBæXLÕK>È@2À8(¼3#Á8(È<-É:*Ë7)Ð8+Î0%×3)à8/é;4í:5í60ë0+å,'ã0,ã1-ç10ì31ó25ö37÷48÷6;ì-5ê,6í.=ñ0Có-Fö)Gý+Nÿ3Rô9Lå3?ð@Mÿ_lÿlzÿWfõCSõ>Pî3Dí3Aí3>é6<ã99Û83Î4*Ç/$Ë2*Ç.(Ð72òYTö\ZòXVÛA?âHFÜB@Ô<7Î70Í6-Ï8-Ï9+Ê7'Â5#¹8#³9$µ:(¸=-¹;,¶6)¼7.Æ=5ÛNGÙEAÎ50Ð1-á>9ç@:ã81ç51ë20î21ë52ç83á:2Ø:/Ð9.È:.¾6*º8+ÈIBÜ_Yënlû}€ÿ…‰ýƒõv}öw~üyÿx‚ÿsƒÿk}ýdvù^pôSeôF]ý8Vþ=ZïL]ÀTRz_BWhÑC?ÖEBãEFèBDîAEíCFçDEÚEAËB:¿?4»?3±;-©8(¨9(ª9)°8*¼:-Ê;3èIEé??ë=>å78Ú2/ÞA:îZPôh[ÚPCÉA3¾5%Â6'Ç9+È9+Ë7+Ò8,Ñ0&Ú6-æ;4é;4ê40è/,ê-+ë--ó49õ3;ø3=ü3=ÿ1>þ0=ý1=ù1>õ0Aò1Bô4Kõ5Nõ0Nö-Oÿ1Xÿ>_æ3HùO\ÿanÿ_nÿWfûP`ôDXé8JóAQê:GÝ2:Ò/2Ê2-Â8-½;+¼:*Ä:/À2(ÙJBúkcÝLGáPKÏ;9Ï;9àLJÔ@<Ê70Ê7-Î-±9)¯3'º:/ÊD;ÖGAØC=Ô72×2.ç;7ì:6è2.í2-ò,-ô,,ò./ï31è71â:1Ú<1Ò>2Â6)º4)ÅB:×XRçjhú|}ÿ†‰þ€„õv}÷xýz‚ÿx‚ÿqÿi{ûbtø]oòQc÷I`ÿ:Xý?[ðO_ºQNqX:Sf8]uEa|InSv†Y{ˆ]~‹`g‚—l€œl}Ÿm|¤o}¨p€©o‚ªnƒ©l…©lˆ«qˆ®qˆ°r†³r„³oƒµp…·r‰¸t‹µv‰¬tŽ¥wš¨„°´™ÈïØ̾ÚÑÌÂÂÌ«±Á›¡±ZK8ZK8ZK8ZK8ZK8ZK8ZK8ZK8ZK8ZK8ZK8[L9[L9\M:\M:]L:^K<`J<^K<_L=^M;_N<^O<^O<^O:_P;`O;aP>aP>aP>aPÉ@8¾>3¸>1¯9+¨7'©:)­<*´<,Á=1Ï?7ß=:å99ã03â/2à42Û94æMEülaòh[ÙQCÆÍD>Á63É;7äUQÕF@É91È8-É:,È9(È9(Ä=)±?'¦<&¨;&¬=*«7(¬3(¼=4ÓLFÖGAÝE@Û96Ü30é73ì51ë0+ô1-ý,/ÿ+-ú./ô1/í4/æ81ß;1Ø>2É9.½3(À;2ÏNHáa^÷yzÿˆŠÿƒ‡ùzû|ƒÿ{†ÿx„ÿn~þew÷^põZlëL`õIaü9Wû=YîM]²JGhQ1Qd6\tDf~Nuˆ[Žc„h†’jˆ—n‰žsˆ¤t„¦t§r}¨p¨n©mƒ©l…©l…¨n‡«n…­o…¯o°l€²k‚¶n…·r‡³t‡­t§wœ¬…²¹šÈƯ×νÙÒÌ»¿Ê¤¬¿’š­[J8ZK8[J8ZK8[J8ZK8[J8ZK8[J8ZK8[J8[L9\K9\M:]L:]L:^K<^K<^K<^M=^M=^O<^O<\O<`Q>aR=aR?bQ?bQ?aP>aO;bL>hOKgNRbP\cWkjfuv”}|œx—‘z–«•Æ„’Ú}…ðuzþlmÿY[ýDLþ/Iÿ5Rÿ4½=0µ?1¬;+©8(­<,´?.»@1ÊA7ØC=Ù74á85Þ..â30æ:6Ó0'Ï5)ëUGÿwjë[PÑC7Ê<0Ë;0É7*Í6+Ô:0Ú70ß82å63ç32ê01í12ô36ý4<þ%6ÿ#9ÿ"9ÿ"9ÿ!8ÿ6ý5ø6ï2î9ð%Bï(Gî&Jñ'Mÿ3\ÿEhÿbuÿ`l÷WcñQ]òP]ïMZâ@MÔ2=Ú=FÌ7;»/.®/(¦5'¢;(›?&œ>%ª9'²8+ÒVJ»;2Ä?8¾41½2/ÎC@åWSÕHAÈ91Ä6*Å6(Ä5%Æ5$Ã:(±<(§:&¨7%­9*¬4&¯1%Â?5ÛRJÙIAáHBÞ;6Þ2.ê41í1/ï-+ü22þ,/ý+.ù+-ó++í-*æ1*ß4,Ö8,Ñ=1¿2(¼7.ÈIBÙ\Xówwÿ‰‹ÿ‡Šû€…þ†ÿ}ˆÿv„ÿj|þ_s÷XlöTiêD\õD^õ6Uñ:VàLZ¥HC^K-Mc5Uo?b}JtŒ\€–g‡˜lˆ›nŠ r‹¥vŒ¬z†«wªr~§m|¥i}¥g¥g‚¦i‚¥k‚¨mƒ«m‚¬l®h~°i³j„¶o‰¶s‰¯rŽ¬x™°„­»˜¿Å©ËʵËͶ½Åžªº‹—§]K7\K7]K7\K7]K7\K7]K7\K7^L8]L8^L8]L8^L8]L8^L8]L:]J<]K=^L>\L<\L<[N=]P?^SA`SB_R?`P@bQAcRBdQBdNAdLBjMIhKMdPYf[lnk†w{ž€…­‰ˆ²ƒ©¥‡©¾ˆ Ð‚’ây~ðsqújbÿa^ùJWñ>Që:Lî?NïCQê@KæFá9Ê=4Á;0¸:,§6&¯A0­<,¬6(¿A5ÌF=Ì=5Ð72Ú85Ü71Þ5.Þ6-Þ8*Ý<*×:'Ó6%Ù;0ðSLòZOÙE9Ç8*Í>.ÔB3Ò:-Ô3+ðGBá//î5:ó6=î,7ÿBMñ'3ú&2ÿ)2ÿ(2ù'ý"*ÿ'/þ'/ð&ð)ù+7ê .ì&7ñ-Aç#;ÿXrç-Dÿ]lÿ_iþZcùU\õPWëHMÝ?@Í84Ë>7ÄA7·?1¦7&™2!™6#š;'Ÿ<)§8-®7/ÂE?¿;7½31Ä64Å54ÔDCÛLHÚKEÑD;È:0Ä4)Ç5(Ë4)Å5*¼1¹=3Ö_Yésqÿû„†û‡Šÿ„Œÿxˆÿh}ÿ_wÿ[uÿUoøLføEcñ:Yô;[æ?YÛ]i‹@;VF-L^6YuBg†Mw–]}œcg€¡jƒ¦n‚¨o€§n¦m~¥l}¥i|¤h}£f£e£f¥l¦m«l¬k~­g®f±gƒ³i‡µm‹´r°vŽ®|™´‰§½™±Á¤²Á®¦²°˜žz…‹]K7]K7]K7]K7]K7]K7]K7]K7^L8^L8^L8^L8^L8^L8^L8^K:\K;^L>_M?^N>[N=[N=\Q?^RB_SC]QA]OB_OB`NDbPFcOHeNHiMJgNQeS_g_tnny~¨€‡»‡ŠÁž•Ê£‹»«£¹xÓyƒê|{ôvjöi`ø]aóOZìFRòHSøIVõEPï?Jë;Eä9?à:<Ú::Õ=8Î?7Ç>4À/Ç8(Ê8)Ó;.Þ;4öJFä01ð6;ö6Añ.<ÿ@Nï'4ó$,÷%(û),ý+,ü*+ø((ö((÷+,ï$'í%(ê%,ý;DÙ'ð4CüARØ&6ÿjuÿbjþZaüW]ôOSåBC×<8Ñ>6¾8,¿D5¹H6©>,™/)(’(ž-%°:6ÑTPÎHGÃ54Æ45Ñ==ëWUØGBÖG?ÐA9Ç9/Æ3)Ê6,Ð7/Î70Ç=3Â91Â5.Ã2-É4.Ñ83Ø?9ÞE=äJ@ÞA8Ú6-Ý0*ç0,ò21û03û03ô02ó12ô01ó/0ó0.î1-ç4-ß9-×=1¿3$¾aP@`P@]P?\O>[O?[RC[QE[QG\OG\OI_PMcQOfTTgUUgUUgV\h]nli†sv£|ƒº‚ŠËŠÔ˜‘× ŠÊª‚´¹}ŸÏ€“䄆îvósjûeg÷S\íGQðFOöHR÷EQòAKî=Eä7=à7:Ù99Ô<7Í@7ÅA4¾?0¶>-­>-ª<+«:,¸B6ÇH?À;2»0)Ê:2Í6/Ð6.Õ7,Ø8,Ù7(Ù8&Ü9&à:*Ý4-Û4.âA9éOCÞH:È5%È2#Ù@2â>5õHDè13ò5;ù7@ø4@ÿESø2?ð)0ë#&ì$'ù13õ-/ï''ì&%õ12ë)*ö8:è+1â)1ë3=ÿR^ï=Kÿ[gþ^fñV\îOTðMRêEIÝ:;Õ74Ô?9À6,Á?2¼B5³=1¬7-¥3)¡,#œ' š%©/*ÇECÂ::¼,,È35×ABô^]Ð?:ÒC;ÐA9Ë=3Ì9/Ô=4Ú@8Û@;Û@<Ø=;Ý>;ãA?ä>>à::ã?=ëIDàB9Ý<4Ù5,Ý2+ç1-ð31õ12ø02ô02ô02ô01ó/0ó0.î1-ç4-ß9-Ø>2À4%º8+µ;0Ð[Tízwÿ“’û‡Šúƒ‰ý~‰ÿr‚ÿdyÿ[tÿTqÿNmÿFgû=_ô=\îEbßTg¢AHp;3SH2Qa<]xEf‡Nr“Zu˜^tš_xžc{£g{£gy¢fy¢fy¡cx byŸby a| bz cz¢f{¤h{§h{¨e{©a{©`}«`®`‡²jŠµn‹²s‰¬t†¦w‚žuy“no†lSeYAPM2A>^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^M9^L8`N:aP<`Q>]P?ZN>YOCXPEXOH[QO_UTbXYeX_iYcl\fk^glaildqok‚rtšy~µ†Ê…ŒÚŒŽáŽ‡×Ÿ‹Ó­ŠÄ³€©½yŽÌ{Þzò‚wÿsrÿcgùU\ôMTõGPôCMò>Gï-±=0¼F:ÌRGÇH?º5.º1)È91Í81Ó;0Ù=1Û;-Ù6'Ü6&à8+à5-Û2+à=4ìNBãK=Ò:,Ñ8*àB6ß7.ð>:é/0ð16÷4<ü8BÿNZÿLUý>Eò38â$&í/1ê,,ð22è**ë/.ò::Ñæ37Ý,2è9@ðEMÿXcóMWØ=CÚADáBFá>AÞ9=Ü89Ø88Ó97É83Â91½:2ÀA:ÍNHÖVSÐNNÃC@²72¶95ÏKIÙMLãQRïYZêRQñYVÉ51Î>6ÒB9Ð@7Ó?5ÙB9àC<â@;é?@ç8=ì9=ò?Cï:?è58ì>=öMJÞ93Û60Ú3+Þ3,å4.ì30ò21ô01ô02ö/2ö01õ/0õ/.ð0-é4-à8-Ù?3Â6'·5(³9.ËVOï|yÿ“’üˆ‹ý‰þz‡ýoücwÿXqÿOlÿFhÿ@cû9\ô?^éKdØZh…35g;0WO8WgCa{Kj‰Ps’Yt•\u˜^wby¡ez¢fw dv awŸavž`xŸ`xŸ`{Ÿaz cz¢fz£gz§fz§bz¨`z¨]|«]~­_†²g‹´nŒ³tŠ­s†¦u€qtŽii€dQcUDSL8G@^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M;^M9]K5_M5`P9_P;\O>ZN@XOFXQKYPQ`W\g`hnfsshysg{sg}qh}ol}pq†rw—v}«z‚Á‡Ò„ŠàŠ‹å“ãŒÚ „¿žuŸ l‚¬nq¼vlÒviòsmÿllÿgiþ^`ûRWõFMï3Û=1Ú6*Ü4'â6*à3,â70ä=5åE9âF9ÞB3ÞA2â>2Û0&ê72ì0/ï.1ñ.4ú7?ÿPXÿ]dÿZ_ÿOSá.1ã03à,-÷EEè66Ü,,Û-.ë>@Ü25Ù37ÿbhà=BË*2Ê-4Á&*Õ;=á@EÛ6:Ù37ß9=Ü7;Í/0Ì43Í;;ÕGFÞRSì`cõilôekê^aÄ@>ÆE@å^[øhgÿopÿjjåKK×=;É40Ñ>7×D<ÖC;Õ>5Õ<4Ø:1Ü41î5;ñ-7ð,6ò.8ï,4ë,3ó9<þJKß3/Ü3.Ú3+Ü3,ã5.ê40ï4/ò21ô02ö/2÷/1ö.0õ/.ð0-ê3-â7-Ù?3Æ8*´2%²8-ÃNGï|yÿ’‘ÿˆŒÿ‰ÿw…úl|øatûTnýHgÿ>bÿ:_ú6\óAaàNeÂWap/+_?0[W>^lIe}Mk‰St’\u–_v™_xžcy¡cx buŸ`uŸ`u_vž_wž_xŸ`{Ÿaz¡bz¢d{¥e|¦d|§`y§^y¨Z{ª\}¬^€¬a…¯g‡®m‡ªp…¥sƒ r{•nrŠjexe[k^RbU_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N<_N:^L4_N4`N8^O:[N>YOEZSMZTT_ZahbprmzuŒ{u‘{q“zp“vp’qt“rxšt}¨w¶zƒÄ~†Ï„‰Ú‹ŒÞ–Ü™ŠÍ›…¶¢ƒ£ª„‘«~yŸl[šQ>¼MBÔQIâWRëWUñSRñKMí>Cå4:é9<æ9;à;9Ø=8Ó@8ÊB6ÀA0º?/³9,ºA6«5+£.$¾I?Ùg\ÙdZËUI¸<2¸6)À3)Î:0Ù;0Ú6,Þ3)ä6-ß1*ä71ã;2Ý9/Þ>0ãF5äB3ß9+ß1(é4-ð31ï-.í*.ô17ÿEJÿV[ÿ]bÿ\aâ9<ã9<Õ+,ôJKâ89×//Û57Ì()Ì'+øXZÝ>BÕ9=Ñ6:º#Ä(+Ü<>æAEÝ49Ù,2Þ17Ù05Í(.Ò37äKNöaeûhnùcl÷`iú`løbkÖLLÕNJê\ZêVTçMMãHFÏ42Î3/ÙA<àKDäOHßJCÙ@8×:3×6.Ü.-õ2:û-:ø*7õ'4õ)4ø0:ÿ>CÿJJà1.Þ3,Ü3,Ý5,á4-ç4/í4/ð3/ô02÷/2ù.1ø-0ö..ñ/-ë2-â7-Ù=1É;-³1$±7,ºC=ìyvÿÿˆÿ|ˆÿqöhxö_rùRlûDcÿ9^ÿ6]ú6\ðFcÑN`¢IMe5+VD0[Y@^lIe|NkˆRt‘[w•_x™`{ždz cvž`s›]rœ\s›\tœ]v^wž_{Ÿaz¡by¡bz¤b|§b{¦_x¦[x§Yz©Y{ªZ~ª_ƒ­e…¬k‡©m‰§s‰¥u„s|”ru‰pnlfwe_P=_P=_P=_P=_P=_P=_P=_P=^O<^O<^O<^O<^O<^O<^O<_N:aP6aP6aO9^O<[OA[RK\VV_Zakgvso†}z—‚~¡|¥}w£{u¥xv§sy©s}°x¸{„¿~†Ä„‰ÉŽÎ”“Íš“Ç •½«›µ¼¦²É­©Å¦”ªˆmœfJœE2¯A4¶@4ÂB9ÖHDèNNîJKì?Cë=?é;=ä<;ß=:Ù@8Ð@5È>1Á=0½:0¾?6¯4,§1'»I?ÑcVÖh[ÕeWÃOBº>2º4)Ç7,Ö90Ù5,ß2+ç60â0,ã4/â7/Þ7.à>1åC4ä>0Þ4%æ4*é0+ð3/ð..ï-.ò14ó78öBEöMRüY^éFKöQWØ37ëFJÝ8<æAEÚ7:Î.0Ñ05äHKÒ7;Ð7:¹#%Õ;=Û8;å;>ëÿ0=ú*7ü.:ÿ;EÿCHûABã1/ß4-Ý4-Ý5,â4-æ3,í4/ñ40ô02÷/2ù.1ø-0ö..ñ/-ë2-ã7-Ø:/Í>0µ1%±7,²;5ésqÿŠŠÿ‡ÿv†þi}óató[p÷PjúCbÿ7`ÿ7aù;_ìLf¿O[~86]=0NF1VX@ZeEcxMj…RrŽ[v”^yša{ždxžas›]p˜Yp™WqšXqšXt›\uœ]y_xŸ`x¡_y¢^z¥^y¤\x¤Yx¤Wy¥V{§X©_‚¬d„«h†¨l‡¥o†¢q€šmx‘jq…ij~cbv]_P=_P=_P=_P=_P=_P=_P=_P=^O<^O<^O<^O<^O<^O<^O<_N:cQ9cQ9aP<]P@ZPG\TR_Zaa_mtrŠyx˜€¨ƒ°~~°yy¯yu°wwµw|¾x€Á}…Ä‚ˆÄ…ŠÁ¿—–¾ ¼¬§»¶¬µ¾³±È¸«Ð¾¦ÖÁ¢Ñ»–Ьˆ¯oT®\G¤G5¨>0ÂG?àWQïWVñNOé@Cê=?æ<=â=;ß=:×=5Ñ:1É90Á80Á<5¹:3¸=5ÁOEÇXMÇ]OÑeXÓcUÂL>¼:-Å8.Ò91×4-ß2,ç60æ40á2-à5.ã<3çC7æC4â:-ß3%ê5,æ.&ð0-ï/,ð31ñ54ç-.â24çBF÷X]öW\ÿouåDJëHMà@Æ02Ö:=òHKî9>ð7?ø=Fò7Bè-8ô>Jÿ]gÿmwÿjrÿcn÷]gú^kÿaoÿ]nùYeò\]ãPIâJGÕ74Ò/0Ù54Ò0.Ø95ßD?ãJDâIAÙ@8Ó6/Ö4/Ü71è66ê'/ü0<þ2=÷+6ù0:ÿ>Eý?Aì44â3.à5.Þ6-ß4,á3*è3,ï4/ô41ö01÷/2ù.1ø-0ø..ò/-ë2-ã7-×9.Ñ?2¶0%²6,°61èpoÿ‡ˆÿ†Žÿp‚ücxñ\pôXn÷OiûBbÿ9aÿ`P@`P@_O?_O?_O?aQAbRB_O?]M=]M=aQAcSCbRB`Q>dS?aP>]P@^QI[QPZSZeapsq‰yxšz|¥~€±€¹}ºxz·rs´lo¶twÈv{Ì€ƒÊ‹Æ–—䤾²°»¼¹´ËƳÓÌ°ÙϬÛϧÜÏ£ÝУÙ˜٘Ѩˆ¸€g ^FËzgÖue½H?×QN÷ccéKLå?Aâ89ä::â:9Ü75Ù61Ö;6Ë81À5.ÇB;»<3¿I?ÆXK¹OAÎdVÑcTÌXIÅG9Ä:/Í6-Ø7/á6/ã4/ß0-ß2,à70ä=4à<0Ý7)ß5(å7,ä/$ê/&ì/)î1-î20ë40è51â64×79æJNõY]íNS×8=×6<ùX`ÿ~„ÿ~†ÿouÿgoÿipÿflõ\añX[ûZ_ÿUZÿDKü8Bû7Aö2>î+9ì0>ñ=HÿS_ÿ`iÿgrÿepþbmÿcnÿ`oý]gíSSßF@Ö85Ö41×11×/.Ø31Û94áD=ÜB:Ù?7Ö<4×90Û81à93æ66ð7<ó4;ó4;ö4<õ6;ò59ë33ã1/Þ3,Þ5.ß7.à5+ä3+é2,ï2,õ20÷12ø03ú/2ù.1ù//ó0.ì3.å7.à?5Ì8,¿6,¯/&¸;7ÒXWÿ˜šþ{ƒÿm€ÿe|ø\rðPhôGeüCeÿ;dù9`õNlÓRd‰=?P, C;&CG.KM5Y_CZjEcxMqˆZx’bx–`t•\r–Yq˜Yl•Sm–Rn—So˜Tr™Xt›Zuœ]uœ[t›XtWv Xw¡Wv¢Wv¢Uu¡Tt S{¥[{£]zž^u—[m‹Ub~MXrCSj>AW0?U/`P@`P@`P@_O?`P@aQAbRB`P@_O?`P@bRBcSCbRB`P@fVG_QF\OG^TSaZad`omkƒvw–wy¢{}®}¸x|¹quµkp´lo¶nq¾uvÐ|~Õ‰‰Ó˜˜Î¨§Ç¸¶ÁÉźÓαÛתâÛ¥çÞ¥æÝ¢äÛ¤âØ£ÛÑ ÔǛӼš»œ€©}dÅ‹wÊ}m´VJÒa[örpìZ[çKLã?@ç=>ë>@ç;;â66Û64Ö=8É83Ê?8¹6.¸>3½K@¶H;È]MÝo`Ô`QÆH:½5)Ä0&Ô6-Ü5-Û0)â51å95ä=7à<3Ü8.Û5)ß4*ã5*ì7.í5+í2+ë0+ç0,ã2,á4.Ý52Ö87Ø>@äJLóW[ú^bü\dþ]eÿaiôS[ïNVñQYÿ_gÿjqÿflõZ`óNTí4:ñ,5ô*6÷-9ñ'5å!-æ'6í7CþPZÿZdÿblÿdmÿenÿcmý[hõQZåEEÞ<7Û64Þ63ß55Ü30Ú2/Û62à>9Û>7Ø;4×:3Û81ß82å95ç:6é9;ê7:ë7:î79î79ì65å31ß2,Ü3,Ý6-ß7,â6,å2+ê1,ò1,õ20÷12÷03ú/2ù.1÷//ó0.ì3.å7.ß<3Ô=2Â8.¶1*·74ØZ[ÿ“ûs}ÿfzÿ^vùWo÷OiùFfû?bü^QA^QA^QA^QA_RB`SCaTD`SC_RB`SCaTDaTD`SC^PCbUM\QM[QRcYbkdtqm„vu•y{¤y{¬y~¶x|»nsµei°`g¯jn¸ruÆ}}ׇ„Ý—”Û©§Ø»¹ÏËÊÈÜØ¿åá´éäªíè¦ðé¥íå¤çá§âÛ§×Ï¡ËÃœ¸¯©››ƒk¨ƒp§o`œRGº]UÝmi÷uuï__äJLå@DëADì>@è8:â66ß=:Ô;6ÔA:Â70·7,·>3®=/¶F8Ûj\ßi[Ù[MÊB6Å2(Ñ4+Ù6-Ù2,Þ52éA>ìGCà=6Õ2)Õ1'Ú2'Þ0%æ4*è1)ç.)æ/)ã2,â7/á=4àB9Æ-(Ê43ÜDCðVXú^b÷ZaóS[ñQ[èFQêHSïOYü\fÿmvÿntôY_ã>Dé.5ô-4û2<ü2>õ+9í'4ö6EÿKW÷ISõPWøW_þ^fÿckÿ`i÷RYéBIÞ97Þ71ã75é<8ë;;æ95á51Ý60Ý:3Ù;2×90×90Ü71á83ç:6é<8ã99ã99å97ç98è88æ74á40Û2+Ú6-Û7-Þ8,â6,ç2)ë0)ó0,÷10õ12õ13ø02÷/1÷//ò0.î3.ç6.Ý90ÜD9Ç80»4.µ/.ä_bÿƒˆølwþbxþWsúPmþLlÿCfö:]ó;_ìIfÔSgDJl;4O>,=<':?(ED/FH0Q\U'B\/E_2Ic6WJ:ZM=\O?^QA]P@^QA_RBaTD`SC`SC`SCaTDaTD`SC_RB\PDZOMZQVbXcjcsqm†vu•xz£z|­w|´sy·mr´bi¯]d¬ag±lr¾x{ʉ‰ß•‘夡䶵áÇÄÙÕÑÎáÝÄçä¹ëæ¯îê­îè¬éâ«ãÛªÚÓ©Ë¡»¶™¥¥›™„“ˆv˜q™rc›bW³i`Ïrmû‹‰õutê[]æLNèCGí@Dìô@?ï=;æ95à72Ý82Ú91Ù80Ù80Ü71ã73è96é:7â:7à;9ã:7æ:8ç:6å84à5.Ú3+Ú6,Û7-Þ8,â6,ç2)ë0)ò/+ö0/ô22ô23÷12ö01ö0/ò0.î3.ç6.Ü8/àF<É91¾3.¶,,îfjÿy€øgtÿbyýTqþKkÿGjÿ>cò6Yë=^ãQhÄXeˆBBgC7[N;GF1AC-JH3EE-LU6Sc>btLlƒUp‹XnRkPiŽKgIhJh‘Kj“Mk”Pm–To–Wp—Vt›Xs›Uq™So—Pj“MgJeŽHdG`‡D]AWy=Rq8Mi6Lf6Ne7Of8Lf7Oi9Sm>UH8WJ:[N>\O?]P@]P@_RBaTD_RB`SCaTDaTD`SC_RB_RB^QIVMR_Xhnf{tp‰xt—xw¡xz«y{´sy·jr³`g­[c«_g°jr»v|Æ€„Γ•àžžä­®ç»½æËÉßÔÓØÝÛÎáßÆåá¾æâ¼äß¹à׶ÚеÎƱ¾µ¦­§›˜šŒŒŽ€‰…yŠ|q‘vk›si¨meºoi扄î~ósrñedñWYðMNîDEì@@ã:7à;7äB=ÞE?Ì<3Æ=3ÄB5¯1#®0"ÇI;ÜXKÖN@Ì=/Î8*Ð6*Ñ3*Ö42õUUÿkhú]XãD>Ü;3ß;2ã80â4-ã2,â1+Ý0)Ô0'Í/$Æ/$Â0#Å9,À4'Á3)Ë:5×CAÛEGÛBGÚ@HàDOëOZòVaòVaú^iÿgoóYaáBGê:<í57í38ï28ñ3=÷9CÿHSÿV_ä6?Ý4;ß6;ëADùJOüIMô;Aé13è51ë95ï<8ò<9ó;9ð:7é73â70ß;2Ü;1Û:0Ü90ß82ä73è64é75æ:8ä;8æ:8è:9è;7æ95á6/Ü3,Û7-Ü8.ß9-á7*å3)é1)ñ0)ô1-ó32ñ33ô22ô01ô1/ò0.î3.ç6.Þ7/àC:Ê70À1-À13÷jpÿqzúftû]túPmÿCfÿ=dÿ9cõ8^æEdÙZm«V[wE>dJ=aYFTO;KI4PI6GE.GP3L\8ZlFf|Nm…SmŠRlŒMhJfŽHgHg‘Ii’Lj“Ol•Sn•Vo–Ut™Vs˜Un•Rj’LfKcŒHaŠF_ˆFZBX|?St;Pn8Ok:Rl=Wn@ZqCUo?Vq>WqARE5UH8XK;ZM=[N>\O?^QA`SC`SCaTDaTDaTD`SC`SCbUEaVP^Vcje|yu}yšzy¡xy©vy°sw´jr³cj°[c«]e®hp¹v~LJшŒÓ™Ý£¥à¯³ã»¿åÆÇãÏÎÞÔÓØ×ÖÑÙ×ËÙÖÇ×ÑÅÒÉÀÌþŹ¹´¨¬£šŠ‹†x{tyvquleleogŽa[`[ÀsmØyuð{ü|yÿrpýccöSTðHGïC?ê>:á<6àA;Ñ:1ÓC:ÝTJÂ>2¸6)½9,Â=.È?/ÏB1×C5Ö@1Ñ7-Ð2/êLMú_]òWSßD?Ù:4Û81à70æ93ç92ç92â:1Ú9/Ñ9,Ê8+Ä8)°(¸3"È@2ÓI>ÒD@Ë;:Ì7;Ï:@Ñ7AâHRíV_ðYbõ^g÷`iêU[ÜAEå@>ì?;ñACúGJÿLTÿQYÿT]ÿV^á4:Ú/5Ü/3ç7:ô=Aø;?÷48ó12í42ï95ð86í42ë20ê20ç40á4.ã<4à=4ß<3Þ;2á83ä73è43è43è88ç98è88ë99ë97é75â5/Þ3,Û7-Ü8,Ý:+ß7*ã2(ç0(ï0(ò1,ñ42ð43ó32ó11ó1/ñ1.ì3.ç6.à91Ù<3Ì71Á0-Ñ@CÿnuýkuùbqðRiõHfÿ;aÿ4^ÿ6bû>däNiÊ\i‹GFjF:]L<]VCXQ>RJ7OG4ID.DJ.GU2Sc>^sHgMj‡OjŠKgŒGgŒFfŽGfHgJi’Nk”Rm”Um”Uq•Uo”Qj‘NgŽKcŒH`‰E_ˆF^†G\‚E[~DWxAVr?Uo@YpB]rG^uG[sCYtAXs@NB2QE5UI9WK;XL\P@^RBaUEbVFbVFaUE_SCaUEfZJh]YngwupŽ|x™{y wx¦vw­pu¯jo¯ah¬^f®_g°em¶pxÀ}…ؙ͉ؗ Ö¡¨Öª±Û´¹ßº¿ßÀÁÝÃÃÛÇÆØÆÃÔÅÁÐÁ»É¼³Ä»°Áµ¨¼¦˜¯–‹œˆ…Œqqqtpopfewhe†nj„_Y•d_›ZT¹f`Ùsnðzvÿ{wÿwsÿhfüZWþRNõHBæ=6çD=Ø;4ÛG=ê\RÅ;0Ä<0½7+¾6(Ç>.ÑD3ÔB3ÔA1×A3Ò86Ø>>ÝCCÜB@Ö=7Õ81Ø7/Þ7/å:3æ93å:3â;3Û>5ÕA5ÑE8ÌG6®-¼;%ÍJ8ÑL=Æ=5»0+À00Ê9>×AJáKTëU`ðZeð]eìYaßLRÔ>@Ï4/Ø7/à;9ê@@òCHõDJñBIî?Fâ5;ß26ã36ï8<õ79ø14û/2ü14ï20ð95ð74ì0.è,*ç0,æ3.à3,ä=5à=4à=4à<3ã:5æ95ê65ì65ì57ì57í57î68î66ë54ä2.Þ1+Þ7.Ý9-Ý:+ß7*á4&æ1&í1(ñ1,ð42î53ñ42ò21ó1/ñ1.ì3.ç6.â;3Ò4+Ò:5Æ20çUXÿpxùcnòZiçI`óEfÿ8bÿ/]ÿ5bÿBhÜLe±PYj5/^G7XK:UN;[P>VI8M@0JC0@F,AO.K[6Xj@bxGfJhˆIf‹FeŠDc‹BcEeŽHgLh‘Oi‘Rk’Sn’RlPhNd‹JaŠH_ˆF_‡H_‡H_…H_‚H]~G]yF]wH`wKcxOczN]uC[vAZu@JC3MF6QH9TK.ÑE6Ë>-Á2"Ê7'ÛE7ÞE?Ó97Ì3.Í50Ô;5×=5Ý<4á=4ä;4ä92Þ5.×4+Ï5)Ê8+Å<,Â?-ÔS>ÈG2½<)¾:-Ã=2Ä;5Â74Â43ÜKNÞMRáPUåTYèY]åVXÜMOÓD@É5+Ñ7+Ø7/Ý52â24å26æ18æ.6ì4>ì3;ó5?û9Bý4>ú+5ÿ(3ÿ/9ø-3ù57ù59ð./ë*+é0.è51â5/ã<4à=4à=4á=4ä;6ç:6ë76î66ì46ë35ì25í34í55ê41ã1-Û0(Þ8,Ý:+Ý:+Þ8(à4&ã3$é3&ì4*î50î52ð42ð3/ò2/ï2,ì4,ç6.ä=4Í/&×>9Ì35ùbgÿoy÷[iðNcêC]ùEhÿ:eÿ0]ÿ6aöGhÉJ]“CFR,#VI8SL:OH6[O?UI9F?-HF1>B'@J(IU1Sd:_rEe}Ig„JeˆHcˆCa‰BbŠCcEeŽHfMhPiQlPkMfJcŠIaˆG`‡F`‡H`†I^G^F_}G`|Ia{Kd{Mf|Nf~N]xC]z@^{CDB6FD8JF;PG>RH>WI>]M>_O?`Q>aR?`SB_VGbYRgb_ojnso~wq“zt |y¨yw©pp¦gg£`a¢\_¤`b­fhµopÀyzÌ„‚Ö‹ß–’眙栞ݡ¡×££Ù¤¤Ú¦£Ø¥¢×¥¡Ô¤ Ó¥žÑ£Í¢šÉ¢™ÈŸ–Ù»Ž‚°ƒ|žrn}igld^`fZZkYUrWP}WNŒWO•RI¨ZPµXPÁZSØkdìyrù‚|ÿ‹†ùuqÿusí_]ßPLÙEAïZTÌ71Å2*Ä6*Ã7(À7'Ã7&Æ9(Ê;+Ð<.Õ?1Ò8.Ö<2×?4Ó;0Í5(Í3'Ø:/â@5à90á90Þ7.×7+Ï7)É:*Æ?,ÄA/Â=.Æ@4ËE:ÍG<ÌC;Å<4»2,¶+&Ç<7ÐEBÙOLàVSãYVáXRØOIÐC:Ì;*Ó:(Ü8,â5.è./ì*2ð(3ô'6ú->ú+?û*?ý)?ÿ(?ÿ&?ÿ$<ÿ$<ÿ$8ÿ'9ÿ+<þ,9ó+5í.5è45ç;9Ý84Ý:3Þ;4à;5ã:5æ95é73ë54ë35ì46ë54é54ç53â5/Ý5,Û5)Ü8,Û9*Ü9(Þ9&ß8&â7%ã6%æ4&ì5-í4/ð50ñ4.ñ5,í5+ê5*å7,à90Ø7/Õ:6Û?BÿmwÿbsûSjõIcÿKjö6[ÿ6_ÿcçNj¯IV^$"D, ?:'HE4PMC/?G/BH&EK%KS.S]8[kDavKd~NdƒJb†F`ˆBa‰@c‹BeFhJlPm‘Ql‘LiŽHgŒGf‹HfŠJe‰Ic…HaƒGdƒJdIbGc~GdJdHe~Ga}C[{<\=_‚B=?4?A6FC[K>]M=`O;`Q<^SA^VIc[Xhcinlyso†tp•vpžtp¢pm¢gfŸaaŸ]^¡\\¤ed°kjºtrÅ}{φ‚Ù‰à”Žæ˜“å›–Ùœ˜Õ™Öžš×ž˜Ö—Õœ–Ô›•Ñž–Ñœ”Íœ“Ê›’ǚē‰»ˆ®‚xtk|mdif]^f[YiZSoWM{UJŠVKšVK°\RºYRÁXRÓfaàqjãvoí~wý‡…ÿ‡…÷usîgdãUSëZUÇ2,Â/%Å7)Ã7&À7%Á8&Ä8'È;*Ï;-Ó=/Õ9,Õ9,Ó:,Ò:,Ñ9+Ñ9+Ô8+Ø8,ß;1à90Ü8.Ö8,Ï9*È9(Á:&¾9&¾6*Á80Æ=5É@8ÊA9È?7Å<4Â91¿4-Ç>6ÑH@ØOGÚQI×NFÌC;Ã7*Ê7%Ó8$Ý7)å4,í//ô+3ù)7ý(:ÿ+@ÿ*Aÿ)Aÿ&Aÿ#@ÿ!<ÿ=ÿ:ÿ:ÿ 9ÿ%;ÿ);÷-9ð19ê7:å;;Ü94Ü:5Þ;4à;5ã:5æ95é73ë52ë35ì46ë54è64ä71ß6/Ü5,Ù5)Û9*Û9*Ü9(Ü9&Þ9&ß8%á8%ã6%ç5+ê3+ë4,ë5*ë5*ê6(ä7)á7*ß;1Õ4,Ó54óTYÿesÿ[põGbÿIhÿAdÿ;`ý3[ù;aòMmÍLb‰8?S*$A5'69(;<,B@1DA0@?-=B.>G,=CKP'\b_„?b‡B69.:<1??7DA:KB;OE/Ô>/Î6(Ë/"Ú:.Ú8-Ù7,Ö8,Ð:+É:)Â9&¾7$½5)À6,Â8.Ä:0Ç=3Ê@6ËA7ÌB8Ç:1Ê@6ÏE;ÐF<ÒH>ÑG=Ê@6Å7+Ì6%Ö6&ß7,ç4/ñ03ö-5û+9ÿ*<ü';ü'=û%=ù#;û!:ú7ü7þ6ÿ8ÿ6ÿ$8ý*;÷2<ñ6=ë8;ä::Ü94Ü:5Þ;4à;5å95ç85é73ë52í36î47í55ê65å61á6/Ü5,Ø4(Ú8)Ù9)Ú9'Û8%Ý8%Þ7$à7$á6%á5'â4)ã5*ã6(ã6(á7(Þ6)Û7+Ý<2Ð1+Ø88ÿkrÿ]nþPiñ<[ÿHlÿ7]ÿ>eù5[î>bæVqª?Qa#(L/);7+07'37&9<)@=*A<(@>)BB&?FXa4s~T€Œdw‡`hSa}La€G`ƒC`…?a‰@cŒ@hŽEjJkMl‘Nn“Mk‘HhHgŒGh‹Kh‹KfˆLd†Je„KdƒJc€FdGf‚Hf‚GeFb€Bc†DeŠEhH25*58-;<4A>7G@:KB;RE.Ñ>.Ë8(Ç/!Ò6)Ó5)Ò4(Ò6)Ñ9+Í<+È=*Ä;)Ä:-Ä:/Æ90Æ9/Ç:1È;1É<3Ë=3ÓD<ÓE;ÐA9Ë=3Ë<4ÏA7Ï@8Î;1Î5'Ù5)â5.ë31ò/5÷+6ù)7ü):ù&9÷&;÷&;ø'<û&<ý%:ÿ$:ÿ#:ÿ"7þ#7ú%7ù,;÷5>ò9?è8:à87Ü94Ü:5Þ;4à;5å95ç85é73ë54î47î47î66ê65æ72á6/Ü5,×5*Ø8*Ø8(Ø8(Ù8&Ú7&Ü7$Ý6$Ý6$Û5%Ü6(Ý7'Ü9(Ü9(Û:(Ù9)×:+×:1Ð3.ëHKÿoyÿVjøD_ø<_ÿAgÿ3\ÿ8bø>cèMlÅOe€0=J C1-11'.6'4=,=B.B@+B<$E>$HE$U\0p~MŸr—¨|ƒ˜mj„W_{J]~E_ƒCa†@bŠAfCkJl‘Lm’Om’Oo”Nl’IiŽIhHiŒLiŒLhŠNg‰Mf…LdƒJdGe‚HgƒHh„If‚Gd‚DgŠHiŽIl‘L-3'36+891<;6B=9G@:MD=QG=SI=SK>UNDZUQa^eigumklkŠjhb`XVˆPP†QQXYš`cªfj´orÁuxÉ|Ђ…Ö†‡Ù‡ˆØŠ‰Ù‹ŠÖ‹ŒÏ‹ŠÌŠ‰Í‰‡Ð‰…ш„ÑŠƒÑ‰‚ÐŒ„Ï‹„È…Á†º†°‡¥~w–m…„Yj€SZnVTc\RZaOZ_HeZDxUB’LD¸TRÐSWÛRYå^dèejãklæuqäunâoh÷~vÿ‚{ÿ‡~ôl`É?2Á8(À;(¿='¿='À<'Â;'Å:'Ç8(Í7)Ø:/Ù8.Ò8,Ï9+Ì:+É:*È9)É7(Ï9+Ñ7+Ò8,Ñ7+Ï7*Ì8*Ë<,Ë>-Ê<0É=0Ê<2É;/È:0Æ8,Å7-Å5*Ð@7Ð@5Í=4É9.Ë80Î;1Í:2Ì5,Ð/%Ù0)ä20ì25ô/8ù-9û+;ü,<ü-?û.?ü/@ü/@þ/Aÿ/?ÿ-?ÿ.@ÿ)9ü)8÷+7õ0:ñ6=í8=ã77Ü43Ü94Ü:5Þ;6â:7å95ç85ê65ì44ñ48ñ48ï56í76æ72á6/Ú6,×5*Ø8*Ö9(Ö9(Ø9&Ø9&Ù8&Ú7&Ù8&Õ8%Õ:&Ö;'Õ=(Ô=(Ô=*Ô=,Ô<.Ñ7/Ú;8ÿ^eÿaqÿPi÷<[ÿAiÿ4_ÿ4`û1YôKlÛYq•>NZ%-C),:2/-0)08+7@/:B+<<"A<UH(`[5{…S£lª¾‹¨¾Ž¥wo‹[aK^F`„DcˆBeDj“Go”Np•Po“So“So”Nl’IiŽIgŒGiŒLiŒLi‹OhŠNf…Je„IdƒHe„Ig…Ih†Hg…Ge…DiŽIi‘Kl”N+1%.4*470893>:7B=:HA;KD1Î8*È4&Ê8)Ë<,É:,È:,É;/É;-Ê:/È9+È5+Ç5(Ê6,Ï;/Ò>4Ó?3Ö?6Õ>3Î7.É,#Ò+%Ü-*ç02ð39ö1;ú0<ý0?ý0?ù0@÷1@÷1@ö0=÷/<÷-9ú,9ú*7ý/<ù/;õ0:ð3:í6;æ69ß55Ù42Ü94Ý:5ß:6â:7å95ç85ê65ì44ò59ò59ð67í76æ74ß6/Ú6-Ö6*Õ7+Ô8)Ô8)Ô9'Õ8'Õ8%×7'Ô9%Ð9$Î<%Ï=&Ï?'Î@(Î@*Ð?.Ò;0Ñ61ëHIÿfrÿOdÿHfû7[ÿAmý/]ÿ7aò4XãPj¼Ufm19E(*E697325406906=-3;#38CCja:…TŸ®w©Á‡µÎ—¯Ç“’®}v”be†Q`‚F`…BcˆBgFm–Jr˜Or—Rq•Up”To”Nl‘KhHf‹Fh‹KiŒLi‹Ni‹Og†Kf…Je„If…IhˆIi‰Hi‡Gf†CjJk“Mn–P(0#+1'/4-350764<85@=8C>8IEù4>ù1>ú0@ø/?ò.<ï/<í/9í07ï-5ï,2ò+2ñ*1õ2:õ3;ò5;ì59å57á55Þ65Ü75Ü86Ý97ß:6ã:7æ87é77ê67ì46ô5:ô5:ñ7:î87æ74à70Ú6-Ô6*Ó7*Ñ8*Ð8*Ð9(Ð9(Ð9&Ñ8(Ð9&Ë9"È:"È>$Ç?%È@(È@*Ì=-Ï;1×96üU\ÿ^qÿGcÿ?aÿ:aÿ7gþ3bû8`íFdÅNa‰@IS12A64@:<:46?56<7179+4="9CSZ.‚‚P¢§q±ÅŠ¯ËŽ°Ì’¦Ã’®}{™egˆQ_E^ƒ@c‰@iDo•Js™Ps˜Sq•Uo“Sn“NkJgŒGeŠEgŠJh‹Ki‹Ni‹NfˆKd†Id†IeˆHgŠJh‹Ii‰Hf‰Ej’Ll–No™Q&.!(0%-2+13.331764:95<;6GD=DD*¾;'¼7$À4#ÑB2ãOAäN@ØB4Ë7)Ë7)Ð>/Ê;+É:*Ç8(Æ7'È6'Ê6(Î8*Ð8+Ó;.Õ;/Õ9-Ò6*Õ7,Ú<1Ý<2Ü71è88ñ8=÷:Aû9Bú4Aõ/<ò,;ï,:í/;ê19ê38ë48í57ñ56ô36ó57ð37ï6;í9<é69â45Ý33ß76à;9Ý86Þ97á96ã:7æ87é77ê67ì46ô5:ô5:ñ7:ì89æ95ß82Ø7/Ó7+Ð8+Í:*Í9+Ì;*Í:*Í:(Í:*Ì;(Å9"Â:"Ã=$Â>%Ã?(Æ?+Ê<.Ï81ß<89?48E26C41=:)>E&FU*bs?›a­½±ËŒ«É‹¦Ã‹º„Ž¬z{™ef‡PZ|@^?a‡>hŽCo•Jr˜Or—Rp”Tn’Rn“NjIf‹Fd‰Df‰Ih‹Ki‹Ni‹NfˆKe‡Jd‡GeˆFgŠHh‹Gh‹GeŠDk“Lm—OpšR(0!'/"(-&).(.0-3317839:4==5?@8DE@JLKORYVXeZ\s]^}YX‚[Y‹^]–ee£nn¶wxÈØ„…⌌ðŠŠì†‡ä‚‚Ü€€Ö‚€Óƒ‚΀ƒÈ„ǃƒË„„ΆƒÐˆƒÓ‹„ÒŒ„ÏŠ€ÅŠ€¼‰€¯‡}Ÿ€xwozkegf]Xm[Qm[Mi\Lf^Kd_IeaHhaGo_FoP;…UA¥]O¿aYÑYXÝQTîS[ø\`ùheæYPÔD<Î70Ñ7/×:1Ö=/Ô;+Ï9(Í:&Ï9(Ñ:)Ô8)Ø8*Ü5,Ü5,Ð/%Í3)Ì8,Ê>/Å@/Á@-¾=*¼9'Â9)¾0"éWJßK?Ã/#Ñ=1Î2Ü<0Ù7,Ú8-â>4ìC<õBEò9?ð2<ö4?ö2@ñ-;í-:í2=ì7>æ5;ä68å78ë99ð:9ñ78ï77ò;=î<<ê::æ87á85ß74Ü75Ü75Þ97á98ã99æ::é9;ì9<í9<ï8<ô7;ó6:ð8:í9:ç;9à;5×90Ï7,Ê8+È9)Ç9+Æ:)Ç:)Ç:(È;*Ç<)Á9#Ä='¾:#¶4¼9%ÉD3Ï?6Ê1,ÿ^eÿVgÿIbÿ<\ø1X÷0Yû6cõBiçYo¬FQo33N3,B?6>C<@78@-1L/3K2.A9&DJ(Zn=~š_ž¸w¨Å‚¬ÊŒŸ¾‚˜¶€”²~‚ nf„RXvBY{?]€>c‡AiDn”Im•Ll”Nk’Ol‘NiŽIfŠDc†Bc†Bf‰Ih‹KfŠLdˆJg‹MhŒNg‹Kf‹HeŠEf‹EjIk“Jq›QržSt U*0")/#).').(-/,130561782;<4>?7AD=HJGOPTSUaXYkZ\u\Z^]‰db”kj¤utº~·‡ß‹Œéð‰‰ë…„ ؀~Ҁς‚Ì…†É†‡È‡ˆË‰ˆÎ‹ˆÏŒ†Î†ÌŽ…ÈŠ€¼‰±†|¡‚x‘{s€tknlb`e]Re`Me^Kf^Kh]Ki\Ij^Hk_Gn^Ew_G[C’YF­ZLÇVPÞRSõQXÿX_ðUSãLEÙ>9Õ60Ù6/Ü90Û9,Ö9(Ó8&Ñ8&Ñ8(Ô8)×7)Ü6*ß4,Ý5,Î0'É5)È9+Æ=-ÄA/Á@-¿<*¾9(Ä8)Ë<.äREÜH<È4(Ì:-È:,Â4&Ê=,Ë<+Ê;*Ê;*Ë:)Ì9)Î8)Ï6(Ó7*Ö8,Ù7,×3)Õ1'Ø1(Þ7.ç<5øDGñ8>í/9ï/:ð0=î.;ë1<ë6?ä5:Ü36Ø22ß:8îEBøIFøDCó?>é:7ç98å97â96á85à85á98á98à87â88å99ç9:é9;ì9<í9<î7;ó6:ò59î68ê88ä;8Ü:5Ó9/Ë7+Æ8*Ã:*Â:*À;*À;*Á<)Á<+Á<)½9$Á?)»:%³5¹:'Á;/Ê:2Ø<=ÿ^gÿPdÿA[ù8Wö6[õ;`ô>dãIe«?Lƒ?>_:2G;/:>08>2F<:R>=N0.S8/VK5ciEx[°pÂ}¡Æš¹}š¹€š¶ƒ©xrŽ^YuETp=\{B_@b†@iCm“Hl”Kk“LiMiMgŒGe‰Cc†Bc†DgŠJiŒLhŒNg‹MiOiMiŽKgŒGgŒFfŽEl’Im•LpœQoRt U-1"-1#,/&,.)//-11/34/45-9;0<>1@B7EHAKMLQRWUUaVWi\Yt^]fdŒpn zx·…ƒÎ‹ßêŽïŽŒíŠ‰ç‡„ßÓ|Ë}ȀƅLjˆÆŠŠÊŒŠÉŒŠÉŒˆÅŒ„¿‹‚·‰€­†|¡€v{p€ujpndbi_Vc]M_aL_aKc^Jg\Jl[In\Ho]Gq]EwaIxX?‡S=£VDÇXOãUSøOTþMSâ><Þ<7Ý84Þ71á6/á6.Ý7+Ú7(Ô7&Ó8$Ó8&Õ8'Ø6)Ý5*à3,Ý5,Ë3(Ä6(Â9)Á<+Â?-Â?-Á<+À8(Ã5'ÜJ=ÚF:ÕA5Îå84â62à72à72à72á85â96ä;8ä;8á77ä88æ8:è8;ë8<ë8<ë8<ì8;ï58î47ì57ç77â:7Ù:4Ï8/Ç7,Â8+¿:+½;+»<+»<+»<)»<+»<)¸9&½@*³9$±6$¶;+µ0'Ã40ìPTÿ[iÿJ`õ:Uð7Vñ@]ïHfçHdÍNa‚89e?6R@2DA09=,57)>6+K9/E-#R=,g]Bˆ_’«t—»{–Áz–¿{”³xœ¸…š´…€šm\uKHb5Nh8[xB_}?cƒ@hŒDl’Gj’Ih’JgLfKd‰Dd‡Cc†DeˆFh‹KkŽNkOjŽNiOiOiMhJgHh’Hl”Ko™Ms¡Vs£Wv¤Y24&04&01)01+12-23.34.46+9;-;>-?A3DF9IJDMONRQWSS]XVd\Zoda~nl”zw¬„‚ÃŒ‰Ö‘㔑ê“뎋≅قÌ|Ã|¿€~½„‚Á†…Á‰ˆÂŠÃ‹ˆ¿‰…¸‡®…}¤…{€vŽyn~rgmmaak^Vi[Pc\J]`K]aJc^Jh[JmZKqZJtZIv[FsWAxR;ŠQ=ªYFÍ[PãTPðFIñ>AÛ2/Ü5/á51ã60ã5.á5+à6)Û8)Ö7$Ó8$Ñ8&Ô9'Ø6)Ü6*à3,Ú6-È6)½8'¼7&½:(¿>+Â?-Ã;+Ä8)Æ4'éUIÓ<1Ì8,ÑB4¾5%À=+À=+À8(Ä8'Å9(Ç:)È9)Ë7)Ì6(Í3'Ò6*Ô3)Õ2)Û4,ã:3é>7ì?9ì=:è45ì59ï6;î5;ê2:æ39ä7=â<@óUVübbÿmjÿidóVQäA<ß63Ý4/ß61Þ71Þ71ß82á85â96å97æ:8å78æ89è8;é9<ë8<ë8<ë8<ì7<î5:î68ê67å97ß<7Ö<4Ì9/Å9,¾9*º;*¶;)µ<)µ<+´=)³;*³<(³:'·@,­8&­8'³;-«+"Ã54ý`gÿTdúG\ð-=@-@C.DG4IK>MNFQPNRRRVUSYX]a_lkius›€}²ˆ†ÇŒŠÓ•’ᔑâÜ‹‡Ó„Ä}º|µ|³~·„º‡„¹‰…·Š„²†¨z›€xs‡znzrfjm_^j[Ti[PjZKfZJb_Lb_Le^Li\Kn[Lr[Kw\K{ZG~UA†R=›RA¶VFÎRHÚG@â88å33Ý1-ß3/â5/ã5.á3,ß3)Ý5(Ü9(Ó8$Ð9$Ï:&Ñ:'Ô8)Ù7*Ý5,Ø7-Ä;+¹:)µ6%·8'½;+Â=.Ç;.Ç7,Ð90õ\TÖ=5É5+ÏA5¸3$·:(¼?+¿:)Ã:*Æ:+È:,Ê;-Ì:-Ï8-Ñ7-Ð3*Ò1)Ö1+Þ71å<7ê>:è;7æ74é75ï;<ðë8>è7=ê7;î7;î79ê7:ä::ß=:Ö=7Ë;2Ã;/º8*µ:*³;*¯<)¯<*¬<(¬;)¬;)ª;(¬=*¦8'§9*ª8-¬/)Ë@CÿhrôM^óH[íDYåH[ÙO^ÉT]·TWœXUdM?OL9LG4JE1FD-?B'=D#>H#KV.\g.==1==3==5;<4;=2;=/?B/@D-CG.FJ3KL:NOAQQIRRHYWJZZN_^\gerqn‰{y¡ƒ€·‡…Čьӊϊ…ǃº~y¯zw¦yv¥{v¬|y®€|®ƒ}©ƒ}£x—|t‹zrvksrffm_\j\Sk[NlZLl[Kk[Ki]Mg^Mi]Mj]Mn]Ms^Mz]MZI“`O›VG§N@¸J=Å@7Ï6.Ø1+Þ1+á51á6/â5.â4-à2)Þ4'Ü6&Ú;(Ñ9$Í;$Ì;&Î;'Ñ:)Õ9*Ù7,Ó9-Á>,´;(°5#²5#»9)Ä<.É;/Ë7-Ù?7ø[TãIAÎ:0Ì@3¸6&¬3 µ<)¼9'¿7'À7'Ã7(Å7)É7*Î7,Ñ7-Ù<3Û:2Þ93å<7ê>:ê=9ç85ã41è96ë<9ì::è8:ì>@øPPÿbcÿppùheâTPÊ=6À1+É40Ö;7ß=:à;7â;5á:2â94á83ã73ä73å55æ66é69é69ê7;ë8<ë8>ê7=è7=é6:ï8<ì89è8:ã;:Ý>:Ó>7É<2À8ÛTXûepîK\ïI]éJ\ÛM[ÉQZ´VV ZRŠ`RPI7HM9NI5H@+;567>O%Lf6lŠTw”\„›e‰šd›f£k”­t˜°|ƒ•mn}\Q`Cg{HiƒFl‹Gm‘Gj“Gf’GbGcŽGhJlMo’Pn“PlMiŽKjJj’Ls›TsUsSržQržOs¢Rw¦Uz«Zv¦Zu¥[s£YRK;RK;RJ=RJ=RJ=RJ=RJ=RK;UNXQ?YR@[TD\UE\UEb[HaZHaYLbYRe][kaiqftuj{zn„|pˆs‹s‰|p„uj{mbre]jc`k`_g_\c_Z^^ZY^YUaZRbZOe[Og[Ki\Kk\Ik\Gm]Fm]Fj^HicMqfTqZJuOB‹WJœ\P£YL¬ZL¥N=¦E4§<,±7(Â8-Ñ80Ü41Ý1-ß6/Þ7.Þ7.Þ7.Þ7.Û7+Ø6)×7)Õ8)Ô8)Ò9)Ò9)Ò9+Ò9+Ô8+Í;,½;+¶>-®9(©1 «2!·9*ÀÔH9Â=,·2#ÝPFØJ@ÔF<ÔD;ÚG?ÞG@àC>à<:à74æ87ì::ì::ç77â64à93Ü=7ÙF>ÏB9Ä:/¼4(·1&¹5)¿;/Ã?3Ã:0É<3Ò?7Ú?:â=;ç;9ì89í9:ç7:å8:å8:å99å97å97å95å95à40á51ä65å76æ89ç9:ç9:ç9;ë;>æ9;ß99Ü=:ÖA=ÍB;ÁA6·?1©:)£<+ =*›<(™:&–:%—8&‘8&A0‹<-‡/#‘/&¼LJämoçloÍVZ½LNµNOªQM¢UO›XO—]R•aTŠjSWZ/:M7FTa)~ŽP›°oŸ¼yœ½x’µs~ah€L\mCYdBT]BHP9?D0:=,@C2<@1:>0]sBgƒHpKo“Kl’Gj’Ii“KgJlPm‘So“Sl“Pm’Mk“Jm–Jm˜IqœLqžMrŸNr¡Pt£Rv§UyªYzª^y¦cm™ZbŽOWN?WN?WN?WN?WN?WN?WN?WN?XO@YPAYPA[RC\SD]TE^UF_VGd[JcZIcYMcYOf[Uj_]nbdpdhreltgpvirvirsfmm`gg[_bXY^[VZZRYVOWTKXTIXTH\VH^WGcZKcZIf[Ig\Hi]Gj^Fk_Gh`IcbMngTv\MSFšVM«VO°RJ·QE¯H9¬C0¬=,±9)¾8,Ë80Õ62Ù40Ý6.Ü8.Ü8.Ü8.Û7-Ú8-Ù7,×7+×7+Õ7+Õ7+Õ7+Ô8+Ô8+Ô8+Î:,¾<.¶>.®9(¦1 §2 ²:)¹>.¾<.Æ:-Ç4*Ë4)Ò;0ÜE:áOBßQCÝOCÛF?Ø@;Ó<5Ò;4Ö=7Ú=8Ü86Ý33ç77ë78î79ë78ç77å97â=9ÛB:ÊA7¿?4¸:,±6'¯5&²8)¸=-¿@1ÅA4Í@6×@7ß=8ã:7é77ï56ñ7:é6:ç6<ç7:æ89æ87å95å95ã:5â92ã:3ã:5ä;6ä;8ä;8å99å99ä:;ã;;ß<=Ù?=ÐA;Ä?6·=2¬;-¥;+ =*œ=+—<)–;(’:&“8%Œ:%€9'€8)‰5*<5¿QP×eeÑ^a·MM¬NL¤TMYP˜\Q—^S—^S˜_VŒfQ`_/Sg*^r3zO™¯n¥¾|™²pˆ bj‚HauBTe;JX7FP7?H59?158-:^tEgƒHqMp”Ln’Hk”Hk“Lh‘Km‘Qn’Tm”Sm”Qk“Lk”Hl—Hm˜HpJpJp Ls¢Qu¦Tx©Xx©Xx¨^m—Xb‹QY‚H]TE]TE]TE]TE]TE]TE]TE]TE[RC\SD]TE^UF_VG`WHaXIaXGe]Je]Hd[Jd[Le[Qf[Uh]Yh][i]]j^^k__k__i^\f[YbWS_VQZVMWTKUQHRNCQMBSOCWQCXRB^WG^WEaYFc[Fg\Hi^Hk`JhbLbaMngUy_PˆXN¢[U±VQ²IE¸E@¹@7¸>1·;/¸8+¼8+Ã9,É;/Ñ:/Ù8.Û7-Û7-Û9.Ú8-Ù7,Ù7,×7+×7+Õ7+Õ7+Ô8+Ô8+Ô8+Ò9+Í;,À>0¶>.­:(£2 £3ª:&³>,¹>.Ä?0Ä8+Å2(È4*Ð<0ØF9ÜM?âNDÙ:6Ø43Ô20Ö42Û97á=<æ<<é;<í9<î5:ë27é26è58å99á<:Ù@:¾8-µ:+±6'®4%­5%°8(µ<+»=.ÈD5ÏC6ÖB8Ü=7â94è64í55ï79ê69é69é69ç77ç77æ95å95å:3ã:3ä;4ä;6ã<6ã;8â:9á99Þ88Ý9:Ü<<Ú@>ÓB=È?9¹:1­7+¥7(¡;,<+™<+”;)“:(9&7%Š9&z6#y6%ˆ9, F=¹SOÀWT¸PO«IF¢MHœSL™YP—^S—aW—aW˜_V‹ePsrFzV“¦n¤¹€«À‡ž³{|[[oaXIaXIaXIaXIaXIaXIaXIaXI_VG`WH`WHaXIbYJcZKd[Ld[Je]Hf^Gf^Ig_Lg^Of\Pf\Rf\Sh]Wh]Wh]Wh^Ug]Te[QdZPc[N]YMZVJVRFRNBPL@PM>TN@UO?WQAYTA[VC]XDaZGd]Jf_LfaMdcQleUv\OŠ[Q©b\¸ZX¶FD¹<:Ã<8Æ;6Ä:0Â8-½8)¼:*¾?.Ç?/Ó9-Ù7,Ú8-Ù9-Ú8-Ø8,Ø8,Õ7+Õ7+Ô8+Ô8+Ô8+Ô8+Ô8+Ò9+Í;,Á?1¶>.¬9'¢3 3¢8"¬=)µ@.¼?-¿:+Ã7*Å5*Ë7+Î:.Îî7<ì38é06æ25å58á77Ú65Î61·5(¯7'®6&¬7&¬7&®9(²:)µ:*ÃA1ÊB4ÔA7Ü?8â;5æ95ë76î87í68ë78ë78ê86ê86è94ç:4æ;4â92á:2ß:4à;7Þ:8Ü:8Û97Ù99Ö<:Õ@<ÒC=ÊA;»;2¯6+¤6'ž7(œ;*˜;)”;)’;(:&8$Œ7#‡9%€=*v5#5'™E:ªPH¬MG©LG¦QLPJ˜UL”ZO”^R•aV•aV—aWgT‰…_™©x­½Ž¦¸ˆ¡ts†YN`8/A->3B%:F.=F3;A3:=2:=4<=599-?@2<>39<1<@29B/?L2PbNK:NK:NK:PMTQ@VS@XWC[ZF]\H^]Kb`Qf^QmWJ†[R¬ic¾c`ÁMMÈBCÐ;=Ô89Ó84Ì70Á9+º=)µC+¼B+Î;+×7)Ø8*×:+Ù9+Ö9*Ö9*Ô8)Ô8)Ô8)Ô8)Ò9)Ò9)Ò9)Ò9)Í;,Á?1¶>0«:(¡6"š4›7 £=&¯B-³;*º;,Â:,Ç9-Ë8.Î:0Ð<0Ù:4é9<ì4<æ39ã28â38á48â38â25é6<é49ç4:ç7:ã9<Û76Ð21À0(´6(­:(­:(«:(«:(«:(¬9&¯7&¸:+Á;/Î>3Ø?7à=8ä;8è96ì87î66î66î66í74ê84è:3ç:3ä<3á:2ß;2ß<5Ü=7Û=:Ù><×=;Ô>=Ï@<ËB<ÅB:¹=5­7-£5(ž7(š:*–;)“<)‘;*:(Š9&‰8%ˆ7$ƒ8%ƒ@-u4"{3%“G:¤QI¡NFžNG¡WN˜UL’XLZN\N]R”`U—aWhW‰f˜¥z©€Žj]kHDS42@&$2-:&0;*5=.9?3?1;=28;0;?18A.>K1PbÜ87Ô70Ç;.¼?+±C*µA(Ê;*Ô7(Õ8)Õ9*Ö9*Õ9*Õ9*Ô8)Ô8)Ò9)Ò9)Ò9)Ò9)Ò9)Ò9)Í;,Á?1µ=/«<)¢9$™6•5›;"§A*²B.¹@/¿;,Ã7*Å2(Ë4+Ò;0ß=8ê5:î3<ë6=é8>ç:>ä;>ã:=â9<ß58á7:â9>á=>Û=>Ñ96Ã2/¶0'¯9+«>*«>*©>*ª=)©<(©:'«8%¯6%¹7)Å;0Ð=3Ù<5ß<7ä;8è;7î87ï75ï75î85ë:4é;4ç<4ä=4â>5à?7ÞA:ÚA;ÙA>ÕA?Ñ@=ÍB?Ã?:»@8³=3ª8-¡5(›5'˜8(•<*‘<(<)Š<(ˆ:&†9'„7%ƒ6$6%}:)t3!~9*—OA£YNœRG•OE˜VJ•YN[MŽZMŒ[MŽ\Q“_T™`W‘gW~xXyƒ^r|ZU`B;E,/;%0;*0<.3=24<16<2?1:<17:/:>07@-=J0Oa;bxIk‡Lu”Qu™Qt˜NqšNršSpšRršQsœPr›Op™Kn™Jp›LsžOv¡Ry¥X{§Zz¨]x¦]qŸWg”O]ŠEX‚B`‡NY€ISzCg^Og^Og^Og^Og^Og^Og^Og^Og^Og^Og^Oh_Ph_Ph_Ph_Pi`OjaPjbOjbOjbOi`Oi`OiaNiaNiaNh`Kh`Kh`Ih`IhaGhaGhaGf_Le^Kb[I\WDWR?PM:LI8IH6IH6GH6GJ9GK:HL;IMì;Aê@CæAEàBCÜ@AÙ??Í12Ð66Ó:<Ñ=;É;9¾71µ4.­4)ª<-¥>+¥>+¥@,¥>+¤>(¦;'©:'ª7%²7'¼8+Å8.Ì70Ô94Ü=9æ>;é:7ì95ì95ë:4é;4è;4å=4â>4àB7ÝC9ÚC<ÕB;ÏA=Ê?<Ç=;¿>9±<3©:/¢8+œ6(˜7'”8)‘:):(‹=)‰<*‡<)ƒ:'‚9(€7&6%}6$x3#x5%…B2˜UEWK”PCPD•ZL“YMZN\Q\Q’[T•\U˜[VŽbUkbEV`=JS4=G,6?*2=,4>35?66=68?8=B;CF=EG/;9*78*=>0:<17:/:>06?,=J0N`:awHk‡Lu”Qu™Qt˜Nr›OršSpšPq›OrNqœMp›LošKrNu¡Ty¥X«`~©az¥]qœUf‘L_‰G]‡E^ˆIb‰PY€ISzCh_Ph_Ph_Ph_Ph_Ph_Ph_Ph_Pg^Oh_Ph_Ph_Ph_Ph_Pi`Qi`QmdUlcTjaRi`Qh_Pg^Og^Mh`MiaNiaLiaLiaLh`Ih`IhaGh`IgaKf_Le^Kb[H\WDUR?PMSQDSPAXLÂYSÙROàDEà::Ü75Õ;3Ê>/º=)µ8"É:)Ï8'Ð9(Ò;*Ò;*Ò;*Ò;*Ò;*Ñ:)Ñ:)Ñ:)Ñ:)Ñ:)Ñ:)Ñ:)Í;,Á;0¶:.­<,§>+™9#3“7Ÿ?'£9#°;)À>0Æ<1Ì8.Ð7/Ù<5ã?=ì=Bî?DéCEâDCØ@?Ê;7À50»1.¹/,¼51¾:6»<6³:2ª8.¤8,¡:+¡=-Ÿ>+ ?,¡@-¡@-¡A+£>*¦=*©;*­:(²7(¹5)¿5+É90Ô?9àC>ä=7è;5è;5ç<4å<5ä=4á>5Þ@5ÜD9ØD:ÒC;ÊA9Ä?:¼;6¸85°93¢7-™8(•5'“6'‘:)<*‹:)…8&ˆ=*…<+ƒ<*€<)~:'|8%{6&{6&y1#€8*ŒG8–SC’PB‹L=RE™_S‘WL’YN”[R–]T–]V—\V–YTŒ^QaX;EM(6@8A&>G26BE*;:&78(=>09;069.:>06?,F7GK=IK=AE4KJ6\Q;aE/ƒJ9Àj]Üg`ãUSäFEåA@àA=Õ>5É=0Æ=-Æ4%Ë5&Ì6'Í7(Í7(Î8)Ñ;,Ó=.Ò<-Ò<-Ò<-Ò<-Ñ;,Ñ;,Ñ;,Î<-»2(¶7.±;/¨:)š7"”5•7œ9"®A-³;+º6)Á4*Í6/×<7âC?êHEèDEèEHÝCCÉ:6»61´80®8.©4+«9/©9.¤8. 8-›9,–:+“<+’<+–=+˜=*™>+š?,›@-A, A-£@-¢;*¥:(«7(°6)¶6+¾8-Ä;3Ì<4Ú=6à=6â?8âA7âA9ÞB6Ú@6×@5ØH=ÒE;ÇA8»;2²5/ª3-¦1*Ÿ2+™9-’;*‘9+:*‹:)ˆ;)‡;+…<+€9'}8(|9(|9(|9({8'y6&x3$w- ‹A4—OC“MAŽL@‘QE“UJŽRG˜\R˜\R‘UMTL—ZU•XS”WT“gZ]T5IQ*AK(BK,>H/7@+2=-4?14<1HPCZ^PW[JMO:DF.AA'==%:;)>?1;=2:=2;?14=*;H.PbF7>F7=E6@F8>E5>F1HL5MI0U?'Q:¼sbËcXà_ZëUTçGGâ@>àA=Ø?9Î:0Í9+Î=,Ï=.Ï>-Ï;-Î;+Í9+Í:*Î:,Ð:+Ð:,Ð:+Ð:,Ð:+Ð:,Í;.É?5ÅB:¼B7®=/Ÿ6#–1–1›2¨5#´6(Ã;/ÑA8ÞE?æIDéJFêKHÞCAÛEDÐB>¼<3¯9/©=0¥?1Ÿ=0Ÿ?1œ>2—>0”>/=/Š>.‡@.ˆ?,Ž=*‘;*’<+“=,”?+•>+—>,™>,Ÿ@.¡=-¤:,¨8,¬8+±8-¶:0¼9/Ê<2Ð<2Ó?5ÕA7×C9ÖC9ÔD9ÑE8ÊB6ÃA4¹=3°:0©6/¤5.Ÿ4,™7,’:.Œ=,Š;,ˆ;+†:*„;*ƒ<*<,~;*|;){9)y:)x9(w8'u6'w4$€4'D7˜NC‘K?ŒJ>QD’TIRG“SJ˜XO˜UO—VPœ]X”WRŽSOŠcT]W5Xc9_jBZfBIT66C)4@*0:<19<1<@25>+;H.PbMKD63Å?3ÅA4ÃA3ÁA4¶;,²:,ª8-£7+ž6+›6,˜7.”:/;/ˆ<,‡;-„;,‚:+€;+€;+<,};+z;*z;,w9*v8)u7(t6)v4&ˆ;1”F<–NBŽJ=ˆHEI0?C(=@#:<$89';<.8:/9<1=A36?,MK4Ñ>4Ò>4Ò>4Ó?5Ó?5Ó?5Ó>7Ó?;ÑB>ËD>ÆF=ÂF<ÃI>ÇM@ÎPDÙSHÝPGâMGäIEäGBâC?àA=ÛB=ÕFBÉD?º?7«=0Ÿ>.šC0•G3”I6F4ŒE3ˆC3…B1€A0}@.zA.|?-‚:,†8,…9+†:,†:,‡;-‡;+ˆ;+‰:+‹:)Ž8)8*•9,™;/=/¢<0ª:/­8.¯9/°:.°:.°:,¯9+®8*¨7)¥7(ž6)›6*•7+’8-‘9/Ž<0ˆ<.…<-ƒ;,9*:*~9*}:*};+|:,z;,y;,w9*s8*q6(r7)u5)ŒD8’H=‘K?ŠH:‡I<‹OD“TK—TL–QL›TP˜QO”SO–\X_Xh^—~j””p…’fu‚WYh?CR+?O*P`B)=A(;='78(:;-79.9<1=A37@-NKB1=I1?G/LG1S>+g=-•ZL­_Sœ>4ž3+¶?9ØXUóigödeëRUæJNèNPÙIAÓF<Í@6Ë>4Î@6ÒD:ÕG=×G>ÚJAÚJAÝJBÝJBÞKCÞKCàKDàKEëSRèTTãSRÜROØSLØSLÛULàUNàLHáIFãEBâC@äB@âC@äEBàFDÙJFÊE@¹>7¬=2¡?2˜B1’E3G4ŒE3ˆC3‡B3ƒ@0?1~?0z?/|>/€:.ƒ9.ƒ9.ƒ9.ƒ;-ƒ;-ƒ;-ƒ;-9*‚9*…9+‡:*‰:+;-<.“;/›;/ž9-Ÿ9- :,¡9,¢8+¢8*¢8*Ÿ8)œ8)˜8(”8)9*Œ:,‰:-‡;-„:-‚:,9+€8*}8)}7+|8+{9+z8,y9-x:-v8+q5*o5)q7+t9+ŒH;I<‰I=„I;…K?ŒRF“WM˜XO˜QMœUQ˜RP“VQ’`YˆbWƒg[†zdnrQZi@JY0AR(IZ0Wi?dvNj|VXiEL[:?L.:D)C-B47@-;H.L^8_uFi…Jt“Pt˜Pt˜Nr›Os›TpœQnMmžLp¡Pw¨Y|ªaz¨`rXi“QZƒA\„EaˆIeŒMgŽMgŽKhJfŠLc†PY{IRtBi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`QkbSkbSkbSkbSkbSkbSkbSkaUlbYlbYlbYlbVlbVlcRlcRldQldQldQlcRlcTlbVlbXlbXlbXocUnbRkbQlcRlcRkbQg`Pd]M^WGYSCSM?MJ;KH9GE6EB3?B/;H.?H-OC-a=-ƒE:«XR´NJž,+²:9¹=;ÓSRòpnþvvñehëX^ð^_ãUQÚPFÔG@ÐC:ÑD=ÔG>ÖGAÖG?ÙHCÚJBÜHDÝJCÞJFÞKDàKGàKGâHHáGIÜHHÙGGÖHD×HDØGBÛFBàBAäABæBAèBBçCBäB@ßA>ÛA?ÛJGÊC?¹<6®>3¢@3˜A0A0C3ŠA2ˆ@1‡?1…=1‚<0€<1=1=1;1;1ƒ:3;1;1€.™9)–9(“:*:+Š;,‡;+„;,‚:+‚:,9+7)~6({5){5){5)z6)x6*x8,w9,s8*p4)o5)r:-v<0‹M@‰K<„J<‚M=…QC‹VH’XM—WN“NI™TO—VR•\Ue\{^PfVF`^GEO->N)?O(J\2_rEk~QexKXj@M_7@Q-6E&7D*=F1=D4:>07;-8:,:;-68-8;0>B47@-9F,I[5[qBeFr‘Ns—Os—Mr›Os›TpœQmœLo Os¤Ux¨\z¨`s [i“Q`ŠHYB^†GeŒMgŽMfJeGgŒGhŒLa„NXzHQsAi`Qi`Qi`Qi`Qi`Qi`Qi`Qi`QkbSkbSkbSkbSkbSkbSkbSkbSlbXlbVlbVlcRlcRldOldOldMldMldMldOldQlcRlcTlbVlbVocUmaSkbSlcTmdUlcTi`Qf_Ob[K^WGXQARLÐB>Í@9ÒC?ÒC=ÔC@ÕD?×CAØD@ÙECÚDCÝADÝADÞDFÝGHßIHàJIãIIåGHçACêADìBEìBEçAAâ@>Û=:Õ=:ÚFFÉ=<¹83°;2¦@4˜?1‘>0@1ŠG]/AV-7H$1@!6B*=F5PK8MH5ID1DC.@F*DD([B,ˆTG¯\X«>A¬/3ÎINÆ?EÀ;>»;<ÄFGØZ[ãefÛY[ÌGHÑJGÐEBÍB?ÐB>ÔFBÔFBÐB>É>7ÏD=ÏD=ÒD@ÔEAÖEBÙECÚDEÝDFÞ?Cß@DÞBEßEEáGGàFFàBCá>?èBDé@Cè>Aç=>ä>>ãA?áC@ßECÖBBÅ98¶50°;4¦?6š>3=/?2ˆ)=C5ã?>â@=â@=ÞC?ÓB?Å>:¶93ª70Ÿ:0—=2Ž>3†>2ƒ?2?3=2;3„93†93ˆ81ˆ92…;0„<.„<.ƒ;-;/€:.€:.€:.~:-~:-~:-~:-};/};/};/};/}90}90~80~8.€7.€7.€7.~8,€8,~8,}9,|8-{9-z8,x8,x8,x8.x8.w7-v8-v6,t6+s5*q5+m1'r6,n4)m3(o6+m4)q8-I=…SH…SJ†RGˆRH‹PHQJ”QK•RL“TMTK‰[N‚cQo_HYU:MV7O_;j~YbxQYoHUjCRg@Mb;IY5CR17D&4>#2:#6;'<>0@B5@@6<>358-39-4:.7:/9=/;?.=B,%Q?)kP=XG„NBˆE=“D?±WV¸TT»QQÀPOÀNMÁMMÂLJÃKJÐTTÈHGÂ=>Ä=:ÐB@ÓEAÏB;Ç>4ÊD9ÉE9ËF=ÍG>ÔFBØDDÜAEÝAEáBFáCDáCDâDEâDCáFDáFDáFDàEAßD@àB?ßA>àA=àA=àA=ÞC?ÔE?ÈC<º>6¬:0 90”:/Š<0‚<0€A2~@3~>4<3ƒ:3†91ˆ81‰90‡;.…<-„;,„;,ƒ;-‚:,‚:,‚:,9-9-9-9-~:/~:/~:/~:/}90}90}90}90}90}90|90|90|90z:0z:0y9/y9/y9/w9.w9.w8/w8/t8.s7-r6,r6,p6+p6+k1&q7,m4)l3(o6+l3(p7,~H>„RI…SLˆQJ‹PJQL”PM•QN”SOŠOG…SH€[K{ePsiPhkLfqQgxT^tMXnGPf?La:K_:K\:GV7CP4>2;=04:03;05;16<0:A,>D*Q[9^mDkRpŒRp“Sq™RsSsžVxŸ^|¢exžak‘T`†I]ƒF]ƒF\‚E`†Ia‡Jc‰Le‹NdŠMbˆK`†I^„I]LRtBIk9i`Qi`Qi`QjaRjaRkbSkbSkbSjaRjaRjaRjaRjaRjaRjaRjaRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTnbTqdTo_Pm]Pm_RqeYog\ldYhbVfbWpl`{xi~{jyizubpiVe`JTT(MB.S@/U8(]7*l=3n70u91~;5‡@:’IB›PJ¥XP­ZR»^YºSN·GE¼B?ÈDBÑFCÓD@Ï@:ÐA;ÐC<ÒE>ÔG@ÖGCÚFFÛEFÞDFßCDßCDßCDßCDàDEßEEßECßECÞDBÞDBÜD?ÛC>ÜC=ÜC=ÜC=ÛC>ÖE@ÎE?ÃB<³>5¢:1”8-ˆ9,ƒ;-‚@2@1~>2=1ƒ:1†91‡81ˆ:0‡;.„;,„;,„;,‚:,‚:,€:.€:.9-9-~:/~:/~:/~:/~:/~:/}90}90}90}90|90{8/{8/{8/{;1{;1z:0y;0x:/x:/x:/x:/t8.t8.s7-s7-r6,q5+o5*o5*j1&o6+m4)k2'l6*i3'm7+}G=‡PI‡PI‹PJŽQL‘RM’SN”UP‘VPŒWO‡[P~^OtbNoiQorUlwYfwUQeBK_:EY6DU3EV6GV9GT8ER8?I0*7;*:<.<>0;=/9;.6<25=26<26<0:0=@-=C)MW5Zi@f|MlˆNn‘Qq™RuŸUtŸWz¡`w`n”Wc‰L\‚E\‚E\‚EZ€C_…Ha‡JbˆKdŠMc‰La‡J_…H]ƒH[}JPr@Gi7i`Qi`Qi`QjaRjaRkbSkbSkbSjaRjaRjaRjaRjaRjaRjaRjaRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTnbTrdWoaTm_Rk_SkaWlcZle[jf]jf]xtiˆ„x‘•’Œ~‰‚r}zg`cNOT>DG2FE1HC0F=,L<,VC4P9+R6*V4*Y5)\6+a9/e=1m=1ŠKBSJ®UO¶NK¼FDÆABÒDCØFFÔ@>ÕA?ÖB>ÖE@ÙECÚFDÛEDÝEDÞDDßCDßCDÞDDÞDDÝEDÝEBÞFCÛFBÚEAÙD>ØE>×D<×D<ÙD=ØE>ÔD<ÓF?ÉF>ºA8§;1˜8,Œ9+…<-ƒ@0@1~?0=/ƒ:1„:/‡9/ˆ:.„:-„;,„;,ƒ:+‚:,‚:,9-9-9-9-~:/~:/~:/~:/~:/~:/}90|90}90{8/{8/{8/{8/x8.{;1y;0y;0y;0x:/x:/x:/v:/s7-s7-s7-r6,q5+o5*o5*m4)j1&o6+l3(h2&k5)h2&l6*|F<ŠOGŒOJPKRMSN‘VPWPŒZQ‰]R…aUy_PiZGd_IdhO\fKN]@EU8AQ4=M0G2:A/9=,9=.9=.8<-7;-7=36=56;46<2:<1;=/bxIj†Ln‘Qs›Tw¡Wx¢Z{¢ar˜[e‹N\‚EZ€C\‚E\‚EZ€C_…H`†Ia‡JbˆKa‡J`†I^„G]ƒHY{HNp>Eg5haQhaQhaQibRibRjcSjcSjcSibRibRibRibRibRibRibRibRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTlcTrfXth\sg[mcYjaXle]snhzwp~w† ”¨¥œ«§œ¨¤™£‘™–‡z{kcfSOR?GJ7EH5BE2BE2EH5KL0A9,A7+@6*F4(S5*qB8ŒPHŸPK¯IG¿GIÌEIÓBEÖ@BÙ@BÚBAÛCBÚEAÚEAÜDAÜDAÞDDÞDFÞDFÞDFÞDDÝEDÝEDÚDCÚFB×FAÖF>ÔE=ÔE=ÓF=ÔE=ÕF>ÔA:ÓC;ÎE=ÁB9®>3ž9-‘;.Š.€=-;/„:-†:-‡;.„:-ƒ;-‚:,‚:,‚:,9+9-9-~:/~:/~:/~:/}:1}:1}:1}:1|91z:1|91y90y90x8/x8/v7.y:1y:1x90v:0v:0u9/u9/t:/r7/q6.q6.p5-o4,n3+n3+m4+j1(m7-j4*h2(j4*f2'j6+}D;NGNHQJTLUOŽWPŠYRƒ[Q{YMv\OkZJ]UBYXDY^HOYA?K3:H/7E.4B+5A+8D.=I3CL7EN9BK6?H5.5<,4:,5<45<56;56;49;0:-;@)GP1Ra:`vGi…Ko’RuVy£Yy£[xŸ`n‘W`ƒIZ}C[~D^G^G]€F`ƒIa„Jb…Kb…Ka„J`ƒI_‚H^IW|ILp@Bf6haQhaQhaQibRibRjcSjcSjcSibRibRibRibRibRibRibRibRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTlcTkaUndZpf\lcZkd\rmg„|‘Œ§£ µ±®ÄÁ¼ÉÆÁÉľÅÀºÀ¹±¹²¨¤œˆ‚rfcTPQ?FI8>E3;D1:F28E38E38C2:B34(P:/e?6€EA¡PO¿X[ÊQVÊCIÕFJ×EFÚFFÛEDÝEBÞDBÝD?ÞCAÞDDÞDFÞDFÞDFÜDCÜDCÜDCÚDCÙEA×FAÕF@ÓF=ÒE<ÐF<ÑG=ÔE=Ô?8Õ@9ÐC:ÆC9¶A7¥=0–=/Œ=.†>/‚?/>.€=-<-ƒ;-„:-…;.‚:,‚:,‚:,‚:,9+:+9-~8,~:/~:/~:/~:/}:1}:1}:1}:1z:1z:1y90y90x8/v7.v7.t8.w8/u9/u9/s9.t8.s9.r8-r8-q6.q6.p5-o4,n3+m4+l3*j4*h2(l6,i3)f2'h4)e1&i5*{B9ŽMG’MH‘PJTLVO‡XNYO|\Qs\Nk[L`WFVSBPSBJQ?@I64@,3<+2;*09(09(2;*5>-9B1G4:F2:C25@/3>-1<,3:33954954928919;.;>-;@*CL/O^7]sDi„Mp“SwŸYy£Yw¡Yq˜Yf‰OZ}CX{A\E]€F]€F^G`ƒI`ƒI`ƒI`ƒI`ƒI_‚H^G]€JV{HJn@Ae7haQhaQhaQibRibRjcSjcSjcSibRibRibRibRibRibRibRibRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTlbVj`VjaXkdZkg^upjˆ…€Ÿžš°°®ÃÂÀÓÒÐâáßçæäçãàãÞÚÞÖÓÙÎÈμ²¸¥——‡zym]_YIKL:@E1;D/>J6=H7=F5;C4;>5:;3983880==3C<2N71a84ˆHH¯]_Å`dÊWZÍQSÓNO×MKÛKJÞHGáFDãDAâBBßCDÞDFÞDFÝCEÝCEÜBDÜBBÛCBÚDCØD@ÕD?ÓF?ÒE<ÐF<ÐG=ÔE=Ù@:Ù@:ÑB:ÈC:¼C:¬@4™;/Œ9+‰=/ƒ>.>-€=,<,ƒ;,ƒ;,„<-‚:,‚:,‚:,9+9-9-~8.}9.~:/~:/}:1}:1}:1}:1}:1}:1z:1y:1x90x90w8/t8.s7-r8-t8.s9.r8-q8-r8-p7,p7,p7,o6-o6-n5,n5,m4+l3*k2)i3)g1'k7,h4)e1&h4)b0%f4)zA8MG’MH‘PJŽULˆXNYOxZOr\Nk^N^WGRPAKN=CJ:9B12:+08)17+17-06,/5+/5)08+2:+4<-9D4;F5=H7-.800621622717829;0:<.:?)?H+KY5[qChƒLq“Vwž[w¡YsœVgP^IUx@WzB[~F[~F[~F]€H_‚J_‚J_‚J_‚J^I^I]€H]€JUvIJk@@a6haQhaQhaQibRibRjcSjcSjcSibRibRibRibRibRibRibRibRkbSkbSkbSkbSkbSkbSkbSkbSlcTlcTlcTlcTlcTlcTlcTlbVpg^ng_lgatqj‡„¡ œ¼¼ºÎÐÏÏÏÏàààòòòúøùû÷ö÷óðñìéðâßèÐÆÝÁµÁ«¢‘}ub^\GKM7CH2AI2AI4@G5BD7AA7B=9C97?:69<5>?7B71J.+d66QR³giÆnmÀ\\ÇZWÐVS×QNÜLKâHHæCDåBCßCFÝDFÝDFÝCEÝCEÜBDÜBBÜBBÜDCÙCB×C?ÓD>ÒE>ÐF<ÐF<ÔE=ÜC=ÛA9ÒB:ÊD;¿E:°A6œ:-‹5&ŠD69A208+/7*6<247058157247025.06,08-19,6A3:E5=J9>K9-,6..400511606718:/:<.:?+WzB[~FY|DY|D\G_‚J_‚J^I^I^I]€H]€H]LStIHhA?]7icSicSicSicSicSicSicSicSicSicSicSicSicSicSicSjcSkbSkbSkbSlcTlcTmdUmdUmdUmdUmdUmdUmdUmdUmdUmdUldWibZgd]vsn“’Ž¯¯­ÄÆÅÚÜÛêîïóôöö÷ùüüþÿÿÿÿÿýÿûúü÷ôýòì÷áÔòØÇàʵƶŸª ‡ˆ„ibbFEH-DH/CG0FE1GD5F<3C60F42H:9>=9>?:B:7I75cGF’jjÅ“’è­©Ò‹‡ÇtnÀ]XÆSPÕONßJLçFKéFKßEGßIKÚDFÔ;>Ø>@áGIàDGÖ:=Ú@@Ú@@ÙA@ÖB>ÔC>ÑB<ÐA;ÑA9ÞC>ÛA9Ó@9ÊA9¾B8°@5Ÿ:.8*Œ=0‡>/ƒ>.>-€=,<+=*<,:+9-9-~8,~8.|8-|8-|8-|90|90|90|90z:1z:1z:1z:1y=5w<4w;3u:2t91q8/p7.p7.o6-m7-m7-l8-m7-l8-m7-m7-i2+m6/p92o81k4-g2*g2*h3+e0(i7.d2)]-#`0&_/%b2(s>6ŒOJPKˆQJRJ}YMv_QfYITN>DE5>E5:C25@04&DR1WlCh‚Rs”]wž_r›Wk”R[~DXyDTu@Tu@WxCZ{F[|GZ{F^JbƒNbƒN^J\}H_€K`L^~MTsJFd@2I:3L95K<9?:7BA?MHE]RPyjg£Ž‹Î²®èÅ¿ÿ×Ñ쳪͂|Àc^ÊVVØRSßHMÚADÖDEÕEEØHHÜJKÛEFÕ<>Ö<>ÛACÙ??Ù??ÙA@×A@ÖB>ÓB=ÒA<Ó@9ÜA<Û@;Ó@9ËB:¿C;±A6 ;1’8-Œ=0‡>/ƒ>.>-€=,<+<,<,:+9-9-~8,}9.|8-|8-|8-|90|90|90|90z:1{;2{;2z;2w<4u<3u:2s:1r90n8.o6-m7-m7-l8-l8-l8-l8-j8-l8-l8-k6.n70o81n91l7/i4,g2*e3*c1(d4*_/%^.$b2(^.$`0&p>5JE‡RL‡XR~XOrVKdRDQJ:>?/:A16A05@03>04<14<15;17:379477577557246116//6./7,.9+1<.4A08E49H58G44E24B1.8/.5..3--2+23+46+8:-9=,7?(DQ3WlEh‚Ut•`wbp˜YgPY|DWxCTu@Tu@VwBYzEYzEYzE[|G_€K_€K\}H[|G^J^J^{MSnKF_A9R4icSicSicSicSicSicSicSicSicSicSicSicSicSicSicSicSkbSkbSkbSlcTlcTmdUmdUmdUmdUmdUmdUmdUmdUneVneVlfZed_y{x—™˜²¶·ÍÑÒäéìôùüúÿÿûÿÿüÿÿýþÿþþþÿþüÿÿûÿÿúÿÿôþüçúùÝïðÑáåÄÒØ´¼ÄŸ ¨ƒ‡‘l`gEQX7DG,DC.JD4LD7KA8I>:C;9SJKia_wvœ’¾³¯ÙÎÈêÜÓþèÝÿóéÿäÛð©£ÃecµBEÇDIÚRVÛUTÑMKÊDAÍCAÔFE×EFØDDÙCDÖ=?×>@Ø@?Ö@?ÖB@ÓB?ÓB=ÔA:Ù@:Ù@:ÒB:ËE<ÀD<²B7¡<2“9.Ž<0‰=0ƒ>/>.=-~<,€=-€=-9-9-~:/}9.}9.|8-{8/{8/}:1}:1{;2{;2{;2{;2z;4x<4t;2q;1r90o9/n8.l8-l6,k7,l8-j8-j8-j8-j8-i9-j8-j8-n91m80m80m80m80i7.f4+c1(d2)a1']-#_0&c4*\-#_0&sD<}PJVP~YQpTI^J?OC7?<-46(2;*0;+1<.2=/4<14<15;17:379479668357257227007/08-.9+0;-2?.6C27E48G48G49F54>33:2/4-,2(/0(13(57*6:)6>'DQ5YmJk„Zw—fwœfl“Z_‡KWxCWuCTr@Tr@VtBXvDYwEYwEZxF]{I_}K]{I]{I_}K^|JZwKPgJAW@3I2icSicSicSicSicSicSicSicSicSicSicSicSicSicSicSicSjcSkbSkbSlcTlcTmdUmdUmdUmdUmdUmdUneVneVneVneVmg[jkfƒ‡ˆ£§¨¹¾ÁÐÕØåíïóûýõýÿûÿÿûÿÿüÿÿüþûýþùþýøÿþ÷ÿÿóøýæôýÞî÷ØæòÎÝéÃÎÚ´¶Á™¡«†€‡efmLMQ6FH0HJ5KI:HD9D@7OGDj`_‹€¤š™·¯¬ËÆÂÞÛÔêæÝúñèÿûñÿ÷íÿÝÕû¶±åŽÊcd°@?ÃPKÉTMÉPHÃF@ÈGBÔMJÖKHÐ@?Ò>>Ó??Õ?>ÕA?ÕA?ÓB?ÓB=ÓB=Ö>9Õ@:ÒC=ÌE?ÀE>²A9¢=5•;2Ž<1‰=0ƒ>/>.=/~<,€=-€=-9-9-~:/}9.}9.|8-{8/{8/~;2~;2|<3{;2{;2{;2z;4x<4r90o9/o9/m9.l8-k7,j6+h6+i7,i7,i7,h8,h8,h8,h8,h8,m;2l7/j5-i7.j8/j8/f4+a1'e5+a2(].$a2(b3)Y* a2(yNE\VvWRiNGWC:I<3@:.:;-8<.08)/:*3;.4Ð@?ÑA@ÒC?ÑC?ÑC?ÒC=Ó?;ÒA<ÐE@ÉE@½C>¯@9 >5•=3Ž<1‰<2ƒ=1=0=1~<.=/=/~:/~:/~:/}9.|90{8/{8/{8/|<3|<3|<3{;2z;4y:3y:3w;3n70m80l7/l7/k6.h6-h6-h6-i7.h8.h8.g8.g8.g8.g8.h8.k92h6/f4-g5.i70h70e4-b1*c2+b3+_0(]1(]1(V*!b6-{ULtYRaNHN?8A7.=6,;9-9;.9<139-3;.5;/6<06<07:/58-47.69049238139/39/2:/19.19,.9+.9+/:,0;-3>.6C2:E5Qn>Qn>Qn>Qn>Qn>Sp@Sp@WtD[xH]zJ]zJ_|L_|LZwGRlECU?6D7(6)gdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSicSjcSkbSkbSlcTlcTmdUmdUmdUmdUmdUneVneVofWpgXpgXng]lnmz‚…“š «µ·ÄÎÐÜæèí÷ùôþÿõþýöÿüúÿúûÿùûþóøúíõöèñôãôýêôýèôüåóùßòöÛéìÍØ×¹ÅÄ¥±°’ŽregOMP;GK:FM=GOBKQG{{sŸš”ž¸ØÎÌßÓÓçÛÛóëéü÷ôðïêüüôÿÿöÿýóÿùïÿóêÿçÞÿ×ËØ“ƒ¸eS£J:´TF½WIµF;·@8ÈKEÇC>ÊC?ÌB?ÎC@ÎC>ÎC>ÍD>ÍB=ÑB<ÒC?ÎDAÅD?¸A=ª=8ž;5•<4Ž;3‰<2ƒ=3=2=1~<0=1=/~:/~:/~:/}9.|90{8/{8/{8/|<3{;2{;2z:1y:3x92w81u91n70l7/l7/j8/i7.i7.h6-g7-g7-g7-f7-f7-f7-f7-f7-f7-h70h6/g5.g5.g6/h70g6/f5.a2*e6.^2)\0'`4+a5,i=4uSJXG@E>6<5/95,;8/8:/57,36+69.5;/7:/69.69.58-57,36+28,19,28.19,19.19,19,19,.9+.9+.9+/:,0;+3>.6A17B2ex\umt’lf‰_RwKBh9KkVsCZwG]zJ^{K_|L_|LVsCNg@ÉD=ÈC<ÉB<ÑC?ÐE@ÌEAÂC=³=9¦;5œ;5•<6Œ<3‡=4…<5=4<3~<0=1=1~:/~:/~:/}9.|90{8/{8/{8/{;2{;2y:3x92w81v70v70s7/n70j8/j8/j8/j8/h8.h8.h8.g7-f7-f7-f7-d8-d8-d8-f7-g6/h70i81i81h70i81j;3l=5g80k<4b6-a5,oC:xLCtI@nMDC9056.45/8918;247.14+25,58-58-57,46+46+46+46)37)/7(.9)08+.9).9+.9)08)08)19*08)08+/7*08+19,3;.4<-9B1:C0;B0:A1:<.68*24&/3$29'IU?cu[m„gf„bWyTInE?d8Hg;Li;Nk=Nk=Li;Li;Mj
    UrDYvH[xJ]zL^{M\yKQn@G_;6B4+4/#)%gdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSgdSicSjcSjcSjbUlbVlbVmcWmdUmdUmdUleUmfVngWogZnh\oh^mjekormtzƒŠ¥®³ÃÌÑÕßáæîñôüþôýú÷ýùùþ÷úÿôüÿòüÿñüÿîýþðûøïþúñÿùïÿúíÿùéÿòßïàËÝηÁ²›¢—|ubb_NXZL]cWmwn|†}¦¬¢¾ÀµÚÕÏîäâüîîÿôôÿô÷þôõÿùùûúøûýøüÿúøÿõôüñ÷ýñÿÿñÿùèÿôãÿÌ»½p›QD©SFµSH²C:ÀJ@ÄH@ÇG>ÉF>ÈE=ÇD<ÆC;ÆC;ÍG>ÌG>ÇG>¼C;­>5Ÿ:2—:3‘>6Š=5†=4ƒ=5=4€<3;0;1;1~:/~:/~:1}90|90{8/{8/{8/z:1z:1x92w81v70u6/u6/q6.m80k90j8/j8/i9/i9/i9/h8.g7-f7-g7-f7-f7-f7-f7-f7-f5.j81m;4k:3j92j:0m>4oC8l@5oD;d<2c=2zVJ†dZyWMbLA>:13814927<54:0/5+25,9<336+25*24)03(13(25*46+47,.6),7)/7*-8*/7*/7*/7*/7*19,08+08-/7,/7,/7,08-08+7?09B14*00!''heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjdVjdVjdXldYlcZmeZmeXmfVg`NjeRnkXol]he\feasqr‚†Š“–ž¡«³¶ÃÈËØÝàêîïö÷ùùûúüþýþþüÿÿúýþöúýòùüñúýòûþóùúòúúòùùíüúëþüçù÷ÞéåÊÕÔ¶º¹›˜˜|qtY_dMbkXr}l„‚‘›´¹²ËÌÇãâÞòîë÷óòû÷öýùøüø÷ÿþüþþüþþüýÿúýÿúýÿúýÿúýÿúúü÷ÿÿúÿûöÿêåا £`X›D=µNE¿MCÂF<ÄD9ÊE<ÎI@ÎKAËH@ÇG<ÆG8ÃH8½J8³H8¦E5šB4‘B5‹C5†B5„B6‚@4‚>3‚<2„:1†91†9191~:1|91{80z7/z7/w7.v6-w7.w7.w8/w8/v7.u6-q5+n3+l7/i81i81h70h70g6/g6/g6/f5.g6/i70i81h70g6/e4-e3,h3-j5/m80k90j:0i;.i=0kA3gB2jI:dH:v_O~k\ŠxjŒoRJ=79.4:04:039/39/39/28.28.17-17-36-06,25,/5+14+/5+/4-.5-/4-.5-/4-/4-/4-/4-05./4-/4-.3,.3,/4-/4-/6.1;23=26@58B79D67B45@03>-4?.DQ=WeN[kQPbHEX<@T8BW6Ic>Ke>Kf=Kf=JeOj?UpGYtK\vO]wP]wRWqNHb?;O6&1+&+.$),heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjcYkdZlc\md[meZmfVidQjhSmjWjk[gg_lll~„“š¨¯µ¸ÂÄÑÖÙâçêòóõûüþÿþÿÿþÿþýûÿþúÿÿúþÿùûüôøûòöüò÷ýó÷úñøúïøúí÷úéùûåòõÚßâÃÌЯ´¸—‘–vkqUYaI_kUtoŒ˜Š§œ¿Á¼ÓÓÑççåóóñ÷÷õûûùüüúûûùþþüþþüþþüþþüþþüþþüþþüûÿþõÿÿõÿÿþÿÿÿûúÿíêð¿ºÂ~uŸKA¯M@¹K>ÂL@ÅK>ÃE9¼=4¾?6ÃE9ÄF7ÃJ7½L:³J7¦F6™C2‘C6E7…C7‚B8A7>5‚<4ƒ:3†91„93~92}:2z:1z:1y90x8/v7.v7.u6-v7.t8.t8.t8.r6,o5*m4+l7/i81j81h70i70h70g6/g6/e3,e3,g5.h6/j81j81j81k92k60l71k90k;1k;/j>1j@0iD2gH6kP=gRAufSueŒ…s†ƒrKL<69.39/39/39/28.28.28.17-17-17-17-06,06,/5+/5+/5+/4./4./4./4./4./4./4./4.05//4..3-.3-.3-.3-/4./6/.80/:21=34@66B66B66B45B16C1CP>P]IR`IIW@AO6BP7EU:Jb@Jd?Ke@Ke>Ic6I5&1-',0$)-heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjcYkdZlc\md[meZmfVmhUkiTmjWjk[kkcwww‘’—§¬²¿ÆÌÒÜÞìñô÷üÿþÿÿþÿÿÿþÿÿþÿþýûÿþúÿÿúýþøúûóõøïñ÷ëñ÷ëô÷ìõùëöøêõøåõ÷áîîÔÛÛ¿ÉÊ«°±’“–yuy`kpZt{iˆŸ§œ®µ­ÍÏÊÞÞÜïïíøøöûûùþþüþþüýýûþþüþþüþþüþþüþþüþþüþþüýÿþûÿÿûÿÿÿÿÿÿûùÿúôÿ÷íýÑÆØž”L=¥RB©L;§@1·G;ÏYMÏUJ¼@4ÄD7ÆH:ÃK=¹I;ªB7?3—@7“E;‰@9„A9A8?6~>5}=4<4}=4z;4x<4w;3w;3u:2t91t91t91r90r90r90r90o9/n8.l6,k5+l7/j81l71j81k60i70i70h6/g5.g5.f5.g6/h70i81k:3k:3l;4j;3i:0h<1k?2jC4iD2fE2fI7lVAjYGujV†m‘Ž{€mEF658-28.28.28.17-17-17-06,17-17-17-06,06,/5+/5+/5+/4./4./4./4./4./4./4./4./4./4..3--2,-2,.3-/4..5.+5-+6.-9//;12>24@46B47D38E3?L:ER>CQ:;I28F->L3DT9J_@Jb@LdBKc?Ia=G`9F_8G`9RkDXpL]uS^vVZqTPgK=T8.A.&1-',0%*.heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjcYkdZlc\md[meZmfVniVljUlkWlm]pqi€‚ž¡¦¹¾ÄÄËÑÛåçõúýûÿÿüýÿüýÿþüýüûùÿþüÿÿûÿþùûüôõöîîñæéïãçíßíñâðôåñôãñôßòñÜêêÐØؼÇÇ«²±•¡¡‰‘“}“€œž‘ª­¢¶»´ÀÅ¿ÜÜÚééçööôûûùýýûÿÿýÿÿýýýûþþüþþüþþüþþüþþüþþüþþüþþþûûýÿþÿÿþÿ÷òïüóìÿüóÿûíÿôäìñ¹p•P@¢O?¸XJ·M?µE9ÀG<ÁA6ÈE;ÅI?½G=¯@9¡<4š=6–A4e=1f>2hC3iE5fG3cG2cJ6hV@i\IskV…‚oŽzpq_9=,47,28.17-17-17-06,06,06,17-17-17-06,06,/5+/5+/5+.3-.3-.3-.3-.3-.3-.3-.3-.3-.3--2,-2,-2,-2,.3--4-*4,)4,*6,+7-.:.1=14@25A36C2:G5N4DX¿@7ÆC;ÅF?¿D=±>;¦:7ž:8™>;‘=;Š?<„@=}@=xA6s>6r=5r=5r=5p>5o=4n>4m=3l<2k;1j;1i:0i:0j:0n72p62p62m61m61l71i70i70l;4k:3h91e90e90e90e:1d<2fB6cA5cC4dD5dG5dI6bI3_I2^L6eV?jbMrmW„ƒo„‡r[`L3:(28,28.17-17-17-06,06,06,17-17-17-06,06,/5+/5+/5+.3-.3-.3-.3-.3-.3-.3-.3--2,-2,,1+,1+,1+,1+-2,,3,,6.+5-*4+*4++5,.8-0;-2=/2=-5@/6A05A-1=)1=)5A-8F/=O5@T8FY=H\@J]?I^=K^>K`?TgG[pQcvZauZYkSJ]G6G4&4%$-*$),"'*heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjcYkdZlc\md[meZlfVjgTkjUlnYorasvm…„Ÿ¤¨¸¿ÇÖßäí÷ùûÿÿûÿÿûüÿþÿÿÿþÿþýûÿÿûÿÿúüüôóõêëíâãçÙÝãÕÜãÑäéÓçìÕéíÖêìÔëëÓèæÏßÚÄÓθÓκÌƶËøÐÉÁ×ÒÎàÛØêæåðïíóòðùù÷ýýûýýûýýûÿÿýþþüüüúþþüþþüþþüþþüþþüþþüþþüÿýüÿûüÿøùÿþýþÿýùÿýôÿøïÿõ÷ÿöð÷çÿÿíÿîÛͧ”¤kX¢[GªWE­L;¹D:ÀD<ÀE>¼E?´A>ª=:¢:9š;9•=5o?5o?5o@6n?5m>4k<2h<1h<1h<1l<2o83q62p62p62m61l71j81i81h70g80e90e:1d<2e?4f@5dB6^B4aG8cL:dM;cM8`K6]K3]M4]Q9bX?mhRss[€ƒnv{eFO:4=*39-28.28.28.17-17-17-06,17-17-17-06,06,/5+/5+/5+-2,-2,-2,-2,-2,-2,-2,-2,-2,,1++0*+0*+0*+0*,1+,3,.5.,6.*4+*4+*4++5,-7,.9+-8*0;+4?/5@/4?.3?+3>-3@,7F/9K3@O8BT:GW¸J=¹I>¸I@´G@¯D>¥=:œ:7–=9>:ˆ?9€A:xA:tD:pF:pE5j>5n=6o83r73p62p62n72l71j81i81d8/d90c;1d>3d@4cA5cA5_C5ZE4_NnlUtv^|kcmU2>(6B.3;.39/39/39/28.28.28.17-17-17-17-06,06,/5+/5+/5+-2,-2,-2,-2,-2,-2,-2,-2,,1+,1++0**/)*/)+0*,1++2+-4-+5-*4,*4,+5,+5,,6+-7,,6+/:,2=/6A17B27B15@04?.2?-4C.:G3=L5AO8DT:JX?L\BTbI\kTcqZ^mXUbPDRA2>0#/%&/,&,,$**heVheVheVheVheVheVheVheVheVheVheVheVheVheVheVheVjdVjdVjcYkdZlc\md[lfZlfVolYmlWjlWgkZflbr{xŽ˜š¨±¸ÊÓØãìñøýÿ÷üÿúûÿþÿÿÿþÿúùõÿÿúýýõøøîðòåéëÝåéØãêØåíÖæìÒéíÒêíÒèèÎèæÏèãÏáÚÈØÐÃØÎÄÝÒÌêßÛøíëÿôöÿõùÿõûÿùüþüýÿÿýÿÿýþþüþþüÿÿýÿÿýýýûþþüþþüþþüþþüþþüþþüþþüÿþúÿýûÿýûýüúùýüøÿÿõÿÿóÿÿíýúóÿûûÿúÿÿôÿöæÿóßÿãÍ×­•©oY¨WD®Q@¬O>¯OA±OB­K@¤C<™<5•>7?6ˆ?8A7{B7uD6qE8qE8p?8q?8s>8q?8q?8q?8q?8p?8sB;qB:o@8m>6l=5j>5m>6o>7o83q73o83m82m82i81h91f:1f;2d>3d@4bB5`C5]A3\@2WB1TG4[S>f^Gi^HbX?ZS9ZS7\W:ZV;XW;kmUsw^u}fUaI&28D03;.4:04:039/39/39/28.28.17-17-17-06,06,/5+/5+/5+-2,-2,-2,-2,-2,-2,-2,-2,,1++0*+0**/)*/)+0*+0*,1++2+)3+*4,+5-+5,,6--7.-7,,6+.8-2<16A39D69D47B46A10;+2?-5B09F22=/x=/t?/sB3tD6r=5r=7t=8s>8u@:u@:t?9q?8sA:q@9q@9q@9p?8n?7o>7o>7k92m82l:3l;4l;4h<3g<3c=2c?3^>1dG9cG9T=-N9(M8'@1WQ;PN7KI0OK2]Y>ieJeaDVU7XX<]`CosZz€fdlU=I1-9#2>*4-1=)2>*9E/BN8IU?O[GVbN]hWYdTLWI/u@8s>8u>9u@:t?9o=6p>7sA:q?8p?8p?8n?7o>7m>6n=6m>6k<4l=5m>6k?6j?6gA6eA5bB5dG9[A2^G7^I8N=+F7$G8%>6!LL4GK2DG,DD*MM1\[?baC`aBYY=dgJsw^sy_X`I:D,/;%7C/6>16<26<26<25;15;15;15;15;15;15;14:04:039/39/39/27127127116016016005/05/.3-.3--2,-2,,1+,1++0*+0**1**1*)0))0))0)*1*+2*,3+.5--4,.5-07/4;39A6?F>BJ?;F8:E57B14?.3?+6B.)r>)s@+tD0vE4q?4n<3q<4tB9sA8o?5qA7xH>n>4m>4m>4k?4l=3j>3l=3j>3g?5gA6gA6gC7eC7cC6`C5^D5bK;UB1ZI7`S@RG3C;&E=(FA+AE,BH.AE*<@%?B%NN2_`AijKaaEnqTvzagmSJO94<%4=(=F38>28>48>48>47=37=37=36<28>48>47=37=37=36<26<26<25:449349349338238238227105/05//4..3--2,,1++0*+0*).().().().().(*/)+0*,1+160/4.,1+,1+/4.6;4=BK:4.8/-4--4-,3,gdUgdUheVheVheVheVifWifWifWifWifWifWifWifWifWifWkeWkeWlcZmd[md]mf\mg[jiWkmXimVjoYjs`hthm|wˆ˜˜¦³¹¿ÊÐÓÜãëðööûÿüýÿýÿþÿÿýÿþùþþöýýñúûí÷úçô÷âîóÜåíÕâèÎÛàÀ×Ú»ÖÖ¼Ù×ÂÝ×ÇÞ×ÍåÛÙìààøìðûðöÿõûÿùþÿúýÿûûÿûûÿýüÿþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüýÿüøÿþøÿþûÿþþþþÿüþÿúÿÿùÿÿøþÿúýÿùüÿùùÿýúÿÿøÿÿøûÿõüþðÿÿíÿüéÿñßÿðÝÿïÚñÒ½´z{R>tJ4uH3vI4zM8}P;yL7nA.e7'{M@sD:qB8sD:oC8g;0d8-g=1i?3i?3i?3g?3f>2f>2f>2e?2b@4bB5`C5_C5_C5[D4ZE4WD3XI6OB/\T?oiSc^HMK4IG0IK3>D*?H-@F*48>47=37=37=39?58>48>48>48>48>48>48>47<67<67<66;56;56;55:45:438238216005//4.-2,,1+,1++0*+0**/)*/)+0*,1+-2,-2,05/.3-+0*+0*-2.2718=9;B:@K=@M;@M;=J68E13@,1?(0>'4.:0,6..5.-4-gdUgdUgdUheVheVifWifWifWifWifWifWifWifWifWifWifWkeWldWlcZmd[md]mf\mg[jiWkmXinWiqZgs_drejyt…••£²·½ÈÎÒÛâêïõôùýûüÿýÿþÿÿýÿÿúÿÿøÿÿóþÿñûþë÷úåðõÞæîÖâèÌÙÜ¿ÕÕ¹ÒйÔѾÚÔÈàÙÑêàßôéíþóùÿ÷üÿûÿÿýÿÿþÿÿþüÿþúÿþúþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüýÿþúÿÿúÿÿûÿÿþþþÿýþÿüüÿûüÿûúÿúøÿù÷ÿú÷ÿýøÿÿûÿÿûýÿúýþùùôîÿþöÿýôÿüóÿûîÿ÷çûæÕéÒÀÏ´¡¶š…”uawVCjI6lI6rM;uP>mF7iB3gB2jE5nI9nJ:oK;oK;eA1cB1cB1cB1cB1cB1bC1`C3]F6\G6\G6ZG6ZG6WH5TG4RG3PH3NH2fdM~~frrZVX@JL4GM3A.:>-;>39?59?58>48>47=37=37=38>48>48>48>48>48>48>48>49>89>89>88=78=78=77<67<66;55:449338227105//4./4.-2.-2.,1-+0,+0,,1--2.-2.,1-,1-,1-,1-.210513764;4;G9=L9@O<@O:8F71?2-9-,6--4,,3+fcTfcTgdUheVheVifWjgXjgXifWifWifWifWifWifWifWifWldWldWlcZmd[md]mf\mg[jiWkmXinWiqZgs_bpcgxr‚””£²·ÀËÑÔÝäëðöõúþûüÿýÿþÿÿýÿÿúÿÿøÿÿôÿÿóÿÿïúýèò÷àçðÕâèÌ×Ú½ÑѵÍË´Î˺ÖÏÅÞ×Ñìâã÷îóÿöþÿúÿÿýÿÿþÿÿÿýþÿúþÿùþÿúþÿúþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþüþþþýþÿýþÿýþÿýÿþýÿüþÿúþÿùÿÿ÷ýýóýýõþýøþýùÿþüþþþÿýÿÿþÿþùÿÿüÿÿûüûöóÿøòÿýôÿþñÿýíÿúéÿòà÷äÓçÒ¿Ò»©¹ŸŽŸ„srb|]K}^LtUCaD2W:(Y<*[>,X=*`E2`E2`E2_F2`G3`G3`G3]H3\K7\M:\M:YL9XM9UM8RL6QL6NL5QQ9ikS|€gmqXSY?FL2>G,48>48>48>47=37=38>48>48>48>49?59?5:?9:?9:?9:?99>89>89>88=78=78=77<66;55:4493382382/40.3/-2.,1-+0,+0,+0,+0,+0,,1--10.21/32/32/32-4-3?17F3=L7@O:?N7M:MJ9BC3=@5;A7;A7;A7:@6:@6:@69?58>48>48>49?59?5:@6:@6:@6;@:;@:;@::?9:?99>89>89>8:?9:?99>89>88=78=77<67<6495273162/40-2.,1-+/.+/.,0/,0/-10.21.23.23-12+1-+9*/@-6H2;M7=O7A6>A6>A6=@7=@79?59?59?5:@6:@6:B7:B7:B7;@9;@9;@::?8:?99>79>89>7;@:;@9;@:;@9:?9:?8:?9:?98?87=94;4382160/4..3/.3/.21.21,2.,2.+2++2*,4))6%$6)=!2F+8L1;O6;M5;M5;M58J29K3;M5H&DK*FM+EL*PV4PT3KN/HK,TT8bbFccIZZ@[Y@\ZA][B][B[Y@XV=US:SQ8HF1GD1DA0A?0@>1>>2??5>@5;>59?59?59A69A48C58C58C5:B79A69@88@58?79A69@8:B7:A9:B79@8:B7;B:E=8B:8B:7A88@56>14O<>P::L6@R8EW=FY=DX=@T;5H2+<),6+,3++2*ZgM[hN\hP]iQbjSckTglXhkXghVghVifWifWkeWlfXmeZmgYmgYkhYkg[kg\jf]jf[hfZefVhiWglVfo\erajwnzŠ‰œ«²ºÈÑÐÙàáéìò÷ûøþþùþúúÿøûþóùýïøùë÷øæõôâíìØéæÓåâÏÜ×ÄÒ˹ʿ­Á´¤¹­¡¼¯¦Á¶²ËÁÀÛÐÖæßæûóþý÷ÿþûÿÿþÿþýÿüýÿüýÿüýÿþþþþþþþþþþþþþþþþþþÿþüÿþüÿþüÿþüÿýúÿüùÿüùÿýúÿýùÿþúÿþýÿýüÿüýÿýþÿþÿÿþÿÿýþýûüÿþýÿþûÿüúÿøóøíçòåÝöèßûðêÿúýÿüÿÿýþÿÿýÿÿûýÿüýÿþüýÿýþÿýþÿÿýÿÿþüÿþõÿÿîÿþèÿÿäúöÝýûâäàÇ‹‡lRM0SN0QK+QK+UO/UO/TO1TO1SO2SO2QP4QP4QM2PO3PN5NQ6MO7JP6HM6EM5HQ6EN1BK.?I'BI(FM+JP,KQ-NR/PT1VZ7^bA_bCY\?TWWU>XV=YW>XV=XW;WV:XT9QK3OI3LG4ID1DA2B@3A?3>@5<=59?59?59A67B48C57D37D3:B79A69A68@58@59A69A6:B7:B7:B7:B7:B7;C874>63=40>-3C)9M*BY/Ga1Op;Ln;Li=Fa>BY?F;J@?I>>I9?G8>F7>D8=B;>E>9C;6@74B19I/BV3Pg=XrB^J[}JXuIMhECZ@9O:6G54E2XR6:@6:@69A67B47B46C26C2;C8:B79A69A69A69A6:B7;C8;C8:B7:B7;C8;C8=E:>F;=G<=G?>H=>I9?G8>F7>D8=B;=D=9C;6@74B19I/DX5Ri?[uEZ{FWyFTqEIdA=T:2H3/@.->+6H2@R8L_CReGSgKOcG@W=6I30:/07/-4,YgMZhN\hP^jRblTemVinZjo[mn\lm[mk\mj[nhZnhZoi]oi[liZkhYjfZieZie\ieZig[ghXghVchRajWerao|s{‹ŠŸ¦¢°¹ÁËÔÔÝäéñôòúüôúøñöðíðçèìÞâãÕÚÛÉÒÑ¿ÌɶÉıþ«¿¸¦¼³¢Ê¾®ÓŸÜÐÄæÙÑíâàöìíÿôúÿùÿÿ÷ÿÿúÿÿüÿþýÿýüÿûüþüþýþÿÿþþþþþþþþþþþþþþþþþþÿþüÿþüþýûþýûÿýúÿýúÿýúÿûøÿúöþùõÿýüÿûúýùúþúûþüýÿýþÿþÿÿýþÿüûÿýúÿüúÿøó÷ìæòåÝøêáÿôîÿúýÿüÿÿýþÿÿýÿÿûýÿúýÿþüýÿüýÿýþÿÿþÿÿÿýÿþõÿýìÿûãþúßÿüæÿÿéçâÌŒˆoRL2TO2TM0UN1TN.UO/VQ3VQ3UQ4SO2ON2NM1PL1NM1NL3KN3LN6KQ7KP9JR:LU:IR5JS6OY7SZ9T[9]c?fnG‚’c’¦sŸ±›ª’¡zˆ”pr{\\bFLP7KM5LK6KI4LJ5PK5TN8VP:WQ;VP:SN;QL9LI:IG:GE9CE:=>6:@6:@69A67B47B46C26C2;C8;C8:B79A69A6:B7;C8;C8;C8;C8;C8;C8F;=G<=G?=G<=H8>F7=E6=C7=B;:A:7A95?64B19I/BV3Ne;Uo?Tu@RtAPmAE`=9P6-C.+<*+<)1C-. # The master version of this file is at the FSF in /home/gd/gnu/lib. # # This script attempts to guess a canonical system name similar to # config.sub. If it succeeds, it prints the system name on stdout, and # exits with 0. Otherwise, it exits with 1. # # The plan is that this can be called by configure scripts if you # don't specify an explicit system type (host/target name). # # Only a few systems have been added to this list; please add others # (but try to keep the structure clean). # # This is needed to find uname on a Pyramid OSx when run in the BSD universe. # (ghazi@noc.rutgers.edu 8/24/94.) if (test -f /.attbin/uname) >/dev/null 2>&1 ; then PATH=$PATH:/.attbin ; export PATH fi UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown trap 'rm -f dummy.c dummy.o dummy; exit 1' 1 2 15 # Note: order is significant - the case branches are not exclusive. case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in alpha:OSF1:*:*) if test $UNAME_RELEASE = "V4.0"; then UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` fi # A Vn.n version is a released version. # A Tn.n version is a released field test version. # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. cat <dummy.s .globl main .ent main main: .frame \$30,0,\$26,0 .prologue 0 .long 0x47e03d80 # implver $0 lda \$2,259 .long 0x47e20c21 # amask $2,$1 srl \$1,8,\$2 sll \$2,2,\$2 sll \$0,3,\$0 addl \$1,\$0,\$0 addl \$2,\$0,\$0 ret \$31,(\$26),1 .end main EOF ${CC-cc} dummy.s -o dummy 2>/dev/null if test "$?" = 0 ; then ./dummy case "$?" in 7) UNAME_MACHINE="alpha" ;; 15) UNAME_MACHINE="alphaev5" ;; 14) UNAME_MACHINE="alphaev56" ;; 10) UNAME_MACHINE="alphapca56" ;; 16) UNAME_MACHINE="alphaev6" ;; esac fi rm -f dummy.s dummy echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[VTX]//' | tr [[A-Z]] [[a-z]]` exit 0 ;; 21064:Windows_NT:50:3) echo alpha-dec-winnt3.5 exit 0 ;; Amiga*:UNIX_System_V:4.0:*) echo m68k-cbm-sysv4 exit 0;; amiga:NetBSD:*:*) echo m68k-cbm-netbsd${UNAME_RELEASE} exit 0 ;; amiga:OpenBSD:*:*) echo m68k-unknown-openbsd${UNAME_RELEASE} exit 0 ;; arc64:OpenBSD:*:*) echo mips64el-unknown-openbsd${UNAME_RELEASE} exit 0 ;; arc:OpenBSD:*:*) echo mipsel-unknown-openbsd${UNAME_RELEASE} exit 0 ;; hkmips:OpenBSD:*:*) echo mips-unknown-openbsd${UNAME_RELEASE} exit 0 ;; pmax:OpenBSD:*:*) echo mipsel-unknown-openbsd${UNAME_RELEASE} exit 0 ;; sgi:OpenBSD:*:*) echo mips-unknown-openbsd${UNAME_RELEASE} exit 0 ;; wgrisc:OpenBSD:*:*) echo mipsel-unknown-openbsd${UNAME_RELEASE} exit 0 ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix${UNAME_RELEASE} exit 0;; arm32:NetBSD:*:*) echo arm-unknown-netbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` exit 0 ;; SR2?01:HI-UX/MPP:*:*) echo hppa1.1-hitachi-hiuxmpp exit 0;; Pyramid*:OSx*:*:*|MIS*:OSx*:*:*) # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. if test "`(/bin/universe) 2>/dev/null`" = att ; then echo pyramid-pyramid-sysv3 else echo pyramid-pyramid-bsd fi exit 0 ;; NILE:*:*:dcosx) echo pyramid-pyramid-svr4 exit 0 ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit 0 ;; i86pc:SunOS:5.*:*) echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit 0 ;; sun4*:SunOS:6*:*) # According to config.sub, this is the proper way to canonicalize # SunOS6. Hard to guess exactly what SunOS6 will be like, but # it's likely to be more like Solaris than SunOS4. echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit 0 ;; sun4*:SunOS:*:*) case "`/usr/bin/arch -k`" in Series*|S4*) UNAME_RELEASE=`uname -v` ;; esac # Japanese Language versions have a version number like `4.1.3-JL'. echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` exit 0 ;; sun3*:SunOS:*:*) echo m68k-sun-sunos${UNAME_RELEASE} exit 0 ;; sun*:*:4.2BSD:*) UNAME_RELEASE=`(head -1 /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 case "`/bin/arch`" in sun3) echo m68k-sun-sunos${UNAME_RELEASE} ;; sun4) echo sparc-sun-sunos${UNAME_RELEASE} ;; esac exit 0 ;; aushp:SunOS:*:*) echo sparc-auspex-sunos${UNAME_RELEASE} exit 0 ;; atari*:NetBSD:*:*) echo m68k-atari-netbsd${UNAME_RELEASE} exit 0 ;; atari*:OpenBSD:*:*) echo m68k-unknown-openbsd${UNAME_RELEASE} exit 0 ;; sun3*:NetBSD:*:*) echo m68k-sun-netbsd${UNAME_RELEASE} exit 0 ;; sun3*:OpenBSD:*:*) echo m68k-unknown-openbsd${UNAME_RELEASE} exit 0 ;; mac68k:NetBSD:*:*) echo m68k-apple-netbsd${UNAME_RELEASE} exit 0 ;; mac68k:OpenBSD:*:*) echo m68k-unknown-openbsd${UNAME_RELEASE} exit 0 ;; mvme68k:OpenBSD:*:*) echo m68k-unknown-openbsd${UNAME_RELEASE} exit 0 ;; mvme88k:OpenBSD:*:*) echo m88k-unknown-openbsd${UNAME_RELEASE} exit 0 ;; powerpc:machten:*:*) echo powerpc-apple-machten${UNAME_RELEASE} exit 0 ;; RISC*:Mach:*:*) echo mips-dec-mach_bsd4.3 exit 0 ;; RISC*:ULTRIX:*:*) echo mips-dec-ultrix${UNAME_RELEASE} exit 0 ;; VAX*:ULTRIX*:*:*) echo vax-dec-ultrix${UNAME_RELEASE} exit 0 ;; 2020:CLIX:*:*) echo clipper-intergraph-clix${UNAME_RELEASE} exit 0 ;; mips:*:*:UMIPS | mips:*:*:RISCos) sed 's/^ //' << EOF >dummy.c int main (argc, argv) int argc; char **argv; { #if defined (host_mips) && defined (MIPSEB) #if defined (SYSTYPE_SYSV) printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_SVR4) printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); #endif #endif exit (-1); } EOF ${CC-cc} dummy.c -o dummy \ && ./dummy `echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` \ && rm dummy.c dummy && exit 0 rm -f dummy.c dummy echo mips-mips-riscos${UNAME_RELEASE} exit 0 ;; Night_Hawk:Power_UNIX:*:*) echo powerpc-harris-powerunix exit 0 ;; m88k:CX/UX:7*:*) echo m88k-harris-cxux7 exit 0 ;; m88k:*:4*:R4*) echo m88k-motorola-sysv4 exit 0 ;; m88k:*:3*:R3*) echo m88k-motorola-sysv3 exit 0 ;; AViiON:dgux:*:*) # DG/UX returns AViiON for all architectures UNAME_PROCESSOR=`/usr/bin/uname -p` if [ $UNAME_PROCESSOR = mc88100 -o $UNAME_PROCESSOR = mc88110 ] ; then if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx \ -o ${TARGET_BINARY_INTERFACE}x = x ] ; then echo m88k-dg-dgux${UNAME_RELEASE} else echo m88k-dg-dguxbcs${UNAME_RELEASE} fi else echo i586-dg-dgux${UNAME_RELEASE} fi exit 0 ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) echo m88k-dolphin-sysv3 exit 0 ;; M88*:*:R3*:*) # Delta 88k system running SVR3 echo m88k-motorola-sysv3 exit 0 ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) echo m88k-tektronix-sysv3 exit 0 ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) echo m68k-tektronix-bsd exit 0 ;; *:IRIX*:*:*) echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` exit 0 ;; ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id exit 0 ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i?86:AIX:*:*) echo i386-ibm-aix exit 0 ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then sed 's/^ //' << EOF >dummy.c #include main() { if (!__power_pc()) exit(1); puts("powerpc-ibm-aix3.2.5"); exit(0); } EOF ${CC-cc} dummy.c -o dummy && ./dummy && rm dummy.c dummy && exit 0 rm -f dummy.c dummy echo rs6000-ibm-aix3.2.5 elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then echo rs6000-ibm-aix3.2.4 else echo rs6000-ibm-aix3.2 fi exit 0 ;; *:AIX:*:4) if /usr/sbin/lsattr -EHl proc0 | grep POWER >/dev/null 2>&1; then IBM_ARCH=rs6000 else IBM_ARCH=powerpc fi if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=4.${UNAME_RELEASE} fi echo ${IBM_ARCH}-ibm-aix${IBM_REV} exit 0 ;; *:AIX:*:*) echo rs6000-ibm-aix exit 0 ;; ibmrt:4.4BSD:*|romp-ibm:BSD:*) echo romp-ibm-bsd4.4 exit 0 ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC NetBSD and echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to exit 0 ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) echo rs6000-bull-bosx exit 0 ;; DPX/2?00:B.O.S.:*:*) echo m68k-bull-sysv3 exit 0 ;; 9000/[34]??:4.3bsd:1.*:*) echo m68k-hp-bsd exit 0 ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) echo m68k-hp-bsd4.4 exit 0 ;; 9000/[3478]??:HP-UX:*:*) case "${UNAME_MACHINE}" in 9000/31? ) HP_ARCH=m68000 ;; 9000/[34]?? ) HP_ARCH=m68k ;; 9000/7?? | 9000/8?[1679] ) HP_ARCH=hppa1.1 ;; 9000/8?? ) HP_ARCH=hppa1.0 ;; esac HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` echo ${HP_ARCH}-hp-hpux${HPUX_REV} exit 0 ;; 3050*:HI-UX:*:*) sed 's/^ //' << EOF >dummy.c #include int main () { long cpu = sysconf (_SC_CPU_VERSION); /* The order matters, because CPU_IS_HP_MC68K erroneously returns true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct results, however. */ if (CPU_IS_PA_RISC (cpu)) { switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; default: puts ("hppa-hitachi-hiuxwe2"); break; } } else if (CPU_IS_HP_MC68K (cpu)) puts ("m68k-hitachi-hiuxwe2"); else puts ("unknown-hitachi-hiuxwe2"); exit (0); } EOF ${CC-cc} dummy.c -o dummy && ./dummy && rm dummy.c dummy && exit 0 rm -f dummy.c dummy echo unknown-hitachi-hiuxwe2 exit 0 ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) echo hppa1.1-hp-bsd exit 0 ;; 9000/8??:4.3bsd:*:*) echo hppa1.0-hp-bsd exit 0 ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) echo hppa1.1-hp-osf exit 0 ;; hp8??:OSF1:*:*) echo hppa1.0-hp-osf exit 0 ;; i?86:OSF1:*:*) if [ -x /usr/sbin/sysversion ] ; then echo ${UNAME_MACHINE}-unknown-osf1mk else echo ${UNAME_MACHINE}-unknown-osf1 fi exit 0 ;; parisc*:Lites*:*:*) echo hppa1.1-hp-lites exit 0 ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) echo c1-convex-bsd exit 0 ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit 0 ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) echo c34-convex-bsd exit 0 ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) echo c38-convex-bsd exit 0 ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) echo c4-convex-bsd exit 0 ;; CRAY*X-MP:*:*:*) echo xmp-cray-unicos exit 0 ;; CRAY*Y-MP:*:*:*) echo ymp-cray-unicos${UNAME_RELEASE} exit 0 ;; CRAY*[A-Z]90:*:*:*) echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ exit 0 ;; CRAY*TS:*:*:*) echo t90-cray-unicos${UNAME_RELEASE} exit 0 ;; CRAY-2:*:*:*) echo cray2-cray-unicos exit 0 ;; F300:UNIX_System_V:*:*) FUJITSU_SYS=`uname -p | tr [A-Z] [a-z] | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` echo "f300-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit 0 ;; F301:UNIX_System_V:*:*) echo f301-fujitsu-uxpv`echo $UNAME_RELEASE | sed 's/ .*//'` exit 0 ;; hp3[0-9][05]:NetBSD:*:*) echo m68k-hp-netbsd${UNAME_RELEASE} exit 0 ;; hp300:OpenBSD:*:*) echo m68k-unknown-openbsd${UNAME_RELEASE} exit 0 ;; i?86:BSD/386:*:* | *:BSD/OS:*:*) echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} exit 0 ;; *:FreeBSD:*:*) echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` exit 0 ;; *:NetBSD:*:*) echo ${UNAME_MACHINE}-unknown-netbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` exit 0 ;; *:OpenBSD:*:*) echo ${UNAME_MACHINE}-unknown-openbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` exit 0 ;; i*:CYGWIN*:*) echo i386-pc-cygwin32 exit 0 ;; i*:MINGW*:*) echo i386-pc-mingw32 exit 0 ;; p*:CYGWIN*:*) echo powerpcle-unknown-cygwin32 exit 0 ;; prep*:SunOS:5.*:*) echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit 0 ;; *:GNU:*:*) echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` exit 0 ;; *:Linux:*:*) # The BFD linker knows what the default object file format is, so # first see if it will tell us. ld_help_string=`ld --help 2>&1` ld_supported_emulations=`echo $ld_help_string \ | sed -ne '/supported emulations:/!d s/[ ][ ]*/ /g s/.*supported emulations: *// s/ .*// p'` case "$ld_supported_emulations" in i?86linux) echo "${UNAME_MACHINE}-pc-linux-gnuaout" ; exit 0 ;; i?86coff) echo "${UNAME_MACHINE}-pc-linux-gnucoff" ; exit 0 ;; sparclinux) echo "${UNAME_MACHINE}-unknown-linux-gnuaout" ; exit 0 ;; m68klinux) echo "${UNAME_MACHINE}-unknown-linux-gnuaout" ; exit 0 ;; elf32ppc) echo "powerpc-unknown-linux-gnu" ; exit 0 ;; esac if test "${UNAME_MACHINE}" = "alpha" ; then sed 's/^ //' <dummy.s .globl main .ent main main: .frame \$30,0,\$26,0 .prologue 0 .long 0x47e03d80 # implver $0 lda \$2,259 .long 0x47e20c21 # amask $2,$1 srl \$1,8,\$2 sll \$2,2,\$2 sll \$0,3,\$0 addl \$1,\$0,\$0 addl \$2,\$0,\$0 ret \$31,(\$26),1 .end main EOF LIBC="" ${CC-cc} dummy.s -o dummy 2>/dev/null if test "$?" = 0 ; then ./dummy case "$?" in 7) UNAME_MACHINE="alpha" ;; 15) UNAME_MACHINE="alphaev5" ;; 14) UNAME_MACHINE="alphaev56" ;; 10) UNAME_MACHINE="alphapca56" ;; 16) UNAME_MACHINE="alphaev6" ;; esac objdump --private-headers dummy | \ grep ld.so.1 > /dev/null if test "$?" = 0 ; then LIBC="libc1" fi fi rm -f dummy.s dummy echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} ; exit 0 elif test "${UNAME_MACHINE}" = "mips" ; then cat >dummy.c </dev/null && ./dummy "${UNAME_MACHINE}" && rm dummy.c dummy && exit 0 rm -f dummy.c dummy else # Either a pre-BFD a.out linker (linux-gnuoldld) # or one that does not give us useful --help. # GCC wants to distinguish between linux-gnuoldld and linux-gnuaout. # If ld does not provide *any* "supported emulations:" # that means it is gnuoldld. echo "$ld_help_string" | grep >/dev/null 2>&1 "supported emulations:" test $? != 0 && echo "${UNAME_MACHINE}-pc-linux-gnuoldld" && exit 0 case "${UNAME_MACHINE}" in i?86) VENDOR=pc; ;; *) VENDOR=unknown; ;; esac # Determine whether the default compiler is a.out or elf cat >dummy.c < main(argc, argv) int argc; char *argv[]; { #ifdef __ELF__ # ifdef __GLIBC__ # if __GLIBC__ >= 2 printf ("%s-${VENDOR}-linux-gnu\n", argv[1]); # else printf ("%s-${VENDOR}-linux-gnulibc1\n", argv[1]); # endif # else printf ("%s-${VENDOR}-linux-gnulibc1\n", argv[1]); # endif #else printf ("%s-${VENDOR}-linux-gnuaout\n", argv[1]); #endif return 0; } EOF ${CC-cc} dummy.c -o dummy 2>/dev/null && ./dummy "${UNAME_MACHINE}" && rm dummy.c dummy && exit 0 rm -f dummy.c dummy fi ;; # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. earlier versions # are messed up and put the nodename in both sysname and nodename. i?86:DYNIX/ptx:4*:*) echo i386-sequent-sysv4 exit 0 ;; i?86:UNIX_SV:4.2MP:2.*) # Unixware is an offshoot of SVR4, but it has its own version # number series starting with 2... # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. # Use sysv4.2uw... so that sysv4* matches it. echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} exit 0 ;; i?86:*:4.*:* | i?86:SYSTEM_V:4.*:*) if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then echo ${UNAME_MACHINE}-univel-sysv${UNAME_RELEASE} else echo ${UNAME_MACHINE}-pc-sysv${UNAME_RELEASE} fi exit 0 ;; i?86:*:3.2:*) if test -f /usr/options/cb.name; then UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then UNAME_REL=`(/bin/uname -X|egrep Release|sed -e 's/.*= //')` (/bin/uname -X|egrep i80486 >/dev/null) && UNAME_MACHINE=i486 (/bin/uname -X|egrep '^Machine.*Pentium' >/dev/null) \ && UNAME_MACHINE=i586 echo ${UNAME_MACHINE}-pc-sco$UNAME_REL else echo ${UNAME_MACHINE}-pc-sysv32 fi exit 0 ;; pc:*:*:*) # uname -m prints for DJGPP always 'pc', but it prints nothing about # the processor, so we play safe by assuming i386. echo i386-pc-msdosdjgpp exit 0 ;; Intel:Mach:3*:*) echo i386-pc-mach3 exit 0 ;; paragon:*:*:*) echo i860-intel-osf1 exit 0 ;; i860:*:4.*:*) # i860-SVR4 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 else # Add other i860-SVR4 vendors below as they are discovered. echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 fi exit 0 ;; mini*:CTIX:SYS*5:*) # "miniframe" echo m68010-convergent-sysv exit 0 ;; M68*:*:R3V[567]*:*) test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;; 3[34]??:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 4850:*:4.0:3.0) OS_REL='' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && echo i486-ncr-sysv4.3${OS_REL} && exit 0 /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && echo i586-ncr-sysv4.3${OS_REL} && exit 0 ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && echo i486-ncr-sysv4 && exit 0 ;; m68*:LynxOS:2.*:*) echo m68k-unknown-lynxos${UNAME_RELEASE} exit 0 ;; mc68030:UNIX_System_V:4.*:*) echo m68k-atari-sysv4 exit 0 ;; i?86:LynxOS:2.*:*) echo i386-unknown-lynxos${UNAME_RELEASE} exit 0 ;; TSUNAMI:LynxOS:2.*:*) echo sparc-unknown-lynxos${UNAME_RELEASE} exit 0 ;; rs6000:LynxOS:2.*:* | PowerPC:LynxOS:2.*:*) echo rs6000-unknown-lynxos${UNAME_RELEASE} exit 0 ;; SM[BE]S:UNIX_SV:*:*) echo mips-dde-sysv${UNAME_RELEASE} exit 0 ;; RM*:SINIX-*:*:*) echo mips-sni-sysv4 exit 0 ;; *:SINIX-*:*:*) if uname -p 2>/dev/null >/dev/null ; then UNAME_MACHINE=`(uname -p) 2>/dev/null` echo ${UNAME_MACHINE}-sni-sysv4 else echo ns32k-sni-sysv fi exit 0 ;; PENTIUM:CPunix:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says echo i586-unisys-sysv4 exit 0 ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm echo hppa1.1-stratus-sysv4 exit 0 ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. echo i860-stratus-sysv4 exit 0 ;; mc68*:A/UX:*:*) echo m68k-apple-aux${UNAME_RELEASE} exit 0 ;; news*:NEWS-OS:*:6*) echo mips-sony-newsos6 exit 0 ;; R3000:*System_V*:*:* | R4000:UNIX_SYSV:*:*) if [ -d /usr/nec ]; then echo mips-nec-sysv${UNAME_RELEASE} else echo mips-unknown-sysv${UNAME_RELEASE} fi exit 0 ;; esac #echo '(No uname command or uname output not recognized.)' 1>&2 #echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2 cat >dummy.c < # include #endif main () { #if defined (sony) #if defined (MIPSEB) /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, I don't know.... */ printf ("mips-sony-bsd\n"); exit (0); #else #include printf ("m68k-sony-newsos%s\n", #ifdef NEWSOS4 "4" #else "" #endif ); exit (0); #endif #endif #if defined (__arm) && defined (__acorn) && defined (__unix) printf ("arm-acorn-riscix"); exit (0); #endif #if defined (hp300) && !defined (hpux) printf ("m68k-hp-bsd\n"); exit (0); #endif #if defined (NeXT) #if !defined (__ARCHITECTURE__) #define __ARCHITECTURE__ "m68k" #endif int version; version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); exit (0); #endif #if defined (MULTIMAX) || defined (n16) #if defined (UMAXV) printf ("ns32k-encore-sysv\n"); exit (0); #else #if defined (CMU) printf ("ns32k-encore-mach\n"); exit (0); #else printf ("ns32k-encore-bsd\n"); exit (0); #endif #endif #endif #if defined (__386BSD__) printf ("i386-pc-bsd\n"); exit (0); #endif #if defined (sequent) #if defined (i386) printf ("i386-sequent-dynix\n"); exit (0); #endif #if defined (ns32000) printf ("ns32k-sequent-dynix\n"); exit (0); #endif #endif #if defined (_SEQUENT_) struct utsname un; uname(&un); if (strncmp(un.version, "V2", 2) == 0) { printf ("i386-sequent-ptx2\n"); exit (0); } if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ printf ("i386-sequent-ptx1\n"); exit (0); } printf ("i386-sequent-ptx\n"); exit (0); #endif #if defined (vax) #if !defined (ultrix) printf ("vax-dec-bsd\n"); exit (0); #else printf ("vax-dec-ultrix\n"); exit (0); #endif #endif #if defined (alliant) && defined (i860) printf ("i860-alliant-bsd\n"); exit (0); #endif exit (1); } EOF ${CC-cc} dummy.c -o dummy 2>/dev/null && ./dummy && rm dummy.c dummy && exit 0 rm -f dummy.c dummy # Apollos put the system type in the environment. test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit 0; } # Convex versions that predate uname can use getsysinfo(1) if [ -x /usr/convex/getsysinfo ] then case `getsysinfo -f cpu_type` in c1*) echo c1-convex-bsd exit 0 ;; c2*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit 0 ;; c34*) echo c34-convex-bsd exit 0 ;; c38*) echo c38-convex-bsd exit 0 ;; c4*) echo c4-convex-bsd exit 0 ;; esac fi #echo '(Unable to guess system type)' 1>&2 exit 1 Papyrus3/JpegDir/JpgLossy/JCPREPCT.C0000755000175000017500000003021307535143454014154 0ustar /* * jcprepct.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains the compression preprocessing controller. * This controller manages the color conversion, downsampling, * and edge expansion steps. * * Most of the complexity here is associated with buffering input rows * as required by the downsampler. See the comments at the head of * jcsample.c for the downsampler's needs. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* At present, jcsample.c can request context rows only for smoothing. * In the future, we might also need context rows for CCIR601 sampling * or other more-complex downsampling procedures. The code to support * context rows should be compiled only if needed. */ #ifdef INPUT_SMOOTHING_SUPPORTED #define CONTEXT_ROWS_SUPPORTED #endif /* * For the simple (no-context-row) case, we just need to buffer one * row group's worth of pixels for the downsampling step. At the bottom of * the image, we pad to a full row group by replicating the last pixel row. * The downsampler's last output row is then replicated if needed to pad * out to a full iMCU row. * * When providing context rows, we must buffer three row groups' worth of * pixels. Three row groups are physically allocated, but the row pointer * arrays are made five row groups high, with the extra pointers above and * below "wrapping around" to point to the last and first real row groups. * This allows the downsampler to access the proper context rows. * At the top and bottom of the image, we create dummy context rows by * copying the first or last real pixel row. This copying could be avoided * by pointer hacking as is done in jdmainct.c, but it doesn't seem worth the * trouble on the compression side. */ /* Private buffer controller object */ typedef struct { struct jpeg_c_prep_controller pub; /* public fields */ /* Downsampling input buffer. This buffer holds color-converted data * until we have enough to do a downsample step. */ JSAMPARRAY color_buf[MAX_COMPONENTS]; JDIMENSION rows_to_go; /* counts rows remaining in source image */ int next_buf_row; /* index of next row to store in color_buf */ #ifdef CONTEXT_ROWS_SUPPORTED /* only needed for context case */ int this_row_group; /* starting row index of group to process */ int next_buf_stop; /* downsample when we reach this index */ #endif } my_prep_controller; typedef my_prep_controller * my_prep_ptr; /* * Initialize for a processing pass. */ METHODDEF(void) start_pass_prep (j_compress_ptr cinfo, J_BUF_MODE pass_mode) { my_prep_ptr prep = (my_prep_ptr) cinfo->prep; if (pass_mode != JBUF_PASS_THRU) ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); /* Initialize total-height counter for detecting bottom of image */ prep->rows_to_go = cinfo->image_height; /* Mark the conversion buffer empty */ prep->next_buf_row = 0; #ifdef CONTEXT_ROWS_SUPPORTED /* Preset additional state variables for context mode. * These aren't used in non-context mode, so we needn't test which mode. */ prep->this_row_group = 0; /* Set next_buf_stop to stop after two row groups have been read in. */ prep->next_buf_stop = 2 * cinfo->max_v_samp_factor; #endif } /* * Expand an image vertically from height input_rows to height output_rows, * by duplicating the bottom row. */ LOCAL(void) expand_bottom_edge (JSAMPARRAY image_data, JDIMENSION num_cols, int input_rows, int output_rows) { register int row; for (row = input_rows; row < output_rows; row++) { jcopy_sample_rows(image_data, input_rows-1, image_data, row, 1, num_cols); } } /* * Process some data in the simple no-context case. * * Preprocessor output data is counted in "row groups". A row group * is defined to be v_samp_factor sample rows of each component. * Downsampling will produce this much data from each max_v_samp_factor * input rows. */ METHODDEF(void) pre_process_data (j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail, JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr, JDIMENSION out_row_groups_avail) { my_prep_ptr prep = (my_prep_ptr) cinfo->prep; int numrows, ci; JDIMENSION inrows; jpeg_component_info * compptr; while (*in_row_ctr < in_rows_avail && *out_row_group_ctr < out_row_groups_avail) { /* Do color conversion to fill the conversion buffer. */ inrows = in_rows_avail - *in_row_ctr; numrows = cinfo->max_v_samp_factor - prep->next_buf_row; numrows = (int) MIN((JDIMENSION) numrows, inrows); (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr, prep->color_buf, (JDIMENSION) prep->next_buf_row, numrows); *in_row_ctr += numrows; prep->next_buf_row += numrows; prep->rows_to_go -= numrows; /* If at bottom of image, pad to fill the conversion buffer. */ if (prep->rows_to_go == 0 && prep->next_buf_row < cinfo->max_v_samp_factor) { for (ci = 0; ci < cinfo->num_components; ci++) { expand_bottom_edge(prep->color_buf[ci], cinfo->image_width, prep->next_buf_row, cinfo->max_v_samp_factor); } prep->next_buf_row = cinfo->max_v_samp_factor; } /* If we've filled the conversion buffer, empty it. */ if (prep->next_buf_row == cinfo->max_v_samp_factor) { (*cinfo->downsample->downsample) (cinfo, prep->color_buf, (JDIMENSION) 0, output_buf, *out_row_group_ctr); prep->next_buf_row = 0; (*out_row_group_ctr)++; } /* If at bottom of image, pad the output to a full iMCU height. * Note we assume the caller is providing a one-iMCU-height output buffer! */ if (prep->rows_to_go == 0 && *out_row_group_ctr < out_row_groups_avail) { for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { expand_bottom_edge(output_buf[ci], compptr->width_in_blocks * DCTSIZE, (int) (*out_row_group_ctr * compptr->v_samp_factor), (int) (out_row_groups_avail * compptr->v_samp_factor)); } *out_row_group_ctr = out_row_groups_avail; break; /* can exit outer loop without test */ } } } #ifdef CONTEXT_ROWS_SUPPORTED /* * Process some data in the context case. */ METHODDEF(void) pre_process_context (j_compress_ptr cinfo, JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail, JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr, JDIMENSION out_row_groups_avail) { my_prep_ptr prep = (my_prep_ptr) cinfo->prep; int numrows, ci; int buf_height = cinfo->max_v_samp_factor * 3; JDIMENSION inrows; while (*out_row_group_ctr < out_row_groups_avail) { if (*in_row_ctr < in_rows_avail) { /* Do color conversion to fill the conversion buffer. */ inrows = in_rows_avail - *in_row_ctr; numrows = prep->next_buf_stop - prep->next_buf_row; numrows = (int) MIN((JDIMENSION) numrows, inrows); (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr, prep->color_buf, (JDIMENSION) prep->next_buf_row, numrows); /* Pad at top of image, if first time through */ if (prep->rows_to_go == cinfo->image_height) { for (ci = 0; ci < cinfo->num_components; ci++) { int row; for (row = 1; row <= cinfo->max_v_samp_factor; row++) { jcopy_sample_rows(prep->color_buf[ci], 0, prep->color_buf[ci], -row, 1, cinfo->image_width); } } } *in_row_ctr += numrows; prep->next_buf_row += numrows; prep->rows_to_go -= numrows; } else { /* Return for more data, unless we are at the bottom of the image. */ if (prep->rows_to_go != 0) break; /* When at bottom of image, pad to fill the conversion buffer. */ if (prep->next_buf_row < prep->next_buf_stop) { for (ci = 0; ci < cinfo->num_components; ci++) { expand_bottom_edge(prep->color_buf[ci], cinfo->image_width, prep->next_buf_row, prep->next_buf_stop); } prep->next_buf_row = prep->next_buf_stop; } } /* If we've gotten enough data, downsample a row group. */ if (prep->next_buf_row == prep->next_buf_stop) { (*cinfo->downsample->downsample) (cinfo, prep->color_buf, (JDIMENSION) prep->this_row_group, output_buf, *out_row_group_ctr); (*out_row_group_ctr)++; /* Advance pointers with wraparound as necessary. */ prep->this_row_group += cinfo->max_v_samp_factor; if (prep->this_row_group >= buf_height) prep->this_row_group = 0; if (prep->next_buf_row >= buf_height) prep->next_buf_row = 0; prep->next_buf_stop = prep->next_buf_row + cinfo->max_v_samp_factor; } } } /* * Create the wrapped-around downsampling input buffer needed for context mode. */ LOCAL(void) create_context_buffer (j_compress_ptr cinfo) { my_prep_ptr prep = (my_prep_ptr) cinfo->prep; int rgroup_height = cinfo->max_v_samp_factor; int ci, i; jpeg_component_info * compptr; JSAMPARRAY true_buffer, fake_buffer; /* Grab enough space for fake row pointers for all the components; * we need five row groups' worth of pointers for each component. */ fake_buffer = (JSAMPARRAY) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (cinfo->num_components * 5 * rgroup_height) * SIZEOF(JSAMPROW)); for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { /* Allocate the actual buffer space (3 row groups) for this component. * We make the buffer wide enough to allow the downsampler to edge-expand * horizontally within the buffer, if it so chooses. */ true_buffer = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE * cinfo->max_h_samp_factor) / compptr->h_samp_factor), (JDIMENSION) (3 * rgroup_height)); /* Copy true buffer row pointers into the middle of the fake row array */ MEMCOPY(fake_buffer + rgroup_height, true_buffer, 3 * rgroup_height * SIZEOF(JSAMPROW)); /* Fill in the above and below wraparound pointers */ for (i = 0; i < rgroup_height; i++) { fake_buffer[i] = true_buffer[2 * rgroup_height + i]; fake_buffer[4 * rgroup_height + i] = true_buffer[i]; } prep->color_buf[ci] = fake_buffer + rgroup_height; fake_buffer += 5 * rgroup_height; /* point to space for next component */ } } #endif /* CONTEXT_ROWS_SUPPORTED */ /* * Initialize preprocessing controller. */ GLOBAL(void) jinit_c_prep_controller (j_compress_ptr cinfo, boolean need_full_buffer) { my_prep_ptr prep; int ci; jpeg_component_info * compptr; if (need_full_buffer) /* safety check */ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); prep = (my_prep_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_prep_controller)); cinfo->prep = (struct jpeg_c_prep_controller *) prep; prep->pub.start_pass = start_pass_prep; /* Allocate the color conversion buffer. * We make the buffer wide enough to allow the downsampler to edge-expand * horizontally within the buffer, if it so chooses. */ if (cinfo->downsample->need_context_rows) { /* Set up to provide context rows */ #ifdef CONTEXT_ROWS_SUPPORTED prep->pub.pre_process_data = pre_process_context; create_context_buffer(cinfo); #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } else { /* No context, just make it tall enough for one row group */ prep->pub.pre_process_data = pre_process_data; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { prep->color_buf[ci] = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE * cinfo->max_h_samp_factor) / compptr->h_samp_factor), (JDIMENSION) cinfo->max_v_samp_factor); } } } Papyrus3/JpegDir/JpgLossy/jconfig.manx0000755000175000017500000000233007535143454015141 0ustar /* jconfig.manx --- jconfig.h for Amiga systems using Manx Aztec C ver 5.x. */ /* see jconfig.doc for explanations */ #define HAVE_PROTOTYPES #define HAVE_UNSIGNED_CHAR #define HAVE_UNSIGNED_SHORT /* #define void char */ /* #define const */ #undef CHAR_IS_UNSIGNED #define HAVE_STDDEF_H #define HAVE_STDLIB_H #undef NEED_BSD_STRINGS #undef NEED_SYS_TYPES_H #undef NEED_FAR_POINTERS #undef NEED_SHORT_EXTERNAL_NAMES #undef INCOMPLETE_TYPES_BROKEN #ifdef JPEG_INTERNALS #undef RIGHT_SHIFT_IS_UNSIGNED #define TEMP_DIRECTORY "JPEGTMP:" /* recommended setting for Amiga */ #define SHORTxSHORT_32 /* produces better DCT code with Aztec C */ #endif /* JPEG_INTERNALS */ #ifdef JPEG_CJPEG_DJPEG #define BMP_SUPPORTED /* BMP image file format */ #define GIF_SUPPORTED /* GIF image file format */ #define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ #undef RLE_SUPPORTED /* Utah RLE image file format */ #define TARGA_SUPPORTED /* Targa image file format */ #define TWO_FILE_COMMANDLINE #define NEED_SIGNAL_CATCHER #undef DONT_USE_B_MODE #undef PROGRESS_REPORT /* optional */ #define signal_catcher _abort /* hack for Aztec C naming requirements */ #endif /* JPEG_CJPEG_DJPEG */ Papyrus3/JpegDir/JpgLossy/jconfig.dj0000755000175000017500000000223507535143454014577 0ustar /* jconfig.dj --- jconfig.h for DJGPP (Delorie's GNU C port) on MS-DOS. */ /* see jconfig.doc for explanations */ #define HAVE_PROTOTYPES #define HAVE_UNSIGNED_CHAR #define HAVE_UNSIGNED_SHORT /* #define void char */ /* #define const */ #undef CHAR_IS_UNSIGNED #define HAVE_STDDEF_H #define HAVE_STDLIB_H #undef NEED_BSD_STRINGS #undef NEED_SYS_TYPES_H #undef NEED_FAR_POINTERS /* DJGPP uses flat 32-bit addressing */ #undef NEED_SHORT_EXTERNAL_NAMES #undef INCOMPLETE_TYPES_BROKEN #ifdef JPEG_INTERNALS #undef RIGHT_SHIFT_IS_UNSIGNED #endif /* JPEG_INTERNALS */ #ifdef JPEG_CJPEG_DJPEG #define BMP_SUPPORTED /* BMP image file format */ #define GIF_SUPPORTED /* GIF image file format */ #define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ #undef RLE_SUPPORTED /* Utah RLE image file format */ #define TARGA_SUPPORTED /* Targa image file format */ #undef TWO_FILE_COMMANDLINE /* optional */ #define USE_SETMODE /* Needed to make one-file style work in DJGPP */ #undef NEED_SIGNAL_CATCHER /* Define this if you use jmemname.c */ #undef DONT_USE_B_MODE #undef PROGRESS_REPORT /* optional */ #endif /* JPEG_CJPEG_DJPEG */ Papyrus3/JpegDir/JpgLossy/CKCONFIG.C0000755000175000017500000003043007535143454014126 0ustar /* * ckconfig.c * * Copyright (C) 1991-1994, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. */ /* * This program is intended to help you determine how to configure the JPEG * software for installation on a particular system. The idea is to try to * compile and execute this program. If your compiler fails to compile the * program, make changes as indicated in the comments below. Once you can * compile the program, run it, and it will produce a "jconfig.h" file for * your system. * * As a general rule, each time you try to compile this program, * pay attention only to the *first* error message you get from the compiler. * Many C compilers will issue lots of spurious error messages once they * have gotten confused. Go to the line indicated in the first error message, * and read the comments preceding that line to see what to change. * * Almost all of the edits you may need to make to this program consist of * changing a line that reads "#define SOME_SYMBOL" to "#undef SOME_SYMBOL", * or vice versa. This is called defining or undefining that symbol. */ /* First we must see if your system has the include files we need. * We start out with the assumption that your system has all the ANSI-standard * include files. If you get any error trying to include one of these files, * undefine the corresponding HAVE_xxx symbol. */ #define HAVE_STDDEF_H /* replace 'define' by 'undef' if error here */ #ifdef HAVE_STDDEF_H /* next line will be skipped if you undef... */ #include #endif #define HAVE_STDLIB_H /* same thing for stdlib.h */ #ifdef HAVE_STDLIB_H #include #endif #include /* If you ain't got this, you ain't got C. */ /* We have to see if your string functions are defined by * strings.h (old BSD convention) or string.h (everybody else). * We try the non-BSD convention first; define NEED_BSD_STRINGS * if the compiler says it can't find string.h. */ #undef NEED_BSD_STRINGS #ifdef NEED_BSD_STRINGS #include #else #include #endif /* On some systems (especially older Unix machines), type size_t is * defined only in the include file . If you get a failure * on the size_t test below, try defining NEED_SYS_TYPES_H. */ #undef NEED_SYS_TYPES_H /* start by assuming we don't need it */ #ifdef NEED_SYS_TYPES_H #include #endif /* Usually type size_t is defined in one of the include files we've included * above. If not, you'll get an error on the "typedef size_t my_size_t;" line. * In that case, first try defining NEED_SYS_TYPES_H just above. * If that doesn't work, you'll have to search through your system library * to figure out which include file defines "size_t". Look for a line that * says "typedef something-or-other size_t;". Then, change the line below * that says "#include " to instead include the file * you found size_t in, and define NEED_SPECIAL_INCLUDE. If you can't find * type size_t anywhere, try replacing "#include " with * "typedef unsigned int size_t;". */ #undef NEED_SPECIAL_INCLUDE /* assume we DON'T need it, for starters */ #ifdef NEED_SPECIAL_INCLUDE #include #endif typedef size_t my_size_t; /* The payoff: do we have size_t now? */ /* The next question is whether your compiler supports ANSI-style function * prototypes. You need to know this in order to choose between using * makefile.ansi and using makefile.unix. * The #define line below is set to assume you have ANSI function prototypes. * If you get an error in this group of lines, undefine HAVE_PROTOTYPES. */ #define HAVE_PROTOTYPES #ifdef HAVE_PROTOTYPES int testfunction (int arg1, int * arg2); /* check prototypes */ struct methods_struct { /* check method-pointer declarations */ int (*error_exit) (char *msgtext); int (*trace_message) (char *msgtext); int (*another_method) (void); }; int testfunction (int arg1, int * arg2) /* check definitions */ { return arg2[arg1]; } int test2function (void) /* check void arg list */ { return 0; } #endif /* Now we want to find out if your compiler knows what "unsigned char" means. * If you get an error on the "unsigned char un_char;" line, * then undefine HAVE_UNSIGNED_CHAR. */ #define HAVE_UNSIGNED_CHAR #ifdef HAVE_UNSIGNED_CHAR unsigned char un_char; #endif /* Now we want to find out if your compiler knows what "unsigned short" means. * If you get an error on the "unsigned short un_short;" line, * then undefine HAVE_UNSIGNED_SHORT. */ #define HAVE_UNSIGNED_SHORT #ifdef HAVE_UNSIGNED_SHORT unsigned short un_short; #endif /* Now we want to find out if your compiler understands type "void". * If you get an error anywhere in here, undefine HAVE_VOID. */ #define HAVE_VOID #ifdef HAVE_VOID /* Caution: a C++ compiler will insist on complete prototypes */ typedef void * void_ptr; /* check void * */ #ifdef HAVE_PROTOTYPES /* check ptr to function returning void */ typedef void (*void_func) (int a, int b); #else typedef void (*void_func) (); #endif #ifdef HAVE_PROTOTYPES /* check void function result */ void test3function (void_ptr arg1, void_func arg2) #else void test3function (arg1, arg2) void_ptr arg1; void_func arg2; #endif { char * locptr = (char *) arg1; /* check casting to and from void * */ arg1 = (void *) locptr; (*arg2) (1, 2); /* check call of fcn returning void */ } #endif /* Now we want to find out if your compiler knows what "const" means. * If you get an error here, undefine HAVE_CONST. */ #define HAVE_CONST #ifdef HAVE_CONST static const int carray[3] = {1, 2, 3}; #ifdef HAVE_PROTOTYPES int test4function (const int arg1) #else int test4function (arg1) const int arg1; #endif { return carray[arg1]; } #endif /* If you get an error or warning about this structure definition, * define INCOMPLETE_TYPES_BROKEN. */ #undef INCOMPLETE_TYPES_BROKEN #ifndef INCOMPLETE_TYPES_BROKEN typedef struct undefined_structure * undef_struct_ptr; #endif /* If you get an error about duplicate names, * define NEED_SHORT_EXTERNAL_NAMES. */ #undef NEED_SHORT_EXTERNAL_NAMES #ifndef NEED_SHORT_EXTERNAL_NAMES int possibly_duplicate_function () { return 0; } int possibly_dupli_function () { return 1; } #endif /************************************************************************ * OK, that's it. You should not have to change anything beyond this * point in order to compile and execute this program. (You might get * some warnings, but you can ignore them.) * When you run the program, it will make a couple more tests that it * can do automatically, and then it will create jconfig.h and print out * any additional suggestions it has. ************************************************************************ */ #ifdef HAVE_PROTOTYPES int is_char_signed (int arg) #else int is_char_signed (arg) int arg; #endif { if (arg == 189) { /* expected result for unsigned char */ return 0; /* type char is unsigned */ } else if (arg != -67) { /* expected result for signed char */ printf("Hmm, it seems 'char' is not eight bits wide on your machine.\n"); printf("I fear the JPEG software will not work at all.\n\n"); } return 1; /* assume char is signed otherwise */ } #ifdef HAVE_PROTOTYPES int is_shifting_signed (long arg) #else int is_shifting_signed (arg) long arg; #endif /* See whether right-shift on a long is signed or not. */ { long res = arg >> 4; if (res == -0x7F7E80CL) { /* expected result for signed shift */ return 1; /* right shift is signed */ } /* see if unsigned-shift hack will fix it. */ /* we can't just test exact value since it depends on width of long... */ res |= (~0L) << (32-4); if (res == -0x7F7E80CL) { /* expected result now? */ return 0; /* right shift is unsigned */ } printf("Right shift isn't acting as I expect it to.\n"); printf("I fear the JPEG software will not work at all.\n\n"); return 0; /* try it with unsigned anyway */ } #ifdef HAVE_PROTOTYPES int main (int argc, char ** argv) #else int main (argc, argv) int argc; char ** argv; #endif { char signed_char_check = (char) (-67); FILE *outfile; /* Attempt to write jconfig.h */ if ((outfile = fopen("jconfig.h", "w")) == NULL) { printf("Failed to write jconfig.h\n"); return 1; } /* Write out all the info */ fprintf(outfile, "/* jconfig.h --- generated by ckconfig.c */\n"); fprintf(outfile, "/* see jconfig.doc for explanations */\n\n"); #ifdef HAVE_PROTOTYPES fprintf(outfile, "#define HAVE_PROTOTYPES\n"); #else fprintf(outfile, "#undef HAVE_PROTOTYPES\n"); #endif #ifdef HAVE_UNSIGNED_CHAR fprintf(outfile, "#define HAVE_UNSIGNED_CHAR\n"); #else fprintf(outfile, "#undef HAVE_UNSIGNED_CHAR\n"); #endif #ifdef HAVE_UNSIGNED_SHORT fprintf(outfile, "#define HAVE_UNSIGNED_SHORT\n"); #else fprintf(outfile, "#undef HAVE_UNSIGNED_SHORT\n"); #endif #ifdef HAVE_VOID fprintf(outfile, "/* #define void char */\n"); #else fprintf(outfile, "#define void char\n"); #endif #ifdef HAVE_CONST fprintf(outfile, "/* #define const */\n"); #else fprintf(outfile, "#define const\n"); #endif if (is_char_signed((int) signed_char_check)) fprintf(outfile, "#undef CHAR_IS_UNSIGNED\n"); else fprintf(outfile, "#define CHAR_IS_UNSIGNED\n"); #ifdef HAVE_STDDEF_H fprintf(outfile, "#define HAVE_STDDEF_H\n"); #else fprintf(outfile, "#undef HAVE_STDDEF_H\n"); #endif #ifdef HAVE_STDLIB_H fprintf(outfile, "#define HAVE_STDLIB_H\n"); #else fprintf(outfile, "#undef HAVE_STDLIB_H\n"); #endif #ifdef NEED_BSD_STRINGS fprintf(outfile, "#define NEED_BSD_STRINGS\n"); #else fprintf(outfile, "#undef NEED_BSD_STRINGS\n"); #endif #ifdef NEED_SYS_TYPES_H fprintf(outfile, "#define NEED_SYS_TYPES_H\n"); #else fprintf(outfile, "#undef NEED_SYS_TYPES_H\n"); #endif fprintf(outfile, "#undef NEED_FAR_POINTERS\n"); #ifdef NEED_SHORT_EXTERNAL_NAMES fprintf(outfile, "#define NEED_SHORT_EXTERNAL_NAMES\n"); #else fprintf(outfile, "#undef NEED_SHORT_EXTERNAL_NAMES\n"); #endif #ifdef INCOMPLETE_TYPES_BROKEN fprintf(outfile, "#define INCOMPLETE_TYPES_BROKEN\n"); #else fprintf(outfile, "#undef INCOMPLETE_TYPES_BROKEN\n"); #endif fprintf(outfile, "\n#ifdef JPEG_INTERNALS\n\n"); if (is_shifting_signed(-0x7F7E80B1L)) fprintf(outfile, "#undef RIGHT_SHIFT_IS_UNSIGNED\n"); else fprintf(outfile, "#define RIGHT_SHIFT_IS_UNSIGNED\n"); fprintf(outfile, "\n#endif /* JPEG_INTERNALS */\n"); fprintf(outfile, "\n#ifdef JPEG_CJPEG_DJPEG\n\n"); fprintf(outfile, "#define BMP_SUPPORTED /* BMP image file format */\n"); fprintf(outfile, "#define GIF_SUPPORTED /* GIF image file format */\n"); fprintf(outfile, "#define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */\n"); fprintf(outfile, "#undef RLE_SUPPORTED /* Utah RLE image file format */\n"); fprintf(outfile, "#define TARGA_SUPPORTED /* Targa image file format */\n\n"); fprintf(outfile, "#undef TWO_FILE_COMMANDLINE /* You may need this on non-Unix systems */\n"); fprintf(outfile, "#undef NEED_SIGNAL_CATCHER /* Define this if you use jmemname.c */\n"); fprintf(outfile, "#undef DONT_USE_B_MODE\n"); fprintf(outfile, "/* #define PROGRESS_REPORT */ /* optional */\n"); fprintf(outfile, "\n#endif /* JPEG_CJPEG_DJPEG */\n"); /* Close the jconfig.h file */ fclose(outfile); /* User report */ printf("Configuration check for Independent JPEG Group's software done.\n"); printf("\nI have written the jconfig.h file for you.\n\n"); #ifdef HAVE_PROTOTYPES printf("You should use makefile.ansi as the starting point for your Makefile.\n"); #else printf("You should use makefile.unix as the starting point for your Makefile.\n"); #endif #ifdef NEED_SPECIAL_INCLUDE printf("\nYou'll need to change jconfig.h to include the system include file\n"); printf("that you found type size_t in, or add a direct definition of type\n"); printf("size_t if that's what you used. Just add it to the end.\n"); #endif return 0; } Papyrus3/JpegDir/JpgLossy/RDJPGCOM.C0000755000175000017500000003404707535143454014160 0ustar /* * rdjpgcom.c * * Copyright (C) 1994-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains a very simple stand-alone application that displays * the text in COM (comment) markers in a JFIF file. * This may be useful as an example of the minimum logic needed to parse * JPEG markers. */ #define JPEG_CJPEG_DJPEG /* to get the command-line config symbols */ #include "jinclude.h" /* get auto-config symbols, */ #include /* to declare isupper(), tolower() */ #ifdef USE_SETMODE #include /* to declare setmode()'s parameter macros */ /* If you have setmode() but not , just delete this line: */ #include /* to declare setmode() */ #endif #ifdef USE_CCOMMAND /* command-line reader for Macintosh */ #ifdef __MWERKS__ #include /* Metrowerks needs this */ #include /* ... and this */ #endif #ifdef THINK_C #include /* Think declares it here */ #endif #endif #ifdef DONT_USE_B_MODE /* define mode parameters for fopen() */ #define READ_BINARY "r" #else #ifdef VMS /* VMS is very nonstandard */ #define READ_BINARY "rb", "ctx=stm" #else /* standard ANSI-compliant case */ #define READ_BINARY "rb" #endif #endif #ifndef EXIT_FAILURE /* define exit() codes if not provided */ #define EXIT_FAILURE 1 #endif #ifndef EXIT_SUCCESS #ifdef VMS #define EXIT_SUCCESS 1 /* VMS is very nonstandard */ #else #define EXIT_SUCCESS 0 #endif #endif /* * These macros are used to read the input file. * To reuse this code in another application, you might need to change these. */ static FILE * infile; /* input JPEG file */ /* Return next input byte, or EOF if no more */ #define NEXTBYTE() getc(infile) /* Error exit handler */ #define ERREXIT(msg) (fprintf(stderr, "%s\n", msg), exit(EXIT_FAILURE)) /* Read one byte, testing for EOF */ static int read_1_byte (void) { int c; c = NEXTBYTE(); if (c == EOF) ERREXIT("Premature EOF in JPEG file"); return c; } /* Read 2 bytes, convert to unsigned int */ /* All 2-byte quantities in JPEG markers are MSB first */ static unsigned int read_2_bytes (void) { int c1, c2; c1 = NEXTBYTE(); if (c1 == EOF) ERREXIT("Premature EOF in JPEG file"); c2 = NEXTBYTE(); if (c2 == EOF) ERREXIT("Premature EOF in JPEG file"); return (((unsigned int) c1) << 8) + ((unsigned int) c2); } /* * JPEG markers consist of one or more 0xFF bytes, followed by a marker * code byte (which is not an FF). Here are the marker codes of interest * in this program. (See jdmarker.c for a more complete list.) */ #define M_SOF0 0xC0 /* Start Of Frame N */ #define M_SOF1 0xC1 /* N indicates which compression process */ #define M_SOF2 0xC2 /* Only SOF0-SOF2 are now in common use */ #define M_SOF3 0xC3 #define M_SOF5 0xC5 /* NB: codes C4 and CC are NOT SOF markers */ #define M_SOF6 0xC6 #define M_SOF7 0xC7 #define M_SOF9 0xC9 #define M_SOF10 0xCA #define M_SOF11 0xCB #define M_SOF13 0xCD #define M_SOF14 0xCE #define M_SOF15 0xCF #define M_SOI 0xD8 /* Start Of Image (beginning of datastream) */ #define M_EOI 0xD9 /* End Of Image (end of datastream) */ #define M_SOS 0xDA /* Start Of Scan (begins compressed data) */ #define M_APP0 0xE0 /* Application-specific marker, type N */ #define M_APP12 0xEC /* (we don't bother to list all 16 APPn's) */ #define M_COM 0xFE /* COMment */ /* * Find the next JPEG marker and return its marker code. * We expect at least one FF byte, possibly more if the compressor used FFs * to pad the file. * There could also be non-FF garbage between markers. The treatment of such * garbage is unspecified; we choose to skip over it but emit a warning msg. * NB: this routine must not be used after seeing SOS marker, since it will * not deal correctly with FF/00 sequences in the compressed image data... */ static int next_marker (void) { int c; int discarded_bytes = 0; /* Find 0xFF byte; count and skip any non-FFs. */ c = read_1_byte(); while (c != 0xFF) { discarded_bytes++; c = read_1_byte(); } /* Get marker code byte, swallowing any duplicate FF bytes. Extra FFs * are legal as pad bytes, so don't count them in discarded_bytes. */ do { c = read_1_byte(); } while (c == 0xFF); if (discarded_bytes != 0) { fprintf(stderr, "Warning: garbage data found in JPEG file\n"); } return c; } /* * Read the initial marker, which should be SOI. * For a JFIF file, the first two bytes of the file should be literally * 0xFF M_SOI. To be more general, we could use next_marker, but if the * input file weren't actually JPEG at all, next_marker might read the whole * file and then return a misleading error message... */ static int first_marker (void) { int c1, c2; c1 = NEXTBYTE(); c2 = NEXTBYTE(); if (c1 != 0xFF || c2 != M_SOI) ERREXIT("Not a JPEG file"); return c2; } /* * Most types of marker are followed by a variable-length parameter segment. * This routine skips over the parameters for any marker we don't otherwise * want to process. * Note that we MUST skip the parameter segment explicitly in order not to * be fooled by 0xFF bytes that might appear within the parameter segment; * such bytes do NOT introduce new markers. */ static void skip_variable (void) /* Skip over an unknown or uninteresting variable-length marker */ { unsigned int length; /* Get the marker parameter length count */ length = read_2_bytes(); /* Length includes itself, so must be at least 2 */ if (length < 2) ERREXIT("Erroneous JPEG marker length"); length -= 2; /* Skip over the remaining bytes */ while (length > 0) { (void) read_1_byte(); length--; } } /* * Process a COM marker. * We want to print out the marker contents as legible text; * we must guard against non-text junk and varying newline representations. */ static void process_COM (void) { unsigned int length; int ch; int lastch = 0; /* Get the marker parameter length count */ length = read_2_bytes(); /* Length includes itself, so must be at least 2 */ if (length < 2) ERREXIT("Erroneous JPEG marker length"); length -= 2; while (length > 0) { ch = read_1_byte(); /* Emit the character in a readable form. * Nonprintables are converted to \nnn form, * while \ is converted to \\. * Newlines in CR, CR/LF, or LF form will be printed as one newline. */ if (ch == '\r') { printf("\n"); } else if (ch == '\n') { if (lastch != '\r') printf("\n"); } else if (ch == '\\') { printf("\\\\"); } else if (isprint(ch)) { putc(ch, stdout); } else { printf("\\%03o", ch); } lastch = ch; length--; } printf("\n"); } /* * Process a SOFn marker. * This code is only needed if you want to know the image dimensions... */ static void process_SOFn (int marker) { unsigned int length; unsigned int image_height, image_width; int data_precision, num_components; const char * process; int ci; length = read_2_bytes(); /* usual parameter length count */ data_precision = read_1_byte(); image_height = read_2_bytes(); image_width = read_2_bytes(); num_components = read_1_byte(); switch (marker) { case M_SOF0: process = "Baseline"; break; case M_SOF1: process = "Extended sequential"; break; case M_SOF2: process = "Progressive"; break; case M_SOF3: process = "Lossless"; break; case M_SOF5: process = "Differential sequential"; break; case M_SOF6: process = "Differential progressive"; break; case M_SOF7: process = "Differential lossless"; break; case M_SOF9: process = "Extended sequential, arithmetic coding"; break; case M_SOF10: process = "Progressive, arithmetic coding"; break; case M_SOF11: process = "Lossless, arithmetic coding"; break; case M_SOF13: process = "Differential sequential, arithmetic coding"; break; case M_SOF14: process = "Differential progressive, arithmetic coding"; break; case M_SOF15: process = "Differential lossless, arithmetic coding"; break; default: process = "Unknown"; break; } printf("JPEG image is %uw * %uh, %d color components, %d bits per sample\n", image_width, image_height, num_components, data_precision); printf("JPEG process: %s\n", process); if (length != (unsigned int) (8 + num_components * 3)) ERREXIT("Bogus SOF marker length"); for (ci = 0; ci < num_components; ci++) { (void) read_1_byte(); /* Component ID code */ (void) read_1_byte(); /* H, V sampling factors */ (void) read_1_byte(); /* Quantization table number */ } } /* * Parse the marker stream until SOS or EOI is seen; * display any COM markers. * While the companion program wrjpgcom will always insert COM markers before * SOFn, other implementations might not, so we scan to SOS before stopping. * If we were only interested in the image dimensions, we would stop at SOFn. * (Conversely, if we only cared about COM markers, there would be no need * for special code to handle SOFn; we could treat it like other markers.) */ static int scan_JPEG_header (int verbose) { int marker; /* Expect SOI at start of file */ if (first_marker() != M_SOI) ERREXIT("Expected SOI marker first"); /* Scan miscellaneous markers until we reach SOS. */ for (;;) { marker = next_marker(); switch (marker) { /* Note that marker codes 0xC4, 0xC8, 0xCC are not, and must not be, * treated as SOFn. C4 in particular is actually DHT. */ case M_SOF0: /* Baseline */ case M_SOF1: /* Extended sequential, Huffman */ case M_SOF2: /* Progressive, Huffman */ case M_SOF3: /* Lossless, Huffman */ case M_SOF5: /* Differential sequential, Huffman */ case M_SOF6: /* Differential progressive, Huffman */ case M_SOF7: /* Differential lossless, Huffman */ case M_SOF9: /* Extended sequential, arithmetic */ case M_SOF10: /* Progressive, arithmetic */ case M_SOF11: /* Lossless, arithmetic */ case M_SOF13: /* Differential sequential, arithmetic */ case M_SOF14: /* Differential progressive, arithmetic */ case M_SOF15: /* Differential lossless, arithmetic */ if (verbose) process_SOFn(marker); else skip_variable(); break; case M_SOS: /* stop before hitting compressed data */ return marker; case M_EOI: /* in case it's a tables-only JPEG stream */ return marker; case M_COM: process_COM(); break; case M_APP12: /* Some digital camera makers put useful textual information into * APP12 markers, so we print those out too when in -verbose mode. */ if (verbose) { printf("APP12 contains:\n"); process_COM(); } else skip_variable(); break; default: /* Anything else just gets skipped */ skip_variable(); /* we assume it has a parameter count... */ break; } } /* end loop */ } /* Command line parsing code */ static const char * progname; /* program name for error messages */ static void usage (void) /* complain about bad command line */ { fprintf(stderr, "rdjpgcom displays any textual comments in a JPEG file.\n"); fprintf(stderr, "Usage: %s [switches] [inputfile]\n", progname); fprintf(stderr, "Switches (names may be abbreviated):\n"); fprintf(stderr, " -verbose Also display dimensions of JPEG image\n"); exit(EXIT_FAILURE); } static int keymatch (char * arg, const char * keyword, int minchars) /* Case-insensitive matching of (possibly abbreviated) keyword switches. */ /* keyword is the constant keyword (must be lower case already), */ /* minchars is length of minimum legal abbreviation. */ { register int ca, ck; register int nmatched = 0; while ((ca = *arg++) != '\0') { if ((ck = *keyword++) == '\0') return 0; /* arg longer than keyword, no good */ if (isupper(ca)) /* force arg to lcase (assume ck is already) */ ca = tolower(ca); if (ca != ck) return 0; /* no good */ nmatched++; /* count matched characters */ } /* reached end of argument; fail if it's too short for unique abbrev */ if (nmatched < minchars) return 0; return 1; /* A-OK */ } /* * The main program. */ int main (int argc, char **argv) { int argn; char * arg; int verbose = 0; /* On Mac, fetch a command line. */ #ifdef USE_CCOMMAND argc = ccommand(&argv); #endif progname = argv[0]; if (progname == NULL || progname[0] == 0) progname = "rdjpgcom"; /* in case C library doesn't provide it */ /* Parse switches, if any */ for (argn = 1; argn < argc; argn++) { arg = argv[argn]; if (arg[0] != '-') break; /* not switch, must be file name */ arg++; /* advance over '-' */ if (keymatch(arg, "verbose", 1)) { verbose++; } else usage(); } /* Open the input file. */ /* Unix style: expect zero or one file name */ if (argn < argc-1) { fprintf(stderr, "%s: only one input file\n", progname); usage(); } if (argn < argc) { if ((infile = fopen(argv[argn], READ_BINARY)) == NULL) { fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]); exit(EXIT_FAILURE); } } else { /* default input file is stdin */ #ifdef USE_SETMODE /* need to hack file mode? */ setmode(fileno(stdin), O_BINARY); #endif #ifdef USE_FDOPEN /* need to re-open in binary mode? */ if ((infile = fdopen(fileno(stdin), READ_BINARY)) == NULL) { fprintf(stderr, "%s: can't open stdin\n", progname); exit(EXIT_FAILURE); } #else infile = stdin; #endif } /* Scan the JPEG headers. */ (void) scan_JPEG_header(verbose); /* All done. */ exit(EXIT_SUCCESS); return 0; /* suppress no-return-value warnings */ } Papyrus3/JpegDir/JpgLossy/testimgp.jpg0000755000175000017500000001301507535143454015175 0ustar ÿØÿàJFIFÿÛC    $.' ",#(7),01444'9=82<.342ÿÛC  2!!22222222222222222222222222222222222222222222222222ÿ•ã"ÿÄÿÄÿÚ òÓ5Šجík.vuÓ*uiç¾}]Jç´½*Ò*y¤¥ÚnV­¥<Åuâ· ÕÙÍô´>wWQSŸ$ ´Á2Â]1Žiuv¥¥€Ò¬«=:ÓvJ]5ÕÕm1~ÞmËϸ<ü±éy÷Õ¹x׋»ÅËçMÁ§1¶[>_mÆ~g¹ÅÒ¾6ýlüµÂκ%Ø‹Mùû—k‚^‚ðô´ÅEÌõ]éh£¥¥èº>[Ö[ç'®°¼¸eù….%+ÑÃ.=-9{»53V|Ïv‚œ…RYX­ƒzËѧšºF”O_—Ñ#BÝ΢õ}/‰yð=3üÞ»gœ/O,“×K4tÎvîÒÌæÙ<^Î𔙊 ²'[.b²jMf'Ng”×ÊÛÇ¿mœý2ðu[&M–P³`ÝÍÔôèt1ìôª^92º÷yýÛy·¬=2hÌ(ų›ÉºÂpŠÙm׋[®<6îWÄ(‡K’i{SHo==1!²ãÃy›§/O4ZÒîÌÛ0δ¢5ØçKl!bÍEjÜšÞ†<­Ì×”ùôïùÿ@¢ö3Êi*SP ô’NÌêt=/ËÑôO”kû}íòÔK¹9õenX€hÁX+0oVlíÏ¡K±‰ÞàvP>¹Ù4ÎsÊž¨Ƭڈ÷,­˜#Òè+U Ã7’ö¢×æYýç}zºó¡iÈjÈÝ.|0¢(eNžÀnf;(Â0¡íX&Ñ°{Œ!Œõ™€ÀXbØ ¨@™tã+ ²» £2æ\AæM1‹†‰`„­ùçëU9v Ú»8’=7)-*â …{ÊÛNü`É=FÌXOÍܸ6¨w1Sm—¸¿"O§(L™ H³’{ëÓ‰£T>?µ¢6«žØ LíÀÏËwjLl7†~1 1cËqˆÖ,u)¨aŠ/o y)Sé ÌÓرÄ,"/ó4¿w#L§ºx¹pµçÈl‰P[œ(«2dP­8ÃB„ò†ª+ñ¾¹÷œ?qÇ<›Úƒ GäÓÛŠÓاÆs1Û·ç™Êðè¾ÝqñMCÒãFÈͧqøÎ1;L,#0žà§~[+q„ÞíØlÂWs.'ÉØ÷¦Èút&mHÈãÄ©SŒ­¬ÃbŠA•[ÿ`v½Ýš1µ …YÙâýKôÔ'Œ$ßAŠ˜¼šT©íƒ(ÞeÎSœ&åì% «Gk‹å~›¡æ=…Ïøæ)—M9÷˜DrVî:ǘٞíï€Ú³Y„÷èôàµ5:uÊ™pñË¡Ð…™ô ’dÆØš?Ž ¦Û%î ñ17/³dùo„“*#Ž~+¢å•ŠÌ¸S2êtO‚7UK㇢ç#A®d5£ÜÅô?€Ü˜ éÍéز̞•œLØ2`;8-Þ_T­­˜ÚÁ¾Ÿî!ý¼¹ ÃŽÏCyÛÖ?ØØ-—ÀÂ:PY{OùÏÿÄ&!1 A2Q"BÿÚ?õÁ’¸>oò9gÊ”6ë’vnõZ/\1cgÁ3&9F[b?ã”ÿë“úÙ¯³/,}’FÖŽ4—Fãe7Q1ø“»‘8ÛÀí;ìÊââìŸ|z4cÂç*F,QÅ"Û² “b}œ.l¿Ùùt8¸ödWŠC—ÑkG#œ^ãu•Q‹¡4¹>FÉBÍ”q|•ždöcÛû½ôæ4Š%‡„±c#î½? ªÈJ:ÙÉÈ’&ÆúÑ7H—i•Š5(¡£“­bPÿ0ºQDÕ”i…é!/ÜJ6j×j(¼/I Ì1ù”,?æ?ÿÄ* !01"AQa@23bqr‘ÿÚ?ûÒn Ÿ¦*ìv5oÍY+4ÙåG•–Ál…øW<©‡‹°²…'c-›zû6ðº–ØqàÜc²4¹Ú!x³*¡éK–›æÈPlÏ-ž\´4¶KD£›§L…†/–’ áuByY°†Ùƒ ó^Jô²°¿µ44¡VMæ¯MªÎl‹¿Vïî´ŽJ„<ýü®ŸöØh+ª5 )ãoÞñöÑñSÕÜ©%ö¹¿W…=Û•ÎÜ•1¤,pò¦è *3 ï{;¦B4„+<©£¦¥¦±k‚P€úÔ6šÄ©Tyبî„.šz*]:jQòSÎXÀ¾FÌÍ¡èþ6H9ØÃÿÿÄ"!1AQa q‘¡±ÿÚ?!L¥/Á.ûb¡à£|Qt+Žj‚q(r“b|o\'Ë—FÊ%+ƒ=‡²”˜¢Q B„=EÑ<Œ¾)Á' aÚišÃux˜½é‘Z±ÍQHŒNeƒ}‹1&" A¡|*¢¹HUÑüòoײ»ÿ “H&ÚÂ.-ŒCÇ=ç#Aþ”¦ü3nƒmD(d{‡ÔÊEC*`oŠé˜Û !¦Ýo"Ta¢bD1lo¶]1¬m —=šTËö/ø¥D½ 2`I”àJ1¨HÑÐq¼h„YOÁFØ¢ÑfàðÌeü ;©öDˆ¡jŒt†”XhhcO‚V7¦t84?7‘í˜ø¤!²,F£]ÿ°Ó°é4"#,Ž„›N2 x2©6þˆÚ183[[ø ·k²ÈŸZ9èQ$x%ðXDß’[c@› Œ·Ø×#(Á{>Ø´]Ž%9دÌx†.x±Û2Œ}X(xJìESØå±²#g ApÕ2‘©‘ý<ÁŽXg§³EètúæÆWOÈ“ôZ"'“éÌoBN­¯F‡“3³ô¶¸oÌf?ß1â™:”fO’bPUCv‡ØRÝW®0ЦH£ìL†{FWè«+^Q°Û¾ÈCÂ+ÏCììzç¢^Š*Ì/4S*‹DçhHàmÖ7h„kÓxFœOÉÔÙX­ c'é®4)L_93õCèÜ2•î.(öA$¢‚"™£Hf BF†ØƯ|'´'¡ßBSe9D»lÐVý¹Ó‚ϧFCìÅ­¢ÐÇ~xRò,È E`lRŽÁ–3:œ·VÓ2²ØÕ*Wh§ÃÁÒ¸ÂôÃœÚ&©Œ ±(­ñQý_鈨i&Ì^É´Š6P N7a‹1Ò%è$á¬F Óö=B,+fÛ/ŒLÚdex¡xOðSE{¾4lltiœ52„È'Õ¢àÍøôy:× R¾(Уƒ¦:³È>[ãcšál~"ñÐƪ­ ·o‹Š2¾ ýI…£¬5ºÆ{®í:ò†ÎÿؾÍÃ\AcDãQ|(‚‘t„ü›þ±!aTɵÇÃh±”ñ¯à×5zpC²ò²™’›Ù¡“Îôf Á˜ÑA°|Ù8N+ða3%¥¨¾Î× éìU‚¹CKÀæh‰„Œ:ƒy?ÿÚ Ü猿¡%á×pð[|·‹ Çž#å8;/±9ëKËY¬Y =AN-§}zr=Ì4QÊ×õ–i< [ÄmºýÂ_6Vpݵ ÄÈSÃàÃNç-w4Í>h‹Š?~,ÍL`Àßñϼ‹À|€?ÿÄ#!1AQa q‘¡±ðÿÚ?L¥á Ø%n»,‡"Òm–èU ‹Ñ-àÀ‰F„ XÒ¿ì%KµŒ>ÅZ,¿w¸Yòg²^‡7°Ê!…!7dSX¦:ÙGX³†“Ø+.˜›óà Á–Z³ ª‡f‰oØ‘zÙ!ÙàBFëRj_À¦†1"3× &ðLžJÖ”´X ‰”²,I!"„ßð$bd¥r :9ˆÙ¡bM™¦ú °QVf÷¿Âô^ÙgÐuhvñO ÌU®ŠFGCZÎüvBñ›7RBü‚šÂ%HleL5®_´E3ÃܱàÊé|Šh[Ì"ç§:6·±ù½ \ÿÄ!1QAaqÿÚ?K,²gí+b½L;Æ9ÍuÍÒíÀ1:“òþð¦ÅoȽ¾BinØŸ‹On öY˜·Ì?l¥oRzX7…N:,¬ëä³»3»úÌXéÙE³ ³mc±>Þ…„»=!=gRà £–ûZ ;ÊߣhÙk^ά]cÀö ›nñ©ÐÞû zµ$nT=î(€ðîüÁ½¶rîq/Ö%¼‚Ë#îÁå“®ãÂYmÛƒÿqÑK®yux•ï‰¼^Óìùy¼qíxqÿÄ'!1AQaq‘¡Ñ±Á áðñÿÚ?ô;ÊŘ€JÈ‹8ÌEP©Ü4cè–MŒ(§L$eEX™\D(2ÂY«gpø¼¤¬¨Œl—0ƒs&á‚RÃ1^ñ*9ú 2Š`ÅÌ!šˆ±óQõèj &ˆŠërŒÊÂRÂ3"D©hHÝzT÷,˜†Á1Tø–ªéŠ*Æ‚U,ê]B`À³­,Cq¨b(É<¸ÔÂK±ŠªÔø$Zá^`LçAìô`¢8Êi›*ÄmtpÁJ°–åØÏ üÍŠQÒ÷…@÷î=l"­ M~¢’‰ËÏD4 1– J;pË”ýÉÁ¾‘)€8§’R\Œ ~¥»PR߈öÝj 2üç iôÍ— ¬Q5:bdÁó JvWaÖ.“lDÅ6¬]<%ÊO+ú‚ˆÐÄEÝÍ…¦8ñº0½Àßȵ åXy¿<¤[|Ķ‰Mw8çÔESñ‡¤²`"€hfH £q7KZeBIÀæT«™¬ð͸<3Ùˆ¨ß–´O¶£åKØiðœÊ=+ú¢©È¨ƒ*ûA¬ÉLeXI±26AÀ›*­i˜IFÚÛ)Â- ó/+ñpÏÂŽñÄ£›`…•‘°©X¬ÝÆ/´¤“E'¾(“'ØÌA­w gˆJ\Ë…yï 2Ëf ±Z=à×tqsþ¢à,²w›Ç_êòaúF`ß´¼^£Ü)ãPEV–Z«øŒn_àýC,r=ã ~ƒUY€Úi.O2á•f#PÛDYEtu«9â #˜À–Ó°8šÄ£¢T*Þ¼D¬ó1Éˈݓ`8<ùŽ®#Æ ¸ûCOßõ®8‘Ëd¨{ª%,-ï MÛÉp±-Œ¨ù˜yìDoÏP`ûÎVƽ@3=_®¥Xx!“o‚5_#Q#ZãÙRº|BÅ #(ß?@†IJqŠ‰K?†?1VyX6áÏãïPõ. x¥HSžYSA  å·H¶ÆŽZß32³ÄÝ[úÿ¹8]¹Ef-Ã7p:YopA´a%\«¨AŒ~aZWÌÛ€GŠ´. t\ö"ÅÔVõŒËRe Âø™»Ž­1³—‹¨²WdŸøK¬ ±VŒ&z6ÚÛŠh¥Ù²órœœÇža„Œ)XX¾\~áªhe^¡"ÚãÛ‰Ul“ËVàÔYªØ且±¬§áŽa$2á”Y 0! @r/ý@‘ÂÇÙê\Ñ%ìæV™ÃW˜õE{ľ_0Î^!¨+Ð.nœÿýÜK®_ö„B§ÁCÉ—æ„Q3¹Iˆ•‘J‚K• `⌲» à4D/kl%Ljyª“Îÿ0EZý£«Y4 µCe4vGžbes˜`<ƱÂòö·-fxFänqqÅ/¤ˆ‰L®Q œü£§ŒY÷5Š£dY—liˆæ¯4þ#€Ámÿˆ!’]EÌÁ\wÅôZˆô(÷É@¶Z såLÌмK2à% <uNwŸRÁ¿59ŠXêP Ž£B«¥L¯²Ó÷~zø……ðé;IxÌFÙ´b„F\DP{@M¬Ñ//Ó|±¾ÛbŒà¸°C;îZ·DVžýIÎRš+eµ°Ý…#¯mñE<‚äìx—3t¤:…KZÜ9‰q5O1L:‹àûSˆÜeÍ£˜rE Ú„”Ó/‘ÊFíÄ3èLήᄕˆ„¢y ž§[ˆ%ó½™fÛçô¨õáY_OîWéј|2”hqž=C#´¾c™òÇÆUâ&/Fn=œuÓ¢/PÜ@Ç©ˆÅXˆRÍL"ƒR΋3@ôX7sx‹Ès8‹+ÇíZo »ji€¶›ñ³$±a^•˜3dA§Qì'P…Ôcó?ÿÙPapyrus3/JpegDir/JpgLossy/JDMAINCT.C0000755000175000017500000005061607535143454014144 0ustar /* * jdmainct.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains the main buffer controller for decompression. * The main buffer lies between the JPEG decompressor proper and the * post-processor; it holds downsampled data in the JPEG colorspace. * * Note that this code is bypassed in raw-data mode, since the application * supplies the equivalent of the main buffer in that case. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* * In the current system design, the main buffer need never be a full-image * buffer; any full-height buffers will be found inside the coefficient or * postprocessing controllers. Nonetheless, the main controller is not * trivial. Its responsibility is to provide context rows for upsampling/ * rescaling, and doing this in an efficient fashion is a bit tricky. * * Postprocessor input data is counted in "row groups". A row group * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size) * sample rows of each component. (We require DCT_scaled_size values to be * chosen such that these numbers are integers. In practice DCT_scaled_size * values will likely be powers of two, so we actually have the stronger * condition that DCT_scaled_size / min_DCT_scaled_size is an integer.) * Upsampling will typically produce max_v_samp_factor pixel rows from each * row group (times any additional scale factor that the upsampler is * applying). * * The coefficient controller will deliver data to us one iMCU row at a time; * each iMCU row contains v_samp_factor * DCT_scaled_size sample rows, or * exactly min_DCT_scaled_size row groups. (This amount of data corresponds * to one row of MCUs when the image is fully interleaved.) Note that the * number of sample rows varies across components, but the number of row * groups does not. Some garbage sample rows may be included in the last iMCU * row at the bottom of the image. * * Depending on the vertical scaling algorithm used, the upsampler may need * access to the sample row(s) above and below its current input row group. * The upsampler is required to set need_context_rows TRUE at global selection * time if so. When need_context_rows is FALSE, this controller can simply * obtain one iMCU row at a time from the coefficient controller and dole it * out as row groups to the postprocessor. * * When need_context_rows is TRUE, this controller guarantees that the buffer * passed to postprocessing contains at least one row group's worth of samples * above and below the row group(s) being processed. Note that the context * rows "above" the first passed row group appear at negative row offsets in * the passed buffer. At the top and bottom of the image, the required * context rows are manufactured by duplicating the first or last real sample * row; this avoids having special cases in the upsampling inner loops. * * The amount of context is fixed at one row group just because that's a * convenient number for this controller to work with. The existing * upsamplers really only need one sample row of context. An upsampler * supporting arbitrary output rescaling might wish for more than one row * group of context when shrinking the image; tough, we don't handle that. * (This is justified by the assumption that downsizing will be handled mostly * by adjusting the DCT_scaled_size values, so that the actual scale factor at * the upsample step needn't be much less than one.) * * To provide the desired context, we have to retain the last two row groups * of one iMCU row while reading in the next iMCU row. (The last row group * can't be processed until we have another row group for its below-context, * and so we have to save the next-to-last group too for its above-context.) * We could do this most simply by copying data around in our buffer, but * that'd be very slow. We can avoid copying any data by creating a rather * strange pointer structure. Here's how it works. We allocate a workspace * consisting of M+2 row groups (where M = min_DCT_scaled_size is the number * of row groups per iMCU row). We create two sets of redundant pointers to * the workspace. Labeling the physical row groups 0 to M+1, the synthesized * pointer lists look like this: * M+1 M-1 * master pointer --> 0 master pointer --> 0 * 1 1 * ... ... * M-3 M-3 * M-2 M * M-1 M+1 * M M-2 * M+1 M-1 * 0 0 * We read alternate iMCU rows using each master pointer; thus the last two * row groups of the previous iMCU row remain un-overwritten in the workspace. * The pointer lists are set up so that the required context rows appear to * be adjacent to the proper places when we pass the pointer lists to the * upsampler. * * The above pictures describe the normal state of the pointer lists. * At top and bottom of the image, we diddle the pointer lists to duplicate * the first or last sample row as necessary (this is cheaper than copying * sample rows around). * * This scheme breaks down if M < 2, ie, min_DCT_scaled_size is 1. In that * situation each iMCU row provides only one row group so the buffering logic * must be different (eg, we must read two iMCU rows before we can emit the * first row group). For now, we simply do not support providing context * rows when min_DCT_scaled_size is 1. That combination seems unlikely to * be worth providing --- if someone wants a 1/8th-size preview, they probably * want it quick and dirty, so a context-free upsampler is sufficient. */ /* Private buffer controller object */ typedef struct { struct jpeg_d_main_controller pub; /* public fields */ /* Pointer to allocated workspace (M or M+2 row groups). */ JSAMPARRAY buffer[MAX_COMPONENTS]; boolean buffer_full; /* Have we gotten an iMCU row from decoder? */ JDIMENSION rowgroup_ctr; /* counts row groups output to postprocessor */ /* Remaining fields are only used in the context case. */ /* These are the master pointers to the funny-order pointer lists. */ JSAMPIMAGE xbuffer[2]; /* pointers to weird pointer lists */ int whichptr; /* indicates which pointer set is now in use */ int context_state; /* process_data state machine status */ JDIMENSION rowgroups_avail; /* row groups available to postprocessor */ JDIMENSION iMCU_row_ctr; /* counts iMCU rows to detect image top/bot */ } my_main_controller; typedef my_main_controller * my_main_ptr; /* context_state values: */ #define CTX_PREPARE_FOR_IMCU 0 /* need to prepare for MCU row */ #define CTX_PROCESS_IMCU 1 /* feeding iMCU to postprocessor */ #define CTX_POSTPONED_ROW 2 /* feeding postponed row group */ /* Forward declarations */ METHODDEF(void) process_data_simple_main JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); METHODDEF(void) process_data_context_main JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); #ifdef QUANT_2PASS_SUPPORTED METHODDEF(void) process_data_crank_post JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); #endif LOCAL(void) alloc_funny_pointers (j_decompress_ptr cinfo) /* Allocate space for the funny pointer lists. * This is done only once, not once per pass. */ { my_main_ptr main = (my_main_ptr) cinfo->main; int ci, rgroup; int M = cinfo->min_DCT_scaled_size; jpeg_component_info *compptr; JSAMPARRAY xbuf; /* Get top-level space for component array pointers. * We alloc both arrays with one call to save a few cycles. */ main->xbuffer[0] = (JSAMPIMAGE) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, cinfo->num_components * 2 * SIZEOF(JSAMPARRAY)); main->xbuffer[1] = main->xbuffer[0] + cinfo->num_components; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) / cinfo->min_DCT_scaled_size; /* height of a row group of component */ /* Get space for pointer lists --- M+4 row groups in each list. * We alloc both pointer lists with one call to save a few cycles. */ xbuf = (JSAMPARRAY) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW)); xbuf += rgroup; /* want one row group at negative offsets */ main->xbuffer[0][ci] = xbuf; xbuf += rgroup * (M + 4); main->xbuffer[1][ci] = xbuf; } } LOCAL(void) make_funny_pointers (j_decompress_ptr cinfo) /* Create the funny pointer lists discussed in the comments above. * The actual workspace is already allocated (in main->buffer), * and the space for the pointer lists is allocated too. * This routine just fills in the curiously ordered lists. * This will be repeated at the beginning of each pass. */ { my_main_ptr main = (my_main_ptr) cinfo->main; int ci, i, rgroup; int M = cinfo->min_DCT_scaled_size; jpeg_component_info *compptr; JSAMPARRAY buf, xbuf0, xbuf1; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) / cinfo->min_DCT_scaled_size; /* height of a row group of component */ xbuf0 = main->xbuffer[0][ci]; xbuf1 = main->xbuffer[1][ci]; /* First copy the workspace pointers as-is */ buf = main->buffer[ci]; for (i = 0; i < rgroup * (M + 2); i++) { xbuf0[i] = xbuf1[i] = buf[i]; } /* In the second list, put the last four row groups in swapped order */ for (i = 0; i < rgroup * 2; i++) { xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i]; xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i]; } /* The wraparound pointers at top and bottom will be filled later * (see set_wraparound_pointers, below). Initially we want the "above" * pointers to duplicate the first actual data line. This only needs * to happen in xbuffer[0]. */ for (i = 0; i < rgroup; i++) { xbuf0[i - rgroup] = xbuf0[0]; } } } LOCAL(void) set_wraparound_pointers (j_decompress_ptr cinfo) /* Set up the "wraparound" pointers at top and bottom of the pointer lists. * This changes the pointer list state from top-of-image to the normal state. */ { my_main_ptr main = (my_main_ptr) cinfo->main; int ci, i, rgroup; int M = cinfo->min_DCT_scaled_size; jpeg_component_info *compptr; JSAMPARRAY xbuf0, xbuf1; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) / cinfo->min_DCT_scaled_size; /* height of a row group of component */ xbuf0 = main->xbuffer[0][ci]; xbuf1 = main->xbuffer[1][ci]; for (i = 0; i < rgroup; i++) { xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i]; xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i]; xbuf0[rgroup*(M+2) + i] = xbuf0[i]; xbuf1[rgroup*(M+2) + i] = xbuf1[i]; } } } LOCAL(void) set_bottom_pointers (j_decompress_ptr cinfo) /* Change the pointer lists to duplicate the last sample row at the bottom * of the image. whichptr indicates which xbuffer holds the final iMCU row. * Also sets rowgroups_avail to indicate number of nondummy row groups in row. */ { my_main_ptr main = (my_main_ptr) cinfo->main; int ci, i, rgroup, iMCUheight, rows_left; jpeg_component_info *compptr; JSAMPARRAY xbuf; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { /* Count sample rows in one iMCU row and in one row group */ iMCUheight = compptr->v_samp_factor * compptr->DCT_scaled_size; rgroup = iMCUheight / cinfo->min_DCT_scaled_size; /* Count nondummy sample rows remaining for this component */ rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight); if (rows_left == 0) rows_left = iMCUheight; /* Count nondummy row groups. Should get same answer for each component, * so we need only do it once. */ if (ci == 0) { main->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1); } /* Duplicate the last real sample row rgroup*2 times; this pads out the * last partial rowgroup and ensures at least one full rowgroup of context. */ xbuf = main->xbuffer[main->whichptr][ci]; for (i = 0; i < rgroup * 2; i++) { xbuf[rows_left + i] = xbuf[rows_left-1]; } } } /* * Initialize for a processing pass. */ METHODDEF(void) start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode) { my_main_ptr main = (my_main_ptr) cinfo->main; switch (pass_mode) { case JBUF_PASS_THRU: if (cinfo->upsample->need_context_rows) { main->pub.process_data = process_data_context_main; make_funny_pointers(cinfo); /* Create the xbuffer[] lists */ main->whichptr = 0; /* Read first iMCU row into xbuffer[0] */ main->context_state = CTX_PREPARE_FOR_IMCU; main->iMCU_row_ctr = 0; } else { /* Simple case with no context needed */ main->pub.process_data = process_data_simple_main; } main->buffer_full = FALSE; /* Mark buffer empty */ main->rowgroup_ctr = 0; break; #ifdef QUANT_2PASS_SUPPORTED case JBUF_CRANK_DEST: /* For last pass of 2-pass quantization, just crank the postprocessor */ main->pub.process_data = process_data_crank_post; break; #endif default: ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); break; } } /* * Process some data. * This handles the simple case where no context is required. */ METHODDEF(void) process_data_simple_main (j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail) { my_main_ptr main = (my_main_ptr) cinfo->main; JDIMENSION rowgroups_avail; /* Read input data if we haven't filled the main buffer yet */ if (! main->buffer_full) { if (! (*cinfo->coef->decompress_data) (cinfo, main->buffer)) return; /* suspension forced, can do nothing more */ main->buffer_full = TRUE; /* OK, we have an iMCU row to work with */ } /* There are always min_DCT_scaled_size row groups in an iMCU row. */ rowgroups_avail = (JDIMENSION) cinfo->min_DCT_scaled_size; /* Note: at the bottom of the image, we may pass extra garbage row groups * to the postprocessor. The postprocessor has to check for bottom * of image anyway (at row resolution), so no point in us doing it too. */ /* Feed the postprocessor */ (*cinfo->post->post_process_data) (cinfo, main->buffer, &main->rowgroup_ctr, rowgroups_avail, output_buf, out_row_ctr, out_rows_avail); /* Has postprocessor consumed all the data yet? If so, mark buffer empty */ if (main->rowgroup_ctr >= rowgroups_avail) { main->buffer_full = FALSE; main->rowgroup_ctr = 0; } } /* * Process some data. * This handles the case where context rows must be provided. */ METHODDEF(void) process_data_context_main (j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail) { my_main_ptr main = (my_main_ptr) cinfo->main; /* Read input data if we haven't filled the main buffer yet */ if (! main->buffer_full) { if (! (*cinfo->coef->decompress_data) (cinfo, main->xbuffer[main->whichptr])) return; /* suspension forced, can do nothing more */ main->buffer_full = TRUE; /* OK, we have an iMCU row to work with */ main->iMCU_row_ctr++; /* count rows received */ } /* Postprocessor typically will not swallow all the input data it is handed * in one call (due to filling the output buffer first). Must be prepared * to exit and restart. This switch lets us keep track of how far we got. * Note that each case falls through to the next on successful completion. */ switch (main->context_state) { case CTX_POSTPONED_ROW: /* Call postprocessor using previously set pointers for postponed row */ (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr], &main->rowgroup_ctr, main->rowgroups_avail, output_buf, out_row_ctr, out_rows_avail); if (main->rowgroup_ctr < main->rowgroups_avail) return; /* Need to suspend */ main->context_state = CTX_PREPARE_FOR_IMCU; if (*out_row_ctr >= out_rows_avail) return; /* Postprocessor exactly filled output buf */ /*FALLTHROUGH*/ case CTX_PREPARE_FOR_IMCU: /* Prepare to process first M-1 row groups of this iMCU row */ main->rowgroup_ctr = 0; main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size - 1); /* Check for bottom of image: if so, tweak pointers to "duplicate" * the last sample row, and adjust rowgroups_avail to ignore padding rows. */ if (main->iMCU_row_ctr == cinfo->total_iMCU_rows) set_bottom_pointers(cinfo); main->context_state = CTX_PROCESS_IMCU; /*FALLTHROUGH*/ case CTX_PROCESS_IMCU: /* Call postprocessor using previously set pointers */ (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr], &main->rowgroup_ctr, main->rowgroups_avail, output_buf, out_row_ctr, out_rows_avail); if (main->rowgroup_ctr < main->rowgroups_avail) return; /* Need to suspend */ /* After the first iMCU, change wraparound pointers to normal state */ if (main->iMCU_row_ctr == 1) set_wraparound_pointers(cinfo); /* Prepare to load new iMCU row using other xbuffer list */ main->whichptr ^= 1; /* 0=>1 or 1=>0 */ main->buffer_full = FALSE; /* Still need to process last row group of this iMCU row, */ /* which is saved at index M+1 of the other xbuffer */ main->rowgroup_ctr = (JDIMENSION) (cinfo->min_DCT_scaled_size + 1); main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size + 2); main->context_state = CTX_POSTPONED_ROW; } } /* * Process some data. * Final pass of two-pass quantization: just call the postprocessor. * Source data will be the postprocessor controller's internal buffer. */ #ifdef QUANT_2PASS_SUPPORTED METHODDEF(void) process_data_crank_post (j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail) { (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL, (JDIMENSION *) NULL, (JDIMENSION) 0, output_buf, out_row_ctr, out_rows_avail); } #endif /* QUANT_2PASS_SUPPORTED */ /* * Initialize main buffer controller. */ GLOBAL(void) jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer) { my_main_ptr main; int ci, rgroup, ngroups; jpeg_component_info *compptr; main = (my_main_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_main_controller)); cinfo->main = (struct jpeg_d_main_controller *) main; main->pub.start_pass = start_pass_main; if (need_full_buffer) /* shouldn't happen */ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); /* Allocate the workspace. * ngroups is the number of row groups we need. */ if (cinfo->upsample->need_context_rows) { if (cinfo->min_DCT_scaled_size < 2) /* unsupported, see comments above */ ERREXIT(cinfo, JERR_NOTIMPL); alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */ ngroups = cinfo->min_DCT_scaled_size + 2; } else { ngroups = cinfo->min_DCT_scaled_size; } for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) / cinfo->min_DCT_scaled_size; /* height of a row group of component */ main->buffer[ci] = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, compptr->width_in_blocks * compptr->DCT_scaled_size, (JDIMENSION) (rgroup * ngroups)); } } Papyrus3/JpegDir/JpgLossy/libjpeg.doc0000755000175000017500000047505007535143454014755 0ustar USING THE IJG JPEG LIBRARY Copyright (C) 1994-1998, Thomas G. Lane. This file is part of the Independent JPEG Group's software. For conditions of distribution and use, see the accompanying README file. This file describes how to use the IJG JPEG library within an application program. Read it if you want to write a program that uses the library. The file example.c provides heavily commented skeleton code for calling the JPEG library. Also see jpeglib.h (the include file to be used by application programs) for full details about data structures and function parameter lists. The library source code, of course, is the ultimate reference. Note that there have been *major* changes from the application interface presented by IJG version 4 and earlier versions. The old design had several inherent limitations, and it had accumulated a lot of cruft as we added features while trying to minimize application-interface changes. We have sacrificed backward compatibility in the version 5 rewrite, but we think the improvements justify this. TABLE OF CONTENTS ----------------- Overview: Functions provided by the library Outline of typical usage Basic library usage: Data formats Compression details Decompression details Mechanics of usage: include files, linking, etc Advanced features: Compression parameter selection Decompression parameter selection Special color spaces Error handling Compressed data handling (source and destination managers) I/O suspension Progressive JPEG support Buffered-image mode Abbreviated datastreams and multiple images Special markers Raw (downsampled) image data Really raw data: DCT coefficients Progress monitoring Memory management Memory usage Library compile-time options Portability considerations Notes for MS-DOS implementors You should read at least the overview and basic usage sections before trying to program with the library. The sections on advanced features can be read if and when you need them. OVERVIEW ======== Functions provided by the library --------------------------------- The IJG JPEG library provides C code to read and write JPEG-compressed image files. The surrounding application program receives or supplies image data a scanline at a time, using a straightforward uncompressed image format. All details of color conversion and other preprocessing/postprocessing can be handled by the library. The library includes a substantial amount of code that is not covered by the JPEG standard but is necessary for typical applications of JPEG. These functions preprocess the image before JPEG compression or postprocess it after decompression. They include colorspace conversion, downsampling/upsampling, and color quantization. The application indirectly selects use of this code by specifying the format in which it wishes to supply or receive image data. For example, if colormapped output is requested, then the decompression library automatically invokes color quantization. A wide range of quality vs. speed tradeoffs are possible in JPEG processing, and even more so in decompression postprocessing. The decompression library provides multiple implementations that cover most of the useful tradeoffs, ranging from very-high-quality down to fast-preview operation. On the compression side we have generally not provided low-quality choices, since compression is normally less time-critical. It should be understood that the low-quality modes may not meet the JPEG standard's accuracy requirements; nonetheless, they are useful for viewers. A word about functions *not* provided by the library. We handle a subset of the ISO JPEG standard; most baseline, extended-sequential, and progressive JPEG processes are supported. (Our subset includes all features now in common use.) Unsupported ISO options include: * Hierarchical storage * Lossless JPEG * Arithmetic entropy coding (unsupported for legal reasons) * DNL marker * Nonintegral subsampling ratios We support both 8- and 12-bit data precision, but this is a compile-time choice rather than a run-time choice; hence it is difficult to use both precisions in a single application. By itself, the library handles only interchange JPEG datastreams --- in particular the widely used JFIF file format. The library can be used by surrounding code to process interchange or abbreviated JPEG datastreams that are embedded in more complex file formats. (For example, this library is used by the free LIBTIFF library to support JPEG compression in TIFF.) Outline of typical usage ------------------------ The rough outline of a JPEG compression operation is: Allocate and initialize a JPEG compression object Specify the destination for the compressed data (eg, a file) Set parameters for compression, including image size & colorspace jpeg_start_compress(...); while (scan lines remain to be written) jpeg_write_scanlines(...); jpeg_finish_compress(...); Release the JPEG compression object A JPEG compression object holds parameters and working state for the JPEG library. We make creation/destruction of the object separate from starting or finishing compression of an image; the same object can be re-used for a series of image compression operations. This makes it easy to re-use the same parameter settings for a sequence of images. Re-use of a JPEG object also has important implications for processing abbreviated JPEG datastreams, as discussed later. The image data to be compressed is supplied to jpeg_write_scanlines() from in-memory buffers. If the application is doing file-to-file compression, reading image data from the source file is the application's responsibility. The library emits compressed data by calling a "data destination manager", which typically will write the data into a file; but the application can provide its own destination manager to do something else. Similarly, the rough outline of a JPEG decompression operation is: Allocate and initialize a JPEG decompression object Specify the source of the compressed data (eg, a file) Call jpeg_read_header() to obtain image info Set parameters for decompression jpeg_start_decompress(...); while (scan lines remain to be read) jpeg_read_scanlines(...); jpeg_finish_decompress(...); Release the JPEG decompression object This is comparable to the compression outline except that reading the datastream header is a separate step. This is helpful because information about the image's size, colorspace, etc is available when the application selects decompression parameters. For example, the application can choose an output scaling ratio that will fit the image into the available screen size. The decompression library obtains compressed data by calling a data source manager, which typically will read the data from a file; but other behaviors can be obtained with a custom source manager. Decompressed data is delivered into in-memory buffers passed to jpeg_read_scanlines(). It is possible to abort an incomplete compression or decompression operation by calling jpeg_abort(); or, if you do not need to retain the JPEG object, simply release it by calling jpeg_destroy(). JPEG compression and decompression objects are two separate struct types. However, they share some common fields, and certain routines such as jpeg_destroy() can work on either type of object. The JPEG library has no static variables: all state is in the compression or decompression object. Therefore it is possible to process multiple compression and decompression operations concurrently, using multiple JPEG objects. Both compression and decompression can be done in an incremental memory-to- memory fashion, if suitable source/destination managers are used. See the section on "I/O suspension" for more details. BASIC LIBRARY USAGE =================== Data formats ------------ Before diving into procedural details, it is helpful to understand the image data format that the JPEG library expects or returns. The standard input image format is a rectangular array of pixels, with each pixel having the same number of "component" or "sample" values (color channels). You must specify how many components there are and the colorspace interpretation of the components. Most applications will use RGB data (three components per pixel) or grayscale data (one component per pixel). PLEASE NOTE THAT RGB DATA IS THREE SAMPLES PER PIXEL, GRAYSCALE ONLY ONE. A remarkable number of people manage to miss this, only to find that their programs don't work with grayscale JPEG files. There is no provision for colormapped input. JPEG files are always full-color or full grayscale (or sometimes another colorspace such as CMYK). You can feed in a colormapped image by expanding it to full-color format. However JPEG often doesn't work very well with source data that has been colormapped, because of dithering noise. This is discussed in more detail in the JPEG FAQ and the other references mentioned in the README file. Pixels are stored by scanlines, with each scanline running from left to right. The component values for each pixel are adjacent in the row; for example, R,G,B,R,G,B,R,G,B,... for 24-bit RGB color. Each scanline is an array of data type JSAMPLE --- which is typically "unsigned char", unless you've changed jmorecfg.h. (You can also change the RGB pixel layout, say to B,G,R order, by modifying jmorecfg.h. But see the restrictions listed in that file before doing so.) A 2-D array of pixels is formed by making a list of pointers to the starts of scanlines; so the scanlines need not be physically adjacent in memory. Even if you process just one scanline at a time, you must make a one-element pointer array to conform to this structure. Pointers to JSAMPLE rows are of type JSAMPROW, and the pointer to the pointer array is of type JSAMPARRAY. The library accepts or supplies one or more complete scanlines per call. It is not possible to process part of a row at a time. Scanlines are always processed top-to-bottom. You can process an entire image in one call if you have it all in memory, but usually it's simplest to process one scanline at a time. For best results, source data values should have the precision specified by BITS_IN_JSAMPLE (normally 8 bits). For instance, if you choose to compress data that's only 6 bits/channel, you should left-justify each value in a byte before passing it to the compressor. If you need to compress data that has more than 8 bits/channel, compile with BITS_IN_JSAMPLE = 12. (See "Library compile-time options", later.) The data format returned by the decompressor is the same in all details, except that colormapped output is supported. (Again, a JPEG file is never colormapped. But you can ask the decompressor to perform on-the-fly color quantization to deliver colormapped output.) If you request colormapped output then the returned data array contains a single JSAMPLE per pixel; its value is an index into a color map. The color map is represented as a 2-D JSAMPARRAY in which each row holds the values of one color component, that is, colormap[i][j] is the value of the i'th color component for pixel value (map index) j. Note that since the colormap indexes are stored in JSAMPLEs, the maximum number of colors is limited by the size of JSAMPLE (ie, at most 256 colors for an 8-bit JPEG library). Compression details ------------------- Here we revisit the JPEG compression outline given in the overview. 1. Allocate and initialize a JPEG compression object. A JPEG compression object is a "struct jpeg_compress_struct". (It also has a bunch of subsidiary structures which are allocated via malloc(), but the application doesn't control those directly.) This struct can be just a local variable in the calling routine, if a single routine is going to execute the whole JPEG compression sequence. Otherwise it can be static or allocated from malloc(). You will also need a structure representing a JPEG error handler. The part of this that the library cares about is a "struct jpeg_error_mgr". If you are providing your own error handler, you'll typically want to embed the jpeg_error_mgr struct in a larger structure; this is discussed later under "Error handling". For now we'll assume you are just using the default error handler. The default error handler will print JPEG error/warning messages on stderr, and it will call exit() if a fatal error occurs. You must initialize the error handler structure, store a pointer to it into the JPEG object's "err" field, and then call jpeg_create_compress() to initialize the rest of the JPEG object. Typical code for this step, if you are using the default error handler, is struct jpeg_compress_struct cinfo; struct jpeg_error_mgr jerr; ... cinfo.err = jpeg_std_error(&jerr); jpeg_create_compress(&cinfo); jpeg_create_compress allocates a small amount of memory, so it could fail if you are out of memory. In that case it will exit via the error handler; that's why the error handler must be initialized first. 2. Specify the destination for the compressed data (eg, a file). As previously mentioned, the JPEG library delivers compressed data to a "data destination" module. The library includes one data destination module which knows how to write to a stdio stream. You can use your own destination module if you want to do something else, as discussed later. If you use the standard destination module, you must open the target stdio stream beforehand. Typical code for this step looks like: FILE * outfile; ... if ((outfile = fopen(filename, "wb")) == NULL) { fprintf(stderr, "can't open %s\n", filename); exit(1); } jpeg_stdio_dest(&cinfo, outfile); where the last line invokes the standard destination module. WARNING: it is critical that the binary compressed data be delivered to the output file unchanged. On non-Unix systems the stdio library may perform newline translation or otherwise corrupt binary data. To suppress this behavior, you may need to use a "b" option to fopen (as shown above), or use setmode() or another routine to put the stdio stream in binary mode. See cjpeg.c and djpeg.c for code that has been found to work on many systems. You can select the data destination after setting other parameters (step 3), if that's more convenient. You may not change the destination between calling jpeg_start_compress() and jpeg_finish_compress(). 3. Set parameters for compression, including image size & colorspace. You must supply information about the source image by setting the following fields in the JPEG object (cinfo structure): image_width Width of image, in pixels image_height Height of image, in pixels input_components Number of color channels (samples per pixel) in_color_space Color space of source image The image dimensions are, hopefully, obvious. JPEG supports image dimensions of 1 to 64K pixels in either direction. The input color space is typically RGB or grayscale, and input_components is 3 or 1 accordingly. (See "Special color spaces", later, for more info.) The in_color_space field must be assigned one of the J_COLOR_SPACE enum constants, typically JCS_RGB or JCS_GRAYSCALE. JPEG has a large number of compression parameters that determine how the image is encoded. Most applications don't need or want to know about all these parameters. You can set all the parameters to reasonable defaults by calling jpeg_set_defaults(); then, if there are particular values you want to change, you can do so after that. The "Compression parameter selection" section tells about all the parameters. You must set in_color_space correctly before calling jpeg_set_defaults(), because the defaults depend on the source image colorspace. However the other three source image parameters need not be valid until you call jpeg_start_compress(). There's no harm in calling jpeg_set_defaults() more than once, if that happens to be convenient. Typical code for a 24-bit RGB source image is cinfo.image_width = Width; /* image width and height, in pixels */ cinfo.image_height = Height; cinfo.input_components = 3; /* # of color components per pixel */ cinfo.in_color_space = JCS_RGB; /* colorspace of input image */ jpeg_set_defaults(&cinfo); /* Make optional parameter settings here */ 4. jpeg_start_compress(...); After you have established the data destination and set all the necessary source image info and other parameters, call jpeg_start_compress() to begin a compression cycle. This will initialize internal state, allocate working storage, and emit the first few bytes of the JPEG datastream header. Typical code: jpeg_start_compress(&cinfo, TRUE); The "TRUE" parameter ensures that a complete JPEG interchange datastream will be written. This is appropriate in most cases. If you think you might want to use an abbreviated datastream, read the section on abbreviated datastreams, below. Once you have called jpeg_start_compress(), you may not alter any JPEG parameters or other fields of the JPEG object until you have completed the compression cycle. 5. while (scan lines remain to be written) jpeg_write_scanlines(...); Now write all the required image data by calling jpeg_write_scanlines() one or more times. You can pass one or more scanlines in each call, up to the total image height. In most applications it is convenient to pass just one or a few scanlines at a time. The expected format for the passed data is discussed under "Data formats", above. Image data should be written in top-to-bottom scanline order. The JPEG spec contains some weasel wording about how top and bottom are application-defined terms (a curious interpretation of the English language...) but if you want your files to be compatible with everyone else's, you WILL use top-to-bottom order. If the source data must be read in bottom-to-top order, you can use the JPEG library's virtual array mechanism to invert the data efficiently. Examples of this can be found in the sample application cjpeg. The library maintains a count of the number of scanlines written so far in the next_scanline field of the JPEG object. Usually you can just use this variable as the loop counter, so that the loop test looks like "while (cinfo.next_scanline < cinfo.image_height)". Code for this step depends heavily on the way that you store the source data. example.c shows the following code for the case of a full-size 2-D source array containing 3-byte RGB pixels: JSAMPROW row_pointer[1]; /* pointer to a single row */ int row_stride; /* physical row width in buffer */ row_stride = image_width * 3; /* JSAMPLEs per row in image_buffer */ while (cinfo.next_scanline < cinfo.image_height) { row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride]; jpeg_write_scanlines(&cinfo, row_pointer, 1); } jpeg_write_scanlines() returns the number of scanlines actually written. This will normally be equal to the number passed in, so you can usually ignore the return value. It is different in just two cases: * If you try to write more scanlines than the declared image height, the additional scanlines are ignored. * If you use a suspending data destination manager, output buffer overrun will cause the compressor to return before accepting all the passed lines. This feature is discussed under "I/O suspension", below. The normal stdio destination manager will NOT cause this to happen. In any case, the return value is the same as the change in the value of next_scanline. 6. jpeg_finish_compress(...); After all the image data has been written, call jpeg_finish_compress() to complete the compression cycle. This step is ESSENTIAL to ensure that the last bufferload of data is written to the data destination. jpeg_finish_compress() also releases working memory associated with the JPEG object. Typical code: jpeg_finish_compress(&cinfo); If using the stdio destination manager, don't forget to close the output stdio stream (if necessary) afterwards. If you have requested a multi-pass operating mode, such as Huffman code optimization, jpeg_finish_compress() will perform the additional passes using data buffered by the first pass. In this case jpeg_finish_compress() may take quite a while to complete. With the default compression parameters, this will not happen. It is an error to call jpeg_finish_compress() before writing the necessary total number of scanlines. If you wish to abort compression, call jpeg_abort() as discussed below. After completing a compression cycle, you may dispose of the JPEG object as discussed next, or you may use it to compress another image. In that case return to step 2, 3, or 4 as appropriate. If you do not change the destination manager, the new datastream will be written to the same target. If you do not change any JPEG parameters, the new datastream will be written with the same parameters as before. Note that you can change the input image dimensions freely between cycles, but if you change the input colorspace, you should call jpeg_set_defaults() to adjust for the new colorspace; and then you'll need to repeat all of step 3. 7. Release the JPEG compression object. When you are done with a JPEG compression object, destroy it by calling jpeg_destroy_compress(). This will free all subsidiary memory (regardless of the previous state of the object). Or you can call jpeg_destroy(), which works for either compression or decompression objects --- this may be more convenient if you are sharing code between compression and decompression cases. (Actually, these routines are equivalent except for the declared type of the passed pointer. To avoid gripes from ANSI C compilers, jpeg_destroy() should be passed a j_common_ptr.) If you allocated the jpeg_compress_struct structure from malloc(), freeing it is your responsibility --- jpeg_destroy() won't. Ditto for the error handler structure. Typical code: jpeg_destroy_compress(&cinfo); 8. Aborting. If you decide to abort a compression cycle before finishing, you can clean up in either of two ways: * If you don't need the JPEG object any more, just call jpeg_destroy_compress() or jpeg_destroy() to release memory. This is legitimate at any point after calling jpeg_create_compress() --- in fact, it's safe even if jpeg_create_compress() fails. * If you want to re-use the JPEG object, call jpeg_abort_compress(), or call jpeg_abort() which works on both compression and decompression objects. This will return the object to an idle state, releasing any working memory. jpeg_abort() is allowed at any time after successful object creation. Note that cleaning up the data destination, if required, is your responsibility; neither of these routines will call term_destination(). (See "Compressed data handling", below, for more about that.) jpeg_destroy() and jpeg_abort() are the only safe calls to make on a JPEG object that has reported an error by calling error_exit (see "Error handling" for more info). The internal state of such an object is likely to be out of whack. Either of these two routines will return the object to a known state. Decompression details --------------------- Here we revisit the JPEG decompression outline given in the overview. 1. Allocate and initialize a JPEG decompression object. This is just like initialization for compression, as discussed above, except that the object is a "struct jpeg_decompress_struct" and you call jpeg_create_decompress(). Error handling is exactly the same. Typical code: struct jpeg_decompress_struct cinfo; struct jpeg_error_mgr jerr; ... cinfo.err = jpeg_std_error(&jerr); jpeg_create_decompress(&cinfo); (Both here and in the IJG code, we usually use variable name "cinfo" for both compression and decompression objects.) 2. Specify the source of the compressed data (eg, a file). As previously mentioned, the JPEG library reads compressed data from a "data source" module. The library includes one data source module which knows how to read from a stdio stream. You can use your own source module if you want to do something else, as discussed later. If you use the standard source module, you must open the source stdio stream beforehand. Typical code for this step looks like: FILE * infile; ... if ((infile = fopen(filename, "rb")) == NULL) { fprintf(stderr, "can't open %s\n", filename); exit(1); } jpeg_stdio_src(&cinfo, infile); where the last line invokes the standard source module. WARNING: it is critical that the binary compressed data be read unchanged. On non-Unix systems the stdio library may perform newline translation or otherwise corrupt binary data. To suppress this behavior, you may need to use a "b" option to fopen (as shown above), or use setmode() or another routine to put the stdio stream in binary mode. See cjpeg.c and djpeg.c for code that has been found to work on many systems. You may not change the data source between calling jpeg_read_header() and jpeg_finish_decompress(). If you wish to read a series of JPEG images from a single source file, you should repeat the jpeg_read_header() to jpeg_finish_decompress() sequence without reinitializing either the JPEG object or the data source module; this prevents buffered input data from being discarded. 3. Call jpeg_read_header() to obtain image info. Typical code for this step is just jpeg_read_header(&cinfo, TRUE); This will read the source datastream header markers, up to the beginning of the compressed data proper. On return, the image dimensions and other info have been stored in the JPEG object. The application may wish to consult this information before selecting decompression parameters. More complex code is necessary if * A suspending data source is used --- in that case jpeg_read_header() may return before it has read all the header data. See "I/O suspension", below. The normal stdio source manager will NOT cause this to happen. * Abbreviated JPEG files are to be processed --- see the section on abbreviated datastreams. Standard applications that deal only in interchange JPEG files need not be concerned with this case either. It is permissible to stop at this point if you just wanted to find out the image dimensions and other header info for a JPEG file. In that case, call jpeg_destroy() when you are done with the JPEG object, or call jpeg_abort() to return it to an idle state before selecting a new data source and reading another header. 4. Set parameters for decompression. jpeg_read_header() sets appropriate default decompression parameters based on the properties of the image (in particular, its colorspace). However, you may well want to alter these defaults before beginning the decompression. For example, the default is to produce full color output from a color file. If you want colormapped output you must ask for it. Other options allow the returned image to be scaled and allow various speed/quality tradeoffs to be selected. "Decompression parameter selection", below, gives details. If the defaults are appropriate, nothing need be done at this step. Note that all default values are set by each call to jpeg_read_header(). If you reuse a decompression object, you cannot expect your parameter settings to be preserved across cycles, as you can for compression. You must set desired parameter values each time. 5. jpeg_start_decompress(...); Once the parameter values are satisfactory, call jpeg_start_decompress() to begin decompression. This will initialize internal state, allocate working memory, and prepare for returning data. Typical code is just jpeg_start_decompress(&cinfo); If you have requested a multi-pass operating mode, such as 2-pass color quantization, jpeg_start_decompress() will do everything needed before data output can begin. In this case jpeg_start_decompress() may take quite a while to complete. With a single-scan (non progressive) JPEG file and default decompression parameters, this will not happen; jpeg_start_decompress() will return quickly. After this call, the final output image dimensions, including any requested scaling, are available in the JPEG object; so is the selected colormap, if colormapped output has been requested. Useful fields include output_width image width and height, as scaled output_height out_color_components # of color components in out_color_space output_components # of color components returned per pixel colormap the selected colormap, if any actual_number_of_colors number of entries in colormap output_components is 1 (a colormap index) when quantizing colors; otherwise it equals out_color_components. It is the number of JSAMPLE values that will be emitted per pixel in the output arrays. Typically you will need to allocate data buffers to hold the incoming image. You will need output_width * output_components JSAMPLEs per scanline in your output buffer, and a total of output_height scanlines will be returned. Note: if you are using the JPEG library's internal memory manager to allocate data buffers (as djpeg does), then the manager's protocol requires that you request large buffers *before* calling jpeg_start_decompress(). This is a little tricky since the output_XXX fields are not normally valid then. You can make them valid by calling jpeg_calc_output_dimensions() after setting the relevant parameters (scaling, output color space, and quantization flag). 6. while (scan lines remain to be read) jpeg_read_scanlines(...); Now you can read the decompressed image data by calling jpeg_read_scanlines() one or more times. At each call, you pass in the maximum number of scanlines to be read (ie, the height of your working buffer); jpeg_read_scanlines() will return up to that many lines. The return value is the number of lines actually read. The format of the returned data is discussed under "Data formats", above. Don't forget that grayscale and color JPEGs will return different data formats! Image data is returned in top-to-bottom scanline order. If you must write out the image in bottom-to-top order, you can use the JPEG library's virtual array mechanism to invert the data efficiently. Examples of this can be found in the sample application djpeg. The library maintains a count of the number of scanlines returned so far in the output_scanline field of the JPEG object. Usually you can just use this variable as the loop counter, so that the loop test looks like "while (cinfo.output_scanline < cinfo.output_height)". (Note that the test should NOT be against image_height, unless you never use scaling. The image_height field is the height of the original unscaled image.) The return value always equals the change in the value of output_scanline. If you don't use a suspending data source, it is safe to assume that jpeg_read_scanlines() reads at least one scanline per call, until the bottom of the image has been reached. If you use a buffer larger than one scanline, it is NOT safe to assume that jpeg_read_scanlines() fills it. (The current implementation returns only a few scanlines per call, no matter how large a buffer you pass.) So you must always provide a loop that calls jpeg_read_scanlines() repeatedly until the whole image has been read. 7. jpeg_finish_decompress(...); After all the image data has been read, call jpeg_finish_decompress() to complete the decompression cycle. This causes working memory associated with the JPEG object to be released. Typical code: jpeg_finish_decompress(&cinfo); If using the stdio source manager, don't forget to close the source stdio stream if necessary. It is an error to call jpeg_finish_decompress() before reading the correct total number of scanlines. If you wish to abort decompression, call jpeg_abort() as discussed below. After completing a decompression cycle, you may dispose of the JPEG object as discussed next, or you may use it to decompress another image. In that case return to step 2 or 3 as appropriate. If you do not change the source manager, the next image will be read from the same source. 8. Release the JPEG decompression object. When you are done with a JPEG decompression object, destroy it by calling jpeg_destroy_decompress() or jpeg_destroy(). The previous discussion of destroying compression objects applies here too. Typical code: jpeg_destroy_decompress(&cinfo); 9. Aborting. You can abort a decompression cycle by calling jpeg_destroy_decompress() or jpeg_destroy() if you don't need the JPEG object any more, or jpeg_abort_decompress() or jpeg_abort() if you want to reuse the object. The previous discussion of aborting compression cycles applies here too. Mechanics of usage: include files, linking, etc ----------------------------------------------- Applications using the JPEG library should include the header file jpeglib.h to obtain declarations of data types and routines. Before including jpeglib.h, include system headers that define at least the typedefs FILE and size_t. On ANSI-conforming systems, including is sufficient; on older Unix systems, you may need to define size_t. If the application needs to refer to individual JPEG library error codes, also include jerror.h to define those symbols. jpeglib.h indirectly includes the files jconfig.h and jmorecfg.h. If you are installing the JPEG header files in a system directory, you will want to install all four files: jpeglib.h, jerror.h, jconfig.h, jmorecfg.h. The most convenient way to include the JPEG code into your executable program is to prepare a library file ("libjpeg.a", or a corresponding name on non-Unix machines) and reference it at your link step. If you use only half of the library (only compression or only decompression), only that much code will be included from the library, unless your linker is hopelessly brain-damaged. The supplied makefiles build libjpeg.a automatically (see install.doc). While you can build the JPEG library as a shared library if the whim strikes you, we don't really recommend it. The trouble with shared libraries is that at some point you'll probably try to substitute a new version of the library without recompiling the calling applications. That generally doesn't work because the parameter struct declarations usually change with each new version. In other words, the library's API is *not* guaranteed binary compatible across versions; we only try to ensure source-code compatibility. (In hindsight, it might have been smarter to hide the parameter structs from applications and introduce a ton of access functions instead. Too late now, however.) On some systems your application may need to set up a signal handler to ensure that temporary files are deleted if the program is interrupted. This is most critical if you are on MS-DOS and use the jmemdos.c memory manager back end; it will try to grab extended memory for temp files, and that space will NOT be freed automatically. See cjpeg.c or djpeg.c for an example signal handler. It may be worth pointing out that the core JPEG library does not actually require the stdio library: only the default source/destination managers and error handler need it. You can use the library in a stdio-less environment if you replace those modules and use jmemnobs.c (or another memory manager of your own devising). More info about the minimum system library requirements may be found in jinclude.h. ADVANCED FEATURES ================= Compression parameter selection ------------------------------- This section describes all the optional parameters you can set for JPEG compression, as well as the "helper" routines provided to assist in this task. Proper setting of some parameters requires detailed understanding of the JPEG standard; if you don't know what a parameter is for, it's best not to mess with it! See REFERENCES in the README file for pointers to more info about JPEG. It's a good idea to call jpeg_set_defaults() first, even if you plan to set all the parameters; that way your code is more likely to work with future JPEG libraries that have additional parameters. For the same reason, we recommend you use a helper routine where one is provided, in preference to twiddling cinfo fields directly. The helper routines are: jpeg_set_defaults (j_compress_ptr cinfo) This routine sets all JPEG parameters to reasonable defaults, using only the input image's color space (field in_color_space, which must already be set in cinfo). Many applications will only need to use this routine and perhaps jpeg_set_quality(). jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace) Sets the JPEG file's colorspace (field jpeg_color_space) as specified, and sets other color-space-dependent parameters appropriately. See "Special color spaces", below, before using this. A large number of parameters, including all per-component parameters, are set by this routine; if you want to twiddle individual parameters you should call jpeg_set_colorspace() before rather than after. jpeg_default_colorspace (j_compress_ptr cinfo) Selects an appropriate JPEG colorspace based on cinfo->in_color_space, and calls jpeg_set_colorspace(). This is actually a subroutine of jpeg_set_defaults(). It's broken out in case you want to change just the colorspace-dependent JPEG parameters. jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline) Constructs JPEG quantization tables appropriate for the indicated quality setting. The quality value is expressed on the 0..100 scale recommended by IJG (cjpeg's "-quality" switch uses this routine). Note that the exact mapping from quality values to tables may change in future IJG releases as more is learned about DCT quantization. If the force_baseline parameter is TRUE, then the quantization table entries are constrained to the range 1..255 for full JPEG baseline compatibility. In the current implementation, this only makes a difference for quality settings below 25, and it effectively prevents very small/low quality files from being generated. The IJG decoder is capable of reading the non-baseline files generated at low quality settings when force_baseline is FALSE, but other decoders may not be. jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor, boolean force_baseline) Same as jpeg_set_quality() except that the generated tables are the sample tables given in the JPEC spec section K.1, multiplied by the specified scale factor (which is expressed as a percentage; thus scale_factor = 100 reproduces the spec's tables). Note that larger scale factors give lower quality. This entry point is useful for conforming to the Adobe PostScript DCT conventions, but we do not recommend linear scaling as a user-visible quality scale otherwise. force_baseline again constrains the computed table entries to 1..255. int jpeg_quality_scaling (int quality) Converts a value on the IJG-recommended quality scale to a linear scaling percentage. Note that this routine may change or go away in future releases --- IJG may choose to adopt a scaling method that can't be expressed as a simple scalar multiplier, in which case the premise of this routine collapses. Caveat user. jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl, const unsigned int *basic_table, int scale_factor, boolean force_baseline) Allows an arbitrary quantization table to be created. which_tbl indicates which table slot to fill. basic_table points to an array of 64 unsigned ints given in normal array order. These values are multiplied by scale_factor/100 and then clamped to the range 1..65535 (or to 1..255 if force_baseline is TRUE). CAUTION: prior to library version 6a, jpeg_add_quant_table expected the basic table to be given in JPEG zigzag order. If you need to write code that works with either older or newer versions of this routine, you must check the library version number. Something like "#if JPEG_LIB_VERSION >= 61" is the right test. jpeg_simple_progression (j_compress_ptr cinfo) Generates a default scan script for writing a progressive-JPEG file. This is the recommended method of creating a progressive file, unless you want to make a custom scan sequence. You must ensure that the JPEG color space is set correctly before calling this routine. Compression parameters (cinfo fields) include: J_DCT_METHOD dct_method Selects the algorithm used for the DCT step. Choices are: JDCT_ISLOW: slow but accurate integer algorithm JDCT_IFAST: faster, less accurate integer method JDCT_FLOAT: floating-point method JDCT_DEFAULT: default method (normally JDCT_ISLOW) JDCT_FASTEST: fastest method (normally JDCT_IFAST) The FLOAT method is very slightly more accurate than the ISLOW method, but may give different results on different machines due to varying roundoff behavior. The integer methods should give the same results on all machines. On machines with sufficiently fast FP hardware, the floating-point method may also be the fastest. The IFAST method is considerably less accurate than the other two; its use is not recommended if high quality is a concern. JDCT_DEFAULT and JDCT_FASTEST are macros configurable by each installation. J_COLOR_SPACE jpeg_color_space int num_components The JPEG color space and corresponding number of components; see "Special color spaces", below, for more info. We recommend using jpeg_set_color_space() if you want to change these. boolean optimize_coding TRUE causes the compressor to compute optimal Huffman coding tables for the image. This requires an extra pass over the data and therefore costs a good deal of space and time. The default is FALSE, which tells the compressor to use the supplied or default Huffman tables. In most cases optimal tables save only a few percent of file size compared to the default tables. Note that when this is TRUE, you need not supply Huffman tables at all, and any you do supply will be overwritten. unsigned int restart_interval int restart_in_rows To emit restart markers in the JPEG file, set one of these nonzero. Set restart_interval to specify the exact interval in MCU blocks. Set restart_in_rows to specify the interval in MCU rows. (If restart_in_rows is not 0, then restart_interval is set after the image width in MCUs is computed.) Defaults are zero (no restarts). One restart marker per MCU row is often a good choice. NOTE: the overhead of restart markers is higher in grayscale JPEG files than in color files, and MUCH higher in progressive JPEGs. If you use restarts, you may want to use larger intervals in those cases. const jpeg_scan_info * scan_info int num_scans By default, scan_info is NULL; this causes the compressor to write a single-scan sequential JPEG file. If not NULL, scan_info points to an array of scan definition records of length num_scans. The compressor will then write a JPEG file having one scan for each scan definition record. This is used to generate noninterleaved or progressive JPEG files. The library checks that the scan array defines a valid JPEG scan sequence. (jpeg_simple_progression creates a suitable scan definition array for progressive JPEG.) This is discussed further under "Progressive JPEG support". int smoothing_factor If non-zero, the input image is smoothed; the value should be 1 for minimal smoothing to 100 for maximum smoothing. Consult jcsample.c for details of the smoothing algorithm. The default is zero. boolean write_JFIF_header If TRUE, a JFIF APP0 marker is emitted. jpeg_set_defaults() and jpeg_set_colorspace() set this TRUE if a JFIF-legal JPEG color space (ie, YCbCr or grayscale) is selected, otherwise FALSE. UINT8 JFIF_major_version UINT8 JFIF_minor_version The version number to be written into the JFIF marker. jpeg_set_defaults() initializes the version to 1.01 (major=minor=1). You should set it to 1.02 (major=1, minor=2) if you plan to write any JFIF 1.02 extension markers. UINT8 density_unit UINT16 X_density UINT16 Y_density The resolution information to be written into the JFIF marker; not used otherwise. density_unit may be 0 for unknown, 1 for dots/inch, or 2 for dots/cm. The default values are 0,1,1 indicating square pixels of unknown size. boolean write_Adobe_marker If TRUE, an Adobe APP14 marker is emitted. jpeg_set_defaults() and jpeg_set_colorspace() set this TRUE if JPEG color space RGB, CMYK, or YCCK is selected, otherwise FALSE. It is generally a bad idea to set both write_JFIF_header and write_Adobe_marker. In fact, you probably shouldn't change the default settings at all --- the default behavior ensures that the JPEG file's color space can be recognized by the decoder. JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS] Pointers to coefficient quantization tables, one per table slot, or NULL if no table is defined for a slot. Usually these should be set via one of the above helper routines; jpeg_add_quant_table() is general enough to define any quantization table. The other routines will set up table slot 0 for luminance quality and table slot 1 for chrominance. JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS] JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS] Pointers to Huffman coding tables, one per table slot, or NULL if no table is defined for a slot. Slots 0 and 1 are filled with the JPEG sample tables by jpeg_set_defaults(). If you need to allocate more table structures, jpeg_alloc_huff_table() may be used. Note that optimal Huffman tables can be computed for an image by setting optimize_coding, as discussed above; there's seldom any need to mess with providing your own Huffman tables. There are some additional cinfo fields which are not documented here because you currently can't change them; for example, you can't set arith_code TRUE because arithmetic coding is unsupported. Per-component parameters are stored in the struct cinfo.comp_info[i] for component number i. Note that components here refer to components of the JPEG color space, *not* the source image color space. A suitably large comp_info[] array is allocated by jpeg_set_defaults(); if you choose not to use that routine, it's up to you to allocate the array. int component_id The one-byte identifier code to be recorded in the JPEG file for this component. For the standard color spaces, we recommend you leave the default values alone. int h_samp_factor int v_samp_factor Horizontal and vertical sampling factors for the component; must be 1..4 according to the JPEG standard. Note that larger sampling factors indicate a higher-resolution component; many people find this behavior quite unintuitive. The default values are 2,2 for luminance components and 1,1 for chrominance components, except for grayscale where 1,1 is used. int quant_tbl_no Quantization table number for component. The default value is 0 for luminance components and 1 for chrominance components. int dc_tbl_no int ac_tbl_no DC and AC entropy coding table numbers. The default values are 0 for luminance components and 1 for chrominance components. int component_index Must equal the component's index in comp_info[]. (Beginning in release v6, the compressor library will fill this in automatically; you don't have to.) Decompression parameter selection --------------------------------- Decompression parameter selection is somewhat simpler than compression parameter selection, since all of the JPEG internal parameters are recorded in the source file and need not be supplied by the application. (Unless you are working with abbreviated files, in which case see "Abbreviated datastreams", below.) Decompression parameters control the postprocessing done on the image to deliver it in a format suitable for the application's use. Many of the parameters control speed/quality tradeoffs, in which faster decompression may be obtained at the price of a poorer-quality image. The defaults select the highest quality (slowest) processing. The following fields in the JPEG object are set by jpeg_read_header() and may be useful to the application in choosing decompression parameters: JDIMENSION image_width Width and height of image JDIMENSION image_height int num_components Number of color components J_COLOR_SPACE jpeg_color_space Colorspace of image boolean saw_JFIF_marker TRUE if a JFIF APP0 marker was seen UINT8 JFIF_major_version Version information from JFIF marker UINT8 JFIF_minor_version UINT8 density_unit Resolution data from JFIF marker UINT16 X_density UINT16 Y_density boolean saw_Adobe_marker TRUE if an Adobe APP14 marker was seen UINT8 Adobe_transform Color transform code from Adobe marker The JPEG color space, unfortunately, is something of a guess since the JPEG standard proper does not provide a way to record it. In practice most files adhere to the JFIF or Adobe conventions, and the decoder will recognize these correctly. See "Special color spaces", below, for more info. The decompression parameters that determine the basic properties of the returned image are: J_COLOR_SPACE out_color_space Output color space. jpeg_read_header() sets an appropriate default based on jpeg_color_space; typically it will be RGB or grayscale. The application can change this field to request output in a different colorspace. For example, set it to JCS_GRAYSCALE to get grayscale output from a color file. (This is useful for previewing: grayscale output is faster than full color since the color components need not be processed.) Note that not all possible color space transforms are currently implemented; you may need to extend jdcolor.c if you want an unusual conversion. unsigned int scale_num, scale_denom Scale the image by the fraction scale_num/scale_denom. Default is 1/1, or no scaling. Currently, the only supported scaling ratios are 1/1, 1/2, 1/4, and 1/8. (The library design allows for arbitrary scaling ratios but this is not likely to be implemented any time soon.) Smaller scaling ratios permit significantly faster decoding since fewer pixels need be processed and a simpler IDCT method can be used. boolean quantize_colors If set TRUE, colormapped output will be delivered. Default is FALSE, meaning that full-color output will be delivered. The next three parameters are relevant only if quantize_colors is TRUE. int desired_number_of_colors Maximum number of colors to use in generating a library-supplied color map (the actual number of colors is returned in a different field). Default 256. Ignored when the application supplies its own color map. boolean two_pass_quantize If TRUE, an extra pass over the image is made to select a custom color map for the image. This usually looks a lot better than the one-size- fits-all colormap that is used otherwise. Default is TRUE. Ignored when the application supplies its own color map. J_DITHER_MODE dither_mode Selects color dithering method. Supported values are: JDITHER_NONE no dithering: fast, very low quality JDITHER_ORDERED ordered dither: moderate speed and quality JDITHER_FS Floyd-Steinberg dither: slow, high quality Default is JDITHER_FS. (At present, ordered dither is implemented only in the single-pass, standard-colormap case. If you ask for ordered dither when two_pass_quantize is TRUE or when you supply an external color map, you'll get F-S dithering.) When quantize_colors is TRUE, the target color map is described by the next two fields. colormap is set to NULL by jpeg_read_header(). The application can supply a color map by setting colormap non-NULL and setting actual_number_of_colors to the map size. Otherwise, jpeg_start_decompress() selects a suitable color map and sets these two fields itself. [Implementation restriction: at present, an externally supplied colormap is only accepted for 3-component output color spaces.] JSAMPARRAY colormap The color map, represented as a 2-D pixel array of out_color_components rows and actual_number_of_colors columns. Ignored if not quantizing. CAUTION: if the JPEG library creates its own colormap, the storage pointed to by this field is released by jpeg_finish_decompress(). Copy the colormap somewhere else first, if you want to save it. int actual_number_of_colors The number of colors in the color map. Additional decompression parameters that the application may set include: J_DCT_METHOD dct_method Selects the algorithm used for the DCT step. Choices are the same as described above for compression. boolean do_fancy_upsampling If TRUE, do careful upsampling of chroma components. If FALSE, a faster but sloppier method is used. Default is TRUE. The visual impact of the sloppier method is often very small. boolean do_block_smoothing If TRUE, interblock smoothing is applied in early stages of decoding progressive JPEG files; if FALSE, not. Default is TRUE. Early progression stages look "fuzzy" with smoothing, "blocky" without. In any case, block smoothing ceases to be applied after the first few AC coefficients are known to full accuracy, so it is relevant only when using buffered-image mode for progressive images. boolean enable_1pass_quant boolean enable_external_quant boolean enable_2pass_quant These are significant only in buffered-image mode, which is described in its own section below. The output image dimensions are given by the following fields. These are computed from the source image dimensions and the decompression parameters by jpeg_start_decompress(). You can also call jpeg_calc_output_dimensions() to obtain the values that will result from the current parameter settings. This can be useful if you are trying to pick a scaling ratio that will get close to a desired target size. It's also important if you are using the JPEG library's memory manager to allocate output buffer space, because you are supposed to request such buffers *before* jpeg_start_decompress(). JDIMENSION output_width Actual dimensions of output image. JDIMENSION output_height int out_color_components Number of color components in out_color_space. int output_components Number of color components returned. int rec_outbuf_height Recommended height of scanline buffer. When quantizing colors, output_components is 1, indicating a single color map index per pixel. Otherwise it equals out_color_components. The output arrays are required to be output_width * output_components JSAMPLEs wide. rec_outbuf_height is the recommended minimum height (in scanlines) of the buffer passed to jpeg_read_scanlines(). If the buffer is smaller, the library will still work, but time will be wasted due to unnecessary data copying. In high-quality modes, rec_outbuf_height is always 1, but some faster, lower-quality modes set it to larger values (typically 2 to 4). If you are going to ask for a high-speed processing mode, you may as well go to the trouble of honoring rec_outbuf_height so as to avoid data copying. (An output buffer larger than rec_outbuf_height lines is OK, but won't provide any material speed improvement over that height.) Special color spaces -------------------- The JPEG standard itself is "color blind" and doesn't specify any particular color space. It is customary to convert color data to a luminance/chrominance color space before compressing, since this permits greater compression. The existing de-facto JPEG file format standards specify YCbCr or grayscale data (JFIF), or grayscale, RGB, YCbCr, CMYK, or YCCK (Adobe). For special applications such as multispectral images, other color spaces can be used, but it must be understood that such files will be unportable. The JPEG library can handle the most common colorspace conversions (namely RGB <=> YCbCr and CMYK <=> YCCK). It can also deal with data of an unknown color space, passing it through without conversion. If you deal extensively with an unusual color space, you can easily extend the library to understand additional color spaces and perform appropriate conversions. For compression, the source data's color space is specified by field in_color_space. This is transformed to the JPEG file's color space given by jpeg_color_space. jpeg_set_defaults() chooses a reasonable JPEG color space depending on in_color_space, but you can override this by calling jpeg_set_colorspace(). Of course you must select a supported transformation. jccolor.c currently supports the following transformations: RGB => YCbCr RGB => GRAYSCALE YCbCr => GRAYSCALE CMYK => YCCK plus the null transforms: GRAYSCALE => GRAYSCALE, RGB => RGB, YCbCr => YCbCr, CMYK => CMYK, YCCK => YCCK, and UNKNOWN => UNKNOWN. The de-facto file format standards (JFIF and Adobe) specify APPn markers that indicate the color space of the JPEG file. It is important to ensure that these are written correctly, or omitted if the JPEG file's color space is not one of the ones supported by the de-facto standards. jpeg_set_colorspace() will set the compression parameters to include or omit the APPn markers properly, so long as it is told the truth about the JPEG color space. For example, if you are writing some random 3-component color space without conversion, don't try to fake out the library by setting in_color_space and jpeg_color_space to JCS_YCbCr; use JCS_UNKNOWN. You may want to write an APPn marker of your own devising to identify the colorspace --- see "Special markers", below. When told that the color space is UNKNOWN, the library will default to using luminance-quality compression parameters for all color components. You may well want to change these parameters. See the source code for jpeg_set_colorspace(), in jcparam.c, for details. For decompression, the JPEG file's color space is given in jpeg_color_space, and this is transformed to the output color space out_color_space. jpeg_read_header's setting of jpeg_color_space can be relied on if the file conforms to JFIF or Adobe conventions, but otherwise it is no better than a guess. If you know the JPEG file's color space for certain, you can override jpeg_read_header's guess by setting jpeg_color_space. jpeg_read_header also selects a default output color space based on (its guess of) jpeg_color_space; set out_color_space to override this. Again, you must select a supported transformation. jdcolor.c currently supports YCbCr => GRAYSCALE YCbCr => RGB GRAYSCALE => RGB YCCK => CMYK as well as the null transforms. (Since GRAYSCALE=>RGB is provided, an application can force grayscale JPEGs to look like color JPEGs if it only wants to handle one case.) The two-pass color quantizer, jquant2.c, is specialized to handle RGB data (it weights distances appropriately for RGB colors). You'll need to modify the code if you want to use it for non-RGB output color spaces. Note that jquant2.c is used to map to an application-supplied colormap as well as for the normal two-pass colormap selection process. CAUTION: it appears that Adobe Photoshop writes inverted data in CMYK JPEG files: 0 represents 100% ink coverage, rather than 0% ink as you'd expect. This is arguably a bug in Photoshop, but if you need to work with Photoshop CMYK files, you will have to deal with it in your application. We cannot "fix" this in the library by inverting the data during the CMYK<=>YCCK transform, because that would break other applications, notably Ghostscript. Photoshop versions prior to 3.0 write EPS files containing JPEG-encoded CMYK data in the same inverted-YCCK representation used in bare JPEG files, but the surrounding PostScript code performs an inversion using the PS image operator. I am told that Photoshop 3.0 will write uninverted YCCK in EPS/JPEG files, and will omit the PS-level inversion. (But the data polarity used in bare JPEG files will not change in 3.0.) In either case, the JPEG library must not invert the data itself, or else Ghostscript would read these EPS files incorrectly. Error handling -------------- When the default error handler is used, any error detected inside the JPEG routines will cause a message to be printed on stderr, followed by exit(). You can supply your own error handling routines to override this behavior and to control the treatment of nonfatal warnings and trace/debug messages. The file example.c illustrates the most common case, which is to have the application regain control after an error rather than exiting. The JPEG library never writes any message directly; it always goes through the error handling routines. Three classes of messages are recognized: * Fatal errors: the library cannot continue. * Warnings: the library can continue, but the data is corrupt, and a damaged output image is likely to result. * Trace/informational messages. These come with a trace level indicating the importance of the message; you can control the verbosity of the program by adjusting the maximum trace level that will be displayed. You may, if you wish, simply replace the entire JPEG error handling module (jerror.c) with your own code. However, you can avoid code duplication by only replacing some of the routines depending on the behavior you need. This is accomplished by calling jpeg_std_error() as usual, but then overriding some of the method pointers in the jpeg_error_mgr struct, as illustrated by example.c. All of the error handling routines will receive a pointer to the JPEG object (a j_common_ptr which points to either a jpeg_compress_struct or a jpeg_decompress_struct; if you need to tell which, test the is_decompressor field). This struct includes a pointer to the error manager struct in its "err" field. Frequently, custom error handler routines will need to access additional data which is not known to the JPEG library or the standard error handler. The most convenient way to do this is to embed either the JPEG object or the jpeg_error_mgr struct in a larger structure that contains additional fields; then casting the passed pointer provides access to the additional fields. Again, see example.c for one way to do it. (Beginning with IJG version 6b, there is also a void pointer "client_data" in each JPEG object, which the application can also use to find related data. The library does not touch client_data at all.) The individual methods that you might wish to override are: error_exit (j_common_ptr cinfo) Receives control for a fatal error. Information sufficient to generate the error message has been stored in cinfo->err; call output_message to display it. Control must NOT return to the caller; generally this routine will exit() or longjmp() somewhere. Typically you would override this routine to get rid of the exit() default behavior. Note that if you continue processing, you should clean up the JPEG object with jpeg_abort() or jpeg_destroy(). output_message (j_common_ptr cinfo) Actual output of any JPEG message. Override this to send messages somewhere other than stderr. Note that this method does not know how to generate a message, only where to send it. format_message (j_common_ptr cinfo, char * buffer) Constructs a readable error message string based on the error info stored in cinfo->err. This method is called by output_message. Few applications should need to override this method. One possible reason for doing so is to implement dynamic switching of error message language. emit_message (j_common_ptr cinfo, int msg_level) Decide whether or not to emit a warning or trace message; if so, calls output_message. The main reason for overriding this method would be to abort on warnings. msg_level is -1 for warnings, 0 and up for trace messages. Only error_exit() and emit_message() are called from the rest of the JPEG library; the other two are internal to the error handler. The actual message texts are stored in an array of strings which is pointed to by the field err->jpeg_message_table. The messages are numbered from 0 to err->last_jpeg_message, and it is these code numbers that are used in the JPEG library code. You could replace the message texts (for instance, with messages in French or German) by changing the message table pointer. See jerror.h for the default texts. CAUTION: this table will almost certainly change or grow from one library version to the next. It may be useful for an application to add its own message texts that are handled by the same mechanism. The error handler supports a second "add-on" message table for this purpose. To define an addon table, set the pointer err->addon_message_table and the message numbers err->first_addon_message and err->last_addon_message. If you number the addon messages beginning at 1000 or so, you won't have to worry about conflicts with the library's built-in messages. See the sample applications cjpeg/djpeg for an example of using addon messages (the addon messages are defined in cderror.h). Actual invocation of the error handler is done via macros defined in jerror.h: ERREXITn(...) for fatal errors WARNMSn(...) for corrupt-data warnings TRACEMSn(...) for trace and informational messages. These macros store the message code and any additional parameters into the error handler struct, then invoke the error_exit() or emit_message() method. The variants of each macro are for varying numbers of additional parameters. The additional parameters are inserted into the generated message using standard printf() format codes. See jerror.h and jerror.c for further details. Compressed data handling (source and destination managers) ---------------------------------------------------------- The JPEG compression library sends its compressed data to a "destination manager" module. The default destination manager just writes the data to a stdio stream, but you can provide your own manager to do something else. Similarly, the decompression library calls a "source manager" to obtain the compressed data; you can provide your own source manager if you want the data to come from somewhere other than a stdio stream. In both cases, compressed data is processed a bufferload at a time: the destination or source manager provides a work buffer, and the library invokes the manager only when the buffer is filled or emptied. (You could define a one-character buffer to force the manager to be invoked for each byte, but that would be rather inefficient.) The buffer's size and location are controlled by the manager, not by the library. For example, if you desired to decompress a JPEG datastream that was all in memory, you could just make the buffer pointer and length point to the original data in memory. Then the buffer-reload procedure would be invoked only if the decompressor ran off the end of the datastream, which would indicate an erroneous datastream. The work buffer is defined as an array of datatype JOCTET, which is generally "char" or "unsigned char". On a machine where char is not exactly 8 bits wide, you must define JOCTET as a wider data type and then modify the data source and destination modules to transcribe the work arrays into 8-bit units on external storage. A data destination manager struct contains a pointer and count defining the next byte to write in the work buffer and the remaining free space: JOCTET * next_output_byte; /* => next byte to write in buffer */ size_t free_in_buffer; /* # of byte spaces remaining in buffer */ The library increments the pointer and decrements the count until the buffer is filled. The manager's empty_output_buffer method must reset the pointer and count. The manager is expected to remember the buffer's starting address and total size in private fields not visible to the library. A data destination manager provides three methods: init_destination (j_compress_ptr cinfo) Initialize destination. This is called by jpeg_start_compress() before any data is actually written. It must initialize next_output_byte and free_in_buffer. free_in_buffer must be initialized to a positive value. empty_output_buffer (j_compress_ptr cinfo) This is called whenever the buffer has filled (free_in_buffer reaches zero). In typical applications, it should write out the *entire* buffer (use the saved start address and buffer length; ignore the current state of next_output_byte and free_in_buffer). Then reset the pointer & count to the start of the buffer, and return TRUE indicating that the buffer has been dumped. free_in_buffer must be set to a positive value when TRUE is returned. A FALSE return should only be used when I/O suspension is desired (this operating mode is discussed in the next section). term_destination (j_compress_ptr cinfo) Terminate destination --- called by jpeg_finish_compress() after all data has been written. In most applications, this must flush any data remaining in the buffer. Use either next_output_byte or free_in_buffer to determine how much data is in the buffer. term_destination() is NOT called by jpeg_abort() or jpeg_destroy(). If you want the destination manager to be cleaned up during an abort, you must do it yourself. You will also need code to create a jpeg_destination_mgr struct, fill in its method pointers, and insert a pointer to the struct into the "dest" field of the JPEG compression object. This can be done in-line in your setup code if you like, but it's probably cleaner to provide a separate routine similar to the jpeg_stdio_dest() routine of the supplied destination manager. Decompression source managers follow a parallel design, but with some additional frammishes. The source manager struct contains a pointer and count defining the next byte to read from the work buffer and the number of bytes remaining: const JOCTET * next_input_byte; /* => next byte to read from buffer */ size_t bytes_in_buffer; /* # of bytes remaining in buffer */ The library increments the pointer and decrements the count until the buffer is emptied. The manager's fill_input_buffer method must reset the pointer and count. In most applications, the manager must remember the buffer's starting address and total size in private fields not visible to the library. A data source manager provides five methods: init_source (j_decompress_ptr cinfo) Initialize source. This is called by jpeg_read_header() before any data is actually read. Unlike init_destination(), it may leave bytes_in_buffer set to 0 (in which case a fill_input_buffer() call will occur immediately). fill_input_buffer (j_decompress_ptr cinfo) This is called whenever bytes_in_buffer has reached zero and more data is wanted. In typical applications, it should read fresh data into the buffer (ignoring the current state of next_input_byte and bytes_in_buffer), reset the pointer & count to the start of the buffer, and return TRUE indicating that the buffer has been reloaded. It is not necessary to fill the buffer entirely, only to obtain at least one more byte. bytes_in_buffer MUST be set to a positive value if TRUE is returned. A FALSE return should only be used when I/O suspension is desired (this mode is discussed in the next section). skip_input_data (j_decompress_ptr cinfo, long num_bytes) Skip num_bytes worth of data. The buffer pointer and count should be advanced over num_bytes input bytes, refilling the buffer as needed. This is used to skip over a potentially large amount of uninteresting data (such as an APPn marker). In some applications it may be possible to optimize away the reading of the skipped data, but it's not clear that being smart is worth much trouble; large skips are uncommon. bytes_in_buffer may be zero on return. A zero or negative skip count should be treated as a no-op. resync_to_restart (j_decompress_ptr cinfo, int desired) This routine is called only when the decompressor has failed to find a restart (RSTn) marker where one is expected. Its mission is to find a suitable point for resuming decompression. For most applications, we recommend that you just use the default resync procedure, jpeg_resync_to_restart(). However, if you are able to back up in the input data stream, or if you have a-priori knowledge about the likely location of restart markers, you may be able to do better. Read the read_restart_marker() and jpeg_resync_to_restart() routines in jdmarker.c if you think you'd like to implement your own resync procedure. term_source (j_decompress_ptr cinfo) Terminate source --- called by jpeg_finish_decompress() after all data has been read. Often a no-op. For both fill_input_buffer() and skip_input_data(), there is no such thing as an EOF return. If the end of the file has been reached, the routine has a choice of exiting via ERREXIT() or inserting fake data into the buffer. In most cases, generating a warning message and inserting a fake EOI marker is the best course of action --- this will allow the decompressor to output however much of the image is there. In pathological cases, the decompressor may swallow the EOI and again demand data ... just keep feeding it fake EOIs. jdatasrc.c illustrates the recommended error recovery behavior. term_source() is NOT called by jpeg_abort() or jpeg_destroy(). If you want the source manager to be cleaned up during an abort, you must do it yourself. You will also need code to create a jpeg_source_mgr struct, fill in its method pointers, and insert a pointer to the struct into the "src" field of the JPEG decompression object. This can be done in-line in your setup code if you like, but it's probably cleaner to provide a separate routine similar to the jpeg_stdio_src() routine of the supplied source manager. For more information, consult the stdio source and destination managers in jdatasrc.c and jdatadst.c. I/O suspension -------------- Some applications need to use the JPEG library as an incremental memory-to- memory filter: when the compressed data buffer is filled or emptied, they want control to return to the outer loop, rather than expecting that the buffer can be emptied or reloaded within the data source/destination manager subroutine. The library supports this need by providing an "I/O suspension" mode, which we describe in this section. The I/O suspension mode is not a panacea: nothing is guaranteed about the maximum amount of time spent in any one call to the library, so it will not eliminate response-time problems in single-threaded applications. If you need guaranteed response time, we suggest you "bite the bullet" and implement a real multi-tasking capability. To use I/O suspension, cooperation is needed between the calling application and the data source or destination manager; you will always need a custom source/destination manager. (Please read the previous section if you haven't already.) The basic idea is that the empty_output_buffer() or fill_input_buffer() routine is a no-op, merely returning FALSE to indicate that it has done nothing. Upon seeing this, the JPEG library suspends operation and returns to its caller. The surrounding application is responsible for emptying or refilling the work buffer before calling the JPEG library again. Compression suspension: For compression suspension, use an empty_output_buffer() routine that returns FALSE; typically it will not do anything else. This will cause the compressor to return to the caller of jpeg_write_scanlines(), with the return value indicating that not all the supplied scanlines have been accepted. The application must make more room in the output buffer, adjust the output buffer pointer/count appropriately, and then call jpeg_write_scanlines() again, pointing to the first unconsumed scanline. When forced to suspend, the compressor will backtrack to a convenient stopping point (usually the start of the current MCU); it will regenerate some output data when restarted. Therefore, although empty_output_buffer() is only called when the buffer is filled, you should NOT write out the entire buffer after a suspension. Write only the data up to the current position of next_output_byte/free_in_buffer. The data beyond that point will be regenerated after resumption. Because of the backtracking behavior, a good-size output buffer is essential for efficiency; you don't want the compressor to suspend often. (In fact, an overly small buffer could lead to infinite looping, if a single MCU required more data than would fit in the buffer.) We recommend a buffer of at least several Kbytes. You may want to insert explicit code to ensure that you don't call jpeg_write_scanlines() unless there is a reasonable amount of space in the output buffer; in other words, flush the buffer before trying to compress more data. The compressor does not allow suspension while it is trying to write JPEG markers at the beginning and end of the file. This means that: * At the beginning of a compression operation, there must be enough free space in the output buffer to hold the header markers (typically 600 or so bytes). The recommended buffer size is bigger than this anyway, so this is not a problem as long as you start with an empty buffer. However, this restriction might catch you if you insert large special markers, such as a JFIF thumbnail image, without flushing the buffer afterwards. * When you call jpeg_finish_compress(), there must be enough space in the output buffer to emit any buffered data and the final EOI marker. In the current implementation, half a dozen bytes should suffice for this, but for safety's sake we recommend ensuring that at least 100 bytes are free before calling jpeg_finish_compress(). A more significant restriction is that jpeg_finish_compress() cannot suspend. This means you cannot use suspension with multi-pass operating modes, namely Huffman code optimization and multiple-scan output. Those modes write the whole file during jpeg_finish_compress(), which will certainly result in buffer overrun. (Note that this restriction applies only to compression, not decompression. The decompressor supports input suspension in all of its operating modes.) Decompression suspension: For decompression suspension, use a fill_input_buffer() routine that simply returns FALSE (except perhaps during error recovery, as discussed below). This will cause the decompressor to return to its caller with an indication that suspension has occurred. This can happen at four places: * jpeg_read_header(): will return JPEG_SUSPENDED. * jpeg_start_decompress(): will return FALSE, rather than its usual TRUE. * jpeg_read_scanlines(): will return the number of scanlines already completed (possibly 0). * jpeg_finish_decompress(): will return FALSE, rather than its usual TRUE. The surrounding application must recognize these cases, load more data into the input buffer, and repeat the call. In the case of jpeg_read_scanlines(), increment the passed pointers past any scanlines successfully read. Just as with compression, the decompressor will typically backtrack to a convenient restart point before suspending. When fill_input_buffer() is called, next_input_byte/bytes_in_buffer point to the current restart point, which is where the decompressor will backtrack to if FALSE is returned. The data beyond that position must NOT be discarded if you suspend; it needs to be re-read upon resumption. In most implementations, you'll need to shift this data down to the start of your work buffer and then load more data after it. Again, this behavior means that a several-Kbyte work buffer is essential for decent performance; furthermore, you should load a reasonable amount of new data before resuming decompression. (If you loaded, say, only one new byte each time around, you could waste a LOT of cycles.) The skip_input_data() source manager routine requires special care in a suspension scenario. This routine is NOT granted the ability to suspend the decompressor; it can decrement bytes_in_buffer to zero, but no more. If the requested skip distance exceeds the amount of data currently in the input buffer, then skip_input_data() must set bytes_in_buffer to zero and record the additional skip distance somewhere else. The decompressor will immediately call fill_input_buffer(), which should return FALSE, which will cause a suspension return. The surrounding application must then arrange to discard the recorded number of bytes before it resumes loading the input buffer. (Yes, this design is rather baroque, but it avoids complexity in the far more common case where a non-suspending source manager is used.) If the input data has been exhausted, we recommend that you emit a warning and insert dummy EOI markers just as a non-suspending data source manager would do. This can be handled either in the surrounding application logic or within fill_input_buffer(); the latter is probably more efficient. If fill_input_buffer() knows that no more data is available, it can set the pointer/count to point to a dummy EOI marker and then return TRUE just as though it had read more data in a non-suspending situation. The decompressor does not attempt to suspend within standard JPEG markers; instead it will backtrack to the start of the marker and reprocess the whole marker next time. Hence the input buffer must be large enough to hold the longest standard marker in the file. Standard JPEG markers should normally not exceed a few hundred bytes each (DHT tables are typically the longest). We recommend at least a 2K buffer for performance reasons, which is much larger than any correct marker is likely to be. For robustness against damaged marker length counts, you may wish to insert a test in your application for the case that the input buffer is completely full and yet the decoder has suspended without consuming any data --- otherwise, if this situation did occur, it would lead to an endless loop. (The library can't provide this test since it has no idea whether "the buffer is full", or even whether there is a fixed-size input buffer.) The input buffer would need to be 64K to allow for arbitrary COM or APPn markers, but these are handled specially: they are either saved into allocated memory, or skipped over by calling skip_input_data(). In the former case, suspension is handled correctly, and in the latter case, the problem of buffer overrun is placed on skip_input_data's shoulders, as explained above. Note that if you provide your own marker handling routine for large markers, you should consider how to deal with buffer overflow. Multiple-buffer management: In some applications it is desirable to store the compressed data in a linked list of buffer areas, so as to avoid data copying. This can be handled by having empty_output_buffer() or fill_input_buffer() set the pointer and count to reference the next available buffer; FALSE is returned only if no more buffers are available. Although seemingly straightforward, there is a pitfall in this approach: the backtrack that occurs when FALSE is returned could back up into an earlier buffer. For example, when fill_input_buffer() is called, the current pointer & count indicate the backtrack restart point. Since fill_input_buffer() will set the pointer and count to refer to a new buffer, the restart position must be saved somewhere else. Suppose a second call to fill_input_buffer() occurs in the same library call, and no additional input data is available, so fill_input_buffer must return FALSE. If the JPEG library has not moved the pointer/count forward in the current buffer, then *the correct restart point is the saved position in the prior buffer*. Prior buffers may be discarded only after the library establishes a restart point within a later buffer. Similar remarks apply for output into a chain of buffers. The library will never attempt to backtrack over a skip_input_data() call, so any skipped data can be permanently discarded. You still have to deal with the case of skipping not-yet-received data, however. It's much simpler to use only a single buffer; when fill_input_buffer() is called, move any unconsumed data (beyond the current pointer/count) down to the beginning of this buffer and then load new data into the remaining buffer space. This approach requires a little more data copying but is far easier to get right. Progressive JPEG support ------------------------ Progressive JPEG rearranges the stored data into a series of scans of increasing quality. In situations where a JPEG file is transmitted across a slow communications link, a decoder can generate a low-quality image very quickly from the first scan, then gradually improve the displayed quality as more scans are received. The final image after all scans are complete is identical to that of a regular (sequential) JPEG file of the same quality setting. Progressive JPEG files are often slightly smaller than equivalent sequential JPEG files, but the possibility of incremental display is the main reason for using progressive JPEG. The IJG encoder library generates progressive JPEG files when given a suitable "scan script" defining how to divide the data into scans. Creation of progressive JPEG files is otherwise transparent to the encoder. Progressive JPEG files can also be read transparently by the decoder library. If the decoding application simply uses the library as defined above, it will receive a final decoded image without any indication that the file was progressive. Of course, this approach does not allow incremental display. To perform incremental display, an application needs to use the decoder library's "buffered-image" mode, in which it receives a decoded image multiple times. Each displayed scan requires about as much work to decode as a full JPEG image of the same size, so the decoder must be fairly fast in relation to the data transmission rate in order to make incremental display useful. However, it is possible to skip displaying the image and simply add the incoming bits to the decoder's coefficient buffer. This is fast because only Huffman decoding need be done, not IDCT, upsampling, colorspace conversion, etc. The IJG decoder library allows the application to switch dynamically between displaying the image and simply absorbing the incoming bits. A properly coded application can automatically adapt the number of display passes to suit the time available as the image is received. Also, a final higher-quality display cycle can be performed from the buffered data after the end of the file is reached. Progressive compression: To create a progressive JPEG file (or a multiple-scan sequential JPEG file), set the scan_info cinfo field to point to an array of scan descriptors, and perform compression as usual. Instead of constructing your own scan list, you can call the jpeg_simple_progression() helper routine to create a recommended progression sequence; this method should be used by all applications that don't want to get involved in the nitty-gritty of progressive scan sequence design. (If you want to provide user control of scan sequences, you may wish to borrow the scan script reading code found in rdswitch.c, so that you can read scan script files just like cjpeg's.) When scan_info is not NULL, the compression library will store DCT'd data into a buffer array as jpeg_write_scanlines() is called, and will emit all the requested scans during jpeg_finish_compress(). This implies that multiple-scan output cannot be created with a suspending data destination manager, since jpeg_finish_compress() does not support suspension. We should also note that the compressor currently forces Huffman optimization mode when creating a progressive JPEG file, because the default Huffman tables are unsuitable for progressive files. Progressive decompression: When buffered-image mode is not used, the decoder library will read all of a multi-scan file during jpeg_start_decompress(), so that it can provide a final decoded image. (Here "multi-scan" means either progressive or multi-scan sequential.) This makes multi-scan files transparent to the decoding application. However, existing applications that used suspending input with version 5 of the IJG library will need to be modified to check for a suspension return from jpeg_start_decompress(). To perform incremental display, an application must use the library's buffered-image mode. This is described in the next section. Buffered-image mode ------------------- In buffered-image mode, the library stores the partially decoded image in a coefficient buffer, from which it can be read out as many times as desired. This mode is typically used for incremental display of progressive JPEG files, but it can be used with any JPEG file. Each scan of a progressive JPEG file adds more data (more detail) to the buffered image. The application can display in lockstep with the source file (one display pass per input scan), or it can allow input processing to outrun display processing. By making input and display processing run independently, it is possible for the application to adapt progressive display to a wide range of data transmission rates. The basic control flow for buffered-image decoding is jpeg_create_decompress() set data source jpeg_read_header() set overall decompression parameters cinfo.buffered_image = TRUE; /* select buffered-image mode */ jpeg_start_decompress() for (each output pass) { adjust output decompression parameters if required jpeg_start_output() /* start a new output pass */ for (all scanlines in image) { jpeg_read_scanlines() display scanlines } jpeg_finish_output() /* terminate output pass */ } jpeg_finish_decompress() jpeg_destroy_decompress() This differs from ordinary unbuffered decoding in that there is an additional level of looping. The application can choose how many output passes to make and how to display each pass. The simplest approach to displaying progressive images is to do one display pass for each scan appearing in the input file. In this case the outer loop condition is typically while (! jpeg_input_complete(&cinfo)) and the start-output call should read jpeg_start_output(&cinfo, cinfo.input_scan_number); The second parameter to jpeg_start_output() indicates which scan of the input file is to be displayed; the scans are numbered starting at 1 for this purpose. (You can use a loop counter starting at 1 if you like, but using the library's input scan counter is easier.) The library automatically reads data as necessary to complete each requested scan, and jpeg_finish_output() advances to the next scan or end-of-image marker (hence input_scan_number will be incremented by the time control arrives back at jpeg_start_output()). With this technique, data is read from the input file only as needed, and input and output processing run in lockstep. After reading the final scan and reaching the end of the input file, the buffered image remains available; it can be read additional times by repeating the jpeg_start_output()/jpeg_read_scanlines()/jpeg_finish_output() sequence. For example, a useful technique is to use fast one-pass color quantization for display passes made while the image is arriving, followed by a final display pass using two-pass quantization for highest quality. This is done by changing the library parameters before the final output pass. Changing parameters between passes is discussed in detail below. In general the last scan of a progressive file cannot be recognized as such until after it is read, so a post-input display pass is the best approach if you want special processing in the final pass. When done with the image, be sure to call jpeg_finish_decompress() to release the buffered image (or just use jpeg_destroy_decompress()). If input data arrives faster than it can be displayed, the application can cause the library to decode input data in advance of what's needed to produce output. This is done by calling the routine jpeg_consume_input(). The return value is one of the following: JPEG_REACHED_SOS: reached an SOS marker (the start of a new scan) JPEG_REACHED_EOI: reached the EOI marker (end of image) JPEG_ROW_COMPLETED: completed reading one MCU row of compressed data JPEG_SCAN_COMPLETED: completed reading last MCU row of current scan JPEG_SUSPENDED: suspended before completing any of the above (JPEG_SUSPENDED can occur only if a suspending data source is used.) This routine can be called at any time after initializing the JPEG object. It reads some additional data and returns when one of the indicated significant events occurs. (If called after the EOI marker is reached, it will immediately return JPEG_REACHED_EOI without attempting to read more data.) The library's output processing will automatically call jpeg_consume_input() whenever the output processing overtakes the input; thus, simple lockstep display requires no direct calls to jpeg_consume_input(). But by adding calls to jpeg_consume_input(), you can absorb data in advance of what is being displayed. This has two benefits: * You can limit buildup of unprocessed data in your input buffer. * You can eliminate extra display passes by paying attention to the state of the library's input processing. The first of these benefits only requires interspersing calls to jpeg_consume_input() with your display operations and any other processing you may be doing. To avoid wasting cycles due to backtracking, it's best to call jpeg_consume_input() only after a hundred or so new bytes have arrived. This is discussed further under "I/O suspension", above. (Note: the JPEG library currently is not thread-safe. You must not call jpeg_consume_input() from one thread of control if a different library routine is working on the same JPEG object in another thread.) When input arrives fast enough that more than one new scan is available before you start a new output pass, you may as well skip the output pass corresponding to the completed scan. This occurs for free if you pass cinfo.input_scan_number as the target scan number to jpeg_start_output(). The input_scan_number field is simply the index of the scan currently being consumed by the input processor. You can ensure that this is up-to-date by emptying the input buffer just before calling jpeg_start_output(): call jpeg_consume_input() repeatedly until it returns JPEG_SUSPENDED or JPEG_REACHED_EOI. The target scan number passed to jpeg_start_output() is saved in the cinfo.output_scan_number field. The library's output processing calls jpeg_consume_input() whenever the current input scan number and row within that scan is less than or equal to the current output scan number and row. Thus, input processing can "get ahead" of the output processing but is not allowed to "fall behind". You can achieve several different effects by manipulating this interlock rule. For example, if you pass a target scan number greater than the current input scan number, the output processor will wait until that scan starts to arrive before producing any output. (To avoid an infinite loop, the target scan number is automatically reset to the last scan number when the end of image is reached. Thus, if you specify a large target scan number, the library will just absorb the entire input file and then perform an output pass. This is effectively the same as what jpeg_start_decompress() does when you don't select buffered-image mode.) When you pass a target scan number equal to the current input scan number, the image is displayed no faster than the current input scan arrives. The final possibility is to pass a target scan number less than the current input scan number; this disables the input/output interlock and causes the output processor to simply display whatever it finds in the image buffer, without waiting for input. (However, the library will not accept a target scan number less than one, so you can't avoid waiting for the first scan.) When data is arriving faster than the output display processing can advance through the image, jpeg_consume_input() will store data into the buffered image beyond the point at which the output processing is reading data out again. If the input arrives fast enough, it may "wrap around" the buffer to the point where the input is more than one whole scan ahead of the output. If the output processing simply proceeds through its display pass without paying attention to the input, the effect seen on-screen is that the lower part of the image is one or more scans better in quality than the upper part. Then, when the next output scan is started, you have a choice of what target scan number to use. The recommended choice is to use the current input scan number at that time, which implies that you've skipped the output scans corresponding to the input scans that were completed while you processed the previous output scan. In this way, the decoder automatically adapts its speed to the arriving data, by skipping output scans as necessary to keep up with the arriving data. When using this strategy, you'll want to be sure that you perform a final output pass after receiving all the data; otherwise your last display may not be full quality across the whole screen. So the right outer loop logic is something like this: do { absorb any waiting input by calling jpeg_consume_input() final_pass = jpeg_input_complete(&cinfo); adjust output decompression parameters if required jpeg_start_output(&cinfo, cinfo.input_scan_number); ... jpeg_finish_output() } while (! final_pass); rather than quitting as soon as jpeg_input_complete() returns TRUE. This arrangement makes it simple to use higher-quality decoding parameters for the final pass. But if you don't want to use special parameters for the final pass, the right loop logic is like this: for (;;) { absorb any waiting input by calling jpeg_consume_input() jpeg_start_output(&cinfo, cinfo.input_scan_number); ... jpeg_finish_output() if (jpeg_input_complete(&cinfo) && cinfo.input_scan_number == cinfo.output_scan_number) break; } In this case you don't need to know in advance whether an output pass is to be the last one, so it's not necessary to have reached EOF before starting the final output pass; rather, what you want to test is whether the output pass was performed in sync with the final input scan. This form of the loop will avoid an extra output pass whenever the decoder is able (or nearly able) to keep up with the incoming data. When the data transmission speed is high, you might begin a display pass, then find that much or all of the file has arrived before you can complete the pass. (You can detect this by noting the JPEG_REACHED_EOI return code from jpeg_consume_input(), or equivalently by testing jpeg_input_complete().) In this situation you may wish to abort the current display pass and start a new one using the newly arrived information. To do so, just call jpeg_finish_output() and then start a new pass with jpeg_start_output(). A variant strategy is to abort and restart display if more than one complete scan arrives during an output pass; this can be detected by noting JPEG_REACHED_SOS returns and/or examining cinfo.input_scan_number. This idea should be employed with caution, however, since the display process might never get to the bottom of the image before being aborted, resulting in the lower part of the screen being several passes worse than the upper. In most cases it's probably best to abort an output pass only if the whole file has arrived and you want to begin the final output pass immediately. When receiving data across a communication link, we recommend always using the current input scan number for the output target scan number; if a higher-quality final pass is to be done, it should be started (aborting any incomplete output pass) as soon as the end of file is received. However, many other strategies are possible. For example, the application can examine the parameters of the current input scan and decide whether to display it or not. If the scan contains only chroma data, one might choose not to use it as the target scan, expecting that the scan will be small and will arrive quickly. To skip to the next scan, call jpeg_consume_input() until it returns JPEG_REACHED_SOS or JPEG_REACHED_EOI. Or just use the next higher number as the target scan for jpeg_start_output(); but that method doesn't let you inspect the next scan's parameters before deciding to display it. In buffered-image mode, jpeg_start_decompress() never performs input and thus never suspends. An application that uses input suspension with buffered-image mode must be prepared for suspension returns from these routines: * jpeg_start_output() performs input only if you request 2-pass quantization and the target scan isn't fully read yet. (This is discussed below.) * jpeg_read_scanlines(), as always, returns the number of scanlines that it was able to produce before suspending. * jpeg_finish_output() will read any markers following the target scan, up to the end of the file or the SOS marker that begins another scan. (But it reads no input if jpeg_consume_input() has already reached the end of the file or a SOS marker beyond the target output scan.) * jpeg_finish_decompress() will read until the end of file, and thus can suspend if the end hasn't already been reached (as can be tested by calling jpeg_input_complete()). jpeg_start_output(), jpeg_finish_output(), and jpeg_finish_decompress() all return TRUE if they completed their tasks, FALSE if they had to suspend. In the event of a FALSE return, the application must load more input data and repeat the call. Applications that use non-suspending data sources need not check the return values of these three routines. It is possible to change decoding parameters between output passes in the buffered-image mode. The decoder library currently supports only very limited changes of parameters. ONLY THE FOLLOWING parameter changes are allowed after jpeg_start_decompress() is called: * dct_method can be changed before each call to jpeg_start_output(). For example, one could use a fast DCT method for early scans, changing to a higher quality method for the final scan. * dither_mode can be changed before each call to jpeg_start_output(); of course this has no impact if not using color quantization. Typically one would use ordered dither for initial passes, then switch to Floyd-Steinberg dither for the final pass. Caution: changing dither mode can cause more memory to be allocated by the library. Although the amount of memory involved is not large (a scanline or so), it may cause the initial max_memory_to_use specification to be exceeded, which in the worst case would result in an out-of-memory failure. * do_block_smoothing can be changed before each call to jpeg_start_output(). This setting is relevant only when decoding a progressive JPEG image. During the first DC-only scan, block smoothing provides a very "fuzzy" look instead of the very "blocky" look seen without it; which is better seems a matter of personal taste. But block smoothing is nearly always a win during later stages, especially when decoding a successive-approximation image: smoothing helps to hide the slight blockiness that otherwise shows up on smooth gradients until the lowest coefficient bits are sent. * Color quantization mode can be changed under the rules described below. You *cannot* change between full-color and quantized output (because that would alter the required I/O buffer sizes), but you can change which quantization method is used. When generating color-quantized output, changing quantization method is a very useful way of switching between high-speed and high-quality display. The library allows you to change among its three quantization methods: 1. Single-pass quantization to a fixed color cube. Selected by cinfo.two_pass_quantize = FALSE and cinfo.colormap = NULL. 2. Single-pass quantization to an application-supplied colormap. Selected by setting cinfo.colormap to point to the colormap (the value of two_pass_quantize is ignored); also set cinfo.actual_number_of_colors. 3. Two-pass quantization to a colormap chosen specifically for the image. Selected by cinfo.two_pass_quantize = TRUE and cinfo.colormap = NULL. (This is the default setting selected by jpeg_read_header, but it is probably NOT what you want for the first pass of progressive display!) These methods offer successively better quality and lesser speed. However, only the first method is available for quantizing in non-RGB color spaces. IMPORTANT: because the different quantizer methods have very different working-storage requirements, the library requires you to indicate which one(s) you intend to use before you call jpeg_start_decompress(). (If we did not require this, the max_memory_to_use setting would be a complete fiction.) You do this by setting one or more of these three cinfo fields to TRUE: enable_1pass_quant Fixed color cube colormap enable_external_quant Externally-supplied colormap enable_2pass_quant Two-pass custom colormap All three are initialized FALSE by jpeg_read_header(). But jpeg_start_decompress() automatically sets TRUE the one selected by the current two_pass_quantize and colormap settings, so you only need to set the enable flags for any other quantization methods you plan to change to later. After setting the enable flags correctly at jpeg_start_decompress() time, you can change to any enabled quantization method by setting two_pass_quantize and colormap properly just before calling jpeg_start_output(). The following special rules apply: 1. You must explicitly set cinfo.colormap to NULL when switching to 1-pass or 2-pass mode from a different mode, or when you want the 2-pass quantizer to be re-run to generate a new colormap. 2. To switch to an external colormap, or to change to a different external colormap than was used on the prior pass, you must call jpeg_new_colormap() after setting cinfo.colormap. NOTE: if you want to use the same colormap as was used in the prior pass, you should not do either of these things. This will save some nontrivial switchover costs. (These requirements exist because cinfo.colormap will always be non-NULL after completing a prior output pass, since both the 1-pass and 2-pass quantizers set it to point to their output colormaps. Thus you have to do one of these two things to notify the library that something has changed. Yup, it's a bit klugy, but it's necessary to do it this way for backwards compatibility.) Note that in buffered-image mode, the library generates any requested colormap during jpeg_start_output(), not during jpeg_start_decompress(). When using two-pass quantization, jpeg_start_output() makes a pass over the buffered image to determine the optimum color map; it therefore may take a significant amount of time, whereas ordinarily it does little work. The progress monitor hook is called during this pass, if defined. It is also important to realize that if the specified target scan number is greater than or equal to the current input scan number, jpeg_start_output() will attempt to consume input as it makes this pass. If you use a suspending data source, you need to check for a FALSE return from jpeg_start_output() under these conditions. The combination of 2-pass quantization and a not-yet-fully-read target scan is the only case in which jpeg_start_output() will consume input. Application authors who support buffered-image mode may be tempted to use it for all JPEG images, even single-scan ones. This will work, but it is inefficient: there is no need to create an image-sized coefficient buffer for single-scan images. Requesting buffered-image mode for such an image wastes memory. Worse, it can cost time on large images, since the buffered data has to be swapped out or written to a temporary file. If you are concerned about maximum performance on baseline JPEG files, you should use buffered-image mode only when the incoming file actually has multiple scans. This can be tested by calling jpeg_has_multiple_scans(), which will return a correct result at any time after jpeg_read_header() completes. It is also worth noting that when you use jpeg_consume_input() to let input processing get ahead of output processing, the resulting pattern of access to the coefficient buffer is quite nonsequential. It's best to use the memory manager jmemnobs.c if you can (ie, if you have enough real or virtual main memory). If not, at least make sure that max_memory_to_use is set as high as possible. If the JPEG memory manager has to use a temporary file, you will probably see a lot of disk traffic and poor performance. (This could be improved with additional work on the memory manager, but we haven't gotten around to it yet.) In some applications it may be convenient to use jpeg_consume_input() for all input processing, including reading the initial markers; that is, you may wish to call jpeg_consume_input() instead of jpeg_read_header() during startup. This works, but note that you must check for JPEG_REACHED_SOS and JPEG_REACHED_EOI return codes as the equivalent of jpeg_read_header's codes. Once the first SOS marker has been reached, you must call jpeg_start_decompress() before jpeg_consume_input() will consume more input; it'll just keep returning JPEG_REACHED_SOS until you do. If you read a tables-only file this way, jpeg_consume_input() will return JPEG_REACHED_EOI without ever returning JPEG_REACHED_SOS; be sure to check for this case. If this happens, the decompressor will not read any more input until you call jpeg_abort() to reset it. It is OK to call jpeg_consume_input() even when not using buffered-image mode, but in that case it's basically a no-op after the initial markers have been read: it will just return JPEG_SUSPENDED. Abbreviated datastreams and multiple images ------------------------------------------- A JPEG compression or decompression object can be reused to process multiple images. This saves a small amount of time per image by eliminating the "create" and "destroy" operations, but that isn't the real purpose of the feature. Rather, reuse of an object provides support for abbreviated JPEG datastreams. Object reuse can also simplify processing a series of images in a single input or output file. This section explains these features. A JPEG file normally contains several hundred bytes worth of quantization and Huffman tables. In a situation where many images will be stored or transmitted with identical tables, this may represent an annoying overhead. The JPEG standard therefore permits tables to be omitted. The standard defines three classes of JPEG datastreams: * "Interchange" datastreams contain an image and all tables needed to decode the image. These are the usual kind of JPEG file. * "Abbreviated image" datastreams contain an image, but are missing some or all of the tables needed to decode that image. * "Abbreviated table specification" (henceforth "tables-only") datastreams contain only table specifications. To decode an abbreviated image, it is necessary to load the missing table(s) into the decoder beforehand. This can be accomplished by reading a separate tables-only file. A variant scheme uses a series of images in which the first image is an interchange (complete) datastream, while subsequent ones are abbreviated and rely on the tables loaded by the first image. It is assumed that once the decoder has read a table, it will remember that table until a new definition for the same table number is encountered. It is the application designer's responsibility to figure out how to associate the correct tables with an abbreviated image. While abbreviated datastreams can be useful in a closed environment, their use is strongly discouraged in any situation where data exchange with other applications might be needed. Caveat designer. The JPEG library provides support for reading and writing any combination of tables-only datastreams and abbreviated images. In both compression and decompression objects, a quantization or Huffman table will be retained for the lifetime of the object, unless it is overwritten by a new table definition. To create abbreviated image datastreams, it is only necessary to tell the compressor not to emit some or all of the tables it is using. Each quantization and Huffman table struct contains a boolean field "sent_table", which normally is initialized to FALSE. For each table used by the image, the header-writing process emits the table and sets sent_table = TRUE unless it is already TRUE. (In normal usage, this prevents outputting the same table definition multiple times, as would otherwise occur because the chroma components typically share tables.) Thus, setting this field to TRUE before calling jpeg_start_compress() will prevent the table from being written at all. If you want to create a "pure" abbreviated image file containing no tables, just call "jpeg_suppress_tables(&cinfo, TRUE)" after constructing all the tables. If you want to emit some but not all tables, you'll need to set the individual sent_table fields directly. To create an abbreviated image, you must also call jpeg_start_compress() with a second parameter of FALSE, not TRUE. Otherwise jpeg_start_compress() will force all the sent_table fields to FALSE. (This is a safety feature to prevent abbreviated images from being created accidentally.) To create a tables-only file, perform the same parameter setup that you normally would, but instead of calling jpeg_start_compress() and so on, call jpeg_write_tables(&cinfo). This will write an abbreviated datastream containing only SOI, DQT and/or DHT markers, and EOI. All the quantization and Huffman tables that are currently defined in the compression object will be emitted unless their sent_tables flag is already TRUE, and then all the sent_tables flags will be set TRUE. A sure-fire way to create matching tables-only and abbreviated image files is to proceed as follows: create JPEG compression object set JPEG parameters set destination to tables-only file jpeg_write_tables(&cinfo); set destination to image file jpeg_start_compress(&cinfo, FALSE); write data... jpeg_finish_compress(&cinfo); Since the JPEG parameters are not altered between writing the table file and the abbreviated image file, the same tables are sure to be used. Of course, you can repeat the jpeg_start_compress() ... jpeg_finish_compress() sequence many times to produce many abbreviated image files matching the table file. You cannot suppress output of the computed Huffman tables when Huffman optimization is selected. (If you could, there'd be no way to decode the image...) Generally, you don't want to set optimize_coding = TRUE when you are trying to produce abbreviated files. In some cases you might want to compress an image using tables which are not stored in the application, but are defined in an interchange or tables-only file readable by the application. This can be done by setting up a JPEG decompression object to read the specification file, then copying the tables into your compression object. See jpeg_copy_critical_parameters() for an example of copying quantization tables. To read abbreviated image files, you simply need to load the proper tables into the decompression object before trying to read the abbreviated image. If the proper tables are stored in the application program, you can just allocate the table structs and fill in their contents directly. For example, to load a fixed quantization table into table slot "n": if (cinfo.quant_tbl_ptrs[n] == NULL) cinfo.quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) &cinfo); quant_ptr = cinfo.quant_tbl_ptrs[n]; /* quant_ptr is JQUANT_TBL* */ for (i = 0; i < 64; i++) { /* Qtable[] is desired quantization table, in natural array order */ quant_ptr->quantval[i] = Qtable[i]; } Code to load a fixed Huffman table is typically (for AC table "n"): if (cinfo.ac_huff_tbl_ptrs[n] == NULL) cinfo.ac_huff_tbl_ptrs[n] = jpeg_alloc_huff_table((j_common_ptr) &cinfo); huff_ptr = cinfo.ac_huff_tbl_ptrs[n]; /* huff_ptr is JHUFF_TBL* */ for (i = 1; i <= 16; i++) { /* counts[i] is number of Huffman codes of length i bits, i=1..16 */ huff_ptr->bits[i] = counts[i]; } for (i = 0; i < 256; i++) { /* symbols[] is the list of Huffman symbols, in code-length order */ huff_ptr->huffval[i] = symbols[i]; } (Note that trying to set cinfo.quant_tbl_ptrs[n] to point directly at a constant JQUANT_TBL object is not safe. If the incoming file happened to contain a quantization table definition, your master table would get overwritten! Instead allocate a working table copy and copy the master table into it, as illustrated above. Ditto for Huffman tables, of course.) You might want to read the tables from a tables-only file, rather than hard-wiring them into your application. The jpeg_read_header() call is sufficient to read a tables-only file. You must pass a second parameter of FALSE to indicate that you do not require an image to be present. Thus, the typical scenario is create JPEG decompression object set source to tables-only file jpeg_read_header(&cinfo, FALSE); set source to abbreviated image file jpeg_read_header(&cinfo, TRUE); set decompression parameters jpeg_start_decompress(&cinfo); read data... jpeg_finish_decompress(&cinfo); In some cases, you may want to read a file without knowing whether it contains an image or just tables. In that case, pass FALSE and check the return value from jpeg_read_header(): it will be JPEG_HEADER_OK if an image was found, JPEG_HEADER_TABLES_ONLY if only tables were found. (A third return value, JPEG_SUSPENDED, is possible when using a suspending data source manager.) Note that jpeg_read_header() will not complain if you read an abbreviated image for which you haven't loaded the missing tables; the missing-table check occurs later, in jpeg_start_decompress(). It is possible to read a series of images from a single source file by repeating the jpeg_read_header() ... jpeg_finish_decompress() sequence, without releasing/recreating the JPEG object or the data source module. (If you did reinitialize, any partial bufferload left in the data source buffer at the end of one image would be discarded, causing you to lose the start of the next image.) When you use this method, stored tables are automatically carried forward, so some of the images can be abbreviated images that depend on tables from earlier images. If you intend to write a series of images into a single destination file, you might want to make a specialized data destination module that doesn't flush the output buffer at term_destination() time. This would speed things up by some trifling amount. Of course, you'd need to remember to flush the buffer after the last image. You can make the later images be abbreviated ones by passing FALSE to jpeg_start_compress(). Special markers --------------- Some applications may need to insert or extract special data in the JPEG datastream. The JPEG standard provides marker types "COM" (comment) and "APP0" through "APP15" (application) to hold application-specific data. Unfortunately, the use of these markers is not specified by the standard. COM markers are fairly widely used to hold user-supplied text. The JFIF file format spec uses APP0 markers with specified initial strings to hold certain data. Adobe applications use APP14 markers beginning with the string "Adobe" for miscellaneous data. Other APPn markers are rarely seen, but might contain almost anything. If you wish to store user-supplied text, we recommend you use COM markers and place readable 7-bit ASCII text in them. Newline conventions are not standardized --- expect to find LF (Unix style), CR/LF (DOS style), or CR (Mac style). A robust COM reader should be able to cope with random binary garbage, including nulls, since some applications generate COM markers containing non-ASCII junk. (But yours should not be one of them.) For program-supplied data, use an APPn marker, and be sure to begin it with an identifying string so that you can tell whether the marker is actually yours. It's probably best to avoid using APP0 or APP14 for any private markers. (NOTE: the upcoming SPIFF standard will use APP8 markers; we recommend you not use APP8 markers for any private purposes, either.) Keep in mind that at most 65533 bytes can be put into one marker, but you can have as many markers as you like. By default, the IJG compression library will write a JFIF APP0 marker if the selected JPEG colorspace is grayscale or YCbCr, or an Adobe APP14 marker if the selected colorspace is RGB, CMYK, or YCCK. You can disable this, but we don't recommend it. The decompression library will recognize JFIF and Adobe markers and will set the JPEG colorspace properly when one is found. You can write special markers immediately following the datastream header by calling jpeg_write_marker() after jpeg_start_compress() and before the first call to jpeg_write_scanlines(). When you do this, the markers appear after the SOI and the JFIF APP0 and Adobe APP14 markers (if written), but before all else. Specify the marker type parameter as "JPEG_COM" for COM or "JPEG_APP0 + n" for APPn. (Actually, jpeg_write_marker will let you write any marker type, but we don't recommend writing any other kinds of marker.) For example, to write a user comment string pointed to by comment_text: jpeg_write_marker(cinfo, JPEG_COM, comment_text, strlen(comment_text)); If it's not convenient to store all the marker data in memory at once, you can instead call jpeg_write_m_header() followed by multiple calls to jpeg_write_m_byte(). If you do it this way, it's your responsibility to call jpeg_write_m_byte() exactly the number of times given in the length parameter to jpeg_write_m_header(). (This method lets you empty the output buffer partway through a marker, which might be important when using a suspending data destination module. In any case, if you are using a suspending destination, you should flush its buffer after inserting any special markers. See "I/O suspension".) Or, if you prefer to synthesize the marker byte sequence yourself, you can just cram it straight into the data destination module. If you are writing JFIF 1.02 extension markers (thumbnail images), don't forget to set cinfo.JFIF_minor_version = 2 so that the encoder will write the correct JFIF version number in the JFIF header marker. The library's default is to write version 1.01, but that's wrong if you insert any 1.02 extension markers. (We could probably get away with just defaulting to 1.02, but there used to be broken decoders that would complain about unknown minor version numbers. To reduce compatibility risks it's safest not to write 1.02 unless you are actually using 1.02 extensions.) When reading, two methods of handling special markers are available: 1. You can ask the library to save the contents of COM and/or APPn markers into memory, and then examine them at your leisure afterwards. 2. You can supply your own routine to process COM and/or APPn markers on-the-fly as they are read. The first method is simpler to use, especially if you are using a suspending data source; writing a marker processor that copes with input suspension is not easy (consider what happens if the marker is longer than your available input buffer). However, the second method conserves memory since the marker data need not be kept around after it's been processed. For either method, you'd normally set up marker handling after creating a decompression object and before calling jpeg_read_header(), because the markers of interest will typically be near the head of the file and so will be scanned by jpeg_read_header. Once you've established a marker handling method, it will be used for the life of that decompression object (potentially many datastreams), unless you change it. Marker handling is determined separately for COM markers and for each APPn marker code. To save the contents of special markers in memory, call jpeg_save_markers(cinfo, marker_code, length_limit) where marker_code is the marker type to save, JPEG_COM or JPEG_APP0+n. (To arrange to save all the special marker types, you need to call this routine 17 times, for COM and APP0-APP15.) If the incoming marker is longer than length_limit data bytes, only length_limit bytes will be saved; this parameter allows you to avoid chewing up memory when you only need to see the first few bytes of a potentially large marker. If you want to save all the data, set length_limit to 0xFFFF; that is enough since marker lengths are only 16 bits. As a special case, setting length_limit to 0 prevents that marker type from being saved at all. (That is the default behavior, in fact.) After jpeg_read_header() completes, you can examine the special markers by following the cinfo->marker_list pointer chain. All the special markers in the file appear in this list, in order of their occurrence in the file (but omitting any markers of types you didn't ask for). Both the original data length and the saved data length are recorded for each list entry; the latter will not exceed length_limit for the particular marker type. Note that these lengths exclude the marker length word, whereas the stored representation within the JPEG file includes it. (Hence the maximum data length is really only 65533.) It is possible that additional special markers appear in the file beyond the SOS marker at which jpeg_read_header stops; if so, the marker list will be extended during reading of the rest of the file. This is not expected to be common, however. If you are short on memory you may want to reset the length limit to zero for all marker types after finishing jpeg_read_header, to ensure that the max_memory_to_use setting cannot be exceeded due to addition of later markers. The marker list remains stored until you call jpeg_finish_decompress or jpeg_abort, at which point the memory is freed and the list is set to empty. (jpeg_destroy also releases the storage, of course.) Note that the library is internally interested in APP0 and APP14 markers; if you try to set a small nonzero length limit on these types, the library will silently force the length up to the minimum it wants. (But you can set a zero length limit to prevent them from being saved at all.) Also, in a 16-bit environment, the maximum length limit may be constrained to less than 65533 by malloc() limitations. It is therefore best not to assume that the effective length limit is exactly what you set it to be. If you want to supply your own marker-reading routine, you do it by calling jpeg_set_marker_processor(). A marker processor routine must have the signature boolean jpeg_marker_parser_method (j_decompress_ptr cinfo) Although the marker code is not explicitly passed, the routine can find it in cinfo->unread_marker. At the time of call, the marker proper has been read from the data source module. The processor routine is responsible for reading the marker length word and the remaining parameter bytes, if any. Return TRUE to indicate success. (FALSE should be returned only if you are using a suspending data source and it tells you to suspend. See the standard marker processors in jdmarker.c for appropriate coding methods if you need to use a suspending data source.) If you override the default APP0 or APP14 processors, it is up to you to recognize JFIF and Adobe markers if you want colorspace recognition to occur properly. We recommend copying and extending the default processors if you want to do that. (A better idea is to save these marker types for later examination by calling jpeg_save_markers(); that method doesn't interfere with the library's own processing of these markers.) jpeg_set_marker_processor() and jpeg_save_markers() are mutually exclusive --- if you call one it overrides any previous call to the other, for the particular marker type specified. A simple example of an external COM processor can be found in djpeg.c. Also, see jpegtran.c for an example of using jpeg_save_markers. Raw (downsampled) image data ---------------------------- Some applications need to supply already-downsampled image data to the JPEG compressor, or to receive raw downsampled data from the decompressor. The library supports this requirement by allowing the application to write or read raw data, bypassing the normal preprocessing or postprocessing steps. The interface is different from the standard one and is somewhat harder to use. If your interest is merely in bypassing color conversion, we recommend that you use the standard interface and simply set jpeg_color_space = in_color_space (or jpeg_color_space = out_color_space for decompression). The mechanism described in this section is necessary only to supply or receive downsampled image data, in which not all components have the same dimensions. To compress raw data, you must supply the data in the colorspace to be used in the JPEG file (please read the earlier section on Special color spaces) and downsampled to the sampling factors specified in the JPEG parameters. You must supply the data in the format used internally by the JPEG library, namely a JSAMPIMAGE array. This is an array of pointers to two-dimensional arrays, each of type JSAMPARRAY. Each 2-D array holds the values for one color component. This structure is necessary since the components are of different sizes. If the image dimensions are not a multiple of the MCU size, you must also pad the data correctly (usually, this is done by replicating the last column and/or row). The data must be padded to a multiple of a DCT block in each component: that is, each downsampled row must contain a multiple of 8 valid samples, and there must be a multiple of 8 sample rows for each component. (For applications such as conversion of digital TV images, the standard image size is usually a multiple of the DCT block size, so that no padding need actually be done.) The procedure for compression of raw data is basically the same as normal compression, except that you call jpeg_write_raw_data() in place of jpeg_write_scanlines(). Before calling jpeg_start_compress(), you must do the following: * Set cinfo->raw_data_in to TRUE. (It is set FALSE by jpeg_set_defaults().) This notifies the library that you will be supplying raw data. * Ensure jpeg_color_space is correct --- an explicit jpeg_set_colorspace() call is a good idea. Note that since color conversion is bypassed, in_color_space is ignored, except that jpeg_set_defaults() uses it to choose the default jpeg_color_space setting. * Ensure the sampling factors, cinfo->comp_info[i].h_samp_factor and cinfo->comp_info[i].v_samp_factor, are correct. Since these indicate the dimensions of the data you are supplying, it's wise to set them explicitly, rather than assuming the library's defaults are what you want. To pass raw data to the library, call jpeg_write_raw_data() in place of jpeg_write_scanlines(). The two routines work similarly except that jpeg_write_raw_data takes a JSAMPIMAGE data array rather than JSAMPARRAY. The scanlines count passed to and returned from jpeg_write_raw_data is measured in terms of the component with the largest v_samp_factor. jpeg_write_raw_data() processes one MCU row per call, which is to say v_samp_factor*DCTSIZE sample rows of each component. The passed num_lines value must be at least max_v_samp_factor*DCTSIZE, and the return value will be exactly that amount (or possibly some multiple of that amount, in future library versions). This is true even on the last call at the bottom of the image; don't forget to pad your data as necessary. The required dimensions of the supplied data can be computed for each component as cinfo->comp_info[i].width_in_blocks*DCTSIZE samples per row cinfo->comp_info[i].height_in_blocks*DCTSIZE rows in image after jpeg_start_compress() has initialized those fields. If the valid data is smaller than this, it must be padded appropriately. For some sampling factors and image sizes, additional dummy DCT blocks are inserted to make the image a multiple of the MCU dimensions. The library creates such dummy blocks itself; it does not read them from your supplied data. Therefore you need never pad by more than DCTSIZE samples. An example may help here. Assume 2h2v downsampling of YCbCr data, that is cinfo->comp_info[0].h_samp_factor = 2 for Y cinfo->comp_info[0].v_samp_factor = 2 cinfo->comp_info[1].h_samp_factor = 1 for Cb cinfo->comp_info[1].v_samp_factor = 1 cinfo->comp_info[2].h_samp_factor = 1 for Cr cinfo->comp_info[2].v_samp_factor = 1 and suppose that the nominal image dimensions (cinfo->image_width and cinfo->image_height) are 101x101 pixels. Then jpeg_start_compress() will compute downsampled_width = 101 and width_in_blocks = 13 for Y, downsampled_width = 51 and width_in_blocks = 7 for Cb and Cr (and the same for the height fields). You must pad the Y data to at least 13*8 = 104 columns and rows, the Cb/Cr data to at least 7*8 = 56 columns and rows. The MCU height is max_v_samp_factor = 2 DCT rows so you must pass at least 16 scanlines on each call to jpeg_write_raw_data(), which is to say 16 actual sample rows of Y and 8 each of Cb and Cr. A total of 7 MCU rows are needed, so you must pass a total of 7*16 = 112 "scanlines". The last DCT block row of Y data is dummy, so it doesn't matter what you pass for it in the data arrays, but the scanlines count must total up to 112 so that all of the Cb and Cr data gets passed. Output suspension is supported with raw-data compression: if the data destination module suspends, jpeg_write_raw_data() will return 0. In this case the same data rows must be passed again on the next call. Decompression with raw data output implies bypassing all postprocessing: you cannot ask for rescaling or color quantization, for instance. More seriously, you must deal with the color space and sampling factors present in the incoming file. If your application only handles, say, 2h1v YCbCr data, you must check for and fail on other color spaces or other sampling factors. The library will not convert to a different color space for you. To obtain raw data output, set cinfo->raw_data_out = TRUE before jpeg_start_decompress() (it is set FALSE by jpeg_read_header()). Be sure to verify that the color space and sampling factors are ones you can handle. Then call jpeg_read_raw_data() in place of jpeg_read_scanlines(). The decompression process is otherwise the same as usual. jpeg_read_raw_data() returns one MCU row per call, and thus you must pass a buffer of at least max_v_samp_factor*DCTSIZE scanlines (scanline counting is the same as for raw-data compression). The buffer you pass must be large enough to hold the actual data plus padding to DCT-block boundaries. As with compression, any entirely dummy DCT blocks are not processed so you need not allocate space for them, but the total scanline count includes them. The above example of computing buffer dimensions for raw-data compression is equally valid for decompression. Input suspension is supported with raw-data decompression: if the data source module suspends, jpeg_read_raw_data() will return 0. You can also use buffered-image mode to read raw data in multiple passes. Really raw data: DCT coefficients --------------------------------- It is possible to read or write the contents of a JPEG file as raw DCT coefficients. This facility is mainly intended for use in lossless transcoding between different JPEG file formats. Other possible applications include lossless cropping of a JPEG image, lossless reassembly of a multi-strip or multi-tile TIFF/JPEG file into a single JPEG datastream, etc. To read the contents of a JPEG file as DCT coefficients, open the file and do jpeg_read_header() as usual. But instead of calling jpeg_start_decompress() and jpeg_read_scanlines(), call jpeg_read_coefficients(). This will read the entire image into a set of virtual coefficient-block arrays, one array per component. The return value is a pointer to an array of virtual-array descriptors. Each virtual array can be accessed directly using the JPEG memory manager's access_virt_barray method (see Memory management, below, and also read structure.doc's discussion of virtual array handling). Or, for simple transcoding to a different JPEG file format, the array list can just be handed directly to jpeg_write_coefficients(). Each block in the block arrays contains quantized coefficient values in normal array order (not JPEG zigzag order). The block arrays contain only DCT blocks containing real data; any entirely-dummy blocks added to fill out interleaved MCUs at the right or bottom edges of the image are discarded during reading and are not stored in the block arrays. (The size of each block array can be determined from the width_in_blocks and height_in_blocks fields of the component's comp_info entry.) This is also the data format expected by jpeg_write_coefficients(). When you are done using the virtual arrays, call jpeg_finish_decompress() to release the array storage and return the decompression object to an idle state; or just call jpeg_destroy() if you don't need to reuse the object. If you use a suspending data source, jpeg_read_coefficients() will return NULL if it is forced to suspend; a non-NULL return value indicates successful completion. You need not test for a NULL return value when using a non-suspending data source. It is also possible to call jpeg_read_coefficients() to obtain access to the decoder's coefficient arrays during a normal decode cycle in buffered-image mode. This frammish might be useful for progressively displaying an incoming image and then re-encoding it without loss. To do this, decode in buffered- image mode as discussed previously, then call jpeg_read_coefficients() after the last jpeg_finish_output() call. The arrays will be available for your use until you call jpeg_finish_decompress(). To write the contents of a JPEG file as DCT coefficients, you must provide the DCT coefficients stored in virtual block arrays. You can either pass block arrays read from an input JPEG file by jpeg_read_coefficients(), or allocate virtual arrays from the JPEG compression object and fill them yourself. In either case, jpeg_write_coefficients() is substituted for jpeg_start_compress() and jpeg_write_scanlines(). Thus the sequence is * Create compression object * Set all compression parameters as necessary * Request virtual arrays if needed * jpeg_write_coefficients() * jpeg_finish_compress() * Destroy or re-use compression object jpeg_write_coefficients() is passed a pointer to an array of virtual block array descriptors; the number of arrays is equal to cinfo.num_components. The virtual arrays need only have been requested, not realized, before jpeg_write_coefficients() is called. A side-effect of jpeg_write_coefficients() is to realize any virtual arrays that have been requested from the compression object's memory manager. Thus, when obtaining the virtual arrays from the compression object, you should fill the arrays after calling jpeg_write_coefficients(). The data is actually written out when you call jpeg_finish_compress(); jpeg_write_coefficients() only writes the file header. When writing raw DCT coefficients, it is crucial that the JPEG quantization tables and sampling factors match the way the data was encoded, or the resulting file will be invalid. For transcoding from an existing JPEG file, we recommend using jpeg_copy_critical_parameters(). This routine initializes all the compression parameters to default values (like jpeg_set_defaults()), then copies the critical information from a source decompression object. The decompression object should have just been used to read the entire JPEG input file --- that is, it should be awaiting jpeg_finish_decompress(). jpeg_write_coefficients() marks all tables stored in the compression object as needing to be written to the output file (thus, it acts like jpeg_start_compress(cinfo, TRUE)). This is for safety's sake, to avoid emitting abbreviated JPEG files by accident. If you really want to emit an abbreviated JPEG file, call jpeg_suppress_tables(), or set the tables' individual sent_table flags, between calling jpeg_write_coefficients() and jpeg_finish_compress(). Progress monitoring ------------------- Some applications may need to regain control from the JPEG library every so often. The typical use of this feature is to produce a percent-done bar or other progress display. (For a simple example, see cjpeg.c or djpeg.c.) Although you do get control back frequently during the data-transferring pass (the jpeg_read_scanlines or jpeg_write_scanlines loop), any additional passes will occur inside jpeg_finish_compress or jpeg_start_decompress; those routines may take a long time to execute, and you don't get control back until they are done. You can define a progress-monitor routine which will be called periodically by the library. No guarantees are made about how often this call will occur, so we don't recommend you use it for mouse tracking or anything like that. At present, a call will occur once per MCU row, scanline, or sample row group, whichever unit is convenient for the current processing mode; so the wider the image, the longer the time between calls. During the data transferring pass, only one call occurs per call of jpeg_read_scanlines or jpeg_write_scanlines, so don't pass a large number of scanlines at once if you want fine resolution in the progress count. (If you really need to use the callback mechanism for time-critical tasks like mouse tracking, you could insert additional calls inside some of the library's inner loops.) To establish a progress-monitor callback, create a struct jpeg_progress_mgr, fill in its progress_monitor field with a pointer to your callback routine, and set cinfo->progress to point to the struct. The callback will be called whenever cinfo->progress is non-NULL. (This pointer is set to NULL by jpeg_create_compress or jpeg_create_decompress; the library will not change it thereafter. So if you allocate dynamic storage for the progress struct, make sure it will live as long as the JPEG object does. Allocating from the JPEG memory manager with lifetime JPOOL_PERMANENT will work nicely.) You can use the same callback routine for both compression and decompression. The jpeg_progress_mgr struct contains four fields which are set by the library: long pass_counter; /* work units completed in this pass */ long pass_limit; /* total number of work units in this pass */ int completed_passes; /* passes completed so far */ int total_passes; /* total number of passes expected */ During any one pass, pass_counter increases from 0 up to (not including) pass_limit; the step size is usually but not necessarily 1. The pass_limit value may change from one pass to another. The expected total number of passes is in total_passes, and the number of passes already completed is in completed_passes. Thus the fraction of work completed may be estimated as completed_passes + (pass_counter/pass_limit) -------------------------------------------- total_passes ignoring the fact that the passes may not be equal amounts of work. When decompressing, pass_limit can even change within a pass, because it depends on the number of scans in the JPEG file, which isn't always known in advance. The computed fraction-of-work-done may jump suddenly (if the library discovers it has overestimated the number of scans) or even decrease (in the opposite case). It is not wise to put great faith in the work estimate. When using the decompressor's buffered-image mode, the progress monitor work estimate is likely to be completely unhelpful, because the library has no way to know how many output passes will be demanded of it. Currently, the library sets total_passes based on the assumption that there will be one more output pass if the input file end hasn't yet been read (jpeg_input_complete() isn't TRUE), but no more output passes if the file end has been reached when the output pass is started. This means that total_passes will rise as additional output passes are requested. If you have a way of determining the input file size, estimating progress based on the fraction of the file that's been read will probably be more useful than using the library's value. Memory management ----------------- This section covers some key facts about the JPEG library's built-in memory manager. For more info, please read structure.doc's section about the memory manager, and consult the source code if necessary. All memory and temporary file allocation within the library is done via the memory manager. If necessary, you can replace the "back end" of the memory manager to control allocation yourself (for example, if you don't want the library to use malloc() and free() for some reason). Some data is allocated "permanently" and will not be freed until the JPEG object is destroyed. Most data is allocated "per image" and is freed by jpeg_finish_compress, jpeg_finish_decompress, or jpeg_abort. You can call the memory manager yourself to allocate structures that will automatically be freed at these times. Typical code for this is ptr = (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, size); Use JPOOL_PERMANENT to get storage that lasts as long as the JPEG object. Use alloc_large instead of alloc_small for anything bigger than a few Kbytes. There are also alloc_sarray and alloc_barray routines that automatically build 2-D sample or block arrays. The library's minimum space requirements to process an image depend on the image's width, but not on its height, because the library ordinarily works with "strip" buffers that are as wide as the image but just a few rows high. Some operating modes (eg, two-pass color quantization) require full-image buffers. Such buffers are treated as "virtual arrays": only the current strip need be in memory, and the rest can be swapped out to a temporary file. If you use the simplest memory manager back end (jmemnobs.c), then no temporary files are used; virtual arrays are simply malloc()'d. Images bigger than memory can be processed only if your system supports virtual memory. The other memory manager back ends support temporary files of various flavors and thus work in machines without virtual memory. They may also be useful on Unix machines if you need to process images that exceed available swap space. When using temporary files, the library will make the in-memory buffers for its virtual arrays just big enough to stay within a "maximum memory" setting. Your application can set this limit by setting cinfo->mem->max_memory_to_use after creating the JPEG object. (Of course, there is still a minimum size for the buffers, so the max-memory setting is effective only if it is bigger than the minimum space needed.) If you allocate any large structures yourself, you must allocate them before jpeg_start_compress() or jpeg_start_decompress() in order to have them counted against the max memory limit. Also keep in mind that space allocated with alloc_small() is ignored, on the assumption that it's too small to be worth worrying about; so a reasonable safety margin should be left when setting max_memory_to_use. If you use the jmemname.c or jmemdos.c memory manager back end, it is important to clean up the JPEG object properly to ensure that the temporary files get deleted. (This is especially crucial with jmemdos.c, where the "temporary files" may be extended-memory segments; if they are not freed, DOS will require a reboot to recover the memory.) Thus, with these memory managers, it's a good idea to provide a signal handler that will trap any early exit from your program. The handler should call either jpeg_abort() or jpeg_destroy() for any active JPEG objects. A handler is not needed with jmemnobs.c, and shouldn't be necessary with jmemansi.c or jmemmac.c either, since the C library is supposed to take care of deleting files made with tmpfile(). Memory usage ------------ Working memory requirements while performing compression or decompression depend on image dimensions, image characteristics (such as colorspace and JPEG process), and operating mode (application-selected options). As of v6b, the decompressor requires: 1. About 24K in more-or-less-fixed-size data. This varies a bit depending on operating mode and image characteristics (particularly color vs. grayscale), but it doesn't depend on image dimensions. 2. Strip buffers (of size proportional to the image width) for IDCT and upsampling results. The worst case for commonly used sampling factors is about 34 bytes * width in pixels for a color image. A grayscale image only needs about 8 bytes per pixel column. 3. A full-image DCT coefficient buffer is needed to decode a multi-scan JPEG file (including progressive JPEGs), or whenever you select buffered-image mode. This takes 2 bytes/coefficient. At typical 2x2 sampling, that's 3 bytes per pixel for a color image. Worst case (1x1 sampling) requires 6 bytes/pixel. For grayscale, figure 2 bytes/pixel. 4. To perform 2-pass color quantization, the decompressor also needs a 128K color lookup table and a full-image pixel buffer (3 bytes/pixel). This does not count any memory allocated by the application, such as a buffer to hold the final output image. The above figures are valid for 8-bit JPEG data precision and a machine with 32-bit ints. For 12-bit JPEG data, double the size of the strip buffers and quantization pixel buffer. The "fixed-size" data will be somewhat smaller with 16-bit ints, larger with 64-bit ints. Also, CMYK or other unusual color spaces will require different amounts of space. The full-image coefficient and pixel buffers, if needed at all, do not have to be fully RAM resident; you can have the library use temporary files instead when the total memory usage would exceed a limit you set. (But if your OS supports virtual memory, it's probably better to just use jmemnobs and let the OS do the swapping.) The compressor's memory requirements are similar, except that it has no need for color quantization. Also, it needs a full-image DCT coefficient buffer if Huffman-table optimization is asked for, even if progressive mode is not requested. If you need more detailed information about memory usage in a particular situation, you can enable the MEM_STATS code in jmemmgr.c. Library compile-time options ---------------------------- A number of compile-time options are available by modifying jmorecfg.h. The JPEG standard provides for both the baseline 8-bit DCT process and a 12-bit DCT process. The IJG code supports 12-bit lossy JPEG if you define BITS_IN_JSAMPLE as 12 rather than 8. Note that this causes JSAMPLE to be larger than a char, so it affects the surrounding application's image data. The sample applications cjpeg and djpeg can support 12-bit mode only for PPM and GIF file formats; you must disable the other file formats to compile a 12-bit cjpeg or djpeg. (install.doc has more information about that.) At present, a 12-bit library can handle *only* 12-bit images, not both precisions. (If you need to include both 8- and 12-bit libraries in a single application, you could probably do it by defining NEED_SHORT_EXTERNAL_NAMES for just one of the copies. You'd have to access the 8-bit and 12-bit copies from separate application source files. This is untested ... if you try it, we'd like to hear whether it works!) Note that a 12-bit library always compresses in Huffman optimization mode, in order to generate valid Huffman tables. This is necessary because our default Huffman tables only cover 8-bit data. If you need to output 12-bit files in one pass, you'll have to supply suitable default Huffman tables. You may also want to supply your own DCT quantization tables; the existing quality-scaling code has been developed for 8-bit use, and probably doesn't generate especially good tables for 12-bit. The maximum number of components (color channels) in the image is determined by MAX_COMPONENTS. The JPEG standard allows up to 255 components, but we expect that few applications will need more than four or so. On machines with unusual data type sizes, you may be able to improve performance or reduce memory space by tweaking the various typedefs in jmorecfg.h. In particular, on some RISC CPUs, access to arrays of "short"s is quite slow; consider trading memory for speed by making JCOEF, INT16, and UINT16 be "int" or "unsigned int". UINT8 is also a candidate to become int. You probably don't want to make JSAMPLE be int unless you have lots of memory to burn. You can reduce the size of the library by compiling out various optional functions. To do this, undefine xxx_SUPPORTED symbols as necessary. You can also save a few K by not having text error messages in the library; the standard error message table occupies about 5Kb. This is particularly reasonable for embedded applications where there's no good way to display a message anyway. To do this, remove the creation of the message table (jpeg_std_message_table[]) from jerror.c, and alter format_message to do something reasonable without it. You could output the numeric value of the message code number, for example. If you do this, you can also save a couple more K by modifying the TRACEMSn() macros in jerror.h to expand to nothing; you don't need trace capability anyway, right? Portability considerations -------------------------- The JPEG library has been written to be extremely portable; the sample applications cjpeg and djpeg are slightly less so. This section summarizes the design goals in this area. (If you encounter any bugs that cause the library to be less portable than is claimed here, we'd appreciate hearing about them.) The code works fine on ANSI C, C++, and pre-ANSI C compilers, using any of the popular system include file setups, and some not-so-popular ones too. See install.doc for configuration procedures. The code is not dependent on the exact sizes of the C data types. As distributed, we make the assumptions that char is at least 8 bits wide short is at least 16 bits wide int is at least 16 bits wide long is at least 32 bits wide (These are the minimum requirements of the ANSI C standard.) Wider types will work fine, although memory may be used inefficiently if char is much larger than 8 bits or short is much bigger than 16 bits. The code should work equally well with 16- or 32-bit ints. In a system where these assumptions are not met, you may be able to make the code work by modifying the typedefs in jmorecfg.h. However, you will probably have difficulty if int is less than 16 bits wide, since references to plain int abound in the code. char can be either signed or unsigned, although the code runs faster if an unsigned char type is available. If char is wider than 8 bits, you will need to redefine JOCTET and/or provide custom data source/destination managers so that JOCTET represents exactly 8 bits of data on external storage. The JPEG library proper does not assume ASCII representation of characters. But some of the image file I/O modules in cjpeg/djpeg do have ASCII dependencies in file-header manipulation; so does cjpeg's select_file_type() routine. The JPEG library does not rely heavily on the C library. In particular, C stdio is used only by the data source/destination modules and the error handler, all of which are application-replaceable. (cjpeg/djpeg are more heavily dependent on stdio.) malloc and free are called only from the memory manager "back end" module, so you can use a different memory allocator by replacing that one file. The code generally assumes that C names must be unique in the first 15 characters. However, global function names can be made unique in the first 6 characters by defining NEED_SHORT_EXTERNAL_NAMES. More info about porting the code may be gleaned by reading jconfig.doc, jmorecfg.h, and jinclude.h. Notes for MS-DOS implementors ----------------------------- The IJG code is designed to work efficiently in 80x86 "small" or "medium" memory models (i.e., data pointers are 16 bits unless explicitly declared "far"; code pointers can be either size). You may be able to use small model to compile cjpeg or djpeg by itself, but you will probably have to use medium model for any larger application. This won't make much difference in performance. You *will* take a noticeable performance hit if you use a large-data memory model (perhaps 10%-25%), and you should avoid "huge" model if at all possible. The JPEG library typically needs 2Kb-3Kb of stack space. It will also malloc about 20K-30K of near heap space while executing (and lots of far heap, but that doesn't count in this calculation). This figure will vary depending on selected operating mode, and to a lesser extent on image size. There is also about 5Kb-6Kb of constant data which will be allocated in the near data segment (about 4Kb of this is the error message table). Thus you have perhaps 20K available for other modules' static data and near heap space before you need to go to a larger memory model. The C library's static data will account for several K of this, but that still leaves a good deal for your needs. (If you are tight on space, you could reduce the sizes of the I/O buffers allocated by jdatasrc.c and jdatadst.c, say from 4K to 1K. Another possibility is to move the error message table to far memory; this should be doable with only localized hacking on jerror.c.) About 2K of the near heap space is "permanent" memory that will not be released until you destroy the JPEG object. This is only an issue if you save a JPEG object between compression or decompression operations. Far data space may also be a tight resource when you are dealing with large images. The most memory-intensive case is decompression with two-pass color quantization, or single-pass quantization to an externally supplied color map. This requires a 128Kb color lookup table plus strip buffers amounting to about 40 bytes per column for typical sampling ratios (eg, about 25600 bytes for a 640-pixel-wide image). You may not be able to process wide images if you have large data structures of your own. Of course, all of these concerns vanish if you use a 32-bit flat-memory-model compiler, such as DJGPP or Watcom C. We highly recommend flat model if you can use it; the JPEG library is significantly faster in flat model. Papyrus3/JpegDir/JpgLossy/JCSAMPLE.C0000755000175000017500000004566207535143454014156 0ustar /* * jcsample.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains downsampling routines. * * Downsampling input data is counted in "row groups". A row group * is defined to be max_v_samp_factor pixel rows of each component, * from which the downsampler produces v_samp_factor sample rows. * A single row group is processed in each call to the downsampler module. * * The downsampler is responsible for edge-expansion of its output data * to fill an integral number of DCT blocks horizontally. The source buffer * may be modified if it is helpful for this purpose (the source buffer is * allocated wide enough to correspond to the desired output width). * The caller (the prep controller) is responsible for vertical padding. * * The downsampler may request "context rows" by setting need_context_rows * during startup. In this case, the input arrays will contain at least * one row group's worth of pixels above and below the passed-in data; * the caller will create dummy rows at image top and bottom by replicating * the first or last real pixel row. * * An excellent reference for image resampling is * Digital Image Warping, George Wolberg, 1990. * Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7. * * The downsampling algorithm used here is a simple average of the source * pixels covered by the output pixel. The hi-falutin sampling literature * refers to this as a "box filter". In general the characteristics of a box * filter are not very good, but for the specific cases we normally use (1:1 * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not * nearly so bad. If you intend to use other sampling ratios, you'd be well * advised to improve this code. * * A simple input-smoothing capability is provided. This is mainly intended * for cleaning up color-dithered GIF input files (if you find it inadequate, * we suggest using an external filtering program such as pnmconvol). When * enabled, each input pixel P is replaced by a weighted sum of itself and its * eight neighbors. P's weight is 1-8*SF and each neighbor's weight is SF, * where SF = (smoothing_factor / 1024). * Currently, smoothing is only supported for 2h2v sampling factors. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* Pointer to routine to downsample a single component */ typedef JMETHOD(void, downsample1_ptr, (j_compress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY output_data)); /* Private subobject */ typedef struct { struct jpeg_downsampler pub; /* public fields */ /* Downsampling method pointers, one per component */ downsample1_ptr methods[MAX_COMPONENTS]; } my_downsampler; typedef my_downsampler * my_downsample_ptr; /* * Initialize for a downsampling pass. */ METHODDEF(void) start_pass_downsample (j_compress_ptr cinfo) { /* no work for now */ } /* * Expand a component horizontally from width input_cols to width output_cols, * by duplicating the rightmost samples. */ LOCAL(void) expand_right_edge (JSAMPARRAY image_data, int num_rows, JDIMENSION input_cols, JDIMENSION output_cols) { register JSAMPROW ptr; register JSAMPLE pixval; register int count; int row; int numcols = (int) (output_cols - input_cols); if (numcols > 0) { for (row = 0; row < num_rows; row++) { ptr = image_data[row] + input_cols; pixval = ptr[-1]; /* don't need GETJSAMPLE() here */ for (count = numcols; count > 0; count--) *ptr++ = pixval; } } } /* * Do downsampling for a whole row group (all components). * * In this version we simply downsample each component independently. */ METHODDEF(void) sep_downsample (j_compress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION in_row_index, JSAMPIMAGE output_buf, JDIMENSION out_row_group_index) { my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample; int ci; jpeg_component_info * compptr; JSAMPARRAY in_ptr, out_ptr; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { in_ptr = input_buf[ci] + in_row_index; out_ptr = output_buf[ci] + (out_row_group_index * compptr->v_samp_factor); (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr); } } /* * Downsample pixel values of a single component. * One row group is processed per call. * This version handles arbitrary integral sampling ratios, without smoothing. * Note that this version is not actually used for customary sampling ratios. */ METHODDEF(void) int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY output_data) { int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v; JDIMENSION outcol, outcol_h; /* outcol_h == outcol*h_expand */ JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE; JSAMPROW inptr, outptr; INT32 outvalue; h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor; v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor; numpix = h_expand * v_expand; numpix2 = numpix/2; /* Expand input data enough to let all the output samples be generated * by the standard loop. Special-casing padded output would be more * efficient. */ expand_right_edge(input_data, cinfo->max_v_samp_factor, cinfo->image_width, output_cols * h_expand); inrow = 0; for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) { outptr = output_data[outrow]; for (outcol = 0, outcol_h = 0; outcol < output_cols; outcol++, outcol_h += h_expand) { outvalue = 0; for (v = 0; v < v_expand; v++) { inptr = input_data[inrow+v] + outcol_h; for (h = 0; h < h_expand; h++) { outvalue += (INT32) GETJSAMPLE(*inptr++); } } *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix); } inrow += v_expand; } } /* * Downsample pixel values of a single component. * This version handles the special case of a full-size component, * without smoothing. */ METHODDEF(void) fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY output_data) { /* Copy the data */ jcopy_sample_rows(input_data, 0, output_data, 0, cinfo->max_v_samp_factor, cinfo->image_width); /* Edge-expand */ expand_right_edge(output_data, cinfo->max_v_samp_factor, cinfo->image_width, compptr->width_in_blocks * DCTSIZE); } /* * Downsample pixel values of a single component. * This version handles the common case of 2:1 horizontal and 1:1 vertical, * without smoothing. * * A note about the "bias" calculations: when rounding fractional values to * integer, we do not want to always round 0.5 up to the next integer. * If we did that, we'd introduce a noticeable bias towards larger values. * Instead, this code is arranged so that 0.5 will be rounded up or down at * alternate pixel locations (a simple ordered dither pattern). */ METHODDEF(void) h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY output_data) { int outrow; JDIMENSION outcol; JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE; register JSAMPROW inptr, outptr; register int bias; /* Expand input data enough to let all the output samples be generated * by the standard loop. Special-casing padded output would be more * efficient. */ expand_right_edge(input_data, cinfo->max_v_samp_factor, cinfo->image_width, output_cols * 2); for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) { outptr = output_data[outrow]; inptr = input_data[outrow]; bias = 0; /* bias = 0,1,0,1,... for successive samples */ for (outcol = 0; outcol < output_cols; outcol++) { *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1]) + bias) >> 1); bias ^= 1; /* 0=>1, 1=>0 */ inptr += 2; } } } /* * Downsample pixel values of a single component. * This version handles the standard case of 2:1 horizontal and 2:1 vertical, * without smoothing. */ METHODDEF(void) h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY output_data) { int inrow, outrow; JDIMENSION outcol; JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE; register JSAMPROW inptr0, inptr1, outptr; register int bias; /* Expand input data enough to let all the output samples be generated * by the standard loop. Special-casing padded output would be more * efficient. */ expand_right_edge(input_data, cinfo->max_v_samp_factor, cinfo->image_width, output_cols * 2); inrow = 0; for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) { outptr = output_data[outrow]; inptr0 = input_data[inrow]; inptr1 = input_data[inrow+1]; bias = 1; /* bias = 1,2,1,2,... for successive samples */ for (outcol = 0; outcol < output_cols; outcol++) { *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) + GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]) + bias) >> 2); bias ^= 3; /* 1=>2, 2=>1 */ inptr0 += 2; inptr1 += 2; } inrow += 2; } } #ifdef INPUT_SMOOTHING_SUPPORTED /* * Downsample pixel values of a single component. * This version handles the standard case of 2:1 horizontal and 2:1 vertical, * with smoothing. One row of context is required. */ METHODDEF(void) h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, JSAMPARRAY input_data, JSAMPARRAY output_data) { int inrow, outrow; JDIMENSION colctr; JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE; register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr; INT32 membersum, neighsum, memberscale, neighscale; /* Expand input data enough to let all the output samples be generated * by the standard loop. Special-casing padded output would be more * efficient. */ expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2, cinfo->image_width, output_cols * 2); /* We don't bother to form the individual "smoothed" input pixel values; * we can directly compute the output which is the average of the four * smoothed values. Each of the four member pixels contributes a fraction * (1-8*SF) to its own smoothed image and a fraction SF to each of the three * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final * output. The four corner-adjacent neighbor pixels contribute a fraction * SF to just one smoothed pixel, or SF/4 to the final output; while the * eight edge-adjacent neighbors contribute SF to each of two smoothed * pixels, or SF/2 overall. In order to use integer arithmetic, these * factors are scaled by 2^16 = 65536. * Also recall that SF = smoothing_factor / 1024. */ memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */ neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */ inrow = 0; for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) { outptr = output_data[outrow]; inptr0 = input_data[inrow]; inptr1 = input_data[inrow+1]; above_ptr = input_data[inrow-1]; below_ptr = input_data[inrow+2]; /* Special case for first column: pretend column -1 is same as column 0 */ membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) + GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]); neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) + GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) + GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) + GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]); neighsum += neighsum; neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) + GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]); membersum = membersum * memberscale + neighsum * neighscale; *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16); inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2; for (colctr = output_cols - 2; colctr > 0; colctr--) { /* sum of pixels directly mapped to this output element */ membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) + GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]); /* sum of edge-neighbor pixels */ neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) + GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) + GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) + GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]); /* The edge-neighbors count twice as much as corner-neighbors */ neighsum += neighsum; /* Add in the corner-neighbors */ neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) + GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]); /* form final output scaled up by 2^16 */ membersum = membersum * memberscale + neighsum * neighscale; /* round, descale and output it */ *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16); inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2; } /* Special case for last column */ membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) + GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]); neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) + GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) + GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) + GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]); neighsum += neighsum; neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) + GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]); membersum = membersum * memberscale + neighsum * neighscale; *outptr = (JSAMPLE) ((membersum + 32768) >> 16); inrow += 2; } } /* * Downsample pixel values of a single component. * This version handles the special case of a full-size component, * with smoothing. One row of context is required. */ METHODDEF(void) fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY input_data, JSAMPARRAY output_data) { int outrow; JDIMENSION colctr; JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE; register JSAMPROW inptr, above_ptr, below_ptr, outptr; INT32 membersum, neighsum, memberscale, neighscale; int colsum, lastcolsum, nextcolsum; /* Expand input data enough to let all the output samples be generated * by the standard loop. Special-casing padded output would be more * efficient. */ expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2, cinfo->image_width, output_cols); /* Each of the eight neighbor pixels contributes a fraction SF to the * smoothed pixel, while the main pixel contributes (1-8*SF). In order * to use integer arithmetic, these factors are multiplied by 2^16 = 65536. * Also recall that SF = smoothing_factor / 1024. */ memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */ neighscale = cinfo->smoothing_factor * 64; /* scaled SF */ for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) { outptr = output_data[outrow]; inptr = input_data[outrow]; above_ptr = input_data[outrow-1]; below_ptr = input_data[outrow+1]; /* Special case for first column */ colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) + GETJSAMPLE(*inptr); membersum = GETJSAMPLE(*inptr++); nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) + GETJSAMPLE(*inptr); neighsum = colsum + (colsum - membersum) + nextcolsum; membersum = membersum * memberscale + neighsum * neighscale; *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16); lastcolsum = colsum; colsum = nextcolsum; for (colctr = output_cols - 2; colctr > 0; colctr--) { membersum = GETJSAMPLE(*inptr++); above_ptr++; below_ptr++; nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) + GETJSAMPLE(*inptr); neighsum = lastcolsum + (colsum - membersum) + nextcolsum; membersum = membersum * memberscale + neighsum * neighscale; *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16); lastcolsum = colsum; colsum = nextcolsum; } /* Special case for last column */ membersum = GETJSAMPLE(*inptr); neighsum = lastcolsum + (colsum - membersum) + colsum; membersum = membersum * memberscale + neighsum * neighscale; *outptr = (JSAMPLE) ((membersum + 32768) >> 16); } } #endif /* INPUT_SMOOTHING_SUPPORTED */ /* * Module initialization routine for downsampling. * Note that we must select a routine for each component. */ GLOBAL(void) jinit_downsampler (j_compress_ptr cinfo) { my_downsample_ptr downsample; int ci; jpeg_component_info * compptr; boolean smoothok = TRUE; downsample = (my_downsample_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_downsampler)); cinfo->downsample = (struct jpeg_downsampler *) downsample; downsample->pub.start_pass = start_pass_downsample; downsample->pub.downsample = sep_downsample; downsample->pub.need_context_rows = FALSE; if (cinfo->CCIR601_sampling) ERREXIT(cinfo, JERR_CCIR601_NOTIMPL); /* Verify we can handle the sampling factors, and set up method pointers */ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { if (compptr->h_samp_factor == cinfo->max_h_samp_factor && compptr->v_samp_factor == cinfo->max_v_samp_factor) { #ifdef INPUT_SMOOTHING_SUPPORTED if (cinfo->smoothing_factor) { downsample->methods[ci] = fullsize_smooth_downsample; downsample->pub.need_context_rows = TRUE; } else #endif downsample->methods[ci] = fullsize_downsample; } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor && compptr->v_samp_factor == cinfo->max_v_samp_factor) { smoothok = FALSE; downsample->methods[ci] = h2v1_downsample; } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor && compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) { #ifdef INPUT_SMOOTHING_SUPPORTED if (cinfo->smoothing_factor) { downsample->methods[ci] = h2v2_smooth_downsample; downsample->pub.need_context_rows = TRUE; } else #endif downsample->methods[ci] = h2v2_downsample; } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 && (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) { smoothok = FALSE; downsample->methods[ci] = int_downsample; } else ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL); } #ifdef INPUT_SMOOTHING_SUPPORTED if (cinfo->smoothing_factor && !smoothok) TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL); #endif } Papyrus3/JpegDir/JpgLossy/WRRLE.C0000755000175000017500000002251307535143454013641 0ustar /* * wrrle.c * * Copyright (C) 1991-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to write output images in RLE format. * The Utah Raster Toolkit library is required (version 3.1 or later). * * These routines may need modification for non-Unix environments or * specialized applications. As they stand, they assume output to * an ordinary stdio stream. * * Based on code contributed by Mike Lijewski, * with updates from Robert Hutchinson. */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ #ifdef RLE_SUPPORTED /* rle.h is provided by the Utah Raster Toolkit. */ #include /* * We assume that JSAMPLE has the same representation as rle_pixel, * to wit, "unsigned char". Hence we can't cope with 12- or 16-bit samples. */ #if BITS_IN_JSAMPLE != 8 Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */ #endif /* * Since RLE stores scanlines bottom-to-top, we have to invert the image * from JPEG's top-to-bottom order. To do this, we save the outgoing data * in a virtual array during put_pixel_row calls, then actually emit the * RLE file during finish_output. */ /* * For now, if we emit an RLE color map then it is always 256 entries long, * though not all of the entries need be used. */ #define CMAPBITS 8 #define CMAPLENGTH (1<<(CMAPBITS)) typedef struct { struct djpeg_dest_struct pub; /* public fields */ jvirt_sarray_ptr image; /* virtual array to store the output image */ rle_map *colormap; /* RLE-style color map, or NULL if none */ rle_pixel **rle_row; /* To pass rows to rle_putrow() */ } rle_dest_struct; typedef rle_dest_struct * rle_dest_ptr; /* Forward declarations */ METHODDEF(void) rle_put_pixel_rows JPP((j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied)); /* * Write the file header. * * In this module it's easier to wait till finish_output to write anything. */ METHODDEF(void) start_output_rle (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) { rle_dest_ptr dest = (rle_dest_ptr) dinfo; size_t cmapsize; int i, ci; #ifdef PROGRESS_REPORT cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; #endif /* * Make sure the image can be stored in RLE format. * * - RLE stores image dimensions as *signed* 16 bit integers. JPEG * uses unsigned, so we have to check the width. * * - Colorspace is expected to be grayscale or RGB. * * - The number of channels (components) is expected to be 1 (grayscale/ * pseudocolor) or 3 (truecolor/directcolor). * (could be 2 or 4 if using an alpha channel, but we aren't) */ if (cinfo->output_width > 32767 || cinfo->output_height > 32767) ERREXIT2(cinfo, JERR_RLE_DIMENSIONS, cinfo->output_width, cinfo->output_height); if (cinfo->out_color_space != JCS_GRAYSCALE && cinfo->out_color_space != JCS_RGB) ERREXIT(cinfo, JERR_RLE_COLORSPACE); if (cinfo->output_components != 1 && cinfo->output_components != 3) ERREXIT1(cinfo, JERR_RLE_TOOMANYCHANNELS, cinfo->num_components); /* Convert colormap, if any, to RLE format. */ dest->colormap = NULL; if (cinfo->quantize_colors) { /* Allocate storage for RLE-style cmap, zero any extra entries */ cmapsize = cinfo->out_color_components * CMAPLENGTH * SIZEOF(rle_map); dest->colormap = (rle_map *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, cmapsize); MEMZERO(dest->colormap, cmapsize); /* Save away data in RLE format --- note 8-bit left shift! */ /* Shifting would need adjustment for JSAMPLEs wider than 8 bits. */ for (ci = 0; ci < cinfo->out_color_components; ci++) { for (i = 0; i < cinfo->actual_number_of_colors; i++) { dest->colormap[ci * CMAPLENGTH + i] = GETJSAMPLE(cinfo->colormap[ci][i]) << 8; } } } /* Set the output buffer to the first row */ dest->pub.buffer = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, dest->image, (JDIMENSION) 0, (JDIMENSION) 1, TRUE); dest->pub.buffer_height = 1; dest->pub.put_pixel_rows = rle_put_pixel_rows; #ifdef PROGRESS_REPORT if (progress != NULL) { progress->total_extra_passes++; /* count file writing as separate pass */ } #endif } /* * Write some pixel data. * * This routine just saves the data away in a virtual array. */ METHODDEF(void) rle_put_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied) { rle_dest_ptr dest = (rle_dest_ptr) dinfo; if (cinfo->output_scanline < cinfo->output_height) { dest->pub.buffer = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, dest->image, cinfo->output_scanline, (JDIMENSION) 1, TRUE); } } /* * Finish up at the end of the file. * * Here is where we really output the RLE file. */ METHODDEF(void) finish_output_rle (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) { rle_dest_ptr dest = (rle_dest_ptr) dinfo; rle_hdr header; /* Output file information */ rle_pixel **rle_row, *red, *green, *blue; JSAMPROW output_row; char cmapcomment[80]; int row, col; int ci; #ifdef PROGRESS_REPORT cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; #endif /* Initialize the header info */ header = *rle_hdr_init(NULL); header.rle_file = dest->pub.output_file; header.xmin = 0; header.xmax = cinfo->output_width - 1; header.ymin = 0; header.ymax = cinfo->output_height - 1; header.alpha = 0; header.ncolors = cinfo->output_components; for (ci = 0; ci < cinfo->output_components; ci++) { RLE_SET_BIT(header, ci); } if (cinfo->quantize_colors) { header.ncmap = cinfo->out_color_components; header.cmaplen = CMAPBITS; header.cmap = dest->colormap; /* Add a comment to the output image with the true colormap length. */ sprintf(cmapcomment, "color_map_length=%d", cinfo->actual_number_of_colors); rle_putcom(cmapcomment, &header); } /* Emit the RLE header and color map (if any) */ rle_put_setup(&header); /* Now output the RLE data from our virtual array. * We assume here that (a) rle_pixel is represented the same as JSAMPLE, * and (b) we are not on a machine where FAR pointers differ from regular. */ #ifdef PROGRESS_REPORT if (progress != NULL) { progress->pub.pass_limit = cinfo->output_height; progress->pub.pass_counter = 0; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } #endif if (cinfo->output_components == 1) { for (row = cinfo->output_height-1; row >= 0; row--) { rle_row = (rle_pixel **) (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, dest->image, (JDIMENSION) row, (JDIMENSION) 1, FALSE); rle_putrow(rle_row, (int) cinfo->output_width, &header); #ifdef PROGRESS_REPORT if (progress != NULL) { progress->pub.pass_counter++; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } #endif } } else { for (row = cinfo->output_height-1; row >= 0; row--) { rle_row = (rle_pixel **) dest->rle_row; output_row = * (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, dest->image, (JDIMENSION) row, (JDIMENSION) 1, FALSE); red = rle_row[0]; green = rle_row[1]; blue = rle_row[2]; for (col = cinfo->output_width; col > 0; col--) { *red++ = GETJSAMPLE(*output_row++); *green++ = GETJSAMPLE(*output_row++); *blue++ = GETJSAMPLE(*output_row++); } rle_putrow(rle_row, (int) cinfo->output_width, &header); #ifdef PROGRESS_REPORT if (progress != NULL) { progress->pub.pass_counter++; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } #endif } } #ifdef PROGRESS_REPORT if (progress != NULL) progress->completed_extra_passes++; #endif /* Emit file trailer */ rle_puteof(&header); fflush(dest->pub.output_file); if (ferror(dest->pub.output_file)) ERREXIT(cinfo, JERR_FILE_WRITE); } /* * The module selection routine for RLE format output. */ GLOBAL(djpeg_dest_ptr) jinit_write_rle (j_decompress_ptr cinfo) { rle_dest_ptr dest; /* Create module interface object, fill in method pointers */ dest = (rle_dest_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(rle_dest_struct)); dest->pub.start_output = start_output_rle; dest->pub.finish_output = finish_output_rle; /* Calculate output image dimensions so we can allocate space */ jpeg_calc_output_dimensions(cinfo); /* Allocate a work array for output to the RLE library. */ dest->rle_row = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, cinfo->output_width, (JDIMENSION) cinfo->output_components); /* Allocate a virtual array to hold the image. */ dest->image = (*cinfo->mem->request_virt_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, (JDIMENSION) (cinfo->output_width * cinfo->output_components), cinfo->output_height, (JDIMENSION) 1); return (djpeg_dest_ptr) dest; } #endif /* RLE_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/DJPEG0000755000175000017500000057202007535143454013421 0ustar ELF4ï°4 (44  Ôwkwkwlwl¬,yy¨/usr/lib/ld.so.1—“FV‹(i65`-dM1'Klna†‰,w_me)o€<OQrp‘I;$LYsT:U|@7ubxtW0‚ˆ/Z…~ŽŒŠ}+8X ’{‡j^k"%>?.A*&NP2SED][RC4!3#cB9v=hqG„yz\JfHƒgÔè˜È€ ÄO” O° OÈ wl wŒ yy¬y´y¼yÄ{©˜³üœ&t-aÐô DxpJøð\oÈ øl{@u~˜z|<(‡˜¼’D @ª{³}X@!¸LüHÎx×wl í„l|C¼${H xôw¼%wÈ*8@8~xP|4`”Hüoxdw˜h ¤…|À P•TL¢xÄ©x ±ÿàÈXÓO” Ù@øñxøx4þh T§(t.Vˆø@xˆF äÄ\Á¼ôtx”y @4Ž´¬äž°(¨wì¯MDHËyô Úxáx¸èŒÔ`üykäX—H1‡ÈH}X@NˆØ8dCl$týèˆ1p\œ†|”´N (ÆàPÜwÔâû tùxPèh{@!!€¼-ìLCDLQxÐV|dlCà,Ž4Ä’ L©9˜Ü¹nÌüËMŒ€ãxÜê£ „øC@,{wŒ (wø.xL5äÈO…è”c_¬X{DÀŽwk •OÈ ¢@0³x(º~”Ð{H !×Èxï0È4ôM´°x¬ „!Dh/x@4xX=x|D|(OxèV¦ hƒ$HyO° C,ŽÈ´  t¸±wà¹`Œ@ jpeg_idct_1x1jinit_input_controller_startjpeg_std_message_tablefreadjpeg_start_outputjpeg_idct_ifast_environ_endwrite_stdoutjpeg_abortjpeg_open_backing_storekeymatch_iob__register_frame_info__flsbuf_GLOBAL_OFFSET_TABLE_jpeg_consume_inputjpeg_free_large__ctypeabortatexitexitjdiv_round_upjpeg_destroy_decompressjcopy_block_rowjpeg_stdio_srctolowerjpeg_idct_4x4jpeg_idct_floatjpeg_destroymallocsprintfjpeg_save_markersjpeg_idct_islow_initjinit_d_main_controllerfwrite.umuljinit_d_post_controllerjinit_master_decompressjinit_write_targa.uremjinit_2pass_quantizerjinit_color_deconverter.remjpeg_fill_bit_bufferjinit_upsamplerjzero_farsscanf__register_frame_info_tableread_color_mapfclosegetenvjpeg_read_scanlines_DYNAMICjinit_write_bmpjpeg_calc_output_dimensionsjpeg_finish_decompress__iobjpeg_start_decompressjpeg_free_smalljinit_marker_readerjinit_phuff_decoderjpeg_has_multiple_scans__frame_state_forjinit_1pass_quantizer_exitjpeg_resync_to_restartjround_upjpeg_finish_outputenvironjpeg_std_errorjpeg_alloc_huff_tablejpeg_mem_initfreejpeg_CreateDecompressjpeg_mem_availablejpeg_read_raw_datajpeg_alloc_quant_tablejinit_write_ppmjinit_inverse_dct__deregister_frame_infostrcmpjpeg_idct_2x2jpeg_get_small_edata_PROCEDURE_LINKAGE_TABLE_fopenmemsetjpeg_set_marker_processorjpeg_input_completejinit_d_coef_controllerjinit_huff_decoder_etext_lib_versionjinit_memory_mgrfflushjpeg_abort_decompress_ctypejpeg_make_d_derived_tblmainjinit_write_gif.udivjinit_merged_upsamplerjpeg_mem_term.div__filbufmemcpyread_stdinstrlenjpeg_new_colormapjpeg_read_header_finijpeg_get_largejcopy_sample_rowsjpeg_huff_decodefprintfjpeg_natural_orderlibc.so.1SYSVABI_1.3libc.so.1Ì7̳Ö{@#{H/}XWw¼1wÈ2wÔ_wà‘wìMwøtxPx+xAx(}x4Bx@†xLuxX‡xd7xp x|ˆxˆFx”Ix <x¬ƒx¸QxÄ;xÐgxÜoxèŠxô0¼ à @¢ Dœ#  €€@ÖfÓ#°@Öb@ŒV’•, ” ”@ –ã@Ô"À@™@ÖW@ÖXã¿@/Ö®àì®À ÒÀÐ@Ѐ¢ €  Ð Ð$Ð?üŸÂÐЀ¢ 2¿ÿøÐ @‹©ÐÀÇàèã¿Çàèã¿@/Ö®àd®À ÐÀ’` @‹tÒÀ Çàèã¿Çàèã¿axÕ’â8Ô£4@ÖaxÕ’¢P@ÖaxÕ’¢`@ÖaxÕ’¢ˆ@Ö axÕ’¢À@ÖaxÕ’¢ð@ÖaxÕ’£ @ÕûaxÕ’£`Õ”ã @ÕóaxÕ’£¨Õ”ã @ÕëaxÕ’£ØÕ”ã @ÕãaxÖ’ Ö”àX@ÕÛaxÖ’ hÕ”ã @ÕÓaxÖ’ ˜@ÕÍaxÖ’ ¸Ö”àX@ÕÅaxÖ’ èÕ”ã @Õ½axÖ’¡(Õ”ã @ÕµaxÖ’¡`@Õ¯axÖ’¡@Õ©axÖ’¡È@Õ£axÖ’¢@ÕaxÖ’¢H@Õ—axÖ’¢€@Õ‘axÖ’¢À@Õ‹axÖ’¢ø@Õ…axÖ’£(@Õ @ÕvÇàèã¿xð' Dò' Hô' Lö' Pø' T’ Ò"#0À"#8РDÒÀ"`h Ð'¿ìпìÒ H€¢ €€ºÐ¿ì’‘*`Ò L ÒÒ'¿èпèÒ •*`‘: €¢ -€ пìÒ P€¢ €À"#8€ž€¡Ð¿è’ Ò'¿èпèÖ’£X” @€¢ €À"#0€ŒÐ¿èÖ’£`” @€¢ €Ð¿èÖ’£h” @ø€¢ €Ð¿èÖ’£p” @ € пèÖ’£€” @怢 €€$Ð¿ì’  Ð'¿ìÒ H€¢ €ÿþäп쒑*`Ò L ”¿äÐÖ’ã@Õ€¢ €ÿþÔРDÒ¿äÒ" `РD’ Ò" T€DпèÖ’£˜” @¹€¢ €HÐ¿ì’  Ð'¿ìÒ H€¢ €ÿþ¹Ð¿ì’‘*`Ô L’ Ð@Ö’£ ” @¡€¢ €Ð DÀ" H€*п쒑*`Ô L’ Ð@Ö’£¨” @€¢ €Ð D’ Ò" H€Ð¿ì’‘*`Ô L’ Ð@Ö’£°” @|€¢ €Ð D’ Ò" H€ÿþ€õпèÖ’£¸” @j€¢ €HÐ¿ì’  Ð'¿ìÒ H€¢ €ÿþjп쒑*`Ô L’ Ð@Ö’£À” @R€¢ €Ð D’ Ò" X€)п쒑*`Ô L’ Ð@Ö’£È” @?€¢ €Ð DÀ" X€Ð¿ì’‘*`Ô L’ Ð@Ö’£Ð” @-€¢ €Ð D’ Ò" X€ÿþ0€¦Ð¿èÖ’£Ø” @€¢ € пèÖ’£à” @€¢ €€Ò!°€¢`€axÖ’£è×”à×– (@Ô1’ Ò"!°Ò DÐ@Ò DÐ@Ò DÔ@Ò h”`Ô" h€uпèÖ’£¨” @ꀢ €Ð DÀ" \РD’ Ò" XРDÒ T€¢`€Ð D’ ØÒ" `РD’ Ò" HРDÀ" L€Xпè×’ P” @Í€¢ €’ Ò"#0€Jпè×’ X” @¿€¢ € пè×’ h” @¶€¢ €€Ð D’ Ò" ,€1пè×’ x” @¦€¢ €<Ð¿ì’  Ð'¿ìÒ H€¢ €ÿý¦Ð T€¢ €,п쒑*`Ô L’ Ð@×’ €@ÓÄÐ'¿àÐ¿à€¢ €Ð¿ì’‘*`Ò L– ax×’ ˆÔ£4ÖÀ@Ó« @ӢРDÒ¿à@)пà@ӪРD’ Ò" T€îпè×’  ” @c€¢ €A xÐ/¿ßÐ¿ì’  Ð'¿ìÒ H€¢ €ÿýaп쒑*`Ò L ”¿à–¿ßÐ×’ °@Ó~€¢ €ÿýPпߓ* ‘:`€¢ m€ пߓ* ‘:`€¢ M€€ Ð¿à”“* ’"@•*`”€‘* Ð'¿àÒ DÐ`Ò¿à– •*à”"€ —* –À “*àÒ" ,€¦Ð¿è×’ ¸” @€¢ €Ð DÀ" L€™Ð¿è×’ È” @€¢ €Ð DÀ" \€ŒÐ¿è×’ Ð” @€¢ €’ Ò"#0€~пè×’ Ø” @ó€¢ €Ð¿ì’  Ð'¿ìÒ H€¢ €ÿüóÒ¿ì” “* Ô L’@ Ô@Ô"#8€aпè×’ à” @Ö€¢ € пè×’ è” @Í€¢ €€’ Ò"#0€Hпè×’ ð” @½€¢ €’ Ò"#0€:пè×’ ø” @¯€¢ €!Ð¿ì’  Ð'¿ìÒ H€¢ €ÿü¯Ð¿ì’‘*`Ò L Ò D”`0Ò D–`4Ð×’!@ÒÊ€¢ €ÿüœ€Ð¿è×’¡” @‡€¢ €’ Ò"#0€ÿüŠÐ¿ì’ Ò'¿ì¿ýCп찀Çàè㿈ð' DРDÒ Ò'¿ìпìÒ €¢`€Ð¿ìÒ Ð DŸÂ@€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿ìпìÒ¿ìÔ`’¿ÿÒ" пìÒÖ @” àÿ’`Ò"° €Çàèã¿€ð' DРDÒÐ`h€¢ 4€  Ð'¿ìÀ'¿àРDÿÿÇ“* Ò'¿èРDÿÿÂÒ¿è@Ð'¿èпè’?þÒ'¿èп쀢 €Ð DÒ! €¢`þ€ ax×’¡Ô¿è@ÒO€ РDÒ! ” ax×’á(Ö¿è@ÒCÒ¿èÿ’Ò'¿è€¢`€€dРDÿÿ“Ð'¿äп쀢 €Zп䀢 € ax×’¡@@Ò'€Lп䀢 €Ð¿à€¢ €ax×’¡@@Ò€<п䀢 \€ ax×’¡H@Ò €0cIÒ¿ä Ò `W’ ÿ€¢`€axÔax’¿ÿ” Ô"€¢ € п䒡x@Ñû€ ’ ”!x@ ÒÔ¿çÔ*@’`Ò"€ ax×’¡PÔ¿ä@ÑÛпäÐ'¿à¿ÿ—п쀢 €ax×’¡@@ÑÍ° €Çàèã½ ð' Dò' HÀ'½Ò HÔ@Ô"#4Ò#4€¢`€ Ðc4Ò •*`‘: €¢ €€×’¡XÒ"#4’½˜ @|Ð'¾ ’¾  ’ >”!Ð@ÃÓcÐÐ'¾#èÐ'¾$Ð'¾’¾  ’ þK”â@3Õ’¾  ’ ìK”â@3Î’¾  Ò DÔ H– ˜ ÿü Ð'½”Ò DÿÒ½”€¢@€ ax×’á`Ô£4@ÑvÿûNн”Ò D€¢ €$н”’‘*`Ô H’ Ð@×’ €@ÑkÐ'½ŒÐ½Œ€¢ €Ð½”’‘*`Ò H– ax×’ ˆÔ£4ÖÀ@ÑR @ÑI€@XÐ'½ŒÒ#8€¢`€Ðc8×’¡€@ÑEÐ'½ˆÐ½ˆ€¢ €ax×’ ˆÔ£4Öã8@Ñ0 @Ñ'€@@Ð'½ˆ’¾  Ò½Œ@=’¾  ’ @ï’¾  Ò DÔ H– ˜ ÿûžÐ'½”Ò#0€¢`€5Ð#0’‘*`L’£ÈÐ Â3à4 44<4t4X’¾  ’ @ þÐ'½€*’¾  ’ @ öÐ'½€"’¾  @cÐ'½€’¾  @UÐ'½€’¾  @ŠÐ'½€ о ’$Ò" о ’¾ Ô ŸÂ€€Ð½Ò½ˆÒ" ’¾  @ н’¾ Ô Ò½ŸÂ€Ð¾¬Ò¾”€¢ €€¾ Ò½Ô½Ò`Ô @óÐ'½„н’¾ Ö  Ò½Ô½„ŸÂÀ¿ÿéн’¾ Ô  Ò½ŸÂ€’¾  @l’¾  @BнŒ’¡X€¢ €Ð½Œ@Мнˆ’¡h€¢ €Ð½ˆ@Го€¢ € € @Ðz° €Çàè㿈ð' Dò' Hô' LРHÐ'¿ìпìÔ¿ìÖ¿ìÐ ’ Ô  Öà @Ð{Çàè㿈ð' Dò' Hô' LРHÐ'¿ìпìÒ â@пìà пìä $€¤ €€ Ð @Ð,¢`  ¤¿ÿ¿ÿöпìÔ¿ìÖ¿ìÐ ’ Ô  Öà @ÐWÇàè㿈ð' Dò' Hô' LРHÐ'¿ìРDÒ ˆæ@РD’ Ô ˆ@ èРD’ Ô ˆ@ êпìÒ ä@пìà РDì p€¥ €€Ð €¢ ÿ¤ Ð ÀÐ,  Ð Ð,  Ð @Ð,  ¬¿ÿ¿ÿîпìÔ¿ìÖ¿ìÐ ’ Ô  Öà @ÐÇàè㿈ð' Dò' Hô' LРHÐ'¿ìРDÒ ˆä@пìÒ â@пìà РDæ p€¤à€€ Ò @ `ÿÒ €Ò,¢`  ¦ÿÿ¿ÿôпìÔ¿ìÖ¿ìÐ ’ Ô  Öà @ÏõÇàè㿈ð' Dò' HРHÐ'¿ìÒ DÐ`,€¢ €€¢ €€Ð¿ìÔ DÖ DÐ ×’!ˆÔ pÖàt˜ ÿ@ÏʀпìÔ DÖ DÐ ×’!˜Ô pÖàt˜ ÿ@Ͻ€ РDÒ$Ð"`РDÒÔ@РDŸÂ€Çàèã¿ð' Dò' HÒ HÐ` @ϺРHÒ Ð ` ’ `ÿ€¢ € РDÒ %Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' DРDÒ Ö@РD’ ” (ŸÂÀÐ'¿ìпìN’ XÒ"пìN’¡,Ò" РD@Xà¿ìРDÒ DÐ pÒ`x@ÏŒÐ$ $пìÒ¿ìÔ`$Ô" РDÒ Ô¿ìÖ@РD’ Ô  ŸÂÀÒ¿ìÐ"`РDÒ T€¢`€2РDà РDÒ DÐ pÒ`|@Ïo”Ø Ð D’ – ŸÃÒ¿ìÐ"`Ð¿ì’ Ò" РDÒ T€¢`€Ð¿ìM’¢@Ò" €Ð DÒ ,€¢`€Ð¿ìM’£´Ò" €Ð¿ìM’¢ÐÒ" €Ð¿ìÒ¿ìÔ`Ô" пìÒ¿ì”`Ô" Ð¿ì’ Ò" пìM’¡üÒ" п찀Çàèã¿ð' DРDÒ 8€¢`€&РDÔ D’ 8Ô@Ô* <” Ô"@Ò D`<Ô DÖ D’ Ô 8Öà @ÏÒ DÔ`8€¢ €Ð DÒ Ð@’ %Ò" РDÒ Ð@Ò DÔÐ`ŸÂ€Ð DÀ" 8Çàèã¿ð' Dò' HРDÒ DÔ DÖ HØ (•*À Ò`$”@ Ô" $РDÒ DÔ DÒ`(Ô ’@ Ò" (РDÒ (€¢`€€#РDÔ DÒ DÔ DÖ 8”à– Ö"`8 Ò DÔ `'’ ¿ÿÒ* <РDÒ 8€¢`þ€Ð Dÿÿ¦Ð DÒ DÔ`$“: Ò" $РDÒ DÔ`(’¿øÒ" (¿ÿÚÇàèã¿ð' Dò' HРDÒ HÒ" РDÒ D” Ö`“*€ ”ÿÔ" РDÔ H’¿ÿ” “*€ Ò" ,РDÒ DÔ`,’ Ò" 0РDÒ DÔ`,’ Ò" 4РDÀ" 8РDÀ" $РDÀ" (Ò DРDÒ`,ÿÿÇàèã¿ð' Dò' HРDÒ Hÿÿ”РDÒ DÐ 4Ò` €¢ € Ò DРDÒ DÔ`4’ Ò" 4€ Ò DРDÒ`,ÿÿ€Ð DÒ DÔ`,’ Ò" 4Çàèã¿ð' DÒ DРDÒ`0ÿÿrРDÒ (€¢`€Ð DÔ DÒ DÔ DÖ 8”à– Ö"`8 Ò DÔ `'’ ¿ÿÒ* <РDÒ 8€¢`þ€Ð Dÿÿ+РDÿÿ(Çàèã¿ð' Dò' HÒ DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò H `ÿÒ DÒ` @Î7€ РDÒ `ÒÔ KÔ*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò H‘2`’ ÿÔ D Ò  @΀ РDÒ `ÒÔ H—2 ” Ô*@’`Ò"Çàèã¿ð' Dò' HÒ DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò DРHÒ` @Íõ€ РDÒ `ÒÔ KÔ*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò DРHÒ` @ÍÙ€ РDÒ `ÒÔ KÔ*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò DРHÒ` @ͽ€ РDÒ `ÒÔ KÔ*@’`Ò"Çàèã¿xð' Dò' Hô' LРDÒ Ð`Ô’?øÒ'¿ÜРH€¢!€Ð DÒ Ð@’$Ò" РDÒ Ð@Ò HÒ" РDÒ Ð@Ò DÔÐ`ŸÂ€ Ð'¿ì Ò¿ì‘* Ò H€¢@€€Ð¿ì’ Ò'¿ì¿ÿô Ò¿ì‘* Ð'¿èп쀢 € Ð'¿ä€Ð¿ìÐ'¿äÒ DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò D GÒ` @Íb€ РDÒ `Ò” GÔ*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò D IÒ` @ÍF€ РDÒ `Ò” IÔ*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò D FÒ` @Í*€ РDÒ `Ò” FÔ*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò D 8Ò` @Í€ РDÒ `Ò” 8Ô*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò D 7Ò` @Ìò€ РDÒ `Ò” 7Ô*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò D aÒ` @ÌÖ€ РDÒ `Ò” aÔ*@’`Ò"РDÒ Ð DÒ`pÿþ{РDÒ Ð DÒ`tÿþu €Ð'¿àÒ¿ìÿ“* Ð¿à’ Ò'¿àÒ¿ìÿÒ¿à@Ð'¿àÒ DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò DпàÒ` @Ì¡€ РDÒ `ÒÔ¿ãÔ*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò D Ò` @Ì…€ РDÒ `ÒÀ*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò D Ò` @Ìj€ РDÒ `ÒÀ*@’`Ò"À'¿ØпØҿ耢 €€ÇпØÒ H€¢ €¹Ð L€¢ € Ð DÒ Ð`,€¢ €Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ €Ð LÒÔ¿Ø@ Ò `ÿÒ¿Ü‘: Ò DÒ` @Ì0€Ð DÒ `ÒÔ LրؿؔÀ Ö €” àÿØ¿Ü—:€ ” Ô*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò L ÒÔ¿Ø@ Ò `ÿÒ¿Ü‘: Ò DÒ` @̀РDÒ `Ò” Ö L”€ րؿؔÀ Ö €” àÿØ¿Ü—:€ ” Ô*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò L ÒÔ¿Ø@ Ò `ÿÒ¿Ü‘: Ò DÒ` @ËԀРDÒ `Ò” Ö L”€ րؿؔÀ Ö €” àÿØ¿Ü—:€ ” Ô*@’`Ò"€ РLÒÔ¿Ø@ Ò `ÿÔ¿Ü“: РDÿý«€Ò¿Ø” ‘* " Ô H’¿ÿ•:`—2 ”@ “:  Ô H’¿ÿ@Ë®’РDÿý–€Ð D’ ÿýпؒ Ò'¿Ø¿ÿ6Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò D ,Ò` @Ë€ РDÒ `Ò” ,Ô*@’`Ò"РD’ ÿý(РD’ ÿý$РDÒ Ð DÒ`pÿýРDÒ Ð DÒ`tÿýÒ DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò D Ò` @ËQ€ РDÒ `ÒÀ*@’`Ò"Ò DÐ` Ò DÐ` Ò DÔ` Ö€’ÿÿ” Ô"€¢ € Ò DпäÒ` @Ë6€ РDÒ `ÒÔ¿çÔ*@’`Ò"Ð¿ä’ Ð DÿüjÇàè㿈ð' Dò' HРHÐ'¿ìРDÒ T€¢`€ Ò DÔ DпìÒ`„Ô ˆÿýe€Ð¿ì’!” ÿý^Çàè㿈ð' Dò' Hô' LРHÐ'¿ìпìÒ à@РDâ p€¤`€€ Ð ’ ÿ  пìÿüb¢ÿ¿ÿôÇàè㿈ð' Dò' HРHÐ'¿ìпìÿüwÒ¿ìÐ` Ò¿ìÐ` Ò¿ìÔ` Ö€’ÿÿ” Ô"€¢ € Ò¿ì Ò` @ÊÖ€ пìÒ `ÒÀ*@’`Ò"Ò¿ìÐ` Ò¿ìÐ` Ò¿ìÔ` Ö€’ÿÿ” Ô"€¢ € Ò¿ì ;Ò` @Ê»€ пìÒ `Ò” ;Ô*@’`Ò"Ò¿ìÐ` @ʳпìÒ Ð ` ’ `ÿ€¢ € РDÒ %Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' DРDÒ Ö@РD’ ”!<ŸÂÀÐ'¿ìпìÒ DÒ" пìR’£„Ò"пìR’£ìÒ" пìS’ XÒ" РDÒ ,€¢`€Ð DÒ ,€¢`€ РDÒ#öÐ"`РDÒÔ@РDŸÂ€Ð DÒ ,€¢`€ РDÒ Ô€¢`€€ РD’ Ò" TРDÒ `€¢a€Ð D’!Ò" `РD@РDÒ |€¢`€ РDÒ#ôÐ"`РDÒÔ@РDŸÂ€Ð DÒ Ô DØ`РD’ Ô p– ŸÃÒ¿ìÐ"`Ð¿ì’ Ò" п찀Çàèã¿xð' Dò' Hô' L’¿Ø ’ ” @Ê2РL€¢ €  Ð/¿ÙРO’ ?ÿÒ/¿ÝÒ L‘:`Ð/¿Þ Ð/¿ßРDÒ sÒ/¿äРDÒ p‘2`Ð/¿åРDÒ wÒ/¿æРDÒ t‘2`Ð/¿ç Ð/¿éРDÒ ,€¢`€ Ð/¿Ú Ð/¿è€Ð L€¢ € Ð/¿Ú Ð/¿è€ Ð/¿Ú Ð/¿è¿ØÖ H’ ” Öà @É耢 € РDÒ %Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' Dò' Hô' LРHÐ'¿ìпìÒ à@пìâ РDä p€¤ €€ Ð Ð,@Ð Ð,`Ð Ð,`  ¢`¤¿ÿ¿ÿòпìÔ¿ìÖ¿ìÐ ’ Ô Öà @ɳÇàè㿈ð' Dò' Hô' LРHÐ'¿ìпìÒ à@пìâ РDä p€¤ €€ Ð Ð,@  ¢`¤¿ÿ¿ÿöпìÔ¿ìÖ¿ìÐ ’ Ô Öà @ÉÇàè㿈ð' Dò' Hô' LРHÐ'¿ìРDÒ ˆä@пìÒ à@пìâ РDæ p€¤à€€ Ò `ÿÒ €Ò,@  ¢`¦ÿÿ¿ÿôпìÔ¿ìÖ¿ìÐ ’ Ô Öà @ÉfÇàèã¿€ð' Dò' HРHÐ'¿ìРDÒ ,€¢`€Ð DÒ H” ÿÿ'РDÒ T€¢`€Ð¿ìT’¡ðÒ" €Ð¿ìT’¡`Ò" €ÂРDÒ ,€¢`€³Ð DÒ T€¢`€£Ð DÒ „Ò'¿èп耢!€Ð DÒ$Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð DÒ HÔ¿èÿþòпìÒ Ò'¿àÀ'¿äпäҿ耢 €€xÒ¿àпàÒ¿àÔ@’¿ÿ” Ô"€¢ €Ð D’ Ô ˆ@ ÒÔ¿ä@ Ô ’  ÿ Ò¿à@Èû€Ò¿à`ÒÔ D– Ø ˆ”À րؿä”À Ö €Ö*@’`Ò"Ò¿àпàÒ¿àÔ@’¿ÿ” Ô"€¢ €Ð D’ Ô ˆ@ ÒÔ¿ä@ Ô ’  ÿ Ò¿à@ÈÔ€Ò¿à`ÒÔ D– Ø ˆ”À րؿä”À Ö €Ö*@’`Ò"Ò¿àпàÒ¿àÔ@’¿ÿ” Ô"€¢ €Ð DÒ ˆÐ@Ò¿ä Ô ’  ÿ Ò¿à@ȯ€Ò¿à`ÒÔ DÖ ˆÔÀֿ䔀 Ö €Ö*@’`Ò"Ð¿ä’ Ò'¿ä¿ÿ…пìT’¡`Ò" € РDÒ H” ÿþfпìT’ ÀÒ" € РDÒ$ Ð"`РDÒÔ@РDŸÂ€Çàèã¿ð' Dò' HÒ HÐ` @È~РHÒ Ð ` ’ `ÿ€¢ € РDÒ %Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìпìT’¢”Ò"пìU’¢Ò" РD@à¿ìРDÒ DÐ pÒ`|@ÈPÐ$ РDÒ Ô¿ìÖ@РD’ Ô ŸÂÀÒ¿ìÐ"`РDÒ Ô¿ìØ`РD’ Ô – ŸÃÒ¿ìÐ"`Ð¿ì’ Ò" п찀Çàèã¿€ð' Dò' Hô' LРHÐ'¿ìÒ DÐ`Ò¿ìÔ¿ìÚ Ð DÒ`Ô ,– ˜ ŸÃ@Ð'¿èÒ¿ìпìÒ¿ìÔ`,’ Ò" ,пìÒ à@пèâРDä p€¤ €€Ð Ð,`  Ð Ð,`  Ð Ð,@  ¢`¤¿ÿ¿ÿðпìÒ (Ò'¿äÒ¿äÿ’Ò'¿ä€¢`€€À,@¢`¿ÿõÇàèã¿€ð' Dò' Hô' LРHÐ'¿ìÒ DÐ`Ò¿ìÔ¿ìÚ Ð DÒ`Ô ,– ˜ ŸÃ@Ð'¿èÒ¿ìпìÒ¿ìÔ`,’ Ò" ,пìÒ à@пèâРDä p€¤ €€ Ð Ð,@  ¢`¤¿ÿ¿ÿöпìÒ (Ò'¿äÒ¿äÿ’Ò'¿ä€¢`€€À,@¢`¿ÿõÇàèã¿ð' Dò' HÇàèã¿Hð' Dò' HРDÒ ,€¢`€Ð DÒ T€¢`€ Ð'¿¬!Ð'¿¨€ Ð'¿¬À'¿¨€ Ð'¿¬!Ð'¿¨Ð¿¨’‘*`’ 6Ò'¿´Ð HÒ DÐ $Ò`t@ÇÒ¿´@Ð'¿°’¿à ’ ” @Ç~’¿¸ ’ ” (@Çx BÐ/¿à MÐ/¿áп³’ ?ÿÒ/¿âÒ¿°‘:`’ ÿÐ/¿ãÒ¿°‘:`’ ÿÐ/¿äÒ¿°‘:`’ ÿÐ/¿åп·’ ?ÿÒ/¿êÒ¿´‘:`’ ÿÐ/¿ëÒ¿´‘:`’ ÿÐ/¿ìÒ¿´‘:`’ ÿÐ/¿í (Ð/¿¸À/¿¹Ð DÒ sÒ/¿¼Ð DÒ p‘2`Ð/¿½Ð DÒ p‘2`Ð/¿¾Ð DÒ p‘2`Ð/¿¿Ð DÒ wÒ/¿ÀРDÒ t‘2`Ð/¿ÁРDÒ t‘2`Ð/¿ÂРDÒ t‘2`Ð/¿Ã Ð/¿ÄÀ/¿Åп¯’ ?ÿÒ/¿ÆÒ¿¬‘:`’ ÿÐ/¿ÇРDÒ ! `ÿ€¢ €pРDÒ! •*`‘2 ”“* ’@•*`”€‘* ’ ÿÐ/¿ÐРDÒ! •*`‘2 ”“* ’@•*`”€‘* “:  ’ ?ÿÒ/¿ÑРDÒ! •*`‘2 ”“* ’@•*`”€‘* “:  ’ ?ÿÒ/¿ÒРDÒ! •*`‘2 ”“* ’@•*`”€‘* “:  ’ ?ÿÒ/¿ÓРDÒ!"•*`‘2 ”“* ’@•*`”€‘* ’ ÿÐ/¿ÔРDÒ!"•*`‘2 ”“* ’@•*`”€‘* “:  ’ ?ÿÒ/¿ÕРDÒ!"•*`‘2 ”“* ’@•*`”€‘* “:  ’ ?ÿÒ/¿ÖРDÒ!"•*`‘2 ”“* ’@•*`”€‘* “:  ’ ?ÿÒ/¿×п«’ ?ÿÒ/¿ØÒ¿¨‘:`’ ÿÐ/¿Ù¿àÖ H’ ” Öà @Æ•€¢ € РDÒ %Ð"`РDÒÔ@РDŸÂ€¿¸Ö H’ ” (Öà @Æ€¢ (€ РDÒ %Ð"`РDÒÔ@РDŸÂ€Ð¿¨€¢ €Ð DÒ HÔ¿¨– @³Çàèã¿`ð' Dò' HРDÒ ,€¢`€Ð DÒ T€¢`€ Ð'¿Ä!Ð'¿À€ Ð'¿ÄÀ'¿À€ Ð'¿Ä!Ð'¿ÀпÀ”“* ’@`Ð'¿ÌРHÒ DÐ $Ò`t@ÆFÒ¿Ì@Ð'¿È’¿à ’ ” @ÆC’¿Ð ’ ” @Æ= BÐ/¿à MÐ/¿áп˒ ?ÿÒ/¿âÒ¿È‘:`’ ÿÐ/¿ãÒ¿È‘:`’ ÿÐ/¿äÒ¿È‘:`’ ÿÐ/¿åпϒ ?ÿÒ/¿êÒ¿Ì‘:`’ ÿÐ/¿ëÒ¿Ì‘:`’ ÿÐ/¿ìÒ¿Ì‘:`’ ÿÐ/¿í Ð/¿ÐÀ/¿ÑРDÒ sÒ/¿ÔРDÒ p‘2`Ð/¿ÕРDÒ wÒ/¿ÖРDÒ t‘2`Ð/¿× Ð/¿ØÀ/¿Ùпǒ ?ÿÒ/¿ÚÒ¿Ä‘:`’ ÿÐ/¿Û¿àÖ H’ ” Öà @Å怢 € РDÒ %Ð"`РDÒÔ@РDŸÂ€¿ÐÖ H’ ” Öà @ÅÒ€¢ € РDÒ %Ð"`РDÒÔ@РDŸÂ€Ð¿À€¢ €Ð DÒ HÔ¿À– @Çàèã¿€ð' Dò' Hô' Lö' PРDÒ ˆÒ'¿ìРDÒ „Ò'¿èРHÒ Ò'¿äп쀢 €'РDÒ x€¢`€–À'¿àпàҿ耢 €€ŒÒ¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ € Ò¿ì ÒÔ¿à@ Ô ’  ÿ Ò¿ä@Å€Ò¿ä`Ò” ֿ씀 րؿà”À Ö €Ö*@’`Ò"Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ € Ò¿ì ÒÔ¿à@ Ô ’  ÿ Ò¿ä@Å\€Ò¿ä`Ò” ֿ씀 րؿà”À Ö €Ö*@’`Ò"Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ €Ð¿ìÒÔ¿à@ Ô ’  ÿ Ò¿ä@Å9€ Ò¿ä`ÒÔ¿ìրؿà”À Ö €Ö*@’`Ò"РP€¢ €Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ € Ò¿ä@Å€Ò¿ä`ÒÀ*@’`Ò"Ð¿à’ Ò'¿à¿ÿq€ŒÀ'¿àпàҿ耢 €€„Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ €Ð¿ìÒÔ¿à@ Ô ’  ÿ Ò¿ä@Äï€ Ò¿ä`ÒÔ¿ìրؿà”À Ö €Ö*@’`Ò"Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ €Ð¿ìÒÔ¿à@ Ô ’  ÿ Ò¿ä@Ä΀ Ò¿ä`ÒÔ¿ìրؿà”À Ö €Ö*@’`Ò"Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ €Ð¿ìÒÔ¿à@ Ô ’  ÿ Ò¿ä@Ä­€ Ò¿ä`ÒÔ¿ìրؿà”À Ö €Ö*@’`Ò"РP€¢ €Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ € Ò¿ä@ÄŽ€Ò¿ä`ÒÀ*@’`Ò"Ð¿à’ Ò'¿à¿ÿy€mÀ'¿àÐ¿à€¢ ÿ€€fÒ¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ €Ð¿àÒ¿ä@Äj€ Ò¿ä`ÒÔ¿ãÔ*@’`Ò"Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ €Ð¿àÒ¿ä@ÄS€ Ò¿ä`ÒÔ¿ãÔ*@’`Ò"Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ €Ð¿àÒ¿ä@Ä<€ Ò¿ä`ÒÔ¿ãÔ*@’`Ò"РP€¢ €Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ € Ò¿ä@Ä!€Ò¿ä`ÒÀ*@’`Ò"Ð¿à’ Ò'¿à¿ÿ˜Ð¿àÒ L€¢ €Ð DÒ$Ð"`РDÒпàÐ"`РDÒÔ@РDŸÂ€Ð¿àÒ L€¢ €€cÒ¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ € Ò¿ä@Ãë€Ò¿ä`ÒÀ*@’`Ò"Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ € Ò¿ä@ÃÕ€Ò¿ä`ÒÀ*@’`Ò"Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ € Ò¿ä@ÿ€Ò¿ä`ÒÀ*@’`Ò"РP€¢ €Ò¿äпäÒ¿äÔ@’¿ÿ” Ô"€¢ € Ò¿ä@Ã¥€Ò¿ä`ÒÀ*@’`Ò"Ð¿à’ Ò'¿à¿ÿšÇàèã¿€ð' Dò' HРHÐ'¿ìпìà РDÒ Ò'¿àпìÒ €¢`€Ð DÒ¿ìÿý €Ð DÒ¿ìÿûàРDÒ tÒ'¿äп䀢 €€IÐ¿à€¢ €Ð¿àÒ DÔ`tÒ¿ä”"€ Ô" пàÒ DÔ`tÔ" пàÒРDŸÂ@Ò DÐ`Ò¿ìÖ¿ä”ÿÿÚ Ð DÒ`– ˜ ŸÃ@Ð'¿èпèâпìä $€¤ €€Òÿ’Ò$€¢`€ Ð @’ ÿ ’@Ã=€ ÒÔ @Ô*@’`Ò"¢`¤¿ÿ¿ÿäпä’?ÿÒ'¿ä¿ÿµÐ¿à€¢ €Ò¿àпàÒ¿àÔ`’ Ò" @Ã%Ð ’ `ÿ€¢ € РDÒ %Ð"`РDÒÔ@РDŸÂ€Çàèã¿€ð' Dò' HРDÒ Ö@РD’ ” 0ŸÂÀÐ'¿ìпìV’¡ˆÒ"пìZ’¡ÀÒ" пìÒ HÒ" РDÒ ,€¢`€Ð¿ìV’ Ò" €"РDÒ ,€¢`€Ð DÒ T€¢`€Ð¿ìV’ Ò" €Ð¿ìU’£€Ò" € РDÒ#íÐ"`РDÒÔ@РDŸÂ€Ð D@ –РDÒ DÐ pÒ`|@ÂËÐ'¿èпìÒ¿èÒ" Ò¿è `€¢ €€Ð¿è’ Ò'¿è¿ÿöпìÒ¿èÒ" $пìÒ¿ìÔ¿èÒ` ”"€ Ô" (РDÒ Ø DÄ`РD’ ” Ö¿èØ tš ŸÀ€Ò¿ìÐ"`пìÀ" ,РDÒ €¢`€ РDÒ Ò'¿äÒ¿äпäÒ¿äÔ`’ Ò" РDÒ Ø`РD’ Ô¿è– ŸÃÒ¿ìÐ"`Ð¿ì’ Ò" п찀Çàèã¿xð' Dò' Hô' Lö' PРDÒ ˆÐ@Ð'¿ìРD’ Ô ˆ@ ÒÒ'¿èРD’ Ô ˆ@ ÒÒ'¿äРDÒ „Ò'¿àÀ'¿ÜпÜÒ¿à€¢ €€$пìÒ¿Ü Ò `ÿÒ H€¢ €Ð¿èÒ¿Ü Ò `ÿÒ L€¢ € пäÒ¿Ü Ò `ÿÒ P€¢ €€.пܒ Ò'¿Ü¿ÿÙÐ¿à€¢ ÿ€Ð DÒ 9Ð"`РDÒ!Ð"`РDÒÔ@РDŸÂ€Ð¿ìÒ¿à Ò KÒ*пèÒ¿à Ò OÒ*пäÒ¿à Ò SÒ*Ò DРDÒ DÔ`„’ Ò" „Çàèã¿@ð' Dò' H Ð'¿´Ð¿´€¢ €€0п´’‘*`’¿¸ @Ò HРHÒ HÔ@’¿ÿ” Ô"€¢ €Ð H@€ Ô H’ Ô@Ö € àÿ” Ô"@Ð$€¢?ÿ€ РDÒ$Ð"`РDÒÔ@РDŸÂ€Ð¿´’ Ò'¿´¿ÿÎп¼€¢ I€Ð¿À€¢ F€€ РDÒ$Ð"`РDÒÔ@РDŸÂ€Ò¿à `€€¢ € РDÒ$Ð"`РDÒÔ@РDŸÂ€Ò¿à `’ ‘*@Ð'¿°À'¿´Ð¿´Ò¿°€¢ €€jÒ HРHÒ HÔ@’¿ÿ” Ô"€¢ €Ð H@Á¨€ Ô H’ Ô@Ö € àÿ” Ô"@Ð'¿¬Ò HРHÒ HÔ@’¿ÿ” Ô"€¢ €Ð H@Á‘€ Ô H’ Ô@Ö € àÿ” Ô"@Ð'¿¨Ò HРHÒ HÔ@’¿ÿ” Ô"€¢ €Ð H@Áz€ Ô H’ Ô@Ö € àÿ” Ô"@Ð'¿¤Ð¿¬€¢?ÿ€ п¨€¢?ÿ€Ð¿¤€¢?ÿ€€ РDÒ$Ð"`РDÒÔ@РDŸÂ€Ð DÒ¿¬Ô¿¨Ö¿¤ÿþËп´’ Ò'¿´¿ÿ“Çàèã¿ð' DÒ DРDÒ DÔ@’¿ÿ” Ô"€¢ €Ð D@Á< € Ò D`ÒÔ @   ÿ’`Ò"€¤ #€%Ò DРDÒ DÔ@’¿ÿ” Ô"€¢ €Ð D@Á" € Ò D`ÒÔ @   ÿ’`Ò"€¤ €€¤?ÿ€€€¿ÿß°€Çàèã¿ð' Dò' HРHÿÿ¸ €¤?ÿ€ РDÒ$Ð"`РDÒÔ@РDŸÂ€€¤ € €¤ € €¤ €€¤ €€¿ÿဤ /€€¤ 9€€ РDÒ$Ð"`РDÒÔ@РDŸÂ€¢?ÐРHÿÿ„ €¢ /€€¤ 9€€€ ’‘*`“* ¢ ¢Т@¿ÿê°€Çàèã¿hð' Dò' HÒ HРHÒ HÔ@’¿ÿ” Ô"€¢ €Ð H@À£€ Ô H’ Ô@Ö € àÿ” Ô"@Ð'¿ìРDÒ HÿÿÐ'¿èРDÒ Hÿÿ‹Ð'¿äРDÒ Hÿÿ†Ð'¿àп耢 € п䀢 €Ð¿à€¢ €€Ð DÒ$Ð"`РDÒÔ@РDŸÂ€Ð¿à€¢ ÿ€ РDÒ$Ð"`РDÒÔ@РDŸÂ€Ð¿ì€¢ 3€€¢ 6€6€´À'¿ÜпÜҿ䀢 €€)À'¿ØпØҿ耢 €€Ð DÒ HÿÿAÐ'¿ÔРDÒ Hÿÿ<Ð'¿ÐРDÒ Hÿÿ7Ð'¿ÌРDÒ¿ÔÔ¿ÐÖ¿Ìÿý®Ð¿Ø’ Ò'¿Ø¿ÿáпܒ Ò'¿Ü¿ÿÔ€ŽÀ'¿ÜпÜҿ䀢 €€wÀ'¿ØпØҿ耢 €€jÒ HРHÒ HÔ@’¿ÿ” Ô"€¢ €Ð H@À € Ô H’ Ô@Ö € àÿ” Ô"@Ð'¿ÔÒ HРHÒ HÔ@’¿ÿ” Ô"€¢ €Ð H@¿ô€ Ô H’ Ô@Ö € àÿ” Ô"@Ð'¿ÐÒ HРHÒ HÔ@’¿ÿ” Ô"€¢ €Ð H@¿Ý€ Ô H’ Ô@Ö € àÿ” Ô"@Ð'¿ÌпԀ¢?ÿ€ пЀ¢?ÿ€Ð¿Ì€¢?ÿ€€ РDÒ$Ð"`РDÒÔ@РDŸÂ€Ð DÒ¿ÔÔ¿ÐÖ¿Ìÿý.пؒ Ò'¿Ø¿ÿ“пܒ Ò'¿Ü¿ÿ†€Ð DÒ$Ð"`РDÒÔ@РDŸÂ€€Çàèã¿ð' Dò' HРDÒ Ø`РD’ ”!– ŸÃÒ DÐ"`ˆÐ DÀ" „Ò HРHÒ HÔ@’¿ÿ” Ô"€¢ €Ð H@¿~€ Ô H’ Ô@Ö € àÿ” Ô"@€¢ G€€¢ P€ €Ð DÒ HÿýM€Ð DÒ Hÿþ²€Ð DÒ$Ð"`РDÒÔ@РDŸÂ€€Çàèã¿ð' Dò' Hô' L¤ РDÒ •*`¡: ’ Ð' D€¢`€€% HÒÔ @—* £:à”’`Ò"€¢ €° €!cIÒ  `’ ÿ€¢`€@¿, €¤€° €¤ ¿ÿÓРL€¤€€° €° €Çàè㿈aXÐ'¿ìп찀Çàè㿈ahÐ'¿ìп찀Çàèã¿€ð' Dò' Hô' LРDÀ" РH€¢ >€Ð DÒ Ð"`РDÒ >Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð L€¢!ЀРDÒ Ð"`РDÒ!ÐÐ"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð DÒÒ'¿èРDÒ Ò'¿äРD’ ”!Ð@¾¿Ð DÒ¿èÒ"РDÒ¿äÒ" РD’ Ò" РD@p¤Ð DÀ" РDÀ" À'¿ìп쀢 €€ РDÒ¿ì” “*  À" ¤Ð¿ì’ Ò'¿ì¿ÿñÀ'¿ìп쀢 €€Ð DÒ¿ì” “*  À" ´Ð DÒ¿ì” “*  À" ÄÐ¿ì’ Ò'¿ì¿ÿëРDÀ"!0РD@æРD@ hРD’ ÈÒ" Çàèã¿ð' DРD@g4Çàèã¿ð' DРD@fþÇàèã¿€ð' DÒ DÐ`$€¢ €€¢ €€¢ € €ß€¢ €¢€ÚРD’ Ò" (РD’ Ò" ,€ØРDÒ!€¢`€Ð D’ Ò" (€‰Ð DÒ!$€¢`€/РDÒ !( `ÿ€¢ €€¢ € € РD’ Ò" (€Ð D’ Ò" (€Ð DÒ rÐ"`Ò DÐ@Ò DÔ a(’  ÿÒ" РDÒÔ`РD’?ÿŸÂ€Ð D’ Ò" (€€WРDÒ ØÐ@Ð'¿ìРD’ TÔ Ø@ ÒÒ'¿èРD’ ¨Ô Ø@ ÒÒ'¿äп쀢 €Ð¿è€¢ € п䀢 €Ð D’ Ò" (€6п쀢 R€Ð¿è€¢ G€ п䀢 B€Ð D’ Ò" (€%РDÒ`Ð'¿àпàÒ¿ìÒ" Ò¿à Ò¿èÒ" Ò¿à Ò¿äÒ"РDÒ oÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿâРD’ Ò" (РD’ Ò" ,€BРDÒ!$€¢`€/РDÒ !( `ÿ€¢ €€¢ € € РD’ Ò" (€Ð D’ Ò" (€Ð DÒ rÐ"`Ò DÐ@Ò DÔ a(’  ÿÒ" РDÒÔ`РD’?ÿŸÂ€Ð D’ Ò" (€€Ð D’ Ò" (РD’ Ò" ,€Ð DÀ" (РDÀ" ,€Ð D’ Ò" 0РD’ Ò" 4РD×Ôa¨Ô: 8РDÀ" @РDÀ" DРDÀ" HРD’ Ò" LРD’ Ò" PРDÀ" TРD’ Ò" XРD’ Ò" \РD’!Ò" `РDÀ" ˆÐ DÀ" dРDÀ" hРDÀ" lÇàè㿈ð' Dò' HРDÒ €¢`ȀРDÒ €¢`ɀРDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð D@5Ð'¿ìп쀢 €€¢ €€¢ €"€"€¢ €€ Ð'¿ì€Ð H€¢ € РDÒ 3Ð"`РDÒÔ@РDŸÂ€Ð D@e™ Ð'¿ì€€Ð¿ì°€Çàè㿈ð' DÀ'¿ìРDÒ 8€¢ €C’‘*`a’ ¬Ð „؅…`…p…p…p…p…p…p…”…pРDÒ!´Ô`РDŸÂ€Ð DÒ Ô`РDŸÂ€Ð D’ ÉÒ" РDÒ!´Ô@РDŸÂ€Ð'¿ìп쀢 €Ð Dÿþ[РD’ ÊÒ" € Ð'¿ì€Ð DÒ!´Ô@РDŸÂ€Ð'¿ì€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð¿ì°€Çàèã¿ð' DРDÒ €¢`Ç€ РDÒ €¢`Ò€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!´Ð`°€Çàèã¿ð' DРDÒ €¢`É€ РDÒ €¢`Ò€€Ð DÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!´Ð`°€Çàèã¿ð' DРDÒ €¢`Í€ РDÒ €¢`΀€#РDÒ @€¢`€Ð DÒ DÐ ŒÒ`t€¢ € РDÒ CÐ"`РDÒÔ@РDŸÂ€Ð DÒ!¤Ô`РDŸÂ€Ð D’ ÒÒ" € РDÒ €¢`πРD’ ÒÒ" €Ð DÒ €¢`ҀРDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ!´Ð`€¢ €€Ð DÒ!´Ô@РDŸÂ€€¢ €° €¿ÿìРDÒ Ô`РDŸÂ€Ð D@dw° €Çàè㿈ð' DРDÒ €¢`ʀРD@ŒÐ DÒ @€¢`€Ð D’ ÏÒ" ° €yРD’ ËÒ" РDÒ €¢`Ë€WРDÒ!´Ð`€¢ €KРDÒ €¢`€Ð DÒ Ô@РDŸÂ€Ð DÒ!´Ô@РDŸÂ€Ð'¿ìп쀢 €° €Rп쀢 €€,РDÒ €¢`€%п쀢 €Ð¿ì€¢ €€Ò DÐ`Ò DÐ`Ò DÔ`Ò ”`’ Ò" РDÔ Ð €¢@€ Ò DÐ`Ò DÔ`Ò DÔ Òa@”€ Ô" ¿ÿ¹Ð DÒ DÔ`Ô" ˜€Ð DÒ €¢`̀РDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð D@°€Çàè㿈ð' DРDÒ €¢`Ì€ РDÒ!¤Ô@РDŸÂ€Ð DÀ" ŒÐ D’ ÌÒ" РDÒ!¤Ð`€¢ €€HРDÒ DÐ ŒÒ`t€¢ €€/РDÒ €¢`€Ò DÐ`Ò DÔ`ŒÔ" Ò DÐ`Ò DÔ`tÔ" РDÒ Ô@РDŸÂ€Ð DÒ ŒÒ'¿ìÒ DÐa¨Ò D”`ŒØ РD’ – ŸÃРDÒ ŒÐ¿ì€¢@€° €"¿ÿÌРDÒ!¤Ô`РDŸÂ€Ð DÒ!¤Ô@РDŸÂ€Ð DÀ" Œ¿ÿ´Ð DÒ DÔ`D€¢ €’ ΀’ ÍÒ" ° €Çàè㿈ð' Dò' Hô' LРDÒ €¢`̀РDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ DÐ ŒÒ`t€¢ €Ð DÒ {Ð"`РDÒÔ`РD’?ÿŸÂ€° €+РDÒ €¢`€Ò DÐ`Ò DÔ`ŒÔ" Ò DÐ`Ò DÔ`tÔ" РDÒ Ô@РDŸÂ€À'¿ìРDÒ!¨”¿ìØ`РDÒ HÖ LŸÃРDÒ DÔ`ŒÒ¿ì”€ Ô" ŒÐ¿ì°€Çàè㿈ð' Dò' Hô' LРDÒ €¢`΀РDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ DÐ ŒÒ`t€¢ €Ð DÒ {Ð"`РDÒÔ`РD’?ÿŸÂ€° €DРDÒ €¢`€Ò DÐ`Ò DÔ`ŒÔ" Ò DÐ`Ò DÔ`tÔ" РDÒ Ô@РDŸÂ€Ð DÒ DÐ!8Òa<@º:Ð'¿ìРLҿ쀢 € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ!¬Ô` РDÒ HŸÂ€€¢ €° € РDÒ DÔ`ŒÒ¿ì”€ Ô" ŒÐ¿ì°€Çàèã¿ð' Dò' HРDÒ €¢`πРDÒ €¢`̀РDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð H€¢ € Ð' HРDÒ!´Ð`€¢ € РDÒ HÐ €¢@€Ð DÒ Ò' HРDÒ HÒ" ˜Ð Dÿþ‘°€Çàèã¿ð' DРDÒ €¢`Í€ РDÒ €¢`΀€Ð DÒ @€¢`€ РDÒ!¤Ô`РDŸÂ€Ð D’ ÐÒ" €Ð DÒ €¢`ЀРDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ DÐ Ò`˜€¢ € РDÒ!´Ð`€¢ €€€Ð DÒ!´Ô@РDŸÂ€€¢ €° € ¿ÿãРD’ ÏÒ" ° €Çàè㿈ð' DРDÒ Ò'¿ìÐ¿ì’ Ò" $Çàè㿈ð' DРDÒ Ò'¿ìпìÖ¿ìÐ ’ Öà@¹sÐ'¿èп耢 €(пìÒ $€¢`€ РDÒ *Ð"`РDÒÔ@РDŸÂ€Ð DÒ xÐ"`РDÒÔ`РD’?ÿŸÂ€Ð¿ìÒ  ÿÐ*@Ð¿ì’ Ô @ ’ ÙÒ* Ð'¿èпìÒ¿ìÔ` Ô"пìÒ¿èÒ" пìÀ" $° €Çàè㿈ð' Dò' HРDÒ Ò'¿ìРH€¢ € пìÒ HÐ €¢@€€ пìÒ HÐ ’"@Ò' HРDÿÿ¢¿ÿðпìÒ¿ìÔ@Ò H”€ Ô"пìÒ¿ìÔ`Ò H”"€ Ô" Çàèã¿ð' DÇàè㿈ð' Dò' HРDÒ €¢`€Ð DÒ Ö@РD’ ” (ŸÂÀÒ DÐ"`РDÒ Ò'¿ìРDÒ Ö@РD’ ŸÂÀÒ¿ìÐ"` РDÒ Ò'¿ìпìd’¢PÒ" пìd’¢xÒ" пìd’£Ò" пì~’£ Ò" пìe’ 8Ò" пìÒ HÒ" пìÀ" пìÀ"Çàèã¿ð' DРDÒ L€¢`€ РDÒ!,€¢`€€° €pРDÒ (€¢`€Ð DÒ $€¢`€Ð DÒ ,€¢`€ РDÒ x€¢`€€° €WРDÒ ØÐ`€¢ €*РD’ TÔ Ø@ Ò €¢`€"РD’ ¨Ô Ø@ Ò €¢`€Ð DÒ ØÐ` €¢ €Ð D’ TÔ Ø@ Ò €¢`€ РD’ ¨Ô Ø@ Ò €¢`€€° €&РDÒ ØРDÒ`$Ð!<€¢@€Ð D’ TÔ Ø@ Ò DÐ $Òa<€¢ €Ð D’ ¨Ô Ø@ Ò DÐ $Òa<€¢ €€° €° €Çàèã¿€ð' DРDÒ €¢`ʀРDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ 0” ‘* Ò DÔ`4€¢ €Ò DÐ`’ @aÒ DÐ"`pÒ DÐ` ’ @aÒ DÐ"`tРD’ Ò"!<€EРDÒ 0” ‘* Ò DÔ`4€¢ €Ò DÐ`’ @`þÒ DÐ"`pÒ DÐ` ’ @`÷Ò DÐ"`tРD’ Ò"!<€)РDÒ 0” ‘* Ò DÔ`4€¢ €Ò DÐ`’ @`âÒ DÐ"`pÒ DÐ` ’ @`ÛÒ DÐ"`tРD’ Ò"!<€ РDÒ DÔ`Ô" pРDÒ DÔ` Ô" tРD’ Ò"!<À'¿ìРDÒ ØÒ'¿èРDÒ¿ìÐ $€¢@€€>РDÒ!<Ò'¿äп䀢 €$Ò¿èÐ`Ò¿ä@·¯’¡*`РDÒ DÐ!4Òa<@·§€¤€Ò¿èÐ` Ò¿ä@·Ÿ’¡*`РDÒ DÐ!8Òa<@·—€¤€€€Ð¿ä’‘*`Ð'¿ä¿ÿÔпèÒ¿äÒ" $Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ¾À'¿ìРDÒ ØÒ'¿èРDÒ¿ìÐ $€¢@€€4à DпèÒ¿èÐ Ò`$@·k’ Ò @·fÒ DÔa4’ •*`’ @``Ò¿èÐ"`(à DпèÒ¿èÐ Ò`$@·V’ Ò @·QÒ DÔa8’ •*`’ @`KÒ¿èÐ"`,Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿÈРDÒ ,ÿ€¢ €’‘*`f’£pР›„›˜›˜›¬›¬Ð D’ Ò" x€Ð D’ Ò" x€ РD’ Ò" x€Ð DÒ DÔ`$Ô" x€Ð DÒ DÔ`T€¢ €Ô DÒ x€’ Ò" |РDÿþN€¢ €Ð DÒ DÔa8Ô" €€Ð D’ Ò" €Çàè㿈ð' DРDÒ Ö@РD’ ”%€ŸÂÀÐ'¿ìпì’!Ò'¿ìРDÒ¿ìÒ"!Dпì’? ’ ”!@¶êÀ'¿èп耢 ÿ€€ пìÒ¿è Ò¿ëÒ*Ð¿è’ Ò'¿è¿ÿòÐ¿ì’ €Ò'¿ì €Ð'¿èп耢!ÿ€€ пìÒ¿è ’ ÿÒ*Ð¿è’ Ò'¿è¿ÿòпì’" ’ ”!€@¶½Ò¿ìc€Ò DÒaD” €@¶ÂÇàèã¿xð' DРDÒ!¤Ò'¿ìРDÿþkРDÿÿ©Ð DÒ DÐ pÒ`x@¶Ð'¿äпäÐ'¿àпàҿ䀢 € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð¿ìÀ" РDÿýÊÒ¿ìÐ"`пìÀ" пìÀ" РDÒ T€¢`€ РDÒ @€¢`€ €Ð DÀ" dРDÀ" hРDÀ" lРDÒ T€¢`€WРDÒ D€¢`€ РDÒ /Ð"`РDÒÔ@РDŸÂ€Ð DÒ x€¢`€ РD’ Ò" dРDÀ" hРDÀ" lРDÀ" ˆ€Ð DÒ ˆ€¢`€Ð D’ Ò" h€Ð DÒ \€¢`€Ð D’ Ò" l€Ð D’ Ò" dРDÒ d€¢`€ РD@PпìÒ DÔaÌÔ" РDÒ l€¢`€ РDÒ h€¢`€€ РD@ZÄпìÒ DÔaÌÔ" РDÒ D€¢`€Ð¿ìÒ €¢`€Ð D@^[€Ð D@HdРD@EÒ DРDÒ`l@1õРD@3РDÒ à€¢`€Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ Ü€¢`€Ð D@$-€Ð D@Ý Ò DÔa´Ò €¢`€ Ò DÔ`@€¢ €€ Ð'¿èРDÒ¿è@/£Ð DÒ D€¢`€Ð D’ @'ÓРDÒ Ô`РDŸÂ€Ð DÒ!´Ô`РDŸÂ€Ð DÒ €¢`€>РDÒ @€¢`€9РDÒ!´Ð`€¢ €3РDÒ Ü€¢`€ Ò DÐ`$”“* ’@`Ð'¿Ü€Ð DÒ $Ò'¿ÜРDÒ À"`РDà Ò DÐa@Ò¿Ü@µ…Ð$ РDÒ À"` Ò DÐ`Ò DÔ`l€¢ €’ €’ Ò" Ò¿ìпìÒ¿ìÔ` ’ Ò" Çàè㿈ð' DРDÒ!¤Ò'¿ìпìÒ €¢`€Ð¿ìÀ" РDÒ!ÌÔ@РD’ ŸÂ€Ð DÒ!°Ô@РD’ ŸÂ€Ð DÒ!¨Ô@РD’ ŸÂ€€yРDÒ T€¢`€/РDÒ ˆ€¢`€*РDÒ \€¢`€Ð DÒ l€¢`€ РDÒ¿ìÔ`Ô"!ÌÐ¿ì’ Ò" €Ð DÒ d€¢`€Ð DÒ¿ìÔ`Ô"!Ì€ РDÒ .Ð"`РDÒÔ@РDŸÂ€Ð DÒ!ÀÔ@РDŸÂ€Ð DÒ!¬Ô`РDŸÂ€Ð DÒ D€¢`€6пìÒ €¢`€Ð DÒ!ÈÔ@РDŸÂ€Ð DÒ!ÄÔ@РDŸÂ€Ð DÒ T€¢`€ РDÔ!ÌÒ¿ìԀРDÒ`ŸÂ€Ò DÐa°Ò¿ìÔ`€¢ €’ €’ ÔРDŸÂ€Ð DÒ!¨Ô@РD’ ŸÂ€Ð DÒ €¢`€/Ò DÐ`Ò¿ìÔ` Ô" Ò DÐ`Ò¿ìà` Ò¿ìÔ`€¢ €’ €’ Ò" РDÒ @€¢`€Ð DÒ!´Ð`€¢ €Ò DÐ`Ò DÔ`â Ò DÔ`l€¢ €’`€’`Ò" Çàè㿈ð' DРDÒ!¤Ò'¿ìРDÒ T€¢`€Ð DÒ!ÌÔ`РDŸÂ€Ò¿ìпìÒ¿ìÔ` ’ Ò" Çàè㿈ð' DРDÒ!¤Ò'¿ìРDÒ €¢`πРDÒ Ð"`Ò DÐ@Ò DÔ`Ô" РDÒÔ@РDŸÂ€Ð DÒ T€¢`€Ð DÒ h€¢`€Ð DÒ ˆ€¢`€Ð DÒ¿ìÔ`Ô"!ÌРDÒ!ÌÔ` РDŸÂ€Ð¿ìÀ" € РDÒ .Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!¤Ð¿ìh’¢ˆÒ"пìi’¡ÀÒ" пìÀ" РDÿý~Çàè㿈ð' DÒ DÐ` ?’£Ü€¢ € Ò DÐ`?’£Ü€¢ €€Ð DÒ )Ð"`Ò DÐ@?’£ÜÒ" РDÒÔ@РDŸÂ€Ð DÒ Ô€¢`€Ð DÒ Ð"`Ò DÐ@Ò DÔ`ÔÔ" РDÒÔ@РDŸÂ€Ð DÒ $€¢` €Ð DÒ Ð"`Ò DÐ@Ò DÔ`$Ô" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð D’ Ò"!4РD’ Ò"!8À'¿ìРDÒ ØÒ'¿èРDÒ¿ìÐ $€¢@€€>пèÒ €¢`€Ð¿èÒ €¢`€Ð¿èÒ €¢`€ пèÒ €¢`€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÖ¿èÔàÖa4€¢€ €Ôa4Ô"!4РDÒ DÖ¿èÔà Öa8€¢€ €Ôa8Ô"!8Ð¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ¾Ð D’ Ò"!<À'¿ìРDÒ ØÒ'¿èРDÒ¿ìÐ $€¢@€€HÐ¿è’ Ò" $РDÒ¿èÐ Ò`@³uÒ DÔa4’ •*`’ @\oÒ¿èÐ"`РDÒ¿èÐ Ò` @³fÒ DÔa8’ •*`’ @\`Ò¿èÐ"` РDÒ¿èÐ Ò`@³WÒ DÒa4@\TÒ¿èÐ"`(РDÒ¿èÐ Ò` @³KÒ DÒa8@\HÒ¿èÐ"`,Ð¿è’ Ò" 0пèÀ" LÐ¿ì’ Ò'¿ìÐ¿è’ TÒ'¿è¿ÿ´Ð DÒ DÔa8’ •*`Ð ’ @\0Ò DÐ"a@РDÒ DÐ!HÒ`$€¢ € РDÒ Ü€¢`€€Ð DÒ!´ Ð"`€Ð DÒ!´À"`Çàèã¿€ð' DРDÒ!H€¢`€6РDÒ!LÒ'¿àРDÒ¿àÔ`Ô"!\РDÒ¿àÔ` Ô"!`Ð¿à’ Ò" 4Ð¿à’ Ò" 8Ð¿à’ Ò" <пàÒ¿àÔ`$Ô" @Ð¿à’ Ò" DпàÒ¿àÔ  Ò` @³Ð'¿äп䀢 €Ð¿àÒ Ò'¿äпàÒ¿äÒ" HРD’ Ò"!dРDÀ"!h€¶Ð DÒ!H€¢`€ РDÒ!H€¢`€€Ð DÒ Ð"`Ò DÐ@Ò DÔaHÔ" РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ DÔa4’ •*`Ð ’ @[²Ò DÐ"a\РDÒ DÔa8’ •*`Ð ’ @[§Ò DÐ"a`РDÀ"!dÀ'¿ìРDÒ¿ìÐ!H€¢@€€vРDÒ¿ì” “*  Ò!LÒ'¿àпàÒ¿àÔ`Ô" 4пàÒ¿àÔ` Ô" 8à¿àпàÒ¿àÐ 4Ò`8@²ƒÐ$ <à¿àпàÒ¿àÐ 4Ò`$@²{Ð$ @пàÒ¿àÔ  Ò`4@²ˆÐ'¿äп䀢 €Ð¿àÒ 4Ò'¿äпàÒ¿äÒ" DпàÒ¿àÔ  Ò`8@²vÐ'¿äп䀢 €Ð¿àÒ 8Ò'¿äпàÒ¿äÒ" HпàÒ <Ò'¿èРDÒ!dÔ¿è@ €¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€¿èÒ” ’ÿÒ"€¢ €€Ô DÒ DadÒ– ™*à”€ Ö¿ìÖ"¡h’`Ò"¿ÿëÐ¿ì’ Ò'¿ì¿ÿ†Çàèã¿€ð' DÀ'¿ìРDÒ¿ìÐ!H€¢@€€OРDÒ¿ì” “*  Ò!LÒ'¿äпäÒ L€¢`€€<пäÒ Ò'¿èп耢 €Ð¿è€¢ € РDÒ¿è” “*  Ò ¤€¢`€€Ð DÒ 4Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð DÒ Ö@РD’ ” „ŸÂÀÐ'¿àРDÒ¿è” “* ” пàÒ ¤” „@±åпäÒ¿àÒ" LÐ¿ì’ Ò'¿ì¿ÿ­Çàèã¿ð' DРDÿþ²Ð Dÿÿ Ð DÒ!¼Ô@РDŸÂ€Ð DÒ!¬Ô@РDŸÂ€Ò DÐa´Ò DÔa¬Ò Ò"Çàèã¿ð' DÒ DÐa´l’¡¬Ò"Çàè㿈ð' DРDÒ!´Ò'¿ìпìÒ €¢`€° €gРDÒ!¸Ô`РDŸÂ€Ð'¿èп耢 €€¢ €€¢ €P€P€¢ €$€KпìÒ €¢`€ РDÿýQпìÀ" €Ð¿ìÒ €¢`€ РDÒ #Ð"`РDÒÔ@РDŸÂ€Ð Dÿÿš€+Ð¿ì’ Ò" пìÒ €¢`€Ð DÒ!¸Ð`€¢ € РDÒ ;Ð"`РDÒÔ@РDŸÂ€€ РDÒ DÐ ˜Ò`€¢ €Ð DÒ DÔ`Ô" ˜€€Ð¿è°€Çàè㿈ð' DРDÒ!´Ò'¿ìпìl’¡¬Ò"пìÀ" пìÀ" Ð¿ì’ Ò" РDÒÔ`РDŸÂ€Ð DÒ!¸Ô@РDŸÂ€Ð DÀ"  Çàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!´Ð¿ìl’¡¬Ò"пìl’£|Ò" пìl’¡Ò" пìl’¡ˆÒ" пìÀ" пìÀ" Ð¿ì’ Ò" Çàè㿈ð' DРDÒ fÐ"`РDÒÔ`РD’ ŸÂ€Ð DÒ!¸Ð` €¢ € РDÒ =Ð"`РDÒÔ@РDŸÂ€À'¿ìп쀢 €€Ð DÒ¿ì À* äРDÒ¿ì ’ Ò* ôРDÒ¿ì ’ Ò*!Ð¿ì’ Ò'¿ì¿ÿéРDÀ"!РDÀ" (РDÀ"!,РDÀ"!РD’ Ò*!РD’ Ò*!РDÀ*!РD’ Ò2! РD’ Ò2!"РDÀ"!$РDÀ*!(РDÒ!¸ Ð"` ° €Çàèã¿pð' Dò' Hô' LРDÒ Ò'¿ÜпÜÒÒ'¿ØпÜÒ Ò'¿ÔРDÒ HÒ" ÜРDÒ LÒ" àпԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €XпÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿Ô¿ØÒÖ @” àÿ—* Ö'¿ì’`Ò"пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €8пÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿Ô¿ØÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿Ô€¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €Ð¿ÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ D¿ØÒÖ @˜ àÿØ" Ô’`Ò"€¿ÿÞпԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €íпÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ D¿ØÒØ @– ÿ™*àØ"  ’`Ò"пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €ÌпÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔРDÖ D’¿ØÔ@Ú €˜ `ÿÖà ˜À Ø" ” Ô"@€¿ÿºÐ¿Ô€¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €¤Ð¿ÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ D¿ØÒØ @– ÿ™*àØ" ’`Ò"пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €ƒÐ¿ÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔРDÖ D’¿ØÔ@Ú €˜ `ÿÖà˜À Ø" ” Ô"@€¿ÿºÐ¿Ô€¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €[пÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ D¿ØÒÖ @˜ àÿØ" $’`Ò"€¿ÿÞпì’?øÒ'¿ìРDÒ`Ð'¿ÐпÐÒ DÔa Ô" Ò¿Ð Ò DÔ`Ô" Ò¿Ð Ò DÔ` Ô" Ò¿Ð Ò DÔ`$Ô"РDÒ dÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÙРDÒ!¸Ð`€¢ € РDÒ :Ð"`РDÒÔ@РDŸÂ€Ð DÒ €¢`€Ð DÒ €¢`€ РDÒ $€¢`€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ò DÐ`$”“* ’@п쀢 € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ø€¢`€Ò DÐ`Ô DÒ $– •*à”€ —* –À •*àÖРD’ ŸÂÀÒ DÐ"`ØÀ'¿äРDÒ ØÒ'¿àРDÒ¿äÐ $€¢@€€¬Ð¿àÒ¿äÒ" пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €§Ð¿ÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ¿à¿ØÒÖ @˜ àÿØ"€’`Ò"€¿ÿÞпԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €‚пÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿Ô¿ØÒÔ @–  ÿÖ'¿è’`Ò"€¿ÿßпàÔ¿è“: ” `Ô" пàÒ¿è” `Ô" пԀ¢ €Ð¿ÜÒ Ð DŸÂ@€¢ €° €VпÜÒÒ'¿ØпÜÒ Ò'¿ÔпԒ?ÿÒ'¿ÔÔ¿à¿ØÒÖ @˜ àÿØ" ’`Ò"€¿ÿÞРDÒ`Ð'¿ÐпÐÒ¿àÔ@Ô" Ò¿Ð Ò¿àÔ`Ô" Ò¿Ð Ò¿àÔ` Ô" Ò¿Ð Ò¿àÔ`Ô"РDÒ eÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÙÐ¿ä’ Ò'¿äÐ¿à’ TÒ'¿à¿ÿPРDÒ!¸ Ð"`пÜÒ¿ØÒ"пÜÒ¿ÔÒ" ° €Çàèã¿`ð' DРDÒ Ò'¿ÐпÐÒÒ'¿ÌпÐÒ Ò'¿ÈРDÒ!¸Ð`€¢ € РDÒ >Ð"`РDÒÔ@РDŸÂ€Ð¿È€¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €ïпÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÖ @” àÿ—* Ö'¿ì’`Ò"пȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €ÏпÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿È€¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €©Ð¿ÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿à’`Ò"€¿ÿßРDÒ gÐ"`РDÒпàÐ"`РDÒÔ`РD’ ŸÂ€Ð¿à’‘*`’ п쀢 € Ð¿à€¢ €Ð¿à€¢ €€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ¿àÒ"!HÀ'¿èпèÒ¿à€¢ €€«Ð¿È€¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €PпÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ø’`Ò"€¿ÿßпȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €,пÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßÀ'¿äРDÒ ØÒ'¿ÔРDÒ¿äÐ $€¢@€€Ð¿ÔÒ¿ØЀ¢@€€Ð¿ä’ Ò'¿äпԒ TÒ'¿Ô¿ÿêРDÒ Ð"`РDÒпØÐ"`РDÒÔ@РDŸÂ€Ð DÒ¿è” “*  Ò¿ÔÒ"!LпÔÔ¿Ü“: ” `Ô" пÔÒ¿Ü” `Ô" РDÒ`Ð'¿ÄпÄÒ¿ØÒ" Ò¿Ä Ò¿ÔÔ`Ô" Ò¿Ä Ò¿ÔÔ`Ô"РDÒ hÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿàÐ¿è’ Ò'¿è¿ÿRпȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €¦Ð¿ÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßРDÒ¿ÜÒ"!пȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €€Ð¿ÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßРDÒ¿ÜÒ"!”пȀ¢ €Ð¿ÐÒ Ð DŸÂ@€¢ €° €ZпÐÒÒ'¿ÌпÐÒ Ò'¿ÈпȒ?ÿÒ'¿È¿ÌÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßРDÔ¿Ü“: ” `Ô"!˜Ð DÒ¿Ü” `Ô"!œÐ DÒ`Ð'¿ÄпÄÒ DÔaÔ" Ò¿Ä Ò DÔa”Ô" Ò¿Ä Ò DÔa˜Ô" Ò¿Ä Ò DÔaœÔ"РDÒ iÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÙРDÒ!¸À"`Ò DРDÒ DÔ`’ Ò" пÐÒ¿ÌÒ"пÐÒ¿ÈÒ" ° €Çàèã¾Pð' DРDÒ Ò'¾¼Ð¾¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €ßо¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´¾¸ÒÖ @” àÿ—* Ö'¿ì’`Ò"о´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €¿Ð¾¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´¾¸ÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì’?þÒ'¿ìп쀢 €€‰Ð¾´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €‘о¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´¾¸ÒÔ @–  ÿÖ'¾È’`Ò"€¿ÿßРDÒ PÐ"`РDÒоÈÐ"`РDÒÔ`РD’ ŸÂ€À/¿ÐÀ'¾Ä Ð'¾Ìо̀¢ €€2о´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €Uо¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´Ð¾Ì–¿Ð’¾¸Ô@Ø €Ø*À” Ô"@€¿ÿÞо̒¿ÐÔ @  ÿÒ¾Ä@Ð'¾Äо̒ Ò'¾Ì¿ÿÌпì’?ïÒ'¿ìРDÒ`Ð'¾°Ð¾°Ò¿Ñ” `ÿÔ" Ò¾° Ò¿Ò” `ÿÔ" Ò¾° Ò¿Ó” `ÿÔ" Ò¾° Ò¿Ô” `ÿÔ" Ò¾° Ò¿Õ” `ÿÔ" Ò¾° Ò¿Ö” `ÿÔ" Ò¾° Ò¿×” `ÿÔ" Ò¾° Ò¿Ø” `ÿÔ"РDÒ VÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÁРDÒ`Ð'¾°Ð¾°Ò¿Ù” `ÿÔ" Ò¾° Ò¿Ú” `ÿÔ" Ò¾° Ò¿Û” `ÿÔ" Ò¾° Ò¿Ü” `ÿÔ" Ò¾° Ò¿Ý” `ÿÔ" Ò¾° Ò¿Þ” `ÿÔ" Ò¾° Ò¿ß” `ÿÔ" Ò¾° Ò¿à” `ÿÔ"РDÒ VÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÁоĀ¢!€ оÄҿ쀢 €€ РDÒ Ð"`РDÒÔ@РDŸÂ€À'¾ÌоÌҾĀ¢ €€,о´€¢ €Ð¾¼Ò РDŸÂ@€¢ €° €€Ð¾¼ÒÒ'¾¸Ð¾¼Ò Ò'¾´Ð¾´’?ÿÒ'¾´Ð¾Ì–¾Ð’¾¸Ô@Ø €Ø*À” Ô"@€¿ÿÞо̒ Ò'¾Ì¿ÿÑпìÒ¾Ä" Ð'¿ìÒ¾È `€¢ €Ð¾È’?ðÒ'¾ÈоȒ‘*`’ ÄРD’ Ò'¾À€ оȒ‘*`’ ´Ð D’ Ò'¾ÀоȀ¢ €Ð¾È€¢ €€Ð DÒ Ð"`РDÒоÈÐ"`РDÒÔ@РDŸÂ€Ð¾ÀÒ€¢`€Ð D@SÒ¾ÀÐ"@оÀ’¿ÐД @ª5оÀÒ`’¾Ð”!@ª.¿þuп쀢 € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¾¼Ò¾¸Ò"о¼Ò¾´Ò" ° €Çàèã¿hð' DРDÒ Ò'¿ÔпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €ÔпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿ—* Ö'¿ì’`Ò"п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €´Ð¿ÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì’?þÒ'¿ìп쀢 €€~п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €†Ð¿ÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÔ @–  ÿÖ'¿è’`Ò"€¿ÿßпè“: Ò'¿àÐ¿è’ Ò'¿èРDÒ QÐ"`РDÒпèÐ"`РDÒпàÐ"`РDÒÔ`РD’ ŸÂ€Ð¿è€¢ €Ð DÒ Ð"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð DÒ¿è” “*  Ò ¤€¢`€ РD@R)Ò DÔ¿è– •*à’@ Ð"`¤Ð DÒ¿è” “*  Ò ¤Ò'¿ØÀ'¿äп䀢 ?€€‚Ð¿à€¢ €Iп̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €Ð¿ÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿ—* Ö'¿Ü’`Ò"п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €ôпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿÖ¿Ü”À Ô'¿Ü’`Ò"€¿ÿ½€&п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €ÌпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÔ @–  ÿÖ'¿Ü’`Ò"€¿ÿßпØØÔ¿ä– •*à–`Œ’€ Ô@’ •*`Ò¿ÞÒ2 Ð¿ä’ Ò'¿ä¿ÿ|РDÒÐ`h€¢ €~À'¿äп䀢 ?€€wРDÒ`Ð'¿ÈпÈÒ¿ØÔ¿ä– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò" Ò¿È Ò¿ØÖ¿ä”à– •*àÒ@ •*`“2 Ò"РDÒ ]Ð"`РDÒÔ`РD’ ŸÂ€€¿ÿ’Ð¿ä’ Ò'¿ä¿ÿ‡Ð¿ì’?¿Ò'¿ìÐ¿à€¢ €Ð¿ì’?ÀÒ'¿ì¿þ€Ð¿ì€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ÔÒ¿ÐÒ"пÔÒ¿ÌÒ" ° €Çàèã¿xð' DРDÒ Ò'¿äпäÒÒ'¿àпäÒ Ò'¿Üп܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €§Ð¿äÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÖ @” àÿ—* Ö'¿ì’`Ò"п܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €‡Ð¿äÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿Ü€¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €SпäÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÖ @” àÿ—* Ö'¿è’`Ò"п܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €3пäÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÖ @” àÿÖ¿è”À Ô'¿è’`Ò"€¿ÿ½Ð DÒ RÐ"`РDÒпèÐ"`РDÒÔ`РD’ ŸÂ€Ð DÒ¿èÒ"!пäÒ¿àÒ"пäÒ¿ÜÒ" ° €Çàè㿈ð' Dò' Hô' Lö' PРLÒ P Ð'¿ìРL€¢ €þРHÒ `ÿ€¢ J€ø Ò H Ò `ÿ€¢ F€ð Ò H Ò `ÿ€¢ I€è Ò H Ò `ÿ€¢ F€à Ò H Ò `ÿ€¢ €ØРD’ Ò"!РD’ Ô H’@ Ô @Ô*!РD’ Ô H’@ Ô @Ô*!РD’ Ô H’@ Ô @Ô*!РD’ Ô H’@ Ö @” àÿ“* ” Ö H”€ Ö €” àÿ’ ”@ Ô2! РD’ Ô H’@ Ö @” àÿ“* ” Ö H”€ Ö €” àÿ’ ”@ Ô2!"РDÒ ! `ÿ€¢ €Ð DÒ wÐ"`Ò DÐ@Ò DÔ a’  ÿÒ" Ò DÐ@Ò DÔ a’  ÿÒ" РDÒÔ`РD’?ÿŸÂ€Ð DÒ`Ð'¿èпèÒ DÔ a’  ÿÒ" Ò¿è Ò DÔ a’  ÿÒ" Ò¿è Ò DÔa —* “2àÒ" Ò¿è Ò DÔa"—* “2àÒ" Ò¿è Ò DÔ a’  ÿÒ"РDÒ WÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÌ Ò H ’ Ô H’@ Ð Ò @ ’ ÿ€¢`€Ð DÒ ZÐ"`Ò DÐ@’ Ô H’@ Ô @’  ÿÒ" Ò DÐ@’ Ô H’@ Ô @’  ÿÒ" РDÒÔ`РD’ ŸÂ€Ð¿ì’?òÒ'¿ì Ò H Ò `ÿ’ Ô H’@ Ô @’  ÿ@¦a”“* ’@п쀢 €Ð DÒ XÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€žÐ L€¢ €‹Ð HÒ `ÿ€¢ J€… Ò H Ò `ÿ€¢ F€} Ò H Ò `ÿ€¢ X€u Ò H Ò `ÿ€¢ X€m Ò H Ò `ÿ€¢ €e Ò H Ò `ÿ€¢ € €¢ €€¢ € €:€¢ €&€5РDÒ lÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€=РDÒ mÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€,РDÒ nÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€Ð DÒ YÐ"`Ò DÐ@’ Ô H’@ Ô @’  ÿÒ" РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€€€Ð DÒ MÐ"`РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€Çàèã¿xð' Dò' Hô' Lö' PРL€¢ €‚РHÒ `ÿ€¢ A€| Ò H Ò `ÿ€¢ d€t Ò H Ò `ÿ€¢ o€l Ò H Ò `ÿ€¢ b€d Ò H Ò `ÿ€¢ e€\ Ò H Ô ’  ÿ‘*`’ Ô H’@ Ô @’  ÿ Ð'¿ì Ò H Ô ’  ÿ‘*`’ Ô H’@ Ô @’  ÿ Ð'¿è Ò H Ô ’  ÿ‘*`’ Ô H’@ Ô @’  ÿ Ð'¿ä Ò H Ò `ÿÐ'¿àРDÒ`Ð'¿ÜпÜÒ¿ìÒ" Ò¿Ü Ò¿èÒ" Ò¿Ü Ò¿äÒ" Ò¿Ü Ò¿àÒ"РDÒ LÐ"`РDÒÔ`РD’ ŸÂ€€¿ÿÝРD’ Ò"!$РDÒ¿ãÒ*!(€Ð DÒ NÐ"`Ò DÐ@Ò LÔ P’@ Ò" РDÒÔ`РD’ ŸÂ€Çàèã¿`ð' DРDÒ Ò'¿ÌпÌÒÒ'¿ÈпÌÒ Ò'¿ÄпĀ¢ €Ð¿ÌÒ Ð DŸÂ@€¢ €° €ÂпÌÒÒ'¿ÈпÌÒ Ò'¿ÄпĒ?ÿÒ'¿Ä¿ÈÒÖ @” àÿ—* Ö'¿ì’`Ò"пĀ¢ €Ð¿ÌÒ Ð DŸÂ@€¢ €° €¢Ð¿ÌÒÒ'¿ÈпÌÒ Ò'¿ÄпĒ?ÿÒ'¿Ä¿ÈÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì’?þÒ'¿ìп쀢 € Ð'¿Ð€ п쀢 €Ð¿ìÐ'¿Ð€À'¿ÐÀ'¿ÔпÔҿЀ¢ €€,пĀ¢ €Ð¿ÌÒ Ð DŸÂ@€¢ €° €_пÌÒÒ'¿ÈпÌÒ Ò'¿ÄпĒ?ÿÒ'¿ÄпԖ¿Ø’¿ÈÔ@Ø €Ø*À” Ô"@€¿ÿÞпԒ Ò'¿Ô¿ÿÑпìÒ¿Ð" Ð'¿ìÒ DÐa €¢ à€€¢ î€ €’¿ØРDÔ¿ÐÖ¿ìÿý€’¿ØРDÔ¿ÐÖ¿ìÿþ³€Ð DÒ DÐ"`Ò DÐ@Ò DÔa Ô" РDÒÔ@РDŸÂ€€Ð¿ÌÒ¿ÈÒ"пÌÒ¿ÄÒ" п쀢 € РDÒ Ô`РDÒ¿ìŸÂ€° €Çàèã¿hð' DРDÒ!¸Ò'¿ìпìÒ ¤Ò'¿èÀ'¿ØРDÒ Ò'¿ÔпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп耢 €“п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €GпÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿ—* Ö'¿Ø’`Ò"п̀¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €'пÔÒÒ'¿ÐпÔÒ Ò'¿Ìп̒?ÿÒ'¿Ì¿ÐÒÖ @” àÿÖ¿Ø”À Ô'¿Ø’`Ò"€¿ÿ½Ð¿Ø’?þÒ'¿Øп؀¢ €BРDÒ! €¢`þ€Ð¿ìÒ `Ò'¿È€ пìÒ DÔa ’¿ ” “*  Ò dÒ'¿ÈпØÒ¿È€¢ €Ð¿ØÐ'¿ÈÒ DÐ`Ò¿È”`Ö Ð D’ ŸÂÀÐ'¿èпèÀ"пèÒ DÔ a£Ô* пèÒ¿ØÒ" пèÒ¿ÈÒ" пèÔ¿è’ ” Ô" Ô'¿ÜпìÒ¿èÒ" ¤Ð¿ìÀ" ¨À'¿äпÈÐ'¿à€À'¿àÀ'¿äÀ'¿Ü€ пìÒ ¨Ò'¿äпèÒ Ò'¿àпèÒ Ð¿ä’@Ò'¿ÜпäÒ¿à€¢ €€BпÔÒ¿ÐÒ"пÔÒ¿ÌÒ" пìÒ¿äÒ" ¨Ð¿Ì€¢ €Ð¿ÔÒ Ð DŸÂ@€¢ €° €šÐ¿ÔÒÒ'¿ÐпÔÒ Ò'¿ÌпäÒ¿à€¢ €Ð¿Ì€¢ €€€¿ÜÒ”¿ÐÖ€Ø ÀØ*@–àÖ"€’`Ò"п̒?ÿÒ'¿ÌÐ¿ä’ Ò'¿ä¿ÿã¿ÿ»Ð¿è€¢ €&РDÒ!0€¢`€Ð DÒ¿èÒ"!0€Ð DÒ!0Ò'¿ÈпÈÒ€¢`€€Ð¿ÈÒÒ'¿È¿ÿöпÈÒ¿èÒ"пèÒ Ò'¿ÜпèÒ Ð¿à’"@Ò'¿ØпìÀ" ¤Ò DÐa €¢ à€€¢ î€ €Ð DÒ¿ÜÔ¿àÖ¿Øÿû¯€"РDÒ¿ÜÔ¿àÖ¿ØÿýN€Ð DÒ [Ð"`Ò DÐ@Ò DÔa Ô" Ò DÐ@Ò¿àÔ¿Ø’@ Ò" РDÒÔ`РD’ ŸÂ€€Ð¿ÔÒ¿ÐÒ"пÔÒ¿ÌÒ" п؀¢ € РDÒ Ô`РDҿ؟€° €Çàèã¿€ð' DРDÒ Ò'¿èпèÒÒ'¿äпèÒ Ò'¿àÐ¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €cпèÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÖ @” àÿ—* Ö'¿ì’`Ò"Ð¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €CпèÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÖ @” àÿÖ¿ì”À Ô'¿ì’`Ò"€¿ÿ½Ð¿ì’?þÒ'¿ìРDÒ [Ð"`Ò DÐ@Ò DÔa Ô" РDÒпìÐ"`РDÒÔ`РD’ ŸÂ€Ð¿èÒ¿äÒ"пèÒ¿àÒ" п쀢 € РDÒ Ô`РDÒ¿ìŸÂ€° €Çàèã¿€ð' DРDÒ Ò'¿èпèÒÒ'¿äпèÒ Ò'¿àÐ¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €¼Ð¿èÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÔ @–  ÿÖ'¿ì’`Ò"€¿ÿßп쀢 ÿ€€6Ò DÐa¸Ò DÐa¸Ò DÔa¸Ò ”`Ô" пèÒ¿äÒ"пèÒ¿àÒ" Ð¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €ƒÐ¿èÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÔ @–  ÿÖ'¿ì’`Ò"€¿ÿß¿ÿÈÐ¿à€¢ €Ð¿èÒ Ð DŸÂ@€¢ €° €]пèÒÒ'¿äпèÒ Ò'¿àпà’?ÿÒ'¿à¿äÒÔ @–  ÿÖ'¿ì’`Ò"€¿ÿßп쀢 ÿ€€¿ÿ×п쀢 €€Ò DÐa¸Ò DÔa¸Ò ”`Ô" пèÒ¿äÒ"пèÒ¿àÒ" ¿ÿcРDÒ!¸Ð`€¢ €Ð DÒ tÐ"`Ò DÐ@Ò DÔa¸Ò Ò" РDÒпìÐ"`РDÒÔ`РD’?ÿŸÂ€Ð DÒ!¸À"`РDÒ¿ìÒ"! Ð¿èÒ¿äÒ"пèÒ¿àÒ" ° €Çàèã¿xð' DРDÒ Ò'¿äпäÒÒ'¿àпäÒ Ò'¿Üп܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €bпäÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÔ @–  ÿÖ'¿ì’`Ò"€¿ÿßп܀¢ €Ð¿äÒ Ð DŸÂ@€¢ €° €>пäÒÒ'¿àпäÒ Ò'¿Üпܒ?ÿÒ'¿Ü¿àÒÔ @–  ÿÖ'¿è’`Ò"€¿ÿßп쀢 ÿ€Ð¿è€¢ Ø€€Ð DÒ 5Ð"`РDÒпìÐ"`РDÒпèÐ"`РDÒÔ@РDŸÂ€Ð DÒ¿èÒ"! Ð¿äÒ¿àÒ"пäÒ¿ÜÒ" ° €Çàèã¿ð' DРDÒ! €¢`€Ð DÒ!¸Ð` €¢ € РDÿÿv€¢ €° €Q€ РDÿþ•€¢ €° €FÒ DÐa €¢ Ï€,€¢ Í€€¢ Āƀ¢ Ä€€¢ Á€ €¢ À€O€¢ €ý€€¢ €T€¢ Àx€€¢ É€Y€¢ É€p€¢ Ë€m€¢ Ë€™€[€¢ Û€ª€¢ Û€€¢ Ø€ €¢ ؀ـ¢ Ù€x€¢ Ú€g€î€¢ ï€ €¢ à€©€¢ Ü€Ú€¢ Ý€˜€à€¢ þ€²€ÛРDÿï—€¢ €° €ç€áРD’ ” ÿï倢 €° €Ú€ÔРD’ ” ÿïØ€¢ €° €Í€ÇРD’ ” ÿïË€¢ €° €À€ºÐ D’ ” ÿï¾€¢ €° €³€­Ð DÒ <Ð"`Ò DÐ@Ò DÔa Ô" РDÒÔ@РDŸÂ€€œÐ Dÿò€¢ €° €—РDÀ"! ° €’РDÒ UÐ"`РDÒÔ`РD’ ŸÂ€Ð DÀ"! ° €‚РDÿýK€¢ €° €y€sРDÿô €¢ €° €n€hРDÿõû€¢ €° €c€]РDÿ÷Þ€¢ €° €X€RÒ DÐa¸Ò DÔa ’¿ ” “*  Ò Ð DŸÂ@€¢ €° €D€>РDÒ!¸Ô`РDŸÂ€€¢ €° €6€0РDÒ \Ð"`Ò DÐ@Ò DÔa Ô" РDÒÔ`РD’ ŸÂ€€Ð Dÿü뀢 €° €€Ð DÒ DÐ"`Ò DÐ@Ò DÔa Ô" РDÒÔ@РDŸÂ€€Ð DÀ"! ¿þŸÇàèã¿ð' DРDÒ! €¢`€ РDÿý?€¢ €° €:РDÒ DÔa¸Ö ’àÐÐ! €¢ €Ð DÒ bÐ"`Ò DÐ@Ò DÔa¸Ò Ò" РDÒÔ`РD’ ŸÂ€Ð DÀ"! €Ò DÐ`Ô DÒ¡¸Ô РDÒ`ŸÂ€€¢ €° € Ò DÐa¸Ò DÔa¸Ö ’à” `Ô" ° €Çàè㿈ð' Dò' HРDÒ! Ò'¿ì Ð'¿èРDÒ yÐ"`РDÒпìÐ"`РDÒРHÐ"`РDÒÔ`РD’?ÿŸÂ€Ð¿ì€¢ ¿€ Ð'¿è€>п쀢 πп쀢 ×€€ Ð'¿è€0Ò H`’ `Ðҿ쀢@€ Ò H`’ `Ðҿ쀢@€€ Ð'¿è€Ò Hÿ’ `Ðҿ쀢@€ Ò Hþ’ `Ðҿ쀢@€€ Ð'¿è€ Ð'¿èРDÒ aÐ"`РDÒпìÐ"`РDÒпèÐ"`РDÒÔ`РD’ ŸÂ€Ð¿è€¢ €€¢ €€¢ € €€¢ €€Ð DÀ"! ° €Ð Dÿüt€¢ €° € РDÒ! Ò'¿ì€° €¿ÿ‚Çàè㿈ð' DРDÒ!¸Ò'¿ìРDÀ" ØРDÀ" РDÀ"! Ð¿ìÀ" пìÀ" пìÀ" пìÀ" ¤Çàè㿈ð' DРDÒ Ö@РD’ ” ¬ŸÂÀÐ'¿ìРDÒ¿ìÒ"!¸Ð¿ì’¡”Ò"пì}’ \Ò" пì~’¡øÒ" пì{’¡ Ò" пìÀ" `À'¿èп耢 €€Ð¿ìÒ¿è” “*  {’¡ Ò" пìÒ¿è” “*  À" dÐ¿è’ Ò'¿è¿ÿéпìy’ Ò" пìy’ Ò" XРDÿÿ¨Çàèã¿€ð' Dò' Hô' LРDÒ!¸Ò'¿ìРDÒ Ð`0’?ìÒ'¿èРLҿ耢 €Ð¿èÐ' LРL€¢ €ycpÐ'¿äРH€¢ à€ Ð L€¢ € Ð' L€ РH€¢ î€Ð L€¢ € Ð' L€{a Ð'¿äРH€¢ à€Ð H€¢ y`Ð'¿äРH€¢ þ€ пìÒ¿äÒ" пìÒ LÒ" `€*РH€¢ ߀РH€¢ ï€Ð¿ìÔ H’¿ ” “*  Ò¿äÒ" пìÔ H’¿ ” “*  Ò LÒ" d€Ð DÒ DÐ"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Çàè㿈ð' Dò' Hô' LРDÒ!¸Ò'¿ìРH€¢ þ€Ð¿ìÒ LÒ" €"РH€¢ ߀РH€¢ ï€ Ð¿ìÔ H’¿ ” “*  Ò LÒ" €Ð DÒ DÐ"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Çàèã¿xð' DРDÒ!¼Ò'¿ìРDÒ!€¢`€Ð DÒ!”€¢`?€Ð DÒ!˜€¢`€ РDÒ!œ€¢`€€ РDÒ zÐ"`РDÒÔ`РD’?ÿŸÂ€À'¿èРDÒ¿èÐ!H€¢@€€0РDÒ¿è” “*  Ò!LÒ'¿ØпØÒ Ò'¿àпØÒ Ò'¿ÜÐ¿à’‘*`’ (пì–@РD’ Ô¿à@пܒ‘*`’ 8пì–@РD’ Ô¿Ü@vпìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿÌÀ'¿äРDÒ¿äÐ!d€¢@€€UРDÒ¿ä” “*  Ò!hÒ'¿èРDÒ¿è” “*  Ò!LÒ'¿ØпìÒ¿ä” “*  Ò¿ìÔ¿ØÖ ” —* ’@ Ô`(Ô" HпìÒ¿ä” “*  Ò¿ìÔ¿ØÖ ” —* ’@ Ô`8Ô" pпØÒ 0€¢`€Ð¿ìÒ¿ä” “*  ’ Ò" ˜Ð¿ìÒ¿ä” “*  Ò¿ØÔ`$€¢ 4€’ ’ Ò" À€Ð¿ìÒ¿ä” “*  Ò¿ìÔ¿ä– •*à’@ À"`ÀÀ" ˜Ð¿ä’ Ò'¿ä¿ÿ§Ð¿ìÀ" пìÀ" пìÀ" пìÒ DÔaÔ" $ÇàèãºPð' Dò' Hô' Lö' PРL€¢ €Ð L€¢ €€Ð DÒ 2Ð"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð H€¢ € РDÒ L” “* ” Р´€Ò DÔ L– •*à’@ Ð`ÄÐ'¿ìп쀢 €Ð DÒ 2Ð"`РDÒРLÐ"`РDÒÔ@РDŸÂ€Ð PÒ€¢`€ РDÒ Ö@РD’ ”%ŸÂÀÒ PÐ"@РPÒÒ'¿èпèÒ¿ìÒ" ŒÀ'¿ä Ð'¿Üп܀¢ €€6пìÒ¿ÜÐ ’ ÿÒ'¿àÐ¿à€¢ € пäÒ¿à €¢!€€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ò¿àÿ’Ò'¿à€¢ÿ€€ ¿äÒ” –¾ÀØ¿ßØ*À ’`Ò"¿ÿïпܒ Ò'¿Ü¿ÿÈп䒾ÀÀ*@пäÐ'¿ÔÀ'º´Ð¾À“* ‘:`Ð'¿ØÀ'¿äп䒾ÀÐ @“* ‘:`€¢ €€4п䒾ÀÐ @“* ‘:`Ò¿Ø€¢ €€¿äÒ– •*à–º¸Øº´Ø"À ’`Ò"к´’ Ò'º´¿ÿé Ò¿Ø‘* Òº´€¢@€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ðº´“* Ò'º´Ð¿Ø’ Ò'¿Ø¿ÿÆÀ'¿ä Ð'¿Üп܀¢ €€5пìÒ¿ÜÔ  ÿ€¢ €#пèÒ¿Ü” “*  Ò¿ä” “* ”º¸Ö¿äÒ€ ”"À Ô" HпìÒ¿ÜÔ  ÿÒ¿ä@Ð'¿äпèÒ¿Ü” “* Ö¿ä”ÿÿ– •*à–º¸ÔÀ Ô" €Ð¿èÒ¿Ü” “* ”?ÿÔ" пܒ Ò'¿Ü¿ÿÉпèÿ’£ÿÒ" DÐ¿è’  ’ ”$@›ÁÀ'¿ä Ð'¿Üп܀¢ €€H Ð'¿àпìÒ¿ÜÔ  ÿÒ¿à€¢@€€7п䒑*`’º¸” Ö¿Ü”"€ Ð@“* Ò'¿Ð Ò¿Ü" ’ ‘*@Ð'¿Ìп̀¢ €€Ð¿èҿД “*  Ò¿ÜÒ" пèÒ¿Ð Ò¿ìÔ¿ä’@ Ô `Ô*$пВ Ò'¿Ðп̒?ÿÒ'¿Ì¿ÿåÐ¿à’ Ò'¿àÐ¿ä’ Ò'¿ä¿ÿÃпܒ Ò'¿Ü¿ÿ¶Ð H€¢ €)À'¿àпàÒ¿Ô€¢ €€!пìÒ¿à Ò  `ÿÐ'º°Ðº°€¢ €Ðº°€¢ €€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿à’ Ò'¿à¿ÿÜÇàè㿈ð' D ¢ö' PРDäРDæ РDÒ Ò'¿ìпìÒ! €¢`€T€¤`€€M€¤à€Ð¿ìÒ Ô` пìŸÂ€€¢ €° €hпìÒ ä@пìÒ æ`¦ÿÿÐ €¨ ÿ¤ €¥ ÿ€,€¤à€Ð¿ìÒ Ô` пìŸÂ€€¢ €° €LпìÒ ä@пìÒ æ`¦ÿÿÐ €¨ ÿ¤ €¥ ÿ€€¿ÿ‥ €¨ ÿ€Ð¿ìè"! € ¡,  ¢`¿ÿ²€Ð P€¢€Ð¿ìÒ!¼Ð`€¢ €Ð¿ìÒ uÐ"`пìÒÔ`пì’?ÿŸÂ€Ð¿ìÒ!¼ Ð"`’ "@¡,¢ РDä"РDæ" РDà" РDâ" ° €Çàèã¿ð' D ¢ö' Pø' Tä T€¤@€Ð D’”–ÿÿe€¢ €°?ÿ€XРDà РDâ ¢$@§<’ ‘*@’?ÿ¦ À РP’•*`Ð €¤À€€§,à€¤`€Ð D’”– ÿÿA€¢ €°?ÿ€4РDà РDâ ¢ÿ“< `¦À¤ ¿ÿÝРDà" РDâ" €¤ €Ð DÒ Ð@’ vÒ" РDÒ Ð@Ò DÔ Ð`’?ÿŸÂ€° €Ò PÐ`ŒÒ P”—* ’@ Ô`H’À  Ò  `ÿ°€Çàè㿈ð' DРDÒ!¼Ò'¿ìÒ DÐa¸Ô DÒ¡¸Ô¿ìÖ ” €¢ €” •: Ò`”@ Ô" пìÀ" РDÒ!¸Ô`РDŸÂ€€¢ €° €%À'¿èРDÒ¿èÐ!H€¢@€€ пìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿïпìÒ DÔaÔ" $РDÒ! €¢`€Ð¿ìÀ" ° €Çàèã¿Pð' Dò' HРDÒ!¼Ò'¿ìРDÒ!€¢`€Ð¿ìÒ $€¢`€ РDÿÿ¨€¢ €° €æпìÒ €¢`€ØРDÐ'¿àРDÒ Ð@Ð'¿ÐРDÒ Ð`Ð'¿Ôпìà пìâ пìÒ Ò'¿ÀÒ Ò'¿ÄÒ Ò'¿ÈÐ Ð'¿ÌÀ'¿èРDÒ¿èÐ!d€¢@€€£Ð¿è’‘*`Ò H ÒÒ'¿¼Ð¿ìÒ¿è” “*  Ò HÒ'¿¸Ð¿ìÒ¿è” “*  Ò pÒ'¿´€¤`€’¿Ð ’”– ÿþc€¢ €° €œà¿Øâ¿Ü€¤`€ª €ø­<¬  ÿп¸’•*` ê €¢ € ¢$@п¸’Ð d¤ ÿ€ª ’¿Ð ’”Ö¿¸˜ÿþƤ€¢ €° €pà¿Øâ¿Ü€¤ €-€¤@€’¿Ð ’”–ÿþ"€¢ €° €[à¿Øâ¿Ü¢$@©<’ ‘*@’?ÿ¨ ×”—* ”a°’À Ô@€¥ € ×”—* ”að’À Ô@ ¤Ð¿ìÒ¿è” “*  Ò ˜€¢`€Ð DÒ¿è” “*  Ò!hÒ'¿°Ð¿°’‘*`’¿ÀÐ@¤€Ð¿°’‘*`’¿Àä"@п¼ä2пìÒ¿è” “*  Ò À€¢`€¦ €¤à?€€‡€¤`€’¿Ð ’”– ÿýË€¢ €° €à¿Øâ¿Ü€¤`€ª €ø­<¬  ÿп´’•*` ê €¢ € ¢$@п´’Ð d¤ ÿ€ª ’¿Ð ’”Ö¿´˜ÿþ.¤€¢ €° €Øà¿Øâ¿Ü©< ¤  €¤ €;¦À€¤@€’¿Ð ’”–ÿý‡€¢ €° €Àà¿Øâ¿Ü¢$@©<’ ‘*@’?ÿ¨ ×”—* ”a°’À Ô@€¥ € ×”—* ”að’À Ô@ ¤Ø’•*`’ Œ€ Ò “* Ô¿¼@ ä2€€¥ €€¦à¦à¿ÿx€j¦ €¤à?€€d€¤`€’¿Ð ’”– ÿý>€¢ €° €wà¿Øâ¿Ü€¤`€ª €ø­<¬  ÿп´’•*` ê €¢ € ¢$@п´’Ð d¤ ÿ€ª ’¿Ð ’”Ö¿´˜ÿý¡¤€¢ €° €Kà¿Øâ¿Ü©< ¤  €¤ €¦À€¤@€’¿Ð ’”–ÿüú€¢ €° €3à¿Øâ¿Ü¢$@€€¥ €€¦à¦à¿ÿ›Ð¿è’ Ò'¿è¿þYРDÒ Ð¿ÐÐ"@РDÒ Ð¿ÔÐ"`пìà" пìâ" пìÒ¿ÀÒ" Ò¿ÄÒ" Ò¿ÈÒ" Ò¿ÌÒ" Ò¿ìпìÒ¿ìÔ`$’¿ÿÒ" $° €Çàè㿈ð' DРDÒ Ö@РD’ ” èŸÂÀÐ'¿ìРDÒ¿ìÒ"!¼Ð¿ì€’¡¬Ò"п섒 HÒ" À'¿èп耢 €€Ð¿ìÒ¿è” “*  Ò¿ìÔ¿è– •*à’@ À"`8À" (Ð¿è’ Ò'¿è¿ÿëÇàèã¿hð' DРDÒ!¼Ò'¿ìРDÒ!”`€  `?ÿÐ'¿èÀ'¿äп耢 € РDÒ!”€¢`€ Ð'¿ä€Ð DÒ DÐ!Òa”€¢ € РDÒ!”€¢`?€€ Ð'¿äРDÒ!H€¢`€ Ð'¿äРDÒ!˜€¢`€ РDÒ DÔa˜’¿ÿÐ!œ€¢ € Ð'¿äРDÒ!œ€¢` € Ð'¿äп䀢 € РDÒ Ð"`Ò DÐ@Ò DÔaÔ" Ò DÐ@Ò DÔa”Ô" Ò DÐ@Ò DÔa˜Ô" Ò DÐ@Ò DÔaœÔ" $РDÒÔ@РDŸÂ€À'¿àРDÒ¿àÐ!H€¢@€€tРDÒ¿à” “* ” СLÒ Ò'¿ÌРDÒ¿Ì” “* Ð  ’ Ò'¿Ôп耢 €Ð¿ÔÒ€¢`€Ð DÒ sÐ"`РDÒпÌÐ"`РDÒÀ"`РDÒÔ`РD’?ÿŸÂ€Ð DÒ!Ò'¿ÜРDÒ¿ÜÐ!”€¢@€€9пܒ‘*`Ô¿Ô’ Ð@Ò¿Ü” “* Ô¿Ô’@ Ô@€¢ € Ð'¿ÈРDÒ!˜Ð¿È€¢@€Ð DÒ sÐ"`РDÒпÌÐ"`РDÒпÜÐ"`РDÒÔ`РD’?ÿŸÂ€Ð¿Ü’‘*`Ò¿Ô Ò DÔaœÔ"пܒ Ò'¿Ü¿ÿÃÐ¿à’ Ò'¿à¿ÿˆÐ DÒ!˜€¢`€Ð¿è€¢ €Ð¿ì‡’£¨Ò" €Ð¿ìˆ’£¸Ò" €Ð¿è€¢ €Ð¿ìŠ’ Ò" €Ð¿ìŠ’¡äÒ" À'¿àРDÒ¿àÐ!H€¢@€€CРDÒ¿à” “*  Ò!LÒ'¿Ðп耢 €Ð DÒ!˜€¢`€Ð¿ÐÒ Ò'¿Øпؒ‘*`’ ,пì–@РD’ Ô¿ØÿùĀпÐÒ Ò'¿Øпؒ‘*`’ ,пì–@РD’ Ô¿Øÿù´Ð¿ìÒ¿ìÔ¿Ø– •*à’@ Ô`,Ô" <пìÒ¿à” “*  À" Ð¿à’ Ò'¿à¿ÿ¹Ð¿ìÀ" пìÀ" пìÀ" пìÀ" пìÒ DÔaÔ" (Çàè㿈ð' DРDÒ!¼Ò'¿ìÒ DÐa¸Ô DÒ¡¸Ô¿ìÖ ” €¢ €” •: Ò`”@ Ô" пìÀ" РDÒ!¸Ô`РDŸÂ€€¢ €° €'À'¿èРDÒ¿èÐ!H€¢@€€ пìÒ¿è” “*  À" Ð¿è’ Ò'¿è¿ÿïпìÀ" пìÒ DÔaÔ" (РDÒ! €¢`€Ð¿ìÀ" ° €Çàèã¿@ð' Dò' HРDÒ!¼Ò'¿ìРDÒ!œÒ'¿èРDÒ!€¢`€Ð¿ìÒ (€¢`€ РDÿÿ£€¢ €° €èпìÒ €¢`€ÚРDÐ'¿ÐРDÒ Ð@Ð'¿ÀРDÒ Ð`Ð'¿Äпìä пìæ пìÒ Ò'¿¨Ò Ò'¿¬Ò Ò'¿°Ò Ò'¿´Ð $Ð'¿¸À'¿äРDÒ¿äÐ!d€¢@€€¡Ð¿ä’‘*`Ò H ÒÒ'¿ÜРDÒ¿ä” “*  Ò!hÒ'¿àРDÒ¿à” “*  Ò!LÒ'¿ Ð¿ìÒ¿ Ô`’ •*` Ò ,Ò'¿¤€¤à€’¿À ’”– ÿú~€¢ €° €”ä¿Èæ¿Ì€¤à€¨ €ÿø«<€ª `ÿп¤’•*` è €¢ € ¦$Àп¤’Ð d  ÿ€¨ ’¿À ’”Ö¿¤˜ÿúá €¢ €° €hä¿Èæ¿Ì€¤ €-€¤À€’¿À ’”–ÿú=€¢ €° €Sä¿Èæ¿Ì¦$À£<€’ ‘*@’?ÿ¢ @ ×”—* ”b0’À Ô@€¤@ € ×”—* ”bp’À Ô@  Ð¿à’‘*`’¿¨@Ò   Ð¿à’‘*`’¿¨@à" пÜÔ¿è“, Ò2Ð¿ä’ Ò'¿ä¿ÿ[РDÒ Ð¿ÀÐ"@РDÒ Ð¿ÄÐ"`пìä" пìæ" пìÒ¿¨Ò" Ò¿¬Ò" Ò¿°Ò" Ò¿´Ò" Ò¿¸Ò" $Ò¿ìпìÒ¿ìÔ`(’¿ÿÒ" (° €Çàèã¿Xð' Dò' HРDÒ!¼Ò'¿ìРDÒ!”Ò'¿èРDÒ!œÒ'¿äРDÒ!€¢`€Ð¿ìÒ (€¢`€ РDÿþœ€¢ €° €õпìÒ €¢`€çпìÒ Ò'¿àÐ¿à€¢ €Ð¿à’?ÿÒ'¿à€ØРDÐ'¿ÐРDÒ Ð@Ð'¿ÀРDÒ Ð`Ð'¿Äпìæ пìè РHÒÒ'¿ÜпìÒ <Ò'¿¼Ð Dâ!п耤@€€°€¥ €’¿À ’”– ÿùŽ€¢ €° €¸æ¿Èè¿Ì€¥ €ª €?ø­<À¬  ÿп¼’•*` ê €¢ € ¨%п¼’Ð d  ÿ€ª ’¿À ’”Ö¿¼˜ÿùñ €¢ €° €Œæ¿Èè¿Ì¥<   €¤ €=¢@€¥€’¿À ’”–ÿùJ€¢ €° €tæ¿Èè¿Ì¨%¥<À’ ‘*@’?ÿ¤ € ×”—* ”b0’À Ô@€¤€ € ×”—* ”bp’À Ô@  Ø’•*`’ Œ€ Ò “* Ô¿Ü@ Ô¿ä“, Ò2€/€¤ €¢`€) “*Ò'¿à€¤ €€¥€’¿À ’”–ÿù€¢ €° €.æ¿Èè¿Ì¨%’‘<À ” “*€”ÿ¤ пà’Ò'¿àпà’?ÿÒ'¿à€¢`¿ÿNРDÒ Ð¿ÀÐ"@РDÒ Ð¿ÄÐ"`пìæ" пìè" пìÒ¿àÒ" Ò¿ìпìÒ¿ìÔ`(’¿ÿÒ" (° €Çàèã¿hð' Dò' HРDÒ!¼Ò'¿ìРD’ Ð!œ“*@Ò'¿èРDÒ!€¢`€Ð¿ìÒ (€¢`€ РDÿý‰€¢ €° €YРDÐ'¿ØРDÒ Ð@Ð'¿ÈРDÒ Ð`Ð'¿Ìпìà пìâ À'¿äРDÒ¿äÐ!d€¢@€€-п䒑*`Ò H ÒÒ'¿à€¤`€’¿È ’”– ÿøŠ€¢ €° €+à¿Ðâ¿Ô¢ÿ“< `€¢ €Ð¿àÒ¿àÔ@ҿꔀ Ô2Ð¿ä’ Ò'¿ä¿ÿÏРDÒ Ð¿ÈÐ"@РDÒ Ð¿ÌÐ"`пìà" пìâ" Ò¿ìпìÒ¿ìÔ`(’¿ÿÒ" (° €Çàèã¾Hð' Dò' HРDÒ!¼Ò'¿ìРDÒ!”Ò'¿èРD’ Ð!œ“*@Ò'¿äРD’?ÿÐ!œ“*@Ò'¿àРDÒ!€¢`€Ð¿ìÒ (€¢`€ РDÿý €¢ €° €½Ð¿ìÒ €¢`€–РDÐ'¿ÈРDÒ Ð@Ð'¿¸Ð DÒ Ð`Ð'¿¼Ð¿ìæ пìè пìÒ Ò'¿ÜРHÒÒ'¿ØпìÒ <Ò'¿´À'¿°Ð Dâ!п܀¢ €Ð¿è€¤@€€ €¥ €’¿¸ ’”– ÿø€¢ €€læ¿Àè¿Ä€¥ €ª €?ø­<À¬  ÿп´’•*` ê €¢ € ¨%п´’Ð d  ÿ€ª ’¿¸ ’”Ö¿´˜ÿød €¢ €€Aæ¿Àè¿Ä¥<   €¤ €.€¤ € РDÒ vÐ"`РDÒÔ`РD’?ÿŸÂ€€¥ €’¿¸ ’”– ÿ÷±€¢ €€æ¿Àè¿Ä¨?ÿ“<À `€¢ €à¿ä€à¿à€(€¤ €% “*Ò'¿Ü€¤ €€¥€’¿¸ ’”–ÿ÷Š€¢ €€öæ¿Àè¿Ä¨%’‘<À ” “*€”ÿ¤ пܒÒ'¿Ü€xØ’•*`’ Œ€ Ò “* пؒ Ò'¿ÔпÔÒ•*`‘: €¢ €:€¥ €’¿¸ ’”– ÿ÷Z€¢ €€Ææ¿Àè¿Ä¨?ÿ“<À `€¢ € пÔÒ•*`‘: Ò¿ä €¢ €Ð¿ÔÒ•*`‘: €¢ € пÔÒ¿ÔÔ@ҿ攀 Ô2€Ð¿ÔÒ¿ÔÔ@ҿ─ Ô2€¤¿ÿ€¤ €€ ¢`п耤@€€¿ÿ©€¤ €Ø’•*`’ Œ€ ÒÒ'¾¬Ð¾¬’‘*`Ò¿Ø à2¿°Ò– •*à–¾°Ø¾¬Ø"À ’`Ò"¢`¿þóп܀¢ €Vп耤@€€MØ’•*`’ Œ€ Ò “* пؒ Ò'¿ÔпÔÒ•*`‘: €¢ €8€¥ €’¿¸ ’”– ÿöÛ€¢ €€Gæ¿Àè¿Ä¨?ÿ“<À `€¢ € пÔÒ•*`‘: Ò¿ä €¢ €Ð¿ÔÒ•*`‘: €¢ € пÔÒ¿ÔÔ@ҿ攀 Ô2€Ð¿ÔÒ¿ÔÔ@ҿ─ Ô2¢`¿ÿ±Ð¿Ü’?ÿÒ'¿ÜРDÒ Ð¿¸Ð"@РDÒ Ð¿¼Ð"`пìæ" пìè" пìÒ¿ÜÒ" Ò¿ìпìÒ¿ìÔ`(’¿ÿÒ" (° €Ð¿°€¢ €€Ò¿°ÿ’Ò'¿° “* ¾°Ò  “* Ô¿Ø@ À2¿ÿí° €Çàèã¿€ð' DРDÒ Ö@РD’ ” @ŸÂÀÐ'¿ìРDÒ¿ìÒ"!¼Ð¿ì†’¡Ò"À'¿àÐ¿à€¢ €€ пìÒ¿à” “*  À" ,Ð¿à’ Ò'¿à¿ÿñÒ DÐ`Ò DÔ`$’ •*`ÖРD’ ŸÂÀÒ DÐ"` Ð DÒ  Ò'¿èÀ'¿äРDÒ¿äÐ $€¢@€€À'¿àÐ¿à€¢ ?€€ ¿èÒ”?ÿÔ"@’`Ò"Ð¿à’ Ò'¿à¿ÿñÐ¿ä’ Ò'¿ä¿ÿâÇàèã¿xð' DРDÒ!¨Ò'¿ìРDÒ!<Ò'¿àÒ DÐ`Ò DÔ`$’ •*`ÖРD’ ŸÂÀÒ¿ìÐ"`8пìÒ¿ìÔ DÖ $” —* Ò`8”@ Ô" <À'¿èРDÒ ØÒ'¿ÜРDÒ¿èÐ $€¢@€€FпÜÒ¿ÜÐ Ò`$@‘,Ò DÒa<@‘+Ð'¿äРDà Ð¿à’  Ò¿ä@‘’•*`ÖРD’ ŸÂÀÐ'¿Øп䒑*`Ò¿Ø@Ð'¿ØпìÒ¿è” “* Ô 8@ Ò¿ØÒ"Ð¿à’  Ò¿ä@‘’‘*`Ò¿Ø@Ð'¿ØпìÒ¿è” “* Ô <@ Ò¿ØÒ"Ð¿è’ Ò'¿èпܒ TÒ'¿Ü¿ÿ¶Çàèã¿hð' DРDÒ!¨Ò'¿ìРDÒ!<Ò'¿ÜÀ'¿èРDÒ ØÒ'¿ØРDÒ¿èÐ $€¢@€€¨Ð¿ØÒ¿ØÐ Ò`$@ÒÒ DÒa<@ÑÐ'¿àпìÒ¿è” “* Ô 8@ ÒÒ'¿ÐпìÒ¿è” “* Ô <@ ÒÒ'¿ÌпìÒ¿è” “*  Ò Ò'¿ÔÀ'¿äпܒ  Ò¿à@¯Ò¿ä€¢@€€Ð¿ä’‘*`Ò¿Ð Ò¿ä” “* Ô¿Ì’@ Ô¿ä– •*àÖ¿Ô”€ Ö€Ö"@Ö"Ð¿ä’ Ò'¿ä¿ÿßÀ'¿äÐ¿à’‘*`ҿ䀢@€€7пܒ?þ Ò¿à@Ò¿ä ’‘*`Ò¿Ì  пàÒ¿Ü@wÒ¿ä ’‘*`Ò¿Ô ÒÒ$пàÒ¿Ü@kÒ¿ä ’‘*`Ò¿Ì  пܒ?þ Ò¿à@_Ò¿ä ’‘*`Ò¿Ô ÒÒ$Ð¿ä’ Ò'¿ä¿ÿÄÀ'¿äпäÒ¿à€¢ €€Ð¿äÒ¿à" ’‘*`Ò¿Ð Ò¿ÐÔ@Ô"Ð¿ä’ Ò'¿ä¿ÿìÐ¿è’ Ò'¿èпؒ TÒ'¿Ø¿ÿTÇàèã¿pð' DРDÒ!¨Ò'¿ìРDÒ!<Ò'¿ÜÀ'¿èРDÒ ØÒ'¿ØРDÒ¿èÐ $€¢@€€‚пØÒ¿ØÐ Ò`$@Ò DÒa<@Ð'¿àпìÒ¿è” “* Ô 8@ ÒÒ'¿ÔпìÒ¿è” “* Ô <@ ÒÒ'¿ÐÀ'¿äпäÒ¿à€¢ €€WпäÒ¿à" ’‘*`Ò¿Ô  пܒ  Ò¿à@ìÒ¿ä ’‘*`Ò¿Ô ÒÒ$пäÒ¿à" ’‘*`ҿР пܒ  Ò¿à@×Ò¿ä ’‘*`Ò¿Ð ÒÒ$пܒ  Ò¿à@ÉÒ¿ä ’‘*`Ò¿Ô Ò¿ä” “* Ô¿Ô’@ Ô@Ô"пܒ  Ò¿à@¶Ò¿ä ’‘*`Ò¿Ð Ò¿ä” “* Ô¿Ð’@ Ô@Ô"Ð¿ä’ Ò'¿ä¿ÿ¦Ð¿è’ Ò'¿èпؒ TÒ'¿Ø¿ÿzÇàèã¿pð' DРDÒ!¨Ò'¿ìÀ'¿èРDÒ ØÒ'¿ÔРDÒ¿èÐ $€¢@€€[пÔÒ¿ÔÐ Ò`$@ƒÐ'¿ÜÒ DпÜÒa<@€Ð'¿àпÔÒ , Ò¿Ü@‹Ð'¿Øп؀¢ €Ð¿ÜÐ'¿Øп耢 € à¿ìпؒ?ÿ Ò¿à@g’ Ò$ HпìÒ¿ìÔ`@– “*àÔ¿è– •*à Ò 8€ ÒÒ'¿ÐÀ'¿äÐ¿à’‘*`ҿ䀢@€€Ð¿ØÒ¿ä ’‘*`Ò¿Ð Ò¿Ø” “* Ô¿Ð’@ ÔüÔ"Ð¿ä’ Ò'¿ä¿ÿæÐ¿è’ Ò'¿èпԒ TÒ'¿Ô¿ÿ¡Çàè㿈ð' Dò' HРDÒ!¨Ò'¿ìРH€¢ €€¢ €#€'РDÒ!ÄÐ`€¢ €Ð¿ì’¡xÒ" РDÿþ(пìÀ" @пìÀ" DпìÀ" L€Ð¿ì’ ŒÒ" пìÀ" 0пìÀ" 4€Ð¿ì’ @Ò" €Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Çàèã¿€ð' Dò' Hô' Lö' PРDÒ!¨Ò'¿ìпìÒ 0€¢`€Ò DÐa¬Ô¿ì’ Ô РDŸÂ€€¢ €€!Ð¿ì’ Ò" 0РDÒ!<Ò'¿èÒ DÐa°Ô¿ì’ Ö¿ì”à4Ö PÖ# \Ä Ð DÖ¿èØ HÚ LŸÀ€Ð¿ìÒ 4п耢@ €Ð¿ìÀ" 0пìÀ" 4Çàèã¿€ð' Dò' Hô' Lö' PРDÒ!¨Ò'¿ìпìÒ 0€¢`€Ò DÐa¬Ò¿ìÔ¿ìÖ @” —* ’@ Ô Ð DÒ`8ŸÂ€€¢ €€“Ð¿ì’ Ò" 0Ò¿ìпìÒ¿ìÔ`L’ Ò" LÒ¿ìÐ`D€¢ €K€¢ €€¢ €1€}€¢ €€xÒ DÐa°Ò¿ìÔ¿ìÖ @” —* ’@ Ö¿ì”à4Ö¿ìØ PØ# \Ä Ð DÒ`8ÖàHØ HÚ LŸÀ€Ð¿ìÒ¿ìÐ 4Ò`H€¢ €€ZпìÀ" DРLÒРP€¢@ €€PпìÀ" 4пìÒ DÔa<’¿ÿÒ" HпìÒ DÐ LÒa@€¢ €Ð Dÿþ¦Ð¿ì’ Ò" DÒ DÐa°Ò¿ìÔ¿ìÖ @” —* ’@ Ö¿ì”à4Ö¿ìØ PØ# \Ä Ð DÒ`8ÖàHØ HÚ LŸÀ€Ð¿ìÒ¿ìÐ 4Ò`H€¢ €€Ð¿ìÒ L€¢`€Ð DÿýçпìÒ¿ìÔ`@’ Ò" @пìÀ" 0пìÒ DÔa<’ Ò" 4пìÒ DÔa<’ Ò" HÐ¿ì’ Ò" DÇàè㿈ð' Dò' Hô' Lö' PÒ DÐa°Ò PÒ# \Ä Ð D’ ” – Ø HÚ LŸÀ€Çàèã¿xð' Dò' HРDÒ Ö@РD’ ” PŸÂÀÐ'¿ìРDÒ¿ìÒ"!¨Ð¿ìŽ’£„Ò"РH€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ!ÄÐ`€¢ €Ð DÒ!<€¢`€ РDÒ /Ð"`РDÒÔ@РDŸÂ€Ð DÿüXРDÒ!<`Ð'¿à€Ð DÒ!<Ò'¿àÀ'¿èРDÒ ØÒ'¿ÜРDÒ¿èÐ $€¢@€€/пÜÒ¿ÜÐ Ò`$@–Ò DÒa<@•Ð'¿äРDà пÜÒ¿ÜÐ Ò`$@‰¢Ð¿äÒ¿à@„–Ø Ð D’ ”ŸÃÒ¿ìÔ¿è– •*à’@ Ð"`Ð¿è’ Ò'¿èпܒ TÒ'¿Ü¿ÿÍÇàè㿈ð' DРDÒ!¬Ò'¿ìРDÒ!H€¢`€Ð¿ì’ Ò" €Ð DÒ DÔa@’¿ÿÐ ”€¢ € пìÒ DÔaLÒ  Ò" €Ð¿ìÒ DÔaLÒ HÒ" пìÀ" пìÀ" Çàèã¿ð' DРDÀ" ”РDÿÿÒÇàè㿈ð' DРDÒ!¬Ò'¿ìпìÒ €¢`€Ð DÒ P€¢`€Ð D@Þ€¢ €Ð¿ì”’¡ÜÒ" €Ð¿ì’’£œÒ" РDÀ" œÇàèã¿Pð' Dò' HРDÒ!¬Ò'¿ìРDÒ!\ÿÐ'¿äРDÒ!@ÿÐ'¿àпìÒ Ò'¿ÌпìÒ¿ÌÐ €¢@€€ÏпìÒ Ò'¿èпèҿ䀢 €€¾Ð¿ìÒ DÔad’ •*`Ð ’ @6KÒ DÐa¼Ô¿ì’  Ô Ð DŸÂ€€¢ € пìÒ¿ÌÒ" пìÒ¿èÒ" ° €ÉÀ'¿ÜÀ'¿ØРDÒ¿ØÐ!H€¢@€€’РDÒ¿Ø” “*  Ò!LÒ'¿¸Ð¿¸Ò 0€¢`€ п¸Ò¿ÜÐ <’@Ò'¿Ü€zÒ DÐaÀÒ¿¸Ô`’ •*` Ò Ò'¿´Ð¿èҿ䀢 €Ò¿¸Ð`4€Ò¿¸Ð`DÐ'¿Èп¸Ò  “* РH @Ò¿¸Ð¿ÌÒ`$@Œ›’‘*`Ò@Ð'¿ÄÒ¿¸Ð¿èÒ`@@Œ‘Ð'¿ÀÀ'¿Ðп¸Ò¿ÐÐ 8€¢@€€FРDÒ ”Ð¿à€¢@ € пÌÒ¿Ð Ò¿¸Ô`H€¢ €€%пÀÐ'¿¼À'¿ÔпÔÒ¿È€¢ €€Ð¿ìÒ¿ÜÔ¿Ô’@ ” “* ” Ú¿´Ð DÒ¿¸Ô  Ö¿ÄØ¿¼ŸÃ@п¸Ò¿¼Ð $’@Ò'¿¼Ð¿Ô’ Ò'¿Ô¿ÿâп¸Ò¿ÜÐ 4’@Ò'¿Üп¸Ò $ “* пĒ Ò'¿ÄпВ Ò'¿Ð¿ÿ¶Ð¿Ø’ Ò'¿Ø¿ÿjÐ¿è’ Ò'¿è¿ÿ?пìÀ" п̒ Ò'¿Ì¿ÿ-Ò DРDÒ DÔ`œ’ Ò" œÒ DРDÒ DÖ`””à’ Ò" ”РDÔ!@€¢@ €Ð Dÿþ²° € РDÒ!´Ô` РDŸÂ€° €Çàèã¿ð' D° €Çàèã¿Xð' DРDÒ!¬Ò'¿ìÀ'¿àРDÒ¿àÐ!H€¢@€€*РDÒ¿à” “*  Ò!LÒ'¿¸Ð Dà пìÒ¿¸Ô`’ •*`¢ РDÒ¿¸Ð ”Ò` @‹å”Ö¿¸Ú РDÒ`HÖà ˜ ŸÃ@Ò¿à” “* ”¿ÀÐ"€ Ð¿à’ Ò'¿à¿ÿÒпìÒ Ò'¿ÔпìÒ¿ÔÐ €¢@€€ƒÐ¿ìÒ Ò'¿èРDÒ¿èÐ!\€¢@ €€qÀ'¿äÀ'¿àРDÒ¿àÐ!H€¢@€€NРDÒ¿à” “*  Ò!LÒ'¿¸Ò¿¸Ð¿èÒ`4@‹¥Ð'¿ÐÀ'¿Øп¸Ò¿ØÐ 8€¢@€€3Ð¿à’‘*`’¿ÀÔ¿ØÖ¿Ô”€ – •*àÒ@€ ҿД “* Ð’ Ò'¿¼À'¿Üп¸Ò¿ÜÐ 4€¢@€€Ô¿ì¿äÒ– ›*à˜€ ”¿¼Ö€Ö# –à€Ö"€’`Ò"пܒ Ò'¿Ü¿ÿèпؒ Ò'¿Ø¿ÿÉÐ¿à’ Ò'¿à¿ÿ®Ò DÐa¼Ô¿ì’  Ô Ð DŸÂ€€¢ € пìÒ¿ÔÒ" пìÒ¿èÒ" ° €)Ð¿è’ Ò'¿è¿ÿ‹Ð¿ìÀ" пԒ Ò'¿Ô¿ÿyÒ DРDÒ DÖ`””à’ Ò" ”РDÔ!@€¢@ €Ð DÿýË° € РDÒ!´Ô` РDŸÂ€° €Çàèã¿`ð' Dò' HРDÒ!¬Ò'¿ìРDÒ!@ÿÐ'¿èРDÒ DÐ Ò`˜€¢ €Ð DÒ DÐ Ò`˜€¢ € РDÒ DÐ ”Ò`œ€¢ €€€Ð DÒ!´Ô@РDŸÂ€€¢ €° €¬¿ÿÛÀ'¿àРDÒ ØÒ'¿ÄРDÒ¿àÐ $€¢@€€‹Ð¿ÄÒ 0€¢`€€|РDà пìÒ¿à” “* ¢ РDÒ¿ÄÐ œÒ` @ŠÖ”Ö¿ÄÚ Ð DÒ`HÖà ˜ ŸÃ@Ð'¿ÔРDÒ œÐ¿è€¢@€Ð¿ÄÒ Ò'¿Ø€Ð¿ÄÒ¿ÄÔ  Ò` @ŠÏÐ'¿Øп؀¢ €Ð¿ÄÒ Ò'¿ØÒ DÐaÀÒ¿à” “*  Ò Ò'¿ÀÐ¿à’‘*`Ò H ÒÒ'¿ÌÀ'¿ÜпÜÒ¿Ø€¢ €€4пܒ‘*`Ò¿Ô ÒÒ'¿ÐÀ'¿ÈÀ'¿äпÄÒ¿äÐ €¢@ €€Ú¿ÀРDÒ¿ÄÔ¿ÐÖ¿ÌØ¿ÈŸÃ@пВ €Ò'¿ÐпÄÒ¿ÈÐ $’@Ò'¿ÈÐ¿ä’ Ò'¿ä¿ÿåпÄÒ $ “* п̒ Ò'¿Ìпܒ Ò'¿Ü¿ÿÉÐ¿à’ Ò'¿àпĒ TÒ'¿Ä¿ÿqÒ DРDÒ DÖ`œ”à’ Ò" œÐ DÔ!@€¢@ €° €° €Çàèã¿pð' DРDÒ!¬Ò'¿ìÀ'¿èРDÒ Ü€¢`€ РDÒ  €¢`€€° € Ð¿ìÒ p€¢`€Ò DÐ`Ô DÒ $” —* –À •*àÖРD’ ŸÂÀÒ¿ìÐ"`pпìÒ pÒ'¿ÐÀ'¿äРDÒ ØÒ'¿ÜРDÒ¿äÐ $€¢@€€yпÜÒ LÒ'¿Ø€¢`€° €tпØÒ•*`‘2 €¢ €'пØÒ •*`‘2 €¢ € пØÒ •*`‘2 €¢ €Ð¿ØÒ •*`‘2 €¢ €Ð¿ØÒ •*`‘2 €¢ € пØÒ •*`‘2 €¢ €€° €EРDÒ¿ä” “* Ð  ’ Ò'¿ÔпÔÒ€¢`€° €6 Ð'¿àÐ¿à€¢ €€Ð¿à’‘*`Ò¿Ð Ò¿à” “* Ô¿Ô’@ Ô@Ô"Ð¿à’‘*`Ò¿Ô Ò€¢`€ Ð'¿èÐ¿à’ Ò'¿à¿ÿàпВ Ò'¿ÐÐ¿ä’ Ò'¿äпܒ TÒ'¿Ü¿ÿƒÐ¿è°€Çàèã¾pð' Dò' HРDÒ!¬Ò'¿ìРDÒ!@ÿÐ'¿èРDÒ DÐ Ò`˜€¢ € РDÒ!´Ð`€¢ €€€(РDÒ DÐ Ò`˜€¢ €Ð DÒ!”`€  `?ÿÐ'¾ÔРDÒ DÔ`œÖ¾Ô’€ Ð ”€¢ €€Ð DÒ!´Ô@РDŸÂ€€¢ €° €5¿ÿËÀ'¿ÜРDÒ ØÒ'¿´Ð DÒ¿ÜÐ $€¢@€€Ð¿´Ò 0€¢`€€Ð DÒ œÐ¿è€¢@€ п´Ò Ò'¿ÔпԒ‘*`Ð'¿ÐÀ'¿¨€Ð¿´Ò¿´Ô  Ò` @‰AÐ'¿ÔпԀ¢ €Ð¿´Ò Ò'¿ÔпÔÐ'¿Ð Ð'¿¨Ð DÒ œ€¢`€(п´Ò¿ÐÐ ’@Ò'¿ÐРDà пìÒ¿Ü” “* ¢ РDÒ œÿÒ¿´Ò` @‰”Ú Ð DÒ`HֿИ ŸÃ@Ð'¿Ìп´Ò  “* п̒ Ò'¿ÌÀ'¿¬€Ò DÐ`Ò¿ìÔ¿Ü– •*à’@ Ú Ð DÒ`H” ֿИ ŸÃ@Ð'¿Ì Ð'¿¬Ð¿ìÒ¿Ü– •*à”€ “* Ð p’ Ò'¿$п´Ò LÒ'¿ п Ò•*`‘2 Ð'¿Ð¿ Ò •*`‘2 Ð'¿Ð¿ Ò •*`‘2 Ð'¿Ð¿ Ò •*`‘2 Ð'¿Ð¿ Ò •*`‘2 Ð'¿ п Ò •*`‘2 Ð'¿Ò DÐaÀÒ¿Ü” “*  Ò Ò'¿°Ð¿Ü’‘*`Ò H ÒÒ'¿¼À'¿ØпØÒ¿Ô€¢ €€dпؒ‘*`Ò¿Ì ÒÒ'¿È﬈¢ € п؀¢ €Ð¿ÈÐ'¿Ä€ пؒ‘*`Ò¿Ì Ò?üÒ'¿Äп¨€¢ € Ò¿ÔÿÒ¿Ø€¢@€Ð¿ÈÐ'¿À€ пؒ‘*`Ò¿Ì Ò Ò'¿ÀпÄÒ•*`‘: ’Ò'¾ø Ð'¾üÐ'¿Ð¿ÈÒ•*`‘: ’Ò'¾ì Ð'¾ðÐ'¾ôпÀÒ•*`‘: ’Ò'¾à Ð'¾äÐ'¾èÀ'¿¸Ð¿´Ò ÿÐ'¿àÀ'¿äпäÒ¿à€¢ €€’¿(пȔ @1˜Ð¿äÒ¿à€¢ € €Ò¿Ä Ò•*`‘: Ð'¾ø €Ò¿È Ò•*`‘: Ð'¾ì €Ò¿À Ò•*`‘: Ð'¾à Ò¿$ ÒÒ'¾Ü€¢`€Qп*“* ‘:`€¢ €KоôÒ¾ì" ”“* ’@•*`п’ @ˆÐ'¿Ð¿€¢ €Ò¿‘*`Ò¿ Ô¿“* @ˆ Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿‘*`Ò¿" Ô¿“* @‡îÐ'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿* Ò¿$ ÒÒ'¾Ü€¢`€Qп8“* ‘:`€¢ €KоüÒ¾ä" ”“* ’@•*`п’ @‡¼Ð'¿Ð¿€¢ €Ò¿‘*`Ò¿ Ô¿“* @‡²Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿‘*`Ò¿" Ô¿“* @‡—Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿8 Ò¿$ ÒÒ'¾Ü€¢`€SпH“* ‘:`€¢ €MоüÒ¾ä Ҿ𔠓* " ”“* ’@п@‡cÐ'¿Ð¿€¢ €Ò¿‘*`Ò¿ Ô¿“* @‡YÐ'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿‘*`Ò¿" Ô¿“* @‡>Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿H Ò¿$ ÒÒ'¾Ü€¢`€Sп:“* ‘:`€¢ €MпҾø" Ò¾è" Ò¾à ”“* ’@п@‡ Ð'¿Ð¿€¢ €Ò¿ ‘*`Ò¿ Ô¿ “* @‡Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿ ‘*`Ò¿" Ô¿ “* @†åÐ'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿: Ò¿$ ÒÒ'¾Ü€¢`€Sп,“* ‘:`€¢ €MоôÒ¾ì Ҿ𔠓* " ”“* ’@п@†±Ð'¿Ð¿€¢ €Ò¿‘*`Ò¿ Ô¿“* @†§Ð'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Ø€Ò¿‘*`Ò¿" Ô¿“* @†ŒÐ'¾Øо܀¢ € Ҿܑ* Ҿ؀¢@€ Ҿܑ* ’?ÿÒ'¾Øоؒ Ò'¾ØоÚÐ7¿,”¿(Ú¿°Ð DÒ¿´Ö¿¼Ø¿¸ŸÃ@оüÐ'¿Ð¾øÐ'¾üоðÐ'¾ôоìÐ'¾ðоäÐ'¾èоàÐ'¾äпȒ €Ò'¿ÈпĒ €Ò'¿ÄпÀ’ €Ò'¿Àп´Ò¿¸Ð $’@Ò'¿¸Ð¿ä’ Ò'¿ä¿ýüп´Ò $ “* п¼’ Ò'¿¼Ð¿Ø’ Ò'¿Ø¿ý™Ð¿Ü’ Ò'¿Üп´’ TÒ'¿´¿üèÒ DРDÒ DÖ`œ”à’ Ò" œÐ DÔ!@€¢@ €° €° €Çàèã¿€ð' Dò' HРDÒ Ö@РD’ ” tŸÂÀÐ'¿ìРDÒ¿ìÒ"!¬Ð¿ì’£,Ò"п쒣PÒ" пìÀ" pРH€¢ €OÀ'¿èРDÒ ØÒ'¿àРDÒ¿èÐ $€¢@€€5пàÒ Ò'¿äРDÒ Ü€¢`€Ð¿ä’•*`€Ð'¿äРDà пàÒ¿àÐ Ò`@.÷¢Ð¿àÒ¿àÐ Ò` @.ð˜Ä РD’ ” –Ú¿äŸÀ€Ò¿ìÔ¿è– •*à’@ Ð"`HÐ¿è’ Ò'¿èÐ¿à’ TÒ'¿à¿ÿÇп쒒 Ò" п쒒£œÒ" пìÒ¿ì”`HÔ" €,РDÒ Ö`РD’ ”%ŸÂÀÐ'¿àÀ'¿äп䀢 €€Ð¿ìÒ¿ä” “*  Ò¿ä” “* Ô¿à’€ Ò" Ð¿ä’ Ò'¿ä¿ÿìп쒒 Ò" п쒣ÜÒ" пìÀ" Çàè㿈ð' Dò' HРDÒ!°Ò'¿ìРH€¢ €I€¢ €€¢ € €V€¢ €)€QРDÒ T€¢`€Ð¿ì˜’£äÒ" пìÒ €¢`€Ò DÐ`Ò¿ìÖ¿ìÚ Ð DÒ`” Öà˜ ŸÃ@Ò¿ìÐ"` €Ð¿ìÒ DÔaÄÒ Ò" €8пìÒ €¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ì™’ ÜÒ" €#пìÒ €¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ì™’¢dÒ" €Ð DÒ Ð"`РDÒÔ@РDŸÂ€€Ð¿ìÒ¿ìÀ"`À" Çàèã¿xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!°Ò'¿ìРXÒ \Ð’"@Ò'¿äпìÒ¿äÐ €¢@€Ð¿ìÒ Ò'¿äÀ'¿èÒ DÐaÄØ¿ìš¿èÒ¿äÒ# \Ä Ð DÒ HÔ LÖ PØ ŸÀ€Ò DÐaÌÒ¿ìÔ XÖ€” —* Ø T”À Ø Ð DÒ` Ö¿èŸÃРXÒ XÔ@ҿ蔀 Ô"Çàèã¿xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!°Ò'¿ìпìÒ €¢`€Ò DÐ`Ò¿ìÔ¿ìÖ¿ìÚ Ð DÒ`Ô Öà˜ ŸÃ@Ò¿ìÐ"` пìÒ Ò'¿èÒ DÐaÄØ¿ìÒ¿ìš`Ò¿ìÔ`Ô# \Ä Ð DÒ HÔ LÖ PØ ŸÀ€Ð¿ìÒ Ð¿è€¢@€Ð¿ìÒ Ð¿è’"@Ò'¿äÒ DÐaÌÒ¿ìÔ¿è– •*àÖ` ’€ Ø Ð D” Ö¿äŸÃРXÒ XÔ@ҿ䔀 Ô"пìÒ¿ìÐ Ò`€¢ € пìÒ¿ìÔ¿ìÒ`Ô ’@ Ò" пìÀ" Çàèã¿€ð' Dò' Hô' Lö' Pø' Tú' XРDÒ!°Ò'¿ìпìÒ €¢`€Ò DÐ`Ò¿ìÔ¿ìÖ¿ìÚ Ð DÒ`Ô Öà˜ ŸÃ@Ò¿ìÐ"` пìÒ¿ìÐ Ò`" Ð'¿èРXÒ \Ð’"@Ò'¿äпèҿ䀢 €Ð¿äÐ'¿èРDÒ¿ìÐ tÒ`" Ð'¿äпèҿ䀢 €Ð¿äÐ'¿èÒ DÐaÌÒ¿ìÔ¿ìÖ ” —* Ô` ’À Ô XÖ€” —* Ø T”À Ø Ð DÖ¿èŸÃРXÒ XÔ@ҿ蔀 Ô"пìÒ¿ìÔ`ҿ蔀 Ô" пìÒ¿ìÐ Ò`€¢ € пìÒ¿ìÔ¿ìÒ`Ô ’@ Ò" пìÀ" Çàè㿈ð' Dò' HРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!°Ð¿ì˜’¢Ò"пìÀ" пìÀ" РDÒ T€¢`€9пìÒ DÔa8Ô" РH€¢ €Ð Dà РDÒ DÐ pÒ`x@ƒÛ¢Ð DÒ¿ìÐ tÒ`@,å˜Ú¿ìÄ Ð D’ ” –Ú`ŸÀ€Ò¿ìÐ"`€Ð Dà РDÒ DÐ pÒ`x@ƒ¾”Ö¿ìØ Ð D’ ÖàŸÃÒ¿ìÐ"` Çàèã¿hð' DРDÒ!ÀÒ'¿ìÀ'¿ÜÀ'¿ØÀ'¿èРDÒ ØÒ'¿àРDÒ¿èÐ $€¢@€€CÒ¿àÐ`$€¢ €€¢ €€¢ € €K€¢ €€¢ €€CªaÐ'¿ØÀ'¿Ü€N¨c Ð'¿ØÀ'¿Ü€H¦`hÐ'¿ØÀ'¿Ü€BÒ DÐ`H€¢ €€¢  €€¢ €€¢`Ð'¿ØÀ'¿Ü€›cÈÐ'¿Ø Ð'¿Ü€Ÿ`ÀÐ'¿Ø Ð'¿Ü€Ð DÒ 0Ð"`РDÒÔ@РDŸÂ€€€Ð DÒ Ð"`Ò DÐ@Ò¿àÔ`$Ô" РDÒÔ@РDŸÂ€€Ð¿ìÒ¿è” “*  Ò¿ØÒ" пàÒ 0€¢`€Ð¿ìÒ¿è” “*  Ò ,п܀¢@€€€ºÐ¿àÒ LÒ'¿ÔпԀ¢ €€±Ð¿ìÒ¿è” “*  Ò¿ÜÒ" ,п܀¢ €-€¢ €€¢ € €’€¢ €M€Ð¿àÒ PÒ'¿ÐÀ'¿äп䀢 ?€€Ð¿ä’‘*`Ò¿Ð Ò¿ÔÔ¿ä– •*àÒ@ •*`“2 Ò"Ð¿ä’ Ò'¿ä¿ÿê€{пàÒ PÒ'¿ÐÀ'¿äп䀢 ?€€!п䒑*`ҿР пÔÒ¿ä” “* Ð “* ‘2`×Ô¿ä– •*à–b°’€ Ô@—* “:à@‚¾’(‘:` Ð$Ð¿ä’ Ò'¿ä¿ÿÝ€PпàÒ PÒ'¿ÐÀ'¿äÀ'¿Ìп̀¢ €€7À'¿ÈпȀ¢ €€+п䒑*`Ò¿Ð Ò¿ÔÔ¿ä– •*àÒ@ •*`“2 Ò'¿ðÍ¿ð… ×Ô¿Ì– •*à–c0’€ É@… ‰D×Ô¿È– •*à–c0’€ É@… ‰D‰ ÂÉ"Ð¿ä’ Ò'¿äпȒ Ò'¿È¿ÿÓп̒ Ò'¿Ì¿ÿǀРDÒ 0Ð"`РDÒÔ@РDŸÂ€€Ð¿è’ Ò'¿èÐ¿à’ TÒ'¿à¿þ¹Çàèã¿€ð' DРDÒ Ö@РD’ ” TŸÂÀÐ'¿ìРDÒ¿ìÒ"!Àп욒¡tÒ"À'¿èРDÒ ØÒ'¿äРDÒ¿èÐ $€¢@€€!РDÒ Ö@РD’ ”!ŸÂÀÒ¿äÐ"`PÒ¿äÐ`P’ ”!@‚4пìÒ¿è” “*  ’?ÿÒ" ,Ð¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÛÇàèã¾(ð' Dò' Hô' Lö' Pø' TРDÒ!D`€Ð'¿˜Ð LÐ'¿¨Ð HÒ PÒ'¿¤¾Ð'¿  Ð'¿”¢ €€  Ò¿¨ Ò•*`‘: €¢ €r Ò¿¨ Ò•*`‘: €¢ €i 0Ò¿¨ Ò•*`‘: €¢ €` @Ò¿¨ Ò•*`‘: €¢ €W PÒ¿¨ Ò•*`‘: €¢ €N `Ò¿¨ Ò•*`‘: €¢ €E pÒ¿¨ Ò•*`‘: €¢ €<п¨Ò•*`‘: Ò¿¤Ò@@½Ð'¾ŒÐ¿ Ò¾ŒÒ" Ò¿  Ò¾ŒÒ" @Ò¿  Ò¾ŒÒ" `Ò¿  Ò¾ŒÒ" €Ò¿  Ò¾ŒÒ"  Ò¿  Ò¾ŒÒ" ÀÒ¿  Ò¾ŒÒ" àÒ¿  Ò¾ŒÒ"п¨’ Ò'¿¨Ð¿¤’ Ò'¿¤Ð¿ ’ Ò'¿ €"п¨Ò•*`‘: Ò¿¤Ò@@ƒÐ'¿ì Ò¿¨ Ò•*`‘: ’ @Ô¿¤’@ Ò@@vÐ'¿è @Ò¿¨ Ò•*`‘: ’ €Ô¿¤’@ Ò@@iÐ'¿ä `Ò¿¨ Ò•*`‘: ’ ÀÔ¿¤’@ Ò@@\Ð'¿àпìÒ¿ä Ð'¿ÌпìÒ¿ä" Ð'¿ÈпèÒ¿à Ð'¿ÀпèÒ¿à" ’•*`”€“* ’"@ •*`”€‘* “: пÀ’"@Ò'¿ÄпÌÒ¿À Ð'¿ìпÌÒ¿À" Ð'¿àпÈÒ¿Ä Ð'¿èпÈÒ¿Ä" Ð'¿ä Ò¿¨ Ò•*`‘: ’ Ô¿¤’@ Ò@@$Ð'¿Ü 0Ò¿¨ Ò•*`‘: ’ `Ô¿¤’@ Ò@@Ð'¿Ø PÒ¿¨ Ò•*`‘: ’  Ô¿¤’@ Ò@@ Ð'¿Ô pÒ¿¨ Ò•*`‘: ’ àÔ¿¤’@ Ò@@€ýÐ'¿ÐпÔÒ¿Ø Ð'¿¬Ð¿ÔÒ¿Ø" Ð'¿¸Ð¿ÜÒ¿Ð Ð'¿´Ð¿ÜÒ¿Ð" Ð'¿°Ð¿´Ò¿¬ Ð'¿Ðп´Ò¿¬" ’•*`”€“* ’"@ •*`”€‘* “: Ò'¿Èп¸Ò¿° ”“* ’"@•*`”"€“* ’@‘:`Ð'¿¼Ð¿°”“* ’@•*`”€“* ’@‘:`Ò¿¼" Ð'¿Ìп¸”“* ’"@•*`”"€‘* " ’ ‘:`Ò¿¼ Ð'¿ÄпÄÒ¿Ð" Ð'¿ÔпÈÒ¿Ô" Ð'¿ØпÌÒ¿Ø Ð'¿Üп Ò¿ìÔ¿Ð’@ Ò" àÒ¿  Ò¿ìÔ¿Ð’"@ Ò" Ò¿  Ò¿èÔ¿Ô’@ Ò" ÀÒ¿  Ò¿èÔ¿Ô’"@ Ò" @Ò¿  Ò¿äÔ¿Ø’@ Ò"  Ò¿  Ò¿äÔ¿Ø’"@ Ò" €Ò¿  Ò¿àÔ¿Ü’@ Ò" `Ò¿  Ò¿àÔ¿Ü’"@ Ò"п¨’ Ò'¿¨Ð¿¤’ Ò'¿¤Ð¿ ’ Ò'¿ Ð¿”’?ÿÒ'¿”¿þ^¾Ð'¿ À'¿”¢ €€~п”’‘*`Ò P ÒРT’@Ò'¿œ Ò¿  Ò€¢`€_ Ò¿  Ò€¢`€X Ò¿  Ò€¢`€Q Ò¿  Ò€¢`€J Ò¿  Ò€¢`€C Ò¿  Ò€¢`€< Ò¿  Ò€¢`€5п Ò‘:`’ #ÿÔ¿˜@ Ò Ò/¾‹Ð¿œÒ¾‹Ò* Ò¿œ Ò¾‹Ò* Ò¿œ Ò¾‹Ò* Ò¿œ Ò¾‹Ò* Ò¿œ Ò¾‹Ò* Ò¿œ Ò¾‹Ò* Ò¿œ Ò¾‹Ò* Ò¿œ Ò¾‹Ò*п ’ Ò'¿ € п ’ Ô¿ ’@ ÐÒ@ Ð'¿Ìп ’ Ô¿ ’@ ÐÒ@" Ð'¿È Ò¿  ’ Ô¿ ’@ ÐÒ@ Ð'¿À Ò¿  ’ Ô¿ ’@ ÐÒ@" ’•*`”€“* ’"@ •*`”€‘* “: пÀ’"@Ò'¿ÄпÌÒ¿À Ð'¿ìпÌÒ¿À" Ð'¿àпÈÒ¿Ä Ð'¿èпÈÒ¿Ä" Ð'¿ä Ò¿  ’ Ô¿ ’@ ÐÒ@ Ð'¿¬ Ò¿  ’ Ô¿ ’@ ÐÒ@" Ð'¿¸ Ò¿  ’ Ô¿ ’@ ÐÒ@ Ð'¿´ Ò¿  ’ Ô¿ ’@ ÐÒ@" Ð'¿°Ð¿´Ò¿¬ Ð'¿Ðп´Ò¿¬" ’•*`”€“* ’"@ •*`”€‘* “: Ò'¿Èп¸Ò¿° ”“* ’"@•*`”"€“* ’@‘:`Ð'¿¼Ð¿°”“* ’@•*`”€“* ’@‘:`Ò¿¼" Ð'¿Ìп¸”“* ’"@•*`”"€‘* " ’ ‘:`Ò¿¼ Ð'¿ÄпÄÒ¿Ð" Ð'¿ÔпÈÒ¿Ô" Ð'¿ØпÌÒ¿Ø Ð'¿ÜпœÒ¿ìÔ¿Ð’@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿ìÔ¿Ð’"@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿èÔ¿Ô’@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿èÔ¿Ô’"@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿äÔ¿Ø’@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿äÔ¿Ø’"@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿àÔ¿Ü’@ •:`’ £ÿÔ¿˜’@ Ô @Ô* Ò¿œ Ò¿àÔ¿Ü’"@ •:`’ £ÿÔ¿˜’@ Ô @Ô*п ’ Ò'¿ Ð¿”’ Ò'¿”¿þ€Çàèã¾(ð' Dò' Hô' Lö' Pø' TРDÒ!D`€Ð'¿˜Ð LÐ'¿¨Ð HÒ PÒ'¿¤¾Ð'¿  Ð'¿”¢ €€– Ò¿¨ Ò•*`‘: €¢ €t Ò¿¨ Ò•*`‘: €¢ €k 0Ò¿¨ Ò•*`‘: €¢ €b @Ò¿¨ Ò•*`‘: €¢ €Y PÒ¿¨ Ò•*`‘: €¢ €P `Ò¿¨ Ò•*`‘: €¢ €G pÒ¿¨ Ò•*`‘: €¢ €>п¨Ò•*`‘: Ð'¿ðÉ¿ð… „Ð¿¤Ç… ‰#Å'¾ŒÐ¿ Ò¾ŒÒ" Ò¿  Ò¾ŒÒ" @Ò¿  Ò¾ŒÒ" `Ò¿  Ò¾ŒÒ" €Ò¿  Ò¾ŒÒ"  Ò¿  Ò¾ŒÒ" ÀÒ¿  Ò¾ŒÒ" àÒ¿  Ò¾ŒÒ"п¨’ Ò'¿¨Ð¿¤’ Ò'¿¤Ð¿ ’ Ò'¿ €Ð¿¨Ò•*`‘: Ð'¿ðÉ¿ð… „Ð¿¤Ç… ‰#Å'¿ì Ò¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „ @Ò¿¤ Ç… ‰#Å'¿è @Ò¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „ €Ò¿¤ Ç… ‰#Å'¿ä `Ò¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „ ÀÒ¿¤ Ç… ‰#Å'¿àÅ¿ìÇ¿ä… ˆ#Å'¿ÌÅ¿ìÇ¿ä… ˆ£Å'¿ÈÅ¿èÇ¿à… ˆ#Å'¿ÀÅ¿èÇ¿à… ˆ£×Ç#p… ‰#Ç¿À… ˆ£Å'¿ÄÅ¿ÌÇ¿À… ˆ#Å'¿ìÅ¿ÌÇ¿À… ˆ£Å'¿àÅ¿ÈÇ¿Ä… ˆ#Å'¿èÅ¿ÈÇ¿Ä… ˆ£Å'¿ä Ò¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „ Ò¿¤ Ç… ‰#Å'¿Ü 0Ò¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „ `Ò¿¤ Ç… ‰#Å'¿Ø PÒ¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „  Ò¿¤ Ç… ‰#Å'¿Ô pÒ¿¨ Ò•*`‘: Ð'¿ðÉ¿ð… „ àÒ¿¤ Ç… ‰#Å'¿ÐÅ¿ÔÇ¿Ø… ˆ#Å'¿¬Å¿ÔÇ¿Ø… ˆ£Å'¿¸Å¿ÜÇ¿Ð… ˆ#Å'¿´Å¿ÜÇ¿Ð… ˆ£Å'¿°Å¿´Ç¿¬… ˆ#Å'¿ÐÅ¿´Ç¿¬… ˆ£×Ç#p… ‰#Å'¿ÈÅ¿¸Ç¿°… ˆ#×Ç#t… ‰#Å'¿¼Å¿°×Ç#x… ‰#Ç¿¼… ˆ£Å'¿ÌÅ¿¸×Ç#|… ‰#Ç¿¼… ˆ#Å'¿ÄÅ¿ÄÇ¿Ð… ˆ£Å'¿ÔÅ¿ÈÇ¿Ô… ˆ£Å'¿ØÅ¿ÌÇ¿Ø… ˆ#Å'¿Üп Å¿ìÇ¿Ð… ˆ#Å" àÒ¿  Å¿ìÇ¿Ð… ˆ£Å" Ò¿  Å¿èÇ¿Ô… ˆ#Å" ÀÒ¿  Å¿èÇ¿Ô… ˆ£Å" @Ò¿  Å¿äÇ¿Ø… ˆ#Å"  Ò¿  Å¿äÇ¿Ø… ˆ£Å" €Ò¿  Å¿àÇ¿Ü… ˆ#Å" `Ò¿  Å¿àÇ¿Ü… ˆ£Å"п¨’ Ò'¿¨Ð¿¤’ Ò'¿¤Ð¿ ’ Ò'¿ Ð¿”’?ÿÒ'¿”¿þh¾Ð'¿ À'¿”¢ €€Ð¿”’‘*`Ò P ÒРT’@Ò'¿œÐ¿ ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿Ìп ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿È Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿À Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ£×Ç#p… ‰#Ç¿À… ˆ£Å'¿ÄÅ¿ÌÇ¿À… ˆ#Å'¿ìÅ¿ÌÇ¿À… ˆ£Å'¿àÅ¿ÈÇ¿Ä… ˆ#Å'¿èÅ¿ÈÇ¿Ä… ˆ£Å'¿ä Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿¬ Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿¸ Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ#Å'¿´ Ò¿  ’ Ô¿ ’@ ÅÇ@… ˆ£Å'¿°Å¿´Ç¿¬… ˆ#Å'¿ÐÅ¿´Ç¿¬… ˆ£×Ç#p… ‰#Å'¿ÈÅ¿¸Ç¿°… ˆ#×Ç#t… ‰#Å'¿¼Å¿°×Ç#x… ‰#Ç¿¼… ˆ£Å'¿ÌÅ¿¸×Ç#|… ‰#Ç¿¼… ˆ#Å'¿ÄÅ¿ÄÇ¿Ð… ˆ£Å'¿ÔÅ¿ÈÇ¿Ô… ˆ£Å'¿ØÅ¿ÌÇ¿Ø… ˆ#Å'¿ÜпœÅ¿ìÇ¿Ð… ˆ#‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿ìÇ¿Ð… ˆ£‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿èÇ¿Ô… ˆ#‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿èÇ¿Ô… ˆ£‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿äÇ¿Ø… ˆ#‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿äÇ¿Ø… ˆ£‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿àÇ¿Ü… ˆ#‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô* Ò¿œ Å¿àÇ¿Ü… ˆ£‰ "É'¿ðÒ¿ð”`“: ” cÿÖ¿˜’€ Ô @Ô*п ’ Ò'¿ Ð¿”’ Ò'¿”¿þàÇàèã¾8ð' Dò' Hô' Lö' Pø' TРDÒ!D`€Ð'¿¨Ð LÐ'¿¸Ð HÒ PÒ'¿´¾ Ð'¿° Ð'¿¤Ð¿¤€¢ €€ Ò¿¸ Ò•*`‘: €¢ €s Ò¿¸ Ò•*`‘: €¢ €j 0Ò¿¸ Ò•*`‘: €¢ €a @Ò¿¸ Ò•*`‘: €¢ €X PÒ¿¸ Ò•*`‘: €¢ €O `Ò¿¸ Ò•*`‘: €¢ €F pÒ¿¸ Ò•*`‘: €¢ €=п¸Ò•*`‘: Ò¿´Ò@@{«“* Ò'¾œÐ¿°Ò¾œÒ" Ò¿° Ò¾œÒ" @Ò¿° Ò¾œÒ" `Ò¿° Ò¾œÒ" €Ò¿° Ò¾œÒ"  Ò¿° Ò¾œÒ" ÀÒ¿° Ò¾œÒ" àÒ¿° Ò¾œÒ"п¸’ Ò'¿¸Ð¿´’ Ò'¿´Ð¿°’ Ò'¿°€ Ò¿¸ Ò•*`‘: ’ @Ô¿´’@ Ò@@{lÐ'¿È `Ò¿¸ Ò•*`‘: ’ ÀÔ¿´’@ Ò@@{_Ð'¿ÄпÈÒ¿Ä ”“* ’@•*`”"€‘* ’" Ò'¿ÌпĔ“* ’"@•*`”"€“* ’@•*`”€ Ò¿Ì@Ð'¿äпȔ“* ’@•*`”€“* ’"@‘*`Ò¿Ì@Ð'¿àп¸Ò•*`‘: Ò¿´Ò@@{1Ð'¿È @Ò¿¸ Ò•*`‘: ’ €Ô¿´’@ Ò@@{$Ð'¿ÄпÈÒ¿Ä “* Ò'¿ìпÈÒ¿Ä" “* Ò'¿èпìÒ¿à Ð'¿ÜпìÒ¿à" Ð'¿ÐпèÒ¿ä Ð'¿ØпèÒ¿ä" Ð'¿Ô pÒ¿¸ Ò•*`‘: ’ àÔ¿´’@ Ò@@zýÐ'¿ì PÒ¿¸ Ò•*`‘: ’  Ô¿´’@ Ò@@zðÐ'¿è 0Ò¿¸ Ò•*`‘: ’ `Ô¿´’@ Ò@@zãÐ'¿ä Ò¿¸ Ò•*`‘: ’ Ô¿´’@ Ò@@zÖÐ'¿àпìÒ¿à Ð'¿ÌпèÒ¿ä Ð'¿ÈпìÒ¿ä Ð'¿ÄпèÒ¿à Ð'¿ÀпÄÒ¿À ’•*`”€“* ’"@ •*`”€“* @Ð'¿¼Ð¿ì”“* ’@•*`’@ •*`”"€‘* Ð'¿ìп蔓* ’@•*`”"€“* ’"@•*`”€“* "@Ð'¿èп䔓* ’@•*`’@ •*`”"€‘* " “* Ò'¿äÐ¿à”“* ’@•*` ’@ •*`"€Ð'¿àп̔“* ’"@•*`”€“* ’"@•*`”€“* ’"@•*`€’ Ò'¿ÌпȔ“* ’@•*`”€“* ’@•*`"€’ Ò'¿ÈпĔ“* ’"@•*`”"€“* ’@•*`€’ Ò'¿ÄпÀ”“* ’@•*`”€“* ’"@‘*`’ Ò'¿ÀпÄÒ¿¼ Ð'¿ÄпÀÒ¿¼ Ð'¿ÀпÌÒ¿Ä Ò¿ì@Ð'¿ìпÈÒ¿À Ò¿è@Ð'¿èпÈÒ¿Ä Ò¿ä@Ð'¿äпÌÒ¿À Ò¿à@Ð'¿àп°Ò¿ÜÔ¿à’@ ”d“:  Ò" àÒ¿° Ò¿ÜÔ¿à’"@ ”d“:  Ò" Ò¿° Ò¿ØÔ¿ä’@ ”d“:  Ò" ÀÒ¿° Ò¿ØÔ¿ä’"@ ”d“:  Ò" @Ò¿° Ò¿ÔÔ¿è’@ ”d“:  Ò"  Ò¿° Ò¿ÔÔ¿è’"@ ”d“:  Ò" `Ò¿° Ò¿ÐÔ¿ì’@ ”d“:  Ò" €Ò¿° Ò¿ÐÔ¿ì’"@ ”d“:  Ò"п¸’ Ò'¿¸Ð¿´’ Ò'¿´Ð¿°’ Ò'¿°Ð¿¤’?ÿÒ'¿¤¿ýï¾ Ð'¿°À'¿¤Ð¿¤€¢ €€çп¤’‘*`Ò P ÒРT’@Ò'¿¬ Ò¿° Ò€¢`€` Ò¿° Ò€¢`€Y Ò¿° Ò€¢`€R Ò¿° Ò€¢`€K Ò¿° Ò€¢`€D Ò¿° Ò€¢`€= Ò¿° Ò€¢`€6п°Ò`“:  cÿÒ¿¨ Ò Ò/¾›Ð¿¬Ò¾›Ò* Ò¿¬ Ò¾›Ò* Ò¿¬ Ò¾›Ò* Ò¿¬ Ò¾›Ò* Ò¿¬ Ò¾›Ò* Ò¿¬ Ò¾›Ò* Ò¿¬ Ò¾›Ò* Ò¿¬ Ò¾›Ò*п°’ Ò'¿°€t Ò¿° ÒÒ'¿È Ò¿° ÒÒ'¿ÄпÈÒ¿Ä ”“* ’@•*`”"€‘* ’" Ò'¿ÌпĔ“* ’"@•*`”"€“* ’@•*`”€ Ò¿Ì@Ð'¿äпȔ“* ’@•*`”€“* ’"@‘*`Ò¿Ì@Ð'¿àп°’ Ô¿°’@ ÐÒ@ “* Ò'¿ìп°’ Ô¿°’@ ÐÒ@" “* Ò'¿èпìÒ¿à Ð'¿ÜпìÒ¿à" Ð'¿ÐпèÒ¿ä Ð'¿ØпèÒ¿ä" Ð'¿Ô Ò¿° ÒÒ'¿ì Ò¿° ÒÒ'¿è Ò¿° ÒÒ'¿ä Ò¿° ÒÒ'¿àпìÒ¿à Ð'¿ÌпèÒ¿ä Ð'¿ÈпìÒ¿ä Ð'¿ÄпèÒ¿à Ð'¿ÀпÄÒ¿À ’•*`”€“* ’"@ •*`”€“* @Ð'¿¼Ð¿ì”“* ’@•*`’@ •*`”"€‘* Ð'¿ìп蔓* ’@•*`”"€“* ’"@•*`”€“* "@Ð'¿èп䔓* ’@•*`’@ •*`”"€‘* " “* Ò'¿äÐ¿à”“* ’@•*` ’@ •*`"€Ð'¿àп̔“* ’"@•*`”€“* ’"@•*`”€“* ’"@•*`€’ Ò'¿ÌпȔ“* ’@•*`”€“* ’@•*`"€’ Ò'¿ÈпĔ“* ’"@•*`”"€“* ’@•*`€’ Ò'¿ÄпÀ”“* ’@•*`”€“* ’"@‘*`’ Ò'¿ÀпÄÒ¿¼ Ð'¿ÄпÀÒ¿¼ Ð'¿ÀпÌÒ¿Ä Ò¿ì@Ð'¿ìпÈÒ¿À Ò¿è@Ð'¿èпÈÒ¿Ä Ò¿ä@Ð'¿äпÌÒ¿À Ò¿à@Ð'¿àп¬Ò¿ÜÔ¿à’@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ÜÔ¿à’"@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ØÔ¿ä’@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ØÔ¿ä’"@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ÔÔ¿è’@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ÔÔ¿è’"@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ÐÔ¿ì’@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô* Ò¿¬ Ò¿ÐÔ¿ì’"@ €’@ •:`’ £ÿÔ¿¨’@ Ô @Ô*п°’ Ò'¿°Ð¿¤’ Ò'¿¤¿þÇàèã¾Ðð' Dò' Hô' Lö' Pø' TРDÒ!D`€Ð'¿¼Ð LÐ'¿ÌРHÒ PÒ'¿È¿8Ð'¿Ä Ð'¿¸Ð¿¸€¢ €€_п¸€¢ €€K Ò¿Ì Ò•*`‘: €¢ €M Ò¿Ì Ò•*`‘: €¢ €D 0Ò¿Ì Ò•*`‘: €¢ €; PÒ¿Ì Ò•*`‘: €¢ €2 `Ò¿Ì Ò•*`‘: €¢ €) pÒ¿Ì Ò•*`‘: €¢ € пÌÒ•*`‘: Ò¿ÈÒ@@w˜“* Ò'¿4пÄÒ¿4Ò" Ò¿Ä Ò¿4Ò" @Ò¿Ä Ò¿4Ò" `Ò¿Ä Ò¿4Ò"€÷пÌÒ•*`‘: Ò¿ÈÒ@@wzÐ'¿ìпì“* Ò'¿ì Ò¿Ì Ò•*`‘: ’ @Ô¿È’@ Ò@@wjÐ'¿Ø `Ò¿Ì Ò•*`‘: ’ ÀÔ¿È’@ Ò@@w]Ð'¿ÔÒ¿Ø” ‘* " •* ”"€ —* –À ‘*à Ò¿Ô– •*à”€ —* –À •*à”"€ “* ”  Ð'¿èпìÒ¿è Ð'¿äпìÒ¿è" Ð'¿à pÒ¿Ì Ò•*`‘: ’ àÔ¿È’@ Ò@@w2Ð'¿Ü PÒ¿Ì Ò•*`‘: ’  Ô¿È’@ Ò@@w%Ð'¿Ø 0Ò¿Ì Ò•*`‘: ’ `Ô¿È’@ Ò@@wÐ'¿Ô Ò¿Ì Ò•*`‘: ’ Ô¿È’@ Ò@@w Ð'¿Ðпܔ“* ’"@•*`”"€“* ’@•*` Ò¿Ø– •*à”"€ —* –"À •*à”"€ —* –À  Ò¿Ô– •*à”€ —* –"À •*à”"€ “* ”€ ’  ҿЖ •*à”€ —* –"À •*à”€  Ð'¿ìпܔ“* ’@•*`”€“*  Ò¿Ø– •*à”€ —* –"À •*à”€ —* –"À “*à”  Ò¿Ô– •*à”"€ —* –À •*à”"€ —* –À •*à”"€ —* –À  ҿЖ •*à”€ —* –À •*à”€ —* –"À  Ð'¿èпÄÒ¿äÔ¿è’@ ”h“:  Ò" `Ò¿Ä Ò¿äÔ¿è’"@ ”h“:  Ò" Ò¿Ä Ò¿àÔ¿ì’@ ”h“:  Ò" @Ò¿Ä Ò¿àÔ¿ì’"@ ”h“:  Ò"п̒ Ò'¿ÌпȒ Ò'¿ÈпĒ Ò'¿Äп¸’?ÿÒ'¿¸¿þŸ¿8Ð'¿ÄÀ'¿¸Ð¿¸€¢ €€*п¸’‘*`Ò P ÒРT’@Ò'¿À Ò¿Ä Ò€¢`€E Ò¿Ä Ò€¢`€> Ò¿Ä Ò€¢`€7 Ò¿Ä Ò€¢`€0 Ò¿Ä Ò€¢`€) Ò¿Ä Ò€¢`€"пÄÒ`“:  cÿÒ¿¼ Ò Ò/¿3пÀÒ¿3Ò* Ò¿À Ò¿3Ò* Ò¿À Ò¿3Ò* Ò¿À Ò¿3Ò*пĒ Ò'¿Ä€ÒпÄÒ‘*`Ð'¿ì Ò¿Ä Ò” ‘* " •* ”"€ —* –À ‘*à ’ Ö¿Ä”@ Ò€– •*à”€ —* –À •*à”"€ “* ”  Ð'¿èпìÒ¿è Ð'¿äпìÒ¿è" Ð'¿à Ò¿Ä ÒÒ'¿Ü Ò¿Ä ÒÒ'¿Ø Ò¿Ä ÒÒ'¿Ô Ò¿Ä ÒÒ'¿Ðпܔ“* ’"@•*`”"€“* ’@•*` Ò¿Ø– •*à”"€ —* –"À •*à”"€ —* –À  Ò¿Ô– •*à”€ —* –"À •*à”"€ “* ”€ ’  ҿЖ •*à”€ —* –"À •*à”€  Ð'¿ìпܔ“* ’@•*`”€“*  Ò¿Ø– •*à”€ —* –"À •*à”€ —* –"À “*à”  Ò¿Ô– •*à”"€ —* –À •*à”"€ —* –À •*à”"€ —* –À  ҿЖ •*à”€ —* –À •*à”€ —* –"À  Ð'¿èпÀÒ¿äÔ¿è’@ ’@ •:`’ £ÿÔ¿¼’@ Ô @Ô* Ò¿À Ò¿äÔ¿è’"@ ’@ •:`’ £ÿÔ¿¼’@ Ô @Ô* Ò¿À Ò¿àÔ¿ì’@ ’@ •:`’ £ÿÔ¿¼’@ Ô @Ô* Ò¿À Ò¿àÔ¿ì’"@ ’@ •:`’ £ÿÔ¿¼’@ Ô @Ô*пĒ Ò'¿Äп¸’ Ò'¿¸¿þÔÇàèã¿ ð' Dò' Hô' Lö' Pø' TРDÒ!D`€Ð'¿ÐРLÐ'¿àРHÒ PÒ'¿Ü¿ˆÐ'¿Ø Ð'¿Ìп̀¢ €€áп̀¢ € п̀¢ €Ð¿Ì€¢ €€€Ã Ò¿à Ò•*`‘: €¢ €1 0Ò¿à Ò•*`‘: €¢ €( PÒ¿à Ò•*`‘: €¢ € pÒ¿à Ò•*`‘: €¢ €Ð¿àÒ•*`‘: Ò¿ÜÒ@@t÷“* Ò'¿„пØÒ¿„Ò" Ò¿Ø Ò¿„Ò"€‹Ð¿àÒ•*`‘: Ò¿ÜÒ@@tãÐ'¿äпä“* Ò'¿è pÒ¿à Ò•*`‘: ’ àÔ¿Ü’@ Ò@@tÓÐ'¿äп䔓* ’@•*`”"€“* ’@•*`”€‘* ’ Ò'¿ì PÒ¿à Ò•*`‘: ’  Ô¿Ü’@ Ò@@t¹Ð'¿äп䒕*`”"€“* ’"@•*`’@ •*`€Ò¿ì@Ð'¿ì 0Ò¿à Ò•*`‘: ’ `Ô¿Ü’@ Ò@@tŸÐ'¿äп䔓* ’@•*`”€“* ’"@•*`”"€“* ’@‘*`’ Ð¿ì’ Ò'¿ì Ò¿à Ò•*`‘: ’ Ô¿Ü’@ Ò@@tÐ'¿äп䔓* ’"@•*`”€“* ’"@‘*`Ò¿ì@Ð'¿ìпØÒ¿èÔ¿ì’@ ’@ •:` Ô" Ò¿Ø Ò¿èÔ¿ì’"@ ’@ •:` Ô"Ð¿à’ Ò'¿àпܒ Ò'¿Üпؒ Ò'¿Øп̒?ÿÒ'¿Ì¿ÿ¿ˆÐ'¿ØÀ'¿Ìп̀¢ €€ Ð¿Ì’‘*`Ò P ÒРT’@Ò'¿Ô Ò¿Ø Ò€¢`€- Ò¿Ø Ò€¢`€& Ò¿Ø Ò€¢`€ Ò¿Ø Ò€¢`€Ð¿ØÒ`“:  cÿÒ¿Ð Ò Ò/¿ƒÐ¿ÔÒ¿ƒÒ* Ò¿Ô Ò¿ƒÒ*пؒ Ò'¿Ø€`пØÒ‘*`Ð'¿è Ô¿Ø’ Ð@”“* ’@•*`”"€“* ’@•*`”€“*  ’ Ö¿Ø”@ Ò€” —* –"À •*à”"€ —* ”€ —* ’À  ’ Ö¿Ø”@ Ò€– •*à”€ —* –À •*à”"€ —* –"À •*à”€ “* ”  ’ Ö¿Ø”@ Ò€– •*à”"€ —* –À •*à”"€ “*  Ð'¿ìпÔÒ¿èÔ¿ì’@ ’@ •:`’ £ÿÔ¿Ð’@ Ô @Ô* Ò¿Ô Ò¿èÔ¿ì’"@ ’@ •:`’ £ÿÔ¿Ð’@ Ô @Ô*пؒ Ò'¿Øп̒ Ò'¿Ì¿ÿ^Çàèã¿€ð' Dò' Hô' Lö' Pø' TРDÒ!D`€Ð'¿äРHÒ PÒ'¿èРLÒ•*`‘: Ò¿èÒ@@s–Ð'¿ìÒ¿ì`“: Ò'¿ìРPÒÔ T@ Ô¿ì’ £ÿÔ¿ä’@ Ô @Ô*Çàè㿈ð' DРDÒ!ÄÒ'¿ìпìÒ DÔa8Ô" \пìÒ DÔ`tÔ" `Çàèã¿€ð' Dò' Hô' Lö' Pø' Tú' XРDÒ!ÄÒ'¿ìпìÒ DÐ \Òa8€¢ €;À'¿èРDÒ ØÒ'¿äРDÒ¿èÐ $€¢@€€-пìÒ¿è” “*   п蒑*`Ò H¢ РLÒ¿ìÔ¿è– •*à’@ ÐÒ`d@sE’‘*`Ò@” п蒑*`’ пì–@Ø 4РDÒ¿äŸÃÐ¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÏпìÀ" \РDÒ¿ìÐ!8Ò`\" Ð'¿àпìÒ¿àÐ `€¢@€Ð¿ìÒ `Ò'¿àРXÒ \Ð’"@Ò' \пàÒ \€¢ €Ð \Ð'¿àÒ DÐaÈÔ¿ì’  Ô¿ìÖ XØÀ– ™*àÚ T– Ú Ð DÔ \Ø¿àŸÃ@РXÒ XÔ@Ò¿à”€ Ô"пìÒ¿ìÔ``Ò¿à”"€ Ô" `пìÒ¿ìÔ`\Ò¿à”€ Ô" \пìÒ DÐ \Òa8€¢ €Ò LРLÒ LÔ@’ Ò"Çàèã¿ð' Dò' Hô' Lö' PРPÒ LÒ"Çàèã¿ð' Dò' Hô' Lö' PРPÀ"Çàèã¿pð' Dò' Hô' Lö' PРDÒ!ÄÒ'¿ìРPÒÒ'¿èпìÒ HÔ` Ò Œ `ÿÐ'¿àпìÒ HÔ` Ò – `ÿÐ'¿ÜÀ'¿ÔÀ'¿ØРDÒ¿ÔÐ!8€¢@€€?пؒ‘*`Ò L àпԒ‘*`Ò¿è âРDÒ p@ Ð'¿äп䀤@ €€ä   æ¿à€¤à€€ä,@¢`¦ÿÿ¿ÿø¿ÿíп܀¢ € пԖ пܘ?ÿÚ DпèÒ¿ÔÔ¿èÚ`p@šÐ¿Ø’ Ò'¿ØпÔÒ¿Ü Ð'¿Ô¿ÿ½Çàèã¿€ð' Dò' Hô' Lö' PРPÒÒ'¿ìÀ'¿äÖ DØ¿äÖá8€£ €€%Ö¿ä˜ —+ Ø L–À ÐÀÖ¿ä˜ —+ Ø¿ì–À ÒÀÖ DØàp–@ Ö'¿èֿ耢@ €€ Ô  Ô*@’`Ô*@’`¿ÿôÖ¿ä˜àØ'¿ä¿ÿ×Çàèã¿€ð' Dò' Hô' Lö' PРPÒÒ'¿ìÀ'¿àÀ'¿äРDÒ¿àÐ!8€¢@€€2п䒑*`Ò L àÐ¿à’‘*`Ò¿ì âРDÒ p@ Ð'¿èп耤@ €€ ä   ä,@¢`ä,@¢`¿ÿôÐ¿à– Ú DпìÒ¿àÔ¿ì˜ Ú`p@Ð¿ä’ Ò'¿äÐ¿à’ Ò'¿à¿ÿÊÇàè㿈ð' Dò' Hô' Lö' PРPÒÒ'¿ìÀ'¿èØ DÚ¿èØ!8€£@ €€UØ¿èš ™+`Ú L˜ ÐØ¿èš ™+`Ú¿ì˜ ÒØ ” ÿ ˜ Ø*@’`š ™+`˜ Ä š ÿ˜ š …;`˜Ø*@’`Ø HÚ (–þ€¢à€€Ø ” ÿ˜ ›+ ”€  Ú ?þ˜ `ÿš€ ˜`›; ˜ Ø*@’`Ú ˜ `ÿš€ ˜`›; ˜ Ø*@’`–ÿÿ¿ÿäØ ” ÿš ™+`˜ Ä ?ÿš ÿ˜ š …;`˜Ø*@’`˜ Ø*@’`Ø¿èš Ú'¿è¿ÿ§Çàèã¿€ð' Dò' Hô' Lö' PРPÒÒ'¿ìÀ'¿äÀ'¿èÆ DÞ¿äÆá8€£À€€”À'¿àÆ¿à€ à€€ˆÆ¿èž‡+àÞ L†ÀÐÀÆ¿à€ à€ Æ¿èž‡+àÞ L†ÀÒÿü€Æ¿èž‡+àÞ L†ÀÒà†¿äÞÀ ¢¡,`â¿ì ÔžàÞ ÀÆ –àÿ† Ÿ(à–ÀÞ @† àÿ–À’` Æ šàÿ† Ÿ(àš@Þ @† àÿš@’` † Ÿ(à†àŸ8à†Æ*€” ž ‡+à†À žÀ †àŸ8à†Æ*€” ˜ – Æ HÞà(„ÿþ€  €€#Æ šàÿ† Ÿ(àš@Þ @† àÿš@’` ž ‡+à†À žÀ †àŸ8à†Æ*€” ž ‡+à†À žÀ †àŸ8à†Æ*€” ˜ – „¿ÿ¿ÿÜž ‡+à†À žÀ †àŸ8à†Æ*€” † Ÿ(à†àŸ8à†Æ*€” Æ¿àžàÞ'¿à¿ÿvÆ¿èžàÞ'¿è¿ÿhÇàèã¿hð' DРDÒ Ö@РD’ ”  ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Äп쪒¢(Ò"п쪒¢dÒ" пìÀ" РDÒ!,€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€ Ò DÔ`L€¢ €Ò DÔa<€¢ € Ð'¿ÜÀ'¿èРDÒ ØÒ'¿äРDÒ¿èÐ $€¢@€€ùпäÒ¿äÐ Ò`$@pžÒ DÒa<@pÐ'¿ØпäÒ¿äÐ Ò`$@p“Ò DÒa<@p’Ð'¿ÔРDÒ!4Ò'¿ÐРDÒ!8Ò'¿ÌпìÒ¿è” “*  Ò¿ÔÒ" d Ð'¿àпäÒ 0€¢`€ пìÒ¿è” “*  «’ èÒ" 4À'¿à€¢Ð¿ØҿЀ¢ €Ð¿ÔÒ¿Ì€¢ € пìÒ¿è” “*  «’ ÀÒ" 4À'¿à€Ð¿Ø’‘*`ҿЀ¢ €$пÔÒ¿Ì€¢ €Ð¿Ü€¢ €Ð¿äÒ (€¢`€ пìÒ¿è” “*  ¬’ |Ò" 4€ пìÒ¿è” “*  «’¢”Ò" 4€dпؒ‘*`ҿЀ¢ €)пԒ‘*`Ò¿Ì€¢ €"п܀¢ €Ð¿äÒ (€¢`€Ð¿ìÒ¿è” “*  ¬’¢Ò" 4Ð¿ì’ Ò" € пìÒ¿è” “*  «’£lÒ" 4€6Ò¿Ð Ò¿Ø@p€¢ €$Ò¿Ì Ò¿Ô@p€¢ €Ð¿ìÒ¿è” “*  «’¡ Ò" 4пìÒ¿è  Ð¿ÐÒ¿Ø@oçÐ, ŒÐ¿ìÒ¿è  Ð¿ÌÒ¿Ô@oßÐ, –€ РDÒ &Ð"`РDÒÔ@РDŸÂ€Ð¿à€¢ €Ð Dà РDÒ DÐ pÒa4@Ô”Ö DØ Ð D’ Öá8ŸÃÒ¿ìÔ¿è– •*à’@ Ð"` Ð¿è’ Ò'¿èÐ¿ä’ TÒ'¿ä¿ÿÇàèã¿€ð' DРDÒ!ÈÒ'¿ìРDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`РDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"` РDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`РDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`À'¿è?€Ð'¿äп耢 ÿ€€[пìÒ¿è” “* Ô @ Ò¿ä– •*à”€ —* –"À •*à”€ “* ”€  ’€ •:`Ô"пìÒ¿è” “* Ô @ Ò¿ä– •*à”"€ —* –À •*à”"€ “* ’"@ •*` ’€ •:`Ô"пìÒ¿è” “* Ô @ Ò¿ä” —* –À •*à”"€ —* ”€ —* –À “*à” Ô"пìÒ¿è” “* Ô @ Ò¿ä” —* –À •*à”"€ —* –"À “*à’"@ •*`’  ’@ Ò"Ð¿è’ Ò'¿èÐ¿ä’ Ò'¿ä¿ÿ£Çàè㿈ð' Dò' Hô' Lö' Pø' TРDÒ!ÈÒ'¿ìÞ Dààpà'¿èà DÞ!Dâ¿ìà`ä¿ìâ  æ¿ìäàè¿ìæ ê T¨ÿªê' T€¥`€€Mè Hê L¬«- ì¨@ب ê H¨ê L¬«- ì¨@Ú¨ ê H¨ê L¬«- ì¨@Äè Lª ê' L¨ PêÖ@ª`ê%† è¿è€ À €€#è  ÿè @’ ÿ耔 ÿ¨ «- ì¨ê Àê*Àª ©-`ª ­-`èÀꀨ«= ¨ê Àê*ਠ«- ì@¨ê Àê*à–à†à¿ÿÛ¿ÿ®Çàè㿈ð' Dò' Hô' Lö' Pø' TØ DÖ $Ø DÚ pÚ'¿ìÚ T˜ÿš Ú' T€£`€€2À'¿èؿ耣 €€#Ø¿èš ™+`Ú H˜ Ú L„ ›( Ä˜@ÐØ PÚØ¿è’@ Կ쀢 €€ Ø Ø*@ ’@ ”¿ÿ¿ÿöØ¿èš Ú'¿è¿ÿÛØ Lš Ú' LØ Pš Ú' P¿ÿÉÇàèã¿ð' Dò' Hô' Lö' Pø' TРHÚ DÐÒ LÔ P– Ø TÚ`p@}Çàè㿈ð' Dò' Hô' Lö' Pø' TÖ DØàpØ'¿ìØ T–?ÿ˜ Ø' T€£ €€#Ú H– LØÀ„ †…(àÆ@š€Ð@˜ Ø"À– PØÀÒ˜ Ø"À” ֿ쀢€ €€ Ö Ö*`Ö*`Ö*@’`” ¿ÿô¿ÿØÇàè㿈ð' Dò' Hô' Lö' Pø' TРDÒ!ÈÒ'¿ìà Dâ pâ'¿èâ DàaDä¿ìâ æ¿ìäà è¿ìæ ê¿ìè`ì Tª¿ÿ¬ì' T€¥ €€^ê Hì L®­-àî@ª€Ø@ª ì Hª@ì L®­-àî@ª€Ú@ª ì Hª@ì L®­-àî@ª€Ä@ª ì Hª@ì L®­-àî@ª€Æ@ê L¬`ì' Lª Pì@Ö€¬ ì%@ž ê¿è€£À €€+ê  `ÿê @’ `ÿꀔ `ÿª ÿ¬ ¯- ð@¬ª%@ì @ì*Àª ÿ® ­-à® ±-àìîÀ¬€¯= ¬ª%@ì @ì*ઠÿ¬ ¯- ð€¬ª%@ì @ì*àêÀê*à–àžà¿ÿÓ¿ÿÇàèã¿ð' DÇàè㿈ð' DРDÒ Ö@РD’ ” ŸÂÀÐ'¿ìРDÒ¿ìÒ"!Èп찒¡¬Ò"РDÒ (ÿ€¢ €A’‘*`°’¢8Ð ÂÂLÂÂÂÔÂÔРDÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€5РDÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€$РDÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ $€¢`€ РDÒ Ð"`РDÒÔ@РDŸÂ€€Ò DÐ`,€¢ €J€¢ €€¢ € €€¢ €r€˜Ð D’ Ò" xРDÒ (€¢`€ РDÒ (€¢`€€"п쯒¢œÒ"  Ð'¿èРDÒ¿èÐ $€¢@€€Ð DÒ¿è– •*à”€ —* –À “*àÔ Ø@ À" 0Ð¿è’ Ò'¿è¿ÿê€ Ð DÒ Ð"`РDÒÔ@РDŸÂ€€zРD’ Ò" xРDÒ (€¢`€ п쮒£ÔÒ" РDÿý3€"РDÒ (€¢`€Ð¿ì¯’¢äÒ" €Ð DÒ (€¢`€Ð¿ì¯’¡„Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€GРD’ Ò" xРDÒ (€¢`€ п쯒£¸Ò" РDÿý€Ð DÒ (€¢`€Ð¿ì¯’¡„Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ DÐ ,Ò`(€¢ € РDÒ DÔ`$Ô" xп쯒¡„Ò" € РDÒ Ð"`РDÒÔ@РDŸÂ€€Ð DÒ T€¢`€Ð D’ Ò" |€Ð DÒ DÔ`xÔ" |Çàèã¿pð' Dò' HРDÒ xÒ'¿ìРDÒ `Ò'¿è Ð'¿àÐ¿à’ Ò'¿àпàÐ'¿Ð Ð'¿ÜпÜҿ쀢 €€ пÐÒ¿à@lFÐ'¿Ðпܒ Ò'¿Ü¿ÿñпÐҿ耢 €€¿ÿáпà’?ÿÒ'¿àÐ¿à€¢ €Ð DÒ 8Ð"`РDÒпÐÐ"`РDÒÔ@РDŸÂ€ Ð'¿äÀ'¿ÜпÜҿ쀢 €€Ð¿Ü’‘*`Ò H Ò¿àÒ"пäÒ¿à@l Ð'¿äпܒ Ò'¿Ü¿ÿêÀ'¿ÔÀ'¿ÜпÜҿ쀢 €€IРDÒ ,€¢`€ ØÒ¿Ü” “*  €’@Ð@€Ð¿ÜÐ'¿Øпؒ‘*`Ô H’ пäÒ@@kçÐ'¿Ðпؒ‘*`Ò H Ô’ Ð¿Ð@kÙÐ'¿ÐпÐҿ耢 €€Ð¿Ø’‘*`Ò H Ò¿Ø “* Ô H@ Ò¿Ø” “* Ô H’@ Ô@’ Ò"пÐÐ'¿ä Ð'¿Ôпܒ Ò'¿Ü¿ÿ´Ð¿Ô€¢ €€¿ÿªÐ¿ä°€Çàèã¿ð' Dò' Hô' Lö' PРL’•*`’"€Ð P•: —2 ” ‘: ’@ Ò P@k˜°€Çàèã¿ð' Dò' Hô' Lö' PРL’•*` ’•*`"€Ò P Ò P” “* @k€°€Çàèã¿`ð' DРDÒ!ÌÒ'¿ìÐ¿ì’ Ð Dÿÿ Ð'¿äРDÒ x€¢`€,РDÒ`Ð'¿ÀпÀÒ¿äÒ" Ò¿À Ò¿ìÔ` Ô" Ò¿À Ò¿ìÔ`$Ô" Ò¿À Ò¿ìÔ`(Ô"РDÒ ^Ð"`РDÒÔ`РD’ ŸÂ€€¿ÿڀРDÒ _Ð"`РDÒпäÐ"`РDÒÔ`РD’ ŸÂ€Ð DÒ Ö DØ`РD’ Ô¿äÖàxŸÃÐ'¿èпäÐ'¿ÌÀ'¿àРDÒ¿àÐ x€¢@€€UпìÒ¿à” “*  Ò Ò'¿ÔпÌÒ¿Ô@kÐ'¿ÐÀ'¿ÜпÜÒ¿Ô€¢ €€:пԖ?ÿРDÒ¿àÔ¿ÜÿÿXÐ'¿ÄпÜÒ¿Ð@jùÐ'¿ÈпÈҿ䀢 €€!À'¿ØпØҿЀ¢ €€Ð¿à’‘*`Ò¿è Ò¿ÈÔ¿Ø’@ Ô@ Ò¿ÇÒ*пؒ Ò'¿Ø¿ÿêпÈÒ¿Ì Ð'¿È¿ÿÜпܒ Ò'¿Ü¿ÿÃпÐÐ'¿ÌÐ¿à’ Ò'¿à¿ÿ§Ð¿ìÒ¿èÒ" пìÒ¿äÒ" Çàèã¿hð' DРDÒ!ÌÒ'¿ìРDÒ X€¢`€ !þÐ'¿ÌÐ¿ì’ Ò" €À'¿ÌпìÀ" Ò DÐ`Ò¿Ì”aÖ DØ Ð D’ ÖàxŸÃÒ¿ìÐ"`пìÒ Ò'¿ÔÀ'¿äРDÒ¿äÐ x€¢@€€~пìÒ¿ä” “*  Ò Ò'¿ØпÔÒ¿Ø@j‰Ð'¿Ôп̀¢ €Ð¿ìÒ¿ä” “* Ô @ Ò¿ìÔ¿ä– •*àÖ`’€ Ô@’ ÿÒ"пìÒ¿ä” “* Ô @ ÒÒ'¿èÀ'¿Ðпؖ?ÿРDÒ¿ä” ÿþÔÐ'¿ÜÀ'¿àÐ¿à€¢ ÿ€€#пàÒ¿Ü€¢ €€Ò¿Ð`”Ô'¿Ðпؖ?ÿРDÒ¿äÿþ»Ð'¿Ü¿ÿîпèÒ¿à  Ð¿ÐÒ¿Ô@j?Ð,Ð¿à’ Ò'¿à¿ÿÛп̀¢ € Ð'¿àÐ¿à€¢ ÿ€€Ð¿èÒ¿à" Ò¿èÔ @Ô*пàÒ¿è ’ ÿÔ¿è’@ Ô @Ô* ÿÐ¿à’ Ò'¿à¿ÿéÐ¿ä’ Ò'¿ä¿ÿ~Çàèã¿xð' Dò' HРDÒ Ö@РD’ ”$ŸÂÀÐ'¿ìÒ Hÿ’‘*` Ð'¿ÜÀ'¿èп耢 €€?À'¿äп䀢 €€3×Ò¿è” “* Ô¿ä’@ ”#€@ Ò `ÿ’‘*`’ ÿ"@’•*`"€Ð'¿àпèÒ¿ä” ¡* “* пì¢@Ð¿à€¢ € пठҿÜ@iÔ¤ €Ð¿àÒ¿Ü@iͤä$@Ð¿ä’ Ò'¿ä¿ÿËÐ¿è’ Ò'¿è¿ÿ¿Ð¿ì°€Çàèã¿xð' DРDÒ!ÌÒ'¿ìÀ'¿äРDÒ¿äÐ x€¢@€€?пìÒ¿ä” “*  Ò Ò'¿ÜÀ'¿èÀ'¿àпàҿ䀢 €€Ð¿ìÒ¿à” “*  Ò¿ÜÐ €¢@€ пìÒ¿à” “*  Ò 4Ò'¿è€Ð¿à’ Ò'¿à¿ÿãп耢 €Ð DÒ¿ÜÿÿiÐ'¿èпìÒ¿ä” “*  Ò¿èÒ" 4Ð¿ä’ Ò'¿ä¿ÿ½Çàèã¿xð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìпìÒ Ò'¿èØ DÚ pÚ'¿ÜÚ DØ`xÀ'¿äÚ¿äÄ P€£@€€9Ú¿ä„ ›( Ä Hš@Ô@Ú¿ä„ ›( Ä Lš@Ö@Ú¿ÜÚ'¿àÚ¿à€£`€€  ’ €¢@ €€š …+`Æ¿èš€Æ €„àÿÆ@š€Ä @š ÿ ” ’`¿ÿîšÚ*À–àÚ¿à„ÿÄ'¿à¿ÿÞÚ¿ä„`Ä'¿ä¿ÿÄÇàèã¿pð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìÖ¿ìØàÖÖ'¿èÖ¿ì˜ Úà– ØÀØ'¿äÖ¿ì˜ Úà– ØÀØ'¿àÖ DØàpØ'¿ÔÀ'¿ÜÖ¿ÜØ P€¢À €€:ֿܘ —+ Ø H–À ÒÀֿܘ —+ Ø L–À ÔÀÖ¿ÔÖ'¿ØÖ¿Ø€¢à€€!Ø @– ÿØ¿è–À Ø À ÿ’`Ø @– ÿØ¿ä–À Ø À– ÿ ’`Ø @– ÿØ¿à–À Ø À– ÿ ’`–Ö*€” Ö¿Ø˜ÿÿØ'¿Ø¿ÿÝֿܘàØ'¿Ü¿ÿÃÇàèã¿hð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìРDÒ xÒ'¿ØРDÒ pÒ'¿ÈÀ'¿ÐпÐÒ P€¢ €€lпВ‘*`Ô L’ Ð@Ò¿È@ýпìÒ 0Ò'¿àÀ'¿ÔпÔÒ¿Ø€¢ €€LпВ‘*`Ò H ÒпԠ@пВ‘*`Ò L âпìÒ¿Ô” “* Ô @ ÒÒ'¿èпìÒ¿Ô” “*  Ò¿à” “* Ð 4’ Ò'¿äÀ'¿ÜпÈÐ'¿Ìп̀¢ €€Ò `ÿÒ¿Ü” “* Ô¿ä’@ Ô@ Ò¿è Ò @Ð ’@Ò,@пؠ¢`Ò¿Ü`’ Ò'¿Üп̒?ÿÒ'¿Ì¿ÿáпԒ Ò'¿Ô¿ÿ±Ò¿à`’ Ò'¿àпìÒ¿àÒ" 0пВ Ò'¿Ð¿ÿ‘Çàèã¿`ð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìÖ¿ìØàÖÖ'¿èÖ¿ì˜ Úà– ØÀØ'¿äÖ¿ì˜ Úà– ØÀØ'¿àÖ DØàpØ'¿ÀÀ'¿ÈÖ¿ÈØ P€¢À €€sÖ¿ìØà0Ø'¿ÐֿȘ —+ Ø H–À ÒÀֿȘ —+ Ø L–À ÔÀÖ¿ìؿК ™+`Öà4˜À Ø'¿ÜÖ¿ìؿК ™+`Öà8˜À Ø'¿ØÖ¿ìؿК ™+`Öà<˜À Ø'¿ÔÀ'¿ÌÖ¿ÀÖ'¿ÄÖ¿Ä€¢à€€:Ø @– ÿØ¿Ìš ™+`ڿܘ Ú–À Ø¿è–À Ø À ÿ’`Ø @– ÿØ¿Ìš ™+`ڿؘ Ú–À Ø¿ä–À Ø À– ÿ ’`Ø @– ÿØ¿Ìš ™+`Ú¿Ô˜ Ú–À Ø¿à–À Ø À– ÿ ’`–Ö*€” Ø¿Ì– ˜ àØ'¿ÌֿĘÿÿØ'¿Ä¿ÿÄؿЖ ˜ àØ'¿ÐÖ¿ìØ¿ÐØ"à0ֿȘàØ'¿È¿ÿŠÇàèã¿Pð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìРDÒ xÒ'¿ÌРDÒ pÒ'¿´Ð DÒ!DÒ'¿°À'¿¼Ð¿¼Ò P€¢ €€¹Ð¿¼’‘*`Ô L’ Ð@Ò¿´@âÀ'¿ÀпÀÒ¿Ì€¢ €€œÐ¿¼’‘*`Ò H ÒпÀ¤@п¼’‘*`Ò L æпìÒ T€¢`€Ð¿´’?ÿ Ò¿Ì@gb¤€Ò¿´ÿ¦À?ÿÐ'¿Èп̒ Ò'¿ÄпìÒ¿À” “*  Ò¿´” “* ”`Ð D¢€€  Ð'¿ÈпÌÐ'¿ÄпìÒ¿À” “*  â DпìÒ¿À” “* Ô @ ÒÒ'¿ØпìÒ¿À” “* Ô @ ÒÒ'¿Ô  À'¿äÀ'¿èп´Ð'¿¸Ð¿¸€¢ €€AпȒ‘*`Ò@•*`‘:    ¡< Ò € `ÿ Ò¿° Ò   `ÿÒ¿Ø Ò `ÿÐ'¿ÐÐ ÀÒ¿Ó Ð,ÀпÔÒ¿Ð Ò `ÿ $à'¿à“* Ò'¿ÜÐ¿Ü Ð¿æ’ Ð4@пܠпè’Ò'¿äпàÐ'¿èпܠпĤ€Ð¿È¦ÀпȒ‘*`¢@п¸’?ÿÒ'¿¸¿ÿ½Ð¿æÐ4@пÀ’ Ò'¿À¿ÿaпìÒ¿ìÔ`T– €  ’`?ÿÒ" Tп¼’ Ò'¿¼¿ÿDÇàèã¿€ð' DРDÒ!ÌÒ'¿ìРDÒ p`’‘*`Ð'¿èÀ'¿äРDÒ¿äÐ x€¢@€€Ð DÒ Ö`РD’ Ô¿èŸÂÀÒ¿ìÔ¿ä– •*à’@ Ð"`DÐ¿ä’ Ò'¿ä¿ÿçÇàèã¿€ð' Dò' HРDÒ!ÌÒ'¿ìРDÒ¿ìÔ`Ô" ˆÐ DÒ¿ìÔ`Ô" „Ò DÐ`X€¢ €€¢  €€¢ €8€cРDÒ x€¢`€Ð¿ì´’£ÔÒ" €Ð¿ì´’¢Ò" €^РDÒ x€¢`€Ð¿ìµ’£PÒ" €Ð¿ìµ’¡HÒ" пìÀ" 0пìÒ €¢`€Ð Dÿû©Ð¿ìÒ 4€¢`€Ð Dÿü§€;п춒¡¨Ò" пìÀ" TпìÒ D€¢`€Ð Dÿÿ|РDÒ p`’‘*`Ð'¿èÀ'¿äРDÒ¿äÐ x€¢@€€Ð¿ìÒ¿ä” “* ” РDÒ¿è@”Ð¿ä’ Ò'¿ä¿ÿì€Ð DÒ 0Ð"`РDÒÔ@РDŸÂ€€Çàèã¿ð' DÇàèã¿ð' DРDÒ .Ð"`РDÒÔ@РDŸÂ€Çàè㿈ð' DРDÒ Ö@РD’ ” XŸÂÀÐ'¿ìРDÒ¿ìÒ"!Ìп췒¡”Ò"п췒£¼Ò" п췒£ÌÒ" пìÀ" DпìÀ" 4РDÒ x€¢`€Ð DÒ 7Ð"`РDÒ Ð"`РDÒÔ@РDŸÂ€Ð DÒ `€¢a€Ð DÒ 9Ð"`РDÒ!Ð"`РDÒÔ@РDŸÂ€Ð DÿúQРDÿûРDÒ X€¢`€Ð DÿþëÇàèã¿€ð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìÖ¿ìÔàÖ DØàpØ'¿àÀ'¿èÖ¿èØ P€¢À €€<Ö¿è˜ —+ Ø H–À ÐÀÖ¿àÖ'¿äÖ¿ä€¢à€€)Ø – ÿ™2à– ÿ˜ —+ Ú ˜ `ÿ›3 ˜ `ÿš ™+`Ö€ ’ Ø – ÿ™2à– ÿ˜ —+ ’@ Ö@˜à– Ö2@™*à—3 €¢à€Ö@˜ÿÿØ2@ Ö¿ä˜ÿÿØ'¿ä¿ÿÕÖ¿è˜àØ'¿è¿ÿÁÇàè㿈ð' Dò' H” À'¿ì’ РDÖ H€¢@ €€Ö €¢À €Ö €¢à€Ð'¿ìÔ ’` ¿ÿîÖ¿ì° €Çàè㿈ð' Dò' H” À'¿ì’ РDÖ H€¢@ €€ Ö €¢À €Ð'¿ìÔ ’` ¿ÿòÖ¿ì° €Çàèã¿Pð' Dò' HРDÒ!ÌÒ'¿ìпìÒ Ò'¿èРHÒÒ'¿ÔРHÒ Ò'¿ÐРHÒ Ò'¿ÌРHÒ Ò'¿ÈРHÒ Ò'¿ÄРHÒ Ò'¿ÀпÐÒ¿Ô€¢ €LпÔÐ'¿àпàҿЀ¢ €€CпÌÐ'¿ÜпÜÒ¿È€¢ €€4Ð¿à’‘*`Ò¿è Ò¿Ü” “* Ô@ Ò¿Ä” “*  Ð'¿äпÄÐ'¿ØпØÒ¿À€¢ €€¿äÒÔ@—* •2à’`Ò"€¢ €Ð HÒ¿àÒ'¿ÔÒ"€Ð¿Ø’ Ò'¿Ø¿ÿæпܒ Ò'¿Ü¿ÿÉÐ¿à’ Ò'¿à¿ÿºÐ¿ÐÒ¿Ô€¢ €LпÐÐ'¿àпàÒ¿Ô€¢ €€CпÌÐ'¿ÜпÜÒ¿È€¢ €€4Ð¿à’‘*`Ò¿è Ò¿Ü” “* Ô@ Ò¿Ä” “*  Ð'¿äпÄÐ'¿ØпØÒ¿À€¢ €€¿äÒÔ@—* •2à’`Ò"€¢ €Ð HÒ¿àÒ'¿ÐÒ" €Ð¿Ø’ Ò'¿Ø¿ÿæпܒ Ò'¿Ü¿ÿÉпà’?ÿÒ'¿à¿ÿºÐ¿ÈÒ¿Ì€¢ €LпÌÐ'¿ÜпÜÒ¿È€¢ €€CпÔÐ'¿àпàҿЀ¢ €€4Ð¿à’‘*`Ò¿è Ò¿Ü” “* Ô@ Ò¿Ä” “*  Ð'¿äпÄÐ'¿ØпØÒ¿À€¢ €€¿äÒÔ@—* •2à’`Ò"€¢ €Ð HÒ¿ÜÒ'¿ÌÒ" €Ð¿Ø’ Ò'¿Ø¿ÿæÐ¿à’ Ò'¿à¿ÿÉпܒ Ò'¿Ü¿ÿºÐ¿ÈÒ¿Ì€¢ €LпÈÐ'¿ÜпÜÒ¿Ì€¢ €€CпÔÐ'¿àпàҿЀ¢ €€4Ð¿à’‘*`Ò¿è Ò¿Ü” “* Ô@ Ò¿Ä” “*  Ð'¿äпÄÐ'¿ØпØÒ¿À€¢ €€¿äÒÔ@—* •2à’`Ò"€¢ €Ð HÒ¿ÜÒ'¿ÈÒ" €Ð¿Ø’ Ò'¿Ø¿ÿæÐ¿à’ Ò'¿à¿ÿÉпܒ?ÿÒ'¿Ü¿ÿºÐ¿ÀÒ¿Ä€¢ €LпÄÐ'¿ØпØÒ¿À€¢ €€CпÔÐ'¿àпàҿЀ¢ €€4Ð¿à’‘*`Ò¿è Ò¿Ì” “* Ô@ Ò¿Ø” “*  Ð'¿äпÌÐ'¿ÜпÜÒ¿È€¢ €€Ð¿äÒ•*`‘2 €¢ €Ð HÒ¿ØÒ'¿ÄÒ" €Ð¿Ü’ Ò'¿ÜÐ¿ä’ @Ò'¿ä¿ÿæÐ¿à’ Ò'¿à¿ÿÉпؒ Ò'¿Ø¿ÿºÐ¿ÀÒ¿Ä€¢ €LпÀÐ'¿ØпØÒ¿Ä€¢ €€CпÔÐ'¿àпàҿЀ¢ €€4Ð¿à’‘*`Ò¿è Ò¿Ì” “* Ô@ Ò¿Ø” “*  Ð'¿äпÌÐ'¿ÜпÜÒ¿È€¢ €€Ð¿äÒ•*`‘2 €¢ €Ð HÒ¿ØÒ'¿ÀÒ" €Ð¿Ü’ Ò'¿ÜÐ¿ä’ @Ò'¿ä¿ÿæÐ¿à’ Ò'¿à¿ÿÉпؒ?ÿÒ'¿Ø¿ÿºÐ¿ÐÒ¿Ô" “*  “* Ò'¿¼Ð¿ÈÔ¿Ì’" ‘*`’•*`€Ð'¿¸Ð¿ÀÒ¿Ä" “* Ò'¿´à Hп¼Ò¿¼@c¢Ð¿¸Ò¿¸@c¢@п´Ò¿´@c ’@Ò$ À'¿°Ð¿ÔÐ'¿àпàҿЀ¢ €€@пÌÐ'¿ÜпÜÒ¿È€¢ €€1Ð¿à’‘*`Ò¿è Ò¿Ü” “* Ô@ Ò¿Ä” “*  Ð'¿äпÄÐ'¿ØпØÒ¿À€¢ €€Ð¿äÒ•*`‘2 €¢ €Ð¿°’ Ò'¿°Ð¿Ø’ Ò'¿ØÐ¿ä’ Ò'¿ä¿ÿéпܒ Ò'¿Ü¿ÿÌÐ¿à’ Ò'¿à¿ÿ½Ð HÒ¿°Ò" Çàèã¿xð' Dò' Hô' Lö' PРLÒ P€¢ €€Ð L’‘*`Ò P€¢ € РHÒ Lÿý@ €Ð HÒ LÿýZ €¤ €€…РL’‘*`Ò H¢ Ð Ð$`Ð Ð$` Ð Ð$`ÐÐ$@Ð Ð$`Ð Ð$`Ð Ò" “*  “* Ò'¿äÐ Ô ’" ‘*`’•*`€Ð'¿àÐ Ò " “* Ò'¿ÜпàÐ'¿Ø Ð'¿ìпäÒ¿Ø€¢ €Ð¿äÐ'¿ØÀ'¿ìпÜÒ¿Ø€¢ € Ð'¿ìп쀢 €€¢ €€¢ € €4€¢ €"€/Ð Ò “: •2` “: Ò'¿èпèÐ$ Ð¿è’ Ò$@€ Ð Ò  “: •2` “: Ò'¿èпèÐ$ Ð¿è’ Ò$`€Ð Ò  “: •2` “: Ò'¿èпèÐ$ Ð¿è’ Ò$`€Ð D’ÿü÷РD’ÿüóРL’ Ò' L¿ÿ`РL°€Çàèã¿Hð' Dò' Hô' LРDÒ!ÌÒ'¿ìпìÒ Ò'¿èÀ'¿¸À'¿´À'¿°À'¿¬Ð HÒÒ'¿ÔРHÒ Ò'¿ÐРHÒ Ò'¿ÌРHÒ Ò'¿ÈРHÒ Ò'¿ÄРHÒ Ò'¿ÀпÔÐ'¿àпàҿЀ¢ €€aпÌÐ'¿ÜпÜÒ¿È€¢ €€RÐ¿à’‘*`Ò¿è Ò¿Ü” “* Ô@ Ò¿Ä” “*  Ð'¿äпÄÐ'¿ØпØÒ¿À€¢ €€5¿äÒÔ@™* —3 ” Ô'¿¼’`Ò"€¢ €$п¸Ò¿¼ Ð'¿¸Ò¿à‘*`’  Ò¿¼@a¯Ò¿´@Ð'¿´Ò¿Ü‘*`’  Ò¿¼@a¥Ò¿°@Ð'¿°Ò¿Ø‘*`’  Ò¿¼@a›Ò¿¬@Ð'¿¬Ð¿Ø’ Ò'¿Ø¿ÿÈпܒ Ò'¿Ü¿ÿ«Ð¿à’ Ò'¿à¿ÿœÐ DÒ ˆÐ@Ò L  Ò¿¸‘:`Ô¿´’  Ò¿¸@aÐ,РD’ Ô ˆ@ ÒРL @Ò¿¸‘:`Ô¿°’  Ò¿¸@aoÐ,РD’ Ô ˆ@ ÒРL @Ò¿¸‘:`Ô¿¬’  Ò¿¸@a_Ð,Çàèã¿€ð' Dò' HÒ DÐ`Ò H– •*àÖРD’ ŸÂÀÐ'¿ì Ð'¿èпìÀ"Ð¿ì’ Ò" пìÀ" Ð¿ì’ ?Ò" пìÀ" Ð¿ì’ Ò" РDÒ¿ìÿü РDÒ¿ìÔ¿èÖ HÿþtÐ'¿èÀ'¿äпäҿ耢 €€Ð¿ä’‘*`Ô¿ì’ Ð DÔ¿äÿÿÐ¿ä’ Ò'¿ä¿ÿíРDÒ¿èÒ" „РDÒ `Ð"`РDÒпèÐ"`РDÒÔ`РD’ ŸÂ€Çàèã»Xð' Dò' Hô' Lö' Pø' TРDÒ „Ò'¿ìРH’ Ò'¿èРHÒ¿è “: Ò'¿ÜРL’ Ò'¿äРLÒ¿ä “: Ò'¿ØРP’ Ò'¿àРPÒ¿à “: Ò'¿ÔÿÿcÿÐ'¿ÄÀ'¿ÐпÐҿ쀢 €€HРDÒ ˆÐ@Ò¿Ð Ò `ÿÐ'¿ÌпÌÒ H€¢ €Ð¿ÌÒ H" ’‘*`Ð'¿¸Ð¿¸Ò¿¸@`ÂÐ'¿ÀпÌÒ¿è" ’‘*`Ð'¿¸Ð¿¸Ò¿¸@`·Ð'¿¼€=пÌҿ耢 €Ð¿ÌÒ¿è" ’‘*`Ð'¿¸Ð¿¸Ò¿¸@`¥Ð'¿ÀпÌÒ H" ’‘*`Ð'¿¸Ð¿¸Ò¿¸@`šÐ'¿¼€ À'¿ÀпÌÒ¿Ü€¢ €Ð¿ÌÒ¿è" ’‘*`Ð'¿¸Ð¿¸Ò¿¸@`‡Ð'¿¼€ пÌÒ H" ’‘*`Ð'¿¸Ð¿¸Ò¿¸@`zÐ'¿¼Ð D’ Ô ˆ@ ÒÔ¿Ð@ Ò `ÿÐ'¿ÌпÌÒ L€¢ € пÌÒ L" ’•*`€Ð'¿¸Ð¿¸Ò¿¸@`_Ò¿À@Ð'¿ÀпÌÒ¿ä" ’•*`€Ð'¿¸Ð¿¸Ò¿¸@`QÒ¿¼@Ð'¿¼€HпÌҿ䀢 € пÌÒ¿ä" ’•*`€Ð'¿¸Ð¿¸Ò¿¸@`<Ò¿À@Ð'¿ÀпÌÒ L" ’•*`€Ð'¿¸Ð¿¸Ò¿¸@`.Ò¿¼@Ð'¿¼€%пÌÒ¿Ø€¢ €Ð¿ÌÒ¿ä" ’•*`€Ð'¿¸Ð¿¸Ò¿¸@`Ò¿¼@Ð'¿¼€Ð¿ÌÒ L" ’•*`€Ð'¿¸Ð¿¸Ò¿¸@` Ò¿¼@Ð'¿¼Ð D’ Ô ˆ@ ÒÔ¿Ð@ Ò `ÿÐ'¿ÌпÌÒ P€¢ €Ð¿ÌÒ P" Ð'¿¸Ð¿¸Ò¿¸@_ïÒ¿À@Ð'¿ÀпÌÒ¿à" Ð'¿¸Ð¿¸Ò¿¸@_äÒ¿¼@Ð'¿¼€<пÌÒ¿à€¢ €Ð¿ÌÒ¿à" Ð'¿¸Ð¿¸Ò¿¸@_ÒÒ¿À@Ð'¿ÀпÌÒ P" Ð'¿¸Ð¿¸Ò¿¸@_ÇÒ¿¼@Ð'¿¼€Ð¿ÌÒ¿Ô€¢ €Ð¿ÌÒ¿à" Ð'¿¸Ð¿¸Ò¿¸@_µÒ¿¼@Ð'¿¼€ пÌÒ P" Ð'¿¸Ð¿¸Ò¿¸@_¨Ò¿¼@Ð'¿¼Ð¿Ð’‘*`’»¸Ô¿ÀÔ"@п¼Ò¿Ä€¢ €Ð¿¼Ð'¿ÄпВ Ò'¿Ð¿þµÀ'¿ÈÀ'¿ÐпÐҿ쀢 €€Ð¿Ð’‘*`’»¸Ð@Ò¿Ä€¢ € ¿ÈÒÖ T”@ Ö¿ÓÖ*€’`Ò"пВ Ò'¿Ð¿ÿåпȰ€Çàèã½Xð' Dò' Hô' Lö' Pø' Tú' X ½¸ Ð'¿àÐ¿à€¢ €€ ÿÿcÿÐ$  пà’?ÿÒ'¿à¿ÿóÀ'¿àпàÒ T€¢ €€¦Ð XÒ¿à Ò `ÿÐ'¿ÜРDÒ ˆÐ@Ò¿Ü Ò `ÿÒ H"@’‘*`Ð'¿ÄпÄÒ¿Ä@_6Ð'¿ÔРD’ Ô ˆ@ ÒÔ¿Ü@ Ò `ÿÒ L"@’•*`€Ð'¿ÀпÀÒ¿À@_"Ò¿Ô@Ð'¿ÔРD’ Ô ˆ@ ÒÔ¿Ü@ Ò `ÿÒ P"@Ð'¿¼Ð¿¼Ò¿¼@_Ò¿Ô@Ð'¿ÔпĒ‘*`’!Ò'¿ÄпÀ”“* ’@‘*`’ Ò'¿Àп¼’‘*`’ @Ò'¿¼ ½¸Ð \Ð'¿ØпÄÐ'¿Ì Ð'¿ìп쀢 €€CпÔÐ'¿ÐпÀÐ'¿È Ð'¿èп耢 €€+â¿Ð俼 Ð'¿äп䀢 €€Ð€¤@€â$пØÒ¿ßÒ*¢@¤ €  пؒ Ò'¿Øпä’?ÿÒ'¿ä¿ÿéпÐÒ¿È Ð'¿ÐпȒ! Ò'¿Èпè’?ÿÒ'¿è¿ÿÓпÔÒ¿Ì Ð'¿Ôп̒"Ò'¿Ìпì’?ÿÒ'¿ì¿ÿ»Ð¿à’ Ò'¿à¿ÿWÇàèã½àð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìпìÒ Ò'¿èРH“: Ò' HРL“: Ò' LРP“: Ò' PÒ H‘*`’ Ò'¿äÒ L‘*`’ Ò'¿àÒ P‘*`’ Ò'¿Ü˜¾ÐРDÒ¿äÔ¿àÖ¿Üÿý|Ð'¾Ìš¾Ð¾HÐ# \РDÒ¿äÔ¿àÖ¿ÜؾÌÿÿРH“* Ò' HРL“* Ò' LРP“* Ò' P ¾HÀ'¿Øп؀¢ €€7À'¿ÔпԀ¢ €€+РHÒ¿Ø ’‘*`Ò¿è Ò LÔ¿Ô’@ ” “* Ð¢@РP’‘*`¢@À'¿ÐпЀ¢ €€ Ò `ÿ’ Ò4@  ¢`пВ Ò'¿Ð¿ÿñпԒ Ò'¿Ô¿ÿÓпؒ Ò'¿Ø¿ÿÇÇàèã¿xð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìпìÒ Ò'¿èРDÒ pÒ'¿ÜÀ'¿äпäÒ P€¢ €€Jп䒑*`Ò H àп䒑*`Ò L âпÜÐ'¿àÐ¿à€¢ €€1Ò `ÿ“2 ¦ `ÿ  Ò `ÿ“2 ¨ `ÿ  Ò `ÿ“2 ª `ÿ  “* Ô¿è@ ’•*`Ф€“* ¤€ Ѐ“* ‘2`€¢ €Ð D’”–ÿÿ8Ð  ’?ÿÒ,@¢`пà’?ÿÒ'¿à¿ÿÍÐ¿ä’ Ò'¿ä¿ÿ³Çàèã¿8ð' Dò' Hô' Lö' PРDÒ!ÌÒ'¿ìпìÒ Ò'¿èРDÒ pÒ'¿°Ð DÒ!DÒ'¿¬Ð¿ìÒ (Ò'¿¨Ð DÒ ˆÐ@Ð'¿¤Ð D’ Ô ˆ@ ÒÒ'¿ Ð D’ Ô ˆ@ ÒÒ'¿œÀ'¿¸Ð¿¸Ò P€¢ €€Ð¿¸’‘*`Ò H ÒÒ'¿Ìп¸’‘*`Ò L ÒÒ'¿ÈпìÒ $€¢`€ Ò¿°ÿ”“* ’@п̒ Ò'¿ÌÒ¿°ÿÒ¿È@Ð'¿È?ÿÐ'¿À?ýÐ'¿¼Ð¿ìÔ¿°’ – •*à”€ “* Ð ¦@пìÀ" $€  Ð'¿À Ð'¿¼Ð¿ìæ Ð¿ì’ Ò" $¤ ¢   À'¿ÜÀ'¿àÀ'¿äÀ'¿ÐÀ'¿ÔÀ'¿Øп°Ð'¿´Ð¿´€¢ €€ºÐ¿¼’‘*`ÒÀ•*`‘:    ¡< п¼’‘*`’Ð`“* ‘:`¢@¢`£<`п¼’‘*`’Ð`“* ‘:`¤€¤ ¥< “* Ô¿¨@ à“* Ô¿¨@ â“* Ô¿¨@ äпÌÒ `ÿ  Ò¿Ì Ò `ÿ¢@ Ò¿Ì Ò `ÿ¤€Ò¿¬ Ò   `ÿÒ¿¬@ Ò ¢ `ÿÒ¿¬€ Ò ¤ `ÿ‘< ’‘*`Ò¿è “<`” “* Ô@ “< ” “*  Ð'¿ÄпÄÒ•*`‘2 €¢ €“< •<`—< Ð DÿþMÒ¿ÄÔ@“* ‘2`?ÿÒ¿ÈÐ*@Ô¿¤’ Ô @’  ÿ $ Ô¿ ’ Ô @’  ÿ¢$@ Ô¿œ’ Ô @’  ÿ¤$€ ”—* ’   Ô¿Ú–”€ Ô4À  Ô¿ä–€Ö'¿ØÐ'¿ä  ”—* ’ ¢@ Ô¿Ö–”€ Ô4à¢@ Ô¿à–€Ö'¿ÔÐ'¿à¢@ ”—* ’ ¤€ Ô¿Ò–”€ Ô4ऀ Ô¿Ü–€Ö'¿ÐÐ'¿Ü¤€ пÌÒ¿¼ Ð'¿ÌпÈÒ¿À Ð'¿Èп¼’‘*`¦Àп´’?ÿÒ'¿´¿ÿDпÚÐ4ÀпÖÐ4àпÒÐ4àп¸’ Ò'¿¸¿þíÇàèã¿€ð' DРDÒ!ÌÒ'¿ìРDÒ Ö@РD’ ”'üŸÂÀÐ'¿èпè’#üÒ'¿èпìÒ¿èÒ" (À'¿àÀ'¿äп䀢 €€Ð¿ä’‘*`Ò¿è Ò¿àÒ"Ò¿ä ’‘*`Ò¿è Ò¿à” Ô"Ð¿ä’ Ò'¿äÐ¿à’ Ò'¿à¿ÿäп䀢 /€€Ð¿ä’‘*`Ò¿è Ò¿àÒ"Ò¿ä ’‘*`Ò¿è Ò¿à” Ô"Ð¿ä’ Ò'¿äÒ¿ä` Ò¿à Ð'¿à¿ÿáп䀢 ÿ€€Ð¿ä’‘*`Ò¿è Ò¿àÒ"Ò¿ä ’‘*`Ò¿è Ò¿à” Ô"Ð¿ä’ Ò'¿ä¿ÿçÇàè㿈ð' DРDÒ!ÌÒ'¿ìРDÒ¿ìÔ`Ô" ˆÒ¿ìРDÒ`ÿú·Ð¿ì’ Ò" Çàèã¿ð' DÇàèã¿€ð' Dò' HРDÒ!ÌÒ'¿ìпìÒ Ò'¿èРDÒ X€¢`€Ð D’ Ò" XРH€¢ €Ð¿ì¸’¡TÒ" пìÁ’£ÌÒ" Ð¿ì’ Ò" €gРDÒ X€¢`€Ð¿ìÀ’¡ Ò" €Ð¿ì¿’£ŒÒ" пìÂ’ Ò" РDÒ „Ò'¿äп䀢 €Ð DÒ 8Ð"`РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ä€¢!€Ð DÒ 9Ð"`РDÒ!Ð"`РDÒÔ@РDŸÂ€Ð DÒ X€¢`€(РDÒ p`”“* ’@‘*`Ð'¿àпìÒ €¢`€ РDÒ Ö`РD’ Ô¿àŸÂÀÒ¿ìÐ"` Ò¿ìÐ` Ò¿à@çпìÒ (€¢`€Ð DÿþòпìÀ" $пìÒ €¢`€À'¿äп䀢 €€Ð¿ä’‘*`Ô¿è’ Ð@@ÈÐ¿ä’ Ò'¿ä¿ÿîпìÀ" Çàè㿈ð' DРDÒ!ÌÒ'¿ìÐ¿ì’ Ò" Çàèã¿€ð' DРDÒ Ö@РD’ ” ,ŸÂÀÐ'¿ìРDÒ¿ìÒ"!ÌпìÂ’ (Ò"пìÂ’¢¼Ò" пìÀ" пìÀ" (РDÒ x€¢`€ РDÒ /Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ö@РD’ ” €ŸÂÀÒ¿ìÐ"`À'¿èп耢 €€Ð DÒ Ö`РD’ ŸÂÀÒ¿ìÔ¿è– •*àÖ`’€ Ð"@Ð¿è’ Ò'¿è¿ÿèÐ¿ì’ Ò" РDÒ l€¢`€9РDÒ `Ò'¿äп䀢 €Ð DÒ 8Ð"`РDÒ Ð"`РDÒÔ@РDŸÂ€Ð¿ä€¢!€Ð DÒ 9Ð"`РDÒ!Ð"`РDÒÔ@РDŸÂ€Ð DÒ Ø`РD’ Ô¿ä– ŸÃÒ¿ìÐ"`пìÒ¿äÒ" €Ð¿ìÀ" РDÒ X€¢`€Ð D’ Ò" XРDÒ X€¢`€Ò DÐ`Ò DÔ`p’ ” —* –À •*àÖ Ð D’ ŸÂÀÒ¿ìÐ"` РDÿþÇàèã¿€ð' DРDÒ!ÄÒ'¿ìРDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`РDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`РDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`РDÒ Ö@РD’ ”$ŸÂÀÒ¿ìÐ"`À'¿è?€Ð'¿äп耢 ÿ€€[пìÒ¿è” “* Ô @ Ò¿ä– •*à”€ —* –"À •*à”€ “* ”€  ’€ •:`Ô"пìÒ¿è” “* Ô @ Ò¿ä– •*à”"€ —* –À •*à”"€ “* ’"@ •*` ’€ •:`Ô"пìÒ¿è” “* Ô @ Ò¿ä” —* –À •*à”"€ —* ”€ —* –À “*à” Ô"пìÒ¿è” “* Ô @ Ò¿ä” —* –À •*à”"€ —* –"À “*à’"@ •*`’  ’@ Ò"Ð¿è’ Ò'¿èÐ¿ä’ Ò'¿ä¿ÿ£Çàè㿈ð' DРDÒ!ÄÒ'¿ìпìÀ" $пìÒ DÔ`tÔ" ,Çàèã¿xð' Dò' Hô' Lö' Pø' Tú' XРDÒ!ÄÒ'¿ìпìÒ $€¢`€Ò¿ì` Ò XÔ@’ •*`Ò T”€ Ú¿ì’ – ˜ Ú`(@ Ð'¿ÜпìÀ" $€> Ð'¿ÜпìÒ¿ÜÐ ,€¢@€Ð¿ìÒ ,Ò'¿ÜРXÒ \Ð’"@Ò' \пÜÒ \€¢ €Ð \Ð'¿ÜРXÒ “* Ô T@ ÒÒ'¿àп܀¢ € РXÒ “* Ô T@ Ò Ò'¿ä€Ð¿ìÒ Ò'¿äÐ¿ì’ Ò" $пìÔ L–¿àØ Ð DÒ HÔ€ŸÃРXÒ XÔ@Ò¿Ü”€ Ô"пìÒ¿ìÔ`,Ò¿Ü”"€ Ô" ,пìÒ $€¢`€Ò LРLÒ LÔ@’ Ò"Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XРDÒ!ÄÒ'¿ìпìÔ LÒ XÖ@’ —*`Ò T–À Ø Ð DÒ HÔ€ŸÃÒ XРXÒ XÔ@’ Ò"Ò LРLÒ LÔ@’ Ò"Çàèã¿`ð' Dò' Hô' Lö' PРDÒ!ÄÒ'¿ìÄ DÚ¡DÄ¿ìÆ Æ'¿ÐÄ¿ìÆ Æ'¿ÌÄ¿ìÆ Æ'¿ÈÄ¿ìÆ Æ'¿ÄÄ HÆ Lž‡+àÞ€„ÀÆ€Æ'¿à„ Æ H„€Æ Lž‡+àÞ€„ÀÆ€Æ'¿Ü„ Æ H„€Æ Lž‡+àÞ€„ÀÆ€Æ'¿ØÄ P؀ĠDÆ p…0àÄ'¿ÔÄ¿Ô€  €€O„¿ÜÆ€ÞÀ  àÿà'¿è†àÆ €„¿ØÆ€ÞÀ  àÿà'¿ä†àÆ €Ä¿ä†…(àƿЄ€Ò€Ä¿è†…(àÆ¿Ä„€Æ¿äž‡+à޿ȆÀÄ€ÆÀ”€•: Ä¿è†…(àÆ¿Ì„€Ö€„¿àÆ€ÞÀ àÿ†àÆ €„ Æ @Æ+„ Æ @Æ+ „ Æ @Æ+ ˜ „¿àÆ€ÞÀ àÿ†àÆ €„ Æ @Æ+„ Æ @Æ+ „ Æ @Æ+ ˜ Ä¿Ô†¿ÿÆ'¿Ô¿ÿ¯Ä DÆ p„à€  €0Ä¿ÜÆ€„àÿÄ'¿èÄ¿ØÆ€„àÿÄ'¿äĿ䆅(àƿЄ€Ò€Ä¿è†…(àÆ¿Ä„€Æ¿äž‡+à޿ȆÀÄ€ÆÀ”€•: Ä¿è†…(àÆ¿Ì„€Ö€Ä¿àÆ€àÿ„ Æ @Æ+„ Æ @Æ+ „ Æ @Æ+ Çàèã¿`ð' Dò' Hô' Lö' PРDÒ!ÄÒ'¿ìÆ DÄáDÆ¿ìÞàÞ'¿ÌÆ¿ìÞàÞ'¿ÈÆ¿ìÞàÞ'¿ÄÆ¿ìÞàÞ'¿ÀÆ HÞ L Ÿ, àÀ†ÀÞÀÞ'¿àÆ HÞ L Ÿ, àÀ†ÀÞàÞ'¿Ü† Þ H†ÀÞ L Ÿ, àÀ†ÀÞÀÞ'¿Ø† Þ H†ÀÞ L Ÿ, àÀ†ÀÞÀÞ'¿ÔÆ PØÀ† Þ P†ÀÚÀÆ DÞàp‡3àÆ'¿ÐƿЀ à€€o†¿ØÞÀà À¢ ÿâ'¿èžàÞ À†¿ÔÞÀà À¢ ÿâ'¿äžàÞ Àƿ䞇+à޿̆ÀÒÀƿ螇+àÞ¿À†ÀÞ¿ä Ÿ, à¿ÄžÀÆÀÞÀ”À•: Æ¿èž‡+à޿ȆÀÖÀ†¿àÞÀà À ÿžàÞ À† Þ€Þ+† Þ€Þ+ † Þ€Þ+ ˜ †¿àÞÀà À ÿžàÞ À† Þ€Þ+† Þ€Þ+ † Þ€Þ+ ˜ †¿ÜÞÀà À ÿžàÞ À† Þ€Þ+@† Þ€Þ+`† Þ€Þ+`š`†¿ÜÞÀà À ÿžàÞ À† Þ€Þ+@† Þ€Þ+`† Þ€Þ+`š`ƿОÿÿÞ'¿Ð¿ÿÆ DÞàp† à€ à€<Æ¿ØÞÀ† àÿÆ'¿èÆ¿ÔÞÀ† àÿÆ'¿äƿ䞇+à޿̆ÀÒÀƿ螇+àÞ¿À†ÀÞ¿ä Ÿ, à¿ÄžÀÆÀÞÀ”À•: Æ¿èž‡+à޿ȆÀÖÀÆ¿àÞÀ àÿ† Þ€Þ+† Þ€Þ+ † Þ€Þ+ Æ¿ÜÞÀ àÿ† Þ€Þ+@† Þ€Þ+`† Þ€Þ+`Çàè㿈ð' DРDÒ Ö@РD’ ” 0ŸÂÀÐ'¿ìРDÒ¿ìÒ"!ÄпìÃ’£ìÒ"пìÀ" à¿ìРDÒ DÐ pÒ`x@W“Ð$ (РDÒ!8€¢`€Ð¿ìÄ’  Ò" пìÅ’¡ Ò" РDÒ Ô¿ìÖ`РD’ Ô (ŸÂÀÒ¿ìÐ"` € пìÄ’¢Ò" пìÄ’¢œÒ" пìÀ" РDÿüÈÇàè㿈ð' DРDÒ €¢`€€& Ð'¿ìп쀢 €€Ð DÒ Ô`$РDÒ¿ìŸÂ€Ð¿ì’?ÿÒ'¿ì¿ÿðРDÒ €¢`€ РD’ ÈÒ" РDÀ"!0€Ð D’ dÒ" Çàèã¿ð' DРDÒ €¢`€Ð DÒ Ô`(РDŸÂ€Ð DÀ" РDÀ" Çàè㿈ð' DРDÒ Ö@РD’ ” „ŸÂÀÐ'¿ìпìÀ" €Ð¿ì°€Çàè㿈ð' DРDÒ Ö@РD’ ”!ŸÂÀÐ'¿ìпìÀ"!п찀Çàèã¿ð' Dò' HРDÔ H’ ’ÿ Ò H@Vù°€Çàèã¿ð' Dò' HÒ DÿÒ H Ð' DÒ D Ò H@VüÒ D"@°€Çàèã¿ð' Dò' Hô' Lö' Pø' Tú' Xä XРH’‘*`Ò D@Ð' DРP’‘*`Ò L@Ð' Læ T€¤à€€Ð Dà Ð' D LÒâ@’`Ò"’”@VǦÿÿ¿ÿìÇàèã¿ð' Dò' Hô' LРL’•*`РHÒ D@V·Çàèã¿ð' Dò' HРD’ Ô H@V¡Çàèã¿ð' DРDÒÔ`РDŸÂ€Ð DÿÿV @VpÇàèã¾Èð' DРDÔ’¿(Ô  РDŸÂ€”¿(axÝ’ã8@VdÇàè㿈ð' Dò' HРDÒÒ'¿ìРH€¢ €Ð¿ìÒ l€¢`€ пìÒ h€¢`€€Ð¿ìÒ Ð DŸÂ@Ò¿ìпìÒ¿ìÔ`l’ Ò" l€ пìÒ hРH€¢@€Ð¿ìÒ Ð DŸÂ@Çàèã¿hð' Dò' HРDÒÒ'¿ìпìÒ Ò'¿èÀ'¿äп耢 €Ð¿ìÒ¿èÐ t€¢@€ пìÒ¿è” “* Ô p@ ÒÒ'¿ä€Ð¿ìÒ x€¢`€Ð¿ìÒ¿èÐ |€¢@€Ð¿ìÒ¿èÐ €€¢@€ пìÒ¿ìÔ¿èÖ`|’"€ ” “* Ô x@ ÒÒ'¿äп䀢 € пìÒ¿èÒ" пìÒ pÐ@Ð'¿äÀ'¿ØпäÐ'¿à¿àÒÔ @Ô/¿ß—* •:à’`Ò"€¢ €€Ð¿ß“* ‘:`€¢ %€ пàÒ •*`‘: €¢ s€ Ð'¿Ø€¿ÿâп؀¢ € Ð¿ì” Ð HÒ¿ä@Uð€Ô¿ìÖ¿ìØ¿ìÚ¿ìпìÒ (Ò# \пìÒ ,Ò# `пìÒ 0Ò# dпìÒ 4Ò# hРHÒ¿äÔ ÖàØ Ú`$@UÖÇàèã¿ð' DРDÒÀ"`lРDÒÀ"`Çàèã¿ð' DРDÇ’¡ØÒ"РDÇ’¢`Ò" РDÇ’¢Ò" РDÇ’£ Ò" РDÈ’¡XÒ" РDÀ" hРDÀ" lРDÀ" РDØ’¡ÐÒ" pРD’ {Ò" tРDÀ" xРDÀ" |РDÀ" €Ð D°€Çàèã¿ð' Dò' HРDÒ 6Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Çàèã¿pð' Dò' Hô' LРDÒ Ò'¿ìРLæ²’¡ð€¢ €Ð D’ ÿÿÞРL’ Ò'¿Üп܀¢ €Ò L`Ò¿Ü" Ð' LРH€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€À'¿äпìÒ H” “*  Ò 4Ò'¿èп耢 €€Ð¿èÒ Ð L€¢@ €€ пèÐ'¿äпèÒÒ'¿è¿ÿíп耢 €dРL’ Ò'¿Øп䀢 € ÝÒ H” “* ”#@@ ÒÒ'¿Ô€ ÝÒ H” “* ”#H@ ÒÒ'¿Ôæ²bÒ¿Ø" Ò¿Ô€¢@€æ²bÒ¿Ø" Ð'¿ÔпØÔ¿Ô’ РD@­Ð'¿èп耢 €€Ò¿Ô‘2`Ð'¿ÔпԀ¢ 1€Ð D’ ÿÿZ¿ÿèпìÒ¿ìÔ¿ØÖ¿Ô”€ Ò`L”@ Ô" LпèÀ"пèÀ" пèÒ LÔ¿Ô’@ Ò" п䀢 € пìÒ H” “*  Ò¿èÒ" 4€Ð¿äÒ¿èÒ"Ð¿è’ Ò'¿àпèÒ¿àÐ ’@Ò'¿àпèÒ¿èÔ`Ò L”€ Ô" пèÒ¿èÔ`Ò L”"€ Ô" пఀÇàèã¿€ð' Dò' Hô' LРDÒ Ò'¿ìРLæ²’¡ð€¢ €Ð D’ ÿÿ РL’ Ò'¿äп䀢 €Ò L`Ò¿ä" Ð' LРH€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð L’ РD@8Ð'¿èп耢 €Ð D’ ÿþÚпìÒ¿ìÔ`L’ Ô L’@ Ò" LпèÒ¿ìÔ H– •*à’@ Ô`<Ô"пèÒ LÒ" пèÀ" пìÒ H” “*  Ò¿èÒ" <Ò¿è`°€Çàèã¿pð' Dò' Hô' Lö' PРDÒ Ò'¿ìæ²aðÒ L@TGÐ'¿ÔпԀ¢ € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð¿ÔÒ P€¢ €Ð¿ÔÐ'¿à€Ð PÐ'¿àпìÒ¿àÒ" PРP’•*`РDÒ HÿþšÐ'¿èÀ'¿ÜпÜÒ P€¢ €€3РPÒ¿Ü" Ò¿à€¢ €Ð¿àÐ'¿àпàÒ L@Sï”РDÒ HÿÿQÐ'¿äпàÐ'¿Øп؀¢ €€¿ÜÒ” – •*àֿ蔀 Ö¿äÖ"€’`Ò"пäÒ L Ð'¿äпؒ?ÿÒ'¿Ø¿ÿè¿ÿÊп谀Çàèã¿pð' Dò' Hô' Lö' PРDÒ Ò'¿ìРL”“* æ²¡ð@SÔÐ'¿ÔпԀ¢ € РDÒ FÐ"`РDÒÔ@РDŸÂ€Ð¿ÔÒ P€¢ €Ð¿ÔÐ'¿à€Ð PÐ'¿àпìÒ¿àÒ" PРP’•*`РDÒ Hÿþ'Ð'¿èÀ'¿ÜпÜÒ P€¢ €€6РPÒ¿Ü" Ò¿à€¢ €Ð¿àÐ'¿àпàÒ L@S|’•*`РDÒ HÿþÝÐ'¿äпàÐ'¿Øп؀¢ €€¿ÜÒ” – •*àֿ蔀 Ö¿äÖ"€’`Ò"РL’‘*`Ò¿ä@Ð'¿äпؒ?ÿÒ'¿Ø¿ÿæ¿ÿÇп谀Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XРDÒ Ò'¿ìРH€¢ €Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð DÒ H” €ÿýÃÐ'¿èпèÀ"пèÒ TÒ" пèÒ PÒ" пèÒ XÒ" пèÒ LÒ" пèÀ" (пèÒ¿ìÔ`DÔ" ,пìÒ¿èÒ" Dп谀Çàè㿈ð' Dò' Hô' Lö' Pø' Tú' XРDÒ Ò'¿ìРH€¢ €Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð DÒ H” €ÿý„Ð'¿èпèÀ"пèÒ TÒ" пèÒ PÒ" пèÒ XÒ" пèÒ LÒ" пèÀ" (пèÒ¿ìÔ`HÔ" ,пìÒ¿èÒ" Hп谀Çàèã¿pð' DРDÒ Ò'¿ìÀ'¿èÀ'¿äпìÒ DÒ'¿ÔпԀ¢ €€Ð¿ÔÒ€¢`€Ð¿ÔÒ¿ÔÐ Ò`@R¶Ò¿è@Ð'¿èпÔÒ¿ÔÐ Ò`@R­Ò¿ä@Ð'¿äпÔÒ ,Ò'¿Ô¿ÿàпìÒ HÒ'¿ÐпЀ¢ €€"пÐÒ€¢`€Ð¿ÐÒ¿ÐÐ Ò`@R’‘*`Ò¿è@Ð'¿èпÐÒ¿ÐÐ Ò`@R…’‘*`Ò¿ä@Ð'¿äпÐÒ ,Ò'¿Ð¿ÿÜп耢 €€ÆÖ¿ìРDÒ¿èÔ¿äÖàL@YÐ'¿àпàҿ䀢 €æ²bÐ'¿Ø€ пàÒ¿è@RbÐ'¿Øп؀¢ € Ð'¿ØпìÒ DÒ'¿ÔпԀ¢ €€KпÔÒ€¢`€AпÔÒ ÿÒ¿ÔÒ` @R`’ Ò'¿ÜпÜÒ¿Ø€¢ €Ð¿ÔÒ¿ÔÔ`Ô" €à¿ÔÒ¿ÔпØÒ` @R/Ð$ пԠ 0пÔÒ¿ÔÐ Ò`@R&”РD’@пԒ Ò" (Ô¿ÔÖ¿ÔРD’ Ô ÖàÿýâÒ¿ÔÐ"@пÔÒ¿ìÔ`PÔ" пÔÀ" пÔÀ" пÔÀ" $пÔÒ ,Ò'¿Ô¿ÿ³Ð¿ìÒ HÒ'¿ÐпЀ¢ €€LпÐÒ€¢`€BпÐÒ ÿÒ¿ÐÒ` @R ’ Ò'¿ÜпÜÒ¿Ø€¢ €Ð¿ÐÒ¿ÐÔ`Ô" €à¿ÐÒ¿ÐпØÒ` @QÜÐ$ пР 0пÐÒ¿ÐÐ Ò`@QÓ’•*`РD’@ÃпВ Ò" (Ô¿ÐÖ¿ÐРD’ Ô ÖàÿýÿÒ¿ÐÐ"@пÐÒ¿ìÔ`PÔ" пÐÀ" пÐÀ" пÐÀ" $пÐÒ ,Ò'¿Ð¿ÿ²Çàèã¿xð' Dò' Hô' LРHÒ Ò'¿ìÒ HÐ`Ò¿ì@Q£Ð'¿èÀ'¿ØРHÒ¿ØÐ €¢@€€iРHÒ HÔ`Ö¿Ø’"€ Ð €¢ €Ò HÐ`€Ò HÔ`Ò¿Ø"€ Ð'¿àРHÒ Ð¿Ø’@Ò'¿ÜРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àÐ¿à€¢ €€8пàÒ¿ì@QdÐ'¿äРL€¢ €Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 4РDÔ€Ö¿èØ¿äŸÃ@€Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 0РDÔ€Ö¿èØ¿äŸÃ@пèÒ¿ä Ð'¿èРHÒ¿ØÐ ’@Ò'¿Ø¿ÿ“Çàèã¿xð' Dò' Hô' LРHÒ  “* Ò'¿ìÒ HÐ`Ò¿ì@Q"Ð'¿èÀ'¿ØРHÒ¿ØÐ €¢@€€iРHÒ HÔ`Ö¿Ø’"€ Ð €¢ €Ò HÐ`€Ò HÔ`Ò¿Ø"€ Ð'¿àРHÒ Ð¿Ø’@Ò'¿ÜРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àРHÒ Ô¿Ü"@ Ò¿à€¢ €Ð¿àÐ'¿àÐ¿à€¢ €€8пàÒ¿ì@PãÐ'¿äРL€¢ €Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 4РDÔ€Ö¿èØ¿äŸÃ@€Ð HÔ H’ 0Ô Hֿؘ —+ Ø€”À Ú 0РDÔ€Ö¿èØ¿äŸÃ@пèÒ¿ä Ð'¿èРHÒ¿ØÐ ’@Ò'¿Ø¿ÿ“Çàèã¿€ð' Dò' Hô' Lö' Pø' TРLÒ P Ð'¿ìРHÒ¿ìÐ €¢@€Ð HÒ PÐ €¢@€ РHÒ€¢`€€Ð DÒ Ð"`РDÒÔ@РDŸÂ€Ð HÒ LÐ €¢@ € РHÒ HÐ Ò` ҿ쀢@€€:РHÒ (€¢`€ РDÒ EÐ"`РDÒÔ@РDŸÂ€Ð HÒ $€¢`€ РDÒ H” ÿþ±Ð HÀ" $РHÒ LÐ €¢@€Ð HÒ LÒ" €Ð HÒ¿ìÐ ’"@Ò'¿äп䀢 €À'¿äРHÒ¿äÒ" РDÒ H” ÿþ’РHÒ Ð¿ì€¢@€\РHÒ Ð L€¢@€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð LÐ'¿è€Ð HÒ Ò'¿èРT€¢ €Ð HÒ¿ìÒ" РHÒ €¢`€'РHÒ Ò'¿äРHÒ¿èÐ ’"@Ò'¿èРHÒ¿ìÐ ’"@Ò'¿ìпèҿ쀢 €€Ð HÒ¿è” “* Ð’@Ð@Ò¿äÿùSÐ¿è’ Ò'¿è¿ÿì€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð T€¢ €Ð H’ Ò" $РHÒ HÔ LÖ`’"€ ” “* Ô@ °€Çàèã¿€ð' Dò' Hô' Lö' Pø' TРLÒ P Ð'¿ìРHÒ¿ìÐ €¢@€Ð HÒ PÐ €¢@€ РHÒ€¢`€€Ð DÒ Ð"`РDÒÔ@РDŸÂ€Ð HÒ LÐ €¢@ € РHÒ HÐ Ò` ҿ쀢@€€:РHÒ (€¢`€ РDÒ EÐ"`РDÒÔ@РDŸÂ€Ð HÒ $€¢`€ РDÒ H” ÿþKРHÀ" $РHÒ LÐ €¢@€Ð HÒ LÒ" €Ð HÒ¿ìÐ ’"@Ò'¿äп䀢 €À'¿äРHÒ¿äÒ" РDÒ H” ÿþ,РHÒ Ð¿ì€¢@€^РHÒ Ð L€¢@€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð LÐ'¿è€Ð HÒ Ò'¿èРT€¢ €Ð HÒ¿ìÒ" РHÒ €¢`€)РHÒ  “* Ò'¿äРHÒ¿èÐ ’"@Ò'¿èРHÒ¿ìÐ ’"@Ò'¿ìпèҿ쀢 €€Ð HÒ¿è” “* Ð’@Ð@Ò¿äÿølÐ¿è’ Ò'¿è¿ÿì€Ð T€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð T€¢ €Ð H’ Ò" $РHÒ HÔ LÖ`’"€ ” “* Ô@ °€Çàèã¿xð' Dò' HРDÒ Ò'¿ìРH€¢ €Ð H€¢ €€Ð DÒ Ð"`РDÒРHÐ"`РDÒÔ@РDŸÂ€Ð H€¢ €>пìÒ DÒ'¿Üп܀¢ €€Ð¿ÜÒ (€¢`€ пÜÀ" (пÜÔ¿Ü’ 0Ô 8РDŸÂ€Ð¿ÜÒ ,Ò'¿Ü¿ÿéпìÀ" DпìÒ HÒ'¿Øп؀¢ €€Ð¿ØÒ (€¢`€ пØÀ" (пØÔ¿Ø’ 0Ô 8РDŸÂ€Ð¿ØÒ ,Ò'¿Ø¿ÿéпìÀ" HпìÒ H” “*  Ò <Ò'¿äпìÒ H” “*  À" <п䀢 €€Ð¿äÒÒ'¿ØпäÒ¿äÐ Ò` ’ Ò'¿àРDÒ¿äÔ¿à@EпìÒ¿ìÔ`LÒ¿à”"€ Ô" LпØÐ'¿ä¿ÿãпìÒ H” “*  Ò 4Ò'¿èпìÒ H” “*  À" 4п耢 €€Ð¿èÒÒ'¿ØпèÒ¿èÐ Ò` ’ Ò'¿àРDÒ¿èÔ¿à@пìÒ¿ìÔ`LÒ¿à”"€ Ô" LпØÐ'¿è¿ÿãÇàè㿈ð' D Ð'¿ìп쀢 €€ РDÒ¿ìÿÿ<пì’?ÿÒ'¿ì¿ÿóÒ DРDÒ`” T@àРDÀ" РD@Çàèã¿xð' DРDÀ" € РDÒ Ð"`РDÒÔ@РDŸÂ€æ²bÐ'¿àпàæ²’¢€¢ € РDÒ Ð"`РDÒÔ@РDŸÂ€Ð D@ëÐ'¿èРD’ T@£Ð'¿ìп쀢 €Ð D@åРDÒ 6Ð"`РDÒÀ"`РDÒÔ@РDŸÂ€Ð¿ìÈ’¢ˆÒ"пìÉ’¡ÐÒ" пìÉ’£dÒ" пìÊ’¡(Ò" пìÊ’£Ò" пìÊ’£üÒ" пìË’ øÒ" пìÍ’¡€Ò" пìÎ’¡Ò" пìÏ’ °Ò" $пìÏ’£Ò" (пìæ²’¢Ò" 0пìÒ¿èÒ" , Ð'¿äп䀢 €€Ð¿ìÒ¿ä” “*  À" 4пìÒ¿ä” “*  À" <пä’?ÿÒ'¿ä¿ÿëпìÀ" DпìÀ" HÐ¿ì’ TÒ" LРDÒ¿ìÒ" ÝcP@M’Ð'¿Üп܀¢ €- xÐ/¿Û”¿è–¿ÛпÜÝ’#X@MQ€¢ €!пۓ* ‘:`€¢ m€ пۓ* ‘:`€¢ M€€ п蔓* ’"@•*`”€‘* Ð'¿èпìÒ¿è– •*à”"€ —* –À “*àÒ" ,Çàèã¿ð' Dò' HРH@M]°€Çàèã¿ð' Dò' Hô' LРH@MTÇàèã¿ð' Dò' HРH@MI°€Çàèã¿ð' Dò' Hô' LРH@M@Çàèã¿ð' Dò' Hô' Lö' PРL°€Çàèã¿ð' Dò' Hô' LРDÒ 1Ð"`РDÒÔ@РDŸÂ€Çàèã¿ð' D° €Çàèã¿ð' DÇàè” – Æ  „à…(€ €ˆà€€–À¿ÿù” ÃàÖ"@† ”Ö  „ à…(€”€€Šà€¿ÿú†à€ à€€Šà@€„?ÿ…(€”€ÃàÔ"@…*`€¢`€Ô"€ÖÔ?üÆàÄ € À€’‚ÿÔ"Ö"?ü¿ÿ÷?üÃàÄ’ € € €Ä €  "€ÄÄ €  2€’`Ä„Æ € à¿ÿô Ãà ã¿à€äÀЀ¢ €âÐ €¢ "€ÐÐ €¢ €’ÿÿÉ”Ò €¢@€  ¤ Ð @€¢8€¢ÐÒ €¢`¿ÿç° à&€ä&Àâ'Çàè㿀Р€¢ € À'¿ìЀ¢ €Ð¿ìÿÿºÐÒ¿ì  ’@Ò'¿ìЀ¢ ¿ÿøпì€Ð& ÿÿ®Ð Ð'¿ìпìÐ& @LŠ‘* ’?ÿÒ'¿èÀ'¿äÀ'¿ìÒ €¢`€¢  Ѐ¢ €Ò¿è’”¿ì–¿èÐÿÿ«˜¿ä  Ѐ¢ ¿ÿø’€ Ò¿èÐ ’”¿ì–¿èÿÿž˜¿äÒ¿èâ& пäÒ&Ð& Çàèã¿@/L®à(®À ÐÀà€¤ €¢Ð€¢ €€¤@ÿÿ¬Ð€¤@*€à Ð €¤@ €€¤ à €¤ 2¿ÿñЀ¤ €° Ø – €¢À €À Ú •2 ‘* ð@Ò €¤@ :€Ð €˜ @€¤@€– €¢À ¿ÿòÀ ° Çàè㿈@/K®ã@®À ÒÀÔ "  @L!Ð&@€¢ €Ð@’`@LÒÀ €¢ €Ð@ÐJ€¢ z€-° @LÐ@Ô@’`ÒÀ  €° @L €¢ 2€À&`Ð Ô Ò ‘* •* ”€“*`Ð ’@  Ð&`° ÿþÝ’`ÿþè’` °ÐÒ@Ð&`ÐJ@€¢ z€° ÿþÐ’¿ìÒ¿ì° Çàèã¿€Ô€Š @€ ° Ò @K³  ?ÒÀ’@€ßÒ&À€Š €€  ?Ð'¿è€k€Š À€€¢ .Ð'¿è@€ÒÀ*!¬€Î“* @àÐ ÃÀ8Ðü8tÄ88ä°$Tt000000000000000000000000000000ÐÐÔ Ò ‘* •* ”€“*`Ð ’@ € ÒÐÀ Ð&À€‹° ÐÔ ÒÀ‘* ”€’@ Ò&À€‚° ÔÐ Ò •* ‘*  “*`Ô ’@ÐÀ”€  Ð&À€s° ÿþQ’¿èÿþO’¿ìÔ¿ì°Ò  @K9 Ð'¿ìÒ¿è ’@ Ð*a¬Ð¿è‘* @€_Ò" ÿþ=’¿èÒ¿è°’@ €WÀ*a¬ÿþ5’¿èÿþ3’¿äÒ¿è” ’@ Ô*a¬Ò¿è°Ð¿ä“*`’@ €GÐ"` ¿èÿþ$’ÿþ"’¿ìÒ °Ð¿ìÒ6a¨€;Ð&` ¿èÿþ’Ò °€3Ò6a¨ÿþ’¿ìÒ¿ì°€,Ò&`@K" ’@K”"€$à&bà"”"@K’@K0€ Ð'¿è– пè@Ö*!¬Ô¿è“* ’@ ¿ð‘* Ð"`” €¢ ¿ÿõÔ'¿è0€ ÿýé’¿ìÒ¿ì°€Ò&` @KÇàèã¿@/J®âl®Àð&`À&`À&@ ÒÀÀ&` Ð@À&`Ð&`ò"@Çàèã¿@/J®â$®Àð&`ð&` À&` ÒÀÀ&@Ð@À&`Ð&`ò"@Çàèã¿@/J®áÜ®À ÔÀЀ€¢ €Ò€Ð`€¢€ Ð`Ð"€Ð@€¢ € @J»Ð` 0€€¢ ¿ÿò”`@J¾Çàèã½XÿþL¤’ €ÿþ’¿Ø ’ €½À€=° ’ @J‚”"пêÒ¿ÜÐ7¿jÒ'½ÄР?ü$€Ò ¢ €¤€ пؒ½À”¿Øÿþ±–  €¤ ¿ÿúпØÐJ€¢ z€  ÿýo’½¼Ò½¼  ЀҠ€¢ €¤€Ò'½¸Ð½¸€¢€ ’½À”¿Øÿþ”–½¸ €¤ ¿ÿ÷н¸’½À@JW”"°Çàèã¿@/J®à4®À ÐÀÒ?ü€¢ÿ€  ?üП ?üЀ¢?ÿ¿ÿûÇàèã¿Çàèã¿ ÿsÛÿÿåÇàèã¿ ÿs²ÇàèVUèUÀUUhU8UTøTÐT°TˆTpTXT0TTSèS¸SˆS`S@SRøRàR¸R˜R€RpRXRHR0RQàQ¸Q Q€Q`Q(PðPàP P€Unsupported output file formatUnrecognized input file format --- perhaps you need -targaungetc failedOutput file format cannot handle %d colormap entriesColor map file is invalid or of unsupported format%ux%u colormapped Targa image%ux%u grayscale Targa image%ux%u RGB Targa imageTarga output must be grayscale or RGBInvalid or unsupported Targa fileUnsupported Targa colormap format%ux%u text PPM image%ux%u PPM image%ux%u text PGM image%ux%u PGM imageNot a PPM/PGM fileNonnumeric data in PPM filePPM output must be grayscale or RGBRan out of GIF bitsPremature end of GIF imageBogus char 0x%02x in GIF file, ignoringCorrupt data in GIF fileCaution: nonsquare pixels in inputIgnoring GIF extension block of type 0x%02xWarning: unexpected GIF version number '%c%c%c'%ux%ux%d GIF imageNot a GIF fileToo few images in GIF fileGIF output must be grayscale or RGBBogus GIF codesize %dGIF output got confused%ux%u 8-bit colormapped OS2 BMP image%ux%u 24-bit OS2 BMP image%ux%u 8-bit colormapped BMP image%ux%u 24-bit BMP imageNot a BMP file - does not start with BMSorry, compressed BMPs not yet supportedBMP output must be grayscale or RGBInvalid BMP file: biPlanes not equal to 1Invalid BMP file: bad header lengthOnly 8- and 24-bit BMP files are supportedUnsupported BMP colormap formatusage: %s [switches] [inputfile] Switches (names may be abbreviated): -colors N Reduce image to no more than N colors -fast Fast, low-quality processing -grayscale Force grayscale output -scale M/N Scale output image by fraction M/N, eg, 1/8 -bmp Select BMP output format (Windows style)%s -gif Select GIF output format%s -os2 Select BMP output format (OS/2 style)%s -pnm Select PBMPLUS (PPM/PGM) output format%s (default) -targa Select Targa output format%s Switches for advanced users: -dct int Use integer DCT method%s -dct fast Use fast integer DCT (less accurate)%s -dct float Use floating-point DCT method%s -dither fs Use F-S dithering (default) -dither none Don't use dithering in quantization -dither ordered Use ordered dither (medium speed, quality) -map FILE Map to colors used in named image file -nosmooth Don't use high-quality upsampling -onepass Use 1-pass quantization (fast, low quality) -maxmemory N Maximum memory to use (in kbytes) -outfile name Specify name for output file -verbose or -debug Emit debug output bmpcolorscoloursquantizequantise%ddctintfastfloatditherfsnoneordereddebugverboseIndependent JPEG Group's DJPEG, version %s %s 6b 27-Mar-1998Copyright (C) 1998, Thomas G. Lanegifgrayscalegreyscalemaprb%s: can't open %s maxmemory%ld%cnosmoothonepassos2outfilepnmppmrlescale%d/%dtargaComment, length %ld: APP%d, length %ld: \\\%03odjpeg%s: only one input file wbP5 %ld %ld %d P6 %ld %ld %d ?ð @€ @ÿÿÿÿÿÿÿýÿÿÿùÿÿÿñÿÿÿáÿÿÿÁÿÿÿÿÿÿÿÿþÿÿüÿÿøÿÿðÿÿàÿÿÀÿÿ€ @€ @ÿÿÿÿÿÿÿýÿÿÿùÿÿÿñÿÿÿáÿÿÿÁÿÿÿÿÿÿÿÿþÿÿüÿÿøÿÿðÿÿàÿÿÀÿÿ€@XÅSŸKB@2I"£¨XÅ{!sühbXÅE¿0 ~SŸsümAbTSŸA³-AKBhbbTX~KB;!(ºÃ@XÅSŸKB@2I"£¨2IE¿A³;!2I'‚7 à"£0 -A(º"£7¿ Ž¨~è à Žß?ð?ö1P±Haï?ô箑MoÊ?òÐbïlª?ð?é$iÀ§¿;?áQz{Ç »?ѨUÞr«]?µó?ìƒ^?Š‹ÔÀ'=uÀ0ð Ì<üÃ3óÏ?ÿ€@°pŒL¼|ƒC³sO¿ àÐ,ìÜ#ãÓ/ïß `P¬lœ\£c“S¯oŸ_È8øÄ4ô Ë;ûÇ7÷ˆH¸x„D´t‹K»{‡G·w(èØ$äÔ+ëÛ'çרh˜X¤d”T«k›[§g—WÂ2òÎ>þÁ1ñ Í=ý‚B²rŽN¾~A±qM½}"âÒ.îÞ!áÑ-íÝ¢b’R®nž^¡a‘Q­m] Ê:úÆ6ö É9ùÅ5õŠJºz†F¶v‰I¹y…Eµu*êÚ&æÖ)éÙ%åÕªjšZ¦f–V©i™Y¥e•U     !(0)" #*1892+$%,3:;4-&'.5<=6/7>?????????????????w vàvÀv˜vxvXv8vuðuØuÀu¨uhu8utðt¸t€thtHtsÈs¨sxsXs0sràrÈr°r˜r€rXr@r(rqèq¸qqhq@qpøpØp˜pppHp0poào¸oo`o0onàn¸nn`n0nmÐm mxmXm8mlÐl°lˆl`lHl0lkøk¸kpk@kjèjÈj˜jxj`jHj8jiØi˜ihi@ihøhÐh¨hhhh@h8gøg¸g˜gˆghgHg(gfèf f`f(eðeØeÀe˜ePedØd°d€d`d(cøcÈApplication transferred too many scanlinesInvalid SOS parameters for sequential JPEGCorrupt JPEG data: found marker 0x%02x instead of RST%dPremature end of JPEG fileWarning: unknown JFIF revision number %d.%02dCorrupt JPEG data: bad Huffman codeCorrupt JPEG data: premature end of data segmentCorrupt JPEG data: %u extraneous bytes before marker 0x%02xInconsistent progression sequence for component %d coefficient %dUnknown Adobe color transform code %dObtained XMS handle %uFreed XMS handle %uUnrecognized component IDs %d %d %d, assuming YCbCrJFIF extension marker: RGB thumbnail image, length %uJFIF extension marker: palette thumbnail image, length %uJFIF extension marker: JPEG-compressed thumbnail image, length %uOpened temporary file %sClosed temporary file %s Ss=%d, Se=%d, Ah=%d, Al=%d Component %d: dc=%d ac=%dStart Of Scan: %d componentsStart of Image Component %d: %dhx%dv q=%dStart Of Frame 0x%02x: width=%u, height=%u, components=%dSmoothing not supported with nonstandard sampling ratiosRST%dAt marker 0x%02x, recovery action %dSelected %d colors for quantizationQuantizing to %d colorsQuantizing to %d = %d*%d*%d colors %4u %4u %4u %4u %4u %4u %4u %4uUnexpected marker 0x%02xMiscellaneous marker 0x%02x, length %u with %d x %d thumbnail imageJFIF extension marker: type 0x%02x, length %uWarning: thumbnail image size does not match data length %uJFIF APP0 marker: version %d.%02d, density %dx%d %d %3d %3d %3d %3d %3d %3d %3d %3dEnd Of ImageObtained EMS handle %uFreed EMS handle %uDefine Restart Interval %uDefine Quantization Table %d precision %dDefine Huffman Table 0x%02xDefine Arithmetic Table 0x%02x: 0x%02xUnknown APP14 marker (not Adobe), length %uUnknown APP0 marker (not JFIF), length %uAdobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %dCaution: quantization tables are too coarse for baseline JPEG6b 27-Mar-1998Copyright (C) 1998, Thomas G. LaneWrite to XMS failedRead from XMS failedImage too wide for this implementationVirtual array controller messed upUnsupported marker type 0x%02xApplication transferred too few scanlinesWrite failed on temporary file --- out of disk space?Seek failed on temporary fileRead failed on temporary fileFailed to create temporary file %sInvalid JPEG file structure: SOS before SOFInvalid JPEG file structure: two SOI markersUnsupported JPEG process: SOF type 0x%02xInvalid JPEG file structure: missing SOS markerInvalid JPEG file structure: two SOF markersCannot quantize to more than %d colorsCannot quantize to fewer than %d colorsCannot quantize more than %d color componentsInsufficient memory (case %d)Not a JPEG file: starts with 0x%02x 0x%02xQuantization table 0x%02x was not definedJPEG datastream contains no imageHuffman table 0x%02x was not definedBacking store not supportedRequested feature was omitted at compile timeNot implemented yetInvalid color quantization mode changeScan script does not transmit all dataCannot transcode due to multiple use of quantization table %dPremature end of input fileEmpty input fileMaximum supported image dimension is %u pixelsMissing Huffman code table entryHuffman code size table overflowFractional sampling not implemented yetOutput file write error --- out of disk space?Input file read errorDidn't expect more than one scanWrite to EMS failedRead from EMS failedEmpty JPEG image (DNL not supported)Bogus DQT index %dBogus DHT index %dBogus DAC value 0x%xBogus DAC index %dUnsupported color conversion requestToo many color components: %d, max %dCCIR601 sampling not implemented yetSuspension not allowed hereBuffer passed to JPEG library is too smallBogus virtual array accessJPEG parameter struct mismatch: library thinks size is %u, caller expects %uImproper call to JPEG library in state %dInvalid scan script at entry %dBogus sampling factorsInvalid progressive parameters at scan script entry %dInvalid progressive parameters Ss=%d Se=%d Ah=%d Al=%dUnsupported JPEG data precision %dInvalid memory pool code %dSampling factors too large for interleaved scanWrong JPEG library version: library is %d, caller expects %dBogus marker lengthBogus JPEG colorspaceBogus input colorspaceBogus Huffman table definitionIDCT output block size %d not supportedDCT coefficient out of rangeInvalid component ID %d in SOSBogus buffer control modeMAX_ALLOC_CHUNK is wrong, please fixALIGN_TYPE is wrong, please fixSorry, there are legal restrictions on arithmetic codingBogus message code %d%s @>€ˆJPEGMEM%ld%cehyy¬yÄ{w`wh{<y¸00¿ÿó<0¿ÿðH0¿ÿíT0¿ÿê`0¿ÿçl0¿ÿäx0¿ÿá„0¿ÿÞ0¿ÿÛœ0¿ÿب0¿ÿÕ´0¿ÿÒÀ0¿ÿÏÌ0¿ÿÌØ0¿ÿÉä0¿ÿÆð0¿ÿÃü0¿ÿÀ0¿ÿ½0¿ÿº 0¿ÿ·,0¿ÿ´80¿ÿ±D0¿ÿ®P0¿ÿ«\0¿ÿ¨h0¿ÿ¥â O” O°oÿÿþ€oÿÿÿèÈ ·˜ oÿýüwŒDÄ h yÀÿÿÿÿÿÿÿÿ|e  e Dx4 (D¬L 8DøH HE@TXE”œ - etF0 - eG@è - e¬H(( - eÈIP¬ - eäLüH - eMDH - eMŒ€ - e8N ( - eÿñÔè˜È€ ÄO” O° OÈ wl wŒ yy¬y´y¼yÄ{ c~˜ÿñÿñÿñ%y¬)y´7y¼E|[|jyÄ}y°‹ø–<¡{ª¶ÿñ¾{8ÊOа ß{4è{0öH¸ü-T´" TH$y°6.ÀHÿñP6@`9,lr5ü8XÔ’6Ðä£7´¤µ5üDÄÿñÌ;t´Ù>ä âLX\ô;tK„h>L˜"=¨0<(ô7=ĈF?ðdQAT 0]KìllÿñvOd\ƒVl•Od¤R”ˆµQ`ÃQð¤ÕPÀ äÿñìW€ûÿñ^„¼Yœè%iÀ$7W€FYˆWXøea@€tW€ƒÿñŽtDPŸn<¬­n<¼s4Åu”`ÒoèLßÿñè{÷ÿñ~°t|d*ÿñ5ˆØD‹ÄVÿña’xs’P‚”8Ž’P(š“¨ªÿñµ•DÉ¢ˆ8á•Dð¥À`œL8„.ÿñ8±¬ÐH±ˆ$Z§œi±pz§œPˆ«ìÄ—¯°hª³|€ÁÿñÌòlðÙäpîí ôüÚôœ ´˜¶ è ×ð(´˜l0¿ìh8Ð8¸@ÈTäHçp°TïX`ápný”T‚ùø(–ô\œ£ÿñ¬,¼]°@ ȬàHüë¬ú]ð@ ÿñ„$"^0@ .)äŒC(ÜXg€€^p@ Ž#¸P¢¨¶ÿñÁ;„Ñ@@Pé2ÌÀþ2Ì <Œì&4Œð:=xÈT9Ô°h7|X€ÿñ‹HžOÔ«H€¸BˆÇC,$ØCÜ$ëQÜ Ð CPŒ Kœl $Bˆ¤ 3ÿñ >d܈ Sb bbà sfd¼ †cäø ™ÿñ ¤it ³^°€ ¿itX Ê_0@ Ûÿñ æoÈ õÿñ |À ÿñ ˆ )ÿñ 4˜h Cÿñ N­ ˆ [ª(< oª( ~¬è$ Œ²˜  °|˜ ´¬À( Ưl Ô®”Ø âªd\ ïÿñ ù¿¸ô ¹D ½„ ,¾äÔ =¹ L¾œH ^Á¬ p»Ô° €ÿñ ŠÙ¨H ÓÔt ­Ê\è ½ÕH ÑÉœ` ÞÆ° íßÌ8 Æ°ì _€ %Ïðl 8×PX MÍD¬ _ÒD nÑ\4 „Éü` ˜Ü𤠫`€  ·ß¼ ËÝ”( Þÿñ èÌL õ ú„  òØP !üÐ 2áTD CíD´ Ný¤è `áT o ¼( …ïøà “ã ´ ž ð ®ÿŒ€ ¾ô(\ Ñ☄ èãt ü(”ÿñì44 ¨DH ¨W˜j ä} ä’œ§ÿñ±˜ÀÿñÉ8Øÿñá`ÀîØýØ@ 8!X('H6ÿñ@)(ØM'dÄZ3|g1€üt?€‚wH ’"<¡<°à«9œ¾5€”Ñ"<Lß%Дë"ˆH÷w@ ,øˆ+üü/+üCÿñNC@]ÿñew` kwh qDøH|{<„D¬L“Dx4¢IP¬³H((ÄyÄÔE@TßF0êE”œóG@èüÿñ{O4+O4:y´HOˆSyÀ`y¸mÿñt©˜‚³üœ™t¨aÐô ¿xpÅøð×oÈ øç{@ð~˜õ|<(˜¼ D @%{.}X@!3LüHIxRwl h„l|{C¼$‹{H “xô™w¼ wÈ¥8@³~xË|4Û”Hüêxdò˜h ¤|À PTLxÄ$x ,ÿà>ˆXNO” T@ølxsx4yh T‘§(t©Vˆø»xˆÁ äÄ×Á¼ôïx”ô @4 ´¬ä°(#wì*MDHFyô Ux\x¸iŒÔ`}y†käX–—H²‡ÈÉ}X@ψØ8åCl$õýè 1p\†|”5N (GàP]wÔcû tzxP„èh—{@!Ÿ!€¼®ìLÄDLÒxÐ×|díCà,Ž4Ä L*9˜Ü:nÌüLMŒ€dxÜk£ „yC@,ˆ{wŒ ©wø¯xL¶äÈÐ…è”ä_¬XüDÀwk OÈ #@04x(;~”Q{H !XÈxp0È4uM´°…x¬‹„¢Dh°x@µxX¾x|Å|(Ðxèצ éƒ$HúO° C,È´! t¸2wà:`Œ@ djpegcrti.svalues-Xa.ccrtstuff.cp.2__CTOR_LIST____DTOR_LIST____do_global_dtors_auxgcc2_compiled.__EH_FRAME_BEGIN__force_to_datafini_dummyinit_dummyobject.7frame_dummydjpeg.coutfilenamecdjpeg_message_tableprognamerequested_fmtusagejpeg_getcparse_switchesgcc2_compiled.printed_version.4print_text_markerwrppm.ccopy_pixel_rowsfinish_output_ppmgcc2_compiled.start_output_ppmput_demapped_rgbput_demapped_grayput_pixel_rowswrgif.cflush_packetput_wordfinish_output_gifgcc2_compiled.start_output_gifcompress_termcompress_initoutputcompress_pixelput_3bytesemit_headerput_pixel_rowswrtarga.cwrite_headerfinish_output_tgagcc2_compiled.start_output_tgaput_gray_rowsput_demapped_grayput_pixel_rowswrrle.cgcc2_compiled.wrbmp.cwrite_os2_headerwrite_bmp_headerfinish_output_bmpgcc2_compiled.start_output_bmpput_gray_rowswrite_colormapput_pixel_rowsrdcolmap.cread_pbm_integeradd_map_entrygcc2_compiled.pbm_getcread_ppm_mapread_gif_mapcdjpeg.cgcc2_compiled.jdapimin.cdefault_decompress_parmsgcc2_compiled.jdapistd.cgcc2_compiled.output_pass_setupjdatasrc.cfill_input_buffergcc2_compiled.term_sourceinit_sourceskip_input_datajdmaster.cuse_merged_upsampleprepare_for_output_passgcc2_compiled.finish_output_passprepare_range_limit_tablemaster_selectionjdinput.cconsume_markersfinish_input_passgcc2_compiled.start_input_passinitial_setupper_scan_setuplatch_quant_tablesreset_input_controllerjdmarker.cfirst_markerget_interesting_appnskip_variableexamine_app0gcc2_compiled.get_sofget_driget_soiget_sosget_dqtget_dhtsave_markernext_markerexamine_app14reset_marker_readerread_restart_markerread_markersjdhuff.cprocess_restartextend_teststart_pass_huff_decoderdecode_mcugcc2_compiled.extend_offsetjdphuff.cprocess_restartextend_testdecode_mcu_AC_refinedecode_mcu_DC_refinegcc2_compiled.start_pass_phuff_decoderextend_offsetdecode_mcu_AC_firstdecode_mcu_DC_firstjdmainct.cstart_pass_mainprocess_data_crank_postalloc_funny_pointersgcc2_compiled.process_data_simple_mainmake_funny_pointersprocess_data_context_mainset_bottom_pointersset_wraparound_pointersjdcoefct.cdummy_consume_datasmoothing_okconsume_datagcc2_compiled.start_input_passdecompress_onepassdecompress_smooth_datastart_output_passdecompress_datastart_iMCU_rowjdpostct.cpost_process_prepassgcc2_compiled.start_pass_dpostpost_process_2passpost_process_1passjddctmgr.cgcc2_compiled.aanscales.2start_passaanscalefactor.3jidctfst.cgcc2_compiled.jidctflt.cgcc2_compiled.jidctint.cgcc2_compiled.jidctred.cgcc2_compiled.jdsample.cint_upsamplestart_pass_upsamplegcc2_compiled.noop_upsampleh2v2_fancy_upsampleh2v1_fancy_upsamplefullsize_upsampleh2v2_upsampleh2v1_upsamplesep_upsamplejdcolor.cycck_cmyk_convertbuild_ycc_rgb_tablenull_convertgray_rgb_convertgcc2_compiled.grayscale_convertstart_pass_dcolorycc_rgb_convertjquant1.cquantize_fs_dithercolor_quantize3create_colormapquantize_ord_ditheroutput_valuegcc2_compiled.new_color_map_1_quantselect_ncolorsbase_dither_matrixmake_odither_arrayquantize3_ord_dithercreate_colorindexcolor_quantizecreate_odither_tableslargest_input_valuealloc_fs_workspaceRGB_order.2finish_pass_1_quantstart_pass_1_quantjquant2.cfinish_pass1finish_pass2find_best_colorsselect_colorsinit_error_limitprescan_quantizemedian_cutfill_inverse_cmapgcc2_compiled.new_color_map_2_quantcompute_colorupdate_boxpass2_fs_ditherpass2_no_ditherfind_nearby_colorsfind_biggest_color_popfind_biggest_volumestart_pass_2_quantjdmerge.cstart_pass_merged_upsamplebuild_ycc_rgb_tablegcc2_compiled.merged_1v_upsamplemerged_2v_upsampleh2v2_merged_upsampleh2v1_merged_upsamplejcomapi.cgcc2_compiled.jutils.cgcc2_compiled.jerror.cemit_messagegcc2_compiled.error_exitformat_messagereset_error_mgroutput_messagejmemmgr.calloc_barrayalloc_sarraydo_barray_iodo_sarray_ioself_destructextra_pool_slopgcc2_compiled.free_poolaccess_virt_barrayaccess_virt_sarrayout_of_memoryalloc_largealloc_smallfirst_pool_sloprealize_virt_arraysrequest_virt_barrayrequest_virt_sarrayjmemnobs.cgcc2_compiled.frame.c.LLC0.LLC1fde_insertobjectsdecode_sleb128decode_uleb128execute_cfa_insnextract_cie_info__FRAME_BEGIN__count_fdesframe_initadd_fdesfind_fdecrtstuff.c__FRAME_END____do_global_ctors_auxgcc2_compiled.force_to_datainit_dummy__DTOR_END____CTOR_END__crtn.sjpeg_idct_1x1jinit_input_controller_start_START_jpeg_std_message_tablefreadjpeg_start_outputjpeg_idct_ifast_environ_endwrite_stdoutjpeg_abortjpeg_open_backing_storekeymatch_iob__register_frame_info__flsbuf_GLOBAL_OFFSET_TABLE_jpeg_consume_inputjpeg_free_large__ctypeabortatexitexitjdiv_round_upjpeg_destroy_decompressjcopy_block_rowjpeg_stdio_srctolowerjpeg_idct_4x4jpeg_idct_floatjpeg_destroymallocsprintfjpeg_save_markersjpeg_idct_islow_initjinit_d_main_controllerfwrite.umuljinit_d_post_controllerjinit_master_decompressjinit_write_targa.uremjinit_2pass_quantizerjinit_color_deconverter.remjpeg_fill_bit_bufferjinit_upsamplerjzero_farsscanf__register_frame_info_tableread_color_mapfclosegetenv_END_jpeg_read_scanlines_DYNAMICjinit_write_bmpjpeg_calc_output_dimensionsjpeg_finish_decompress__iobjpeg_start_decompressjpeg_free_smalljinit_marker_readerjinit_phuff_decoderjpeg_has_multiple_scans__frame_state_forjinit_1pass_quantizer_exitjpeg_resync_to_restartjround_upjpeg_finish_outputenvironjpeg_std_errorjpeg_alloc_huff_tablejpeg_mem_initfreejpeg_CreateDecompressjpeg_mem_availablejpeg_read_raw_datajpeg_alloc_quant_tablejinit_write_ppmjinit_inverse_dct__deregister_frame_infostrcmpjpeg_idct_2x2jpeg_get_small_edata_PROCEDURE_LINKAGE_TABLE_fopenmemsetjpeg_set_marker_processorjpeg_input_completejinit_d_coef_controllerjinit_huff_decoder_etext_lib_versionjinit_memory_mgrfflushjpeg_abort_decompress_ctypejpeg_make_d_derived_tblmainjinit_write_gif.udivjinit_merged_upsamplerjpeg_mem_term.div__filbufmemcpyread_stdinstrlenjpeg_new_colormapjpeg_read_header_finijpeg_get_largejcopy_sample_rowsjpeg_huff_decodefprintfjpeg_natural_orderas: WorkShop Compilers 4.X dev 18 Sep 1996 as: WorkShop Compilers 4.X dev 18 Sep 1996 @(#)SunOS 5.6 Generic August 1997as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 GCC: (GNU) 2.8.1as: WorkShop Compilers 4.X dev 18 Sep 1996 ld: Software Generation Utilities - Solaris/ELF (3.0); <I4œ,Ù dDx"dDx,<;€e€€®€Ï€õ€A€€³€Ý€€(€B€]€~€·€Ú€þ€(€<‚F‚]‚u‚z‚’‚¦‚»‚Ѐ€€Ž€.€¢„‚¢¢¢¢¢’‚¢¢¢¢£‚¢®‚¢º‚À .€ ƒ€ ý€-€z€Á€¶€”€€€‘€‚€<€†€å€?€¯€€n€ï€ ,€!€!ƒ€#q€$b€¢$÷‚%€v% €¨%5€ó%K€ ¢%`‚%h€&j€&…€¢'=€2'Q€3'e€4'y€5'€6'¢€( €(€L( €)&€)|$iDx)“@h)§@h )¸$4)¹$~D¬)Ð@})Ü@} )í$L)î€*<$ÂDø*O@Á*m@Á *w@Á *ˆ$H*‰$ÏE@*œ@Î*­$T*®$áE”*¿@ß*Ð@ß*Þ@ß*ô@à+ @à+$œ+$ÿF0+0@þ+<$+=$'G@+N@&+Y$è+Z$RH(+s@Q+}@Q+$(+$IP+©@}+³@}+Á@~+Î@~+Ù$¬+Ú$ùLü+ø@ø,@ø,$H,$ MD,7@ ,E@ ,Q$H,R$MŒ,r@,€$€,$4N ,£@3,µ@3,Æ$(,Ç(P{<,ØdO4.interp.hash.dynsym.dynstr.SUNW_version.rela.bss.rela.plt.text.init.fini.rodata.got.plt.dynamic.data.ctors.dtors.eh_frame.bss.symtab.strtab.comment.stab.index.stab.shstrtab.stab.indexstr.stabstrvalues-Xa.cXt ; O ; V=3.1 ; R=WorkShop Compilers 4.2 30 Oct 1996 C 4.2/space/respin/usr/src/lib/libc; /ws/on297-tools/SUNWspro/SC4.2/bin/../SC4.2/bin/cc -xO3 -xcg89 -Wa,-cg92 -xspace -W0,-Lt -Xt -Iinc -DTEXT_DOMAIN='"SUNW_OST_OSLIB"' -I/space/respin/proto/root_sparc/usr/include -c port/gen/values-Xa.c -W0,-xpframe.c/ext1/SOURCES/gcc-2.8.1/./frame.cgcc2_compiled.int:t(0,1)=r(0,1);-2147483648;2147483647;char:t(0,2)=r(0,2);0;127;long int:t(0,3)=r(0,3);-2147483648;2147483647;unsigned int:t(0,4)=r(0,4);0;-1;long unsigned int:t(0,5)=r(0,5);0;-1;long long int:t(0,6)=r(0,1);01000000000000000000000;0777777777777777777777;long long unsigned int:t(0,7)=r(0,1);0000000000000;01777777777777777777777;short int:t(0,8)=r(0,8);-32768;32767;short unsigned int:t(0,9)=r(0,9);0;65535;signed char:t(0,10)=r(0,10);-128;127;unsigned char:t(0,11)=r(0,11);0;255;float:t(0,12)=r(0,1);4;0;double:t(0,13)=r(0,1);8;0;long double:t(0,14)=r(0,1);16;0;complex int:t(0,15)=s8real:(0,1),0,32;imag:(0,1),32,32;;complex float:t(0,16)=r(0,16);4;0;complex double:t(0,17)=r(0,17);8;0;complex long double:t(0,18)=r(0,18);16;0;void:t(0,19)=(0,19)tconfig.hconfig/sparc/xm-sol2.hconfig/sparc/xm-sysv4.htm.hconfig/sparc/sol2-sld.hconfig/sparc/sol2.hconfig/sparc/sysv4.hconfig/sparc/sparc.hcmodel:T(8,1)=eCM_32:0,CM_MEDLOW:1,CM_MEDMID:2,CM_MEDANY:3,CM_EMBMEDANY:4,;processor_type:T(8,2)=ePROCESSOR_V7:0,PROCESSOR_CYPRESS:1,PROCESSOR_V8:2,PROCESSOR_SUPERSPARC:3,PROCESSOR_SPARCLITE:4,PROCESSOR_F930:5,PROCESSOR_F934:6,PROCESSOR_SPARCLET:7,PROCESSOR_TSC701:8,PROCESSOR_V8PLUS:9,PROCESSOR_V9:10,PROCESSOR_ULTRASPARC:11,;sparc_cpu_select:T(8,3)=s16string:(8,4)=*(0,2),0,32;name:(8,4),32,32;set_tune_p:(0,1),64,32;set_arch_p:(0,1),96,32;;reg_class:T(8,5)=eNO_REGS:0,FPCC_REGS:1,GENERAL_REGS:2,FP_REGS:3,EXTRA_FP_REGS:4,GENERAL_OR_FP_REGS:5,GENERAL_OR_EXTRA_FP_REGS:6,ALL_REGS:7,LIM_REG_CLASSES:8,;sparc_args:T(8,6)=s12words:(0,1),0,32;prototype_p:(0,1),32,32;libcall_p:(0,1),64,32;;config/svr4.hconfig/xm-svr4.hdefaults.hgansidecl.hdwarf2.hdwarf_tag:T(13,1)=eDW_TAG_padding:0,DW_TAG_array_type:1,DW_TAG_class_type:2,DW_TAG_entry_point:3,DW_TAG_enumeration_type:4,DW_TAG_formal_parameter:5,DW_TAG_imported_declaration:8,DW_TAG_label:10,DW_TAG_lexical_block:11,DW_TAG_member:13,DW_TAG_pointer_type:15,DW_TAG_reference_type:16,DW_TAG_compile_unit:17,DW_TAG_string_type:18,DW_TAG_structure_type:19,DW_TAG_subroutine_type:21,DW_TAG_typedef:22,DW_TAG_union_type:23,DW_TAG_unspecified_parameters:24,DW_TAG_variant:25,DW_TAG_common_block:26,DW_TAG_common_inclusion:27,DW_TAG_inheritance:28,DW_TAG_inlined_subroutine:29,DW_TAG_module:30,DW_TAG_ptr_to_member_type:31,\DW_TAG_set_type:32,DW_TAG_subrange_type:33,DW_TAG_with_stmt:34,DW_TAG_access_declaration:35,DW_TAG_base_type:36,DW_TAG_catch_block:37,DW_TAG_const_type:38,DW_TAG_constant:39,DW_TAG_enumerator:40,DW_TAG_file_type:41,DW_TAG_friend:42,DW_TAG_namelist:43,DW_TAG_namelist_item:44,DW_TAG_packed_type:45,DW_TAG_subprogram:46,DW_TAG_template_type_param:47,DW_TAG_template_value_param:48,DW_TAG_thrown_type:49,DW_TAG_try_block:50,DW_TAG_variant_part:51,DW_TAG_variable:52,DW_TAG_volatile_type:53,DW_TAG_MIPS_loop:16513,DW_TAG_format_label:16641,DW_TAG_function_template:16642,DW_TAG_class_template:16643,;dwarf_form:T(13,2)=eDW_FORM_addr:1,DW_FORM_block2:3,DW_FORM_block4:4,DW_FORM_data2:5,DW_FORM_data4:6,DW_FORM_data8:7,DW_FORM_string:8,DW_FORM_block:9,DW_FORM_block1:10,DW_FORM_data1:11,DW_FORM_flag:12,DW_FORM_sdata:13,DW_FORM_strp:14,DW_FORM_udata:15,DW_FORM_ref_addr:16,DW_FORM_ref1:17,DW_FORM_ref2:18,DW_FORM_ref4:19,DW_FORM_ref8:20,DW_FORM_ref_udata:21,DW_FORM_indirect:22,;dwarf_attribute:T(13,3)=eDW_AT_sibling:1,DW_AT_location:2,DW_AT_name:3,DW_AT_ordering:9,DW_AT_subscr_data:10,DW_AT_byte_size:11,DW_AT_bit_offset:12,DW_AT_bit_size:13,DW_AT_element_list:15,DW_AT_stmt_list:16,DW_AT_low_pc:17,DW_AT_high_pc:18,DW_AT_language:19,DW_AT_member:20,DW_AT_discr:21,DW_AT_discr_value:22,DW_AT_visibility:23,DW_AT_import:24,DW_AT_string_length:25,DW_AT_common_reference:26,DW_AT_comp_dir:27,DW_AT_const_value:28,DW_AT_containing_type:29,DW_AT_default_value:30,DW_AT_inline:32,DW_AT_is_optional:33,DW_AT_lower_bound:34,DW_AT_producer:37,\DW_AT_prototyped:39,DW_AT_return_addr:42,DW_AT_start_scope:44,DW_AT_stride_size:46,DW_AT_upper_bound:47,DW_AT_abstract_origin:49,DW_AT_accessibility:50,DW_AT_address_class:51,DW_AT_artificial:52,DW_AT_base_types:53,DW_AT_calling_convention:54,DW_AT_count:55,DW_AT_data_member_location:56,DW_AT_decl_column:57,DW_AT_decl_file:58,DW_AT_decl_line:59,DW_AT_declaration:60,DW_AT_discr_list:61,DW_AT_encoding:62,DW_AT_external:63,DW_AT_frame_base:64,DW_AT_friend:65,DW_AT_identifier_case:66,DW_AT_macro_info:67,DW_AT_namelist_items:68,DW_AT_priority:69,DW_AT_segment:70,DW_AT_specification:71,\DW_AT_static_link:72,DW_AT_type:73,DW_AT_use_location:74,DW_AT_variable_parameter:75,DW_AT_virtuality:76,DW_AT_vtable_elem_location:77,DW_AT_MIPS_fde:8193,DW_AT_MIPS_loop_begin:8194,DW_AT_MIPS_tail_loop_begin:8195,DW_AT_MIPS_epilog_begin:8196,DW_AT_MIPS_loop_unroll_factor:8197,DW_AT_MIPS_software_pipeline_depth:8198,DW_AT_MIPS_linkage_name:8199,DW_AT_MIPS_stride:8200,DW_AT_MIPS_abstract_name:8201,DW_AT_MIPS_clone_origin:8202,DW_AT_MIPS_has_inlines:8203,DW_AT_sf_names:8449,DW_AT_src_info:8450,DW_AT_mac_info:8451,DW_AT_src_coords:8452,DW_AT_body_begin:8453,DW_AT_body_end:8454,;dwarf_location_atom:T(13,4)=eDW_OP_addr:3,DW_OP_deref:6,DW_OP_const1u:8,DW_OP_const1s:9,DW_OP_const2u:10,DW_OP_const2s:11,DW_OP_const4u:12,DW_OP_const4s:13,DW_OP_const8u:14,DW_OP_const8s:15,DW_OP_constu:16,DW_OP_consts:17,DW_OP_dup:18,DW_OP_drop:19,DW_OP_over:20,DW_OP_pick:21,DW_OP_swap:22,DW_OP_rot:23,DW_OP_xderef:24,DW_OP_abs:25,DW_OP_and:26,DW_OP_div:27,DW_OP_minus:28,DW_OP_mod:29,DW_OP_mul:30,DW_OP_neg:31,DW_OP_not:32,DW_OP_or:33,DW_OP_plus:34,DW_OP_plus_uconst:35,DW_OP_shl:36,DW_OP_shr:37,\DW_OP_shra:38,DW_OP_xor:39,DW_OP_bra:40,DW_OP_eq:41,DW_OP_ge:42,DW_OP_gt:43,DW_OP_le:44,DW_OP_lt:45,DW_OP_ne:46,DW_OP_skip:47,DW_OP_lit0:48,DW_OP_lit1:49,DW_OP_lit2:50,DW_OP_lit3:51,DW_OP_lit4:52,DW_OP_lit5:53,DW_OP_lit6:54,DW_OP_lit7:55,DW_OP_lit8:56,DW_OP_lit9:57,DW_OP_lit10:58,DW_OP_lit11:59,DW_OP_lit12:60,DW_OP_lit13:61,DW_OP_lit14:62,DW_OP_lit15:63,DW_OP_lit16:64,DW_OP_lit17:65,DW_OP_lit18:66,DW_OP_lit19:67,DW_OP_lit20:68,DW_OP_lit21:69,DW_OP_lit22:70,DW_OP_lit23:71,\DW_OP_lit24:72,DW_OP_lit25:73,DW_OP_lit26:74,DW_OP_lit27:75,DW_OP_lit28:76,DW_OP_lit29:77,DW_OP_lit30:78,DW_OP_lit31:79,DW_OP_reg0:80,DW_OP_reg1:81,DW_OP_reg2:82,DW_OP_reg3:83,DW_OP_reg4:84,DW_OP_reg5:85,DW_OP_reg6:86,DW_OP_reg7:87,DW_OP_reg8:88,DW_OP_reg9:89,DW_OP_reg10:90,DW_OP_reg11:91,DW_OP_reg12:92,DW_OP_reg13:93,DW_OP_reg14:94,DW_OP_reg15:95,DW_OP_reg16:96,DW_OP_reg17:97,DW_OP_reg18:98,DW_OP_reg19:99,DW_OP_reg20:100,DW_OP_reg21:101,DW_OP_reg22:102,DW_OP_reg23:103,DW_OP_reg24:104,\DW_OP_reg25:105,DW_OP_reg26:106,DW_OP_reg27:107,DW_OP_reg28:108,DW_OP_reg29:109,DW_OP_reg30:110,DW_OP_reg31:111,DW_OP_breg0:112,DW_OP_breg1:113,DW_OP_breg2:114,DW_OP_breg3:115,DW_OP_breg4:116,DW_OP_breg5:117,DW_OP_breg6:118,DW_OP_breg7:119,DW_OP_breg8:120,DW_OP_breg9:121,DW_OP_breg10:122,DW_OP_breg11:123,DW_OP_breg12:124,DW_OP_breg13:125,DW_OP_breg14:126,DW_OP_breg15:127,DW_OP_breg16:128,DW_OP_breg17:129,DW_OP_breg18:130,DW_OP_breg19:131,DW_OP_breg20:132,DW_OP_breg21:133,DW_OP_breg22:134,DW_OP_breg23:135,DW_OP_breg24:136,\DW_OP_breg25:137,DW_OP_breg26:138,DW_OP_breg27:139,DW_OP_breg28:140,DW_OP_breg29:141,DW_OP_breg30:142,DW_OP_breg31:143,DW_OP_regx:144,DW_OP_fbreg:145,DW_OP_bregx:146,DW_OP_piece:147,DW_OP_deref_size:148,DW_OP_xderef_size:149,DW_OP_nop:150,;dwarf_type:T(13,5)=eDW_ATE_void:0,DW_ATE_address:1,DW_ATE_boolean:2,DW_ATE_complex_float:3,DW_ATE_float:4,DW_ATE_signed:5,DW_ATE_signed_char:6,DW_ATE_unsigned:7,DW_ATE_unsigned_char:8,;dwarf_array_dim_ordering:T(13,6)=eDW_ORD_row_major:0,DW_ORD_col_major:1,;dwarf_access_attribute:T(13,7)=eDW_ACCESS_public:1,DW_ACCESS_protected:2,DW_ACCESS_private:3,;dwarf_visibility_attribute:T(13,8)=eDW_VIS_local:1,DW_VIS_exported:2,DW_VIS_qualified:3,;dwarf_virtuality_attribute:T(13,9)=eDW_VIRTUALITY_none:0,DW_VIRTUALITY_virtual:1,DW_VIRTUALITY_pure_virtual:2,;dwarf_id_case:T(13,10)=eDW_ID_case_sensitive:0,DW_ID_up_case:1,DW_ID_down_case:2,DW_ID_case_insensitive:3,;dwarf_calling_convention:T(13,11)=eDW_CC_normal:1,DW_CC_program:2,DW_CC_nocall:3,;dwarf_inline_attribute:T(13,12)=eDW_INL_not_inlined:0,DW_INL_inlined:1,DW_INL_declared_not_inlined:2,DW_INL_declared_inlined:3,;dwarf_discrim_list:T(13,13)=eDW_DSC_label:0,DW_DSC_range:1,;dwarf_line_number_ops:T(13,14)=eDW_LNS_extended_op:0,DW_LNS_copy:1,DW_LNS_advance_pc:2,DW_LNS_advance_line:3,DW_LNS_set_file:4,DW_LNS_set_column:5,DW_LNS_negate_stmt:6,DW_LNS_set_basic_block:7,DW_LNS_const_add_pc:8,DW_LNS_fixed_advance_pc:9,;dwarf_line_number_x_ops:T(13,15)=eDW_LNE_end_sequence:1,DW_LNE_set_address:2,DW_LNE_define_file:3,;dwarf_call_frame_info:T(13,16)=eDW_CFA_advance_loc:64,DW_CFA_offset:128,DW_CFA_restore:192,DW_CFA_nop:0,DW_CFA_set_loc:1,DW_CFA_advance_loc1:2,DW_CFA_advance_loc2:3,DW_CFA_advance_loc4:4,DW_CFA_offset_extended:5,DW_CFA_restore_extended:6,DW_CFA_undefined:7,DW_CFA_same_value:8,DW_CFA_register:9,DW_CFA_remember_state:10,DW_CFA_restore_state:11,DW_CFA_def_cfa:12,DW_CFA_def_cfa_register:13,DW_CFA_def_cfa_offset:14,DW_CFA_MIPS_advance_loc8:29,DW_CFA_GNU_window_save:45,DW_CFA_GNU_args_size:46,;dwarf_source_language:T(13,17)=eDW_LANG_C89:1,DW_LANG_C:2,DW_LANG_Ada83:3,DW_LANG_C_plus_plus:4,DW_LANG_Cobol74:5,DW_LANG_Cobol85:6,DW_LANG_Fortran77:7,DW_LANG_Fortran90:8,DW_LANG_Pascal83:9,DW_LANG_Modula2:10,DW_LANG_Mips_Assembler:32769,;dwarf_macinfo_record_type:T(13,18)=eDW_MACINFO_define:1,DW_MACINFO_undef:2,DW_MACINFO_start_file:3,DW_MACINFO_end_file:4,DW_MACINFO_vendor_ext:255,;include/stddef.hptrdiff_t:t(14,1)=(0,1)size_t:t(14,2)=(0,4)wchar_t:t(14,3)=(0,3)wint_t:t(14,4)=(0,4)frame.hframe_state:T(15,1)=s532cfa:(15,2)=*(0,19),0,32;eh_ptr:(15,2),32,32;cfa_offset:(0,3),64,32;args_size:(0,3),96,32;reg_or_offset:(15,3)=ar(0,0);0;101;(0,3),128,3264;cfa_reg:(0,9),3392,16;retaddr_column:(0,9),3408,16;saved:(15,4)=ar(0,0);0;101;(0,2),3424,816;;frame_state:t(15,5)=(15,1)object:T(15,6)=s24pc_begin:(15,2),0,32;pc_end:(15,2),32,32;fde_begin:(15,7)=*(15,8)=xsdwarf_fde:,64,32;fde_array:(15,9)=*(15,7),96,32;count:(14,2),128,32;next:(15,10)=*(15,6),160,32;;sword:t(0,20)=(0,1)uword:t(0,21)=(0,4)uaddr:t(0,22)=(0,4)saddr:t(0,23)=(0,1)ubyte:t(0,24)=(0,11)dwarf_cie:T(0,25)=s12length:(0,21),0,32;CIE_id:(0,20),32,32;version:(0,24),64,8;augmentation:(0,26)=ar(0,0);0;-1;(0,2),72,0;;dwarf_fde:T(15,8)=s16length:(0,21),0,32;CIE_delta:(0,20),32,32;pc_begin:(15,2),64,32;pc_range:(0,22),96,32;;fde:t(0,27)=(15,8)cie_info:T(0,28)=s20augmentation:(8,4),0,32;eh_ptr:(15,2),32,32;code_align:(0,1),64,32;data_align:(0,1),96,32;ra_regno:(0,4),128,32;;frame_state_internal:T(0,29)=s536s:(15,1),0,4256;saved_state:(0,30)=*(0,29),4256,32;;decode_uleb128:f(15,2)buf:P(0,31)=*(0,11)r:P(0,32)=*(0,4)decode_sleb128:f(15,2)buf:P(0,31)r:P(0,33)=*(0,1)unaligned:T(0,34)=u8p:(15,2),0,32;b2:(0,9),0,16;b4:(0,4),0,32;b8:(0,7),0,64;;fde_insert:f(0,19)array:P(0,35)=*(0,36)=*(0,27)i:P(14,2)this_fde:P(0,36)count_fdes:f(14,2)this_fde:P(0,36)add_fdes:f(0,19)this_fde:P(0,36)array:P(0,35)i_ptr:P(0,37)=*(14,2)beg_ptr:P(0,38)=*(15,2)end_ptr:P(0,38)frame_init:f(0,19)ob:P(15,10)find_fde:f(0,36)pc:P(15,2)extract_cie_info:f(15,2)f:P(0,36)c:P(0,39)=*(0,28)execute_cfa_insn:f(15,2)p:P(15,2)state:P(0,30)info:P(0,39)pc:P(0,38)__register_frame_info:F(0,19)begin:P(15,2)ob:P(15,10)__register_frame_info_table:F(0,19)begin:P(15,2)ob:P(15,10)__deregister_frame_info:F(0,19)begin:P(15,2)__frame_state_for:F(0,40)=*(15,1)pc_target:P(15,2)state_in:P(0,40)objects:S(15,10)ÔÔ èè° ˜˜ 0ÈÈ ·oÿÿþ€€ -  $ 7ÄÄD  A1ŒGO”O”MO°O°SOÈOÈ'£[wlwl `wŒwŒx eyy¨ny¬y¬ty´y´{y¼y¼‚yÄyÄTŒ{{€‘{I™—M¡¯e Öª¹<$ ¶¹`\ ¼À¼ÞÆÁš;ÕÂÕ,ÙPapyrus3/JpegDir/JpgLossy/WRBMP.C0000755000175000017500000003402307535143454013634 0ustar /* * wrbmp.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to write output images in Microsoft "BMP" * format (MS Windows 3.x and OS/2 1.x flavors). * Either 8-bit colormapped or 24-bit full-color format can be written. * No compression is supported. * * These routines may need modification for non-Unix environments or * specialized applications. As they stand, they assume output to * an ordinary stdio stream. * * This code contributed by James Arthur Boucher. */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ #ifdef BMP_SUPPORTED /* * To support 12-bit JPEG data, we'd have to scale output down to 8 bits. * This is not yet implemented. */ #if BITS_IN_JSAMPLE != 8 Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */ #endif /* * Since BMP stores scanlines bottom-to-top, we have to invert the image * from JPEG's top-to-bottom order. To do this, we save the outgoing data * in a virtual array during put_pixel_row calls, then actually emit the * BMP file during finish_output. The virtual array contains one JSAMPLE per * pixel if the output is grayscale or colormapped, three if it is full color. */ /* Private version of data destination object */ typedef struct { struct djpeg_dest_struct pub; /* public fields */ boolean is_os2; /* saves the OS2 format request flag */ jvirt_sarray_ptr whole_image; /* needed to reverse row order */ JDIMENSION data_width; /* JSAMPLEs per row */ JDIMENSION row_width; /* physical width of one row in the BMP file */ int pad_bytes; /* number of padding bytes needed per row */ JDIMENSION cur_output_row; /* next row# to write to virtual array */ } bmp_dest_struct; typedef bmp_dest_struct * bmp_dest_ptr; /* Forward declarations */ LOCAL(void) write_colormap JPP((j_decompress_ptr cinfo, bmp_dest_ptr dest, int map_colors, int map_entry_size)); /* * Write some pixel data. * In this module rows_supplied will always be 1. */ METHODDEF(void) put_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied) /* This version is for writing 24-bit pixels */ { bmp_dest_ptr dest = (bmp_dest_ptr) dinfo; JSAMPARRAY image_ptr; register JSAMPROW inptr, outptr; register JDIMENSION col; int pad; /* Access next row in virtual array */ image_ptr = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, dest->whole_image, dest->cur_output_row, (JDIMENSION) 1, TRUE); dest->cur_output_row++; /* Transfer data. Note destination values must be in BGR order * (even though Microsoft's own documents say the opposite). */ inptr = dest->pub.buffer[0]; outptr = image_ptr[0]; for (col = cinfo->output_width; col > 0; col--) { outptr[2] = *inptr++; /* can omit GETJSAMPLE() safely */ outptr[1] = *inptr++; outptr[0] = *inptr++; outptr += 3; } /* Zero out the pad bytes. */ pad = dest->pad_bytes; while (--pad >= 0) *outptr++ = 0; } METHODDEF(void) put_gray_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied) /* This version is for grayscale OR quantized color output */ { bmp_dest_ptr dest = (bmp_dest_ptr) dinfo; JSAMPARRAY image_ptr; register JSAMPROW inptr, outptr; register JDIMENSION col; int pad; /* Access next row in virtual array */ image_ptr = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, dest->whole_image, dest->cur_output_row, (JDIMENSION) 1, TRUE); dest->cur_output_row++; /* Transfer data. */ inptr = dest->pub.buffer[0]; outptr = image_ptr[0]; for (col = cinfo->output_width; col > 0; col--) { *outptr++ = *inptr++; /* can omit GETJSAMPLE() safely */ } /* Zero out the pad bytes. */ pad = dest->pad_bytes; while (--pad >= 0) *outptr++ = 0; } /* * Startup: normally writes the file header. * In this module we may as well postpone everything until finish_output. */ METHODDEF(void) start_output_bmp (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) { /* no work here */ } /* * Finish up at the end of the file. * * Here is where we really output the BMP file. * * First, routines to write the Windows and OS/2 variants of the file header. */ LOCAL(void) write_bmp_header (j_decompress_ptr cinfo, bmp_dest_ptr dest) /* Write a Windows-style BMP file header, including colormap if needed */ { char bmpfileheader[14]; char bmpinfoheader[40]; #define PUT_2B(array,offset,value) \ (array[offset] = (char) ((value) & 0xFF), \ array[offset+1] = (char) (((value) >> 8) & 0xFF)) #define PUT_4B(array,offset,value) \ (array[offset] = (char) ((value) & 0xFF), \ array[offset+1] = (char) (((value) >> 8) & 0xFF), \ array[offset+2] = (char) (((value) >> 16) & 0xFF), \ array[offset+3] = (char) (((value) >> 24) & 0xFF)) INT32 headersize, bfSize; int bits_per_pixel, cmap_entries; /* Compute colormap size and total file size */ if (cinfo->out_color_space == JCS_RGB) { if (cinfo->quantize_colors) { /* Colormapped RGB */ bits_per_pixel = 8; cmap_entries = 256; } else { /* Unquantized, full color RGB */ bits_per_pixel = 24; cmap_entries = 0; } } else { /* Grayscale output. We need to fake a 256-entry colormap. */ bits_per_pixel = 8; cmap_entries = 256; } /* File size */ headersize = 14 + 40 + cmap_entries * 4; /* Header and colormap */ bfSize = headersize + (INT32) dest->row_width * (INT32) cinfo->output_height; /* Set unused fields of header to 0 */ MEMZERO(bmpfileheader, SIZEOF(bmpfileheader)); MEMZERO(bmpinfoheader, SIZEOF(bmpinfoheader)); /* Fill the file header */ bmpfileheader[0] = 0x42; /* first 2 bytes are ASCII 'B', 'M' */ bmpfileheader[1] = 0x4D; PUT_4B(bmpfileheader, 2, bfSize); /* bfSize */ /* we leave bfReserved1 & bfReserved2 = 0 */ PUT_4B(bmpfileheader, 10, headersize); /* bfOffBits */ /* Fill the info header (Microsoft calls this a BITMAPINFOHEADER) */ PUT_2B(bmpinfoheader, 0, 40); /* biSize */ PUT_4B(bmpinfoheader, 4, cinfo->output_width); /* biWidth */ PUT_4B(bmpinfoheader, 8, cinfo->output_height); /* biHeight */ PUT_2B(bmpinfoheader, 12, 1); /* biPlanes - must be 1 */ PUT_2B(bmpinfoheader, 14, bits_per_pixel); /* biBitCount */ /* we leave biCompression = 0, for none */ /* we leave biSizeImage = 0; this is correct for uncompressed data */ if (cinfo->density_unit == 2) { /* if have density in dots/cm, then */ PUT_4B(bmpinfoheader, 24, (INT32) (cinfo->X_density*100)); /* XPels/M */ PUT_4B(bmpinfoheader, 28, (INT32) (cinfo->Y_density*100)); /* XPels/M */ } PUT_2B(bmpinfoheader, 32, cmap_entries); /* biClrUsed */ /* we leave biClrImportant = 0 */ if (JFWRITE(dest->pub.output_file, bmpfileheader, 14) != (size_t) 14) ERREXIT(cinfo, JERR_FILE_WRITE); if (JFWRITE(dest->pub.output_file, bmpinfoheader, 40) != (size_t) 40) ERREXIT(cinfo, JERR_FILE_WRITE); if (cmap_entries > 0) write_colormap(cinfo, dest, cmap_entries, 4); } LOCAL(void) write_os2_header (j_decompress_ptr cinfo, bmp_dest_ptr dest) /* Write an OS2-style BMP file header, including colormap if needed */ { char bmpfileheader[14]; char bmpcoreheader[12]; INT32 headersize, bfSize; int bits_per_pixel, cmap_entries; /* Compute colormap size and total file size */ if (cinfo->out_color_space == JCS_RGB) { if (cinfo->quantize_colors) { /* Colormapped RGB */ bits_per_pixel = 8; cmap_entries = 256; } else { /* Unquantized, full color RGB */ bits_per_pixel = 24; cmap_entries = 0; } } else { /* Grayscale output. We need to fake a 256-entry colormap. */ bits_per_pixel = 8; cmap_entries = 256; } /* File size */ headersize = 14 + 12 + cmap_entries * 3; /* Header and colormap */ bfSize = headersize + (INT32) dest->row_width * (INT32) cinfo->output_height; /* Set unused fields of header to 0 */ MEMZERO(bmpfileheader, SIZEOF(bmpfileheader)); MEMZERO(bmpcoreheader, SIZEOF(bmpcoreheader)); /* Fill the file header */ bmpfileheader[0] = 0x42; /* first 2 bytes are ASCII 'B', 'M' */ bmpfileheader[1] = 0x4D; PUT_4B(bmpfileheader, 2, bfSize); /* bfSize */ /* we leave bfReserved1 & bfReserved2 = 0 */ PUT_4B(bmpfileheader, 10, headersize); /* bfOffBits */ /* Fill the info header (Microsoft calls this a BITMAPCOREHEADER) */ PUT_2B(bmpcoreheader, 0, 12); /* bcSize */ PUT_2B(bmpcoreheader, 4, cinfo->output_width); /* bcWidth */ PUT_2B(bmpcoreheader, 6, cinfo->output_height); /* bcHeight */ PUT_2B(bmpcoreheader, 8, 1); /* bcPlanes - must be 1 */ PUT_2B(bmpcoreheader, 10, bits_per_pixel); /* bcBitCount */ if (JFWRITE(dest->pub.output_file, bmpfileheader, 14) != (size_t) 14) ERREXIT(cinfo, JERR_FILE_WRITE); if (JFWRITE(dest->pub.output_file, bmpcoreheader, 12) != (size_t) 12) ERREXIT(cinfo, JERR_FILE_WRITE); if (cmap_entries > 0) write_colormap(cinfo, dest, cmap_entries, 3); } /* * Write the colormap. * Windows uses BGR0 map entries; OS/2 uses BGR entries. */ LOCAL(void) write_colormap (j_decompress_ptr cinfo, bmp_dest_ptr dest, int map_colors, int map_entry_size) { JSAMPARRAY colormap = cinfo->colormap; int num_colors = cinfo->actual_number_of_colors; FILE * outfile = dest->pub.output_file; int i; if (colormap != NULL) { if (cinfo->out_color_components == 3) { /* Normal case with RGB colormap */ for (i = 0; i < num_colors; i++) { putc(GETJSAMPLE(colormap[2][i]), outfile); putc(GETJSAMPLE(colormap[1][i]), outfile); putc(GETJSAMPLE(colormap[0][i]), outfile); if (map_entry_size == 4) putc(0, outfile); } } else { /* Grayscale colormap (only happens with grayscale quantization) */ for (i = 0; i < num_colors; i++) { putc(GETJSAMPLE(colormap[0][i]), outfile); putc(GETJSAMPLE(colormap[0][i]), outfile); putc(GETJSAMPLE(colormap[0][i]), outfile); if (map_entry_size == 4) putc(0, outfile); } } } else { /* If no colormap, must be grayscale data. Generate a linear "map". */ for (i = 0; i < 256; i++) { putc(i, outfile); putc(i, outfile); putc(i, outfile); if (map_entry_size == 4) putc(0, outfile); } } /* Pad colormap with zeros to ensure specified number of colormap entries */ if (i > map_colors) ERREXIT1(cinfo, JERR_TOO_MANY_COLORS, i); for (; i < map_colors; i++) { putc(0, outfile); putc(0, outfile); putc(0, outfile); if (map_entry_size == 4) putc(0, outfile); } } METHODDEF(void) finish_output_bmp (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) { bmp_dest_ptr dest = (bmp_dest_ptr) dinfo; register FILE * outfile = dest->pub.output_file; JSAMPARRAY image_ptr; register JSAMPROW data_ptr; JDIMENSION row; register JDIMENSION col; cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; /* Write the header and colormap */ if (dest->is_os2) write_os2_header(cinfo, dest); else write_bmp_header(cinfo, dest); /* Write the file body from our virtual array */ for (row = cinfo->output_height; row > 0; row--) { if (progress != NULL) { progress->pub.pass_counter = (long) (cinfo->output_height - row); progress->pub.pass_limit = (long) cinfo->output_height; (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); } image_ptr = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, dest->whole_image, row-1, (JDIMENSION) 1, FALSE); data_ptr = image_ptr[0]; for (col = dest->row_width; col > 0; col--) { putc(GETJSAMPLE(*data_ptr), outfile); data_ptr++; } } if (progress != NULL) progress->completed_extra_passes++; /* Make sure we wrote the output file OK */ fflush(outfile); if (ferror(outfile)) ERREXIT(cinfo, JERR_FILE_WRITE); } /* * The module selection routine for BMP format output. */ GLOBAL(djpeg_dest_ptr) jinit_write_bmp (j_decompress_ptr cinfo, boolean is_os2) { bmp_dest_ptr dest; JDIMENSION row_width; /* Create module interface object, fill in method pointers */ dest = (bmp_dest_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(bmp_dest_struct)); dest->pub.start_output = start_output_bmp; dest->pub.finish_output = finish_output_bmp; dest->is_os2 = is_os2; if (cinfo->out_color_space == JCS_GRAYSCALE) { dest->pub.put_pixel_rows = put_gray_rows; } else if (cinfo->out_color_space == JCS_RGB) { if (cinfo->quantize_colors) dest->pub.put_pixel_rows = put_gray_rows; else dest->pub.put_pixel_rows = put_pixel_rows; } else { ERREXIT(cinfo, JERR_BMP_COLORSPACE); } /* Calculate output image dimensions so we can allocate space */ jpeg_calc_output_dimensions(cinfo); /* Determine width of rows in the BMP file (padded to 4-byte boundary). */ row_width = cinfo->output_width * cinfo->output_components; dest->data_width = row_width; while ((row_width & 3) != 0) row_width++; dest->row_width = row_width; dest->pad_bytes = (int) (row_width - dest->data_width); /* Allocate space for inversion array, prepare for write pass */ dest->whole_image = (*cinfo->mem->request_virt_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, row_width, cinfo->output_height, (JDIMENSION) 1); dest->cur_output_row = 0; if (cinfo->progress != NULL) { cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; progress->total_extra_passes++; /* count file input as separate pass */ } /* Create decompressor output buffer. */ dest->pub.buffer = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, row_width, (JDIMENSION) 1); dest->pub.buffer_height = 1; return (djpeg_dest_ptr) dest; } #endif /* BMP_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/MAKEFILE.BCC0000755000175000017500000003453507535143454014337 0ustar # Makefile for Independent JPEG Group's software # This makefile is suitable for Borland C on MS-DOS or OS/2. # It works with Borland C++ for DOS, revision 3.0 or later, # and has been tested with Borland C++ for OS/2. # Watch out for optimization bugs in the OS/2 compilers --- see notes below! # Thanks to Tom Wright and Ge' Weijers (original DOS) and # Ken Porter (OS/2) for this file. # Read installation instructions before saying "make" !! # Are we under DOS or OS/2? !if !$d(DOS) && !$d(OS2) !if $d(__OS2__) OS2=1 !else DOS=1 !endif !endif # The name of your C compiler: CC= bcc # You may need to adjust these cc options: !if $d(DOS) CFLAGS= -O2 -mm -w-par -w-stu -w-ccc -w-rch !else CFLAGS= -O1 -w-par -w-stu -w-ccc -w-rch !endif # -O2 enables full code optimization (for pre-3.0 Borland C++, use -O -G -Z). # -O2 is buggy in Borland OS/2 C++ revision 2.0, so use -O1 there for now. # If you have Borland OS/2 C++ revision 1.0, use -O or no optimization at all. # -mm selects medium memory model (near data, far code pointers; DOS only!) # -w-par suppresses warnings about unused function parameters # -w-stu suppresses warnings about incomplete structures # -w-ccc suppresses warnings about compile-time-constant conditions # -w-rch suppresses warnings about unreachable code # Generally, we recommend defining any configuration symbols in jconfig.h, # NOT via -D switches here. # Link-time cc options: !if $d(DOS) LDFLAGS= -mm # memory model option here must match CFLAGS! !else LDFLAGS= # -lai full-screen app # -lc case-significant link !endif # Put here the object file name for the correct system-dependent memory # manager file. # For DOS, we recommend jmemdos.c and jmemdosa.asm. # For OS/2, we recommend jmemnobs.c (flat memory!) # SYSDEPMEMLIB must list the same files with "+" signs for the librarian. !if $d(DOS) SYSDEPMEM= jmemdos.obj jmemdosa.obj SYSDEPMEMLIB= +jmemdos.obj +jmemdosa.obj !else SYSDEPMEM= jmemnobs.obj SYSDEPMEMLIB= +jmemnobs.obj !endif # End of configurable options. # source files: JPEG library proper LIBSOURCES= jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c \ jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c \ jcphuff.c jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c \ jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c \ jdinput.c jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c \ jdpostct.c jdsample.c jdtrans.c jerror.c jfdctflt.c jfdctfst.c \ jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c jquant1.c \ jquant2.c jutils.c jmemmgr.c # memmgr back ends: compile only one of these into a working library SYSDEPSOURCES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemmac.c # source files: cjpeg/djpeg/jpegtran applications, also rdjpgcom/wrjpgcom APPSOURCES= cjpeg.c djpeg.c jpegtran.c rdjpgcom.c wrjpgcom.c cdjpeg.c \ rdcolmap.c rdswitch.c transupp.c rdppm.c wrppm.c rdgif.c wrgif.c \ rdtarga.c wrtarga.c rdbmp.c wrbmp.c rdrle.c wrrle.c SOURCES= $(LIBSOURCES) $(SYSDEPSOURCES) $(APPSOURCES) # files included by source files INCLUDES= jchuff.h jdhuff.h jdct.h jerror.h jinclude.h jmemsys.h jmorecfg.h \ jpegint.h jpeglib.h jversion.h cdjpeg.h cderror.h transupp.h # documentation, test, and support files DOCS= README install.doc usage.doc cjpeg.1 djpeg.1 jpegtran.1 rdjpgcom.1 \ wrjpgcom.1 wizard.doc example.c libjpeg.doc structure.doc \ coderules.doc filelist.doc change.log MKFILES= configure makefile.cfg makefile.ansi makefile.unix makefile.bcc \ makefile.mc6 makefile.dj makefile.wat makefile.vc makelib.ds \ makeapps.ds makeproj.mac makcjpeg.st makdjpeg.st makljpeg.st \ maktjpeg.st makefile.manx makefile.sas makefile.mms makefile.vms \ makvms.opt CONFIGFILES= jconfig.cfg jconfig.bcc jconfig.mc6 jconfig.dj jconfig.wat \ jconfig.vc jconfig.mac jconfig.st jconfig.manx jconfig.sas \ jconfig.vms CONFIGUREFILES= config.guess config.sub install-sh ltconfig ltmain.sh OTHERFILES= jconfig.doc ckconfig.c ansi2knr.c ansi2knr.1 jmemdosa.asm TESTFILES= testorig.jpg testimg.ppm testimg.bmp testimg.jpg testprog.jpg \ testimgp.jpg DISTFILES= $(DOCS) $(MKFILES) $(CONFIGFILES) $(SOURCES) $(INCLUDES) \ $(CONFIGUREFILES) $(OTHERFILES) $(TESTFILES) # library object files common to compression and decompression COMOBJECTS= jcomapi.obj jutils.obj jerror.obj jmemmgr.obj $(SYSDEPMEM) # compression library object files CLIBOBJECTS= jcapimin.obj jcapistd.obj jctrans.obj jcparam.obj jdatadst.obj \ jcinit.obj jcmaster.obj jcmarker.obj jcmainct.obj jcprepct.obj \ jccoefct.obj jccolor.obj jcsample.obj jchuff.obj jcphuff.obj \ jcdctmgr.obj jfdctfst.obj jfdctflt.obj jfdctint.obj # decompression library object files DLIBOBJECTS= jdapimin.obj jdapistd.obj jdtrans.obj jdatasrc.obj \ jdmaster.obj jdinput.obj jdmarker.obj jdhuff.obj jdphuff.obj \ jdmainct.obj jdcoefct.obj jdpostct.obj jddctmgr.obj jidctfst.obj \ jidctflt.obj jidctint.obj jidctred.obj jdsample.obj jdcolor.obj \ jquant1.obj jquant2.obj jdmerge.obj # These objectfiles are included in libjpeg.lib LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS) # object files for sample applications (excluding library files) COBJECTS= cjpeg.obj rdppm.obj rdgif.obj rdtarga.obj rdrle.obj rdbmp.obj \ rdswitch.obj cdjpeg.obj DOBJECTS= djpeg.obj wrppm.obj wrgif.obj wrtarga.obj wrrle.obj wrbmp.obj \ rdcolmap.obj cdjpeg.obj TROBJECTS= jpegtran.obj rdswitch.obj cdjpeg.obj transupp.obj all: libjpeg.lib cjpeg.exe djpeg.exe jpegtran.exe rdjpgcom.exe wrjpgcom.exe libjpeg.lib: $(LIBOBJECTS) - del libjpeg.lib tlib libjpeg.lib /E /C @&&| +jcapimin.obj +jcapistd.obj +jctrans.obj +jcparam.obj +jdatadst.obj & +jcinit.obj +jcmaster.obj +jcmarker.obj +jcmainct.obj +jcprepct.obj & +jccoefct.obj +jccolor.obj +jcsample.obj +jchuff.obj +jcphuff.obj & +jcdctmgr.obj +jfdctfst.obj +jfdctflt.obj +jfdctint.obj +jdapimin.obj & +jdapistd.obj +jdtrans.obj +jdatasrc.obj +jdmaster.obj +jdinput.obj & +jdmarker.obj +jdhuff.obj +jdphuff.obj +jdmainct.obj +jdcoefct.obj & +jdpostct.obj +jddctmgr.obj +jidctfst.obj +jidctflt.obj +jidctint.obj & +jidctred.obj +jdsample.obj +jdcolor.obj +jquant1.obj +jquant2.obj & +jdmerge.obj +jcomapi.obj +jutils.obj +jerror.obj +jmemmgr.obj & $(SYSDEPMEMLIB) | cjpeg.exe: $(COBJECTS) libjpeg.lib $(CC) $(LDFLAGS) -ecjpeg.exe $(COBJECTS) libjpeg.lib djpeg.exe: $(DOBJECTS) libjpeg.lib $(CC) $(LDFLAGS) -edjpeg.exe $(DOBJECTS) libjpeg.lib jpegtran.exe: $(TROBJECTS) libjpeg.lib $(CC) $(LDFLAGS) -ejpegtran.exe $(TROBJECTS) libjpeg.lib rdjpgcom.exe: rdjpgcom.c !if $d(DOS) $(CC) -ms -O rdjpgcom.c !else $(CC) $(CFLAGS) rdjpgcom.c !endif # On DOS, wrjpgcom needs large model so it can malloc a 64K chunk wrjpgcom.exe: wrjpgcom.c !if $d(DOS) $(CC) -ml -O wrjpgcom.c !else $(CC) $(CFLAGS) wrjpgcom.c !endif # This "{}" syntax allows Borland Make to "batch" source files. # In this way, each run of the compiler can build many modules. .c.obj: $(CC) $(CFLAGS) -c{ $<} jconfig.h: jconfig.doc echo You must prepare a system-dependent jconfig.h file. echo Please read the installation directions in install.doc. exit 1 clean: - del *.obj - del libjpeg.lib - del cjpeg.exe - del djpeg.exe - del jpegtran.exe - del rdjpgcom.exe - del wrjpgcom.exe - del testout*.* test: cjpeg.exe djpeg.exe jpegtran.exe - del testout*.* djpeg -dct int -ppm -outfile testout.ppm testorig.jpg djpeg -dct int -bmp -colors 256 -outfile testout.bmp testorig.jpg cjpeg -dct int -outfile testout.jpg testimg.ppm djpeg -dct int -ppm -outfile testoutp.ppm testprog.jpg cjpeg -dct int -progressive -opt -outfile testoutp.jpg testimg.ppm jpegtran -outfile testoutt.jpg testprog.jpg !if $d(DOS) fc /b testimg.ppm testout.ppm fc /b testimg.bmp testout.bmp fc /b testimg.jpg testout.jpg fc /b testimg.ppm testoutp.ppm fc /b testimgp.jpg testoutp.jpg fc /b testorig.jpg testoutt.jpg !else echo n > n.tmp comp testimg.ppm testout.ppm < n.tmp comp testimg.bmp testout.bmp < n.tmp comp testimg.jpg testout.jpg < n.tmp comp testimg.ppm testoutp.ppm < n.tmp comp testimgp.jpg testoutp.jpg < n.tmp comp testorig.jpg testoutt.jpg < n.tmp del n.tmp !endif jcapimin.obj: jcapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcapistd.obj: jcapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccoefct.obj: jccoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccolor.obj: jccolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcdctmgr.obj: jcdctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jchuff.obj: jchuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcinit.obj: jcinit.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmainct.obj: jcmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmarker.obj: jcmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmaster.obj: jcmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcomapi.obj: jcomapi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcparam.obj: jcparam.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcphuff.obj: jcphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcprepct.obj: jcprepct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcsample.obj: jcsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jctrans.obj: jctrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapimin.obj: jdapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapistd.obj: jdapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdatadst.obj: jdatadst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdatasrc.obj: jdatasrc.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdcoefct.obj: jdcoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdcolor.obj: jdcolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jddctmgr.obj: jddctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jdhuff.obj: jdhuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdinput.obj: jdinput.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmainct.obj: jdmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmarker.obj: jdmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmaster.obj: jdmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmerge.obj: jdmerge.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdphuff.obj: jdphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdpostct.obj: jdpostct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdsample.obj: jdsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdtrans.obj: jdtrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jerror.obj: jerror.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jversion.h jerror.h jfdctflt.obj: jfdctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctfst.obj: jfdctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctint.obj: jfdctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctflt.obj: jidctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctfst.obj: jidctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctint.obj: jidctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctred.obj: jidctred.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jquant1.obj: jquant1.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jquant2.obj: jquant2.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jutils.obj: jutils.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemmgr.obj: jmemmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemansi.obj: jmemansi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemname.obj: jmemname.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemnobs.obj: jmemnobs.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemdos.obj: jmemdos.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemmac.obj: jmemmac.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h cjpeg.obj: cjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h djpeg.obj: djpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h jpegtran.obj: jpegtran.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.h jversion.h rdjpgcom.obj: rdjpgcom.c jinclude.h jconfig.h wrjpgcom.obj: wrjpgcom.c jinclude.h jconfig.h cdjpeg.obj: cdjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdcolmap.obj: rdcolmap.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdswitch.obj: rdswitch.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.obj: transupp.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h transupp.h rdppm.obj: rdppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrppm.obj: wrppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdgif.obj: rdgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrgif.obj: wrgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdtarga.obj: rdtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrtarga.obj: wrtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdbmp.obj: rdbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrbmp.obj: wrbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdrle.obj: rdrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrrle.obj: wrrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jmemdosa.obj: jmemdosa.asm tasm /mx jmemdosa.asm Papyrus3/JpegDir/JpgLossy/JCONFIG.H0000755000175000017500000000254207535143454014032 0ustar /* jconfig.vc --- jconfig.h for Microsoft Visual C++ on Windows 95 or NT. */ /* see jconfig.doc for explanations */ #define HAVE_PROTOTYPES #define HAVE_UNSIGNED_CHAR #define HAVE_UNSIGNED_SHORT /* #define void char */ /* #define const */ #undef CHAR_IS_UNSIGNED #define HAVE_STDDEF_H #define HAVE_STDLIB_H #undef NEED_BSD_STRINGS #undef NEED_SYS_TYPES_H #undef NEED_FAR_POINTERS /* we presume a 32-bit flat memory model */ #undef NEED_SHORT_EXTERNAL_NAMES #undef INCOMPLETE_TYPES_BROKEN /* Define "boolean" as unsigned char, not int, per Windows custom */ #ifndef __RPCNDR_H__ /* don't conflict if rpcndr.h already read */ typedef unsigned char boolean; #endif #define HAVE_BOOLEAN /* prevent jmorecfg.h from redefining it */ #ifdef JPEG_INTERNALS #undef RIGHT_SHIFT_IS_UNSIGNED #endif /* JPEG_INTERNALS */ #ifdef JPEG_CJPEG_DJPEG #define BMP_SUPPORTED /* BMP image file format */ #define GIF_SUPPORTED /* GIF image file format */ #define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ #undef RLE_SUPPORTED /* Utah RLE image file format */ #define TARGA_SUPPORTED /* Targa image file format */ #define TWO_FILE_COMMANDLINE /* optional */ #define USE_SETMODE /* Microsoft has setmode() */ #undef NEED_SIGNAL_CATCHER #undef DONT_USE_B_MODE #undef PROGRESS_REPORT /* optional */ #endif /* JPEG_CJPEG_DJPEG */ Papyrus3/JpegDir/JpgLossy/makefile.manx0000755000175000017500000002724107535143454015307 0ustar # Makefile for Independent JPEG Group's software # This makefile is for Amiga systems using Manx Aztec C ver 5.x. # Thanks to D.J. James (djjames@cup.portal.com) for this version. # Read installation instructions before saying "make" !! # The name of your C compiler: CC= cc # You may need to adjust these cc options: # Uncomment for generic 68000 code (will work on any Amiga) ARCHFLAGS= -sn # Uncomment for 68020/68030 code (faster, but won't run on 68000 CPU) #ARCHFLAGS= -c2 CFLAGS= -MC -MD $(ARCHFLAGS) -spfam -r4 # Link-time cc options: LDFLAGS= -g # To link any special libraries, add the necessary -l commands here. LDLIBS= -lml -lcl # Put here the object file name for the correct system-dependent memory # manager file. For Amiga we recommend jmemname.o. SYSDEPMEM= jmemname.o # miscellaneous OS-dependent stuff # linker LN= ln # file deletion command RM= delete quiet # library (.lib) file creation command AR= lb # End of configurable options. # source files: JPEG library proper LIBSOURCES= jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c \ jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c \ jcphuff.c jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c \ jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c \ jdinput.c jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c \ jdpostct.c jdsample.c jdtrans.c jerror.c jfdctflt.c jfdctfst.c \ jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c jquant1.c \ jquant2.c jutils.c jmemmgr.c # memmgr back ends: compile only one of these into a working library SYSDEPSOURCES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemmac.c # source files: cjpeg/djpeg/jpegtran applications, also rdjpgcom/wrjpgcom APPSOURCES= cjpeg.c djpeg.c jpegtran.c rdjpgcom.c wrjpgcom.c cdjpeg.c \ rdcolmap.c rdswitch.c transupp.c rdppm.c wrppm.c rdgif.c wrgif.c \ rdtarga.c wrtarga.c rdbmp.c wrbmp.c rdrle.c wrrle.c SOURCES= $(LIBSOURCES) $(SYSDEPSOURCES) $(APPSOURCES) # files included by source files INCLUDES= jchuff.h jdhuff.h jdct.h jerror.h jinclude.h jmemsys.h jmorecfg.h \ jpegint.h jpeglib.h jversion.h cdjpeg.h cderror.h transupp.h # documentation, test, and support files DOCS= README install.doc usage.doc cjpeg.1 djpeg.1 jpegtran.1 rdjpgcom.1 \ wrjpgcom.1 wizard.doc example.c libjpeg.doc structure.doc \ coderules.doc filelist.doc change.log MKFILES= configure makefile.cfg makefile.ansi makefile.unix makefile.bcc \ makefile.mc6 makefile.dj makefile.wat makefile.vc makelib.ds \ makeapps.ds makeproj.mac makcjpeg.st makdjpeg.st makljpeg.st \ maktjpeg.st makefile.manx makefile.sas makefile.mms makefile.vms \ makvms.opt CONFIGFILES= jconfig.cfg jconfig.bcc jconfig.mc6 jconfig.dj jconfig.wat \ jconfig.vc jconfig.mac jconfig.st jconfig.manx jconfig.sas \ jconfig.vms CONFIGUREFILES= config.guess config.sub install-sh ltconfig ltmain.sh OTHERFILES= jconfig.doc ckconfig.c ansi2knr.c ansi2knr.1 jmemdosa.asm TESTFILES= testorig.jpg testimg.ppm testimg.bmp testimg.jpg testprog.jpg \ testimgp.jpg DISTFILES= $(DOCS) $(MKFILES) $(CONFIGFILES) $(SOURCES) $(INCLUDES) \ $(CONFIGUREFILES) $(OTHERFILES) $(TESTFILES) # library object files common to compression and decompression COMOBJECTS= jcomapi.o jutils.o jerror.o jmemmgr.o $(SYSDEPMEM) # compression library object files CLIBOBJECTS= jcapimin.o jcapistd.o jctrans.o jcparam.o jdatadst.o jcinit.o \ jcmaster.o jcmarker.o jcmainct.o jcprepct.o jccoefct.o jccolor.o \ jcsample.o jchuff.o jcphuff.o jcdctmgr.o jfdctfst.o jfdctflt.o \ jfdctint.o # decompression library object files DLIBOBJECTS= jdapimin.o jdapistd.o jdtrans.o jdatasrc.o jdmaster.o \ jdinput.o jdmarker.o jdhuff.o jdphuff.o jdmainct.o jdcoefct.o \ jdpostct.o jddctmgr.o jidctfst.o jidctflt.o jidctint.o jidctred.o \ jdsample.o jdcolor.o jquant1.o jquant2.o jdmerge.o # These objectfiles are included in libjpeg.lib LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS) # object files for sample applications (excluding library files) COBJECTS= cjpeg.o rdppm.o rdgif.o rdtarga.o rdrle.o rdbmp.o rdswitch.o \ cdjpeg.o DOBJECTS= djpeg.o wrppm.o wrgif.o wrtarga.o wrrle.o wrbmp.o rdcolmap.o \ cdjpeg.o TROBJECTS= jpegtran.o rdswitch.o cdjpeg.o transupp.o all: libjpeg.lib cjpeg djpeg jpegtran rdjpgcom wrjpgcom libjpeg.lib: $(LIBOBJECTS) -$(RM) libjpeg.lib $(AR) libjpeg.lib $(LIBOBJECTS) cjpeg: $(COBJECTS) libjpeg.lib $(LN) $(LDFLAGS) -o cjpeg $(COBJECTS) libjpeg.lib $(LDLIBS) djpeg: $(DOBJECTS) libjpeg.lib $(LN) $(LDFLAGS) -o djpeg $(DOBJECTS) libjpeg.lib $(LDLIBS) jpegtran: $(TROBJECTS) libjpeg.lib $(LN) $(LDFLAGS) -o jpegtran $(TROBJECTS) libjpeg.lib $(LDLIBS) rdjpgcom: rdjpgcom.o $(LN) $(LDFLAGS) -o rdjpgcom rdjpgcom.o $(LDLIBS) wrjpgcom: wrjpgcom.o $(LN) $(LDFLAGS) -o wrjpgcom wrjpgcom.o $(LDLIBS) jconfig.h: jconfig.doc echo You must prepare a system-dependent jconfig.h file. echo Please read the installation directions in install.doc. exit 1 clean: -$(RM) *.o cjpeg djpeg jpegtran libjpeg.lib rdjpgcom wrjpgcom -$(RM) core testout*.* test: cjpeg djpeg jpegtran -$(RM) testout*.* djpeg -dct int -ppm -outfile testout.ppm testorig.jpg djpeg -dct int -bmp -colors 256 -outfile testout.bmp testorig.jpg cjpeg -dct int -outfile testout.jpg testimg.ppm djpeg -dct int -ppm -outfile testoutp.ppm testprog.jpg cjpeg -dct int -progressive -opt -outfile testoutp.jpg testimg.ppm jpegtran -outfile testoutt.jpg testprog.jpg cmp testimg.ppm testout.ppm cmp testimg.bmp testout.bmp cmp testimg.jpg testout.jpg cmp testimg.ppm testoutp.ppm cmp testimgp.jpg testoutp.jpg cmp testorig.jpg testoutt.jpg jcapimin.o: jcapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcapistd.o: jcapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccoefct.o: jccoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccolor.o: jccolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcdctmgr.o: jcdctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jchuff.o: jchuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcinit.o: jcinit.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmainct.o: jcmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmarker.o: jcmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmaster.o: jcmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcomapi.o: jcomapi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcparam.o: jcparam.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcphuff.o: jcphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcprepct.o: jcprepct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcsample.o: jcsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jctrans.o: jctrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapimin.o: jdapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapistd.o: jdapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdatadst.o: jdatadst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdatasrc.o: jdatasrc.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdcoefct.o: jdcoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdcolor.o: jdcolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jddctmgr.o: jddctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jdhuff.o: jdhuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdinput.o: jdinput.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmainct.o: jdmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmarker.o: jdmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmaster.o: jdmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmerge.o: jdmerge.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdphuff.o: jdphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdpostct.o: jdpostct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdsample.o: jdsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdtrans.o: jdtrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jerror.o: jerror.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jversion.h jerror.h jfdctflt.o: jfdctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctfst.o: jfdctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctint.o: jfdctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctflt.o: jidctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctfst.o: jidctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctint.o: jidctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctred.o: jidctred.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jquant1.o: jquant1.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jquant2.o: jquant2.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jutils.o: jutils.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemmgr.o: jmemmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemansi.o: jmemansi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemname.o: jmemname.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemnobs.o: jmemnobs.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemdos.o: jmemdos.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemmac.o: jmemmac.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h cjpeg.o: cjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h djpeg.o: djpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h jpegtran.o: jpegtran.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.h jversion.h rdjpgcom.o: rdjpgcom.c jinclude.h jconfig.h wrjpgcom.o: wrjpgcom.c jinclude.h jconfig.h cdjpeg.o: cdjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdcolmap.o: rdcolmap.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdswitch.o: rdswitch.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.o: transupp.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h transupp.h rdppm.o: rdppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrppm.o: wrppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdgif.o: rdgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrgif.o: wrgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdtarga.o: rdtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrtarga.o: wrtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdbmp.o: rdbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrbmp.o: wrbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdrle.o: rdrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrrle.o: wrrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h Papyrus3/JpegDir/JpgLossy/VSSVER.SCC0000755000175000017500000000246007535143454014223 0ustar 4Ðm¼\óÒ³s`—˜Ë5+¥4¨tœh¶Í<Ý5¬€Úpê <Ý6Ûr¶Í<Ý7F®ÛǶÍ<Ý8EÐœŸ¶Í<Ý9 €™C¶Í<Ý:è~ê¶Í<Ý;¯ž“l¶Í<Ý<Üðd¶Í<Ý=¾IŽô¶Í<Ý>rèy•¶Í<Ý?ΔO¶Í<Ý@(}¶Í<ÝA”Ùl6¶Í<ÝBz@9†¶Í<ÝC *4K¶Í<ÝDáäQt¶Í<ÝEX¸~`a<ÝF¦P·@a<ÝGÞáƒa<ÝHpƒ§Óa<ÝIìÔ•÷a<ÝJj’@a<ÝK¹·’~a<ÝL ³Ö¨a<ÝMŒÕœ a<ÝNŽ>Éa<ÝOÊÉa<ÝP¹&Û¾a<ÝQ!6¿*a<ÝRajî—a<ÝScE-a<ÝToŠÅPa<ÝU±[ƒa<ÝV)í`a<ÝW+Q°a<ÝXØ£1Ca<ÝY뼀 a<ÝZ¤;na<Ý[ËeûY-uÛ<Ý\½ôMa<Ý]&P¹qa<Ý^¬¼=¢a<Ý_AEAža<Ý`Áh k<ÝaE˜ D k<ÝbŽ± k<ÝcoúÍ{ k<Ýd¯gA k<Ýe@@cö™)<ÝfX›´º_P£<Ýg^ƒÉ_P£<Ýh@€«_P£<Ýi  ( k<ÝjJ-µ k<Ýk_n²¢ k<Ýl6X8PÃÃXíme¡—) k<Ýn;0†Gí¦ª<Ýoöj8hÔ« <Ýp:Ãa k<Ýq¼ðp¹ k<ÝrÏ£ k<Ýs Vè4ZÃ<Ýt2w;2_P£<ÝuÃ]Pg_P£<ÝvŽ€_P£<Ýw•˜g÷_P£<Ýx Ïg’_P£<ÝyùÖØŸ_P£<Ýzœ\wT_P£<Ý{áÕì_P£<Ý|(¯_P£<Ý}äëým/lD<Ý~;fum‰‹I<ݶa§ m´ØH<Ýš;E²ÂmvJ<Ý›Òߨøm=GM<Ýœ.©“À?¸<Ý;3??¸<Ýž©Â–›?¸<ÝPapyrus3/JpegDir/JpgLossy/JMEMANSI.C0000755000175000017500000001125107535143454014146 0ustar /* * jmemansi.c * * Copyright (C) 1992-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file provides a simple generic implementation of the system- * dependent portion of the JPEG memory manager. This implementation * assumes that you have the ANSI-standard library routine tmpfile(). * Also, the problem of determining the amount of memory available * is shoved onto the user. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jmemsys.h" /* import the system-dependent declarations */ #ifndef HAVE_STDLIB_H /* should declare malloc(),free() */ extern void * malloc JPP((size_t size)); extern void free JPP((void *ptr)); #endif #ifndef SEEK_SET /* pre-ANSI systems may not define this; */ #define SEEK_SET 0 /* if not, assume 0 is correct */ #endif /* * Memory allocation and freeing are controlled by the regular library * routines malloc() and free(). */ GLOBAL(void *) jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject) { return (void *) malloc(sizeofobject); } GLOBAL(void) jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject) { free(object); } /* * "Large" objects are treated the same as "small" ones. * NB: although we include FAR keywords in the routine declarations, * this file won't actually work in 80x86 small/medium model; at least, * you probably won't be able to process useful-size images in only 64KB. */ GLOBAL(void FAR *) jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject) { return (void FAR *) malloc(sizeofobject); } GLOBAL(void) jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject) { free(object); } /* * This routine computes the total memory space available for allocation. * It's impossible to do this in a portable way; our current solution is * to make the user tell us (with a default value set at compile time). * If you can actually get the available space, it's a good idea to subtract * a slop factor of 5% or so. */ #ifndef DEFAULT_MAX_MEM /* so can override from makefile */ #define DEFAULT_MAX_MEM 1000000L /* default: one megabyte */ #endif GLOBAL(long) jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed, long max_bytes_needed, long already_allocated) { return cinfo->mem->max_memory_to_use - already_allocated; } /* * Backing store (temporary file) management. * Backing store objects are only used when the value returned by * jpeg_mem_available is less than the total space needed. You can dispense * with these routines if you have plenty of virtual memory; see jmemnobs.c. */ METHODDEF(void) read_backing_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { if (fseek(info->temp_file, file_offset, SEEK_SET)) ERREXIT(cinfo, JERR_TFILE_SEEK); if (JFREAD(info->temp_file, buffer_address, byte_count) != (size_t) byte_count) ERREXIT(cinfo, JERR_TFILE_READ); } METHODDEF(void) write_backing_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { if (fseek(info->temp_file, file_offset, SEEK_SET)) ERREXIT(cinfo, JERR_TFILE_SEEK); if (JFWRITE(info->temp_file, buffer_address, byte_count) != (size_t) byte_count) ERREXIT(cinfo, JERR_TFILE_WRITE); } METHODDEF(void) close_backing_store (j_common_ptr cinfo, backing_store_ptr info) { fclose(info->temp_file); /* Since this implementation uses tmpfile() to create the file, * no explicit file deletion is needed. */ } /* * Initial opening of a backing-store object. * * This version uses tmpfile(), which constructs a suitable file name * behind the scenes. We don't have to use info->temp_name[] at all; * indeed, we can't even find out the actual name of the temp file. */ GLOBAL(void) jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed) { if ((info->temp_file = tmpfile()) == NULL) ERREXITS(cinfo, JERR_TFILE_CREATE, ""); info->read_backing_store = read_backing_store; info->write_backing_store = write_backing_store; info->close_backing_store = close_backing_store; } /* * These routines take care of any system-dependent initialization and * cleanup required. */ GLOBAL(long) jpeg_mem_init (j_common_ptr cinfo) { return DEFAULT_MAX_MEM; /* default for max_memory_to_use */ } GLOBAL(void) jpeg_mem_term (j_common_ptr cinfo) { /* no work */ } Papyrus3/JpegDir/JpgLossy/JDMARKER.C0000755000175000017500000012275607535143454014157 0ustar /* * jdmarker.c * * Copyright (C) 1991-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to decode JPEG datastream markers. * Most of the complexity arises from our desire to support input * suspension: if not all of the data for a marker is available, * we must exit back to the application. On resumption, we reprocess * the marker. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" typedef enum { /* JPEG marker codes */ M_SOF0 = 0xc0, M_SOF1 = 0xc1, M_SOF2 = 0xc2, M_SOF3 = 0xc3, M_SOF5 = 0xc5, M_SOF6 = 0xc6, M_SOF7 = 0xc7, M_JPG = 0xc8, M_SOF9 = 0xc9, M_SOF10 = 0xca, M_SOF11 = 0xcb, M_SOF13 = 0xcd, M_SOF14 = 0xce, M_SOF15 = 0xcf, M_DHT = 0xc4, M_DAC = 0xcc, M_RST0 = 0xd0, M_RST1 = 0xd1, M_RST2 = 0xd2, M_RST3 = 0xd3, M_RST4 = 0xd4, M_RST5 = 0xd5, M_RST6 = 0xd6, M_RST7 = 0xd7, M_SOI = 0xd8, M_EOI = 0xd9, M_SOS = 0xda, M_DQT = 0xdb, M_DNL = 0xdc, M_DRI = 0xdd, M_DHP = 0xde, M_EXP = 0xdf, M_APP0 = 0xe0, M_APP1 = 0xe1, M_APP2 = 0xe2, M_APP3 = 0xe3, M_APP4 = 0xe4, M_APP5 = 0xe5, M_APP6 = 0xe6, M_APP7 = 0xe7, M_APP8 = 0xe8, M_APP9 = 0xe9, M_APP10 = 0xea, M_APP11 = 0xeb, M_APP12 = 0xec, M_APP13 = 0xed, M_APP14 = 0xee, M_APP15 = 0xef, M_JPG0 = 0xf0, M_JPG13 = 0xfd, M_COM = 0xfe, M_TEM = 0x01, M_ERROR = 0x100 } JPEG_MARKER; /* Private state */ typedef struct { struct jpeg_marker_reader pub; /* public fields */ /* Application-overridable marker processing methods */ jpeg_marker_parser_method process_COM; jpeg_marker_parser_method process_APPn[16]; /* Limit on marker data length to save for each marker type */ unsigned int length_limit_COM; unsigned int length_limit_APPn[16]; /* Status of COM/APPn marker saving */ jpeg_saved_marker_ptr cur_marker; /* NULL if not processing a marker */ unsigned int bytes_read; /* data bytes read so far in marker */ /* Note: cur_marker is not linked into marker_list until it's all read. */ } my_marker_reader; typedef my_marker_reader * my_marker_ptr; /* * Macros for fetching data from the data source module. * * At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect * the current restart point; we update them only when we have reached a * suitable place to restart if a suspension occurs. */ /* Declare and initialize local copies of input pointer/count */ #define INPUT_VARS(cinfo) \ struct jpeg_source_mgr * datasrc = (cinfo)->src; \ const JOCTET * next_input_byte = datasrc->next_input_byte; \ size_t bytes_in_buffer = datasrc->bytes_in_buffer /* Unload the local copies --- do this only at a restart boundary */ #define INPUT_SYNC(cinfo) \ ( datasrc->next_input_byte = next_input_byte, \ datasrc->bytes_in_buffer = bytes_in_buffer ) /* Reload the local copies --- used only in MAKE_BYTE_AVAIL */ #define INPUT_RELOAD(cinfo) \ ( next_input_byte = datasrc->next_input_byte, \ bytes_in_buffer = datasrc->bytes_in_buffer ) /* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available. * Note we do *not* do INPUT_SYNC before calling fill_input_buffer, * but we must reload the local copies after a successful fill. */ #define MAKE_BYTE_AVAIL(cinfo,action) \ if (bytes_in_buffer == 0) { \ if (! (*datasrc->fill_input_buffer) (cinfo)) \ { action; } \ INPUT_RELOAD(cinfo); \ } /* Read a byte into variable V. * If must suspend, take the specified action (typically "return FALSE"). */ #define INPUT_BYTE(cinfo,V,action) \ MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \ bytes_in_buffer--; \ V = GETJOCTET(*next_input_byte++); ) /* As above, but read two bytes interpreted as an unsigned 16-bit integer. * V should be declared unsigned int or perhaps INT32. */ #define INPUT_2BYTES(cinfo,V,action) \ MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \ bytes_in_buffer--; \ V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \ MAKE_BYTE_AVAIL(cinfo,action); \ bytes_in_buffer--; \ V += GETJOCTET(*next_input_byte++); ) /* * Routines to process JPEG markers. * * Entry condition: JPEG marker itself has been read and its code saved * in cinfo->unread_marker; input restart point is just after the marker. * * Exit: if return TRUE, have read and processed any parameters, and have * updated the restart point to point after the parameters. * If return FALSE, was forced to suspend before reaching end of * marker parameters; restart point has not been moved. Same routine * will be called again after application supplies more input data. * * This approach to suspension assumes that all of a marker's parameters * can fit into a single input bufferload. This should hold for "normal" * markers. Some COM/APPn markers might have large parameter segments * that might not fit. If we are simply dropping such a marker, we use * skip_input_data to get past it, and thereby put the problem on the * source manager's shoulders. If we are saving the marker's contents * into memory, we use a slightly different convention: when forced to * suspend, the marker processor updates the restart point to the end of * what it's consumed (ie, the end of the buffer) before returning FALSE. * On resumption, cinfo->unread_marker still contains the marker code, * but the data source will point to the next chunk of marker data. * The marker processor must retain internal state to deal with this. * * Note that we don't bother to avoid duplicate trace messages if a * suspension occurs within marker parameters. Other side effects * require more care. */ LOCAL(boolean) get_soi (j_decompress_ptr cinfo) /* Process an SOI marker */ { int i; TRACEMS(cinfo, 1, JTRC_SOI); if (cinfo->marker->saw_SOI) ERREXIT(cinfo, JERR_SOI_DUPLICATE); /* Reset all parameters that are defined to be reset by SOI */ for (i = 0; i < NUM_ARITH_TBLS; i++) { cinfo->arith_dc_L[i] = 0; cinfo->arith_dc_U[i] = 1; cinfo->arith_ac_K[i] = 5; } cinfo->restart_interval = 0; /* Set initial assumptions for colorspace etc */ cinfo->jpeg_color_space = JCS_UNKNOWN; cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling??? */ cinfo->saw_JFIF_marker = FALSE; cinfo->JFIF_major_version = 1; /* set default JFIF APP0 values */ cinfo->JFIF_minor_version = 1; cinfo->density_unit = 0; cinfo->X_density = 1; cinfo->Y_density = 1; cinfo->saw_Adobe_marker = FALSE; cinfo->Adobe_transform = 0; cinfo->marker->saw_SOI = TRUE; return TRUE; } LOCAL(boolean) get_sof (j_decompress_ptr cinfo, boolean is_prog, boolean is_arith) /* Process a SOFn marker */ { INT32 length; int c, ci; jpeg_component_info * compptr; INPUT_VARS(cinfo); cinfo->progressive_mode = is_prog; cinfo->arith_code = is_arith; INPUT_2BYTES(cinfo, length, return FALSE); INPUT_BYTE(cinfo, cinfo->data_precision, return FALSE); INPUT_2BYTES(cinfo, cinfo->image_height, return FALSE); INPUT_2BYTES(cinfo, cinfo->image_width, return FALSE); INPUT_BYTE(cinfo, cinfo->num_components, return FALSE); length -= 8; TRACEMS4(cinfo, 1, JTRC_SOF, cinfo->unread_marker, (int) cinfo->image_width, (int) cinfo->image_height, cinfo->num_components); if (cinfo->marker->saw_SOF) ERREXIT(cinfo, JERR_SOF_DUPLICATE); /* We don't support files in which the image height is initially specified */ /* as 0 and is later redefined by DNL. As long as we have to check that, */ /* might as well have a general sanity check. */ if (cinfo->image_height <= 0 || cinfo->image_width <= 0 || cinfo->num_components <= 0) ERREXIT(cinfo, JERR_EMPTY_IMAGE); if (length != (cinfo->num_components * 3)) ERREXIT(cinfo, JERR_BAD_LENGTH); if (cinfo->comp_info == NULL) /* do only once, even if suspend */ cinfo->comp_info = (jpeg_component_info *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, cinfo->num_components * SIZEOF(jpeg_component_info)); for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { compptr->component_index = ci; INPUT_BYTE(cinfo, compptr->component_id, return FALSE); INPUT_BYTE(cinfo, c, return FALSE); compptr->h_samp_factor = (c >> 4) & 15; compptr->v_samp_factor = (c ) & 15; INPUT_BYTE(cinfo, compptr->quant_tbl_no, return FALSE); TRACEMS4(cinfo, 1, JTRC_SOF_COMPONENT, compptr->component_id, compptr->h_samp_factor, compptr->v_samp_factor, compptr->quant_tbl_no); } cinfo->marker->saw_SOF = TRUE; INPUT_SYNC(cinfo); return TRUE; } LOCAL(boolean) get_sos (j_decompress_ptr cinfo) /* Process a SOS marker */ { INT32 length; int i, ci, n, c, cc; jpeg_component_info * compptr; INPUT_VARS(cinfo); if (! cinfo->marker->saw_SOF) ERREXIT(cinfo, JERR_SOS_NO_SOF); INPUT_2BYTES(cinfo, length, return FALSE); INPUT_BYTE(cinfo, n, return FALSE); /* Number of components */ TRACEMS1(cinfo, 1, JTRC_SOS, n); if (length != (n * 2 + 6) || n < 1 || n > MAX_COMPS_IN_SCAN) ERREXIT(cinfo, JERR_BAD_LENGTH); cinfo->comps_in_scan = n; /* Collect the component-spec parameters */ for (i = 0; i < n; i++) { INPUT_BYTE(cinfo, cc, return FALSE); INPUT_BYTE(cinfo, c, return FALSE); for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { if (cc == compptr->component_id) goto id_found; } ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, cc); id_found: cinfo->cur_comp_info[i] = compptr; compptr->dc_tbl_no = (c >> 4) & 15; compptr->ac_tbl_no = (c ) & 15; TRACEMS3(cinfo, 1, JTRC_SOS_COMPONENT, cc, compptr->dc_tbl_no, compptr->ac_tbl_no); } /* Collect the additional scan parameters Ss, Se, Ah/Al. */ INPUT_BYTE(cinfo, c, return FALSE); cinfo->Ss = c; INPUT_BYTE(cinfo, c, return FALSE); cinfo->Se = c; INPUT_BYTE(cinfo, c, return FALSE); cinfo->Ah = (c >> 4) & 15; cinfo->Al = (c ) & 15; TRACEMS4(cinfo, 1, JTRC_SOS_PARAMS, cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al); /* Prepare to scan data & restart markers */ cinfo->marker->next_restart_num = 0; /* Count another SOS marker */ cinfo->input_scan_number++; INPUT_SYNC(cinfo); return TRUE; } #ifdef D_ARITH_CODING_SUPPORTED LOCAL(boolean) get_dac (j_decompress_ptr cinfo) /* Process a DAC marker */ { INT32 length; int index, val; INPUT_VARS(cinfo); INPUT_2BYTES(cinfo, length, return FALSE); length -= 2; while (length > 0) { INPUT_BYTE(cinfo, index, return FALSE); INPUT_BYTE(cinfo, val, return FALSE); length -= 2; TRACEMS2(cinfo, 1, JTRC_DAC, index, val); if (index < 0 || index >= (2*NUM_ARITH_TBLS)) ERREXIT1(cinfo, JERR_DAC_INDEX, index); if (index >= NUM_ARITH_TBLS) { /* define AC table */ cinfo->arith_ac_K[index-NUM_ARITH_TBLS] = (UINT8) val; } else { /* define DC table */ cinfo->arith_dc_L[index] = (UINT8) (val & 0x0F); cinfo->arith_dc_U[index] = (UINT8) (val >> 4); if (cinfo->arith_dc_L[index] > cinfo->arith_dc_U[index]) ERREXIT1(cinfo, JERR_DAC_VALUE, val); } } if (length != 0) ERREXIT(cinfo, JERR_BAD_LENGTH); INPUT_SYNC(cinfo); return TRUE; } #else /* ! D_ARITH_CODING_SUPPORTED */ #define get_dac(cinfo) skip_variable(cinfo) #endif /* D_ARITH_CODING_SUPPORTED */ LOCAL(boolean) get_dht (j_decompress_ptr cinfo) /* Process a DHT marker */ { INT32 length; UINT8 bits[17]; UINT8 huffval[256]; int i, index, count; JHUFF_TBL **htblptr; INPUT_VARS(cinfo); INPUT_2BYTES(cinfo, length, return FALSE); length -= 2; while (length > 16) { INPUT_BYTE(cinfo, index, return FALSE); TRACEMS1(cinfo, 1, JTRC_DHT, index); bits[0] = 0; count = 0; for (i = 1; i <= 16; i++) { INPUT_BYTE(cinfo, bits[i], return FALSE); count += bits[i]; } length -= 1 + 16; TRACEMS8(cinfo, 2, JTRC_HUFFBITS, bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7], bits[8]); TRACEMS8(cinfo, 2, JTRC_HUFFBITS, bits[9], bits[10], bits[11], bits[12], bits[13], bits[14], bits[15], bits[16]); /* Here we just do minimal validation of the counts to avoid walking * off the end of our table space. jdhuff.c will check more carefully. */ if (count > 256 || ((INT32) count) > length) ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); for (i = 0; i < count; i++) INPUT_BYTE(cinfo, huffval[i], return FALSE); length -= count; if (index & 0x10) { /* AC table definition */ index -= 0x10; htblptr = &cinfo->ac_huff_tbl_ptrs[index]; } else { /* DC table definition */ htblptr = &cinfo->dc_huff_tbl_ptrs[index]; } if (index < 0 || index >= NUM_HUFF_TBLS) ERREXIT1(cinfo, JERR_DHT_INDEX, index); if (*htblptr == NULL) *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits)); MEMCOPY((*htblptr)->huffval, huffval, SIZEOF((*htblptr)->huffval)); } if (length != 0) ERREXIT(cinfo, JERR_BAD_LENGTH); INPUT_SYNC(cinfo); return TRUE; } LOCAL(boolean) get_dqt (j_decompress_ptr cinfo) /* Process a DQT marker */ { INT32 length; int n, i, prec; unsigned int tmp; JQUANT_TBL *quant_ptr; INPUT_VARS(cinfo); INPUT_2BYTES(cinfo, length, return FALSE); length -= 2; while (length > 0) { INPUT_BYTE(cinfo, n, return FALSE); prec = n >> 4; n &= 0x0F; TRACEMS2(cinfo, 1, JTRC_DQT, n, prec); if (n >= NUM_QUANT_TBLS) ERREXIT1(cinfo, JERR_DQT_INDEX, n); if (cinfo->quant_tbl_ptrs[n] == NULL) cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) cinfo); quant_ptr = cinfo->quant_tbl_ptrs[n]; for (i = 0; i < DCTSIZE2; i++) { if (prec) INPUT_2BYTES(cinfo, tmp, return FALSE); else INPUT_BYTE(cinfo, tmp, return FALSE); /* We convert the zigzag-order table to natural array order. */ quant_ptr->quantval[jpeg_natural_order[i]] = (UINT16) tmp; } if (cinfo->err->trace_level >= 2) { for (i = 0; i < DCTSIZE2; i += 8) { TRACEMS8(cinfo, 2, JTRC_QUANTVALS, quant_ptr->quantval[i], quant_ptr->quantval[i+1], quant_ptr->quantval[i+2], quant_ptr->quantval[i+3], quant_ptr->quantval[i+4], quant_ptr->quantval[i+5], quant_ptr->quantval[i+6], quant_ptr->quantval[i+7]); } } length -= DCTSIZE2+1; if (prec) length -= DCTSIZE2; } if (length != 0) ERREXIT(cinfo, JERR_BAD_LENGTH); INPUT_SYNC(cinfo); return TRUE; } LOCAL(boolean) get_dri (j_decompress_ptr cinfo) /* Process a DRI marker */ { INT32 length; unsigned int tmp; INPUT_VARS(cinfo); INPUT_2BYTES(cinfo, length, return FALSE); if (length != 4) ERREXIT(cinfo, JERR_BAD_LENGTH); INPUT_2BYTES(cinfo, tmp, return FALSE); TRACEMS1(cinfo, 1, JTRC_DRI, tmp); cinfo->restart_interval = tmp; INPUT_SYNC(cinfo); return TRUE; } /* * Routines for processing APPn and COM markers. * These are either saved in memory or discarded, per application request. * APP0 and APP14 are specially checked to see if they are * JFIF and Adobe markers, respectively. */ #define APP0_DATA_LEN 14 /* Length of interesting data in APP0 */ #define APP14_DATA_LEN 12 /* Length of interesting data in APP14 */ #define APPN_DATA_LEN 14 /* Must be the largest of the above!! */ LOCAL(void) examine_app0 (j_decompress_ptr cinfo, JOCTET FAR * data, unsigned int datalen, INT32 remaining) /* Examine first few bytes from an APP0. * Take appropriate action if it is a JFIF marker. * datalen is # of bytes at data[], remaining is length of rest of marker data. */ { INT32 totallen = (INT32) datalen + remaining; if (datalen >= APP0_DATA_LEN && GETJOCTET(data[0]) == 0x4A && GETJOCTET(data[1]) == 0x46 && GETJOCTET(data[2]) == 0x49 && GETJOCTET(data[3]) == 0x46 && GETJOCTET(data[4]) == 0) { /* Found JFIF APP0 marker: save info */ cinfo->saw_JFIF_marker = TRUE; cinfo->JFIF_major_version = GETJOCTET(data[5]); cinfo->JFIF_minor_version = GETJOCTET(data[6]); cinfo->density_unit = GETJOCTET(data[7]); cinfo->X_density = (GETJOCTET(data[8]) << 8) + GETJOCTET(data[9]); cinfo->Y_density = (GETJOCTET(data[10]) << 8) + GETJOCTET(data[11]); /* Check version. * Major version must be 1, anything else signals an incompatible change. * (We used to treat this as an error, but now it's a nonfatal warning, * because some bozo at Hijaak couldn't read the spec.) * Minor version should be 0..2, but process anyway if newer. */ if (cinfo->JFIF_major_version != 1) WARNMS2(cinfo, JWRN_JFIF_MAJOR, cinfo->JFIF_major_version, cinfo->JFIF_minor_version); /* Generate trace messages */ TRACEMS5(cinfo, 1, JTRC_JFIF, cinfo->JFIF_major_version, cinfo->JFIF_minor_version, cinfo->X_density, cinfo->Y_density, cinfo->density_unit); /* Validate thumbnail dimensions and issue appropriate messages */ if (GETJOCTET(data[12]) | GETJOCTET(data[13])) TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL, GETJOCTET(data[12]), GETJOCTET(data[13])); totallen -= APP0_DATA_LEN; if (totallen != ((INT32)GETJOCTET(data[12]) * (INT32)GETJOCTET(data[13]) * (INT32) 3)) TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int) totallen); } else if (datalen >= 6 && GETJOCTET(data[0]) == 0x4A && GETJOCTET(data[1]) == 0x46 && GETJOCTET(data[2]) == 0x58 && GETJOCTET(data[3]) == 0x58 && GETJOCTET(data[4]) == 0) { /* Found JFIF "JFXX" extension APP0 marker */ /* The library doesn't actually do anything with these, * but we try to produce a helpful trace message. */ switch (GETJOCTET(data[5])) { case 0x10: TRACEMS1(cinfo, 1, JTRC_THUMB_JPEG, (int) totallen); break; case 0x11: TRACEMS1(cinfo, 1, JTRC_THUMB_PALETTE, (int) totallen); break; case 0x13: TRACEMS1(cinfo, 1, JTRC_THUMB_RGB, (int) totallen); break; default: TRACEMS2(cinfo, 1, JTRC_JFIF_EXTENSION, GETJOCTET(data[5]), (int) totallen); break; } } else { /* Start of APP0 does not match "JFIF" or "JFXX", or too short */ TRACEMS1(cinfo, 1, JTRC_APP0, (int) totallen); } } LOCAL(void) examine_app14 (j_decompress_ptr cinfo, JOCTET FAR * data, unsigned int datalen, INT32 remaining) /* Examine first few bytes from an APP14. * Take appropriate action if it is an Adobe marker. * datalen is # of bytes at data[], remaining is length of rest of marker data. */ { unsigned int version, flags0, flags1, transform; if (datalen >= APP14_DATA_LEN && GETJOCTET(data[0]) == 0x41 && GETJOCTET(data[1]) == 0x64 && GETJOCTET(data[2]) == 0x6F && GETJOCTET(data[3]) == 0x62 && GETJOCTET(data[4]) == 0x65) { /* Found Adobe APP14 marker */ version = (GETJOCTET(data[5]) << 8) + GETJOCTET(data[6]); flags0 = (GETJOCTET(data[7]) << 8) + GETJOCTET(data[8]); flags1 = (GETJOCTET(data[9]) << 8) + GETJOCTET(data[10]); transform = GETJOCTET(data[11]); TRACEMS4(cinfo, 1, JTRC_ADOBE, version, flags0, flags1, transform); cinfo->saw_Adobe_marker = TRUE; cinfo->Adobe_transform = (UINT8) transform; } else { /* Start of APP14 does not match "Adobe", or too short */ TRACEMS1(cinfo, 1, JTRC_APP14, (int) (datalen + remaining)); } } METHODDEF(boolean) get_interesting_appn (j_decompress_ptr cinfo) /* Process an APP0 or APP14 marker without saving it */ { INT32 length; JOCTET b[APPN_DATA_LEN]; unsigned int i, numtoread; INPUT_VARS(cinfo); INPUT_2BYTES(cinfo, length, return FALSE); length -= 2; /* get the interesting part of the marker data */ if (length >= APPN_DATA_LEN) numtoread = APPN_DATA_LEN; else if (length > 0) numtoread = (unsigned int) length; else numtoread = 0; for (i = 0; i < numtoread; i++) INPUT_BYTE(cinfo, b[i], return FALSE); length -= numtoread; /* process it */ switch (cinfo->unread_marker) { case M_APP0: examine_app0(cinfo, (JOCTET FAR *) b, numtoread, length); break; case M_APP14: examine_app14(cinfo, (JOCTET FAR *) b, numtoread, length); break; default: /* can't get here unless jpeg_save_markers chooses wrong processor */ ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker); break; } /* skip any remaining data -- could be lots */ INPUT_SYNC(cinfo); if (length > 0) (*cinfo->src->skip_input_data) (cinfo, (long) length); return TRUE; } #ifdef SAVE_MARKERS_SUPPORTED METHODDEF(boolean) save_marker (j_decompress_ptr cinfo) /* Save an APPn or COM marker into the marker list */ { my_marker_ptr marker = (my_marker_ptr) cinfo->marker; jpeg_saved_marker_ptr cur_marker = marker->cur_marker; unsigned int bytes_read, data_length; JOCTET FAR * data; INT32 length = 0; INPUT_VARS(cinfo); if (cur_marker == NULL) { /* begin reading a marker */ INPUT_2BYTES(cinfo, length, return FALSE); length -= 2; if (length >= 0) { /* watch out for bogus length word */ /* figure out how much we want to save */ unsigned int limit; if (cinfo->unread_marker == (int) M_COM) limit = marker->length_limit_COM; else limit = marker->length_limit_APPn[cinfo->unread_marker - (int) M_APP0]; if ((unsigned int) length < limit) limit = (unsigned int) length; /* allocate and initialize the marker item */ cur_marker = (jpeg_saved_marker_ptr) (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(struct jpeg_marker_struct) + limit); cur_marker->next = NULL; cur_marker->marker = (UINT8) cinfo->unread_marker; cur_marker->original_length = (unsigned int) length; cur_marker->data_length = limit; /* data area is just beyond the jpeg_marker_struct */ data = cur_marker->data = (JOCTET FAR *) (cur_marker + 1); marker->cur_marker = cur_marker; marker->bytes_read = 0; bytes_read = 0; data_length = limit; } else { /* deal with bogus length word */ bytes_read = data_length = 0; data = NULL; } } else { /* resume reading a marker */ bytes_read = marker->bytes_read; data_length = cur_marker->data_length; data = cur_marker->data + bytes_read; } while (bytes_read < data_length) { INPUT_SYNC(cinfo); /* move the restart point to here */ marker->bytes_read = bytes_read; /* If there's not at least one byte in buffer, suspend */ MAKE_BYTE_AVAIL(cinfo, return FALSE); /* Copy bytes with reasonable rapidity */ while (bytes_read < data_length && bytes_in_buffer > 0) { *data++ = *next_input_byte++; bytes_in_buffer--; bytes_read++; } } /* Done reading what we want to read */ if (cur_marker != NULL) { /* will be NULL if bogus length word */ /* Add new marker to end of list */ if (cinfo->marker_list == NULL) { cinfo->marker_list = cur_marker; } else { jpeg_saved_marker_ptr prev = cinfo->marker_list; while (prev->next != NULL) prev = prev->next; prev->next = cur_marker; } /* Reset pointer & calc remaining data length */ data = cur_marker->data; length = cur_marker->original_length - data_length; } /* Reset to initial state for next marker */ marker->cur_marker = NULL; /* Process the marker if interesting; else just make a generic trace msg */ switch (cinfo->unread_marker) { case M_APP0: examine_app0(cinfo, data, data_length, length); break; case M_APP14: examine_app14(cinfo, data, data_length, length); break; default: TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) (data_length + length)); break; } /* skip any remaining data -- could be lots */ INPUT_SYNC(cinfo); /* do before skip_input_data */ if (length > 0) (*cinfo->src->skip_input_data) (cinfo, (long) length); return TRUE; } #endif /* SAVE_MARKERS_SUPPORTED */ METHODDEF(boolean) skip_variable (j_decompress_ptr cinfo) /* Skip over an unknown or uninteresting variable-length marker */ { INT32 length; INPUT_VARS(cinfo); INPUT_2BYTES(cinfo, length, return FALSE); length -= 2; TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) length); INPUT_SYNC(cinfo); /* do before skip_input_data */ if (length > 0) (*cinfo->src->skip_input_data) (cinfo, (long) length); return TRUE; } /* * Find the next JPEG marker, save it in cinfo->unread_marker. * Returns FALSE if had to suspend before reaching a marker; * in that case cinfo->unread_marker is unchanged. * * Note that the result might not be a valid marker code, * but it will never be 0 or FF. */ LOCAL(boolean) next_marker (j_decompress_ptr cinfo) { int c; INPUT_VARS(cinfo); for (;;) { INPUT_BYTE(cinfo, c, return FALSE); /* Skip any non-FF bytes. * This may look a bit inefficient, but it will not occur in a valid file. * We sync after each discarded byte so that a suspending data source * can discard the byte from its buffer. */ while (c != 0xFF) { cinfo->marker->discarded_bytes++; INPUT_SYNC(cinfo); INPUT_BYTE(cinfo, c, return FALSE); } /* This loop swallows any duplicate FF bytes. Extra FFs are legal as * pad bytes, so don't count them in discarded_bytes. We assume there * will not be so many consecutive FF bytes as to overflow a suspending * data source's input buffer. */ do { INPUT_BYTE(cinfo, c, return FALSE); } while (c == 0xFF); if (c != 0) break; /* found a valid marker, exit loop */ /* Reach here if we found a stuffed-zero data sequence (FF/00). * Discard it and loop back to try again. */ cinfo->marker->discarded_bytes += 2; INPUT_SYNC(cinfo); } if (cinfo->marker->discarded_bytes != 0) { WARNMS2(cinfo, JWRN_EXTRANEOUS_DATA, cinfo->marker->discarded_bytes, c); cinfo->marker->discarded_bytes = 0; } cinfo->unread_marker = c; INPUT_SYNC(cinfo); return TRUE; } LOCAL(boolean) first_marker (j_decompress_ptr cinfo) /* Like next_marker, but used to obtain the initial SOI marker. */ /* For this marker, we do not allow preceding garbage or fill; otherwise, * we might well scan an entire input file before realizing it ain't JPEG. * If an application wants to process non-JFIF files, it must seek to the * SOI before calling the JPEG library. */ { int c, c2; INPUT_VARS(cinfo); INPUT_BYTE(cinfo, c, return FALSE); INPUT_BYTE(cinfo, c2, return FALSE); if (c != 0xFF || c2 != (int) M_SOI) ERREXIT2(cinfo, JERR_NO_SOI, c, c2); cinfo->unread_marker = c2; INPUT_SYNC(cinfo); return TRUE; } /* * Read markers until SOS or EOI. * * Returns same codes as are defined for jpeg_consume_input: * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. */ METHODDEF(int) read_markers (j_decompress_ptr cinfo) { /* Outer loop repeats once for each marker. */ for (;;) { /* Collect the marker proper, unless we already did. */ /* NB: first_marker() enforces the requirement that SOI appear first. */ if (cinfo->unread_marker == 0) { if (! cinfo->marker->saw_SOI) { if (! first_marker(cinfo)) return JPEG_SUSPENDED; } else { if (! next_marker(cinfo)) return JPEG_SUSPENDED; } } /* At this point cinfo->unread_marker contains the marker code and the * input point is just past the marker proper, but before any parameters. * A suspension will cause us to return with this state still true. */ switch (cinfo->unread_marker) { case M_SOI: if (! get_soi(cinfo)) return JPEG_SUSPENDED; break; case M_SOF0: /* Baseline */ case M_SOF1: /* Extended sequential, Huffman */ if (! get_sof(cinfo, FALSE, FALSE)) return JPEG_SUSPENDED; break; case M_SOF2: /* Progressive, Huffman */ if (! get_sof(cinfo, TRUE, FALSE)) return JPEG_SUSPENDED; break; case M_SOF9: /* Extended sequential, arithmetic */ if (! get_sof(cinfo, FALSE, TRUE)) return JPEG_SUSPENDED; break; case M_SOF10: /* Progressive, arithmetic */ if (! get_sof(cinfo, TRUE, TRUE)) return JPEG_SUSPENDED; break; /* Currently unsupported SOFn types */ case M_SOF3: /* Lossless, Huffman */ case M_SOF5: /* Differential sequential, Huffman */ case M_SOF6: /* Differential progressive, Huffman */ case M_SOF7: /* Differential lossless, Huffman */ case M_JPG: /* Reserved for JPEG extensions */ case M_SOF11: /* Lossless, arithmetic */ case M_SOF13: /* Differential sequential, arithmetic */ case M_SOF14: /* Differential progressive, arithmetic */ case M_SOF15: /* Differential lossless, arithmetic */ ERREXIT1(cinfo, JERR_SOF_UNSUPPORTED, cinfo->unread_marker); break; case M_SOS: if (! get_sos(cinfo)) return JPEG_SUSPENDED; cinfo->unread_marker = 0; /* processed the marker */ return JPEG_REACHED_SOS; case M_EOI: TRACEMS(cinfo, 1, JTRC_EOI); cinfo->unread_marker = 0; /* processed the marker */ return JPEG_REACHED_EOI; case M_DAC: if (! get_dac(cinfo)) return JPEG_SUSPENDED; break; case M_DHT: if (! get_dht(cinfo)) return JPEG_SUSPENDED; break; case M_DQT: if (! get_dqt(cinfo)) return JPEG_SUSPENDED; break; case M_DRI: if (! get_dri(cinfo)) return JPEG_SUSPENDED; break; case M_APP0: case M_APP1: case M_APP2: case M_APP3: case M_APP4: case M_APP5: case M_APP6: case M_APP7: case M_APP8: case M_APP9: case M_APP10: case M_APP11: case M_APP12: case M_APP13: case M_APP14: case M_APP15: if (! (*((my_marker_ptr) cinfo->marker)->process_APPn[ cinfo->unread_marker - (int) M_APP0]) (cinfo)) return JPEG_SUSPENDED; break; case M_COM: if (! (*((my_marker_ptr) cinfo->marker)->process_COM) (cinfo)) return JPEG_SUSPENDED; break; case M_RST0: /* these are all parameterless */ case M_RST1: case M_RST2: case M_RST3: case M_RST4: case M_RST5: case M_RST6: case M_RST7: case M_TEM: TRACEMS1(cinfo, 1, JTRC_PARMLESS_MARKER, cinfo->unread_marker); break; case M_DNL: /* Ignore DNL ... perhaps the wrong thing */ if (! skip_variable(cinfo)) return JPEG_SUSPENDED; break; default: /* must be DHP, EXP, JPGn, or RESn */ /* For now, we treat the reserved markers as fatal errors since they are * likely to be used to signal incompatible JPEG Part 3 extensions. * Once the JPEG 3 version-number marker is well defined, this code * ought to change! */ ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker); break; } /* Successfully processed marker, so reset state variable */ cinfo->unread_marker = 0; } /* end loop */ } /* * Read a restart marker, which is expected to appear next in the datastream; * if the marker is not there, take appropriate recovery action. * Returns FALSE if suspension is required. * * This is called by the entropy decoder after it has read an appropriate * number of MCUs. cinfo->unread_marker may be nonzero if the entropy decoder * has already read a marker from the data source. Under normal conditions * cinfo->unread_marker will be reset to 0 before returning; if not reset, * it holds a marker which the decoder will be unable to read past. */ METHODDEF(boolean) read_restart_marker (j_decompress_ptr cinfo) { /* Obtain a marker unless we already did. */ /* Note that next_marker will complain if it skips any data. */ if (cinfo->unread_marker == 0) { if (! next_marker(cinfo)) return FALSE; } if (cinfo->unread_marker == ((int) M_RST0 + cinfo->marker->next_restart_num)) { /* Normal case --- swallow the marker and let entropy decoder continue */ TRACEMS1(cinfo, 3, JTRC_RST, cinfo->marker->next_restart_num); cinfo->unread_marker = 0; } else { /* Uh-oh, the restart markers have been messed up. */ /* Let the data source manager determine how to resync. */ if (! (*cinfo->src->resync_to_restart) (cinfo, cinfo->marker->next_restart_num)) return FALSE; } /* Update next-restart state */ cinfo->marker->next_restart_num = (cinfo->marker->next_restart_num + 1) & 7; return TRUE; } /* * This is the default resync_to_restart method for data source managers * to use if they don't have any better approach. Some data source managers * may be able to back up, or may have additional knowledge about the data * which permits a more intelligent recovery strategy; such managers would * presumably supply their own resync method. * * read_restart_marker calls resync_to_restart if it finds a marker other than * the restart marker it was expecting. (This code is *not* used unless * a nonzero restart interval has been declared.) cinfo->unread_marker is * the marker code actually found (might be anything, except 0 or FF). * The desired restart marker number (0..7) is passed as a parameter. * This routine is supposed to apply whatever error recovery strategy seems * appropriate in order to position the input stream to the next data segment. * Note that cinfo->unread_marker is treated as a marker appearing before * the current data-source input point; usually it should be reset to zero * before returning. * Returns FALSE if suspension is required. * * This implementation is substantially constrained by wanting to treat the * input as a data stream; this means we can't back up. Therefore, we have * only the following actions to work with: * 1. Simply discard the marker and let the entropy decoder resume at next * byte of file. * 2. Read forward until we find another marker, discarding intervening * data. (In theory we could look ahead within the current bufferload, * without having to discard data if we don't find the desired marker. * This idea is not implemented here, in part because it makes behavior * dependent on buffer size and chance buffer-boundary positions.) * 3. Leave the marker unread (by failing to zero cinfo->unread_marker). * This will cause the entropy decoder to process an empty data segment, * inserting dummy zeroes, and then we will reprocess the marker. * * #2 is appropriate if we think the desired marker lies ahead, while #3 is * appropriate if the found marker is a future restart marker (indicating * that we have missed the desired restart marker, probably because it got * corrupted). * We apply #2 or #3 if the found marker is a restart marker no more than * two counts behind or ahead of the expected one. We also apply #2 if the * found marker is not a legal JPEG marker code (it's certainly bogus data). * If the found marker is a restart marker more than 2 counts away, we do #1 * (too much risk that the marker is erroneous; with luck we will be able to * resync at some future point). * For any valid non-restart JPEG marker, we apply #3. This keeps us from * overrunning the end of a scan. An implementation limited to single-scan * files might find it better to apply #2 for markers other than EOI, since * any other marker would have to be bogus data in that case. */ GLOBAL(boolean) jpeg_resync_to_restart (j_decompress_ptr cinfo, int desired) { int marker = cinfo->unread_marker; int action = 1; /* Always put up a warning. */ WARNMS2(cinfo, JWRN_MUST_RESYNC, marker, desired); /* Outer loop handles repeated decision after scanning forward. */ for (;;) { if (marker < (int) M_SOF0) action = 2; /* invalid marker */ else if (marker < (int) M_RST0 || marker > (int) M_RST7) action = 3; /* valid non-restart marker */ else { if (marker == ((int) M_RST0 + ((desired+1) & 7)) || marker == ((int) M_RST0 + ((desired+2) & 7))) action = 3; /* one of the next two expected restarts */ else if (marker == ((int) M_RST0 + ((desired-1) & 7)) || marker == ((int) M_RST0 + ((desired-2) & 7))) action = 2; /* a prior restart, so advance */ else action = 1; /* desired restart or too far away */ } TRACEMS2(cinfo, 4, JTRC_RECOVERY_ACTION, marker, action); switch (action) { case 1: /* Discard marker and let entropy decoder resume processing. */ cinfo->unread_marker = 0; return TRUE; case 2: /* Scan to the next marker, and repeat the decision loop. */ if (! next_marker(cinfo)) return FALSE; marker = cinfo->unread_marker; break; case 3: /* Return without advancing past this marker. */ /* Entropy decoder will be forced to process an empty segment. */ return TRUE; } } /* end loop */ } /* * Reset marker processing state to begin a fresh datastream. */ METHODDEF(void) reset_marker_reader (j_decompress_ptr cinfo) { my_marker_ptr marker = (my_marker_ptr) cinfo->marker; cinfo->comp_info = NULL; /* until allocated by get_sof */ cinfo->input_scan_number = 0; /* no SOS seen yet */ cinfo->unread_marker = 0; /* no pending marker */ marker->pub.saw_SOI = FALSE; /* set internal state too */ marker->pub.saw_SOF = FALSE; marker->pub.discarded_bytes = 0; marker->cur_marker = NULL; } /* * Initialize the marker reader module. * This is called only once, when the decompression object is created. */ GLOBAL(void) jinit_marker_reader (j_decompress_ptr cinfo) { my_marker_ptr marker; int i; /* Create subobject in permanent pool */ marker = (my_marker_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_marker_reader)); cinfo->marker = (struct jpeg_marker_reader *) marker; /* Initialize public method pointers */ marker->pub.reset_marker_reader = reset_marker_reader; marker->pub.read_markers = read_markers; marker->pub.read_restart_marker = read_restart_marker; /* Initialize COM/APPn processing. * By default, we examine and then discard APP0 and APP14, * but simply discard COM and all other APPn. */ marker->process_COM = skip_variable; marker->length_limit_COM = 0; for (i = 0; i < 16; i++) { marker->process_APPn[i] = skip_variable; marker->length_limit_APPn[i] = 0; } marker->process_APPn[0] = get_interesting_appn; marker->process_APPn[14] = get_interesting_appn; /* Reset marker processing state */ reset_marker_reader(cinfo); } /* * Control saving of COM and APPn markers into marker_list. */ #ifdef SAVE_MARKERS_SUPPORTED GLOBAL(void) jpeg_save_markers (j_decompress_ptr cinfo, int marker_code, unsigned int length_limit) { my_marker_ptr marker = (my_marker_ptr) cinfo->marker; long maxlength; jpeg_marker_parser_method processor; /* Length limit mustn't be larger than what we can allocate * (should only be a concern in a 16-bit environment). */ maxlength = cinfo->mem->max_alloc_chunk - SIZEOF(struct jpeg_marker_struct); if (((long) length_limit) > maxlength) length_limit = (unsigned int) maxlength; /* Choose processor routine to use. * APP0/APP14 have special requirements. */ if (length_limit) { processor = save_marker; /* If saving APP0/APP14, save at least enough for our internal use. */ if (marker_code == (int) M_APP0 && length_limit < APP0_DATA_LEN) length_limit = APP0_DATA_LEN; else if (marker_code == (int) M_APP14 && length_limit < APP14_DATA_LEN) length_limit = APP14_DATA_LEN; } else { processor = skip_variable; /* If discarding APP0/APP14, use our regular on-the-fly processor. */ if (marker_code == (int) M_APP0 || marker_code == (int) M_APP14) processor = get_interesting_appn; } if (marker_code == (int) M_COM) { marker->process_COM = processor; marker->length_limit_COM = length_limit; } else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15) { marker->process_APPn[marker_code - (int) M_APP0] = processor; marker->length_limit_APPn[marker_code - (int) M_APP0] = length_limit; } else ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code); } #endif /* SAVE_MARKERS_SUPPORTED */ /* * Install a special processing method for COM or APPn markers. */ GLOBAL(void) jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code, jpeg_marker_parser_method routine) { my_marker_ptr marker = (my_marker_ptr) cinfo->marker; if (marker_code == (int) M_COM) marker->process_COM = routine; else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15) marker->process_APPn[marker_code - (int) M_APP0] = routine; else ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code); } Papyrus3/JpegDir/JpgLossy/ANSI2KNR.C0000755000175000017500000005474007535143454014144 0ustar /* ansi2knr.c */ /* Convert ANSI C function definitions to K&R ("traditional C") syntax */ /* ansi2knr is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. No author or distributor accepts responsibility to anyone for the consequences of using it or for whether it serves any particular purpose or works at all, unless he says so in writing. Refer to the GNU General Public License (the "GPL") for full details. Everyone is granted permission to copy, modify and redistribute ansi2knr, but only under the conditions described in the GPL. A copy of this license is supposed to have been given to you along with ansi2knr so you can know your rights and responsibilities. It should be in a file named COPYLEFT. [In the IJG distribution, the GPL appears below, not in a separate file.] Among other things, the copyright notice and this notice must be preserved on all copies. We explicitly state here what we believe is already implied by the GPL: if the ansi2knr program is distributed as a separate set of sources and a separate executable file which are aggregated on a storage medium together with another program, this in itself does not bring the other program under the GPL, nor does the mere fact that such a program or the procedures for constructing it invoke the ansi2knr executable bring any other part of the program under the GPL. */ /* ---------- Here is the GNU GPL file COPYLEFT, referred to above ---------- ----- These terms do NOT apply to the JPEG software itself; see README ------ GHOSTSCRIPT GENERAL PUBLIC LICENSE (Clarified 11 Feb 1988) Copyright (C) 1988 Richard M. Stallman Everyone is permitted to copy and distribute verbatim copies of this license, but changing it is not allowed. You can also use this wording to make the terms for other programs. The license agreements of most software companies keep you at the mercy of those companies. By contrast, our general public license is intended to give everyone the right to share Ghostscript. To make sure that you get the rights we want you to have, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. Hence this license agreement. Specifically, we want to make sure that you have the right to give away copies of Ghostscript, that you receive source code or else can get it if you want it, that you can change Ghostscript or use pieces of it in new free programs, and that you know you can do these things. To make sure that everyone has such rights, we have to forbid you to deprive anyone else of these rights. For example, if you distribute copies of Ghostscript, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must tell them their rights. Also, for our own protection, we must make certain that everyone finds out that there is no warranty for Ghostscript. If Ghostscript is modified by someone else and passed on, we want its recipients to know that what they have is not what we distributed, so that any problems introduced by others will not reflect on our reputation. Therefore we (Richard M. Stallman and the Free Software Foundation, Inc.) make the following terms which say what you must do to be allowed to distribute or change Ghostscript. COPYING POLICIES 1. You may copy and distribute verbatim copies of Ghostscript source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy a valid copyright and license notice "Copyright (C) 1989 Aladdin Enterprises. All rights reserved. Distributed by Free Software Foundation, Inc." (or with whatever year is appropriate); keep intact the notices on all files that refer to this License Agreement and to the absence of any warranty; and give any other recipients of the Ghostscript program a copy of this License Agreement along with the program. You may charge a distribution fee for the physical act of transferring a copy. 2. You may modify your copy or copies of Ghostscript or any portion of it, and copy and distribute such modifications under the terms of Paragraph 1 above, provided that you also do the following: a) cause the modified files to carry prominent notices stating that you changed the files and the date of any change; and b) cause the whole of any work that you distribute or publish, that in whole or in part contains or is a derivative of Ghostscript or any part thereof, to be licensed at no charge to all third parties on terms identical to those contained in this License Agreement (except that you may choose to grant more extensive warranty protection to some or all third parties, at your option). c) You may charge a distribution fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. Mere aggregation of another unrelated program with this program (or its derivative) on a volume of a storage or distribution medium does not bring the other program under the scope of these terms. 3. You may copy and distribute Ghostscript (or a portion or derivative of it, under Paragraph 2) in object code or executable form under the terms of Paragraphs 1 and 2 above provided that you also do one of the following: a) accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Paragraphs 1 and 2 above; or, b) accompany it with a written offer, valid for at least three years, to give any third party free (except for a nominal shipping charge) a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Paragraphs 1 and 2 above; or, c) accompany it with the information you received as to where the corresponding source code may be obtained. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form alone.) For an executable file, complete source code means all the source code for all modules it contains; but, as a special exception, it need not include source code for modules which are standard libraries that accompany the operating system on which the executable file runs. 4. You may not copy, sublicense, distribute or transfer Ghostscript except as expressly provided under this License Agreement. Any attempt otherwise to copy, sublicense, distribute or transfer Ghostscript is void and your rights to use the program under this License agreement shall be automatically terminated. However, parties who have received computer software programs from you with this License Agreement will not have their licenses terminated so long as such parties remain in full compliance. 5. If you wish to incorporate parts of Ghostscript into other free programs whose distribution conditions are different, write to the Free Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet worked out a simple rule that can be stated here, but we will often permit this. We will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software. Your comments and suggestions about our licensing policies and our software are welcome! Please contact the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, or call (617) 876-3296. NO WARRANTY BECAUSE GHOSTSCRIPT IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, RICHARD M. STALLMAN, ALADDIN ENTERPRISES, L. PETER DEUTSCH, AND/OR OTHER PARTIES PROVIDE GHOSTSCRIPT "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF GHOSTSCRIPT IS WITH YOU. SHOULD GHOSTSCRIPT PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M. STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., L. PETER DEUTSCH, ALADDIN ENTERPRISES, AND/OR ANY OTHER PARTY WHO MAY MODIFY AND REDISTRIBUTE GHOSTSCRIPT AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GHOSTSCRIPT, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. -------------------- End of file COPYLEFT ------------------------------ */ /* * Usage: ansi2knr input_file [output_file] * If no output_file is supplied, output goes to stdout. * There are no error messages. * * ansi2knr recognizes function definitions by seeing a non-keyword * identifier at the left margin, followed by a left parenthesis, * with a right parenthesis as the last character on the line, * and with a left brace as the first token on the following line * (ignoring possible intervening comments). * It will recognize a multi-line header provided that no intervening * line ends with a left or right brace or a semicolon. * These algorithms ignore whitespace and comments, except that * the function name must be the first thing on the line. * The following constructs will confuse it: * - Any other construct that starts at the left margin and * follows the above syntax (such as a macro or function call). * - Some macros that tinker with the syntax of the function header. */ /* * The original and principal author of ansi2knr is L. Peter Deutsch * . Other authors are noted in the change history * that follows (in reverse chronological order): lpd 96-01-21 added code to cope with not HAVE_CONFIG_H and with compilers that don't understand void, as suggested by Tom Lane lpd 96-01-15 changed to require that the first non-comment token on the line following a function header be a left brace, to reduce sensitivity to macros, as suggested by Tom Lane lpd 95-06-22 removed #ifndefs whose sole purpose was to define undefined preprocessor symbols as 0; changed all #ifdefs for configuration symbols to #ifs lpd 95-04-05 changed copyright notice to make it clear that including ansi2knr in a program does not bring the entire program under the GPL lpd 94-12-18 added conditionals for systems where ctype macros don't handle 8-bit characters properly, suggested by Francois Pinard ; removed --varargs switch (this is now the default) lpd 94-10-10 removed CONFIG_BROKETS conditional lpd 94-07-16 added some conditionals to help GNU `configure', suggested by Francois Pinard ; properly erase prototype args in function parameters, contributed by Jim Avera ; correct error in writeblanks (it shouldn't erase EOLs) lpd 89-xx-xx original version */ /* Most of the conditionals here are to make ansi2knr work with */ /* or without the GNU configure machinery. */ #if HAVE_CONFIG_H # include #endif #include #include #if HAVE_CONFIG_H /* For properly autoconfiguring ansi2knr, use AC_CONFIG_HEADER(config.h). This will define HAVE_CONFIG_H and so, activate the following lines. */ # if STDC_HEADERS || HAVE_STRING_H # include # else # include # endif #else /* not HAVE_CONFIG_H */ /* Otherwise do it the hard way */ # ifdef BSD # include # else # ifdef VMS extern int strlen(), strncmp(); # else # include # endif # endif #endif /* not HAVE_CONFIG_H */ #if STDC_HEADERS # include #else /* malloc and free should be declared in stdlib.h, but if you've got a K&R compiler, they probably aren't. */ # ifdef MSDOS # include # else # ifdef VMS extern char *malloc(); extern void free(); # else extern char *malloc(); extern int free(); # endif # endif #endif /* * The ctype macros don't always handle 8-bit characters correctly. * Compensate for this here. */ #ifdef isascii # undef HAVE_ISASCII /* just in case */ # define HAVE_ISASCII 1 #else #endif #if STDC_HEADERS || !HAVE_ISASCII # define is_ascii(c) 1 #else # define is_ascii(c) isascii(c) #endif #define is_space(c) (is_ascii(c) && isspace(c)) #define is_alpha(c) (is_ascii(c) && isalpha(c)) #define is_alnum(c) (is_ascii(c) && isalnum(c)) /* Scanning macros */ #define isidchar(ch) (is_alnum(ch) || (ch) == '_') #define isidfirstchar(ch) (is_alpha(ch) || (ch) == '_') /* Forward references */ char *skipspace(); int writeblanks(); int test1(); int convert1(); /* The main program */ int main(argc, argv) int argc; char *argv[]; { FILE *in, *out; #define bufsize 5000 /* arbitrary size */ char *buf; char *line; char *more; /* * In previous versions, ansi2knr recognized a --varargs switch. * If this switch was supplied, ansi2knr would attempt to convert * a ... argument to va_alist and va_dcl; if this switch was not * supplied, ansi2knr would simply drop any such arguments. * Now, ansi2knr always does this conversion, and we only * check for this switch for backward compatibility. */ int convert_varargs = 1; if ( argc > 1 && argv[1][0] == '-' ) { if ( !strcmp(argv[1], "--varargs") ) { convert_varargs = 1; argc--; argv++; } else { fprintf(stderr, "Unrecognized switch: %s\n", argv[1]); exit(1); } } switch ( argc ) { default: printf("Usage: ansi2knr input_file [output_file]\n"); exit(0); case 2: out = stdout; break; case 3: out = fopen(argv[2], "w"); if ( out == NULL ) { fprintf(stderr, "Cannot open output file %s\n", argv[2]); exit(1); } } in = fopen(argv[1], "r"); if ( in == NULL ) { fprintf(stderr, "Cannot open input file %s\n", argv[1]); exit(1); } fprintf(out, "#line 1 \"%s\"\n", argv[1]); buf = malloc(bufsize); line = buf; while ( fgets(line, (unsigned)(buf + bufsize - line), in) != NULL ) { test: line += strlen(line); switch ( test1(buf) ) { case 2: /* a function header */ convert1(buf, out, 1, convert_varargs); break; case 1: /* a function */ /* Check for a { at the start of the next line. */ more = ++line; f: if ( line >= buf + (bufsize - 1) ) /* overflow check */ goto wl; if ( fgets(line, (unsigned)(buf + bufsize - line), in) == NULL ) goto wl; switch ( *skipspace(more, 1) ) { case '{': /* Definitely a function header. */ convert1(buf, out, 0, convert_varargs); fputs(more, out); break; case 0: /* The next line was blank or a comment: */ /* keep scanning for a non-comment. */ line += strlen(line); goto f; default: /* buf isn't a function header, but */ /* more might be. */ fputs(buf, out); strcpy(buf, more); line = buf; goto test; } break; case -1: /* maybe the start of a function */ if ( line != buf + (bufsize - 1) ) /* overflow check */ continue; /* falls through */ default: /* not a function */ wl: fputs(buf, out); break; } line = buf; } if ( line != buf ) fputs(buf, out); free(buf); fclose(out); fclose(in); return 0; } /* Skip over space and comments, in either direction. */ char * skipspace(p, dir) register char *p; register int dir; /* 1 for forward, -1 for backward */ { for ( ; ; ) { while ( is_space(*p) ) p += dir; if ( !(*p == '/' && p[dir] == '*') ) break; p += dir; p += dir; while ( !(*p == '*' && p[dir] == '/') ) { if ( *p == 0 ) return p; /* multi-line comment?? */ p += dir; } p += dir; p += dir; } return p; } /* * Write blanks over part of a string. * Don't overwrite end-of-line characters. */ int writeblanks(start, end) char *start; char *end; { char *p; for ( p = start; p < end; p++ ) if ( *p != '\r' && *p != '\n' ) *p = ' '; return 0; } /* * Test whether the string in buf is a function definition. * The string may contain and/or end with a newline. * Return as follows: * 0 - definitely not a function definition; * 1 - definitely a function definition; * 2 - definitely a function prototype (NOT USED); * -1 - may be the beginning of a function definition, * append another line and look again. * The reason we don't attempt to convert function prototypes is that * Ghostscript's declaration-generating macros look too much like * prototypes, and confuse the algorithms. */ int test1(buf) char *buf; { register char *p = buf; char *bend; char *endfn; int contin; if ( !isidfirstchar(*p) ) return 0; /* no name at left margin */ bend = skipspace(buf + strlen(buf) - 1, -1); switch ( *bend ) { case ';': contin = 0 /*2*/; break; case ')': contin = 1; break; case '{': return 0; /* not a function */ case '}': return 0; /* not a function */ default: contin = -1; } while ( isidchar(*p) ) p++; endfn = p; p = skipspace(p, 1); if ( *p++ != '(' ) return 0; /* not a function */ p = skipspace(p, 1); if ( *p == ')' ) return 0; /* no parameters */ /* Check that the apparent function name isn't a keyword. */ /* We only need to check for keywords that could be followed */ /* by a left parenthesis (which, unfortunately, is most of them). */ { static char *words[] = { "asm", "auto", "case", "char", "const", "double", "extern", "float", "for", "if", "int", "long", "register", "return", "short", "signed", "sizeof", "static", "switch", "typedef", "unsigned", "void", "volatile", "while", 0 }; char **key = words; char *kp; int len = endfn - buf; while ( (kp = *key) != 0 ) { if ( strlen(kp) == len && !strncmp(kp, buf, len) ) return 0; /* name is a keyword */ key++; } } return contin; } /* Convert a recognized function definition or header to K&R syntax. */ int convert1(buf, out, header, convert_varargs) char *buf; FILE *out; int header; /* Boolean */ int convert_varargs; /* Boolean */ { char *endfn; register char *p; char **breaks; unsigned num_breaks = 2; /* for testing */ char **btop; char **bp; char **ap; char *vararg = 0; /* Pre-ANSI implementations don't agree on whether strchr */ /* is called strchr or index, so we open-code it here. */ for ( endfn = buf; *(endfn++) != '('; ) ; top: p = endfn; breaks = (char **)malloc(sizeof(char *) * num_breaks * 2); if ( breaks == 0 ) { /* Couldn't allocate break table, give up */ fprintf(stderr, "Unable to allocate break table!\n"); fputs(buf, out); return -1; } btop = breaks + num_breaks * 2 - 2; bp = breaks; /* Parse the argument list */ do { int level = 0; char *lp = NULL; char *rp; char *end = NULL; if ( bp >= btop ) { /* Filled up break table. */ /* Allocate a bigger one and start over. */ free((char *)breaks); num_breaks <<= 1; goto top; } *bp++ = p; /* Find the end of the argument */ for ( ; end == NULL; p++ ) { switch(*p) { case ',': if ( !level ) end = p; break; case '(': if ( !level ) lp = p; level++; break; case ')': if ( --level < 0 ) end = p; else rp = p; break; case '/': p = skipspace(p, 1) - 1; break; default: ; } } /* Erase any embedded prototype parameters. */ if ( lp ) writeblanks(lp + 1, rp); p--; /* back up over terminator */ /* Find the name being declared. */ /* This is complicated because of procedure and */ /* array modifiers. */ for ( ; ; ) { p = skipspace(p - 1, -1); switch ( *p ) { case ']': /* skip array dimension(s) */ case ')': /* skip procedure args OR name */ { int level = 1; while ( level ) switch ( *--p ) { case ']': case ')': level++; break; case '[': case '(': level--; break; case '/': p = skipspace(p, -1) + 1; break; default: ; } } if ( *p == '(' && *skipspace(p + 1, 1) == '*' ) { /* We found the name being declared */ while ( !isidfirstchar(*p) ) p = skipspace(p, 1) + 1; goto found; } break; default: goto found; } } found: if ( *p == '.' && p[-1] == '.' && p[-2] == '.' ) { if ( convert_varargs ) { *bp++ = "va_alist"; vararg = p-2; } else { p++; if ( bp == breaks + 1 ) /* sole argument */ writeblanks(breaks[0], p); else writeblanks(bp[-1] - 1, p); bp--; } } else { while ( isidchar(*p) ) p--; *bp++ = p+1; } p = end; } while ( *p++ == ',' ); *bp = p; /* Make a special check for 'void' arglist */ if ( bp == breaks+2 ) { p = skipspace(breaks[0], 1); if ( !strncmp(p, "void", 4) ) { p = skipspace(p+4, 1); if ( p == breaks[2] - 1 ) { bp = breaks; /* yup, pretend arglist is empty */ writeblanks(breaks[0], p + 1); } } } /* Put out the function name and left parenthesis. */ p = buf; while ( p != endfn ) putc(*p, out), p++; /* Put out the declaration. */ if ( header ) { fputs(");", out); for ( p = breaks[0]; *p; p++ ) if ( *p == '\r' || *p == '\n' ) putc(*p, out); } else { for ( ap = breaks+1; ap < bp; ap += 2 ) { p = *ap; while ( isidchar(*p) ) putc(*p, out), p++; if ( ap < bp - 1 ) fputs(", ", out); } fputs(") ", out); /* Put out the argument declarations */ for ( ap = breaks+2; ap <= bp; ap += 2 ) (*ap)[-1] = ';'; if ( vararg != 0 ) { *vararg = 0; fputs(breaks[0], out); /* any prior args */ fputs("va_dcl", out); /* the final arg */ fputs(bp[0], out); } else fputs(breaks[0], out); } free((char *)breaks); return 0; } Papyrus3/JpegDir/JpgLossy/ltconfig0000755000175000017500000012710107535143454014371 0ustar #! /bin/sh # ltconfig - Create a system-specific libtool. # Copyright (C) 1996-1998 Free Software Foundation, Inc. # Gordon Matzigkeit , 1996 # # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # A lot of this script is taken from autoconf-2.10. # The HP-UX ksh and POSIX shell print the target directory to stdout # if CDPATH is set. if test "${CDPATH+set}" = set; then CDPATH=; export CDPATH; fi echo=echo if test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then : else # The Solaris and AIX default echo program unquotes backslashes. # This makes it impossible to quote backslashes using # echo "$something" | sed 's/\\/\\\\/g' # So, we emulate echo with printf '%s\n' echo="printf %s\\n" if test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then : else # Oops. We have no working printf. Try to find a not-so-buggy echo. echo=echo IFS="${IFS= }"; save_ifs="$IFS"; IFS="${IFS}:" for dir in $PATH /usr/ucb; do if test -f $dir/echo && test "X`$dir/echo '\t'`" = 'X\t'; then echo="$dir/echo" break fi done IFS="$save_ifs" fi fi # Sed substitution that helps us do robust quoting. It backslashifies # metacharacters that are still active within double-quoted strings. Xsed='sed -e s/^X//' sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g' # Same as above, but do not quote variable references. double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g' # The name of this program. progname=`$echo "X$0" | $Xsed -e 's%^.*/%%'` # Constants: PROGRAM=ltconfig PACKAGE=libtool VERSION=1.2 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.c 1>&5' ac_link='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.c $LIBS 1>&5' rm="rm -f" help="Try \`$progname --help' for more information." # Global variables: can_build_shared=yes enable_shared=yes # All known linkers require a `.a' archive for static linking. enable_static=yes ltmain= silent= srcdir= ac_config_guess= ac_config_sub= host= nonopt= verify_host=yes with_gcc=no with_gnu_ld=no old_AR="$AR" old_CC="$CC" old_CFLAGS="$CFLAGS" old_CPPFLAGS="$CPPFLAGS" old_LD="$LD" old_LN_S="$LN_S" old_NM="$NM" old_RANLIB="$RANLIB" # Parse the command line options. args= prev= for option do case "$option" in -*=*) optarg=`echo "$option" | sed 's/[-_a-zA-Z0-9]*=//'` ;; *) optarg= ;; esac # If the previous option needs an argument, assign it. if test -n "$prev"; then eval "$prev=\$option" prev= continue fi case "$option" in --help) cat <&2 echo "$help" 1>&2 exit 1 ;; *) if test -z "$ltmain"; then ltmain="$option" elif test -z "$host"; then # This generates an unnecessary warning for sparc-sun-solaris4.1.3_U1 # if test -n "`echo $option| sed 's/[-a-z0-9.]//g'`"; then # echo "$progname: warning \`$option' is not a valid host type" 1>&2 # fi host="$option" else echo "$progname: too many arguments" 1>&2 echo "$help" 1>&2 exit 1 fi ;; esac done if test -z "$ltmain"; then echo "$progname: you must specify a LTMAIN file" 1>&2 echo "$help" 1>&2 exit 1 fi if test -f "$ltmain"; then : else echo "$progname: \`$ltmain' does not exist" 1>&2 echo "$help" 1>&2 exit 1 fi # Quote any args containing shell metacharacters. ltconfig_args= for arg do case "$arg" in *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*) ltconfig_args="$ltconfig_args '$arg'" ;; *) ltconfig_args="$ltconfig_args $arg" ;; esac done # A relevant subset of AC_INIT. # File descriptor usage: # 0 standard input # 1 file creation # 2 errors and warnings # 3 some systems may open it to /dev/tty # 4 used on the Kubota Titan # 5 compiler messages saved in config.log # 6 checking for... messages and results if test "$silent" = yes; then exec 6>/dev/null else exec 6>&1 fi exec 5>>./config.log # NLS nuisances. # Only set LANG and LC_ALL to C if already set. # These must not be set unconditionally because not all systems understand # e.g. LANG=C (notably SCO). if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi if test "${LANG+set}" = set; then LANG=C; export LANG; fi if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu. if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then ac_n= ac_c=' ' ac_t=' ' else ac_n=-n ac_c= ac_t= fi else ac_n= ac_c='\c' ac_t= fi if test -z "$srcdir"; then # Assume the source directory is the same one as the path to ltmain.sh. srcdir=`$echo "$ltmain" | $Xsed -e 's%/[^/]*$%%'` test "$srcdir" = "$ltmain" && srcdir=. fi trap "$rm conftest*; exit 1" 1 2 15 if test "$verify_host" = yes; then # Check for config.guess and config.sub. ac_aux_dir= for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do if test -f $ac_dir/config.guess; then ac_aux_dir=$ac_dir break fi done if test -z "$ac_aux_dir"; then echo "$progname: cannot find config.guess in $srcdir $srcdir/.. $srcdir/../.." 1>&2 echo "$help" 1>&2 exit 1 fi ac_config_guess=$ac_aux_dir/config.guess ac_config_sub=$ac_aux_dir/config.sub # Make sure we can run config.sub. if $ac_config_sub sun4 >/dev/null 2>&1; then : else echo "$progname: cannot run $ac_config_sub" 1>&2 echo "$help" 1>&2 exit 1 fi echo $ac_n "checking host system type""... $ac_c" 1>&6 host_alias=$host case "$host_alias" in "") if host_alias=`$ac_config_guess`; then : else echo "$progname: cannot guess host type; you must specify one" 1>&2 echo "$help" 1>&2 exit 1 fi ;; esac host=`$ac_config_sub $host_alias` echo "$ac_t$host" 1>&6 # Make sure the host verified. test -z "$host" && exit 1 elif test -z "$host"; then echo "$progname: you must specify a host type if you use \`--no-verify'" 1>&2 echo "$help" 1>&2 exit 1 else host_alias=$host fi # Transform linux* to *-*-linux-gnu*, to support old configure scripts. case "$host_os" in linux-gnu*) ;; linux*) host=`echo $host | sed 's/^\(.*-.*-linux\)\(.*\)$/\1-gnu\2/'` esac host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` case "$host_os" in aix3*) # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. if test "${COLLECT_NAMES+set}" != set; then COLLECT_NAMES= export COLLECT_NAMES fi ;; esac # Determine commands to create old-style static archives. old_archive_cmds='$AR cru $oldlib$oldobjs' old_postinstall_cmds='chmod 644 $oldlib' old_postuninstall_cmds= # Set a sane default for `AR'. test -z "$AR" && AR=ar # If RANLIB is not set, then run the test. if test "${RANLIB+set}" != "set"; then result=no echo $ac_n "checking for ranlib... $ac_c" 1>&6 IFS="${IFS= }"; save_ifs="$IFS"; IFS="${IFS}:" for dir in $PATH; do test -z "$dir" && dir=. if test -f $dir/ranlib; then RANLIB="ranlib" result="ranlib" break fi done IFS="$save_ifs" echo "$ac_t$result" 1>&6 fi if test -n "$RANLIB"; then old_archive_cmds="$old_archive_cmds;\$RANLIB \$oldlib" old_postinstall_cmds="\$RANLIB \$oldlib;$old_postinstall_cmds" fi # Check to see if we are using GCC. if test "$with_gcc" != yes || test -z "$CC"; then # If CC is not set, then try to find GCC or a usable CC. if test -z "$CC"; then echo $ac_n "checking for gcc... $ac_c" 1>&6 IFS="${IFS= }"; save_ifs="$IFS"; IFS="${IFS}:" for dir in $PATH; do IFS="$save_ifs" test -z "$dir" && dir=. if test -f $dir/gcc; then CC="gcc" break fi done IFS="$save_ifs" if test -n "$CC"; then echo "$ac_t$CC" 1>&6 else echo "$ac_t"no 1>&6 fi fi # Not "gcc", so try "cc", rejecting "/usr/ucb/cc". if test -z "$CC"; then echo $ac_n "checking for cc... $ac_c" 1>&6 IFS="${IFS= }"; save_ifs="$IFS"; IFS="${IFS}:" cc_rejected=no for dir in $PATH; do test -z "$dir" && dir=. if test -f $dir/cc; then if test "$dir/cc" = "/usr/ucb/cc"; then cc_rejected=yes continue fi CC="cc" break fi done IFS="$save_ifs" if test $cc_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $CC shift if test $# -gt 0; then # We chose a different compiler from the bogus one. # However, it has the same name, so the bogon will be chosen # first if we set CC to just the name; use the full file name. shift set dummy "$dir/cc" "$@" shift CC="$@" fi fi if test -n "$CC"; then echo "$ac_t$CC" 1>&6 else echo "$ac_t"no 1>&6 fi if test -z "$CC"; then echo "$progname: error: no acceptable cc found in \$PATH" 1>&2 exit 1 fi fi # Now see if the compiler is really GCC. with_gcc=no echo $ac_n "checking whether we are using GNU C... $ac_c" 1>&6 echo "$progname:424: checking whether we are using GNU C" >&5 $rm conftest.c cat > conftest.c <&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then with_gcc=yes fi $rm conftest.c echo "$ac_t$with_gcc" 1>&6 fi # Allow CC to be a program name with arguments. set dummy $CC compiler="$2" echo $ac_n "checking for $compiler option to produce PIC... $ac_c" 1>&6 pic_flag= special_shlib_compile_flags= wl= link_static_flag= no_builtin_flag= if test "$with_gcc" = yes; then wl='-Wl,' link_static_flag='-static' no_builtin_flag=' -fno-builtin' case "$host_os" in aix3* | aix4* | irix5* | irix6* | osf3* | osf4*) # PIC is the default for these OSes. ;; os2*) # We can build DLLs from non-PIC. ;; amigaos*) # FIXME: we need at least 68020 code to build shared libraries, but # adding the `-m68020' flag to GCC prevents building anything better, # like `-m68040'. pic_flag='-m68020 -resident32 -malways-restore-a4' ;; *) pic_flag='-fPIC' ;; esac else # PORTME Check for PIC flags for the system compiler. case "$host_os" in aix3* | aix4*) # All AIX code is PIC. link_static_flag='-bnso -bI:/lib/syscalls.exp' ;; hpux9* | hpux10*) # Is there a better link_static_flag that works with the bundled CC? wl='-Wl,' link_static_flag="${wl}-a ${wl}archive" pic_flag='+Z' ;; irix5* | irix6*) wl='-Wl,' link_static_flag='-non_shared' # PIC (with -KPIC) is the default. ;; os2*) # We can build DLLs from non-PIC. ;; osf3* | osf4*) # All OSF/1 code is PIC. wl='-Wl,' link_static_flag='-non_shared' ;; sco3.2v5*) pic_flag='-Kpic' link_static_flag='-dn' special_shlib_compile_flags='-belf' ;; solaris2*) pic_flag='-KPIC' link_static_flag='-Bstatic' wl='-Wl,' ;; sunos4*) pic_flag='-PIC' link_static_flag='-Bstatic' wl='-Qoption ld ' ;; sysv4.2uw2*) pic_flag='-KPIC' link_static_flag='-Bstatic' wl='-Wl,' ;; uts4*) pic_flag='-pic' link_static_flag='-Bstatic' ;; *) can_build_shared=no ;; esac fi if test -n "$pic_flag"; then echo "$ac_t$pic_flag" 1>&6 # Check to make sure the pic_flag actually works. echo $ac_n "checking if $compiler PIC flag $pic_flag works... $ac_c" 1>&6 $rm conftest* echo > conftest.c save_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS $pic_flag -DPIC" echo "$progname:547: checking if $compiler PIC flag $pic_flag works" >&5 if { (eval echo $progname:548: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>conftest.err; } && test -s conftest.o; then # Append any warnings to the config.log. cat conftest.err 1>&5 # On HP-UX, both CC and GCC only warn that PIC is supported... then they # create non-PIC objects. So, if there were any warnings, we assume that # PIC is not supported. if test -s conftest.err; then echo "$ac_t"no 1>&6 can_build_shared=no pic_flag= else echo "$ac_t"yes 1>&6 pic_flag=" $pic_flag" fi else # Append any errors to the config.log. cat conftest.err 1>&5 can_build_shared=no pic_flag= echo "$ac_t"no 1>&6 fi CFLAGS="$save_CFLAGS" $rm conftest* else echo "$ac_t"none 1>&6 fi # Check for any special shared library compilation flags. if test -n "$special_shlib_compile_flags"; then echo "$progname: warning: \`$CC' requires \`$special_shlib_compile_flags' to build shared libraries" 1>&2 if echo "$old_CC $old_CFLAGS " | egrep -e "[ ]$special_shlib_compile_flags[ ]" >/dev/null; then : else echo "$progname: add \`$special_shlib_compile_flags' to the CC or CFLAGS env variable and reconfigure" 1>&2 can_build_shared=no fi fi echo $ac_n "checking if $compiler static flag $link_static_flag works... $ac_c" 1>&6 $rm conftest* echo 'main(){return(0);}' > conftest.c save_LDFLAGS="$LDFLAGS" LDFLAGS="$LDFLAGS $link_static_flag" echo "$progname:591: checking if $compiler static flag $link_static_flag works" >&5 if { (eval echo $progname:592: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then echo "$ac_t$link_static_flag" 1>&6 else echo "$ac_t"none 1>&6 link_static_flag= fi LDFLAGS="$save_LDFLAGS" $rm conftest* if test -z "$LN_S"; then # Check to see if we can use ln -s, or we need hard links. echo $ac_n "checking whether ln -s works... $ac_c" 1>&6 $rm conftestdata if ln -s X conftestdata 2>/dev/null; then $rm conftestdata LN_S="ln -s" else LN_S=ln fi if test "$LN_S" = "ln -s"; then echo "$ac_t"yes 1>&6 else echo "$ac_t"no 1>&6 fi fi # Make sure LD is an absolute path. if test -z "$LD"; then ac_prog=ld if test "$with_gcc" = yes; then # Check if gcc -print-prog-name=ld gives a path. echo $ac_n "checking for ld used by GCC... $ac_c" 1>&6 echo "$progname:624: checking for ld used by GCC" >&5 ac_prog=`($CC -print-prog-name=ld) 2>&5` case "$ac_prog" in # Accept absolute paths. /* | [A-Za-z]:\\*) test -z "$LD" && LD="$ac_prog" ;; "") # If it fails, then pretend we are not using GCC. ac_prog=ld ;; *) # If it is relative, then search for the first ld in PATH. with_gnu_ld=unknown ;; esac elif test "$with_gnu_ld" = yes; then echo $ac_n "checking for GNU ld... $ac_c" 1>&6 echo "$progname:642: checking for GNU ld" >&5 else echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6 echo "$progname:645: checking for non-GNU ld" >&5 fi if test -z "$LD"; then IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f "$ac_dir/$ac_prog"; then LD="$ac_dir/$ac_prog" # Check to see if the program is GNU ld. I'd rather use --version, # but apparently some GNU ld's only accept -v. # Break only if it was the GNU/non-GNU ld that we prefer. if "$LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then test "$with_gnu_ld" != no && break else test "$with_gnu_ld" != yes && break fi fi done IFS="$ac_save_ifs" fi if test -n "$LD"; then echo "$ac_t$LD" 1>&6 else echo "$ac_t"no 1>&6 fi if test -z "$LD"; then echo "$progname: error: no acceptable ld found in \$PATH" 1>&2 exit 1 fi fi # Check to see if it really is or is not GNU ld. echo $ac_n "checking if the linker ($LD) is GNU ld... $ac_c" 1>&6 # I'd rather use --version here, but apparently some GNU ld's only accept -v. if $LD -v 2>&1 &5; then with_gnu_ld=yes else with_gnu_ld=no fi echo "$ac_t$with_gnu_ld" 1>&6 # See if the linker supports building shared libraries. echo $ac_n "checking whether the linker ($LD) supports shared libraries... $ac_c" 1>&6 allow_undefined_flag= no_undefined_flag= archive_cmds= old_archive_from_new_cmds= export_dynamic_flag_spec= hardcode_libdir_flag_spec= hardcode_libdir_separator= hardcode_direct=no hardcode_minus_L=no hardcode_shlibpath_var=unsupported runpath_var= case "$host_os" in amigaos* | sunos4*) # On these operating systems, we should treat GNU ld like the system ld. gnu_ld_acts_native=yes ;; *) gnu_ld_acts_native=no ;; esac ld_shlibs=yes if test "$with_gnu_ld" = yes && test "$gnu_ld_acts_native" != yes; then # See if GNU ld supports shared libraries. if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then archive_cmds='$CC -shared ${wl}-soname $wl$soname -o $lib$libobjs' runpath_var=LD_RUN_PATH ld_shlibs=yes else ld_shlibs=no fi if test "$ld_shlibs" = yes; then hardcode_libdir_flag_spec='${wl}--rpath ${wl}$libdir' export_dynamic_flag_spec='${wl}--export-dynamic' fi else # PORTME fill in a description of your system's linker (not GNU ld) case "$host_os" in aix3*) allow_undefined_flag=unsupported archive_cmds='$NM$libobjs | $global_symbol_pipe | sed '\''s/.* //'\'' > $lib.exp;$LD -o $objdir/$soname$libobjs -bE:$lib.exp -T512 -H512 -bM:SRE;$AR cru $lib $objdir/$soname' # Note: this linker hardcodes the directories in LIBPATH if there # are no directories specified by -L. hardcode_minus_L=yes if test "$with_gcc" = yes && test -z "$link_static_flag"; then # Neither direct hardcoding nor static linking is supported with a # broken collect2. hardcode_direct=unsupported fi ;; aix4*) allow_undefined_flag=unsupported archive_cmds='$NM$libobjs | $global_symbol_pipe | sed '\''s/.* //'\'' > $lib.exp;$CC -o $objdir/$soname$libobjs ${wl}-bE:$lib.exp ${wl}-bM:SRE ${wl}-bnoentry;$AR cru $lib $objdir/$soname' hardcode_direct=yes hardcode_minus_L=yes ;; amigaos*) archive_cmds='$rm $objdir/a2ixlibrary.data;$echo "#define NAME $libname" > $objdir/a2ixlibrary.data;$echo "#define LIBRARY_ID 1" >> $objdir/a2ixlibrary.data;$echo "#define VERSION $major" >> $objdir/a2ixlibrary.data;$echo "#define REVISION $revision" >> $objdir/a2ixlibrary.data;$AR cru $lib$libobjs;$RANLIB $lib;(cd $objdir && a2ixlibrary -32)' hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes ;; # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor # support. Future versions do this automatically, but an explicit c++rt0.o # does not break anything, and helps significantly (at the cost of a little # extra space). freebsd2.2*) archive_cmds='$LD -Bshareable -o $lib$libobjs /usr/lib/c++rt0.o' hardcode_libdir_flag_spec='-R$libdir' hardcode_direct=yes hardcode_minus_L=yes hardcode_shlibpath_var=no ;; # Unfortunately, older versions of FreeBSD 2 do not have this feature. freebsd2*) archive_cmds='$LD -Bshareable -o $lib$libobjs' hardcode_direct=yes hardcode_minus_L=yes hardcode_shlibpath_var=no ;; # FreeBSD 3, at last, uses gcc -shared to do shared libraries. freebsd3*) archive_cmds='$CC -shared -o $lib$libobjs' hardcode_libdir_flag_spec='-R$libdir' hardcode_direct=yes hardcode_minus_L=yes hardcode_shlibpath_var=no ;; hpux9*) archive_cmds='$rm $objdir/$soname;$LD -b +s +b $install_libdir -o $objdir/$soname$libobjs;mv $objdir/$soname $lib' hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' hardcode_direct=yes hardcode_minus_L=yes export_dynamic_flag_spec='${wl}-E' ;; hpux10*) archive_cmds='$LD -b +h $soname +s +b $install_libdir -o $lib$libobjs' hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' hardcode_direct=yes hardcode_minus_L=yes export_dynamic_flag_spec='${wl}-E' ;; irix5* | irix6*) archive_cmds='$LD -shared -o $lib -soname $soname -set_version $verstring$libobjs' hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' ;; netbsd*) # Tested with NetBSD 1.2 ld archive_cmds='$LD -Bshareable -o $lib$libobjs' hardcode_libdir_flag_spec='-R$libdir' hardcode_direct=yes hardcode_shlibpath_var=no ;; openbsd*) archive_cmds='$LD -Bshareable -o $lib$libobjs' hardcode_libdir_flag_spec='-R$libdir' hardcode_direct=yes hardcode_shlibpath_var=no ;; os2*) hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes allow_undefined_flag=unsupported archive_cmds='$echo "LIBRARY $libname INITINSTANCE" > $objdir/$libname.def;$echo "DESCRIPTION \"$libname\"" >> $objdir/$libname.def;$echo DATA >> $objdir/$libname.def;$echo " SINGLE NONSHARED" >> $objdir/$libname.def;$echo EXPORTS >> $objdir/$libname.def;emxexp$libobjs >> $objdir/$libname.def;$CC -Zdll -Zcrtdll -o $lib$libobjs $objdir/$libname.def' old_archive_from_new_cmds='emximp -o $objdir/$libname.a $objdir/$libname.def' ;; osf3* | osf4*) allow_undefined_flag=' -expect_unresolved \*' archive_cmds='$LD -shared${allow_undefined_flag} -o $lib -soname $soname -set_version $verstring$libobjs$deplibs' hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' hardcode_libdir_separator=: ;; sco3.2v5*) archive_cmds='$LD -G -o $lib$libobjs' hardcode_direct=yes ;; solaris2*) no_undefined_flag=' -z text' archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib$libobjs' hardcode_libdir_flag_spec='-R$libdir' hardcode_shlibpath_var=no # Solaris 2 before 2.5 hardcodes -L paths. case "$host_os" in solaris2.[0-4]*) hardcode_minus_L=yes ;; esac ;; sunos4*) if test "$with_gcc" = yes; then archive_cmds='$CC -shared -o $lib$libobjs' else archive_cmds='$LD -assert pure-text -Bstatic -o $lib$libobjs' fi if test "$with_gnu_ld" = yes; then export_dynamic_flag_spec='${wl}-export-dynamic' fi hardcode_libdir_flag_spec='-L$libdir' hardcode_direct=yes hardcode_minus_L=yes hardcode_shlibpath_var=no ;; uts4*) archive_cmds='$LD -G -h $soname -o $lib$libobjs' hardcode_libdir_flag_spec='-L$libdir' hardcode_direct=no hardcode_minus_L=no hardcode_shlibpath_var=no ;; *) ld_shlibs=no can_build_shared=no ;; esac fi echo "$ac_t$ld_shlibs" 1>&6 if test -z "$NM"; then echo $ac_n "checking for BSD-compatible nm... $ac_c" 1>&6 case "$NM" in /* | [A-Za-z]:\\*) ;; # Let the user override the test with a path. *) IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:" for ac_dir in /usr/ucb /usr/ccs/bin $PATH /bin; do test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/nm; then # Check to see if the nm accepts a BSD-compat flag. # Adding the `sed 1q' prevents false positives on HP-UX, which says: # nm: unknown option "B" ignored if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then NM="$ac_dir/nm -B" elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then NM="$ac_dir/nm -p" else NM="$ac_dir/nm" fi break fi done IFS="$ac_save_ifs" test -z "$NM" && NM=nm ;; esac echo "$ac_t$NM" 1>&6 fi # Check for command to grab the raw symbol name followed by C symbol from nm. echo $ac_n "checking command to parse $NM output... $ac_c" 1>&6 # These are sane defaults that work on at least a few old systems. # [They come from Ultrix. What could be older than Ultrix?!! ;)] # Character class describing NM global symbol codes. symcode='[BCDEGRSTU]' # Regexp to match symbols that can be accessed directly from C. sympat='\([_A-Za-z][_A-Za-z0-9]*\)' # Transform the above into a raw symbol and a C symbol. symxfrm='\1 \1' # Define system-specific variables. case "$host_os" in aix*) symcode='[BCDTU]' ;; irix*) # Cannot use undefined symbols on IRIX because inlined functions mess us up. symcode='[BCDEGRST]' ;; solaris2*) symcode='[BDTU]' ;; esac # If we're using GNU nm, then use its standard symbol codes. if $NM -V 2>&1 | egrep '(GNU|with BFD)' > /dev/null; then symcode='[ABCDGISTUW]' fi # Write the raw and C identifiers. global_symbol_pipe="sed -n -e 's/^.* $symcode $sympat$/$symxfrm/p'" # Check to see that the pipe works correctly. pipe_works=no $rm conftest* cat > conftest.c <&5 if { (eval echo $progname:972: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; } && test -s conftest.o; then # Now try to grab the symbols. nlist=conftest.nm if { echo "$progname:975: eval \"$NM conftest.o | $global_symbol_pipe > $nlist\"" >&5; eval "$NM conftest.o | $global_symbol_pipe > $nlist 2>&5"; } && test -s "$nlist"; then # Try sorting and uniquifying the output. if sort "$nlist" | uniq > "$nlist"T; then mv -f "$nlist"T "$nlist" wcout=`wc "$nlist" 2>/dev/null` count=`$echo "X$wcout" | $Xsed -e 's/^[ ]*\([0-9][0-9]*\).*$/\1/'` (test "$count" -ge 0) 2>/dev/null || count=-1 else rm -f "$nlist"T count=-1 fi # Make sure that we snagged all the symbols we need. if egrep ' nm_test_var$' "$nlist" >/dev/null; then if egrep ' nm_test_func$' "$nlist" >/dev/null; then cat < conftest.c #ifdef __cplusplus extern "C" { #endif EOF # Now generate the symbol file. sed 's/^.* \(.*\)$/extern char \1;/' < "$nlist" >> conftest.c cat <> conftest.c #if defined (__STDC__) && __STDC__ # define __ptr_t void * #else # define __ptr_t char * #endif /* The number of symbols in dld_preloaded_symbols, -1 if unsorted. */ int dld_preloaded_symbol_count = $count; /* The mapping between symbol names and symbols. */ struct { char *name; __ptr_t address; } dld_preloaded_symbols[] = { EOF sed 's/^\(.*\) \(.*\)$/ {"\1", (__ptr_t) \&\2},/' < "$nlist" >> conftest.c cat <<\EOF >> conftest.c {0, (__ptr_t) 0} }; #ifdef __cplusplus } #endif EOF # Now try linking the two files. mv conftest.o conftestm.o save_LIBS="$LIBS" save_CFLAGS="$CFLAGS" LIBS='conftestm.o' CFLAGS="$CFLAGS$no_builtin_flag" if { (eval echo $progname:1033: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then pipe_works=yes else echo "$progname: failed program was:" >&5 cat conftest.c >&5 fi LIBS="$save_LIBS" else echo "cannot find nm_test_func in $nlist" >&5 fi else echo "cannot find nm_test_var in $nlist" >&5 fi else echo "cannot run $global_symbol_pipe" >&5 fi else echo "$progname: failed program was:" >&5 cat conftest.c >&5 fi $rm conftest* # Do not use the global_symbol_pipe unless it works. echo "$ac_t$pipe_works" 1>&6 test "$pipe_works" = yes || global_symbol_pipe= # Check hardcoding attributes. echo $ac_n "checking how to hardcode library paths into programs... $ac_c" 1>&6 hardcode_action= if test -n "$hardcode_libdir_flag_spec" || \ test -n "$runpath_var"; then # We can hardcode non-existant directories. if test "$hardcode_direct" != no && \ test "$hardcode_minus_L" != no && \ test "$hardcode_shlibpath_var" != no; then # Linking always hardcodes the temporary library directory. hardcode_action=relink else # We can link without hardcoding, and we can hardcode nonexisting dirs. hardcode_action=immediate fi elif test "$hardcode_direct" != yes && \ test "$hardcode_minus_L" != yes && \ test "$hardcode_shlibpath_var" != yes; then # We cannot hardcode anything. hardcode_action=unsupported else # We can only hardcode existing directories. hardcode_action=relink fi echo "$ac_t$hardcode_action" 1>&6 test "$hardcode_action" = unsupported && can_build_shared=no reload_flag= reload_cmds='$LD$reload_flag -o $output$reload_objs' echo $ac_n "checking for $LD option to reload object files... $ac_c" 1>&6 # PORTME Some linker may need a different reload flag. reload_flag='-r' echo "$ac_t$reload_flag" test -n "$reload_flag" && reload_flag=" $reload_flag" # PORTME Fill in your ld.so characteristics library_names_spec= libname_spec='lib$name' soname_spec= postinstall_cmds= postuninstall_cmds= finish_cmds= finish_eval= shlibpath_var= version_type=none dynamic_linker="$host_os ld.so" echo $ac_n "checking dynamic linker characteristics... $ac_c" 1>&6 case "$host_os" in aix3* | aix4*) version_type=linux library_names_spec='${libname}${release}.so.$versuffix $libname.a' shlibpath_var=LIBPATH # AIX has no versioning support, so we append a major version to the name. soname_spec='${libname}${release}.so.$major' ;; amigaos*) library_names_spec='$libname.ixlibrary $libname.a' # Create ${libname}_ixlibrary.a entries in /sys/libs. finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "(cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a)"; (cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a) || exit 1; done' ;; freebsd2* | freebsd3*) version_type=sunos library_names_spec='${libname}${release}.so.$versuffix $libname.so' finish_cmds='PATH="$PATH:/sbin" ldconfig -m $libdir' shlibpath_var=LD_LIBRARY_PATH ;; gnu*) version_type=sunos library_names_spec='${libname}${release}.so.$versuffix' shlibpath_var=LD_LIBRARY_PATH ;; hpux9* | hpux10*) # Give a soname corresponding to the major version so that dld.sl refuses to # link against other versions. dynamic_linker="$host_os dld.sl" version_type=sunos shlibpath_var=SHLIB_PATH library_names_spec='${libname}${release}.sl.$versuffix ${libname}${release}.sl.$major $libname.sl' soname_spec='${libname}${release}.sl.$major' # HP-UX runs *really* slowly unless shared libraries are mode 555. postinstall_cmds='chmod 555 $lib' ;; irix5* | irix6*) version_type=osf soname_spec='${libname}${release}.so' library_names_spec='${libname}${release}.so.$versuffix $libname.so' shlibpath_var=LD_LIBRARY_PATH ;; # No shared lib support for Linux oldld, aout, or coff. linux-gnuoldld* | linux-gnuaout* | linux-gnucoff*) dynamic_linker=no ;; # This must be Linux ELF. linux-gnu*) version_type=linux library_names_spec='${libname}${release}.so.$versuffix ${libname}${release}.so.$major $libname.so' soname_spec='${libname}${release}.so.$major' finish_cmds='PATH="$PATH:/sbin" ldconfig -n $libdir' shlibpath_var=LD_LIBRARY_PATH if test -f /lib/ld.so.1; then dynamic_linker='GNU ld.so' else # Only the GNU ld.so supports shared libraries on MkLinux. case "$host_cpu" in powerpc*) dynamic_linker=no ;; *) dynamic_linker='Linux ld.so' ;; esac fi ;; netbsd* | openbsd*) version_type=sunos library_names_spec='${libname}${release}.so.$versuffix' finish_cmds='PATH="$PATH:/sbin" ldconfig -m $libdir' shlibpath_var=LD_LIBRARY_PATH ;; os2*) libname_spec='$name' library_names_spec='$libname.dll $libname.a' dynamic_linker='OS/2 ld.exe' shlibpath_var=LIBPATH ;; osf3* | osf4*) version_type=osf soname_spec='${libname}${release}.so' library_names_spec='${libname}${release}.so.$versuffix $libname.so' shlibpath_var=LD_LIBRARY_PATH ;; sco3.2v5*) version_type=osf soname_spec='${libname}${release}.so.$major' library_names_spec='${libname}${release}.so.$versuffix ${libname}${release}.so.$major $libname.so' shlibpath_var=LD_LIBRARY_PATH ;; solaris2*) version_type=linux library_names_spec='${libname}${release}.so.$versuffix ${libname}${release}.so.$major $libname.so' soname_spec='${libname}${release}.so.$major' shlibpath_var=LD_LIBRARY_PATH ;; sunos4*) version_type=sunos library_names_spec='${libname}${release}.so.$versuffix' finish_cmds='PATH="$PATH:/usr/etc" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH ;; sysv4.2uw2*) version_type=linux library_names_spec='${libname}${release}.so.$versuffix ${libname}${release}.so.$major $libname.so' soname_spec='${libname}${release}.so.$major' shlibpath_var=LD_LIBRARY_PATH ;; uts4*) version_type=linux library_names_spec='${libname}${release}.so.$versuffix ${libname}${release}.so.$major $libname.so' soname_spec='${libname}${release}.so.$major' shlibpath_var=LD_LIBRARY_PATH ;; *) dynamic_linker=no ;; esac echo "$ac_t$dynamic_linker" test "$dynamic_linker" = no && can_build_shared=no # Report the final consequences. echo "checking if libtool supports shared libraries... $can_build_shared" 1>&6 echo $ac_n "checking whether to build shared libraries... $ac_c" 1>&6 test "$can_build_shared" = "no" && enable_shared=no # On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case "$host_os" in aix*) test "$enable_shared" = yes && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds;\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; esac echo "$ac_t$enable_shared" 1>&6 # Make sure either enable_shared or enable_static is yes. test "$enable_shared" = yes || enable_static=yes echo "checking whether to build static libraries... $enable_static" 1>&6 echo $ac_n "checking for objdir... $ac_c" 1>&6 rm -f .libs 2>/dev/null mkdir .libs 2>/dev/null if test -d .libs; then objdir=.libs else # MS-DOS does not allow filenames that begin with a dot. objdir=_libs fi rmdir .libs 2>/dev/null echo "$ac_t$objdir" 1>&6 # Copy echo and quote the copy, instead of the original, because it is # used later. ltecho="$echo" # Now quote all the things that may contain metacharacters. for var in ltecho old_CC old_CFLAGS old_CPPFLAGS old_LD old_NM old_RANLIB \ old_LN_S AR CC LD LN_S NM reload_flag reload_cmds wl pic_flag \ link_static_flag no_builtin_flag export_dynamic_flag_spec \ libname_spec library_names_spec soname_spec RANLIB \ old_archive_cmds old_archive_from_new_cmds old_postinstall_cmds \ old_postuninstall_cmds archive_cmds postinstall_cmds postuninstall_cmds \ allow_undefined_flag no_undefined_flag \ finish_cmds finish_eval global_symbol_pipe \ hardcode_libdir_flag_spec hardcode_libdir_separator; do case "$var" in reload_cmds | old_archive_cmds | old_archive_from_new_cmds | \ old_postinstall_cmds | old_postuninstall_cmds | archive_cmds | \ postinstall_cmds | postuninstall_cmds | finish_cmds) # Double-quote double-evaled strings. eval "$var=\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\"\`" ;; *) eval "$var=\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`" ;; esac done ofile=libtool trap "$rm $ofile; exit 1" 1 2 15 echo creating $ofile $rm $ofile cat < $ofile #! /bin/sh # libtool - Provide generalized library-building support services. # Generated automatically by $PROGRAM - GNU $PACKAGE $VERSION # NOTE: Changes made to this file will be lost: look at ltconfig or ltmain.sh. # # Copyright (C) 1996-1998 Free Software Foundation, Inc. # Gordon Matzigkeit , 1996 # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # This program was configured as follows, # on host `(hostname || uname -n) 2>/dev/null | sed 1q`: # # CC="$old_CC" CFLAGS="$old_CFLAGS" CPPFLAGS="$old_CPPFLAGS" \\ # LD="$old_LD" NM="$old_NM" RANLIB="$old_RANLIB" LN_S="$old_LN_S" \\ # $0$ltconfig_args # # Compiler and other test output produced by $progname, useful for # debugging $progname, is in ./config.log if it exists. # Sed that helps us avoid accidentally triggering echo(1) options like -n. Xsed="sed -e s/^X//" # The HP-UX ksh and POSIX shell print the target directory to stdout # if CDPATH is set. if test "\${CDPATH+set}" = set; then CDPATH=; export CDPATH; fi # An echo program that does not interpret backslashes. echo="$ltecho" # The version of $progname that generated this script. LTCONFIG_VERSION="$VERSION" # Shell to use when invoking shell scripts. SHELL=${CONFIG_SHELL-/bin/sh} # Whether or not to build libtool libraries. build_libtool_libs=$enable_shared # Whether or not to build old-style libraries. build_old_libs=$enable_static # The host system. host_alias="$host_alias" host="$host" # The archiver. AR="$AR" # The default C compiler. CC="$CC" # The linker used to build libraries. LD="$LD" # Whether we need hard or soft links. LN_S="$LN_S" # A BSD-compatible nm program. NM="$NM" # The name of the directory that contains temporary libtool files. objdir="$objdir" # How to create reloadable object files. reload_flag="$reload_flag" reload_cmds="$reload_cmds" # How to pass a linker flag through the compiler. wl="$wl" # Additional compiler flags for building library objects. pic_flag="$pic_flag" # Compiler flag to prevent dynamic linking. link_static_flag="$link_static_flag" # Compiler flag to turn off builtin functions. no_builtin_flag="$no_builtin_flag" # Compiler flag to allow reflexive dlopens. export_dynamic_flag_spec="$export_dynamic_flag_spec" # Library versioning type. version_type=$version_type # Format of library name prefix. libname_spec="$libname_spec" # List of archive names. First name is the real one, the rest are links. # The last name is the one that the linker finds with -lNAME. library_names_spec="$library_names_spec" # The coded name of the library, if different from the real name. soname_spec="$soname_spec" # Commands used to build and install an old-style archive. RANLIB="$RANLIB" old_archive_cmds="$old_archive_cmds" old_postinstall_cmds="$old_postinstall_cmds" old_postuninstall_cmds="$old_postuninstall_cmds" # Create an old-style archive from a shared archive. old_archive_from_new_cmds="$old_archive_from_new_cmds" # Commands used to build and install a shared archive. archive_cmds="$archive_cmds" postinstall_cmds="$postinstall_cmds" postuninstall_cmds="$postuninstall_cmds" # Flag that allows shared libraries with undefined symbols to be built. allow_undefined_flag="$allow_undefined_flag" # Flag that forces no undefined symbols. no_undefined_flag="$no_undefined_flag" # Commands used to finish a libtool library installation in a directory. finish_cmds="$finish_cmds" # Same as above, but a single script fragment to be evaled but not shown. finish_eval="$finish_eval" # Take the output of nm and produce a listing of raw symbols and C names. global_symbol_pipe="$global_symbol_pipe" # This is the shared library runtime path variable. runpath_var=$runpath_var # This is the shared library path variable. shlibpath_var=$shlibpath_var # How to hardcode a shared library path into an executable. hardcode_action=$hardcode_action # Flag to hardcode \$libdir into a binary during linking. # This must work even if \$libdir does not exist. hardcode_libdir_flag_spec="$hardcode_libdir_flag_spec" # Whether we need a single -rpath flag with a separated argument. hardcode_libdir_separator="$hardcode_libdir_separator" # Set to yes if using DIR/libNAME.so during linking hardcodes DIR into the # resulting binary. hardcode_direct=$hardcode_direct # Set to yes if using the -LDIR flag during linking hardcodes DIR into the # resulting binary. hardcode_minus_L=$hardcode_minus_L # Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into # the resulting binary. hardcode_shlibpath_var=$hardcode_shlibpath_var EOF case "$host_os" in aix3*) cat <<\EOF >> $ofile # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. if test "${COLLECT_NAMES+set}" != set; then COLLECT_NAMES= export COLLECT_NAMES fi EOF ;; esac # Append the ltmain.sh script. cat "$ltmain" >> $ofile || (rm -f $ofile; exit 1) chmod +x $ofile exit 0 # Local Variables: # mode:shell-script # sh-indentation:2 # End: Papyrus3/JpegDir/JpgLossy/CDERROR.H0000755000175000017500000001240507535143454014052 0ustar /* * cderror.h * * Copyright (C) 1994-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file defines the error and message codes for the cjpeg/djpeg * applications. These strings are not needed as part of the JPEG library * proper. * Edit this file to add new codes, or to translate the message strings to * some other language. */ /* * To define the enum list of message codes, include this file without * defining macro JMESSAGE. To create a message string table, include it * again with a suitable JMESSAGE definition (see jerror.c for an example). */ #ifndef JMESSAGE #ifndef CDERROR_H #define CDERROR_H /* First time through, define the enum list */ #define JMAKE_ENUM_LIST #else /* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */ #define JMESSAGE(code,string) #endif /* CDERROR_H */ #endif /* JMESSAGE */ #ifdef JMAKE_ENUM_LIST typedef enum { #define JMESSAGE(code,string) code , #endif /* JMAKE_ENUM_LIST */ JMESSAGE(JMSG_FIRSTADDONCODE=1000, NULL) /* Must be first entry! */ #ifdef BMP_SUPPORTED JMESSAGE(JERR_BMP_BADCMAP, "Unsupported BMP colormap format") JMESSAGE(JERR_BMP_BADDEPTH, "Only 8- and 24-bit BMP files are supported") JMESSAGE(JERR_BMP_BADHEADER, "Invalid BMP file: bad header length") JMESSAGE(JERR_BMP_BADPLANES, "Invalid BMP file: biPlanes not equal to 1") JMESSAGE(JERR_BMP_COLORSPACE, "BMP output must be grayscale or RGB") JMESSAGE(JERR_BMP_COMPRESSED, "Sorry, compressed BMPs not yet supported") JMESSAGE(JERR_BMP_NOT, "Not a BMP file - does not start with BM") JMESSAGE(JTRC_BMP, "%ux%u 24-bit BMP image") JMESSAGE(JTRC_BMP_MAPPED, "%ux%u 8-bit colormapped BMP image") JMESSAGE(JTRC_BMP_OS2, "%ux%u 24-bit OS2 BMP image") JMESSAGE(JTRC_BMP_OS2_MAPPED, "%ux%u 8-bit colormapped OS2 BMP image") #endif /* BMP_SUPPORTED */ #ifdef GIF_SUPPORTED JMESSAGE(JERR_GIF_BUG, "GIF output got confused") JMESSAGE(JERR_GIF_CODESIZE, "Bogus GIF codesize %d") JMESSAGE(JERR_GIF_COLORSPACE, "GIF output must be grayscale or RGB") JMESSAGE(JERR_GIF_IMAGENOTFOUND, "Too few images in GIF file") JMESSAGE(JERR_GIF_NOT, "Not a GIF file") JMESSAGE(JTRC_GIF, "%ux%ux%d GIF image") JMESSAGE(JTRC_GIF_BADVERSION, "Warning: unexpected GIF version number '%c%c%c'") JMESSAGE(JTRC_GIF_EXTENSION, "Ignoring GIF extension block of type 0x%02x") JMESSAGE(JTRC_GIF_NONSQUARE, "Caution: nonsquare pixels in input") JMESSAGE(JWRN_GIF_BADDATA, "Corrupt data in GIF file") JMESSAGE(JWRN_GIF_CHAR, "Bogus char 0x%02x in GIF file, ignoring") JMESSAGE(JWRN_GIF_ENDCODE, "Premature end of GIF image") JMESSAGE(JWRN_GIF_NOMOREDATA, "Ran out of GIF bits") #endif /* GIF_SUPPORTED */ #ifdef PPM_SUPPORTED JMESSAGE(JERR_PPM_COLORSPACE, "PPM output must be grayscale or RGB") JMESSAGE(JERR_PPM_NONNUMERIC, "Nonnumeric data in PPM file") JMESSAGE(JERR_PPM_NOT, "Not a PPM/PGM file") JMESSAGE(JTRC_PGM, "%ux%u PGM image") JMESSAGE(JTRC_PGM_TEXT, "%ux%u text PGM image") JMESSAGE(JTRC_PPM, "%ux%u PPM image") JMESSAGE(JTRC_PPM_TEXT, "%ux%u text PPM image") #endif /* PPM_SUPPORTED */ #ifdef RLE_SUPPORTED JMESSAGE(JERR_RLE_BADERROR, "Bogus error code from RLE library") JMESSAGE(JERR_RLE_COLORSPACE, "RLE output must be grayscale or RGB") JMESSAGE(JERR_RLE_DIMENSIONS, "Image dimensions (%ux%u) too large for RLE") JMESSAGE(JERR_RLE_EMPTY, "Empty RLE file") JMESSAGE(JERR_RLE_EOF, "Premature EOF in RLE header") JMESSAGE(JERR_RLE_MEM, "Insufficient memory for RLE header") JMESSAGE(JERR_RLE_NOT, "Not an RLE file") JMESSAGE(JERR_RLE_TOOMANYCHANNELS, "Cannot handle %d output channels for RLE") JMESSAGE(JERR_RLE_UNSUPPORTED, "Cannot handle this RLE setup") JMESSAGE(JTRC_RLE, "%ux%u full-color RLE file") JMESSAGE(JTRC_RLE_FULLMAP, "%ux%u full-color RLE file with map of length %d") JMESSAGE(JTRC_RLE_GRAY, "%ux%u grayscale RLE file") JMESSAGE(JTRC_RLE_MAPGRAY, "%ux%u grayscale RLE file with map of length %d") JMESSAGE(JTRC_RLE_MAPPED, "%ux%u colormapped RLE file with map of length %d") #endif /* RLE_SUPPORTED */ #ifdef TARGA_SUPPORTED JMESSAGE(JERR_TGA_BADCMAP, "Unsupported Targa colormap format") JMESSAGE(JERR_TGA_BADPARMS, "Invalid or unsupported Targa file") JMESSAGE(JERR_TGA_COLORSPACE, "Targa output must be grayscale or RGB") JMESSAGE(JTRC_TGA, "%ux%u RGB Targa image") JMESSAGE(JTRC_TGA_GRAY, "%ux%u grayscale Targa image") JMESSAGE(JTRC_TGA_MAPPED, "%ux%u colormapped Targa image") #else JMESSAGE(JERR_TGA_NOTCOMP, "Targa support was not compiled") #endif /* TARGA_SUPPORTED */ JMESSAGE(JERR_BAD_CMAP_FILE, "Color map file is invalid or of unsupported format") JMESSAGE(JERR_TOO_MANY_COLORS, "Output file format cannot handle %d colormap entries") JMESSAGE(JERR_UNGETC_FAILED, "ungetc failed") #ifdef TARGA_SUPPORTED JMESSAGE(JERR_UNKNOWN_FORMAT, "Unrecognized input file format --- perhaps you need -targa") #else JMESSAGE(JERR_UNKNOWN_FORMAT, "Unrecognized input file format") #endif JMESSAGE(JERR_UNSUPPORTED_FORMAT, "Unsupported output file format") #ifdef JMAKE_ENUM_LIST JMSG_LASTADDONCODE } ADDON_MESSAGE_CODE; #undef JMAKE_ENUM_LIST #endif /* JMAKE_ENUM_LIST */ /* Zap JMESSAGE macro so that future re-inclusions do nothing by default */ #undef JMESSAGE Papyrus3/JpegDir/JpgLossy/CDJPEG.C0000755000175000017500000001140507535143454013700 0ustar /* * cdjpeg.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains common support routines used by the IJG application * programs (cjpeg, djpeg, jpegtran). */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ #include /* to declare isupper(), tolower() */ #ifdef NEED_SIGNAL_CATCHER #include /* to declare signal() */ #endif #ifdef USE_SETMODE #include /* to declare setmode()'s parameter macros */ /* If you have setmode() but not , just delete this line: */ #include /* to declare setmode() */ #endif /* * Signal catcher to ensure that temporary files are removed before aborting. * NB: for Amiga Manx C this is actually a global routine named _abort(); * we put "#define signal_catcher _abort" in jconfig.h. Talk about bogus... */ #ifdef NEED_SIGNAL_CATCHER static j_common_ptr sig_cinfo; void /* must be global for Manx C */ signal_catcher (int signum) { if (sig_cinfo != NULL) { if (sig_cinfo->err != NULL) /* turn off trace output */ sig_cinfo->err->trace_level = 0; jpeg_destroy(sig_cinfo); /* clean up memory allocation & temp files */ } exit(EXIT_FAILURE); } GLOBAL(void) enable_signal_catcher (j_common_ptr cinfo) { sig_cinfo = cinfo; #ifdef SIGINT /* not all systems have SIGINT */ signal(SIGINT, signal_catcher); #endif #ifdef SIGTERM /* not all systems have SIGTERM */ signal(SIGTERM, signal_catcher); #endif } #endif /* * Optional progress monitor: display a percent-done figure on stderr. */ #ifdef PROGRESS_REPORT METHODDEF(void) progress_monitor (j_common_ptr cinfo) { cd_progress_ptr prog = (cd_progress_ptr) cinfo->progress; int total_passes = prog->pub.total_passes + prog->total_extra_passes; int percent_done = (int) (prog->pub.pass_counter*100L/prog->pub.pass_limit); if (percent_done != prog->percent_done) { prog->percent_done = percent_done; if (total_passes > 1) { fprintf(stderr, "\rPass %d/%d: %3d%% ", prog->pub.completed_passes + prog->completed_extra_passes + 1, total_passes, percent_done); } else { fprintf(stderr, "\r %3d%% ", percent_done); } fflush(stderr); } } GLOBAL(void) start_progress_monitor (j_common_ptr cinfo, cd_progress_ptr progress) { /* Enable progress display, unless trace output is on */ if (cinfo->err->trace_level == 0) { progress->pub.progress_monitor = progress_monitor; progress->completed_extra_passes = 0; progress->total_extra_passes = 0; progress->percent_done = -1; cinfo->progress = &progress->pub; } } GLOBAL(void) end_progress_monitor (j_common_ptr cinfo) { /* Clear away progress display */ if (cinfo->err->trace_level == 0) { fprintf(stderr, "\r \r"); fflush(stderr); } } #endif /* * Case-insensitive matching of possibly-abbreviated keyword switches. * keyword is the constant keyword (must be lower case already), * minchars is length of minimum legal abbreviation. */ GLOBAL(boolean) keymatch (char * arg, const char * keyword, int minchars) { register int ca, ck; register int nmatched = 0; while ((ca = *arg++) != '\0') { if ((ck = *keyword++) == '\0') return FALSE; /* arg longer than keyword, no good */ if (isupper(ca)) /* force arg to lcase (assume ck is already) */ ca = tolower(ca); if (ca != ck) return FALSE; /* no good */ nmatched++; /* count matched characters */ } /* reached end of argument; fail if it's too short for unique abbrev */ if (nmatched < minchars) return FALSE; return TRUE; /* A-OK */ } /* * Routines to establish binary I/O mode for stdin and stdout. * Non-Unix systems often require some hacking to get out of text mode. */ GLOBAL(PAPY_FILE) read_stdin (void) { FILE * input_file = stdin; #ifdef USE_SETMODE /* need to hack file mode? */ setmode(fileno(stdin), O_BINARY); #endif #ifdef USE_FDOPEN /* need to re-open in binary mode? */ if ((input_file = fdopen(fileno(stdin), READ_BINARY)) == NULL) { fprintf(stderr, "Cannot reopen stdin\n"); exit(EXIT_FAILURE); } #endif return input_file; } GLOBAL(PAPY_FILE) write_stdout (void) { FILE * output_file = stdout; #ifdef USE_SETMODE /* need to hack file mode? */ setmode(fileno(stdout), O_BINARY); #endif #ifdef USE_FDOPEN /* need to re-open in binary mode? */ if ((output_file = fdopen(fileno(stdout), WRITE_BINARY)) == NULL) { fprintf(stderr, "Cannot reopen stdout\n"); exit(EXIT_FAILURE); } #endif return output_file; } Papyrus3/JpegDir/JpgLossy/jconfig.wat0000755000175000017500000000223107535143454014771 0ustar /* jconfig.wat --- jconfig.h for Watcom C/C++ on MS-DOS or OS/2. */ /* see jconfig.doc for explanations */ #define HAVE_PROTOTYPES #define HAVE_UNSIGNED_CHAR #define HAVE_UNSIGNED_SHORT /* #define void char */ /* #define const */ #define CHAR_IS_UNSIGNED #define HAVE_STDDEF_H #define HAVE_STDLIB_H #undef NEED_BSD_STRINGS #undef NEED_SYS_TYPES_H #undef NEED_FAR_POINTERS /* Watcom uses flat 32-bit addressing */ #undef NEED_SHORT_EXTERNAL_NAMES #undef INCOMPLETE_TYPES_BROKEN #ifdef JPEG_INTERNALS #undef RIGHT_SHIFT_IS_UNSIGNED #endif /* JPEG_INTERNALS */ #ifdef JPEG_CJPEG_DJPEG #define BMP_SUPPORTED /* BMP image file format */ #define GIF_SUPPORTED /* GIF image file format */ #define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ #undef RLE_SUPPORTED /* Utah RLE image file format */ #define TARGA_SUPPORTED /* Targa image file format */ #undef TWO_FILE_COMMANDLINE /* optional */ #define USE_SETMODE /* Needed to make one-file style work in Watcom */ #undef NEED_SIGNAL_CATCHER /* Define this if you use jmemname.c */ #undef DONT_USE_B_MODE #undef PROGRESS_REPORT /* optional */ #endif /* JPEG_CJPEG_DJPEG */ Papyrus3/JpegDir/JpgLossy/TRANSUPP.H0000755000175000017500000001341007535143454014223 0ustar /* * transupp.h * * Copyright (C) 1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains declarations for image transformation routines and * other utility code used by the jpegtran sample application. These are * NOT part of the core JPEG library. But we keep these routines separate * from jpegtran.c to ease the task of maintaining jpegtran-like programs * that have other user interfaces. * * NOTE: all the routines declared here have very specific requirements * about when they are to be executed during the reading and writing of the * source and destination files. See the comments in transupp.c, or see * jpegtran.c for an example of correct usage. */ /* If you happen not to want the image transform support, disable it here */ #ifndef TRANSFORMS_SUPPORTED #define TRANSFORMS_SUPPORTED 1 /* 0 disables transform code */ #endif /* Short forms of external names for systems with brain-damaged linkers. */ #ifdef NEED_SHORT_EXTERNAL_NAMES #define jtransform_request_workspace jTrRequest #define jtransform_adjust_parameters jTrAdjust #define jtransform_execute_transformation jTrExec #define jcopy_markers_setup jCMrkSetup #define jcopy_markers_execute jCMrkExec #endif /* NEED_SHORT_EXTERNAL_NAMES */ /* * Codes for supported types of image transformations. */ typedef enum { JXFORM_NONE, /* no transformation */ JXFORM_FLIP_H, /* horizontal flip */ JXFORM_FLIP_V, /* vertical flip */ JXFORM_TRANSPOSE, /* transpose across UL-to-LR axis */ JXFORM_TRANSVERSE, /* transpose across UR-to-LL axis */ JXFORM_ROT_90, /* 90-degree clockwise rotation */ JXFORM_ROT_180, /* 180-degree rotation */ JXFORM_ROT_270 /* 270-degree clockwise (or 90 ccw) */ } JXFORM_CODE; /* * Although rotating and flipping data expressed as DCT coefficients is not * hard, there is an asymmetry in the JPEG format specification for images * whose dimensions aren't multiples of the iMCU size. The right and bottom * image edges are padded out to the next iMCU boundary with junk data; but * no padding is possible at the top and left edges. If we were to flip * the whole image including the pad data, then pad garbage would become * visible at the top and/or left, and real pixels would disappear into the * pad margins --- perhaps permanently, since encoders & decoders may not * bother to preserve DCT blocks that appear to be completely outside the * nominal image area. So, we have to exclude any partial iMCUs from the * basic transformation. * * Transpose is the only transformation that can handle partial iMCUs at the * right and bottom edges completely cleanly. flip_h can flip partial iMCUs * at the bottom, but leaves any partial iMCUs at the right edge untouched. * Similarly flip_v leaves any partial iMCUs at the bottom edge untouched. * The other transforms are defined as combinations of these basic transforms * and process edge blocks in a way that preserves the equivalence. * * The "trim" option causes untransformable partial iMCUs to be dropped; * this is not strictly lossless, but it usually gives the best-looking * result for odd-size images. Note that when this option is active, * the expected mathematical equivalences between the transforms may not hold. * (For example, -rot 270 -trim trims only the bottom edge, but -rot 90 -trim * followed by -rot 180 -trim trims both edges.) * * We also offer a "force to grayscale" option, which simply discards the * chrominance channels of a YCbCr image. This is lossless in the sense that * the luminance channel is preserved exactly. It's not the same kind of * thing as the rotate/flip transformations, but it's convenient to handle it * as part of this package, mainly because the transformation routines have to * be aware of the option to know how many components to work on. */ typedef struct { /* Options: set by caller */ JXFORM_CODE transform; /* image transform operator */ boolean trim; /* if TRUE, trim partial MCUs as needed */ boolean force_grayscale; /* if TRUE, convert color image to grayscale */ /* Internal workspace: caller should not touch these */ int num_components; /* # of components in workspace */ jvirt_barray_ptr * workspace_coef_arrays; /* workspace for transformations */ } jpeg_transform_info; #if TRANSFORMS_SUPPORTED /* Request any required workspace */ EXTERN(void) jtransform_request_workspace JPP((j_decompress_ptr srcinfo, jpeg_transform_info *info)); /* Adjust output image parameters */ EXTERN(jvirt_barray_ptr *) jtransform_adjust_parameters JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo, jvirt_barray_ptr *src_coef_arrays, jpeg_transform_info *info)); /* Execute the actual transformation, if any */ EXTERN(void) jtransform_execute_transformation JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo, jvirt_barray_ptr *src_coef_arrays, jpeg_transform_info *info)); #endif /* TRANSFORMS_SUPPORTED */ /* * Support for copying optional markers from source to destination file. */ typedef enum { JCOPYOPT_NONE, /* copy no optional markers */ JCOPYOPT_COMMENTS, /* copy only comment (COM) markers */ JCOPYOPT_ALL /* copy all optional markers */ } JCOPY_OPTION; #define JCOPYOPT_DEFAULT JCOPYOPT_COMMENTS /* recommended default */ /* Setup decompression object to save desired markers in memory */ EXTERN(void) jcopy_markers_setup JPP((j_decompress_ptr srcinfo, JCOPY_OPTION option)); /* Copy markers saved in the given source object to the destination object */ EXTERN(void) jcopy_markers_execute JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo, JCOPY_OPTION option)); Papyrus3/JpegDir/JpgLossy/JDATADST.C0000755000175000017500000001301007535143454014134 0ustar /* * jdatadst.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains compression data destination routines for the case of * emitting JPEG data to a file (or any stdio stream). While these routines * are sufficient for most applications, some will want to use a different * destination manager. * IMPORTANT: we assume that fwrite() will correctly transcribe an array of * JOCTETs into 8-bit-wide elements on external storage. If char is wider * than 8 bits on your machine, you may need to do some tweaking. */ /* this is not a core library module, so it doesn't define JPEG_INTERNALS */ #include "jinclude.h" #include "jpeglib.h" #include "jerror.h" /* Expanded data destination object for stdio output */ /*typedef struct { struct jpeg_destination_mgr pub; /*public fields */ /* PAPY_FILE outfile; /* target stream */ /* JOCTET * buffer; /* start of buffer */ /*} my_destination_mgr; typedef my_destination_mgr * my_dest_ptr; */ #define OUTPUT_BUF_SIZE 5000000 /* choose an efficiently fwrite'able size */ /* * Initialize destination --- called by jpeg_start_compress * before any data is actually written. */ METHODDEF(void) init_destination (j_compress_ptr cinfo) { my_dest_ptr dest = (my_dest_ptr) cinfo->dest; unsigned long thesize = cinfo->image_width * cinfo->image_height; /* Allocate the output buffer --- it will be released when done with image */ /* dest->buffer = (JOCTET *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, OUTPUT_BUF_SIZE * SIZEOF(JOCTET));*/ /* Allocate the output buffer --- it will be released when done with image */ dest->buffer = (JOCTET *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, thesize * SIZEOF(JOCTET)); dest->pub.next_output_byte = dest->buffer; dest->pub.free_in_buffer = thesize; /*dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;*/ } /* * Empty the output buffer --- called whenever buffer fills up. * * In typical applications, this should write the entire output buffer * (ignoring the current state of next_output_byte & free_in_buffer), * reset the pointer & count to the start of the buffer, and return TRUE * indicating that the buffer has been dumped. * * In applications that need to be able to suspend compression due to output * overrun, a FALSE return indicates that the buffer cannot be emptied now. * In this situation, the compressor will return to its caller (possibly with * an indication that it has not accepted all the supplied scanlines). The * application should resume compression after it has made more room in the * output buffer. Note that there are substantial restrictions on the use of * suspension --- see the documentation. * * When suspending, the compressor will back up to a convenient restart point * (typically the start of the current MCU). next_output_byte & free_in_buffer * indicate where the restart point will be if the current call returns FALSE. * Data beyond this point will be regenerated after resumption, so do not * write it out when emptying the buffer externally. */ METHODDEF(boolean) empty_output_buffer (j_compress_ptr cinfo) { my_dest_ptr dest = (my_dest_ptr) cinfo->dest; /*if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) != (size_t) OUTPUT_BUF_SIZE) ERREXIT(cinfo, JERR_FILE_WRITE);*/ dest->pub.next_output_byte = dest->buffer; dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; return TRUE; } /* * Terminate destination --- called by jpeg_finish_compress * after all data has been written. Usually needs to flush buffer. * * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding * application must deal with any cleanup that should happen even * for error exit. */ METHODDEF(void) term_destination (j_compress_ptr cinfo) { my_dest_ptr dest = (my_dest_ptr) cinfo->dest; size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer; /* Write any data remaining in the buffer */ if (datacount > 0) { /*if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount) ERREXIT(cinfo, JERR_FILE_WRITE);*/ } /*fflush(dest->outfile);*/ /* Make sure we wrote the output file OK */ /*if (ferror(dest->outfile)) ERREXIT(cinfo, JERR_FILE_WRITE);*/ } /* * Prepare for output to a stdio stream. * The caller must have already opened the stream, and is responsible * for closing it after finishing compression. */ GLOBAL(void) jpeg_stdio_dest (j_compress_ptr cinfo, PAPY_FILE *outfile) { my_dest_ptr dest; /* The destination object is made permanent so that multiple JPEG images * can be written to the same file without re-executing jpeg_stdio_dest. * This makes it dangerous to use this manager and a different destination * manager serially with the same JPEG object, because their private object * sizes may be different. Caveat programmer. */ if (cinfo->dest == NULL) { /* first time for this JPEG object? */ cinfo->dest = (struct jpeg_destination_mgr *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, SIZEOF(my_destination_mgr)); } dest = (my_dest_ptr) cinfo->dest; dest->pub.init_destination = init_destination; dest->pub.empty_output_buffer = empty_output_buffer; dest->pub.term_destination = term_destination; dest->outfile = *outfile; } Papyrus3/JpegDir/JpgLossy/Jlossy.ncb0000755000175000017500000000004707535143454014607 0ustar Microsoft C/C++ program database 2.00 Papyrus3/JpegDir/JpgLossy/JDHUFF.C0000755000175000017500000005201507535143454013714 0ustar /* * jdhuff.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains Huffman entropy decoding routines. * * Much of the complexity here has to do with supporting input suspension. * If the data source module demands suspension, we want to be able to back * up to the start of the current MCU. To do this, we copy state variables * into local working storage, and update them back to the permanent * storage only upon successful completion of an MCU. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jdhuff.h" /* Declarations shared with jdphuff.c */ /* * Expanded entropy decoder object for Huffman decoding. * * The savable_state subrecord contains fields that change within an MCU, * but must not be updated permanently until we complete the MCU. */ typedef struct { int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */ } savable_state; /* This macro is to work around compilers with missing or broken * structure assignment. You'll need to fix this code if you have * such a compiler and you change MAX_COMPS_IN_SCAN. */ #ifndef NO_STRUCT_ASSIGN #define ASSIGN_STATE(dest,src) ((dest) = (src)) #else #if MAX_COMPS_IN_SCAN == 4 #define ASSIGN_STATE(dest,src) \ ((dest).last_dc_val[0] = (src).last_dc_val[0], \ (dest).last_dc_val[1] = (src).last_dc_val[1], \ (dest).last_dc_val[2] = (src).last_dc_val[2], \ (dest).last_dc_val[3] = (src).last_dc_val[3]) #endif #endif typedef struct { struct jpeg_entropy_decoder pub; /* public fields */ /* These fields are loaded into local variables at start of each MCU. * In case of suspension, we exit WITHOUT updating them. */ bitread_perm_state bitstate; /* Bit buffer at start of MCU */ savable_state saved; /* Other state at start of MCU */ /* These fields are NOT loaded into local working state. */ unsigned int restarts_to_go; /* MCUs left in this restart interval */ /* Pointers to derived tables (these workspaces have image lifespan) */ d_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS]; d_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS]; /* Precalculated info set up by start_pass for use in decode_mcu: */ /* Pointers to derived tables to be used for each block within an MCU */ d_derived_tbl * dc_cur_tbls[D_MAX_BLOCKS_IN_MCU]; d_derived_tbl * ac_cur_tbls[D_MAX_BLOCKS_IN_MCU]; /* Whether we care about the DC and AC coefficient values for each block */ boolean dc_needed[D_MAX_BLOCKS_IN_MCU]; boolean ac_needed[D_MAX_BLOCKS_IN_MCU]; } huff_entropy_decoder; typedef huff_entropy_decoder * huff_entropy_ptr; /* * Initialize for a Huffman-compressed scan. */ METHODDEF(void) start_pass_huff_decoder (j_decompress_ptr cinfo) { huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; int ci, blkn, dctbl, actbl; jpeg_component_info * compptr; /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG. * This ought to be an error condition, but we make it a warning because * there are some baseline files out there with all zeroes in these bytes. */ if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 || cinfo->Ah != 0 || cinfo->Al != 0) WARNMS(cinfo, JWRN_NOT_SEQUENTIAL); for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; dctbl = compptr->dc_tbl_no; actbl = compptr->ac_tbl_no; /* Compute derived values for Huffman tables */ /* We may do this more than once for a table, but it's not expensive */ jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl, & entropy->dc_derived_tbls[dctbl]); jpeg_make_d_derived_tbl(cinfo, FALSE, actbl, & entropy->ac_derived_tbls[actbl]); /* Initialize DC predictions to 0 */ entropy->saved.last_dc_val[ci] = 0; } /* Precalculate decoding info for each block in an MCU of this scan */ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { ci = cinfo->MCU_membership[blkn]; compptr = cinfo->cur_comp_info[ci]; /* Precalculate which table to use for each block */ entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no]; entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no]; /* Decide whether we really care about the coefficient values */ if (compptr->component_needed) { entropy->dc_needed[blkn] = TRUE; /* we don't need the ACs if producing a 1/8th-size image */ entropy->ac_needed[blkn] = (compptr->DCT_scaled_size > 1); } else { entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE; } } /* Initialize bitread state variables */ entropy->bitstate.bits_left = 0; entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */ entropy->pub.insufficient_data = FALSE; /* Initialize restart counter */ entropy->restarts_to_go = cinfo->restart_interval; } /* * Compute the derived values for a Huffman table. * This routine also performs some validation checks on the table. * * Note this is also used by jdphuff.c. */ GLOBAL(void) jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno, d_derived_tbl ** pdtbl) { JHUFF_TBL *htbl; d_derived_tbl *dtbl; int p, i, l, si, numsymbols; int lookbits, ctr; char huffsize[257]; unsigned int huffcode[257]; unsigned int code; /* Note that huffsize[] and huffcode[] are filled in code-length order, * paralleling the order of the symbols themselves in htbl->huffval[]. */ /* Find the input Huffman table */ if (tblno < 0 || tblno >= NUM_HUFF_TBLS) ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno); htbl = isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno]; if (htbl == NULL) ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno); /* Allocate a workspace if we haven't already done so. */ if (*pdtbl == NULL) *pdtbl = (d_derived_tbl *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(d_derived_tbl)); dtbl = *pdtbl; dtbl->pub = htbl; /* fill in back link */ /* Figure C.1: make table of Huffman code length for each symbol */ p = 0; for (l = 1; l <= 16; l++) { i = (int) htbl->bits[l]; if (i < 0 || p + i > 256) /* protect against table overrun */ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); while (i--) huffsize[p++] = (char) l; } huffsize[p] = 0; numsymbols = p; /* Figure C.2: generate the codes themselves */ /* We also validate that the counts represent a legal Huffman code tree. */ code = 0; si = huffsize[0]; p = 0; while (huffsize[p]) { while (((int) huffsize[p]) == si) { huffcode[p++] = code; code++; } /* code is now 1 more than the last code used for codelength si; but * it must still fit in si bits, since no code is allowed to be all ones. */ if (((INT32) code) >= (((INT32) 1) << si)) ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); code <<= 1; si++; } /* Figure F.15: generate decoding tables for bit-sequential decoding */ p = 0; for (l = 1; l <= 16; l++) { if (htbl->bits[l]) { /* valoffset[l] = huffval[] index of 1st symbol of code length l, * minus the minimum code of length l */ dtbl->valoffset[l] = (INT32) p - (INT32) huffcode[p]; p += htbl->bits[l]; dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */ } else { dtbl->maxcode[l] = -1; /* -1 if no codes of this length */ } } dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */ /* Compute lookahead tables to speed up decoding. * First we set all the table entries to 0, indicating "too long"; * then we iterate through the Huffman codes that are short enough and * fill in all the entries that correspond to bit sequences starting * with that code. */ MEMZERO(dtbl->look_nbits, SIZEOF(dtbl->look_nbits)); p = 0; for (l = 1; l <= HUFF_LOOKAHEAD; l++) { for (i = 1; i <= (int) htbl->bits[l]; i++, p++) { /* l = current code's length, p = its index in huffcode[] & huffval[]. */ /* Generate left-justified code followed by all possible bit sequences */ lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l); for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) { dtbl->look_nbits[lookbits] = l; dtbl->look_sym[lookbits] = htbl->huffval[p]; lookbits++; } } } /* Validate symbols as being reasonable. * For AC tables, we make no check, but accept all byte values 0..255. * For DC tables, we require the symbols to be in range 0..15. * (Tighter bounds could be applied depending on the data depth and mode, * but this is sufficient to ensure safe decoding.) */ if (isDC) { for (i = 0; i < numsymbols; i++) { int sym = htbl->huffval[i]; if (sym < 0 || sym > 15) ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); } } } /* * Out-of-line code for bit fetching (shared with jdphuff.c). * See jdhuff.h for info about usage. * Note: current values of get_buffer and bits_left are passed as parameters, * but are returned in the corresponding fields of the state struct. * * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width * of get_buffer to be used. (On machines with wider words, an even larger * buffer could be used.) However, on some machines 32-bit shifts are * quite slow and take time proportional to the number of places shifted. * (This is true with most PC compilers, for instance.) In this case it may * be a win to set MIN_GET_BITS to the minimum value of 15. This reduces the * average shift distance at the cost of more calls to jpeg_fill_bit_buffer. */ #ifdef SLOW_SHIFT_32 #define MIN_GET_BITS 15 /* minimum allowable value */ #else #define MIN_GET_BITS (BIT_BUF_SIZE-7) #endif GLOBAL(boolean) jpeg_fill_bit_buffer (bitread_working_state * state, register bit_buf_type get_buffer, register int bits_left, int nbits) /* Load up the bit buffer to a depth of at least nbits */ { /* Copy heavily used state fields into locals (hopefully registers) */ register const JOCTET * next_input_byte = state->next_input_byte; register size_t bytes_in_buffer = state->bytes_in_buffer; j_decompress_ptr cinfo = state->cinfo; /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */ /* (It is assumed that no request will be for more than that many bits.) */ /* We fail to do so only if we hit a marker or are forced to suspend. */ if (cinfo->unread_marker == 0) { /* cannot advance past a marker */ while (bits_left < MIN_GET_BITS) { register int c; /* Attempt to read a byte */ if (bytes_in_buffer == 0) { if (! (*cinfo->src->fill_input_buffer) (cinfo)) return FALSE; next_input_byte = cinfo->src->next_input_byte; bytes_in_buffer = cinfo->src->bytes_in_buffer; } bytes_in_buffer--; c = GETJOCTET(*next_input_byte++); /* If it's 0xFF, check and discard stuffed zero byte */ if (c == 0xFF) { /* Loop here to discard any padding FF's on terminating marker, * so that we can save a valid unread_marker value. NOTE: we will * accept multiple FF's followed by a 0 as meaning a single FF data * byte. This data pattern is not valid according to the standard. */ do { if (bytes_in_buffer == 0) { if (! (*cinfo->src->fill_input_buffer) (cinfo)) return FALSE; next_input_byte = cinfo->src->next_input_byte; bytes_in_buffer = cinfo->src->bytes_in_buffer; } bytes_in_buffer--; c = GETJOCTET(*next_input_byte++); } while (c == 0xFF); if (c == 0) { /* Found FF/00, which represents an FF data byte */ c = 0xFF; } else { /* Oops, it's actually a marker indicating end of compressed data. * Save the marker code for later use. * Fine point: it might appear that we should save the marker into * bitread working state, not straight into permanent state. But * once we have hit a marker, we cannot need to suspend within the * current MCU, because we will read no more bytes from the data * source. So it is OK to update permanent state right away. */ cinfo->unread_marker = c; /* See if we need to insert some fake zero bits. */ goto no_more_bytes; } } /* OK, load c into get_buffer */ get_buffer = (get_buffer << 8) | c; bits_left += 8; } /* end while */ } else { no_more_bytes: /* We get here if we've read the marker that terminates the compressed * data segment. There should be enough bits in the buffer register * to satisfy the request; if so, no problem. */ if (nbits > bits_left) { /* Uh-oh. Report corrupted data to user and stuff zeroes into * the data stream, so that we can produce some kind of image. * We use a nonvolatile flag to ensure that only one warning message * appears per data segment. */ if (! cinfo->entropy->insufficient_data) { WARNMS(cinfo, JWRN_HIT_MARKER); cinfo->entropy->insufficient_data = TRUE; } /* Fill the buffer with zero bits */ get_buffer <<= MIN_GET_BITS - bits_left; bits_left = MIN_GET_BITS; } } /* Unload the local registers */ state->next_input_byte = next_input_byte; state->bytes_in_buffer = bytes_in_buffer; state->get_buffer = get_buffer; state->bits_left = bits_left; return TRUE; } /* * Out-of-line code for Huffman code decoding. * See jdhuff.h for info about usage. */ GLOBAL(int) jpeg_huff_decode (bitread_working_state * state, register bit_buf_type get_buffer, register int bits_left, d_derived_tbl * htbl, int min_bits) { register int l = min_bits; register INT32 code; /* HUFF_DECODE has determined that the code is at least min_bits */ /* bits long, so fetch that many bits in one swoop. */ CHECK_BIT_BUFFER(*state, l, return -1); code = GET_BITS(l); /* Collect the rest of the Huffman code one bit at a time. */ /* This is per Figure F.16 in the JPEG spec. */ while (code > htbl->maxcode[l]) { code <<= 1; CHECK_BIT_BUFFER(*state, 1, return -1); code |= GET_BITS(1); l++; } /* Unload the local registers */ state->get_buffer = get_buffer; state->bits_left = bits_left; /* With garbage input we may reach the sentinel value l = 17. */ if (l > 16) { WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE); return 0; /* fake a zero as the safest result */ } return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ]; } /* * Figure F.12: extend sign bit. * On some machines, a shift and add will be faster than a table lookup. */ #ifdef AVOID_TABLES #define HUFF_EXTEND(x,s) ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x)) #else #define HUFF_EXTEND(x,s) ((x) < extend_test[s] ? (x) + extend_offset[s] : (x)) static const int extend_test[16] = /* entry n is 2**(n-1) */ { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 }; static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */ { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1, ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1, ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1, ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 }; #endif /* AVOID_TABLES */ /* * Check for a restart marker & resynchronize decoder. * Returns FALSE if must suspend. */ LOCAL(boolean) process_restart (j_decompress_ptr cinfo) { huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; int ci; /* Throw away any unused bits remaining in bit buffer; */ /* include any full bytes in next_marker's count of discarded bytes */ cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8; entropy->bitstate.bits_left = 0; /* Advance past the RSTn marker */ if (! (*cinfo->marker->read_restart_marker) (cinfo)) return FALSE; /* Re-initialize DC predictions to 0 */ for (ci = 0; ci < cinfo->comps_in_scan; ci++) entropy->saved.last_dc_val[ci] = 0; /* Reset restart counter */ entropy->restarts_to_go = cinfo->restart_interval; /* Reset out-of-data flag, unless read_restart_marker left us smack up * against a marker. In that case we will end up treating the next data * segment as empty, and we can avoid producing bogus output pixels by * leaving the flag set. */ if (cinfo->unread_marker == 0) entropy->pub.insufficient_data = FALSE; return TRUE; } /* * Decode and return one MCU's worth of Huffman-compressed coefficients. * The coefficients are reordered from zigzag order into natural array order, * but are not dequantized. * * The i'th block of the MCU is stored into the block pointed to by * MCU_data[i]. WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER. * (Wholesale zeroing is usually a little faster than retail...) * * Returns FALSE if data source requested suspension. In that case no * changes have been made to permanent state. (Exception: some output * coefficients may already have been assigned. This is harmless for * this module, since we'll just re-assign them on the next call.) */ METHODDEF(boolean) decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data) { huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy; int blkn; BITREAD_STATE_VARS; savable_state state; /* Process restart marker if needed; may have to suspend */ if (cinfo->restart_interval) { if (entropy->restarts_to_go == 0) if (! process_restart(cinfo)) return FALSE; } /* If we've run out of data, just leave the MCU set to zeroes. * This way, we return uniform gray for the remainder of the segment. */ if (! entropy->pub.insufficient_data) { /* Load up working state */ BITREAD_LOAD_STATE(cinfo,entropy->bitstate); ASSIGN_STATE(state, entropy->saved); /* Outer loop handles each block in the MCU */ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) { JBLOCKROW block = MCU_data[blkn]; d_derived_tbl * dctbl = entropy->dc_cur_tbls[blkn]; d_derived_tbl * actbl = entropy->ac_cur_tbls[blkn]; register int s, k, r; /* Decode a single block's worth of coefficients */ /* Section F.2.2.1: decode the DC coefficient difference */ HUFF_DECODE(s, br_state, dctbl, return FALSE, label1); if (s) { CHECK_BIT_BUFFER(br_state, s, return FALSE); r = GET_BITS(s); s = HUFF_EXTEND(r, s); } if (entropy->dc_needed[blkn]) { /* Convert DC difference to actual value, update last_dc_val */ int ci = cinfo->MCU_membership[blkn]; s += state.last_dc_val[ci]; state.last_dc_val[ci] = s; /* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */ (*block)[0] = (JCOEF) s; } if (entropy->ac_needed[blkn]) { /* Section F.2.2.2: decode the AC coefficients */ /* Since zeroes are skipped, output area must be cleared beforehand */ for (k = 1; k < DCTSIZE2; k++) { HUFF_DECODE(s, br_state, actbl, return FALSE, label2); r = s >> 4; s &= 15; if (s) { k += r; CHECK_BIT_BUFFER(br_state, s, return FALSE); r = GET_BITS(s); s = HUFF_EXTEND(r, s); /* Output coefficient in natural (dezigzagged) order. * Note: the extra entries in jpeg_natural_order[] will save us * if k >= DCTSIZE2, which could happen if the data is corrupted. */ (*block)[jpeg_natural_order[k]] = (JCOEF) s; } else { if (r != 15) break; k += 15; } } } else { /* Section F.2.2.2: decode the AC coefficients */ /* In this path we just discard the values */ for (k = 1; k < DCTSIZE2; k++) { HUFF_DECODE(s, br_state, actbl, return FALSE, label3); r = s >> 4; s &= 15; if (s) { k += r; CHECK_BIT_BUFFER(br_state, s, return FALSE); DROP_BITS(s); } else { if (r != 15) break; k += 15; } } } } /* Completed MCU, so update state */ BITREAD_SAVE_STATE(cinfo,entropy->bitstate); ASSIGN_STATE(entropy->saved, state); } /* Account for restart interval (no-op if not using restarts) */ entropy->restarts_to_go--; return TRUE; } /* * Module initialization routine for Huffman entropy decoding. */ GLOBAL(void) jinit_huff_decoder (j_decompress_ptr cinfo) { huff_entropy_ptr entropy; int i; entropy = (huff_entropy_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(huff_entropy_decoder)); cinfo->entropy = (struct jpeg_entropy_decoder *) entropy; entropy->pub.start_pass = start_pass_huff_decoder; entropy->pub.decode_mcu = decode_mcu; /* Mark tables unallocated */ for (i = 0; i < NUM_HUFF_TBLS; i++) { entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL; } } Papyrus3/JpegDir/JpgLossy/MAKEFILE.SAS0000755000175000017500000003104607535143454014370 0ustar # Makefile for Independent JPEG Group's software # This makefile is for Amiga systems using SAS C 6.0 and up. # Thanks to Ed Hanway, Mark Rinfret, and Jim Zepeda. # Read installation instructions before saying "make" !! # The name of your C compiler: CC= sc # You may need to adjust these cc options: # Uncomment the following lines for generic 680x0 version ARCHFLAGS= cpu=any SUFFIX= # Uncomment the following lines for 68030-only version #ARCHFLAGS= cpu=68030 #SUFFIX=.030 CFLAGS= nostackcheck data=near parms=register optimize $(ARCHFLAGS) \ ignore=104 ignore=304 ignore=306 # ignore=104 disables warnings for mismatched const qualifiers # ignore=304 disables warnings for variables being optimized out # ignore=306 disables warnings for the inlining of functions # Generally, we recommend defining any configuration symbols in jconfig.h, # NOT via define switches here. # Link-time cc options: LDFLAGS= SC SD ND BATCH # To link any special libraries, add the necessary commands here. LDLIBS= LIB:scm.lib LIB:sc.lib # Put here the object file name for the correct system-dependent memory # manager file. For Amiga we recommend jmemname.o. SYSDEPMEM= jmemname.o # miscellaneous OS-dependent stuff # linker LN= slink # file deletion command RM= delete quiet # library (.lib) file creation command AR= oml # End of configurable options. # source files: JPEG library proper LIBSOURCES= jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c \ jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c \ jcphuff.c jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c \ jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c \ jdinput.c jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c \ jdpostct.c jdsample.c jdtrans.c jerror.c jfdctflt.c jfdctfst.c \ jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c jquant1.c \ jquant2.c jutils.c jmemmgr.c # memmgr back ends: compile only one of these into a working library SYSDEPSOURCES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemmac.c # source files: cjpeg/djpeg/jpegtran applications, also rdjpgcom/wrjpgcom APPSOURCES= cjpeg.c djpeg.c jpegtran.c rdjpgcom.c wrjpgcom.c cdjpeg.c \ rdcolmap.c rdswitch.c transupp.c rdppm.c wrppm.c rdgif.c wrgif.c \ rdtarga.c wrtarga.c rdbmp.c wrbmp.c rdrle.c wrrle.c SOURCES= $(LIBSOURCES) $(SYSDEPSOURCES) $(APPSOURCES) # files included by source files INCLUDES= jchuff.h jdhuff.h jdct.h jerror.h jinclude.h jmemsys.h jmorecfg.h \ jpegint.h jpeglib.h jversion.h cdjpeg.h cderror.h transupp.h # documentation, test, and support files DOCS= README install.doc usage.doc cjpeg.1 djpeg.1 jpegtran.1 rdjpgcom.1 \ wrjpgcom.1 wizard.doc example.c libjpeg.doc structure.doc \ coderules.doc filelist.doc change.log MKFILES= configure makefile.cfg makefile.ansi makefile.unix makefile.bcc \ makefile.mc6 makefile.dj makefile.wat makefile.vc makelib.ds \ makeapps.ds makeproj.mac makcjpeg.st makdjpeg.st makljpeg.st \ maktjpeg.st makefile.manx makefile.sas makefile.mms makefile.vms \ makvms.opt CONFIGFILES= jconfig.cfg jconfig.bcc jconfig.mc6 jconfig.dj jconfig.wat \ jconfig.vc jconfig.mac jconfig.st jconfig.manx jconfig.sas \ jconfig.vms CONFIGUREFILES= config.guess config.sub install-sh ltconfig ltmain.sh OTHERFILES= jconfig.doc ckconfig.c ansi2knr.c ansi2knr.1 jmemdosa.asm TESTFILES= testorig.jpg testimg.ppm testimg.bmp testimg.jpg testprog.jpg \ testimgp.jpg DISTFILES= $(DOCS) $(MKFILES) $(CONFIGFILES) $(SOURCES) $(INCLUDES) \ $(CONFIGUREFILES) $(OTHERFILES) $(TESTFILES) # library object files common to compression and decompression COMOBJECTS= jcomapi.o jutils.o jerror.o jmemmgr.o $(SYSDEPMEM) # compression library object files CLIBOBJECTS= jcapimin.o jcapistd.o jctrans.o jcparam.o jdatadst.o jcinit.o \ jcmaster.o jcmarker.o jcmainct.o jcprepct.o jccoefct.o jccolor.o \ jcsample.o jchuff.o jcphuff.o jcdctmgr.o jfdctfst.o jfdctflt.o \ jfdctint.o # decompression library object files DLIBOBJECTS= jdapimin.o jdapistd.o jdtrans.o jdatasrc.o jdmaster.o \ jdinput.o jdmarker.o jdhuff.o jdphuff.o jdmainct.o jdcoefct.o \ jdpostct.o jddctmgr.o jidctfst.o jidctflt.o jidctint.o jidctred.o \ jdsample.o jdcolor.o jquant1.o jquant2.o jdmerge.o # These objectfiles are included in libjpeg.lib LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS) # object files for sample applications (excluding library files) COBJECTS= cjpeg.o rdppm.o rdgif.o rdtarga.o rdrle.o rdbmp.o rdswitch.o \ cdjpeg.o DOBJECTS= djpeg.o wrppm.o wrgif.o wrtarga.o wrrle.o wrbmp.o rdcolmap.o \ cdjpeg.o TROBJECTS= jpegtran.o rdswitch.o cdjpeg.o transupp.o all: libjpeg.lib cjpeg$(SUFFIX) djpeg$(SUFFIX) jpegtran$(SUFFIX) rdjpgcom$(SUFFIX) wrjpgcom$(SUFFIX) # note: do several AR steps to avoid command line length limitations libjpeg.lib: $(LIBOBJECTS) -$(RM) libjpeg.lib $(AR) libjpeg.lib r $(CLIBOBJECTS) $(AR) libjpeg.lib r $(DLIBOBJECTS) $(AR) libjpeg.lib r $(COMOBJECTS) cjpeg$(SUFFIX): $(COBJECTS) libjpeg.lib $(LN) image_height <= 0 || cinfo->image_width <= 0 || cinfo->num_components <= 0 || cinfo->input_components <= 0) ERREXIT(cinfo, JERR_EMPTY_IMAGE); /* Make sure image isn't bigger than I can handle */ if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION || (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION) ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION); /* Width of an input scanline must be representable as JDIMENSION. */ samplesperrow = (long) cinfo->image_width * (long) cinfo->input_components; jd_samplesperrow = (JDIMENSION) samplesperrow; if ((long) jd_samplesperrow != samplesperrow) ERREXIT(cinfo, JERR_WIDTH_OVERFLOW); /* For now, precision must match compiled-in value... */ if (cinfo->data_precision != BITS_IN_JSAMPLE) ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision); /* Check that number of components won't exceed internal array sizes */ if (cinfo->num_components > MAX_COMPONENTS) ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components, MAX_COMPONENTS); /* Compute maximum sampling factors; check factor validity */ cinfo->max_h_samp_factor = 1; cinfo->max_v_samp_factor = 1; for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR || compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR) ERREXIT(cinfo, JERR_BAD_SAMPLING); cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor, compptr->h_samp_factor); cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor, compptr->v_samp_factor); } /* Compute dimensions of components */ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) { /* Fill in the correct component_index value; don't rely on application */ compptr->component_index = ci; /* For compression, we never do DCT scaling. */ compptr->DCT_scaled_size = DCTSIZE; /* Size in DCT blocks */ compptr->width_in_blocks = (JDIMENSION) jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor, (long) (cinfo->max_h_samp_factor * DCTSIZE)); compptr->height_in_blocks = (JDIMENSION) jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor, (long) (cinfo->max_v_samp_factor * DCTSIZE)); /* Size in samples */ compptr->downsampled_width = (JDIMENSION) jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor, (long) cinfo->max_h_samp_factor); compptr->downsampled_height = (JDIMENSION) jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor, (long) cinfo->max_v_samp_factor); /* Mark component needed (this flag isn't actually used for compression) */ compptr->component_needed = TRUE; } /* Compute number of fully interleaved MCU rows (number of times that * main controller will call coefficient controller). */ cinfo->total_iMCU_rows = (JDIMENSION) jdiv_round_up((long) cinfo->image_height, (long) (cinfo->max_v_samp_factor*DCTSIZE)); } #ifdef C_MULTISCAN_FILES_SUPPORTED LOCAL(void) validate_script (j_compress_ptr cinfo) /* Verify that the scan script in cinfo->scan_info[] is valid; also * determine whether it uses progressive JPEG, and set cinfo->progressive_mode. */ { const jpeg_scan_info * scanptr; int scanno, ncomps, ci, coefi, thisi; int Ss, Se, Ah, Al; boolean component_sent[MAX_COMPONENTS]; #ifdef C_PROGRESSIVE_SUPPORTED int * last_bitpos_ptr; int last_bitpos[MAX_COMPONENTS][DCTSIZE2]; /* -1 until that coefficient has been seen; then last Al for it */ #endif if (cinfo->num_scans <= 0) ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, 0); /* For sequential JPEG, all scans must have Ss=0, Se=DCTSIZE2-1; * for progressive JPEG, no scan can have this. */ scanptr = cinfo->scan_info; if (scanptr->Ss != 0 || scanptr->Se != DCTSIZE2-1) { #ifdef C_PROGRESSIVE_SUPPORTED cinfo->progressive_mode = TRUE; last_bitpos_ptr = & last_bitpos[0][0]; for (ci = 0; ci < cinfo->num_components; ci++) for (coefi = 0; coefi < DCTSIZE2; coefi++) *last_bitpos_ptr++ = -1; #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } else { cinfo->progressive_mode = FALSE; for (ci = 0; ci < cinfo->num_components; ci++) component_sent[ci] = FALSE; } for (scanno = 1; scanno <= cinfo->num_scans; scanptr++, scanno++) { /* Validate component indexes */ ncomps = scanptr->comps_in_scan; if (ncomps <= 0 || ncomps > MAX_COMPS_IN_SCAN) ERREXIT2(cinfo, JERR_COMPONENT_COUNT, ncomps, MAX_COMPS_IN_SCAN); for (ci = 0; ci < ncomps; ci++) { thisi = scanptr->component_index[ci]; if (thisi < 0 || thisi >= cinfo->num_components) ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno); /* Components must appear in SOF order within each scan */ if (ci > 0 && thisi <= scanptr->component_index[ci-1]) ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno); } /* Validate progression parameters */ Ss = scanptr->Ss; Se = scanptr->Se; Ah = scanptr->Ah; Al = scanptr->Al; if (cinfo->progressive_mode) { #ifdef C_PROGRESSIVE_SUPPORTED /* The JPEG spec simply gives the ranges 0..13 for Ah and Al, but that * seems wrong: the upper bound ought to depend on data precision. * Perhaps they really meant 0..N+1 for N-bit precision. * Here we allow 0..10 for 8-bit data; Al larger than 10 results in * out-of-range reconstructed DC values during the first DC scan, * which might cause problems for some decoders. */ #if BITS_IN_JSAMPLE == 8 #define MAX_AH_AL 10 #else #define MAX_AH_AL 13 #endif if (Ss < 0 || Ss >= DCTSIZE2 || Se < Ss || Se >= DCTSIZE2 || Ah < 0 || Ah > MAX_AH_AL || Al < 0 || Al > MAX_AH_AL) ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); if (Ss == 0) { if (Se != 0) /* DC and AC together not OK */ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); } else { if (ncomps != 1) /* AC scans must be for only one component */ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); } for (ci = 0; ci < ncomps; ci++) { last_bitpos_ptr = & last_bitpos[scanptr->component_index[ci]][0]; if (Ss != 0 && last_bitpos_ptr[0] < 0) /* AC without prior DC scan */ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); for (coefi = Ss; coefi <= Se; coefi++) { if (last_bitpos_ptr[coefi] < 0) { /* first scan of this coefficient */ if (Ah != 0) ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); } else { /* not first scan */ if (Ah != last_bitpos_ptr[coefi] || Al != Ah-1) ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); } last_bitpos_ptr[coefi] = Al; } } #endif } else { /* For sequential JPEG, all progression parameters must be these: */ if (Ss != 0 || Se != DCTSIZE2-1 || Ah != 0 || Al != 0) ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno); /* Make sure components are not sent twice */ for (ci = 0; ci < ncomps; ci++) { thisi = scanptr->component_index[ci]; if (component_sent[thisi]) ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno); component_sent[thisi] = TRUE; } } } /* Now verify that everything got sent. */ if (cinfo->progressive_mode) { #ifdef C_PROGRESSIVE_SUPPORTED /* For progressive mode, we only check that at least some DC data * got sent for each component; the spec does not require that all bits * of all coefficients be transmitted. Would it be wiser to enforce * transmission of all coefficient bits?? */ for (ci = 0; ci < cinfo->num_components; ci++) { if (last_bitpos[ci][0] < 0) ERREXIT(cinfo, JERR_MISSING_DATA); } #endif } else { for (ci = 0; ci < cinfo->num_components; ci++) { if (! component_sent[ci]) ERREXIT(cinfo, JERR_MISSING_DATA); } } } #endif /* C_MULTISCAN_FILES_SUPPORTED */ LOCAL(void) select_scan_parameters (j_compress_ptr cinfo) /* Set up the scan parameters for the current scan */ { int ci; #ifdef C_MULTISCAN_FILES_SUPPORTED if (cinfo->scan_info != NULL) { /* Prepare for current scan --- the script is already validated */ my_master_ptr master = (my_master_ptr) cinfo->master; const jpeg_scan_info * scanptr = cinfo->scan_info + master->scan_number; cinfo->comps_in_scan = scanptr->comps_in_scan; for (ci = 0; ci < scanptr->comps_in_scan; ci++) { cinfo->cur_comp_info[ci] = &cinfo->comp_info[scanptr->component_index[ci]]; } cinfo->Ss = scanptr->Ss; cinfo->Se = scanptr->Se; cinfo->Ah = scanptr->Ah; cinfo->Al = scanptr->Al; } else #endif { /* Prepare for single sequential-JPEG scan containing all components */ if (cinfo->num_components > MAX_COMPS_IN_SCAN) ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components, MAX_COMPS_IN_SCAN); cinfo->comps_in_scan = cinfo->num_components; for (ci = 0; ci < cinfo->num_components; ci++) { cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci]; } cinfo->Ss = 0; cinfo->Se = DCTSIZE2-1; cinfo->Ah = 0; cinfo->Al = 0; } } LOCAL(void) per_scan_setup (j_compress_ptr cinfo) /* Do computations that are needed before processing a JPEG scan */ /* cinfo->comps_in_scan and cinfo->cur_comp_info[] are already set */ { int ci, mcublks, tmp; jpeg_component_info *compptr; if (cinfo->comps_in_scan == 1) { /* Noninterleaved (single-component) scan */ compptr = cinfo->cur_comp_info[0]; /* Overall image size in MCUs */ cinfo->MCUs_per_row = compptr->width_in_blocks; cinfo->MCU_rows_in_scan = compptr->height_in_blocks; /* For noninterleaved scan, always one block per MCU */ compptr->MCU_width = 1; compptr->MCU_height = 1; compptr->MCU_blocks = 1; compptr->MCU_sample_width = DCTSIZE; compptr->last_col_width = 1; /* For noninterleaved scans, it is convenient to define last_row_height * as the number of block rows present in the last iMCU row. */ tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor); if (tmp == 0) tmp = compptr->v_samp_factor; compptr->last_row_height = tmp; /* Prepare array describing MCU composition */ cinfo->blocks_in_MCU = 1; cinfo->MCU_membership[0] = 0; } else { /* Interleaved (multi-component) scan */ if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN) ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan, MAX_COMPS_IN_SCAN); /* Overall image size in MCUs */ cinfo->MCUs_per_row = (JDIMENSION) jdiv_round_up((long) cinfo->image_width, (long) (cinfo->max_h_samp_factor*DCTSIZE)); cinfo->MCU_rows_in_scan = (JDIMENSION) jdiv_round_up((long) cinfo->image_height, (long) (cinfo->max_v_samp_factor*DCTSIZE)); cinfo->blocks_in_MCU = 0; for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; /* Sampling factors give # of blocks of component in each MCU */ compptr->MCU_width = compptr->h_samp_factor; compptr->MCU_height = compptr->v_samp_factor; compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height; compptr->MCU_sample_width = compptr->MCU_width * DCTSIZE; /* Figure number of non-dummy blocks in last MCU column & row */ tmp = (int) (compptr->width_in_blocks % compptr->MCU_width); if (tmp == 0) tmp = compptr->MCU_width; compptr->last_col_width = tmp; tmp = (int) (compptr->height_in_blocks % compptr->MCU_height); if (tmp == 0) tmp = compptr->MCU_height; compptr->last_row_height = tmp; /* Prepare array describing MCU composition */ mcublks = compptr->MCU_blocks; if (cinfo->blocks_in_MCU + mcublks > C_MAX_BLOCKS_IN_MCU) ERREXIT(cinfo, JERR_BAD_MCU_SIZE); while (mcublks-- > 0) { cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci; } } } /* Convert restart specified in rows to actual MCU count. */ /* Note that count must fit in 16 bits, so we provide limiting. */ if (cinfo->restart_in_rows > 0) { long nominal = (long) cinfo->restart_in_rows * (long) cinfo->MCUs_per_row; cinfo->restart_interval = (unsigned int) MIN(nominal, 65535L); } } /* * Per-pass setup. * This is called at the beginning of each pass. We determine which modules * will be active during this pass and give them appropriate start_pass calls. * We also set is_last_pass to indicate whether any more passes will be * required. */ METHODDEF(void) prepare_for_pass (j_compress_ptr cinfo) { my_master_ptr master = (my_master_ptr) cinfo->master; switch (master->pass_type) { case main_pass: /* Initial pass: will collect input data, and do either Huffman * optimization or data output for the first scan. */ select_scan_parameters(cinfo); per_scan_setup(cinfo); if (! cinfo->raw_data_in) { (*cinfo->cconvert->start_pass) (cinfo); (*cinfo->downsample->start_pass) (cinfo); (*cinfo->prep->start_pass) (cinfo, JBUF_PASS_THRU); } (*cinfo->fdct->start_pass) (cinfo); (*cinfo->entropy->start_pass) (cinfo, cinfo->optimize_coding); (*cinfo->coef->start_pass) (cinfo, (master->total_passes > 1 ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU)); (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU); if (cinfo->optimize_coding) { /* No immediate data output; postpone writing frame/scan headers */ master->pub.call_pass_startup = FALSE; } else { /* Will write frame/scan headers at first jpeg_write_scanlines call */ master->pub.call_pass_startup = TRUE; } break; #ifdef ENTROPY_OPT_SUPPORTED case huff_opt_pass: /* Do Huffman optimization for a scan after the first one. */ select_scan_parameters(cinfo); per_scan_setup(cinfo); if (cinfo->Ss != 0 || cinfo->Ah == 0 || cinfo->arith_code) { (*cinfo->entropy->start_pass) (cinfo, TRUE); (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST); master->pub.call_pass_startup = FALSE; break; } /* Special case: Huffman DC refinement scans need no Huffman table * and therefore we can skip the optimization pass for them. */ master->pass_type = output_pass; master->pass_number++; /*FALLTHROUGH*/ #endif case output_pass: /* Do a data-output pass. */ /* We need not repeat per-scan setup if prior optimization pass did it. */ if (! cinfo->optimize_coding) { select_scan_parameters(cinfo); per_scan_setup(cinfo); } (*cinfo->entropy->start_pass) (cinfo, FALSE); (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST); /* We emit frame/scan headers now */ if (master->scan_number == 0) (*cinfo->marker->write_frame_header) (cinfo); (*cinfo->marker->write_scan_header) (cinfo); master->pub.call_pass_startup = FALSE; break; default: ERREXIT(cinfo, JERR_NOT_COMPILED); } master->pub.is_last_pass = (master->pass_number == master->total_passes-1); /* Set up progress monitor's pass info if present */ if (cinfo->progress != NULL) { cinfo->progress->completed_passes = master->pass_number; cinfo->progress->total_passes = master->total_passes; } } /* * Special start-of-pass hook. * This is called by jpeg_write_scanlines if call_pass_startup is TRUE. * In single-pass processing, we need this hook because we don't want to * write frame/scan headers during jpeg_start_compress; we want to let the * application write COM markers etc. between jpeg_start_compress and the * jpeg_write_scanlines loop. * In multi-pass processing, this routine is not used. */ METHODDEF(void) pass_startup (j_compress_ptr cinfo) { cinfo->master->call_pass_startup = FALSE; /* reset flag so call only once */ (*cinfo->marker->write_frame_header) (cinfo); (*cinfo->marker->write_scan_header) (cinfo); } /* * Finish up at end of pass. */ METHODDEF(void) finish_pass_master (j_compress_ptr cinfo) { my_master_ptr master = (my_master_ptr) cinfo->master; /* The entropy coder always needs an end-of-pass call, * either to analyze statistics or to flush its output buffer. */ (*cinfo->entropy->finish_pass) (cinfo); /* Update state for next pass */ switch (master->pass_type) { case main_pass: /* next pass is either output of scan 0 (after optimization) * or output of scan 1 (if no optimization). */ master->pass_type = output_pass; if (! cinfo->optimize_coding) master->scan_number++; break; case huff_opt_pass: /* next pass is always output of current scan */ master->pass_type = output_pass; break; case output_pass: /* next pass is either optimization or output of next scan */ if (cinfo->optimize_coding) master->pass_type = huff_opt_pass; master->scan_number++; break; } master->pass_number++; } /* * Initialize master compression control. */ GLOBAL(void) jinit_c_master_control (j_compress_ptr cinfo, boolean transcode_only) { my_master_ptr master; master = (my_master_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_comp_master)); cinfo->master = (struct jpeg_comp_master *) master; master->pub.prepare_for_pass = prepare_for_pass; master->pub.pass_startup = pass_startup; master->pub.finish_pass = finish_pass_master; master->pub.is_last_pass = FALSE; /* Validate parameters, determine derived values */ initial_setup(cinfo); if (cinfo->scan_info != NULL) { #ifdef C_MULTISCAN_FILES_SUPPORTED validate_script(cinfo); #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } else { cinfo->progressive_mode = FALSE; cinfo->num_scans = 1; } if (cinfo->progressive_mode) /* TEMPORARY HACK ??? */ cinfo->optimize_coding = TRUE; /* assume default tables no good for progressive mode */ /* Initialize my private state */ if (transcode_only) { /* no main pass in transcoding */ if (cinfo->optimize_coding) master->pass_type = huff_opt_pass; else master->pass_type = output_pass; } else { /* for normal compression, first pass is always this type: */ master->pass_type = main_pass; } master->scan_number = 0; master->pass_number = 0; if (cinfo->optimize_coding) master->total_passes = cinfo->num_scans * 2; else master->total_passes = cinfo->num_scans; } Papyrus3/JpegDir/JpgLossy/JCAPISTD.C0000755000175000017500000001363207535143454014151 0ustar /* * jcapistd.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains application interface code for the compression half * of the JPEG library. These are the "standard" API routines that are * used in the normal full-compression case. They are not used by a * transcoding-only application. Note that if an application links in * jpeg_start_compress, it will end up linking in the entire compressor. * We thus must separate this file from jcapimin.c to avoid linking the * whole compression library into a transcoder. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* * Compression initialization. * Before calling this, all parameters and a data destination must be set up. * * We require a write_all_tables parameter as a failsafe check when writing * multiple datastreams from the same compression object. Since prior runs * will have left all the tables marked sent_table=TRUE, a subsequent run * would emit an abbreviated stream (no tables) by default. This may be what * is wanted, but for safety's sake it should not be the default behavior: * programmers should have to make a deliberate choice to emit abbreviated * images. Therefore the documentation and examples should encourage people * to pass write_all_tables=TRUE; then it will take active thought to do the * wrong thing. */ GLOBAL(void) jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables) { if (cinfo->global_state != CSTATE_START) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); if (write_all_tables) jpeg_suppress_tables(cinfo, FALSE); /* mark all tables to be written */ /* (Re)initialize error mgr and destination modules */ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo); (*cinfo->dest->init_destination) (cinfo); /* Perform master selection of active modules */ jinit_compress_master(cinfo); /* Set up for the first pass */ (*cinfo->master->prepare_for_pass) (cinfo); /* Ready for application to drive first pass through jpeg_write_scanlines * or jpeg_write_raw_data. */ cinfo->next_scanline = 0; cinfo->global_state = (cinfo->raw_data_in ? CSTATE_RAW_OK : CSTATE_SCANNING); } /* * Write some scanlines of data to the JPEG compressor. * * The return value will be the number of lines actually written. * This should be less than the supplied num_lines only in case that * the data destination module has requested suspension of the compressor, * or if more than image_height scanlines are passed in. * * Note: we warn about excess calls to jpeg_write_scanlines() since * this likely signals an application programmer error. However, * excess scanlines passed in the last valid call are *silently* ignored, * so that the application need not adjust num_lines for end-of-image * when using a multiple-scanline buffer. */ GLOBAL(JDIMENSION) jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION num_lines) { JDIMENSION row_ctr, rows_left; if (cinfo->global_state != CSTATE_SCANNING) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); if (cinfo->next_scanline >= cinfo->image_height) WARNMS(cinfo, JWRN_TOO_MUCH_DATA); /* Call progress monitor hook if present */ if (cinfo->progress != NULL) { cinfo->progress->pass_counter = (long) cinfo->next_scanline; cinfo->progress->pass_limit = (long) cinfo->image_height; (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); } /* Give master control module another chance if this is first call to * jpeg_write_scanlines. This lets output of the frame/scan headers be * delayed so that application can write COM, etc, markers between * jpeg_start_compress and jpeg_write_scanlines. */ if (cinfo->master->call_pass_startup) (*cinfo->master->pass_startup) (cinfo); /* Ignore any extra scanlines at bottom of image. */ rows_left = cinfo->image_height - cinfo->next_scanline; if (num_lines > rows_left) num_lines = rows_left; row_ctr = 0; (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, num_lines); cinfo->next_scanline += row_ctr; return row_ctr; } /* * Alternate entry point to write raw data. * Processes exactly one iMCU row per call, unless suspended. */ GLOBAL(JDIMENSION) jpeg_write_raw_data (j_compress_ptr cinfo, JSAMPIMAGE data, JDIMENSION num_lines) { JDIMENSION lines_per_iMCU_row; if (cinfo->global_state != CSTATE_RAW_OK) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); if (cinfo->next_scanline >= cinfo->image_height) { WARNMS(cinfo, JWRN_TOO_MUCH_DATA); return 0; } /* Call progress monitor hook if present */ if (cinfo->progress != NULL) { cinfo->progress->pass_counter = (long) cinfo->next_scanline; cinfo->progress->pass_limit = (long) cinfo->image_height; (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); } /* Give master control module another chance if this is first call to * jpeg_write_raw_data. This lets output of the frame/scan headers be * delayed so that application can write COM, etc, markers between * jpeg_start_compress and jpeg_write_raw_data. */ if (cinfo->master->call_pass_startup) (*cinfo->master->pass_startup) (cinfo); /* Verify that at least one iMCU row has been passed. */ lines_per_iMCU_row = cinfo->max_v_samp_factor * DCTSIZE; if (num_lines < lines_per_iMCU_row) ERREXIT(cinfo, JERR_BUFFER_SIZE); /* Directly compress the row. */ if (! (*cinfo->coef->compress_data) (cinfo, data)) { /* If compressor did not consume the whole row, suspend processing. */ return 0; } /* OK, we processed one iMCU row. */ cinfo->next_scanline += lines_per_iMCU_row; return lines_per_iMCU_row; } Papyrus3/JpegDir/JpgLossy/RDPPM.C0000755000175000017500000003574307535143454013641 0ustar /* * rdppm.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains routines to read input images in PPM/PGM format. * The extended 2-byte-per-sample raw PPM/PGM formats are supported. * The PBMPLUS library is NOT required to compile this software * (but it is highly useful as a set of PPM image manipulation programs). * * These routines may need modification for non-Unix environments or * specialized applications. As they stand, they assume input from * an ordinary stdio stream. They further assume that reading begins * at the start of the file; start_input may need work if the * user interface has already read some data (e.g., to determine that * the file is indeed PPM format). */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif #ifdef PPM_SUPPORTED /* Portions of this code are based on the PBMPLUS library, which is: ** ** Copyright (C) 1988 by Jef Poskanzer. ** ** Permission to use, copy, modify, and distribute this software and its ** documentation for any purpose and without fee is hereby granted, provided ** that the above copyright notice appear in all copies and that both that ** copyright notice and this permission notice appear in supporting ** documentation. This software is provided "as is" without express or ** implied warranty. */ /* Macros to deal with unsigned chars as efficiently as compiler allows */ #ifdef HAVE_UNSIGNED_CHAR typedef unsigned char U_CHAR; #define UCH(x) ((int) (x)) #else /* !HAVE_UNSIGNED_CHAR */ #ifdef CHAR_IS_UNSIGNED typedef char U_CHAR; #define UCH(x) ((int) (x)) #else typedef char U_CHAR; #define UCH(x) ((int) (x) & 0xFF) #endif #endif /* HAVE_UNSIGNED_CHAR */ /*#define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (len)))*/ #define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (0))) /* * On most systems, reading individual bytes with getc() is drastically less * efficient than buffering a row at a time with fread(). On PCs, we must * allocate the buffer in near data space, because we are assuming small-data * memory model, wherein fread() can't reach far memory. If you need to * process very wide images on a PC, you might have to compile in large-memory * model, or else replace fread() with a getc() loop --- which will be much * slower. */ /* Private version of data source object */ typedef struct { struct cjpeg_source_struct pub; /* public fields */ U_CHAR *iobuffer; /* non-FAR pointer to I/O buffer */ JSAMPROW pixrow; /* FAR pointer to same */ size_t buffer_width; /* width of I/O buffer */ JSAMPLE *rescale; /* => maxval-remapping array, or NULL */ } ppm_source_struct; typedef ppm_source_struct * ppm_source_ptr; LOCAL(int) pbm_getc (PAPY_FILE infile) /* Read next char, skipping over any comments */ /* A comment/newline sequence is returned as a newline */ { int ch; PapyULong bytesToRead = 1L; /*ch = getc(infile); */ Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &ch); if (ch == '#') { do { /*ch = getc(infile);*/ Papy3FRead (infile, &bytesToRead, (PapyULong) 1L, (void *) &ch); } while (ch != '\n' && ch != EOF); } return ch; } LOCAL(unsigned int) read_pbm_integer (j_compress_ptr cinfo, PAPY_FILE infile) /* Read an unsigned decimal integer from the PPM file */ /* Swallows one trailing character after the integer */ /* Note that on a 16-bit-int machine, only values up to 64k can be read. */ /* This should not be a problem in practice. */ { register int ch; register unsigned int val; /* Skip any leading whitespace */ do { ch = pbm_getc(infile); if (ch == EOF) ERREXIT(cinfo, JERR_INPUT_EOF); } while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'); if (ch < '0' || ch > '9') ERREXIT(cinfo, JERR_PPM_NONNUMERIC); val = ch - '0'; while ((ch = pbm_getc(infile)) >= '0' && ch <= '9') { val *= 10; val += ch - '0'; } return val; } /* * Read one row of pixels. * * We provide several different versions depending on input file format. * In all cases, input is scaled to the size of JSAMPLE. * * A really fast path is provided for reading byte/sample raw files with * maxval = MAXJSAMPLE, which is the normal case for 8-bit data. */ METHODDEF(JDIMENSION) get_text_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading text-format PGM files with any maxval */ { ppm_source_ptr source = (ppm_source_ptr) sinfo; PAPY_FILE infile = source->pub.input_file; register JSAMPROW ptr; register JSAMPLE *rescale = source->rescale; JDIMENSION col; ptr = source->pub.buffer[0]; for (col = cinfo->image_width; col > 0; col--) { *ptr++ = rescale[read_pbm_integer(cinfo, infile)]; } return 1; } METHODDEF(JDIMENSION) get_text_rgb_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading text-format PPM files with any maxval */ { ppm_source_ptr source = (ppm_source_ptr) sinfo; PAPY_FILE infile = source->pub.input_file; register JSAMPROW ptr; register JSAMPLE *rescale = source->rescale; JDIMENSION col; ptr = source->pub.buffer[0]; for (col = cinfo->image_width; col > 0; col--) { *ptr++ = rescale[read_pbm_integer(cinfo, infile)]; *ptr++ = rescale[read_pbm_integer(cinfo, infile)]; *ptr++ = rescale[read_pbm_integer(cinfo, infile)]; } return 1; } METHODDEF(JDIMENSION) get_scaled_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading raw-byte-format PGM files with any maxval */ { ppm_source_ptr source = (ppm_source_ptr) sinfo; register JSAMPROW ptr; register U_CHAR * bufferptr; register JSAMPLE *rescale = source->rescale; JDIMENSION col; if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width)) ERREXIT(cinfo, JERR_INPUT_EOF); ptr = source->pub.buffer[0]; bufferptr = source->iobuffer; for (col = cinfo->image_width; col > 0; col--) { *ptr++ = rescale[UCH(*bufferptr++)]; } return 1; } METHODDEF(JDIMENSION) get_scaled_rgb_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading raw-byte-format PPM files with any maxval */ { ppm_source_ptr source = (ppm_source_ptr) sinfo; register JSAMPROW ptr; register U_CHAR * bufferptr; register JSAMPLE *rescale = source->rescale; JDIMENSION col; if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width)) ERREXIT(cinfo, JERR_INPUT_EOF); ptr = source->pub.buffer[0]; bufferptr = source->iobuffer; for (col = cinfo->image_width; col > 0; col--) { *ptr++ = rescale[UCH(*bufferptr++)]; *ptr++ = rescale[UCH(*bufferptr++)]; *ptr++ = rescale[UCH(*bufferptr++)]; } return 1; } METHODDEF(JDIMENSION) get_raw_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading raw-byte-format files with maxval = MAXJSAMPLE. * In this case we just read right into the JSAMPLE buffer! * Note that same code works for PPM and PGM files. */ { ppm_source_ptr source = (ppm_source_ptr) sinfo; if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width)) ERREXIT(cinfo, JERR_INPUT_EOF); return 1; } METHODDEF(JDIMENSION) get_word_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading raw-word-format PGM files with any maxval */ { ppm_source_ptr source = (ppm_source_ptr) sinfo; register JSAMPROW ptr; register U_CHAR * bufferptr; register JSAMPLE *rescale = source->rescale; JDIMENSION col; if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width)) ERREXIT(cinfo, JERR_INPUT_EOF); ptr = source->pub.buffer[0]; bufferptr = source->iobuffer; for (col = cinfo->image_width; col > 0; col--) { register int temp; temp = UCH(*bufferptr++); temp |= UCH(*bufferptr++) << 8; *ptr++ = rescale[temp]; } return 1; } METHODDEF(JDIMENSION) get_word_rgb_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) /* This version is for reading raw-word-format PPM files with any maxval */ { ppm_source_ptr source = (ppm_source_ptr) sinfo; register JSAMPROW ptr; register U_CHAR * bufferptr; register JSAMPLE *rescale = source->rescale; JDIMENSION col; if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width)) ERREXIT(cinfo, JERR_INPUT_EOF); ptr = source->pub.buffer[0]; bufferptr = source->iobuffer; for (col = cinfo->image_width; col > 0; col--) { register int temp; temp = UCH(*bufferptr++); temp |= UCH(*bufferptr++) << 8; *ptr++ = rescale[temp]; temp = UCH(*bufferptr++); temp |= UCH(*bufferptr++) << 8; *ptr++ = rescale[temp]; temp = UCH(*bufferptr++); temp |= UCH(*bufferptr++) << 8; *ptr++ = rescale[temp]; } return 1; } /* * Read the file header; return image size and component count. */ METHODDEF(void) start_input_ppm (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { ppm_source_ptr source = (ppm_source_ptr) sinfo; char ch [2]; int c; unsigned int w, h, maxval; boolean need_iobuffer, use_raw_buffer, need_rescale; PapyULong bytesToRead = 1L; /*if (getc(source->pub.input_file) != 'P')*/ Papy3FRead (source->pub.input_file, &bytesToRead, (PapyULong) 1L, (void *) &ch); if (ch [0] != 'P') ERREXIT(cinfo, JERR_PPM_NOT); /*c = getc(source->pub.input_file); /* subformat discriminator character */ Papy3FRead (source->pub.input_file, &bytesToRead, (PapyULong) 1L, (void *) &c); /* detect unsupported variants (ie, PBM) before trying to read header */ switch (c) { case '2': /* it's a text-format PGM file */ case '3': /* it's a text-format PPM file */ case '5': /* it's a raw-format PGM file */ case '6': /* it's a raw-format PPM file */ break; default: ERREXIT(cinfo, JERR_PPM_NOT); break; } /* fetch the remaining header info */ w = read_pbm_integer(cinfo, source->pub.input_file); h = read_pbm_integer(cinfo, source->pub.input_file); maxval = read_pbm_integer(cinfo, source->pub.input_file); if (w <= 0 || h <= 0 || maxval <= 0) /* error check */ ERREXIT(cinfo, JERR_PPM_NOT); cinfo->data_precision = BITS_IN_JSAMPLE; /* we always rescale data to this */ cinfo->image_width = (JDIMENSION) w; cinfo->image_height = (JDIMENSION) h; /* initialize flags to most common settings */ need_iobuffer = TRUE; /* do we need an I/O buffer? */ use_raw_buffer = FALSE; /* do we map input buffer onto I/O buffer? */ need_rescale = TRUE; /* do we need a rescale array? */ switch (c) { case '2': /* it's a text-format PGM file */ cinfo->input_components = 1; cinfo->in_color_space = JCS_GRAYSCALE; TRACEMS2(cinfo, 1, JTRC_PGM_TEXT, w, h); source->pub.get_pixel_rows = get_text_gray_row; need_iobuffer = FALSE; break; case '3': /* it's a text-format PPM file */ cinfo->input_components = 3; cinfo->in_color_space = JCS_RGB; TRACEMS2(cinfo, 1, JTRC_PPM_TEXT, w, h); source->pub.get_pixel_rows = get_text_rgb_row; need_iobuffer = FALSE; break; case '5': /* it's a raw-format PGM file */ cinfo->input_components = 1; cinfo->in_color_space = JCS_GRAYSCALE; TRACEMS2(cinfo, 1, JTRC_PGM, w, h); if (maxval > 255) { source->pub.get_pixel_rows = get_word_gray_row; } else if (maxval == MAXJSAMPLE && SIZEOF(JSAMPLE) == SIZEOF(U_CHAR)) { source->pub.get_pixel_rows = get_raw_row; use_raw_buffer = TRUE; need_rescale = FALSE; } else { source->pub.get_pixel_rows = get_scaled_gray_row; } break; case '6': /* it's a raw-format PPM file */ cinfo->input_components = 3; cinfo->in_color_space = JCS_RGB; TRACEMS2(cinfo, 1, JTRC_PPM, w, h); if (maxval > 255) { source->pub.get_pixel_rows = get_word_rgb_row; } else if (maxval == MAXJSAMPLE && SIZEOF(JSAMPLE) == SIZEOF(U_CHAR)) { source->pub.get_pixel_rows = get_raw_row; use_raw_buffer = TRUE; need_rescale = FALSE; } else { source->pub.get_pixel_rows = get_scaled_rgb_row; } break; } /* Allocate space for I/O buffer: 1 or 3 bytes or words/pixel. */ if (need_iobuffer) { source->buffer_width = (size_t) w * cinfo->input_components * ((maxval<=255) ? SIZEOF(U_CHAR) : (2*SIZEOF(U_CHAR))); source->iobuffer = (U_CHAR *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, source->buffer_width); } /* Create compressor input buffer. */ if (use_raw_buffer) { /* For unscaled raw-input case, we can just map it onto the I/O buffer. */ /* Synthesize a JSAMPARRAY pointer structure */ /* Cast here implies near->far pointer conversion on PCs */ source->pixrow = (JSAMPROW) source->iobuffer; source->pub.buffer = & source->pixrow; source->pub.buffer_height = 1; } else { /* Need to translate anyway, so make a separate sample buffer. */ source->pub.buffer = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) w * cinfo->input_components, (JDIMENSION) 1); source->pub.buffer_height = 1; } /* Compute the rescaling array if required. */ if (need_rescale) { INT32 val, half_maxval; /* On 16-bit-int machines we have to be careful of maxval = 65535 */ source->rescale = (JSAMPLE *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, (size_t) (((long) maxval + 1L) * SIZEOF(JSAMPLE))); half_maxval = maxval / 2; for (val = 0; val <= (INT32) maxval; val++) { /* The multiplication here must be done in 32 bits to avoid overflow */ source->rescale[val] = (JSAMPLE) ((val*MAXJSAMPLE + half_maxval)/maxval); } } } /* * Finish up at the end of the file. */ METHODDEF(void) finish_input_ppm (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) { /* no work */ } /* * The module selection routine for PPM format input. */ GLOBAL(cjpeg_source_ptr) jinit_read_ppm (j_compress_ptr cinfo) { ppm_source_ptr source; /* Create module interface object */ source = (ppm_source_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(ppm_source_struct)); /* Fill in method ptrs, except get_pixel_rows which start_input sets */ source->pub.start_input = start_input_ppm; source->pub.finish_input = finish_input_ppm; return (cjpeg_source_ptr) source; } #endif /* PPM_SUPPORTED */ Papyrus3/JpegDir/JpgLossy/JDPOSTCT.C0000755000175000017500000002343507535143454014204 0ustar /* * jdpostct.c * * Copyright (C) 1994-1996, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains the decompression postprocessing controller. * This controller manages the upsampling, color conversion, and color * quantization/reduction steps; specifically, it controls the buffering * between upsample/color conversion and color quantization/reduction. * * If no color quantization/reduction is required, then this module has no * work to do, and it just hands off to the upsample/color conversion code. * An integrated upsample/convert/quantize process would replace this module * entirely. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* Private buffer controller object */ typedef struct { struct jpeg_d_post_controller pub; /* public fields */ /* Color quantization source buffer: this holds output data from * the upsample/color conversion step to be passed to the quantizer. * For two-pass color quantization, we need a full-image buffer; * for one-pass operation, a strip buffer is sufficient. */ jvirt_sarray_ptr whole_image; /* virtual array, or NULL if one-pass */ JSAMPARRAY buffer; /* strip buffer, or current strip of virtual */ JDIMENSION strip_height; /* buffer size in rows */ /* for two-pass mode only: */ JDIMENSION starting_row; /* row # of first row in current strip */ JDIMENSION next_row; /* index of next row to fill/empty in strip */ } my_post_controller; typedef my_post_controller * my_post_ptr; /* Forward declarations */ METHODDEF(void) post_process_1pass JPP((j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); #ifdef QUANT_2PASS_SUPPORTED METHODDEF(void) post_process_prepass JPP((j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); METHODDEF(void) post_process_2pass JPP((j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)); #endif /* * Initialize for a processing pass. */ METHODDEF(void) start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode) { my_post_ptr post = (my_post_ptr) cinfo->post; switch (pass_mode) { case JBUF_PASS_THRU: if (cinfo->quantize_colors) { /* Single-pass processing with color quantization. */ post->pub.post_process_data = post_process_1pass; /* We could be doing buffered-image output before starting a 2-pass * color quantization; in that case, jinit_d_post_controller did not * allocate a strip buffer. Use the virtual-array buffer as workspace. */ if (post->buffer == NULL) { post->buffer = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, post->whole_image, (JDIMENSION) 0, post->strip_height, TRUE); } } else { /* For single-pass processing without color quantization, * I have no work to do; just call the upsampler directly. */ post->pub.post_process_data = cinfo->upsample->upsample; } break; #ifdef QUANT_2PASS_SUPPORTED case JBUF_SAVE_AND_PASS: /* First pass of 2-pass quantization */ if (post->whole_image == NULL) ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); post->pub.post_process_data = post_process_prepass; break; case JBUF_CRANK_DEST: /* Second pass of 2-pass quantization */ if (post->whole_image == NULL) ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); post->pub.post_process_data = post_process_2pass; break; #endif /* QUANT_2PASS_SUPPORTED */ default: ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); break; } post->starting_row = post->next_row = 0; } /* * Process some data in the one-pass (strip buffer) case. * This is used for color precision reduction as well as one-pass quantization. */ METHODDEF(void) post_process_1pass (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail) { my_post_ptr post = (my_post_ptr) cinfo->post; JDIMENSION num_rows, max_rows; /* Fill the buffer, but not more than what we can dump out in one go. */ /* Note we rely on the upsampler to detect bottom of image. */ max_rows = out_rows_avail - *out_row_ctr; if (max_rows > post->strip_height) max_rows = post->strip_height; num_rows = 0; (*cinfo->upsample->upsample) (cinfo, input_buf, in_row_group_ctr, in_row_groups_avail, post->buffer, &num_rows, max_rows); /* Quantize and emit data. */ (*cinfo->cquantize->color_quantize) (cinfo, post->buffer, output_buf + *out_row_ctr, (int) num_rows); *out_row_ctr += num_rows; } #ifdef QUANT_2PASS_SUPPORTED /* * Process some data in the first pass of 2-pass quantization. */ METHODDEF(void) post_process_prepass (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail) { my_post_ptr post = (my_post_ptr) cinfo->post; JDIMENSION old_next_row, num_rows; /* Reposition virtual buffer if at start of strip. */ if (post->next_row == 0) { post->buffer = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, post->whole_image, post->starting_row, post->strip_height, TRUE); } /* Upsample some data (up to a strip height's worth). */ old_next_row = post->next_row; (*cinfo->upsample->upsample) (cinfo, input_buf, in_row_group_ctr, in_row_groups_avail, post->buffer, &post->next_row, post->strip_height); /* Allow quantizer to scan new data. No data is emitted, */ /* but we advance out_row_ctr so outer loop can tell when we're done. */ if (post->next_row > old_next_row) { num_rows = post->next_row - old_next_row; (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + old_next_row, (JSAMPARRAY) NULL, (int) num_rows); *out_row_ctr += num_rows; } /* Advance if we filled the strip. */ if (post->next_row >= post->strip_height) { post->starting_row += post->strip_height; post->next_row = 0; } } /* * Process some data in the second pass of 2-pass quantization. */ METHODDEF(void) post_process_2pass (j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail) { my_post_ptr post = (my_post_ptr) cinfo->post; JDIMENSION num_rows, max_rows; /* Reposition virtual buffer if at start of strip. */ if (post->next_row == 0) { post->buffer = (*cinfo->mem->access_virt_sarray) ((j_common_ptr) cinfo, post->whole_image, post->starting_row, post->strip_height, FALSE); } /* Determine number of rows to emit. */ num_rows = post->strip_height - post->next_row; /* available in strip */ max_rows = out_rows_avail - *out_row_ctr; /* available in output area */ if (num_rows > max_rows) num_rows = max_rows; /* We have to check bottom of image here, can't depend on upsampler. */ max_rows = cinfo->output_height - post->starting_row; if (num_rows > max_rows) num_rows = max_rows; /* Quantize and emit data. */ (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + post->next_row, output_buf + *out_row_ctr, (int) num_rows); *out_row_ctr += num_rows; /* Advance if we filled the strip. */ post->next_row += num_rows; if (post->next_row >= post->strip_height) { post->starting_row += post->strip_height; post->next_row = 0; } } #endif /* QUANT_2PASS_SUPPORTED */ /* * Initialize postprocessing controller. */ GLOBAL(void) jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer) { my_post_ptr post; post = (my_post_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_post_controller)); cinfo->post = (struct jpeg_d_post_controller *) post; post->pub.start_pass = start_pass_dpost; post->whole_image = NULL; /* flag for no virtual arrays */ post->buffer = NULL; /* flag for no strip buffer */ /* Create the quantization buffer, if needed */ if (cinfo->quantize_colors) { /* The buffer strip height is max_v_samp_factor, which is typically * an efficient number of rows for upsampling to return. * (In the presence of output rescaling, we might want to be smarter?) */ post->strip_height = (JDIMENSION) cinfo->max_v_samp_factor; if (need_full_buffer) { /* Two-pass color quantization: need full-image storage. */ /* We round up the number of rows to a multiple of the strip height. */ #ifdef QUANT_2PASS_SUPPORTED post->whole_image = (*cinfo->mem->request_virt_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, cinfo->output_width * cinfo->out_color_components, (JDIMENSION) jround_up((long) cinfo->output_height, (long) post->strip_height), post->strip_height); #else ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); #endif /* QUANT_2PASS_SUPPORTED */ } else { /* One-pass color quantization: just make a strip buffer. */ post->buffer = (*cinfo->mem->alloc_sarray) ((j_common_ptr) cinfo, JPOOL_IMAGE, cinfo->output_width * cinfo->out_color_components, post->strip_height); } } } Papyrus3/JpegDir/JpgLossy/jconfig.mac0000755000175000017500000000233207535143454014740 0ustar /* jconfig.mac --- jconfig.h for CodeWarrior on Apple Macintosh */ /* see jconfig.doc for explanations */ #define HAVE_PROTOTYPES #define HAVE_UNSIGNED_CHAR #define HAVE_UNSIGNED_SHORT /* #define void char */ /* #define const */ #undef CHAR_IS_UNSIGNED #define HAVE_STDDEF_H #define HAVE_STDLIB_H #undef NEED_BSD_STRINGS #undef NEED_SYS_TYPES_H #undef NEED_FAR_POINTERS #undef NEED_SHORT_EXTERNAL_NAMES #undef INCOMPLETE_TYPES_BROKEN #ifdef JPEG_INTERNALS #undef RIGHT_SHIFT_IS_UNSIGNED #define USE_MAC_MEMMGR /* Define this if you use jmemmac.c */ #define ALIGN_TYPE long /* Needed for 680x0 Macs */ #endif /* JPEG_INTERNALS */ #ifdef JPEG_CJPEG_DJPEG #define BMP_SUPPORTED /* BMP image file format */ #define GIF_SUPPORTED /* GIF image file format */ #define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ #undef RLE_SUPPORTED /* Utah RLE image file format */ #define TARGA_SUPPORTED /* Targa image file format */ #define USE_CCOMMAND /* Command line reader for Macintosh */ #define TWO_FILE_COMMANDLINE /* Binary I/O thru stdin/stdout doesn't work */ #undef NEED_SIGNAL_CATCHER #undef DONT_USE_B_MODE #undef PROGRESS_REPORT /* optional */ #endif /* JPEG_CJPEG_DJPEG */ Papyrus3/JpegDir/JpgLossy/ansi2knr.10000755000175000017500000000303507535143454014451 0ustar .TH ANSI2KNR 1 "19 Jan 1996" .SH NAME ansi2knr \- convert ANSI C to Kernighan & Ritchie C .SH SYNOPSIS .I ansi2knr [--varargs] input_file [output_file] .SH DESCRIPTION If no output_file is supplied, output goes to stdout. .br There are no error messages. .sp .I ansi2knr recognizes function definitions by seeing a non-keyword identifier at the left margin, followed by a left parenthesis, with a right parenthesis as the last character on the line, and with a left brace as the first token on the following line (ignoring possible intervening comments). It will recognize a multi-line header provided that no intervening line ends with a left or right brace or a semicolon. These algorithms ignore whitespace and comments, except that the function name must be the first thing on the line. .sp The following constructs will confuse it: .br - Any other construct that starts at the left margin and follows the above syntax (such as a macro or function call). .br - Some macros that tinker with the syntax of the function header. .sp The --varargs switch is obsolete, and is recognized only for backwards compatibility. The present version of .I ansi2knr will always attempt to convert a ... argument to va_alist and va_dcl. .SH AUTHOR L. Peter Deutsch wrote the original ansi2knr and continues to maintain the current version; most of the code in the current version is his work. ansi2knr also includes contributions by Francois Pinard and Jim Avera . Papyrus3/JpegDir/JpgLossy/MAKEFILE.MC60000755000175000017500000003352707535143454014335 0ustar # Makefile for Independent JPEG Group's software # This makefile is for Microsoft C for MS-DOS, version 6.00A and up. # Use NMAKE, not Microsoft's brain-damaged MAKE. # Thanks to Alan Wright and Chris Turner of Olivetti Research Ltd. # Read installation instructions before saying "nmake" !! # You may need to adjust these compiler options: CFLAGS = -AM -Oecigt -Gs -W3 # -AM medium memory model (or use -AS for small model, if you remove features) # -Oecigt -Gs maximum safe optimisation (-Ol has bugs in MSC 6.00A) # -W3 warning level 3 # You might also want to add -G2 if you have an 80286, etc. # Generally, we recommend defining any configuration symbols in jconfig.h, # NOT via -D switches here. # Jan-Herman Buining suggests the following switches for MS C 8.0 and a 486: # CFLAGS = /AM /f- /FPi87 /G3 /Gs /Gy /Ob1 /Oc /Oe /Og /Oi /Ol /On /Oo /Ot \ # /OV4 /W3 # except for jquant1.c, which must be compiled with /Oo- to avoid a compiler # crash. # Ingar Steinsland suggests the following switches when building # a 16-bit Windows DLL: # CFLAGS = -ALw -Gsw -Zpe -W3 -O2 -Zi -Zd # Put here the object file name for the correct system-dependent memory # manager file. For DOS, we recommend jmemdos.c and jmemdosa.asm. # (But not for Windows; see install.doc if you use this makefile for Windows.) SYSDEPMEM= jmemdos.obj jmemdosa.obj # SYSDEPMEMLIB must list the same files with "+" signs for the librarian. SYSDEPMEMLIB= +jmemdos.obj +jmemdosa.obj # End of configurable options. # source files: JPEG library proper LIBSOURCES= jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c \ jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c \ jcphuff.c jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c \ jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c \ jdinput.c jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c \ jdpostct.c jdsample.c jdtrans.c jerror.c jfdctflt.c jfdctfst.c \ jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c jquant1.c \ jquant2.c jutils.c jmemmgr.c # memmgr back ends: compile only one of these into a working library SYSDEPSOURCES= jmemansi.c jmemname.c jmemnobs.c jmemdos.c jmemmac.c # source files: cjpeg/djpeg/jpegtran applications, also rdjpgcom/wrjpgcom APPSOURCES= cjpeg.c djpeg.c jpegtran.c rdjpgcom.c wrjpgcom.c cdjpeg.c \ rdcolmap.c rdswitch.c transupp.c rdppm.c wrppm.c rdgif.c wrgif.c \ rdtarga.c wrtarga.c rdbmp.c wrbmp.c rdrle.c wrrle.c SOURCES= $(LIBSOURCES) $(SYSDEPSOURCES) $(APPSOURCES) # files included by source files INCLUDES= jchuff.h jdhuff.h jdct.h jerror.h jinclude.h jmemsys.h jmorecfg.h \ jpegint.h jpeglib.h jversion.h cdjpeg.h cderror.h transupp.h # documentation, test, and support files DOCS= README install.doc usage.doc cjpeg.1 djpeg.1 jpegtran.1 rdjpgcom.1 \ wrjpgcom.1 wizard.doc example.c libjpeg.doc structure.doc \ coderules.doc filelist.doc change.log MKFILES= configure makefile.cfg makefile.ansi makefile.unix makefile.bcc \ makefile.mc6 makefile.dj makefile.wat makefile.vc makelib.ds \ makeapps.ds makeproj.mac makcjpeg.st makdjpeg.st makljpeg.st \ maktjpeg.st makefile.manx makefile.sas makefile.mms makefile.vms \ makvms.opt CONFIGFILES= jconfig.cfg jconfig.bcc jconfig.mc6 jconfig.dj jconfig.wat \ jconfig.vc jconfig.mac jconfig.st jconfig.manx jconfig.sas \ jconfig.vms CONFIGUREFILES= config.guess config.sub install-sh ltconfig ltmain.sh OTHERFILES= jconfig.doc ckconfig.c ansi2knr.c ansi2knr.1 jmemdosa.asm TESTFILES= testorig.jpg testimg.ppm testimg.bmp testimg.jpg testprog.jpg \ testimgp.jpg DISTFILES= $(DOCS) $(MKFILES) $(CONFIGFILES) $(SOURCES) $(INCLUDES) \ $(CONFIGUREFILES) $(OTHERFILES) $(TESTFILES) # library object files common to compression and decompression COMOBJECTS= jcomapi.obj jutils.obj jerror.obj jmemmgr.obj $(SYSDEPMEM) # compression library object files CLIBOBJECTS= jcapimin.obj jcapistd.obj jctrans.obj jcparam.obj jdatadst.obj \ jcinit.obj jcmaster.obj jcmarker.obj jcmainct.obj jcprepct.obj \ jccoefct.obj jccolor.obj jcsample.obj jchuff.obj jcphuff.obj \ jcdctmgr.obj jfdctfst.obj jfdctflt.obj jfdctint.obj # decompression library object files DLIBOBJECTS= jdapimin.obj jdapistd.obj jdtrans.obj jdatasrc.obj \ jdmaster.obj jdinput.obj jdmarker.obj jdhuff.obj jdphuff.obj \ jdmainct.obj jdcoefct.obj jdpostct.obj jddctmgr.obj jidctfst.obj \ jidctflt.obj jidctint.obj jidctred.obj jdsample.obj jdcolor.obj \ jquant1.obj jquant2.obj jdmerge.obj # These objectfiles are included in libjpeg.lib LIBOBJECTS= $(CLIBOBJECTS) $(DLIBOBJECTS) $(COMOBJECTS) # object files for sample applications (excluding library files) COBJECTS= cjpeg.obj rdppm.obj rdgif.obj rdtarga.obj rdrle.obj rdbmp.obj \ rdswitch.obj cdjpeg.obj DOBJECTS= djpeg.obj wrppm.obj wrgif.obj wrtarga.obj wrrle.obj wrbmp.obj \ rdcolmap.obj cdjpeg.obj TROBJECTS= jpegtran.obj rdswitch.obj cdjpeg.obj transupp.obj # need linker response file because file list > 128 chars RFILE = libjpeg.ans all: libjpeg.lib cjpeg.exe djpeg.exe jpegtran.exe rdjpgcom.exe wrjpgcom.exe libjpeg.lib: $(LIBOBJECTS) $(RFILE) del libjpeg.lib lib @$(RFILE) # linker response file for building libjpeg.lib $(RFILE) : makefile del $(RFILE) echo libjpeg.lib >$(RFILE) # silly want-to-create-it prompt: echo y >>$(RFILE) echo +jcapimin.obj +jcapistd.obj +jctrans.obj +jcparam.obj & >>$(RFILE) echo +jdatadst.obj +jcinit.obj +jcmaster.obj +jcmarker.obj & >>$(RFILE) echo +jcmainct.obj +jcprepct.obj +jccoefct.obj & >>$(RFILE) echo +jccolor.obj +jcsample.obj +jchuff.obj +jcphuff.obj & >>$(RFILE) echo +jcdctmgr.obj +jfdctfst.obj +jfdctflt.obj & >>$(RFILE) echo +jfdctint.obj +jdapimin.obj +jdapistd.obj & >>$(RFILE) echo +jdtrans.obj +jdatasrc.obj +jdmaster.obj +jdinput.obj & >>$(RFILE) echo +jdmarker.obj +jdhuff.obj +jdphuff.obj +jdmainct.obj & >>$(RFILE) echo +jdcoefct.obj +jdpostct.obj +jddctmgr.obj & >>$(RFILE) echo +jidctfst.obj +jidctflt.obj +jidctint.obj & >>$(RFILE) echo +jidctred.obj +jdsample.obj +jdcolor.obj +jquant1.obj & >>$(RFILE) echo +jquant2.obj +jdmerge.obj +jcomapi.obj +jutils.obj & >>$(RFILE) echo +jerror.obj +jmemmgr.obj & >>$(RFILE) echo $(SYSDEPMEMLIB) ; >>$(RFILE) cjpeg.exe: $(COBJECTS) libjpeg.lib echo $(COBJECTS) >cjpeg.lst link /STACK:4096 /EXEPACK @cjpeg.lst, cjpeg.exe, , libjpeg.lib, ; del cjpeg.lst djpeg.exe: $(DOBJECTS) libjpeg.lib echo $(DOBJECTS) >djpeg.lst link /STACK:4096 /EXEPACK @djpeg.lst, djpeg.exe, , libjpeg.lib, ; del djpeg.lst jpegtran.exe: $(TROBJECTS) libjpeg.lib link /STACK:4096 /EXEPACK $(TROBJECTS), jpegtran.exe, , libjpeg.lib, ; rdjpgcom.exe: rdjpgcom.c $(CC) -AS -O -W3 rdjpgcom.c # wrjpgcom needs large model so it can malloc a 64K chunk wrjpgcom.exe: wrjpgcom.c $(CC) -AL -O -W3 wrjpgcom.c jconfig.h: jconfig.doc echo You must prepare a system-dependent jconfig.h file. echo Please read the installation directions in install.doc. exit 1 clean: del *.obj del libjpeg.lib del cjpeg.exe del djpeg.exe del jpegtran.exe del rdjpgcom.exe del wrjpgcom.exe del testout*.* test: cjpeg.exe djpeg.exe jpegtran.exe del testout*.* djpeg -dct int -ppm -outfile testout.ppm testorig.jpg djpeg -dct int -bmp -colors 256 -outfile testout.bmp testorig.jpg cjpeg -dct int -outfile testout.jpg testimg.ppm djpeg -dct int -ppm -outfile testoutp.ppm testprog.jpg cjpeg -dct int -progressive -opt -outfile testoutp.jpg testimg.ppm jpegtran -outfile testoutt.jpg testprog.jpg fc /b testimg.ppm testout.ppm fc /b testimg.bmp testout.bmp fc /b testimg.jpg testout.jpg fc /b testimg.ppm testoutp.ppm fc /b testimgp.jpg testoutp.jpg fc /b testorig.jpg testoutt.jpg jcapimin.obj: jcapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcapistd.obj: jcapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccoefct.obj: jccoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jccolor.obj: jccolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcdctmgr.obj: jcdctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jchuff.obj: jchuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcinit.obj: jcinit.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmainct.obj: jcmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmarker.obj: jcmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcmaster.obj: jcmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcomapi.obj: jcomapi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcparam.obj: jcparam.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcphuff.obj: jcphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jchuff.h jcprepct.obj: jcprepct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jcsample.obj: jcsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jctrans.obj: jctrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapimin.obj: jdapimin.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdapistd.obj: jdapistd.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdatadst.obj: jdatadst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdatasrc.obj: jdatasrc.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h jdcoefct.obj: jdcoefct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdcolor.obj: jdcolor.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jddctmgr.obj: jddctmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jdhuff.obj: jdhuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdinput.obj: jdinput.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmainct.obj: jdmainct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmarker.obj: jdmarker.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmaster.obj: jdmaster.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdmerge.obj: jdmerge.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdphuff.obj: jdphuff.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdhuff.h jdpostct.obj: jdpostct.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdsample.obj: jdsample.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdtrans.obj: jdtrans.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jerror.obj: jerror.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jversion.h jerror.h jfdctflt.obj: jfdctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctfst.obj: jfdctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jfdctint.obj: jfdctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctflt.obj: jidctflt.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctfst.obj: jidctfst.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctint.obj: jidctint.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jidctred.obj: jidctred.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jdct.h jquant1.obj: jquant1.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jquant2.obj: jquant2.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jutils.obj: jutils.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemmgr.obj: jmemmgr.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemansi.obj: jmemansi.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemname.obj: jmemname.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemnobs.obj: jmemnobs.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemdos.obj: jmemdos.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h jmemmac.obj: jmemmac.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h jmemsys.h cjpeg.obj: cjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h djpeg.obj: djpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h jpegtran.obj: jpegtran.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.h jversion.h rdjpgcom.obj: rdjpgcom.c jinclude.h jconfig.h wrjpgcom.obj: wrjpgcom.c jinclude.h jconfig.h cdjpeg.obj: cdjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdcolmap.obj: rdcolmap.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdswitch.obj: rdswitch.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h transupp.obj: transupp.c jinclude.h jconfig.h jpeglib.h jmorecfg.h jpegint.h jerror.h transupp.h rdppm.obj: rdppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrppm.obj: wrppm.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdgif.obj: rdgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrgif.obj: wrgif.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdtarga.obj: rdtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrtarga.obj: wrtarga.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdbmp.obj: rdbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrbmp.obj: wrbmp.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h rdrle.obj: rdrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h wrrle.obj: wrrle.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jmemdosa.obj : jmemdosa.asm masm /mx $*; Papyrus3/JpegDir/JpgLossy/JDAPIMIN.C0000755000175000017500000003135007535143454014140 0ustar /* * jdapimin.c * * Copyright (C) 1994-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains application interface code for the decompression half * of the JPEG library. These are the "minimum" API routines that may be * needed in either the normal full-decompression case or the * transcoding-only case. * * Most of the routines intended to be called directly by an application * are in this file or in jdapistd.c. But also see jcomapi.c for routines * shared by compression and decompression, and jdtrans.c for the transcoding * case. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* * Initialization of a JPEG decompression object. * The error manager must already be set up (in case memory manager fails). */ GLOBAL(void) jpeg_CreateDecompress (j_decompress_ptr cinfo, int version, size_t structsize) { int i; /* Guard against version mismatches between library and caller. */ cinfo->mem = NULL; /* so jpeg_destroy knows mem mgr not called */ if (version != JPEG_LIB_VERSION) ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version); if (structsize != SIZEOF(struct jpeg_decompress_struct)) ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE, (int) SIZEOF(struct jpeg_decompress_struct), (int) structsize); /* For debugging purposes, we zero the whole master structure. * But the application has already set the err pointer, and may have set * client_data, so we have to save and restore those fields. * Note: if application hasn't set client_data, tools like Purify may * complain here. */ { struct jpeg_error_mgr * err = cinfo->err; void * client_data = cinfo->client_data; /* ignore Purify complaint here */ MEMZERO(cinfo, SIZEOF(struct jpeg_decompress_struct)); cinfo->err = err; cinfo->client_data = client_data; } cinfo->is_decompressor = TRUE; /* Initialize a memory manager instance for this object */ jinit_memory_mgr((j_common_ptr) cinfo); /* Zero out pointers to permanent structures. */ cinfo->progress = NULL; cinfo->src = NULL; for (i = 0; i < NUM_QUANT_TBLS; i++) cinfo->quant_tbl_ptrs[i] = NULL; for (i = 0; i < NUM_HUFF_TBLS; i++) { cinfo->dc_huff_tbl_ptrs[i] = NULL; cinfo->ac_huff_tbl_ptrs[i] = NULL; } /* Initialize marker processor so application can override methods * for COM, APPn markers before calling jpeg_read_header. */ cinfo->marker_list = NULL; jinit_marker_reader(cinfo); /* And initialize the overall input controller. */ jinit_input_controller(cinfo); /* OK, I'm ready */ cinfo->global_state = DSTATE_START; } /* * Destruction of a JPEG decompression object */ GLOBAL(void) jpeg_destroy_decompress (j_decompress_ptr cinfo) { jpeg_destroy((j_common_ptr) cinfo); /* use common routine */ } /* * Abort processing of a JPEG decompression operation, * but don't destroy the object itself. */ GLOBAL(void) jpeg_abort_decompress (j_decompress_ptr cinfo) { jpeg_abort((j_common_ptr) cinfo); /* use common routine */ } /* * Set default decompression parameters. */ LOCAL(void) default_decompress_parms (j_decompress_ptr cinfo) { /* Guess the input colorspace, and set output colorspace accordingly. */ /* (Wish JPEG committee had provided a real way to specify this...) */ /* Note application may override our guesses. */ switch (cinfo->num_components) { case 1: cinfo->jpeg_color_space = JCS_GRAYSCALE; cinfo->out_color_space = JCS_GRAYSCALE; break; case 3: if (cinfo->saw_JFIF_marker) { cinfo->jpeg_color_space = JCS_YCbCr; /* JFIF implies YCbCr */ } else if (cinfo->saw_Adobe_marker) { switch (cinfo->Adobe_transform) { case 0: cinfo->jpeg_color_space = JCS_RGB; break; case 1: cinfo->jpeg_color_space = JCS_YCbCr; break; default: WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform); cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */ break; } } else { /* Saw no special markers, try to guess from the component IDs */ int cid0 = cinfo->comp_info[0].component_id; int cid1 = cinfo->comp_info[1].component_id; int cid2 = cinfo->comp_info[2].component_id; if (cid0 == 1 && cid1 == 2 && cid2 == 3) cinfo->jpeg_color_space = JCS_YCbCr; /* assume JFIF w/out marker */ else if (cid0 == 82 && cid1 == 71 && cid2 == 66) cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */ else { TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2); cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */ } } /* Always guess RGB is proper output colorspace. */ cinfo->out_color_space = JCS_RGB; break; case 4: if (cinfo->saw_Adobe_marker) { switch (cinfo->Adobe_transform) { case 0: cinfo->jpeg_color_space = JCS_CMYK; break; case 2: cinfo->jpeg_color_space = JCS_YCCK; break; default: WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform); cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */ break; } } else { /* No special markers, assume straight CMYK. */ cinfo->jpeg_color_space = JCS_CMYK; } cinfo->out_color_space = JCS_CMYK; break; default: cinfo->jpeg_color_space = JCS_UNKNOWN; cinfo->out_color_space = JCS_UNKNOWN; break; } /* Set defaults for other decompression parameters. */ cinfo->scale_num = 1; /* 1:1 scaling */ cinfo->scale_denom = 1; cinfo->output_gamma = 1.0; cinfo->buffered_image = FALSE; cinfo->raw_data_out = FALSE; cinfo->dct_method = JDCT_DEFAULT; cinfo->do_fancy_upsampling = TRUE; cinfo->do_block_smoothing = TRUE; cinfo->quantize_colors = FALSE; /* We set these in case application only sets quantize_colors. */ cinfo->dither_mode = JDITHER_FS; #ifdef QUANT_2PASS_SUPPORTED cinfo->two_pass_quantize = TRUE; #else cinfo->two_pass_quantize = FALSE; #endif cinfo->desired_number_of_colors = 256; cinfo->colormap = NULL; /* Initialize for no mode change in buffered-image mode. */ cinfo->enable_1pass_quant = FALSE; cinfo->enable_external_quant = FALSE; cinfo->enable_2pass_quant = FALSE; } /* * Decompression startup: read start of JPEG datastream to see what's there. * Need only initialize JPEG object and supply a data source before calling. * * This routine will read as far as the first SOS marker (ie, actual start of * compressed data), and will save all tables and parameters in the JPEG * object. It will also initialize the decompression parameters to default * values, and finally return JPEG_HEADER_OK. On return, the application may * adjust the decompression parameters and then call jpeg_start_decompress. * (Or, if the application only wanted to determine the image parameters, * the data need not be decompressed. In that case, call jpeg_abort or * jpeg_destroy to release any temporary space.) * If an abbreviated (tables only) datastream is presented, the routine will * return JPEG_HEADER_TABLES_ONLY upon reaching EOI. The application may then * re-use the JPEG object to read the abbreviated image datastream(s). * It is unnecessary (but OK) to call jpeg_abort in this case. * The JPEG_SUSPENDED return code only occurs if the data source module * requests suspension of the decompressor. In this case the application * should load more source data and then re-call jpeg_read_header to resume * processing. * If a non-suspending data source is used and require_image is TRUE, then the * return code need not be inspected since only JPEG_HEADER_OK is possible. * * This routine is now just a front end to jpeg_consume_input, with some * extra error checking. */ GLOBAL(int) jpeg_read_header (j_decompress_ptr cinfo, boolean require_image) { int retcode; if (cinfo->global_state != DSTATE_START && cinfo->global_state != DSTATE_INHEADER) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); retcode = jpeg_consume_input(cinfo); switch (retcode) { case JPEG_REACHED_SOS: retcode = JPEG_HEADER_OK; break; case JPEG_REACHED_EOI: if (require_image) /* Complain if application wanted an image */ ERREXIT(cinfo, JERR_NO_IMAGE); /* Reset to start state; it would be safer to require the application to * call jpeg_abort, but we can't change it now for compatibility reasons. * A side effect is to free any temporary memory (there shouldn't be any). */ jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */ retcode = JPEG_HEADER_TABLES_ONLY; break; case JPEG_SUSPENDED: /* no work */ break; } return retcode; } /* * Consume data in advance of what the decompressor requires. * This can be called at any time once the decompressor object has * been created and a data source has been set up. * * This routine is essentially a state machine that handles a couple * of critical state-transition actions, namely initial setup and * transition from header scanning to ready-for-start_decompress. * All the actual input is done via the input controller's consume_input * method. */ GLOBAL(int) jpeg_consume_input (j_decompress_ptr cinfo) { int retcode = JPEG_SUSPENDED; /* NB: every possible DSTATE value should be listed in this switch */ switch (cinfo->global_state) { case DSTATE_START: /* Start-of-datastream actions: reset appropriate modules */ (*cinfo->inputctl->reset_input_controller) (cinfo); /* Initialize application's data source module */ (*cinfo->src->init_source) (cinfo); cinfo->global_state = DSTATE_INHEADER; /*FALLTHROUGH*/ case DSTATE_INHEADER: retcode = (*cinfo->inputctl->consume_input) (cinfo); if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */ /* Set up default parameters based on header data */ default_decompress_parms(cinfo); /* Set global state: ready for start_decompress */ cinfo->global_state = DSTATE_READY; } break; case DSTATE_READY: /* Can't advance past first SOS until start_decompress is called */ retcode = JPEG_REACHED_SOS; break; case DSTATE_PRELOAD: case DSTATE_PRESCAN: case DSTATE_SCANNING: case DSTATE_RAW_OK: case DSTATE_BUFIMAGE: case DSTATE_BUFPOST: case DSTATE_STOPPING: retcode = (*cinfo->inputctl->consume_input) (cinfo); break; default: ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); } return retcode; } /* * Have we finished reading the input file? */ GLOBAL(boolean) jpeg_input_complete (j_decompress_ptr cinfo) { /* Check for valid jpeg object */ if (cinfo->global_state < DSTATE_START || cinfo->global_state > DSTATE_STOPPING) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); return cinfo->inputctl->eoi_reached; } /* * Is there more than one scan? */ GLOBAL(boolean) jpeg_has_multiple_scans (j_decompress_ptr cinfo) { /* Only valid after jpeg_read_header completes */ if (cinfo->global_state < DSTATE_READY || cinfo->global_state > DSTATE_STOPPING) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); return cinfo->inputctl->has_multiple_scans; } /* * Finish JPEG decompression. * * This will normally just verify the file trailer and release temp storage. * * Returns FALSE if suspended. The return value need be inspected only if * a suspending data source is used. */ GLOBAL(boolean) jpeg_finish_decompress (j_decompress_ptr cinfo) { if ((cinfo->global_state == DSTATE_SCANNING || cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) { /* Terminate final pass of non-buffered mode */ if (cinfo->output_scanline < cinfo->output_height) ERREXIT(cinfo, JERR_TOO_LITTLE_DATA); (*cinfo->master->finish_output_pass) (cinfo); cinfo->global_state = DSTATE_STOPPING; } else if (cinfo->global_state == DSTATE_BUFIMAGE) { /* Finishing after a buffered-image operation */ cinfo->global_state = DSTATE_STOPPING; } else if (cinfo->global_state != DSTATE_STOPPING) { /* STOPPING = repeat call after a suspension, anything else is error */ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); } /* Read until EOI */ while (! cinfo->inputctl->eoi_reached) { if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED) return FALSE; /* Suspend, come back later */ } /* Do final cleanup */ (*cinfo->src->term_source) (cinfo); /* We can use jpeg_abort to release memory and reset global_state */ jpeg_abort((j_common_ptr) cinfo); return TRUE; } Papyrus3/JpegDir/JpgLossy/JMEMDOS.C0000755000175000017500000004623707535143454014055 0ustar /* * jmemdos.c * * Copyright (C) 1992-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file provides an MS-DOS-compatible implementation of the system- * dependent portion of the JPEG memory manager. Temporary data can be * stored in extended or expanded memory as well as in regular DOS files. * * If you use this file, you must be sure that NEED_FAR_POINTERS is defined * if you compile in a small-data memory model; it should NOT be defined if * you use a large-data memory model. This file is not recommended if you * are using a flat-memory-space 386 environment such as DJGCC or Watcom C. * Also, this code will NOT work if struct fields are aligned on greater than * 2-byte boundaries. * * Based on code contributed by Ge' Weijers. */ /* * If you have both extended and expanded memory, you may want to change the * order in which they are tried in jopen_backing_store. On a 286 machine * expanded memory is usually faster, since extended memory access involves * an expensive protected-mode-and-back switch. On 386 and better, extended * memory is usually faster. As distributed, the code tries extended memory * first (what? not everyone has a 386? :-). * * You can disable use of extended/expanded memory entirely by altering these * definitions or overriding them from the Makefile (eg, -DEMS_SUPPORTED=0). */ #ifndef XMS_SUPPORTED #define XMS_SUPPORTED 1 #endif #ifndef EMS_SUPPORTED #define EMS_SUPPORTED 1 #endif #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" #include "jmemsys.h" /* import the system-dependent declarations */ #ifndef HAVE_STDLIB_H /* should declare these */ extern void * malloc JPP((size_t size)); extern void free JPP((void *ptr)); extern char * getenv JPP((const char * name)); #endif #ifdef NEED_FAR_POINTERS #ifdef __TURBOC__ /* These definitions work for Borland C (Turbo C) */ #include /* need farmalloc(), farfree() */ #define far_malloc(x) farmalloc(x) #define far_free(x) farfree(x) #else /* These definitions work for Microsoft C and compatible compilers */ #include /* need _fmalloc(), _ffree() */ #define far_malloc(x) _fmalloc(x) #define far_free(x) _ffree(x) #endif #else /* not NEED_FAR_POINTERS */ #define far_malloc(x) malloc(x) #define far_free(x) free(x) #endif /* NEED_FAR_POINTERS */ #ifdef DONT_USE_B_MODE /* define mode parameters for fopen() */ #define READ_BINARY "r" #else #define READ_BINARY "rb" #endif #ifndef USE_MSDOS_MEMMGR /* make sure user got configuration right */ You forgot to define USE_MSDOS_MEMMGR in jconfig.h. /* deliberate syntax error */ #endif #if MAX_ALLOC_CHUNK >= 65535L /* make sure jconfig.h got this right */ MAX_ALLOC_CHUNK should be less than 64K. /* deliberate syntax error */ #endif /* * Declarations for assembly-language support routines (see jmemdosa.asm). * * The functions are declared "far" as are all their pointer arguments; * this ensures the assembly source code will work regardless of the * compiler memory model. We assume "short" is 16 bits, "long" is 32. */ typedef void far * XMSDRIVER; /* actually a pointer to code */ typedef struct { /* registers for calling XMS driver */ unsigned short ax, dx, bx; void far * ds_si; } XMScontext; typedef struct { /* registers for calling EMS driver */ unsigned short ax, dx, bx; void far * ds_si; } EMScontext; extern short far jdos_open JPP((short far * handle, char far * filename)); extern short far jdos_close JPP((short handle)); extern short far jdos_seek JPP((short handle, long offset)); extern short far jdos_read JPP((short handle, void far * buffer, unsigned short count)); extern short far jdos_write JPP((short handle, void far * buffer, unsigned short count)); extern void far jxms_getdriver JPP((XMSDRIVER far *)); extern void far jxms_calldriver JPP((XMSDRIVER, XMScontext far *)); extern short far jems_available JPP((void)); extern void far jems_calldriver JPP((EMScontext far *)); /* * Selection of a file name for a temporary file. * This is highly system-dependent, and you may want to customize it. */ static int next_file_num; /* to distinguish among several temp files */ LOCAL(void) select_file_name (char * fname) { const char * env; char * ptr; FILE * tfile; /* Keep generating file names till we find one that's not in use */ for (;;) { /* Get temp directory name from environment TMP or TEMP variable; * if none, use "." */ if ((env = (const char *) getenv("TMP")) == NULL) if ((env = (const char *) getenv("TEMP")) == NULL) env = "."; if (*env == '\0') /* null string means "." */ env = "."; ptr = fname; /* copy name to fname */ while (*env != '\0') *ptr++ = *env++; if (ptr[-1] != '\\' && ptr[-1] != '/') *ptr++ = '\\'; /* append backslash if not in env variable */ /* Append a suitable file name */ next_file_num++; /* advance counter */ sprintf(ptr, "JPG%03d.TMP", next_file_num); /* Probe to see if file name is already in use */ if ((tfile = fopen(fname, READ_BINARY)) == NULL) break; fclose(tfile); /* oops, it's there; close tfile & try again */ } } /* * Near-memory allocation and freeing are controlled by the regular library * routines malloc() and free(). */ GLOBAL(void *) jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject) { return (void *) malloc(sizeofobject); } GLOBAL(void) jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject) { free(object); } /* * "Large" objects are allocated in far memory, if possible */ GLOBAL(void FAR *) jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject) { return (void FAR *) far_malloc(sizeofobject); } GLOBAL(void) jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject) { far_free(object); } /* * This routine computes the total memory space available for allocation. * It's impossible to do this in a portable way; our current solution is * to make the user tell us (with a default value set at compile time). * If you can actually get the available space, it's a good idea to subtract * a slop factor of 5% or so. */ #ifndef DEFAULT_MAX_MEM /* so can override from makefile */ #define DEFAULT_MAX_MEM 300000L /* for total usage about 450K */ #endif GLOBAL(long) jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed, long max_bytes_needed, long already_allocated) { return cinfo->mem->max_memory_to_use - already_allocated; } /* * Backing store (temporary file) management. * Backing store objects are only used when the value returned by * jpeg_mem_available is less than the total space needed. You can dispense * with these routines if you have plenty of virtual memory; see jmemnobs.c. */ /* * For MS-DOS we support three types of backing storage: * 1. Conventional DOS files. We access these by direct DOS calls rather * than via the stdio package. This provides a bit better performance, * but the real reason is that the buffers to be read or written are FAR. * The stdio library for small-data memory models can't cope with that. * 2. Extended memory, accessed per the XMS V2.0 specification. * 3. Expanded memory, accessed per the LIM/EMS 4.0 specification. * You'll need copies of those specs to make sense of the related code. * The specs are available by Internet FTP from the SIMTEL archives * (oak.oakland.edu and its various mirror sites). See files * pub/msdos/microsoft/xms20.arc and pub/msdos/info/limems41.zip. */ /* * Access methods for a DOS file. */ METHODDEF(void) read_file_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { if (jdos_seek(info->handle.file_handle, file_offset)) ERREXIT(cinfo, JERR_TFILE_SEEK); /* Since MAX_ALLOC_CHUNK is less than 64K, byte_count will be too. */ if (byte_count > 65535L) /* safety check */ ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK); if (jdos_read(info->handle.file_handle, buffer_address, (unsigned short) byte_count)) ERREXIT(cinfo, JERR_TFILE_READ); } METHODDEF(void) write_file_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { if (jdos_seek(info->handle.file_handle, file_offset)) ERREXIT(cinfo, JERR_TFILE_SEEK); /* Since MAX_ALLOC_CHUNK is less than 64K, byte_count will be too. */ if (byte_count > 65535L) /* safety check */ ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK); if (jdos_write(info->handle.file_handle, buffer_address, (unsigned short) byte_count)) ERREXIT(cinfo, JERR_TFILE_WRITE); } METHODDEF(void) close_file_store (j_common_ptr cinfo, backing_store_ptr info) { jdos_close(info->handle.file_handle); /* close the file */ remove(info->temp_name); /* delete the file */ /* If your system doesn't have remove(), try unlink() instead. * remove() is the ANSI-standard name for this function, but * unlink() was more common in pre-ANSI systems. */ TRACEMSS(cinfo, 1, JTRC_TFILE_CLOSE, info->temp_name); } LOCAL(boolean) open_file_store (j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed) { short handle; select_file_name(info->temp_name); if (jdos_open((short far *) & handle, (char far *) info->temp_name)) { /* might as well exit since jpeg_open_backing_store will fail anyway */ ERREXITS(cinfo, JERR_TFILE_CREATE, info->temp_name); return FALSE; } info->handle.file_handle = handle; info->read_backing_store = read_file_store; info->write_backing_store = write_file_store; info->close_backing_store = close_file_store; TRACEMSS(cinfo, 1, JTRC_TFILE_OPEN, info->temp_name); return TRUE; /* succeeded */ } /* * Access methods for extended memory. */ #if XMS_SUPPORTED static XMSDRIVER xms_driver; /* saved address of XMS driver */ typedef union { /* either long offset or real-mode pointer */ long offset; void far * ptr; } XMSPTR; typedef struct { /* XMS move specification structure */ long length; XMSH src_handle; XMSPTR src; XMSH dst_handle; XMSPTR dst; } XMSspec; #define ODD(X) (((X) & 1L) != 0) METHODDEF(void) read_xms_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { XMScontext ctx; XMSspec spec; char endbuffer[2]; /* The XMS driver can't cope with an odd length, so handle the last byte * specially if byte_count is odd. We don't expect this to be common. */ spec.length = byte_count & (~ 1L); spec.src_handle = info->handle.xms_handle; spec.src.offset = file_offset; spec.dst_handle = 0; spec.dst.ptr = buffer_address; ctx.ds_si = (void far *) & spec; ctx.ax = 0x0b00; /* EMB move */ jxms_calldriver(xms_driver, (XMScontext far *) & ctx); if (ctx.ax != 1) ERREXIT(cinfo, JERR_XMS_READ); if (ODD(byte_count)) { read_xms_store(cinfo, info, (void FAR *) endbuffer, file_offset + byte_count - 1L, 2L); ((char FAR *) buffer_address)[byte_count - 1L] = endbuffer[0]; } } METHODDEF(void) write_xms_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { XMScontext ctx; XMSspec spec; char endbuffer[2]; /* The XMS driver can't cope with an odd length, so handle the last byte * specially if byte_count is odd. We don't expect this to be common. */ spec.length = byte_count & (~ 1L); spec.src_handle = 0; spec.src.ptr = buffer_address; spec.dst_handle = info->handle.xms_handle; spec.dst.offset = file_offset; ctx.ds_si = (void far *) & spec; ctx.ax = 0x0b00; /* EMB move */ jxms_calldriver(xms_driver, (XMScontext far *) & ctx); if (ctx.ax != 1) ERREXIT(cinfo, JERR_XMS_WRITE); if (ODD(byte_count)) { read_xms_store(cinfo, info, (void FAR *) endbuffer, file_offset + byte_count - 1L, 2L); endbuffer[0] = ((char FAR *) buffer_address)[byte_count - 1L]; write_xms_store(cinfo, info, (void FAR *) endbuffer, file_offset + byte_count - 1L, 2L); } } METHODDEF(void) close_xms_store (j_common_ptr cinfo, backing_store_ptr info) { XMScontext ctx; ctx.dx = info->handle.xms_handle; ctx.ax = 0x0a00; jxms_calldriver(xms_driver, (XMScontext far *) & ctx); TRACEMS1(cinfo, 1, JTRC_XMS_CLOSE, info->handle.xms_handle); /* we ignore any error return from the driver */ } LOCAL(boolean) open_xms_store (j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed) { XMScontext ctx; /* Get address of XMS driver */ jxms_getdriver((XMSDRIVER far *) & xms_driver); if (xms_driver == NULL) return FALSE; /* no driver to be had */ /* Get version number, must be >= 2.00 */ ctx.ax = 0x0000; jxms_calldriver(xms_driver, (XMScontext far *) & ctx); if (ctx.ax < (unsigned short) 0x0200) return FALSE; /* Try to get space (expressed in kilobytes) */ ctx.dx = (unsigned short) ((total_bytes_needed + 1023L) >> 10); ctx.ax = 0x0900; jxms_calldriver(xms_driver, (XMScontext far *) & ctx); if (ctx.ax != 1) return FALSE; /* Succeeded, save the handle and away we go */ info->handle.xms_handle = ctx.dx; info->read_backing_store = read_xms_store; info->write_backing_store = write_xms_store; info->close_backing_store = close_xms_store; TRACEMS1(cinfo, 1, JTRC_XMS_OPEN, ctx.dx); return TRUE; /* succeeded */ } #endif /* XMS_SUPPORTED */ /* * Access methods for expanded memory. */ #if EMS_SUPPORTED /* The EMS move specification structure requires word and long fields aligned * at odd byte boundaries. Some compilers will align struct fields at even * byte boundaries. While it's usually possible to force byte alignment, * that causes an overall performance penalty and may pose problems in merging * JPEG into a larger application. Instead we accept some rather dirty code * here. Note this code would fail if the hardware did not allow odd-byte * word & long accesses, but all 80x86 CPUs do. */ typedef void far * EMSPTR; typedef union { /* EMS move specification structure */ long length; /* It's easy to access first 4 bytes */ char bytes[18]; /* Misaligned fields in here! */ } EMSspec; /* Macros for accessing misaligned fields */ #define FIELD_AT(spec,offset,type) (*((type *) &(spec.bytes[offset]))) #define SRC_TYPE(spec) FIELD_AT(spec,4,char) #define SRC_HANDLE(spec) FIELD_AT(spec,5,EMSH) #define SRC_OFFSET(spec) FIELD_AT(spec,7,unsigned short) #define SRC_PAGE(spec) FIELD_AT(spec,9,unsigned short) #define SRC_PTR(spec) FIELD_AT(spec,7,EMSPTR) #define DST_TYPE(spec) FIELD_AT(spec,11,char) #define DST_HANDLE(spec) FIELD_AT(spec,12,EMSH) #define DST_OFFSET(spec) FIELD_AT(spec,14,unsigned short) #define DST_PAGE(spec) FIELD_AT(spec,16,unsigned short) #define DST_PTR(spec) FIELD_AT(spec,14,EMSPTR) #define EMSPAGESIZE 16384L /* gospel, see the EMS specs */ #define HIBYTE(W) (((W) >> 8) & 0xFF) #define LOBYTE(W) ((W) & 0xFF) METHODDEF(void) read_ems_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { EMScontext ctx; EMSspec spec; spec.length = byte_count; SRC_TYPE(spec) = 1; SRC_HANDLE(spec) = info->handle.ems_handle; SRC_PAGE(spec) = (unsigned short) (file_offset / EMSPAGESIZE); SRC_OFFSET(spec) = (unsigned short) (file_offset % EMSPAGESIZE); DST_TYPE(spec) = 0; DST_HANDLE(spec) = 0; DST_PTR(spec) = buffer_address; ctx.ds_si = (void far *) & spec; ctx.ax = 0x5700; /* move memory region */ jems_calldriver((EMScontext far *) & ctx); if (HIBYTE(ctx.ax) != 0) ERREXIT(cinfo, JERR_EMS_READ); } METHODDEF(void) write_ems_store (j_common_ptr cinfo, backing_store_ptr info, void FAR * buffer_address, long file_offset, long byte_count) { EMScontext ctx; EMSspec spec; spec.length = byte_count; SRC_TYPE(spec) = 0; SRC_HANDLE(spec) = 0; SRC_PTR(spec) = buffer_address; DST_TYPE(spec) = 1; DST_HANDLE(spec) = info->handle.ems_handle; DST_PAGE(spec) = (unsigned short) (file_offset / EMSPAGESIZE); DST_OFFSET(spec) = (unsigned short) (file_offset % EMSPAGESIZE); ctx.ds_si = (void far *) & spec; ctx.ax = 0x5700; /* move memory region */ jems_calldriver((EMScontext far *) & ctx); if (HIBYTE(ctx.ax) != 0) ERREXIT(cinfo, JERR_EMS_WRITE); } METHODDEF(void) close_ems_store (j_common_ptr cinfo, backing_store_ptr info) { EMScontext ctx; ctx.ax = 0x4500; ctx.dx = info->handle.ems_handle; jems_calldriver((EMScontext far *) & ctx); TRACEMS1(cinfo, 1, JTRC_EMS_CLOSE, info->handle.ems_handle); /* we ignore any error return from the driver */ } LOCAL(boolean) open_ems_store (j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed) { EMScontext ctx; /* Is EMS driver there? */ if (! jems_available()) return FALSE; /* Get status, make sure EMS is OK */ ctx.ax = 0x4000; jems_calldriver((EMScontext far *) & ctx); if (HIBYTE(ctx.ax) != 0) return FALSE; /* Get version, must be >= 4.0 */ ctx.ax = 0x4600; jems_calldriver((EMScontext far *) & ctx); if (HIBYTE(ctx.ax) != 0 || LOBYTE(ctx.ax) < 0x40) return FALSE; /* Try to allocate requested space */ ctx.ax = 0x4300; ctx.bx = (unsigned short) ((total_bytes_needed + EMSPAGESIZE-1L) / EMSPAGESIZE); jems_calldriver((EMScontext far *) & ctx); if (HIBYTE(ctx.ax) != 0) return FALSE; /* Succeeded, save the handle and away we go */ info->handle.ems_handle = ctx.dx; info->read_backing_store = read_ems_store; info->write_backing_store = write_ems_store; info->close_backing_store = close_ems_store; TRACEMS1(cinfo, 1, JTRC_EMS_OPEN, ctx.dx); return TRUE; /* succeeded */ } #endif /* EMS_SUPPORTED */ /* * Initial opening of a backing-store object. */ GLOBAL(void) jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info, long total_bytes_needed) { /* Try extended memory, then expanded memory, then regular file. */ #if XMS_SUPPORTED if (open_xms_store(cinfo, info, total_bytes_needed)) return; #endif #if EMS_SUPPORTED if (open_ems_store(cinfo, info, total_bytes_needed)) return; #endif if (open_file_store(cinfo, info, total_bytes_needed)) return; ERREXITS(cinfo, JERR_TFILE_CREATE, ""); } /* * These routines take care of any system-dependent initialization and * cleanup required. */ GLOBAL(long) jpeg_mem_init (j_common_ptr cinfo) { next_file_num = 0; /* initialize temp file name generator */ return DEFAULT_MAX_MEM; /* default for max_memory_to_use */ } GLOBAL(void) jpeg_mem_term (j_common_ptr cinfo) { /* Microsoft C, at least in v6.00A, will not successfully reclaim freed * blocks of size > 32Kbytes unless we give it a kick in the rear, like so: */ #ifdef NEED_FHEAPMIN _fheapmin(); #endif } Papyrus3/JpegDir/JpgLossy/CDJPEG.H0000755000175000017500000001426307535143454013712 0ustar /* * cdjpeg.h * * Copyright (C) 1994-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains common declarations for the sample applications * cjpeg and djpeg. It is NOT used by the core JPEG library. */ #define JPEG_CJPEG_DJPEG /* define proper options in jconfig.h */ #define JPEG_INTERNAL_OPTIONS /* cjpeg.c,djpeg.c need to see xxx_SUPPORTED */ #include "jinclude.h" #include "jpeglib.h" #include "jerror.h" /* get library error codes too */ #include "cderror.h" /* get application-specific error codes */ /* * Object interface for cjpeg's source file decoding modules */ typedef struct cjpeg_source_struct * cjpeg_source_ptr; struct cjpeg_source_struct { JMETHOD(void, start_input, (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)); JMETHOD(JDIMENSION, get_pixel_rows, (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)); JMETHOD(void, finish_input, (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)); PAPY_FILE input_file; JSAMPARRAY buffer; JDIMENSION buffer_height; }; /* * Object interface for djpeg's output file encoding modules */ typedef struct djpeg_dest_struct * djpeg_dest_ptr; struct djpeg_dest_struct { /* start_output is called after jpeg_start_decompress finishes. * The color map will be ready at this time, if one is needed. */ JMETHOD(void, start_output, (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)); /* Emit the specified number of pixel rows from the buffer. */ JMETHOD(void, put_pixel_rows, (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, JDIMENSION rows_supplied)); /* Finish up at the end of the image. */ JMETHOD(void, finish_output, (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)); /* Target file spec; filled in by djpeg.c after object is created. */ PAPY_FILE output_file; /* Output pixel-row buffer. Created by module init or start_output. * Width is cinfo->output_width * cinfo->output_components; * height is buffer_height. */ JSAMPARRAY buffer; JDIMENSION buffer_height; }; /* * cjpeg/djpeg may need to perform extra passes to convert to or from * the source/destination file format. The JPEG library does not know * about these passes, but we'd like them to be counted by the progress * monitor. We use an expanded progress monitor object to hold the * additional pass count. */ struct cdjpeg_progress_mgr { struct jpeg_progress_mgr pub; /* fields known to JPEG library */ int completed_extra_passes; /* extra passes completed */ int total_extra_passes; /* total extra */ /* last printed percentage stored here to avoid multiple printouts */ int percent_done; }; typedef struct cdjpeg_progress_mgr * cd_progress_ptr; /* Short forms of external names for systems with brain-damaged linkers. */ #ifdef NEED_SHORT_EXTERNAL_NAMES #define jinit_read_bmp jIRdBMP #define jinit_write_bmp jIWrBMP #define jinit_read_gif jIRdGIF #define jinit_write_gif jIWrGIF #define jinit_read_ppm jIRdPPM #define jinit_write_ppm jIWrPPM #define jinit_read_rle jIRdRLE #define jinit_write_rle jIWrRLE #define jinit_read_targa jIRdTarga #define jinit_write_targa jIWrTarga #define read_quant_tables RdQTables #define read_scan_script RdScnScript #define set_quant_slots SetQSlots #define set_sample_factors SetSFacts #define read_color_map RdCMap #define enable_signal_catcher EnSigCatcher #define start_progress_monitor StProgMon #define end_progress_monitor EnProgMon #define read_stdin RdStdin #define write_stdout WrStdout #endif /* NEED_SHORT_EXTERNAL_NAMES */ /* Module selection routines for I/O modules. */ EXTERN(cjpeg_source_ptr) jinit_read_bmp JPP((j_compress_ptr cinfo)); EXTERN(djpeg_dest_ptr) jinit_write_bmp JPP((j_decompress_ptr cinfo, boolean is_os2)); EXTERN(cjpeg_source_ptr) jinit_read_gif JPP((j_compress_ptr cinfo)); EXTERN(djpeg_dest_ptr) jinit_write_gif JPP((j_decompress_ptr cinfo)); EXTERN(cjpeg_source_ptr) jinit_read_ppm JPP((j_compress_ptr cinfo)); EXTERN(djpeg_dest_ptr) jinit_write_ppm JPP((j_decompress_ptr cinfo)); EXTERN(cjpeg_source_ptr) jinit_read_rle JPP((j_compress_ptr cinfo)); EXTERN(djpeg_dest_ptr) jinit_write_rle JPP((j_decompress_ptr cinfo)); EXTERN(cjpeg_source_ptr) jinit_read_targa JPP((j_compress_ptr cinfo)); EXTERN(djpeg_dest_ptr) jinit_write_targa JPP((j_decompress_ptr cinfo)); /* cjpeg support routines (in rdswitch.c) */ EXTERN(boolean) read_quant_tables JPP((j_compress_ptr cinfo, char * filename, int scale_factor, boolean force_baseline)); EXTERN(boolean) read_scan_script JPP((j_compress_ptr cinfo, char * filename)); EXTERN(boolean) set_quant_slots JPP((j_compress_ptr cinfo, char *arg)); EXTERN(boolean) set_sample_factors JPP((j_compress_ptr cinfo, char *arg)); /* djpeg support routines (in rdcolmap.c) */ EXTERN(void) read_color_map JPP((j_decompress_ptr cinfo, PAPY_FILE infile)); /* common support routines (in cdjpeg.c) */ EXTERN(void) enable_signal_catcher JPP((j_common_ptr cinfo)); EXTERN(void) start_progress_monitor JPP((j_common_ptr cinfo, cd_progress_ptr progress)); EXTERN(void) end_progress_monitor JPP((j_common_ptr cinfo)); EXTERN(boolean) keymatch JPP((char * arg, const char * keyword, int minchars)); EXTERN(PAPY_FILE) read_stdin JPP((void)); EXTERN(PAPY_FILE) write_stdout JPP((void)); /* miscellaneous useful macros */ #ifdef DONT_USE_B_MODE /* define mode parameters for fopen() */ #define READ_BINARY "r" #define WRITE_BINARY "w" #else #ifdef VMS /* VMS is very nonstandard */ #define READ_BINARY "rb", "ctx=stm" #define WRITE_BINARY "wb", "ctx=stm" #else /* standard ANSI-compliant case */ #define READ_BINARY "rb" #define WRITE_BINARY "wb" #endif #endif #ifndef EXIT_FAILURE /* define exit() codes if not provided */ #define EXIT_FAILURE 1 #endif #ifndef EXIT_SUCCESS #ifdef VMS #define EXIT_SUCCESS 1 /* VMS is very nonstandard */ #else #define EXIT_SUCCESS 0 #endif #endif #ifndef EXIT_WARNING #ifdef VMS #define EXIT_WARNING 1 /* VMS is very nonstandard */ #else #define EXIT_WARNING 2 #endif #endif Papyrus3/JpegDir/JpgLossy/DJPEG.C0000755000175000017500000004676307535143454013614 0ustar /* * djpeg.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains a command-line user interface for the JPEG decompressor. * It should work on any system with Unix- or MS-DOS-style command lines. * * Two different command line styles are permitted, depending on the * compile-time switch TWO_FILE_COMMANDLINE: * djpeg [options] inputfile outputfile * djpeg [options] [inputfile] * In the second style, output is always to standard output, which you'd * normally redirect to a file or pipe to some other program. Input is * either from a named file or from standard input (typically redirected). * The second style is convenient on Unix but is unhelpful on systems that * don't support pipes. Also, you MUST use the first style if your system * doesn't do binary I/O to stdin/stdout. * To simplify script writing, the "-outfile" switch is provided. The syntax * djpeg [options] -outfile outputfile inputfile * works regardless of which command line style is used. */ #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ #include "jversion.h" /* for version message */ #include /* to declare isprint() */ #ifdef USE_CCOMMAND /* command-line reader for Macintosh */ #ifdef __MWERKS__ #include /* Metrowerks needs this */ #include /* ... and this */ #endif #ifdef THINK_C #include /* Think declares it here */ #endif #endif /* Create the add-on message string table. */ #define JMESSAGE(code,string) string , static const char * const cdjpeg_message_table[] = { #include "cderror.h" NULL }; /* * This list defines the known output image formats * (not all of which need be supported by a given version). * You can change the default output format by defining DEFAULT_FMT; * indeed, you had better do so if you undefine PPM_SUPPORTED. */ typedef enum { FMT_BMP, /* BMP format (Windows flavor) */ FMT_GIF, /* GIF format */ FMT_OS2, /* BMP format (OS/2 flavor) */ FMT_PPM, /* PPM/PGM (PBMPLUS formats) */ FMT_RLE, /* RLE format */ FMT_TARGA, /* Targa format */ FMT_TIFF /* TIFF format */ } IMAGE_FORMATS; #ifndef DEFAULT_FMT /* so can override from CFLAGS in Makefile */ #define DEFAULT_FMT FMT_PPM #endif static IMAGE_FORMATS requested_fmt; /* * Argument-parsing code. * The switch parser is designed to be useful with DOS-style command line * syntax, ie, intermixed switches and file names, where only the switches * to the left of a given file name affect processing of that file. * The main program in this file doesn't actually use this capability... */ static const char * progname; /* program name for error messages */ static char * outfilename; /* for -outfile switch */ LOCAL(void) usage (void) /* complain about bad command line */ { fprintf(stderr, "usage: %s [switches] ", progname); #ifdef TWO_FILE_COMMANDLINE fprintf(stderr, "inputfile outputfile\n"); #else fprintf(stderr, "[inputfile]\n"); #endif fprintf(stderr, "Switches (names may be abbreviated):\n"); fprintf(stderr, " -colors N Reduce image to no more than N colors\n"); fprintf(stderr, " -fast Fast, low-quality processing\n"); fprintf(stderr, " -grayscale Force grayscale output\n"); #ifdef IDCT_SCALING_SUPPORTED fprintf(stderr, " -scale M/N Scale output image by fraction M/N, eg, 1/8\n"); #endif #ifdef BMP_SUPPORTED fprintf(stderr, " -bmp Select BMP output format (Windows style)%s\n", (DEFAULT_FMT == FMT_BMP ? " (default)" : "")); #endif #ifdef GIF_SUPPORTED fprintf(stderr, " -gif Select GIF output format%s\n", (DEFAULT_FMT == FMT_GIF ? " (default)" : "")); #endif #ifdef BMP_SUPPORTED fprintf(stderr, " -os2 Select BMP output format (OS/2 style)%s\n", (DEFAULT_FMT == FMT_OS2 ? " (default)" : "")); #endif #ifdef PPM_SUPPORTED fprintf(stderr, " -pnm Select PBMPLUS (PPM/PGM) output format%s\n", (DEFAULT_FMT == FMT_PPM ? " (default)" : "")); #endif #ifdef RLE_SUPPORTED fprintf(stderr, " -rle Select Utah RLE output format%s\n", (DEFAULT_FMT == FMT_RLE ? " (default)" : "")); #endif #ifdef TARGA_SUPPORTED fprintf(stderr, " -targa Select Targa output format%s\n", (DEFAULT_FMT == FMT_TARGA ? " (default)" : "")); #endif fprintf(stderr, "Switches for advanced users:\n"); #ifdef DCT_ISLOW_SUPPORTED fprintf(stderr, " -dct int Use integer DCT method%s\n", (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : "")); #endif #ifdef DCT_IFAST_SUPPORTED fprintf(stderr, " -dct fast Use fast integer DCT (less accurate)%s\n", (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : "")); #endif #ifdef DCT_FLOAT_SUPPORTED fprintf(stderr, " -dct float Use floating-point DCT method%s\n", (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : "")); #endif fprintf(stderr, " -dither fs Use F-S dithering (default)\n"); fprintf(stderr, " -dither none Don't use dithering in quantization\n"); fprintf(stderr, " -dither ordered Use ordered dither (medium speed, quality)\n"); #ifdef QUANT_2PASS_SUPPORTED fprintf(stderr, " -map FILE Map to colors used in named image file\n"); #endif fprintf(stderr, " -nosmooth Don't use high-quality upsampling\n"); #ifdef QUANT_1PASS_SUPPORTED fprintf(stderr, " -onepass Use 1-pass quantization (fast, low quality)\n"); #endif fprintf(stderr, " -maxmemory N Maximum memory to use (in kbytes)\n"); fprintf(stderr, " -outfile name Specify name for output file\n"); fprintf(stderr, " -verbose or -debug Emit debug output\n"); exit(EXIT_FAILURE); } LOCAL(int) parse_switches (j_decompress_ptr cinfo, int argc, char **argv, int last_file_arg_seen, boolean for_real) /* Parse optional switches. * Returns argv[] index of first file-name argument (== argc if none). * Any file names with indexes <= last_file_arg_seen are ignored; * they have presumably been processed in a previous iteration. * (Pass 0 for last_file_arg_seen on the first or only iteration.) * for_real is FALSE on the first (dummy) pass; we may skip any expensive * processing. */ { int argn; char * arg; /* Set up default JPEG parameters. */ requested_fmt = DEFAULT_FMT; /* set default output file format */ outfilename = NULL; cinfo->err->trace_level = 0; /* Scan command line options, adjust parameters */ for (argn = 1; argn < argc; argn++) { arg = argv[argn]; if (*arg != '-') { /* Not a switch, must be a file name argument */ if (argn <= last_file_arg_seen) { outfilename = NULL; /* -outfile applies to just one input file */ continue; /* ignore this name if previously processed */ } break; /* else done parsing switches */ } arg++; /* advance past switch marker character */ if (keymatch(arg, "bmp", 1)) { /* BMP output format. */ requested_fmt = FMT_BMP; } else if (keymatch(arg, "colors", 1) || keymatch(arg, "colours", 1) || keymatch(arg, "quantize", 1) || keymatch(arg, "quantise", 1)) { /* Do color quantization. */ int val; if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%d", &val) != 1) usage(); cinfo->desired_number_of_colors = val; cinfo->quantize_colors = TRUE; } else if (keymatch(arg, "dct", 2)) { /* Select IDCT algorithm. */ if (++argn >= argc) /* advance to next argument */ usage(); if (keymatch(argv[argn], "int", 1)) { cinfo->dct_method = JDCT_ISLOW; } else if (keymatch(argv[argn], "fast", 2)) { cinfo->dct_method = JDCT_IFAST; } else if (keymatch(argv[argn], "float", 2)) { cinfo->dct_method = JDCT_FLOAT; } else usage(); } else if (keymatch(arg, "dither", 2)) { /* Select dithering algorithm. */ if (++argn >= argc) /* advance to next argument */ usage(); if (keymatch(argv[argn], "fs", 2)) { cinfo->dither_mode = JDITHER_FS; } else if (keymatch(argv[argn], "none", 2)) { cinfo->dither_mode = JDITHER_NONE; } else if (keymatch(argv[argn], "ordered", 2)) { cinfo->dither_mode = JDITHER_ORDERED; } else usage(); } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) { /* Enable debug printouts. */ /* On first -d, print version identification */ static boolean printed_version = FALSE; if (! printed_version) { fprintf(stderr, "Independent JPEG Group's DJPEG, version %s\n%s\n", JVERSION, JCOPYRIGHT); printed_version = TRUE; } cinfo->err->trace_level++; } else if (keymatch(arg, "fast", 1)) { /* Select recommended processing options for quick-and-dirty output. */ cinfo->two_pass_quantize = FALSE; cinfo->dither_mode = JDITHER_ORDERED; if (! cinfo->quantize_colors) /* don't override an earlier -colors */ cinfo->desired_number_of_colors = 216; cinfo->dct_method = JDCT_FASTEST; cinfo->do_fancy_upsampling = FALSE; } else if (keymatch(arg, "gif", 1)) { /* GIF output format. */ requested_fmt = FMT_GIF; } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) { /* Force monochrome output. */ cinfo->out_color_space = JCS_GRAYSCALE; } else if (keymatch(arg, "map", 3)) { /* Quantize to a color map taken from an input file. */ if (++argn >= argc) /* advance to next argument */ usage(); if (for_real) { /* too expensive to do twice! */ #ifdef QUANT_2PASS_SUPPORTED /* otherwise can't quantize to supplied map */ FILE * mapfile; if ((mapfile = fopen(argv[argn], READ_BINARY)) == NULL) { fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]); exit(EXIT_FAILURE); } read_color_map(cinfo, mapfile); fclose(mapfile); cinfo->quantize_colors = TRUE; #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } } else if (keymatch(arg, "maxmemory", 3)) { /* Maximum memory in Kb (or Mb with 'm'). */ long lval; char ch = 'x'; if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1) usage(); if (ch == 'm' || ch == 'M') lval *= 1000L; cinfo->mem->max_memory_to_use = lval * 1000L; } else if (keymatch(arg, "nosmooth", 3)) { /* Suppress fancy upsampling */ cinfo->do_fancy_upsampling = FALSE; } else if (keymatch(arg, "onepass", 3)) { /* Use fast one-pass quantization. */ cinfo->two_pass_quantize = FALSE; } else if (keymatch(arg, "os2", 3)) { /* BMP output format (OS/2 flavor). */ requested_fmt = FMT_OS2; } else if (keymatch(arg, "outfile", 4)) { /* Set output file name. */ if (++argn >= argc) /* advance to next argument */ usage(); outfilename = argv[argn]; /* save it away for later use */ } else if (keymatch(arg, "pnm", 1) || keymatch(arg, "ppm", 1)) { /* PPM/PGM output format. */ requested_fmt = FMT_PPM; } else if (keymatch(arg, "rle", 1)) { /* RLE output format. */ requested_fmt = FMT_RLE; } else if (keymatch(arg, "scale", 1)) { /* Scale the output image by a fraction M/N. */ if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%d/%d", &cinfo->scale_num, &cinfo->scale_denom) != 2) usage(); } else if (keymatch(arg, "targa", 1)) { /* Targa output format. */ requested_fmt = FMT_TARGA; } else { usage(); /* bogus switch */ } } return argn; /* return index of next arg (file name) */ } /* * Marker processor for COM and interesting APPn markers. * This replaces the library's built-in processor, which just skips the marker. * We want to print out the marker as text, to the extent possible. * Note this code relies on a non-suspending data source. */ LOCAL(unsigned int) jpeg_getc (j_decompress_ptr cinfo) /* Read next byte */ { struct jpeg_source_mgr * datasrc = cinfo->src; if (datasrc->bytes_in_buffer == 0) { if (! (*datasrc->fill_input_buffer) (cinfo)) ERREXIT(cinfo, JERR_CANT_SUSPEND); } datasrc->bytes_in_buffer--; return GETJOCTET(*datasrc->next_input_byte++); } METHODDEF(boolean) print_text_marker (j_decompress_ptr cinfo) { boolean traceit = (cinfo->err->trace_level >= 1); INT32 length; unsigned int ch; unsigned int lastch = 0; length = jpeg_getc(cinfo) << 8; length += jpeg_getc(cinfo); length -= 2; /* discount the length word itself */ if (traceit) { if (cinfo->unread_marker == JPEG_COM) fprintf(stderr, "Comment, length %ld:\n", (long) length); else /* assume it is an APPn otherwise */ fprintf(stderr, "APP%d, length %ld:\n", cinfo->unread_marker - JPEG_APP0, (long) length); } while (--length >= 0) { ch = jpeg_getc(cinfo); if (traceit) { /* Emit the character in a readable form. * Nonprintables are converted to \nnn form, * while \ is converted to \\. * Newlines in CR, CR/LF, or LF form will be printed as one newline. */ if (ch == '\r') { fprintf(stderr, "\n"); } else if (ch == '\n') { if (lastch != '\r') fprintf(stderr, "\n"); } else if (ch == '\\') { fprintf(stderr, "\\\\"); } else if (isprint(ch)) { putc(ch, stderr); } else { fprintf(stderr, "\\%03o", ch); } lastch = ch; } } if (traceit) fprintf(stderr, "\n"); return TRUE; } /* * The main program. */ int main (int argc, char **argv) { struct jpeg_decompress_struct cinfo; struct jpeg_error_mgr jerr; #ifdef PROGRESS_REPORT struct cdjpeg_progress_mgr progress; #endif int file_index; djpeg_dest_ptr dest_mgr = NULL; FILE * input_file; FILE * output_file; JDIMENSION num_scanlines; /* On Mac, fetch a command line. */ #ifdef USE_CCOMMAND argc = ccommand(&argv); #endif progname = argv[0]; if (progname == NULL || progname[0] == 0) progname = "djpeg"; /* in case C library doesn't provide it */ /* Initialize the JPEG decompression object with default error handling. */ cinfo.err = jpeg_std_error(&jerr); jpeg_create_decompress(&cinfo); /* Add some application-specific error messages (from cderror.h) */ jerr.addon_message_table = cdjpeg_message_table; jerr.first_addon_message = JMSG_FIRSTADDONCODE; jerr.last_addon_message = JMSG_LASTADDONCODE; /* Insert custom marker processor for COM and APP12. * APP12 is used by some digital camera makers for textual info, * so we provide the ability to display it as text. * If you like, additional APPn marker types can be selected for display, * but don't try to override APP0 or APP14 this way (see libjpeg.doc). */ jpeg_set_marker_processor(&cinfo, JPEG_COM, print_text_marker); jpeg_set_marker_processor(&cinfo, JPEG_APP0+12, print_text_marker); /* Now safe to enable signal catcher. */ #ifdef NEED_SIGNAL_CATCHER enable_signal_catcher((j_common_ptr) &cinfo); #endif /* Scan command line to find file names. */ /* It is convenient to use just one switch-parsing routine, but the switch * values read here are ignored; we will rescan the switches after opening * the input file. * (Exception: tracing level set here controls verbosity for COM markers * found during jpeg_read_header...) */ file_index = parse_switches(&cinfo, argc, argv, 0, FALSE); #ifdef TWO_FILE_COMMANDLINE /* Must have either -outfile switch or explicit output file name */ if (outfilename == NULL) { if (file_index != argc-2) { fprintf(stderr, "%s: must name one input and one output file\n", progname); usage(); } outfilename = argv[file_index+1]; } else { if (file_index != argc-1) { fprintf(stderr, "%s: must name one input and one output file\n", progname); usage(); } } #else /* Unix style: expect zero or one file name */ if (file_index < argc-1) { fprintf(stderr, "%s: only one input file\n", progname); usage(); } #endif /* TWO_FILE_COMMANDLINE */ /* Open the input file. */ if (file_index < argc) { if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) { fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]); exit(EXIT_FAILURE); } } else { /* default input file is stdin */ input_file = read_stdin(); } /* Open the output file. */ if (outfilename != NULL) { if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) { fprintf(stderr, "%s: can't open %s\n", progname, outfilename); exit(EXIT_FAILURE); } } else { /* default output file is stdout */ output_file = write_stdout(); } #ifdef PROGRESS_REPORT start_progress_monitor((j_common_ptr) &cinfo, &progress); #endif /* Specify data source for decompression */ jpeg_stdio_src(&cinfo, input_file); /* Read file header, set default decompression parameters */ (void) jpeg_read_header(&cinfo, TRUE); /* Adjust default decompression parameters by re-parsing the options */ file_index = parse_switches(&cinfo, argc, argv, 0, TRUE); /* Initialize the output module now to let it override any crucial * option settings (for instance, GIF wants to force color quantization). */ switch (requested_fmt) { #ifdef BMP_SUPPORTED case FMT_BMP: dest_mgr = jinit_write_bmp(&cinfo, FALSE); break; case FMT_OS2: dest_mgr = jinit_write_bmp(&cinfo, TRUE); break; #endif #ifdef GIF_SUPPORTED case FMT_GIF: dest_mgr = jinit_write_gif(&cinfo); break; #endif #ifdef PPM_SUPPORTED case FMT_PPM: dest_mgr = jinit_write_ppm(&cinfo); break; #endif #ifdef RLE_SUPPORTED case FMT_RLE: dest_mgr = jinit_write_rle(&cinfo); break; #endif #ifdef TARGA_SUPPORTED case FMT_TARGA: dest_mgr = jinit_write_targa(&cinfo); break; #endif default: ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT); break; } dest_mgr->output_file = output_file; /* Start decompressor */ (void) jpeg_start_decompress(&cinfo); /* Write output file header */ (*dest_mgr->start_output) (&cinfo, dest_mgr); /* Process data */ while (cinfo.output_scanline < cinfo.output_height) { num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer, dest_mgr->buffer_height); (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines); } #ifdef PROGRESS_REPORT /* Hack: count final pass as done in case finish_output does an extra pass. * The library won't have updated completed_passes. */ progress.pub.completed_passes = progress.pub.total_passes; #endif /* Finish decompression and release memory. * I must do it in this order because output module has allocated memory * of lifespan JPOOL_IMAGE; it needs to finish before releasing memory. */ (*dest_mgr->finish_output) (&cinfo, dest_mgr); (void) jpeg_finish_decompress(&cinfo); jpeg_destroy_decompress(&cinfo); /* Close files, if we opened them */ if (input_file != stdin) fclose(input_file); if (output_file != stdout) fclose(output_file); #ifdef PROGRESS_REPORT end_progress_monitor((j_common_ptr) &cinfo); #endif /* All done. */ exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS); return 0; /* suppress no-return-value warnings */ } Papyrus3/JpegDir/JpgLossy/JCTRANS.C0000755000175000017500000003403507535143454014054 0ustar /* * jctrans.c * * Copyright (C) 1995-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains library routines for transcoding compression, * that is, writing raw DCT coefficient arrays to an output JPEG file. * The routines in jcapimin.c will also be needed by a transcoder. */ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" /* Forward declarations */ LOCAL(void) transencode_master_selection JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)); LOCAL(void) transencode_coef_controller JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)); /* * Compression initialization for writing raw-coefficient data. * Before calling this, all parameters and a data destination must be set up. * Call jpeg_finish_compress() to actually write the data. * * The number of passed virtual arrays must match cinfo->num_components. * Note that the virtual arrays need not be filled or even realized at * the time write_coefficients is called; indeed, if the virtual arrays * were requested from this compression object's memory manager, they * typically will be realized during this routine and filled afterwards. */ GLOBAL(void) jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays) { if (cinfo->global_state != CSTATE_START) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); /* Mark all tables to be written */ jpeg_suppress_tables(cinfo, FALSE); /* (Re)initialize error mgr and destination modules */ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo); (*cinfo->dest->init_destination) (cinfo); /* Perform master selection of active modules */ transencode_master_selection(cinfo, coef_arrays); /* Wait for jpeg_finish_compress() call */ cinfo->next_scanline = 0; /* so jpeg_write_marker works */ cinfo->global_state = CSTATE_WRCOEFS; } /* * Initialize the compression object with default parameters, * then copy from the source object all parameters needed for lossless * transcoding. Parameters that can be varied without loss (such as * scan script and Huffman optimization) are left in their default states. */ GLOBAL(void) jpeg_copy_critical_parameters (j_decompress_ptr srcinfo, j_compress_ptr dstinfo) { JQUANT_TBL ** qtblptr; jpeg_component_info *incomp, *outcomp; JQUANT_TBL *c_quant, *slot_quant; int tblno, ci, coefi; /* Safety check to ensure start_compress not called yet. */ if (dstinfo->global_state != CSTATE_START) ERREXIT1(dstinfo, JERR_BAD_STATE, dstinfo->global_state); /* Copy fundamental image dimensions */ dstinfo->image_width = srcinfo->image_width; dstinfo->image_height = srcinfo->image_height; dstinfo->input_components = srcinfo->num_components; dstinfo->in_color_space = srcinfo->jpeg_color_space; /* Initialize all parameters to default values */ jpeg_set_defaults(dstinfo); /* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB. * Fix it to get the right header markers for the image colorspace. */ jpeg_set_colorspace(dstinfo, srcinfo->jpeg_color_space); dstinfo->data_precision = srcinfo->data_precision; dstinfo->CCIR601_sampling = srcinfo->CCIR601_sampling; /* Copy the source's quantization tables. */ for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) { if (srcinfo->quant_tbl_ptrs[tblno] != NULL) { qtblptr = & dstinfo->quant_tbl_ptrs[tblno]; if (*qtblptr == NULL) *qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo); MEMCOPY((*qtblptr)->quantval, srcinfo->quant_tbl_ptrs[tblno]->quantval, SIZEOF((*qtblptr)->quantval)); (*qtblptr)->sent_table = FALSE; } } /* Copy the source's per-component info. * Note we assume jpeg_set_defaults has allocated the dest comp_info array. */ dstinfo->num_components = srcinfo->num_components; if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS) ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components, MAX_COMPONENTS); for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info; ci < dstinfo->num_components; ci++, incomp++, outcomp++) { outcomp->component_id = incomp->component_id; outcomp->h_samp_factor = incomp->h_samp_factor; outcomp->v_samp_factor = incomp->v_samp_factor; outcomp->quant_tbl_no = incomp->quant_tbl_no; /* Make sure saved quantization table for component matches the qtable * slot. If not, the input file re-used this qtable slot. * IJG encoder currently cannot duplicate this. */ tblno = outcomp->quant_tbl_no; if (tblno < 0 || tblno >= NUM_QUANT_TBLS || srcinfo->quant_tbl_ptrs[tblno] == NULL) ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno); slot_quant = srcinfo->quant_tbl_ptrs[tblno]; c_quant = incomp->quant_table; if (c_quant != NULL) { for (coefi = 0; coefi < DCTSIZE2; coefi++) { if (c_quant->quantval[coefi] != slot_quant->quantval[coefi]) ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno); } } /* Note: we do not copy the source's Huffman table assignments; * instead we rely on jpeg_set_colorspace to have made a suitable choice. */ } /* Also copy JFIF version and resolution information, if available. * Strictly speaking this isn't "critical" info, but it's nearly * always appropriate to copy it if available. In particular, * if the application chooses to copy JFIF 1.02 extension markers from * the source file, we need to copy the version to make sure we don't * emit a file that has 1.02 extensions but a claimed version of 1.01. * We will *not*, however, copy version info from mislabeled "2.01" files. */ if (srcinfo->saw_JFIF_marker) { if (srcinfo->JFIF_major_version == 1) { dstinfo->JFIF_major_version = srcinfo->JFIF_major_version; dstinfo->JFIF_minor_version = srcinfo->JFIF_minor_version; } dstinfo->density_unit = srcinfo->density_unit; dstinfo->X_density = srcinfo->X_density; dstinfo->Y_density = srcinfo->Y_density; } } /* * Master selection of compression modules for transcoding. * This substitutes for jcinit.c's initialization of the full compressor. */ LOCAL(void) transencode_master_selection (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays) { /* Although we don't actually use input_components for transcoding, * jcmaster.c's initial_setup will complain if input_components is 0. */ cinfo->input_components = 1; /* Initialize master control (includes parameter checking/processing) */ jinit_c_master_control(cinfo, TRUE /* transcode only */); /* Entropy encoding: either Huffman or arithmetic coding. */ if (cinfo->arith_code) { ERREXIT(cinfo, JERR_ARITH_NOTIMPL); } else { if (cinfo->progressive_mode) { #ifdef C_PROGRESSIVE_SUPPORTED jinit_phuff_encoder(cinfo); #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } else jinit_huff_encoder(cinfo); } /* We need a special coefficient buffer controller. */ transencode_coef_controller(cinfo, coef_arrays); jinit_marker_writer(cinfo); /* We can now tell the memory manager to allocate virtual arrays. */ (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo); /* Write the datastream header (SOI, JFIF) immediately. * Frame and scan headers are postponed till later. * This lets application insert special markers after the SOI. */ (*cinfo->marker->write_file_header) (cinfo); } /* * The rest of this file is a special implementation of the coefficient * buffer controller. This is similar to jccoefct.c, but it handles only * output from presupplied virtual arrays. Furthermore, we generate any * dummy padding blocks on-the-fly rather than expecting them to be present * in the arrays. */ /* Private buffer controller object */ typedef struct { struct jpeg_c_coef_controller pub; /* public fields */ JDIMENSION iMCU_row_num; /* iMCU row # within image */ JDIMENSION mcu_ctr; /* counts MCUs processed in current row */ int MCU_vert_offset; /* counts MCU rows within iMCU row */ int MCU_rows_per_iMCU_row; /* number of such rows needed */ /* Virtual block array for each component. */ jvirt_barray_ptr * whole_image; /* Workspace for constructing dummy blocks at right/bottom edges. */ JBLOCKROW dummy_buffer[C_MAX_BLOCKS_IN_MCU]; } my_coef_controller; typedef my_coef_controller * my_coef_ptr; LOCAL(void) start_iMCU_row (j_compress_ptr cinfo) /* Reset within-iMCU-row counters for a new row */ { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; /* In an interleaved scan, an MCU row is the same as an iMCU row. * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows. * But at the bottom of the image, process only what's left. */ if (cinfo->comps_in_scan > 1) { coef->MCU_rows_per_iMCU_row = 1; } else { if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1)) coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor; else coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height; } coef->mcu_ctr = 0; coef->MCU_vert_offset = 0; } /* * Initialize for a processing pass. */ METHODDEF(void) start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode) { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; if (pass_mode != JBUF_CRANK_DEST) ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); coef->iMCU_row_num = 0; start_iMCU_row(cinfo); } /* * Process some data. * We process the equivalent of one fully interleaved MCU row ("iMCU" row) * per call, ie, v_samp_factor block rows for each component in the scan. * The data is obtained from the virtual arrays and fed to the entropy coder. * Returns TRUE if the iMCU row is completed, FALSE if suspended. * * NB: input_buf is ignored; it is likely to be a NULL pointer. */ METHODDEF(boolean) compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf) { my_coef_ptr coef = (my_coef_ptr) cinfo->coef; JDIMENSION MCU_col_num; /* index of current MCU within row */ JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1; JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1; int blkn, ci, xindex, yindex, yoffset, blockcnt; JDIMENSION start_col; JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN]; JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU]; JBLOCKROW buffer_ptr; jpeg_component_info *compptr; /* Align the virtual buffers for the components used in this scan. */ for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; buffer[ci] = (*cinfo->mem->access_virt_barray) ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index], coef->iMCU_row_num * compptr->v_samp_factor, (JDIMENSION) compptr->v_samp_factor, FALSE); } /* Loop to process one whole iMCU row */ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row; yoffset++) { for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row; MCU_col_num++) { /* Construct list of pointers to DCT blocks belonging to this MCU */ blkn = 0; /* index of current DCT block within MCU */ for (ci = 0; ci < cinfo->comps_in_scan; ci++) { compptr = cinfo->cur_comp_info[ci]; start_col = MCU_col_num * compptr->MCU_width; blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width : compptr->last_col_width; for (yindex = 0; yindex < compptr->MCU_height; yindex++) { if (coef->iMCU_row_num < last_iMCU_row || yindex+yoffset < compptr->last_row_height) { /* Fill in pointers to real blocks in this row */ buffer_ptr = buffer[ci][yindex+yoffset] + start_col; for (xindex = 0; xindex < blockcnt; xindex++) MCU_buffer[blkn++] = buffer_ptr++; } else { /* At bottom of image, need a whole row of dummy blocks */ xindex = 0; } /* Fill in any dummy blocks needed in this row. * Dummy blocks are filled in the same way as in jccoefct.c: * all zeroes in the AC entries, DC entries equal to previous * block's DC value. The init routine has already zeroed the * AC entries, so we need only set the DC entries correctly. */ for (; xindex < compptr->MCU_width; xindex++) { MCU_buffer[blkn] = coef->dummy_buffer[blkn]; MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0]; blkn++; } } } /* Try to write the MCU. */ if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) { /* Suspension forced; update state counters and exit */ coef->MCU_vert_offset = yoffset; coef->mcu_ctr = MCU_col_num; return FALSE; } } /* Completed an MCU row, but perhaps not an iMCU row */ coef->mcu_ctr = 0; } /* Completed the iMCU row, advance counters for next one */ coef->iMCU_row_num++; start_iMCU_row(cinfo); return TRUE; } /* * Initialize coefficient buffer controller. * * Each passed coefficient array must be the right size for that * coefficient: width_in_blocks wide and height_in_blocks high, * with unitheight at least v_samp_factor. */ LOCAL(void) transencode_coef_controller (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays) { my_coef_ptr coef; JBLOCKROW buffer; int i; coef = (my_coef_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(my_coef_controller)); cinfo->coef = (struct jpeg_c_coef_controller *) coef; coef->pub.start_pass = start_pass_coef; coef->pub.compress_data = compress_output; /* Save pointer to virtual arrays */ coef->whole_image = coef_arrays; /* Allocate and pre-zero space for dummy DCT blocks. */ buffer = (JBLOCKROW) (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK)); jzero_far((void FAR *) buffer, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK)); for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) { coef->dummy_buffer[i] = buffer + i; } } Papyrus3/JpegDir/JpgLossy/JERROR.H0000755000175000017500000003362307535143454013762 0ustar /* * jerror.h * * Copyright (C) 1994-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file defines the error and message codes for the JPEG library. * Edit this file to add new codes, or to translate the message strings to * some other language. * A set of error-reporting macros are defined too. Some applications using * the JPEG library may wish to include this file to get the error codes * and/or the macros. */ /* * To define the enum list of message codes, include this file without * defining macro JMESSAGE. To create a message string table, include it * again with a suitable JMESSAGE definition (see jerror.c for an example). */ #ifndef JMESSAGE #ifndef JERROR_H /* First time through, define the enum list */ #define JMAKE_ENUM_LIST #else /* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */ #define JMESSAGE(code,string) #endif /* JERROR_H */ #endif /* JMESSAGE */ #ifdef JMAKE_ENUM_LIST typedef enum { #define JMESSAGE(code,string) code , #endif /* JMAKE_ENUM_LIST */ JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! */ /* For maintenance convenience, list is alphabetical by message code name */ JMESSAGE(JERR_ARITH_NOTIMPL, "Sorry, there are legal restrictions on arithmetic coding") JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix") JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix") JMESSAGE(JERR_BAD_BUFFER_MODE, "Bogus buffer control mode") JMESSAGE(JERR_BAD_COMPONENT_ID, "Invalid component ID %d in SOS") JMESSAGE(JERR_BAD_DCT_COEF, "DCT coefficient out of range") JMESSAGE(JERR_BAD_DCTSIZE, "IDCT output block size %d not supported") JMESSAGE(JERR_BAD_HUFF_TABLE, "Bogus Huffman table definition") JMESSAGE(JERR_BAD_IN_COLORSPACE, "Bogus input colorspace") JMESSAGE(JERR_BAD_J_COLORSPACE, "Bogus JPEG colorspace") JMESSAGE(JERR_BAD_LENGTH, "Bogus marker length") JMESSAGE(JERR_BAD_LIB_VERSION, "Wrong JPEG library version: library is %d, caller expects %d") JMESSAGE(JERR_BAD_MCU_SIZE, "Sampling factors too large for interleaved scan") JMESSAGE(JERR_BAD_POOL_ID, "Invalid memory pool code %d") JMESSAGE(JERR_BAD_PRECISION, "Unsupported JPEG data precision %d") JMESSAGE(JERR_BAD_PROGRESSION, "Invalid progressive parameters Ss=%d Se=%d Ah=%d Al=%d") JMESSAGE(JERR_BAD_PROG_SCRIPT, "Invalid progressive parameters at scan script entry %d") JMESSAGE(JERR_BAD_SAMPLING, "Bogus sampling factors") JMESSAGE(JERR_BAD_SCAN_SCRIPT, "Invalid scan script at entry %d") JMESSAGE(JERR_BAD_STATE, "Improper call to JPEG library in state %d") JMESSAGE(JERR_BAD_STRUCT_SIZE, "JPEG parameter struct mismatch: library thinks size is %u, caller expects %u") JMESSAGE(JERR_BAD_VIRTUAL_ACCESS, "Bogus virtual array access") JMESSAGE(JERR_BUFFER_SIZE, "Buffer passed to JPEG library is too small") JMESSAGE(JERR_CANT_SUSPEND, "Suspension not allowed here") JMESSAGE(JERR_CCIR601_NOTIMPL, "CCIR601 sampling not implemented yet") JMESSAGE(JERR_COMPONENT_COUNT, "Too many color components: %d, max %d") JMESSAGE(JERR_CONVERSION_NOTIMPL, "Unsupported color conversion request") JMESSAGE(JERR_DAC_INDEX, "Bogus DAC index %d") JMESSAGE(JERR_DAC_VALUE, "Bogus DAC value 0x%x") JMESSAGE(JERR_DHT_INDEX, "Bogus DHT index %d") JMESSAGE(JERR_DQT_INDEX, "Bogus DQT index %d") JMESSAGE(JERR_EMPTY_IMAGE, "Empty JPEG image (DNL not supported)") JMESSAGE(JERR_EMS_READ, "Read from EMS failed") JMESSAGE(JERR_EMS_WRITE, "Write to EMS failed") JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan") JMESSAGE(JERR_FILE_READ, "Input file read error") JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?") JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet") JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow") JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry") JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels") JMESSAGE(JERR_INPUT_EMPTY, "Empty input file") JMESSAGE(JERR_INPUT_EOF, "Premature end of input file") JMESSAGE(JERR_MISMATCHED_QUANT_TABLE, "Cannot transcode due to multiple use of quantization table %d") JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data") JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change") JMESSAGE(JERR_NOTIMPL, "Not implemented yet") JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time") JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported") JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined") JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image") JMESSAGE(JERR_NO_QUANT_TABLE, "Quantization table 0x%02x was not defined") JMESSAGE(JERR_NO_SOI, "Not a JPEG file: starts with 0x%02x 0x%02x") JMESSAGE(JERR_OUT_OF_MEMORY, "Insufficient memory (case %d)") JMESSAGE(JERR_QUANT_COMPONENTS, "Cannot quantize more than %d color components") JMESSAGE(JERR_QUANT_FEW_COLORS, "Cannot quantize to fewer than %d colors") JMESSAGE(JERR_QUANT_MANY_COLORS, "Cannot quantize to more than %d colors") JMESSAGE(JERR_SOF_DUPLICATE, "Invalid JPEG file structure: two SOF markers") JMESSAGE(JERR_SOF_NO_SOS, "Invalid JPEG file structure: missing SOS marker") JMESSAGE(JERR_SOF_UNSUPPORTED, "Unsupported JPEG process: SOF type 0x%02x") JMESSAGE(JERR_SOI_DUPLICATE, "Invalid JPEG file structure: two SOI markers") JMESSAGE(JERR_SOS_NO_SOF, "Invalid JPEG file structure: SOS before SOF") JMESSAGE(JERR_TFILE_CREATE, "Failed to create temporary file %s") JMESSAGE(JERR_TFILE_READ, "Read failed on temporary file") JMESSAGE(JERR_TFILE_SEEK, "Seek failed on temporary file") JMESSAGE(JERR_TFILE_WRITE, "Write failed on temporary file --- out of disk space?") JMESSAGE(JERR_TOO_LITTLE_DATA, "Application transferred too few scanlines") JMESSAGE(JERR_UNKNOWN_MARKER, "Unsupported marker type 0x%02x") JMESSAGE(JERR_VIRTUAL_BUG, "Virtual array controller messed up") JMESSAGE(JERR_WIDTH_OVERFLOW, "Image too wide for this implementation") JMESSAGE(JERR_XMS_READ, "Read from XMS failed") JMESSAGE(JERR_XMS_WRITE, "Write to XMS failed") JMESSAGE(JMSG_COPYRIGHT, JCOPYRIGHT) JMESSAGE(JMSG_VERSION, JVERSION) JMESSAGE(JTRC_16BIT_TABLES, "Caution: quantization tables are too coarse for baseline JPEG") JMESSAGE(JTRC_ADOBE, "Adobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %d") JMESSAGE(JTRC_APP0, "Unknown APP0 marker (not JFIF), length %u") JMESSAGE(JTRC_APP14, "Unknown APP14 marker (not Adobe), length %u") JMESSAGE(JTRC_DAC, "Define Arithmetic Table 0x%02x: 0x%02x") JMESSAGE(JTRC_DHT, "Define Huffman Table 0x%02x") JMESSAGE(JTRC_DQT, "Define Quantization Table %d precision %d") JMESSAGE(JTRC_DRI, "Define Restart Interval %u") JMESSAGE(JTRC_EMS_CLOSE, "Freed EMS handle %u") JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u") JMESSAGE(JTRC_EOI, "End Of Image") JMESSAGE(JTRC_HUFFBITS, " %3d %3d %3d %3d %3d %3d %3d %3d") JMESSAGE(JTRC_JFIF, "JFIF APP0 marker: version %d.%02d, density %dx%d %d") JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE, "Warning: thumbnail image size does not match data length %u") JMESSAGE(JTRC_JFIF_EXTENSION, "JFIF extension marker: type 0x%02x, length %u") JMESSAGE(JTRC_JFIF_THUMBNAIL, " with %d x %d thumbnail image") JMESSAGE(JTRC_MISC_MARKER, "Miscellaneous marker 0x%02x, length %u") JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x") JMESSAGE(JTRC_QUANTVALS, " %4u %4u %4u %4u %4u %4u %4u %4u") JMESSAGE(JTRC_QUANT_3_NCOLORS, "Quantizing to %d = %d*%d*%d colors") JMESSAGE(JTRC_QUANT_NCOLORS, "Quantizing to %d colors") JMESSAGE(JTRC_QUANT_SELECTED, "Selected %d colors for quantization") JMESSAGE(JTRC_RECOVERY_ACTION, "At marker 0x%02x, recovery action %d") JMESSAGE(JTRC_RST, "RST%d") JMESSAGE(JTRC_SMOOTH_NOTIMPL, "Smoothing not supported with nonstandard sampling ratios") JMESSAGE(JTRC_SOF, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d") JMESSAGE(JTRC_SOF_COMPONENT, " Component %d: %dhx%dv q=%d") JMESSAGE(JTRC_SOI, "Start of Image") JMESSAGE(JTRC_SOS, "Start Of Scan: %d components") JMESSAGE(JTRC_SOS_COMPONENT, " Component %d: dc=%d ac=%d") JMESSAGE(JTRC_SOS_PARAMS, " Ss=%d, Se=%d, Ah=%d, Al=%d") JMESSAGE(JTRC_TFILE_CLOSE, "Closed temporary file %s") JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s") JMESSAGE(JTRC_THUMB_JPEG, "JFIF extension marker: JPEG-compressed thumbnail image, length %u") JMESSAGE(JTRC_THUMB_PALETTE, "JFIF extension marker: palette thumbnail image, length %u") JMESSAGE(JTRC_THUMB_RGB, "JFIF extension marker: RGB thumbnail image, length %u") JMESSAGE(JTRC_UNKNOWN_IDS, "Unrecognized component IDs %d %d %d, assuming YCbCr") JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u") JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u") JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d") JMESSAGE(JWRN_BOGUS_PROGRESSION, "Inconsistent progression sequence for component %d coefficient %d") JMESSAGE(JWRN_EXTRANEOUS_DATA, "Corrupt JPEG data: %u extraneous bytes before marker 0x%02x") JMESSAGE(JWRN_HIT_MARKER, "Corrupt JPEG data: premature end of data segment") JMESSAGE(JWRN_HUFF_BAD_CODE, "Corrupt JPEG data: bad Huffman code") JMESSAGE(JWRN_JFIF_MAJOR, "Warning: unknown JFIF revision number %d.%02d") JMESSAGE(JWRN_JPEG_EOF, "Premature end of JPEG file") JMESSAGE(JWRN_MUST_RESYNC, "Corrupt JPEG data: found marker 0x%02x instead of RST%d") JMESSAGE(JWRN_NOT_SEQUENTIAL, "Invalid SOS parameters for sequential JPEG") JMESSAGE(JWRN_TOO_MUCH_DATA, "Application transferred too many scanlines") #ifdef JMAKE_ENUM_LIST JMSG_LASTMSGCODE } J_MESSAGE_CODE; #undef JMAKE_ENUM_LIST #endif /* JMAKE_ENUM_LIST */ /* Zap JMESSAGE macro so that future re-inclusions do nothing by default */ #undef JMESSAGE #ifndef JERROR_H #define JERROR_H /* Macros to simplify using the error and trace message stuff */ /* The first parameter is either type of cinfo pointer */ /* Fatal errors (print message and exit) */ #define ERREXIT(cinfo,code) \ ((cinfo)->err->msg_code = (code), \ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) #define ERREXIT1(cinfo,code,p1) \ ((cinfo)->err->msg_code = (code), \ (cinfo)->err->msg_parm.i[0] = (p1), \ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) #define ERREXIT2(cinfo,code,p1,p2) \ ((cinfo)->err->msg_code = (code), \ (cinfo)->err->msg_parm.i[0] = (p1), \ (cinfo)->err->msg_parm.i[1] = (p2), \ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) #define ERREXIT3(cinfo,code,p1,p2,p3) \ ((cinfo)->err->msg_code = (code), \ (cinfo)->err->msg_parm.i[0] = (p1), \ (cinfo)->err->msg_parm.i[1] = (p2), \ (cinfo)->err->msg_parm.i[2] = (p3), \ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) #define ERREXIT4(cinfo,code,p1,p2,p3,p4) \ ((cinfo)->err->msg_code = (code), \ (cinfo)->err->msg_parm.i[0] = (p1), \ (cinfo)->err->msg_parm.i[1] = (p2), \ (cinfo)->err->msg_parm.i[2] = (p3), \ (cinfo)->err->msg_parm.i[3] = (p4), \ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) #define ERREXITS(cinfo,code,str) \ ((cinfo)->err->msg_code = (code), \ strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) #define MAKESTMT(stuff) do { stuff } while (0) /* Nonfatal errors (we can keep going, but the data is probably corrupt) */ #define WARNMS(cinfo,code) \ ((cinfo)->err->msg_code = (code), \ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) #define WARNMS1(cinfo,code,p1) \ ((cinfo)->err->msg_code = (code), \ (cinfo)->err->msg_parm.i[0] = (p1), \ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) #define WARNMS2(cinfo,code,p1,p2) \ ((cinfo)->err->msg_code = (code), \ (cinfo)->err->msg_parm.i[0] = (p1), \ (cinfo)->err->msg_parm.i[1] = (p2), \ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) /* Informational/debugging messages */ #define TRACEMS(cinfo,lvl,code) \ ((cinfo)->err->msg_code = (code), \ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) #define TRACEMS1(cinfo,lvl,code,p1) \ ((cinfo)->err->msg_code = (code), \ (cinfo)->err->msg_parm.i[0] = (p1), \ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) #define TRACEMS2(cinfo,lvl,code,p1,p2) \ ((cinfo)->err->msg_code = (code), \ (cinfo)->err->msg_parm.i[0] = (p1), \ (cinfo)->err->msg_parm.i[1] = (p2), \ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) #define TRACEMS3(cinfo,lvl,code,p1,p2,p3) \ MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); \ (cinfo)->err->msg_code = (code); \ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) #define TRACEMS4(cinfo,lvl,code,p1,p2,p3,p4) \ MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ (cinfo)->err->msg_code = (code); \ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) #define TRACEMS5(cinfo,lvl,code,p1,p2,p3,p4,p5) \ MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ _mp[4] = (p5); \ (cinfo)->err->msg_code = (code); \ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) #define TRACEMS8(cinfo,lvl,code,p1,p2,p3,p4,p5,p6,p7,p8) \ MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ _mp[4] = (p5); _mp[5] = (p6); _mp[6] = (p7); _mp[7] = (p8); \ (cinfo)->err->msg_code = (code); \ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) #define TRACEMSS(cinfo,lvl,code,str) \ ((cinfo)->err->msg_code = (code), \ strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) #endif /* JERROR_H */ Papyrus3/JpegDir/JpgLossy/makeproj.mac0000755000175000017500000002453307535143454015140 0ustar -- -- makeproj.mac -- -- This AppleScript builds Code Warrior PRO Release 2 project files for the -- libjpeg library as well as the test programs 'cjpeg', 'djpeg', 'jpegtran'. -- (We'd distribute real project files, except they're not text -- and would create maintenance headaches.) -- -- The script then compiles and links the library and the test programs. -- NOTE: if you haven't already created a 'jconfig.h' file, the script -- automatically copies 'jconfig.mac' to 'jconfig.h'. -- -- To use this script, you must have AppleScript 1.1 or later installed -- and a suitable AppleScript editor like Script Editor or Script Debugger -- (http://www.latenightsw.com). Open this file with your AppleScript -- editor and execute the "run" command to build the projects. -- -- Thanks to Dan Sears and Don Agro for this script. -- Questions about this script can be addressed to dogpark@interlog.com -- on run choose folder with prompt ">>> Select IJG source folder <<<" set ijg_folder to result choose folder with prompt ">>> Select MetroWerks folder <<<" set cw_folder to result -- if jconfig.h doesn't already exist, copy jconfig.mac tell application "Finder" if not (exists file "jconfig.h" of ijg_folder) then duplicate {file "jconfig.mac" of folder ijg_folder} select file "jconfig.mac copy" of folder ijg_folder set name of selection to "jconfig.h" end if end tell tell application "CodeWarrior IDE 2.1" with timeout of 10000 seconds -- create libjpeg project activate Create Project (ijg_folder as string) & "libjpeg.proj" Set Preferences of panel "Target Settings" to {Target Name:"libjpeg"} Set Preferences of panel "PPC Project" to {File Name:"libjpeg"} Set Preferences of panel "Target Settings" to {Linker:"MacOS PPC Linker"} Set Preferences of panel "PPC Project" to {Project Type:library} Set Preferences of panel "C/C++ Compiler" to {ANSI Strict:true} Set Preferences of panel "C/C++ Compiler" to {Enums Always Ints:true} Set Preferences of panel "PPC Codegen" to {Struct Alignment:PowerPC} Set Preferences of panel "PPC Linker" to {Generate SYM File:false} Add Files (ijg_folder as string) & "jcapimin.c" To Segment 1 Add Files (ijg_folder as string) & "jcapistd.c" To Segment 1 Add Files (ijg_folder as string) & "jctrans.c" To Segment 1 Add Files (ijg_folder as string) & "jcparam.c" To Segment 1 Add Files (ijg_folder as string) & "jdatadst.c" To Segment 1 Add Files (ijg_folder as string) & "jcinit.c" To Segment 1 Add Files (ijg_folder as string) & "jcmaster.c" To Segment 1 Add Files (ijg_folder as string) & "jcmarker.c" To Segment 1 Add Files (ijg_folder as string) & "jcmainct.c" To Segment 1 Add Files (ijg_folder as string) & "jcprepct.c" To Segment 1 Add Files (ijg_folder as string) & "jccoefct.c" To Segment 1 Add Files (ijg_folder as string) & "jccolor.c" To Segment 1 Add Files (ijg_folder as string) & "jcsample.c" To Segment 1 Add Files (ijg_folder as string) & "jchuff.c" To Segment 1 Add Files (ijg_folder as string) & "jcphuff.c" To Segment 1 Add Files (ijg_folder as string) & "jcdctmgr.c" To Segment 1 Add Files (ijg_folder as string) & "jfdctfst.c" To Segment 1 Add Files (ijg_folder as string) & "jfdctflt.c" To Segment 1 Add Files (ijg_folder as string) & "jfdctint.c" To Segment 1 Add Files (ijg_folder as string) & "jdapimin.c" To Segment 1 Add Files (ijg_folder as string) & "jdapistd.c" To Segment 1 Add Files (ijg_folder as string) & "jdtrans.c" To Segment 1 Add Files (ijg_folder as string) & "jdatasrc.c" To Segment 1 Add Files (ijg_folder as string) & "jdmaster.c" To Segment 1 Add Files (ijg_folder as string) & "jdinput.c" To Segment 1 Add Files (ijg_folder as string) & "jdmarker.c" To Segment 1 Add Files (ijg_folder as string) & "jdhuff.c" To Segment 1 Add Files (ijg_folder as string) & "jdphuff.c" To Segment 1 Add Files (ijg_folder as string) & "jdmainct.c" To Segment 1 Add Files (ijg_folder as string) & "jdcoefct.c" To Segment 1 Add Files (ijg_folder as string) & "jdpostct.c" To Segment 1 Add Files (ijg_folder as string) & "jddctmgr.c" To Segment 1 Add Files (ijg_folder as string) & "jidctfst.c" To Segment 1 Add Files (ijg_folder as string) & "jidctflt.c" To Segment 1 Add Files (ijg_folder as string) & "jidctint.c" To Segment 1 Add Files (ijg_folder as string) & "jidctred.c" To Segment 1 Add Files (ijg_folder as string) & "jdsample.c" To Segment 1 Add Files (ijg_folder as string) & "jdcolor.c" To Segment 1 Add Files (ijg_folder as string) & "jquant1.c" To Segment 1 Add Files (ijg_folder as string) & "jquant2.c" To Segment 1 Add Files (ijg_folder as string) & "jdmerge.c" To Segment 1 Add Files (ijg_folder as string) & "jcomapi.c" To Segment 1 Add Files (ijg_folder as string) & "jutils.c" To Segment 1 Add Files (ijg_folder as string) & "jerror.c" To Segment 1 Add Files (ijg_folder as string) & "jmemmgr.c" To Segment 1 Add Files (ijg_folder as string) & "jmemmac.c" To Segment 1 -- compile and link the library Make Project Close Project -- create cjpeg project activate Create Project (ijg_folder as string) & "cjpeg.proj" Set Preferences of panel "Target Settings" to {Target Name:"cjpeg"} Set Preferences of panel "PPC Project" to {File Name:"cjpeg"} Set Preferences of panel "Target Settings" to {Linker:"MacOS PPC Linker"} Set Preferences of panel "C/C++ Compiler" to {ANSI Strict:true} Set Preferences of panel "C/C++ Compiler" to {Enums Always Ints:true} Set Preferences of panel "PPC Codegen" to {Struct Alignment:PowerPC} Set Preferences of panel "PPC Linker" to {Generate SYM File:false} Add Files (ijg_folder as string) & "cjpeg.c" To Segment 1 Add Files (ijg_folder as string) & "rdppm.c" To Segment 1 Add Files (ijg_folder as string) & "rdgif.c" To Segment 1 Add Files (ijg_folder as string) & "rdtarga.c" To Segment 1 Add Files (ijg_folder as string) & "rdrle.c" To Segment 1 Add Files (ijg_folder as string) & "rdbmp.c" To Segment 1 Add Files (ijg_folder as string) & "rdswitch.c" To Segment 1 Add Files (ijg_folder as string) & "cdjpeg.c" To Segment 1 Add Files (ijg_folder as string) & "libjpeg" To Segment 2 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C:Bin:MSL C.PPC.Lib" To Segment 3 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C:Bin:MSL SIOUX.PPC.Lib" To Segment 3 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:MacOS Support:Libraries:Runtime:Runtime PPC:MSL RuntimePPC.Lib" To Segment 3 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:MacOS Support:Libraries:MacOS Common:InterfaceLib" To Segment 4 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:MacOS Support:Libraries:MacOS Common:MathLib" To Segment 4 -- compile and link cjpeg Make Project Close Project -- create djpeg project activate Create Project (ijg_folder as string) & "djpeg.proj" Set Preferences of panel "Target Settings" to {Target Name:"djpeg"} Set Preferences of panel "PPC Project" to {File Name:"djpeg"} Set Preferences of panel "Target Settings" to {Linker:"MacOS PPC Linker"} Set Preferences of panel "C/C++ Compiler" to {ANSI Strict:true} Set Preferences of panel "C/C++ Compiler" to {Enums Always Ints:true} Set Preferences of panel "PPC Codegen" to {Struct Alignment:PowerPC} Set Preferences of panel "PPC Linker" to {Generate SYM File:false} Add Files (ijg_folder as string) & "djpeg.c" To Segment 1 Add Files (ijg_folder as string) & "wrppm.c" To Segment 1 Add Files (ijg_folder as string) & "wrgif.c" To Segment 1 Add Files (ijg_folder as string) & "wrtarga.c" To Segment 1 Add Files (ijg_folder as string) & "wrrle.c" To Segment 1 Add Files (ijg_folder as string) & "wrbmp.c" To Segment 1 Add Files (ijg_folder as string) & "rdcolmap.c" To Segment 1 Add Files (ijg_folder as string) & "cdjpeg.c" To Segment 1 Add Files (ijg_folder as string) & "libjpeg" To Segment 2 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C:Bin:MSL C.PPC.Lib" To Segment 3 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C:Bin:MSL SIOUX.PPC.Lib" To Segment 3 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:MacOS Support:Libraries:Runtime:Runtime PPC:MSL RuntimePPC.Lib" To Segment 3 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:MacOS Support:Libraries:MacOS Common:InterfaceLib" To Segment 4 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:MacOS Support:Libraries:MacOS Common:MathLib" To Segment 4 -- compile and link djpeg Make Project Close Project -- create jpegtran project activate Create Project (ijg_folder as string) & "jpegtran.proj" Set Preferences of panel "Target Settings" to {Target Name:"jpegtran"} Set Preferences of panel "PPC Project" to {File Name:"jpegtran"} Set Preferences of panel "Target Settings" to {Linker:"MacOS PPC Linker"} Set Preferences of panel "C/C++ Compiler" to {ANSI Strict:true} Set Preferences of panel "C/C++ Compiler" to {Enums Always Ints:true} Set Preferences of panel "PPC Codegen" to {Struct Alignment:PowerPC} Set Preferences of panel "PPC Linker" to {Generate SYM File:false} Add Files (ijg_folder as string) & "jpegtran.c" To Segment 1 Add Files (ijg_folder as string) & "rdswitch.c" To Segment 1 Add Files (ijg_folder as string) & "cdjpeg.c" To Segment 1 Add Files (ijg_folder as string) & "transupp.c" To Segment 1 Add Files (ijg_folder as string) & "libjpeg" To Segment 2 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C:Bin:MSL C.PPC.Lib" To Segment 3 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C:Bin:MSL SIOUX.PPC.Lib" To Segment 3 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:MacOS Support:Libraries:Runtime:Runtime PPC:MSL RuntimePPC.Lib" To Segment 3 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:MacOS Support:Libraries:MacOS Common:InterfaceLib" To Segment 4 Add Files (cw_folder as string) & "Metrowerks CodeWarrior:MacOS Support:Libraries:MacOS Common:MathLib" To Segment 4 -- compile and link jpegtran Make Project Close Project quit end timeout end tell end run Papyrus3/JpegDir/Copyright JPEG lossy0000755000175000017500000004744607535143454014637 0ustar The Independent JPEG Group's JPEG software ========================================== README for release 6 of 2-Aug-95 ================================ This distribution contains the sixth public release of the Independent JPEG Group's free JPEG software. You are welcome to redistribute this software and to use it for any purpose, subject to the conditions under LEGAL ISSUES, below. Serious users of this software (particularly those incorporating it into larger programs) should contact IJG at jpeg-info@uunet.uu.net to be added to our electronic mailing list. Mailing list members are notified of updates and have a chance to participate in technical discussions, etc. This software is the work of Tom Lane, Philip Gladstone, Luis Ortiz, Jim Boucher, Lee Crocker, Julian Minguillon, George Phillips, Davide Rossi, Ge' Weijers, and other members of the Independent JPEG Group. IJG is not affiliated with the official ISO JPEG standards committee. DOCUMENTATION ROADMAP ===================== This file contains the following sections: OVERVIEW General description of JPEG and the IJG software. LEGAL ISSUES Copyright, lack of warranty, terms of distribution. REFERENCES Where to learn more about JPEG. ARCHIVE LOCATIONS Where to find newer versions of this software. RELATED SOFTWARE Other stuff you should get. FILE FORMAT WARS Software *not* to get. TO DO Plans for future IJG releases. Other documentation files in the distribution are: User documentation: install.doc How to configure and install the IJG software. usage.doc Usage instructions for cjpeg, djpeg, jpegtran, rdjpgcom, and wrjpgcom. *.1 Unix-style man pages for programs (same info as usage.doc). wizard.doc Advanced usage instructions for JPEG wizards only. change.log Version-to-version change highlights. Programmer and internal documentation: libjpeg.doc How to use the JPEG library in your own programs. example.c Sample code for calling the JPEG library. structure.doc Overview of the JPEG library's internal structure. filelist.doc Road map of IJG files. coderules.doc Coding style rules --- please read if you contribute code. Please read at least the files install.doc and usage.doc. Useful information can also be found in the JPEG FAQ (Frequently Asked Questions) article. See ARCHIVE LOCATIONS below to find out where to obtain the FAQ article. If you want to understand how the JPEG code works, we suggest reading one or more of the REFERENCES, then looking at the documentation files (in roughly the order listed) before diving into the code. OVERVIEW ======== This package contains C software to implement JPEG image compression and decompression. JPEG (pronounced "jay-peg") is a standardized compression method for full-color and gray-scale images. JPEG is intended for compressing "real-world" scenes; line drawings, cartoons and other non-realistic images are not its strong suit. JPEG is lossy, meaning that the output image is not exactly identical to the input image. Hence you must not use JPEG if you have to have identical output bits. However, on typical photographic images, very good compression levels can be obtained with no visible change, and remarkably high compression levels are possible if you can tolerate a low-quality image. For more details, see the references, or just experiment with various compression settings. This software implements JPEG baseline, extended-sequential, and progressive compression processes. Provision is made for supporting all variants of these processes, although some uncommon parameter settings aren't implemented yet. For legal reasons, we are not distributing code for the arithmetic-coding variants of JPEG; see LEGAL ISSUES. We have made no provision for supporting the hierarchical or lossless processes defined in the standard. We provide a set of library routines for reading and writing JPEG image files, plus two sample applications "cjpeg" and "djpeg", which use the library to perform conversion between JPEG and some other popular image file formats. The library is intended to be reused in other applications. In order to support file conversion and viewing software, we have included considerable functionality beyond the bare JPEG coding/decoding capability; for example, the color quantization modules are not strictly part of JPEG decoding, but they are essential for output to colormapped file formats or colormapped displays. These extra functions can be compiled out of the library if not required for a particular application. We have also included "jpegtran", a utility for lossless transcoding between different JPEG processes, and "rdjpgcom" and "wrjpgcom", two simple applications for inserting and extracting textual comments in JFIF files. The emphasis in designing this software has been on achieving portability and flexibility, while also making it fast enough to be useful. In particular, the software is not intended to be read as a tutorial on JPEG. (See the REFERENCES section for introductory material.) Rather, it is intended to be reliable, portable, industrial-strength code. We do not claim to have achieved that goal in every aspect of the software, but we strive for it. We welcome the use of this software as a component of commercial products. No royalty is required, but we do ask for an acknowledgement in product documentation, as described under LEGAL ISSUES. LEGAL ISSUES ============ In plain English: 1. We don't promise that this software works. (But if you find any bugs, please let us know!) 2. You can use this software for whatever you want. You don't have to pay us. 3. You may not pretend that you wrote this software. If you use it in a program, you must acknowledge somewhere in your documentation that you've used the IJG code. In legalese: The authors make NO WARRANTY or representation, either express or implied, with respect to this software, its quality, accuracy, merchantability, or fitness for a particular purpose. This software is provided "AS IS", and you, its user, assume the entire risk as to its quality and accuracy. This software is copyright (C) 1991, 1992, 1993, 1994, 1995, Thomas G. Lane. All Rights Reserved except as specified below. Permission is hereby granted to use, copy, modify, and distribute this software (or portions thereof) for any purpose, without fee, subject to these conditions: (1) If any part of the source code for this software is distributed, then this README file must be included, with this copyright and no-warranty notice unaltered; and any additions, deletions, or changes to the original files must be clearly indicated in accompanying documentation. (2) If only executable code is distributed, then the accompanying documentation must state that "this software is based in part on the work of the Independent JPEG Group". (3) Permission for use of this software is granted only if the user accepts full responsibility for any undesirable consequences; the authors accept NO LIABILITY for damages of any kind. These conditions apply to any software derived from or based on the IJG code, not just to the unmodified library. If you use our work, you ought to acknowledge us. Permission is NOT granted for the use of any IJG author's name or company name in advertising or publicity relating to this software or products derived from it. This software may be referred to only as "the Independent JPEG Group's software". We specifically permit and encourage the use of this software as the basis of commercial products, provided that all warranty or liability claims are assumed by the product vendor. ansi2knr.c is included in this distribution by permission of L. Peter Deutsch, sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA. ansi2knr.c is NOT covered by the above copyright and conditions, but instead by the usual distribution terms of the Free Software Foundation; principally, that you must include source code if you redistribute it. (See the file ansi2knr.c for full details.) However, since ansi2knr.c is not needed as part of any program generated from the IJG code, this does not limit you more than the foregoing paragraphs do. The configuration script "configure" was produced with GNU Autoconf. It is copyright by the Free Software Foundation but is freely distributable. It appears that the arithmetic coding option of the JPEG spec is covered by patents owned by IBM, AT&T, and Mitsubishi. Hence arithmetic coding cannot legally be used without obtaining one or more licenses. For this reason, support for arithmetic coding has been removed from the free JPEG software. (Since arithmetic coding provides only a marginal gain over the unpatented Huffman mode, it is unlikely that very many implementations will support it.) So far as we are aware, there are no patent restrictions on the remaining code. WARNING: Unisys has begun to enforce their patent on LZW compression against GIF encoders and decoders. You will need a license from Unisys to use the included rdgif.c or wrgif.c files in a commercial or shareware application. At this time, Unisys is not enforcing their patent against freeware, so distribution of this package remains legal. However, we intend to remove GIF support from the IJG package as soon as a suitable replacement format becomes reasonably popular. We are required to state that "The Graphics Interchange Format(c) is the Copyright property of CompuServe Incorporated. GIF(sm) is a Service Mark property of CompuServe Incorporated." REFERENCES ========== We highly recommend reading one or more of these references before trying to understand the innards of the JPEG software. The best short technical introduction to the JPEG compression algorithm is Wallace, Gregory K. "The JPEG Still Picture Compression Standard", Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44. (Adjacent articles in that issue discuss MPEG motion picture compression, applications of JPEG, and related topics.) If you don't have the CACM issue handy, a PostScript file containing a revised version of Wallace's article is available at ftp.uu.net, graphics/jpeg/wallace.ps.gz. The file (actually a preprint for an article that appeared in IEEE Trans. Consumer Electronics) omits the sample images that appeared in CACM, but it includes corrections and some added material. Note: the Wallace article is copyright ACM and IEEE, and it may not be used for commercial purposes. A somewhat less technical, more leisurely introduction to JPEG can be found in "The Data Compression Book" by Mark Nelson, published by M&T Books (Redwood City, CA), 1991, ISBN 1-55851-216-0. This book provides good explanations and example C code for a multitude of compression methods including JPEG. It is an excellent source if you are comfortable reading C code but don't know much about data compression in general. The book's JPEG sample code is far from industrial-strength, but when you are ready to look at a full implementation, you've got one here... The best full description of JPEG is the textbook "JPEG Still Image Data Compression Standard" by William B. Pennebaker and Joan L. Mitchell, published by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1. Price US$59.95, 638 pp. The book includes the complete text of the ISO JPEG standards (DIS 10918-1 and draft DIS 10918-2). This is by far the most complete exposition of JPEG in existence, and we highly recommend it. The JPEG standard itself is not available electronically; you must order a paper copy through ISO. (Unless you feel a need to own a certified official copy, we recommend buying the Pennebaker and Mitchell book instead; it's much cheaper and includes a great deal of useful explanatory material.) In the US, copies of the standard may be ordered from ANSI Sales at (212) 642-4900, or from Global Engineering Documents at (800) 854-7179. (ANSI doesn't take credit card orders, but Global does.) It's not cheap: as of 1992, ANSI was charging $95 for Part 1 and $47 for Part 2, plus 7% shipping/handling. The standard is divided into two parts, Part 1 being the actual specification, while Part 2 covers compliance testing methods. Part 1 is titled "Digital Compression and Coding of Continuous-tone Still Images, Part 1: Requirements and guidelines" and has document number ISO/IEC IS 10918-1. Part 2 is titled "Digital Compression and Coding of Continuous-tone Still Images, Part 2: Compliance testing" and has document number ISO/IEC IS 10918-2. Extensions to the original JPEG standard are defined in Part 3, a new ISO document. Part 3 is undergoing ISO balloting and is expected to be approved by the end of 1995. IJG currently does not support any Part 3 extensions. The JPEG standard does not specify all details of an interchangeable file format. For the omitted details we follow the "JFIF" conventions, revision 1.02. A copy of the JFIF spec is available from: Literature Department C-Cube Microsystems, Inc. 1778 McCarthy Blvd. Milpitas, CA 95035 phone (408) 944-6300, fax (408) 944-6314 A PostScript version of this document is available at ftp.uu.net, file graphics/jpeg/jfif.ps.gz. It can also be obtained by e-mail from the C-Cube mail server, netlib@c3.pla.ca.us. Send the message "send jfif_ps from jpeg" to the server to obtain the JFIF document; send the message "help" if you have trouble. The TIFF 6.0 file format specification can be obtained by FTP from sgi.com (192.48.153.1), file graphics/tiff/TIFF6.ps.Z; or you can order a printed copy from Aldus Corp. at (206) 628-6593. The JPEG incorporation scheme found in the TIFF 6.0 spec of 3-June-92 has a number of serious problems. IJG does not recommend use of the TIFF 6.0 design (TIFF Compression tag 6). Instead, we recommend the JPEG design proposed by TIFF Technical Note #2 (Compression tag 7). Copies of this Note can be obtained from sgi.com or from ftp.uu.net:/graphics/jpeg/. It is expected that the next revision of the TIFF spec will replace the 6.0 JPEG design with the Note's design. Although IJG's own code does not support TIFF/JPEG, the free libtiff library uses our library to implement TIFF/JPEG per the Note. libtiff is available from sgi.com:/graphics/tiff/. ARCHIVE LOCATIONS ================= The "official" archive site for this software is ftp.uu.net (Internet address 192.48.96.9). The most recent released version can always be found there in directory graphics/jpeg. This particular version will be archived as graphics/jpeg/jpegsrc.v6.tar.gz. If you are on the Internet, you can retrieve files from ftp.uu.net by standard anonymous FTP. If you don't have FTP access, UUNET's archives are also available via UUCP; contact help@uunet.uu.net for information on retrieving files that way. Numerous Internet sites maintain copies of the UUNET files; in particular, you can probably find a copy at any site that archives comp.sources.misc submissions. However, only ftp.uu.net is guaranteed to have the latest official version. You can also obtain this software in DOS-compatible "zip" archive format from the SimTel archives (ftp.coast.net:/SimTel/msdos/graphics/), or on CompuServe in the GRAPHSUPPORT forum (GO GRAPHSUP), library 12 "JPEG Tools". Again, these versions may sometimes lag behind the ftp.uu.net release. The JPEG FAQ (Frequently Asked Questions) article is a useful source of general information about JPEG. It is updated constantly and therefore is not included in this distribution. The FAQ is posted every two weeks to Usenet newsgroups comp.graphics, news.answers, and other groups. You can always obtain the latest version from the news.answers archive at rtfm.mit.edu. By FTP, fetch /pub/usenet/news.answers/jpeg-faq/part1 and .../part2. If you don't have FTP, send e-mail to mail-server@rtfm.mit.edu with body send usenet/news.answers/jpeg-faq/part1 send usenet/news.answers/jpeg-faq/part2 RELATED SOFTWARE ================ Numerous viewing and image manipulation programs now support JPEG. (Quite a few of them use this library to do so.) The JPEG FAQ described above lists some of the more popular free and shareware viewers, and tells where to obtain them on Internet. If you are on a Unix machine, we highly recommend Jef Poskanzer's free PBMPLUS image software, which provides many useful operations on PPM-format image files. In particular, it can convert PPM images to and from a wide range of other formats. You can obtain this package by FTP from ftp.x.org (contrib/pbmplus*.tar.Z) or ftp.ee.lbl.gov (pbmplus*.tar.Z). There is also a newer update of this package called NETPBM, available from wuarchive.wustl.edu under directory /graphics/graphics/packages/NetPBM/. Unfortunately PBMPLUS/NETPBM is not nearly as portable as the IJG software is; you are likely to have difficulty making it work on any non-Unix machine. A different free JPEG implementation, written by the PVRG group at Stanford, is available from havefun.stanford.edu in directory pub/jpeg. This program is designed for research and experimentation rather than production use; it is slower, harder to use, and less portable than the IJG code, but it is easier to read and modify. Also, the PVRG code supports lossless JPEG, which we do not. FILE FORMAT WARS ================ Some JPEG programs produce files that are not compatible with our library. The root of the problem is that the ISO JPEG committee failed to specify a concrete file format. Some vendors "filled in the blanks" on their own, creating proprietary formats that no one else could read. (For example, none of the early commercial JPEG implementations for the Macintosh were able to exchange compressed files.) The file format we have adopted is called JFIF (see REFERENCES). This format has been agreed to by a number of major commercial JPEG vendors, and it has become the de facto standard. JFIF is a minimal or "low end" representation. We recommend the use of TIFF/JPEG (TIFF revision 6.0 as modified by TIFF Technical Note #2) for "high end" applications that need to record a lot of additional data about an image. TIFF/JPEG is fairly new and not yet widely supported, unfortunately. The upcoming JPEG Part 3 standard defines a file format called SPIFF. SPIFF is interoperable with JFIF, in the sense that most JFIF decoders should be able to read the most common variant of SPIFF. SPIFF has some technical advantages over JFIF, but its major claim to fame is simply that it is an official standard rather than an informal one. At this point it is unclear whether SPIFF will supersede JFIF or whether JFIF will remain the de-facto standard. IJG intends to support SPIFF once the standard is frozen, but we have not decided whether it should become our default output format or not. (In any case, our decoder will remain capable of reading JFIF indefinitely.) Various proprietary file formats incorporating JPEG compression also exist. We have little or no sympathy for the existence of these formats. Indeed, one of the original reasons for developing this free software was to help force convergence on common, open format standards for JPEG files. Don't use a proprietary file format! TO DO ===== In future versions, we are considering supporting some of the upcoming JPEG Part 3 extensions --- principally, variable quantization and the SPIFF file format. Tuning the software for better behavior at low quality/high compression settings is also of interest. The current method for scaling the quantization tables is known not to be very good at low Q values. As always, speeding things up is high on our priority list. Please send bug reports, offers of help, etc. to jpeg-info@uunet.uu.net. Papyrus3/JpegDir/JPEG_lossless_modif.rtf0000644000175000017500000000107410035011542015410 0ustar {\rtf1\mac\ansicpg10000\cocoartf102 {\fonttbl\f0\fswiss\fcharset77 Helvetica;} {\colortbl;\red255\green255\blue255;} \paperw11900\paperh16840\margl1440\margr1440\vieww9660\viewh15200\viewkind0 \pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\ql\qnatural \f0\fs24 \cf0 This library, made by the Cornell University has been modified by the Digital Imaging Unit of the Service of Medical informatics, University Hospitals of Geneva, Switzerland.\ \ The modifications are regarding the file and memory systems.\ \ Geneva, April 2004\ }Papyrus3/JpegDir/Copyright JPEG lossless0000755000175000017500000000751007535143454015321 0ustar Copyright (c) 1993 Cornell University, Kongji Huang All rights reserved. Permission to use, copy, modify, and distribute this software and its documentation for research purposes, without fee, and without written agreement is hereby granted, provided that the above copyright notice and the following two paragraphs appear in all copies of this software. IN NO EVENT SHALL THE CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. THE CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. --------------------------------------------------------------------------- Copyright (c) 1993 The Regents of the University of California, Brian C. Smith All rights reserved. Permission to use, copy, modify, and distribute this software and its documentation for any purpose, without fee, and without written agreement is hereby granted, provided that the above copyright notice and the following two paragraphs appear in all copies of this software. IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. --------------------------------------------------------------------------- IJG Copyright The authors make NO WARRANTY or representation, either express or implied, with respect to this software, its quality, accuracy, merchantability, or fitness for a particular purpose. This software is provided "AS IS", and you, its user, assume the entire risk as to its quality and accuracy. This software is copyright (C) 1991, 1992, Thomas G. Lane. All Rights Reserved except as specified below. Permission is hereby granted to use, copy, modify, and distribute this software (or portions thereof) for any purpose, without fee, subject to these conditions: (1) If any part of the source code for this software is distributed, then this README file must be included, with this copyright and no-warranty notice unaltered; and any additions, deletions, or changes to the original files must be clearly indicated in accompanying documentation. (2) If only executable code is distributed, then the accompanying documentation must state that "this software is based in part on the work of the Independent JPEG Group". (3) Permission for use of this software is granted only if the user accepts full responsibility for any undesirable consequences; the authors accept NO LIABILITY for damages of any kind. Permission is NOT granted for the use of any IJG author's name or company name in advertising or publicity relating to this software or products derived from it. This software may be referred to only as "the Independent JPEG Group's software". We specifically permit and encourage the use of this software as the basis of commercial products, provided that all warranty or liability claims are assumed by the product vendor. Papyrus3/JpegDir/JpgLless/0000777000175000017500000000000010047674372012611 5ustar Papyrus3/JpegDir/JpgLless/huffcoptimisebug.c0000755000175000017500000014011007535143454016314 0ustar /* * huffcoptimisebug.c -- * * Code for JPEG lossless encoding. Many parts are grabbed from the IJG * software, so: * * Copyright (C) 1991, 1992, Thomas G. Lane. * Part of the Independent JPEG Group's software. * See the file Copyright for more details. * * Copyright (c) 1993 Brian C. Smith, The Regents of the University * of California * All rights reserved. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Copyright (c) 1997 OSIRIS Team. Digital Imaging Unit * University Hospital of Geneva * changes made by David Bandon * All rights reserved * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #include #include #include #include #include "jpeg.h" #include "mcu.h" #include "io.h" #include "proto.h" #include "predict.h" #include "jpegless.h" /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #ifndef PapyEalloc3H #include "PapyEalloc3.h" #endif #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PapyDef3.h" #endif #ifndef PapyEalloc3H #include "Papaloc3.h" #endif #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif /* FILENAME83 defined */ #define RST0 0xD0 /* RST0 marker code */ #define MIN_BUF_FREE 512 /* Min Buffer free for EncodeOneBlock */ #define NUM_HUFF_TBLS 4 /* Max # of Huffman tables can be */ /* used in one scan. */ /* * Lookup table for number of bits is a 8 bit value. Initialized * in HuffEncoderInit. */ int numBitsTable [256]; static int bmask[] = {0x0000, 0x00000001, 0x00000003, 0x00000007, 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF}; /* * Static variables for output buffering. */ static int huffPutBuffer; /* current bit-accumulation buffer */ static int huffPutBits; /* # of bits now in it */ /* * Global variables for output buffering. */ PapyUChar outputBuffer[JPEG_BUF_SIZE]; PapyULong numOutputBytes; /* bytes in the output buffer */ /* * Static varible to count the times each category symbol occurs. * Array freqCountPtrs[i][tblNo] is the frequency table of PSV (i-1) * to build the Huffman table tblNo. */ static long *freqCountPtrs[7][NUM_HUFF_TBLS]; /* *-------------------------------------------------------------- * * FlushBytes -- * * Output the bytes we've accumulated so far to the output * file. * * Results: * None. * * Side effects: * The numOutputBytes is reset. * *-------------------------------------------------------------- */ void FlushBytes () { if (numOutputBytes) WriteJpegData ((PapyUChar *)outputBuffer, numOutputBytes); numOutputBytes = 0L; } /* *-------------------------------------------------------------- * * EmitByteNoFlush -- * * Write a single byte out to the output buffer. * Assumes the caller is checking for flushing the buffer. * * Results: * None. * * Side effects: * The output buffer may get flushed. * *-------------------------------------------------------------- */ #define EmitByteNoFlush(val) { \ if (numOutputBytes >= JPEG_BUF_SIZE) \ FlushBytes(); \ outputBuffer[numOutputBytes++] = (PapyUChar)(val); \ } /* *-------------------------------------------------------------- * * EmitBits -- * * Code for outputting bits to the file * * Only the right 24 bits of huffPutBuffer are used; the valid * bits are left-justified in this part. At most 16 bits can be * passed to EmitBits in one call, and we never retain more than 7 * bits in huffPutBuffer between calls, so 24 bits are * sufficient. * * Results: * None. * * Side effects: * huffPutBuffer and huffPutBits are updated. * *-------------------------------------------------------------- */ #define EmitBits(code,size) { \ int putBuffer; \ int putBits; \ /* \ * if size is 0, caller used an invalid Huffman table entry \ */ \ assert (size != 0); \ /* \ * Mask off any excess bits in code. \ */ \ putBits = (size); \ putBuffer = ((code) & bmask[putBits]); \ putBits += huffPutBits; \ putBuffer <<= 24 - putBits; \ putBuffer |= huffPutBuffer; \ while (putBits >= 8) { \ int c; \ c = (putBuffer >> 16) & 0xFF; \ /* \ * Output whole bytes we've accumulated with byte stuffing \ */ \ EmitByteNoFlush (c); \ if (c == 0xFF) { \ EmitByteNoFlush (0); \ } \ putBuffer <<= 8; \ putBits -= 8; \ } \ /* \ * Update global variables \ */ \ huffPutBuffer = putBuffer; \ huffPutBits = putBits; \ } /* *-------------------------------------------------------------- * * FlushBits -- * * Flush any remaining bits in the bit buffer. Used before emitting * a marker. * * Results: * None. * * Side effects: * huffPutBuffer and huffPutBits are reset * *-------------------------------------------------------------- */ static void FlushBits () { /* * The first call forces output of any partial bytes. * We can then zero the buffer. */ EmitBits((Ushort) 0x7F,7); huffPutBuffer = 0; huffPutBits = 0; } /* *-------------------------------------------------------------- * * EncodeOneDiff -- * * Encode a single difference value. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ #define EncodeOneDiff(diff,dctbl) { \ register int temp, temp2; \ register short nbits; \ int bMagCat16; \ /* \ * Encode the DC coefficient difference per section F.1.2.1 \ */ \ temp = temp2 = diff; \ if (temp < 0) { \ temp = -temp; \ /* \ * For a negative input, want temp2 = bitwise complement of \ * abs(input). This code assumes we are on a two's complement \ * machine. \ */ \ temp2--; \ } \ /* \ * Find the number of bits needed for the magnitude of the coefficient \ */ \ nbits=0; \ if (temp) { \ while (temp >= 256) { \ nbits += 8; \ temp >>= 8; \ } \ nbits += numBitsTable[temp&0xff]; \ } \ /* \ * Emit the Huffman-coded symbol for the number of bits \ */ \ EmitBits(dctbl->ehufco[nbits],dctbl->ehufsi[nbits]); \ /* TCC special case for regular magnitude category 16 \ * if the huffman code is 8 bits or less, and the difference \ * magnitude is 16 bits, we know that this is a regular magnitude \ * category 16 code, and not a special >8bit one that handles \ * large negative numbers \ */ \ bMagCat16 = (nbits == 16) && !(dctbl->ehufco[nbits] & 0xff00) && \ (dctbl->ehufsi[nbits] < 9); \ \ /* \ * Emit that number of bits of the value, if positive, \ * or the complement of its magnitude, if negative. \ */ \ if (nbits && !bMagCat16) \ EmitBits ((Ushort) temp2, nbits); \ } /* *-------------------------------------------------------------- * * HuffEncoderInit -- * * Initialize for a Huffman-compressed scan. * * Results: * None * * Side effects: * None * *-------------------------------------------------------------- */ void HuffEncoderInit (CompressInfo *cPtr) { short i, nbits, temp; /*JpegComponentInfo *compptr;*/ /* * Initialize static variables */ huffPutBuffer = 0; huffPutBits = 0; /* * Initialize the output buffer */ numOutputBytes = 0L; /* * Initialize restart stuff */ cPtr->restartRowsToGo = cPtr->restartInRows; cPtr->nextRestartNum = 0; /* * Initialize number of bits lookup table. */ for (i = 0; i < 256; i++) { temp = i; nbits = 1; while (temp >>= 1) { nbits++; } numBitsTable [i] = nbits; } /* for */ } /* endof function HuffEncoderInit */ /* *-------------------------------------------------------------- * * EmitRestart -- * * Emit a restart marker & resynchronize predictions. * * Results: * None. * * Side effects: * Any remaining bits are flushed. * *-------------------------------------------------------------- */ static void EmitRestart (CompressInfo *cPtr) { FlushBits (); EmitByteNoFlush (0xFF); EmitByteNoFlush (RST0 + cPtr->nextRestartNum); /* * Update restart state */ cPtr->restartRowsToGo = cPtr->restartInRows; cPtr->nextRestartNum++; cPtr->nextRestartNum &= 7; } /* *-------------------------------------------------------------- * * EncodeFirstRow -- * * Encode the first raster line of samples at the start of * the scan and at the beginning of each restart interval. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void EncodeFirstRow(CompressInfo *cPtr, PapyUShort *ImageIn) { register short curComp,ci; register int col,compsInScan,numCOL; register JpegComponentInfo *compptr; int Pr,Pt,diff; PapyUChar *ImageIn8b; Pr=cPtr->dataPrecision; Pt=cPtr->Pt; compsInScan=cPtr->compsInScan; numCOL=cPtr->imageWidth; if (cPtr->dataPrecision == 8) ImageIn8b = (Uchar *) ImageIn; if (cPtr->dataPrecision == 8) { /* * At the start of the scan or at the beginning of restart interval, * 1<<(Pr-Pt-1) is the predictor. */ for (curComp = 0; curComp < compsInScan; curComp++) { ci = cPtr->MCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; diff = ImageIn8b[0] - (1<<(Pr-Pt-1)); EncodeOneDiff(diff,cPtr->dcHuffTblPtrs[compptr->dcTblNo]); } /* * In rest of the first row, left neighboring pixel is the predictor. */ for (col=1; colMCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; diff = ImageIn8b[col]-ImageIn8b[col-1]; EncodeOneDiff (diff, cPtr->dcHuffTblPtrs[compptr->dcTblNo]); } } if (cPtr->restartInRows) { cPtr->restartRowsToGo--; } } else { /* 16 bits */ for (curComp = 0; curComp < compsInScan; curComp++) { ci = cPtr->MCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; diff = ImageIn[0] - (1<<(Pr-Pt-1)); EncodeOneDiff(diff,cPtr->dcHuffTblPtrs[compptr->dcTblNo]); } /* * In rest of the first row, left neighboring pixel is the predictor. */ for (col=1; colMCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; diff = ImageIn[col]-ImageIn[col-1]; EncodeOneDiff (diff, cPtr->dcHuffTblPtrs[compptr->dcTblNo]); } } if (cPtr->restartInRows) { cPtr->restartRowsToGo--; } } } /* *-------------------------------------------------------------- * * HuffEncode -- * * Encode and output Huffman-compressed image data. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void HuffEncode (CompressInfo *cPtr, PapyUShort *Image) { register short curComp, ci; register int col,row; register JpegComponentInfo *compptr; register int diff; int predictor; int numCOL,numROW,compsInScan; int psv; PapyUChar *readim8b; PapyUShort *readim16b; numCOL=cPtr->imageWidth; numROW=cPtr->imageHeight; compsInScan=cPtr->compsInScan; psv=cPtr->Ss; if (cPtr->dataPrecision == 8) readim8b = (Uchar *) Image; else readim16b = (Ushort *) Image; EncodeFirstRow(cPtr,Image); if (cPtr->dataPrecision == 8) { readim8b += numCOL; for (row=1; rowrestartInRows) { if (cPtr->restartRowsToGo == 0) { EmitRestart (cPtr); EncodeFirstRow(cPtr,Image); readim8b += numCOL; continue; } cPtr->restartRowsToGo--; } /* * In the first column, the upper neighboring pixel * is the predictor. */ for (curComp = 0; curComp < compsInScan; curComp++) { ci = cPtr->MCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; diff = *readim8b - *(readim8b-numCOL); EncodeOneDiff (diff, cPtr->dcHuffTblPtrs[compptr->dcTblNo]); readim8b++; } /* * In the rest of the column on this row, predictor is * calculated according to psv. */ for (col=1; colMCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; if (psv == 5) predictor = *(readim8b-1) +((*(readim8b - numCOL) - *(readim8b-numCOL-1))>>1); else { if (psv == 1) predictor = *(readim8b-1); else { if (psv == 2) predictor = *(readim8b-numCOL); else { if (psv == 3) predictor = *(readim8b-numCOL-1); else { if (psv == 4) predictor = *(readim8b-1) + *(readim8b-numCOL) - *(readim8b-numCOL-1); else { if (psv == 0) predictor = 0; else { if (psv == 7) predictor = (*(readim8b-1) + *(readim8b-numCOL))>>1; else { if (psv == 6) predictor = *(readim8b-numCOL)+((*(readim8b-1)-*(readim8b-numCOL-1))>>1); else { predictor = 0; } /* end else psv 6 */ } /* end else psv 7 */ } /* end else psv 0 */ } /* end else psv 4 */ } /* end else psv 3 */ } /* end else psv 2 */ } /* end else psv 1 */ } /* end else psv 5*/ diff= *readim8b - predictor; EncodeOneDiff (diff, cPtr->dcHuffTblPtrs[compptr->dcTblNo]); } /* end for Curcomp */ readim8b++; } /* end for row */ } /* end 8 bits */ } else { /* 16 bits */ readim16b += numCOL; for (row=1; rowrestartInRows) { if (cPtr->restartRowsToGo == 0) { EmitRestart (cPtr); EncodeFirstRow(cPtr,Image); continue; } cPtr->restartRowsToGo--; } /* * In the first column, the upper neighboring pixel * is the predictor. */ for (curComp = 0; curComp < compsInScan; curComp++) { ci = cPtr->MCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; diff = *readim16b - *(readim16b-numCOL); EncodeOneDiff (diff, cPtr->dcHuffTblPtrs[compptr->dcTblNo]); readim16b++; } /* * In the rest of the column on this row, predictor is * calculated according to psv. */ for (col=1; colMCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; if (psv == 5) predictor = *(readim16b-1) +((*(readim16b - numCOL) - *(readim16b-numCOL-1))>>1); else { if (psv == 1) predictor = *(readim16b-1); else { if (psv == 2) predictor = *(readim16b-numCOL); else { if (psv == 3) predictor = *(readim16b-numCOL-1); else { if (psv == 4) predictor = *(readim16b-1) + *(readim16b-numCOL) - *(readim16b-numCOL-1); else { if (psv == 0) predictor = 0; else { if (psv == 6) predictor = *(readim16b-numCOL)+((*(readim16b-1)-*(readim16b-numCOL-1))>>1); else { if (psv == 7) predictor = (*(readim16b-1) + *(readim16b-numCOL))>>1; else { predictor = 0; } /* end else psv 7 */ } /* end else psv 6 */ } /* end else psv 0 */ } /* end else psv 4 */ } /* end else psv 3 */ } /* end else psv 2 */ } /* end else psv 1 */ } /* end else psv 5 */ diff= *readim16b - predictor; EncodeOneDiff (diff, cPtr->dcHuffTblPtrs[compptr->dcTblNo]); } /* end for Curcomp */ readim16b++; } /* end for row */ } /*end for col */ } /* end else */ } /* end HuffCode */ /* *-------------------------------------------------------------- * * HuffEncoderTerm -- * * Finish up at the end of a Huffman-compressed scan. * * Results: * None. * * Side effects: * Any remaing bits are flushed. * *-------------------------------------------------------------- */ void HuffEncoderTerm () { /* * Flush out the last data */ FlushBits (); FlushBytes (); } /* *-------------------------------------------------------------- * * Huffman coding optimization. * * This actually is optimization, in the sense that we find the * best possible Huffman table(s) for the given data. We first * scan the supplied data and count the number of uses of each * category symbol that is to be Huffman-coded. (This process * must agree with the code above.) Then we build an optimal * Huffman coding tree for the observed counts. * *-------------------------------------------------------------- */ /* *-------------------------------------------------------------- * * GenHuffCoding -- * * Generate the optimal coding for the given counts. * This algorithm is explained in section K.2 of the * JPEG standard. * * Results: * htbl->bits and htbl->huffval are costructed. * * Side effects: * None. * *-------------------------------------------------------------- */ void GenHuffCoding (HuffmanTable *htbl, long *freq) /* long freq[] */ { #define MAX_CLEN 32 /* assumed maximum initial code length */ Uchar bits[MAX_CLEN+1]; /* bits[k] = # of symbols with code length k */ short codesize[257]; /* codesize[k] = code length of symbol k */ short others[257]; /* next symbol in current branch of tree */ int c1, c2; int p, i, j; long v; MEMSET((void *)(bits), 0, sizeof(bits)); MEMSET((void *)(codesize), 0, sizeof(codesize)); for (i = 0; i < 257; i++) others[i] = -1; /* init links to empty */ /* * Including the pseudo-symbol 256 in the Huffman procedure guarantees * that no real symbol is given code-value of all ones, because 256 * will be placed in the largest codeword category. */ freq[256] = 1; /* make sure there is a nonzero count */ /* * Huffman's basic algorithm to assign optimal code lengths to symbols */ for (;;) { /* * Find the smallest nonzero frequency, set c1 = its symbol. * In case of ties, take the larger symbol number. */ c1 = -1; v = 1000000000L; for (i = 0; i <= 256; i++) { if (freq[i] && freq[i] <= v) { v = freq[i]; c1 = i; } } /* * Find the next smallest nonzero frequency, set c2 = its symbol. * In case of ties, take the larger symbol number. */ c2 = -1; v = 1000000000L; for (i = 0; i <= 256; i++) { if (freq[i] && freq[i] <= v && i != c1) { v = freq[i]; c2 = i; } } /* * Done if we've merged everything into one frequency. */ if (c2 < 0) break; /* * Else merge the two counts/trees. */ freq[c1] += freq[c2]; freq[c2] = 0; /* * Increment the codesize of everything in c1's tree branch. */ codesize[c1]++; while (others[c1] >= 0) { c1 = others[c1]; codesize[c1]++; } /* * chain c2 onto c1's tree branch */ others[c1] = c2; /* * Increment the codesize of everything in c2's tree branch. */ codesize[c2]++; while (others[c2] >= 0) { c2 = others[c2]; codesize[c2]++; } } /* * Now count the number of symbols of each code length. */ for (i = 0; i <= 256; i++) { if (codesize[i]) { /* * The JPEG standard seems to think that this can't happen, * but I'm paranoid... */ if (codesize[i] > MAX_CLEN) { fprintf(stderr, "Huffman code size table overflow: codesize[%d]=%d\n", i,codesize[i]); return; /* MAL exit(-1); */ } bits[codesize[i]]++; } } /* * JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure * Huffman procedure assigned any such lengths, we must adjust the coding. * Here is what the JPEG spec says about how this next bit works: * Since symbols are paired for the longest Huffman code, the symbols are * removed from this length category two at a time. The prefix for the pair * (which is one bit shorter) is allocated to one of the pair; then, * skipping the BITS entry for that prefix length, a code word from the next * shortest nonzero BITS entry is converted into a prefix for two code words * one bit longer. */ for (i = MAX_CLEN; i > 16; i--) { while (bits[i] > 0) { j = i - 2; /* find length of new prefix to be used */ while (bits[j] == 0) j--; bits[i] -= 2; /* remove two symbols */ bits[i-1]++; /* one goes in this length */ bits[j+1] += 2; /* two new symbols in this length */ bits[j]--; /* symbol of this length is now a prefix */ } } /* * Remove the count for the pseudo-symbol 256 from * the largest codelength. */ while (bits[i] == 0) /* find largest codelength still in use */ i--; bits[i]--; /* * Return final symbol counts (only for lengths 0..16). */ MEMCPY((htbl->bits),(bits),sizeof(htbl->bits)); /* * Return a list of the symbols sorted by code length. * It's not real clear to me why we don't need to consider the codelength * changes made above, but the JPEG spec seems to think this works. */ p = 0; for (i = 1; i <= MAX_CLEN; i++) { for (j = 0; j <= 255; j++) { if (codesize[j] == i) { htbl->huffval[p] = (Uchar) j; p++; } } } } /* *-------------------------------------------------------------- * * AllPredCountOneDiff -- * * Count this difference value in all 7 frequency counting * tables. This function is called when processing the first * row and first column of the image. Pixels in the first row * always use the left neighbors or (1= 256) { nbits += 8; temp >>= 8; } nbits += numBitsTable[temp&0xff]; } freqCountPtrs[0][tblNo][nbits]++; freqCountPtrs[1][tblNo][nbits]++; freqCountPtrs[2][tblNo][nbits]++; freqCountPtrs[3][tblNo][nbits]++; freqCountPtrs[4][tblNo][nbits]++; freqCountPtrs[5][tblNo][nbits]++; freqCountPtrs[6][tblNo][nbits]++; } #ifdef DEBUG /* *-------------------------------------------------------------- * * CountOneDiff -- * * Count the difference value in countTable. * * Results: * diff is counted in countTable. * * Side effects: * None. * *-------------------------------------------------------------- */ void CountOneDiff(int diff, long *countTable) /* long countTable[];*/ { register int temp, temp2; register short nbits; /* * Encode the DC coefficient difference per section F.1.2.1 */ temp = temp2 = diff; if (temp < 0) { temp = -temp; /* * For a negative input, want temp2 = bitwise complement of * abs(input). This code assumes we are on a two's complement * machine. */ temp2--; } /* * Find the number of bits needed for the magnitude of the coefficient */ nbits=0; if (temp) { while (temp >= 256) { nbits += 8; temp >>= 8; } nbits += numBitsTable[temp&0xff]; } countTable[nbits]++; } /* *-------------------------------------------------------------- * * AllPredCountOneComp -- * * The sample, curRowBuf[col][curComp], is counted in the * frequency counting tables, freqCountPts, of the 7 PSVs. * * Results: * None. * * Side effects: * curRowBuf[col][curComp] is counted in freqCountPtrs[i][tblNo] * for i=0 to 6. * *-------------------------------------------------------------- */ void AllPredCountOneComp(int col, int curComp, int tblNo, MCU *curRowBuf, MCU *prevRowBuf) { register int left,upper,diag,leftcol,r,curValue; leftcol=col-1; upper=prevRowBuf[col][curComp]; left=curRowBuf[leftcol][curComp]; diag=prevRowBuf[leftcol][curComp]; curValue=curRowBuf[col][curComp]; /* predictor 1 */ r = curValue - left; CountOneDiff(r,freqCountPtrs[0][tblNo]); /* predictor 2 */ r = curValue - upper; CountOneDiff(r,freqCountPtrs[1][tblNo]); /* predictor 3 */ r = curValue - diag; CountOneDiff(r,freqCountPtrs[2][tblNo]); /* predictor 4 */ r = curValue - (left+upper-diag); CountOneDiff(r,freqCountPtrs[3][tblNo]); /* predictor 5 */ r = curValue - (left+((upper-diag)>>1)); CountOneDiff(r,freqCountPtrs[4][tblNo]); /* predictor 6 */ r = curValue - (upper+((left-diag)>>1)); CountOneDiff(r,freqCountPtrs[5][tblNo]); /* predictor 7 */ r = curValue - ((left+upper)>>1); CountOneDiff(r,freqCountPtrs[6][tblNo]); } #else /* DEBUG */ /* *-------------------------------------------------------------- * * CountOneDiff (macro) -- * * Count the difference value in countTable. * * Results: * diff is counted in countTable. * * Side effects: * None. * *-------------------------------------------------------------- */ #define CountOneDiff(diff, countTable){ \ register int temp, temp2; \ register short nbits; \ \ temp = temp2 = diff; \ if (temp < 0) { \ temp = -temp; \ temp2--; \ } \ \ nbits=0; \ if (temp) { \ while (temp >= 256) { \ nbits += 8; \ temp >>= 8; \ } \ nbits += numBitsTable[temp&0xff]; \ } \ countTable[nbits]++; \ } /* *-------------------------------------------------------------- * * AllPredCountOneComp (macro) -- * * The sample, curRowBuf[col][curComp], is counted in the * frequency counting tables, freqCountPts, of the 7 PSVs. * * Results: * None. * * Side effects: * curRowBuf[col][curComp] is counted in freqCountPtrs[i][tblNo] * for i=0 to 6. * *-------------------------------------------------------------- */ #define AllPredCountOneComp(col,curComp,tblNo,curRowBuf,prevRowBuf) { \ register int left,upper,diag,leftcol,r,curValue; \ \ leftcol=col-1; \ upper=prevRowBuf[col][curComp]; \ left=curRowBuf[leftcol][curComp]; \ diag=prevRowBuf[leftcol][curComp]; \ curValue=curRowBuf[col][curComp]; \ /* predictor 1 */ \ r = curValue - left; \ CountOneDiff(r,freqCountPtrs[0][tblNo]); \ /* predictor 2 */ \ r = curValue - upper; \ CountOneDiff(r,freqCountPtrs[1][tblNo]); \ /* predictor 3 */ \ r = curValue - diag; \ CountOneDiff(r,freqCountPtrs[2][tblNo]); \ /* predictor 4 */ \ r = curValue - (left+upper-diag); \ CountOneDiff(r,freqCountPtrs[3][tblNo]); \ /* predictor 5 */ \ r = curValue - (left+((upper-diag)>>1)); \ CountOneDiff(r,freqCountPtrs[4][tblNo]); \ /* predictor 6 */ \ r = curValue - (upper+((left-diag)>>1)); \ CountOneDiff(r,freqCountPtrs[5][tblNo]); \ /* predictor 7 */ \ r = curValue - ((left+upper)>>1); \ CountOneDiff(r,freqCountPtrs[6][tblNo]); \ } #endif /*else DEBUG*/ /* *-------------------------------------------------------------- * * FreqCountSelValueSet -- * * Count the times each category symbol occurs in this * image for each PSV in the psvSet. * * Results: * None. * * Side effects: * The freqCountPtrs[i] has counted all category * symbols appeared in the image, where i is a * element in psvSet. * *-------------------------------------------------------------- */ void FreqCountSelValueSet(CompressInfo *cPtr) { register short curComp,ci,tblNo ; register int col,row; register JpegComponentInfo *compptr; register int r,i,curCountTblNo; int numCOL,numROW,compsInScan; int Pr,Pt; int predictor; MCU *prevRowBuf,*curRowBuf; numCOL=cPtr->imageWidth; numROW=cPtr->imageHeight; compsInScan=cPtr->compsInScan; Pr=cPtr->dataPrecision; Pt=cPtr->Pt; prevRowBuf=NULL; curRowBuf=mcuTable; for (row=0; rowMCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; tblNo=compptr->dcTblNo; for (i=0;iimageWidth; numROW=cPtr->imageHeight; compsInScan=cPtr->compsInScan; Pr=cPtr->dataPrecision; Pt=cPtr->Pt; Ss=cPtr->Ss; prevRowBuf=NULL; curRowBuf=mcuTable; /* * Do some specical case checking such that we can reduce the * computations in the main loop. */ /* * For the very first mcu in the scan, predictor is 1<<(Pr-Pt-1). */ for (curComp = 0; curComp < compsInScan; curComp++) { ci = cPtr->MCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; r = curRowBuf[0][curComp] - (1<<(Pr-Pt-1)); AllPredCountOneDiff(r,compptr->dcTblNo); } /* * In rest of the first row, left neighboring pixel is the predictor. */ for (col=1; colMCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; r = curRowBuf[col][curComp]-curRowBuf[col-1][curComp]; AllPredCountOneDiff(r,compptr->dcTblNo); } } prevRowBuf=curRowBuf; curRowBuf+=numCOL; for (row=1; rowMCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; r = curRowBuf[0][curComp]-prevRowBuf[0][curComp]; AllPredCountOneDiff(r,compptr->dcTblNo); } /* * Call AllPredCountOneComp to count the rest samples on this row. */ for (col=1; colMCUmembership[curComp]; compptr = cPtr->curCompInfo[ci]; AllPredCountOneComp(col,curComp,compptr->dcTblNo, curRowBuf,prevRowBuf); } } prevRowBuf=curRowBuf; curRowBuf+=numCOL; } } /* *-------------------------------------------------------------- * * FreqCountInit -- * * Allocate and zero the count tables. * * Results: * None. * * Side effects: * Seven tables pointed by freqCountPtrs[][] have been * allocated and initiallized. * *-------------------------------------------------------------- */ void FreqCountInit(CompressInfo *cPtr) { int i,j,tbl; for (i = 0; i < NUM_HUFF_TBLS; i++) { for (j=0;j<7;j++) freqCountPtrs[j][i] = NULL; } /* * Create seven count tables for each Huffman table. * Initialize the table entries to zero. * Note that GenHuffCoding expects 257 entries in each table, * although I think 17 will be enough. */ for (i = 0; i < cPtr->compsInScan; i++) { tbl = cPtr->curCompInfo[i]->dcTblNo; for (j=0;j<7;j++) { if (freqCountPtrs[j][tbl] == NULL) { freqCountPtrs[j][tbl] = (long *) emalloc3 (257 *sizeof(long)); MEMSET((void *)(freqCountPtrs[j][tbl]), 0, 257*sizeof(long)); } } } } /* *-------------------------------------------------------------- * * EmitBitsSum -- * * Find the number of bits emiting for a PSV (curCountTblNo+1). * It includes the total bits of category symbols and additional * bits. * * Results: * Total "category symbol" and "additional bits" output bits * for this PSV. * * Side effects: * If in vervose mode, totalHuffSym and totalAddBits for * this PSV is stored. These data are later output as statistics * data. * *-------------------------------------------------------------- */ long EmitBitsSum(int curCountTblNo, HuffmanTable **htblPtr) /* HuffmanTable *htblPtr[4]; */ { int i,tbl; long addBitSum,symLenSum,totalBits; addBitSum=0; symLenSum=0; /* * Count additional bits and Huffman symbol size. */ for (tbl = 0; tbl < NUM_HUFF_TBLS; tbl++) { if (freqCountPtrs[curCountTblNo][tbl] != NULL) { for (i=1;i<17;i++) { addBitSum+=freqCountPtrs[curCountTblNo][tbl][i]*i; } for (i=0;i<17;i++) { symLenSum+=freqCountPtrs[curCountTblNo][tbl][i]* htblPtr[tbl]->ehufsi[i]; } } } totalBits=symLenSum+addBitSum; if (verbose) { totalHuffSym[curCountTblNo]=symLenSum; totalAddBits[curCountTblNo]=addBitSum; } return (totalBits); } /* *-------------------------------------------------------------- * * HuffOptimize -- * * Find the best coding parameters for a Huffman-coded scan. * When called, the scan data has already been converted to * a sequence of MCU groups of source image samples, which * are stored in a "big" array, mcuTable. * * It counts the times each category symbol occurs. Based on * this counting, optimal Huffman tables are built. Then it * uses this optimal Huffman table and counting table to find * the best PSV. * * Results: * Optimal Huffman tables are retured in cPtr->dcHuffTblPtrs[tbl]. * Best PSV is retured in cPtr->Ss. * * Side effects: * None. * *-------------------------------------------------------------- */ void HuffOptimize (CompressInfo *cPtr, long *bestTotalBits) { int tbl,i; HuffmanTable *curHtblPtr[4]; long curTotalBits; long curFreqCount[257]; int curCountTblNo; FreqCountInit(cPtr); /* * Collect the frequency count in freqCountPtrs for each PSV. * Experiment data shows that when numSelValue > 4, * FreqCountAllSelValue does a better job than FreqCountSelValueSet. */ if (numSelValue>3) { FreqCountAllSelValue(cPtr); } else { FreqCountSelValueSet(cPtr); } /* * Generate optimal Huffman tables and find the best PSV. * Loop through each PSV is the psvSet. Whenever a better PSV * is found, its Huffman table is stored in cPtr->dcHuffTblPtrs; * and itself is stored in cPtr->Ss. */ /* * Set curCountTblNo to the first PSV. Allocate memory, * and point bestHtblPtr to cPtr->dcHuffTblPtrs, */ curCountTblNo=psvSet[0]-1; for (tbl = 0; tbl < NUM_HUFF_TBLS; tbl++) { curHtblPtr[tbl]=NULL; if (freqCountPtrs[curCountTblNo][tbl] != NULL) { curHtblPtr[tbl]=(HuffmanTable *) emalloc3 (sizeof(HuffmanTable)); if (cPtr->dcHuffTblPtrs[tbl] == NULL) { cPtr->dcHuffTblPtrs[tbl]=(HuffmanTable *) emalloc3 (sizeof(HuffmanTable)); } } } /* * Generate the Huffman tables for the first PSV and count the * total output bits of category symbols and additional bits. */ for (tbl = 0; tbl < NUM_HUFF_TBLS; tbl++) { if (freqCountPtrs[curCountTblNo][tbl] != NULL) { /* * Make an extra copy of the freqency tables since * GenHuffCoding destroys it. We need these tables * to count output bits next. */ MEMCPY(curFreqCount,freqCountPtrs[curCountTblNo][tbl], 257*sizeof(long)); GenHuffCoding(cPtr->dcHuffTblPtrs[tbl], curFreqCount); FixHuffTbl(cPtr->dcHuffTblPtrs[tbl]); } } *bestTotalBits=EmitBitsSum(curCountTblNo,cPtr->dcHuffTblPtrs); cPtr->Ss=psvSet[0]; /* * Generate the Huffman tables and count the output bits for the * remaining PSVs. Store the best one in cPtr pionted structure. */ for (i=1; idcHuffTblPtrs[tbl],curHtblPtr[tbl]); } } *bestTotalBits=curTotalBits; cPtr->Ss=psvSet[i]; /* printf("psv %d , total bytes %d \n", psvSet[i], *bestTotalBits); */ } } /* * Set sent_table FALSE so updated table will be * written to JPEG file. */ for (tbl = 0; tbl < NUM_HUFF_TBLS; tbl++) { if (cPtr->dcHuffTblPtrs[tbl] != NULL) { cPtr->dcHuffTblPtrs[tbl]->sentTable = 0; } } /* * Release the freqency Count tables, and temporary Huffman tables. */ for (tbl = 0; tbl < NUM_HUFF_TBLS; tbl++) { for (i=0;i<7;i++) { if (freqCountPtrs[i][tbl] != NULL) { efree3((void **) &freqCountPtrs[i][tbl]); } } if (curHtblPtr[tbl] != NULL) { efree3((void **) &curHtblPtr[tbl]); } } } /* *-------------------------------------------------------------- * * StdPickSelValue -- * * Select the best PSV from the psvSet. Default Huffman * tables and frequency counting tables are used in the * selection procedure. * * Results: * Chosen selection value is stored in cPtr->Ss * * Side effects: * None. * *-------------------------------------------------------------- */ void StdPickSelValue(CompressInfo *cPtr, long *bestTotalBits) { int tbl,i; long curTotalBits; /*long curFreqCount[257];*/ int curCountTblNo; FreqCountInit(cPtr); /* * Collect the frequency count in freqCountPtrs for each PSV. * Experiment data shows that when numSelValue > 4, * FreqCountAllSelValue does a better job than FreqCountSelValueSet. */ if (numSelValue>3) { FreqCountAllSelValue(cPtr); } else { FreqCountSelValueSet(cPtr); } /* * Loop through each PSV in the psvSet, and store the PSV * which generates the least output bits in cPtr->Ss. */ curCountTblNo=psvSet[0]-1; *bestTotalBits=EmitBitsSum(curCountTblNo,cPtr->dcHuffTblPtrs); cPtr->Ss=psvSet[0]; for (i=1; idcHuffTblPtrs); if (curTotalBits<*bestTotalBits) { *bestTotalBits=curTotalBits; cPtr->Ss=psvSet[i]; } } /* * Release frequency counting tables. */ for (tbl = 0; tbl < NUM_HUFF_TBLS; tbl++) { for (i=0;i<7;i++) { if (freqCountPtrs[i][tbl] != NULL) { efree3((void **) &freqCountPtrs[i][tbl]); } } } } /* *-------------------------------------------------------------- * * AddHuffTable -- * * Huffman table setup routines. Copy bits and val tables * into a Huffman table. * * Results: * bits and val are copied into htblprt. * (*htblptr)->sentTable is set to 0. * * Side effects: * None. * *-------------------------------------------------------------- */ void AddHuffTable (HuffmanTable **htblptr, Uchar *bits, Uchar *val) { if (*htblptr == NULL) *htblptr = (HuffmanTable *) (emalloc3 (sizeof(HuffmanTable))); MEMCPY((*htblptr)->bits, bits, sizeof((*htblptr)->bits)); MEMCPY((*htblptr)->huffval, val, sizeof((*htblptr)->huffval)); /* * Initialize sent_table FALSE so table will be written to JPEG file. * In an application where we are writing non-interchange JPEG files, * it might be desirable to save space by leaving default Huffman tables * out of the file. To do that, just initialize sent_table = TRUE... */ (*htblptr)->sentTable = 0; } /* *-------------------------------------------------------------- * * LoadStdHuffTables -- * * Load the standard Huffman tables (cf. JPEG standard * section K.3) into compression data structure pointed * by cPtr. * IMPORTANT: these are only valid for 8-bit data precision! * * Results: * Standard Huffman table, bits and val, are copied into * cPtr->dcHuffTblPtrs. * * Side effects: * None. * *-------------------------------------------------------------- */ void LoadStdHuffTables (CompressInfo *cPtr) { /* static Uchar dcLuminanceBits[17] = { 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 }; static Uchar dcLuminanceVal[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; */ static Uchar dcLuminanceBits[17] = { 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0 }; static Uchar dcLuminanceVal[17] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; /* static Uchar dcChrominanceBits[17] = { 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }; static Uchar dcChrominanceVal[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; */ static Uchar dcChrominanceBits[17] = { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; static Uchar dcChrominanceVal[17] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; AddHuffTable(&(cPtr->dcHuffTblPtrs[0]),dcLuminanceBits,dcLuminanceVal); AddHuffTable(&(cPtr->dcHuffTblPtrs[1]),dcChrominanceBits,dcChrominanceVal); } Papyrus3/JpegDir/JpgLless/Jlless.dsw0000755000175000017500000000103307535143454014560 0ustar Microsoft Developer Studio Workspace File, Format Version 5.00 # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! ############################################################################### Project: "Jpglless"=.\Jlless32.dsp - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Global: Package=<5> {{{ }}} Package=<3> {{{ }}} ############################################################################### Papyrus3/JpegDir/JpgLless/.DS_Store0000777000175000017500000001400410047674372014276 0ustar Bud1%  @€ @€ @€ @ E%DSDB`€ @€ @€ @Papyrus3/JpegDir/JpgLless/JPEGLESS.H0000755000175000017500000000707607535143454014147 0ustar /* * JPEGLess.h * * --------------------------------------------------------------- * * Lossless JPEG compression and decompression algorithms. * * --------------------------------------------------------------- * * It is based on the program originally named ljpgtopnm and pnmtoljpg. * Major portions taken from the Independetn JPEG Group' software, and * from the Cornell lossless JPEG code (the original copyright notices * for those packages appears below). * Changes were done by the Osiris Team for Papyrus integration and * optimization purposes. * * --------------------------------------------------------------- * * This is the main routine for the lossless JPEG decoder. Large * parts are stolen from the IJG code, so: * * Copyright (C) 1991, 1992, Thomas G. Lane. * Part of the Independent JPEG Group's software. * See the file Copyright for more details. * * Copyright (c) 1993 Brian C. Smith, The Regents of the University * of California * All rights reserved. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Copyright (c) 1997 OSIRIS Team. Digital Imaging Unit * University Hospital of Geneva * Changes made by Yves Ligier and David Bandon * All rights reserved * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* includes */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PAPYDEF3.h" #endif #endif /* FILENAME83 defined */ #include "jpeg.h" /* Global variables for lossless encoding process */ extern int psvSet[7]; /* the PSV (prediction selection value) set */ extern int numSelValue; /* number of PSVs in psvSet */ extern PapyULong inputFileBytes; /* the input file size in bytes */ extern PapyULong outputFileBytes; /* the output file size in bytes */ extern long totalHuffSym[7]; /* total bits of category symbols for each PSV */ extern long totalAddBits[7]; /* total bits of additional bits for each PSV */ extern int verbose; /* the verbose flag */ /* * read a JPEG lossless (8 or 16 bit) image in a file and decode it */ extern void JPEGLosslessDecodeImage (PAPY_FILE, PapyUShort *, int , PapyULong); extern void JPEGDecode_WithoutFile (PapyUShort *, PapyUShort *,int, PapyULong); /* * Encode a (8 or 16 bit) image according to the JPEG lossless algorithm */ extern void JPEGLosslessEncodeImage (PapyUShort *, PapyUChar **, PapyULong *, int, int, int); Papyrus3/JpegDir/JpgLless/Makefile0000755000175000017500000000165007535143454014252 0ustar # @(#)Makefile 1.3 5/3/91 ARCH= Solaris DSTDIR= .. MANDIR= $(DSTDIR)/man INCDIR= $(DSTDIR)/include BINDIR= $(DSTDIR)/test LIBDIR= ../$(DSTDIR)/$(ARCH)/lib LINTLIBDIR= $(LIBDIR)/lint CPPFLAGS= -I$(INCDIR) -I../.. -D_NO_LONGLONG CFLAGS= -g LINTFLAGS= -hb SOURCES= decompoptimise.c \ huffcoptimisebug.c \ huffdoptimise.c \ jpegutil.c \ mcu.c \ pmreadoptimise.c \ pnmtoljpoptimisebug.c \ predict.c \ read.c \ write.c LIBRARY= libJpglless.a OBJECTS= $(SOURCES:%.c=$(ARCH)/%.o) $(LIBDIR)/$(LIBRARY): createdir $(OBJECTS) ar rv $@ $(OBJECTS) lint: $(SOURCES) $(LINT.c) $(SOURCES) createdir: test -d $(ARCH) || mkdir -p $(ARCH) test -d $(DSTDIR)/$(ARCH)/lib || mkdir -p $(DSTDIR)/$(ARCH)/lib clean: -rm -Rf $(ARCH) .KEEP_STATE: .INIT: $(LIBDIR) $(ARCH) $(LIBDIR) $(ARCH) : test -d $@ || mkdir -p $@ $(ARCH)/%.o: %.c $(COMPILE.c) $< -o $@ Papyrus3/JpegDir/JpgLless/MCU.C0000755000175000017500000000775107535143454013352 0ustar /* * mcu.c -- * * Support for MCU allocation, deallocation, and printing. * * Copyright (c) 1993 Brian C. Smith, The Regents of the University * of California * All rights reserved. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #include #include /* #include */ #include #include "jpeg.h" #include "mcu.h" #include "proto.h" /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyEalloc3H #include "PapyEalloc3.h" #endif #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyEalloc3H #include "Papaloc3.h" #endif #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif MCU *mcuTable; /* the global mcu table that buffers the source image */ MCU *mcuROW1, *mcuROW2; /* point to two rows of MCU in encoding & decoding */ int numMCU; /* number of MCUs in mcuTable */ /* *-------------------------------------------------------------- * * MakeMCU, InitMcuTable -- * * InitMcuTable does a big malloc to get the amount of memory * we'll need for storing MCU's, once we know the size of our * input and output images. * MakeMCU returns an MCU for input parsing. * * Results: * A new MCU * * Side effects: * None. * *-------------------------------------------------------------- */ void InitMcuTable (int numMCU,int compsInScan) { int i, mcuSize; char *buffer; /* * Compute size of on MCU (in bytes). Round up so it's on a * boundary for any alignment. In this code, we assume this * is a whole multiple of sizeof(double). */ mcuSize = compsInScan * sizeof (ComponentType); /* mcuSize = JroundUp(mcuSize,sizeof(double)); */ /* * Allocate the MCU table, and a buffer which will contain all * the data. Then carve up the buffer by hand. Note that * mcuTable[0] points to the buffer, in case we want to free * it up later. */ mcuTable = (MCU *) emalloc3 (numMCU * sizeof (MCU)); if (mcuTable == NULL) fprintf(stderr,"Not enough memory for mcuTable\n"); buffer = (char *) emalloc3 (numMCU * mcuSize); if (buffer == NULL) fprintf(stderr,"Not enough memory for buffer\n"); for (i = 0; i < numMCU; i++) { mcuTable[i] = (MCU) (buffer + i * mcuSize); } } #define MakeMCU() (mcuTable[numMCU++]) /* *-------------------------------------------------------------- * * PrintMCU -- * * Send an MCU in quasi-readable form to stdout. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void PrintMCU (int compsInScan, MCU mcu) { ComponentType r; int b; static int callCount; for (b=0; b #include /* #include */ #include #include "jpeg.h" #include "mcu.h" #include "io.h" #include "proto.h" /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyEalloc3H #include "PapyEalloc3.h" #endif #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyEalloc3H #include "Papaloc3.h" #endif #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif /* * Enumerate all the JPEG marker codes */ typedef enum { M_SOF0 = 0xc0, M_SOF1 = 0xc1, M_SOF2 = 0xc2, M_SOF3 = 0xc3, M_SOF5 = 0xc5, M_SOF6 = 0xc6, M_SOF7 = 0xc7, M_JPG = 0xc8, M_SOF9 = 0xc9, M_SOF10 = 0xca, M_SOF11 = 0xcb, M_SOF13 = 0xcd, M_SOF14 = 0xce, M_SOF15 = 0xcf, M_DHT = 0xc4, M_DAC = 0xcc, M_RST0 = 0xd0, M_RST1 = 0xd1, M_RST2 = 0xd2, M_RST3 = 0xd3, M_RST4 = 0xd4, M_RST5 = 0xd5, M_RST6 = 0xd6, M_RST7 = 0xd7, M_SOI = 0xd8, M_EOI = 0xd9, M_SOS = 0xda, M_DQT = 0xdb, M_DNL = 0xdc, M_DRI = 0xdd, M_DHP = 0xde, M_EXP = 0xdf, M_APP0 = 0xe0, M_APP15 = 0xef, M_JPG0 = 0xf0, M_JPG13 = 0xfd, M_COM = 0xfe, M_TEM = 0x01, M_ERROR = 0x100 } JpegMarker; /* *-------------------------------------------------------------- * * EmitMarker -- * * Emit a marker code into the output stream. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ static void EmitMarker (JpegMarker mark) { EmitByte (0xFF); EmitByte (mark); } /* *-------------------------------------------------------------- * * Emit2bytes -- * * Emit a 2-byte integer; these are always MSB first in JPEG * files * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ static void Emit2bytes (int value) { EmitByte ((value >> 8) & 0xFF); EmitByte (value & 0xFF); } /* *-------------------------------------------------------------- * * EmitDht -- * * Emit a DHT marker, follwed by the huffman data. * * Results: * None * * Side effects: * None * *-------------------------------------------------------------- */ static void EmitDht (CompressInfo *cPtr, int index, int isAc) { HuffmanTable *htbl; int length, i; if (isAc) { /* printf("Not a huffman table for lossless mode\n"); */ } else { htbl = cPtr->dcHuffTblPtrs[index]; } if (htbl == NULL) { /* printf ("Huffman table 0x%02x was not defined\n", index); exit (1); */ } if (!htbl->sentTable) { EmitMarker (M_DHT); length = 0; for (i = 1; i <= 16; i++) length += htbl->bits[i]; Emit2bytes (length + 2 + 1 + 16); EmitByte (index); for (i = 1; i <= 16; i++) EmitByte (htbl->bits[i]); for (i = 0; i < length; i++) EmitByte (htbl->huffval[i]); htbl->sentTable = 1; } } /* *-------------------------------------------------------------- * * EmitDri -- * * Emit a DRI marker * * Results: * None. * * Side effects: * Exit on too big restart interval. * *-------------------------------------------------------------- */ static void EmitDri (CompressInfo *cPtr) { int restartInterval; restartInterval = cPtr->restartInRows * cPtr->imageWidth; /* * DIS only specifies 16 bits to store this value, so */ if (restartInterval > 65535) { /* printf("Error: Restart interval is too big.\n"); printf("It should be less than %d rows.\n", 65535/cPtr->imageWidth); */ return; /* MAL exit(1); */ } EmitMarker (M_DRI); Emit2bytes (4); /* length */ Emit2bytes ((int)restartInterval); } /* *-------------------------------------------------------------- * * EmitSof -- * * Emit a SOF marker plus data. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ static void EmitSof (CompressInfo *cPtr, JpegMarker code) { int i; EmitMarker (code); Emit2bytes (3 * cPtr->numComponents + 2 + 5 + 1); /* length */ if ((cPtr->imageHeight > 65535) || (cPtr->imageWidth > 65535)) { /* printf ("Maximum image dimension for JFIF is 65535 pixels\n"); */ return; /* MAL exit(1); */ } EmitByte (cPtr->dataPrecision); Emit2bytes ((int)cPtr->imageHeight); Emit2bytes ((int)cPtr->imageWidth); EmitByte (cPtr->numComponents); for (i = 0; i < cPtr->numComponents; i++) { EmitByte (cPtr->compInfo[i].componentId); EmitByte ((cPtr->compInfo[i].hSampFactor << 4) + cPtr->compInfo[i].vSampFactor); EmitByte (0); /* Tq shall be 0 for lossless */ } } /* *-------------------------------------------------------------- * * EmitSos -- * * Emit a SOS marker plus data. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ static void EmitSos (CompressInfo *cPtr) { int i; EmitMarker (M_SOS); Emit2bytes (2*cPtr->compsInScan + 2 + 1 + 3); /* length */ EmitByte (cPtr->compsInScan); /* Ns */ for (i = 0; i < cPtr->compsInScan; i++) { /* Cs,Td,Ta */ EmitByte (cPtr->curCompInfo[i]->componentId); EmitByte ((cPtr->curCompInfo[i]->dcTblNo << 4)); } EmitByte (cPtr->Ss); /* the PSV */ EmitByte (0); /* Spectral selection end - Se */ EmitByte(cPtr->Pt & 0x0F); /* the point transform parameter */ } /* *-------------------------------------------------------------- * * WriteFileTrailer -- * * Write the End of image marker at the end of a JPEG file. * * XXX: This is hardwored into stdout. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void WriteFileTrailer (CompressInfo *cPtr) { EmitMarker (M_EOI); } /* *-------------------------------------------------------------- * * WriteScanHeader -- * * Write the start of a scan (everything through the SOS marker). * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void WriteScanHeader (CompressInfo *cPtr) { int i; /* * Emit Huffman tables. Note that EmitDht takes care of * suppressing duplicate tables. */ for (i = 0; i < cPtr->compsInScan; i++) { EmitDht (cPtr, cPtr->curCompInfo[i]->dcTblNo, 0); } /* * Emit DRI if required --- note that DRI value could change for each * scan. If it doesn't, a tiny amount of space is wasted in * multiple-scan files. We assume DRI will never be nonzero for one * scan and zero for a later one. */ if (cPtr->restartInRows) EmitDri (cPtr); EmitSos (cPtr); } /* *-------------------------------------------------------------- * * WriteFileHeader -- * * Write the file header. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void WriteFileHeader (CompressInfo *cPtr) { EmitMarker (M_SOI); /* first the SOI */ EmitSof (cPtr, M_SOF3); } Papyrus3/JpegDir/JpgLless/maindecompression.c0000755000175000017500000001612507535143454016500 0ustar #include #include #include #include #ifdef Mac #include #include #include #include #endif /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #ifndef PapyEalloc3H #include "PapyEalloc3.h" #endif #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PAPYDEF3.h" #endif #ifndef PapyEalloc3H #include "Papaloc3.h" #endif #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif /* FILENAME83 defined */ PAPY_FILE JpegFile; extern void JPEGLosslessDecodeImage (PAPY_FILE, PapyUHShort *, int, int); typedef enum { M_SOF0 = 0xc0, M_SOF1 = 0xc1, M_SOF2 = 0xc2, M_SOF3 = 0xc3, M_SOF5 = 0xc5, M_SOF6 = 0xc6, M_SOF7 = 0xc7, M_JPG = 0xc8, M_SOF9 = 0xc9, M_SOF10 = 0xca, M_SOF11 = 0xcb, M_SOF13 = 0xcd, M_SOF14 = 0xce, M_SOF15 = 0xcf, M_DHT = 0xc4, M_DAC = 0xcc, M_RST0 = 0xd0, M_RST1 = 0xd1, M_RST2 = 0xd2, M_RST3 = 0xd3, M_RST4 = 0xd4, M_RST5 = 0xd5, M_RST6 = 0xd6, M_RST7 = 0xd7, M_SOI = 0xd8, M_EOI = 0xd9, M_SOS = 0xda, M_DQT = 0xdb, M_DNL = 0xdc, M_DRI = 0xdd, M_DHP = 0xde, M_EXP = 0xdf, M_APP0 = 0xe0, M_APP15 = 0xef, M_JPG0 = 0xf0, M_JPG13 = 0xfd, M_COM = 0xfe, M_TEM = 0x01, M_ERROR = 0x100 } JpegMarker; void main(void) { int c, c2, nbytes, lenght, lenght_elt; /* Read File Header */ int Precision, imageHeight, imageWidth; /* image parameters*/ short numComponents; PapyULong foo =0L; PapyULong imagesize; PapyULong imagesizelim; int numBytes; PapyUHChar *readBuffer; int i, j, tempo, bufsize; int Buffindex; PapyUHShort *image; PapyULong refPoint; PapyShort err; short fileNb; FSSpec fFile; struct stat buf_stat; PapyUHChar *imagefin; time_t tempsBegin, tempsEnd; char name[30]; PAPY_FILE OutFile; void *fFileOut; /* err = ProfilerInit(collectDetailed, bestTimeBase, 100, 20); if (err != 0) { printf("Error in ProfilerInit: %d \n", err); exit(-1); } ProfilerSetStatus(false); */ strcpy((char *) fFile.name, "Ankle.jpeg"); c2pstr((char *) fFile.name); printf("Decompile %s\n", fFile.name); fFile.vRefNum = - LMGetSFSaveDisk (); fFile.parID = LMGetCurDirStore (); /* Open the file in the Papyrus 3 way */ err= Papy3FOpen (NULL, 'r', 0, &JpegFile, (void *) &fFile); if (err < 0) { printf("Open file failed... \n"); exit(-1); } /* Papy3FTell ( (PAPY_FILE) JpegFile, (PapyLong *) &refPoint); printf("refpoint %d %d\n", refPoint, err); */ if (fstat(JpegFile,&buf_stat) == -1) { printf("error in stat \n"); exit(-1); } lenght = buf_stat.st_size; /* Rewind the file */ err = Papy3FSeek(JpegFile, SEEK_SET, 0L); if (err < 0) { printf("Seek file failed... \n"); exit(-1); } /* Read File Header */ /* * Demand an SOI marker at the start of the file --- otherwise it's * probably not a JPEG file at all. */ bufsize = 100L; readBuffer = (PapyUHChar *) ecalloc3((PapyULong) bufsize, (PapyULong) sizeof(PapyUHChar)); numBytes = 100L; Papy3FRead (JpegFile, (PapyULong *) &numBytes, (PapyULong) foo, (void *) readBuffer); /* Papy3FTell ( (PAPY_FILE) JpegFile, (PapyLong *) &refPoint); printf("refpoint %d %d\n", refPoint, err); */ Buffindex = 0; c = readBuffer[Buffindex++]; c2 = readBuffer[Buffindex++]; if ((c != 0xFF) || (c2 != M_SOI)) { if( c == EOF ) { printf("Reached end of input file. All done!\n"); Papy3FClose (&JpegFile); exit(1); } else { printf ("Not a JPEG file. Found %02X %02X\n", c, c2); exit (1); } }/*endif*/ /* GetSoi (dcPtr); OK, process SOI */ /* * Process markers until SOF */ nbytes = 0; do { do { nbytes++; c = readBuffer[Buffindex++]; } while (c != 0xFF); do { c = readBuffer[Buffindex++]; } while (c == 0xFF); } while (c == 0); switch (c) { case M_SOF0: case M_SOF1: case M_SOF3: tempo = readBuffer[Buffindex++]; lenght_elt = (tempo<<8) + readBuffer[Buffindex++]; Precision = readBuffer[Buffindex++]; tempo = readBuffer[Buffindex++]; imageHeight = (tempo<<8) + readBuffer[Buffindex++]; tempo = readBuffer[Buffindex++]; imageWidth = (tempo<<8) + readBuffer[Buffindex++]; numComponents = readBuffer[Buffindex++]; printf("Depth %d... numComponents %d... \n", (int) Precision, (int) numComponents); printf("height %d width %d... \n", (int) imageHeight, (int) imageWidth); break; default: fprintf (stderr, "Unsupported SOF marker type 0x%02x", c); break; } efree3 (&readBuffer); /* Rewind the file */ err = Papy3FSeek(JpegFile, SEEK_SET, 0L); if (err < 0) { printf("Seek file failed... \n"); exit(-1); } /* Papy3FTell ( (PAPY_FILE) JpegFile, (PapyLong *) &refPoint); printf("refpoint %d (after rewind)\n", refPoint); */ /* Define memory for output image */ printf("numcomponents %d \n", numComponents); if (Precision == 8) imagesize = (PapyULong) imageWidth*imageHeight*numComponents; else imagesize = (PapyULong) imageWidth*imageHeight*numComponents*2; image = (PapyUHShort *) emalloc3((PapyULong) imagesize); /* jpeg lossless compression */ tempsBegin = time(NULL); /* ProfilerSetStatus(true); */ JPEGLosslessDecodeImage ((PAPY_FILE) JpegFile, (PapyUHShort *) image, (int) Precision, (int) lenght); /* ProfilerSetStatus(false); ProfilerDump("\pDec_Det_Optimise.psv1"); ProfilerTerm(); */ printf("duree: %d secondes \n", (time(NULL) - tempsBegin)); Papy3FClose (&JpegFile); strcpy((char *) name, "Ankle.ppm"); /* c2pstr((char *) name); */ /* Open the outfile in the Papyrus 3 way */ err= Papy3FCreate (name, 0, 0, &OutFile, &fFileOut); if (err < 0) { printf("Creation outfile failed... \n"); exit(-1); } err= Papy3FOpen (name, 'w', 0, &OutFile, fFileOut); if (err < 0) { printf("Open outfile failed... \n"); exit(-1); } /* Rewind the file */ err = Papy3FSeek(OutFile, SEEK_SET, 0L); if (err < 0) { printf("Seek outfile failed... \n"); exit(-1); } err = Papy3FWrite(OutFile, (PapyULong *) &imagesize, 1L, image); if ( err < 0) { printf("error in outfile write process %d\n", err); Papy3FClose (&OutFile); exit(-1); } Papy3FClose (&OutFile); efree3(&image); printf("Sortie a fin de programme... \n"); }Papyrus3/JpegDir/JpgLless/Jlless.plg0000755000175000017500000000441507535143454014554 0ustar 
    Build Log
    

    
--------------------Configuration: Jpglless - Win32 Debug--------------------

    

    Command Lines
    
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3BB.tmp" with contents
[
/nologo /Zp1 /MLd /W3 /Gm /Zi /Od /I "..\..\..\Papyrus3\\" /D "_WINDOWS" /D "STRICT" /D "_DEBUG" /D "WIN32" /FR".\Debug/" /Fp".\Debug/Jlless.pch" /YX /Fo".\Debug/" /Fd".\PAPYRUS3.PDB" /FD /c 
"C:\FormatConversion\Dicom\Papyrus3\JpegDir\JpgLless\decompoptimise.c"
"C:\FormatConversion\Dicom\Papyrus3\JpegDir\JpgLless\huffcoptimisebug.c"
"C:\FormatConversion\Dicom\Papyrus3\JpegDir\JpgLless\huffdoptimise.c"
"C:\FormatConversion\Dicom\Papyrus3\JpegDir\JpgLless\JPEGUTIL.C"
"C:\FormatConversion\Dicom\Papyrus3\JpegDir\JpgLless\MCU.C"
"C:\FormatConversion\Dicom\Papyrus3\JpegDir\JpgLless\pmreadoptimise.c"
"C:\FormatConversion\Dicom\Papyrus3\JpegDir\JpgLless\pnmtoljpoptimisebug.c"
"C:\FormatConversion\Dicom\Papyrus3\JpegDir\JpgLless\PREDICT.C"
"C:\FormatConversion\Dicom\Papyrus3\JpegDir\JpgLless\READ.C"
"C:\FormatConversion\Dicom\Papyrus3\JpegDir\JpgLless\WRITE.C"
]
Creating command line "cl.exe @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3BB.tmp" 
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3BC.tmp" with contents
[
/nologo /out:".\Debug\Jlless.lib" 
.\Debug\decompoptimise.obj
.\Debug\huffcoptimisebug.obj
.\Debug\huffdoptimise.obj
.\Debug\JPEGUTIL.OBJ
.\Debug\MCU.OBJ
.\Debug\pmreadoptimise.obj
.\Debug\pnmtoljpoptimisebug.obj
.\Debug\PREDICT.OBJ
.\Debug\READ.OBJ
.\Debug\WRITE.OBJ
]
Creating command line "link.exe -lib @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3BC.tmp"

    Output Window
    
Compiling...
decompoptimise.c
huffcoptimisebug.c
huffdoptimise.c
C:\FormatConversion\Dicom\Papyrus3\JpegDir\JpgLless\huffdoptimise.c(727) : warning C4554: '>>' : check operator precedence for possible error; use parentheses to clarify precedence
C:\FormatConversion\Dicom\Papyrus3\JpegDir\JpgLless\huffdoptimise.c(888) : warning C4554: '>>' : check operator precedence for possible error; use parentheses to clarify precedence
JPEGUTIL.C
MCU.C
pmreadoptimise.c
pnmtoljpoptimisebug.c
PREDICT.C
READ.C
WRITE.C
Creating library...




    Results
    
Jlless.lib - 0 error(s), 2 warning(s)
    Papyrus3/JpegDir/JpgLless/Makefile.sun40000755000175000017500000000137207535143454015143 0ustar # @(#)Makefile 1.3 16/11/94 ARCH= sun4 DSTDIR= ../../.. MANDIR= $(DSTDIR)/man INCDIR= $(DSTDIR)/include BINDIR= $(DSTDIR)/test LIBDIR= $(DSTDIR)/$(ARCH)/lib CPPFLAGS= -I$(INCDIR) -I../.. -DXTFUNCPROTO -g CFLAGS= -g LINTFLAGS= -hb SOURCES= decompoptimise.c \ huffcoptimisebug.c \ huffdoptimise.c \ jpegutil.c \ mcu.c \ pmreadoptimise.c \ pnmtoljpoptimisebug.c \ predict.c \ read.c \ write.c LIBRARY= libJpglless.a OBJECTS= $(SOURCES:%.c=$(ARCH)/%.o) $(LIBDIR)/$(LIBRARY): $(OBJECTS) ar rv $@ $? ranlib $@ lint: $(SOURCES) $(LINT.c) $(SOURCES) .KEEP_STATE: .INIT: $(LIBDIR) $(ARCH) $(LIBDIR) $(ARCH) : test -d $@ || mkdir -p $@ $(ARCH)/%.o: %.c $(COMPILE.cc) $< -o $@ Papyrus3/JpegDir/JpgLless/READ.C0000755000175000017500000003365307535143454013441 0ustar /* * read.c -- * * Code for reading and processing JPEG markers. Large parts are grabbed * from the IJG software, so: * * Copyright (C) 1991, 1992, Thomas G. Lane. * Part of the Independent JPEG Group's software. * See the file Copyright for more details. * * Copyright (c) 1993 Brian C. Smith, The Regents of the University * of California * All rights reserved. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #include #include #include #include "jpeg.h" #include "mcu.h" #include "io.h" #include "proto.h" /* * To fix a memory leak (memory malloc'd then never freed) in the original * version of lossless JPEG decompression, memory is allocated for 4 * Huffman tables once here, then pointers set later as needed */ HuffmanTable HuffmanTableMemory[4]; /* * Enumerate all the JPEG marker codes */ typedef enum { M_SOF0 = 0xc0, M_SOF1 = 0xc1, M_SOF2 = 0xc2, M_SOF3 = 0xc3, M_SOF5 = 0xc5, M_SOF6 = 0xc6, M_SOF7 = 0xc7, M_JPG = 0xc8, M_SOF9 = 0xc9, M_SOF10 = 0xca, M_SOF11 = 0xcb, M_SOF13 = 0xcd, M_SOF14 = 0xce, M_SOF15 = 0xcf, M_DHT = 0xc4, M_DAC = 0xcc, M_RST0 = 0xd0, M_RST1 = 0xd1, M_RST2 = 0xd2, M_RST3 = 0xd3, M_RST4 = 0xd4, M_RST5 = 0xd5, M_RST6 = 0xd6, M_RST7 = 0xd7, M_SOI = 0xd8, M_EOI = 0xd9, M_SOS = 0xda, M_DQT = 0xdb, M_DNL = 0xdc, M_DRI = 0xdd, M_DHP = 0xde, M_EXP = 0xdf, M_APP0 = 0xe0, M_APP15 = 0xef, M_JPG0 = 0xf0, M_JPG13 = 0xfd, M_COM = 0xfe, M_TEM = 0x01, M_ERROR = 0x100 } JpegMarker; /* *-------------------------------------------------------------- * * Get2bytes -- * * Get a 2-byte unsigned integer (e.g., a marker parameter length * field) * * Results: * Next two byte of input as an integer. * * Side effects: * Bitstream is parsed. * *-------------------------------------------------------------- */ static Uint Get2bytes () { int a; a = GetJpegChar(); return (a << 8) + GetJpegChar(); } /* *-------------------------------------------------------------- * * SkipVariable -- * * Skip over an unknown or uninteresting variable-length marker * * Results: * None. * * Side effects: * Bitstream is parsed over marker. * * *-------------------------------------------------------------- */ static void SkipVariable () { int length; length = Get2bytes () - 2; while (length--) { GetJpegChar(); } } /* *-------------------------------------------------------------- * * GetDht -- * * Process a DHT marker * * Results: * None * * Side effects: * A huffman table is read. * Exits on error. * *-------------------------------------------------------------- */ static void GetDht (DecompressInfo *dcPtr) { int length; Uchar bits[17]; Uchar huffval[256]; int i, index, count; HuffmanTable **htblptr; length = Get2bytes () - 2; while (length) { index = GetJpegChar(); bits[0] = 0; count = 0; for (i = 1; i <= 16; i++) { bits[i] = GetJpegChar(); count += bits[i]; } if (count > 256) { fprintf (stderr, "Bogus DHT counts"); return; /* MAL exit(1); */ } for (i = 0; i < count; i++) huffval[i] = GetJpegChar(); length -= 1 + 16 + count; if (index & 0x10) { /* AC table definition */ fprintf(stderr,"Huffman table for lossless JPEG is not defined.\n"); } else { /* DC table definition */ htblptr = &dcPtr->dcHuffTblPtrs[index]; } if (index < 0 || index >= 4) { fprintf (stderr, "Bogus DHT index %d", index); return; /* MAL exit(1); */ } if (*htblptr == NULL) { /* *htblptr = (HuffmanTable *) malloc (sizeof (HuffmanTable)); +++*/ *htblptr = &HuffmanTableMemory[index]; if (*htblptr==NULL) { fprintf(stderr,"Can't malloc HuffmanTable\n"); return; /* MAL exit(-1); */ } } MEMCPY((*htblptr)->bits, bits, sizeof ((*htblptr)->bits)); MEMCPY((*htblptr)->huffval, huffval, sizeof ((*htblptr)->huffval)); } } /* *-------------------------------------------------------------- * * GetDri -- * * Process a DRI marker * * Results: * None * * Side effects: * Exits on error. * Bitstream is parsed. * *-------------------------------------------------------------- */ static void GetDri (DecompressInfo *dcPtr) { if (Get2bytes () != 4) { fprintf (stderr, "Bogus length in DRI"); return; /* MAL exit(1); */ } dcPtr->restartInterval = (Ushort) Get2bytes (); } /* *-------------------------------------------------------------- * * GetApp0 -- * * Process an APP0 marker. * * Results: * None * * Side effects: * Bitstream is parsed * *-------------------------------------------------------------- */ static void GetApp0 () { int length; length = Get2bytes () - 2; while (length-- > 0) /* skip any remaining data */ (void)GetJpegChar(); } /* *-------------------------------------------------------------- * * GetSof -- * * Process a SOFn marker * * Results: * None. * * Side effects: * Bitstream is parsed * Exits on error * dcPtr structure is filled in * *-------------------------------------------------------------- */ static int GetSof (DecompressInfo *dcPtr, int code) { int length; short ci; int c; JpegComponentInfo *compptr; code = code; length = Get2bytes (); dcPtr->dataPrecision = GetJpegChar(); dcPtr->imageHeight = Get2bytes (); dcPtr->imageWidth = Get2bytes (); dcPtr->numComponents = GetJpegChar(); /* * We don't support files in which the image height is initially * specified as 0 and is later redefined by DNL. As long as we * have to check that, might as well have a general sanity check. */ if ((dcPtr->imageHeight <= 0 ) || (dcPtr->imageWidth <= 0) || (dcPtr->numComponents <= 0)) { fprintf (stderr, "Empty JPEG image (DNL not supported)"); return 0; /* MAL exit(1); */ } if ((dcPtr->dataPrecisiondataPrecision>MaxPrecisionBits)) { fprintf (stderr, "Unsupported JPEG data precision"); return 0; /* MAL exit(1); */ } if (length != (dcPtr->numComponents * 3 + 8)) { fprintf (stderr, "Bogus SOF length"); return 0; /* MAL exit(1); */ } for (ci = 0; ci < dcPtr->numComponents; ci++) { compptr = &dcPtr->compInfo[ci]; compptr->componentIndex = ci; compptr->componentId = GetJpegChar(); c = GetJpegChar(); compptr->hSampFactor = (c >> 4) & 15; compptr->vSampFactor = (c) & 15; (void) GetJpegChar(); /* skip Tq */ } return 1; }/*endof GetSof */ /* *-------------------------------------------------------------- * * GetSos -- * * Process a SOS marker * * Results: * None. * * Side effects: * Bitstream is parsed. * Exits on error. * *-------------------------------------------------------------- */ static void GetSos (DecompressInfo *dcPtr) { int length; int i, ci, n, c, cc; JpegComponentInfo *compptr; length = Get2bytes (); /* * Get the number of image components. */ n = GetJpegChar(); dcPtr->compsInScan = n; length -= 3; if (length != (n * 2 + 3) || n < 1 || n > 4) { fprintf (stderr, "Bogus SOS length"); return; /* MAL exit(1); */ } for (i = 0; i < n; i++) { cc = GetJpegChar(); c = GetJpegChar(); length -= 2; for (ci = 0; ci < dcPtr->numComponents; ci++) if (cc == dcPtr->compInfo[ci].componentId) { break; } if (ci >= dcPtr->numComponents) { fprintf (stderr, "Invalid component number in SOS"); return; /* MAL exit(1); */ } compptr = &dcPtr->compInfo[ci]; dcPtr->curCompInfo[i] = compptr; compptr->dcTblNo = (c >> 4) & 15; } /* * Get the PSV, skip Se, and get the point transform parameter. */ dcPtr->Ss = GetJpegChar(); (void)GetJpegChar(); c = GetJpegChar(); dcPtr->Pt = c & 0x0F; }/*endof GetSos */ /* *-------------------------------------------------------------- * * GetSoi -- * * Process an SOI marker * * Results: * None. * * Side effects: * Bitstream is parsed. * Exits on error. * *-------------------------------------------------------------- */ static void GetSoi (DecompressInfo *dcPtr) { /* * Reset all parameters that are defined to be reset by SOI */ dcPtr->restartInterval = 0; } /* *-------------------------------------------------------------- * * NextMarker -- * * Find the next JPEG marker Note that the output might not * be a valid marker code but it will never be 0 or FF * * Results: * The marker found. * * Side effects: * Bitstream is parsed. * *-------------------------------------------------------------- */ static int NextMarker () { int c, nbytes; nbytes = 0; do { /* * skip any non-FF bytes */ do { nbytes++; c = GetJpegChar(); } while (c != 0xFF); /* * skip any duplicate FFs without incrementing nbytes, since * extra FFs are legal */ do { c = GetJpegChar(); } while (c == 0xFF); } while (c == 0); /* repeat if it was a stuffed FF/00 */ return c; } /* *-------------------------------------------------------------- * * ProcessTables -- * * Scan and process JPEG markers that can appear in any order * Return when an SOI, EOI, SOFn, or SOS is found * * Results: * The marker found. * * Side effects: * Bitstream is parsed. * *-------------------------------------------------------------- */ static JpegMarker ProcessTables (DecompressInfo *dcPtr) { int c; while (1) { c = NextMarker (); switch (c) { case M_SOF0: case M_SOF1: case M_SOF2: case M_SOF3: case M_SOF5: case M_SOF6: case M_SOF7: case M_JPG: case M_SOF9: case M_SOF10: case M_SOF11: case M_SOF13: case M_SOF14: case M_SOF15: case M_SOI: case M_EOI: case M_SOS: return ((JpegMarker)c); case M_DHT: GetDht (dcPtr); break; case M_DQT: fprintf(stderr,"Not a lossless JPEG file.\n"); break; case M_DRI: GetDri (dcPtr); break; case M_APP0: GetApp0 (); break; case M_RST0: /* these are all parameterless */ case M_RST1: case M_RST2: case M_RST3: case M_RST4: case M_RST5: case M_RST6: case M_RST7: case M_TEM: fprintf (stderr, "Warning: unexpected marker 0x%02x", c); break; default: /* must be DNL, DHP, EXP, APPn, JPGn, COM, * or RESn */ SkipVariable (); break; } } }/*endof ProcessTables */ /* *-------------------------------------------------------------- * * ReadFileHeader -- * * Initialize and read the file header (everything through * the SOF marker). * * Results: * None * * Side effects: * Exit on error. * *-------------------------------------------------------------- */ int ReadFileHeader (DecompressInfo *dcPtr) { int c, c2; /* * Demand an SOI marker at the start of the file --- otherwise it's * probably not a JPEG file at all. */ c = GetJpegChar(); c2 = GetJpegChar(); if ((c != 0xFF) || (c2 != M_SOI)) { if( c == EOF ) { fprintf(stderr, "Reached end of input file. All done!\n"); /* fclose(outFile); */ return 0; /* MAL exit(1); */ } else { fprintf (stderr, "Not a JPEG file. Found %02X %02X\n", c, c2); return 0; /* MAL exit (1); */ } }/*endif*/ GetSoi (dcPtr); /* OK, process SOI */ /* * Process markers until SOF */ c = ProcessTables (dcPtr); switch (c) { case M_SOF0: case M_SOF1: case M_SOF3: if (!GetSof (dcPtr, c)) return 0; break; default: fprintf (stderr, "Unsupported SOF marker type 0x%02x", c); return 0; break; } return 1; }/*endof ReadFileHeader*/ /* *-------------------------------------------------------------- * * ReadScanHeader -- * * Read the start of a scan (everything through the SOS marker). * * Results: * 1 if find SOS, 0 if find EOI * * Side effects: * Bitstream is parsed, may exit on errors. * *-------------------------------------------------------------- */ int ReadScanHeader (DecompressInfo *dcPtr) { int c; /* * Process markers until SOS or EOI */ c = ProcessTables (dcPtr); switch (c) { case M_SOS: GetSos (dcPtr); return 1; case M_EOI: return 0; default: fprintf (stderr, "Unexpected marker 0x%02x", c); break; } return 0; }/*endof ReadScanHeader*/ Papyrus3/JpegDir/JpgLless/JPEGUTIL.C0000755000175000017500000002067007535143454014144 0ustar /* * JPEGutil.c -- * * Various utility routines used in the jpeg encoder/decoder. Large parts * are stolen from the IJG code, so: * * Copyright (C) 1991, 1992, Thomas G. Lane. * Part of the Independent JPEG Group's software. * See the file Copyright for more details. * * Copyright (c) 1993 Brian C. Smith, The Regents of the University * of California * All rights reserved. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #include #include #include /* #include */ #include "jpeg.h" #include "mcu.h" #include "proto.h" /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyEalloc3H #include "PapyEalloc3.h" #endif #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyEalloc3H #include "Papaloc3.h" #endif #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif /* * To fix memory leaks, memory is allocated once for the mcu buffers. * Enough memory is reserved to accomodate up to 4096-wide images * with up to 4 components. */ char mcuROW1Memory[4096 * sizeof(MCU)]; char mcuROW2Memory[4096 * sizeof(MCU)]; char buf1Memory[4096 * 4 * sizeof(ComponentType)]; char buf2Memory[4096 * 4 * sizeof(ComponentType)]; unsigned int bitMask[] = { 0xffffffff, 0x7fffffff, 0x3fffffff, 0x1fffffff, 0x0fffffff, 0x07ffffff, 0x03ffffff, 0x01ffffff, 0x00ffffff, 0x007fffff, 0x003fffff, 0x001fffff, 0x000fffff, 0x0007ffff, 0x0003ffff, 0x0001ffff, 0x0000ffff, 0x00007fff, 0x00003fff, 0x00001fff, 0x00000fff, 0x000007ff, 0x000003ff, 0x000001ff, 0x000000ff, 0x0000007f, 0x0000003f, 0x0000001f, 0x0000000f, 0x00000007, 0x00000003, 0x00000001}; /* *-------------------------------------------------------------- * * JroundUp -- * * Compute a rounded up to next multiple of b; a >= 0, b > 0 * * Results: * Rounded up value. * * Side effects: * None. * *-------------------------------------------------------------- */ int JroundUp (int a, int b) { a += b - 1; return a - (a % b); } /* *-------------------------------------------------------------- * * DecoderStructInit -- * * Initalize the rest of the fields in the decompression * structure. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void DecoderStructInit (DecompressInfo *dcPtr) { char *buf1,*buf2; short ci,i; JpegComponentInfo *compPtr; int mcuSize; /* * Check sampling factor validity. */ for (ci = 0; ci < dcPtr->numComponents; ci++) { compPtr = &dcPtr->compInfo[ci]; if ((compPtr->hSampFactor != 1) || (compPtr->vSampFactor != 1)) { fprintf (stderr, "Error: Downsampling is not supported.\n"); return; /* MAL exit(-1); */ } } /* * Prepare array describing MCU composition */ if (dcPtr->compsInScan == 1) { dcPtr->MCUmembership[0] = 0; } else { short ci; if (dcPtr->compsInScan > 4) { fprintf (stderr, "Too many components for interleaved scan"); return; /* MAL exit(1); */ } for (ci = 0; ci < dcPtr->compsInScan; ci++) { dcPtr->MCUmembership[ci] = ci; } } /* * Initialize mucROW1 and mcuROW2 which buffer two rows of * pixels for predictor calculation. */ mcuROW1 = (MCU *) mcuROW1Memory; mcuROW2 = (MCU *) mcuROW2Memory; mcuSize=dcPtr->compsInScan * sizeof(ComponentType); buf1 = buf1Memory; buf2 = buf2Memory; for (i=0;iimageWidth;i++) { mcuROW1[i]=(MCU)(buf1+i*mcuSize); mcuROW2[i]=(MCU)(buf2+i*mcuSize); } }/*endof DecoderStructInit*/ /* *-------------------------------------------------------------- * * FixHuffTbl -- * * Compute derived values for a Huffman table one the DHT marker * has been processed. This generates both the encoding and * decoding tables. * * Results: * None. * * Side effects: * None. * *-------------------------------------------------------------- */ void FixHuffTbl (HuffmanTable *htbl) { int p, i, l, lastp, si; char huffsize[257]; Ushort huffcode[257]; Ushort code; int size; int value, ll, ul; /* * Figure C.1: make table of Huffman code length for each symbol * Note that this is in code-length order. */ p = 0; for (l = 1; l <= 16; l++) { for (i = 1; i <= (int)htbl->bits[l]; i++) huffsize[p++] = (char)l; } huffsize[p] = 0; lastp = p; /* * Figure C.2: generate the codes themselves * Note that this is in code-length order. */ code = 0; si = huffsize[0]; p = 0; while (huffsize[p]) { while (((int)huffsize[p]) == si) { huffcode[p++] = code; code++; } code <<= 1; si++; } /* * Figure C.3: generate encoding tables * These are code and size indexed by symbol value * Set any codeless symbols to have code length 0; this allows * EmitBits to detect any attempt to emit such symbols. */ MEMSET(htbl->ehufsi, 0, sizeof(htbl->ehufsi)); for (p = 0; p < lastp; p++) { htbl->ehufco[htbl->huffval[p]] = huffcode[p]; htbl->ehufsi[htbl->huffval[p]] = huffsize[p]; } /* * Figure F.15: generate decoding tables */ p = 0; for (l = 1; l <= 16; l++) { if (htbl->bits[l]) { htbl->valptr[l] = p; htbl->mincode[l] = huffcode[p]; p += htbl->bits[l]; htbl->maxcode[l] = huffcode[p - 1]; } else { htbl->maxcode[l] = -1; } } /* * We put in this value to ensure HuffDecode terminates. */ htbl->maxcode[17] = 0xFFFFFL; /* * Build the numbits, value lookup tables. * These table allow us to gather 8 bits from the bits stream, * and immediately lookup the size and value of the huffman codes. * If size is zero, it means that more than 8 bits are in the huffman * code (this happens about 3-4% of the time). */ /*bzero (htbl->numbits, sizeof(htbl->numbits));*/ memset(htbl->numbits, 0, sizeof(htbl->numbits)); for (p=0; phuffval[p]; code = huffcode[p]; ll = code << (8-size); if (size < 8) { ul = ll | bitMask[24+size]; } else { ul = ll; } for (i=ll; i<=ul; i++) { htbl->numbits[i] = size; htbl->value[i] = value; } } } } /* *-------------------------------------------------------------- * * FreeArray2D -- * * Free the memory of a 2-D array pointed by arrayPtr. * * Results: * None. * * Side effects: * The memory pointed by arrayPtr is freed. * *-------------------------------------------------------------- */ void FreeArray2D(char **arrayPtr) { /* efree3(arrayPtr[0]); */ efree3 ((void **) arrayPtr); } Papyrus3/JpegDir/JpgLless/PREDICT.H0000755000175000017500000001472007535143454014017 0ustar /* * predictor.h -- * * Code for predictor calculation. Its function version, predictor.c, * is used in debugging compilation. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #ifndef _PREDICTOR #define _PREDICTOR #ifndef DEBUG /* *-------------------------------------------------------------- * * Predict -- * * Calculate the predictor for pixel[row][col][curComp], * i.e. curRowBuf[col][curComp]. It handles the all special * cases at image edges, such as first row and first column * of a scan. * * Results: * predictor is passed out. * * Side effects: * None. * *-------------------------------------------------------------- */ #define Predict(row,col,curComp,curRowBuf,prevRowBuf,Pr,Pt,psv,predictor)\ { register int left,upper,diag,leftcol; \ \ leftcol=col-1; \ if (row==0) { \ \ /* \ * The predictor of first pixel is (1<<(Pr-Pt-1), and the \ * predictors for rest of first row are left neighbors. \ */ \ if (col==0) { \ *predictor = (1<<(Pr-Pt-1)); \ } \ else { \ *predictor = curRowBuf[leftcol][curComp]; \ } \ } \ else { \ \ /* \ * The predictors of first column are upper neighbors. \ * All other preditors are calculated according to psv. \ */ \ upper=prevRowBuf[col][curComp]; \ if (col==0) \ *predictor = upper; \ else { \ left=curRowBuf[leftcol][curComp]; \ diag=prevRowBuf[leftcol][curComp]; \ switch (psv) { \ case 0: \ *predictor = 0; \ break; \ case 1: \ *predictor = left; \ break; \ case 2: \ *predictor = upper; \ break; \ case 3: \ *predictor = diag; \ break; \ case 4: \ *predictor = left+upper-diag; \ break; \ case 5: \ *predictor = left+((upper-diag)>>1); \ break; \ case 6: \ *predictor = upper+((left-diag)>>1); \ break; \ case 7: \ *predictor = (left+upper)>>1; \ break; \ default: \ fprintf(stderr,"Warning: Undefined PSV\n"); \ *predictor = 0; \ } \ } \ } \ } /* *-------------------------------------------------------------- * * QuickPredict -- * * Calculate the predictor for sample curRowBuf[col][curComp]. * It does not handle the special cases at image edges, such * as first row and first column of a scan. We put the special * case checkings outside so that the computations in main * loop can be simpler. This has enhenced the performance * significantly. * * Results: * predictor is passed out. * * Side effects: * None. * *-------------------------------------------------------------- */ #define QuickPredict(col,curComp,curRowBuf,prevRowBuf,psv,predictor){ \ register int left,upper,diag,leftcol; \ \ /* \ * All predictor are calculated according to psv. \ */ \ switch (psv) { \ case 0: \ *predictor = 0; \ break; \ case 1: \ *predictor = curRowBuf [col-1] [curComp]; \ break; \ case 2: \ *predictor = prevRowBuf[col][curComp]; \ break; \ case 3: \ *predictor = prevRowBuf [col-1] [curComp]; \ break; \ case 4: \ leftcol = col-1; \ upper = prevRowBuf[col][curComp]; \ left = curRowBuf[leftcol][curComp]; \ diag = prevRowBuf[leftcol][curComp]; \ *predictor = left + upper - diag; \ break; \ case 5: \ leftcol = col-1; \ upper = prevRowBuf[col][curComp]; \ left = curRowBuf[leftcol][curComp]; \ diag = prevRowBuf[leftcol][curComp]; \ *predictor = left+((upper-diag)>>1); \ break; \ case 6: \ leftcol = col-1; \ upper = prevRowBuf[col][curComp]; \ left = curRowBuf[leftcol][curComp]; \ diag = prevRowBuf[leftcol][curComp]; \ *predictor = upper+((left-diag)>>1); \ break; \ case 7: \ leftcol = col-1; \ upper = prevRowBuf[col][curComp]; \ left = curRowBuf[leftcol][curComp]; \ *predictor = (left+upper)>>1; \ break; \ default: \ fprintf(stderr,"Warning: Undefined PSV\n"); \ *predictor = 0; \ } \ } #endif /* DEBUG */ #endif /* _PREDICTOR */ Papyrus3/JpegDir/JpgLless/pnmtoljpoptimisebug.c0000755000175000017500000001742307535143454017076 0ustar /* * pnmtoljpoptimisebug.c -- * * This is the main routine for the lossless JPEG encoder. * * Tranformations were made in order to integrate the lossless JPEG * in the Papyrus Toolkit and to increase the speed. * Main options proposed by the Cornell Univ. were disabled, such as * Huffman table optimization. However this encoder is still JPEG compliant. * Two kinds of images are now supported by this lossless encoder: * - 8-bits grayscale images, * - 16-bits grayscale images. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Copyright (c) 1997 OSIRIS Team. Digital Imaging Unit * University Hospital of Geneva * changes made by David Bandon * All rights reserved * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #include #include #include #include #include "jpeg.h" #include "mcu.h" #include "proto.h" #include "jpegless.h" /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #ifndef PapyEalloc3H #include "PapyEalloc3.h" #endif #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PapyDef3.h" #endif #ifndef PapyEalloc3H #include "Papaloc3.h" #endif #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif #define HEADERSIZE 1000 /* * Global and static variables */ int verbose; /* If verbose!=0, the verbose flag is on. */ int psvSet[7]; /* The PSV set */ int numSelValue; /* Number of elements in psvPSV */ PapyULong inputFileBytes; /* Total input file bytes */ PapyULong outputFileBytes; /* Total output file bytes */ long totalHuffSym[7]; /* Total bits of Huffman coded categroy symbols */ long totalAddBits[7]; /* Total additional bits */ static PAPY_FILE OutFile; /* Output file pointer */ PapyUChar *JPEGBuffer; /* Buffer for JPEG Data */ PapyUChar *readimBuffer; /* Buffer for input image 8 bytes */ PapyUShort *readim16Buffer;/* Buffer for input image 16 bytes */ extern void PmRead (CompressInfo *, int); extern void HuffOptimize (CompressInfo *, long *); extern void LoadStdHuffTables (CompressInfo *); /* *-------------------------------------------------------------- * * WriteJpegData -- * * This is an interface routine to the JPEG library. The * library calls this routine to output a block of data. * * Results: * Number of bytes written. If this is less than numBytes, * it indeicates an error. * * Side effects: * The number of bytes output this time is added to * outputFileBytes. * *-------------------------------------------------------------- */ PapyULong WriteJpegData (PapyUChar *buffer, PapyULong numBytes) /* Data to write */ /* Number of bytes to write */ { PapyULong i; for (i=0; idcTblNo = 0; } /* for */ /* * Load and prepare the standard Huffman table. */ LoadStdHuffTables(&enInfo); for (i = 0; i < enInfo.compsInScan; i++) { compPtr = enInfo.curCompInfo [i]; FixHuffTbl ((enInfo.dcHuffTblPtrs) [compPtr->dcTblNo]); } /* for */ /* * Apply a default psv if optimize flag is off * Select the best PSV using standard Huffman table if optimize flag is on */ if (optimize == 0) enInfo.Ss = 1; else { StdPickSelValue (&enInfo, (long *) &CountBits); JPEGSize = (CountBits >> 3) + HEADERSIZE; } /* * Write the frame and scan headers. Encode the image. * Clean up everything. */ /* Assign memory for JPEG data. Note that the space is redefined since * we do not know the required space before compression */ if (JPEGSize == 0) { if (enInfo.dataPrecision == 8) JPEGSize = enInfo.imageWidth * enInfo.imageHeight; else JPEGSize = enInfo.imageWidth * enInfo.imageHeight * 4; } JPEGBuffer = (PapyUChar *) ecalloc3 ((PapyULong) JPEGSize, (PapyULong) sizeof (PapyUChar)); WriteFileHeader (&enInfo); WriteScanHeader (&enInfo); HuffEncode (&enInfo, (PapyUShort *) Image); /* FreeArray2D ((char **) &mcuTable); */ /* efree3((void **) &mcuTable[0]); */ if (optimize == 1) efree3((void **) &mcuTable); HuffEncoderTerm (); WriteFileTrailer (&enInfo); FlushBytes (); efree3 ((void **) &(enInfo.compInfo)); efree3 ((void **) &(enInfo.dcHuffTblPtrs[0])); efree3 ((void **) &(enInfo.dcHuffTblPtrs[1])); *JPEGBytes = outputFileBytes; *JPEGInput = (PapyUChar *) JPEGBuffer; } /* endof JPEGLosslessEncodeImage */ Papyrus3/JpegDir/JpgLless/IO.H0000755000175000017500000001061207535143454013230 0ustar /* * Copyright (C) 1991, 1992, Thomas G. Lane. * Part of the Independent JPEG Group's software. * See the file Copyright for more details. * * Copyright (c) 1993 Brian C. Smith, The Regents of the University * of California * All rights reserved. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Copyright (c) 1997 OSIRIS Team. Digital Imaging Unit * University Hospital of Geneva * Changes made by Yves Ligier and David Bandon * All rights reserved * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PAPYDEF3.h" #endif #endif /* FILENAME83 defined */ #ifndef _IO #define _IO #include "jpeg.h" /* * Size of the input and output buffer */ #define JPEG_BUF_SIZE 4096 /* * The following variables keep track of the input and output * buffer for the JPEG data. */ extern PapyUChar outputBuffer[JPEG_BUF_SIZE]; /* output buffer */ extern PapyULong numOutputBytes; /* bytes in the output buffer */ extern PapyUChar *inputBuffer; /* Input buffer for JPEG data */ extern int inputBufferOffset; /* Offset of current byte */ extern PapyUChar *readimBuffer; /* input buffer for image data 8 bytes (DB) */ extern PapyUShort *readim16Buffer; /* input buffer for image data 16bytes (DB) */ extern int readimBufferOffset; /* Offset of current byte */ /* * the output file pointer. */ extern PAPY_FILE OutFile; /* *-------------------------------------------------------------- * * EmitByte -- * * Write a single byte out to the output buffer, and * flush if it's full. * * Results: * None. * * Side effects: * The outp[ut buffer may get flushed. * *-------------------------------------------------------------- */ #define EmitByte(val) { \ if (numOutputBytes >= JPEG_BUF_SIZE) { \ FlushBytes(); \ } \ outputBuffer[numOutputBytes++] = (PapyUChar)(val); \ } /* *-------------------------------------------------------------- * * GetJpegChar, UnGetJpegChar -- * * Macros to get the next character from the input stream. * * Results: * GetJpegChar returns the next character in the stream, or EOF * UnGetJpegChar returns nothing. * * Side effects: * A byte is consumed or put back into the inputBuffer. * *-------------------------------------------------------------- */ #define GetJpegChar() (inputBuffer [inputBufferOffset++]) \ #define UnGetJpegChar(ch) (inputBuffer[--inputBufferOffset]=(ch)) /* *-------------------------------------------------------------- * * GetImChar and GetImShort * * Macros to get the next character or short from the input stream. * * Results: * GetImChar returns the next character in the stream, or EOF * GetImShort returns the next Short in the stream, or EOF * * Side effects: * A byte is consumed or put back into the readimBuffer. * *-------------------------------------------------------------- */ #define GetImChar() (readimBuffer[readimBufferOffset++]) #define GetImShort() (readim16Buffer[readimBufferOffset++]) #endif /* _IO */ Papyrus3/JpegDir/JpgLless/maincompression.c0000755000175000017500000001102307535143454016157 0ustar #include #include #include #include #include #ifdef Mac #include #include #include #include #endif #include "jpeg.h" #include "JPEGLess.h" #include "io.h" /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #ifndef PapyEalloc3H #include "PapyEalloc3.h" #endif #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PAPYDEF3.h" #endif #ifndef PapyEalloc3H #include "Papaloc3.h" #endif #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif /* FILENAME83 defined */ Uchar *ImageBuffer; /* FILE **inFile, **outFile; */ void main(void) { PAPY_FILE InFile; PAPY_FILE OutFile; PapyShort err; char fileName [256]; #ifdef Mac FSSpec fFileIn; #else void *fFileIn; #endif /* FSSpec fFileOut; */ char name[30]; void *fFileOut; PapyULong lenght; struct stat buf_stat; PapyULong foo =0L; time_t tempsBegin; long outputJPEGBytes; Uchar *JPEGData; int ImWidth, ImHeight, ImPrecision; PapyUHShort *ImageBufferShort; /* err = ProfilerInit(collectSummary, ticksTimeBase, 100, 20); if (err != 0) { printf("Error in ProfilerInit: %d \n", err); perror("erreur"); exit(-1); } ProfilerSetStatus(false); */ strcpy((char *) fileName, "Ankle.brut"); /* c2pstr((char *) fileName); */ strcpy((char *) name, "Ankle.jpeg"); err = strcmp((char *) fileName, "Ankle.brut"); if ( err == 0) { ImWidth = 1184; ImHeight = 884; ImPrecision = 8; } else { if ( strcmp((char *) fileName, "F-18.brut") == 0) { ImWidth = 320; ImHeight = 240; ImPrecision = 8; } else { if ( strcmp((char *) fileName, "Crois16b.brut") == 0) { ImWidth = 512; ImHeight = 512; ImPrecision = 16; } else { if ( strcmp((char *) fileName, "degrade16b.brut") == 0) { ImWidth = 1024; ImHeight = 1024; ImPrecision = 16; } else exit(-1); } } } /* c2pstr((char *) name); */ printf("Compile %s result: %s\n", fileName, name); #ifdef Mac strcpy((char *) fFileIn.name, fileName); c2pstr((char *) fFileIn.name); fFileIn.vRefNum = - LMGetSFSaveDisk (); fFileIn.parID = LMGetCurDirStore (); #endif /* Open the infile in the Papyrus 3 way */ err= Papy3FOpen (fileName, 'r', 0, &InFile, (void *) &fFileIn); if (err < 0) { printf("Open infile failed... %d\n", err); exit(-1); } /* Rewind the infile */ err = Papy3FSeek(InFile, SEEK_SET, 0L); if (err < 0) { printf("Seek infile failed... \n"); exit(-1); } /* Open the outfile in the Papyrus 3 way */ err= Papy3FCreate (name, 0, 0, &OutFile, &fFileOut); if (err < 0) { printf("Creation outfile failed... \n"); exit(-1); } err= Papy3FOpen (name, 'w', 0, &OutFile, fFileOut); if (err < 0) { printf("Open outfile failed... \n"); exit(-1); } /* err= Papy3FOpen (NULL, 'w', 0, &OutFile, (void *) &fFileOut); if (err < 0) { printf("Open outfile failed... %d\n", err); exit(-1); } */ /* Rewind the file */ err = Papy3FSeek(OutFile, SEEK_SET, 0L); if (err < 0) { printf("Seek outfile failed... \n"); exit(-1); } if (fstat(InFile,&buf_stat) == -1) { printf("error in stat \n"); exit(-1); } lenght = buf_stat.st_size; ImageBuffer = (PapyUHChar *) ecalloc3((PapyULong) lenght+5, (PapyULong) sizeof(PapyUHChar)); Papy3FRead (InFile, (PapyULong *) &lenght, (PapyULong) foo, (void *) ImageBuffer); ImageBuffer [lenght] = EOF; ImageBufferShort = (PapyUHShort *) ImageBuffer; tempsBegin = time(NULL); /* ProfilerSetStatus(true); */ JPEGLosslessEncodeImage ((PapyUHShort *) ImageBufferShort, (PapyUHChar **) &JPEGData, (PapyULong *) &outputJPEGBytes, ImWidth, ImHeight, ImPrecision); /* ProfilerSetStatus(false); ProfilerDump("\pComOpt16_AnkleSummary.prof"); ProfilerTerm(); */ printf("duree: %d secondes \n", (time(NULL) - tempsBegin)); Papy3FClose (&InFile); err = Papy3FWrite(OutFile, (PapyULong *) &outputJPEGBytes, 1L, JPEGData); if ( err < 0) { printf("error in outfile write process %d\n", err); Papy3FClose (&OutFile); exit(-1); } Papy3FClose (&OutFile); efree3 (&ImageBuffer); efree3 (&JPEGData); }Papyrus3/JpegDir/JpgLless/decompoptimise.c0000755000175000017500000001267507535143454016010 0ustar /* * Decompoptimise.c -- * * This is the routine that is called to decompress a frame of angiographic * image data. It is based on the program originally named ljpgtopnm.c. * Major portions taken from the Independetn JPEG Group' software, and * from the Cornell lossless JPEG code (the original copyright notices * for those packages appears below). * Adaptations were performed by the OSIRIS team in order to optimize the * speed. Only 8 or 16-bits grayscale images can be decompressed. * --------------------------------------------------------------- * * This is the main routine for the lossless JPEG decoder. Large * parts are stolen from the IJG code, so: * * Copyright (C) 1991, 1992, Thomas G. Lane. * Part of the Independent JPEG Group's software. * See the file Copyright for more details. * * Copyright (c) 1993 Brian C. Smith, The Regents of the University * of California * All rights reserved. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Copyright (c) 1997 OSIRIS Team. Digital Imaging Unit * University Hospital of Geneva * Changes made by Yves Ligier and David Bandon * All rights reserved * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #include #include #include /*#include */ #include "io.h" #include "jpeg.h" #include "mcu.h" #include "proto.h" /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #ifndef PapyEalloc3H #include "PapyEalloc3.h" #endif #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PapyDef3.h" #endif #ifndef PapyEalloc3H #include "Papaloc3.h" #endif #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif /* FILENAME83 defined */ DecompressInfo dcInfo; PAPY_FILE JpegInFile; /* *-------------------------------------------------------------- * * ReadJpegData -- * * This is an interface routine to the JPEG library. The * JPEG library calls this routine to "get more data" * * Results: * Number of bytes actually returned. * * Side effects: * None. * *-------------------------------------------------------------- */ PapyULong ReadJpegData (PapyUChar *buffer, PapyULong numBytes) { PapyULong foo = 1L; PapyShort err; err = Papy3FRead (JpegInFile, (PapyULong *) &numBytes, (PapyULong) foo, (void *) buffer); if (err<0) { return err; } return numBytes; } void JPEGLosslessDecodeImage (PAPY_FILE inFile, PapyUShort *image16, int depth, PapyULong length) { /* Initialization */ JpegInFile = inFile; MEMSET (&dcInfo, 0, sizeof (dcInfo)); inputBufferOffset = 0; /* Allocate input buffer */ inputBuffer = (PapyUChar *) emalloc3 ((PapyULong)length+5); if (inputBuffer == NULL) { return; } /* Read input buffer */ ReadJpegData ((PapyUChar *)inputBuffer, length); inputBuffer [length] = EOF; if (!ReadFileHeader (&dcInfo)) return;/* Read JPEG File header */ if (!ReadScanHeader (&dcInfo)) return;/* Read the scan header. */ /* * Decode the image bits stream. Clean up everything when * finished decoding. */ DecoderStructInit (&dcInfo); HuffDecoderInit (&dcInfo); DecodeImage (&dcInfo, (PapyUShort **) &image16, depth); /* Free input buffer */ efree3 ((void **)&inputBuffer); return; } void JPEGDecode_WithoutFile (PapyUShort *JPEGPix, PapyUShort *image16,int depth, PapyULong length) { /* Initialization */ MEMSET (&dcInfo, 0, sizeof (dcInfo)); inputBufferOffset = 0; /* Allocate input buffer */ inputBuffer = (PapyUChar *) JPEGPix; if (inputBuffer == NULL) { /* printf("Error with malloc\n"); */ return; /* MAL exit(-1); */ } inputBuffer [length] = EOF; if (!ReadFileHeader (&dcInfo)) return;/* Read JPEG File header */ if (!ReadScanHeader (&dcInfo)) return;/* Read the scan header. */ /* * Decode the image bits stream. Clean up everything when * finished decoding. */ DecoderStructInit (&dcInfo); HuffDecoderInit (&dcInfo); DecodeImage (&dcInfo, (PapyUShort **) &image16, depth); /* Free input buffer */ /* efree3 ((void **)&inputBuffer); */ return; } Papyrus3/JpegDir/JpgLless/Jlless.ncb0000755000175000017500000000004707535143454014531 0ustar Microsoft C/C++ program database 2.00 Papyrus3/JpegDir/JpgLless/huffdoptimise.c0000755000175000017500000007677407535143454015647 0ustar /* * Huffdoptimise.c -- * * Code for JPEG lossless decoding. Large parts are grabbed from the IJG * software, so: * * Copyright (C) 1991, 1992, Thomas G. Lane. * Part of the Independent JPEG Group's software. * See the file Copyright for more details. * * Copyright (c) 1993 Brian C. Smith, The Regents of the University * of California * All rights reserved. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Copyright (c) 1997 OSIRIS Team. Digital Imaging Unit * University Hospital of Geneva * Changes made by Yves Ligier and David Bandon * All rights reserved * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #include #include #include #include "jpeg.h" #include "mcu.h" #include "io.h" #include "proto.h" #include "predict.h" /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PAPYDEF3.h" #endif #endif /* FILENAME83 defined */ #define MAGCAT16_NUMBITS_MARKER 0x1234 /* TCC */ #define RST0 0xD0 /* RST0 marker code */ static long getBuffer; /* current bit-extraction buffer */ static int bitsLeft; /* # of unused bits in it */ /* * The following variables keep track of the input buffer * for the JPEG data, which is read by ReadJpegData. */ PapyUChar *inputBuffer; /* Input buffer for JPEG data */ int inputBufferOffset = 0; /* Offset of current byte */ /* * Code for extracting the next N bits from the input stream. * (N never exceeds 15 for JPEG data.) * This needs to go as fast as possible! * * We read source bytes into getBuffer and dole out bits as needed. * If getBuffer already contains enough bits, they are fetched in-line * by the macros get_bits() and get_bit(). When there aren't enough bits, * FillBitBuffer is called; it will attempt to fill getBuffer to the * "high water mark", then extract the desired number of bits. The idea, * of course, is to minimize the function-call overhead cost of entering * FillBitBuffer. * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width * of getBuffer to be used. (On machines with wider words, an even larger * buffer could be used.) */ #define BITS_PER_LONG (8*sizeof(long)) #define MIN_GET_BITS (BITS_PER_LONG-7) /* max value for long getBuffer */ /* * bmask[n] is mask for n rightmost bits */ static int bmask[] = {0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF}; /* *-------------------------------------------------------------- * * FillBitBuffer -- * * Load up the bit buffer with at least nbits * Process any stuffed bytes at this time. * * Results: * None * * Side effects: * The bitwise global variables are updated. * *-------------------------------------------------------------- */ #define FillBitBuffer(nbits) { \ int c, c2; \ while (bitsLeft < MIN_GET_BITS) { \ c = GetJpegChar (); \ /* If it's 0xFF, check and discard stuffed zero byte */ \ if (c == 0xFF) { \ c2 = GetJpegChar (); \ if (c2 != 0) { \ UnGetJpegChar (c2); \ UnGetJpegChar (c); \ c = 0; \ } \ }/*endif 0xFF*/ \ /* OK, load c into getBuffer */ \ getBuffer = (getBuffer << 8) | c; \ bitsLeft += 8; \ }/*endwhile*/ \ }/*endof FillBitBuffer*/ /* Macros to make things go at some speed! */ /* NB: parameter to get_bits should be simple variable, not expression */ /* #define PmPutRow8(RowBufi,numColo,imagei) { \ register int col; \ for (col = 0; col < numColo; col++) { \ (**imagei) = (PapyUChar) (RowBufi[col][0]); \ ((*imagei)++); \ } \ } */ #define show_bits(nbits,rv) { \ if (bitsLeft < nbits) FillBitBuffer(nbits); \ rv = (getBuffer >> (bitsLeft-(nbits))) & bmask[nbits]; \ } #define show_bits8(rv) { \ if (bitsLeft < 8) FillBitBuffer(8); \ rv = (getBuffer >> (bitsLeft-8)) & 0xff; \ } #define flush_bits(nbits) { \ bitsLeft -= (nbits); \ } #define get_bits(nbits,rv) { \ if (bitsLeft < nbits) FillBitBuffer(nbits); \ rv = ((getBuffer >> (bitsLeft -= (nbits)))) & bmask[nbits]; \ } #define get_bit(rv) { \ if (!bitsLeft) FillBitBuffer(1); \ rv = (getBuffer >> (--bitsLeft)) & 1; \ } /* *-------------------------------------------------------------- * * PmPutRow -- * * Output one row of pixels stored in RowBuf. * * Results: * None * * Side effects: * One row of pixels are write to file pointed by outFile. * *-------------------------------------------------------------- */ void PmPutRow16(MCU *RowBuf, int numCol, PapyUShort **image) { register int col; for (col = 0; col < numCol; col++) { **image = (PapyUShort) RowBuf[col][0]; (*image)++; } } void PmPutRow8(MCU *RowBuf, int numCol, PapyUChar **image) { register int col; for (col = 0; col < numCol; col++) { **image = (PapyUChar) RowBuf[col][0]; (*image)++; } } /* *-------------------------------------------------------------- * * HuffDecode -- * * Taken from Figure F.16: extract next coded symbol from * input stream. This should becode a macro. * * Results: * Next coded symbol * * Side effects: * Bitstream is parsed. * *-------------------------------------------------------------- */ #define HuffDecode(htbl,rv) \ { \ register int l, code, temp; \ int bMagCat16; \ \ /* \ * If the huffman code is less than 8 bits, we can use the fast \ * table lookup to get its value. It's more than 8 bits about \ * 3-4% of the time. \ */ \ show_bits8(code); \ if (htbl->numbits[code]) { \ flush_bits(htbl->numbits[code]); \ rv=htbl->value[code]; \ } \ else { \ flush_bits(8); \ l = 8; \ while (code > htbl->maxcode[l]) { \ get_bit(temp); \ code = (code << 1) | temp; \ l++; \ } \ \ /* \ * With garbage input we may reach the sentinel value l = 17. \ */ \ \ if (l > 16) { \ fprintf (stderr, "Corrupt JPEG data: bad Huffman code"); \ rv = 0; /* fake a zero as the safest result */ \ } else { \ rv = htbl->huffval[htbl->valptr[l] + \ ((int)(code - htbl->mincode[l]))]; \ } \ }/*endelse*/ \ /* TCC to handle magnitude category 16 */ \ bMagCat16 = (rv==16) && !(code & 0xff00) && \ (htbl->numbits[code] < 9); \ if ( bMagCat16 ) \ rv = MAGCAT16_NUMBITS_MARKER; \ \ }/*HuffDecode*/ /* *-------------------------------------------------------------- * * HuffExtend -- * * Code and table for Figure F.12: extend sign bit * * Results: * The extended value. * * Side effects: * None. * *-------------------------------------------------------------- */ static int extendTest[17] = /* entry n is 2**(n-1) */ {0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x8000}; static int extendOffset[17] = /* entry n is (-1 << n) + 1 */ {0, ((-1) << 1) + 1, ((-1) << 2) + 1, ((-1) << 3) + 1, ((-1) << 4) + 1, ((-1) << 5) + 1, ((-1) << 6) + 1, ((-1) << 7) + 1, ((-1) << 8) + 1, ((-1) << 9) + 1, ((-1) << 10) + 1, ((-1) << 11) + 1, ((-1) << 12) + 1, ((-1) << 13) + 1, ((-1) << 14) + 1, ((-1) << 15) + 1, ((-1) <<16) + 1}; #define HuffExtend(x,s) { \ if ((x) < extendTest[s]) { \ (x) += extendOffset[s]; \ } \ } /* *-------------------------------------------------------------- * * HuffDecoderInit -- * * Initialize for a Huffman-compressed scan. * This is invoked after reading the SOS marker. * * Results: * None * * Side effects: * None. * *-------------------------------------------------------------- */ void HuffDecoderInit (DecompressInfo *dcPtr) { short ci; JpegComponentInfo *compptr; /* * Initialize static variables */ bitsLeft = 0; for (ci = 0; ci < dcPtr->compsInScan; ci++) { compptr = dcPtr->curCompInfo[ci]; /*compptr->dcTblNo = 0; */ /* DAB for CT GE images */ /* * Make sure requested tables are present */ if (dcPtr->dcHuffTblPtrs[compptr->dcTblNo] == NULL) { fprintf (stderr, "Error: Use of undefined Huffman table\n"); return; /* MAL exit(1); */ } /* * Compute derived values for Huffman tables. * We may do this more than once for same table, but it's not a * big deal */ FixHuffTbl (dcPtr->dcHuffTblPtrs[compptr->dcTblNo]); } /* * Initialize restart stuff */ dcPtr->restartInRows = (dcPtr->restartInterval)/(dcPtr->imageWidth); dcPtr->restartRowsToGo = dcPtr->restartInRows; dcPtr->nextRestartNum = 0; } /* *-------------------------------------------------------------- * * ProcessRestart -- * * Check for a restart marker & resynchronize decoder. * * Results: * None. * * Side effects: * BitStream is parsed, bit buffer is reset, etc. * *-------------------------------------------------------------- */ static void ProcessRestart(DecompressInfo *dcPtr) { int c, nbytes; /*short ci;*/ /* * Throw away any unused bits remaining in bit buffer */ nbytes = bitsLeft / 8; bitsLeft = 0; /* * Scan for next JPEG marker */ do { do { /* skip any non-FF bytes */ nbytes++; c = GetJpegChar (); } while (c != 0xFF); do { /* skip any duplicate FFs */ /* * we don't increment nbytes here since extra FFs are legal */ c = GetJpegChar (); } while (c == 0xFF); } while (c == 0); /* repeat if it was a stuffed FF/00 */ if (c != (RST0 + dcPtr->nextRestartNum)) { /* * Uh-oh, the restart markers have been messed up too. * Just bail out. */ fprintf (stderr, "Error: Corrupt JPEG data. Exiting...\n"); return; /* MAL exit(-1); */ } /* * Update restart state */ dcPtr->restartRowsToGo = dcPtr->restartInRows; dcPtr->nextRestartNum = (dcPtr->nextRestartNum + 1) & 7; } /* *-------------------------------------------------------------- * * DecodeFirstRow -- * * Decode the first raster line of samples at the start of * the scan and at the beginning of each restart interval. * This includes modifying the component value so the real * value, not the difference is returned. * * Results: * None. * * Side effects: * Bitstream is parsed. * *-------------------------------------------------------------- */ void DecodeFirstRow (DecompressInfo *dcPtr, MCU *curRowBuf) { register short curComp,ci; register int s,col,compsInScan,numCOL; register JpegComponentInfo *compptr; int Pr,Pt,d; HuffmanTable *dctbl; Pr=dcPtr->dataPrecision; Pt=dcPtr->Pt; compsInScan=dcPtr->compsInScan; numCOL=dcPtr->imageWidth; /* * the start of the scan or at the beginning of restart interval. */ for (curComp = 0; curComp < compsInScan; curComp++) { ci = dcPtr->MCUmembership[curComp]; compptr = dcPtr->curCompInfo[ci]; dctbl = dcPtr->dcHuffTblPtrs[compptr->dcTblNo]; /* * Section F.2.2.1: decode the difference */ HuffDecode (dctbl,s); if (s && s!=MAGCAT16_NUMBITS_MARKER) { get_bits(s,d); HuffExtend(d,s); } else if ( s==MAGCAT16_NUMBITS_MARKER ) { d = 32768; } else d = 0; /* * Add the predictor to the difference. */ curRowBuf[0][curComp]=d+(1<<(Pr-Pt-1)); } /* * the rest of the first row */ for (col=1; colMCUmembership[curComp]; compptr = dcPtr->curCompInfo[ci]; dctbl = dcPtr->dcHuffTblPtrs[compptr->dcTblNo]; /* * Section F.2.2.1: decode the difference */ HuffDecode (dctbl,s); if (s && s!=MAGCAT16_NUMBITS_MARKER) { get_bits(s,d); HuffExtend(d,s); } else if ( s==MAGCAT16_NUMBITS_MARKER ) { d = 32768; } else d = 0; /* * Add the predictor to the difference. */ curRowBuf[col][curComp]=d+curRowBuf[col-1][curComp]; } } if (dcPtr->restartInRows) { (dcPtr->restartRowsToGo)--; } }/*endof DecodeFirstRow*/ /* *-------------------------------------------------------------- * * DecodeImage -- * * Decode the input stream. This includes modifying * the component value so the real value, not the * difference is returned. * * Results: * None. * * Side effects: * Bitstream is parsed. * *-------------------------------------------------------------- */ void DecodeImage (DecompressInfo *dcPtr, PapyUShort **image, int depth) { register int s, d, col, row; register short curComp, ci; HuffmanTable *dctbl; JpegComponentInfo *compptr; int predictor; int numCOL, numROW, compsInScan; MCU *prevRowBuf, *curRowBuf; int imagewidth, Pt, psv; PapyUShort *image16tmp; PapyUChar *image8tmp; numCOL = imagewidth=dcPtr->imageWidth; numROW = dcPtr->imageHeight; compsInScan = dcPtr->compsInScan; Pt = dcPtr->Pt; psv = dcPtr->Ss; prevRowBuf = mcuROW2; curRowBuf = mcuROW1; if (depth == 8) image8tmp = (PapyUChar *) *image; else image16tmp = (PapyUShort *) *image; /* * Decode the first row of image. Output the row and * turn this row into a previous row for later predictor * calculation. */ row = 0; DecodeFirstRow (dcPtr, curRowBuf); if (depth == 8) PmPutRow8(curRowBuf, numCOL, &image8tmp); else PmPutRow16 (curRowBuf, numCOL, &image16tmp); swap(MCU *, prevRowBuf, curRowBuf); /* optimal case : 8 bit image, one color component, no restartInRows */ if ((depth == 8) && (compsInScan == 1) && (dcPtr->restartInRows == 0)) { PapyUChar *curPixelPtr; /* int left,upper,diag; */ /* initializations */ curComp = 0; ci = dcPtr->MCUmembership[curComp]; compptr = dcPtr->curCompInfo[ci]; dctbl = dcPtr->dcHuffTblPtrs[compptr->dcTblNo]; curPixelPtr = image8tmp; if (psv == 1) { for (row=1; row>1)))); curPixelPtr++; }/*endfor col*/ }/*endfor row*/ }/*endif psv == 5*/ else { if (psv == 7) { for (row=1; row>1)); curPixelPtr++; }/*endfor col*/ }/*endfor row*/ }/*endif psv == 7*/ else { if (psv == 6) { for (row=1; row>1)); curPixelPtr++; }/*endfor col*/ }/*endfor row*/ }/*endif psv == 6*/ else { for (row=1; rowrestartInRows == 0)) { PapyUShort *curUSPixelPtr; int left,upper,diag; /* initializations */ curComp = 0; ci = dcPtr->MCUmembership[curComp]; compptr = dcPtr->curCompInfo[ci]; dctbl = dcPtr->dcHuffTblPtrs[compptr->dcTblNo]; curUSPixelPtr = image16tmp; for (row=1; row>1))); curUSPixelPtr++; }/*endfor col*/ }/*endif*/ else { for (col=1; col < numCOL; col++) { /* Section F.2.2.1: decode the difference */ HuffDecode (dctbl, s); if (s && s!=MAGCAT16_NUMBITS_MARKER) { get_bits (s, d); HuffExtend (d, s); } else if ( s==MAGCAT16_NUMBITS_MARKER ) { d = 32768; } else d = 0; /* Predict : All predictors are calculated according to psv */ switch (psv) { case 0: predictor = 0; break; case 2: predictor = *(curUSPixelPtr - numCOL); break; case 3: predictor = *(curUSPixelPtr - numCOL - 1); break; case 4: upper = *(curUSPixelPtr - numCOL); left = *(curUSPixelPtr - 1); diag = *(curUSPixelPtr - numCOL - 1); predictor = left + upper - diag; break; /* case 5: predictor = *(curPixelPtr - 1) + ((*(curPixelPtr - numCOL) - (*(curPixelPtr - numCOL - 1))>>1)); break; */ case 6: upper = *(curUSPixelPtr - numCOL); left = *(curUSPixelPtr - 1); diag = *(curUSPixelPtr - numCOL - 1); predictor = upper+((left-diag)>>1); break; case 7: upper = *(curUSPixelPtr - numCOL); left = *(curUSPixelPtr - 1); predictor = (left+upper)>>1; break; default : predictor = 0; }/*endsandwich*/ *curUSPixelPtr = (PapyUShort) (d + predictor); curUSPixelPtr++; }/*endfor col*/ } /*endelse 2nd*/ }/*endelse first*/ }/*endfor row*/ }/*end if second optimal case*/ else { /* other cases.... */ for (row=1; rowrestartInRows) { if (dcPtr->restartRowsToGo == 0) { ProcessRestart (dcPtr); /* * Reset predictors at restart. */ DecodeFirstRow(dcPtr,curRowBuf); if (depth == 8) PmPutRow8(curRowBuf, numCOL, &image8tmp); else PmPutRow16(curRowBuf, numCOL, &image16tmp); swap(MCU *,prevRowBuf,curRowBuf); continue; } dcPtr->restartRowsToGo--; }/*endif*/ /* * For the rest of the column on this row, predictor * calculations are base on PSV. */ /* several color components to decode (RGB colors)*/ /* The upper neighbors are predictors for the first column. */ for (curComp = 0; curComp < compsInScan; curComp++) { ci = dcPtr->MCUmembership[curComp]; compptr = dcPtr->curCompInfo[ci]; dctbl = dcPtr->dcHuffTblPtrs[compptr->dcTblNo]; /* Section F.2.2.1: decode the difference */ HuffDecode (dctbl, s); if (s && s!=MAGCAT16_NUMBITS_MARKER) { get_bits(s,d); HuffExtend(d,s); } else if ( s==MAGCAT16_NUMBITS_MARKER ) { d = 32768; } else d = 0; curRowBuf[0][curComp]=d+prevRowBuf[0][curComp]; }/*endfor curComp*/ for (col=1; col < numCOL; col++) { for (curComp = 0; curComp < compsInScan; curComp++) { ci = dcPtr->MCUmembership[curComp]; compptr = dcPtr->curCompInfo[ci]; dctbl = dcPtr->dcHuffTblPtrs[compptr->dcTblNo]; /* Section F.2.2.1: decode the difference */ HuffDecode (dctbl, s); if (s && s!=MAGCAT16_NUMBITS_MARKER) { get_bits (s, d); HuffExtend (d, s); } else if ( s==MAGCAT16_NUMBITS_MARKER ) { d = 32768; } else d = 0; QuickPredict (col,curComp,curRowBuf,prevRowBuf,psv,&predictor); curRowBuf[col][curComp]=d+predictor; }/*endfor curComp*/ }/*endfor col*/ if (depth == 8) PmPutRow8 (curRowBuf, numCOL, &image8tmp); else PmPutRow16 (curRowBuf, numCOL, &image16tmp); swap(MCU *, prevRowBuf, curRowBuf); }/*endfor row*/ } /*end else if second optimal case*/ }/*endelse*/ }/*endofmethod DecodeImage*/ Papyrus3/JpegDir/JpgLless/pmreadoptimise.c0000755000175000017500000001241607535143454016002 0ustar /* * pmreadoptimise.c -- * * Code for loading mcu (Minimum Code Unit). * mcu is loaded only if the psv optimisation is enabled (optimize = 1) * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Copyright (c) 1997 OSIRIS Team. Digital Imaging Unit * University Hospital of Geneva * changes made by David Bandon * All rights reserved * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #include #include "jpeg.h" #include "mcu.h" #include "proto.h" #include "jpegless.h" #include "io.h" /* Papyrus 3 redefined basic types */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyEalloc3H #include "PapyEalloc3.h" #endif #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyEalloc3H #include "Papaloc3.h" #endif #ifndef PapyFileSystem3H #include "PapFSys3.h" #endif #endif #define PM_MAXVAL 65536 int readimBufferOffset = 0; /* *-------------------------------------------------------------- * * PmRead -- * * Read the source image file pointed by inFile. * * Results: * Source image parameters such as width, height, sample * precision and number of color components are passed * out by enInfo. * * Side effects: * Source image is read into mcuTable, input image size * is counted in inputFileBytes. * *-------------------------------------------------------------- */ void PmRead (CompressInfo *enInfo, int optimi) { int maxMcu; JpegComponentInfo *compPtr; int ci, i, j, c; MCU mcu; /* * Initialize inputFileBytes to 2 bytes since magic number is 2 bytes. * Read magic number, cols, rows, and max color level. Convert the * color level to precision bits. */ inputFileBytes=0; enInfo->numComponents = 1; /* Be careful: image must be grayscale */ enInfo->compInfo = (JpegComponentInfo *) emalloc3 (enInfo->numComponents * sizeof (JpegComponentInfo)); /* * Because JPEG standard (DIS) defined downsampling, in our * CompressInfo structure, we have sampling factor and an * index array MCUmembership, in case a MCU contains several * samples of one color component. But in lossless JPEG, one * normally don't use downsampling. */ for (ci = 0; ci < enInfo->numComponents; ci++) { compPtr = &(enInfo->compInfo[ci]); compPtr->componentId = ci; compPtr->componentIndex = ci; compPtr->hSampFactor = 1; compPtr->vSampFactor = 1; } /* * Set curCompInfo equal to compInfo since these is only * one scan. */ enInfo->compsInScan = enInfo->numComponents; for (ci = 0; ci < enInfo->compsInScan; ci++) { enInfo->curCompInfo[ci] = &(enInfo->compInfo[ci]); } /* * Prepare array indexing MCU components into curCompInfo. */ if (enInfo->compsInScan == 1) { enInfo->MCUmembership [0] = 0; } else { if (enInfo->compsInScan > 4) { return; /* MAL exit(-1); */ } for (ci = 0; ci < enInfo->compsInScan; ci++) { enInfo->MCUmembership [ci] = ci; } } /* else */ /* * Alloc mcuTable. Read source image into the table. * Apply point transform if Pt!=0. Update the input * file size - inputFileBytes. */ /* really needed some initialization of these @!?! global variables ... */ numMCU = 0; readimBufferOffset = 0; maxMcu = enInfo->imageWidth * enInfo->imageHeight; inputFileBytes = 0; /* if the psv optimisation is enabled, mcu is loaded */ if (optimi == 1) { InitMcuTable (maxMcu, enInfo->compsInScan); for (i = 0; i < maxMcu; i++) { mcu = MakeMCU (); for (j = 0; j < enInfo->compsInScan; j++) { if (enInfo->dataPrecision == 8) mcu [j] = (Ushort) readimBuffer [readimBufferOffset++]; else mcu [j] = (Ushort) readim16Buffer [readimBufferOffset++]; c = (int)mcu [j]; /* unix compatibility */ if ( c == EOF ) { return; } if (enInfo->Pt != 0) { mcu[j] >>= enInfo->Pt; } } /* end for j */ } /* end for i */ } /* end if optimi */ if (enInfo->dataPrecision == 8) inputFileBytes += maxMcu * enInfo->compsInScan; else inputFileBytes += maxMcu * enInfo->compsInScan * 2; } /* end of function PmRead */ Papyrus3/JpegDir/JpgLless/JPEG.H0000755000175000017500000001644207535143454013455 0ustar /* * jpeg.h -- * * Basic jpeg data structure definitions. * * * Copyright (C) 1991, 1992, Thomas G. Lane. * Part of the Independent JPEG Group's software. * See the file Copyright for more details. * * Copyright (c) 1993 Brian C. Smith, The Regents of the University * of California * All rights reserved. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #ifndef _JPEG #define _JPEG typedef unsigned char Uchar; typedef unsigned short Ushort; typedef unsigned int Uint; /* * The following structure stores basic information about one component. */ typedef struct JpegComponentInfo { /* * These values are fixed over the whole image. * They are read from the SOF marker. */ short componentId; /* identifier for this component (0..255) */ short componentIndex; /* its index in SOF or cPtr->compInfo[] */ /* * Downsampling is not normally used in lossless JPEG, although * it is permitted by the JPEG standard (DIS). We set all sampling * factors to 1 in this program. */ short hSampFactor; /* horizontal sampling factor */ short vSampFactor; /* vertical sampling factor */ /* * Huffman table selector (0..3). The value may vary * between scans. It is read from the SOS marker. */ short dcTblNo; } JpegComponentInfo; /* * One of the following structures is created for each huffman coding * table. We use the same structure for encoding and decoding, so there * may be some extra fields for encoding that aren't used in the decoding * and vice-versa. */ typedef struct HuffmanTable { /* * These two fields directly represent the contents of a JPEG DHT * marker */ Uchar bits[17]; Uchar huffval[256]; /* * This field is used only during compression. It's initialized * FALSE when the table is created, and set TRUE when it's been * output to the file. */ int sentTable; /* * The remaining fields are computed from the above to allow more * efficient coding and decoding. These fields should be considered * private to the Huffman compression & decompression modules. */ Ushort ehufco[256]; char ehufsi[256]; Ushort mincode[17]; int maxcode[18]; short valptr[17]; int numbits[256]; int value[256]; } HuffmanTable; /* * One of the following structures is used to pass around the * compression information. */ typedef struct CompressInfo { /* * Image width, height, and image data precision (bits/sample) */ int imageWidth; int imageHeight; int dataPrecision; /* * compInfo[i] describes component that appears i'th in SOF * numComponents is the # of color components in JPEG image. */ JpegComponentInfo *compInfo; short numComponents; /* * *curCompInfo[i] describes component that appears i'th in SOS. * compsInScan is the # of color components in current scan. */ JpegComponentInfo *curCompInfo[4]; short compsInScan; /* * MCUmembership[i] indexes the i'th component of MCU into the * curCompInfo array. */ short MCUmembership[10]; /* * Pointers to Huffman coding tables, or NULL if not defined. */ HuffmanTable *dcHuffTblPtrs[4]; /* * prediction seletion value (PSV) and point transform parameter (Pt) */ int Ss; int Pt; /* * In lossless JPEG, restart interval shall be an integer * multiple of the number of MCU in a MCU row. */ int restartInRows; /*if > 0, MCU rows per restart interval; 0 = no restart*/ /* * These fields are private data for the entropy encoder */ int restartRowsToGo; /* MCUs rows left in this restart interval */ short nextRestartNum; /* # of next RSTn marker (0..7) */ } CompressInfo; /* * One of the following structures is used to pass around the * decompression information. */ typedef struct DecompressInfo { /* * Image width, height, and image data precision (bits/sample) * These fields are set by ReadFileHeader or ReadScanHeader */ int imageWidth; int imageHeight; int dataPrecision; /* * compInfo[i] describes component that appears i'th in SOF * numComponents is the # of color components in JPEG image. */ JpegComponentInfo compInfo[4]; short numComponents; /* * *curCompInfo[i] describes component that appears i'th in SOS. * compsInScan is the # of color components in current scan. */ JpegComponentInfo *curCompInfo[4]; short compsInScan; /* * MCUmembership[i] indexes the i'th component of MCU into the * curCompInfo array. */ short MCUmembership[10]; /* * ptrs to Huffman coding tables, or NULL if not defined */ HuffmanTable *dcHuffTblPtrs[4]; /* * prediction seletion value (PSV) and point transform parameter (Pt) */ int Ss; int Pt; /* * In lossless JPEG, restart interval shall be an integer * multiple of the number of MCU in a MCU row. */ int restartInterval;/* MCUs per restart interval, 0 = no restart */ int restartInRows; /*if > 0, MCU rows per restart interval; 0 = no restart*/ /* * these fields are private data for the entropy decoder */ int restartRowsToGo; /* MCUs rows left in this restart interval */ short nextRestartNum; /* # of next RSTn marker (0..7) */ } DecompressInfo; /* *-------------------------------------------------------------- * * swap -- * * Swap the contents stored in a and b. * "type" is the variable type of a and b. * * Results: * The values in a and b are swapped. * * Side effects: * None. * *-------------------------------------------------------------- */ #define swap(type,a,b) {type c; c=(a); (a)=(b); (b)=c;} #define MEMSET(s,c,n) memset((void *)(s),(int)(c),(int)(n)) #define MEMCPY(s1,s2,n) memcpy((void *)(s1),(void *)(s2),(int)(n)) /* * Lossless JPEG specifies data precision to be from 2 to 16 bits/sample. */ #define MinPrecisionBits 2 #define MaxPrecisionBits 16 #define MinPrecisionValue 2 #define MaxPrecisionValue 65535 #endif /* _JPEG */ Papyrus3/JpegDir/JpgLless/PROTO.H0000755000175000017500000000576307535143454013637 0ustar /* * Copyright (C) 1991, 1992, Thomas G. Lane. * Part of the Independent JPEG Group's software. * See the file Copyright for more details. * * Copyright (c) 1993 Brian C. Smith, The Regents of the University * of California * All rights reserved. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Copyright (c) 1997 OSIRIS Team. Digital Imaging Unit * University Hospital of Geneva * Changes made by Yves Ligier and David Bandon * All rights reserved * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #ifndef _PROTO #define _PROTO #ifdef __STDC__ # define P(s) s #else # define P(s) () #endif #include "mcu.h" #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PAPYDEF3.h" #endif #endif /* FILENAME83 defined */ /* huffc.c */ void FlushBytes P((void )); void HuffEncoderInit P((CompressInfo *cPtr )); void HuffEncode P((CompressInfo *cPtr, PapyUShort *Image)); void HuffEncoderTerm P((void )); /* huffd.c */ void HuffDecoderInit P((DecompressInfo *dcPtr )); void DecodeImage P((DecompressInfo *dcPtr, PapyUShort **image, int depth)); /* pnmtoljpg.c ljpgtopnm.c */ PapyULong ReadJpegData P((PapyUChar *buffer , PapyULong numBytes)); PapyULong WriteJpegData P((PapyUChar *buffer , PapyULong numBytes)); void StdPickSelValue P((CompressInfo *cPtr, long *bestTotalBits)); /* read.c */ int ReadFileHeader P((DecompressInfo *dcPtr )); int ReadScanHeader P((DecompressInfo *dcPtr )); /* write.c */ void WriteFileTrailer P((CompressInfo *cPtr )); void WriteScanHeader P((CompressInfo *cPtr )); void WriteFileHeader P((CompressInfo *cPtr )); /* util.c */ int JroundUp P((int a , int b )); void DecoderStructInit P((DecompressInfo *dcPtr )); void FixHuffTbl P((HuffmanTable *htbl)); /* mcu.c */ void InitMcuTable P((int numMCU , int blocksInMCU )); void PrintMCU P((int blocksInMCU , MCU mcu )); #undef P #endif /* _PROTO */ Papyrus3/JpegDir/JpgLless/PREDICT.C0000755000175000017500000001515707535143454014017 0ustar /* * predictor.c -- * * Code for predictor calculation. Its macro version, predictor.h, * is used in non-debugging compilation. * * Copyright (c) 1994 Kongji Huang and Brian C. Smith. * Cornell University * All rights reserved. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL CORNELL UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF CORNELL * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * CORNELL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND CORNELL UNIVERSITY HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #include #include "mcu.h" #ifdef DEBUG /* *-------------------------------------------------------------- * * Predict -- * * Calculate the predictor for pixel[row][col][curComp], * i.e. curRowBuf[col][curComp]. It handles the all special * cases at image edges, such as first row and first column * of a scan. * * Results: * predictor is passed out. * * Side effects: * None. * *-------------------------------------------------------------- */ void Predict(int row,int col,int curComp,MCU *curRowBuf,MCU *prevRowBuf, int Pr,int Pt,int psv,int *predictor) /*int row,col; /* position of the pixel to be predicted */ /*int curComp; /* the pixel's component that is predicting */ /*MCU *curRowBuf,*prevRowBuf; /* current and previous row of image */ /*int Pr; /* data precision */ /*int Pt; /* point transformation */ /*int psv; /* predictor selection value */ /*int *predictor; /* preditor value (output) */ { register int left,upper,diag,leftcol; leftcol=col-1; if (row==0) { /* * The predictor of first pixel is (1<<(Pr-Pt-1), and the * predictors for rest of first row are left neighbors. */ if (col==0) { *predictor = (1<<(Pr-Pt-1)); } else { *predictor = curRowBuf[leftcol][curComp]; } } else { /* * The predictors of first column are upper neighbors. * All other preditors are calculated according to psv. */ upper=prevRowBuf[col][curComp]; if (col==0) *predictor = upper; else { left=curRowBuf[leftcol][curComp]; diag=prevRowBuf[leftcol][curComp]; switch (psv) { case 0: *predictor = 0; break; case 1: *predictor = left; break; case 2: *predictor = upper; break; case 3: *predictor = diag; break; case 4: *predictor = left+upper-diag; break; case 5: *predictor = left+((upper-diag)>>1); break; case 6: *predictor = upper+((left-diag)>>1); break; case 7: *predictor = (left+upper)>>1; break; default: fprintf(stderr,"Warning: Undefined PSV\n"); *predictor = 0; } } } } /* *-------------------------------------------------------------- * * QuickPredict -- * * Calculate the predictor for sample curRowBuf[col][curComp]. * It does not handle the special cases at image edges, such * as first row and first column of a scan. We put the special * case checkings outside so that the computations in main * loop can be simpler. This has enhenced the performance * significantly. * * Results: * predictor is passed out. * * Side effects: * None. * *-------------------------------------------------------------- */ void QuickPredict(int col,int curComp,MCU *curRowBuf,MCU *prevRowBuf,int psv,int *predictor) /*int col; /* column # of the pixel to be predicted */ /*int curComp; /* the pixel's component that is predicting */ /*MCU *curRowBuf,*prevRowBuf; /* current and previous row of image */ /*int psv; /* predictor selection value */ /*int *predictor; /* preditor value (output) */ { register int left,upper,diag,leftcol; /* * All predictor are calculated according to psv. */ switch (psv) { case 0: *predictor = 0; break; case 1: leftcol = col-1; left = curRowBuf[leftcol][curComp]; *predictor = left; break; case 2: upper = prevRowBuf[col][curComp]; *predictor = upper; break; case 3: leftcol = col-1; diag = prevRowBuf[leftcol][curComp]; *predictor = diag; break; case 4: leftcol = col-1; upper = prevRowBuf[col][curComp]; left = curRowBuf[leftcol][curComp]; diag = prevRowBuf[leftcol][curComp]; *predictor = left + upper - diag; break; case 5: leftcol = col-1; upper = prevRowBuf[col][curComp]; left = curRowBuf[leftcol][curComp]; diag = prevRowBuf[leftcol][curComp]; *predictor = left+((upper-diag)>>1); break; case 6: leftcol = col-1; upper = prevRowBuf[col][curComp]; left = curRowBuf[leftcol][curComp]; diag = prevRowBuf[leftcol][curComp]; *predictor = upper+((left-diag)>>1); break; case 7: leftcol = col-1; upper = prevRowBuf[col][curComp]; left = curRowBuf[leftcol][curComp]; *predictor = (left+upper)>>1; break; default: fprintf(stderr,"Warning: Undefined PSV\n"); *predictor = 0; } } #endif /*DEBUG*/ Papyrus3/JpegDir/JpgLless/Jlless.dsp0000755000175000017500000001007207535143454014554 0ustar # Microsoft Developer Studio Project File - Name="Jpglless" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=Jpglless - Win32 Release !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "Jlless.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "Jlless.mak" CFG="Jpglless - Win32 Release" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "Jpglless - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "Jpglless - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName ""$/osiris/Papyrus3/JpegDir/JpgLless", MYGAAAAA" # PROP Scc_LocalPath "." CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "Jpglless - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir ".\Release" # PROP BASE Intermediate_Dir ".\Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir ".\Release" # PROP Intermediate_Dir ".\Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /G3 /Zp1 /W3 /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "STRICT" /D "_WIN16_" /D "FILENAME83" /YX /c # ADD CPP /nologo /Zp1 /W3 /O2 /I "..\Papyrus3\\" /I "..\..\..\Papyrus3\\" /I ".." /D "_WINDOWS" /D "STRICT" /D "NDEBUG" /D "WIN32" /YX /FD /c # ADD BASE RSC /l 0x40c # ADD RSC /l 0x40c BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ELSEIF "$(CFG)" == "Jpglless - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir ".\Debug" # PROP BASE Intermediate_Dir ".\Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir ".\Debug" # PROP Intermediate_Dir ".\Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /Zp1 /W3 /Gm /Zi /Od /Gf /Gy /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "_WIN16_" /D "FILENAME83" /YX /Fd"PAPYRUS3.PDB" /c # ADD CPP /nologo /Zp1 /W3 /Gm /Zi /Od /I "..\..\..\Papyrus3\\" /I ".." /D "_WINDOWS" /D "STRICT" /D "_DEBUG" /D "WIN32" /FR /YX /Fd".\PAPYRUS3.PDB" /FD /c # ADD BASE RSC /l 0x40c # ADD RSC /l 0x40c BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ENDIF # Begin Target # Name "Jpglless - Win32 Release" # Name "Jpglless - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90" # Begin Source File SOURCE=.\decompoptimise.c # End Source File # Begin Source File SOURCE=.\huffcoptimisebug.c # End Source File # Begin Source File SOURCE=.\huffdoptimise.c # End Source File # Begin Source File SOURCE=.\JPEGUTIL.C # End Source File # Begin Source File SOURCE=.\MCU.C # End Source File # Begin Source File SOURCE=.\pmreadoptimise.c # End Source File # Begin Source File SOURCE=.\pnmtoljpoptimisebug.c # End Source File # Begin Source File SOURCE=.\PREDICT.C # End Source File # Begin Source File SOURCE=.\READ.C # End Source File # Begin Source File SOURCE=.\WRITE.C # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd" # Begin Source File SOURCE=.\IO.H # End Source File # Begin Source File SOURCE=.\JPEG.H # End Source File # Begin Source File SOURCE=.\JPEGLESS.H # End Source File # Begin Source File SOURCE=.\MCU.H # End Source File # Begin Source File SOURCE=.\PREDICT.H # End Source File # Begin Source File SOURCE=.\PROTO.H # End Source File # End Group # Begin Group "Resource Files" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe" # End Group # End Target # End Project Papyrus3/DicomDir/0000777000175000017500000000000010047674360011231 5ustar Papyrus3/DicomDir/DicomdirPrivFunctionDef3.h0000755000175000017500000001067310044153774016211 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit (DicomDir library) */ /* File : DicomdirPrivFunctionDef3.h */ /* Function : contains the declarations of the private functions */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 02.1999 version 3.6 */ /* */ /********************************************************************************/ #ifndef DicomdirPrivFunctionDef3H #define DicomdirPrivFunctionDef3H /* --- functions definitions --- */ /* --- DicomDirDataSetRead3 --- */ /* --- DicomDirDataSetWrite3 --- */ void LookForGroupsInRecord3 (Record *, int, int *); /* --- DicomDirFiles3 --- */ /* --- DicomDirInit --- */ Record* CreateRecord3 (int); #endif /* DicomdirPrivFunctionDef3H */ Papyrus3/DicomDir/DicomdirPubFunctionDef3.h0000755000175000017500000001177010044153562016011 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit (Dicomdir library) */ /* File : DicomdirPubFunctionDef3.h */ /* Function : contains the declarations of the public functions */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 02.1999 version 3.6 */ /* */ /********************************************************************************/ #ifndef DicomdirPubFunctionDef3H #define DicomdirPubFunctionDef3H /* --- functions definitions --- */ /* --- DicomDirDataSetRead3 --- */ extern EXPORT32 Record* EXPORT Papy3GetRecord (PapyShort, int); /* --- DicomDirDataSetWrite3 --- */ extern EXPORT32 Item* EXPORT Papy3CreateDicomDirDataSet (PapyShort); extern EXPORT32 Item* EXPORT Papy3CreateDirRecItem (Module*); extern EXPORT32 void EXPORT Papy3LinkRecordToDS (Item *, SElement *, int); extern EXPORT32 Record* EXPORT Papy3CreateRecord (int); /* --- DicomDirFiles --- */ extern EXPORT32 PapyShort EXPORT Papy3DicomDirCreate (char *, int, PAPY_FILE, int, void*); extern EXPORT32 PapyShort EXPORT Papy3WriteAndCloseDicomDir (PapyShort, int); /* --- DicomDirInit --- */ extern EXPORT32 PapyShort EXPORT DicD3Init (); extern EXPORT32 PapyShort EXPORT Papy3RecordFree (SElement **, int, int); #endif /* DicomdirPubFunctionDef3H */ Papyrus3/DicomDir/dicomdir.plg0000755000175000017500000000323507535143454013534 0ustar 
    Build Log
    

    
--------------------Configuration: dicomdir - Win32 Debug--------------------

    

    Command Lines
    
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP37C.tmp" with contents
[
/nologo /MLd /W3 /Gm /GX /ZI /Od /I ".." /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /Fp"dicomdir___Win32_Debug/dicomdir.pch" /YX /Fo"dicomdir___Win32_Debug/" /Fd"dicomdir___Win32_Debug/" /FD /GZ  /c 
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirDataSetRead.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirDataSetWrite.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirFiles.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirInit.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirInitRecords.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\OGlobalDicomFunc.cpp"
]
Creating command line "cl.exe @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP37C.tmp" 
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP37D.tmp" with contents
[
/nologo /out:"dicomdir___Win32_Debug\dicomdir.lib" 
.\dicomdir___Win32_Debug\DicomDirDataSetRead.obj
.\dicomdir___Win32_Debug\DicomDirDataSetWrite.obj
.\dicomdir___Win32_Debug\DicomDirFiles.obj
.\dicomdir___Win32_Debug\DicomDirInit.obj
.\dicomdir___Win32_Debug\DicomDirInitRecords.obj
.\dicomdir___Win32_Debug\OGlobalDicomFunc.obj
]
Creating command line "link.exe -lib @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP37D.tmp"

    Output Window
    
Compiling...
DicomDirDataSetRead.c
DicomDirDataSetWrite.c
DicomDirFiles.c
DicomDirInit.c
DicomDirInitRecords.c
OGlobalDicomFunc.cpp
Creating library...




    Results
    
dicomdir.lib - 0 error(s), 0 warning(s)
    Papyrus3/DicomDir/DicomDirDataSetRead.c0000755000175000017500000002642510044157554015137 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit (DicomDir library) */ /* File : DicomDirDataSetRead3.c */ /* Function : contains the function that will manage the reading of */ /* the records. */ /* Authors : Marianne Logean */ /* */ /* History : 05.1997 version 3.5 */ /* 02.1999 version 3.6 */ /* */ /********************************************************************************/ /* ------------------------- includes -----------------------------------------*/ #include #include #ifndef DicomdirH #include "DicomDir.h" #endif /********************************************************************************/ /* */ /* Papy3GetRecord : Get the specified record from the specified data set. */ /* BEWARE: only useful when reading a DICOMDIR file */ /* return : the read record or NULL. */ /* */ /********************************************************************************/ Record * CALLINGCONV Papy3GetRecord (PapyShort inFileNb, int inRecordID) { int i, j, theElemType, theEnumTag, found, theOddGroup; int *theListOfGroupsP, theElem = FALSE; PapyShort theErr; PapyUShort theElemTag, theElemCreator, theTmpTag; PapyULong theNbVal, theLoopVal; UValue_T *theValP, *theTmpValP; SElement *theGrP, *theTmpGrP; Record *theRecordP, *theElemP; /* Must be a DICOMDIR file */ if (gIsPapyFile [inFileNb] != DICOMDIR) return NULL; /* creation of the record */ theRecordP = CreateRecord3 (inRecordID); /* initialize the lists of groups contained in the record to empty */ theListOfGroupsP = (int *) ecalloc3 ((PapyULong) END_GROUP, (PapyULong) sizeof (int)); /* scan the record to find its group composition */ LookForGroupsInRecord3 (theRecordP, inRecordID, theListOfGroupsP); /* loop on the groups */ for (i = 0; i < END_GROUP; i++) { /* read only the needed groups */ if (theListOfGroupsP [i] == 1) { /* look for the group */ if ((theErr = Papy3GotoGroupNb (inFileNb, (PapyShort) (gArrGroup [i].number))) == 0) { /* test wether it is an odd group number or not */ if (gArrGroup [i].number % 2 != 0) { theOddGroup = TRUE; /* look for the owner range of the PAPYRUS 3.0 elements */ theElemCreator = Papy3FindOwnerRange (inFileNb, gArrGroup [i].number, "PAPYRUS 3.0"); } /* if ...odd group number */ else theOddGroup = FALSE; /* read the group */ if ((theErr = Papy3GroupRead (inFileNb, &theGrP)) < 0) { Papy3RecordFree (&theRecordP, inRecordID, TRUE); efree3 ((void **) &theListOfGroupsP); return NULL; } theElemP = theRecordP; /* test each element of the record to see if it belongs to the group */ for (j = 0; j < gArrRecord [inRecordID]; j++, theElemP++) { /* does the element belongs to the group ? */ if (theElemP->group == theGrP->group) { /* locate the enum place of the element given its tag */ theTmpGrP = theGrP; found = FALSE; theEnumTag = 0; theElemTag = theElemP->element; /* if it is an odd group number */ if (theOddGroup && theElemTag >= 0x0100) { /* convert the element range to the one extracted from the file */ /* 0xaabb -> 0x00bb */ theTmpTag = theElemTag << 8; theTmpTag = theTmpTag >> 8; /* put the elem creator in the 2 most significant bytes... */ /* 0x00cc -> 0xcc00 */ theElemTag = theElemCreator << 8; /* ...and the element tag in the 2 less significant bytes */ /* 0xccbb */ theElemTag |= theTmpTag; } /* if ...odd group number */ while (!found && (theEnumTag <= (int) gArrGroup [i].size)) { if (theTmpGrP->element == theElemTag) found = TRUE; else { theEnumTag++; theTmpGrP++; } /* else */ } /* while */ if (found) { /* extract the element */ theValP = Papy3GetElement (theGrP, theEnumTag, &theNbVal, &theElemType); /* put the element in the module */ if (theValP != NULL) { /* test that it has found at least one element */ if (!theElem) theElem = TRUE; /* loop on the values of the element */ for (theLoopVal = 0L, theTmpValP = theValP; theLoopVal < theNbVal; theLoopVal++, theTmpValP++) { /* depending on the VR of the element put it to the group */ switch (theElemType) /* No OB nor OW */ { case SS : Papy3PutElement (theRecordP, j, &(theTmpValP->ss)); break; case USS : case AT : Papy3PutElement (theRecordP, j, &(theTmpValP->us)); break; case SL : Papy3PutElement (theRecordP, j, &(theTmpValP->sl)); break; case UL : Papy3PutElement (theRecordP, j, &(theTmpValP->ul)); break; case FL : Papy3PutElement (theRecordP, j, &(theTmpValP->fl)); break; case FD : Papy3PutElement (theRecordP, j, &(theTmpValP->fd)); break; case AE : case AS : case CS : case DA : case DS : case DT : case IS : case LO : case LT : case PN : case SH : case ST : case TM : case UI : Papy3PutElement (theRecordP, j, &(theTmpValP->a)); break; case SQ : Papy3PutElement (theRecordP, j, &(theTmpValP->sq)); break; } /* switch */ } /* for ...loop on the values of the element */ } /* if ...the element exists */ } /* if ...the element is not pixel data */ } /* if ...the element belongs to this group */ } /* for ...loop on the elements of the record */ /* free the group */ theErr = Papy3GroupFree (&theGrP, FALSE); } /* if ...the group exists */ } /* if ...group has to be read */ } /* for ...reading of the needed groups */ /* delete the lists of groups number of the record */ efree3 ((void **) &theListOfGroupsP); /* if no element found we have to assume the record is empty ... */ if (!theElem) { Papy3RecordFree (&theRecordP, inRecordID, TRUE); return NULL; } /* if */ else return theRecordP; } /* endof Papy3GetRecord */ Papyrus3/DicomDir/Dicmdir3.dsw0000755000175000017500000000103607535143454013410 0ustar Microsoft Developer Studio Workspace File, Format Version 5.00 # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! ############################################################################### Project: "Dicmdir3"=.\Dicmdir3_32.dsp - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Global: Package=<5> {{{ }}} Package=<3> {{{ }}} ############################################################################### Papyrus3/DicomDir/Dicmdir3.ncb0000755000175000017500000000004707535143454013356 0ustar Microsoft C/C++ program database 2.00 Papyrus3/DicomDir/DicomDirInit.c0000755000175000017500000002602610044156252013710 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit (Dicomdir library) */ /* File : DicomdirInit.c */ /* Function : contains all the initialisation functions */ /* Authors : Marianne Logean */ /* */ /* History : 05.1997 version 3.51 */ /* 02.1999 version 3.6 */ /* */ /********************************************************************************/ /* ------------------------- includes -----------------------------------------*/ #include #ifndef DicomdirH #include "DicomDir.h" #endif #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef DicomdirInitRecordsH #include "DicomDirInitRecords.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef DicomdirInitRecordsH #include "DICINIR3.h" #endif #endif /* FILENAME83 defined */ /********************************************************************************/ /* */ /* InitRecordSize3 : initializes the number of element for each defined */ /* record. */ /* */ /********************************************************************************/ void InitRecordSize3 () { /* initialization of the records length */ gArrRecord [(int) PatientR] = papEndPatientR; gArrRecord [(int) StudyR] = papEndStudyR; gArrRecord [(int) SeriesR] = papEndSeriesR; gArrRecord [(int) ImageR] = papEndImageR; gArrRecord [(int) OverlayR] = papEndOverlayR; gArrRecord [(int) ModalityLUTR] = papEndModalityLUTR; gArrRecord [(int) VOILUTR] = papEndVOILUTR; gArrRecord [(int) CurveR] = papEndCurveR; gArrRecord [(int) Topic] = papEndTopic; gArrRecord [(int) Visit] = papEndVisit; gArrRecord [(int) Result] = papEndResult; gArrRecord [(int) Interpretation] = papEndInterpretation; gArrRecord [(int) StudyComponentR] = papEndStudyComponentR; gArrRecord [(int) PrintQueue] = papEndPrintQueue; gArrRecord [(int) FilmSession] = papEndFilmSession; gArrRecord [(int) BasicFilmBox] = papEndBasicFilmBox; gArrRecord [(int) BasicImageBox] = papEndBasicImageBox; } /* endof InitRecordSize3 */ /********************************************************************************/ /* */ /* DicD3Init : initializes the DicomDir library */ /* return : always return 0 */ /* */ /********************************************************************************/ PapyShort CALLINGCONV DicD3Init () { int i; /* initialize some pointer to NULL */ /* rootDirRecordItem = NULL; */ /* initialize some pointers to NULL */ for (i = 0; i < kMax_file_open; i++) { gPosFirstPatientOffset [i] = 0L; gRefFirstPatientOffset [i] = 0L; gPosLastPatientOffset [i] = 0L; gRefLastPatientOffset [i] = 0L; gPosNextDirRecordOffset [i] = NULL; gRefNextDirRecordOffset [i] = NULL; gPosLowerLevelDirRecordOffset[i] = NULL; gRefLowerLevelDirRecordOffset[i] = NULL; } /* for */ /* test to see wether the toolkit has been initialised or not */ if (gIsDicd3Inited == 21) return 0; else gIsDicd3Inited = 21; /* initialize the number of elements in the records */ InitRecordSize3 (); return 0; } /* endof DicD3Init */ /********************************************************************************/ /* */ /* InitRecord3 : initializes the selected record */ /* */ /********************************************************************************/ void InitRecord3 (int inRecordEnum, SElement *ioElemP) { switch (inRecordEnum) { case PatientR : init_PatientR (ioElemP); break; case StudyR : init_StudyR (ioElemP); break; case SeriesR : init_SeriesR (ioElemP); break; case ImageR : init_ImageR (ioElemP); break; case OverlayR : init_OverlayR (ioElemP); break; case ModalityLUTR : init_ModalityLUTR (ioElemP); break; case CurveR : init_CurveR (ioElemP); break; case Topic : init_Topic (ioElemP); break; case Visit : init_Visit (ioElemP); break; case Result : init_Result (ioElemP); break; case Interpretation : init_Interpretation (ioElemP); break; case StudyComponentR : init_StudyComponentR (ioElemP); break; case PrintQueue : init_PrintQueue (ioElemP); break; case FilmSession : init_FilmSession (ioElemP); break; case BasicFilmBox : init_BasicFilmBox (ioElemP); break; case BasicImageBox : init_BasicImageBox (ioElemP); break; default : break; } /* end switch */ } /* endof InitRecord3 */ /********************************************************************************/ /* */ /* CreateRecord3 : allocates memory for the elements of the record and fill */ /* in the description of the elements of the record. */ /* return : a pointer to the created record */ /* */ /********************************************************************************/ Record* CreateRecord3 (int inRecordID) { Record *theRecordP; theRecordP = (Record *) ecalloc3 ((PapyULong) gArrRecord [inRecordID], (PapyULong) sizeof (Record)); (void) InitRecord3 (inRecordID, theRecordP); return theRecordP; } /* endof CreateRecord3 */ /********************************************************************************/ /* */ /* Papy3RecordFree : Frees a previously allocated record. */ /* return : standard error message if a problem occur zero otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3RecordFree (SElement **ioRecordP, int inRecordID, int inDelSeq) { SElement *theElemP; PapyShort theRecordSize, i, theErr; if (*ioRecordP == NULL) RETURN (papNoError); if (inRecordID < 0) RETURN (papEnumGroup); theRecordSize = gArrRecord [inRecordID]; if (theRecordSize < 0) RETURN (papGroupErr); /* free the elements of the record */ for (i = 0, theElemP = *ioRecordP; i < theRecordSize; i++, theElemP++) if ((theErr = Papy3ClearElement (*ioRecordP, i, inDelSeq)) < 0) RETURN (theErr); efree3 ((void **) ioRecordP); RETURN (papNoError) } /* endof Papy3RecordFree */ Papyrus3/DicomDir/.DS_Store0000777000175000017500000001400410047674360012716 0ustar Bud1%  @€ @€ @€ @ E%DSDB`€ @€ @€ @Papyrus3/DicomDir/DicomDir.h0000755000175000017500000001317110044205360013061 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit (DicomDir library) */ /* File : Dicomdir.h */ /* Function : contains the declarations of types, enumerated types, */ /* constants and global variables */ /* Authors : Mathieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 05.1997 version 3.5 */ /* 02.1999 version 3.6 */ /* */ /********************************************************************************/ #ifndef DicomdirH #define DicomdirH #ifndef Papyrus3H #include "Papyrus3.h" #endif /* --- includes --- */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef DicomdirEnumRecordsH #include "DicomDirEnumRecords.h" #endif #ifndef DicomdirTypeDef3H /* DICOMDIR type definition */ #include "DicomDirTypeDef3.h" #endif #ifndef DicomdirPrivFunctionDef3H /* DICOMDIR private functions */ #include "DicomDirPrivFunctionDef3.h" #endif #ifndef DicomdirPubFunctionDef3H /* DICOMDIR public functions */ #include "DicomDirPubFunctionDef3.h" #endif #ifndef DicomdirGlobalVar3H /* DICOMDIR global variables */ #include "DicomDirGlobalVar3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef DicomdirEnumRecordsH #include "DICDER3.h" #endif #ifndef DicomdirTypeDef3H /* DICOMDIR type definition */ #include "DICDTD3.h" #endif #ifndef DicomdirPrivFunctionDef3H /* DICOMDIR private functions */ #include "DICDPRF3.h" #endif #ifndef DicomdirPubFunctionDef3H /* DICOMDIR public functions */ #include "DICDPUF3.h" #endif #ifndef DicomdirGlobalVar3H /* DICOMDIR global variables */ #include "DICDGLV3.h" #endif #endif /* FILENAME83 defined */ #endif /* DicomdirH */ Papyrus3/DicomDir/DicomDirEnumRecords.h0000755000175000017500000003042010044156776015244 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit (DicomDir library) */ /* File : DicomdirEnumRecords.h */ /* Function : contains the declarations of the Directory Records. */ /* Authors : Marianne Logean */ /* */ /* History : 05.1997 version 3.51 */ /* 02.1999 version 3.6 */ /* */ /********************************************************************************/ #ifndef DicomdirEnumRecordsH #define DicomdirEnumRecordsH /* Directory Record : Patient */ enum { papOffsetofNextDirectoryRecordP, papRecordInuseP, papOffsetofReferencedLowerLevelDirectoryEntityP, papDirectoryRecordTypeP, papPrivateRecordUIDP, papReferencedFileIDP, papMRDRDirectoryRecordOffsetP, papReferencedSOPClassUIDinFileP, papReferencedSOPInstanceUIDinFileP, papReferencedTransferSyntaxUIDinFileP, papSpecificCharacterSetDRP, papPatientsNameDR, papPatientIDDR, papEndPatientR }; /* Directory Record : Study */ enum { papOffsetofNextDirectoryRecordS, papRecordInuseS, papOffsetofReferencedLowerLevelDirectoryEntityS, papDirectoryRecordTypeS, papPrivateRecordUIDS, papReferencedFileIDS, papMRDRDirectoryRecordOffsetS, papReferencedSOPClassUIDinFileS, papReferencedSOPInstanceUIDinFileS, papReferencedTransferSyntaxUIDinFileS, papSpecificCharacterSetDRS, papStudyDateDRS, papStudyTimeDRS, papStudyDescriptionDRS, papStudyInstanceUIDDRS, papStudyIDDRS, papAccessionNumberDRS, papEndStudyR }; /* Directory Record : Series */ enum { papOffsetofNextDirectoryRecordSE, papRecordInuseSE, papOffsetofReferencedLowerLevelDirectoryEntitySE, papDirectoryRecordTypeSE, papPrivateRecordUIDSE, papReferencedFileIDSE, papMRDRDirectoryRecordOffsetSE, papReferencedSOPClassUIDinFileSE, papReferencedSOPInstanceUIDinFileSE, papReferencedTransferSyntaxUIDinFileSE, papSpecificCharacterSetDRSE, papModalityDRSE, papSeriesInstanceUIDDRSE, papSeriesNumberDRSE, papIconImageSequenceDRSE, papEndSeriesR }; /* Directory Record : Image */ enum { papOffsetofNextDirectoryRecordI, papRecordInuseI, papOffsetofReferencedLowerLevelDirectoryEntityI, papDirectoryRecordTypeI, papPrivateRecordUIDI, papReferencedFileIDI, papMRDRDirectoryRecordOffsetI, papReferencedSOPClassUIDinFileI, papReferencedSOPInstanceUIDinFileI, papReferencedTransferSyntaxUIDinFileI, papSpecificCharacterSetDRI, papImageNumberDRI, papIconImageSequenceDRI, papEndImageR }; /* Directory Record : Overlay */ enum { papOffsetofNextDirectoryRecordO, papRecordInuseO, papOffsetofReferencedLowerLevelDirectoryEntityO, papDirectoryRecordTypeO, papPrivateRecordUIDO, papReferencedFileIDO, papMRDRDirectoryRecordOffsetO, papReferencedSOPClassUIDinFileO, papReferencedSOPInstanceUIDinFileO, papReferencedTransferSyntaxUIDinFileO, papSpecificCharacterSetDRO, papOverlayNumberDRO, papIconImageSequenceDRO, papEndOverlayR }; /* Directory Record : ModalityLUT */ enum { papOffsetofNextDirectoryRecordM, papRecordInuseM, papOffsetofReferencedLowerLevelDirectoryEntityM, papDirectoryRecordTypeM, papPrivateRecordUIDM, papReferencedFileIDM, papMRDRDirectoryRecordOffsetM, papReferencedSOPClassUIDinFileM, papReferencedSOPInstanceUIDinFileM, papReferencedTransferSyntaxUIDinFileM, papSpecificCharacterSetDRM, papLUTNumberDRM, papEndModalityLUTR }; /* Directory Record : VOILUT */ enum { papOffsetofNextDirectoryRecordV, papRecordInuseV, papOffsetofReferencedLowerLevelDirectoryEntityV, papDirectoryRecordTypeV, papPrivateRecordUIDV, papReferencedFileIDV, papMRDRDirectoryRecordOffsetV, papReferencedSOPClassUIDinFileV, papReferencedSOPInstanceUIDinFileV, papReferencedTransferSyntaxUIDinFileV, papSpecificCharacterSetDRV, papLUTNumberDRV, papEndVOILUTR }; /* Directory Record : Curve */ enum { papOffsetofNextDirectoryRecordC, papRecordInuseC, papOffsetofReferencedLowerLevelDirectoryEntityC, papDirectoryRecordTypeC, papPrivateRecordUIDC, papReferencedFileIDC, papMRDRDirectoryRecordOffsetC, papReferencedSOPClassUIDinFileC, papReferencedSOPInstanceUIDinFileC, papReferencedTransferSyntaxUIDinFileC, papSpecificCharacterSetDRC, papCurveNumberDRC, papEndCurveR }; /* Directory Record : Topic */ enum { papOffsetofNextDirectoryRecordT, papRecordInuseT, papOffsetofReferencedLowerLevelDirectoryEntityT, papDirectoryRecordTypeT, papPrivateRecordUIDT, papReferencedFileIDT, papMRDRDirectoryRecordOffsetT, papReferencedSOPClassUIDinFileT, papReferencedSOPInstanceUIDinFileT, papReferencedTransferSyntaxUIDinFileT, papSpecificCharacterSetDRT, papTopicTitleDRT, papTopicSubjectDRT, papTopicAuthorDRT, papTopicKeyWordsDRT, papEndTopic }; /* Directory Record : Visit */ enum { papOffsetofNextDirectoryRecordVI, papRecordInuseVI, papOffsetofReferencedLowerLevelDirectoryEntityVI, papDirectoryRecordTypeVI, papPrivateRecordUIDVI, papReferencedFileIDVI, papMRDRDirectoryRecordOffsetVI, papReferencedSOPClassUIDinFileVI, papReferencedSOPInstanceUIDinFileVI, papReferencedTransferSyntaxUIDinFileVI, papAdmittingDateDRVI, papAdmissionIDDRVI, papInstitutionNameDRVI, papSpecificCharacterSetDRVI, papEndVisit }; /* Directory Record : Result */ enum { papOffsetofNextDirectoryRecordR, papRecordInuseR, papOffsetofReferencedLowerLevelDirectoryEntityR, papDirectoryRecordTypeR, papPrivateRecordUIDR, papReferencedFileIDR, papMRDRDirectoryRecordOffsetR, papReferencedSOPClassUIDinFileR, papReferencedSOPInstanceUIDinFileR, papReferencedTransferSyntaxUIDinFileR, papResultsIDDRR, papInstanceCreationDateDRR, papSpecificCharacterSetDRR, papEndResult }; /* Directory Record : Interpretation */ enum { papOffsetofNextDirectoryRecordIN, papRecordInuseIN, papOffsetofReferencedLowerLevelDirectoryEntityIN, papDirectoryRecordTypeIN, papPrivateRecordUIDIN, papReferencedFileIDIN, papMRDRDirectoryRecordOffsetIN, papReferencedSOPClassUIDinFileIN, papReferencedSOPInstanceUIDinFileIN, papReferencedTransferSyntaxUIDinFileIN, papSpecificCharacterSetDRIN, papInterpretationTranscriptionDateDRIN, papInterpretationAuthorDRIN, papInterpretationDiagnosisDescriptionDRIN, papDiagnosisCodeSequenceDRIN, papInterpretationIDDRIN, papInterpretationTypeIDDRIN, papInterpretationStatusIDDRIN, papEndInterpretation }; /* Directory Record : StudyComponent */ enum { papOffsetofNextDirectoryRecordSC, papRecordInuseSC, papOffsetofReferencedLowerLevelDirectoryEntitySC, papDirectoryRecordTypeSC, papPrivateRecordUIDSC, papReferencedFileIDSC, papMRDRDirectoryRecordOffsetSC, papReferencedSOPClassUIDinFileSC, papReferencedSOPInstanceUIDinFileSC, papReferencedTransferSyntaxUIDinFileSC, papSpecificCharacterSetDRSC, papModalityDRSC, papStudyDescriptionDRSC, papProcedureCodeSequenceDRSC, papPerformingPhysiciansNameDRSC, papEndStudyComponentR }; /* Directory Record : PrintQueue */ enum { papOffsetofNextDirectoryRecordPQ, papRecordInusePQ, papOffsetofReferencedLowerLevelDirectoryEntityPQ, papDirectoryRecordTypePQ, papPrivateRecordUIDPQ, papReferencedFileIDPQ, papMRDRDirectoryRecordOffsetPQ, papReferencedSOPClassUIDinFilePQ, papReferencedSOPInstanceUIDinFilePQ, papReferencedTransferSyntaxUIDinFilePQ, papPrintQueueIDDRPQ, papSpecificCharacterSetDRPQ, papPrinterNameDRPQ, papEndPrintQueue }; /* Directory Record : FilmSession */ enum { papOffsetofNextDirectoryRecordFS, papRecordInuseFS, papOffsetofReferencedLowerLevelDirectoryEntityFS, papDirectoryRecordTypeFS, papPrivateRecordUIDFS, papReferencedFileIDFS, papMRDRDirectoryRecordOffsetFS, papReferencedSOPClassUIDinFileFS, papReferencedSOPInstanceUIDinFileFS, papReferencedTransferSyntaxUIDinFileFS, papSpecificCharacterSetDRFS, papFilmSessionLabelDRFS, papExecutionStatusDRFS, papEndFilmSession }; /* Directory Record : BasicFilmBox */ enum { papOffsetofNextDirectoryRecordBFB, papRecordInuseBFB, papOffsetofReferencedLowerLevelDirectoryEntityBFB, papDirectoryRecordTypeBFB, papPrivateRecordUIDBFB, papReferencedFileIDBFB, papMRDRDirectoryRecordOffsetBFB, papReferencedSOPClassUIDinFileBFB, papReferencedSOPInstanceUIDinFileBFB, papReferencedTransferSyntaxUIDinFileBFB, papSpecificCharacterSetDRBFB, papExecutionStatusDRBFB, papEndBasicFilmBox }; /* Directory Record : BasicImageBox */ enum { papOffsetofNextDirectoryRecordBIB, papRecordInuseBIB, papOffsetofReferencedLowerLevelDirectoryEntityBIB, papDirectoryRecordTypeBIB, papPrivateRecordUIDBIB, papReferencedFileIDBIB, papMRDRDirectoryRecordOffsetBIB, papReferencedSOPClassUIDinFileBIB, papReferencedSOPInstanceUIDinFileBIB, papReferencedTransferSyntaxUIDinFileBIB, papSpecificCharacterSetDRBIB, papImagePosition2020DRBIB, papEndBasicImageBox }; #endif /* DicomdirEnumRecordsH */ Papyrus3/DicomDir/DicomDirDataSetWrite.c0000755000175000017500000002762010044157350015346 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit (Dicomdir library) */ /* File : DicomDirDataSetWrite3.c */ /* Function : contains the functions managing the records (writing). */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 05.1997 version 3.51 */ /* 02.1999 version 3.6 */ /* */ /********************************************************************************/ #ifdef Mac #pragma segment papy3 #endif /* ------------------------- includes -----------------------------------------*/ #ifndef DicomdirH #include "DicomDir.h" #endif /********************************************************************************/ /* */ /* Papy3CreateDicomDirDataSet : Create a new data set item and add it to */ /* the list of Data Set of the given file. */ /* return : a pointer to the created Data Set */ /* NULL otherwise */ /* */ /********************************************************************************/ Item * CALLINGCONV Papy3CreateDicomDirDataSet (PapyShort inFileNb) { Object *theObjectP; Item *theItemP; /* creates an empty object that will point to the list of records */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papItem; theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->record = NULL; theObjectP->group = NULL; theObjectP->tmpFileLength = 0L; theItemP = InsertLastInList (&(gArrMemFile [inFileNb]), theObjectP); return theItemP; } /* endof Papy3CreateDicomDirDataSet */ /********************************************************************************/ /* */ /* Papy3CreateDirRecItem : Create a new data set item in the Directory */ /* Record sequence. */ /* return : a pointer to the created item of the data set */ /* NULL otherwise */ /* */ /********************************************************************************/ Item * CALLINGCONV Papy3CreateDirRecItem (Module *inModuleP) { Object *theObjectP; Item *theItemP; Module *theElementP; /* go to the Directory Record Sequence of the module */ theElementP = inModuleP + papDirectoryRecordSequence; /* creates an empty object that will point to the list of records */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papItem; theObjectP->objID = DirectoryInformation; theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->record = NULL; theObjectP->group = NULL; theObjectP->tmpFileLength = 0L; /* test if it is the first item */ if (theElementP->nb_val == 0L) { theElementP->nb_val = 1L; /* allocate room for the value to be inserted */ theElementP->value = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); /* and initializes it to NULL */ theElementP->value->sq = NULL; } /* if ...first time */ theItemP = InsertLastInList (&(theElementP->value->sq), theObjectP); return theItemP; } /* endof Papy3CreateDirRecItem */ /********************************************************************************/ /* */ /* Papy3LinkRecordToDS : Link the given record to the Data Set. */ /* */ /********************************************************************************/ void CALLINGCONV Papy3LinkRecordToDS (Item *inDataSetP, SElement *inRecordP, int inRecordName) { Item *theItemP; Object *theObjectP; /* ------- link the created record to the list of modules/groups/records of the data set ---- */ /* creation of the Object pointing to the record */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papRecord; theObjectP->objID = inRecordName; theObjectP->group = NULL; theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->record = inRecordP; /* link the record to the object */ theObjectP->file = NULL; theObjectP->tmpFileLength = 0L; /* insert the item at the end of the list of modules/groups/records of the data set */ theItemP = InsertLastInList ((Item **) &(inDataSetP->object->item), theObjectP); } /* endof Papy3LinkRecordToDS */ /********************************************************************************/ /* */ /* Papy3FillRecord : Fill the referenced element of the record */ /* */ /********************************************************************************/ void CALLINGCONV Papy3FillRecord (SElement **ioRecordP) { SElement *theElemP; PapyShort i; PapyULong theLongValue; PapyUShort theShortValue; /* initialisations */ theLongValue = 0L; theShortValue = 0; /* fill the 2 first elements of the record (common to all records)*/ i = 0; theElemP = *ioRecordP; /* 0004:1400 */ Papy3PutElement (*ioRecordP, i, &theLongValue); i++; theElemP++; /* 0004:1410 */ Papy3PutElement (*ioRecordP, i, &theShortValue); i++; theElemP++; /* 0004:1420 */ Papy3PutElement (*ioRecordP, i, &theLongValue); } /* endof Papy3FillRecord */ /********************************************************************************/ /* */ /* Papy3CreateRecord : Create a new record. */ /* return : a pointer to the created record */ /* NULL otherwise */ /* */ /********************************************************************************/ Record * CALLINGCONV Papy3CreateRecord (int inRecordName) { Record *theRecordP; /* create the record a la Papy3GroupCreate */ theRecordP = CreateRecord3 (inRecordName); Papy3FillRecord (&theRecordP); return theRecordP; } /* endof Papy3CreateRecord */ /********************************************************************************/ /* */ /* LookForGroupsInRecord3 : Scan a record for its list of groups. Compares */ /* the found groups with the list of existing groups (if any) and build */ /* the list of groups to create or read (list that is returned). */ /* */ /********************************************************************************/ void LookForGroupsInRecord3 (Record *inRecordP, int inRecordID, int *inGrToCreateP) { int *theTmpCrP, i; int theEnumGrNb; Record *theElemP; theElemP = inRecordP; theTmpCrP = inGrToCreateP; /* initialize the array of groups to create to empty */ for (i = 0; i < END_GROUP; i++) theTmpCrP [i] = 0; /* no list just add the groups found to the list */ for (i = 0; i < gArrRecord [inRecordID]; i++) { theEnumGrNb = Papy3ToEnumGroup (theElemP->group); /* put the group in the to read list */ if (theTmpCrP [theEnumGrNb] == 0) theTmpCrP [theEnumGrNb] = 1; /* next element of the record */ theElemP++; } /* for ...loop on the elements of the record */ } /* endof LookForGroupsInRecord3 */ Papyrus3/DicomDir/Dicmdir3.plg0000755000175000017500000000245007535143454013376 0ustar 
    Build Log
    

    
--------------------Configuration: Dicmdir3 - Win32 Debug--------------------

    

    Command Lines
    
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP371.tmp" with contents
[
/nologo /Zp1 /MLd /W3 /Gm /GX /ZI /Od /I ".." /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "FILENAME83" /D "PAPY3_VAR" /D "_MBCS" /D "WIN32" /Fp".\Debug/Dicmdir3.pch" /YX /Fo".\Debug/" /Fd".\Debug/" /FD /c 
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirDatasetRead.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirDatasetWrite.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirFiles.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirInit.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirInitRecords.c"
]
Creating command line "cl.exe @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP371.tmp" 
Creating command line "link.exe -lib /nologo /out:".\Debug\Dicmdir3.lib"  .\Debug\DicomDirDatasetRead.obj .\Debug\DicomDirDatasetWrite.obj .\Debug\DicomDirFiles.obj .\Debug\DicomDirInit.obj .\Debug\DicomDirInitRecords.obj "

    Output Window
    
Compiling...
DicomDirDatasetRead.c
DicomDirDatasetWrite.c
DicomDirFiles.c
DicomDirInit.c
DicomDirInitRecords.c
Creating library...




    Results
    
Dicmdir3.lib - 0 error(s), 0 warning(s)
    Papyrus3/DicomDir/OGlobalDicomFunc.h0000755000175000017500000001032310044166176014505 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ #ifndef OGlobalDicomFuncH #define OGlobalDicomFuncH // *************************************************************************** // *************************************************************************** // // OGlobalDicomFunc // // **************************************************************************** // **************************************************************************** // // FILENAME : OGlobalDicomFunc.h // // CLASSES : none // // DESCRIPTION : Utility routines for DICOM type conversion. // // HISTORY : 24-02-99 CHG creation // // **************************************************************************** // **************************************************************************** // converts a DICOM stored date to a standard one extern void DicomDateToDate (char *, char *); // converts a DICOM stored time to a standard one extern void DicomTimeToTime (char *, char *); // converts a DICOM stored name to a standard one extern void DicomNameToName (char *, char *); #endif // ifndef OGlobalDicomFuncHPapyrus3/DicomDir/DicomDirFiles.c0000755000175000017500000002733510044156620014052 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit (DicomDir library) */ /* File : DicomDirFiles3.c */ /* Function : contains all the file functions */ /* Authors : Marianne Logean */ /* */ /* History : 05.1997 version 3.5 */ /* 02.1999 version 3.6 */ /* */ /********************************************************************************/ /* ------------------------- includes ---------------------------------------*/ #include #include #include #ifndef DicomdirH #include "DicomDir.h" #endif #ifdef _WINDOWS #include #endif enum {kPAPY_READ, kPAPY_WRITE}; /* are we in read or write mode ? */ /********************************************************************************/ /* */ /* Papy3DicomDirCreate : given a filename check if this file does not */ /* exist and creates a new file. It has to put the file Meta Info as well */ /* as the DICM prefix to identify the file. It has to initialize the */ /* variables necessary to store the different offsets. It has to create */ /* the file structure in memory (list). */ /* return : a reference number to the opened file if successful */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3DicomDirCreate (char *inNameP, int inNbFiles, PAPY_FILE inVRefNum, int inToCreate, void *MacFileSpec) { PapyULong theNumberOfBytes; int i, thePapyrusFile = 0; PapyShort theFileNb, theErr; PAPY_FILE theFp; char theBuff [134]; void *theFSSpecP; char theFilename [256]; /* -------- validity tests -------- */ /* we have to have a file */ if (inNbFiles == 0) RETURN (papNbImagesIsZero); /* no valid filename specified */ if (inToCreate && (inNameP == NULL || *inNameP == '\0')) RETURN (papFileName); /* is it a DICOMDIR file? */ ExtractDicomdirFromPath (inNameP, theFilename); if (theFilename [0] != '\0' && ((strcmp ((char*) theFilename, "DICOMDIR.") == 0) || (strcmp ((char*) theFilename, "dicomdir.") == 0) || (strcmp ((char*) theFilename, "dicomdir" ) == 0) || (strcmp ((char*) theFilename, "DICOMDIR" ) == 0))) thePapyrusFile = 3; if (thePapyrusFile != 3) RETURN (papFileName); /* -------- creating and opening the file -------- */ /* look for a valid file number */ theFileNb = FindFreeFile3 (); /* 1 = PAPYRUS 3.X, 3 = DICOMDIR */ gIsPapyFile [theFileNb] = (enum EFile_Type) thePapyrusFile; /* too many open files */ if (theFileNb < 0) RETURN (theFileNb); if (inToCreate) { theFSSpecP = MacFileSpec; if ((theErr = Papy3FCreate (inNameP, inVRefNum, &theFp, &theFSSpecP)) != 0) RETURN (papFileAlreadyExist); if ((theErr = Papy3FOpen (inNameP, 'w', inVRefNum, &theFp, &theFSSpecP)) != 0) RETURN (papFileCreationFailed); if ((theFSSpecP != NULL) && (MacFileSpec == NULL)) efree3 ((void **) &theFSSpecP); // // BLOT ADD: if (theFSSpecP != NULL) efree3 ((void **) &theFSSpecP); } /* if ...inToCreate */ else theFp = inVRefNum; /* assign the file to the array of files */ gPapyFile [theFileNb] = theFp; /* -------- file meta information -------- */ /* Put the DICOM File Meta Information in the file */ /* first put 128 bytes set to 0 */ for (i = 0; i < 128; i++) theBuff [i] = 0; theNumberOfBytes = 128L; /* writes the bytes to the file */ if (Papy3FWrite (theFp, (PapyULong *) &theNumberOfBytes, 1, theBuff) < 0) { theErr = Papy3FClose (&theFp); RETURN (papWriteFile) } /* if */ /* then put the "DICM" string that will identify the file as a DICOM one */ strcpy (theBuff, "DICM"); theNumberOfBytes = (PapyULong) 4L; /* writes the bytes to the file */ if (Papy3FWrite (theFp, (PapyULong *) &theNumberOfBytes, 1, theBuff) < 0) { theErr = Papy3FClose (&theFp); RETURN (papWriteFile) } /* if */ /* creation of the file meta information and initialization of the memory */ /* representation of the file structure (list) */ if ((theErr = CreateFileMetaInformation3 (theFileNb, NONE, LITTLE_ENDIAN_EXPL, SEC_CAPT_IM)) < 0) RETURN (theErr); /* -------- initializations a la Papyrus 2 -------- */ /* set the transfert syntax and the compression used for the file */ gArrTransfSyntax [theFileNb] = LITTLE_ENDIAN_EXPL; gArrCompression [theFileNb] = NONE; /* allocate room for the offsets to the records */ gPosNextDirRecordOffset [theFileNb] = (PapyULong *) ecalloc3 ((PapyULong) END_RECORD, (PapyULong) sizeof (PapyULong)); gRefNextDirRecordOffset [theFileNb] = (PapyULong *) ecalloc3 ((PapyULong) END_RECORD, (PapyULong) sizeof (PapyULong)); gPosLowerLevelDirRecordOffset [theFileNb] = (PapyULong *) ecalloc3 ((PapyULong) END_RECORD, (PapyULong) sizeof (PapyULong)); gRefLowerLevelDirRecordOffset [theFileNb] = (PapyULong *) ecalloc3 ((PapyULong) END_RECORD, (PapyULong) sizeof (PapyULong)); /* and initialize !! */ for (i = 0; i < END_RECORD; i++) { *(gPosNextDirRecordOffset [theFileNb] + i) = 0L; *(gRefNextDirRecordOffset [theFileNb] + i) = 0L; *(gPosLowerLevelDirRecordOffset [theFileNb] + i) = 0L; *(gRefLowerLevelDirRecordOffset [theFileNb] + i) = 0L; } /* the file is in write mode */ gReadOrWrite [theFileNb] = kPAPY_WRITE; RETURN (theFileNb); } /* endof Papy3DicomDirCreate */ /********************************************************************************/ /* */ /* Papy3WriteAndCloseDicomDir : writes the whole in memory structure of the */ /* given file to the disk. It closes any unclosed data set and saves the */ /* references to the data sets and the pixel data. Finally frees some */ /* memory that is no more needed. */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3WriteAndCloseDicomDir (PapyShort inFileNb, int inToClose) { PapyShort theErr; Item *theFileStructP, *theWrkItemP; /* write group 2 (File Meta Information) and free it*/ if ((theErr = Papy3GroupWrite (inFileNb, (gArrMemFile [inFileNb])->object->group, FALSE)) < 0) RETURN (theErr); /* convert all the modules and records to groups */ theFileStructP = gArrMemFile [inFileNb]->next; while (theFileStructP != NULL) { if ((theErr = ItemModulesToGroups3 (inFileNb, theFileStructP, TRUE)) < 0) RETURN (theErr); /* write the groups to the Papyrus file */ theWrkItemP = (Item *) theFileStructP->object->item; while (theWrkItemP != NULL) { /* write the current group to the file and then frees the allocated memory */ if ((theErr = Papy3GroupWrite (inFileNb, theWrkItemP->object->group, FALSE)) < 0) RETURN (theErr); /* get next element of the list */ theWrkItemP = theWrkItemP->next; } /* while ...loop on the groups */ /* get next element of the list */ theFileStructP = theFileStructP->next; } /* while ...loop on the datasets */ /* frees the allocated memory */ Papy3FileClose (inFileNb, inToClose); RETURN (theErr); } /* endof Papy3WriteAndCloseDicomDir */ Papyrus3/DicomDir/Dicmdir3.opt0000755000175000017500000015100007535143454013412 0ustar ÐÏࡱá>þÿ þÿÿÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýÿÿÿ  þÿÿÿ þÿÿÿþÿÿÿI"#$%&'()*þÿÿÿ,-./01234þÿÿÿ6789:;<=>þÿÿÿ@ABCDEFGHþÿÿÿþÿÿÿKLMNOPQRSþÿÿÿUVWXYZ[\]þÿÿÿ_`abcdefgþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿRoot Entryÿÿÿÿÿÿÿÿð·ZàûÀþÿÿÿWorkspace State ÿÿÿÿBrowser ÿÿÿÿ Editorÿÿÿÿÿÿÿÿdicmdir3'C:\Osiris\code4.0\DicomDir\Dicmdir3.dsp3 øÃÇ {áÈhÏ 0Î`®Ó00Î80Î<0ÎD0ÎH0ÎP0ÎT0Î\0Î`0Îh0Îl0Ît0Îx0΀0ÎŒ0Î ¸0ÎðºÞ”0ÎPÌÖ 0ÎÐÌÖÄ0ÎÈ0ÎÐ0ÎÔ0ÎÜ0Îà0Îè0Îì0Îô0Îø0Î1Î1Î1Îv" (/(/àgÏ41Î@1ÎL1ÎX1Îd1Îp1Î|1Έ1Π1Î_p/p/àgÏXÀÕdîQXa'Q ´Qpº'lbÑpº'l %H2ÎJÈ/È/ÈhϨgÏ øGð2ÎdîQXa'Q ´Qpº'l€]Ðpº'l %ð2ΰ/¨gÏ3Î 3ÎïQ@/À1ÑÀÕdîQXa'Q ´Qpº'løÂÂpº'l %1ïQ˜/˜2ш4ÎdîQXa'Q ´Qpº'lÀPÉpº'l %F ˜/°PÉ8]8]p ÌÁÂÐ/r¨ŸÌcÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑ| _5e~ ˜/ âÓ ddX,ddźddXÈ–ddXÈ–ddXÈddXÈ3 øÃÇ {áÈhÏ 0Î`®Ó00Î80Î<0ÎD0ÎH0ÎP0ÎT0Î\0Î`0Îh0Îl0Ît0Îx0΀0ÎŒ0Î ¸0ÎðºÞ”0ÎPÌÖ 0ÎÐÌÖÄ0ÎÈ0ÎÐ0ÎÔ0ÎÜ0Îà0Îè0Îì0Îô0Îø0Î1Î1Î1Îv" (/(/àgÏ41Î@1ÎL1ÎX1Îd1Îp1Î|1Έ1Π1Î_p/p/àgÏXÀÕdîQXa'Q ´Qpº'lbÑpº'l %H2ÎJÈ/È/ÈhϨgÏ øGð2ÎdîQXa'Q ´Qpº'l€]Ðpº'l %ð2ΰ/¨gÏ3Î 3ÎïQ@/À1ÑÀÕdîQXa'Q ´Qpº'løÂÂpº'l %1ïQ˜/˜2ш4ÎdîQXa'Q ´Qpº'lÀPÉpº'l %F ˜/°PÉ8]8]p ÌÁÂÐ/r¨ŸÌcÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑ| _5e~ ˜/ âÓ MLJLddX,ddźddXÈ–ddXÈ–ddXÈddXÈ3 øÃÇ {áÈhÏ 0Î`®Ó00Î80Î<0ÎD0ÎH0ÎP0ÎT0Î\0Î`0Îh0Îl0Ît0Îx0΀0ÎŒ0Î ¸0ÎðºÞ”0ÎPÌÖ 0ÎÐÌÖÄ0ÎÈ0ÎÐ0ÎÔ0ÎÜ0Îà0Îè0Îì0Îô0Îø0Î1Î1Î1Îv" (/(/àgÏ41Î@1ÎL1ÎX1Îd1Îp1Î|1Έ1Π1Î_p/p/àgÏXÀÕdîQXa'Q ´Qpº'lbÑpº'l %H2ÎJÈ/È/ÈhϨgÏ øGð2ÎdîQXa'Q ´Qpº'l€]Ðpº'l %ð2ΰ/¨gÏ3Î 3ÎïQ@/À1ÑÀÕdîQXa'Q ´Qpº'løÂÂpº'l %1ïQ˜/˜2ш4ÎdîQXa'Q ´Qpº'lÀPÉpº'l %F ˜/°PÉ8]8]p ÌÁÂÐ/r¨ŸÌcÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑ| _5e~ ˜/ âÓ Workspace Window"ÿÿÿÿ!Source_Control_Info(ÿÿÿÿÿÿÿÿÿÿÿÿ+IPI_Dicmdir3ÿÿÿÿÿÿÿÿÿÿÿÿ5IPI_ ÿÿÿÿÿÿÿÿÿÿÿÿ?Dicmdir3 ClassViewDicmdir3 classesDicmdir3 classesFileView"Workspace 'Dicmdir3': 1 project(s)"Workspace 'Dicmdir3': 1 project(s)"Workspace 'Dicmdir3': 1 project(s)FileView3 øÃÇ {áÈhÏ 0Î`®Ó00Î80Î<0ÎD0ÎH0ÎP0ÎT0Î\0Î`0Îh0Îl0Ît0Îx0΀0ÎŒ0Î ¸0ÎðºÞ”0ÎPÌÖ 0ÎÐÌÖÄ0ÎÈ0ÎÐ0ÎÔ0ÎÜ0Îà0Îè0Îì0Îô0Îø0Î1Î1Î1Îv" (/(/àgÏ41Î@1ÎL1ÎX1Îd1Îp1Î|1Έ1Π1Î_p/p/àgÏXÀÕdîQXa'Q ´Qpº'lbÑpº'l %H2ÎJÈ/È/ÈhϨgÏ øGð2ÎdîQXa'Q ´Qpº'l€]Ðpº'l %ð2ΰ/¨gÏ3Î 3ÎïQ@/À1ÑÀÕdîQXa'Q ´Qpº'løÂÂpº'l %1ïQ˜/˜2ш4ÎdîQXa'Q ´Qpº'lÀPÉpº'l %F ˜/°PÉ8]8]p ÌÁÂÐ/r¨ŸÌcÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑ| _5e~ ˜/ âÓ Aœc:\osiris\code4.0\dicomdirc:\osiris\code4.0\dicomdirdicmdir3ileView"Workspace 'Dicmdir3': 1 project(s)"Workspace 'Dicmdir3': 1 project(s)"Workspace 'Dicmdir3': 1 project(s)FileView3 øÃÇ {áÈhÏ 0Î`®Ó00Î80Î<0ÎD0ÎH0ÎP0ÎT0Î\0Î`0Îh0Îl0Ît0Îx0΀0ÎŒ0Î ¸0ÎðºÞ”0ÎPÌÖ 0ÎÐÌÖÄ0ÎÈ0ÎÐ0ÎÔ0ÎÜ0Îà0Îè0Îì0Îô0Îø0Î1Î1Î1Îv" (/(/àgÏ41Î@1ÎL1ÎX1Îd1Îp1Î|1Έ1Π1Î_p/p/àgÏXÀÕdîQXa'Q ´Qpº'lbÑpº'l %H2ÎJÈ/È/ÈhϨgÏ øGð2ÎdîQXa'Q ´Qpº'l€]Ðpº'l %ð2ΰ/¨gÏ3Î 3ÎïQ@/À1ÑÀÕdîQXa'Q ´Qpº'løÂÂpº'l %1ïQ˜/˜2ш4ÎdîQXa'Q ´Qpº'lÀPÉpº'l %F ˜/°PÉ8]8]p ÌÁÂÐ/r¨ŸÌcÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑ| _5e~ ˜/ âÓ `êDicmdir3 - Win32 Debug Dicmdir3.dspCProjectDicmdir3 - Win32 DebugDicmdir3 - Win32 ReleaseDicmdir3 - Win32 DebugêSSBR CTargetItemDicmdir3 - Win32 DebugSSBR Source Files CProjGroupSSBRDJW Header Files CProjGroupSSBRDJWResource Files CProjGroupSSBRDJWDJWDJW3 øÃÇ {áÈhÏ 0Î`®Ó00Î80Î<0ÎD0ÎH0ÎP0ÎT0Î\0Î`0Îh0Îl0Ît0Îx0΀0ÎŒ0Î ¸0ÎðºÞ”0ÎPÌÖ 0ÎÐÌÖÄ0ÎÈ0ÎÐ0ÎÔ0ÎÜ0Îà0Îè0Îì0Îô0Îø0Î1Î1Î1Îv" (/(/àgÏ41Î@1ÎL1ÎX1Îd1Îp1Î|1Έ1Π1Î_p/p/àgÏXÀÕdîQXa'Q ´Qpº'lbÑpº'l %H2ÎJÈ/È/ÈhϨgÏ øGð2ÎdîQXa'Q ´Qpº'l€]Ðpº'l %ð2ΰ/¨gÏ3Î 3ÎïQ@/À1ÑÀÕdîQXa'Q ´Qpº'løÂÂpº'l %1ïQ˜/˜2ш4ÎdîQXa'Q ´Qpº'lÀPÉpº'l %F ˜/°PÉ8]8]p ÌÁÂÐ/r¨ŸÌcÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑ| _5e~ ˜/ âÓ `êÿÿÿÿUinc1 - Win32 ReleaseOverlay1 - Win32 DebugDialogc1 - Win32 ReleaseDivers - Win32 ReleaseOverlay1 - Win32 Releaseosiris - Win32 DebugColorc1 - Win32 ReleaseToolsc1 - Win32 DebugOsirisc1 - Win32 Releaseosiris - Win32 ReleaseDialogc1 - Win32 DebugColorc1 - Win32 DebugToolsc1 - Win32 ReleaseUinc1 - Win32 DebugDivers - Win32 DebugOsirisc1 - Win32 Debugÿÿ3 øÃÇ {áÈhÏ 0Î`®Ó00Î80Î<0ÎD0ÎH0ÎP0ÎT0Î\0Î`0Îh0Îl0Ît0Îx0΀0ÎŒ0Î ¸0ÎðºÞ”0ÎPÌÖ 0ÎÐÌÖÄ0ÎÈ0ÎÐ0ÎÔ0ÎÜ0Îà0Îè0Îì0Îô0Îø0Î1Î1Î1Îv" (/(/àgÏ41Î@1ÎL1ÎX1Îd1Îp1Î|1Έ1Π1Î_p/p/àgÏXÀÕdîQXa'Q ´Qpº'lbÑpº'l %H2ÎJÈ/È/ÈhϨgÏ øGð2ÎdîQXa'Q ´Qpº'l€]Ðpº'l %ð2ΰ/¨gÏ3Î 3ÎïQ@/À1ÑÀÕdîQXa'Q ´Qpº'løÂÂpº'l %1ïQ˜/˜2ш4ÎdîQXa'Q ´Qpº'lÀPÉpº'l %F ˜/°PÉ8]8]p ÌÁÂÐ/r¨ŸÌcÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑ| _5e~ ˜/ âÓ ClassView Window"ÿÿÿÿÿÿÿÿÿÿÿÿJDebuggerÿÿÿÿÿÿÿÿÿÿÿÿTDocuments ÿÿÿÿ^ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ CClsFldSlobDicmdir3eleaseOverlay1 - Win32 DebugDialogc1 - Win32 ReleaseDivers - Win32 ReleaseOverlay1 - Win32 Releaseosiris - Win32 DebugColorc1 - Win32 ReleaseToolsc1 - Win32 DebugOsirisc1 - Win32 Releaseosiris - Win32 ReleaseDialogc1 - Win32 DebugColorc1 - Win32 DebugToolsc1 - Win32 ReleaseUinc1 - Win32 DebugDivers - Win32 DebugOsirisc1 - Win32 Debugÿÿ3 øÃÇ {áÈhÏ 0Î`®Ó00Î80Î<0ÎD0ÎH0ÎP0ÎT0Î\0Î`0Îh0Îl0Ît0Îx0΀0ÎŒ0Î ¸0ÎðºÞ”0ÎPÌÖ 0ÎÐÌÖÄ0ÎÈ0ÎÐ0ÎÔ0ÎÜ0Îà0Îè0Îì0Îô0Îø0Î1Î1Î1Îv" (/(/àgÏ41Î@1ÎL1ÎX1Îd1Îp1Î|1Έ1Π1Î_p/p/àgÏXÀÕdîQXa'Q ´Qpº'lbÑpº'l %H2ÎJÈ/È/ÈhϨgÏ øGð2ÎdîQXa'Q ´Qpº'l€]Ðpº'l %ð2ΰ/¨gÏ3Î 3ÎïQ@/À1ÑÀÕdîQXa'Q ´Qpº'løÂÂpº'l %1ïQ˜/˜2ш4ÎdîQXa'Q ´Qpº'lÀPÉpº'l %F ˜/°PÉ8]8]p ÌÁÂÐ/r¨ŸÌcÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑ| _5e~ ˜/ âÓ @ Control-C@ Control-Break€Datatype MisalignmentÀAccess ViolationÀ In Page ErrorÀIllegal InstructionŒÀArray Bounds ExceededÀFloat Denormal OperandŽÀFloat Divide by ZeroÀFloat Inexact ResultÀFloat Invalid Operation‘ÀFloat Overflow’ÀFloat Stack Check“ÀFloat UnderflowÀ No Memory%ÀNoncontinuable Exception&ÀInvalid Disposition”ÀInteger Divide by Zero•ÀInteger Overflow–ÀPrivileged InstructionýÀStack Overflow5À DLL Not FoundBÀDLL Initialization Failed~mÀModule Not FoundmÀProcedure Not FoundÀInvalid HandlecsmàMicrosoft C++ ExceptionWatch1Watch2Watch3Watch4˜3 øÃÇ {áÈhÏ 0Î`®Ó00Î80Î<0ÎD0ÎH0ÎP0ÎT0Î\0Î`0Îh0Îl0Ît0Îx0΀0ÎŒ0Î ¸0ÎðºÞ”0ÎPÌÖ 0ÎÐÌÖÄ0ÎÈ0ÎÐ0ÎÔ0ÎÜ0Îà0Îè0Îì0Îô0Îø0Î1Î1Î1Îv" (/(/àgÏ41Î@1ÎL1ÎX1Îd1Îp1Î|1Έ1Π1Î_p/p/àgÏXÀÕdîQXa'Q ´Qpº'lbÑpº'l %H2ÎJÈ/È/ÈhϨgÏ øGð2ÎdîQXa'Q ´Qpº'l€]Ðpº'l %ð2ΰ/¨gÏ3Î 3ÎïQ@/À1ÑÀÕdîQXa'Q ´Qpº'løÂÂpº'l %1ïQ˜/˜2ш4ÎdîQXa'Q ´Qpº'lÀPÉpº'l %F ˜/°PÉ8]8]p ÌÁÂÐ/r¨ŸÌcÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑ| _5e~ ˜/ âÓ Ì@ Control-C@ Control-Break€Datatype MisalignmentÀAccess ViolationÀ In Page ErrorÀIllegal InstructionŒÀArray Bounds ExceededÀFloat Denormal OperandŽÀFloat Divide by ZeroÀFloat Inexact ResultÀFloat Invalid Operation‘ÀFloat Overflow’ÀFloat Stack Check“ÀFloat UnderflowÀ No Memory%ÀNoncontinuable Exception&ÀInvalid Disposition”ÀInteger Divide by Zero•ÀInteger Overflow–ÀPrivileged InstructionýÀStack Overflow5À DLL Not FoundBÀDLL Initialization Failed~mÀModule Not FoundmÀProcedure Not FoundÀInvalid HandlecsmàMicrosoft C++ ExceptionWatch1Watch2Watch3Watch4˜3 øÃÇ {áÈhÏ 0Î`®Ó00Î80Î<0ÎD0ÎH0ÎP0ÎT0Î\0Î`0Îh0Îl0Ît0Îx0΀0ÎŒ0Î ¸0ÎðºÞ”0ÎPÌÖ 0ÎÐÌÖÄ0ÎÈ0ÎÐ0ÎÔ0ÎÜ0Îà0Îè0Îì0Îô0Îø0Î1Î1Î1Îv" (/(/àgÏ41Î@1ÎL1ÎX1Îd1Îp1Î|1Έ1Π1Î_p/p/àgÏXÀÕdîQXa'Q ´Qpº'lbÑpº'l %H2ÎJÈ/È/ÈhϨgÏ øGð2ÎdîQXa'Q ´Qpº'l€]Ðpº'l %ð2ΰ/¨gÏ3Î 3ÎïQ@/À1ÑÀÕdîQXa'Q ´Qpº'løÂÂpº'l %1ïQ˜/˜2ш4ÎdîQXa'Q ´Qpº'lÀPÉpº'l %F ˜/°PÉ8]8]p ÌÁÂÐ/r¨ŸÌcÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑX ÑÈœÑ| _5e~ ˜/ âÓ Papyrus3/DicomDir/Dicmdir3.dsp0000755000175000017500000001021307535143454013376 0ustar # Microsoft Developer Studio Project File - Name="Dicmdir3" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=Dicmdir3 - Win32 Release !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "Dicmdir3.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "Dicmdir3.mak" CFG="Dicmdir3 - Win32 Release" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "Dicmdir3 - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "Dicmdir3 - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName ""$/osiris/Papyrus3/DicomDirLib", ZXGAAAAA" # PROP Scc_LocalPath "." CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "Dicmdir3 - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir ".\Release" # PROP BASE Intermediate_Dir ".\Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir ".\Release" # PROP Intermediate_Dir ".\Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /G3 /Zp1 /W3 /O2 /I "\osiris\papyrus3" /I "\osiris\papyrus3\jpglless" /I "\osiris\papyrus3\jpglossy" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "STRICT" /D "_WIN16_" /D "FILENAME83" /D "PAPY3_VAR" /YX /c # ADD CPP /nologo /Zp1 /W3 /GX /O2 /I "..\Papyrus3\\" /I "..\Papyrus3\Dicomdir" /I ".." /D "NDEBUG" /D "_WINDOWS" /D "STRICT" /D "FILENAME83" /D "PAPY3_VAR" /D "_MBCS" /D "WIN32" /YX /FD /c # ADD BASE RSC /l 0x40c # ADD RSC /l 0x40c BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ELSEIF "$(CFG)" == "Dicmdir3 - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir ".\Debug" # PROP BASE Intermediate_Dir ".\Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir ".\Debug" # PROP Intermediate_Dir ".\Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /Zp1 /W3 /Gm /Zi /Od /Gf /Gy /I "\osiris\papyrus3" /I "\osiris\papyrus3\jpglless" /I "\osiris\papyrus3\jpglossy" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "_WIN16_" /D "FILENAME83" /D "PAPY3_VAR" /YX /c # ADD CPP /nologo /Zp1 /W3 /Gm /GX /ZI /Od /I ".." /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "FILENAME83" /D "PAPY3_VAR" /D "_MBCS" /D "WIN32" /YX /FD /c # ADD BASE RSC /l 0x40c # ADD RSC /l 0x40c BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ENDIF # Begin Target # Name "Dicmdir3 - Win32 Release" # Name "Dicmdir3 - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90" # Begin Source File SOURCE=.\DicomDirDatasetRead.c # End Source File # Begin Source File SOURCE=.\DicomDirDatasetWrite.c # End Source File # Begin Source File SOURCE=.\DicomDirFiles.c # End Source File # Begin Source File SOURCE=.\DicomDirInit.c # End Source File # Begin Source File SOURCE=.\DicomDirInitRecords.c # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd" # Begin Source File SOURCE=.\DicomDir.h # End Source File # Begin Source File SOURCE=.\DicomDirEnumRecords.h # End Source File # Begin Source File SOURCE=.\DicomDirGlobalVar3.h # End Source File # Begin Source File SOURCE=.\DicomDirInitRecords.h # End Source File # Begin Source File SOURCE=.\DicomDirPrivFunctionDef3.h # End Source File # Begin Source File SOURCE=.\DicomDirPubFunctionDef3.h # End Source File # Begin Source File SOURCE=.\DicomDirTypeDef3.h # End Source File # End Group # Begin Group "Resource Files" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe" # End Group # End Target # End Project Papyrus3/DicomDir/DicomDirInitRecords.h0000755000175000017500000001267710044154136015245 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit (DicomDir library) */ /* File : DicomdirInitRecords.h */ /* Function : declaration of the init fct. */ /* Authors : Marianne Logean */ /* */ /* History : 06.1997 version 3.5 */ /* 02.1999 version 3.6 */ /* */ /********************************************************************************/ #ifndef DicomdirInitRecordsH #define DicomdirInitRecordsH #endif /* ------------------------- functions definition ------------------------------*/ #ifdef _NO_PROTO extern void init_PatientR(); extern void init_StudyR(); extern void init_SeriesR(); extern void init_ImageR(); extern void init_OverlayR(); extern void init_ModalityLUTR(); extern void init_VOILUTR(); extern void init_CurveR(); extern void init_Topic(); extern void init_Visit(); extern void init_Result(); extern void init_Interpretation(); extern void init_StudyComponentR(); extern void init_PrintQueue(); extern void init_FilmSession(); extern void init_BasicFilmBox(); extern void init_BasicImageBox(); #else extern void init_PatientR(SElement[]); extern void init_StudyR(SElement[]); extern void init_SeriesR(SElement[]); extern void init_ImageR(SElement[]); extern void init_OverlayR(SElement[]); extern void init_ModalityLUTR(SElement[]); extern void init_VOILUTR(SElement[]); extern void init_CurveR(SElement[]); extern void init_Topic(SElement[]); extern void init_Visit(SElement[]); extern void init_Result(SElement[]); extern void init_Interpretation(SElement[]); extern void init_StudyComponentR(SElement[]); extern void init_PrintQueue(SElement[]); extern void init_FilmSession(SElement[]); extern void init_BasicFilmBox(SElement[]); extern void init_BasicImageBox(SElement[]); #endif /* DicomdirInitRecordsH */ Papyrus3/DicomDir/DicomdirTypeDef3.h0000755000175000017500000001554310044205466014501 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit (DicomDir library) */ /* File : DicomdirTypeDef3.h */ /* Function : contains the declarations of the constants, the enumerated */ /* types, the structures and the type definition for the */ /* Dicomdir library. */ /* Authors : Marianne Logean */ /* */ /* History : 02.1999 created version 3.6 */ /* */ /********************************************************************************/ #ifndef DicomdirTypeDef3H #define DicomdirTypeDef3H #define VR_AE_LENGTH 16 /* Application Entity */ #define VR_AS_LENGTH 4 /* Age string */ #define VR_AT_LENGTH 4 /* Attribute tag */ #define VR_CS_LENGTH 256 /* Control string */ #define VR_DA_LENGTH 10 /* Date */ #define VR_DS_LENGTH 16 /* Decimal string */ #define VR_DT_LENGTH 26 /* Date/Time */ #define VR_FL_LENGTH 16 /* Float */ #define VR_FD_LENGTH 4 /* Floating double */ #define VR_IS_LENGTH 8 /* Integer string */ #define VR_LO_LENGTH 64 /* Long string */ #define VR_LT_LENGTH 10240 /* Long text */ #define VR_PN_LENGTH 64 /* Person Name */ #define VR_SH_LENGTH 16 /* Short string */ #define VR_SL_LENGTH 4 /* Signed long */ #define VR_SS_LENGTH 2 /* Signed short */ #define VR_ST_LENGTH 1024 /* Short text */ #define VR_TM_LENGTH 16 /* Time */ #define VR_UI_LENGTH 64 /* Unique identifier (UID) */ #define VR_UL_LENGTH 4 /* Unsigned long */ #define VR_US_LENGTH 2 /* Unsigned short */ typedef struct SPatientData_ { struct SPatientData_ *nextPatient; char fileID [VR_CS_LENGTH + 1]; char SOP_ClassUID [VR_UI_LENGTH + 1]; char SOP_InstanceUID [VR_UI_LENGTH + 1]; char patientName [VR_UI_LENGTH + 1]; char patientID [VR_UI_LENGTH + 1]; char *entry; struct SStudyData_ *studyInfo; } SPatientData; typedef struct SStudyData_ { struct SStudyData_ *nextStudy; char fileID [VR_CS_LENGTH + 1]; char SOP_ClassUID [VR_UI_LENGTH + 1]; char SOP_InstanceUID [VR_UI_LENGTH + 1]; char studyDate [VR_DA_LENGTH + 1]; char studyTime [VR_TM_LENGTH + 1]; char studyInstanceUID [VR_UI_LENGTH + 1]; char studyID [VR_UI_LENGTH + 1]; char studyDescription [VR_LO_LENGTH + 1]; char *entry; struct SSeriesData_ *seriesInfo; } SStudyData; typedef struct SSeriesData_ { struct SSeriesData_ *nextSeries; char fileID [VR_CS_LENGTH + 1]; char SOP_ClassUID [VR_UI_LENGTH + 1]; char SOP_InstanceUID [VR_UI_LENGTH + 1]; char modality [VR_CS_LENGTH + 1]; char institutionName [VR_LO_LENGTH + 1]; char institutionAddress [VR_ST_LENGTH + 1]; char seriesInstanceUID [VR_UI_LENGTH + 1]; char seriesNumber [VR_IS_LENGTH + 1]; char performingMD [VR_PN_LENGTH + 1]; char *entry; struct SImageData_ *imageInfo; int nbImages; int multiFrame; } SSeriesData; typedef struct SImageData_ { struct SImageData_ *nextImage; char fileID [VR_CS_LENGTH + 1]; char SOP_ClassUID [VR_UI_LENGTH + 1]; char SOP_InstanceUID [VR_UI_LENGTH + 1]; char imageNumber [VR_IS_LENGTH + 1]; char calibrationObject [VR_CS_LENGTH + 1]; } SImageData; #endif /* DicomdirTypeDef3H */ Papyrus3/DicomDir/DicomDirInitRecords.c0000755000175000017500000022660410044155656015245 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit (Dicomdir library) */ /* File : DicomdirInitRecords.c */ /* Function : contains the Directory record initialisation functions */ /* Authors : Marianne Logean */ /* */ /* History : 05.1997 version 3.51 */ /* 02.1999 version 3.6 */ /* */ /********************************************************************************/ /* ------------------------- includes ---------------------------------------*/ #include #ifndef DicomdirH #include "DicomDir.h" #endif /********************************************************************************/ /* */ /* init_PatientR : initializes the elements of the Directory Record */ /* Patient */ /* */ /********************************************************************************/ void init_PatientR (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordP]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseP]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityP]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeP]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDP]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDP]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetP]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileP]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileP]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileP]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRP]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsNameDR]; theWrkP->group = 0x0010; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientIDDR]; theWrkP->group = 0x0010; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_PatientR */ /********************************************************************************/ /* */ /* init_StudyR : initializes the elements of the Directory Record */ /* Study */ /* */ /********************************************************************************/ void init_StudyR (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordS]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseS]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityS]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeS]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDS]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDS]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetS]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileS]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileS]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileS]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRS]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyDateDRS]; theWrkP->group = 0x0008; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyTimeDRS]; theWrkP->group = 0x0008; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyDescriptionDRS]; theWrkP->group = 0x0008; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyInstanceUIDDRS]; theWrkP->group = 0x0020; theWrkP->element = 0x000D; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyIDDRS]; theWrkP->group = 0x0020; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAccessionNumberDRS]; theWrkP->group = 0x0008; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_StudyR */ /********************************************************************************/ /* */ /* init_SeriesR : initializes the elements of the Directory Record */ /* Series */ /* */ /********************************************************************************/ void init_SeriesR (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordSE]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseSE]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntitySE]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeSE]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDSE]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDSE]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetSE]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileSE]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileSE]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileSE]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRSE]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModalityDRSE]; theWrkP->group = 0x0008; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesInstanceUIDDRSE]; theWrkP->group = 0x0020; theWrkP->element = 0x000E; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesNumberDRSE]; theWrkP->group = 0x0020; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIconImageSequenceDRSE]; theWrkP->group = 0x0088; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_SeriesR */ /********************************************************************************/ /* */ /* init_ImageR : initializes the elements of the Directory Record */ /* Image */ /* */ /********************************************************************************/ void init_ImageR (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordI]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseI]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityI]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeI]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDI]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDI]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetI]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileI]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileI]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileI]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRI]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageNumberDRI]; theWrkP->group = 0x0020; theWrkP->element = 0x0013; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIconImageSequenceDRI]; theWrkP->group = 0x0088; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_ImageR */ /********************************************************************************/ /* */ /* init_OverlayR : initializes the elements of the Directory Record */ /* Overlay */ /* */ /********************************************************************************/ void init_OverlayR (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordO]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseO]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityO]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeO]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDO]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDO]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetO]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileO]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileO]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileO]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRO]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayNumberDRO]; theWrkP->group = 0x0020; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIconImageSequenceDRO]; theWrkP->group = 0x0088; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_OverlayR */ /********************************************************************************/ /* */ /* init_ModalityLUTR : initializes the elements of the Directory Record */ /* Modality LUT */ /* */ /********************************************************************************/ void init_ModalityLUTR (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordM]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseM]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityM]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeM]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDM]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDM]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetM]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileM]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileM]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileM]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRM]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLUTNumberDRM]; theWrkP->group = 0x0020; theWrkP->element = 0x0026; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_ModalityLUTR */ /********************************************************************************/ /* */ /* init_VOILUTR : initializes the elements of the Directory Record */ /* VOILUT */ /* */ /********************************************************************************/ void init_VOILUTR (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordV]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseV]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityV]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeV]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDV]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDV]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetV]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileV]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileV]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileV]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRV]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLUTNumberDRV]; theWrkP->group = 0x0020; theWrkP->element = 0x0026; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_VOILUTR */ /********************************************************************************/ /* */ /* init_CurveR : initializes the elements of the Directory Record */ /* Curve */ /* */ /********************************************************************************/ void init_CurveR (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordC]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseC]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityC]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeC]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDC]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDC]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetC]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileC]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileC]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileC]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRC]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveNumberDRC]; theWrkP->group = 0x0020; theWrkP->element = 0x0024; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_CurveR */ /********************************************************************************/ /* */ /* init_Topic : initializes the elements of the Directory Record */ /* Topic */ /* */ /********************************************************************************/ void init_Topic (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordT]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseT]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityT]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeT]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDT]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDT]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetT]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileT]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileT]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileT]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRT]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTopicTitleDRT]; theWrkP->group = 0x0088; theWrkP->element = 0x0904; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTopicSubjectDRT]; theWrkP->group = 0x0088; theWrkP->element = 0x0906; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTopicAuthorDRT]; theWrkP->group = 0x0088; theWrkP->element = 0x0910; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTopicKeyWordsDRT]; theWrkP->group = 0x0088; theWrkP->element = 0x0912; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-32"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Topic */ /********************************************************************************/ /* */ /* init_Visit : initializes the elements of the Directory Record */ /* Visit */ /* */ /********************************************************************************/ void init_Visit (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordVI]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseVI]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityVI]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeVI]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDVI]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDVI]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetVI]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileVI]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileVI]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileVI]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdmittingDateDRVI]; theWrkP->group = 0x0038; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdmissionIDDRVI]; theWrkP->group = 0x0038; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstitutionNameDRVI]; theWrkP->group = 0x0008; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRVI]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Visit */ /********************************************************************************/ /* */ /* init_Result : initializes the elements of the Directory Record */ /* Result */ /* */ /********************************************************************************/ void init_Result (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordR]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseR]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityR]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeR]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDR]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDR]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetR]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileR]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileR]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileR]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papResultsIDDRR]; theWrkP->group = 0x4008; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstanceCreationDateDRR]; theWrkP->group = 0x0008; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRR]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Result */ /********************************************************************************/ /* */ /* init_Interpretation : initializes the elements of the Directory Record */ /* Interpretation */ /* */ /********************************************************************************/ void init_Interpretation (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordIN]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseIN]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityIN]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeIN]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDIN]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDIN]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetIN]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileIN]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileIN]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileIN]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRIN]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationTranscriptionDateDRIN]; theWrkP->group = 0x4008; theWrkP->element = 0x0108; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationAuthorDRIN]; theWrkP->group = 0x4008; theWrkP->element = 0x010C; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationDiagnosisDescriptionDRIN]; theWrkP->group = 0x4008; theWrkP->element = 0x0115; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDiagnosisCodeSequenceDRIN]; theWrkP->group = 0x4008; theWrkP->element = 0x0117; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationIDDRIN]; theWrkP->group = 0x4008; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationTypeIDDRIN]; theWrkP->group = 0x4008; theWrkP->element = 0x0210; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationStatusIDDRIN]; theWrkP->group = 0x4008; theWrkP->element = 0x0212; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Interpretation */ /********************************************************************************/ /* */ /* init_StudyComponentR : initializes the elements of the Directory Record */ /* Study Component */ /* */ /********************************************************************************/ void init_StudyComponentR (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordSC]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseSC]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntitySC]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeSC]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDSC]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDSC]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetSC]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileSC]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileSC]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileSC]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRSC]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModalityDRSC]; theWrkP->group = 0x0008; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyDescriptionDRSC]; theWrkP->group = 0x0008; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papProcedureCodeSequenceDRSC]; theWrkP->group = 0x0008; theWrkP->element = 0x1032; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformingPhysiciansNameDRSC]; theWrkP->group = 0x0008; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_StudyComponentR */ /********************************************************************************/ /* */ /* init_PrintQueue : initializes the elements of the Directory Record */ /* Print Queue */ /* */ /********************************************************************************/ void init_PrintQueue (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordPQ]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInusePQ]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityPQ]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypePQ]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDPQ]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDPQ]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetPQ]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFilePQ]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFilePQ]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFilePQ]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrintQueueIDDRPQ]; theWrkP->group = 0x2110; theWrkP->element = 0x0099; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRPQ]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrinterNameDRPQ]; theWrkP->group = 0x2110; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_PrintQueue */ /********************************************************************************/ /* */ /* init_FilmSession : initializes the elements of the Directory Record */ /* Film Session */ /* */ /********************************************************************************/ void init_FilmSession (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordFS]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseFS]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityFS]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeFS]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDFS]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDFS]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetFS]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileFS]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileFS]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileFS]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRFS]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilmSessionLabelDRFS]; theWrkP->group = 0x2000; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExecutionStatusDRFS]; theWrkP->group = 0x2100; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_FilmSession */ /********************************************************************************/ /* */ /* init_BasicFilmBox : initializes the elements of the Directory Record */ /* Basic Film Box */ /* */ /********************************************************************************/ void init_BasicFilmBox (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordBFB]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseBFB]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityBFB]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeBFB]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDBFB]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDBFB]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetBFB]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileBFB]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileBFB]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileBFB]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRBFB]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExecutionStatusDRBFB]; theWrkP->group = 0x2100; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_BasicFilmBox */ /********************************************************************************/ /* */ /* init_BasicImageBox : initializes the elements of the Directory Record */ /* Basic Image Box */ /* */ /********************************************************************************/ void init_BasicImageBox (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofNextDirectoryRecordBIB]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseBIB]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityBIB]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeBIB]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDBIB]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDBIB]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetBIB]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileBIB]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileBIB]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileBIB]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetDRBIB]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagePosition2020DRBIB]; theWrkP->group = 0x2020; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_BasicImageBox */ Papyrus3/DicomDir/dicomdir.dsp0000755000175000017500000000756707535143454013554 0ustar # Microsoft Developer Studio Project File - Name="dicomdir" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=dicomdir - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "dicomdir.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "dicomdir.mak" CFG="dicomdir - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "dicomdir - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "dicomdir - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "dicomdir - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "dicomdir___Win32_Release" # PROP BASE Intermediate_Dir "dicomdir___Win32_Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "dicomdir___Win32_Release" # PROP Intermediate_Dir "dicomdir___Win32_Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD CPP /nologo /W3 /GX /O2 /I ".." /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD BASE RSC /l 0x100c /d "NDEBUG" # ADD RSC /l 0x100c /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ELSEIF "$(CFG)" == "dicomdir - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "dicomdir___Win32_Debug" # PROP BASE Intermediate_Dir "dicomdir___Win32_Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "dicomdir___Win32_Debug" # PROP Intermediate_Dir "dicomdir___Win32_Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I ".." /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD BASE RSC /l 0x100c /d "_DEBUG" # ADD RSC /l 0x100c /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ENDIF # Begin Target # Name "dicomdir - Win32 Release" # Name "dicomdir - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\DicomDirDataSetRead.c # End Source File # Begin Source File SOURCE=.\DicomDirDataSetWrite.c # End Source File # Begin Source File SOURCE=.\DicomDirFiles.c # End Source File # Begin Source File SOURCE=.\DicomDirInit.c # End Source File # Begin Source File SOURCE=.\DicomDirInitRecords.c # End Source File # Begin Source File SOURCE=.\OGlobalDicomFunc.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=.\DicomDir.h # End Source File # Begin Source File SOURCE=.\DicomDirEnumRecords.h # End Source File # Begin Source File SOURCE=.\DicomdirGlobalVar3.h # End Source File # Begin Source File SOURCE=.\DicomDirInitRecords.h # End Source File # Begin Source File SOURCE=.\DicomdirPrivFunctionDef3.h # End Source File # Begin Source File SOURCE=.\DicomdirPubFunctionDef3.h # End Source File # Begin Source File SOURCE=.\DicomdirTypeDef3.h # End Source File # Begin Source File SOURCE=.\OGlobalDicomFunc.h # End Source File # End Group # End Target # End Project Papyrus3/DicomDir/OGlobalDicomFunc.cpp0000755000175000017500000001371710044166144015045 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ // *************************************************************************** // *************************************************************************** // // OGlobalDicomFunc // // **************************************************************************** // **************************************************************************** // // FILENAME : OGlobalDicomFunc.cpp // // CLASSES : none // // DESCRIPTION : Utility routines for DICOM type conversion. // // HISTORY : 24-02-99 CHG creation // // **************************************************************************** // **************************************************************************** // ***************************************************************************** // *** INCLUDES // ***************************************************************************** #include // ***************************************************************************** // *** DicomDateToDate // ***************************************************************************** void DicomDateToDate (char *inChar, char *outChar) // converts the date introduced in DICOM files in something more displayable { strcpy (outChar, inChar); if (outChar [4] != '.') // new style { outChar [4] = '.'; outChar [5] = inChar [4]; outChar [6] = inChar [5]; outChar [7] = '.'; outChar [8] = inChar [6]; outChar [9] = inChar [7]; outChar [10] = '\0'; } // if ...new style } // endofmethod DicomDateToDate // ***************************************************************************** // *** DicomTimeToTime // ***************************************************************************** void DicomTimeToTime (char *inChar, char *outChar) // converts the date introduced in DICOM files in something more displayable { strcpy (outChar, inChar); if (outChar [2] != ':') // new style time { outChar [2] = ':'; outChar [3] = inChar [2]; outChar [4] = inChar [3]; outChar [5] = ':'; outChar [6] = inChar [4]; outChar [7] = inChar [5]; outChar [8] = '\0'; } // if ...new style time } // endofmethod DicomTimeToTime // ***************************************************************************** // *** DicomNameToName // ***************************************************************************** void DicomNameToName (char *inChar, char *outChar) // converts the date introduced in DICOM files in something more displayable { long lengthOfString, i; lengthOfString = (long) strlen (inChar); for (i = 0; i < lengthOfString; i++) if (inChar [i] == '^') outChar [i] = ' '; else outChar [i] = inChar [i]; outChar [lengthOfString] = '\0'; } // endofmethod DicomNameToName Papyrus3/DicomDir/DicomdirGlobalVar3.h0000755000175000017500000001052610044156372015007 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit (DicomDir library) */ /* File : DicomdirGlobalVar3.h */ /* Function : contains the declarations of global variables */ /* Authors : Marianne Logean */ /* Christian Girard */ /* */ /* History : 02.1999 version 3.6 */ /* */ /********************************************************************************/ #ifndef DicomdirGlobalVar3H #define DicomdirGlobalVar3H #ifdef FILENAME83 #undef FILENAME83 #endif /* --- global variables --- */ /* has the DICOMDIR toolkit been inited or not ? */ WHERE3 int gIsDicd3Inited; WHERE3 PapyShort gArrRecord [END_RECORD]; #endif /* DicomdirGlobalVar3H */ Papyrus3/PapyErrorMacros3.h0000755000175000017500000001261610044204374013057 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyErrorMacros3.h */ /* Function : contains the fatal, warning and debug printing messages */ /* Authors : Jean-Francois Vurlod */ /* */ /* History : 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef __Papy3ErrorMacros__ #define __Papy3ErrorMacros__ #include /* Eventually there should be a "SetFatalErrorHandler" function. */ #define PAPY_FATAL_ERROR(code,str)\ {\ fprintf(stderr,\ "\nFatal Error -- Code: %d\n\tMessage: %s\n\tFile: %s Line: %d\n",\ code,\ str,\ __FILE__,\ __LINE__);\ if (ExitWhenError) exit((int)code);\ } #define PAPY_WARNING(code,str)\ {\ fprintf(stderr,\ "\nWARNING -- Code: %d\n\tMessage: %s\n\tFile: %s Line: %d\n",\ code,\ str,\ __FILE__,\ __LINE__);\ } #ifdef DEBUG #define PAPY_DEBUG(str)\ {\ fprintf(stderr,\ "\nDEBUG -- Message: %s\n\tFile: %s Line: %d\n",\ str,\ __FILE__,\ __LINE__);\ } #else #define PAPY_DEBUG(str) #endif #endif /* __Papy3ErrorMacros__ */ Papyrus3/PapyFileSystemUnix3.c0000755000175000017500000002501310044202532013531 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyFileSystemUnix3.c */ /* Function : contains machine specific calls to the different file systems */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ /* ------------------------- includes ------------------------------------------*/ #include #include #include #include #include /* open */ #ifndef _WINDOWS #ifndef Mac #ifdef hpux #include #else #include #include #include #include #endif #endif #endif #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #ifndef __PapyError3__ #include "PapyError3.h" #endif /********************************************************************************/ /* */ /* Papy3FCreate : overwrites the standard create file function */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FCreate (char *inFilenameP, PAPY_FILE inVolume, PAPY_FILE *inFp, void **inFSSpecP) { int err; PAPY_FILE file; if ((file = fopen (inFilenameP, "rb")) != NULL) { (void) fclose (file); RETURN (papFileAlreadyExist); } if ((file = fopen (inFilenameP, "wb")) == NULL) RETURN (papFileCreationFailed); (void) fclose (file); return 0; } /* endof Papy3FCreate */ /********************************************************************************/ /* */ /* Papy3FOpen : overwrites the standard open file function */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort Papy3FOpen (char *inFilenameP, char inPermission, PAPY_FILE inVolumeNb, PAPY_FILE *outFp, void *inFSSpecP) /* inPermission r : read, w : write, a : read/write (all) */ { PAPY_FILE file; switch (inPermission) { case 'r' : if ((*outFp = fopen (inFilenameP, "rb")) == NULL) RETURN (papOpenFile); break; case 'w' : if ((*outFp = fopen (inFilenameP, "wb")) == NULL) RETURN (papOpenFile); break; case 'a' : default : if ((*outFp = fopen (inFilenameP, "r+")) == NULL) RETURN (papOpenFile); }/* endsandwich */ /*outFp = &file;*/ return 0; } /* endof Papy3FOpen */ /********************************************************************************/ /* */ /* Papy3FClose : overwrites the standard close file function */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FClose (PAPY_FILE *inFp) { fclose (*inFp); return 0; } /* endof Papy3FClose */ /********************************************************************************/ /* */ /* Papy3FDelete : overwrites the standard delete file function */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FDelete (char *inFilenameP, void *inIdentifierP) { return (unlink ((char *) inFilenameP)); } /* endof Papy3FDelete */ /********************************************************************************/ /* */ /* Papy3FRead : overwrites the standard read from file function */ /* return : error (0 if OK, negative value otherwise) */ /* */ /********************************************************************************/ PapyShort Papy3FRead (PAPY_FILE inFp, PapyULong *ioBytesToReadP, PapyULong inNb, void *ioBufferP) { PapyShort err = 0; err = (PapyShort)(fread ((char *) ioBufferP, (size_t) *ioBytesToReadP, inNb, inFp)); if (err != inNb) return -1; else return 0; } /* endof Papy3FRead */ /********************************************************************************/ /* */ /* Papy3FWrite : overwrite the standard write to file function */ /* return : error (0 if OK, negative value otherwise) */ /* */ /********************************************************************************/ PapyShort Papy3FWrite (PAPY_FILE inFp, PapyULong *ioBytesToWriteP, PapyULong inNb, void *outBufferP) { PapyShort err = 0; err = (PapyShort)(fwrite ((char *) outBufferP, (int)*ioBytesToWriteP, inNb, inFp)); return err; } /* endof Papy3FWrite */ /********************************************************************************/ /* */ /* Papy3FSeek : Papyrus own build file pointer positioning function. */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FSeek (PAPY_FILE inFp, int inPosMode, PapyLong inOffset) { PapyLong startPos, fileLimit; long err; if (inOffset > 100000L) { startPos = (PapyLong) ftell (inFp); /* get the end of file */ err = fseek (inFp, 0L, (int) SEEK_END); fileLimit = (PapyLong) ftell (inFp); if (inOffset > fileLimit) return -1; err = fseek (inFp, (long) startPos, (int) SEEK_SET); } err = fseek (inFp, (long) inOffset, inPosMode); return err; } /* endof Papy3FSeek */ /********************************************************************************/ /* */ /* Papy3FTell : Papyrus function to get the current position of the file */ /* pointer. */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FTell (PAPY_FILE inFp, PapyLong *outFilePosP) { int err = 0; *outFilePosP = (PapyLong) ftell (inFp); return err; } /* endof Papy3FTell */ /********************************************************************************/ /* */ /* Papy3FPrint : Papyrus function to set a string. */ /* */ /********************************************************************************/ void Papy3FPrint (char *inStringP, char *inFormatP, int inValue) { sprintf (inStringP, inFormatP, inValue); } /* endof Papy3FPrint */ Papyrus3/PapyEallocUnix3.c0000755000175000017500000002017110044173376012661 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyEalloc3.c */ /* Function : contains all the allocating stuff */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 07.1992 version 1.2 */ /* 05.1993 version 2.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* */ /********************************************************************************/ /* ------------------------- includes ---------------------------------------*/ #include #include #include #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #include "PapyWild3.h" /********************************************************************************/ /* */ /* checkvp3 : check if the new allocated did not failed */ /* return : the validated pointer if OK */ /* else exit the program */ /* */ /********************************************************************************/ static void * checkvp3 (void *pointer) { if (pointer == NULL) wildrexit ("allocating memory"); return pointer; } /* endof checkvp3 */ /********************************************************************************/ /* */ /* emalloc3 : checked version of malloc */ /* return : the validated pointer if OK */ /* */ /********************************************************************************/ void * emalloc3 (PapyULong size) { return checkvp3 (malloc ((size_t) size)); } /* endof emalloc3 */ /********************************************************************************/ /* */ /* ecalloc3 : checked version of calloc */ /* return : the validated pointer if OK */ /* */ /********************************************************************************/ void * ecalloc3 (PapyULong nelem, PapyULong elsize) { return checkvp3 (calloc ((size_t) nelem, (size_t) elsize)); } /* endof ecalloc3 */ /********************************************************************************/ /* */ /* erealloc3 : checked version of realloc */ /* return : the validated pointer if OK */ /* */ /********************************************************************************/ void * erealloc3 (void *ptr, PapyULong size,PapyULong size2) { return checkvp3 (realloc ((char *)ptr, (size_t) size)); } /* endof erealloc3 */ /********************************************************************************/ /* */ /* efree3 : free the allocated memory and put the pointer to NULL */ /* */ /********************************************************************************/ /* modify it to have the pointer on the pointer to really put it to NULL */ void efree3 (void **p) { if (*p) free((char *)*p); *p = NULL; } /* endof efree3 */ Papyrus3/PapyWild3.c0000755000175000017500000001656610044201456011521 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyWild3.c */ /* Function : handle all the messages for program breaks */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 04.1991 version 1.1 */ /* 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ /* ------------------------- includes ----------------------------------------*/ #include #include #include /********************************************************************************/ /* */ /* wildname : compares the name of the breaking program */ /* return : */ /* */ /********************************************************************************/ char * wildname (register char *inNameP) { register int i; static char theSaved [15]; if (inNameP != NULL && *inNameP != '\0') { for (i = 0; (theSaved [i] = *inNameP) != '\0'; ++inNameP) { if (isalnum (*inNameP) && isupper (*inNameP)) theSaved [i] = tolower (*inNameP); if ((*inNameP == '/' || *inNameP == '\\') && *(inNameP + 1) != '/' && *(inNameP + 1) != '\\' && *(inNameP + 1) != '\0') i = 0; else if (i < sizeof theSaved - 1) ++i; } /* for */ if (i > 5 && (strcmp (&theSaved [i - 4], ".exe") == 0 || strcmp (&theSaved [i - 4], ".com") == 0)) theSaved [i - 4] = '\0'; } /* if */ return (theSaved [0] == '\0') ? "?" : theSaved; } /* endof wildname */ /********************************************************************************/ /* */ /* wild3 : writes the error message */ /* */ /********************************************************************************/ void wild3 (char *inPart1P,char * inPart2P) { inPart1P = inPart1P; inPart2P = inPart2P; #if qDebug (void) fflush (stdout); /* ** One space after the colon matches what perror does ** (although your typing teacher may want a second space). */ (void) fprintf (stderr, "\n%s: wild", wildname ((char *) NULL)); if (inPart1P != NULL && *inPart1P != '\0') (void) fprintf (stderr, " %s", inPart1P); if (inPart2P != NULL && *inPart2P != '\0') (void) fprintf (stderr, " %s", inPart2P); (void) fprintf (stderr, "\n"); #endif } /* endof wild3 */ Papyrus3/PapyEnumModules3.h0000755000175000017500000001771310044202740013054 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyEnumModules3.h */ /* Function : contains the declarations of the modules names */ /* Authors : Christian Girard */ /* */ /* History : 04.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef PapyEnumModulesH #define PapyEnumModulesH #ifndef FILENAME83 /* this is for the normal machines ... */ #include "PapyEnumImagesModules3.h" #else /* FILENAME83 defined for the DOS machines */ #include "PAPEIM3.h" #endif /* FILENAME83 defined */ /* enumeration of the modules */ enum modules { AcquisitionContext, Approval, Audio, BasicAnnotationPresentation, BasicFilmBoxPresentation, BasicFilmBoxRelationship, BasicFilmSessionPresentation, BasicFilmSessionRelationship, BiPlaneImage, BiPlaneOverlay, BiPlaneSequence, Cine, ContrastBolus, CRImage, CRSeries, CTImage, Curve, CurveIdentification, Device, DirectoryInformation, DisplayShutter, DXAnatomyImaged, DXImage, DXDetector, DXPositioning, DXSeries, ExternalPapyrus_FileReferenceSequence, ExternalPatientFileReferenceSequence, ExternalStudyFileReferenceSequence, ExternalVisitReferenceSequence, FileReference, FileSetIdentification, FrameOfReference, FramePointers, GeneralEquipment, GeneralImage, GeneralPatientSummary, GeneralSeries, GeneralSeriesSummary, GeneralStudy, GeneralStudySummary, GeneralVisitSummary, IconImage, IdentifyingImageSequence, ImageBoxRelationship, ImageBoxPixelPresentation, ImageHistogram, ImageIdentification, ImageOverlayBoxRelationship, ImageOverlayBoxPresentation, ImagePixel, ImagePlane, ImagePointer, ImageSequencePap, InternalImagePointerSequence, InterpretationApproval, InterpretationIdentification, InterpretationRecording, InterpretationRelationship, InterpretationState, InterpretationTranscription, IntraOralImage, IntraOralSeries, LUTIdentification, MammographyImage, MammographySeries, Mask, ModalityLUT, MRImage, Multi_frameOverlay, Multi_Frame, NMDetector, NMImage, NMImagePixel, NMIsotope, NMMulti_gatedAcquisitionImage, NMMultiFrame, NMPhase, NMReconstruction, NMSeries, NMTomoAcquisition, OverlayIdentification, OverlayPlane, PaletteColorLookup, PatientDemographic, PatientIdentification, PatientMedical, Patient, PatientRelationship, PatientStudy, PatientSummary, PETCurve, PETImage, PETIsotope, PETMultiGatedAcquisition, PETSeries, PixelOffset, Printer, PrintJob, ResultIdentification, ResultsImpression, ResultRelationship, RFTomographyAcquisition, ROIContour, RTBeams, RTBrachyApplicationSetups, RTDose, RTDoseROI, RTDVH, RTFractionScheme, RTGeneralPlan, RTImage, RTPatientSetup, RTPrescription, RTROIObservations, RTSeries, RTToleranceTables, SCImage, SCImageEquipment, SCMultiFrameImage, SCMultiFrameVector, SlideCoordinates, SOPCommon, SpecimenIdentification, StructureSet, StudyAcquisition, StudyClassification, StudyComponentAcquisition, StudyComponent, StudyComponentRelationship, StudyContent, StudyIdentification, StudyRead, StudyRelationship, StudyScheduling, Therapy, UINOverlaySequence, USImage, USFrameofReference, USRegionCalibration, VisitAdmission, VisitDischarge, VisitIdentification, VisitRelationship, VisitScheduling, VisitStatus, VLImage, VOILUT, XRayAcquisition, XRayAcquisitionDose, XRayCollimator, XRayFiltration, XRayGeneration, XRayGrid, XRayImage, XRayTable, XRayTomographyAcquisition, XRFPositioner, END_MODULE }; /* enumeration of the records */ enum records { PatientR, StudyR, SeriesR, ImageR, OverlayR, ModalityLUTR, VOILUTR, CurveR, Topic, Visit, Result, Interpretation, StudyComponentR, PrintQueue, FilmSession, BasicFilmBox, BasicImageBox, END_RECORD }; #endif /* PapyEnumModulesH */ Papyrus3/PapyInit3.c0000755000175000017500000045763210044203422011523 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyInit3.c */ /* Function : contains all the initialisation functions */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 04.1991 version 1.1 */ /* 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifdef Mac #pragma segment papy3 #endif /* ------------------------- includes -----------------------------------------*/ #include #ifndef Papyrus3H #include "Papyrus3.h" #endif #ifndef PapyInitModules3H #ifndef FILENAME83 /* this is for the normal machines ... */ #include "PapyInitModules3.h" #else /* FILENAME83 defined for the DOS machines */ #include "PAPINIM3.h" #endif #endif /* FILENAME83 defined */ /********************************************************************************/ /* */ /* Papy3AddOwner : this function creates or enlarges the allowed elements */ /* of the shadow-groups that we are able to read */ /* return : always return 0 */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3AddOwner (PapyShort inFileNb, char *inValueP) { SShadowOwner *theShOwP; gNbShadowOwner [inFileNb] ++; if (gNbShadowOwner [inFileNb] == 1) /* first value */ { gShadowOwner [inFileNb] = (SShadowOwner *) emalloc3 ((PapyULong) sizeof (SShadowOwner)); theShOwP = gShadowOwner [inFileNb]; } /* then */ else /* multiple value => need to be enlarged */ { gShadowOwner [inFileNb] = (SShadowOwner *) erealloc3 (gShadowOwner [inFileNb], (PapyULong) ((gNbShadowOwner [inFileNb]) * sizeof (SShadowOwner)), (PapyULong) ((gNbShadowOwner [inFileNb] - 1L) * sizeof (SShadowOwner))); /* OLB */ theShOwP = gShadowOwner [inFileNb] + gNbShadowOwner [inFileNb] - 1; } /* else */ theShOwP->str_value = inValueP; return 0; } /* endof Papy3AddOwner */ /********************************************************************************/ /* */ /* Papy3Init : initializes the PAPYRUS toolkit */ /* return : always return 0 */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3Init () { PapyShort i; /* test to see wether the toolkit has been initialised or not */ if (gIsPapy3Inited == 21) return 0; else gIsPapy3Inited = 21; /* initialize the version number of the PAPYRUS toolkit */ strcpy (gPapyrusVersion, "3.7"); /* initialize the compatibility flag */ strcpy (gPapyrusCompatibility, "2"); /* initialize the group numbers and the number of elements in the groups */ InitGroupNbAndSize3 (); /* initialize the number of elements in the modules */ InitModuleSize3 (); /* for each kind of data set give the modules and their usage */ InitDataSetModules3 (); /* for each modality stores the associated UID */ InitUIDs3 (); /* initialize all the labels associated to the module name and their elements */ InitModulesLabels3 (); /* Modif DRD gCurrFile = -1; */ /* initialize some pointers to NULL */ for (i = 0; i < kMax_file_open; i++) { gCurrTmpFilename [i] = 1; gPapFilename [i] = NULL; gArrMemFile [i] = NULL; gPapyFile [i] = 0; gArrIcons [i] = NULL; gPatientSummaryItem [i] = NULL; gPtrSequenceItem [i] = NULL; gImageSequenceItem [i] = NULL; gArrGroup41 [i] = NULL; gRefSOPClassUID [i] = NULL; gRefImagePointer [i] = NULL; gRefPixelOffset [i] = NULL; gPosImagePointer [i] = NULL; gPosPixelOffset [i] = NULL; gImageSOPinstUID [i] = NULL; gx0028BitsAllocated [i] = 0; } /* for */ gRefSOPInstanceUID = NULL; gRefImageNb = NULL; gRefPixelData = NULL; /* the default size of an icon is 64 */ Papy3SetIconSize ((PapyUShort) 64); return 0; } /* endof Papy3Init */ /********************************************************************************/ /* */ /* Dicom2PapyInit : initializes the global values for the format */ /* conversion in the toolkit */ /* return : always return 0 */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Dicom2PapyInit () { /* initialize the different conversion factors */ gCompression = NONE; gCompressionFactor = 1; gZoomFactor = 1.0; gWindowWidth = 0; gWindowLevel = 0; gSubSamplingFactor = 1.0; /* initialize gCropingRect(X1, Y1, X2, Y2) */ SetCropingPoints (0.0, 0.0, 1.0, 1.0); return 0; } /* endof Dicom2PapyInit */ /****************************************************************************** * Name: SetModality * * Purpose: ******************************************************************************/ enum EModality SetModality (char *modality) /* CR_IM, CT_IM, MR_IM, NM_IM, US_IM, US_MF_IM, SEC_CAPT_IM, DX_IM, MG_IM, IO_IM, RF_IM, PET_IM, PX_IM, VLE_IM, VLM_IM, VLS_IM, VLP_IM, MFSBSC_IM, MFGBSC_IM, MFGWSC_IM, MFTCSC_IM, END_MODALITY */ { if (modality != NULL) { switch (modality [0]) { case 'C' : switch (modality [1]) { case 'T' : return (CT_IM); case 'R' : default : return (CR_IM); }/* switch */ break; case 'D' : return (DX_IM); case 'E' : case 'L' : return (CT_IM); case 'I' : return (IO_IM); case 'M' : switch (modality [2]) { case 'S' : return (MFSBSC_IM); case 'T' : return (MFTCSC_IM); case 'G' : switch (modality [3]) { case 'B' : return (MFGBSC_IM); case 'W' : return (MFGWSC_IM); } /* switch */ break; }/* switch */ return (MR_IM); case 'P' : return (PET_IM); case 'R' : return (RF_IM); case 'N' : case 'S' : return (NM_IM); case 'U' : return (US_IM); case 'V' : switch (modality [2]) { case 'E' : return (VLE_IM); case 'M' : return (VLM_IM); case 'S' : return (VLS_IM); case 'P' : return (VLP_IM); }/* switch */ break; default: return (SEC_CAPT_IM); } /* switch */ } /* endif ...there is a modality */ } /* endof SetModality */ /********************************************************************************/ /* */ /* SetCompression : */ /* return : */ /* */ /********************************************************************************/ void SetCompression (enum EPap_Compression inCompression) { /* initialize gCompression */ gCompression = inCompression; } /* endof SetCompression */ /********************************************************************************/ /* */ /* SetCompressionFactor : */ /* return : */ /* */ /********************************************************************************/ void SetCompressionFactor (int inCompressionFactor) { /* initialize gCompressionFactor */ gCompressionFactor = inCompressionFactor; } /* endof SetCompressionFactor */ /********************************************************************************/ /* */ /* SetZoomFactor : */ /* return : */ /* */ /********************************************************************************/ void SetZoomFactor (float inZoomFactor) { /* initialize gZoomFactor */ gZoomFactor = inZoomFactor; } /* endof SetZoomFactor */ /********************************************************************************/ /* */ /* SetWindowingValue : */ /* return : */ /* */ /********************************************************************************/ void SetWindowingValue (int inWindowLevel, int inWindowWidth) { /* initialize gWindowWidth and gWindowLevel */ gWindowWidth = inWindowWidth; gWindowLevel = inWindowLevel; } /* endof SetWindowingValue */ /********************************************************************************/ /* */ /* SetSubSamplingFactor : */ /* return : */ /* */ /********************************************************************************/ void SetSubSamplingFactor (float inSubSamplingFactor) { /* initialize gSubSamplingFactor */ gSubSamplingFactor = inSubSamplingFactor; } /* endof SetSubSamplingFactor */ /********************************************************************************/ /* */ /* SetCropingPoints : */ /* return : */ /* */ /********************************************************************************/ void SetCropingPoints (float X1, float Y1, float X2, float Y2) { /* initialize gCropingPoints */ gLeftX = X1; gTopY = Y1; gRightX = X2; gBottomY = Y2; } /* endof SetCropingPoints */ /********************************************************************************/ /* */ /* InitGroupNbAndSize3 : initializes the number and the number of elements */ /* for each defined group. */ /* */ /********************************************************************************/ void InitGroupNbAndSize3 () { /* matching of enum-place and real number of the groups names */ gArrGroup [(int) Group2].number = 0x0002; gArrGroup [(int) Group2].size = papEndGroup2; gArrGroup [(int) Group4].number = 0x0004; gArrGroup [(int) Group4].size = papEndGroup4; gArrGroup [(int) Group8].number = 0x0008; gArrGroup [(int) Group8].size = papEndGroup8; gArrGroup [(int) Group10].number = 0x0010; gArrGroup [(int) Group10].size = papEndGroup10; gArrGroup [(int) Group18].number = 0x0018; gArrGroup [(int) Group18].size = papEndGroup18; gArrGroup [(int) Group20].number = 0x0020; gArrGroup [(int) Group20].size = papEndGroup20; gArrGroup [(int) Group28].number = 0x0028; gArrGroup [(int) Group28].size = papEndGroup28; gArrGroup [(int) Group32].number = 0x0032; gArrGroup [(int) Group32].size = papEndGroup32; gArrGroup [(int) Group38].number = 0x0038; gArrGroup [(int) Group38].size = papEndGroup38; gArrGroup [(int) Group3A].number = 0x003A; gArrGroup [(int) Group3A].size = papEndGroup3A; gArrGroup [(int) Group40].number = 0x0040; gArrGroup [(int) Group40].size = papEndGroup40; gArrGroup [(int) Group41].number = 0x0041; gArrGroup [(int) Group41].size = papEndGroup41; gArrGroup [(int) Group50].number = 0x0050; gArrGroup [(int) Group50].size = papEndGroup50; gArrGroup [(int) Group54].number = 0x0054; gArrGroup [(int) Group54].size = papEndGroup54; gArrGroup [(int) Group60].number = 0x0060; gArrGroup [(int) Group60].size = papEndGroup60; gArrGroup [(int) Group70].number = 0x0070; gArrGroup [(int) Group70].size = papEndGroup70; gArrGroup [(int) Group88].number = 0x0088; gArrGroup [(int) Group88].size = papEndGroup88; gArrGroup [(int) Group100].number = 0x00100; gArrGroup [(int) Group100].size = papEndGroup100; gArrGroup [(int) Group2000].number = 0x2000; gArrGroup [(int) Group2000].size = papEndGroup2000; gArrGroup [(int) Group2010].number = 0x2010; gArrGroup [(int) Group2010].size = papEndGroup2010; gArrGroup [(int) Group2020].number = 0x2020; gArrGroup [(int) Group2020].size = papEndGroup2020; gArrGroup [(int) Group2030].number = 0x2030; gArrGroup [(int) Group2030].size = papEndGroup2030; gArrGroup [(int) Group2040].number = 0x2040; gArrGroup [(int) Group2040].size = papEndGroup2040; gArrGroup [(int) Group2050].number = 0x2050; gArrGroup [(int) Group2050].size = papEndGroup2050; gArrGroup [(int) Group2100].number = 0x2100; gArrGroup [(int) Group2100].size = papEndGroup2100; gArrGroup [(int) Group2110].number = 0x2110; gArrGroup [(int) Group2110].size = papEndGroup2110; gArrGroup [(int) Group2120].number = 0x2120; gArrGroup [(int) Group2120].size = papEndGroup2120; gArrGroup [(int) Group2130].number = 0x2130; gArrGroup [(int) Group2130].size = papEndGroup2130; gArrGroup [(int) Group3002].number = 0x3002; gArrGroup [(int) Group3002].size = papEndGroup3002; gArrGroup [(int) Group3004].number = 0x3004; gArrGroup [(int) Group3004].size = papEndGroup3004; gArrGroup [(int) Group3006].number = 0x3006; gArrGroup [(int) Group3006].size = papEndGroup3006; gArrGroup [(int) Group3008].number = 0x3008; gArrGroup [(int) Group3008].size = papEndGroup3008; gArrGroup [(int) Group300A].number = 0x300A; gArrGroup [(int) Group300A].size = papEndGroup300A; gArrGroup [(int) Group300C].number = 0x300C; gArrGroup [(int) Group300C].size = papEndGroup300C; gArrGroup [(int) Group300E].number = 0x300E; gArrGroup [(int) Group300E].size = papEndGroup300E; gArrGroup [(int) Group4000].number = 0x4000; gArrGroup [(int) Group4000].size = papEndGroup4000; gArrGroup [(int) Group4008].number = 0x4008; gArrGroup [(int) Group4008].size = papEndGroup4008; gArrGroup [(int) Group5000].number = 0x5000; gArrGroup [(int) Group5000].size = papEndGroup5000; gArrGroup [(int) Group5400].number = 0x5400; gArrGroup [(int) Group5400].size = papEndGroup5400; gArrGroup [(int) Group6000].number = 0x6000; gArrGroup [(int) Group6000].size = papEndGroup6000; gArrGroup [(int) UINOVERLAY].number = 0x6001; gArrGroup [(int) UINOVERLAY].size = papEndUINOverlay; gArrGroup [(int) Group7FE0].number = 0x7FE0; gArrGroup [(int) Group7FE0].size = papEndGroup7FE0; } /* endof InitGroupNbAndSize3 */ /********************************************************************************/ /* */ /* InitModuleSize3 : initializes the number of element for each defined */ /* module. */ /* */ /********************************************************************************/ void InitModuleSize3 () { /* initialization of the modules length */ gArrModule [(int) AcquisitionContext] = papEndAcquisitionContext; gArrModule [(int) Approval] = papEndApproval; gArrModule [(int) Audio] = papEndAudio; gArrModule [(int) BasicAnnotationPresentation] = papEndBasicAnnotationPresentation; gArrModule [(int) BasicFilmBoxPresentation] = papEndBasicFilmBoxPresentation; gArrModule [(int) BasicFilmBoxRelationship] = papEndBasicFilmBoxRelationship; gArrModule [(int) BasicFilmSessionPresentation] = papEndBasicFilmSessionPresentation; gArrModule [(int) BasicFilmSessionRelationship] = papEndBasicFilmSessionRelationship; gArrModule [(int) BiPlaneSequence] = papEndBiPlaneSequence; gArrModule [(int) BiPlaneImage] = papEndBiPlaneImage; gArrModule [(int) BiPlaneOverlay] = papEndBiPlaneOverlay; gArrModule [(int) Cine] = papEndCine; gArrModule [(int) ContrastBolus] = papEndContrastBolus; gArrModule [(int) CRImage] = papEndCRImage; gArrModule [(int) CRSeries] = papEndCRSeries; gArrModule [(int) CTImage] = papEndCTImage; gArrModule [(int) Curve] = papEndCurve; gArrModule [(int) CurveIdentification] = papEndCurveIdentification; gArrModule [(int) Device] = papEndDevice; gArrModule [(int) DirectoryInformation] = papEndDirectoryInformation; gArrModule [(int) DisplayShutter] = papEndDisplayShutter; gArrModule [(int) DXAnatomyImaged] = papEndDXAnatomyImaged; gArrModule [(int) DXImage] = papEndDXImage; gArrModule [(int) DXDetector] = papEndDXDetector; gArrModule [(int) DXPositioning] = papEndDXPositioning; gArrModule [(int) DXSeries] = papEndDXSeries; gArrModule [(int) ExternalPapyrus_FileReferenceSequence]= papEndExternalPapyrus_FileReferenceSequence; gArrModule [(int) ExternalPatientFileReferenceSequence] = papEndExternalPatientFileReferenceSequence; gArrModule [(int) ExternalStudyFileReferenceSequence] = papEndExternalStudyFileReferenceSequence; gArrModule [(int) ExternalVisitReferenceSequence] = papEndExternalVisitReferenceSequence; gArrModule [(int) FileReference] = papEndFileReference; gArrModule [(int) FileSetIdentification] = papEndFileSetIdentification; gArrModule [(int) FrameOfReference] = papEndFrameOfReference; gArrModule [(int) FramePointers] = papEndFramePointers; gArrModule [(int) GeneralEquipment] = papEndGeneralEquipment; gArrModule [(int) GeneralImage] = papEndGeneralImage; gArrModule [(int) GeneralPatientSummary] = papEndGeneralPatientSummary; gArrModule [(int) GeneralSeries] = papEndGeneralSeries; gArrModule [(int) GeneralSeriesSummary] = papEndGeneralSeriesSummary; gArrModule [(int) GeneralStudy] = papEndGeneralStudy; gArrModule [(int) GeneralStudySummary] = papEndGeneralStudySummary; gArrModule [(int) GeneralVisitSummary] = papEndGeneralVisitSummary; gArrModule [(int) IconImage] = papEndIconImage; gArrModule [(int) IdentifyingImageSequence] = papEndIdentifyingImageSequence; gArrModule [(int) ImageBoxPixelPresentation] = papEndImageBoxPixelPresentation; gArrModule [(int) ImageBoxRelationship] = papEndImageBoxRelationship; gArrModule [(int) ImageHistogram] = papEndImageHistogram; gArrModule [(int) ImageIdentification] = papEndImageIdentification; gArrModule [(int) ImageOverlayBoxPresentation] = papEndImageOverlayBoxPresentation; gArrModule [(int) ImageOverlayBoxRelationship] = papEndImageOverlayBoxRelationship; gArrModule [(int) ImagePixel] = papEndImagePixel; gArrModule [(int) ImagePlane] = papEndImagePlane; gArrModule [(int) ImagePointer] = papEndImagePointer; gArrModule [(int) ImageSequencePap] = papEndImageSequence; gArrModule [(int) InternalImagePointerSequence] = papEndInternalImagePointerSequence; gArrModule [(int) InterpretationApproval] = papEndInterpretationApproval; gArrModule [(int) InterpretationIdentification] = papEndInterpretationIdentification; gArrModule [(int) InterpretationRecording] = papEndInterpretationRecording; gArrModule [(int) InterpretationRelationship] = papEndInterpretationRelationship; gArrModule [(int) InterpretationState] = papEndInterpretationState; gArrModule [(int) InterpretationTranscription] = papEndInterpretationTranscription; gArrModule [(int) IntraOralImage] = papEndIntraOralImage; gArrModule [(int) IntraOralSeries] = papEndIntraOralSeries; gArrModule [(int) LUTIdentification] = papEndLUTIdentification; gArrModule [(int) MammographyImage] = papEndMammographyImage; gArrModule [(int) MammographySeries] = papEndMammographySeries; gArrModule [(int) Mask] = papEndMask; gArrModule [(int) ModalityLUT] = papEndModalityLUT; gArrModule [(int) MRImage] = papEndMRImage; gArrModule [(int) Multi_frameOverlay] = papEndMulti_frameOverlay; gArrModule [(int) Multi_Frame] = papEndMulti_Frame; gArrModule [(int) NMDetector] = papEndNMDetector; gArrModule [(int) NMImage] = papEndNMImage; gArrModule [(int) NMImagePixel] = papEndNMImagePixel; gArrModule [(int) NMIsotope] = papEndNMIsotope; gArrModule [(int) NMMultiFrame] = papEndNMMultiFrame; gArrModule [(int) NMMulti_gatedAcquisitionImage] = papEndNMMulti_gatedAcquisitionImage; gArrModule [(int) NMPhase] = papEndNMPhase; gArrModule [(int) NMReconstruction] = papEndNMReconstruction; gArrModule [(int) NMSeries] = papEndNMSeries; gArrModule [(int) NMTomoAcquisition] = papEndNMTomoAcquisition; gArrModule [(int) OverlayIdentification] = papEndOverlayIdentification; gArrModule [(int) OverlayPlane] = papEndOverlayPlane; gArrModule [(int) PaletteColorLookup] = papEndPaletteColorLookup; gArrModule [(int) PatientDemographic] = papEndPatientDemographic; gArrModule [(int) PatientIdentification] = papEndPatientIdentification; gArrModule [(int) PatientMedical] = papEndPatientMedical; gArrModule [(int) Patient] = papEndPatient; gArrModule [(int) PatientRelationship] = papEndPatientRelationship; gArrModule [(int) PatientStudy] = papEndPatientStudy; gArrModule [(int) PatientSummary] = papEndPatientSummary; gArrModule [(int) PETCurve] = papEndPETCurve; gArrModule [(int) PETImage] = papEndPETImage; gArrModule [(int) PETIsotope] = papEndPETIsotope; gArrModule [(int) PETMultiGatedAcquisition] = papEndPETMultiGatedAcquisition; gArrModule [(int) PETSeries] = papEndPETSeries; gArrModule [(int) PixelOffset] = papEndPixelOffset; gArrModule [(int) Printer] = papEndPrinter; gArrModule [(int) PrintJob] = papEndPrintJob; gArrModule [(int) ResultIdentification] = papEndResultIdentification; gArrModule [(int) ResultsImpression] = papEndResultsImpression; gArrModule [(int) ResultRelationship] = papEndResultRelationship; gArrModule [(int) RFTomographyAcquisition] = papEndRFTomographyAcquisition; gArrModule [(int) ROIContour] = papEndROIContour; gArrModule [(int) RTBeams] = papEndRTBeams; gArrModule [(int) RTBrachyApplicationSetups] = papEndRTBrachyApplicationSetups; gArrModule [(int) RTDose] = papEndRTDose; gArrModule [(int) RTDoseROI] = papEndRTDoseROI; gArrModule [(int) RTDVH] = papEndRTDVH; gArrModule [(int) RTFractionScheme] = papEndRTFractionScheme; gArrModule [(int) RTGeneralPlan] = papEndRTGeneralPlan; gArrModule [(int) RTImage] = papEndRTImage; gArrModule [(int) RTPatientSetup] = papEndRTPatientSetup; gArrModule [(int) RTPrescription] = papEndRTPrescription; gArrModule [(int) RTROIObservations] = papEndRTROIObservations; gArrModule [(int) RTSeries] = papEndRTSeries; gArrModule [(int) RTToleranceTables] = papEndRTToleranceTables; gArrModule [(int) SCImage] = papEndSCImage; gArrModule [(int) SCImageEquipment] = papEndSCImageEquipment; gArrModule [(int) SCMultiFrameImage] = papEndSCMultiFrameImage; gArrModule [(int) SCMultiFrameVector] = papEndSCMultiFrameVector; gArrModule [(int) SOPCommon] = papEndSOPCommon; gArrModule [(int) SpecimenIdentification] = papEndSpecimenIdentification; gArrModule [(int) StructureSet] = papEndStructureSet; gArrModule [(int) StudyAcquisition] = papEndStudyAcquisition; gArrModule [(int) StudyClassification] = papEndStudyClassification; gArrModule [(int) StudyComponentAcquisition] = papEndStudyComponentAcquisition; gArrModule [(int) StudyComponent] = papEndStudyComponent; gArrModule [(int) StudyComponentRelationship] = papEndStudyComponentRelationship; gArrModule [(int) StudyContent] = papEndStudyContent; gArrModule [(int) StudyIdentification] = papEndStudyIdentification; gArrModule [(int) StudyRead] = papEndStudyRead; gArrModule [(int) StudyRelationship] = papEndStudyRelationship; gArrModule [(int) StudyScheduling] = papEndStudyScheduling; gArrModule [(int) Therapy] = papEndTherapy; gArrModule [(int) UINOverlaySequence] = papEndUINOverlaySequence; gArrModule [(int) USImage] = papEndUSImage; gArrModule [(int) USFrameofReference] = papEndUSFrameofReference; gArrModule [(int) USRegionCalibration] = papEndUSRegionCalibration; gArrModule [(int) VisitAdmission] = papEndVisitAdmission; gArrModule [(int) VisitDischarge] = papEndVisitDischarge; gArrModule [(int) VisitIdentification] = papEndVisitIdentification; gArrModule [(int) VisitRelationship] = papEndVisitRelationship; gArrModule [(int) VisitScheduling] = papEndVisitScheduling; gArrModule [(int) VisitStatus] = papEndVisitStatus; gArrModule [(int) VLImage] = papEndVLImage; gArrModule [(int) VOILUT] = papEndVOILUT; gArrModule [(int) XRayAcquisition] = papEndXRayAcquisition; gArrModule [(int) XRayAcquisitionDose] = papEndXRayAcquisitionDose; gArrModule [(int) XRayCollimator] = papEndXRayCollimator; gArrModule [(int) XRayFiltration] = papEndXRayFiltration; gArrModule [(int) XRayGeneration] = papEndXRayGeneration; gArrModule [(int) XRayGrid] = papEndXRayGrid; gArrModule [(int) XRayImage] = papEndXRayImage; gArrModule [(int) XRayTable] = papEndXRayTable; gArrModule [(int) XRayTomographyAcquisition] = papEndXRayTomographyAcquisition; gArrModule [(int) XRFPositioner] = papEndXRFPositioner; } /* endof InitModuleSize3 */ /********************************************************************************/ /* */ /* InitDataSetModules3 : For each imaging modality give the list of modules*/ /* associated as well as their usage (M, C, U). */ /* */ /********************************************************************************/ void InitDataSetModules3 () { Data_Set *theWrkP; /* allocate room for storing the modules for each kind of imaging modality */ gArrModuleNb [CR_IM] = 16; gArrModalities [CR_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [CR_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [CT_IM] = 14; gArrModalities [CT_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [CT_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [MR_IM] = 14; gArrModalities [MR_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [MR_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [NM_IM] = 25; gArrModalities [NM_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [NM_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [US_IM] = 20; gArrModalities [US_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [US_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [US_MF_IM] = 20; gArrModalities [US_MF_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [US_MF_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [SEC_CAPT_IM] = 14; gArrModalities [SEC_CAPT_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [SEC_CAPT_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [DX_IM] = 31; gArrModalities [DX_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [DX_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [MG_IM] = 33; gArrModalities [MG_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [MG_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [IO_IM] = 33; gArrModalities [IO_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [IO_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [RF_IM] = 28; gArrModalities [RF_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [RF_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [PET_IM] = 18; gArrModalities [PET_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [PET_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [VLE_IM] = 12; gArrModalities [VLE_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [VLE_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [VLM_IM] = 13; gArrModalities [VLM_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [VLM_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [VLS_IM] = 15; gArrModalities [VLS_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [VLS_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [VLP_IM] = 13; gArrModalities [VLP_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [VLP_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [MFSBSC_IM] = 16; gArrModalities [MFSBSC_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [MFSBSC_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [MFGBSC_IM] = 17; gArrModalities [MFGBSC_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [MFGBSC_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [MFGWSC_IM] = 17; gArrModalities [MFGWSC_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [MFGWSC_IM], (PapyULong) sizeof (Data_Set)); gArrModuleNb [MFTCSC_IM] = 16; gArrModalities [MFTCSC_IM] = (Data_Set *) ecalloc3 ((PapyULong) gArrModuleNb [MFTCSC_IM], (PapyULong) sizeof (Data_Set)); /* make the list of modules building the CR images */ theWrkP = gArrModalities [CR_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) CRSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; /* added for image calibration */ theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ContrastBolus; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) CRImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Curve; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ModalityLUT; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the CT images */ theWrkP = gArrModalities [CT_IM]; theWrkP->moduleName = Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = FrameOfReference; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = ImagePlane; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = ContrastBolus; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = CTImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = VOILUT; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = SOPCommon; theWrkP->usage = M; /* make the list of modules building the MR images */ theWrkP = gArrModalities [MR_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) FrameOfReference; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ContrastBolus; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) MRImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the NM images */ theWrkP = gArrModalities [NM_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) NMSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) FrameOfReference; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) NMImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) Multi_Frame; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) NMMultiFrame; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) NMImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) NMIsotope; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) NMDetector; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) NMTomoAcquisition; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) NMMulti_gatedAcquisitionImage; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) NMPhase; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) NMReconstruction; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Multi_frameOverlay; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Curve; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the US images */ theWrkP = gArrModalities [US_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) FrameOfReference; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) USFrameofReference; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PaletteColorLookup; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) ContrastBolus; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) USRegionCalibration; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) USImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) CurveIdentification; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Curve; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Audio; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the US_MF images */ theWrkP = gArrModalities [US_MF_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) FrameOfReference; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) USFrameofReference; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ContrastBolus; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) Cine; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) Multi_Frame; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) USRegionCalibration; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) USImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) CurveIdentification; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) Curve; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) Audio; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the SEC_CAPT images */ theWrkP = gArrModalities [SEC_CAPT_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCImageEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) SCImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ModalityLUT; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the DX_IM (XRay) images */ theWrkP = gArrModalities [DX_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) SpecimenIdentification; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) DXSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) FrameOfReference; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ContrastBolus; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) DisplayShutter; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Device; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Therapy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayCollimator; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayTomographyAcquisition; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayAcquisitionDose; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayGeneration; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayFiltration; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayGrid; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) DXAnatomyImaged; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) DXImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) DXDetector; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) DXPositioning; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Curve; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) ImageHistogram; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) AcquisitionContext; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the MG_IM (Mammography) images */ theWrkP = gArrModalities [MG_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) SpecimenIdentification; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) DXSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) MammographySeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) FrameOfReference; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ContrastBolus; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) DisplayShutter; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Device; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Therapy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayCollimator; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayTomographyAcquisition; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayAcquisitionDose; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayGeneration; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayFiltration; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayGrid; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) DXAnatomyImaged; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) DXImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) DXDetector; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) DXPositioning; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) MammographyImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Curve; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) ImageHistogram; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) AcquisitionContext; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the (INTRAORALX) IO_IM images */ theWrkP = gArrModalities [IO_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) SpecimenIdentification; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) DXSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) IntraOralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) FrameOfReference; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ContrastBolus; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) DisplayShutter; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Device; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Therapy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayCollimator; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayTomographyAcquisition; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayAcquisitionDose; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayGeneration; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayFiltration; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayGrid; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) DXAnatomyImaged; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) DXImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) DXDetector; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) DXPositioning; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) IntraOralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Curve; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) ImageHistogram; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) AcquisitionContext; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the RF images */ theWrkP = gArrModalities [RF_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; /* added for image calibration */ theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ContrastBolus; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) Cine; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) Multi_Frame; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) FramePointers; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Mask; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) DisplayShutter; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Therapy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) XRayAcquisition; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) XRayCollimator; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRayTable; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) XRFPositioner; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) RFTomographyAcquisition; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Multi_frameOverlay; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) Curve; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ModalityLUT; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the PET images */ theWrkP = gArrModalities [PET_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) NMSeries; /* is called NM_PETPatientOrientation in the DICOM std */ theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PETSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PETIsotope; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PETMultiGatedAcquisition; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) FrameOfReference; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; /* added for image calibration */ theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PETImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) Curve; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the Visible Light Endoscopic images */ theWrkP = gArrModalities [VLE_IM]; theWrkP->moduleName = Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = ImagePlane; /* added for callibration purpose */ theWrkP->usage = M; theWrkP++; theWrkP->moduleName = ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = AcquisitionContext; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = VLImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = SOPCommon; theWrkP->usage = M; /* make the list of modules building the Visible Light Microscopic images */ theWrkP = gArrModalities [VLM_IM]; theWrkP->moduleName = Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = SpecimenIdentification; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = ImagePlane; /* added for callibration purpose */ theWrkP->usage = M; theWrkP++; theWrkP->moduleName = ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = AcquisitionContext; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = VLImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = SOPCommon; theWrkP->usage = M; /* make the list of modules building the Visible Light Slide Coordinates Microscopic images */ theWrkP = gArrModalities [VLS_IM]; theWrkP->moduleName = Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = SpecimenIdentification; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = FrameOfReference; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = ImagePlane; /* added for callibration purpose */ theWrkP->usage = M; theWrkP++; theWrkP->moduleName = ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = AcquisitionContext; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = VLImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = SlideCoordinates; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = SOPCommon; theWrkP->usage = M; /* make the list of modules building the Visible Light Photographic images */ theWrkP = gArrModalities [VLP_IM]; theWrkP->moduleName = Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = SpecimenIdentification; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = ImagePlane; /* added for callibration purpose */ theWrkP->usage = M; theWrkP++; theWrkP->moduleName = ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = AcquisitionContext; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = VLImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = OverlayPlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = SOPCommon; theWrkP->usage = M; /* make the list of modules building the Multi_Frame Single Bit SEC_CAPT images */ theWrkP = gArrModalities [MFSBSC_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCImageEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) Cine; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) Multi_Frame; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) FramePointers; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCImage; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCMultiFrameImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) SCMultiFrameVector; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the Multi_Frame Grayscale Byte SEC_CAPT images */ theWrkP = gArrModalities [MFGBSC_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCImageEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) Cine; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) Multi_Frame; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) FramePointers; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCImage; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCMultiFrameImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) SCMultiFrameVector; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the Multi_Frame Grayscale Word SEC_CAPT images */ theWrkP = gArrModalities [MFGWSC_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCImageEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) Cine; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) Multi_Frame; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) FramePointers; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCImage; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCMultiFrameImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) SCMultiFrameVector; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) VOILUT; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; /* make the list of modules building the Multi_Frame True Color SEC_CAPT images */ theWrkP = gArrModalities [MFGWSC_IM]; theWrkP->moduleName = (int) Patient; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralSeries; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) PatientStudy; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) GeneralStudy; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralEquipment; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCImageEquipment; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) GeneralImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) ImagePlane; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) ImagePixel; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) Cine; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) Multi_Frame; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) FramePointers; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCImage; theWrkP->usage = U; theWrkP++; theWrkP->moduleName = (int) SCMultiFrameImage; theWrkP->usage = M; theWrkP++; theWrkP->moduleName = (int) SCMultiFrameVector; theWrkP->usage = C; theWrkP++; theWrkP->moduleName = (int) SOPCommon; theWrkP->usage = M; } /* endof InitDataSetModules3 */ /********************************************************************************/ /* */ /* InitUIDs3 : For each imaging modality give the associated UID */ /* */ /********************************************************************************/ void InitUIDs3 () { PapyShort i; /* allocates room for the storage of the UIDs */ for (i = 0; i < END_MODALITY; i++) gArrUIDs [i] = (char *) ecalloc3 ((PapyULong) 31, (PapyULong) sizeof (char)); /* stores the UIDs for each known imaging modality */ strcpy (gArrUIDs [CR_IM], "1.2.840.10008.5.1.4.1.1.1"); strcpy (gArrUIDs [CT_IM], "1.2.840.10008.5.1.4.1.1.2"); strcpy (gArrUIDs [MR_IM], "1.2.840.10008.5.1.4.1.1.4"); strcpy (gArrUIDs [NM_IM], "1.2.840.10008.5.1.4.1.1.20"); strcpy (gArrUIDs [US_IM], "1.2.840.10008.5.1.4.1.1.6.1"); strcpy (gArrUIDs [US_MF_IM], "1.2.840.10008.5.1.4.1.1.3.1"); strcpy (gArrUIDs [SEC_CAPT_IM], "1.2.840.10008.5.1.4.1.1.7"); strcpy (gArrUIDs [PX_IM], "1.2.840.10008.5.1.4.1.1.1.1"); strcpy (gArrUIDs [DX_IM], "1.2.840.10008.5.1.4.1.1.1.1"); strcpy (gArrUIDs [MG_IM], "1.2.840.10008.5.1.4.1.1.1.2"); strcpy (gArrUIDs [IO_IM], "1.2.840.10008.5.1.4.1.1.1.3"); strcpy (gArrUIDs [RF_IM], "1.2.840.10008.5.1.4.1.1.12.2"); strcpy (gArrUIDs [PET_IM], "1.2.840.10008.5.1.4.1.1.128"); strcpy (gArrUIDs [VLE_IM], "1.2.840.10008.5.1.4.1.1.77.1.1"); strcpy (gArrUIDs [VLM_IM], "1.2.840.10008.5.1.4.1.1.77.1.2"); strcpy (gArrUIDs [VLS_IM], "1.2.840.10008.5.1.4.1.1.77.1.3"); strcpy (gArrUIDs [VLP_IM], "1.2.840.10008.5.1.4.1.1.77.1.4"); strcpy (gArrUIDs [MFSBSC_IM], "1.2.840.10008.5.1.4.1.1.7.1"); strcpy (gArrUIDs [MFGBSC_IM], "1.2.840.10008.5.1.4.1.1.7.2"); strcpy (gArrUIDs [MFGWSC_IM], "1.2.840.10008.5.1.4.1.1.7.3"); strcpy (gArrUIDs [MFTCSC_IM], "1.2.840.10008.5.1.4.1.1.7.4"); } /* endof InitUIDs3 */ /********************************************************************************/ /* */ /* Papy3FreeDataSetModules : Free the allocated global variable . */ /* */ /********************************************************************************/ void Papy3FreeDataSetModules () { PapyShort i; /* has the PAPYRUS toolkit been initialized */ if (gIsPapy3Inited == 21) { /* free room used for the storage of the UIDs and the Modalities */ for (i = 0; i < END_MODALITY; i++) { efree3( (void **)&gArrUIDs [i] ); /* PX_IM modality not used and defined for the moment */ if (i != PX_IM) efree3( (void **)&gArrModalities [i]); } } /* if intialized... */ gIsPapy3Inited = 0; } /* Papy3FreeDataSetModules */ /********************************************************************************/ /* */ /* Papy3GroupCreate : allocates memory for the elements of the groups */ /* return : a pointer to the created group */ /* */ /********************************************************************************/ SElement * CALLINGCONV Papy3GroupCreate (int inGroupNb) { SElement *theGrP; theGrP = (SElement *) ecalloc3 ((PapyULong) gArrGroup [inGroupNb].size, (PapyULong) sizeof (SElement)); (void) InitGroup3 (inGroupNb, theGrP); return theGrP; } /* endof Papy3GroupCreate */ /********************************************************************************/ /* */ /* CreateModule3 : allocates memory for the elements of the module and fill*/ /* in the description of the elements of the module. */ /* return : a pointer to the created module */ /* */ /********************************************************************************/ Module* CreateModule3 (int inModuleID) { Module *theModuleP; theModuleP = (Module *) ecalloc3 ((PapyULong) gArrModule [inModuleID], (PapyULong) sizeof (Module)); (void) InitModule3 (inModuleID, theModuleP); return theModuleP; } /* endof CreateModule3 */ /********************************************************************************/ /* */ /* Papy3ClearElement : Clears an element of a given group or module */ /* specified by its number */ /* The delSeq specifies if the sequence has to be deleted or not */ /* return : return 0 if no error */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3ClearElement (SElement *inGrOrModP, PapyShort inElement, int inDelSeq) { SElement *theElemP; UValue_T *theTmpValP; PapyULong i; theElemP = inGrOrModP + inElement; if (theElemP->nb_val > 0L) { theTmpValP = theElemP->value; for (i = 0L; i < theElemP->nb_val; i++) { /*if (theTmpValP == NULL && !(theElemP->group == 0x0041 && (theElemP->inElement == Papy3EnumToElemNb (theElemP, papPointerSequenceGr) || theElemP->inElement == Papy3EnumToElemNb (theElemP, papImageSequenceGr))))*/ if (theTmpValP == NULL && !(theElemP->group == 0x0041 && (theElemP->element == Papy3EnumToElemNb (theElemP, papPointerSequenceGr) || theElemP->element == Papy3EnumToElemNb (theElemP, papImageSequenceGr))) && !(theElemP->group == 0x0088 && theElemP->element == Papy3EnumToElemNb (theElemP, papIconImageSequenceGr))) RETURN (papProblemInValue); switch (theElemP->vr) { case AE : case AS : case CS : case DA : case DS : case DT : case IS : case LO : case LT : case PN : case SH : case ST : case TM : case UI : case UN : case UT : if (theTmpValP->a == NULL) break; efree3 ((void **) &(theTmpValP->a)); break; case OB : if (theTmpValP->a == NULL) break; efree3 ((void **) &(theTmpValP->a)); break; case OW : if (theTmpValP->ow == NULL) break; efree3 ((void **) &(theTmpValP->ow)); /* efree3 ((void **) &theTmpValP); */ break; case SQ : if ((theTmpValP == NULL || theTmpValP->sq == NULL) && !(theElemP->group == 0x0041 && (theElemP->element == Papy3EnumToElemNb (theElemP, papPointerSequenceGr) || theElemP->element == Papy3EnumToElemNb (theElemP, papImageSequenceGr))) && !(theElemP->group == 0x0088 && theElemP->element == Papy3EnumToElemNb (theElemP, papIconImageSequenceGr))) RETURN (papProblemInValue); if (inDelSeq) { if (!(theElemP->group == 0x0041 && (theElemP->element == Papy3EnumToElemNb (theElemP, papPointerSequenceGr) || theElemP->element == Papy3EnumToElemNb (theElemP, papImageSequenceGr))) && !(theElemP->group == 0x0088 && theElemP->element == Papy3EnumToElemNb (theElemP, papIconImageSequenceGr))) { /* we have to delete the whole sequence CHG */ if (DeleteList (0, &(theTmpValP->sq), TRUE, TRUE, TRUE) < 0) RETURN (papProblemInValue); /*efree3 ((void **) &(theTmpValP->sq));*/ } else if (theTmpValP != NULL) theTmpValP->sq = NULL; } /* if ...deletes the sequence */ else if (theTmpValP != NULL) theTmpValP->sq = NULL; break; default : break; } /* switch */ theTmpValP++; } /* for ...loop on the values */ theElemP->nb_val = 0L; efree3 ((void **) &(theElemP->value)); } /* if ...nb_val > 0 */ RETURN (papNoError); } /* endof Papy3ClearElement */ /********************************************************************************/ /* */ /* Papy3GroupFree : Frees a previously allocated group */ /* return : standard error message if a problem occur */ /* zero otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3GroupFree (SElement **ioGroupP, int inDelSeq) { SElement *theElemP; PapyShort theGrSize, i, theErr, theEnumPlace; if (*ioGroupP == NULL) RETURN (papNoError) if ((*ioGroupP)->group < 0x6000 || (*ioGroupP)->group > 0x6FFF) { theEnumPlace = Papy3ToEnumGroup ((*ioGroupP)->group); if (theEnumPlace < 0) RETURN (theEnumPlace) theGrSize = (short) gArrGroup [theEnumPlace].size; } /* then */ else { if ((*ioGroupP)->group % 2 == 0) /* group with even group number */ /* overlays groups are from 0x6000 to 0x601E */ theGrSize = (short) gArrGroup [Group6000].size; else /* group with odd group number = shadow group */ /* UINOverlays are from 0x6001 to 0x6FFF */ theGrSize = (short) gArrGroup [UINOVERLAY].size; } /* else */ if ((*ioGroupP)->group == 0x5000) { for (i = 0; i < theGrSize; i++) if (i != papCurveDataGr) { if ((theErr = Papy3ClearElement (*ioGroupP, i, inDelSeq)) < 0) RETURN (theErr); } /* if */ else { theElemP = *ioGroupP + i; if (theElemP->value != NULL) { switch (theElemP->vr) /* puts the value of the curve data element */ { /* to NULL but do not free the memory !!! */ case OB : theElemP->value->a = NULL; break; case OW : theElemP->value->ow = NULL; break; } /* switch */ efree3 ((void **) &(theElemP->value)); } /* if ...theElemP->value <> NULL */ } /* else */ } /* if ... gropup 0x5000 */ else if ((*ioGroupP)->group != 0x7FE0) { for (i = 0; i < theGrSize; i++) if ((theErr = Papy3ClearElement (*ioGroupP, i, inDelSeq)) < 0) RETURN (theErr); } /* if ...group not 0x7FE0 */ else /* group = 7FE0 */ { theErr = Papy3ClearElement (*ioGroupP, 0, TRUE); if (theErr < 0) RETURN (theErr) theElemP = *ioGroupP + 1; if (theElemP->value != NULL) { switch (theElemP->vr) /* puts the value of the pixel data element */ { /* to NULL but do not free the memory !!! */ case OB : theElemP->value->a = NULL; break; case OW : theElemP->value->ow = NULL; break; } /* switch */ efree3 ((void **) &(theElemP->value)); } /* if ...theElemP->value <> NULL */ } /* else ... group 7FE0 */ efree3 ((void **) ioGroupP); RETURN (papNoError) } /* endof Papy3GroupFree */ /********************************************************************************/ /* */ /* Papy3FreeSQElement : Frees unused SQ from the group */ /* return : standard error message if a problem occur */ /* zero otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3FreeSQElement (SElement **ioGroupP, Module *inModuleP, int inModuleID) { int j, found; PapyShort theGrSize, i, theErr, theEnumGrNb; Module *theElemP; SElement *theArrElemP; if (*ioGroupP == NULL) RETURN (papNoError) if ((*ioGroupP)->group < 0x6000 || (*ioGroupP)->group > 0x6FFF) { theEnumGrNb = Papy3ToEnumGroup ((*ioGroupP)->group); /* gr_nb papyrus -> enum */ if (theEnumGrNb < 0) RETURN (theEnumGrNb) theGrSize = (short) gArrGroup [theEnumGrNb].size; } /* then */ else { if ((*ioGroupP)->group % 2 == 0) /* group with even group number */ /* overlays groups are from 0x6000 to 0x601E */ theGrSize = (short) gArrGroup [Group6000].size; else /* group with odd group number = shadow group */ /* UINOverlays are from 0x6001 to 0x6FFF */ theGrSize = (short) gArrGroup [UINOVERLAY].size; } /* else */ if ((*ioGroupP)->group != 0x7FE0) { for (i = 0, theArrElemP = *ioGroupP; i < theGrSize; i++, theArrElemP++) { found = FALSE; if ((theArrElemP->value != NULL) && (theArrElemP->vr == SQ)) { /* detect now if this sequence exist in the module. If not, delete it */ theElemP = inModuleP; /* test each element of the module to see if it belongs to the group */ for (j = 0; j < gArrModule [inModuleID]; j++, theElemP++) { /* does the element belongs to the group ? */ if ((theElemP->group == theArrElemP->group) && (theElemP->element == theArrElemP->element)) { found = TRUE; } /* if ...the element exists */ } /* for ...loop on the elements of the module */ if (!found) if ((theErr = Papy3ClearElement (*ioGroupP, i, TRUE)) < 0) RETURN (theErr); /* if ...the element is a SQ */ } /* if (theValP != NULL) */ } /* for ...loop on the elements of the group */ } /* if ...group not 0x7FE0 */ RETURN (papNoError) } /* endof Papy3FreeSQElement */ /********************************************************************************/ /* */ /* Papy3ModuleFree : Frees a previously allocated module. */ /* return : standard error message if a problem occur */ /* zero otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3ModuleFree (SElement **ioModuleP, int inModuleID, int inDelSeq) { SElement *theElemP; PapyShort theModuleSize, i, theErr; if (*ioModuleP == NULL) RETURN (papNoError); if (inModuleID < 0) RETURN (papEnumGroup); theModuleSize = gArrModule [inModuleID]; if (theModuleSize < 0) RETURN (papGroupErr); /* free the elements of the module */ for (i = 0, theElemP = *ioModuleP; i < theModuleSize; i++, theElemP++) { if ((inModuleID == ImagePixel && i == papPixelData) || (inModuleID == IconImage && i == papPixelDataII) || (inModuleID == Curve && i == papCurveData) || (inModuleID == OverlayPlane && i == papOverlayData)) { if (theElemP->value != NULL) { switch (theElemP->vr) /* puts the value of the pixel data element */ { /* to NULL but do not free the memory !!! */ case OB : theElemP->value->a = NULL; break; case OW : theElemP->value->ow = NULL; break; } /* switch */ efree3 ((void **) &(theElemP->value)); } /* if ...elem->value <> NULL */ } /* if ... pixel data */ else if ((theErr = Papy3ClearElement (*ioModuleP, i, inDelSeq)) < 0) RETURN (theErr); } /* for */ efree3 ((void **) ioModuleP); RETURN (papNoError) } /* endof Papy3ModuleFree */ /********************************************************************************/ /* */ /* Papy3ImageFree : Frees a previously allocated image */ /* return : 0 if OK else standard error message */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3ImageFree (SElement *inGrOrModP) { PapyShort theErr = 0; if (inGrOrModP == NULL) RETURN (papGroupErr) theErr = Papy3ClearElement (inGrOrModP, papPixelData, TRUE); RETURN (theErr) } /* endof Papy3ImageFree */ /********************************************************************************/ /* */ /* InitGroup3 : initializes the selected group */ /* */ /********************************************************************************/ void InitGroup3 (int inGroupEnum, SElement *ioElemP) { switch (inGroupEnum) { case Group2 : init_group2 (ioElemP); break; case Group4 : init_group4 (ioElemP); break; case Group8 : init_group8 (ioElemP); break; case Group10 : init_group10 (ioElemP); break; case Group18 : init_group18 (ioElemP); break; case Group20 : init_group20 (ioElemP); break; case Group28 : init_group28 (ioElemP); break; case Group32 : init_group32 (ioElemP); break; case Group38 : init_group38 (ioElemP); break; case Group3A : init_group3A (ioElemP); break; case Group40 : init_group40 (ioElemP); break; case Group41 : init_group41 (ioElemP); break; case Group50 : init_group50 (ioElemP); break; case Group54 : init_group54 (ioElemP); break; case Group60 : init_group60 (ioElemP); break; case Group70 : init_group70 (ioElemP); break; case Group88 : init_group88 (ioElemP); break; case Group100 : init_group100 (ioElemP); break; case Group2000 : init_group2000 (ioElemP); break; case Group2010 : init_group2010 (ioElemP); break; case Group2020 : init_group2020 (ioElemP); break; case Group2030 : init_group2030 (ioElemP); break; case Group2040 : init_group2040 (ioElemP); break; case Group2050 : init_group2050 (ioElemP); break; case Group2100 : init_group2100 (ioElemP); break; case Group2110 : init_group2110 (ioElemP); break; case Group2120 : init_group2120 (ioElemP); break; case Group2130 : init_group2130 (ioElemP); break; case Group3002 : init_group3002 (ioElemP); break; case Group3004 : init_group3004 (ioElemP); break; case Group3006 : init_group3006 (ioElemP); break; case Group3008 : init_group3008 (ioElemP); break; case Group300A : init_group300A (ioElemP); break; case Group300C : init_group300C (ioElemP); break; case Group300E : init_group300E (ioElemP); break; case Group4000 : init_group4000 (ioElemP); break; case Group4008 : init_group4008 (ioElemP); break; case Group5000 : init_group5000 (ioElemP); break; case Group5400 : init_group5400 (ioElemP); break; case Group6000 : init_group6000 (ioElemP); break; case Group7FE0 : init_group7FE0 (ioElemP); break; case UINOVERLAY : init_uinoverlay (ioElemP); break; default : break; } /* end switch */ } /* endof InitGroup3 */ /********************************************************************************/ /* */ /* InitModule3 : initializes the selected module */ /* */ /********************************************************************************/ void InitModule3 (int inModuleEnum, SElement *ioElemP) { switch (inModuleEnum) { case AcquisitionContext : init_AcquisitionContext (ioElemP); break; case Approval : init_Approval (ioElemP); break; case Audio : init_Audio (ioElemP); break; case BasicAnnotationPresentation : init_BasicAnnotationPresentation (ioElemP); break; case BasicFilmBoxPresentation : init_BasicFilmBoxPresentation (ioElemP); break; case BasicFilmBoxRelationship : init_BasicFilmBoxRelationship (ioElemP); break; case BasicFilmSessionPresentation : init_BasicFilmSessionPresentation (ioElemP); break; case BasicFilmSessionRelationship : init_BasicFilmSessionRelationship (ioElemP); break; case BiPlaneImage : init_BiPlaneImage (ioElemP); break; case BiPlaneOverlay : init_BiPlaneOverlay (ioElemP); break; case BiPlaneSequence : init_BiPlaneSequence (ioElemP); break; case Cine : init_Cine (ioElemP); break; case ContrastBolus : init_ContrastBolus (ioElemP); break; case CRImage : init_CRImage (ioElemP); break; case CRSeries : init_CRSeries (ioElemP); break; case CTImage : init_CTImage (ioElemP); break; case Curve : init_Curve (ioElemP); break; case CurveIdentification : init_CurveIdentification (ioElemP); break; case Device : init_Device (ioElemP); break; case DirectoryInformation : init_DirectoryInformation (ioElemP); break; case DisplayShutter : init_DisplayShutter (ioElemP); break; case DXAnatomyImaged : init_DXAnatomyImaged (ioElemP); break; case DXImage : init_DXImage (ioElemP); break; case DXDetector : init_DXDetector (ioElemP); break; case DXPositioning : init_DXPositioning (ioElemP); break; case DXSeries : init_DXSeries (ioElemP); break; case ExternalPapyrus_FileReferenceSequence : init_ExternalPapyrus_FileReferenceSequence (ioElemP); break; case ExternalPatientFileReferenceSequence : init_ExternalPatientFileReferenceSequence (ioElemP); break; case ExternalStudyFileReferenceSequence : init_ExternalStudyFileReferenceSequence (ioElemP); break; case ExternalVisitReferenceSequence : init_ExternalVisitReferenceSequence (ioElemP); break; case FileReference : init_FileReference (ioElemP); break; case FileSetIdentification : init_FileSetIdentification (ioElemP); break; case FrameOfReference : init_FrameOfReference (ioElemP); break; case FramePointers : init_FramePointers (ioElemP); break; case GeneralEquipment : init_GeneralEquipment (ioElemP); break; case GeneralImage : init_GeneralImage (ioElemP); break; case GeneralPatientSummary : init_GeneralPatientSummary (ioElemP); break; case GeneralSeries : init_GeneralSeries (ioElemP); break; case GeneralSeriesSummary : init_GeneralSeriesSummary (ioElemP); break; case GeneralStudy : init_GeneralStudy (ioElemP); break; case GeneralStudySummary : init_GeneralStudySummary (ioElemP); break; case GeneralVisitSummary : init_GeneralVisitSummary (ioElemP); break; case IconImage : init_IconImage (ioElemP); break; case IdentifyingImageSequence : init_IdentifyingImageSequence (ioElemP); break; case ImageBoxPixelPresentation : init_ImageBoxPixelPresentation (ioElemP); break; case ImageBoxRelationship : init_ImageBoxRelationship (ioElemP); break; case ImageHistogram : init_ImageHistogram (ioElemP); break; case ImageIdentification : init_ImageIdentification (ioElemP); break; case ImageOverlayBoxPresentation : init_ImageOverlayBoxPresentation (ioElemP); break; case ImageOverlayBoxRelationship : init_ImageOverlayBoxRelationship (ioElemP); break; case ImagePixel : init_ImagePixel (ioElemP); break; case ImagePlane : init_ImagePlane (ioElemP); break; case ImagePointer : init_ImagePointer (ioElemP); break; case ImageSequencePap : init_ImageSequence (ioElemP); break; case InternalImagePointerSequence : init_InternalImagePointerSequence (ioElemP); break; case InterpretationApproval : init_InterpretationApproval (ioElemP); break; case InterpretationIdentification : init_InterpretationIdentification (ioElemP); break; case InterpretationRecording : init_InterpretationRecording (ioElemP); break; case InterpretationRelationship : init_InterpretationRelationship (ioElemP); break; case InterpretationState : init_InterpretationState (ioElemP); break; case InterpretationTranscription : init_InterpretationTranscription (ioElemP); break; case IntraOralImage : init_IntraOralImage (ioElemP); break; case IntraOralSeries : init_IntraOralSeries (ioElemP); break; case LUTIdentification : init_LUTIdentification (ioElemP); break; case MammographyImage : init_MammographyImage (ioElemP); break; case MammographySeries : init_MammographySeries (ioElemP); break; case Mask : init_Mask (ioElemP); break; case ModalityLUT : init_ModalityLUT (ioElemP); break; case MRImage : init_MRImage (ioElemP); break; case Multi_frameOverlay : init_Multi_frameOverlay (ioElemP); break; case Multi_Frame : init_Multi_Frame (ioElemP); break; case NMDetector : init_NMDetector (ioElemP); break; case NMImage : init_NMImage (ioElemP); break; case NMImagePixel : init_NMImagePixel (ioElemP); break; case NMIsotope : init_NMIsotope (ioElemP); break; case NMMultiFrame : init_NMMultiFrame (ioElemP); break; case NMMulti_gatedAcquisitionImage : init_NMMulti_gatedAcquisitionImage (ioElemP); break; case NMPhase : init_NMPhase (ioElemP); break; case NMReconstruction : init_NMReconstruction (ioElemP); break; case NMSeries : init_NMSeries (ioElemP); break; case NMTomoAcquisition : init_NMTomoAcquisition (ioElemP); break; case OverlayIdentification : init_OverlayIdentification (ioElemP); break; case OverlayPlane : init_OverlayPlane (ioElemP); break; case PaletteColorLookup : init_PaletteColorLookup (ioElemP); break; case PatientDemographic : init_PatientDemographic (ioElemP); break; case PatientIdentification : init_PatientIdentification (ioElemP); break; case PatientMedical : init_PatientMedical (ioElemP); break; case Patient : init_Patient (ioElemP); break; case PatientRelationship : init_PatientRelationship (ioElemP); break; case PatientStudy : init_PatientStudy (ioElemP); break; case PatientSummary : init_PatientSummary (ioElemP); break; case PETCurve : init_PETCurve (ioElemP); break; case PETImage : init_PETImage (ioElemP); break; case PETIsotope : init_PETIsotope (ioElemP); break; case PETMultiGatedAcquisition : init_PETMultiGatedAcquisition (ioElemP); break; case PETSeries : init_PETSeries (ioElemP); break; case PixelOffset : init_PixelOffset (ioElemP); break; case Printer : init_Printer (ioElemP); break; case PrintJob : init_PrintJob (ioElemP); break; case ResultIdentification : init_ResultIdentification (ioElemP); break; case ResultsImpression : init_ResultsImpression (ioElemP); break; case ResultRelationship : init_ResultRelationship (ioElemP); break; case RFTomographyAcquisition : init_RFTomographyAcquisition (ioElemP); break; case ROIContour : init_ROIContour (ioElemP); break; case RTBeams : init_RTBeams (ioElemP); break; case RTBrachyApplicationSetups : init_RTBrachyApplicationSetups (ioElemP); break; case RTDose : init_RTDose (ioElemP); break; case RTDoseROI : init_RTDoseROI (ioElemP); break; case RTDVH : init_RTDVH (ioElemP); break; case RTFractionScheme : init_RTFractionScheme (ioElemP); break; case RTGeneralPlan : init_RTGeneralPlan (ioElemP); break; case RTImage : init_RTImage (ioElemP); break; case RTPatientSetup : init_RTPatientSetup (ioElemP); break; case RTPrescription : init_RTPrescription (ioElemP); break; case RTROIObservations : init_RTROIObservations (ioElemP); break; case RTSeries : init_RTSeries (ioElemP); break; case RTToleranceTables : init_RTToleranceTables (ioElemP); break; case SCImageEquipment : init_SCImageEquipment (ioElemP); break; case SCImage : init_SCImage (ioElemP); break; case SCMultiFrameImage : init_SCMultiFrameImage (ioElemP); break; case SCMultiFrameVector : init_SCMultiFrameVector (ioElemP); break; case SlideCoordinates : init_SlideCoordinates (ioElemP); break; case SOPCommon : init_SOPCommon (ioElemP); break; case SpecimenIdentification : init_SpecimenIdentification (ioElemP); break; case StructureSet : init_StructureSet (ioElemP); break; case StudyAcquisition : init_StudyAcquisition (ioElemP); break; case StudyClassification : init_StudyClassification (ioElemP); break; case StudyComponentAcquisition : init_StudyComponentAcquisition (ioElemP); break; case StudyComponent : init_StudyComponent (ioElemP); break; case StudyComponentRelationship : init_StudyComponentRelationship (ioElemP); break; case StudyContent : init_StudyContent (ioElemP); break; case StudyIdentification : init_StudyIdentification (ioElemP); break; case StudyRead : init_StudyRead (ioElemP); break; case StudyRelationship : init_StudyRelationship (ioElemP); break; case StudyScheduling : init_StudyScheduling (ioElemP); break; case Therapy : init_Therapy (ioElemP); break; case UINOverlaySequence : init_UINOverlaySequence (ioElemP); break; case USImage : init_USImage (ioElemP); break; case USFrameofReference : init_USFrameofReference (ioElemP); break; case USRegionCalibration : init_USRegionCalibration (ioElemP); break; case VisitAdmission : init_VisitAdmission (ioElemP); break; case VisitDischarge : init_VisitDischarge (ioElemP); break; case VisitIdentification : init_VisitIdentification (ioElemP); break; case VisitRelationship : init_VisitRelationship (ioElemP); break; case VisitScheduling : init_VisitScheduling (ioElemP); break; case VisitStatus : init_VisitStatus (ioElemP); break; case VLImage : init_VLImage (ioElemP); break; case VOILUT : init_VOILUT (ioElemP); break; case XRayAcquisition : init_XRayAcquisition (ioElemP); break; case XRayAcquisitionDose : init_XRayAcquisitionDose (ioElemP); break; case XRayCollimator : init_XRayCollimator (ioElemP); break; case XRayFiltration : init_XRayFiltration (ioElemP); break; case XRayGeneration : init_XRayGeneration (ioElemP); break; case XRayGrid : init_XRayGrid (ioElemP); break; case XRayImage : init_XRayImage (ioElemP); break; case XRayTable : init_XRayTable (ioElemP); break; case XRayTomographyAcquisition : init_XRayTomographyAcquisition (ioElemP); break; case XRFPositioner : init_XRFPositioner (ioElemP); break; default : break; } /* end switch */ } /* endof InitModule3 */ /********************************************************************************/ /* */ /* InitModulesLabels3 : initializes the labels for the module names and */ /* their elements. */ /* */ /********************************************************************************/ void InitModulesLabels3 () { /* initialization of the module names */ sModule_Acquisition_Context = "Module ACQUISITION CONTEXT"; sModule_Approval = "Module APPROVAL"; sModule_Audio = "Module AUDIO"; sModule_Basic_Annotation_Presentation = "Module BASIC ANNOTATION PRESENTATION"; sModule_Basic_Film_Box_Presentation = "Module BASIC FILM BOX PRESENTATION"; sModule_Basic_Film_Box_Relationship = "Module BASIC FILM BOX RELATIONSHIP"; sModule_Basic_Film_Session_Presentation = "Module BASIC FILM SESSION PRESENTATION"; sModule_Basic_Film_Session_Relationship = "Module BASIC FILM SESSION RELATIONSHIP"; sModule_BiPlane_Image = "Module BI-PLANE IMAGE"; sModule_BiPlane_Overlay = "Module BI-PLANE OVERLAY"; sModule_BiPlane_Sequence = "Module BI-PLANE Sequence"; sModule_Cine = "Module CINE"; sModule_Contrast_Bolus = "Module CONTRAST BOLUS"; sModule_CR_Image = "Module CR IMAGE"; sModule_CR_Series = "Module CR SERIES"; sModule_CT_Image = "Module CT IMAGE"; sModule_Curve = "Module CURVE"; sModule_Curve_Identification = "Module CURVE IDENTIFICATION"; sModule_Device = "Module DEVICE"; sModule_Directory_Information = "Module DIRECTORY INFORMATION"; sModule_Display_Shutter = "Module DISPLAY SHUTTER"; sModule_DX_Anatomy_Imaged = "Module DX ANATOMY IMAGED"; sModule_DX_Image = "Module DX IMAGE"; sModule_DX_Detector = "Module DX DETECTOR"; sModule_DX_Positioning = "Module DX POSITIONING"; sModule_DX_Series = "Module DX SERIES"; sModule_External_Papyrus_File_Reference_Sequence = "Module EXTERNAL PAPYRUS FILE REFERENCE Sequence"; sModule_External_Patient_File_Reference_Sequence = "Module EXTERNAL PATIENT FILE REFERENCE SEQUENCE"; sModule_External_Study_File_Reference_Sequence = "Module EXTERNAL STUDY FILE REFERENCE SEQUENCE"; sModule_External_Visit_Reference_Sequence = "Module EXTERNAL VISIT REFERENCE SEQUENCE"; sModule_File_Reference = "Module FILE REFERENCE"; sModule_File_Set_Identification = "Module FILE SET IDENTIFICATION"; sModule_Frame_Of_Reference = "Module FRAME OF REFERENCE"; sModule_Frame_Pointers = "Module FRAME POINTERS"; sModule_General_Equipment = "Module GENERAL EQUIPMENT"; sModule_General_Image = "Module GENERAL IMAGE"; sModule_General_Patient_Summary = "Module GENERAL PATIENT SUMMARY"; sModule_General_Series = "Module GENERAL SERIES"; sModule_General_Series_Summary = "Module GENERAL SERIES SUMMARY"; sModule_General_Study = "Module GENERAL STUDY"; sModule_General_Study_Summary = "Module GENERAL STUDY SUMMARY"; sModule_General_Visit_Summary = "Module GENERAL VISIT SUMMARY"; sModule_Icon_Image = "Module ICON IMAGE"; sModule_Identifying_Image_Sequence = "Module IDENTIFYING IMAGE SEQUENCE"; sModule_Image_Box_Pixel_Presentation = "Module IMAGE BOX PIXEL PRESENTATION"; sModule_Image_Box_Relationship = "Module IMAGE BOX RELATIONSHIP"; sModule_Image_Histogram = "Module IMAGE HISTOGRAM"; sModule_Image_Identification = "Module IMAGE IDENTIFICATION"; sModule_Image_Overlay_Box_Presentation = "Module IMAGE OVERLAY BOX PRESENTATION"; sModule_Image_Overlay_Box_Relationship = "Module IMAGE OVERLAY BOX RELATIONSHIP"; sModule_Image_Pixel = "Module IMAGE PIXEL"; sModule_Image_Plane = "Module IMAGE PLANE"; sModule_Image_Pointer = "Module IMAGE POINTER"; sModule_Image_Sequence = "Module IMAGE SEQUENCE"; sModule_Internal_Image_Pointer_Sequence = "Module INTERNAL IMAGE POINTER SEQUENCE"; sModule_Interpretation_Approval = "Module INTERPRETATION APPROVAL"; sModule_Interpretation_Identification = "Module INTERPRETATION IDENTIFICATION"; sModule_Interpretation_Recording = "Module INTERPRETATION RECORDING"; sModule_Interpretation_Relationship = "Module INTERPRETATION RELATIONSHIP"; sModule_Interpretation_Transcription = "Module INTERPRETATION TRANSCRIPTION"; sModule_Intra_Oral_Image = "Module INTRA-ORAL IMAGE"; sModule_Intra_Oral_Series = "Module INTRA-ORAL SERIES"; sModule_LUT_Identification = "Module LUT IDENTIFICATION"; sModule_Mammography_Image = "Module MAMMOGRAPHY IMAGE"; sModule_Mammography_Series = "Module MAMMOGRAPHY SERIES"; sModule_Mask = "Module MASK"; sModule_Modality_LUT = "Module MODALITY LUT"; sModule_MR_Image = "Module MR IMAGE"; sModule_Multi_Frame = "Module MULTI_FRAME"; sModule_Multi_frame_Overlay = "Module MULTI_FRAME OVERLAY"; sModule_NM_Detector = "Module NM DETECTOR"; sModule_NM_Image = "Module NM IMAGE"; sModule_NM_Image_Pixel = "Module NM IMAGE PIXEL"; sModule_NM_Isotope = "Module NM ISOTOPE"; sModule_NM_Multi_Frame = "Module NM MULTI FRAME"; sModule_NM_Multi_gated_Acquisition_Image = "Module NM MULTI_GATED ACQUISITION IMAGE"; sModule_NM_Phase = "Module NM PHASE"; sModule_NM_Reconstruction = "Module NM RECONSTRUCTION"; sModule_NM_Series = "Module NM SERIES"; sModule_NM_Tomo_Acquisition = "Module NM TOMO ACQUISITION"; sModule_Overlay_Identification = "Module OVERLAY IDENTIFICATION"; sModule_Overlay_Plane = "Module OVERLAY PLANE"; sModule_Palette_Color_Lookup = "Module PALETTE COLOR LOOKUP"; sModule_Patient = "Module PATIENT"; sModule_Patient_Demographic = "Module PATIENT DEMOGRAPHIC"; sModule_Patient_Identification = "Module PATIENT IDENTIFICATION"; sModule_Patient_Medical = "Module PATIENT MEDICAL"; sModule_Patient_Relationship = "Module PATIENT RELATIONSHIP"; sModule_Patient_Study = "Module PATIENT STUDY"; sModule_Patient_Summary = "Module PATIENT SUMMARY"; sModule_PET_Curve = "Module PET CURVE"; sModule_PET_Image = "Module PET IMAGE"; sModule_PET_Isotope = "Module PET ISOTOPE"; sModule_PET_Multi_Gated_Acquisition= "Module PET MULTI_GATED ACQUISITION"; sModule_PET_Series = "Module PET SERIES"; sModule_Pixel_Offset = "Module PIXEL OFFSET"; sModule_Printer = "Module PRINTER"; sModule_Print_Job = "Module PRINT JOB"; sModule_Result_Identification = "Module RESULT IDENTIFICATION"; sModule_Results_Impression = "Module RESULTS IMPRESSION"; sModule_Result_Relationship = "Module RESULT RELATIONSHIP"; sModule_RF_Tomography_Acquisition = "Module RF TOMOGRAPHY ACQUISITION"; sModule_ROI_Contour = "Module ROI CONTOUR"; sModule_RT_Beams = "Module RT BEAMS"; sModule_RT_Brachy_Application_Setups = "Module RT BRACHY APPLICATION SETUPS"; sModule_RT_Dose = "Module RT DOSE"; sModule_RT_Dose_ROI = "Module RT DOSE ROI"; sModule_RT_DVH = "Module RT DVH"; sModule_RT_Fraction_Scheme = "Module RT FRACTION SCHEME"; sModule_RT_General_Plan = "Module RT GENERAL PLAN"; sModule_RT_Image = "Module RT IMAGE"; sModule_RT_Patient_Setup = "Module RT PATIENT SETUP"; sModule_RT_Prescription = "Module RT PRESCRIPTION"; sModule_RT_ROI_Observations = "Module RT ROI OBSERVATIONS"; sModule_RT_Series = "Module RT SERIES"; sModule_RT_Tolerance_Tables = "Module RT TOLERANCE TABLES"; sModule_SC_Image = "Module SC IMAGE"; sModule_SC_Image_Equipment = "Module SC IMAGE EQUIPMENT"; sModule_SC_Multi_Frame_Image = "Module SC MULTI_FRAME_IMAGE"; sModule_SC_Multi_Frame_Vector = "Module SC MULTI_FRAME_VECTOR"; sModule_Slice_Coordinates = "Module SLICE COORDINATES"; sModule_SOP_Common = "Module SOP COMMON"; sModule_Specimen_Identification = "Module SPECIMEN IDENTIFICATION"; sModule_Structure_Set = "Module STRUCTURE SET"; sModule_Study_Acquisition = "Module STUDY ACQUISITION"; sModule_Study_Classification = "Module STUDY CLASSIFICATION"; sModule_Study_Component = "Module STUDY COMPONENT"; sModule_Study_Component_Acquisition = "Module STUDY COMPONENT ACQUISITION"; sModule_Study_Component_Relationship = "Module STUDY COMPONENT RELATIONSHIP"; sModule_Study_Content = "Module STUDY CONTENT"; sModule_Study_Identification = "Module STUDY IDENTIFICATION"; sModule_Study_Read = "Module STUDY READ"; sModule_Study_Relationship = "Module STUDY RELATIONSHIP"; sModule_Study_Scheduling = "Module STUDY SCHEDULING"; sModule_Therapy = "Module THERAPY"; sModule_UIN_Overlay_Sequence = "Module UIN OVERLAY SEQUENCE"; sModule_US_Frame_of_Reference = "Module US FRAME OF REFERENCE"; sModule_US_Image = "Module US IMAGE"; sModule_US_Region_Calibration = "Module US REGION CALIBRATION"; sModule_Visit_Admission = "Module VISIT ADMISSION"; sModule_Visit_Discharge = "Module VISIT DISCHARGE"; sModule_Visit_Identification = "Module VISIT IDENTIFICATION"; sModule_Visit_Relationship = "Module VISIT RELATIONSHIP"; sModule_Visit_Scheduling = "Module VISIT SCHEDULING"; sModule_Visit_Status = "Module VISIT STATUS"; sModule_VL_Image = "Module VL IMAGE"; sModule_VOI_LUT = "Module VOI LUT"; sModule_XRay_Acquisition = "Module XRAY ACQUISITION"; sModule_XRay_Acquisition_Dose = "Module XRAY ACQUISITION DOSE"; sModule_XRay_Collimator = "Module XRAY COLLIMATOR"; sModule_XRay_Filtration = "Module XRAY FILTRATION"; sModule_XRay_Generation = "Module XRAY GENERATION"; sModule_XRay_Grid = "Module XRAY GRID"; sModule_XRay_Image = "Module XRAY IMAGE"; sModule_XRay_Table = "Module XRAY TABLE"; sModule_XRay_Tomography_Acquisition = "Module XRAY TOMOGRAPHY ACQUISITION"; sModule_XRF_Positioner = "Module XRF POSITIONER"; /* initialization of the sLabels names */ /* Module : Acquisition Context */ sLabel_Acquisition_Context [ 0 ] = "Acquisition Context Sequence"; sLabel_Acquisition_Context [ 1 ] = "Acquisition Context Description"; /* Module : Audio */ sLabel_Audio [ 0 ] = "Audio Type"; sLabel_Audio [ 1 ] = "Audio Sample Format"; sLabel_Audio [ 2 ] = "Number of Channels"; sLabel_Audio [ 3 ] = "Number of Samples"; sLabel_Audio [ 4 ] = "Sample Rate"; sLabel_Audio [ 5 ] = "Total Time"; sLabel_Audio [ 6 ] = "Audio Sample Data"; sLabel_Audio [ 7 ] = "Referenced Image Sequence"; sLabel_Audio [ 8 ] = "Audio Comments"; /* Module : Basic Annotation Presentation */ sLabel_BasicAnnotationPresentation [ 0 ] = "Annotation Position"; sLabel_BasicAnnotationPresentation [ 1 ] = "Text String"; /* Module : Basic Film Box Presentation */ /*??????????????????????????*/ /* Module : Basic Film Box Relationship */ /*??????????????????????????*/ /* Module : Basic Film Session Presentation */ /*??????????????????????????*/ /* Module : Basic Film Session Relationship */ /*??????????????????????????*/ /* Module : BiPlane Image */ /*??????????????????????????*/ /* Module : BiPlane Overlay */ /*??????????????????????????*/ /* Module : BiPlane Sequence */ /*??????????????????????????*/ /* Module : Cine */ sLabel_Cine [ 0 ] = "Preferred Playback Sequencing"; sLabel_Cine [ 1 ] = "Frame Time"; sLabel_Cine [ 2 ] = "Frame Time Vector"; sLabel_Cine [ 3 ] = "Start Trim"; sLabel_Cine [ 4 ] = "Stop Trim"; sLabel_Cine [ 5 ] = "Recommended Display Frame Rate"; sLabel_Cine [ 6 ] = "Cine Rate"; sLabel_Cine [ 7 ] = "Frame Delay"; sLabel_Cine [ 8 ] = "Effective Duration"; sLabel_Cine [ 9 ] = "Actual Frame Duration"; /* Module : Contrast Bolus */ sLabel_Contrast_Bolus [ 0 ] = "Contrast/Bolus Agent"; sLabel_Contrast_Bolus [ 1 ] = "Contrast/Bolus Agent Sequence"; sLabel_Contrast_Bolus [ 2 ] = "Contrast/Bolus Route"; sLabel_Contrast_Bolus [ 3 ] = "Contrast/Bolus Administration Route Sequence"; sLabel_Contrast_Bolus [ 4 ] = "Contrast/Bolus Volume"; sLabel_Contrast_Bolus [ 5 ] = "Contrast/Bolus Start Time"; sLabel_Contrast_Bolus [ 6 ] = "Contrast/Bolus Stop Time"; sLabel_Contrast_Bolus [ 7 ] = "Contrast/Bolus Total Dose"; sLabel_Contrast_Bolus [ 8 ] = "Contrast Flow Rates"; sLabel_Contrast_Bolus [ 9 ] = "Contrast Flow Durations"; sLabel_Contrast_Bolus [ 10 ] = "Contrast/Bolus Ingredient"; sLabel_Contrast_Bolus [ 11 ] = "Contrast/Bolus Ingredient Concentration"; /* Module : CR Image */ sLabel_CR_Image [ 0 ] = "KVP"; sLabel_CR_Image [ 1 ] = "Plate ID"; sLabel_CR_Image [ 2 ] = "Distance Source to Detector"; sLabel_CR_Image [ 3 ] = "Distance Source to Patient"; sLabel_CR_Image [ 4 ] = "Exposure Time"; sLabel_CR_Image [ 5 ] = "X-ray Tube Current"; sLabel_CR_Image [ 6 ] = "Exposure"; sLabel_CR_Image [ 7 ] = "Imager Pixel Spacing"; sLabel_CR_Image [ 8 ] = "Generator Power"; sLabel_CR_Image [ 9 ] = "Acquisition Device Processing Description"; sLabel_CR_Image [ 10 ] = "Acquisition Device Processing Code"; sLabel_CR_Image [ 11 ] = "Cassette Orientation"; sLabel_CR_Image [ 12 ] = "Cassette Size"; sLabel_CR_Image [ 13 ] = "Exposures on Plate"; sLabel_CR_Image [ 14 ] = "Relative X-ray Exposure"; sLabel_CR_Image [ 15 ] = "Sensitivity"; /* Module : CR Series */ sLabel_CR_Series [ 0 ] = "Body Part Examined"; sLabel_CR_Series [ 1 ] = "View Position"; sLabel_CR_Series [ 2 ] = "Filter Type"; sLabel_CR_Series [ 3 ] = "Collimator/grid name"; sLabel_CR_Series [ 4 ] = "Focal Spot"; sLabel_CR_Series [ 5 ] = "Plate Type"; sLabel_CR_Series [ 6 ] = "Phosphor Type"; /* Module : CT Image */ sLabel_CT_Image [ 0 ] = "Image Type"; sLabel_CT_Image [ 1 ] = "Samples per Pixel"; sLabel_CT_Image [ 2 ] = "Photometric Interpretation"; sLabel_CT_Image [ 3 ] = "Bits Allocated"; sLabel_CT_Image [ 4 ] = "Bits Stored"; sLabel_CT_Image [ 5 ] = "High Bit"; sLabel_CT_Image [ 6 ] = "Rescale Intercept"; sLabel_CT_Image [ 7 ] = "Rescale Slope"; sLabel_CT_Image [ 8 ] = "KVP"; sLabel_CT_Image [ 9 ] = "Acquisition Number"; sLabel_CT_Image [ 10 ] = "Scan Options"; sLabel_CT_Image [ 11 ] = "Data Collection Diameter"; sLabel_CT_Image [ 12 ] = "Reconstruction Diameter"; sLabel_CT_Image [ 13 ] = "Distance Source to Detector"; sLabel_CT_Image [ 14 ] = "Distance Source to Patient"; sLabel_CT_Image [ 15 ] = "Gantry/Detector Tilt"; sLabel_CT_Image [ 16 ] = "Table Height"; sLabel_CT_Image [ 17 ] = "Rotation Direction"; sLabel_CT_Image [ 18 ] = "Exposure Time"; sLabel_CT_Image [ 19 ] = "X-ray Tube Current"; sLabel_CT_Image [ 20 ] = "Exposure"; sLabel_CT_Image [ 21 ] = "Filter Type"; sLabel_CT_Image [ 22 ] = "Generator Power"; sLabel_CT_Image [ 23 ] = "Focal Spot"; sLabel_CT_Image [ 24 ] = "Convolution Kernel"; /* Module : Curve */ sLabel_Curve [ 0 ] = "Curve Dimensions"; sLabel_Curve [ 1 ] = "Number of Points"; sLabel_Curve [ 2 ] = "Type of Data"; sLabel_Curve [ 3 ] = "Data Value Representation"; sLabel_Curve [ 4 ] = "Curve Data"; sLabel_Curve [ 5 ] = "Curve Description"; sLabel_Curve [ 6 ] = "Axis Units"; sLabel_Curve [ 7 ] = "Axis Labels"; sLabel_Curve [ 8 ] = "Minimum Coordinate Value"; sLabel_Curve [ 9 ] = "Maximum Coordinate Value"; sLabel_Curve [ 10 ] = "Curve Range"; sLabel_Curve [ 11 ] = "Curve Data Descriptor"; sLabel_Curve [ 12 ] = "Coordinate Start Value"; sLabel_Curve [ 13 ] = "Coordinate Step Value"; sLabel_Curve [ 14 ] = "Curve Label"; sLabel_Curve [ 15 ] = "Referenced Overlay Sequence"; /* Module : Curve Identification */ sLabel_Curve_Identification [ 0 ] = "Curve Number"; sLabel_Curve_Identification [ 1 ] = "Curve Date"; sLabel_Curve_Identification [ 2 ] = "Curve Time"; sLabel_Curve_Identification [ 3 ] = "Referenced Image Sequence"; sLabel_Curve_Identification [ 4 ] = "Referenced Overlay Sequence"; sLabel_Curve_Identification [ 5 ] = "Referenced Curve Sequence"; /* Module : Device */ sLabel_Device [ 0 ] = "Device Sequence"; /* Module : Directory Information */ sLabel_Directory_Information [ 0 ] = "Offset of the First Dir Record"; sLabel_Directory_Information [ 1 ] = "Offset of the Last Dir Record"; sLabel_Directory_Information [ 2 ] = "File-set consistency Flag"; sLabel_Directory_Information [ 3 ] = "Directory Record Sequence"; /* Module : Display Shutter */ sLabel_Display_Shutter [ 0 ] = "Shutter Shape"; sLabel_Display_Shutter [ 1 ] = "Shutter Left Vertical Edge"; sLabel_Display_Shutter [ 2 ] = "Shutter Right Vertical Edge"; sLabel_Display_Shutter [ 3 ] = "Shutter Upper Horizontal Edge"; sLabel_Display_Shutter [ 4 ] = "Shutter Lower Horizontal Edge"; sLabel_Display_Shutter [ 5 ] = "Center of Circular Shutter"; sLabel_Display_Shutter [ 6 ] = "Radius of Circular Shutter"; sLabel_Display_Shutter [ 7 ] = "Vertices of the Polygonal Shutter"; /* Module : DX Anatomy Imaged */ sLabel_DX_Anatomy_Imaged [ 0 ] = "Image Laterality"; sLabel_DX_Anatomy_Imaged [ 1 ] = "Anatomic Region Sequence"; sLabel_DX_Anatomy_Imaged [ 2 ] = "Primary Anatomic Structure Sequence"; /* Module : DX Detector */ sLabel_DX_Detector [ 0 ] = "Detector Type"; sLabel_DX_Detector [ 1 ] = "Detector Configuration"; sLabel_DX_Detector [ 2 ] = "Detector Description"; sLabel_DX_Detector [ 3 ] = "Detector Mode"; sLabel_DX_Detector [ 4 ] = "Detector ID"; sLabel_DX_Detector [ 5 ] = "Date of Last Detector Calibration"; sLabel_DX_Detector [ 6 ] = "Time of Last Detector Calibration"; sLabel_DX_Detector [ 7 ] = "Exposures on Detector Since Last Calibration"; sLabel_DX_Detector [ 8 ] = "Exposures on Detector Since Manufactured"; sLabel_DX_Detector [ 9 ] = "Detector Time Since Last Exposure"; sLabel_DX_Detector [ 10 ] = "Detector Active Time"; sLabel_DX_Detector [ 11 ] = "Detector Activation Offset From Exposure"; sLabel_DX_Detector [ 12 ] = "Detector Binning"; sLabel_DX_Detector [ 13 ] = "Detector Conditions Nominal Flag"; sLabel_DX_Detector [ 14 ] = "Detector Temperature"; sLabel_DX_Detector [ 15 ] = "Sensitivity"; sLabel_DX_Detector [ 16 ] = "Field of View Shape"; sLabel_DX_Detector [ 17 ] = "Field of View Dimensions"; sLabel_DX_Detector [ 18 ] = "Field of View Origin"; sLabel_DX_Detector [ 19 ] = "Field of View Rotation"; sLabel_DX_Detector [ 20 ] = "Field of View Horizontal Flip"; sLabel_DX_Detector [ 21 ] = "Imager Pixel Spacing"; sLabel_DX_Detector [ 22 ] = "Detector Element Physical Size"; sLabel_DX_Detector [ 23 ] = "Detector Element Spacing"; sLabel_DX_Detector [ 24 ] = "Detector Active Shape"; sLabel_DX_Detector [ 25 ] = "Detector Active Dimensions"; sLabel_DX_Detector [ 26 ] = "Detector Active Origin"; /* Module : DX Image */ sLabel_DX_Image [ 0 ] = "Image Type"; sLabel_DX_Image [ 1 ] = "Samples per Pixel"; sLabel_DX_Image [ 2 ] = "Photometric Interpretation"; sLabel_DX_Image [ 3 ] = "Bits Allocated"; sLabel_DX_Image [ 4 ] = "Bits Stored"; sLabel_DX_Image [ 5 ] = "High Bit"; sLabel_DX_Image [ 6 ] = "Pixel Representation"; sLabel_DX_Image [ 7 ] = "Pixel Intensity Relationship"; sLabel_DX_Image [ 8 ] = "Pixel Intensity Relationship Sign"; sLabel_DX_Image [ 9 ] = "Rescale Intercept"; sLabel_DX_Image [ 10 ] = "Rescale Slope"; sLabel_DX_Image [ 11 ] = "Rescale Type"; sLabel_DX_Image [ 12 ] = "Presentation LUT Shape"; sLabel_DX_Image [ 13 ] = "Lossy Image Compression"; sLabel_DX_Image [ 14 ] = "Lossy Image Compression Ratio"; sLabel_DX_Image [ 15 ] = "Derivation Description"; sLabel_DX_Image [ 16 ] = "Acquisition Device Processing Description"; sLabel_DX_Image [ 17 ] = "Acquisition Device Processing Code"; sLabel_DX_Image [ 18 ] = "Patient Orientation"; sLabel_DX_Image [ 19 ] = "Calibration Object"; sLabel_DX_Image [ 20 ] = "Burned In Annotation"; /* Module : DX Positioning */ sLabel_DX_Positioning [ 0 ] = "Projection Eponymous Name Code Sequence"; sLabel_DX_Positioning [ 1 ] = "Patient Position"; sLabel_DX_Positioning [ 2 ] = "View Position"; sLabel_DX_Positioning [ 3 ] = "View Code Sequence"; sLabel_DX_Positioning [ 4 ] = "View Modifier Code Sequence"; sLabel_DX_Positioning [ 5 ] = "Patient Orientation Code Sequence"; sLabel_DX_Positioning [ 6 ] = "Patient Orientation Modifier Code Sequence"; sLabel_DX_Positioning [ 7 ] = "Patient Gantry Relationship Code Sequence"; sLabel_DX_Positioning [ 8 ] = "Distance Source to Patient"; sLabel_DX_Positioning [ 9 ] = "Distance Source to Detector"; sLabel_DX_Positioning [ 10 ] = "Estimated Radiographic Magnification Factor"; sLabel_DX_Positioning [ 11 ] = "Positioner Type"; sLabel_DX_Positioning [ 12 ] = "Positioner Primary Angle"; sLabel_DX_Positioning [ 13 ] = "Positioner Secondary Angle"; sLabel_DX_Positioning [ 14 ] = "Detector Primary Angle"; sLabel_DX_Positioning [ 15 ] = "Detector Secondary Angle"; sLabel_DX_Positioning [ 16 ] = "Column Angulation"; sLabel_DX_Positioning [ 17 ] = "Table Type"; sLabel_DX_Positioning [ 18 ] = "Table Angle"; sLabel_DX_Positioning [ 19 ] = "Body Part Thickness"; sLabel_DX_Positioning [ 20 ] = "Compression Force"; /* Module : DX Series */ sLabel_DX_Series [ 0 ] = "Modality"; sLabel_DX_Series [ 1 ] = "Referenced Study Component Sequence"; sLabel_DX_Series [ 2 ] = "Presentation Indent Type"; /* Module : External Papyrus_File Reference Sequence*/ /*??????????????????????????*/ /* Module : External Patient File Reference Sequence*/ /*??????????????????????????*/ /* Module : External Study File Reference Sequence */ /*??????????????????????????*/ /* Module : External Visit Reference Sequence */ /*??????????????????????????*/ /* Module : File Reference */ /*??????????????????????????*/ /* Module : File Set Identification */ sLabel_File_Set_Identification [ 0 ] = "File-set ID"; sLabel_File_Set_Identification [ 1 ] = "File ID of File-set Descriptor"; sLabel_File_Set_Identification [ 2 ] = "Format of the File-set Descriptor File"; /* Module : Frame Of Reference */ sLabel_Frame_Of_Reference [ 0 ] = "Frame of Reference UID"; sLabel_Frame_Of_Reference [ 1 ] = "Position Reference Indicator"; /* Module : Frame Pointers */ /*??????????????????????????*/ /* Module : General Equipment */ sLabel_General_Equipment [ 0 ] = "Manufacturer"; sLabel_General_Equipment [ 1 ] = "Institution Name"; sLabel_General_Equipment [ 2 ] = "Institution Address"; sLabel_General_Equipment [ 3 ] = "Station Name"; sLabel_General_Equipment [ 4 ] = "Institutional Department Name"; sLabel_General_Equipment [ 5 ] = "Manufacturer's Model Name"; sLabel_General_Equipment [ 6 ] = "Device Serial Number"; sLabel_General_Equipment [ 7 ] = "Software Versions"; sLabel_General_Equipment [ 8 ] = "Spatial Resolution"; sLabel_General_Equipment [ 9 ] = "Date of Last Calibration"; sLabel_General_Equipment [ 10 ] = "Time of Last Calibration"; sLabel_General_Equipment [ 11 ] = "Pixel Padding Value"; /* Module : General Image */ sLabel_General_Image [ 0 ] = "Image Number"; sLabel_General_Image [ 1 ] = "Patient Orientation"; sLabel_General_Image [ 2 ] = "Image Date"; sLabel_General_Image [ 3 ] = "Image Time"; sLabel_General_Image [ 4 ] = "Image Type"; sLabel_General_Image [ 5 ] = "Acquisition Number"; sLabel_General_Image [ 6 ] = "Acquisition Date"; sLabel_General_Image [ 7 ] = "Acquisition Time"; sLabel_General_Image [ 8 ] = "Referenced Image Sequence"; sLabel_General_Image [ 9 ] = "Derivation Description"; sLabel_General_Image [ 10 ] = "Source Image Sequence"; sLabel_General_Image [ 11 ] = "Images in Acquisition"; sLabel_General_Image [ 12 ] = "Image Comments"; sLabel_General_Image [ 13 ] = "Lossy Image Compression"; /* Module : General Patient Summary */ /*??????????????????????????*/ /* Module : General Series */ sLabel_General_Series [ 0 ] = "Modality"; sLabel_General_Series [ 1 ] = "Series Instance UID"; sLabel_General_Series [ 2 ] = "Series Number"; sLabel_General_Series [ 3 ] = "Laterality"; sLabel_General_Series [ 4 ] = "Series Date"; sLabel_General_Series [ 5 ] = "Series Time"; sLabel_General_Series [ 6 ] = "Performing Physicians Name"; sLabel_General_Series [ 7 ] = "Protocol Name"; sLabel_General_Series [ 8 ] = "Series Description"; sLabel_General_Series [ 9 ] = "Operators' Name"; sLabel_General_Series [ 10 ] = "Referenced Study Component Sequence"; sLabel_General_Series [ 11 ] = "Body Part Examined"; sLabel_General_Series [ 12 ] = "Patient Position"; sLabel_General_Series [ 13 ] = "Smallest Pixel Value in Series"; sLabel_General_Series [ 14 ] = "Largest Pixel Value in Series"; /* Module : General Series Summary */ /*??????????????????????????*/ /* Module : General Study */ sLabel_General_Study [ 0 ] = "Study Instance UID" ; sLabel_General_Study [ 1 ] = "Study Date" ; sLabel_General_Study [ 2 ] = "Study Time" ; sLabel_General_Study [ 3 ] = "Referring Physician's Name" ; sLabel_General_Study [ 4 ] = "Study ID" ; sLabel_General_Study [ 5 ] = "Accession Number" ; sLabel_General_Study [ 6 ] = "Study Description" ; sLabel_General_Study [ 7 ] = "Physicians Of Record" ; sLabel_General_Study [ 8 ] = "Name of Physician(s) Reading Study" ; sLabel_General_Study [ 9 ] = "Referenced Study Sequence" ; /* Module : General Study Summary */ /*??????????????????????????*/ /* Module : General Visit Summary */ /*??????????????????????????*/ /* Module : Icon Image */ sLabel_Icon_Image [ 0 ] = "Samples per Pixel"; sLabel_Icon_Image [ 1 ] = "Photometric Interpretation"; sLabel_Icon_Image [ 2 ] = "Rows"; sLabel_Icon_Image [ 3 ] = "Columns"; sLabel_Icon_Image [ 4 ] = "Bits Allocated"; sLabel_Icon_Image [ 5 ] = "Bits Stored"; sLabel_Icon_Image [ 6 ] = "High Bit"; sLabel_Icon_Image [ 7 ] = "Pixel Representation"; sLabel_Icon_Image [ 8 ] = "Red Palette Color Lookup Table Descriptors"; sLabel_Icon_Image [ 9 ] = "Green Palette Color Lookup Table Descriptors"; sLabel_Icon_Image [ 10 ] = "Blue Palette Color Lookup Table Descriptors"; sLabel_Icon_Image [ 11 ] = "Red Palette Color Lookup Table Data"; sLabel_Icon_Image [ 12 ] = "Green Palette Color Lookup Table Data"; sLabel_Icon_Image [ 13 ] = "Blue Palette Color Lookup Table Data"; sLabel_Icon_Image [ 14 ] = "Pixel Data"; /* Module : Identifying Image Sequence */ /*??????????????????????????*/ /* Module : Image Box Pixel Presentation */ /*??????????????????????????*/ /* Module : Image Box Relationship */ /*??????????????????????????*/ /* Module : Image Identification */ /*??????????????????????????*/ /* Module : Image Overlay Box Presentation */ /*??????????????????????????*/ /* Module : Image Overlay Box Relationship */ /*??????????????????????????*/ /* Module : Image Pixel */ sLabel_Image_Pixel [ 0 ] = "Samples per Pixel"; sLabel_Image_Pixel [ 1 ] = "Photometric Interpretation"; sLabel_Image_Pixel [ 2 ] = "Rows"; sLabel_Image_Pixel [ 3 ] = "Columns"; sLabel_Image_Pixel [ 4 ] = "Bits Allocated"; sLabel_Image_Pixel [ 5 ] = "Bits Stored"; sLabel_Image_Pixel [ 6 ] = "High Bit"; sLabel_Image_Pixel [ 7 ] = "Pixel Representation"; sLabel_Image_Pixel [ 8 ] = "Pixel Data"; sLabel_Image_Pixel [ 9 ] = "Planar Configuration"; sLabel_Image_Pixel [ 10 ] = "Pixel Aspect Ratio"; sLabel_Image_Pixel [ 11 ] = "Smallest Image Pixel Value"; sLabel_Image_Pixel [ 12 ] = "Largest Image Pixel Value"; sLabel_Image_Pixel [ 13 ] = "Red Palette Color Lookup Table Descriptor"; sLabel_Image_Pixel [ 14 ] = "Green Palette Color Lookup Table Descriptor"; sLabel_Image_Pixel [ 15 ] = "Blue Palette Color Lookup Table Descriptor"; sLabel_Image_Pixel [ 16 ] = "Red Palette Color Lookup Table Data"; sLabel_Image_Pixel [ 17 ] = "Green Palette Color Lookup Table Data"; sLabel_Image_Pixel [ 18 ] = "Blue Palette Color Lookup Table Data"; /* Module : Image Plane */ sLabel_Image_Plane [ 0 ] = "Pixel Spacing"; sLabel_Image_Plane [ 1 ] = "Image Orientation(Patient)"; sLabel_Image_Plane [ 2 ] = "Image Position(Patient)"; sLabel_Image_Plane [ 3 ] = "Slice Thickness"; sLabel_Image_Plane [ 4 ] = "Slice Location"; /* Module : Image Pointer */ /*??????????????????????????*/ /* Module : Image Sequence */ /*??????????????????????????*/ /* Module : Internal Image Pointer Sequence */ /*??????????????????????????*/ /* Module : Interpretation Approval */ /*??????????????????????????*/ /* Module : Interpretation Identification */ /*??????????????????????????*/ /* Module : Interpretation Recording */ /*??????????????????????????*/ /* Module : Interpretation Relationship */ /*??????????????????????????*/ /* Module : Interpretation State */ /*??????????????????????????*/ /* Module : Interpretation Transcription */ /*??????????????????????????*/ /* Module : Intra_Oral Image */ sLabel_Intra_Oral_Image [ 0 ] = "Positioner Type"; sLabel_Intra_Oral_Image [ 1 ] = "Image Laterality"; sLabel_Intra_Oral_Image [ 2 ] = "Anatomic Region Sequence"; sLabel_Intra_Oral_Image [ 3 ] = "Anatomic Region Modifier Sequence"; sLabel_Intra_Oral_Image [ 4 ] = "Primary Anatomic Structure Sequence"; /* Module : Intra_Oral Series */ sLabel_Intra_Oral_Series [ 0 ] = "Modality"; /* Module : LUT Identification */ /*??????????????????????????*/ /* Module : Mammography Image */ sLabel_Mammography_Image [ 0 ] = "Positioner Type"; sLabel_Mammography_Image [ 1 ] = "Positioner Primary Angle"; sLabel_Mammography_Image [ 2 ] = "Positioner Secondary Angle"; sLabel_Mammography_Image [ 3 ] = "Image Laterality"; sLabel_Mammography_Image [ 4 ] = "Organ Exposed"; sLabel_Mammography_Image [ 5 ] = "Anatomic Region Sequence"; sLabel_Mammography_Image [ 6 ] = "View Code Sequence"; sLabel_Mammography_Image [ 7 ] = "View Modifier Code Sequence"; /* Module : Mammography Series */ sLabel_Mammography_Series [ 0 ] = "Modality"; /* Module : Mask */ sLabel_Mask [ 0 ] = "Mask Subtraction Sequence"; sLabel_Mask [ 1 ] = "Recommended Viewing Mode"; /* Module : Modality LUT */ sLabel_Modality_LUT [ 0 ] = "Modality LUT Sequence"; sLabel_Modality_LUT [ 1 ] = "Rescale Intercept"; sLabel_Modality_LUT [ 2 ] = "Rescale Slope"; sLabel_Modality_LUT [ 3 ] = "Rescale Type"; /* sLabel_Modality_LUT [ ] = "LUT Descriptor"; sLabel_Modality_LUT [ ] = "LUT Explanation"; sLabel_Modality_LUT [ ] = "Modality LUT Type"; sLabel_Modality_LUT [ ] = "LUT Data";*/ /* Module : MR Image */ sLabel_MR_Image [ 0 ] = "Image Type"; sLabel_MR_Image [ 1 ] = "Samples per Pixel"; sLabel_MR_Image [ 2 ] = "Photometric Interpretation"; sLabel_MR_Image [ 3 ] = "Bits Allocated"; sLabel_MR_Image [ 4 ] = "Scanning Sequence"; sLabel_MR_Image [ 5 ] = "Sequence Variant"; sLabel_MR_Image [ 6 ] = "Scan Options"; sLabel_MR_Image [ 7 ] = "MR Acquisition Type"; sLabel_MR_Image [ 8 ] = "Repetition Time"; sLabel_MR_Image [ 9 ] = "Echo Time"; sLabel_MR_Image [ 10 ] = "Echo Train Length"; sLabel_MR_Image [ 11 ] = "Inversion Time"; sLabel_MR_Image [ 12 ] = "Trigger Time"; sLabel_MR_Image [ 13 ] = "Sequence Name"; sLabel_MR_Image [ 14 ] = "Angio Flag"; sLabel_MR_Image [ 15 ] = "Number of Averages"; sLabel_MR_Image [ 16 ] = "Imaging Frequency"; sLabel_MR_Image [ 17 ] = "Imaged Nucleus"; sLabel_MR_Image [ 18 ] = "Echo Number"; sLabel_MR_Image [ 19 ] = "Magnetic Field Strength"; sLabel_MR_Image [ 20 ] = "Spacing Between Slices"; sLabel_MR_Image [ 21 ] = "Number of Phase Encoding Steps"; sLabel_MR_Image [ 22 ] = "Percent Sampling"; sLabel_MR_Image [ 23 ] = "Percent Phase Field of View"; sLabel_MR_Image [ 24 ] = "Pixel Bandwidth"; sLabel_MR_Image [ 25 ] = "Nominal Interval"; sLabel_MR_Image [ 26 ] = "Beat Rejection Flag"; sLabel_MR_Image [ 27 ] = "Low R-R Value"; sLabel_MR_Image [ 28 ] = "High R-R Value"; sLabel_MR_Image [ 29 ] = "Intervals Acquired"; sLabel_MR_Image [ 30 ] = "Intervals Rejected"; sLabel_MR_Image [ 31 ] = "PVC Rejection"; sLabel_MR_Image [ 32 ] = "Skip Beats"; sLabel_MR_Image [ 33 ] = "Heart Rate"; sLabel_MR_Image [ 34 ] = "Cardiac Number of Images"; sLabel_MR_Image [ 35 ] = "Trigger Window"; sLabel_MR_Image [ 36 ] = "Reconstruction Diameter"; sLabel_MR_Image [ 37 ] = "Receiving Coil"; sLabel_MR_Image [ 38 ] = "Transmitting Coil"; sLabel_MR_Image [ 39 ] = "Acquisition Matrix"; sLabel_MR_Image [ 40 ] = "Phase Encoding Direction"; sLabel_MR_Image [ 41 ] = "Flip Angle"; sLabel_MR_Image [ 42 ] = "SAR"; sLabel_MR_Image [ 43 ] = "Variable Flip Angle Flag"; sLabel_MR_Image [ 44 ] = "dB/dt"; sLabel_MR_Image [ 45 ] = "Temporal Position Identifier"; sLabel_MR_Image [ 46 ] = "Number of Temporal Positions"; sLabel_MR_Image [ 47 ] = "Temporal Resolution"; /* Module : Multi_Frame */ sLabel_Multi_Frame [ 0 ] = "Number of Frames"; sLabel_Multi_Frame [ 1 ] = "Frame Increment Pointer"; /* Module : Multi_frame Overlay */ sLabel_Multi_frame_Overlay [ 0 ] = "Number of Frames in Overlay"; sLabel_Multi_frame_Overlay [ 1 ] = "Image Frame Origin"; /* Module : NM Detector */ sLabel_NM_Detector [ 0 ] = "Detector Information Sequence"; /* Module : NM Image */ sLabel_NM_Image [ 0 ] = "Image Type"; sLabel_NM_Image [ 1 ] = "Image ID"; sLabel_NM_Image [ 2 ] = "Lossy Image Compression"; sLabel_NM_Image [ 3 ] = "Counts Accumulated"; sLabel_NM_Image [ 4 ] = "Acquisition Termination Condition"; sLabel_NM_Image [ 5 ] = "Table Height"; sLabel_NM_Image [ 6 ] = "Reconstruction Diameter"; sLabel_NM_Image [ 7 ] = "Distance Source to Detector"; sLabel_NM_Image [ 8 ] = "Table Height"; sLabel_NM_Image [ 9 ] = "Table Traverse"; sLabel_NM_Image [ 10 ] = "Actual Frame Duration"; sLabel_NM_Image [ 11 ] = "Count Rate"; sLabel_NM_Image [ 12 ] = "Preprocessing Function"; sLabel_NM_Image [ 13 ] = "Corrected Image"; sLabel_NM_Image [ 14 ] = "Whole Body Technique"; sLabel_NM_Image [ 15 ] = "Scan Velocity"; sLabel_NM_Image [ 16 ] = "Scan Length"; sLabel_NM_Image [ 17 ] = "Referenced Overlay Sequence"; sLabel_NM_Image [ 18 ] = "Referenced Curve Sequence"; sLabel_NM_Image [ 19 ] = "Trigger Source or Type"; sLabel_NM_Image [ 20 ] = "Anatomic Region Sequence"; sLabel_NM_Image [ 21 ] = "Primary Anatomic Structure Sequence"; /* sLabel_NM_Image [ ] = "Referenced SOP Class UID"; sLabel_NM_Image [ ] = "Referenced SOP Instance UID";*/ /* sLabel_NM_Image [ ] = "Referenced SOP Class UID"; sLabel_NM_Image [ ] = "Referenced SOP Instance UID";*/ /* Module : NM Image Pixel */ sLabel_NM_Image_Pixel [ 0 ] = "Samples per Pixel"; sLabel_NM_Image_Pixel [ 1 ] = "Photometric Interpretation"; sLabel_NM_Image_Pixel [ 2 ] = "Bits Allocated"; sLabel_NM_Image_Pixel [ 3 ] = "Bits Stored"; sLabel_NM_Image_Pixel [ 4 ] = "High Bit"; sLabel_NM_Image_Pixel [ 5 ] = "Pixel Spacing"; /* Module : NM Isotope */ sLabel_NM_Isotope [ 0 ] = "Energy Window Information Sequence"; sLabel_NM_Isotope [ 1 ] = "Radiopharmaceutical Information Sequence"; sLabel_NM_Isotope [ 2 ] = "Intervention Drug Information Sequence"; /* Module : NM Multi Frame */ sLabel_NM_Multi_Frame [ 0 ] = "Frame Increment Pointer"; sLabel_NM_Multi_Frame [ 1 ] = "Energy Window Vector"; sLabel_NM_Multi_Frame [ 2 ] = "Number of Energy Windows"; sLabel_NM_Multi_Frame [ 3 ] = "Detector Vector"; sLabel_NM_Multi_Frame [ 4 ] = "Number of Detectors"; sLabel_NM_Multi_Frame [ 5 ] = "Phase Vector"; sLabel_NM_Multi_Frame [ 6 ] = "Number of Phases"; sLabel_NM_Multi_Frame [ 7 ] = "Rotation Vector"; sLabel_NM_Multi_Frame [ 8 ] = "Number of Rotations"; sLabel_NM_Multi_Frame [ 9 ] = "RR Interval Vector"; sLabel_NM_Multi_Frame [ 10 ] = "Number of RR Intervals"; sLabel_NM_Multi_Frame [ 11 ] = "Time Slot Vector"; sLabel_NM_Multi_Frame [ 12 ] = "Number of Time Slots"; sLabel_NM_Multi_Frame [ 13 ] = "Slice Vector"; sLabel_NM_Multi_Frame [ 14 ] = "Number of Slices"; sLabel_NM_Multi_Frame [ 15 ] = "Angular View Vector"; sLabel_NM_Multi_Frame [ 16 ] = "Time Slice Vector"; /* Module : NM Multi_gated Acquisition Image */ sLabel_NM_Multi_gated_Acquisition_Image [ 0 ] = "Beat Rejection Flag"; sLabel_NM_Multi_gated_Acquisition_Image [ 1 ] = "PVC Rejection"; sLabel_NM_Multi_gated_Acquisition_Image [ 2 ] = "Skip Beats"; sLabel_NM_Multi_gated_Acquisition_Image [ 3 ] = "Heart Rate"; sLabel_NM_Multi_gated_Acquisition_Image [ 4 ] = "Gated Information Sequence"; /* Module : NM Phase */ /*??????????????????????????*/ /* Module : NM Reconstruction */ /*??????????????????????????*/ /* Module : NM Series */ sLabel_NM_Series [ 0 ] = "Patient Orientation Code Sequence"; sLabel_NM_Series [ 1 ] = "Patient Gantry Relationship Code Sequence"; /* Module : NM Tomo Acquisition */ /*??????????????????????????*/ /* Module : Overlay Identification */ sLabel_Overlay_Identification [ 0 ] = "Overlay Number"; sLabel_Overlay_Identification [ 1 ] = "Overlay Date"; sLabel_Overlay_Identification [ 2 ] = "Overlay Time"; sLabel_Overlay_Identification [ 3 ] = "Referenced Image Sequence"; /* sLabel_Overlay_Identification [ ] = "Referenced SOP Class UID"; sLabel_Overlay_Identification [ ] = "Referenced SOP Instance UID";*/ /* Module : Overlay Plane */ sLabel_Overlay_Plane [ 0 ] = "Rows"; sLabel_Overlay_Plane [ 1 ] = "Columns"; sLabel_Overlay_Plane [ 2 ] = "Overlay Type"; sLabel_Overlay_Plane [ 3 ] = "Origin"; sLabel_Overlay_Plane [ 4 ] = "Bits Allocated"; sLabel_Overlay_Plane [ 5 ] = "Bit Position"; sLabel_Overlay_Plane [ 6 ] = "Overlay Data"; sLabel_Overlay_Plane [ 7 ] = "Overlay Description"; sLabel_Overlay_Plane [ 8 ] = "Overlay Subtype"; sLabel_Overlay_Plane [ 9 ] = "Overlay Label"; sLabel_Overlay_Plane [ 10 ] = "ROI Area"; sLabel_Overlay_Plane [ 11 ] = "ROI Mean"; sLabel_Overlay_Plane [ 12 ] = "ROI Standard Deviation"; sLabel_Overlay_Plane [ 13 ] = "Overlay Descriptor Gray"; sLabel_Overlay_Plane [ 14 ] = "Overlay Descriptor Red"; sLabel_Overlay_Plane [ 15 ] = "Overlay Descriptor Green"; sLabel_Overlay_Plane [ 16 ] = "Overlay Descriptor Blue"; sLabel_Overlay_Plane [ 17 ] = "Overlays-Gray"; sLabel_Overlay_Plane [ 18 ] = "Overlays-Red"; sLabel_Overlay_Plane [ 19 ] = "Overlays-Green"; sLabel_Overlay_Plane [ 20 ] = "Overlays-Blue"; /* Module : Palette Color Lookup */ /*??????????????????????????*/ /* Module : Patient */ sLabel_Patient [ 0 ] = "Patient's Name" ; sLabel_Patient [ 1 ] = "Patient ID" ; sLabel_Patient [ 2 ] = "Patient's Birth Date" ; sLabel_Patient [ 3 ] = "Patient's Sex" ; sLabel_Patient [ 4 ] = "Referenced Patient Sequence" ; sLabel_Patient [ 5 ] = "Patient's Birth Time" ; sLabel_Patient [ 6 ] = "Other Patient ID" ; sLabel_Patient [ 7 ] = "Other Patient Names" ; sLabel_Patient [ 8 ] = "Ethnic Group" ; sLabel_Patient [ 9 ] = "Patient Comments"; /* sLabel_Patient [ 5 ] = "Referenced SOP Class UID" ; sLabel_Patient [ 6 ] = "Referenced SOP Instance UID" ;*/ /* Module : Patient Demographic */ /*??????????????????????????*/ /* Module : Patient Identification */ /*??????????????????????????*/ /* Module : Patient Medical */ /*??????????????????????????*/ /* Module : Patient Relationship */ /*??????????????????????????*/ /* Module : Patient Study */ sLabel_Patient_Study [ 0 ] = "Admitting Diagnoses Description"; sLabel_Patient_Study [ 1 ] = "Patient's Age"; sLabel_Patient_Study [ 2 ] = "Patient's Size"; sLabel_Patient_Study [ 3 ] = "Patient's Weight"; sLabel_Patient_Study [ 4 ] = "Occupation"; sLabel_Patient_Study [ 5 ] = "Additional Patients History"; /* Module : Patient Summary */ /*??????????????????????????*/ /* Module : Pixel Offset */ /*??????????????????????????*/ /* Module : Printer */ /*??????????????????????????*/ /* Module : Print Job */ /*??????????????????????????*/ /* Module : Result Identification */ /*??????????????????????????*/ /* Module : Results Impression */ /*??????????????????????????*/ /* Module : Result Relationship */ /*??????????????????????????*/ /* Module : SC Image */ sLabel_SC_Image [ 0 ] = "Date of Secondary Capture"; sLabel_SC_Image [ 1 ] = "Time of Secondary Capture"; /* Module : SC Image Equipment */ sLabel_SC_Image_Equipment [ 0 ] = "Conversion Type"; sLabel_SC_Image_Equipment [ 1 ] = "Modality"; sLabel_SC_Image_Equipment [ 2 ] = "Secondary Capture Device ID"; sLabel_SC_Image_Equipment [ 3 ] = "Secondary Capture Device Manufacturer"; sLabel_SC_Image_Equipment [ 4 ] = "Secondary Capture Device Manufacturer's Model Name"; sLabel_SC_Image_Equipment [ 5 ] = "Secondary Capture Device Software"; sLabel_SC_Image_Equipment [ 6 ] = "Video Image Format Acquired"; sLabel_SC_Image_Equipment [ 7 ] = "Digital Image Format Acquired"; /* Module : SOP Common */ sLabel_SOP_Common [ 0 ] = "SOP Class UID"; sLabel_SOP_Common [ 1 ] = "SOP Instance UID"; sLabel_SOP_Common [ 2 ] = "Specific Character Set"; sLabel_SOP_Common [ 3 ] = "Instance Creation Date"; sLabel_SOP_Common [ 4 ] = "Instance Creation Time"; sLabel_SOP_Common [ 5 ] = "Instance Creator UID"; /* Module : Study Acquisition */ /*??????????????????????????*/ /* Module : Study Classification */ /*??????????????????????????*/ /* Module : Study Component */ /*??????????????????????????*/ /* Module : Study Component Acquisition */ /*??????????????????????????*/ /* Module : Study Component Relationship */ /*??????????????????????????*/ /* Module : Study Content */ /*??????????????????????????*/ /* Module : Study Identification */ /*??????????????????????????*/ /* Module : Study Read */ /*??????????????????????????*/ /* Module : Study Relationship */ /*??????????????????????????*/ /* Module : Study Scheduling */ /*??????????????????????????*/ /* Module : UIN Overlay Sequence */ sLabel_UIN_Overlay_Sequence [ 0 ] = "Owner ID"; sLabel_UIN_Overlay_Sequence [ 1 ] = "UIN overlay sequence"; /* Module : US Frame of Reference */ /*??????????????????????????*/ /* Module : US Image */ sLabel_US_Image [ 0 ] = "Samples per Pixel"; sLabel_US_Image [ 1 ] = "Photometric Interpretation"; sLabel_US_Image [ 2 ] = "Bits Allocated"; sLabel_US_Image [ 3 ] = "Bits Stored"; sLabel_US_Image [ 4 ] = "High Bit"; sLabel_US_Image [ 5 ] = "Planar Configuration"; sLabel_US_Image [ 6 ] = "Pixel Representation"; sLabel_US_Image [ 7 ] = "Frame Increment Pointer"; sLabel_US_Image [ 8 ] = "Image Type"; sLabel_US_Image [ 9 ] = "Lossy Image Compression"; sLabel_US_Image [ 10 ] = "Number of Stages"; sLabel_US_Image [ 11 ] = "Number of Views in Stage"; sLabel_US_Image [ 12 ] = "Ultrasound Color Data Present"; sLabel_US_Image [ 13 ] = "Referenced Overlay Sequence"; sLabel_US_Image [ 14 ] = "Referenced Curve Sequence"; sLabel_US_Image [ 15 ] = "Stage Name"; sLabel_US_Image [ 16 ] = "Stage Number"; sLabel_US_Image [ 17 ] = "View Number"; sLabel_US_Image [ 18 ] = "Number of Event Timers"; sLabel_US_Image [ 19 ] = "Event Elapsed Time(s)"; sLabel_US_Image [ 20 ] = "Event Timer Name(s)"; sLabel_US_Image [ 21 ] = "Anatomic Region Sequence"; sLabel_US_Image [ 22 ] = "Primary Anatomic Structure Sequence"; sLabel_US_Image [ 23 ] = "Transducer Position Sequence"; sLabel_US_Image [ 24 ] = "Transducer Orientation Sequence"; sLabel_US_Image [ 25 ] = "Trigger Time"; sLabel_US_Image [ 26 ] = "Nominal Interval"; sLabel_US_Image [ 27 ] = "Beat Rejection Flag"; sLabel_US_Image [ 28 ] = "Low RR Value"; sLabel_US_Image [ 29 ] = "High RR Value"; sLabel_US_Image [ 30 ] = "Heart Rate"; sLabel_US_Image [ 31 ] = "Output Power"; sLabel_US_Image [ 32 ] = "Transducer Data"; sLabel_US_Image [ 33 ] = "Transducer Type"; sLabel_US_Image [ 34 ] = "Focus Depth"; sLabel_US_Image [ 35 ] = "Preprocessing Function"; sLabel_US_Image [ 36 ] = "Mechanical Index"; sLabel_US_Image [ 37 ] = "Bone Thermal Index"; sLabel_US_Image [ 38 ] = "Cranial Thermal Index"; sLabel_US_Image [ 39 ] = "Soft Tissue Thermal Index"; sLabel_US_Image [ 40 ] = "Soft Tissue focus Thermal Index"; sLabel_US_Image [ 41 ] = "Soft Tissue surface Thermal Index"; sLabel_US_Image [ 42 ] = "Depth of Scan Field"; sLabel_US_Image [ 43 ] = "Image Transformation Matrix"; sLabel_US_Image [ 44 ] = "Image Translation Vector"; sLabel_US_Image [ 45 ] = "Overlay Subtype"; /* Module : US Region Calibration */ sLabel_US_Region_Calibration [ 0 ] = "Sequence of Ultrasound Regions"; /* sLabel_US_Region_Calibration [ ] = "Region Location Min x0"; sLabel_US_Region_Calibration [ ] = "Region Location Min y0"; sLabel_US_Region_Calibration [ ] = "Region Location Max x1"; sLabel_US_Region_Calibration [ ] = "Region Location Max y1"; sLabel_US_Region_Calibration [ ] = "Physical Units X Direction"; sLabel_US_Region_Calibration [ ] = "Physical Units Y Direction"; sLabel_US_Region_Calibration [ ] = "Physical Delta X"; sLabel_US_Region_Calibration [ ] = "Physical Delta Y"; sLabel_US_Region_Calibration [ ] = "Reference Pixel x0"; sLabel_US_Region_Calibration [ ] = "Reference Pixel y0"; sLabel_US_Region_Calibration [ ] = "Ref. Pixel Physical Value X"; sLabel_US_Region_Calibration [ ] = "Ref. Pixel Physical Value Y"; sLabel_US_Region_Calibration [ ] = "Region Spatial Format"; sLabel_US_Region_Calibration [ ] = "Region Data Type"; sLabel_US_Region_Calibration [ ] = "Region Flags"; sLabel_US_Region_Calibration [ ] = "Pixel Component Organization"; sLabel_US_Region_Calibration [ ] = "Pixel Component Mask"; sLabel_US_Region_Calibration [ ] = "Pixel Component Range Start"; sLabel_US_Region_Calibration [ ] = "Pixel Component Range Stop"; sLabel_US_Region_Calibration [ ] = "Pixel Component Physical Units"; sLabel_US_Region_Calibration [ ] = "Pixel Component Data Type"; sLabel_US_Region_Calibration [ ] = "Number of Table Break Points"; sLabel_US_Region_Calibration [ ] = "Table of X Break Points"; sLabel_US_Region_Calibration [ ] = "Table of Y Break Points"; sLabel_US_Region_Calibration [ ] = "Transducer Frequency"; sLabel_US_Region_Calibration [ ] = "Pulse Repetition Frequency"; sLabel_US_Region_Calibration [ ] = "Doppler Correction Angle"; sLabel_US_Region_Calibration [ ] = "Steering Angle"; sLabel_US_Region_Calibration [ ] = "Doppler Sample Volume X Position"; sLabel_US_Region_Calibration [ ] = "Doppler Sample Volume Y Position"; sLabel_US_Region_Calibration [ ] = "TM-Line Position x0"; sLabel_US_Region_Calibration [ ] = "TM-Line Position y0"; sLabel_US_Region_Calibration [ ] = "TM-Line Position x1"; sLabel_US_Region_Calibration [ ] = "TM-Line Position y1";*/ /* Module : Visit Admission */ /*??????????????????????????*/ /* Module : Visit Discharge */ /*??????????????????????????*/ /* Module : Visit Identification */ /*??????????????????????????*/ /* Module : Visit Relationship */ /*??????????????????????????*/ /* Module : Visit Scheduling */ /*??????????????????????????*/ /* Module : Visit Status */ /*??????????????????????????*/ /* Module : VOI LUT */ sLabel_VOI_LUT [ 0 ] = "VOI LUT Sequence"; sLabel_VOI_LUT [ 1 ] = "Window Center"; sLabel_VOI_LUT [ 2 ] = "Window Width"; sLabel_VOI_LUT [ 3 ] = "Window Center & Width Explanation"; /* sLabel_VOI_LUT [ ] = "LUT Descriptor"; sLabel_VOI_LUT [ ] = "LUT Explanation"; sLabel_VOI_LUT [ ] = "LUT Data";*/ /* Module : XRay Acquisition */ sLabel_XRay_Acquisition [ 0 ] = "KVP"; sLabel_XRay_Acquisition [ 1 ] = "Radiation Setting"; sLabel_XRay_Acquisition [ 2 ] = "Xray Tube Current"; sLabel_XRay_Acquisition [ 3 ] = "Exposure Time"; sLabel_XRay_Acquisition [ 4 ] = "Exposure"; sLabel_XRay_Acquisition [ 5 ] = "Grid"; sLabel_XRay_Acquisition [ 6 ] = "Average Pulse Width"; sLabel_XRay_Acquisition [ 7 ] = "Radiation Mode"; sLabel_XRay_Acquisition [ 8 ] = "Type of Filters"; sLabel_XRay_Acquisition [ 9 ] = "Intensifier Size"; sLabel_XRay_Acquisition [ 10 ] = "Field of View Shape"; sLabel_XRay_Acquisition [ 11 ] = "Field of View Dimensions"; sLabel_XRay_Acquisition [ 12 ] = "Imager Pixel Spacing"; sLabel_XRay_Acquisition [ 13 ] = "Focal Spots"; sLabel_XRay_Acquisition [ 14 ] = "Image Area Dose Product"; /* Module : XRay Acquisition Dose */ sLabel_XRay_Acquisition_Dose [ 0 ] = "KVP"; sLabel_XRay_Acquisition_Dose [ 1 ] = "Xray Tube Current"; sLabel_XRay_Acquisition_Dose [ 2 ] = "Exposure Time"; sLabel_XRay_Acquisition_Dose [ 3 ] = "Exposure"; sLabel_XRay_Acquisition_Dose [ 4 ] = "Distance Source to Detector"; sLabel_XRay_Acquisition_Dose [ 5 ] = "Distance Source to Patient"; sLabel_XRay_Acquisition_Dose [ 6 ] = "Image Area Dose Product"; sLabel_XRay_Acquisition_Dose [ 7 ] = "Body Part Thickness"; sLabel_XRay_Acquisition_Dose [ 8 ] = "Entrance Dose"; sLabel_XRay_Acquisition_Dose [ 9 ] = "Exposed Area"; sLabel_XRay_Acquisition_Dose [ 10 ] = "Distance Source to Entrance"; sLabel_XRay_Acquisition_Dose [ 11 ] = "Comments on Radiation Dose"; sLabel_XRay_Acquisition_Dose [ 12 ] = "XRay Output"; sLabel_XRay_Acquisition_Dose [ 13 ] = "Half Value Layer"; sLabel_XRay_Acquisition_Dose [ 14 ] = "Organ Dose"; sLabel_XRay_Acquisition_Dose [ 15 ] = "Organ Exposed"; sLabel_XRay_Acquisition_Dose [ 16 ] = "Anode Target Material"; sLabel_XRay_Acquisition_Dose [ 17 ] = "Filter Material"; sLabel_XRay_Acquisition_Dose [ 18 ] = "Filter Thickness Minimum"; sLabel_XRay_Acquisition_Dose [ 19 ] = "Filter Thickness Maximum"; sLabel_XRay_Acquisition_Dose [ 20 ] = "Rectification Type"; /* Module : XRay Collimator */ sLabel_XRay_Collimator [ 0 ] = "Collimator Shape"; sLabel_XRay_Collimator [ 1 ] = "Collimator Left Vertical Edge"; sLabel_XRay_Collimator [ 2 ] = "Collimator Right Vertical Edge"; sLabel_XRay_Collimator [ 3 ] = "Collimator Upper Horizontal Edge"; sLabel_XRay_Collimator [ 4 ] = "Collimator Lower Horizontal Edge"; sLabel_XRay_Collimator [ 5 ] = "Center of Circular Collimator"; sLabel_XRay_Collimator [ 6 ] = "Radius of Circular Collimator"; sLabel_XRay_Collimator [ 7 ] = "Vertices of the Polygonal Collimator"; /* Module : XRay Image */ sLabel_XRay_Image [ 0 ] = "Frame Increment Pointer"; sLabel_XRay_Image [ 1 ] = "Lossy Image Compression"; sLabel_XRay_Image [ 2 ] = "Image Type"; sLabel_XRay_Image [ 3 ] = "Pixel Intensity Relationship"; sLabel_XRay_Image [ 4 ] = "Samples per Pixel"; sLabel_XRay_Image [ 5 ] = "Photometric Interpretation"; sLabel_XRay_Image [ 6 ] = "Bits Allocated"; sLabel_XRay_Image [ 7 ] = "Bits Stored"; sLabel_XRay_Image [ 8 ] = "High Bit"; sLabel_XRay_Image [ 9 ] = "Pixel Representation"; sLabel_XRay_Image [ 10 ] = "Scan Options"; sLabel_XRay_Image [ 11 ] = "Anatomic Region Sequence"; sLabel_XRay_Image [ 12 ] = "Primary Anatomic Structure Sequence"; sLabel_XRay_Image [ 13 ] = "RWave Pointer"; sLabel_XRay_Image [ 14 ] = "Referenced Image Sequence"; sLabel_XRay_Image [ 15 ] = "Derivation Description"; sLabel_XRay_Image [ 16 ] = "Acquisition Device Processing Description"; sLabel_XRay_Image [ 17 ] = "Calibration Object"; /* Module : XRay Table */ /*??????????????????????????*/ } /* endof InitLabels3 */ Papyrus3/00 README.html0000644000175000017500000000102210076704552011550 0ustar README Papyrus 3 library

    This software is OSI Certified Open Source Software. OSI Certified is a certification mark of the Open Source Initiative.

    Papyrus3/Papyrus3.h0000755000175000017500000001677010044200146011430 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : Papyrus3.h */ /* Function : contains the declarations of types, enumerated types, */ /* constants and global variables */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 04.1991 version 1.1 */ /* 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef Papyrus3H #define Papyrus3H #ifdef FILENAME83 #undef FILENAME83 #endif #include /* BEWARE : Mac must be defined only if we are on a Mac architecture. */ #ifndef unix #ifndef hpux #ifndef __alpha #ifndef _WINDOWS #ifndef Mac #define Mac #endif #endif #endif #endif #endif #ifndef _WINDOWS #ifndef Mac #ifdef hpux #include #else #include #include #include #endif #endif #endif #ifdef PAPY3_VAR #define WHERE3 #else #define WHERE3 extern #endif /* --- includes --- */ #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyEnumGroups3H /* enumeration of the groups */ #include "PapyEnumGroups3.h" #endif #ifndef PapyEnumModulesH /* enumeration of the modules */ #include "PapyEnumModules3.h" #endif #ifndef PapyTypeDef3H /* PAPYRUS type definition */ #include "PapyTypeDef3.h" #endif #ifndef PapyGlobalVar3H /* PAPYRUS global variables */ #include "PapyGlobalVar3.h" #endif #ifndef PapyPrivFunctionDef3H /* PAPYRUS private functions */ #include "PapyPrivFunctionDef3.h" #endif #ifndef PapyPubFunctionDef3H /* PAPYRUS public functions */ #include "PapyPubFunctionDef3.h" #endif #ifndef PapyEalloc3H /* interface to the PAPYRUS memory manager */ #include "PapyEalloc3.h" #endif #ifndef PapyFileSystem3H /* interface to the PAPYRUS file manager */ #include "PapyFileSystem3.h" #endif #ifndef PapyError3H /* interface to the PAPYRUS error manager */ #include "PapyError3.h" #endif #include "PapyWild3.h" #ifndef DicomdirH #include "DicomDir.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H /* PAPYRUS type definition */ #include "PAPTD3.h" #endif #ifndef PapyGlobalVar3H /* PAPYRUS global variables */ #include "PAPGLV3.h" #endif #ifndef PapyPrivFunctionDef3H /* PAPYRUS private functions */ #include "PAPPRF3.h" #endif #ifndef PapyPubFunctionDef3H /* PAPYRUS public functions */ #include "PAPPUF3.h" #endif #ifndef PapyEnumGroups3H #include "PAPEG3.h" #endif #ifndef PapyEnumModulesH #include "PAPEM3.h" #endif #ifndef PapyEalloc3H #include "PAPALOC3.h" #endif #ifndef PapyFileSystem3H #include "PAPFSYS3.h" #endif #ifndef PapyError3H #include "PAPERR3.h" #endif #include "PAPWILD3.h" #ifndef DicomdirH #include "DICOMDIR.h" #endif #endif /* FILENAME83 defined */ #endif /* Papyrus3H */ Papyrus3/Papyrus3.opt0000755000175000017500000017600007751472376012027 0ustar ÐÏࡱá>þÿ þÿÿÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýÿÿÿ  þÿÿÿ þÿÿÿþÿÿÿI"#$%&'()*þÿÿÿ,-./01234þÿÿÿ6789:;<=>þÿÿÿ@ABCDEFGHþÿÿÿrKLMNOPQRSþÿÿÿUVWXYZ[\]þÿÿÿ_`abcdefgþÿÿÿijklmnopqþÿÿÿþÿÿÿtuvwxyz{|þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿRoot EntryÿÿÿÿÿÿÿÿÀ4ƒE¢ÃþÿÿÿWorkspace State ÿÿÿÿBrowserÿÿÿÿ Editor ÿÿÿÿÿÿÿÿjpglless6D:\Osiris\NewCode\Papyrus3\JpegDir\JpgLless\Jlless.dspjpglossy6D:\Osiris\NewCode\Papyrus3\JpegDir\JpgLossy\Jlossy.dspdicomdir0D:\Osiris\NewCode\Papyrus3\dicomdir\dicomdir.dsppapyrus3'D:\Osiris\NewCode\Papyrus3\Papyrus3.dsp»°€!ddX,ddźddXÈ–ddXÈ–ddXÈddXÈ»°€!MLJLddX,ddźddXÈ–ddXÈ–ddXÈddXÈ»°€!Workspace Window" ÿÿÿÿÿÿÿÿ!IPI_Jpgllessÿÿÿÿÿÿÿÿÿÿÿÿ+IPI_Jpglossyÿÿÿÿ5IPI_Papyrus3ÿÿÿÿÿÿÿÿÿÿÿÿ?Papyrus3 ClassViewJpglossy classesJpglossy classesPapyrus3 classesFileView"Workspace 'Papyrus3': 4 project(s)dicomdir files Source Files Header FilesJpglless files Source Files Header FilesJpglossy filesPapyrus3 files Source Files Header FilesPapyFileSystemPC3.cPapyFileSystemPC3.c JPEGLESS.HFileView»°€!`êJpglless - Win32 Debug Jlless.dspCProjectJpglless - Win32 DebugJpglless - Win32 ReleaseJpglless - Win32 DebugêûSSBR CTargetItemJpglless - Win32 DebugSSBR Source Files CProjGroupSSBRDJW Header Files CProjGroupSSBRDJWResource Files CProjGroupSSBRDJWdepCDependencyContainerSSBRDJWDJWDJWOR>»°€!`êJpglossy - Win32 Debug Jlossy.dspCProjectJpglossy - Win32 DebugJpglossy - Win32 ReleaseJpglossy - Win32 DebugêûSSBR CTargetItemJpglossy - Win32 DebugSSBR Source Files CProjGroupSSBRDJW Header Files CProjGroupSSBRDJWResource Files CProjGroupSSBRDJWdepCDependencyContainerSSBRDJWDJWDJWOR>»°€!`êPapyrus3 - Win32 Debug Papyrus3.dspCProjectPapyrus3 - Win32 DebugPapyrus3 - Win32 ReleasePapyrus3 - Win32 DebugêûSSBR CTargetItemPapyrus3 - Win32 DebugSSBR Source Files CProjGroupSSBRDJW Header Files CProjGroupSSBRDJWResource Files CProjGroupSSBRDJWJpgllessCProjectDependencySSBRJpglossyCProjectDependencySSBRdicomdirCProjectDependencySSBRdepCDependencyContainerSSBRDJWDJWDJW»°€!IPI_dicomdir ÿÿÿÿJIPI_ ÿÿÿÿÿÿÿÿÿÿÿÿTClassView Window"ÿÿÿÿÿÿÿÿÿÿÿÿ^Debuggerÿÿÿÿ ÿÿÿÿh`êdicomdir - Win32 Debug dicomdir.dspCProjectdicomdir - Win32 Debugdicomdir - Win32 Release€dicomdir - Win32 Debug€êûSSBR CTargetItemdicomdir - Win32 DebugSSBR Source Files CProjGroupSSBRDJW Header Files CProjGroupSSBRDJWdepCDependencyContainerSSBRDJWDJWDJWSSBRJpglossyCProjectDependencySSBRdicomdirCProjectDependencySSBRdepCDependencyContainerSSBRDJWDJWDJW»°€!`êdicomdir Source FilesDicomDirDataSetRead.cDicomDirDataSetWrite.cDicomDirFiles.cDicomDirInit.cDicomDirInitRecords.cOGlobalDicomFunc.cpp Header Files DicomDir.hDicomDirEnumRecords.hDicomdirGlobalVar3.hDicomDirInitRecords.hDicomdirPrivFunctionDef3.hDicomdirPubFunctionDef3.hDicomdirTypeDef3.hOGlobalDicomFunc.hJpglless Source Files Header FilesResource FilesJpglossy Source Files Header FilesResource FilesPapyrus3 Source Files Header FilesResource FilesJpgllessJpglossyÿÿÿÿUinc1 - Win32 ReleaseOverlay1 - Win32 DebugDialogc1 - Win32 ReleaseDivers - Win32 ReleaseOverlay1 - Win32 Releaseosiris - Win32 DebugColorc1 - Win32 ReleaseToolsc1 - Win32 DebugOsirisc1 - Win32 Releaseosiris - Win32 ReleaseDialogc1 - Win32 DebugColorc1 - Win32 DebugToolsc1 - Win32 ReleaseUinc1 - Win32 DebugDivers - Win32 DebugOsirisc1 - Win32 Debugÿÿ»°€!ÿÿ CClsFldSlobJpglless€Jpglossy€Papyrus3€dicomdirrite.cDicomDirFiles.cDicomDirInit.cDicomDirInitRecords.cOGlobalDicomFunc.cpp Header Files DicomDir.hDicomDirEnumRecords.hDicomdirGlobalVar3.hDicomDirInitRecords.hDicomdirPrivFunctionDef3.hDicomdirPubFunctionDef3.hDicomdirTypeDef3.hOGlobalDicomFunc.hJpglless Source Files Header FilesResource FilesJpglossy Source Files Header FilesResource FilesPapyrus3 Source Files Header FilesResource FilesJpgllessJpglossyÿÿÿÿUinc1 - Win32 ReleaseOverlay1 - Win32 DebugDialogc1 - Win32 ReleaseDivers - Win32 ReleaseOverlay1 - Win32 Releaseosiris - Win32 DebugColorc1 - Win32 ReleaseToolsc1 - Win32 DebugOsirisc1 - Win32 Releaseosiris - Win32 ReleaseDialogc1 - Win32 DebugColorc1 - Win32 DebugToolsc1 - Win32 ReleaseUinc1 - Win32 DebugDivers - Win32 DebugOsirisc1 - Win32 Debugÿÿ»°€! @ Control-C@ Control-Break€Datatype MisalignmentÀAccess ViolationÀ In Page ErrorÀIllegal InstructionŒÀArray Bounds ExceededÀFloat Denormal OperandŽÀFloat Divide by ZeroÀFloat Inexact ResultÀFloat Invalid Operation‘ÀFloat Overflow’ÀFloat Stack Check“ÀFloat UnderflowÀ No Memory%ÀNoncontinuable Exception&ÀInvalid Disposition”ÀInteger Divide by Zero•ÀInteger Overflow–ÀPrivileged InstructionýÀStack Overflow5À DLL Not FoundBÀDLL Initialization Failed~mÀModule Not FoundmÀProcedure Not FoundÀInvalid HandlecsmàMicrosoft C++ ExceptionWatch1Watch2Watch3Watch4˜1 - Win32 DebugToolsc1 - Win32 ReleaseUinc1 - Win32 DebugDivers - Win32 DebugOsirisc1 - Win32 Debugÿÿ»°€!Documentsÿÿÿÿÿÿÿÿÿÿÿÿsÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ˜C/C++· Y°Í„0· Y'Í„§¶ YÓÌ„S¶YW̄׵YÌ„¶YHÍ„ȶYsÍ„ó¶YáÍ„a·<  .\PapyFileSystemPC3.c&{3486698D-49EB-11CF-BF46-00AA004C12E2},ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ)[ÚZeroÀFloat Inexact ResultÀFloat Invalid Operation‘ÀFloat Overflow’ÀFloat Stack Check“ÀFloat UnderflowÀ No Memory%ÀNoncontinuable Exception&ÀInvalid Disposition”ÀInteger Divide by Zero•ÀInteger Overflow–ÀPrivileged InstructionýÀStack Overflow5À DLL Not FoundBÀDLL Initialization Failed~mÀModule Not FoundmÀProcedure Not FoundÀInvalid HandlecsmàMicrosoft C++ ExceptionWatch1Watch2Watch3Watch4˜1 - Win32 DebugToolsc1 - Win32 ReleaseUinc1 - Win32 DebugDivers - Win32 DebugOsirisc1 - Win32 Debugÿÿ»°€!Papyrus3/PapyFileSystemMac3.c0000755000175000017500000003042610044204242013312 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyFileSystemMac3.c */ /* Function : contain specific reading/writing fcts for all kind */ /* of architecture */ /* Authors : Christian Girard */ /* Marianne Logean */ /* Dominique Blot */ /* */ /* History : 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ /* ------------------------- includes ------------------------------------------*/ #include #include #include #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif /********************************************************************************/ /* */ /* Papy3FCreate : overwrites the standard create file function */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FCreate (char *inFilenameP, PAPY_FILE inVolume, PAPY_FILE *inFp, void **inFSSpecP) { int theErr; FSSpec *theFSSpecP; /* foo assignation to a foo var */ inFp = inFp; if ((inFSSpecP != NULL) && (*inFSSpecP != NULL)) theFSSpecP = (FSSpec *) *inFSSpecP; else { /* create the FSSpec ptr */ theFSSpecP = (FSSpec *) emalloc3 ((PapyULong) sizeof (FSSpec)); if (inVolume >= 0) theFSSpecP->vRefNum = inVolume; else theFSSpecP->vRefNum = - LMGetSFSaveDisk (); theFSSpecP->parID = LMGetCurDirStore (); /* test the length of the filename (should not be greater than 64 on the Mac) */ /* so if it is longer the filename is truncated */ if (strlen (inFilenameP) > 64) inFilenameP [63] = '\0'; strcpy ((char *) theFSSpecP->name, inFilenameP); c2pstr ((char *) theFSSpecP->name); } /* else */ /* create the file */ theErr = FSpCreate (theFSSpecP, 'OSIR', 'PAPY', smSystemScript); if ((inFSSpecP != NULL) && (*inFSSpecP == NULL)) *inFSSpecP = theFSSpecP; else efree3 (&theFSSpecP); return theErr; } /* endof Papy3FCreate */ /********************************************************************************/ /* */ /* Papy3FOpen : overwrites the standard open file function */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort Papy3FOpen (char *inFilenameP, char inPermission, PAPY_FILE inVolumeNb, PAPY_FILE *outFp, void *inFSSpecP) /* permission r : read, w : write, a : read/write (all) */ { PapyShort theErr; FSSpec *theFSSpecP; if (inFSSpecP == NULL) { /* create the FSSpec ptr */ theFSSpecP = (FSSpec *) emalloc3 ((PapyULong) sizeof (FSSpec)); /* in case of full pathname BLO, I suppose (!) that inFilenameP is a c-string */ if (inVolumeNb == 0) { c2pstr ((char *) inFilenameP); theErr = FSMakeFSSpec (0, 0, (unsigned char*) inFilenameP, theFSSpecP); p2cstr ((unsigned char *) inFilenameP); } /* if */ else { /* fill in the FSSpec structure */ theFSSpecP->vRefNum = inVolumeNb; theFSSpecP->parID = LMGetCurDirStore (); strcpy ((char *) theFSSpecP->name, inFilenameP); c2pstr ((char *) theFSSpecP->name); } /* else */ } /* if */ else theFSSpecP = (FSSpec *) *((void**) inFSSpecP); /* open the file */ switch (inPermission) { case 'r' : theErr = (PapyShort) FSpOpenDF (theFSSpecP, fsRdPerm, outFp); break; case 'w' : theErr = (PapyShort) FSpOpenDF (theFSSpecP, fsWrPerm, outFp); break; case 'a' : default : theErr = (PapyShort) FSpOpenDF (theFSSpecP, fsRdWrPerm, outFp); } /* switch */ if (inFSSpecP == NULL) efree3 (&theFSSpecP); return theErr; } /* endof Papy3FOpen */ /********************************************************************************/ /* */ /* Papy3FClose : overwrites the standard close file function */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FClose (PAPY_FILE *inFp) { int theErr; theErr = FSClose (*inFp); return theErr; } /* endof Papy3FClose */ /********************************************************************************/ /* */ /* Papy3FDelete : overwrites the standard delete file function */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FDelete (char *inFilenameP, void *inIdentifierP) { int theErr; /* foo use of a foo var */ inFilenameP = inFilenameP; theErr = FSpDelete ((const FSSpec *) inIdentifierP); return theErr; } /* endof Papy3FDelete */ /********************************************************************************/ /* */ /* Papy3FRead : overwrites the standard read from file function */ /* return : error (0 if OK, negative value otherwise) */ /* */ /********************************************************************************/ PapyShort Papy3FRead (PAPY_FILE inFp, PapyULong *ioBytesToReadP, PapyULong inNb, void *ioBufferP) { HIOParam ptrParm; PapyShort theErr; /* foo use of a foo var */ inNb = inNb; ptrParm.ioRefNum = (short) inFp; ptrParm.ioBuffer = (Ptr) ioBufferP; ptrParm.ioReqCount = (long) *ioBytesToReadP; ptrParm.ioPosMode = fsAtMark; theErr = (PapyShort) PBRead ((ParmBlkPtr) &ptrParm, FALSE); return theErr; } /* endof Papy3FRead */ /********************************************************************************/ /* */ /* Papy3FWrite : overwrite the standard write to file function */ /* return : error (0 if OK, negative value otherwise) */ /* */ /********************************************************************************/ PapyShort Papy3FWrite (PAPY_FILE inFp, PapyULong *ioBytesToWriteP, PapyULong inNb, void *outBufferP) { HIOParam ptrParm; PapyShort theErr; /* foo use of a foo var */ inNb = inNb; ptrParm.ioRefNum = (short) inFp; ptrParm.ioBuffer = (Ptr) outBufferP; ptrParm.ioReqCount = (long) *ioBytesToWriteP; ptrParm.ioPosMode = fsAtMark; theErr = (PapyShort) PBWrite ((ParmBlkPtr) &ptrParm, FALSE); return theErr; } /* endof Papy3FWrite */ /********************************************************************************/ /* */ /* Papy3FSeek : Papyrus own build file pointer positioning function. */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FSeek (PAPY_FILE inFp, int inPosMode, PapyLong inOffset) { int theErr; short macPosMode; switch (inPosMode) { case SEEK_SET : macPosMode = fsFromStart; break; case SEEK_CUR : macPosMode = fsFromMark; break; case SEEK_END : macPosMode = fsFromLEOF; break; } theErr = SetFPos (inFp, macPosMode, (long) inOffset); return theErr; } /* endof Papy3FSeek */ /********************************************************************************/ /* */ /* Papy3FTell : Papyrus function to get the current position of the file */ /* pointer. */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FTell (PAPY_FILE inFp, PapyLong *outFilePosP) { int theErr; theErr = GetFPos (inFp, (long *) outFilePosP); return theErr; } /* endof Papy3FTell */ /********************************************************************************/ /* */ /* Papy3FPrint : Papyrus function to set a string */ /* */ /********************************************************************************/ void Papy3FPrint (char *inStringP, char *inFormatP, int inValue) { sprintf (inStringP, inFormatP, inValue); } /* endof Papy3FPrint */ Papyrus3/PapyEalloc3.h0000755000175000017500000001313110044175204012010 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyEalloc3.h */ /* Function : declaration of the fct of emalloc3 */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 04.1991 version 1.1 */ /* 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* */ /********************************************************************************/ #ifndef PapyEalloc3H #define PapyEalloc3H #include #ifdef UNIX #include #endif #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #ifdef _WINDOWS #ifdef __cplusplus extern "C" { #endif /*__cplusplus */ #endif /* _WINDOWS */ #ifdef _NO_PROTO extern void *emalloc3 (); extern void *ecalloc3 (); extern void *erealloc3 (); extern void efree3 (); #else extern void *emalloc3 (PapyULong); extern void *ecalloc3 (PapyULong, PapyULong); extern void *erealloc3 (void *, PapyULong, PapyULong); extern void efree3 (void **); #endif #ifdef _WINDOWS #ifdef __cplusplus } #endif #endif #endif /* PapyEalloc3H */ Papyrus3/.DS_Store0000777000175000017500000003600410076705540011225 0ustar Bud1   <mDirIloc  @€ @€ @€ @<DicomDirIlocblobð'ÿÿÿÿÿÿDicomDirdsclboolJpegDirIlocblob'ÿÿÿÿÿÿJpegDirdsclboolJpegDirfwi0blobNlsvJpegDiricspblobJpegDirlsspblobMakefileIlocblobPŒÿÿÿÿÿÿ Makefile.PCIlocblobðŒÿÿÿÿÿÿ Makefile.sun4IlocblobŒÿÿÿÿÿÿPapyConvertFile3.cIlocblobPñÿÿÿÿÿÿPapyDataSetRead3.cIlocblobðñÿÿÿÿÿÿPapyDataSetWrite3.cIlocblobñÿÿÿÿÿÿ PapyEalloc3.hIlocblobPVÿÿÿÿÿÿPapyEallocMac3.cIlocblobðVÿÿÿÿÿÿPapyEallocPC3.cppIlocblobVÿÿÿÿÿÿPapyEallocUnix3.cIlocblobP»ÿÿÿÿÿÿPapyEnumGroups3.hIlocblobð»ÿÿÿÿÿÿPapyEnumImageGroups3.hIlocblob»ÿÿÿÿÿÿPapyEnumImagesModules3.hIlocblobP ÿÿÿÿÿÿPapyEnumMiscGroups3.hIlocblobð ÿÿÿÿÿÿPapyEnumMiscModules3.hIlocblob ÿÿÿÿÿÿPapyEnumModules3.hIlocblobP…ÿÿÿÿÿÿ PapyError3.cIlocblobð…ÿÿÿÿÿÿ PapyError3.hIlocblob…ÿÿÿÿÿÿPapyErrorMacros3.hIlocblobPêÿÿÿÿÿÿ PapyFiles3.cIlocblobðêÿÿÿÿÿÿPapyFileSystem3.hIlocblobêÿÿÿÿÿÿPapyFileSystemMac3.cIlocblobPOÿÿÿÿÿÿPapyFileSystemPC3.cIlocblobðOÿÿÿÿÿÿPapyFileSystemUnix3.cIlocblobOÿÿÿÿÿÿPapyGetGlobalVar3.cIlocblobP´ÿÿÿÿÿÿPapyGlobalVar3.hIlocblobð´ÿÿÿÿÿÿ PapyInit3.cIlocblob´ÿÿÿÿÿÿPapyInitGroups3.cIlocblobPÿÿÿÿÿÿPapyInitModules3.cIlocblobðÿÿÿÿÿÿPapyInitModules3.hIlocblobÿÿÿÿÿÿ PapyList3.cIlocblobP~ÿÿÿÿÿÿPapyMemorySystemMac3.cIlocblobð~ÿÿÿÿÿÿPapyMemorySystemMac3.hIlocblob~ÿÿÿÿÿÿPapyMemSystem.cppIlocblobPãÿÿÿÿÿÿPapyMemSystem.hIlocblobðãÿÿÿÿÿÿPapyPrivFunctionDef3.hIlocblobãÿÿÿÿÿÿPapyPubFunctionDef3.hIlocblobPHÿÿÿÿÿÿ PapyRead3.cIlocblobðHÿÿÿÿÿÿ Papyrus3.dspIlocblobHÿÿÿÿÿÿ Papyrus3.dswIlocblobP­ÿÿÿÿÿÿ Papyrus3.hIlocblobð­ÿÿÿÿÿÿ Papyrus3.ncbIlocblob­ÿÿÿÿÿÿ Papyrus3.optIlocblobPÿÿÿÿÿÿ Papyrus3.plgIlocblobðÿÿÿÿÿÿPapyTypeDef3.hIlocblobÿÿÿÿÿÿ PapyUtils3.cIlocblobPwÿÿÿÿÿÿ PapyVars3.cIlocblobðwÿÿÿÿÿÿ PapyWild3.cIlocblobwÿÿÿÿÿÿ PapyWild3.hIlocblobPÜÿÿÿÿÿÿPapyWildexit3.cIlocblobðÜÿÿÿÿÿÿ PapyWrite3.cIlocblobÜÿÿÿÿÿÿTESTSIlocblobPAÿÿÿÿÿÿTESTSdsclbool E DSDB `€(0@€ @€ @PapyEnumModules3.hIlocblobP…ÿÿÿÿÿÿ PapyError3.cIlocblobð…ÿÿÿÿÿÿ PapyError3.hIlocblob…ÿÿÿÿÿÿPapyErrorMacros3.hIlocblobPêÿÿÿÿÿÿ PapyFiles3.cIlocblobðêÿÿÿÿÿÿPapyFileSystem3.hIlocblobêÿÿÿÿÿÿPapyFileSystemMac3.cIlocblobPOÿÿÿÿÿÿPapyFileSystemPC3.cIlocblobðOÿÿÿÿÿÿPapyFileSystemUnix3.cIlocblobOÿÿÿÿÿÿPapyGetGlobalVar3.cIlocblobP´ÿÿÿÿÿÿPapyGlobalVar3.hIlocblobð´ÿÿÿÿÿÿ PapyInit3.cIlocblob´ÿÿÿÿÿÿPapyrus3/PapyWild3.h0000755000175000017500000001276010044201544011514 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyWild3.h */ /* Function : declaration of the fct of wild */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 04.1991 version 1.1 */ /* 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef PapyWild3H #define PapyWild3H #endif #ifdef _NO_PROTO extern char *wildname(); extern void wild3(); extern void wild2exit(); extern void wildexit(); extern void wildcexit(); extern void wildrexit(); extern void tameexit(); #else extern char *wildname(register char *); extern void wild3(char *,char *); extern void wild2exit(char *, char *); extern void wildexit(char *); extern void wildcexit(char *); extern void wildrexit(char *); extern void tameexit(); #endif Papyrus3/PapyFileSystem3.h0000755000175000017500000001361110044202064012673 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyFileSystem3.h */ /* Function : contains machine specific calls to the different file systems */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef PapyFileSystem3H #define PapyFileSystem3H /* ------------------------- includes ------------------------------------------*/ /*#ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #ifndef PapyError3H #include "PapyError3.h" #endif /*#else /* FILENAME83 defined for the DOS machines */ /* #ifndef PapyTypeDef3H #include "PAPYDEF3.h" #endif #ifndef PapyError3H #include "PAPERR3.h" #endif #endif */ /* ------------------------- functions definition ------------------------------*/ #ifdef _NO_PROTO extern int Papy3FCreate (); extern PapyShort Papy3FOpen (); extern int Papy3FClose (); extern int Papy3FDelete (); extern PapyShort Papy3FRead (); extern PapyShort Papy3FWrite (); extern int Papy3FTell (); extern int Papy3FSeek (); extern void Papy3FPrint (); #else extern int Papy3FCreate (char *, PAPY_FILE, PAPY_FILE *, void **); extern PapyShort Papy3FOpen (char *, char, PAPY_FILE, PAPY_FILE *, void *); extern int Papy3FClose (PAPY_FILE *); extern int Papy3FDelete (char *, void *); extern PapyShort Papy3FRead (PAPY_FILE, PapyULong *, PapyULong, void *); extern PapyShort Papy3FWrite (PAPY_FILE, PapyULong *, PapyULong, void *); extern int Papy3FTell (PAPY_FILE, PapyLong *); extern int Papy3FSeek (PAPY_FILE, int, PapyLong); extern void Papy3FPrint (char *, char *, int); #endif #endif /* PapyFileSystem3H */ Papyrus3/Makefile0000755000175000017500000000316207535143454011203 0ustar # @(#)Makefile 1.3 5/3/91 ARCH= Solaris DSTDIR= . MANDIR= $(DSTDIR)/man JPEGDIRLL= JpegDir/JpgLless JPEGDIRLY= JpegDir/JpgLossy DICOMDIR= DicomDir MAYODIR= Mayo BINDIR= $(DSTDIR)/test LIBDIR= $(DSTDIR)/$(ARCH)/lib LINTLIBDIR= $(LIBDIR)/lint INSTALLDIR= /home/Dorad/dorad/bin CPPFLAGS= -I. -I../.. -I$(DICOMDIR) -I$(JPEGDIRLL) -I$(JPEGDIRLY) -D_NO_LONGLONG -DSolaris CFLAGS= -g LINTFLAGS= -hb SOURCES= \ PapyConvertFile3.c \ PapyError3.c \ PapyFileSystemUnix3.c \ PapyFiles3.c \ PapyGetGlobalVar3.c \ PapyInit3.c \ PapyInitGroups3.c \ PapyInitModules3.c \ PapyRead3.c \ PapyDataSetRead3.c \ PapyList3.c \ PapyVars3.c \ PapyWrite3.c \ PapyDataSetWrite3.c \ PapyEallocUnix3.c \ PapyWild3.c \ PapyWildexit3.c \ PapyUtils3.c LIBRARY= libP.a OBJECTS= $(SOURCES:%.c=$(ARCH)/%.o) $(LIBDIR)/$(LIBRARY): createdir $(OBJECTS) ar rv $@ $(OBJECTS) cd JpegDir/JpgLless;make; cd JpegDir/JpgLossy;make; cd DicomDir;make lint: $(SOURCES) $(LINT.c) $(SOURCES) createdir: test -d $(ARCH) || mkdir -p $(ARCH) test -d $(DSTDIR)/$(ARCH)/lib || mkdir -p $(DSTDIR)/$(ARCH)/lib install: $(LIBDIR)/$(LIBRARY) cp $(LIBDIR)/libP.a $(INSTALLDIR) cp $(LIBDIR)/libJpglossy.a $(INSTALLDIR) cp $(LIBDIR)/libJpglless.a $(INSTALLDIR) cp $(LIBDIR)/libDicomdir.a $(INSTALLDIR) clean: -rm -Rf $(ARCH); cd JpegDir/JpgLless;make clean; cd JpegDir/JpgLossy;make clean; cd DicomDir;make clean .KEEP_STATE: .INIT: $(LIBDIR) $(ARCH) $(LIBDIR) $(ARCH) : test -d $@ || mkdir -p $@ $(ARCH)/%.o: %.c $(COMPILE.c) $< -o $@ Papyrus3/PapyMemorySystemMac3.c0000755000175000017500000003332610044203046013706 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyMemorySystemMac3.c */ /* Function : contains machine specific calls to the different file systems */ /* Authors : Antoine ROSSET */ /* */ /* History : 02.1998 version 3.1 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ /* ------------------------- includes ------------------------------------------*/ #include #include #include #ifndef PapyFileSystem3H #include "PapyFileSystem3.h" #endif #ifndef PapyMemorySystemMac3H #include "PapyMemorySystemMac3.h" #endif typedef struct SPapyMemStruct { Ptr mFileP; long mFilePos, mFileSize; PAPY_FILE mvRefNum; HIOParam mPtrParm; } SPapyMemStruct; static SPapyMemStruct thePapMemStruct [200]; /* Maximum of 200 files open */ static short theListSize = 0; /********************************************************************************/ /* */ /* Papy3LoadFileMem */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort Papy3LoadFileMem (PAPY_FILE inVRefNum) { OSErr theErr; theErr = (PapyShort) GetEOF (inVRefNum, &thePapMemStruct [theListSize].mFileSize); /* thePapMemStruct [theListSize].mFileP = NewPtr (thePapMemStruct [theListSize].mFileSize);*/ thePapMemStruct [theListSize].mFileP = (char *) emalloc3 ((PapyULong) thePapMemStruct [theListSize].mFileSize); if (thePapMemStruct [theListSize].mFileP == 0L) return -1; thePapMemStruct [theListSize].mPtrParm.ioRefNum = (short) inVRefNum; thePapMemStruct [theListSize].mPtrParm.ioBuffer = (Ptr) thePapMemStruct [theListSize].mFileP; thePapMemStruct [theListSize].mPtrParm.ioReqCount = (long) thePapMemStruct [theListSize].mFileSize; thePapMemStruct [theListSize].mPtrParm.ioPosMode = fsFromStart; theErr = (PapyShort) PBRead ((ParmBlkPtr) &thePapMemStruct [theListSize].mPtrParm, TRUE); /* Read in ASYNC ! */ thePapMemStruct [theListSize].mFilePos = 0L; thePapMemStruct [theListSize].mvRefNum = inVRefNum; theListSize++; return noErr; } /* endof Papy3LoadFileMem */ /********************************************************************************/ /* */ /* Papy3SetMemPtr */ /* return : standard error message */ /* */ /********************************************************************************/ void Papy3SetMemPtr (PAPY_FILE inVRefNum, long inPos, long inSize, Ptr inPtr) { short i; for (i = 0; i < theListSize; i++) { if (thePapMemStruct [i].mvRefNum == inVRefNum) { if (inPtr == NULL) { thePapMemStruct [i].mFilePos = 0L; thePapMemStruct [i].mFileSize = 0L; thePapMemStruct [i].mFileP = 0L; thePapMemStruct [i].mvRefNum = 0L; } /* if */ else { thePapMemStruct [i].mFilePos = inPos; thePapMemStruct [i].mFileSize = inSize; thePapMemStruct [i].mFileP = inPtr; } /* else */ return; } /* if ...inVRefNum */ } /* for */ DebugStr("\pNot found"); return; } /* endof Papy3SetMemPtr */ /********************************************************************************/ /* */ /* Papy3GetMemPtr */ /* return : standard error message */ /* */ /********************************************************************************/ Ptr Papy3GetMemPtr (PAPY_FILE inVRefNum, long *ioPosP, long *ioSizeP, long *ActCount) { short i; for (i = 0; i < theListSize; i++) { if (thePapMemStruct [i].mvRefNum == inVRefNum) { if (ioPosP) *ioPosP = thePapMemStruct [i].mFilePos; if (ioSizeP) *ioSizeP = thePapMemStruct [i].mFileSize; if (ActCount) *ActCount = thePapMemStruct [i].mPtrParm.ioActCount; return thePapMemStruct [i].mFileP; } /* if */ } /* for */ return 0L; } /* endof Papy3GetMemPtr */ /********************************************************************************/ /* */ /* Papy3FLoadMem */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort Papy3FLoadMem (PAPY_FILE inVRefNum) { PapyShort theErr; if (Papy3GetMemPtr (inVRefNum, 0L, 0L, 0L)) Debugger(); theErr = Papy3LoadFileMem (inVRefNum); if (theErr) DebugStr ("\pPapy3LoadFileMem Err"); return theErr; } /* endof Papy3FLoadMem */ /********************************************************************************/ /* */ /* Papy3FOpenMem : overwrites the standard open file function */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort Papy3FOpenMem (char *inFilenameP, char inPermission, PAPY_FILE inVolumeNb, PAPY_FILE *outFp, void *inFSSpecP) /* permission r : read, w : write, a : read/write (all) */ { PapyShort theErr; FSSpec *theFSSpecP; if (inFSSpecP == NULL) { /* create the FSSpec ptr */ theFSSpecP = (FSSpec *) emalloc3 ((PapyULong) sizeof (FSSpec)); /* fill in the FSSpec structure */ theFSSpecP->vRefNum = inVolumeNb; theFSSpecP->parID = LMGetCurDirStore (); strcpy ((char *) theFSSpecP->name, inFilenameP); c2pstr ((char *) theFSSpecP->name); } /* if */ else theFSSpecP = (FSSpec *) inFSSpecP; /* open the file */ switch (inPermission) { case 'r' : theErr = (PapyShort) FSpOpenDF (theFSSpecP, fsRdPerm, outFp); break; case 'w' : theErr = (PapyShort) FSpOpenDF (theFSSpecP, fsWrPerm, outFp); break; case 'a' : default : theErr = (PapyShort) FSpOpenDF (theFSSpecP, fsRdWrPerm, outFp); } /* switch */ if (Papy3GetMemPtr (*outFp, 0L, 0L, 0L)) Debugger(); theErr = Papy3LoadFileMem (*outFp); if (theErr) DebugStr ("\pPapy3LoadFileMem Err"); if (inFSSpecP == NULL) efree3 (&theFSSpecP); return theErr; } /* endof Papy3FOpenMem */ /********************************************************************************/ /* */ /* Papy3FCloseMem : overwrites the standard close file function */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FCloseMem (PAPY_FILE *ioFp) { int theErr; Ptr theFilePtr; long theFilePos, theFileSize; theFilePtr = Papy3GetMemPtr (*ioFp, &theFilePos, &theFileSize, 0L); /*DisposePtr (theFilePtr);*/ efree3 ((void **) &theFilePtr); theFilePtr = 0L; theErr = FSClose (*ioFp); Papy3SetMemPtr (*ioFp, theFilePos, theFileSize, theFilePtr); return theErr; } /* endof Papy3FCloseMem */ /********************************************************************************/ /* */ /* Papy3FReadMem : overwrites the standard read from file function */ /* return : error (0 if OK, negative value otherwise) */ /* */ /********************************************************************************/ PapyShort Papy3FReadMem (PAPY_FILE inFp, PapyULong *inBytesToReadP, PapyULong inNb, void **inBufferP, Boolean inNoMemTransfer) { Ptr theFilePtr; long theFilePos, theFileSize, theActCount; /* dummy instruction... */ inNb = inNb; theFilePtr = Papy3GetMemPtr (inFp, &theFilePos, &theFileSize, &theActCount); /* Wait until the buffer is full to access this data */ while (theFilePos + *inBytesToReadP > theActCount) Papy3GetMemPtr (inFp, 0L, 0L, &theActCount); if (inNoMemTransfer) *inBufferP = theFilePtr + theFilePos; else BlockMoveData (theFilePtr + theFilePos, *inBufferP, *inBytesToReadP); theFilePos += *inBytesToReadP; if (theFilePos > theFileSize) { Debugger(); return EOF; } /* if */ Papy3SetMemPtr (inFp, theFilePos, theFileSize, theFilePtr); return noErr; } /* endof Papy3FReadMem */ /********************************************************************************/ /* */ /* Papy3FSeekMem : Papyrus own build file pointer positioning function. */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FSeekMem (PAPY_FILE inFp, int inPosMode, PapyLong inOffset) { int theErr = noErr; short theMacPosMode; Ptr theFilePtr; long theFilePos, theFileSize; theFilePtr = Papy3GetMemPtr (inFp, &theFilePos, &theFileSize, 0L); switch (inPosMode) { case SEEK_SET : theMacPosMode = fsFromStart; theFilePos = inOffset; break; case SEEK_CUR : theMacPosMode = fsFromMark; theFilePos += inOffset; break; case SEEK_END : theMacPosMode = fsFromLEOF; theFilePos = theFileSize + inOffset; Debugger(); break; } /* switch */ Papy3SetMemPtr (inFp, theFilePos, theFileSize, theFilePtr); return theErr; } /* endof Papy3FSeekMem */ /********************************************************************************/ /* */ /* Papy3FTellMem : Papyrus function to get the current position of the file*/ /* pointer. */ /* return : standard error message */ /* */ /********************************************************************************/ int Papy3FTellMem (PAPY_FILE inFp, PapyLong *outFilePosP) { int theErr = noErr; Ptr theFilePtr; long theFilePos, theFileSize; theFilePtr = Papy3GetMemPtr (inFp, &theFilePos, &theFileSize, 0L); *outFilePosP = theFilePos; return theErr; } /* endof Papy3FTellMem */Papyrus3/PapyDataSetWrite3.c0000755000175000017500000024702310044175326013162 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyDataSetWrite3.c */ /* Function : contains the functions that will manage the Data Sets and */ /* the modules (writing). */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifdef Mac #pragma segment papy3 #endif /* ------------------------- includes -----------------------------------------*/ #include #include #include #ifdef Mac #ifndef __LOWMEM__ #include #endif #ifndef __FILES__ #include #endif #include #endif #ifndef Papyrus3H #include "Papyrus3.h" #endif /********************************************************************************/ /* */ /* CreateFileMetaInformation3 : Creates the file meta information for the */ /* given file. It creates group2 and fill some elements. */ /* return : noError if no problem */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort CreateFileMetaInformation3 (PapyShort inFileNb, enum EPap_Compression inCompression, enum ETransf_Syntax inSyntax, enum EModality inModality) { SElement *theGr2P; Object *theObjectP; Item *theItemP; PapyUShort *theUsP; char *theCharP, theChar [32]; /* creation of the file meta information group */ theGr2P = Papy3GroupCreate (Group2); /* provide the group structure with the needed information */ /* set the last bit of the second byte in the file (after translation) to 1 */ /* in order to identify the file meta information version (Version 2) */ theUsP = (PapyUShort *) emalloc3 ((PapyULong) sizeof (PapyUShort)); *theUsP = 1; Papy3PutImage (inFileNb, theGr2P, papFileMetaInformationVersionGr, theUsP, 0, 0, 8, 2L); theCharP = (char*) &theChar[0]; /* DICOMDIR defined SOP Class UID */ if (gIsPapyFile [inFileNb] == DICOMDIR) { strcpy (theCharP, "1.2.840.10008.1.3.10"); Papy3PutElement (theGr2P, papMediaStorageSOPClassUIDGr, &theCharP); } else /* media storage SOP class UID, i.e the UID of the imaging modality */ Papy3PutElement (theGr2P, papMediaStorageSOPClassUIDGr, &(gArrUIDs [inModality])); /* the transfert syntax that will be used in the rest of the file */ /* actually only the default DICOM syntax is supported, */ /* i.e implicit VR little-endian with or without compression */ /* DISCUSS */ if (inSyntax == LITTLE_ENDIAN_IMPL && inCompression == NONE) strcpy (theCharP, "1.2.840.10008.1.2"); else if (inSyntax == LITTLE_ENDIAN_EXPL && inCompression == NONE) strcpy (theCharP, "1.2.840.10008.1.2.1"); else if (inSyntax == LITTLE_ENDIAN_EXPL && inCompression == JPEG_LOSSLESS) strcpy (theCharP, "1.2.840.10008.1.2.4.70"); else if (inSyntax == LITTLE_ENDIAN_EXPL && inCompression == JPEG_LOSSY) strcpy (theCharP, "1.2.840.10008.1.2.4.51"); #ifdef MAYO_WAVE else if (inSyntax == LITTLE_ENDIAN_EXPL && inCompression == MAYO_WAVELET) strcpy (theCharP, "1.2.840.10008.1.2.4.80"); /* WARNING this is NOW defined in DICOM as JPEG-LS lossless image compression */ /* whereas 1.2.840.10008.1.2.4.81 is JPEG-LS Lossy (near-Lossless) image compression */ /* Warning: this SHOULD NOT BE a proprietary syntax transfer!! * the wavelet compression is still not standardized... */ #endif /* MAYO_WAVE */ else if (gIsPapyFile [inFileNb] == DICOMDIR) /* DICOMDIR: LITTLE_ENDIAN_EXPL */ strcpy (theCharP, "1.2.840.10008.1.2.1"); Papy3PutElement (theGr2P, papTransferSyntaxUIDGr, &theCharP); /* we have to discuss what we will put here DISCUSS */ strcpy (theCharP, "1.2.756.777.000"); Papy3PutElement (theGr2P, papImplementationClassUIDGr, &theCharP); /* create an Object and put the group 2 in it */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->group = theGr2P; theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->record = NULL; theObjectP->tmpFileLength = 0L; theObjectP->whoAmI = papGroup; theObjectP->objID = Group2; /* initialize the memory representation of the file by creating the first */ /* cell that will contain the file meta information */ theItemP = InsertFirstInList (&(gArrMemFile [inFileNb]), theObjectP); return papNoError; } /* endof CreateFileMetaInformation3 */ /********************************************************************************/ /* */ /* CreateDicomFileMetaInformation3 : Creates the file meta information for */ /* the given file. It creates group2 and fill some elements. Then writes */ /* the group to the given file. */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort CreateDicomFileMetaInformation3 (PAPY_FILE inFp, PapyShort inFileNb, enum EPap_Compression inCompression, enum ETransf_Syntax inSyntax, enum EModality inModality, PapyULong *OutMetaInfoSizeP) { SElement *theGr2P; PapyUShort *theUsP; char *theCharP, theChar [32]; unsigned char *theBuffP; PapyShort theErr = 0; int theGroupNb; PapyULong theBufSize, thePos; /* creation of the file meta information group */ theGr2P = Papy3GroupCreate (Group2); /* provide the group structure with the needed information */ /* set the last bit of the second byte in the file (after translation) to 1 */ /* in order to identify the file meta information version (Version 2) */ theUsP = (PapyUShort *) emalloc3 ((PapyULong) sizeof (PapyUShort)); *theUsP = 1; Papy3PutImage (inFileNb, theGr2P, papFileMetaInformationVersionGr, theUsP, 0, 0, 8, 2L); /* media storage SOP class UID, i.e the UID of the imaging modality */ Papy3PutElement (theGr2P, papMediaStorageSOPClassUIDGr, &(gArrUIDs [inModality])); /* the transfert syntax that will be used in the rest of the file */ /* actually only the default DICOM syntax is supported, */ /* i.e implicit VR little-endian with or without compression */ /* DISCUSS */ theCharP = (char*) &theChar[0]; if (inSyntax == LITTLE_ENDIAN_IMPL && inCompression == NONE) strcpy (theCharP, "1.2.840.10008.1.2"); else if (inSyntax == LITTLE_ENDIAN_EXPL && inCompression == NONE) strcpy (theCharP, "1.2.840.10008.1.2.1"); else if (inSyntax == LITTLE_ENDIAN_EXPL && inCompression == JPEG_LOSSLESS) strcpy (theCharP, "1.2.840.10008.1.2.4.70"); else if (inSyntax == LITTLE_ENDIAN_EXPL && inCompression == JPEG_LOSSY) strcpy (theCharP, "1.2.840.10008.1.2.4.51"); #ifdef MAYO_WAVE /* WARNING this is defined in DICOM as JPEG-LS lossless image compression */ /* whereas 1.2.840.10008.1.2.4.81 is JPEG-LS Lossy (near-Lossless) image compression */ else if (inSyntax == LITTLE_ENDIAN_EXPL && inCompression == MAYO_WAVELET) strcpy (theCharP, "1.2.840.10008.1.2.4.80"); /* Warning: this is a proprietary syntax transfer!! * the wavelet compression is still not standardized... */ #endif /* MAYO_WAVE */ Papy3PutElement (theGr2P, papTransferSyntaxUIDGr, &theCharP); /* SOP instance UID of this data set */ /* convert an int into a string and add a number at the end to ensure uniqueness */ Papy3FPrint (theCharP, "64.572.218.916.%d", gCurrTmpFilename [inFileNb]); Papy3PutElement (theGr2P, papMediaStorageSOPInstanceUIDGr, &theCharP); /* who is the creator of this wonderfull file ? */ strcpy (theCharP, "PAPYRUS 3.0"); Papy3PutElement (theGr2P, papSourceApplicationEntityTitleGr, &theCharP); /* we have to discuss what we will put here DISCUSS */ strcpy (theCharP, "1.2.756.777.001"); Papy3PutElement (theGr2P, papImplementationClassUIDGr, &theCharP); /* now write the group to the file */ if ((theGroupNb = Papy3ToEnumGroup (theGr2P->group)) < 0) RETURN (papGroupNumber); /* compute the size of the current group */ ComputeGroupLength3 ((PapyShort) theGroupNb, theGr2P, NULL, inSyntax); theBufSize = theGr2P->value->ul + kLength_length; /* alloc the buffer that will contain the ready to write group */ theBuffP = (unsigned char *) emalloc3 ((PapyULong) theBufSize); thePos = 0L; /* put the elements of the group to the write buffer */ if ((theErr = PutGroupInBuffer (inFileNb, 1, theGroupNb, theGr2P, theBuffP, &thePos, FALSE)) < 0) RETURN (theErr); /* write the buffer to the temporary file */ if ((theErr = WriteGroup3 (inFp, theBuffP, theBufSize)) < 0) RETURN (theErr); /* frees the allocated buffer */ efree3 ((void **) &theBuffP); /* compute the size of the file meta information */ *OutMetaInfoSizeP = theBufSize + 132L; return theErr; } /* endof CreateDicomFileMetaInformation3 */ /********************************************************************************/ /* */ /* Papy3GetGroup2 : Returns a pointer to the group 2 to allow the user to */ /* put the needed elements in it. */ /* return : a pointer to the group 2 */ /* */ /********************************************************************************/ SElement * CALLINGCONV Papy3GetGroup2 (PapyShort inFileNb) { return (gArrMemFile [inFileNb])->object->group; } /* endof Papy3GetGroup2 */ /********************************************************************************/ /* */ /* Papy3GetRecordType : Function only used when creating Dicomdir file */ /* return : an enumerated value which identify the kind of record. */ /* */ /********************************************************************************/ int CALLINGCONV Papy3GetRecordType (SElement *inGroup) { int theElemType; PapyULong thePos; UValue_T *theValP; char theDirType [257]; /* VR_CS_LENGTH = 256 */ int theRecordID = -1; /* Read the directory type (0004,1430) */ theValP = Papy3GetElement (inGroup, papDirectoryRecordTypeGr, &thePos, &theElemType); if (theValP != NULL) strcpy (theDirType , theValP->a); switch (theDirType [0]) { case 'P' : switch (theDirType [1]) { case 'A' : theRecordID = PatientR; break; case 'R' : theRecordID = PrintQueue; break; }/* switch */ break; case 'S' : switch (theDirType [4]) { case 'Y' : if (theDirType [5] == 'C') theRecordID = StudyComponentR; else theRecordID = StudyR; break; case 'E' : theRecordID = SeriesR; break; }/* switch ...theDirType [4] */ break; case 'I' : switch (theDirType [1]) { case 'M' : theRecordID = ImageR; break; case 'N' : theRecordID = Interpretation; break; }/* switch */ break; case 'O' : theRecordID = OverlayR; break; case 'M' : theRecordID = ModalityLUTR; break; case 'V' : switch (theDirType [1]) { case 'O' : theRecordID = VOILUTR; break; case 'I' : theRecordID = Visit; break; }/* switch */ break; case 'C' : theRecordID = CurveR; break; case 'T' : theRecordID = Topic; break; case 'R' : theRecordID = Result; break; case 'F' : theRecordID = FilmSession; break; case 'B' : switch (theDirType [5]) { case 'F' : theRecordID = BasicFilmBox; break; case 'I' : theRecordID = BasicImageBox; break; }/* switch */ break; } /* switch ...theDirType [0] */ return theRecordID; } /* endof Papy3GetRecordType */ /********************************************************************************/ /* */ /* Papy3CreateDataSet : Create a new data set item and add it to */ /* the list of Data Set of the given file. */ /* return : a pointer to the created Data Set */ /* NULL otherwise */ /* */ /********************************************************************************/ Item * CALLINGCONV Papy3CreateDataSet (PapyShort inFileNb) { Object *theObjectP; Item *theItemP, *theWrkP; SElement *theGr41P; int first = FALSE; /* if it is the first data set ... */ if (gImageSequenceItem [inFileNb] == NULL) first = TRUE; /* creates an empty object that will point to the list of modules */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papItem; theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->record = NULL; theObjectP->group = NULL; theObjectP->tmpFileLength = 0L; theItemP = InsertLastInList (&(gImageSequenceItem [inFileNb]), theObjectP); /* if it is the first data set, store the pointer to it in group 41 */ if (first) { theWrkP = gArrMemFile [inFileNb]; theWrkP = theWrkP->next->next; /* locate group41 */ theGr41P = theWrkP->object->group; Papy3PutElement (theGr41P, papImageSequenceGr, &(gImageSequenceItem [inFileNb])); } /* if */ return theItemP; } /* endof Papy3CreateDataSet */ /********************************************************************************/ /* */ /* Papy3InsertItemToSequence : Create a new Object that will point to the */ /* given Item (a group or a module or whatever you liked). Then link the */ /* Object to the given sequence. */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3InsertItemToSequence (Module *inModuleP, int inElemNb, enum EKind_Obj inItemType, void *inItem, int inItemId) { Module *theElementP; Object *theObjectP; Item *theNewItemP, *theObjectListP; int first = FALSE; /* go to the element to add the item to */ theElementP = inModuleP + inElemNb; /* if there were no value, add one */ if (theElementP->nb_val == 0L) { theElementP->nb_val = 1L; /* allocate room for the value to be inserted */ theElementP->value = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); /* and initializes it to NULL */ theElementP->value->sq = NULL; /* creates the first part of the link */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papItem; theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->record = NULL; theObjectP->group = NULL; theObjectP->tmpFileLength = 0L; /* and link it to the sequence */ theObjectListP = InsertLastInList (&(theElementP->value->sq), theObjectP); first = TRUE; } /* if ...no value */ /* get the pointer to the list of objects */ theObjectListP = theElementP->value->sq->object->item; /* creates an empty object that will point to the item to insert */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = inItemType; theObjectP->objID = inItemId; theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->record = NULL; theObjectP->group = NULL; theObjectP->tmpFileLength = 0L; /* assign the item to the Object */ switch (inItemType) { case papItem : theObjectP->item = (Item *) inItem; break; case papGroup : theObjectP->group = (SElement *) inItem; break; case papModule : theObjectP->module = (Module *) inItem; break; case papRecord : theObjectP->record = (Record *) inItem; break; case papTmpFile: default : break; } /* switch */ /* insert the Object in the sequence */ theNewItemP = InsertLastInList (&(theObjectListP), theObjectP); if (first) theElementP->value->sq->object->item = theNewItemP; return 0; } /* endof Papy3InsertItemToSequence */ /********************************************************************************/ /* */ /* CreateIcon3 : Create the icon pixel data for the Icon Image module of */ /* the module currently being closed. */ /* Each pixel of the icon is computed as a subsampling of the original */ /* image. */ /* return : a pointer to the pixel data of the icon. */ /* */ /********************************************************************************/ PapyUShort * CreateIcon3 () { /* PapyUShort gRefColumns; width of original image */ /* PapyUShort gRefRows; height of original image */ /* PapyUShort gRefIsSigned; signed datas or no */ /* PapyUShort gRefBitsAllocated; depth of original image (8 or 16 bits) */ /* PapyUShort* gRefPixelData; original pixmap, char* for 8 bits images or short* for 16 bits images */ /* PapyUShort gIconSize; width of icon */ /* PapyUShort gIconSize; height of icon */ PapyUShort *theUSIconP; /* destination pixmap (16 bits)*/ PapyUChar *theUCIconP; /* ptr on the dest. pixmap (8 bits) */ PapyULong theLine, theRatio; PapyUShort i, j; int theMin, theMax; /* if there were no WW or WL saved in the file then assume default values */ if (gRefWW == -1 && gRefWW == gRefWL) { gRefWW = (int) (gRefPixMax - gRefPixMin + 1); gRefWL = (gRefWW / 2) + (int) gRefPixMin; } /* if */ /* avoids dividing by zero */ if (gRefWW == 0) gRefWW = 1; /* allocate the memory for the icon */ theUSIconP = (PapyUShort *) emalloc3 ((PapyULong) (gIconSize * gIconSize)); theUCIconP = (PapyUChar *) theUSIconP; /* computes the ratios between the image and the icon */ theRatio = (PapyULong) gRefColumns * (PapyULong) gRefRows / (PapyULong) gIconSize; /* 8 bits image */ if (gRefBitsAllocated == 8) { PapyUChar *thePixmapP; thePixmapP = (PapyUChar *) gRefPixelData; for (i = 0; i < gIconSize; i++) /* lines */ { theLine = (PapyULong) ((PapyULong)i * theRatio); theLine = (theLine / gRefColumns) * gRefColumns; /* must be an integer number of lines */ for (j = 0; j < gIconSize; j++, theUCIconP++) /* columns */ *theUCIconP = (PapyUChar) *(thePixmapP + (theLine + ((PapyULong) j * (PapyULong) gRefColumns / (PapyULong) gIconSize))); } /* for ...i */ } /* if ...8 bits image */ /* 12 or 16 bits image */ else { if (gRefIsSigned) { PapyShort *thePixmapP; PapyShort theValue; /* computes the min and max pixel values */ theMin = gRefWL - (gRefWW / 2); theMax = theMin + gRefWW; thePixmapP = (PapyShort *) gRefPixelData; for (i = 0; i < gIconSize; i++) /* lines */ { theLine = (PapyULong) ((PapyULong) i * theRatio); theLine = (theLine / gRefColumns) * gRefColumns; /* must be an integer number of lines */ for (j = 0; j < gIconSize; j++, theUCIconP++) /* columns */ { /* first get the subsampled pixel value */ theValue = (PapyShort) *(thePixmapP + (theLine + ((PapyULong) j * (PapyULong) gRefColumns / (PapyULong) gIconSize))); if (theValue < (PapyShort) theMin) theValue = (PapyShort) theMin; if (theValue > (PapyShort) theMax) theValue = (PapyShort) theMax; /* then convert it to an 8 bit value */ *theUCIconP = (PapyUChar) (((PapyShort) theValue - theMin) * 255 / (PapyShort) gRefWW); } /* for ...j */ } /* for ...i */ } /* if ...signed values */ else /* unsigned values */ { PapyUShort *thePixmapP; PapyUShort theValue; /* computes the min and max pixel values */ theMin = gRefWL - (gRefWW / 2); theMax = theMin + gRefWW; if (theMin < 0) theMin = 0; thePixmapP = (PapyUShort *) gRefPixelData; for (i = 0; i < gIconSize; i++) /* lines */ { theLine = (PapyULong) ((PapyULong) i * theRatio); theLine = (theLine / gRefColumns) * gRefColumns; /* must be an integer number of lines */ for (j = 0; j < gIconSize; j++, theUCIconP++) /* columns */ { /* first get the subsampled pixel value */ theValue = (PapyUShort) *(thePixmapP + (theLine + ((PapyULong) j * (PapyULong) gRefColumns / (PapyULong) gIconSize))); if (theValue < (PapyUShort) theMin) theValue = (PapyUShort) theMin; if (theValue > (PapyUShort) theMax) theValue = (PapyUShort) theMax; /* then convert it to an 8 bit value */ *theUCIconP = (PapyUChar) (((PapyUShort) theValue - theMin) * 255 / (PapyUShort) gRefWW); } /* for ...j */ } /* for ...i */ } /* else ...unsigned values */ } /* else ...12 or 16 bits image */ /* free the original image as we do not need it any more */ gRefPixelData = NULL; return theUSIconP; } /* endof CreateIcon3 */ /********************************************************************************/ /* */ /* CreatePointerSequence3 : Creates the pointer sequence for the given data*/ /* set of the given file. It will fill the Image Identification Module, */ /* the Icon Image Module, the Image Pointer Module and the Pixel Offset */ /* Module. */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort CreatePointerSequence3 (PapyShort inFileNb, Item *inDataSetP) { PapyShort thePosOfInsert, first; int theCreateIconImage = TRUE; PapyULong theULong; Item *theWrkItemP, *theSeqItemP; Object *theObjectP; Module *theModuleP; PapyUShort theUShort, *theIconP; char *theCharP, theChar [16]; /* -------- insert the item in the pointer sequence -------- */ /* Look for the position of the data set in the list in order */ /* to know where to insert the new item in the pointer sequence */ thePosOfInsert = 0; theWrkItemP = gImageSequenceItem [inFileNb]; /* loop until data set found */ while (theWrkItemP != inDataSetP) { thePosOfInsert++; theWrkItemP = theWrkItemP->next; } /* while */ /* if it is the first item of the Pointer Sequence ... */ if (gPtrSequenceItem [inFileNb] == NULL) first = TRUE; else first = FALSE; /* creates an empty object that will point to the list of modules */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papItem; theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->record = NULL; theObjectP->group = NULL; theObjectP->tmpFileLength = 0L; /* insert the item in the pointer sequence at the specified position */ theSeqItemP = InsertInListAt ((Item **) &gPtrSequenceItem [inFileNb], theObjectP, thePosOfInsert); /* if it is the first item of the pointer sequence, store the pointer to it in group 41 */ if (first) { theWrkItemP = gArrMemFile [inFileNb]; theWrkItemP = theWrkItemP->next; theWrkItemP = theWrkItemP->next; /* locate group41 */ Papy3PutElement (theWrkItemP->object->group, papPointerSequenceGr, &theSeqItemP); } /* if */ /* -------- create the Image Identification module -------- */ theModuleP = Papy3CreateModule (theSeqItemP, ImageIdentification); /* fill the elements of the Image Identification module */ Papy3PutElement (theModuleP, papReferencedImageSOPClassUIDII, &gRefSOPClassUID [inFileNb]); Papy3PutElement (theModuleP, papReferencedImageSOPInstanceUID, &gRefSOPInstanceUID); Papy3PutElement (theModuleP, papImageNumberII, &gRefImageNb); efree3 ((void **) &gRefImageNb); efree3 ((void **) &gRefSOPInstanceUID); /* -------- create the Icon Image module -------- */ /* in case of a Papyrus compressed image look if there is an icon to put */ if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL && (gArrCompression [inFileNb] == JPEG_LOSSLESS || gArrCompression [inFileNb] == JPEG_LOSSY #ifdef MAYO_WAVE || gArrCompression [inFileNb] == MAYO_WAVELET #endif ) && gArrIcons [inFileNb] [thePosOfInsert] == NULL) theCreateIconImage = FALSE; if (theCreateIconImage) { theModuleP = Papy3CreateModule (theSeqItemP, IconImage); /* fill the elements of the Icon Image module */ theUShort = 1; Papy3PutElement (theModuleP, papSamplesperPixelII, &theUShort); theCharP = (char *) &theChar [0]; strcpy (theCharP, "MONOCHROME2"); /* monochrome2 : 0 = black */ Papy3PutElement (theModuleP, papPhotometricInterpretationII, &theCharP); Papy3PutElement (theModuleP, papRowsII, &gIconSize); Papy3PutElement (theModuleP, papColumnsII, &gIconSize); theUShort = 8; /* the icon should be coded on 8 bits */ Papy3PutElement (theModuleP, papBitsAllocatedII, &theUShort); Papy3PutElement (theModuleP, papBitsStoredII, &theUShort); theUShort--; /* high bit should be one less than bits allocated */ Papy3PutElement (theModuleP, papHighBitII, &theUShort); theUShort = 0; /* this means pixel representation = PapyUShort */ Papy3PutElement (theModuleP, papPixelRepresentationII, &theUShort); /* take the icon image from the list */ if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL && (gArrCompression [inFileNb] == JPEG_LOSSLESS || gArrCompression [inFileNb] == JPEG_LOSSY #ifdef MAYO_WAVE || gArrCompression [inFileNb] == MAYO_WAVELET #endif )) { theIconP = (PapyUShort *) (gArrIcons [inFileNb] [thePosOfInsert]); Papy3PutImage (inFileNb, theModuleP, papPixelDataII, theIconP, gIconSize, gIconSize, 8, 0L); efree3 ((void **) &(gArrIcons [inFileNb] [thePosOfInsert])); } /* if ...take the icon from the list */ /* create the icon pixels from the image */ else { theIconP = CreateIcon3 (); Papy3PutImage (inFileNb, theModuleP, papPixelDataII, theIconP, gIconSize, gIconSize, 8, 0L); } /* else ...compute the icon from the original image */ } /* if ...creation of the icon image module */ /* -------- create the Image Pointer module -------- */ theModuleP = Papy3CreateModule (theSeqItemP, ImagePointer); /* the offset to the data set is zero relatively to the temp. file */ theULong = 0L; Papy3PutElement (theModuleP, papImagePointer, &theULong); /* -------- create the Pixel Offset module -------- */ theModuleP = Papy3CreateModule (theSeqItemP, PixelOffset); /* the offset to the pixel data in the tmp file */ Papy3PutElement (theModuleP, papPixelOffset, &theULong); return 0; } /* endof CreatePointerSequence3 */ /********************************************************************************/ /* */ /* Papy3LinkModuleToDS : Link the given module to the Data Set. */ /* */ /********************************************************************************/ void CALLINGCONV Papy3LinkModuleToDS (Item *inDataSetP, Module *inModuleP, int inModuleName) { Item *theItemP; Object *theObjectP; /* ------- link the created module to the list of modules of the data set ---- */ /* creation of the Object pointing to the module */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papModule; theObjectP->objID = inModuleName; /* link the module to the object */ theObjectP->module = inModuleP; theObjectP->record = NULL; theObjectP->item = NULL; theObjectP->group = NULL; theObjectP->file = NULL; theObjectP->tmpFileLength = 0L; /* insert the item at the end of the list of modules of the data set */ theItemP = InsertLastInList ((Item **) &(inDataSetP->object->item), theObjectP); } /* endof Papy3LinkModuleToDS */ /********************************************************************************/ /* */ /* Papy3LinkGroupToDS : Link the given group to the Data Set. */ /* */ /********************************************************************************/ void CALLINGCONV Papy3LinkGroupToDS (Item *inDataSetP, SElement *inGroupP, int inGroupName) { Item *theItemP; Object *theObjectP; /* ------- link the created group to the list of modules/groups of the data set ---- */ /* creation of the Object pointing to the group */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papGroup; theObjectP->objID = inGroupName; /* link the group to the object */ theObjectP->group = inGroupP; theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->file = NULL; theObjectP->tmpFileLength = 0L; /* insert the item at the end of the list of modules/groups of the data set */ theItemP = InsertLastInList ((Item **) &(inDataSetP->object->item), theObjectP); } /* endof Papy3LinkGroupToDS */ /********************************************************************************/ /* */ /* Papy3CreateModule : Create a new module and add it to the list of */ /* modules of the Data Set. */ /* return : a pointer to the created module */ /* NULL otherwise */ /* */ /********************************************************************************/ Module * CALLINGCONV Papy3CreateModule (Item *inDataSetP, int inModuleName) { Module *theModuleP; /* create the module a la Papy3GroupCreate */ theModuleP = CreateModule3 (inModuleName); /* link the module to the list of the data set */ Papy3LinkModuleToDS (inDataSetP, theModuleP, inModuleName); return theModuleP; } /* endof Papy3CreateModule */ /********************************************************************************/ /* */ /* Papy3FindModule : Finds the given module in the given data set of the */ /* given file (write). */ /* return : A pointer to the module or NULL if the module does not exist. */ /* */ /********************************************************************************/ Module * CALLINGCONV Papy3FindModule (Item *inDataSetP, int inModuleID) { Item *theWrkItemP; int found = FALSE; /* points to the first module of the list */ theWrkItemP = inDataSetP; if (theWrkItemP == NULL) return NULL; /* loop on the modules until it finds the right one */ while (!found && theWrkItemP->next != NULL) { if (theWrkItemP->object->objID == inModuleID) found = TRUE; else theWrkItemP = theWrkItemP->next; } /* while */ if (found) return theWrkItemP->object->module; else return NULL; } /* endof Papy3FindModule */ /********************************************************************************/ /* */ /* CheckDataSetModules3 : check the given data set to see if all the needed*/ /* modules have been filled. */ /* return : standard error message. */ /* */ /********************************************************************************/ PapyShort CheckDataSetModules3 (PapyShort inFileNb, Item *inDataSetP) { PapyShort i, theMaxLoop, found; Item *theWrkItemP; Data_Set *theWrkDSP; /* how many elements do we have to check ? */ switch (gFileModality [inFileNb]) { case CR_IM : theMaxLoop = gArrModuleNb [CR_IM]; break; case CT_IM : theMaxLoop = gArrModuleNb [CT_IM]; break; case MR_IM : theMaxLoop = gArrModuleNb [MR_IM]; break; case NM_IM : theMaxLoop = gArrModuleNb [NM_IM]; break; case US_IM : theMaxLoop = gArrModuleNb [US_IM]; break; case US_MF_IM : theMaxLoop = gArrModuleNb [US_MF_IM]; break; case SEC_CAPT_IM : theMaxLoop = gArrModuleNb [SEC_CAPT_IM]; break; case PX_IM : case DX_IM : theMaxLoop = gArrModuleNb [DX_IM]; break; case MG_IM : theMaxLoop = gArrModuleNb [MG_IM]; break; case IO_IM : theMaxLoop = gArrModuleNb [IO_IM]; break; case RF_IM : theMaxLoop = gArrModuleNb [RF_IM]; break; case PET_IM : theMaxLoop = gArrModuleNb [PET_IM]; break; case VLE_IM : theMaxLoop = gArrModuleNb [VLE_IM]; break; case VLM_IM : theMaxLoop = gArrModuleNb [VLM_IM]; break; case VLS_IM : theMaxLoop = gArrModuleNb [VLS_IM]; break; case VLP_IM : theMaxLoop = gArrModuleNb [VLP_IM]; break; case MFSBSC_IM : theMaxLoop = gArrModuleNb [MFSBSC_IM]; break; case MFGBSC_IM : theMaxLoop = gArrModuleNb [MFGBSC_IM]; break; case MFGWSC_IM : theMaxLoop = gArrModuleNb [MFGWSC_IM]; break; case MFTCSC_IM : theMaxLoop = gArrModuleNb [MFTCSC_IM]; break; } /* switch */ /* check the data set */ theWrkDSP = gArrModalities [gFileModality [inFileNb]]; for (i = 0; i < theMaxLoop; i++) { /* is the checked module mandatory ? */ if (theWrkDSP->usage == M) { /* look if this module is in the data set */ theWrkItemP = (Item *) inDataSetP->object->item; found = FALSE; while (theWrkItemP != NULL && !found) { if ((theWrkItemP->object != NULL) && (theWrkItemP->object->objID == theWrkDSP->moduleName) && (theWrkItemP->object->whoAmI == papModule)) found = TRUE; theWrkItemP = theWrkItemP->next; } /* while */ if (!found) RETURN (papMissingModule); } /* if ...we only check the mandatory modules */ /* incrementation */ theWrkDSP++; } /* for ...checking the data set */ return 0; } /* endof CheckDataSetModules3 */ /********************************************************************************/ /* */ /* CreatePatientSummary3 : Creates the general patient summary module for */ /* the given file. It takes the datas out of the Patient and the Patient */ /* Study modules. */ /* return : papNoError if no problem, standard error message otherwise. */ /* */ /********************************************************************************/ PapyShort CreatePatientSummary3 (PapyShort inFileNb) { int theElemType; Item *theFirstDataSetP; Module *theFromModuleP, *thePatSumModuleP; UValue_T *theValP; PapyULong theNbVal; /* search the first data set */ theFirstDataSetP = (Item *) gImageSequenceItem [inFileNb]->object->item; /* search for the Patient module */ theFromModuleP = Papy3FindModule (theFirstDataSetP, Patient); if (theFromModuleP == NULL) RETURN (papMissingModule); /* create the general patient summary module and add it to the list of summaries */ thePatSumModuleP = Papy3CreateModule (gPatientSummaryItem [inFileNb], GeneralPatientSummary); /* copy the elements from the Patient module to the Patient Summary module */ theValP = Papy3GetElement (theFromModuleP, papPatientsNameP, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatSumModuleP, papPatientsNameGPS, &(theValP->a)); theValP = Papy3GetElement (theFromModuleP, papPatientIDP, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatSumModuleP, papPatientsID, &(theValP->a)); theValP = Papy3GetElement (theFromModuleP, papPatientsBirthDateP, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatSumModuleP, papPatientsBirthDateGPS, &(theValP->a)); theValP = Papy3GetElement (theFromModuleP, papPatientsSexP, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatSumModuleP, papPatientsSexGPS, &(theValP->a)); /* search for the Patient Study module */ theFromModuleP = Papy3FindModule (theFirstDataSetP, PatientStudy); if (theFromModuleP == NULL) RETURN (papNoError); /* copy the elements from the Patient Study module to the Patient Summary module */ theValP = Papy3GetElement (theFromModuleP, papPatientsSizePS, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatSumModuleP, papPatientsHeight, &(theValP->a)); theValP = Papy3GetElement (theFromModuleP, papPatientsWeightPS, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatSumModuleP, papPatientsWeightGPS, &(theValP->a)); return 0; } /* endof CreatePatientSummary3 */ /********************************************************************************/ /* */ /* CreateStudySummary3 : Creates the general study summary module for */ /* the given file. It takes the datas out of the General Study module. */ /* return : papNoError if no problem, standard error message otherwise. */ /* */ /********************************************************************************/ PapyShort CreateStudySummary3 (PapyShort inFileNb) { int theElemType; Item *theFirstDataSetP; Module *theFromModuleP, *thePatStudyModuleP; UValue_T *theValP; PapyULong theNbVal; /* search the first data set */ theFirstDataSetP = (Item *) gImageSequenceItem [inFileNb]->object->item; /* search for the General Study module */ theFromModuleP = Papy3FindModule (theFirstDataSetP, GeneralStudy); if (theFromModuleP == NULL) RETURN (papMissingModule); /* create the general study summary module and add it to the list of summaries */ thePatStudyModuleP = Papy3CreateModule (gPatientSummaryItem [inFileNb], GeneralStudySummary); /* copy the elements to the General Patient Summary module */ theValP = Papy3GetElement (theFromModuleP, papStudyDateGS, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatStudyModuleP, papStudyDateGSS, &(theValP->a)); theValP = Papy3GetElement (theFromModuleP, papStudyTimeGS, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatStudyModuleP, papStudyTimeGSS, &(theValP->a)); theValP = Papy3GetElement (theFromModuleP, papStudyInstanceUIDGS, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatStudyModuleP, papStudyUID, &(theValP->a)); theValP = Papy3GetElement (theFromModuleP, papStudyIDGS, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatStudyModuleP, papStudyIDGSS, &(theValP->a)); theValP = Papy3GetElement (theFromModuleP, papAccessionNumberGS, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatStudyModuleP, papAccessionnumberGSS, &(theValP->a)); theValP = Papy3GetElement (theFromModuleP, papReferringPhysiciansNameGS, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatStudyModuleP, papReferringPhysiciansNameGSS, &(theValP->a)); return 0; } /* endof CreateStudySummary3 */ /********************************************************************************/ /* */ /* CreateSeriesSummary3 : Creates the general series summary module for the*/ /* given file. It takes the datas out of the General series module and the */ /* group 41. */ /* return : papNoError if no problem, standard error message otherwise. */ /* */ /********************************************************************************/ PapyShort CreateSeriesSummary3 (PapyShort inFileNb) { int theElemType; Item *theFirstDataSetP; Module *theFromModuleP, *thePatSeriesModuleP; UValue_T *theValP; PapyULong theNbVal; /* search the first data set */ theFirstDataSetP = (Item *) gImageSequenceItem [inFileNb]->object->item; /* search for the General Series module */ theFromModuleP = Papy3FindModule (theFirstDataSetP, GeneralSeries); if (theFromModuleP == NULL) RETURN (papMissingModule); /* create the general series summary module and add it to the list of summaries */ thePatSeriesModuleP = Papy3CreateModule (gPatientSummaryItem [inFileNb], GeneralSeriesSummary); /* copy the elements to the General Series Summary module */ theValP = Papy3GetElement (theFromModuleP, papModalityGS, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatSeriesModuleP, papModalityGSS, &(theValP->a)); theValP = Papy3GetElement (theFromModuleP, papSeriesInstanceUIDGS, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatSeriesModuleP, papSeriesInstanceUIDGSS, &(theValP->a)); theValP = Papy3GetElement (theFromModuleP, papSeriesNumberGS, &theNbVal, &theElemType); if (theValP != NULL) Papy3PutElement (thePatSeriesModuleP, papSeriesNumberGSS, &(theValP->a)); /* !! dont take number of images from group 41 as it will remain there when written */ return 0; } /* endof CreateSeriesSummary3 */ /********************************************************************************/ /* */ /* CreateSummaries3 : Creates the summaries modules for the given file. */ /* return : papNoError if no problem, standard error message otherwise. */ /* */ /********************************************************************************/ PapyShort CreateSummaries3 (PapyShort inFileNb) { PapyShort theErr; /* make the link to the memory representation of the file */ gPatientSummaryItem [inFileNb] = gArrMemFile [inFileNb]->next; /* creation of the summaries */ if ((theErr = CreatePatientSummary3 (inFileNb)) < 0) RETURN (theErr); if ((theErr = CreateStudySummary3 (inFileNb)) < 0) RETURN (theErr); if ((theErr = CreateSeriesSummary3 (inFileNb)) < 0) RETURN (theErr); RETURN (0); } /* endof CreateSummaries3 */ /********************************************************************************/ /* */ /* LookForGroupsInModule3 : Scan a module for its list of groups. Compares */ /* the found groups with the list of existing groups (if any) and build */ /* the list of groups to create or read (list that is returned). */ /* */ /********************************************************************************/ void LookForGroupsInModule3 (Module *inModuleP, int inModuleID, int *inDSGroupsTotP, int *inGrToCreateP) { int *theTmpCrP, *theTmpTotP, i; int theEnumGrNb; Module *theElemP; theElemP = inModuleP; theTmpCrP = inGrToCreateP; /* initialize the array of groups to create to empty */ for (i = 0; i < END_GROUP; i++) theTmpCrP [i] = 0; /* test to see wether there is a list of existing groups or not */ if (inDSGroupsTotP != NULL) { theTmpTotP = inDSGroupsTotP; for (i = 0; i < gArrModule [inModuleID]; i++) { theEnumGrNb = Papy3ToEnumGroup (theElemP->group); /* if this group is not already in the array put it in the to create list */ if (*(theTmpTotP + theEnumGrNb) == 0) { *(theTmpCrP + theEnumGrNb) = 1; *(theTmpTotP + theEnumGrNb) = 1; } /* if */ /* next element of the module */ theElemP++; } /* for ...loop on the elements of the module */ } /* if ...existing list of read groups */ else /* no list just add the groups found to the list */ { for (i = 0; i < gArrModule [inModuleID]; i++) { theEnumGrNb = Papy3ToEnumGroup (theElemP->group); /* put the group in the to read list */ if (theTmpCrP [theEnumGrNb] == 0) theTmpCrP [theEnumGrNb] = 1; /* next element of the module */ theElemP++; } /* for ...loop on the elements of the module */ } /* else */ } /* endof LookForGroupsInModule3 */ /********************************************************************************/ /* */ /* SequencesToGroups3 : Convert the list of items of the sequence to a list*/ /* of a list of groups. If the toDel param is set to TRUE, deletes the */ /* modules in the list too. */ /* return : papNoError if no problem, standard error message otherwise. */ /* */ /********************************************************************************/ PapyShort SequencesToGroups3 (PapyShort inFileNb, Item *inSequenceP, int inToDel) { Item *theWrkItemListP; PapyShort theErr; /* loop on the items of the sequence */ theWrkItemListP = inSequenceP; while (theWrkItemListP != NULL) { switch (theWrkItemListP->object->whoAmI) { case papModule: /* translate the content of the data set to a list of groups */ if ((theErr = ItemModulesToGroups3 (inFileNb, theWrkItemListP, inToDel)) < 0) RETURN (theErr); break; case papRecord: /* translate the content of the data set to a list of groups */ if ((theErr = ItemRecordsToGroups3 (inFileNb, theWrkItemListP, inToDel)) < 0) break; case papItem: /* if (theWrkItemListP->object->item != NULL) {*/ switch (theWrkItemListP->object->item->object->whoAmI) { case papRecord: /* translate the content of the data set to a list of groups */ if ((theErr = ItemRecordsToGroups3 (inFileNb, theWrkItemListP, inToDel)) < 0) break; default : SequencesToGroups3 (inFileNb, theWrkItemListP->object->item, inToDel); break; } /* switch ...theWrkItemListP->object->item->object->whoAmI */ /* }*/ break; default: break; } /* switch (theWrkItemListP->object->whoAmI) */ /* get next item of the sequence */ theWrkItemListP = theWrkItemListP->next; } /* while ...loop on the items of the sequence */ return 0; } /* endof SequencesToGroups3 */ /********************************************************************************/ /* */ /* KeepReferences3 : Keep some references to elements that will be needed */ /* by the modules of the pointer sequence. */ /* */ /********************************************************************************/ void KeepReferences3 (PapyShort inFileNb, int inModuleID, int inElementID, UValue_T *inValP) { switch (inModuleID) { case SOPCommon : if (inElementID == papSOPClassUID) /* it is the same SOP class UID for the whole file */ if (gRefSOPClassUID [inFileNb] == NULL) gRefSOPClassUID [inFileNb] = PapyStrDup (inValP->a); if (inElementID == papSOPInstanceUID) gRefSOPInstanceUID = PapyStrDup (inValP->a); break; case GeneralImage : /* papInstanceNumber was papImageNumberGI before */ if (inElementID == papInstanceNumberGI) gRefImageNb = PapyStrDup (inValP->a); break; case ImagePixel : switch (inElementID) { case papRows : gRefRows = inValP->us; break; case papColumns : gRefColumns = inValP->us; break; case papBitsAllocatedIP : gRefBitsAllocated = inValP->us; break; case papBitsStoredIP : gRefBitsStored = inValP->us; break; case papHighBitIP : gRefHighBit = inValP->us; break; case papPixelRepresentationIP : gRefIsSigned = inValP->us; break; case papSmallestImagePixelValue : gRefPixMin = inValP->us; break; case papLargestImagePixelValue : gRefPixMax = inValP->us; break; case papPixelData : gRefPixelData = inValP->ow; break; } /* switch ...elems of image pixel module */ break; case VOILUT : switch (inElementID) { case papWindowWidth : gRefWW = atoi (inValP->a); break; case papWindowCenter : gRefWL = atoi (inValP->a); break; } /* switch ...elems of VOILUT module */ break; } /* switch ...module ID */ } /* endof KeepReferences3 */ /********************************************************************************/ /* */ /* Papy3CheckDirectoryInformation : */ /* return : */ /* */ /********************************************************************************/ void Papy3CheckDirectoryInformation (Module *inModuleP) { PapyULong theLongValue; PapyUShort theShortValue; /* initialize */ theLongValue = 0L; theShortValue = 0; /* 0004:1200 */ Papy3PutElement (inModuleP, papOffsetofTheFirstDirectoryRecord, &theLongValue); /* 0004:1202 */ Papy3PutElement (inModuleP, papOffsetofTheLastDirectoryRecord, &theLongValue); /* 0004:1212 */ Papy3PutElement (inModuleP, papFilesetConsistencyFlag, &theShortValue); /* 0004:1220 */ /*Papy3PutElement (inModuleP, papDirectoryRecordSequence, &theLongValue);*/ } /* endof Papy3CheckDirectoryInformation */ /********************************************************************************/ /* */ /* ItemModulesToGroups3 : Convert the list of modules of the Item to */ /* a list of groups. If the toDel param is set to TRUE, deletes the */ /* modules too. */ /* return : papNoError if no problem, standard error message otherwise. */ /* */ /********************************************************************************/ PapyShort ItemModulesToGroups3 (PapyShort inFileNb, Item *ioDataSetP, int inToDel) { int *theDSGroupsTotP, *theGrToCreateP, *theTmpP; int i, theEnumGr, theEnumTag, found, theElemType; UValue_T *theValP, *theTmpValP; Module *theWrkModP; SElement *theGroupP; Object *theObjectP; Item *theWrkItemMP, *theGroupListP, *theWrkItemGP; PapyShort theErr, theNbOfModuleElem; PapyUShort theElemTag; PapyULong theNbVal, theLoop; /* initialize the lists of groups contained in the data set to empty */ theDSGroupsTotP = (int *) ecalloc3 ((PapyULong) END_GROUP, (PapyULong) sizeof (int)); theGrToCreateP = (int *) ecalloc3 ((PapyULong) END_GROUP, (PapyULong) sizeof (int)); for (i = 0, theTmpP = theDSGroupsTotP; i < END_GROUP; i++, theTmpP++) *theTmpP = 0; /* perform some pointer initialization */ theWrkItemMP = (Item *) ioDataSetP->object->item; /* points on the first module */ theGroupListP = NULL; /* make sure it is blank */ /* loop on the modules of the data set */ while (theWrkItemMP != NULL) { /* if it is a module */ if (theWrkItemMP->object->whoAmI == papModule) { /* Fill Directory Information module */ if (theWrkItemMP->object->objID == DirectoryInformation) Papy3CheckDirectoryInformation (theWrkItemMP->object->module); /* find the groups to create from the description of the module */ LookForGroupsInModule3 (theWrkItemMP->object->module, theWrkItemMP->object->objID, theDSGroupsTotP, theGrToCreateP); /* creation of the needed groups */ for (i = 0; i < END_GROUP; i++) { /* do we have to add the group to the list of groups of the data set */ if (*(theGrToCreateP + i) == 1) { /* creation of the group */ theGroupP = Papy3GroupCreate (i); /* creation of the object to point to the group */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papGroup; theObjectP->objID = i; theObjectP->group = theGroupP; /* link the group to the object */ theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->tmpFileLength = 0L; /* insert the object at its place in the list of groups of the data set */ theWrkItemGP = InsertGroupInList ((Item **) &theGroupListP, theObjectP); } /* if ...add the group to the list of groups of the data set */ } /* for ...loop on the array of groups */ /* copy the elements of the module to the groups */ theNbOfModuleElem = gArrModule [theWrkItemMP->object->objID]; for (i = 0; i < theNbOfModuleElem; i++) { /* get the element from the module */ theValP = Papy3GetElement (theWrkItemMP->object->module, i, &theNbVal, &theElemType); if (theValP != NULL) { /* Keep references to some elements to create the pointer sequence */ KeepReferences3 (inFileNb, theWrkItemMP->object->objID, i, theValP); /* extract the group number to put the element to */ theWrkModP = (Module *) (theWrkItemMP->object->module + i); theEnumGr = Papy3ToEnumGroup (theWrkModP->group); theElemTag = theWrkModP->element; /* locate the group to which to put the element in the group list */ found = FALSE; theWrkItemGP = theGroupListP; while (!found && theWrkItemGP != NULL) if (theWrkItemGP->object->objID == theEnumGr) found = TRUE; else theWrkItemGP = theWrkItemGP->next; /* locate the enum place of the element given its tag */ theGroupP = theWrkItemGP->object->group; found = FALSE; theEnumTag = 0; while (!found) if (theGroupP->element == theElemTag) found = TRUE; else { theEnumTag++; theGroupP++; } /* else */ /* put the value(s) to the group */ theTmpValP = theValP; for (theLoop = 0L; theLoop < theNbVal; theLoop++) { /* depending on the VR of the element put it to the group */ switch (theWrkModP->vr) { case SS : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->ss)); break; case USS : case AT : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->us)); break; case OB : Papy3PutImage (inFileNb, theWrkItemGP->object->group, theEnumTag, (PapyUShort *) theTmpValP->a, 0, 0, 8, theWrkModP->length); break; case OW : Papy3PutImage (inFileNb, theWrkItemGP->object->group, theEnumTag, theTmpValP->ow, 0, 0, 16, theWrkModP->length); break; case SL : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->sl)); break; case UL : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->ul)); break; case FL : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->fl)); break; case FD : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->fd)); break; case AE : case AS : case CS : case DA : case DS : case DT : case IS : case LO : case LT : case PN : case SH : case ST : case TM : case UI : case UT : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->a)); break; case UN : Papy3PutUnknown (theWrkItemGP->object->group, theEnumTag, theTmpValP->a, theWrkModP->length); break; case SQ : /* convert the list of items of the sequence to a list of groups */ if ((theErr = SequencesToGroups3 (inFileNb, theTmpValP->sq, inToDel)) < 0) RETURN (theErr); Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->sq)); break; } /* switch */ theTmpValP++; } /* for ...loop on the value(s) of an element */ } /* if ...theValP != NULL */ } /* for ...loop on the elements of the module */ } /* if ...it is a module */ /* if it is a group insert it at its place in the list */ /* nota : this is done to allow for UIN Overlays to be in the data set */ else if (theWrkItemMP->object->whoAmI == papGroup) { /* creation of the object to point to the group */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papGroup; theObjectP->objID = theWrkItemMP->object->objID; theObjectP->group = theWrkItemMP->object->group; /* link the group to the object */ theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->tmpFileLength = 0L; /* insert the object at its place in the list of groups of the data set */ theWrkItemGP = InsertGroupInList ((Item **) &theGroupListP, theObjectP); } /* else ...it is a group */ /* examine next module (or group) */ theWrkItemMP = theWrkItemMP->next; } /* while ...loop on the modules of the data set */ /* delete the lists of groups number of the data set */ efree3 ((void **) &theDSGroupsTotP); efree3 ((void **) &theGrToCreateP); /* deletes the list of modules and put the list of groups instead */ /* deletes the groups but not the sequences */ if ((theErr = DeleteList (inFileNb, (Papy_List **) &(ioDataSetP->object->item), inToDel, FALSE, FALSE)) < 0) RETURN (theErr); ioDataSetP->object->item = theGroupListP; return 0; } /* endof ItemModulesToGroups3 */ /********************************************************************************/ /* */ /* ItemRecordsToGroups3 : Convert the list of records of the Item to */ /* a list of groups. If the toDel param is set to TRUE, deletes the */ /* record too. */ /* return : papNoError if no problem, standard error message otherwise. */ /* */ /********************************************************************************/ PapyShort ItemRecordsToGroups3 (PapyShort inFileNb, Item *ioDataSetP, int inToDel) { int *theDSGroupsTotP, *theGrToCreateP, *theTmpP; int i, j, theEnumGr, theEnumTag, found, theElemType; UValue_T *theValP, *theTmpValP; SElement *theWrkModP; SElement *theGroupP; Object *theObjectP; Item *theWrkItemMP, *theGroupListP, *theWrkItemGP; PapyShort theErr, theNbOfRecordElem; PapyUShort theElemTag; PapyULong theNbVal, theLoop, theNbRecordGroups, theNbTotGroups; /* initialize the lists of groups contained in the data set to empty */ theDSGroupsTotP = (int *) ecalloc3 ((PapyULong) END_GROUP, (PapyULong) sizeof (int)); theGrToCreateP = (int *) ecalloc3 ((PapyULong) END_GROUP, (PapyULong) sizeof (int)); for (i = 0, theTmpP = theDSGroupsTotP; i < END_GROUP; i++, theTmpP++) *theTmpP = 0; /* perform some pointer initialization */ theWrkItemMP = (Item *) ioDataSetP->object->item; /* points on the first record */ theGroupListP = NULL; /* make sure it is blank */ /* count the number of groups for each records */ theNbRecordGroups = 0L; theNbTotGroups = 0L; /* loop on the records or groups of the data set */ while (theWrkItemMP != NULL) { /* get item which contain the record /* if it is a record */ if (theWrkItemMP->object->whoAmI == papRecord) { theNbRecordGroups = 0; /* find the groups to create from the description of the record */ LookForGroupsInRecord3 (theWrkItemMP->object->record, theWrkItemMP->object->objID, theGrToCreateP); /* creation of the needed groups */ for (i = 0; i < END_GROUP; i++) { /* do we have to add the group to the list of groups of the data set */ if (*(theGrToCreateP + i) == 1) { /* creation of the group */ theGroupP = Papy3GroupCreate (i); /* creation of the object to point to the group */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papGroup; theObjectP->objID = i; theObjectP->group = theGroupP; /* link the group to the object */ theObjectP->item = NULL; theObjectP->record = NULL; theObjectP->module = NULL; theObjectP->tmpFileLength = 0L; /* insert the object at its place in the list of groups of the data set */ theWrkItemGP = InsertLastInList ((Item **) &theGroupListP, theObjectP); /* only useful for records sequence */ theNbRecordGroups++; } /* if ...add the group to the list of groups of the data set */ } /* for ...loop on the array of groups */ /* copy the elements of the record to the groups */ theNbOfRecordElem = gArrRecord [theWrkItemMP->object->objID]; for (i = 0; i < theNbOfRecordElem; i++) { /* get the element from the record */ theValP = Papy3GetElement (theWrkItemMP->object->record, i, &theNbVal, &theElemType); if (theValP != NULL) { /* Keep references to some elements to create the pointer sequence */ KeepReferences3 (inFileNb, theWrkItemMP->object->objID, i, theValP); /* extract the group number to put the element to */ theWrkModP = (SElement *) (theWrkItemMP->object->record + i); theEnumGr = Papy3ToEnumGroup (theWrkModP->group); theElemTag = theWrkModP->element; /* locate the group to which to put the element in the group list */ found = FALSE; theWrkItemGP = theGroupListP; /* found the just created groups */ for (j = 0; j < (int) theNbTotGroups; j++) theWrkItemGP = theWrkItemGP->next; while (!found && theWrkItemGP != NULL) if (theWrkItemGP->object->objID == theEnumGr) found = TRUE; else theWrkItemGP = theWrkItemGP->next; /* locate the enum place of the element given its tag */ theGroupP = theWrkItemGP->object->group; found = FALSE; theEnumTag = 0; while (!found) if (theGroupP->element == theElemTag) found = TRUE; else { theEnumTag++; theGroupP++; } /* else */ /* put the value(s) to the group */ theTmpValP = theValP; for (theLoop = 0L; theLoop < theNbVal; theLoop++) { /* depending on the VR of the element put it to the group */ switch (theWrkModP->vr) { case SS : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->ss)); break; case USS : case AT : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->us)); break; case OB : Papy3PutImage (inFileNb, theWrkItemGP->object->group, theEnumTag, (PapyUShort *) theTmpValP->a, 0, 0, 8, theWrkModP->length); break; case OW : Papy3PutImage (inFileNb, theWrkItemGP->object->group, theEnumTag, theTmpValP->ow, 0, 0, 16, theWrkModP->length); break; case SL : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->sl)); break; case UL : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->ul)); break; case FL : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->fl)); break; case FD : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->fd)); break; case AE : case AS : case CS : case DA : case DS : case DT : case IS : case LO : case LT : case PN : case SH : case ST : case TM : case UI : Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->a)); break; case SQ : /* convert the list of items of the sequence to a list of groups */ if ((theErr = SequencesToGroups3 (inFileNb, theTmpValP->sq, inToDel)) < 0) RETURN (theErr); Papy3PutElement (theWrkItemGP->object->group, theEnumTag, &(theTmpValP->sq)); break; } /* switch */ theTmpValP++; } /* for ...loop on the value(s) of an element */ } /* if ...theValP != NULL */ } /* for ...loop on the elements of the module */ } /* if ...it is a record */ /* if it is a group insert it at its place in the list */ else if (theWrkItemMP->object->whoAmI == papGroup) { /* creation of the object to point to the group */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papGroup; theObjectP->objID = theWrkItemMP->object->objID; theObjectP->group = theWrkItemMP->object->group;/* link the group to the object */ theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->record = NULL; theObjectP->tmpFileLength = 0L; /* insert the object at its place in the list of groups of the data set */ theWrkItemGP = InsertGroupInList ((Item **) &theGroupListP, theObjectP); } /* else ...it is a group */ /* only useful for record sequence */ theNbTotGroups += theNbRecordGroups; /* examine next record */ theWrkItemMP = theWrkItemMP->next; } /* while ...loop on the modules of the data set */ /* delete the lists of groups number of the data set */ efree3 ((void **) &theDSGroupsTotP); efree3 ((void **) &theGrToCreateP); /* deletes the list of records and put the list of groups instead */ /* deletes the groups but not the sequences */ if ((theErr = DeleteList (inFileNb, (Papy_List **) &(ioDataSetP->object->item), inToDel, FALSE, FALSE)) < 0) RETURN (theErr); ioDataSetP->object->item = theGroupListP; return 0; } /* endof ItemRecordsToGroups3 */ /********************************************************************************/ /* */ /* CreateTmpFile3 : Creates and open a temporary file to store the groups */ /* of a data set. */ /* return : a pointer to an object containing the tmp file, NULL otherwise */ /* */ /********************************************************************************/ PapyShort CreateTmpFile3 (PapyShort inFileNb, PAPY_FILE *ioFpP, void **ioVoidP) { char *theFilenameP, theChar [256], theOtherStr [10]; int theLength; PapyShort theErr; /* create the name of the temporary file */ /* i.e. takes the name of the file and concatenate an incremental number */ theFilenameP = (char *) &theChar [0]; strcpy (theFilenameP, gPapFilename [inFileNb]); /* DICOM file case & first image of the data set*/ if ((gIsPapyFile [inFileNb] == DICOM10 || gIsPapyFile [inFileNb] == DICOM_NOT10) && gCurrTmpFilename [inFileNb] == 1) { /* try to open the file */ theErr = Papy3FOpen (theFilenameP, 'w', (PAPY_FILE) 0, ioFpP, ioVoidP); switch (theErr) { case -49: /* file was already open in write mode */ /* in this case the file pointer is simply the original one ... */ *ioFpP = gPapyFile [inFileNb]; case 0: /* was able to open the file in write mode */ /* increment this to ensure uniqueness of temporary files */ gCurrTmpFilename [inFileNb]++; /* remove the "0001.dcm" string from the filename if present */ theLength = (int) strlen (theFilenameP); if (theFilenameP [theLength - 8] == '0' && theFilenameP [theLength - 7] == '0' && theFilenameP [theLength - 6] == '0' && theFilenameP [theLength - 5] == '1' && theFilenameP [theLength - 4] == '.' && theFilenameP [theLength - 3] == 'd' && theFilenameP [theLength - 2] == 'c' && theFilenameP [theLength - 1] == 'm') { theFilenameP [theLength - 8] = '\0'; strcpy (gPapFilename [inFileNb], theFilenameP); } /* if ...string ends by "0001.dcm" */ /* makes sure the file pointer is set correctly */ gPapyFile [inFileNb] = *ioFpP; /* then exits successfully the function */ return 0; break; default: /* file does not exist */ break; } /* switch */ } /* if ... DICOM file */ /* append the incremental number to the filename */ Papy3FPrint (theOtherStr, "%d", gCurrTmpFilename [inFileNb]); strcat (theOtherStr, ".dcm"); strcat (theOtherStr, "\0"); if (gCurrTmpFilename [inFileNb] < 10) strcat (theFilenameP, "000"); else if (gCurrTmpFilename [inFileNb] < 100) strcat (theFilenameP, "00"); else if (gCurrTmpFilename [inFileNb] < 1000) strcat (theFilenameP, "0"); strcat (theFilenameP, theOtherStr); /* increment the number to ensure uniqueness of tmp filenames */ gCurrTmpFilename [inFileNb]++; /* creation of the temporary file */ while (Papy3FCreate (theFilenameP, (PAPY_FILE) -1, ioFpP, ioVoidP) < 0 && gCurrTmpFilename [inFileNb] < kMax_tmp_file) { /* free the memory if some was allocated */ /*if (*ioVoidP != NULL) efree3 ((void **) ioVoidP);*/ /* re-create the name of the temporary file */ Papy3FPrint (theOtherStr, "%d", gCurrTmpFilename [inFileNb]); strcat (theOtherStr, ".dcm"); strcat (theOtherStr, "\0"); strcpy (theFilenameP, gPapFilename [inFileNb]); if (gCurrTmpFilename [inFileNb] < 10) strcat (theFilenameP, "000"); else if (gCurrTmpFilename [inFileNb] < 100) strcat (theFilenameP, "00"); else if (gCurrTmpFilename [inFileNb] < 1000) strcat (theFilenameP, "0"); strcat (theFilenameP, theOtherStr); /* re-increment the number to ensure uniqueness of tmp filenames */ gCurrTmpFilename [inFileNb]++; } /* while ...looking for a temp file to create */ /* the file creation failed */ if (gCurrTmpFilename [inFileNb] == kMax_tmp_file) { /*if (*ioVoidP != NULL) efree3 ((void **) ioVoidP); */ RETURN (papFileCreationFailed); } /* if ...file creation failed */ /* open the created tmp file */ if (Papy3FOpen (theFilenameP, 'w', (PAPY_FILE) 0, ioFpP, ioVoidP) < 0) { /*if (*ioVoidP != NULL) efree3 ((void **) ioVoidP);*/ RETURN (papFileCreationFailed); } /* if ...opening the file failed */ /* this is to mark the DICOM file as being in use for the skeleton */ if ((gIsPapyFile [inFileNb] == DICOM10 || gIsPapyFile [inFileNb] == DICOM_NOT10) && gPapyFile [inFileNb] == 0) gPapyFile [inFileNb] = *ioFpP; return 0; } /* endof CreateTmpFile3 */ /********************************************************************************/ /* */ /* WriteDicomHeader3 : Writes the DICOM header at the begining of the tmp */ /* file (i.e. 128 bytes set to blank followed by the DICM string) as well */ /* as the group 0x0002 which contains the file meta information */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort WriteDicomHeader3 (PAPY_FILE inFp, PapyShort inFileNb, PapyULong *outMetaInfoSizeP) { PapyShort theErr = 0; PapyULong theNumberOfBytes; char theBuff [128]; int i; /* set 128 bytes to blank */ for (i = 0; i < 128; i++) theBuff [i] = 0; theNumberOfBytes = 128L; /* write them to the file */ if (Papy3FWrite (inFp, (PapyULong *) &theNumberOfBytes, 1, theBuff) < 0) { Papy3FClose (&inFp); RETURN (papWriteFile) } /* if */ /* then put the DICM string that identifies the file as a DICOM one */ strcpy (theBuff, "DICM"); theNumberOfBytes = 4L; /* write the string to the file */ if (Papy3FWrite (inFp, (PapyULong *) &theNumberOfBytes, 1, theBuff) < 0) { Papy3FClose (&inFp); RETURN (papWriteFile) } /* if */ /* creation and writting of the file meta information (i.e. group 0x0002) */ theErr = CreateDicomFileMetaInformation3 (inFp, inFileNb, gArrCompression [inFileNb], gArrTransfSyntax [inFileNb], (enum EModality) gFileModality [inFileNb], outMetaInfoSizeP); return theErr; } /* endof WriteDicomHeader3 */ /********************************************************************************/ /* */ /* WriteTmpFile3 : Creates a temporary file to store the groups of a given */ /* data set. It will save as well some relativ positions in the file. */ /* return : papNoError if no problem, standard error message otherwise. */ /* */ /********************************************************************************/ PapyShort WriteTmpFile3 (PapyShort inFileNb, Item *ioDataSetP, int inToDel) { int theGroupNb; PapyShort theErr, theImNb; PAPY_FILE theFp; PapyULong theBufSize, theMetaInfoSize, thePos, theTmpUL; unsigned char *theBuffP; Item *theWrkItemP; void *theVoidP; theVoidP = NULL; theMetaInfoSize = 0L; theFp = NULLFILE; /* create the temporary file that will contain the given data set */ if ((theErr = CreateTmpFile3 (inFileNb, &theFp, &theVoidP)) < 0) RETURN (papFileCreationFailed); /* if the file is a DICOM one, then put the DICOM header to the temp file */ /* in order to get a real DICOM file part 10 compliant */ if (gIsPapyFile [inFileNb] == DICOM10) theErr = WriteDicomHeader3 (theFp, inFileNb, &theMetaInfoSize); /* find the place of the data set in the list of data sets */ theImNb = 0; theWrkItemP = gImageSequenceItem [inFileNb]; while (theWrkItemP != ioDataSetP && theWrkItemP != NULL) { theImNb++; theWrkItemP = theWrkItemP->next; } /* while ...loop on the data sets */ /* initialisation */ gCurrentOverlay [inFileNb] = 0x6000; gCurrentUINOverlay [inFileNb] = 0x6001; /* take a pointer to the first group of the data set */ theWrkItemP = (Item *) ioDataSetP->object->item; /* loop on the groups of the data set */ while (theWrkItemP != NULL) { if ((theGroupNb = Papy3ToEnumGroup (theWrkItemP->object->group->group)) < 0) RETURN (papGroupNumber); /* compute the size of the current group */ ComputeGroupLength3 ((PapyShort) theGroupNb, theWrkItemP->object->group, NULL, gArrTransfSyntax [inFileNb]); theBufSize = theWrkItemP->object->group->value->ul + kLength_length; /* alloc the buffer that will contain the ready to write group */ theBuffP = (unsigned char *) emalloc3 ((PapyULong) theBufSize); thePos = 0L; /* put the elements of the group to the write buffer */ if ((theErr = PutGroupInBuffer (inFileNb, theImNb, theGroupNb, theWrkItemP->object->group, theBuffP, &thePos, FALSE)) < 0) RETURN (theErr); /* add the offsets to the data set to the offset to the group */ if (theWrkItemP->object->group->group == 0x7FE0) { Papy3FTell (theFp, (PapyLong *) &theTmpUL); *(gRefPixelOffset [inFileNb] + theImNb) += theTmpUL; } /* if */ /* write the buffer to the temporary file */ if ((theErr = WriteGroup3 (theFp, theBuffP, theBufSize)) < 0) RETURN (theErr); /* frees the allocated buffer */ efree3 ((void **) &theBuffP); /* get next item */ theWrkItemP = theWrkItemP->next; } /* while ...loop on the groups of the data set */ /* deletes the list of groups of the data set and put the tmp file instead */ if ((theErr = DeleteList (inFileNb, (Papy_List **) &(ioDataSetP->object->item), inToDel, TRUE, TRUE)) < 0) RETURN (theErr); ioDataSetP->object->whoAmI = papTmpFile; ioDataSetP->object->objID = gCurrTmpFilename [inFileNb] - 1; ioDataSetP->object->file = theVoidP; /* stores the length of the tmp file */ if (Papy3FSeek (theFp, (int) SEEK_END, (PapyLong) 0L) != 0) RETURN (papPositioning); Papy3FTell (theFp, (PapyLong *) &(ioDataSetP->object->tmpFileLength)); /* close the temporary file */ Papy3FClose (&theFp); return 0; } /* endof WriteTmpFile3 */ /********************************************************************************/ /* */ /* Papy3CloseDataSet : Close the given data set. If it is the first data */ /* set to be closed, it builds the summaries modules from the data set.It */ /* translates the modules into a group representation, frees the modules */ /* if the toDel param is set to TRUE. Then it saves the list of groups on */ /* a temporary file that is ready to be copied in the definitiv Papyrus */ /* file. */ /* return : papNoError if no problem, standard error message otherwise. */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3CloseDataSet (PapyShort inFileNb, Item *inDataSetP, int inToDel, int inPerformCheck) { PapyShort theErr; /* introduce some odd value to be tested */ gRefPixMin = 0; gRefPixMax = 0; gRefWW = -1; gRefWL = -1; /* check if all the needed modules have been filled only if specified */ if (inPerformCheck) if ((theErr = CheckDataSetModules3 (inFileNb, inDataSetP)) < 0) RETURN (theErr); /* perform the following task only if it is a PAPYRUS file */ if (gIsPapyFile [inFileNb] == PAPYRUS3) { /* if it is the first data set to be saved, create the summaries modules */ if (gPatientSummaryItem [inFileNb] == NULL) if ((theErr = CreateSummaries3 (inFileNb)) < 0) RETURN (theErr); } /* if ...it is a PAPYRUS file */ /* convert the module representation to the group representation */ if ((theErr = ItemModulesToGroups3 (inFileNb, inDataSetP, inToDel)) < 0) RETURN (theErr); /* perform the following task only if it is a PAPYRUS file */ if (gIsPapyFile [inFileNb] == PAPYRUS3) { /* creation of the pointer sequence for this data set */ theErr = CreatePointerSequence3 (inFileNb, inDataSetP); } /* if ...it is a PAPYRUS file */ /* write the data set to a temporary file */ if ((theErr = WriteTmpFile3 (inFileNb, inDataSetP, inToDel)) < 0) RETURN (theErr); RETURN (theErr); } /* endof Papy3CloseDataSet */ Papyrus3/PapyWrite3.c0000755000175000017500000020631410044175576011721 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyWrite3.c */ /* Function : contains all the writing stuff */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 04.1991 version 1.1 */ /* 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifdef Mac #pragma segment papy3 #endif /* ------------------------- includes -----------------------------------------*/ #include #include #include /* open */ #ifndef Papyrus3H #include "Papyrus3.h" #endif #include "jpegless.h" /* interface for JPEG lossless decompressor */ #include "jpeglib.h" /* interface for JPEG lossy decompressor */ #ifdef MAYO_WAVE #include "Mayo.h" /* interface for MAYO/SPIHT wavelet compression */ #define TO_SWAP_MAYO #endif /********************************************************************************/ /* */ /* Put2Bytes : puts a 2-Bytes value (USS, SS or AT) in the write buffer. */ /* */ /********************************************************************************/ void Put2Bytes (PapyUShort inS, unsigned char *ioBufP, PapyULong *ioPosP) /*unsigned short inS; the value to put */ /*unsigned char *ioBufP; the buffer to write to */ /*unsigned long *ioPosP; the current position in the buffer */ { PapyUChar *theCharP; theCharP = ioBufP; theCharP += *ioPosP; *ioPosP += 2; /* put the element according to the little-endian transfert syntax */ *theCharP = (unsigned char) inS; *(theCharP + 1) = (unsigned char) (inS >> 8); } /* endof Put2Bytes */ /********************************************************************************/ /* */ /* Put4Bytes : puts a 4-Byte value (UL, SL or FL) in the write buffer. */ /* */ /********************************************************************************/ void Put4Bytes (PapyULong inLong, unsigned char *ioBufP, PapyULong *ioPosP) /*PapyULong inLong; the value to put */ /*unsigned char *ioBufP; the buffer to write to */ /*PapyULong *ioPosP; the current position in the buffer */ { PapyUChar *theCharP; theCharP = ioBufP; theCharP += *ioPosP; *ioPosP += 4; /* put the element according to the little endian syntax */ *theCharP = (unsigned char) inLong; *(theCharP + 1) = (unsigned char) (inLong >> 8); *(theCharP + 2) = (unsigned char) (inLong >> 16); *(theCharP + 3) = (unsigned char) (inLong >> 24); } /* endof Put4Bytes */ /********************************************************************************/ /* */ /* Put8Bytes : puts a 8-Byte value (FD) in the write buffer. */ /* */ /********************************************************************************/ void Put8Bytes (PapyFloatDouble inFlDbl, unsigned char *ioBufP, PapyULong *ioPosP) /*PapyFloatDouble inFlDbl; the value to put */ /*unsigned char *ioBufP; the buffer to write to */ /*PapyULong *ioPosP; the current position in the buffer */ { unsigned char *theCharDoubleP; PapyUChar *theCharP; PapyShort i; theCharDoubleP = (unsigned char *) &inFlDbl; theCharP = ioBufP; theCharP += *ioPosP; *ioPosP += 8; /* loop on the bytes of the float double to code it */ for (i = 0; i < 4; i++) { *theCharP = * theCharDoubleP; *(theCharP + 1) = *(theCharDoubleP + 1); theCharP += 2; theCharDoubleP += 2; } /* for */ } /* endof Put8Bytes */ /********************************************************************************/ /* */ /* PutString : puts a string in the write buffer */ /* */ /********************************************************************************/ void PutString (char *inCharP, enum EV_R_T inVR, unsigned char *ioBufP, PapyULong *ioPosP) /*char *inCharP; the value to put */ /*enum EV_R_T inVR; is it an ASCII text or an ASCII numeric ? */ /*unsigned char *ioBufP; the buffer to write to */ /*PapyULong *ioPosP; the current position in the buffer */ { int theSize, i, theHasNull = FALSE; PapyChar *theChP, *theCP, *theDupP; theSize = (int) strlen (inCharP); /* duplicate the string */ theChP = (char *) ecalloc3 ((PapyULong) (theSize + 2), (PapyULong) sizeof (char)); theChP = strcpy (theChP, inCharP); /* if the string has not an even length it must be padded ... */ if ((theSize % 2) != 0) /* ...either with a NULL char ... */ if (inVR == UI) { theChP [theSize] = 0x00; strcat (theChP, "\0"); theHasNull = TRUE; } /* ... or with a single SPACE */ else theChP = strcat (theChP, " "); /* put the char in the order of occurence (left to right) */ theCP = theChP; theDupP = (PapyChar *) ioBufP; theDupP += *ioPosP; for (i = 0; i < (int) strlen (theChP); i++, theCP++, theDupP++) *theDupP = *theCP; (*ioPosP) += (PapyULong) strlen (theChP); /* case of an odd UI string. Necessary as the NULL char is never taken into acount */ if (theHasNull) { (*ioPosP) ++; *theDupP = 0x00; } /* free the allocated string */ efree3 ((void **) &theChP); } /* endof PutString */ /********************************************************************************/ /* */ /* Put1ByteImage : puts a 1-Bytes image (OB) in the write buffer. */ /* */ /********************************************************************************/ void Put1ByteImage (char *inImP, unsigned char *ioBufP, PapyULong *ioPosP, PapyULong inSize) /*char *inImP; pointer to the image */ /*unsigned char *ioBufP; the buffer to write to */ /*PapyULong *ioPosP; the current position in the buffer */ /*PapyULong inSize; the size of the element to put */ { PapyUChar *theUCharSP; PapyUChar *theUCharBP; PapyULong i; /* position the pointer to its position in the destination buffer */ theUCharBP = ioBufP; theUCharBP += (*ioPosP); /* initialize the pointer to the image to copy */ theUCharSP = (PapyUChar *) inImP; /* copy the elements to the buffer */ for (i = 0L; i < inSize; i++, theUCharBP++, theUCharSP++) *theUCharBP = *theUCharSP; /* move the pointer to the current position in the buffer */ *ioPosP += inSize; } /* endof Put1ByteImage */ /********************************************************************************/ /* */ /* Put2BytesImage : puts a 2-Bytes image (OW) in the write buffer. */ /* */ /********************************************************************************/ void Put2BytesImage (PapyUShort *inImP, PapyUChar *ioBufP, PapyULong *ioPosP, PapyULong inSize) /*PapyUShort *inImP; pointer to the image */ /*unsigned char *ioBufP; the buffer to write to */ /*PapyULong *ioPosP; the current position in the buffer */ /*PapyULong inSize; the size in bytes of the element to put */ { PapyUShort *theUShortP; PapyULong theNbOfShort, i; PapyUChar *theUCharP; /* position the pointer to its position in the destination buffer */ theUCharP = ioBufP; theUCharP += *ioPosP; /* copy the elements to the buffer */ theNbOfShort = inSize / 2; for (i = 0L, theUShortP = inImP; i < theNbOfShort; theUShortP++, i++) { *theUCharP = (unsigned char) *theUShortP; *(theUCharP + 1) = (unsigned char) ((*theUShortP) >> 8); /* increment */ theUCharP += 2; } /* for */ /* move the pointer to the current position in the buffer */ *ioPosP += inSize; } /* endof Put2BytesImage */ /********************************************************************************/ /* */ /* PutValue : puts a value in the write buffer */ /* */ /********************************************************************************/ void PutValue (UValue_T *inValP, enum EV_R_T inVR, unsigned char *ioBufP, PapyULong *ioPosP) /*UValue_T *inValP; the value to put */ /*enum EV_R_T inVR; ASCII text or ASCII numeric ? */ /*unsigned char *ioBufP; the buffer to write to */ /*PapyULong *ioPosP; the position in the write buffer */ { switch (inVR) { case SS : Put2Bytes (inValP->ss, ioBufP, ioPosP); break; case USS : case AT : Put2Bytes (inValP->us, ioBufP, ioPosP); break; case SL : Put4Bytes (inValP->sl, ioBufP, ioPosP); break; case UL : Put4Bytes (inValP->ul, ioBufP, ioPosP); break; case FL : Put4Bytes ((PapyULong) inValP->fl, ioBufP, ioPosP); break; case FD : Put8Bytes (inValP->fd, ioBufP, ioPosP); break; case AE : case AS : case CS : case DA : case DS : case DT : case IS : case LO : case LT : case PN : case SH : case ST : case TM : case UI : case UT : PutString (inValP->a, inVR, ioBufP, ioPosP); break; case SQ : break; default : /* values of type OB & OW must be put using Put1/2Byte(s)Image */ break; } /* switch ...value representation */ } /* endof PutValue */ /********************************************************************************/ /* */ /* Write_File : , */ /* */ /* return : return 0 if no problem */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort WriteFile (j_compress_ptr inCinfo, PapyULong inDataCount, PAPY_FILE inFp, PapyUChar *outJpegDP, int inSaveJpeg) { my_dest_ptr dest = (my_dest_ptr) inCinfo->dest; inFp = inFp; /* no comment */ if (inSaveJpeg) if (Papy3FWrite (inFp, (PapyULong *) &inDataCount, 1L, (void *) dest->buffer) != 0) return (-1); memcpy (outJpegDP, dest->buffer, inDataCount); return (1); } /* endof WriteFile */ /********************************************************************************/ /* */ /* JPEGLossyEncodeImage : */ /* */ /* return : return 0 if no problem */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort JPEGLossyEncodeImage (PapyShort inFileNb, int inQuality, PapyUChar *outJpegFilename, PapyUChar *inImageBuffP, PapyUChar **outJPEGDataP, PapyULong *outJPEGsizeP,int inImageHeight, int inImageWidth, int inDepth, int inSaveJpeg) { struct jpeg_compress_struct theCInfo; struct jpeg_error_mgr theJerr; PAPY_FILE theFp = NULL; /* #ifdef SAVE_JPEG */ void *theFSSpecP; PAPY_FILE theVRefNum; char theFilename [512]; /* #endif */ JSAMPROW theRowPointer [1]; /* pointer to JSAMPLE row[s] */ int theRowStride; /* physical row width in image buffer */ unsigned int j; PapyULong theDataCount; PapyUChar *theJPEGBuffP; PapyUShort *theImBuffP; /* Temporary routine for Compression evaluation (DAB) */ #ifdef SAVE_RAW PAPY_FILE theFps; void *theFSSpecsP; PAPY_FILE theVRefNums; char theFilenames [20]; long theSizer; PapyUChar *theValTempP, *theFinalValP, *theFinaleValP; PapyUChar theHigh, theLow; int is, js; strcpy((char *) theFilenames, "data.raw"); theFSSpecsP = NULL; theValTempP = (PapyUChar *) inImageBuffP; theFinalValP = (PapyUChar *) inImageBuffP; theFinaleValP = (PapyUChar *) inImageBuffP; #ifdef TO_SWAP if (inDepth == 16) { for (js = 0; js < inImageHeight; js++) { for (is = 0; is < inImageWidth; is++) { theLow = *theValTempP; theValTempP++; theHigh = *theValTempP; theValTempP++; *theFinalValP = theHigh; theFinalValP++; *theFinalValP = theLow; theFinalValP++; } /* for ...is */ } /* for ...js */ } /* if ... depth = 16 */ #endif /* TO_SWAP */ if (Papy3FCreate ((char *) theFilenames, theVRefNums, &theFps, &theFSSpecsP) != 0) RETURN (papFileCreationFailed); if (Papy3FOpen ((char *) theFilenames, 'w', theVRefNums, &theFps, &theFSSpecsP) != 0) RETURN (papOpenFile); if (inDepth == 16) theSizer = (long) (inImageWidth * inImageHeight * 2); else theSizer = (long) (inImageWidth * inImageHeight); if (Papy3FWrite (theFps, (PapyULong *) &theSizer, 1L, (void *) theFinaleValP) != 0) RETURN (papWriteFile); Papy3FClose (&theFps); #endif /* SAVE_RAW */ /* Step 1: allocate and initialize JPEG compression object */ theCInfo.err = jpeg_std_error (&theJerr); jpeg_create_compress (&theCInfo); /* Step 2: specify data destination (eg, a file) */ /* #ifdef SAVE_JPEG */ if (inSaveJpeg) { if (outJpegFilename == NULL) strcpy ((char *) theFilename, "data.jpeg"); else strcpy ((char *) theFilename, (const char *) outJpegFilename); theFSSpecP = NULL; if (Papy3FCreate ((char *) theFilename, theVRefNum, &theFp, &theFSSpecP) != 0) RETURN (papFileCreationFailed); if (Papy3FOpen ((char *) theFilename, 'w', theVRefNum, &theFp, &theFSSpecP) != 0) RETURN (papOpenFile); } /* endif */ /* #endif */ jpeg_stdio_dest ((j_compress_ptr) &theCInfo, (PAPY_FILE *) &theFp); /* Step 3: set parameters for compression */ theCInfo.image_width = inImageWidth; /* image width and height, in pixels */ theCInfo.image_height = inImageHeight; if (gArrPhotoInterpret [inFileNb] == MONOCHROME1 || gArrPhotoInterpret [inFileNb] == MONOCHROME2) { theCInfo.input_components = 1; /* # of color components per pixel */ theCInfo.in_color_space = JCS_GRAYSCALE; /* colorspace of input image */ } if (gArrPhotoInterpret [inFileNb] == RGB) { theCInfo.input_components = 3; /* # of color components per pixel */ theCInfo.in_color_space = JCS_RGB; /* theCInfo.out_color_space = JCS_YCbCr; */ } jpeg_set_defaults ((j_compress_ptr) &theCInfo); jpeg_set_quality (&theCInfo, inQuality, TRUE); /* limit to baseline-JPEG values */ /* Step 4: Start compressor */ jpeg_start_compress (&theCInfo, TRUE); /* Step 5: while (scan lines remain to be written) */ if (inDepth == 16) theImBuffP = (PapyUShort *) inImageBuffP; theRowStride = inImageWidth * theCInfo.input_components; j = 0; while (j < theCInfo.image_height) { /* printf("next_scanline; %d", j); */ if (inDepth == 8) theRowPointer [0] = (unsigned char *) (& inImageBuffP [j * theRowStride]); else theRowPointer [0] = (unsigned char *) (& theImBuffP [j * theRowStride]); /*(void) jpeg_write_scanlines(&theCInfo, theRowPointer, 1); */ j += (int) jpeg_write_scanlines (&theCInfo, theRowPointer, 1); } /* while */ /* Step 6: Finish compression */ jpeg_finish_compress (&theCInfo); /* Step 5b: Fill JPEG Buffer */ theDataCount = (PapyULong) ((inImageWidth * inImageHeight) - theCInfo.dest->free_in_buffer + 5); theJPEGBuffP = (PapyUChar *) ecalloc3 ((PapyULong) theDataCount, (PapyULong) sizeof (PapyUChar)); WriteFile (&theCInfo, theDataCount, (PAPY_FILE) theFp, (PapyUChar *) theJPEGBuffP, inSaveJpeg); *outJPEGDataP = (PapyUChar *) theJPEGBuffP; *outJPEGsizeP = theDataCount; /* #ifdef SAVE_JPEG */ if (inSaveJpeg) Papy3FClose (&theFp); /* #endif */ /* We can use jpeg_abort to release memory and reset global_state */ jpeg_abort( (j_common_ptr) &theCInfo); /* Step 7: release JPEG compression object */ jpeg_destroy_compress (&theCInfo); return (0); } /* endof JPEGLossyEncodeImage */ /********************************************************************************/ /* */ /* WaveletEncodeImage : , */ /* */ /* return : return 0 if no problem */ /* standard error message otherwise */ /* */ /********************************************************************************/ #ifdef MAYO_WAVE PapyShort WaveletEncodeImage (int inRatio, int inLevels, PapyUChar *inImageBuffP, PapyUChar **outWavDataP, PapyULong *outWavsizeP, int inHeight, int inWidth, int inDepth, enum EModality inModality ) { MayoCompressedImage *theCompressedP; MayoRawImage theRaw; int theBytes, j, i; int theOptions; PapyUChar *theDataP; PapyULong theTotalSize, thePos; int theVersion; int theLength; PapyUChar *theValTempP, *theFinalValP; PapyUChar theHigh, theLow; if (inDepth == 8) theBytes = 1; else theBytes = 2; /* Set up options */ theOptions = 0; theOptions |= MAYO_OPT_HVS ; /* Use Human Visualization optimizations */ /* theOptions |= MAYO_OPT_BIN ; */ /* Use Binary encoding */ theOptions |= MAYO_OPT_WTYPE153 ; /* Use wavelet type 153 for compression */ if (inModality == CT_IM) theOptions |= MAYO_OPT_CT; /* Use CT image optimizations */ /* Set up compression ratios according to the modality */ inRatio = 40; if (inModality == CR_IM || inModality == SEC_CAPT_IM) inRatio = 40; if (inModality == CT_IM || inModality == MR_IM) inRatio = 20; if (inModality == US_IM || inModality == NM_IM) inRatio = 15; /* Set up the number of levels: 1 to 5 * a higher value results in better quality, * a lower value results in faster compression */ inLevels = 5; /* Set up the MayoRawImage structure */ theRaw.bytesperpixel = theBytes ; theRaw.xsize = inWidth ; theRaw.ysize = inHeight ; theRaw.buf = inImageBuffP ; /* Swap bytes if it is a 16-bit image*/ #ifdef TO_SWAP_MAYO theValTempP = (PapyUChar *) inImageBuffP; theFinalValP = (PapyUChar *) inImageBuffP; if (inDepth == 16) { for (j = 0; j < inHeight; j++) { for (i = 0; i < inWidth; i++) { theLow = *theValTempP; theValTempP++; theHigh = *theValTempP; theValTempP++; *theFinalValP = theHigh; theFinalValP++; *theFinalValP = theLow; theFinalValP++; } /* for ...i */ } /* for ...j */ } /* if ...depth = 16 */ #endif /* Call the Compress function */ theCompressedP = MayoCompressRaw (&theRaw, inRatio, theOptions, inLevels); /* Fill Wav Buffer */ /* *outWavDataP = (PapyUChar *) theCompressedP->buf; */ /* *outWavsizeP = theCompressedP->length; */ /*theTotalSize = theCompressedP->length + 2*sizeof(int);*/ theTotalSize = theCompressedP->length + 8L; theDataP = (PapyUChar *) emalloc3(theTotalSize); *outWavDataP = (PapyUChar *) theDataP; *outWavsizeP = theTotalSize; theLength = theCompressedP->length; theVersion = theCompressedP->version; thePos = 0L; Put4Bytes ((PapyULong) theLength, theDataP, &thePos); Put4Bytes ((PapyULong) theVersion, theDataP, &thePos); theDataP += thePos; memcpy (theDataP, theCompressedP->buf, theCompressedP->length); efree3 ((void **) &(theCompressedP->buf)); efree3 ((void **) &theCompressedP); return (0); } /* endof waveletEncodeImage */ #endif /********************************************************************************/ /* */ /* Papy3PutElement : writes the value(s) of an element to the given group, */ /* module or record. */ /* return : return 0 if no problem */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3PutElement (SElement *inGrOrModP, int inElement, void *inValP) /*SElement *inGrOrModP; the group or module ID */ /*PapyShort inElement; the element number */ /*void *inValP; the value(s) to write on the file */ { SElement *theElemP; UValue_T *theValP; int theErr; /* goto the specified element */ theElemP = inGrOrModP + inElement; /* allocate room for the value to put */ if (strcmp (theElemP->vm, "1") == 0) /* Single Value */ { if ((theErr = Papy3ClearElement (inGrOrModP, inElement, TRUE)) < 0) RETURN (theErr); theElemP->nb_val = 1L; theValP = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); } /* then */ else /* Multiple Values */ { theElemP->nb_val++; if (theElemP->nb_val == 1L) theValP = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); else theValP = (UValue_T *) erealloc3 (theElemP->value, (PapyULong) (sizeof (UValue_T) * theElemP->nb_val), (PapyULong) (sizeof (UValue_T) * (theElemP->nb_val - 1L))); /* OLB */ } /* else ...multiple value */ theElemP->value = theValP; /* goto the place of the value to put */ theValP = (theElemP->value + theElemP->nb_val - 1L); switch (theElemP->vr) { case OB : case OW : case UN : /* the elements of this type must be put using PapyPutImage for OB, OW */ /* or Papy3PutUnknown for UN */ RETURN (papElemNumber); break; case SS : theValP->ss = *(PapyShort *) inValP; break; case USS : case AT : theValP->us = *(PapyUShort *) inValP; break; case SL : theValP->sl = *(PapyLong *) inValP; break; case UL : theValP->ul = *(PapyULong *) inValP; break; case FL : theValP->fl = *(PapyFloat *) inValP; break; case FD : theValP->fd = *(PapyFloatDouble *) inValP; break; case AE : case AS : case CS : case DA : case DS : case DT : case IS : case LO : case LT : case PN : case SH : case ST : case TM : case UI : case UT : theValP->a = PapyStrDup (*((char**) inValP)); break; case SQ : theValP->sq = *(struct SPapy_List_ **) inValP; break; case RET : /* RETired element */ default : break; } /* switch */ RETURN (papNoError); } /* endof Papy3PutElement */ /********************************************************************************/ /* */ /* Papy3PutIcon : Put an icon for a given image number. This function */ /* must only be used when putting a compressed image in the file. */ /* return : return 0 if no problem */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3PutIcon (PapyShort inFileNb, PapyShort inImageNb, PapyUChar *inIconP) { /**((gArrIcons [inFileNb]) + inImageNb - 1) = inIconP;*/ gArrIcons [inFileNb] [inImageNb - 1] = inIconP; RETURN (papNoError); } /* endof Papy3PutIcon */ /********************************************************************************/ /* */ /* Papy3PutImage : writes the value(s) of an element of type OB or OW to */ /* the given group or module (pixel data or curve elements). */ /* return : return 0 if no problem */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3PutImage (PapyShort inFileNb, SElement *inGrOrModP, int inElement, PapyUShort *inValP, PapyUShort inRows, PapyUShort inColumns, PapyUShort inDepth, PapyULong inSize) { SElement *theElemP; int theErr; enum EV_R_T theVR; PapyUChar *theCompPixP; #ifdef WRITE_RAW_FILE /* Temporary stuffs for compression evaluation. DAB */ PAPY_FILE theFp; void *theFSSpecP; PAPY_FILE theVRefNum; char theFilename[20]; long theSizer; PapyUChar *theValTempP, *theFinalValP, *theFinaleValP; PapyUChar theHigh, theLow; int i, j; #endif theElemP = inGrOrModP + inElement; if ((theErr = Papy3ClearElement (inGrOrModP, inElement, TRUE)) < 0) RETURN (theErr); /* these pixel datas have to be compressed using the JPEG lossless algorithm */ if (theElemP->group == 0x7FE0 && theElemP->element == 0x0010 && (gArrCompression [inFileNb] == JPEG_LOSSLESS || gArrCompression [inFileNb] == JPEG_LOSSY #ifdef MAYO_WAVE || gArrCompression [inFileNb] == MAYO_WAVELET #endif ) && inSize == 0L) { /* compressed images have a Value Representation of OB */ theVR = OB; #ifdef WRITE_RAW_FILE /* Temporary stuffs for compression evaluation. DAB */ #ifdef SWAP_DATA /* That's time to write file! At first, swapped raw */ strcpy((char *) theFilename, "TheFileSwap.raw"); theFSSpecP = NULL; theValTempP = (PapyUChar *) inValP; theFinalValP = (PapyUChar *) inValP; theFinaleValP = (PapyUChar *) inValP; for (j = 0; j < inRows; j++) { for (i = 0; i < inColumns; i++) { theLow = *theValTempP; theValTempP++; theHigh = *theValTempP; theValTempP++; *theFinalValP = theHigh; theFinalValP++; *theFinalValP = theLow; theFinalValP++; } /* for ...i */ } /* for ...j */ if (Papy3FCreate ((char *) theFilename, theVRefNum, &theFp, &theFSSpecP) != 0) RETURN (papFileCreationFailed); if (Papy3FOpen ((char *) theFilename, 'w', theVRefNum, &theFp, &theFSSpecP) != 0) RETURN (papOpenFile); theSizer = (long) (inRows * inColumns * 2); if (Papy3FWrite (theFp, (PapyULong *) &theSizer, 1L, (void *) theFinaleValP) != 0) RETURN (papWriteFile); Papy3FClose (&theFp); #endif /* SWAP_DATA */ #ifdef RAW_DATA /* That's all folks for swapped raw. Let's do the raw data now! */ strcpy((char *) theFilename, "TheFile.raw"); theFSSpecP = NULL; theValTempP = (PapyUChar *) inValP; theFinalValP = (PapyUChar *) inValP; theFinaleValP = (PapyUChar *) inValP; for (j = 0; j < inRows; j++) { for (i = 0; i < inColumns; i++) { theLow = *theValTempP; theValTempP++; theHigh = *theValTempP; theValTempP++; *theFinalValP = theHigh; theFinalValP++; *theFinalValP = theLow; theFinalValP++; } /* for ...i */ } /* for ...j */ if (Papy3FCreate ((char *) theFilename, theVRefNum, &theFp, &theFSSpecP) != 0) RETURN (papFileCreationFailed); if (Papy3FOpen ((char *) theFilename, 'w', theVRefNum, &theFp, &theFSSpecP) != 0) RETURN (papOpenFile); theSizer = (long) (inRows * inColumns * 2); if (Papy3FWrite (theFp, (PapyULong *) &theSizer, 1L, (void *) theFinaleValP) != 0) RETURN (papWriteFile); Papy3FClose (&theFp); #endif /* RAW_DATA*/ #endif /* WRITE_RAW_FILE */ /* call here the compression function */ if (gArrCompression [inFileNb] == JPEG_LOSSY) JPEGLossyEncodeImage (inFileNb, 80, NULL, (PapyUChar *) inValP, (PapyUChar **) &theCompPixP, (PapyULong *) &inSize, (int) inRows, (int) inColumns, (int) inDepth, FALSE); else if (gArrCompression [inFileNb] == JPEG_LOSSLESS) JPEGLosslessEncodeImage ((PapyUShort *) inValP, (PapyUChar **) &theCompPixP, (PapyULong *) &inSize, (int) inColumns, (int) inRows, (int) inDepth); #ifdef MAYO_WAVE else if (gArrCompression [inFileNb] == MAYO_WAVELET) if (WaveletEncodeImage (10, 5, (PapyUChar *) inValP, (PapyUChar **) &theCompPixP, (PapyULong *) &inSize,(int) inRows, (int) inColumns, (int) inDepth, (enum EModality) gFileModality[inFileNb] ) != 0) return (-1); #endif /* MAYO_WAVE */ inValP = (PapyUShort *) theCompPixP; } /* if ...compression algorithm is JPEG lossless */ /* else there is no compression to apply to the pixel datas */ else { /* compressed images have a Value Representation of OB */ if ((theElemP->group == 0x7FE0 && theElemP->element == 0x0010 && (gArrCompression [inFileNb] == JPEG_LOSSLESS || gArrCompression [inFileNb] == JPEG_LOSSY #ifdef MAYO_WAVE || gArrCompression [inFileNb] == MAYO_WAVELET #endif )) || theElemP->group == 0x0002) theVR = OB; /* uncompressed elements have a value representation of OW */ else { theVR = OW; /* this is important for further encoding */ if (gx0028BitsAllocated [inFileNb] == 0) gx0028BitsAllocated [inFileNb] = inDepth; } /* else ..uncompressed image */ /* computes the size of the image if necessary (this is usefull to let people */ /* send a compressed image to this routine) */ if (inSize == 0L) { inSize = (PapyULong) (inRows * inColumns); inSize *= (PapyULong) (inDepth / 8); } /* if */ } /* else ...no compression */ theElemP->nb_val = 1L; theElemP->vr = theVR; theElemP->length = inSize; theElemP->value = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); if (theElemP->vr == OB) theElemP->value->a = (char *) inValP; else theElemP->value->ow = inValP; RETURN (papNoError); } /* endof Papy3PutImage */ /********************************************************************************/ /* */ /* Papy3PutUnknown : writes the value(s) of an element of type UN to */ /* the given group or module (pixel data or curve elements). */ /* return : return 0 if no problem */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3PutUnknown (SElement *inGrOrModP, int inElement, PapyChar *inValP, PapyULong inSize) { SElement *theElemP; int theErr; PapyULong theLoop; theElemP = inGrOrModP + inElement; if ((theErr = Papy3ClearElement (inGrOrModP, inElement, TRUE)) < 0) RETURN (theErr); theElemP->nb_val = 1L; theElemP->vr = UN; theElemP->length = inSize; theElemP->value = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); /* allocate room for the value */ theElemP->value->a = (char *) ecalloc3 ((PapyULong) (inSize), (PapyULong) sizeof (char)); /* copy the value to the element */ for (theLoop = 0L; theLoop < inSize; theLoop++) { theElemP->value->a [theLoop] = inValP [theLoop]; } /* for */ RETURN (papNoError); } /* endof Papy3PutUnknown */ /********************************************************************************/ /* */ /* ComputeElementLength3 : computes the size of a given element. */ /* return : the size of the element */ /* */ /********************************************************************************/ PapyULong ComputeElementLength3 (SElement *inElemP, PapyULong inPos, enum ETransf_Syntax inSyntax) /*SElement *inElemP; the element */ /*unsigned long inPos; which element ? (multiple value text) */ { PapyULong theSize = 0L; Item *theWrkP; SElement *theTmpElemP; theTmpElemP = inElemP; switch (theTmpElemP->vr) { case AT : case USS : case SS : theSize = 2L; break; case UL : case SL : theSize = 4L; break; case FL : theSize = 4L; break; case FD : theSize = 8L; break; case AE : case AS : case CS : case DA : case DS : case DT : case IS : case LO : case LT : case PN : case SH : case ST : case TM : case UI : case UT : if ((theTmpElemP->value + inPos)->a != NULL) theSize = strlen ((theTmpElemP->value + inPos)->a); break; case UN : /* unknown element */ theSize = theTmpElemP->length; break; case OB : /* is it a compressed pixel data element */ if (theTmpElemP->group == 0x7FE0 && theTmpElemP->element == 0x0010) /* add the lenght of the item delimiters */ theSize += 24; case OW : /* for these elements the size is given when they are put */ theSize += theTmpElemP->length; break; case SQ : /* if image sequence => inElemP length = size of the tmp files */ if (theTmpElemP->group == 0x0041 && theTmpElemP->element == Papy3EnumToElemNb (theTmpElemP, papImageSequenceGr)) { theWrkP = (Item *) theTmpElemP->value->sq; while (theWrkP != NULL) { /* 8 is for the item delimiter */ theSize += theWrkP->object->tmpFileLength + 8L; theWrkP = theWrkP->next; } /* while ...loop on the tmp files */ } /* if ...inElemP = image sequence */ else theSize = ComputeSequenceLength3 (theTmpElemP->value->sq, inSyntax); break; default : theSize = 0; break; } /* switch ...inElemP->vr */ RETURN (theSize); } /* endof ComputeElementLength3 */ /********************************************************************************/ /* */ /* ComputeGroupLength3 : computes the size of the given group. */ /* return : always return 0 */ /* */ /********************************************************************************/ PapyShort ComputeGroupLength3 (PapyShort inGroupNb, SElement *ioGroupP, PapyULong *outImSeqSizeP, enum ETransf_Syntax inSyntax) /*int inGroupNb; the enum group number */ /*SElement *ioGroupP; pointer to the group */ { SElement *theElemP; PapyULong theSize, theTotalSize, i, j, theGrSize; theTotalSize = 0L; theSize = 0L; theGrSize = gArrGroup [inGroupNb].size; /* the first elem is group size so start the loop with i = 1 */ for (i = 1L, theElemP = ioGroupP + 1; i < theGrSize; i++, theElemP++) { /* no introduced value, so look for the type of the element */ if (theElemP->nb_val == 0L) { if (theElemP->type_t == T2) theSize = 0L; else continue; theSize += theSize & 1; /* increment if size is odd */ theTotalSize += theSize + 8L; /* group + element + length = 8 */ if (inSyntax == LITTLE_ENDIAN_EXPL && (theElemP->vr == OB || theElemP->vr == OW || theElemP->vr == SQ)) theTotalSize += 4L; } /* if ...no introduced value */ else /* introduced value */ { theSize = ComputeElementLength3 (theElemP, 0L, inSyntax); for (j = 1L; j < theElemP->nb_val; j++) { theSize += ComputeElementLength3 (theElemP, j, inSyntax); if ((theElemP->vr == AE) || (theElemP->vr == AS) || (theElemP->vr == CS) || (theElemP->vr == DA) || (theElemP->vr == DS) || (theElemP->vr == DT) || (theElemP->vr == IS) || (theElemP->vr == LO) || (theElemP->vr == LT) || (theElemP->vr == PN) || (theElemP->vr == SH) || (theElemP->vr == ST) || (theElemP->vr == TM) ||(theElemP->vr == UI)) theSize += 1L; /* the 1 is for the \ separator of mult val */ } /* for */ theSize += theSize & 1; /* increment if size is odd */ theTotalSize += theSize + 8L; /* 8L: grNb+elemNb+valueLength (implicit) */ /* if group 2 (explicit VR) & VR = OB or */ /* Little_Endian_Explicit & VR = OB, OW, SQ, UN or UT then add 4 to the total length */ if ((theElemP->group == 0x0002 && theElemP->vr == OB) || ((inSyntax == LITTLE_ENDIAN_EXPL) && ((theElemP->vr == OB) || (theElemP->vr == OW) || (theElemP->vr == SQ)|| (theElemP->vr == UN)|| (theElemP->vr == UT)))) theTotalSize += 4L; /* if image sequence store the size of the element */ if (theElemP->group == 0x0041 && theElemP->element == Papy3EnumToElemNb (theElemP, papImageSequenceGr)) *outImSeqSizeP = theSize; } /* else ...there is an introduced value */ /* if this is not a compressed pixel data element */ if (!(theElemP->group == 0x7FE0 && theElemP->element == 0x0010 && theElemP->vr == OB)) theElemP->length = theSize; } /* for */ ioGroupP->nb_val = 1L; ioGroupP->length = 4L; ioGroupP->value = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); ioGroupP->value->ul = theTotalSize; RETURN (papNoError) } /* endof ComputeGroupLength3 */ /********************************************************************************/ /* */ /* ComputeSequenceLength3 : computes the size of the given sequence. */ /* return : the size of the element */ /* */ /********************************************************************************/ PapyULong ComputeSequenceLength3 (Item *inSequenceP, enum ETransf_Syntax inSyntax) { PapyShort theEnumGrNb; PapyULong theSeqSize = 0L; Item *theItemListP, *theGrListP; /* loop on the list of items of the sequence */ theItemListP = inSequenceP; while (theItemListP != NULL) { /* loop on the list of groups of the item */ theGrListP = (Item *) theItemListP->object->item; while (theGrListP != NULL) { if (theGrListP->object->whoAmI == papGroup) { theEnumGrNb = Papy3ToEnumGroup (theGrListP->object->group->group); /* compute the size of the group */ ComputeGroupLength3 (theEnumGrNb, theGrListP->object->group, NULL, inSyntax); /* kLength_length is the length of the group length element */ theSeqSize += theGrListP->object->group->value->ul + kLength_length; } else theSeqSize += ComputeSequenceLength3 (theGrListP->object->item, inSyntax); /* get next element of the list of groups */ theGrListP = theGrListP->next; } /* while ...loop on the list of groups of the item */ /* add the size of the item delimiter */ theSeqSize += 8L; /* go to the next item of the sequence */ theItemListP = theItemListP->next; } /* while ...loop on the items of the sequence */ return theSeqSize; } /* endof ComputeSequenceLength3 */ /********************************************************************************/ /* */ /* PutGroupInBuffer : put the elements of the given group in the buffer. */ /* return : standard error message. */ /* */ /********************************************************************************/ PapyShort PutGroupInBuffer (PapyShort inFileNb, PapyShort inImNb, int inGroupNb, SElement *inGroupP, unsigned char *ioBuffP, PapyULong *ioPosP, int inIsPtrSeq) /* inGroupP is the pointer to the group to write to the buffer ioBuffP is the ready to write buffer ioPosP is the current position in the buffer */ { SElement *theElemP; PapyShort theErr, theFuncImNb, theSavedImNb; PapyUShort theUS, theSavedUINOverlayNb = 0x0000; PapyULong i, j, theItemDelimPos, theItemLength, theUL, theNbOfElem, theFilePos, thePosition; char *theStringP, theString [4]; Item *theItemSeqP, *theItemGrP; int theRecordID; PAPY_FILE theFp; /* the file pointer */ /* saves the pos of the item delimiter */ theItemDelimPos = *ioPosP - 8L; theFp = gPapyFile [inFileNb]; /* useful for dicomdir and referenced offset */ Papy3FTell (theFp, (PapyLong *) &theFilePos); /* side effect ? */ theFuncImNb = inImNb; if (inGroupP->group == 0x6000) /* multiple Overlay group ? */ { if (gCurrentOverlay [inFileNb] > kMax_overlay) RETURN (papTooMuchOverlays) else { for (i = 0, theElemP = inGroupP; i < gArrGroup [inGroupNb].size; i++, theElemP++) theElemP->group = gCurrentOverlay [inFileNb]; gCurrentOverlay [inFileNb] += 2; } /* else */ } /* if ...overlay group */ else if (inGroupP->group == 0x6001) /* multiple UINOverlay group ? */ { if (gCurrentUINOverlay [inFileNb] > kMax_UIN_overlay) RETURN (papTooMuchUINOverlays) else { for (i = 0, theElemP = inGroupP; i < gArrGroup [inGroupNb].size; i++, theElemP++) theElemP->group = gCurrentUINOverlay [inFileNb]; gCurrentUINOverlay [inFileNb] += 2; } /* else */ } /* if ...UIN overlay group */ /* group 0x0004 is only needed by the DICOMDIR */ else if (gIsPapyFile [inFileNb] == DICOMDIR && inGroupP->group == 0x0004) { /* useful when setting the NextDirRecordOffset or the NextLowerLevelOffset */ theRecordID = Papy3GetRecordType (inGroupP); } /* else ...group 0x0004 */ theNbOfElem = gArrGroup [inGroupNb].size; /* loop on the elements of the group and put them in the buffer */ for (i = 0L, theElemP = inGroupP; i < theNbOfElem; i++, theElemP++) { /* there is an introduced value */ if (theElemP->nb_val > 0L || theElemP->type_t == T2) { Put2Bytes (theElemP->group , (unsigned char *) ioBuffP, ioPosP); Put2Bytes (theElemP->element, (unsigned char *) ioBuffP, ioPosP); /* LITTLE_ENDIAN_IMPLICIT VR and not group 2 */ if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_IMPL && theElemP->group != 0x0002) Put4Bytes (theElemP->length , (unsigned char *) ioBuffP, ioPosP); /* LITTLE_ENDIAN_EXPLICIT VR or group 2 */ else if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL || theElemP->group == 0x0002) { theStringP = (char *) &theString [0]; switch (theElemP->vr) { case AE : strcpy (theStringP, "AE"); break; case AT : strcpy (theStringP, "AT"); break; case AS : strcpy (theStringP, "AS"); break; case CS : strcpy (theStringP, "CS"); break; case DA : strcpy (theStringP, "DA"); break; case DS : strcpy (theStringP, "DS"); break; case DT : strcpy (theStringP, "DT"); break; case FL : strcpy (theStringP, "FL"); break; case FD : strcpy (theStringP, "FD"); break; case IS : strcpy (theStringP, "IS"); break; case LO : strcpy (theStringP, "LO"); break; case LT : strcpy (theStringP, "LT"); break; case OB : strcpy (theStringP, "OB"); break; case OW : strcpy (theStringP, "OW"); break; case PN : strcpy (theStringP, "PN"); break; case SH : strcpy (theStringP, "SH"); break; case SL : strcpy (theStringP, "SL"); break; case SQ : strcpy (theStringP, "SQ"); break; case SS : strcpy (theStringP, "SS"); break; case ST : strcpy (theStringP, "ST"); break; case TM : strcpy (theStringP, "TM"); break; case UI : strcpy (theStringP, "UI"); break; case UL : strcpy (theStringP, "UL"); break; case UN : strcpy (theStringP, "UN"); break; case UT : strcpy (theStringP, "UT"); break; case USS: strcpy (theStringP, "US"); break; case RET: strcpy (theStringP, "RE"); break; default : strcpy (theStringP, "ZZ"); break; } /* switch ...VR */ /* put the VR in the buffer */ PutString (theStringP, theElemP->vr, (unsigned char *) ioBuffP, ioPosP); /* if the VR is OB, OW, SQ, UN or UT then put 2 bytes set to 0x0000 ... */ /* ... and encode the element length on 4 bytes */ if ((theElemP->vr == OB) || (theElemP->vr == OW) || (theElemP->vr == SQ) || (theElemP->vr == UN) || (theElemP->vr == UT)) { /* put the 0x0000 value to the buffer */ theUS = 0x0000; Put2Bytes (theUS, (unsigned char *) ioBuffP, ioPosP); /* if compressed pixel datas then put an undefined length */ if (gArrCompression [inFileNb] != NONE && theElemP->group == 0x7FE0 && theElemP->element == 0x0010 && theElemP->vr == OB) Put4Bytes (0xFFFFFFFF, (unsigned char *) ioBuffP, ioPosP); /* or put the length of the element */ else Put4Bytes (theElemP->length, (unsigned char *) ioBuffP, ioPosP); } /* if ...VR = OB, OW, SQ, UN or UT */ else /* put the element length in the buffer (2 bytes length */ Put2Bytes ((PapyUShort) theElemP->length, (unsigned char *) ioBuffP, ioPosP); } /* else ...EXPLICIT VR or group 2*/ if (theElemP->nb_val > 0L) { switch (theElemP->vr) { case UL : /* store the positions of the elements of the referenced directory record */ if (gIsPapyFile [inFileNb] == DICOMDIR && theElemP->group == 0x0004) { /* 0004,1200 */ if (theElemP->element == Papy3EnumToElemNb (theElemP, papOffsetofTheFirstDirectoryRecordGr)) gPosFirstPatientOffset [inFileNb] = *ioPosP; /* 0004,1202 */ else if (theElemP->element == Papy3EnumToElemNb (theElemP, papOffsetofTheLastDirectoryRecordGr)) gPosLastPatientOffset [inFileNb] = *ioPosP; /* 0004,1400 */ else if (theElemP->element == Papy3EnumToElemNb (theElemP, papOffsetofNextDirectoryRecordGr)) { if (theRecordID == 0) /* PatientR */ { if (gRefFirstPatientOffset [inFileNb] == 0L) { gRefFirstPatientOffset [inFileNb] = theFilePos + theItemDelimPos; /*gRefFirstPatientOffset [inFileNb] = theFilePos + *ioPosP - 28L; */ /* Let save position */ thePosition = gPosFirstPatientOffset [inFileNb]; Put4Bytes (gRefFirstPatientOffset [inFileNb], ioBuffP, &thePosition); } /* if */ gRefLastPatientOffset [inFileNb] = theFilePos + theItemDelimPos; /*gRefLastPatientOffset [inFileNb] = theFilePos + *ioPosP - 28L;*/ /* Let save position */ thePosition = gPosLastPatientOffset [inFileNb]; Put4Bytes (gRefLastPatientOffset [inFileNb], ioBuffP, &thePosition); } /* if ...recordId = 0 */ /* it exist a previous same level record */ if (*(gPosNextDirRecordOffset [inFileNb] + theRecordID) != 0L) { *(gRefNextDirRecordOffset [inFileNb] + theRecordID) = theFilePos + theItemDelimPos; /**(gRefNextDirRecordOffset [inFileNb] + theRecordID) = theFilePos + *ioPosP - 28L;*/ thePosition = *(gPosNextDirRecordOffset [inFileNb] + theRecordID); /* put the offset in the buffer */ Put4Bytes (*(gRefNextDirRecordOffset [inFileNb] + theRecordID), ioBuffP, &thePosition); } /* if */ *(gPosNextDirRecordOffset [inFileNb] + theRecordID) = *ioPosP; /* reinitialisation of the LowerLevel Directory record offset position */ *(gPosLowerLevelDirRecordOffset [inFileNb] + theRecordID + 1) = 0L; *(gRefLowerLevelDirRecordOffset [inFileNb] + theRecordID + 1) = 0L; /* reinitialisation of the previous Next Directory record offset position */ *(gPosNextDirRecordOffset [inFileNb] + theRecordID + 1) = 0L; /* set the lower level directory record offset for the first LowLevel directory */ if (theRecordID != 0 && *(gRefLowerLevelDirRecordOffset [inFileNb] + theRecordID) == 0) { *(gRefLowerLevelDirRecordOffset [inFileNb] + theRecordID) = theFilePos + theItemDelimPos; /**(gRefLowerLevelDirRecordOffset [inFileNb] + theRecordID) = theFilePos + *ioPosP - 28L;*/ thePosition = *(gPosLowerLevelDirRecordOffset [inFileNb] + theRecordID - 1); /* put the offset in the buffer */ Put4Bytes (*(gRefLowerLevelDirRecordOffset [inFileNb] + theRecordID), ioBuffP, &thePosition); } /* if */ } /* else ...element 0004,1400 */ /* 0004,1420 */ else if (theElemP->element == Papy3EnumToElemNb (theElemP, papOffsetofReferencedLowerLevelDirectoryEntityGr)) *(gPosLowerLevelDirRecordOffset [inFileNb] + theRecordID) = *ioPosP; } /* if DicomDir */ /* store the positions of the elements of the pointer sequence */ if (theElemP->group == 0x0041) { if (theElemP->element == Papy3EnumToElemNb (theElemP, papImagePointerGr)) *(gPosImagePointer [inFileNb] + theFuncImNb) += *ioPosP; else if (theElemP->element == Papy3EnumToElemNb (theElemP, papPixelOffsetGr)) *(gPosPixelOffset [inFileNb] + theFuncImNb) += *ioPosP; } /* if ...group 41 */ case SS : case USS : case AT : case SL : case FL : case FD : for (j = 0; j < theElemP->nb_val; j++) PutValue (theElemP->value + j, theElemP->vr, ioBuffP, ioPosP); break; case OB : /* keep the position of the pixel data for the pointer sequence */ if (!inIsPtrSeq && theElemP->group == 0x7FE0 && theElemP->element == 0x0010) *(gRefPixelOffset [inFileNb] + theFuncImNb) = *ioPosP; /* if it is a compressed image, put the required presentation items */ if (theElemP->group == 0x7FE0 && theElemP->element == 0x0010 && gArrCompression [inFileNb] != NONE) { /* first : an item tag for the Basic Offset Table */ Put2Bytes (0xFFFE , (unsigned char *) ioBuffP, ioPosP); Put2Bytes (0xE000 , (unsigned char *) ioBuffP, ioPosP); /* the length of the Basic Offset Table is set to ZERO */ Put4Bytes (0x00000000 , (unsigned char *) ioBuffP, ioPosP); /* then the first (and unique) fragment of Pixel Data with its item tag */ Put2Bytes (0xFFFE , (unsigned char *) ioBuffP, ioPosP); Put2Bytes (0xE000 , (unsigned char *) ioBuffP, ioPosP); /* then the length of the pixel data element */ Put4Bytes (theElemP->length , (unsigned char *) ioBuffP, ioPosP); } /* if ...it is a compressed pixel data element */ /* put the value of the element to the buffer */ Put1ByteImage (theElemP->value->a , ioBuffP, ioPosP, theElemP->length); /* if it is a compressed image, put the required sequence delimiter item */ if (theElemP->group == 0x7FE0 && theElemP->element == 0x0010 && gArrCompression [inFileNb] != NONE) { /* ladies and gentlemen : the Sequence Delimiter Item tag */ Put2Bytes (0xFFFE , (unsigned char *) ioBuffP, ioPosP); Put2Bytes (0xE0DD , (unsigned char *) ioBuffP, ioPosP); /* and its length */ Put4Bytes (0x00000000 , (unsigned char *) ioBuffP, ioPosP); } /* if ...it is a compressed pixel data element */ /* if it is the pointer sequence, free the icon image datas */ /* free also the compressed pixels datas */ if ((inIsPtrSeq && theElemP->group == 0x7FE0 && theElemP->element == 0x0010) || (!inIsPtrSeq && gArrCompression [inFileNb] != NONE && theElemP->group == 0x7FE0 && theElemP->element == 0x0010)) Papy3ClearElement (inGroupP, papPixelDataGr, TRUE); break; case OW : /* keep the position of the pixel data for the pointer sequence */ if (!inIsPtrSeq && theElemP->group == 0x7FE0 && theElemP->element == 0x0010) *(gRefPixelOffset [inFileNb] + theFuncImNb) = *ioPosP; #ifdef Windows Put2BytesImage (theElemP->value->ow, ioBuffP, ioPosP, theElemP->length); #else // Solaris , Mac if (gx0028BitsAllocated [inFileNb] == 8 || gx0028BitsAllocated [inFileNb] == 24 || (inIsPtrSeq && theElemP->group == 0x7FE0 && theElemP->element == 0x0010)) Put1ByteImage ((char *) theElemP->value->ow , ioBuffP, ioPosP, theElemP->length); else Put2BytesImage (theElemP->value->ow, ioBuffP, ioPosP, theElemP->length); #endif /* if it is the pointer sequence, free the icon image datas */ /* free also the compressed pixels datas */ if ((inIsPtrSeq && theElemP->group == 0x7FE0 && theElemP->element == 0x0010) || (!inIsPtrSeq && gArrCompression [inFileNb] != NONE && theElemP->group == 0x7FE0 && theElemP->element == 0x0010)) Papy3ClearElement (inGroupP, papPixelDataGr, TRUE); break; case AE : case AS : case CS : case DA : case DS : case DT : case IS : case LO : case LT : case PN : case SH : case ST : case TM : case UI : case UN : case UT : if (theElemP->value->a) { theStringP = (char *) emalloc3 ((PapyULong) (theElemP->length + theElemP->nb_val)); strcpy (theStringP, theElemP->value->a); for (j = 1; j < theElemP->nb_val; j++) { strcat (theStringP, "\\"); strcat (theStringP, (theElemP->value + j)->a); } /* for */ PutString (theStringP, theElemP->vr, ioBuffP, ioPosP); efree3 ((void **) &theStringP); } /* if */ break; case SQ : /* if it is the image sequence do nothing */ if (! (theElemP->group == 0x0041 && theElemP->element == Papy3EnumToElemNb (theElemP, papImageSequenceGr))) { /* if element is the pointer to the UIN overlays sequence */ if (inGroupNb == UINOVERLAY && theElemP->nb_val > 0L && theElemP->element == Papy3EnumToElemNb (theElemP, papUINOverlaySequenceGr)) { /* stores the current UINOverlay number */ theSavedUINOverlayNb = gCurrentUINOverlay [inFileNb]; /* reset the UINOverlay counting */ gCurrentUINOverlay [inFileNb] = 0x6001; } /* if ...UIN overlays sequence */ /* save the previous value */ theSavedImNb = theFuncImNb; theFuncImNb = 0; theItemSeqP = (Item *) theElemP->value->sq; /* loop on the items of the sequence */ while (theItemSeqP != NULL) { /* put the item delimiter */ theUS = 0xFFFE; Put2Bytes (theUS, ioBuffP, ioPosP); theUS = 0xE000; Put2Bytes (theUS, ioBuffP, ioPosP); theUL = 0L; theItemDelimPos = *ioPosP; /* saves the pos of the length of the item */ Put4Bytes (theUL, ioBuffP, ioPosP); theItemGrP = (Item *) theItemSeqP->object->item; /* loop on the groups of the data set */ while (theItemGrP != NULL) { if ((inGroupNb = Papy3ToEnumGroup (theItemGrP->object->group->group)) < 0) RETURN (papGroupNumber) /* put the content of the group in the write buffer */ theErr = PutGroupInBuffer (inFileNb, theFuncImNb, inGroupNb, (SElement *) theItemGrP->object->group, ioBuffP, ioPosP, inIsPtrSeq); /* get next item of the data set */ theItemGrP = theItemGrP->next; } /* while ...loop on the groups of the data set */ /* get the next item of the sequence */ theItemSeqP = theItemSeqP->next; /* and increment the position in the list */ theFuncImNb++; /* computes the length of the item */ theItemLength = *ioPosP - theItemDelimPos - 4L; /* -4 = size of item length */ Put4Bytes (theItemLength, ioBuffP, &theItemDelimPos); } /* while ...loop on the items of the sequence */ /* restores the gCurrentUINOverlay number if needed */ if (theSavedUINOverlayNb != 0x0000) gCurrentUINOverlay [inFileNb] = theSavedUINOverlayNb; /* and restore the previous value of theFuncImNb */ theFuncImNb = theSavedImNb; } /* if ...element <> image sequence */ break; default : break; } /* switch ...value representation */ } /* if ...nb_val > 0L */ } /* then ...theElemP->nb_val > 0 or type_t = T2 */ /* no introduced value */ else if (theElemP->type_t == T1 && gIsPapyFile [inFileNb] != DICOMDIR) { /* no default value => error */ efree3 ((void **) &ioBuffP); RETURN (papElemOfTypeOneNotFilled); } /* if ... type_t = T1 */ } /* for ...loop on the elements of the group */ return 0; } /* endof PutGroupInBuffer */ /********************************************************************************/ /* */ /* Papy3GroupWrite : write a group in the opened file */ /* return : the group size */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3GroupWrite (PapyShort inFileNb, SElement *ioGroupP, int inFreeGr) /*SElement *ioGroupP; the group to write */ /*int inFreeGr; would we free the group after writing ? */ { int theGroupNb; int theIsPtrSeq = FALSE; /* is there a Ptr Sequence ? */ char *theTmpFilenameP, theStr [32]; unsigned char *theBuffP; PapyULong theBytesToWrite, theFilePos; PapyULong theBuffSize, theImSeqSize, n; PapyUShort theUS; PapyShort theErr, theImNb, kk; Item *theWrkItemP; PAPY_FILE theTmpFp, theFp; /* the file pointers */ theFp = gPapyFile [inFileNb]; if ((theGroupNb = Papy3ToEnumGroup (ioGroupP->group)) < 0) RETURN (papGroupNumber) /* computes the size of the group */ theImSeqSize = 0L; (void) ComputeGroupLength3 (theGroupNb, ioGroupP, &theImSeqSize, gArrTransfSyntax [inFileNb]); /* element 0 is group size */ theBuffSize = ioGroupP->value->ul + kLength_length; switch (ioGroupP->group) { case 0x0041 : /* if group 41, substract the size of the image sequence */ /* that has to be written separately */ theBuffSize -= theImSeqSize; /* if it is THE group 41 */ if (ioGroupP == gArrMemFile [inFileNb]->next->next->object->group) { Papy3FTell (theFp, (PapyLong *) &theFilePos); /* loop on the images */ for (kk = 0; kk < gArrNbImages [inFileNb]; kk++) { *(gPosImagePointer [inFileNb] + kk) = (PapyULong) theFilePos; *(gPosPixelOffset [inFileNb] + kk) = (PapyULong) theFilePos; } /* for */ /* there is a pointer sequence (so do not save the offset to the icon image) */ theIsPtrSeq = TRUE; } /* if ...THE group 41 */ break; default : break; } /* switch ...group number */ /* allocate the write buffer */ theBuffP = (unsigned char *) emalloc3 ((PapyULong) theBuffSize); n = 0L; /* position in the write buffer */ /* put the group in the write buffer */ theErr = (int) PutGroupInBuffer (inFileNb, 0, theGroupNb, ioGroupP, theBuffP, &n, theIsPtrSeq); /* write the buffer to the file */ if (WriteGroup3 (theFp, theBuffP, theBuffSize) < 0) { efree3 ((void **) &theBuffP); RETURN (papWriteGroup); } /* if */ /* deletes the write buffer */ efree3 ((void **) &theBuffP); /* if THE group 41, copy the temp files to the Papyrus file */ if (ioGroupP->group == 0x0041 && ioGroupP == gArrMemFile [inFileNb]->next->next->object->group) { theWrkItemP = gImageSequenceItem [inFileNb]; theImNb = 0; theTmpFilenameP = (char *) ecalloc3 ((PapyULong) 256, (PapyULong) sizeof (char)); while (theWrkItemP != NULL) { /* allocate room for the item delimiter */ theBuffP = (unsigned char *) emalloc3 ((PapyULong) 8); /* put the item delimiter element */ n = 0L; theUS = 0xFFFE; Put2Bytes (theUS, theBuffP, &n); theUS = 0xE000; Put2Bytes (theUS, theBuffP, &n); Put4Bytes (theWrkItemP->object->tmpFileLength, theBuffP, &n); /* write it to the Papyrus file */ theBytesToWrite = 8L; if (Papy3FWrite (theFp, (PapyULong *) &theBytesToWrite, 1L, theBuffP) < 0) { theErr = Papy3FClose (&theFp); efree3 ((void **) &theBuffP); RETURN (papWriteFile) } /* if */ efree3 ((void **) &theBuffP); /* save the file position this data set will occupy for the backward references */ Papy3FTell (theFp, (PapyLong *)(gRefImagePointer [inFileNb] + theImNb)); /* then updates the position of the pixel data accordingly */ /* so that it is no more a relative value */ *(gRefPixelOffset [inFileNb] + theImNb) += *(gRefImagePointer [inFileNb] + theImNb); /* build the name of the temp file containing the data set */ strcpy (theTmpFilenameP, gPapFilename [inFileNb]); /* append the incremental number to the filename */ Papy3FPrint (theStr, "%d", theWrkItemP->object->objID); strcat (theStr, ".dcm"); strcat (theStr, "\0"); if (theWrkItemP->object->objID < 10) strcat (theTmpFilenameP, "000"); else if (theWrkItemP->object->objID < 100) strcat (theTmpFilenameP, "00"); else if (theWrkItemP->object->objID < 1000) strcat (theTmpFilenameP, "0"); strcat (theTmpFilenameP, theStr); /* open the temp file */ if (Papy3FOpen (theTmpFilenameP, 'r', 0, &theTmpFp, &theWrkItemP->object->file) != 0) RETURN (papOpenFile); /* get the size of the tmp file */ theImSeqSize = theWrkItemP->object->tmpFileLength; /* allocate the copy buffer */ theBuffP = (unsigned char *) ecalloc3 ((PapyULong) theImSeqSize, (PapyULong) sizeof (char)); /* reads the datas from the temp file... */ if ((theErr = (PapyShort) Papy3FRead (theTmpFp, &theImSeqSize, 1L, theBuffP)) < 0) { Papy3FClose (&theTmpFp); efree3 ((void **) &theBuffP); RETURN (papReadFile); } /* if */ /* ...and writes them to the Papyrus file */ if (Papy3FWrite (theFp, &theImSeqSize, 1L, theBuffP) < 0) { theErr = Papy3FClose (&theTmpFp); efree3 ((void **) &theBuffP); RETURN (papWriteFile) } /* if */ /* deletes the copy buffer */ efree3 ((void **) &theBuffP); /* close the temp file and frees memory */ Papy3FClose (&theTmpFp); /* get next item of the list = the next data set saved in a temp file */ theWrkItemP = theWrkItemP->next; /* and increment the position in the list */ theImNb++; } /* while ...loop on the tmp files */ /* deletes the theTmpFilenameP */ efree3 ((void **) &theTmpFilenameP); } /* if ...group 41 */ if (inFreeGr == TRUE) if (ioGroupP->group == 0x0041) { if ((theErr = Papy3GroupFree (&ioGroupP, FALSE)) < 0) RETURN (theErr); } else if ((theErr = Papy3GroupFree (&ioGroupP, TRUE)) < 0) RETURN (theErr); return 0; } /* endof Papy3GroupWrite */ Papyrus3/PapyEnumImagesModules3.h0000755000175000017500000013130310044172532014177 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyEnumImagesModules3.h */ /* Function : contains the declarations of the modules needed for the */ /* image objects . */ /* Authors : Christian Girard */ /* */ /* History : 08.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef PapyEnumImagesModulesH #define PapyEnumImagesModulesH /* Module : Acquisition Context */ enum { papAcquisitionContextSequenceAC, papAcquisitionContextDescriptionAC, papEndAcquisitionContext }; /* Module : Approval */ enum { papApprovalStatus, papReviewDate, papReviewTime, papReviewerName, papEndApproval }; /* Module : Audio */ enum { papAudioType, papAudioSampleFormat, papNumberofChannels, papNumberofSamples, papSampleRate, papTotalTime, papAudioSampleData, papReferencedImageSequenceAudio, papAudioComments, papEndAudio }; /* Module : Basic Annotation Presentation */ enum { papAnnotationPosition, papTextString, papEndBasicAnnotationPresentation }; /* Module : Basic Film Box Presentation */ enum { papImageDisplayFormat, papAnnotationDisplayFormatID, papFilmOrientation, papFilmSizeID, papMagnificationTypeBFBP, papSmoothingTypeBFBP, papBorderDensity, papEmptyImageDensity, papMinDensity, papMaxDensity, papTrim, papConfigurationInformation, papEndBasicFilmBoxPresentation }; /* Module : Basic Film Box Relationship */ enum { papReferencedFilmSessionSequence, papReferencedImageBoxSequenceBFBR, papReferencedBasicAnnotationBoxSequence, papEndBasicFilmBoxRelationship }; /* Module : Basic Film Session Presentation */ enum { papNumberofCopies, papPrintPriorityBFSP, papMediumType, papFilmDestination, papFilmSessionLabel, papMemoryAllocation, papMaximumMemoryAllocation, papEndBasicFilmSessionPresentation }; /* Module : Basic Film Session Relationship */ enum { papReferencedFilmBoxSequence, papEndBasicFilmSessionRelationship }; /* Module : BiPlane Image */ enum { papSmallestImagePixelValueinPlane, papLargestImagePixelValueinPlane, papEndBiPlaneImage }; /* Module : BiPlane Overlay */ enum { papOverlayPlanes, papOverlayPlaneOrigin, papEndBiPlaneOverlay }; /* Module : BiPlane Sequence */ enum { papPlanes, papBiPlaneAcquisitionSequence, papEndBiPlaneSequence }; /* Module : Cine */ enum { papPreferredPlaybackSequencing, papFrameTimeC, papFrameTimeVector, papStartTrim, papStopTrim, papRecommendedDisplayFrameRate, papCineRate, papFrameDelay, papEffectiveDuration, papActualFrameDurationC, papEndCine }; /* Module : Contrast Bolus */ enum { papContrastBolusAgent, papContrastBolusAgentSequence, papContrastBolusRoute, papContrastBolusAdministrationRouteSequence, papContrastBolusVolume, papContrastBolusStartTime, papContrastBolusStopTime, papContrastBolusTotalDose, papContrastFlowRates, papContrastFlowDurations, papContrastBolusIngredient, papContrastBolusIngredientConcentration, papEndContrastBolus }; /* Module : CR Image */ enum { papKVPCRI, papPlateID, papDistanceSourcetoDetectorCRI, papDistanceSourcetoPatientCRI, papExposureTimeCRI, papXrayTubeCurrentCRI, papExposureCRI, papImagerPixelSpacingCRI, papGeneratorPowerCRI, papAcquisitionDeviceProcessingDescription, papAcquisitionDeviceProcessingCode, papCassetteOrientation, papCassetteSize, papExposuresonPlate, papRelativeXrayExposure, papSensitivity, papEndCRImage }; /* Module : CR Series */ enum { papBodyPartExaminedCRS, papViewPosition, papFilterTypeCRS, papCollimatorgridnameCRS, papFocalSpotCRS, papPlateType, papPhosphorType, papEndCRSeries }; /* Module : CT Image */ enum { papImageTypeCTI, papSamplesperPixelCTI, papPhotometricInterpretationCTI, papBitsAllocatedCTI, papBitsStoredCTI, papHighBitCTI, papRescaleInterceptCTI, papRescaleSlopeCTI, papKVPCTI, papAcquisitionNumberCTI, papScanOptionsCTI, papDataCollectionDiameter, papReconstructionDiameterCTI, papDistanceSourcetoDetectorCTI, papDistanceSourcetoPatientCTI, papGantryDetectorTiltCTI, papTableHeightCTI, papRotationDirectionCTI, papExposureTimeCTI, papXrayTubeCurrentCTI, papExposureCTI, papFilterTypeCTI, papGeneratorPowerCTI, papFocalSpotCTI, papConvolutionKernelCTI, papEndCTImage }; /* Module : Curve */ enum { papCurveDimensions, papNumberofPoints, papTypeofData, papDataValueRepresentation, papCurveData, papCurveDescription, papAxisUnits, papAxisLabels, papMinimumCoordinateValue, papMaximumCoordinateValue, papCurveRange, papCurveDataDescriptor, papCoordinateStartValue, papCoordinateStepValue, papCurveLabel, papReferencedOverlaySequence5000, papEndCurve }; /* Module : Curve Identification */ enum { papCurveNumber, papCurveDate, papCurveTime, papReferencedImageSequenceCI, papReferencedOverlaySequenceCI, papReferencedCurveSequenceCI, papEndCurveIdentification }; /* Module : Device */ enum { papDeviceSequence, papEndDevice }; /* Module : Directory Information */ enum { papOffsetofTheFirstDirectoryRecord, papOffsetofTheLastDirectoryRecord, papFilesetConsistencyFlag, papDirectoryRecordSequence, papEndDirectoryInformation }; /* Module : Display Shutter */ enum { papShutterShapeDS, papShutterLeftVerticalEdgeDS, papShutterRightVerticalEdgeDS, papShutterUpperHorizontalEdgeDS, papShutterLowerHorizontalEdgeDS, papCenterofCircularShutterDS, papRadiusofCircularShutterDS, papVerticesofthePolygonalShutterDS, papEndDisplayShutter }; /* Module : DX Anatomy Imaged */ enum { papImageLateralityDXAI, papAnatomicRegionSequenceDXAI, papPrimaryAnatomicStructureSequenceDXAI, papEndDXAnatomyImaged }; /* Module : DX Image */ enum { papImageTypeDXI, papSamplesperPixelDXI, papPhotometricInterpretationDXI, papBitsAllocatedDXI, papBitsStoredDXI, papHighBitDXI, papPixelRepresentationDXI, papPixelIntensityRelationshipDXI, papPixelIntensityRelationshipSignDXI, papRescaleInterceptDXI, papRescaleSlopeDXI, papRescaleTypeDXI, papPresentationLUTShapeDXI, papLossyImageCompressionDXI, papLossyImageCompressionRatioDXI, papDerivationDescriptionDXI, papAcquisitionDeviceProcessingDescriptionDXI, papAcquisitionDeviceProcessingCodeDXI, papPatientOrientationDXI, papCalibrationObjectDXI, papBurnedInAnnotationDXI, papEndDXImage }; /* Module : DX Detector */ enum { papDetectorTypeDXD, papDetectorConfigurationDXD, papDetectorDescriptionDXD, papDetectorModeDXD, papDetectorIDDXD, papDateofLastDetectorCalibrationDXD, papTimeofLastDetectorCalibrationDXD, papExposuresonDetectorSinceLastCalibrationDXD, papExposuresonDetectorSinceManufacturedDXD, papDetectorTimeSinceLastExposureDXD, papDetectorActiveTimeDXD, papDetectorActivationOffsetFromExposureDXD, papDetectorBinningDXD, papDetectorConditionsNominalFlagDXD, papDetectorTemperatureDXD, papSensitivityDXD, papFieldofViewShapeDXD, papFieldofViewDimensionsDXD, papFieldofViewOriginDXD, papFieldofViewRotationDXD, papFieldofViewHorizontalFlipDXD, papImagerPixelSpacingDXD, papDetectorElementPhysicalSizeDXD, papDetectorElementSpacingDXD, papDetectorActiveShapeDXD, papDetectorActiveDimensionsDXD, papDetectorActiveOriginDXD, papEndDXDetector }; /* Module : DX Positioning */ enum { papProjectionEponymousNameCodeSequenceDXP, papPatientPositionDXP, papViewPositionDXP, papViewCodeSequenceDXP, papViewModifierCodeSequenceDXP, papPatientOrientationCodeSequenceDXP, papPatientOrientationModifierCodeSequenceDXP, papPatientGantryRelationshipCodeSequenceDXP, papDistanceSourcetoPatientDXP, papDistanceSourcetoDetectorDXP, papEstimatedRadiographicMagnificationFactorDXP, papPositionerTypeDXP, papPositionerPrimaryAngleDXP, papPositionerSecondaryAngleDXP, papDetectorPrimaryAngleDXP, papDetectorSecondaryAngleDXP, papColumnAngulationDXP, papTableTypeDXP, papTableAngleDXP, papBodyPartThicknessDXP, papCompressionForceDXP, papEndDXPositioning }; /* Module : DX Series */ enum { papModalityDX, papReferencedStudyComponentSequence, papPresentationIndentType, papEndDXSeries }; /* Module : External Papyrus_File Reference Sequence */ enum { papExternalPAPYRUSFileReferenceSequence, papEndExternalPapyrus_FileReferenceSequence }; /* Module : External Patient File Reference Sequence */ enum { papReferencedPatientSequenceEPFRS, papEndExternalPatientFileReferenceSequence }; /* Module : External Study File Reference Sequence */ enum { papReferencedStudySequenceESFRS, papEndExternalStudyFileReferenceSequence }; /* Module : External Visit Reference Sequence */ enum { papReferencedVisitSequenceEVRS, papEndExternalVisitReferenceSequence }; /* Module : File Reference */ enum { papReferencedSOPClassUID, papReferencedSOPInstanceUID, papReferencedFileName, papReferencedFilePath, papEndFileReference }; /* Module : File Set Identification */ enum { papFilesetID, papFileIDofFilesetDescriptorFile, papFormatofFilesetDescriptorFile, papEndFileSetIdentification }; /* Module : Frame Of Reference */ enum { papFrameofReferenceUID, papPositionReferenceIndicator, papEndFrameOfReference }; /* Module : Frame Pointers */ enum { papRepresentativeFrameNumber, papFrameNumbersofInterest, papFramesofInterestDescription, papEndFramePointers }; /* Module : General Equipment */ enum { papManufacturerGE, papInstitutionNameGE, papInstitutionAddressGE, papStationName, papInstitutionalDepartmentName, papManufacturersModelName, papDeviceSerialNumberGE, papSoftwareVersionsGE, papSpatialResolution, papDateofLastCalibration, papTimeofLastCalibration, papPixelPaddingValue, papEndGeneralEquipment }; /* Module : General Image */ enum { papInstanceNumberGI, papPatientOrientation, papImageDate, papImageTime, papImageTypeGI, papAcquisitionNumberGI, papAcquisitionDate, papAcquisitionTime, papReferencedImageSequenceGI, papDerivationDescription, papSourceImageSequence, papImagesinAcquisition, papImageComments, papLossyImageCompressionGI, papEndGeneralImage }; /* Module : General Patient Summary */ enum { papPatientsNameGPS, papPatientsID, papPatientsBirthDateGPS, papPatientsSexGPS, papPatientsHeight, papPatientsWeightGPS, papEndGeneralPatientSummary }; /* Module : General Series */ enum { papModalityGS, papSeriesInstanceUIDGS, papSeriesNumberGS, papLaterality, papSeriesDate, papSeriesTime, papPerformingPhysiciansNameGS, papProtocolName, papSeriesDescription, papOperatorsName, papReferencedStudyComponentSequenceGS, papBodyPartExaminedGS, papPatientPosition, papSmallestPixelValueinSeries, papLargestPixelValueinSeries, papEndGeneralSeries }; /* Module : General Series Summary */ enum { papModalityGSS, papSeriesInstanceUIDGSS, papSeriesNumberGSS, papNumberofimages, papEndGeneralSeriesSummary }; /* Module : General Study */ enum { papStudyInstanceUIDGS, papStudyDateGS, papStudyTimeGS, papReferringPhysiciansNameGS, papStudyIDGS, papAccessionNumberGS, papStudyDescriptionGS, papPhysiciansOfRecordGS, papNameofPhysiciansReadingStudyGS, papReferencedStudySequenceGS, papEndGeneralStudy }; /* Module : General Study Summary */ enum { papStudyDateGSS, papStudyTimeGSS, papStudyUID, papStudyIDGSS, papAccessionnumberGSS, papReferringPhysiciansNameGSS, papEndGeneralStudySummary }; /* Module : General Visit Summary */ enum { papCurrentPatientLocationGVS, papPatientsInstitutionResidenceGVS, papInstitutionNameVS, papEndGeneralVisitSummary }; /* Module : Icon Image */ enum { papSamplesperPixelII, papPhotometricInterpretationII, papRowsII, papColumnsII, papBitsAllocatedII, papBitsStoredII, papHighBitII, papPixelRepresentationII, papRedPaletteColorLookupTableDescriptors, papBluePaletteColorLookupTableDescriptors, papGreenPaletteColorLookupTableDescriptors, papRedPaletteColorLookupTableDataII, papBluePaletteColorLookupTableDataII, papGreenPaletteColorLookupTableDataII, papPixelDataII, papEndIconImage }; /* Module : Identifying Image Sequence */ enum { papImageIdentifierSequence, papEndIdentifyingImageSequence }; /* Module : Image Box Pixel Presentation */ enum { papImagePosition, papPolarity, papMagnificationTypeIBPP, papSmoothingTypeIBPP, papRequestedImageSize, papPreformattedGrayscaleImageSequence, papPreformattedColorImageSequence, papReferencedImageOverlayBoxSequenceIBP, papReferencedSOPClassUID8, papReferencedSOPInstanceUID8, papEndImageBoxPixelPresentation }; /* Module : Image Box Relationship */ enum { papReferencedImageSequenceBR, papReferencedImageOverlayBoxSequence, papReferencedVOILUTSequence, papEndImageBoxRelationship }; /* Module : Image Histogram */ enum { papHistogramSequenceIH, papEndImageHistogram }; /* Module : Image Identification */ enum { papReferencedImageSOPClassUIDII, papReferencedImageSOPInstanceUID, papImageNumberII, papEndImageIdentification }; /* Module : Image Overlay Box Presentation */ enum { papReferencedOverlayPlaneSequence, papOverlayMagnificationType, papOverlaySmoothingType, papOverlayForegroundDensity, papOverlayMode, papThresholdDensity, papEndImageOverlayBoxPresentation }; /* Module : Image Overlay Box Relationship */ enum { papReferencedImageBoxSequenceOBR, papEndImageOverlayBoxRelationship }; /* Module : Image Pixel */ enum { papSamplesperPixelIP, papPhotometricInterpretationIP, papRows, papColumns, papBitsAllocatedIP, papBitsStoredIP, papHighBitIP, papPixelRepresentationIP, papPixelData, papPlanarConfiguration, papPixelAspectRatio, papSmallestImagePixelValue, papLargestImagePixelValue, papRedPaletteColorLookupTableDescriptor, papGreenPaletteColorLookupTableDescriptor, papBluePaletteColorLookupTableDescriptor, papRedPaletteColorLookupTableData, papGreenPaletteColorLookupTableData, papBluePaletteColorLookupTableData, papEndImagePixel }; /* Module : Image Plane */ enum { papPixelSpacing, papImageOrientationPatient, papImagePositionPatient, papSliceThickness, papSliceLocation, papEndImagePlane }; /* Module : Image Pointer */ enum { papImagePointer, papEndImagePointer }; /* Module : Image Sequence */ enum { papImageSequence, papEndImageSequence }; /* Module : Internal Image Pointer Sequence */ enum { papPointerSequence, papEndInternalImagePointerSequence }; /* Module : Interpretation Approval */ enum { papInterpretationApproverSequence, papInterpretationDiagnosisDescription, papInterpretationDiagnosisCodesSequence, papResultsDistributionListSequence, papEndInterpretationApproval }; /* Module : Interpretation Identification */ enum { papInterpretationID, papInterpretationIDIssuer, papEndInterpretationIdentification }; /* Module : Interpretation Recording */ enum { papInterpretationRecordedDate, papInterpretationRecordedTime, papInterpretationRecorder, papReferencetoRecordedSound, papEndInterpretationRecording }; /* Module : Interpretation Relationship */ enum { papReferencedResultsSequenceIR, papEndInterpretationRelationship }; /* Module : Interpretation State */ enum { papInterpretationTypeID, papInterpretationStatusID, papEndInterpretationState }; /* Module : Interpretation Transcription */ enum { papInterpretationTranscriptionDate, papInterpretationTranscriptionTime, papInterpretationTranscriber, papInterpretationText, papInterpretationAuthor, papEndInterpretationTranscription }; /* Module : Intra Oral Image */ enum { papPositionerTypeIOI, papImageLateralityIOI, papAnatomicRegionSequenceIOI, papAnatomicRegionModifierSequenceIOI, papPrimaryAnatomicStructureSequenceIOI, papEndIntraOralImage }; /* Module : Intra Oral Series */ enum { papModalityIOS, papEndIntraOralSeries }; /* Module : LUT Identification */ enum { papLUTNumber, papReferencedImageSequenceLI, papEndLUTIdentification }; /* Module : Mammography Image */ enum { papPositionerTypeMI, papPositionerPrimaryAngleMI, papPositionerSecondaryAngleMI, papImageLateralityMI, papOrganExposedMI, papAnatomicRegionSequenceMI, papViewCodeSequenceMI, papViewModifierCodeSequenceMI, papEndMammographyImage }; /* Module : Mammography Series */ enum { papModalityMS, papEndMammographySeries }; /* Module : Mask */ enum { papMaskSubtractionSequence, papRecommendedViewingMode, papEndMask }; /* Module : Modality LUT */ enum { papModalityLUTSequence, papRescaleInterceptML, papRescaleSlopeML, papRescaleType, papEndModalityLUT }; /* Module : MR Image */ enum { papImageTypeMRI, papSamplesperPixelMRI, papPhotometricInterpretationMRI, papBitsAllocatedMRI, papScanningSequence, papSequenceVariant, papScanOptionsMRI, papMRAcquisitionTypeMRI, papRepetitionTime, papEchoTime, papEchoTrainLength, papInversionTime, papTriggerTimeMRI, papSequenceName, papAngioFlag, papNumberofAverages, papImagingFrequency, papImagedNucleus, papEchoNumber, papMagneticFieldStrength, papSpacingBetweenSlices, papNumberofPhaseEncodingSteps, papPercentSampling, papPercentPhaseFieldofView, papPixelBandwidth, papNominalIntervalMRI, papBeatRejectionFlagMRI, papLowRRValueMRI, papHighRRValueMRI, papIntervalsAcquiredMRI, papIntervalsRejectedMRI, papPVCRejectionMRI, papSkipBeatsMRI, papHeartRateMRI, papCardiacNumberofImagesMRI, papTriggerWindow, papReconstructionDiameterMRI, papReceivingCoil, papTransmittingCoil, papAcquisitionMatrix, papPhaseEncodingDirection, papFlipAngle, papSAR, papVariableFlipAngleFlag, papdBdt, papTemporalPositionIdentifier, papNumberofTemporalPositions, papTemporalResolution, papEndMRImage }; /* Module : Multi_Frame */ enum { papNumberofFrames, papFrameIncrementPointerMF, papEndMulti_Frame }; /* Module : Multi_frame Overlay */ enum { papNumberofFramesinOverlay, papImageFrameOrigin, papEndMulti_frameOverlay }; /* Module : NM Detector */ enum { papDetectorInformationSequence, papEndNMDetector }; /* Module : NM Image */ enum { papImageType, papImageID, papLossyImageCompressionNMI, papCountsAccumulated, papAcquisitionTerminationCondition, papTableHeightNMI, papTableTraverseNMI, papActualFrameDurationNMI, papCountRate, papPreprocessingFunctionNMI, papCorrectedImage, papWholeBodyTechnique, papScanVelocity, papScanLength, papReferencedOverlaySequenceNMI, papReferencedCurveSequenceNMI, papTriggerSourceorType, papAnatomicRegionSequence, papPrimaryAnatomicStructureSequence, papEndNMImage }; /* Module : NM Image Pixel */ enum { papSamplesperPixel, papPhotometricInterpretation, papBitsAllocated, papBitsStored, papHighBit, papPixelSpacingNM, papEndNMImagePixel }; /* Module : NM Isotope */ enum { papEnergyWindowInformationSequence, papRadiopharmaceuticalInformationSequence, papInterventionDrugInformationSequence, papEndNMIsotope }; /* Module : NM Multi Frame */ enum { papFrameIncrementPointer, papEnergyWindowVector, papNumberofEnergyWindows, papDetectorVector, papNumberofDetectors, papPhaseVector, papNumberofPhases, papRotationVector, papNumberofRotations, papRRIntervalVector, papNumberofRRIntervals, papTimeSlotVector, papNumberofTimeSlots, papSliceVector, papNumberofSlices, papAngularViewVector, papTimeSliceVector, papEndNMMultiFrame }; /* Module : NM Multi_gated Acquisition Image */ enum { papBeatRejectionFlagNMAI, papPVCRejectionNMAI, papSkipBeatsNMAI, papHeartRateNMAI, papGatedInformationSequenceNMAI, papEndNMMulti_gatedAcquisitionImage }; /* Module : NM Phase */ enum { papPhaseInformationSequence, papEndNMPhase }; /* Module : NM Reconstruction */ enum { papSpacingBetweenSlicesNM, papReconstructionDiameter, papConvolutionKernel, papSliceThicknessNM, papSliceLocationNM, papEndNMReconstruction }; /* Module : NM Series */ enum { papPatientOrientationCodeSequence, papPatientGantryRelationshipCodeSequence, papEndNMSeries }; /* Module : NM Tomo Acquisition */ enum { papRotationInformationSequence, papTypeofDetectorMotion, papEndNMTomoAcquisition }; /* Module : Overlay Identification */ enum { papOverlayNumber, papOverlayDate, papOverlayTime, papReferencedImageSequenceOI, papEndOverlayIdentification }; /* Module : Overlay Plane */ enum { papRowsOP, papColumnsOP, papOverlayType, papOrigin, papBitsAllocatedOP, papBitPosition, papOverlayData, papOverlayDescription, papOverlaySubtypeOP, papOverlayLabel, papROIArea, papROIMean, papROIStandardDeviation, papOverlayDescriptorGray, papOverlayDescriptorRed, papOverlayDescriptorGreen, papOverlayDescriptorBlue, papOverlaysGray, papOverlaysRed, papOverlaysGreen, papOverlaysBlue, papEndOverlayPlane }; /* Module : Palette Color Lookup */ enum { papRedPaletteColorLookupTableDescriptorPCL, papGreenPaletteColorLookupTableDescriptorPCL, papBluePaletteColorLookupTableDescriptorPCL, papPaletteColorLookupTableUID, papRedPaletteCLUTData, papGreenPaletteCLUTData, papBluePaletteCLUTData, papSegmentedRedPaletteColorLookupTableData, papSegmentedGreenPaletteColorLookupTableData, papSegmentedBluePaletteColorLookupTableData, papEndPaletteColorLookup }; /* Module : Patient */ enum { papPatientsNameP, papPatientIDP, papPatientsBirthDateP, papPatientsSexP, papReferencedPatientSequenceP, papPatientsBirthTimeP, papOtherPatientID, papOtherPatientNamesP, papEthnicGroupP, papPatientCommentsP, papEndPatient }; /* Module : Patient Demographic */ enum { papPatientsAddress, papRegionofResidence, papCountryofResidence, papPatientsTelephoneNumbers, papPatientsBirthDatePD, papPatientsBirthTimePD, papEthnicGroupPD, papPatientsSexPD, papPatientsSizePD, papPatientsWeightPD, papMilitaryRank, papBranchofService, papPatientsInsurancePlanCodeSequence, papPatientsReligiousPreference, papPatientCommentsPD, papEndPatientDemographic }; /* Module : Patient Identification */ enum { papPatientsNamePI, papPatientIDPI, papIssuerofPatientID, papOtherPatientIDs, papOtherPatientNamesPI, papPatientsBirthName, papPatientsMothersBirthName, papMedicalRecordLocator, papEndPatientIdentification }; /* Module : Patient Medical */ enum { papPatientState, papPregnancyStatus, papMedicalAlerts, papContrastAllergies, papSpecialNeeds, papLastMenstrualDate, papSmokingStatus, papAdditionalPatientHistory, papEndPatientMedical }; /* Module : Patient Relationship */ enum { papReferencedVisitSequencePR, papReferencedStudySequencePR, papReferencedPatientAliasSequence, papEndPatientRelationship }; /* Module : Patient Study */ enum { papAdmittingDiagnosesDescription, papPatientsAge, papPatientsSizePS, papPatientsWeightPS, papOccupation, papAdditionalPatientsHistory, papEndPatientStudy }; /* Module : Patient Summary */ enum { papPatientsNamePS, papPatientIDPS, papEndPatientSummary }; /* Module : PET Curve */ enum { papCurveDimensionsPC, papTypeofDataPC, papCurveDataPC, papAxisUnitsPC, papDeadTimeCorrectionFlag, papCountsIncluded, papPreprocessingFunction, papEndPETCurve }; /* Module : PET Image */ enum { papImageTypePI, papSamplesPerPixelPI, papPhotometricInterpretationPI, papBitsAllocatedPI, papBitsStoredPI, papHighBitPI, papRescaleInterceptPI, papRescaleSlopePI, papFrameReferenceTime, papTriggerTime, papFrameTime, papLowRRValue, papHighRRValue, papLossyImageCompression, papImageIndex, papAcquisitionDatePI, papAcquisitionTimePI, papActualFrameDuration, papNominalInterval, papIntervalsAcquired, papIntervalsRejected, papPrimaryCountsAccumulated, papSecondaryCountsAccumulated, papSliceSensitivityFactor, papDecayFactor, papDoseCalibrationFactor, papScatterFractionFactor, papDeadTimeFactor, papReferencedOverlaySequence, papReferencedCurveSequence, papAnatomicRegionSequencePI, papPrimaryAnatomicStructureSequencePI, papEndPETImage }; /* Module : PET Isotope */ enum { papRadiopharmaceuticalInformationSequencePI, papInterventionDrugInformationSequencePI, papEndPETIsotope }; /* Module : PET Multi-gated Acquisition */ enum { papBeatRejectionFlag, papTriggerSourceOrType, papPVCRejection, papSkipBeats, papHeartRate, papFramingType, papEndPETMultiGatedAcquisition }; /* Module : PET Series */ enum { papSeriesDatePET, papSeriesTimePET, papUnits, papCountsSource, papSeriesType, papReprojectionMethod, papNumberofRRIntervalsPET, papNumberofTimeSlotsPET, papNumberofSlicesPET, papNumberofRotationsPET, papRandomsCorrectionMethod, papAttenuationCorrectionMethod, papScatterCorrectionMethod, papDecayCorrection, papReconstructionDiameterPET, papConvolutionKernelPET, papReconstructionMethod, papDetectorLinesOfResponseUsed, papAcquisitionStartCondition, papAcquisitionStartConditionData, papAcquisitionTerminationConditionPET, papAcquisitionTerminationConditionData, papFieldofViewShape, papFieldofViewDimensions, papGantryDetectorTilt, papGantryDetectorSlew, papTypeofDetectorMotionPET, papCollimatorType, papCollimatorgridName, papAxialAcceptance, papAxialMash, papTransverseMash, papDetectorElementSize, papCoincidenceWindowWidth, papEnergyWindowRangeSequence, papEnergyWindowLowerLimit, papEnergyWindowUpperLimit, papSecondaryCountsType, papEndPETSeries }; /* Module : Pixel Offset */ enum { papPixelOffset, papEndPixelOffset }; /* Module : Printer */ enum { papPrinterStatus, papPrinterStatusInfo, papPrinterNameP, papManufacturerP, papManufacturerModelName, papDeviceSerialNumberP, papSoftwareVersionsP, papDateOfLastCalibration, papTimeOfLastCalibration, papEndPrinter }; /* Module : Print Job */ enum { papExecutionStatus, papExecutionStatusInfo, papCreationDate, papCreationTime, papPrintPriorityPJ, papPrinterNamePJ, papOriginator, papEndPrintJob }; /* Module : Result Identification */ enum { papResultsID, papResultsIDIssuer, papEndResultIdentification }; /* Module : Results Impression */ enum { papImpressions, papResultsComments, papEndResultsImpression }; /* Module : Result Relationship */ enum { papReferencedStudySequenceRR, papReferencedInterpretationSequence, papEndResultRelationship }; /* Module : RF Tomography Acquisition */ enum { papTornoLayerHeight, papTornoAngle, papTornoTime, papEndRFTomographyAcquisition }; /* Module : ROI Contour */ enum { papROIContourSequence, papContourNumber, papAttachedContours, papEndROIContour }; /* Module : RT Beams */ enum { papBeamSequence, papHighDoseTechniqueType, papCompensatorNumber, papCompensatorType, papEndRTBeams }; /* Module : RT Brachy Application Setups */ enum { papBrachyTreatmentTechnique, papBrachyTreatmentType, papTreatmentMachineSequence, papSourceSequence, papApplicationSetupSequence, papEndRTBrachyApplicationSetups }; /* Module : RT Dose */ enum { papSamplesperPixelRTD, papPhotometricInterpretationRTD, papBitsAllocatedRTD, papBitsStoredRTD, papHighBitRTD, papPixelRepresentationRTD, papDoseUnitsRTD, papDoseTypeRTD, papInstanceNumber, papDoseCommentRTD, papNormalizationPointRTD, papDoseSummationTypeRTD, papReferencedRTPlanSequenceRTD, papGridFrameOffsetVectorRTD, papDoseGridScalingRTD, papEndRTDose }; /* Module : RT Dose ROI */ enum { papRTDoseROISequence, papEndRTDoseROI }; /* Module : RT DVH */ enum { papReferencedStructureSetSequence, papDVHNormalizationPoint, papDVHNormalizationDoseValue, papDVHSequence, papEndRTDVH }; /* Module : RT Fraction Scheme */ enum { papFractionGroupSequence, papEndRTFractionScheme }; /* Module : RT General Plan */ enum { papRTPlanLabel, papRTPlanName, papRTPlanDescription, papRTPlanInstanceNumber, papOperatorsNameRTGP, papRTPlanDate, papRTPlanTime, papTreatmentProtocols, papTreatmentIntent, papTreatmentSites, papRTPlanGeometry, papReferencedStructureSetSequenceRTGP, papReferencedDoseSequence, papReferencedRTPlanSequence, papEndRTGeneralPlan }; /* Module : RT Image */ enum { papSamplesperPixelRTI, papPhotometricInterpretationRTI, papBitsAllocatedRTI, papBitsStoredRTI, papHighBitRTI, papPixelRepresentationRTI, papRTImageLabelRTI, papRTImageNameRTI, papRTImageDescriptionRTI, papOperatorsNameRTI, papImageTypeRTI, papConversionTypeRTI, papReportedValuesOriginRTI, papRTImagePlaneRTI, papXRayImageReceptortranslation, papXRayImageReceptorAngleRTI, papRTImageOrientationRTI, papImagePlanePixelSpacingRTI, papRTImagePositionRTI, papRadiationMachineNameRTI, papPrimaryDosimeterUnitRTI, papRadiationMachineSADRTI, papRadiationMachineSSDRTI, papRTImageSIDRTI, papSourcetoReferenceObjectDistanceRTI, papReferencedRTPlanSequenceRTI, papReferencedBeamNumberRTI, papReferencedFractionGroupNumberRTI, papFractionNumberRTI, papStartCumulativeMetersetWeightRTI, papEndCumulativeMetersetWeightRTI, papExposureSequenceRTI, papGantryAngleRTI, papDiaphragmPosition, papBeamLimitingDeviceAngleRTI, papPatientSupportAngleRTI, papTableTopEccentricAxisDistanceRTI, papTableTopEccentricAngleRTI, papTableTopVerticalPositionRTI, papTableTopLongitudinalPositionRTI, papTableTopLateralPositionRTI, papEndRTImage }; /* Module : RT Patient Setup */ enum { papPatientSetupSequence, papEndRTPatientSetup }; /* Module : RT Prescription */ enum { papPrescriptionDescription, papDoseReferenceSequence, papEndRTPrescription }; /* Module : RT ROI Observations */ enum { papRTROIObservationsSequence, papEndRTROIObservations }; /* Module : RT Series */ enum { papModalityRTS, papSeriesInstanceUIDRTS, papSeriesNumberRTS, papSeriesDescriptionRTS, papReferencedStudyComponentSequenceRTS, papEndRTSeries }; /* Module : RT Tolerance Tables */ enum { papToleranceTableSequence, papEndRTToleranceTables }; /* Module : Structure Set */ enum { papStructureSetLabel, papStructureSetName, papStructureSetDescription, papStructureSetDate, papStructureSetTime, papReferencedFrameofReferenceSequence, papStructureSetROISequence, papEndStructureSet }; /* Module : SC Image */ enum { papDateofSecondaryCapture, papTimeofSecondaryCapture, papEndSCImage }; /* Module : SC Image Equipment */ enum { papConversionType, papModalitySIE, papSecondaryCaptureDeviceID, papSecondaryCaptureDeviceManufacturer, papSecondaryCaptureDeviceManufacturersModelName, papSecondaryCaptureDeviceSoftwareVersion, papVideoImageFormatAcquired, papDigitalImageFormatAcquired, papEndSCImageEquipment }; /* Module : SC Multi-Frame Image */ enum { papZoomFactor, papPresentationLUTShape, papIllumination, papReflectedAmbientLight, papRescaleIntercept, papRescaleSlope, papRescaleTypeSCMF, papFrameIncrementPointerSCMF, papNominalScannedPixelSpacing, papDigitizingDeviceTransportDirection, papRotationOfScannedFilm, papEndSCMultiFrameImage }; /* Module : SC Multi-Frame Vector */ enum { papFrameTimeVectorSCMFV, papPageNumberVector, papFrameLabelVector, papFramePrimaryAngleVector, papFrameSecondaryAngleVector, papSliceLocationVector, papDisplayWindowLabelVector, papEndSCMultiFrameVector }; /* Module : Slide Coordinates */ enum { papImageCenterPointCoordinatesSequence, papXOffsetInSlideCoordinateSystem, papYOffsetInSlideCoordinateSystem, papZOffsetInSlideCoordinateSystem, papPixelSpacingSequence, papEndSlideCoordinates }; /* Module : SOP Common */ enum { papSOPClassUID, papSOPInstanceUID, papSpecificCharacterSet, papInstanceCreationDate, papInstanceCreationTime, papInstanceCreatorUID, papTimezoneOffsetFromUTC, papEndSOPCommon }; /* Module : Specimen Identification */ enum { papSpecimenAccessionNumber, papSpecimenSequence, papEndSpecimenIdentification }; /* Module : Study Acquisition */ enum { papStudyArrivalDate, papStudyArrivalTime, papStudyDateSA, papStudyTimeSA, papModalitiesInStudy, papStudyCompletionDate, papStudyCompletionTime, papStudyVerifiedDate, papStudyVerifiedTime, papSeriesinStudy, papAcquisitionsinStudy, papEndStudyAcquisition }; /* Module : Study Classification */ enum { papStudyStatusID, papStudyPriorityID, papStudyComments, papEndStudyClassification }; /* Module : Study Component */ enum { papStudyIDSC, papStudyInstanceUIDSC, papReferencedSeriesSequenceSC, papEndStudyComponent }; /* Module : Study Component Acquisition */ enum { papModalitySCA, papStudyDescriptionSCA, papProcedureCodeSequence, papPerformingPhysiciansNameSCA, papStudyComponentStatusID, papEndStudyComponentAcquisition }; /* Module : Study Component Relationship */ enum { papReferencedStudySequenceSCR, papEndStudyComponentRelationship }; /* Module : Study Content */ enum { papStudyIDSCt, papStudyInstanceUIDSCt, papReferencedSeriesSequenceSCt, papEndStudyContent }; /* Module : Study Identification */ enum { papStudyIDSI, papStudyIDIssuer, papOtherStudyNumbers, papEndStudyIdentification }; /* Module : Study Read */ enum { papNameofPhysiciansReadingStudySR, papStudyReadDate, papStudyReadTime, papEndStudyRead }; /* Module : Study Relationship */ enum { papReferencedVisitSequenceSR, papReferencedPatientSequenceSR, papReferencedResultsSequenceSR, papReferencedStudyComponentSequenceSR, papStudyInstanceUIDSR, papAccessionNumberSR, papEndStudyRelationship }; /* Module : Study Scheduling */ enum { papScheduledStudyStartDate, papScheduledStudyStartTime, papScheduledStudyStopDate, papScheduledStudyStopTime, papScheduledStudyLocation, papScheduledStudyLocationAETitle, papReasonforStudy, papRequestingPhysician, papRequestingService, papRequestedProcedureDescription, papRequestedProcedureCodeSequence, papRequestedContrastAgent, papEndStudyScheduling }; /* Module : Therapy */ enum { papInterventionalTherapySequenceTH, papEndTherapy }; /* Module : UIN Overlay Sequence */ enum { papOwnerID, papUINOverlaySequence, papEndUINOverlaySequence }; /* Module : US Frame of Reference */ enum { papRegionLocationMinx0, papRegionLocationMiny0, papRegionLocationMaxx1, papRegionLocationMaxy1, papPhysicalUnitsXDirection, papPhysicalUnitsYDirection, papPhysicalDeltaX, papPhysicalDeltaY, papReferencePixelx0, papReferencePixely0, papRefPixelPhysicalValueX, papRefPixelPhysicalValueY, papEndUSFrameofReference }; /* Module : US Image */ enum { papSamplesperPixelUSI, papPhotometricInterpretationUSI, papBitsAllocatedUSI, papBitsStoredUSI, papHighBitUSI, papPlanarConfigurationUSI, papPixelRepresentationUSI, papFrameIncrementPointerUSI, papImageTypeUSI, papLossyImageCompressionUSI, papNumberofStages, papNumberofViewsinStage, papUltrasoundColorDataPresent, papReferencedOverlaySequenceUSI, papReferencedCurveSequenceUSI, papStageName, papStageCodeSequence, papStageNumber, papViewName, papViewNumber, papNumberofEventTimers, papEventElapsedTimes, papEventTimerNames, papAnatomicRegionSequenceUSI, papPrimaryAnatomicStructureSequenceUSI, papTransducerPositionSequence, papTransducerOrientationSequence, papTriggerTimeUSI, papNominalIntervalUSI, papBeatRejectionFlagUSI, papLowRRValueUSI, papHighRRValueUSI, papHeartRateUSI, papOutputPower, papTransducerData, papTransducerType, papFocusDepth, papPreprocessingFunctionUSI, papMechanicalIndex, papBoneThermalIndex, papCranialThermalIndex, papSoftTissueThermalIndex, papSoftTissuefocusThermalIndex, papSoftTissuesurfaceThermalIndex, papDepthofScanField, papImageTransformationMatrix, papImageTranslationVector, papOverlaySubtype, papEndUSImage }; /* Module : US Region Calibration */ enum { papSequenceofUltrasoundRegions, papEndUSRegionCalibration }; /* Module : Visit Admission */ enum { papAdmittingDate, papAdmittingTime, papRouteofAdmissions, papAdmittingDiagnosisDescription, papAdmittingDiagnosisCodeSequence, papReferringPhysiciansNameVA, papAddress, papReferringPhysiciansPhoneNumbers, papEndVisitAdmission }; /* Module : Visit Discharge */ enum { papDischargeDate, papDischargeTime, papDescription, papDischargeDiagnosisCodeSequence, papEndVisitDischarge }; /* Module : Visit Identification */ enum { papInstitutionNameVI, papInstitutionAddressVI, papInstitutionCodeSequence, papAdmissionID, papIssuerofAdmissionID, papEndVisitIdentification }; /* Module : Visit Relationship */ enum { papReferencedStudySequenceVR, papReferencedPatientSequenceVR, papEndVisitRelationship }; /* Module : Visit Scheduling */ enum { papScheduledAdmissionDate, papScheduledAdmissionTime, papScheduledDischargeDate, papScheduledDischargeTime, papScheduledPatientInstitutionResidence, papEndVisitScheduling }; /* Module : Visit Status */ enum { papVisitStatusID, papCurrentPatientLocationVS, papPatientsInstitutionResidenceVS, papVisitComments, papEndVisitStatus }; /* Module : VL Image */ enum { papImageTypeVL, papPhotometricInterpretationVL, papBitsAllocatedVL, papBitsStoredVL, papHighBitVL, papPixelRepresentationVL, papSamplesperPixelVL, papPlanarConfigurationVL, papImageTimeVL, papLossyImageCompressionVL, papReferencedImageSequenceVL, papEndVLImage }; /* Module : VOI LUT */ enum { papVOILUTSequence, papWindowCenter, papWindowWidth, papWindowCenterWidthExplanation, papEndVOILUT }; /* Module : XRay Acquisition */ enum { papKVP, papRadiationSetting, papXrayTubeCurrent, papExposureTime, papExposure, papGrid, papAveragePulseWidth, papRadiationMode, papTypeofFilters, papIntensifierSize, papFieldofViewShapeXRA, papFieldofViewDimensionsXRA, papImagerPixelSpacing, papFocalSpots, papImageAreaDoseProduct, papEndXRayAcquisition }; /* Module : XRay Acquisition Dose */ enum { papKVPXRAD, papXrayTubeCurrentXRAD, papExposureTimeXRAD, papExposureXRAD, papDistanceSourcetoDetectorXRAD, papDistanceSourcetoPatientXRAD, papImageAreaDoseProductXRAD, papBodyPartThicknessXRAD, papEntranceDoseXRAD, papExposedAreaXRAD, papDistanceSourcetoEntranceXRAD, papCommentsonRadiationDoseXRAD, papXRayOutputXRAD, papHalfValueLayerXRAD, papOrganDoseXRAD, papOrganExposedXRAD, papAnodeTargetMaterialXRAD, papFilterMaterialXRAD, papFilterThicknessMinimumXRAD, papFilterThicknessMaximumXRAD, papRectificationTypeXRAD, papEndXRayAcquisitionDose }; /* Module : XRay Collimator */ enum { papCollimatorShape, papCollimatorLeftVerticalEdge, papCollimatorRightVerticalEdge, papCollimatorUpperHorizontalEdge, papCollimatorLowerHorizontalEdge, papCenterofCircularCollimator, papRadiusofCircularCollimator, papVerticesofthePolygonalCollimator, papEndXRayCollimator }; /* Module : XRay Filtration */ enum { papFilterTypeXRF, papFilterMaterialXRF, papFilterThicknessMinimumXRF, papFilterThicknessMaximumXRF, papEndXRayFiltration }; /* Module : XRay Generation */ enum { papKVPXRG, papXrayTubeCurrentXRG, papExposureTimeXRG, papExposureXRG, papExposureinmAsXRG, papExposureControlModeXRG, papExposureControlModeDescriptionXRG, papExposureStatusXRG, papPhototimerSettingXRG, papFocalSpotsXRG, papAnodeTargetMaterialXRG, papRectificationTypeXRG, papEndXRayGeneration }; /* Module : XRay Grid */ enum { papGridXRG, papGridAbsorbingMaterialXRG, papGridSpacingMaterialXRG, papGridThicknessXRG, papGridPitchXRG, papGridAspectRatioXRG, papGridPeriodXRG, papGridFocalDistanceXRG, papEndXRayGrid }; /* Module : XRay Image */ enum { papFrameIncrementPointerXR, papLossyImageCompressionXR, papImageTypeXR, papPixelIntensityRelationshipXR, papSamplesperPixelXR, papPhotometricInterpretationXR, papBitsAllocatedXR, papBitsStoredXR, papHighBitXR, papPixelRepresentationXR, papScanOptionsXR, papAnatomicRegionSequenceXR, papPrimaryAnatomicStructureSequenceXR, papRWavePointerXR, papReferencedImageSequenceXR, papDerivationDescriptionXR, papAcquisitionDeviceProcessingDescriptionXR, papCalibrationObjectXR, papEndXRayImage }; /* Module : XRay Table */ enum { papTableMotion, papTableVerticalIncrement, papTableLongitudinalIncrement, papTableLateralIncrement, papTableAngle, papEndXRayTable }; /* Module : XRay Tomography Acquisition */ enum { papTornoTypeXRTA, papTornoClassXRTA, papTornoLayerHeightXRTA, papTornoAngleXRTA, papTornoTimeXRTA, papNumberofTornosynthesisSourceImagesXRTA, papEndXRayTomographyAcquisition }; /* Module : XRF Positioner */ enum { papDistanceSourceToDetector, papDistanceSourcetoPatient, papEstimatedRadiographicMagnificationFactor, papColumnAngulation, papEndXRFPositioner }; #endif /* PapyEnumImagesModulesH */ Papyrus3/PapyFiles3.c0000755000175000017500000024332710044205160011655 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyFiles3.c */ /* Function : contains all the file functions */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 04.1991 version 1.1 */ /* 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifdef Mac #pragma segment papy3 #endif /* ------------------------- includes ---------------------------------------*/ #include #include #include #include #ifndef Papyrus3H #include "Papyrus3.h" #endif #ifdef _WINDOWS #include #endif enum {kPAPY_READ, kPAPY_WRITE}; /* are we in read or write mode ? */ /********************************************************************************/ /* */ /* FindFreeFile3 : find a free file number in the array of files or */ /* increment the current number of open files */ /* return : the number of the file, or standard error message */ /* */ /********************************************************************************/ PapyShort CALLINGCONV FindFreeFile3 () { PapyShort i; for (i = 0; i < kMax_file_open; i++) { if (gPapyFile [i] == 0) { return i; } /* if */ } /* for */ RETURN (papMaxOpenFile); } /* endof FindFreeFile3 */ /********************************************************************************/ /* */ /* FileOpen3 : Given a filename open the file for reading */ /* return : no error if OK standard error message otherwise */ /* */ /********************************************************************************/ PapyShort FileOpen3 (char *inNameP, PAPY_FILE inVRefNum, PAPY_FILE *outFp, void* inFSSpec) { PapyShort theErr; if (inNameP == NULL || *inNameP == '\0') RETURN (papFileName); if (inFSSpec) theErr = Papy3FOpen (inNameP, 'r', inVRefNum, outFp, &inFSSpec); else theErr = Papy3FOpen (inNameP, 'r', inVRefNum, outFp, NULL); if ((theErr) < 0) RETURN (papOpenFile); return papNoError; } /* endof FileOpen3 */ /********************************************************************************/ /* */ /* Papy3FileOpen : Given a filename open it and check if it is a Papyrus */ /* file by looking for the DICM string at offset 129. It extracts the */ /* modality and the transfert syntax used for this file. It initializes */ /* the pointers to the data sets and the pixel datas. */ /* return : a reference number to the opened file if successful */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3FileOpen (char *inNameP, PAPY_FILE inVRefNum, int inToOpen, void* inFSSpec) { PAPY_FILE theFp; char theFilename [256]; unsigned char theBuff [15], theVersion [8]; PapyLong theFilePos; PapyULong theReadSize, theNbVal; PapyShort theFileNb, theErr; int i, theElemType; enum EFile_Type thePapyrusFile = PAPYRUS3; SElement *theGroupP; UValue_T *theValP; PapyShort iResult; iResult = papNoError; if (inToOpen) { /* open the file */ if ((theErr = FileOpen3 (inNameP, inVRefNum, &theFp, inFSSpec)) < 0) { iResult = papReadingOpenFile; } } else theFp = inVRefNum; if (iResult == papNoError) { /* set the file pointer at the begining */ if ((theErr = (PapyShort) Papy3FSeek (theFp, (int) SEEK_SET, (PapyLong) 0L)) != 0) { iResult = papPositioning; } else { /* test if the "PAPYRUS 3.X" string is at the begining of the file */ theReadSize = 15L; if ((theErr = (PapyShort) Papy3FRead (theFp, (PapyULong *) &theReadSize, 1L, theBuff)) < 0) { iResult = papReadFile; } else { /* compares the extracted string with the awaited string */ theBuff [14] = '\0'; /* if the PAPYRUS 3.0 string is not here it could be a basic DICOM file */ if (strncmp ((char *) theBuff, "PAPYRUS 3.", 10) != 0) { thePapyrusFile = DICOM10; } /* test the compatibility flag to ensure the file is readable by this */ /* version of the PAPYRUS toolkit */ if (thePapyrusFile == PAPYRUS3) { if ((char) theBuff [13] > gPapyrusCompatibility [0]) { iResult = papReadFile; } /* if ...incompatible version of the PAPYRUS file */ } if (iResult == papNoError) { /* find a free place for the file */ theFileNb = FindFreeFile3 (); if (theFileNb < 0) { iResult = theFileNb; } else { gPapyFile [theFileNb] = theFp; gReadOrWrite [theFileNb] = kPAPY_READ; /* set the papyrus version number */ if (thePapyrusFile == PAPYRUS3) { for (i = 0; i < 4; i++) { theVersion [i] = theBuff [i + 8]; } theVersion [4] = '\0'; /* convert the result to a float */ gPapyrusFileVersion [theFileNb] = (float)atof ((char *) theVersion); } /* if ...it is a PAPYRUS file */ else { /* put the current value */ gPapyrusFileVersion [theFileNb] = (float)atof ((char *) gPapyrusVersion); } /* set the transfert syntax to the default one */ gArrTransfSyntax [theFileNb] = LITTLE_ENDIAN_EXPL; /* go to the place where the "DICM" prefix should be (position 128) */ if ((theErr = (PapyShort) Papy3FSeek (theFp, (int) SEEK_SET, (PapyLong) 128L)) != 0) { iResult = papPositioning; } else { theReadSize = 4L; if ((theErr = (PapyShort) Papy3FRead (theFp, (PapyULong *) &theReadSize, 1L, theBuff)) < 0) { iResult = papReadFile; } else { /* compares the extracted string with the awaited string */ theBuff [4] = '\0'; if (strcmp ((char *) theBuff, "DICM") != 0) { /* it could still be a non-part 10 DICOM file */ /* so try to get the modality element, if everything works fine */ /* assume it is the case */ /* reset the file pointer at the begining of the file */ theErr = Papy3FSeek (theFp, (int) SEEK_SET, (PapyLong) 0L); /* set the transfert syntax to the most banal one */ gArrTransfSyntax [theFileNb] = LITTLE_ENDIAN_IMPL; gArrCompression [theFileNb] = NONE; /* goto group number 8 and if found read it */ if ((theErr = Papy3GotoGroupNb (theFileNb, 0x0008)) < 0) { iResult = papNotPapyrusFile; } else { if ((theErr = Papy3GroupRead (theFileNb, &theGroupP)) < 0) { iResult = papNotPapyrusFile; } } /* else ...group 0x0008 found */ if (iResult == papNoError) { /* try to extract the modality */ theValP = Papy3GetElement (theGroupP, papModalityGr, &theNbVal, &theElemType); if (theValP != NULL) { ExtractModality (theValP, theFileNb); thePapyrusFile = DICOM_NOT10; /* non-part 10 DICOM file */ } else { thePapyrusFile = DICOM10; /* neither a DICOM file nor a PAPYRUS one */ } /* theValp NULL */ /* free the group 8 */ theErr = Papy3GroupFree (&theGroupP, TRUE); /* reset the file pointer to its previous position */ theErr = Papy3FSeek (gPapyFile [theFileNb], SEEK_SET, 0L); /* neither a PAPYRUS nor a DICOM file */ if (thePapyrusFile == DICOM10) { iResult = papNotPapyrusFile; } } /* if ...no error til yet ... */ } /* if ...could it be a non-part 10 DICOM file ? */ else /* is it a DICOMDIR file? */ { ExtractDicomdirFromPath (inNameP, theFilename); if (theFilename [0] != '\0' && ((strncmp ((char*) theFilename, "dicomdir", 8) == 0) || (strncmp ((char*) theFilename, "Dicomdir", 8) == 0) || (strncmp ((char*) theFilename, "DICOMDIR", 8) == 0))) {/* it is a DICOMDIR file: find now if group 0004 exist */ /* set the file pointer at the begining of the Directory Information */ theErr = Papy3FSeek (theFp, (int) SEEK_SET, (PapyLong) 132L); /* goto group number 4 */ if ((theErr = Papy3GotoGroupNb (theFileNb, 0x0004)) >= 0) thePapyrusFile = DICOMDIR; /* DICOMDIR file */ /* reset the file pointer to its previous position */ theErr = Papy3FSeek (gPapyFile [theFileNb], SEEK_SET, 132L); }/* if DICOMDIR filename */ } /* else is it a DICOMDIR file? */ if (iResult == papNoError) { /* is it a PAPYRUS or a basic DICOM file ? */ /* 0 = DICOM part 10, 1 = PAPYRUS 3.X, 2 = non-part 10 DICOM, 3 = DICOMDIR */ gIsPapyFile [theFileNb] = thePapyrusFile; gNbShadowOwner [theFileNb] = 0; /* shadow_group that we allow to read */ (void) Papy3AddOwner (theFileNb, "PAPYRUS 3.0"); /* read group 2 (File Meta Information) to extract the basic informations */ /* regarding the way of reading the file */ if (gIsPapyFile [theFileNb] != DICOM_NOT10) { if ((theErr = ExtractFileMetaInformation3 (theFileNb)) < 0) { iResult = theErr; } } /* if ...anything but a DICOM not 10 file */ if (iResult == papNoError) { if (gIsPapyFile [theFileNb] == DICOMDIR) { iResult = theFileNb; } else { /* extraction of the informations regarding groups 41 such as the number */ /* of images, the offsets to the data set and the pixel datas. */ /* !!! This is only done for the PAPYRUS 3.X files !!! */ if (gIsPapyFile [theFileNb] == PAPYRUS3) { if ((theErr = ExtractPapyDataSetInformation3 (theFileNb)) < 0) { iResult = theErr; } } /* if ...PAPYRUS file */ if (iResult == papNoError) { /* extract some information from group 28 */ /* first : keep the position in the file */ theErr = Papy3FTell (gPapyFile [theFileNb], &theFilePos); /* then go to the data set */ if (gIsPapyFile [theFileNb] == DICOM10) theErr = Papy3FSeek (gPapyFile [theFileNb], SEEK_SET, 132L); else if (gIsPapyFile [theFileNb] == DICOM_NOT10) theErr = Papy3FSeek (gPapyFile [theFileNb], SEEK_SET, 0L); else if (gIsPapyFile [theFileNb] == PAPYRUS3) theErr = Papy3FSeek (gPapyFile [theFileNb], SEEK_SET, *gRefImagePointer [theFileNb]); /* extract the informations from group28 from the file */ if ((theErr = ExtractGroup28Information (theFileNb)) < 0) { iResult = theErr; } /* extract data set information for the DICOM files */ if ((gIsPapyFile [theFileNb] == DICOM10 || gIsPapyFile [theFileNb] == DICOM_NOT10) && (iResult == papNoError)) { if ((theErr = ExtractDicomDataSetInformation3 (theFileNb)) < 0) { iResult = theErr; } } /* if */ if (iResult == papNoError) { /* reset the file pointer to its previous position */ theErr = Papy3FSeek (gPapyFile [theFileNb], SEEK_SET, theFilePos); iResult=theFileNb; } } /* if ...no error 'til yet... */ } /* else ... not a DICOMDIR file */ } /* if ...no error 'til yet... */ } /* if ...no error 'til yet... */ } /* else ...no error reading the DICM string from the file */ } /* else ...no error positioning the file pointer to the place where the DICM string is */ } /* found a free file number for the file */ /* if error */ if (iResult < 0) { gPapyFile [theFileNb] = 0; } /* if */ } /* if ...no error 'til yet... */ } /* else ...no error reading the file looking for the PAPYRUS 3.X str */ } /* else ...no error setting the file pointer at the begining */ /* if error */ if (iResult < 0) { /* if file was open */ if (inToOpen) { Papy3FClose (&theFp); } /* if */ } /* if ...no error 'til yet... */ } /* if ...no error 'til yet... */ return iResult; } /* endof Papy3FileOpen */ /********************************************************************************/ /* */ /* Papy3FileCreate : given a filename check if this file does not exist and*/ /* creates a new file. It has to put the file Meta Info as well as the */ /* DICM prefix to identify the file. It has to initialize the variables */ /* necessary to store the different offsets. It has to create the file */ /* structure in memory (list). */ /* return : a reference number to the opened file if successful */ /* standard error message otherwise */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3FileCreate (char *inNameP, PAPY_FILE inVRefNum, PapyUShort inNbImages, enum ETransf_Syntax inSyntax, enum EPap_Compression inCompression, enum EModality inModality, int inToCreate, int inIsPapyrus, void* inFSSpec) { PapyULong theNumberOfBytes, theLengthOfFilename; int i; PapyShort theFileNb, theErr; PAPY_FILE theFp; char theBuff [134]; Object *theObjectP; Item *theItemP; SElement *theGr41P; /*void *theFSSpecP;*/ /* -------- validity tests -------- */ /* we have to have an image */ if (inNbImages == 0) RETURN (papNbImagesIsZero); /* no valid filename specified */ if (inToCreate && (inNameP == NULL || *inNameP == '\0')) RETURN (papFileName); /* Is the choosen syntax implemented ? */ if (!((inSyntax == LITTLE_ENDIAN_IMPL && inCompression == NONE) || (inSyntax == LITTLE_ENDIAN_EXPL && (inCompression == NONE || inCompression == JPEG_LOSSLESS || inCompression == JPEG_LOSSY #ifdef MAYO_WAVE || inCompression == MAYO_WAVELET #endif )))) RETURN (papSyntaxNotImplemented); /* Is the modality known in DICOM ? */ if (inModality != CR_IM && inModality != CT_IM && inModality != MR_IM && inModality != NM_IM && inModality != US_IM && inModality != US_MF_IM && inModality != SEC_CAPT_IM && inModality != PX_IM && inModality != DX_IM && inModality != MG_IM && inModality != IO_IM && inModality != RF_IM && inModality != PET_IM && inModality != VLE_IM && inModality != VLM_IM && inModality != VLS_IM && inModality != VLP_IM && inModality != MFSBSC_IM && inModality != MFGBSC_IM && inModality != MFGWSC_IM && inModality != MFTCSC_IM) RETURN (papUnknownModality); /* -------- creating and opening the file -------- */ /* look for a valid file number */ theFileNb = FindFreeFile3 (); /* test wether it will be a PAPYRUS file or a set of DICOM files */ if (inIsPapyrus == PAPYRUS3) /* it is a PAPYRUS file, not a basic DICOM file */ gIsPapyFile [theFileNb] = PAPYRUS3; else /* it will be a set of DICOM files */ gIsPapyFile [theFileNb] = DICOM10; /* too many open files */ if (theFileNb < 0) RETURN (theFileNb); if (inToCreate && gIsPapyFile [theFileNb] == PAPYRUS3) { /*if (inFSSpec) theFSSpecP = &inFSSpec; else theFSSpecP = NULL;*/ if ((theErr = Papy3FCreate (inNameP, inVRefNum, &theFp, &inFSSpec)) != 0) RETURN (papFileAlreadyExist); if ((theErr = Papy3FOpen (inNameP, 'w', inVRefNum, &theFp, &inFSSpec)) != 0) RETURN (papFileCreationFailed); /*if (theFSSpecP != NULL) efree3 ((void **) &theFSSpecP);*/ } /* if ...inToCreate */ /* give it the file reference number */ else theFp = inVRefNum; /* assign the file to the array of files */ gPapyFile [theFileNb] = theFp; /* -------- file meta information -------- */ /* if it is a PAPYRUS file */ if (gIsPapyFile [theFileNb] == PAPYRUS3) { /* Put the DICOM File Meta Information in the file */ /* first put a PAPYRUS 3.X string at the begining of the file */ strcpy (theBuff, "PAPYRUS "); strcat (theBuff, gPapyrusVersion); strcat (theBuff, " "); /* set a different compatibility flag depending on the syntax used */ if (inSyntax == LITTLE_ENDIAN_EXPL) strcat (theBuff, gPapyrusCompatibility); else strcat (theBuff, "1"); /* then put 128 bytes set to 0 */ for (i = 14; i < 128; i++) theBuff [i] = 0; theNumberOfBytes = 128L; /* writes the bytes to the file */ if (Papy3FWrite (theFp, (PapyULong *) &theNumberOfBytes, 1, theBuff) < 0) { theErr = Papy3FClose (&theFp); RETURN (papWriteFile) } /* if */ /* then put the "DICM" string that will identify the file as a DICOM one */ strcpy (theBuff, "DICM"); theNumberOfBytes = (PapyULong) 4L; /* writes the bytes to the file */ if (Papy3FWrite (theFp, (PapyULong *) &theNumberOfBytes, 1, theBuff) < 0) { theErr = Papy3FClose (&theFp); RETURN (papWriteFile) } /* if */ } /* if ...PAPYRUS file */ /* creation of the file meta information and initialization of the memory */ /* representation of the file structure (list) */ if ((theErr = CreateFileMetaInformation3 (theFileNb, inCompression, inSyntax, inModality)) < 0) RETURN (theErr); /* -------- creation of the basic objects -------- */ /* add a blank object for the Patient Summary to the file representation */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papItem; theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->group = NULL; theObjectP->tmpFileLength = 0L; theItemP = InsertLastInList (&(gArrMemFile [theFileNb]), theObjectP); /* create a new Object to store group 41 */ theObjectP = (Object *) emalloc3 ((PapyULong) sizeof (Object)); theObjectP->whoAmI = papGroup; theObjectP->item = NULL; theObjectP->module = NULL; theObjectP->tmpFileLength = 0L; /* creation of the group 41 (Papyrus Data Element) */ theGr41P = Papy3GroupCreate (Group41); /* store the group41 in the Object */ theObjectP->group = theGr41P; theObjectP->objID = Group41; /* insert the Object at the end of the list representing the file */ theItemP = InsertLastInList (&(gArrMemFile [theFileNb]), theObjectP); /* put the number of images in the group 41 */ Papy3PutElement (theGr41P, papNumberofimagesGr, &inNbImages); /* -------- initializations a la Papyrus 2 -------- */ /* nb of images in this file */ gArrNbImages [theFileNb] = inNbImages; /* stores the name of the file (will be used to create the tmp files */ theLengthOfFilename = (PapyULong) strlen (inNameP); gPapFilename [theFileNb] = (char *) emalloc3 ((PapyULong) theLengthOfFilename + 1L); strcpy (gPapFilename [theFileNb], inNameP); /* allocates room for the icons only if Papyrus compressed file */ if (inSyntax == LITTLE_ENDIAN_EXPL && (inCompression == JPEG_LOSSLESS || inCompression == JPEG_LOSSY #ifdef MAYO_WAVE || inCompression == MAYO_WAVELET #endif )) { gArrIcons [theFileNb] = (PapyUChar **) ecalloc3 ((PapyULong) inNbImages, (PapyULong) sizeof (PapyUChar *)); /* initializes the icon pointers to NULL */ for (i = 0; i < inNbImages; i++) gArrIcons [theFileNb] [i] = NULL; } /* if ...compressed file */ /* modality of the file */ gFileModality [theFileNb] = inModality; /* set the transfert syntax and the compression used for the file */ gArrTransfSyntax [theFileNb] = inSyntax; gArrCompression [theFileNb] = inCompression; /*if (compression == JPEG_LOSSLESS) gArrCompression [theFileNb] = JPEG_LOSSLESS; else gArrCompression [theFileNb] = JPEG_LOSSY;*/ /* allocate room for the offsets to the data set and pixel data of the file */ gRefImagePointer [theFileNb] = (PapyULong *) ecalloc3 ((PapyULong) inNbImages, (PapyULong) sizeof (PapyULong)); gPosImagePointer [theFileNb] = (PapyULong *) ecalloc3 ((PapyULong) inNbImages, (PapyULong) sizeof (PapyULong)); gRefPixelOffset [theFileNb] = (PapyULong *) ecalloc3 ((PapyULong) inNbImages, (PapyULong) sizeof (PapyULong)); gPosPixelOffset [theFileNb] = (PapyULong *) ecalloc3 ((PapyULong) inNbImages, (PapyULong) sizeof (PapyULong)); /* the file is in write mode */ gReadOrWrite [theFileNb] = kPAPY_WRITE; RETURN (theFileNb); } /* endof Papy3FileCreate */ /********************************************************************************/ /* */ /* write_pos3 : writes from the buffer to the file at the specified pos. */ /* This function is used when writting the backward references to the file */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort write_pos3 (PAPY_FILE inFp, PapyULong inPos, unsigned char **ioBuffP, PapyShort inLength) /*PapyShort inFp; the file pointer */ /*PapyULong inPos; the position to write from */ /*unsigned char **ioBuffP; the buffer to write from */ /*PapyShort inLength; the length of the element to write */ { int theErr; PapyULong theTmpULong; if (Papy3FSeek (inFp, (int) SEEK_SET, (PapyLong) inPos)) { theErr = Papy3FClose (&inFp); efree3 ((void **) ioBuffP); RETURN (papPositioning) } /* if */ theTmpULong = inLength; if (Papy3FWrite (inFp, (PapyULong *) &theTmpULong, 1L, *ioBuffP) < 0) { theErr = Papy3FClose (&inFp); efree3 ((void **) ioBuffP); RETURN (papWriteFile) } /* if */ efree3 ((void **) ioBuffP); RETURN (papNoError); } /* endof write_pos3 */ /********************************************************************************/ /* */ /* Papy3FileClose : Free the memory used by this file and destroys the in */ /* memory structure representing the file. */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3FileClose (PapyShort inFileNb, int inToClose) { PapyShort theErr; int i; /* close the Papyrus file */ if (inToClose) if (Papy3FClose (&(gPapyFile [inFileNb])) != 0) RETURN (papCLOSE_FILE); /* delete the in memory file representation */ if ((theErr = DeleteList (inFileNb, &(gArrMemFile [inFileNb]), TRUE, TRUE, TRUE)) < 0) RETURN (theErr); /* deletes the pointer sequence */ if ((theErr = DeleteList (inFileNb, &(gPtrSequenceItem [inFileNb]), TRUE, TRUE, TRUE)) < 0) RETURN (theErr); if ((theErr = DeleteList (inFileNb, &(gImageSequenceItem [inFileNb]), TRUE, TRUE, TRUE)) < 0) RETURN (theErr); if (gArrGroup41 [inFileNb] != NULL) theErr = Papy3GroupFree (&(gArrGroup41 [inFileNb]), TRUE); /* frees the allocated memory for the file */ if (gPapFilename [inFileNb] != NULL) efree3 ((void **) &(gPapFilename [inFileNb])); /* frees the allocated memory for the file */ if (gShadowOwner [inFileNb] != NULL) efree3 ((void **) &(gShadowOwner [inFileNb])); if (gArrIcons [inFileNb] != NULL) efree3 ((void **) &(gArrIcons [inFileNb])); if (gRefSOPClassUID [inFileNb] != NULL) efree3 ((void **) &(gRefSOPClassUID [inFileNb])); if (gRefImagePointer [inFileNb] != NULL) efree3 ((void **) &(gRefImagePointer [inFileNb])); if (gPosImagePointer [inFileNb] != NULL) efree3 ((void **) &(gPosImagePointer [inFileNb])); if (gRefPixelOffset [inFileNb] != NULL) efree3 ((void **) &(gRefPixelOffset [inFileNb])); if (gPosPixelOffset [inFileNb] != NULL) efree3 ((void **) &(gPosPixelOffset [inFileNb])); if (gImageSOPinstUID [inFileNb] != NULL) { for (i = 0; i < gArrNbImages [inFileNb]; i++) { if (*(gImageSOPinstUID [inFileNb] + i) != NULL) efree3 ((void **) (gImageSOPinstUID [inFileNb] + i)); } /* for */ efree3 ((void **) &(gImageSOPinstUID [inFileNb])); } /* if */ gx0028BitsAllocated [inFileNb] = 0; gPatientSummaryItem [inFileNb] = NULL; gPapyFile [inFileNb] = 0; /* reset the incremental number for the file to zero */ gCurrTmpFilename [inFileNb] = 1; RETURN (theErr); } /* endof Papy3FileClose */ /********************************************************************************/ /* */ /* Papy3WriteAndCloseFile : writes the whole in memory structure of the */ /* given file to the disk. It closes any unclosed data set and saves the */ /* references to the data sets and the pixel data. Finally frees some */ /* memory that is no more needed. */ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3WriteAndCloseFile (PapyShort inFileNb, int inToClose) { unsigned char *theBuffP; PapyShort theErr, i; PapyULong theBufPos; Item *theFileStructP, *theSeqP, *theDataSetP, *theWrkItemP; /* Do the following tasks only if we are writing a PAPYRUS file */ if (gIsPapyFile [inFileNb] == PAPYRUS3) { /* write group 2 (File Meta Information) and free it */ if ((theErr = Papy3GroupWrite (inFileNb, (gArrMemFile [inFileNb])->object->group, FALSE)) < 0) RETURN (theErr); /* convert the Patient summaries modules to groups */ theFileStructP = gArrMemFile [inFileNb]->next; if ((theErr = ItemModulesToGroups3 (inFileNb, theFileStructP, TRUE)) < 0) RETURN (theErr); /* write the groups of the patient summary to the Papyrus file */ theWrkItemP = (Item *) theFileStructP->object->item; while (theWrkItemP != NULL) { /* if gr 41 do not write it as the only element will be in THE gr 41 */ if (theWrkItemP->object->group->group != 0x0041) { /* write the current group to the file and then frees the allocated memory */ if ((theErr = Papy3GroupWrite (inFileNb, theWrkItemP->object->group, FALSE)) < 0) RETURN (theErr); } /* get next element of the list */ theWrkItemP = theWrkItemP->next; } /* while ...loop on the groups of the patient summary */ /* makes sure that all the data sets have been converted to temporary files */ /* if not, converts them and frees the modules of the data set */ theDataSetP = gImageSequenceItem [inFileNb]; while (theDataSetP != NULL) { if (theDataSetP->object->whoAmI != papTmpFile) if ((theErr = Papy3CloseDataSet (inFileNb, theDataSetP, TRUE, TRUE)) < 0) RETURN (theErr); /* get next data set of the list */ theDataSetP = theDataSetP->next; } /* while ...makes sure all data sets have been converted to tmp files */ /* convert the items modules of the pointer sequence to groups */ theSeqP = gPtrSequenceItem [inFileNb]; while (theSeqP != NULL) { if ((theErr = ItemModulesToGroups3 (inFileNb, theSeqP, TRUE)) < 0) RETURN (theErr); /* get the next item of the pointer sequence */ theSeqP = theSeqP->next; } /* while ...loop on the items of the pointer sequence */ /* points to group 41 in the in memory file structure */ theFileStructP = theFileStructP->next; /* write the group 41 */ if ((theErr = Papy3GroupWrite (inFileNb, theFileStructP->object->group, FALSE)) < 0) RETURN (theErr); /* writes the saved references to the file */ /* loop on the images of the file */ for (i = 0; i < gArrNbImages [inFileNb]; i++) { /* put the offset to the data set in the buffer */ theBuffP = (unsigned char *) emalloc3 ((PapyULong) sizeof (PapyULong)); theBufPos = 0; Put4Bytes (*(gRefImagePointer [inFileNb] + i), theBuffP, &theBufPos); /* write the offset from the begining of the file until the data set */ if ((theErr = write_pos3 (gPapyFile [inFileNb], *(gPosImagePointer [inFileNb] + i), &theBuffP, 4)) < 0) RETURN (theErr); efree3 ((void **) &theBuffP); /* put the offset to the pixel datas in the buffer */ theBuffP = (unsigned char *) emalloc3 ((PapyULong) sizeof (PapyULong)); theBufPos = 0L; Put4Bytes (*(gRefPixelOffset [inFileNb] + i), theBuffP, &theBufPos); /* write the offset from the begining of the file until the data set */ if ((theErr = write_pos3 (gPapyFile [inFileNb], *(gPosPixelOffset [inFileNb] + i), &theBuffP, 4)) < 0) RETURN (theErr); efree3 ((void **) &theBuffP); } /* for ...writing the references to the data sets and the pixel datas */ } /* if ...PAPYRUS file */ /* frees the allocated memory */ /* if DICOM file, inFileNb has never existed */ if (gIsPapyFile [inFileNb] == DICOM10) theErr = Papy3FileClose (inFileNb, FALSE); else theErr = Papy3FileClose (inFileNb, inToClose); RETURN (theErr); } /* endof Papy3WriteAndCloseFile */ /********************************************************************************/ /* */ /* ReadGroup3 : reads the next group from the file and put it in a buffer.*/ /* return : standard error message */ /* */ /********************************************************************************/ PapyShort ReadGroup3 (PapyShort inFileNb, PapyUShort *outGroupNbP, unsigned char **outBuffP, PapyULong *outBytesReadP, PapyULong *outGroupLengthP) { PapyULong theStartPos, theCurrPos, theReadLength, theBufPos; PapyULong theGrLength, theElemLength, theFirstElemLength, theTempL, i; PapyUShort theElemNb, theTemplGr2, theElemCreator, theElemNb2; int theErr; PAPY_FILE theFp; theFp = gPapyFile [inFileNb]; theFirstElemLength = (PapyULong) kLength_length; /* 12 */ /* allocate a buffer to read until group length */ *outBuffP = (unsigned char *) emalloc3 (theFirstElemLength); *outBytesReadP = theFirstElemLength; *outGroupLengthP = 0L; /* read the file until the group length value */ theTempL = theFirstElemLength; if ((theErr = (PapyShort) Papy3FRead (theFp, &theTempL, 1L, *outBuffP)) < 0) { theErr = Papy3FClose (&theFp); efree3 ((void **) outBuffP); RETURN (papReadFile) } /* if */ i = 0L; /* position in the read buffer */ *outGroupNbP = Extract2Bytes (*outBuffP, &i); /* group number */ theElemNb = Extract2Bytes (*outBuffP, &i); /* element number */ /* check the transfert syntax */ if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL || *outGroupNbP == 0x0002) { i += 2; /* moves 2 bytes forward */ theTemplGr2 = Extract2Bytes (*outBuffP, &i); theTempL = (PapyULong) theTemplGr2; /* element length */ } /* if ...EXPLICIT VR */ /* IMPLICIT VR */ else theTempL = Extract4Bytes (*outBuffP, &i); /* element length */ /* length of the group element is present */ /* or DICOMDIR, so compute it */ if (theElemNb == 0) /* && *outGroupNbP != 0x0004)*/ theGrLength = Extract4Bytes (*outBuffP, &i); /* group with no length set, so compute it */ else { theErr = Papy3FSeek (theFp, (int) SEEK_CUR, - (long) theFirstElemLength); if (*outGroupNbP != 0x7FE0) theGrLength = ComputeUndefinedGroupLength3 (inFileNb, -1L); else { if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL) theGrLength = 12L; else theGrLength = 8L; } /* else ...group 0x7FE0 */ /* tell Papy3GroupRead to fill the group length element */ *outGroupLengthP = theGrLength; *outBytesReadP = 0L; /* have not read the group length element */ theFirstElemLength = 0L; } /* else ...undefined group length */ /* different ways of reading depending on the group number */ switch (*outGroupNbP) { case 0x0041 : /* if it is group 41, we will not read the pointer sequence and the */ /* image sequence, because they are too big to be kept all the time */ /* find the creator element number for the PAPYRUS 3.0 elements */ if ((theElemCreator = Papy3FindOwnerRange (inFileNb, 0x0041, "PAPYRUS 3.0")) == 0) RETURN (papNotFound); /* save the start of copy area position (file) */ theErr = Papy3FTell ((PAPY_FILE) theFp, (PapyLong *) &theStartPos); /* look for the pointer sequence (elem 0x1010) */ theElemNb2 = theElemCreator << 8; theElemNb2 |= 0x0010; theErr = Papy3GotoElemNb (inFileNb, *outGroupNbP, theElemNb2, &theElemLength); /* make sure we have find the element */ if (theErr == 0) { /* save the file offset to the pointer sequence */ theErr = Papy3FTell ((PAPY_FILE) theFp, (PapyLong *) &theCurrPos); if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_IMPL) theCurrPos += 8L; /* +8 allows for jumping until begin of val */ else if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL) theCurrPos += 12L; /* +12 allows for jumping until begin of val */ /* realloc more place for the group buffer */ theReadLength = theCurrPos - theStartPos; theBufPos = theFirstElemLength; *outBytesReadP += theReadLength; *outBuffP = (unsigned char *) erealloc3 (*outBuffP, (PapyULong) (theFirstElemLength + theReadLength), (PapyULong) theFirstElemLength); /* OLB */ /* read in the group buffer */ theErr = Papy3FSeek (theFp, (int) SEEK_SET, (PapyLong) theStartPos); if ((theErr = (PapyShort) Papy3FRead (theFp, &theReadLength, 1L, ((*outBuffP) + theBufPos))) < 0) { theErr = Papy3FClose (&theFp); efree3 ((void **) outBuffP); RETURN (papReadFile) } /* if */ theBufPos += theReadLength; /* skip the pointer sequence */ theErr = Papy3FSeek (theFp, (int) SEEK_CUR, (PapyLong) theElemLength); /* save the current file position */ theErr = Papy3FTell ((PAPY_FILE) theFp, (PapyLong *) &theStartPos); } /* if ...skip the pointer sequence */ /* look for the image sequence (elem 0x1050) */ theElemNb2 = theElemCreator << 8; theElemNb2 |= 0x0050; theErr = Papy3GotoElemNb (inFileNb, *outGroupNbP, theElemNb2, &theElemLength); /* if image sequence found */ if (theErr == 0) { /* stores the position of the Image Sequence in the file */ theErr = Papy3FTell ((PAPY_FILE) theFp, (PapyLong *) &theCurrPos); if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_IMPL) theCurrPos += 8L; /* +8 allows for jumping until begin of val */ else if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL) theCurrPos += 12L; /* +12 allows for jumping until begin of val */ theReadLength = theCurrPos - theStartPos; *outBytesReadP += theReadLength; /* realloc more place for the group buffer */ *outBuffP = (unsigned char *) erealloc3 (*outBuffP, (PapyULong) (theBufPos + theReadLength), (PapyULong)theBufPos); /* OLB */ /* read in the group buffer */ theErr = Papy3FSeek (theFp, (int) SEEK_SET, (PapyLong) theStartPos); if ((theErr = (PapyShort) Papy3FRead (theFp, &theReadLength, 1L, ((*outBuffP) + theBufPos))) < 0) { theErr = Papy3FClose (&theFp); efree3 ((void **) outBuffP); RETURN (papReadFile) } /* if */ } /* if ...image sequence */ /* there was no image seq, we assume there was no pointer seq too => read whole group */ else if (theErr == -29) { *outBytesReadP += theGrLength; /* re-allocate room for the part of the group we will read */ *outBuffP = (unsigned char *) erealloc3 (*outBuffP, (PapyULong) (theFirstElemLength + theGrLength), (PapyULong) theFirstElemLength); /* OLB */ /* reads the group from the file */ if ((theErr = (PapyShort) Papy3FRead (theFp, &theGrLength, 1L, ((*outBuffP) + theFirstElemLength))) < 0) { theErr = Papy3FClose (&theFp); efree3 ((void **) outBuffP); RETURN (papReadFile) } /* if */ } /* else ...element not found */ break; case 0x7FE0 : /* allocates everything but the pixel data pointer to efficiently use mem */ /* test the value representation */ if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL) theGrLength = (4 * sizeof (PapyUShort)) + sizeof (PapyULong); /* 12 */ else theGrLength = (2 * sizeof (PapyUShort)) + sizeof (PapyULong); /* 8 */ if (theFirstElemLength != 0) { *outBuffP = (unsigned char *) erealloc3 (*outBuffP, (PapyULong) (theFirstElemLength + theGrLength), (PapyULong) theFirstElemLength); /* OLB */ } /* if ...theFirstElemLength <> 0 */ else { efree3 ((void **) outBuffP); /* frees the outbuf */ *outBuffP = (unsigned char *) emalloc3 (theGrLength); } /* theFirstElemLength = 0 */ *outBytesReadP += theGrLength; /* reads the group from the file until the pixel datas */ if ((theErr = (PapyShort) Papy3FRead (theFp, &theGrLength, 1L, ((*outBuffP) + theFirstElemLength))) < 0) { theErr = Papy3FClose (&theFp); efree3 ((void **) outBuffP); RETURN (papReadFile) } /* if */ break; default : *outBytesReadP += theGrLength; /* re-allocate room for the part of the group we will read */ *outBuffP = (unsigned char *) erealloc3 (*outBuffP, (PapyULong) (theFirstElemLength + theGrLength), (PapyULong) theFirstElemLength); /* OLB */ /* reads the group from the file */ if ((theErr = (PapyShort) Papy3FRead (theFp, &theGrLength, 1L, ((*outBuffP) + theFirstElemLength))) < 0) { theErr = Papy3FClose (&theFp); efree3 ((void **) outBuffP); RETURN (papReadFile) } /* if */ break; } /* switch ...group number */ RETURN (papNoError); } /* endof ReadGroup3 */ /********************************************************************************/ /* */ /* WriteGroup3 : writes the next group */ /* return : 0 if OK */ /* else standard error message */ /* */ /********************************************************************************/ PapyShort WriteGroup3 (PAPY_FILE inFp, unsigned char *inBuffP, PapyULong ioBytesToWrite) /*PapyShort inFp; the file to write to */ /*unsigned char *inBuffP; the buffer to write from */ /*PapyULong ioBytesToWrite the number of bytes to write */ { int theErr; if (Papy3FWrite (inFp, &ioBytesToWrite, 1L, inBuffP) < 0) { theErr = Papy3FClose (&inFp); RETURN (papWriteFile) } /* if */ RETURN (papNoError); } /* endof WriteGroup3 */ /********************************************************************************/ /* */ /* Papy3GetNextGroupNb : get the number of the next group to be read */ /* return : the number of the next group if OK */ /* else READ_FILE error (-22) EOF reached */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3GetNextGroupNb (PapyShort inFileNb) { PAPY_FILE theFp; unsigned char theBuff [2]; PapyULong i; PapyUShort theGroupNb; int theErr; theFp = gPapyFile [inFileNb]; i = 2L; if ((theErr = (PapyShort) Papy3FRead (theFp, &i, 1L, (void *) theBuff)) < 0) { theErr = Papy3FClose (&theFp); RETURN (papReadFile) } /* if */ i = 0L; theGroupNb = Extract2Bytes (theBuff, &i); /* resets the file pointer to its previous position */ if (Papy3FSeek (theFp, (int) SEEK_CUR, (PapyLong) -2L) != 0) RETURN (papPositioning); return theGroupNb; } /* endof Papy3GetNextGroupNb */ /********************************************************************************/ /* */ /* Papy3SkipNextGroup : skips the next group */ /* return : 0 if OK */ /* else standard error message (-22 = READ ERROR = eof reached) */ /* or the size of the element is wrong (-27) */ /* or we jumped over the eof (-25) */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3SkipNextGroup (PapyShort inFileNb) { PAPY_FILE theFp; unsigned char theBuff [kLength_length]; PapyULong i; PapyULong theGrLength, theTempL; PapyUShort theTempS, theGrNb; int theErr; theFp = gPapyFile [inFileNb]; i = kLength_length; if ((theErr = (PapyShort) Papy3FRead (theFp, &i, 1L, theBuff)) < 0) { theErr = Papy3FClose (&theFp); RETURN (papReadFile) } /* if */ i = 0L; theGrNb = Extract2Bytes (theBuff, &i); theTempS = Extract2Bytes (theBuff, &i); /* DICOMDIR separator 0xFFFE:0xE000 */ if ((theGrNb == 0xFFFE) && (theTempS == 0xE000)) { theErr = Papy3FSeek (theFp, (int) SEEK_CUR, -4L); RETURN (theErr) } /* if */ /* if the group length elem is here extract the group length from the buffer */ if (theTempS == 0) // Symbios : && (theGrNb != 0x0008)) { /* test the VR */ if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_IMPL && theGrNb != 0x0002) theTempL = Extract4Bytes (theBuff, &i); else { i += 2L; theTempL = (PapyULong) Extract2Bytes (theBuff, &i); } /* else */ /* if (theTempL != 4L) RETURN (papElemSize); this is to let pass little endian impl gr2 files */ theGrLength = Extract4Bytes (theBuff, &i); } /* if ...extract group length from buffer */ /* else the group length element not here compute it */ else { theErr = Papy3FSeek (theFp, (int) SEEK_CUR, (PapyLong) - kLength_length); theGrLength = ComputeUndefinedGroupLength3 (inFileNb, -1L); } /* else ...undefined group length */ /* sets the file pointer at the begining of the next group */ if (Papy3FSeek (theFp, (int) SEEK_CUR, (PapyLong) theGrLength) != 0) RETURN (papPositioning); RETURN (papNoError); } /* endof Papy3SkipNextGroup */ /********************************************************************************/ /* */ /* Papy3GotoGroupNb : goto the specified group nb */ /* return : 0 if OK */ /* else standard error message (-22 = READ ERROR = eof reached) */ /* or we jumped over the eof (-25) */ /* or the group was missing (-29) */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3GotoGroupNb (PapyShort inFileNb, PapyShort inGroupNb) /*PapyShort inFileNb; the file pointer to read from */ /*PapyShort inGroupNb; the group we want to position to */ { PapyShort theLastGroupNb, theCurrGroupNb, theStartGroupNb, theErr; PapyLong theStartPos; theErr = Papy3FTell ((PAPY_FILE) gPapyFile [inFileNb], (PapyLong *) &theStartPos); theLastGroupNb = 0x0000; /* foo intial value */ theCurrGroupNb = Papy3GetNextGroupNb (inFileNb); if (theCurrGroupNb < 0) RETURN (theCurrGroupNb); theStartGroupNb = theCurrGroupNb; while (theCurrGroupNb < inGroupNb && theCurrGroupNb > 0 && theCurrGroupNb != theLastGroupNb && theCurrGroupNb >= theStartGroupNb && theCurrGroupNb != 0x7FE0) { theErr = Papy3SkipNextGroup (inFileNb); if (theErr < 0) { Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) theStartPos); RETURN (theErr); } /* if */ theLastGroupNb = theCurrGroupNb; theCurrGroupNb = Papy3GetNextGroupNb (inFileNb); if (theCurrGroupNb < 0) PAPY3PRINTERRMSG (); } /* while */ if (theCurrGroupNb != inGroupNb) { Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) theStartPos); RETURN (papGroupNumber); } /* if ...group missing */ RETURN (papNoError); } /* endof Papy3GotoGroupNb */ /********************************************************************************/ /* */ /* Papy3FindOwnerRange : Look for the range dynimcally attributed to DICOM */ /* Private Data Elements given the owner name, the group number and the */ /* Papyrus file number. */ /* To make sure the file pointer is set at the right position (begining of */ /* the group to look at one should first call the Papy3GotoGroupNb */ /* function. */ /* return : the element number of the creator element for this range */ /* else standard error message */ /* */ /********************************************************************************/ PapyUShort CALLINGCONV Papy3FindOwnerRange (PapyShort inFileNb, PapyUShort inGroupNb, char *inOwnerStrP) { PAPY_FILE theFp; SShadowOwner *theShOwP; char *theStringP, *theP, theVr [3]; unsigned char theBuff [256], *theBuffP; int j, found = FALSE; PapyShort theErr = 0; PapyUShort theExtrGrNb, theExtrElemNb, tmpUShort; PapyULong theElemLength, theStartPos, i, ii, theTmpULong, theULong; /* save the current file position */ theFp = gPapyFile [inFileNb]; Papy3FTell ((PAPY_FILE) theFp, (PapyLong *) &theStartPos); theExtrGrNb = inGroupNb; /* search loop on the elements */ while (!found && theExtrGrNb == inGroupNb && theErr >= 0) { theBuffP = (unsigned char *) &theBuff [0]; i = 8L; /* grNb, theElemNb & theElemLength */ if ((theErr = (PapyShort) Papy3FRead (theFp, &i, 1L, theBuffP)) < 0) { theErr = Papy3FClose (&theFp); RETURN (papReadFile) } /* if */ /* extract the information from the read buffer */ /* updates the current position in the read buffer */ i = (PapyULong) 2L; /* extract the group number according to the little-endian syntax */ theExtrGrNb = (PapyUShort) (*(theBuffP + 1)); theExtrGrNb = theExtrGrNb << 8; theExtrGrNb |= (PapyUShort) *theBuffP; /* points to the right place in the buffer */ theBuffP = theBuff; theBuffP += i; /* updates the current position in the read buffer */ i += 2L; /* extract the element number according to the little-endian syntax */ theExtrElemNb = (PapyUShort) (*(theBuffP + 1)); theExtrElemNb = theExtrElemNb << 8; theExtrElemNb |= (PapyUShort) *theBuffP; /* points to the right place in the buffer */ theBuffP = theBuff; theBuffP += i; /* check the syntax used for the file */ if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_IMPL) { /* extract the element length according to the little-endian syntax */ theTmpULong = (PapyULong) (*(theBuffP + 3)); theTmpULong = theTmpULong << 24; theULong = theTmpULong; theTmpULong = (PapyULong) (*(theBuffP + 2)); theTmpULong = theTmpULong << 16; theULong |= theTmpULong; theTmpULong = (PapyULong) (*(theBuffP + 1)); theTmpULong = theTmpULong << 8; theULong |= theTmpULong; theTmpULong = (PapyULong) *theBuffP; theULong |= theTmpULong; theElemLength = theULong; /* updates the current position in the read buffer */ i += 4L; } /* if ...implicit VR */ else /* explicit VR */ { /* updates the current position in the read buffer */ i += 2L; /* extract the Value Representation */ theVr [0] = (char) *theBuffP; theVr [1] = (char) *(theBuffP + 1); theVr [2] = '\0'; /* points to the right place in the buffer */ theBuffP = theBuff; theBuffP += i; /* test the VR */ if (strcmp (theVr, "OB") == 0 || strcmp (theVr, "OW") == 0 || strcmp (theVr, "SQ") == 0 || strcmp (theVr, "UN") == 0 || strcmp (theVr, "UT") == 0) { /* read 4 more bytes to get the length of the element */ theBuffP = (unsigned char *) &theBuff [0]; i = 4L; /* elemLength */ if ((theErr = (PapyShort) Papy3FRead (theFp, &i, 1L, theBuffP)) < 0) { theErr = Papy3FClose (&theFp); RETURN (papReadFile) } /* if */ /* extract the element length according to the little-endian syntax */ theTmpULong = (PapyULong) (*(theBuffP + 3)); theTmpULong = theTmpULong << 24; theULong = theTmpULong; theTmpULong = (PapyULong) (*(theBuffP + 2)); theTmpULong = theTmpULong << 16; theULong |= theTmpULong; theTmpULong = (PapyULong) (*(theBuffP + 1)); theTmpULong = theTmpULong << 8; theULong |= theTmpULong; theTmpULong = (PapyULong) *theBuffP; theULong |= theTmpULong; theElemLength = theULong; } /* if ...VR = OB, OW, SQ, UN or UT */ else /* other VRs */ { /* updates the current position in the read buffer */ i += 2L; /* extract the element number according to the little-endian syntax */ tmpUShort = (PapyUShort) (*(theBuffP + 1)); tmpUShort = tmpUShort << 8; tmpUShort |= (PapyUShort) *theBuffP; theElemLength = (PapyULong) tmpUShort; } /* else ...other VRs */ } /* else ...explicit VR */ /* undefined length => VR = SQ */ if (theElemLength == 0xFFFFFFFF) { if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_IMPL) Papy3FSeek (theFp, (int) SEEK_CUR, (PapyLong) -8L); else Papy3FSeek (theFp, (int) SEEK_CUR, (PapyLong) -12L); theElemLength = 0L; if ((theErr = ComputeUndefinedSequenceLength3 (inFileNb, &theElemLength)) < 0) return (PapyUShort) theErr; } /* if ...undefined element length */ /* check if the element is a Creator of Private Data Element one */ if (theExtrGrNb == inGroupNb && theExtrElemNb >= 0x0010 && theExtrElemNb <= 0x00FF) { theBuffP = (unsigned char *) &theBuff [0]; if ((theErr = (PapyShort) Papy3FRead (theFp, &theElemLength, 1L, theBuffP)) < 0) { theErr = Papy3FClose (&theFp); RETURN (papReadFile) } /* if */ /* extract the elements value */ theStringP = (char *) emalloc3 ((PapyULong) (theElemLength + 1)); theP = theStringP; theBuffP = theBuff; /* extract the element from the buffer */ for (ii = 0L; ii < theElemLength; ii++, i++) { *(theP++) = theBuffP [(int) ii]; } /* for */ theStringP [ii] = '\0'; /* string terminator */ /* compares the extracted string with the one we are looking for */ if (strncmp (theStringP, inOwnerStrP, strlen (inOwnerStrP)) == 0) { /* is Papyrus the owner of the element */ j = 0; theShOwP = gShadowOwner [inFileNb]; while (!found && j < gNbShadowOwner [inFileNb]) { /* compares both creator strings */ if (strncmp (theStringP, theShOwP->str_value, strlen (theShOwP->str_value)) == 0) found = TRUE; j++; theShOwP++; } /* while ...looking if Papyrus is the owner of the element */ } /* if ...theStringP comparison */ efree3 ((void **) &theStringP); } /* if ...Creator of Private Data Element */ else /* move the file pointer theElemLength farther */ theErr = Papy3FSeek (theFp, (int) SEEK_CUR, (PapyLong) theElemLength); } /* while ...extraction loop */ /* reset the file pointer to its start position */ Papy3FSeek (theFp, (int) SEEK_SET, (PapyLong) theStartPos); /* if the element is creator of a known element returns the range value */ if (found) return theExtrElemNb; else return 0x0000; } /* endof Papy3FindOwnerRange */ /********************************************************************************/ /* */ /* Papy3GotoElemNb : goto the specified element of the current group. */ /* return : the size of the element if OK */ /* else standard error message (-22 = READ ERROR = eof reached) */ /* or we did not find the element (-29) */ /* */ /********************************************************************************/ PapyShort CALLINGCONV Papy3GotoElemNb (PapyShort inFileNb, PapyUShort inGroupNb, PapyUShort inElemNb, PapyULong *outElemLengthP) /*PapyShort inFileNb; the file pointer to read from */ /*PapyShort inGroupNb; the group we want to position to */ /*PapyShort inElemNb; the element we want to position to */ { PAPY_FILE theFp; char theVR [4]; unsigned char theBuff [10], *theCharP; PapyShort theErr; PapyUShort theTmpElemNb, theLastElemNb, theTmpGrNb, theTmpElemL; PapyULong theStartPos, i, j, theTmpULong, theULong; int found = FALSE; /* save the current file position */ theFp = gPapyFile [inFileNb]; Papy3FTell ((PAPY_FILE) theFp, (PapyLong *) &theStartPos); theTmpGrNb = inGroupNb; theTmpElemNb = 0; theLastElemNb = 0; *outElemLengthP = 0L; while (inGroupNb == theTmpGrNb && !found && theTmpElemNb < inElemNb && theLastElemNb <= theTmpElemNb) { Papy3FSeek (theFp, (int) SEEK_CUR, (PapyLong) *outElemLengthP); i = 8L; theCharP = (unsigned char *) &theBuff [0]; if ((theErr = (PapyShort) Papy3FRead (theFp, &i, 1L, theCharP)) < 0) { theErr = Papy3FClose (&theFp); RETURN (papReadFile) } /* if */ theLastElemNb = theTmpElemNb; /* extract the information from the read buffer */ /* updates the current position in the read buffer */ i = (PapyULong) 2L; /* extract the element according to the little-endian syntax */ theTmpGrNb = (PapyUShort) (*(theCharP + 1)); theTmpGrNb = theTmpGrNb << 8; theTmpGrNb |= (PapyUShort) *theCharP; /* points to the right place in the buffer */ theCharP = theBuff; theCharP += i; /* updates the current position in the read buffer */ i += 2L; /* extract the element according to the little-endian syntax */ theTmpElemNb = (PapyUShort) (*(theCharP + 1)); theTmpElemNb = theTmpElemNb << 8; theTmpElemNb |= (PapyUShort) *theCharP; /* points to the right place in the buffer */ theCharP = theBuff; theCharP += i; /* if it is EXPLICIT VR */ if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL || theTmpGrNb == 0x0002) { theVR [0] = (char) *theCharP; theVR [1] = (char) *(theCharP + 1); theVR [2] = '\0'; theCharP += 2; /* jump over the VR */ /* updates the current position in the read buffer */ i += 2L; if (strcmp (theVR, "OB") == 0 || strcmp (theVR, "OW") == 0 || strcmp (theVR, "SQ") == 0 || strcmp (theVR, "UN") == 0 || strcmp (theVR, "UT") == 0) { /* 2 bytes are set to blank so jump over them */ i += 2L; theCharP +=2; /* read 4 more chars from the file */ j = 4L; theCharP = (unsigned char *) &theBuff [0]; if ((theErr = (PapyShort) Papy3FRead (theFp, &j, 1L, theCharP)) < 0) { theErr = Papy3FClose (&theFp); RETURN (papReadFile) } /* if */ /* extract the element according to the little-endian implicit syntax */ theTmpULong = (PapyULong) (*(theCharP + 3)); theTmpULong = theTmpULong << 24; theULong = theTmpULong; theTmpULong = (PapyULong) (*(theCharP + 2)); theTmpULong = theTmpULong << 16; theULong |= theTmpULong; theTmpULong = (PapyULong) (*(theCharP + 1)); theTmpULong = theTmpULong << 8; theULong |= theTmpULong; theTmpULong = (PapyULong) *theCharP; theULong |= theTmpULong; *outElemLengthP = theULong; /* updates the number of bytes read */ i += 4L; } /* if ...vr = OB, OW, SQ, UN or UT */ else /* other VRs */ { /* extract the element according to the little-endian explicit vr syntax */ theTmpElemL = (PapyUShort) (*(theCharP + 1)); theTmpElemL = theTmpElemL << 8; theTmpElemL |= (PapyUShort) *theCharP; *outElemLengthP = (PapyULong) theTmpElemL; /* updates the number of bytes read */ i += 2L; } /* else ...other VRs */ } /* if ...Little-endian EXPLICIT VR */ else /* Little-endian IMPLICIT VR */ { /* extract the element according to the little-endian implicit syntax */ theTmpULong = (PapyULong) (*(theCharP + 3)); theTmpULong = theTmpULong << 24; theULong = theTmpULong; theTmpULong = (PapyULong) (*(theCharP + 2)); theTmpULong = theTmpULong << 16; theULong |= theTmpULong; theTmpULong = (PapyULong) (*(theCharP + 1)); theTmpULong = theTmpULong << 8; theULong |= theTmpULong; theTmpULong = (PapyULong) *theCharP; theULong |= theTmpULong; *outElemLengthP = theULong; /* updates the current position in the read buffer */ i += 4L; } /* else ...little-endian IMPLICIT VR */ /* have we got the element ? */ if (inGroupNb == theTmpGrNb && inElemNb == theTmpElemNb) found = TRUE; /* undefined length => VR = SQ */ if (*outElemLengthP == 0xFFFFFFFF && !(inGroupNb == 0x7FE0 && inElemNb == 0x0010)) { Papy3FSeek (theFp, (int) SEEK_CUR, -(PapyLong)i); *outElemLengthP = 0L; if ((theErr = ComputeUndefinedSequenceLength3 (inFileNb, outElemLengthP)) < 0) return theErr; } /* if ...undefined element length */ } /* while ...looking for the pointer sequence */ /* if element not reached reset the file pointer to its original position */ if (!found) { Papy3FSeek (theFp, (int) SEEK_SET, (PapyLong) theStartPos); return (PapyShort) papNotFound; } /* if ...element not found */ /* else go back to the begining of the element */ else Papy3FSeek (theFp, (int) SEEK_CUR,-(PapyLong)i); return 0; } /* endof Papy3GotoElemNb */ /********************************************************************************/ /* */ /* Papy3ExtractItemLength : get the length of an item from the item */ /* delimiter */ /* return : the size of the item if OK */ /* else standard error message */ /* */ /********************************************************************************/ PapyULong CALLINGCONV Papy3ExtractItemLength (PapyShort inFileNb) { PAPY_FILE theFp; PapyUShort theUS; PapyULong theItemLength, theBufPos, i; unsigned char *theBuffP, theBuff [8]; theFp = gPapyFile [inFileNb]; theBuffP = (unsigned char *) &theBuff [0]; /* read the file until the item length value */ i = 8L; if (Papy3FRead (theFp, &i, 1L, theBuffP) < 0) { Papy3FClose (&theFp); RETURN (papReadFile) } /* if */ /* extract the values from the buffer */ theBufPos = 0L; theUS = Extract2Bytes (theBuffP, &theBufPos); if (theUS != 0xFFFE) return (PapyULong) papGroupNumber; theUS = Extract2Bytes (theBuffP, &theBufPos); if (theUS != 0xE000) return (PapyULong) papElemNumber; theItemLength = Extract4Bytes (theBuffP, &theBufPos); if (theItemLength <= 0) return (PapyULong) papElemSize; else if (theItemLength == 0xFFFFFFFF) ComputeUndefinedItemLength3 (inFileNb, &theItemLength); return theItemLength; } /* endof Papy3ExtractItemLength */ /********************************************************************************/ /* */ /* ComputeUndefinedItemLength3 : compute the size of an item of undefined */ /* length, starting from the current file position. */ /* */ /********************************************************************************/ PapyShort ComputeUndefinedItemLength3 (PapyShort inFileNb, PapyULong *ioItemLengthP) { PapyULong theElemLength, theBufPos, theFileStartPos, i; PapyUShort theGrNb, theElemNb; char theVR [3]; unsigned char *theBuffP, theBuff [8]; int OK; /* initialisation */ theGrNb = 0; theElemNb = 0; theElemLength = 0L; OK = FALSE; theVR [0] = '\0'; Papy3FTell ((PAPY_FILE) gPapyFile [inFileNb], (PapyLong *) &theFileStartPos); /* allocate the read buffer */ theBuffP = (unsigned char *) &theBuff [0]; /* look for the end of item delimiter */ while (!OK) { /* read the file until the item length value */ i = 8L; if (Papy3FRead (gPapyFile [inFileNb], &i, 1L, theBuffP) < 0) { Papy3FClose (&(gPapyFile [inFileNb])); RETURN (papReadFile) } /* if */ *ioItemLengthP += 8L; /* get the group number, the element number and the element length of the */ /* group */ theBufPos = 0L; theGrNb = Extract2Bytes (theBuffP, &theBufPos); theElemNb = Extract2Bytes (theBuffP, &theBufPos); /* extract the element length depending on the syntax */ if ((gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_IMPL && theGrNb != 0x0002) || (theGrNb == 0xFFFE && theElemNb == 0xE000) || (theGrNb == 0xFFFE && theElemNb == 0xE00D)) theElemLength = Extract4Bytes (theBuffP, &theBufPos); else { /* extract the VR */ theBuffP += theBufPos; theVR [0] = (char) *theBuffP; theVR [1] = (char) *(theBuffP + 1); theVR [2] = '\0'; theBuffP = (unsigned char *) &theBuff [0]; theBufPos += 2; /* get the element length depending on the VR */ if (strcmp (theVR, "OB") == 0 || strcmp (theVR, "OW") == 0 || strcmp (theVR, "SQ") == 0 || strcmp (theVR, "UN") == 0 || strcmp (theVR, "UT") == 0) { /* read 4 more bytes */ i = 4L; if (Papy3FRead (gPapyFile [inFileNb], &i, 1L, theBuffP) < 0) { Papy3FClose (&(gPapyFile [inFileNb])); RETURN (papReadFile) } /* if */ *ioItemLengthP += 4L; theBufPos = 0L; theElemLength = Extract4Bytes (theBuffP, &theBufPos); } else theElemLength = (PapyULong) Extract2Bytes (theBuffP, &theBufPos); } /* else ...EXPLICIT VR */ /* is it the end of item delimiter ? */ if (!(theGrNb == 0xFFFE && theElemNb == 0xE00D && theElemLength == 0L)) { /* if the element <> outGroupLengthP => group of undefined size */ if (theElemNb != 0x0000) { /* restore the previous file position */ if ((theGrNb == 0x0002 || gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL) && (strcmp (theVR, "SQ") == 0 || strcmp (theVR, "OB") == 0 || strcmp (theVR, "OW") == 0)) { Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_CUR, (PapyLong) -12L); *ioItemLengthP -= 12L; } /* if */ else { Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_CUR, (PapyLong) -8L); *ioItemLengthP -= 8L; } /* else */ theElemLength = ComputeUndefinedGroupLength3 (inFileNb, -1L); if ((int) theElemLength < 0) RETURN ((PapyShort) theElemLength); } /* if ...has to compute the group length */ /* add the size of the group to the item length */ *ioItemLengthP += theElemLength; /* move the file pointer */ Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_CUR, (PapyLong) theElemLength); } /* if ...not end of item delimiter */ /* we have reached the end of Item delimiter tag */ else { OK = TRUE; *ioItemLengthP -= 8L; } /* else */ } /* while ...look for the end of item delimiter */ /* reset the file pointer to its previous position */ Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) theFileStartPos); return 0; } /* endof ComputeUndefinedItemLength3 */ /********************************************************************************/ /* */ /* ComputeUndefinedSequenceLength3 : compute the size of a sequence of */ /* undefined length, starting from the current file position. */ /* */ /********************************************************************************/ PapyShort ComputeUndefinedSequenceLength3 (PapyShort inFileNb, PapyULong *ioSeqLengthP) { PapyULong theElemLength, theBufPos, theFileStartPos, i; PapyUShort theGrNb, theElemNb; char theVR [3]; unsigned char *theBuffP, theBuff [8]; int OK, theErr = 0; /* initialisation */ theGrNb = 0; theElemNb = 0; theElemLength = 0L; OK = FALSE; Papy3FTell (gPapyFile [inFileNb], (PapyLong *) &theFileStartPos); /* allocate the read buffer */ theBuffP = (unsigned char *) &theBuff [0]; /* look for the end of sequence delimiter */ while (!OK) { /* read the file until the item length value */ i = 8L; if (Papy3FRead (gPapyFile [inFileNb], &i, 1L, theBuffP) < 0) { Papy3FClose (&(gPapyFile [inFileNb])); RETURN (papReadFile) } /* if */ *ioSeqLengthP += 8L; /* get the group number, the element number and the element length of the */ /* item delimiter element */ theBufPos = 0L; theGrNb = Extract2Bytes (theBuffP, &theBufPos); theElemNb = Extract2Bytes (theBuffP, &theBufPos); /* extract the element length depending on the syntax */ if ((gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_IMPL && theGrNb != 0x0002) || (theGrNb == 0xFFFE && theElemNb == 0xE000) || (theGrNb == 0xFFFE && theElemNb == 0xE00D) || (theGrNb == 0xFFFE && theElemNb == 0xE0DD)) theElemLength = Extract4Bytes (theBuffP, &theBufPos); else { /* extract the VR */ theBuffP += theBufPos; theVR [0] = (char) *theBuffP; theVR [1] = (char) *(theBuffP + 1); theVR [2] = '\0'; theBuffP = (unsigned char *) &theBuff [0]; theBufPos += 2; /* get the element length depending on the VR */ if (strcmp (theVR, "OB") == 0 || strcmp (theVR, "OW") == 0 || strcmp (theVR, "SQ") == 0 || strcmp (theVR, "UN") == 0 || strcmp (theVR, "UT") == 0) { /* read 4 more bytes */ i = 4L; if (Papy3FRead (gPapyFile [inFileNb], &i, 1L, theBuffP) < 0) { Papy3FClose (&(gPapyFile [inFileNb])); RETURN (papReadFile) } /* if */ *ioSeqLengthP += 4L; theBufPos = 0L; theElemLength = Extract4Bytes (theBuffP, &theBufPos); } else theElemLength = (PapyULong) Extract2Bytes (theBuffP, &theBufPos); } /* else ...EXPLICIT VR */ /* is it the sequence delimiter ? */ if (!((theGrNb == 0xFFFE) && (theElemNb == 0xE0DD) && (theElemLength == 0L))) { /* if the element has an undefined length (i.e. item of undefined length */ if (theElemLength == 0xFFFFFFFF) { theElemLength = 0L; if ((theErr = (int) ComputeUndefinedItemLength3 (inFileNb, &theElemLength)) < 0) RETURN (theErr); } /* if */ *ioSeqLengthP += theElemLength; /* move the file pointer */ Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_CUR, (PapyLong) theElemLength); } /* if ...not sequence delimiter */ else OK = TRUE; } /* while ...looking for the end of the sequence */ /* reset the file pointer to its previous position */ Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) theFileStartPos); return 0; } /* endof ComputeUndefinedSequenceLength3 */ /********************************************************************************/ /* */ /* ComputeUndefinedGroupLength3 : compute the size of a group of undefined */ /* length, starting from the current file position. */ /* return : the size of the group if OK */ /* else standard error message */ /* */ /********************************************************************************/ PapyULong ComputeUndefinedGroupLength3 (PapyShort inFileNb, PapyLong inMaxSize) { PapyULong theGroupLength, theElemLength, theBufPos, theFileStartPos, i; PapyUShort theGrNb, theCmpGrNb, theElemNb, theCmpElemNb; PapyShort theErr; char theVR [3]; unsigned char *theBuffP, theBuff [8]; int OK; /* initializations */ strcpy (theVR, " "); if (inMaxSize == -1) inMaxSize = 1000000; /* arbitrary value */ theGroupLength = 0L; Papy3FTell (gPapyFile [inFileNb], (PapyLong *) &theFileStartPos); theBuffP = (unsigned char *) &theBuff [0]; /* read the group number and the element number from the file */ i = 4L; if ((theErr = (PapyShort) Papy3FRead (gPapyFile [inFileNb], &i, 1L, theBuffP)) < 0) { theErr = (PapyShort) Papy3FClose (&(gPapyFile [inFileNb])); RETURN (papReadFile) } /* if */ /* get the group number and the element number */ theBufPos = 0L; theGrNb = Extract2Bytes (theBuffP, &theBufPos); theElemNb = Extract2Bytes (theBuffP, &theBufPos); /* set some comparison variables */ theCmpGrNb = theGrNb; theCmpElemNb = theElemNb; /* reset the file pointer to its previous position */ Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) theFileStartPos); /* loop on the elements of the group */ OK = FALSE; while (!OK) { /* read the file until the element length value */ i = 8L; if ((theErr = (PapyShort) Papy3FRead (gPapyFile [inFileNb], &i, 1L, theBuffP)) < 0) { theErr = (PapyShort) Papy3FClose (&(gPapyFile [inFileNb])); /* Modif DRD RETURN (papReadFile) */ return 0; } /* if */ theGroupLength += 8L; /* get the group number, the element number and the element length */ theBufPos = 0L; theGrNb = Extract2Bytes (theBuffP, &theBufPos); theElemNb = Extract2Bytes (theBuffP, &theBufPos); /* reset the VR ... */ theVR [0] = 'A'; theVR [1] = 'A'; theVR [2] = '\0'; /* extract the element length depending on the syntax */ if ((gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_IMPL && theGrNb != 0x0002) || (theGrNb == 0xFFFE && theElemNb == 0xE000) || (theGrNb == 0xFFFE && theElemNb == 0xE00D)) theElemLength = Extract4Bytes (theBuffP, &theBufPos); else { /* extract the VR */ theBuffP += theBufPos; theVR [0] = (char) *theBuffP; theVR [1] = (char) *(theBuffP + 1); theVR [2] = '\0'; theBuffP = (unsigned char *) &theBuff [0]; theBufPos += 2; /* get the element length depending on the VR */ if (strcmp (theVR, "OB") == 0 || strcmp (theVR, "OW") == 0 || strcmp (theVR, "SQ") == 0 || strcmp (theVR, "UN") == 0 || strcmp (theVR, "UT") == 0) { /* DICOMDIR : here is the record sequence*/ if (theGrNb == 0x0004 && theElemNb == 0x1220) { i = 6L; /* read 6 more bytes: 2(elem) 4(value unuseful) */ if (Papy3FRead (gPapyFile [inFileNb], &i, 1L, theBuffP) < 0) { Papy3FClose (&(gPapyFile [inFileNb])); RETURN (papReadFile) } /* if */ theGroupLength -= 8L; theElemLength = 0L; OK = TRUE; } /* if ...elem = 0x0004, 0x1220 */ else { /* read 4 more bytes */ i = 4L; if (Papy3FRead (gPapyFile [inFileNb], &i, 1L, theBuffP) < 0) { Papy3FClose (&(gPapyFile [inFileNb])); RETURN (papReadFile) } /* if */ theGroupLength += 4L; theBufPos = 0L; theElemLength = Extract4Bytes (theBuffP, &theBufPos); } /* else ...elem not 0x0004, 0x1220 */ } /* if ...VR = OB, OW, SQ, Un or UT */ else theElemLength = (PapyULong) Extract2Bytes (theBuffP, &theBufPos); } /* else ...EXPLICIT VR */ /* makes sure the element belongs to the group */ if (theCmpGrNb == theGrNb && theCmpElemNb <= theElemNb && theGroupLength < (PapyULong) inMaxSize) { /* if the element has an undefined length (i.e. VR = SQ) */ if (theElemLength == 0xFFFFFFFF) { theElemLength = 0L; if ((theErr = ComputeUndefinedSequenceLength3 (inFileNb, &theElemLength)) < 0) RETURN ((PapyULong) theErr); } /* if */ /* add the size of the element to the group size */ theGroupLength += theElemLength; /* move the file pointer */ if ((theErr = Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_CUR, (PapyLong) theElemLength)) < 0) RETURN ((PapyULong) theErr); } /* if ...element in group */ else { OK = TRUE; theGroupLength -= 8L; if (strcmp (theVR, "OB") == 0 || strcmp (theVR, "OW") == 0 || strcmp (theVR, "SQ") == 0) theGroupLength -= 4L; } /* else ...end of group reached */ } /* while ...loop on the elem of the group */ /* reset the file position to the begining of the group */ Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) theFileStartPos); return theGroupLength; } /* endof ComputeUndefinedGroupLength3 */ Papyrus3/PapyPrivFunctionDef3.h0000755000175000017500000001552110044205746013670 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyPrivFunctionDef3.h */ /* Function : contains the declarations of the private functions */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 01.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef PapyPrivFunctionDef3H #define PapyPrivFunctionDef3H /* --- functions definitions --- */ /* --- PapyDataSetRead3 --- */ PapyShort ExtractFileMetaInformation3 (PapyShort); PapyShort ExtractPapyDataSetInformation3 (PapyShort); PapyShort ExtractDicomDataSetInformation3 (PapyShort); PapyShort ExtractGroup28Information (PapyShort); /* --- PapyDataSetWrite3 --- */ void LookForGroupsInModule3 (Module *, int, int *, int *); PapyShort ItemModulesToGroups3 (PapyShort, Item *, int); PapyShort ItemRecordsToGroups3 (PapyShort, Item *, int); int Papy3GetRecordType (SElement *); PapyShort CreateFileMetaInformation3 (PapyShort, enum EPap_Compression, enum ETransf_Syntax, enum EModality); void KeepReferences3 (PapyShort, int, int, UValue_T *); PapyShort SequencesToGroups3 (PapyShort, Item *, int); PapyShort CreateTmpFile3 (PapyShort, PAPY_FILE *, void **); PapyShort WriteDicomHeader3 (PAPY_FILE, PapyShort, PapyULong *); /* --- PapyFiles3 --- */ PapyULong ComputeUndefinedGroupLength3 (PapyShort, PapyLong); PapyShort ComputeUndefinedSequenceLength3 (PapyShort, PapyULong *); PapyShort ComputeUndefinedItemLength3 (PapyShort, PapyULong *); PapyShort ReadGroup3 (PapyShort, PapyUShort *, unsigned char **, PapyULong *, PapyULong *); PapyShort WriteGroup3 (PAPY_FILE fp, unsigned char *, PapyULong); /* --- PapyInit3 --- */ void InitGroup3 (int, SElement *); void InitModule3 (int, SElement *); void InitGroupNbAndSize3 (); void InitModuleSize3 (); void InitDataSetModules3 (); void InitUIDs3 (); void InitModulesLabels3 (); Module* CreateModule3 (int); PapyShort Papy3FreeSQElement (SElement **, Module *, int); /* --- PapyRead3 --- */ PapyShort PutBufferInGroup3 (PapyShort, unsigned char *, SElement *, PapyUShort, PapyULong, PapyULong *, PapyLong); PapyUShort Extract2Bytes (unsigned char *, PapyULong *); extern PapyULong Extract4Bytes (unsigned char *, PapyULong *); /* --- PapyWrite3 --- */ PapyShort ComputeGroupLength3 (PapyShort, SElement *, PapyULong *, enum ETransf_Syntax); PapyULong ComputeSequenceLength3 (Item *, enum ETransf_Syntax); void Put4Bytes (PapyULong, unsigned char *, PapyULong *); PapyShort PutGroupInBuffer (PapyShort, PapyShort, int , SElement *, unsigned char *, PapyULong *, int); #endif /* PapyPrivFunctionDef3H */ Papyrus3/PapyError3.h0000755000175000017500000001737510044205044011714 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyError3.h */ /* Function : Error codes and macros for papyrus generated errors */ /* Authors : Jean-Francois Vurlod */ /* Christian Girard */ /* */ /* History : 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef PapyError3H #define PapyError3H #ifdef NDEBUG #define NODEBUG #endif typedef enum { papNoError = 0, papErrorInPapyErrNo = -1, papNotImplemented = -2, /********************************************************/ /* System Errors */ /********************************************************/ papClib = -3, /* This is the code set for any unix c-library call that returns a bad value. The caller, if interested, can check the global variable errno.*/ papNoMemory = -4, /* Error in allocating heap memory. */ papUIDUnknow = -5, /* PapyRead */ papReadGroup = -6, papWriteGroup = -7, papTooMuchOverlays = -8, /* current overlay is > kMax_overlay */ papTooMuchUINOverlays = -9, /* current overlay is > kMax_UIN_overlay */ papElemOfTypeOneNotFilled = -10, papMissingGr8 = -11, papImageFileNameNotDefind = -12, papLengthIsNotEven = -13, papProblemInValue = -14, papProblemInAscii = -15, papProblemInDef = -16, papTooManyImages = -17, papEnumGroup = -18, papIndexBigger = -19, papNbImagesIsZero = -20, papMaxOpenFile = -21, papFileAlreadyExist = -22, papFileCreationFailed = -23, papReadingOpenFile = -24, papNotFound = -29, papOpenFile = -30, /* error opening file */ papCLOSE_FILE = -31, /* error closing file */ papReadFile = -32, /* error reading file */ papWriteFile = -33, /* error writing to file */ papFileName = -34, /* wrong filename */ papPositioning = -35, /* error positioning the file pointer */ papElemNumber = -36, /* wrong element number */ papElemSize = -37, /* wrong element size */ papGroupErr = -38, /* error in group */ papGroupNumber = -39, /* wrong group number */ papBadArgument = -40, papListError = -41, /* pointer error in the list */ papSyntaxNotImplemented = -42, /* DICOM transfert syntax not implemented */ papCompressNotImplemented = -43, /* compression syntax not implemented */ papUnknownModality = -44, /* Imaging modality unknown in DICOM */ papMissingModule = -45, /* a mandatory module is missing */ papNotPapyrusFile = -46, /* this is not a Papyrus file */ papDeleteFile = -47, papWrongValue = -48, /* a wrong value was found in the file */ papWrongPapVersion = -49, /* file version newer than version of the toolkit */ papLastErrorNb = -50 } EPapyError3; /* --- variable definition --- */ extern EPapyError3 gPapyErrNo; extern char *PapyErrorList []; extern int gPapyErrLigne []; extern char *gPapyErrFileP []; /* --- function definition --- */ extern void Papy3CheckError (int, char *, int); #ifdef NODEBUG #define RETURN(CodeErr) return(CodeErr); #else #define RETURN(CodeErr)\ {\ Papy3CheckError(CodeErr,__FILE__,__LINE__);\ return(CodeErr);\ } #endif #endif /* PapyError3H */ Papyrus3/Papyrus3.dsw0000755000175000017500000000261207535143454012007 0ustar Microsoft Developer Studio Workspace File, Format Version 6.00 # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! ############################################################################### Project: "Jpglless"=.\JpegDir\JpgLless\Jlless.dsp - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Project: "Jpglossy"=.\JpegDir\JpgLossy\Jlossy.dsp - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Project: "Papyrus3"=.\Papyrus3.dsp - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ Begin Project Dependency Project_Dep_Name Jpglless End Project Dependency Begin Project Dependency Project_Dep_Name Jpglossy End Project Dependency Begin Project Dependency Project_Dep_Name dicomdir End Project Dependency }}} ############################################################################### Project: "dicomdir"=.\dicomdir\dicomdir.dsp - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Global: Package=<5> {{{ }}} Package=<3> {{{ }}} ############################################################################### Papyrus3/PapyConvertFile3.c0000755000175000017500000015711110044201776013037 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyConvertFile3.c */ /* Function : contains all the Convertion function */ /* Authors : Marianne Logean */ /* */ /* History : 12.1999 version 1.0 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 11.2001 Modify T1_taille for RGB */ /* */ /********************************************************************************/ /* ------------------------- includes ---------------------------------------*/ #include #include #include #define CHECK_MEMORY #define HAVE_BOOLEAN #include "jpegless.h" /* interface for JPEG lossless */ #include "jpeglib.h" /* interface for JPEG lossy */ #ifndef Papyrus3H #include "Papyrus3.h" #endif struct color /* a color is defined by its red, green and blue intensity */ { int r; int g; int b; }; /********************************************************************************/ /* */ /* ExtractSelection : */ /* return : */ /* */ /********************************************************************************/ PapyUShort * ExtractSelection(PapyUShort *image_buffer, int image_width, int depth, int x1, int y1, int x2, int y2) { PapyUShort i, j, decal; PapyULong sel_dim; sel_dim = (PapyULong)((PapyULong)(x2 - x1) * (y2 - y1)); decal = image_width * y1; if (depth == 8) { PapyUChar *sel_bufferC, *bufferC, *imageChar; PapyUChar *image = (PapyUChar *) emalloc3 ((PapyULong) sel_dim + 1L); sel_bufferC = image; /*bufferC = (PapyUChar *) image_buffer; bufferC += decal; for (i = y1; i < y2; i++) { bufferC += x1; for (j = x1; j < x2; j++) { *sel_bufferC++ = *bufferC++; } bufferC += (image_width - x2); }*/ imageChar = (PapyUChar *) image_buffer; for (j = 0; j < (y2 - y1); j++) { bufferC = imageChar + ((long)x1 + image_width * (y1 + j)); for (i = 0; i < (x2 - x1); i++) *sel_bufferC++ = *bufferC++; }/* endfor */ return ((PapyUShort *) image); } else { PapyUShort *sel_bufferS, *bufferS; PapyUShort *image = (PapyUShort *) emalloc3 ((PapyULong) sel_dim * sizeof (PapyUShort) + 1L); sel_bufferS = image; /*bufferS = (PapyUShort *) image_buffer; bufferS += decal; for (i = y1; i < y2; i++) { bufferS += x1; for (j = x1; j < x2; j++) { *sel_bufferS++ = *bufferS++; } bufferS += (image_width - x2); }*/ for (j = 0; j < (y2 - y1); j++) { bufferS = image_buffer + ((long)x1 + image_width * (y1 + j)); for (i = 0; i < (x2 - x1); i++) *sel_bufferS++ = *bufferS++; }/* endfor */ return ((PapyUShort *) image); } } /* endof ExtractSelection */ /********************************************************************************/ /* */ /* GetPapyFileType : */ /* return : the format of the given file */ /* */ /********************************************************************************/ int GetPapyFileType (char *filename, int *imageNb, int *imageNo, enum EModality *modality) { /* verify if it is Papyrus3 or dicom file or Papyrus2 */ PapyShort file; int fileKind; PapyShort theErr; int theElemType; PapyULong theNbVal; UValue_T *theValP; SElement *theGroup20P; if ((file = Papy3FileOpen (filename, (PAPY_FILE) 0, TRUE, 0)) >= 0) { *imageNb = (int) Papy3GetNbImages (file); *modality = (enum EModality) Papy3GetModality (file); /* if it is a DICOM file: search the dicom image number from the serie */ if (gIsPapyFile [file] == DICOM10 || gIsPapyFile [file] == DICOM_NOT10) { /* Image no in Dicom serie */ *imageNo = 0; Papy3GotoNumber (file, 1, DataSetID); /* goto group 0x0020 */ if ((theErr = Papy3GotoGroupNb (file, 0x0020)) == 0) { /* read group 0x0020 from the file */ if ((theErr = Papy3GroupRead (file, &theGroup20P)) > 0) { /* ACQUISITION NUMBER */ theValP = Papy3GetElement (theGroup20P, papAcquisitionNumberGr, &theNbVal, &theElemType); if (theValP != NULL) *imageNo = atoi(theValP->a); /* IMAGE NUMBER */ theValP = Papy3GetElement (theGroup20P, papImageNumberGr, &theNbVal, &theElemType); if (theValP != NULL) *imageNo = atoi(theValP->a); /* free the group 20 */ theErr = Papy3GroupFree (&theGroup20P, TRUE); }/* read group 0x0020 */ }/* goto group 0x0020 */ }/* if it is a DICOM file */ /* close the file a la Papyrus 3 */ Papy3FileClose (file, TRUE); fileKind = Papy3GetFileKind (file); if (fileKind == 1) return PAPYRUS3; if (fileKind == 0 || fileKind == 2) return DICOM10; else if (fileKind == 3) return other; } else return file; } /* endof GetPapyFileType */ /********************************************************************************/ /* */ /* TI_taille : resize the original image */ /* return : */ /* */ /********************************************************************************/ unsigned char* TI_taille(unsigned char *ori, int orix, int oriy, int dstx, int dsty, int depth, int numPlans, long *taille) { int n, i, j, k, l, m, linescanned, dstimx, dstimy, diffx, diffy; float nf; long oritaille; unsigned char *tmp; unsigned char *oriplane; if (orix > oriy) nf=(float)((float)orix/dstx); else nf=(float)((float)oriy/dsty); n = (int) nf; /* use round when divide result is not an integer */ if ((nf - n) > 0) n++; dstimx = orix/n; dstimy = oriy/n; /* bords de l'image a remplir */ diffx = (dstx - dstimx) / 2; diffy = (dsty - dstimy) / 2; oritaille = (long)orix * (long)oriy; *taille = (long)dstx * (long)dsty; tmp = (unsigned char *) emalloc3 (*taille * (long) numPlans * sizeof(unsigned char)); /*for (i=0;iGetColorManager()->FromCalibratedToRaw (fOriginalImage->GetColorManager()->fMinForkCalib); forkMax = fOriginalImage->GetColorManager()->FromCalibratedToRaw (fOriginalImage->GetColorManager()->fMaxForkCalib); */ /* ============================ 8BITS IMAGE ================================ */ size = inColumns * inRows; newPixmap = (PapyUChar *) emalloc3 ((PapyULong) size); p8b = newPixmap; p16b = inPixmap; if (inDepth > 8) { /* conversion to 8 bit image convert the 16 bit image into 8 bit image */ unsigned short *tab; /* conversion array */ unsigned short dminmax = inMax - inMin; int min = inMin; int max = inMax; if (min < 0) min = 0; if (max < 0) max = 0; tab = (unsigned short *) emalloc3 (65535L * sizeof(unsigned short)); /* conversion array */ for (i=min; i<=max; i++) tab [i] = (unsigned short) (((long)(i - min)) * 255 / dminmax); for (i=0; imoduleName); if (module == NULL) { /* we have to create the module */ module = Papy3CreateModule (dataSet, wrkDS->moduleName); moduleCreated = TRUE; } /* if ...an error occured (bad DICOM file ?) */ /* depending on the module add the modified elements */ switch (wrkDS->moduleName) { case Patient : /* if we dont want to save the patient name (anonymous file) */ /*if (hidePatName == TRUE) { err = Papy3ClearElement (module, papPatientsNameP, TRUE); strcpy (myStringPtr, "Anonymous"); Papy3PutElement (module, papPatientsNameP, &myStringPtr); err = Papy3ClearElement (module, papOtherPatientNamesP, TRUE); }*/ /* if ...hide patient name */ break; case GeneralStudy : /* build a foo Study Instance UID */ if (module [papStudyInstanceUIDGS].nb_val == 0) { strcpy (myStringPtr, "1.2.756.9999.999.99.9"); Papy3PutElement (module, papStudyInstanceUIDGS, &myStringPtr); } /* if */ break; case GeneralSeries : /* build a foo Series Instance UID */ if (module [papSeriesInstanceUIDGS].nb_val == 0) { strcpy (myStringPtr, "1.2.756.9999.999.99.9"); Papy3PutElement (module, papSeriesInstanceUIDGS, &myStringPtr); } /* if */ break; case FrameOfReference : if (module [papFrameofReferenceUID].nb_val == 0L) { strcpy (myStringPtr, "41.22.333.444.555.666.00.1"); Papy3PutElement (module, papFrameofReferenceUID, &myStringPtr); } /* if */ break; case GeneralImage : if (gCompression == NONE) strcpy (myStringPtr, "00"); else strcpy (myStringPtr, "01"); Papy3PutElement (module, papLossyImageCompressionGI, &myStringPtr); break; case ImagePixel : { Papy3ClearElement (module, papSamplesperPixelIP, TRUE); valUS = 1; Papy3PutElement (module, papSamplesperPixelIP, &valUS); if (module [papPixelRepresentationIP].nb_val == 0) { valUS = 0; Papy3PutElement (module, papPixelRepresentationIP, &valUS); } val = Papy3GetElement (module, papRows, &nbVal, &valType); rows = val->us; val = Papy3GetElement (module, papColumns, &nbVal, &valType); columns = val->us; leftcolumns = (int) (gLeftX*columns); toprows = (int) (gTopY*rows); rightcolumns = (int) (gRightX*columns); bottomrows = (int) (gBottomY*rows); Papy3ClearElement (module, papRows, TRUE); selectedrows = (unsigned short) (bottomrows - toprows); Papy3PutElement (module, papRows, &selectedrows); Papy3ClearElement (module, papColumns, TRUE); selectedcolumns = (unsigned short) (rightcolumns - leftcolumns); Papy3PutElement (module, papColumns, &selectedcolumns); /* bits allocated and stored */ val = Papy3GetElement (module, papBitsAllocatedIP, &nbVal, &valType); bitsAllocated = val->us; /* min and max pixel value in the image */ /* valUS = (PapyUShort) newRealImage->GetMinImage (); Papy3PutElement (module, papSmallestImagePixelValue, &valUS); valUS = (PapyUShort) newRealImage->GetMaxImage (); Papy3PutElement (module, papLargestImagePixelValue, &valUS); */ /* PIXEL DATA */ /*image = (PapyUShort *)Papy3GetPixelData (fpOrig, imageNo, module, ImagePixel);*/ Papy3GotoNumber (fpOrig, imageNo, DataSetID); /* then goto group 0x7FE0 */ Papy3GotoGroupNb (fpOrig, 0x7FE0); Papy3GroupRead (fpOrig, &group); /* get the original image because image not present in the module */ /* with Papy3GetModule () */ image = (PapyUShort *)Papy3GetPixelData (fpOrig, imageNo, group, ImagePixel); selectedImage = ExtractSelection (image, columns, bitsAllocated, leftcolumns, toprows, rightcolumns, bottomrows); efree3 ((void **) &image); /* put the image */ Papy3PutImage ((PapyShort)fp, module, papPixelData, selectedImage, (PapyUShort) selectedrows, (PapyUShort) selectedcolumns, (PapyUShort) bitsAllocated, 0L); Papy3GotoNumber (fpOrig, imageNo, DataSetID); } break; case CTImage: { Papy3ClearElement (module, papReconstructionDiameterCTI, TRUE); /* if (!strncmp (fMedStudy->GetPixelSizeUnit (), "mm", 2)) { float pixelSize = fMedStudy->GetPixelSize (); pixelSize = pixelSize * 100 / fParam->zoomFactor; sprintf (myStringPtr, "%.5f", (float) (pixelSize * selectedcolumns)); Papy3PutElement (module, papReconstructionDiameterCTI, &myStringPtr); } */ /* if ...image has been callibrated */ } break; case VOILUT : { /* compute the WW and WL of the image */ /* int WW = fSaveImage->GetForkMax () - fSaveImage->GetForkMin () + 1; int WL = (int) ((WW / 2) + fSaveImage->GetForkMin ()); */ /* clear any previous value */ Papy3ClearElement (module, papWindowCenter, TRUE); Papy3ClearElement (module, papWindowWidth, TRUE); /* then put the new one */ /* IntToString (WL, myStringPtr); Papy3PutElement (module, papWindowCenter, &myStringPtr); IntToString (WW, myStringPtr); Papy3PutElement (module, papWindowWidth, &myStringPtr); */ } break; default : break; } /* switch ...add the modified elements */ /* link the read module to the list of modules of the data set to write */ if (!moduleCreated) Papy3LinkModuleToDS (dataSet, module, wrkDS->moduleName); wrkDS++; } /* for ...loop on the modules of the CT images */ /* close the data set and frees the modules */ err = Papy3CloseDataSet (fp, dataSet, TRUE, TRUE); } /* endfor ...loop on the images */ /* close the original file */ err = (int) Papy3FileClose (fpOrig, TRUE); /* close the file */ err = Papy3WriteAndCloseFile (fp, TRUE); if (err < 0) { PAPY3PRINTERRMSG (); return -1;} } /* endof Papyrus2Papyrus */ /********************************************************************************/ /* */ /* Papyrus2Dicom : convert Papyrus3 file into DICOM format */ /* return : */ /* */ /********************************************************************************/ int Papyrus2Dicom (char *inPapyrusFilename, char *outDicomFilename, PAPY_FILE aRefNum, int nbImages, int *tabImage) { PapyShort fp, fpOrig; int nbImagesOrig, imageNo, *tabIm; /* PapyUShort *image, bitsAllocated, rows, columns; */ enum EModality mod; char myString [256], *myStringPtr; int isOpenOrClose; /*int leftcolumns, toprows, rightcolumns, bottomrows; */ enum ETransf_Syntax syntax; /* PapyUShort *selectedImage; */ PapyShort theErr = 0; long theFileSize; PAPY_FILE thePapyFile; /* initialize */ myStringPtr = myString; tabIm = tabImage; /* open the original file a la Papyrus 3 */ fpOrig = Papy3FileOpen (inPapyrusFilename, (PAPY_FILE) 0, TRUE, 0); /* test if the file has been opened correctly */ if (fpOrig < 0) return (int) fpOrig; thePapyFile = (PAPY_FILE) Papy3GetFile (fpOrig); /* get the fileSize */ theErr = Papy3FSeek (thePapyFile, SEEK_END, 0L); theErr = Papy3FTell (thePapyFile, (PapyLong *) &theFileSize); theErr = Papy3FSeek (thePapyFile, SEEK_SET, 0L); nbImagesOrig = (int) Papy3GetNbImages (fpOrig); mod = (enum EModality) Papy3GetModality (fpOrig); /* enum EPap_Compression {NONE, JPEG_LOSSLESS, JPEG_LOSSY, RLE}; */ syntax = LITTLE_ENDIAN_EXPL; #ifdef Mac isOpenOrClose = FALSE; #else isOpenOrClose = TRUE; aRefNum = (PAPY_FILE) 1; #endif SetCompression (Papy3GetCompression (fpOrig)); fp = Papy3FileCreate (outDicomFilename, aRefNum, (PapyUShort) nbImages, syntax, gCompression, mod, isOpenOrClose, DICOM10, NULL); if (fp < 0) { PAPY3PRINTERRMSG (); return -1;} /* loop on the images */ for (imageNo = 1; imageNo <= nbImagesOrig, *tabIm == 1; imageNo++, tabIm++) { PAPY_FILE theFp; PapyULong theBufSize, theMetaInfoSize; unsigned char *theBuffP; void *theVoidP; /* create the temporary file that will contain the given data set */ if ((theErr = CreateTmpFile3 (fp, &theFp, &theVoidP)) < 0) RETURN (papFileCreationFailed); /* if the file is a DICOM one, then put the DICOM header to the temp file */ /* in order to get a real DICOM file part 10 compliant */ theErr = WriteDicomHeader3 (theFp, fp, &theMetaInfoSize); if (imageNo == nbImagesOrig) /* compute DataSet size for this image */ theBufSize = theFileSize - *(gRefImagePointer [fpOrig] + imageNo - 1); else /* compute DataSet size for this image */ theBufSize = *(gRefImagePointer [fpOrig] + imageNo) - *(gRefImagePointer [fpOrig] + imageNo - 1); /* alloc the buffer that will contain the ready to write group */ theBuffP = (unsigned char *) emalloc3 ((PapyULong) theBufSize); /* position the file pointer to the begining of the data set */ theErr = Papy3GotoNumber (fpOrig, imageNo, DataSetID); theErr = (PapyShort) Papy3FRead (gPapyFile [fpOrig], &theBufSize, 1L, theBuffP); /* write the buffer to the temporary file */ if ((theErr = WriteGroup3 (theFp, theBuffP, theBufSize)) < 0) RETURN (theErr); /* frees the allocated buffer */ efree3 ((void **) &theBuffP); /* close the file */ Papy3FClose (&theFp); } /* loop on the images */ } /* endof Papyrus2Dicom */ /********************************************************************************/ /* */ /* ReadDicomFile : */ /* return : */ /* */ /********************************************************************************/ int ReadDicomFile (char *inDicomFilename, PapyShort inPapyrusFilePointer) { enum EModality mod; PapyShort dicomFilePointer; Data_Set *wrkDS; Module *module; Item *dataSet; int nbImagesOrig, noImage; int moduleCreated, loop, err = 0; PapyUShort *image, bitsAllocated, rows, columns, samplesPerPixel; UValue_T *val; int valType; PapyULong nbVal; SElement *group; /* open the original file a la Papyrus 3 */ dicomFilePointer = Papy3FileOpen (inDicomFilename, (PAPY_FILE) 0, TRUE, 0); /* test if the file has been opened correctly */ if (dicomFilePointer < 0) return (int) dicomFilePointer; mod = (enum EModality) Papy3GetModality (dicomFilePointer); /* same MODALITY */ if (mod != gFileModality [inPapyrusFilePointer]) return (-1); /* is it a multi-frame dicom file */ nbImagesOrig = (int) Papy3GetNbImages (dicomFilePointer); for (noImage = 1; noImage <= nbImagesOrig; noImage++) { /* goto the image */ Papy3GotoNumber (dicomFilePointer, noImage, DataSetID); /* creation of the data set object for this image */ dataSet = Papy3CreateDataSet (inPapyrusFilePointer); /* loop on the modules */ wrkDS = gArrModalities [mod]; for (loop = 0; loop < gArrModuleNb [mod]; loop++) { moduleCreated = FALSE; /* get the module from the original file but it could be blank ... */ module = Papy3GetModule (dicomFilePointer, (short) noImage, wrkDS->moduleName); /*if (module == NULL) { /* we have to create the module */ /* module = Papy3CreateModule (dataSet, wrkDS->moduleName); moduleCreated = TRUE; } /* if ...an error occured (bad DICOM file ?) */ /* depending on the module add the modified elements */ switch (wrkDS->moduleName) { case ImagePixel : { val = Papy3GetElement (module, papRows, &nbVal, &valType); rows = val->us; val = Papy3GetElement (module, papColumns, &nbVal, &valType); columns = val->us; /* leftcolumns = (int) (leftX*columns); toprows = (int) (topY*rows); rightcolumns = (int) (rightX*columns); bottomrows = (int) (bottomY*rows); Papy3ClearElement (module, papRows, TRUE); selectedrows = (unsigned short) (bottomrows - toprows); Papy3PutElement (module, papRows, &selectedrows); Papy3ClearElement (module, papColumns, TRUE); selectedcolumns = (unsigned short) (rightcolumns - leftcolumns); Papy3PutElement (module, papColumns, &selectedcolumns); */ /* bits allocated and stored */ val = Papy3GetElement (module, papBitsAllocatedIP, &nbVal, &valType); bitsAllocated = val->us; /* samples per pixel */ val = Papy3GetElement (module, papSamplesperPixelIP, &nbVal, &valType); samplesPerPixel = val->us; /* min and max pixel value in the image */ /* valUS = (PapyUShort) newRealImage->GetMinImage (); Papy3PutElement (module, papSmallestImagePixelValue, &valUS); valUS = (PapyUShort) newRealImage->GetMaxImage (); Papy3PutElement (module, papLargestImagePixelValue, &valUS); */ /* PIXEL DATA */ /*image = (PapyUHShort *)Papy3GetPixelData (fpOrig, imageNb, module, ImagePixel);*/ Papy3GotoNumber (dicomFilePointer, noImage, DataSetID); /* then goto group 0x7FE0 */ Papy3GotoGroupNb (dicomFilePointer, 0x7FE0); Papy3GroupRead (dicomFilePointer, &group); /* get the original image because image not present in the module */ /* with Papy3GetModule () */ image = (PapyUShort *)Papy3GetPixelData (dicomFilePointer, noImage, group, ImagePixel); /*selectedImage = ExtractSelection (image, columns, bitsAllocated, leftcolumns, toprows, rightcolumns, bottomrows); efree3 ((void **) &image); /* put the image */ /*Papy3PutImage ((PapyShort)inPapyrusFilePointer, module, papPixelData, selectedImage, (PapyUShort) selectedrows, (PapyUShort) selectedcolumns, (PapyUShort) bitsAllocated, 0L);*/ Papy3PutImage ((PapyShort)inPapyrusFilePointer, module, papPixelData, image, (PapyUShort) rows, (PapyUShort) columns, (PapyUShort) (bitsAllocated * samplesPerPixel), 0L); Papy3GotoNumber (dicomFilePointer, noImage, DataSetID); } break; default : break; } /* switch ...add the modified elements */ /* link the read module to the list of modules of the data set to write */ /*if (!moduleCreated)*/ if (module != NULL) Papy3LinkModuleToDS (dataSet, module, wrkDS->moduleName); wrkDS++; } /* for ...loop on the modules of the image */ /* close the data set and frees the modules */ err = Papy3CloseDataSet (inPapyrusFilePointer, dataSet, TRUE, FALSE); } /* endfor ...loop on the images */ /* close the original file */ err = (int) Papy3FileClose (dicomFilePointer, TRUE); } /* endof ReadDicomFile */ /********************************************************************************/ /* */ /* Dicom2Papyrus : convert DICOM serie into a single papyrus file */ /* return : */ /* */ /********************************************************************************/ int Dicom2Papyrus (char *outPapyrusFilename, int inNbDicomImages, char **inDicomFilename, int inIsSerie, enum EModality modality) { int i, isOpenOrClose, err = 0; PAPY_FILE aRefNum; PapyShort papyrusFilePointer; char *dicomPath; enum ETransf_Syntax syntax; SElement *gr; char myString [256], *myStringPtr; int nbImages, imageNo; /* initialize */ myStringPtr = myString; if (inNbDicomImages == 1) GetPapyFileType (inDicomFilename[1], &nbImages, &imageNo, &modality); else nbImages = inNbDicomImages; /* enum EPap_Compression {NONE, JPEG_LOSSLESS, JPEG_LOSSY, RLE}; */ syntax = LITTLE_ENDIAN_EXPL; isOpenOrClose = TRUE; aRefNum = (PAPY_FILE)1; papyrusFilePointer = Papy3FileCreate (outPapyrusFilename, aRefNum, (PapyUShort) nbImages, syntax, gCompression, modality, isOpenOrClose, PAPYRUS3, NULL); /*if (papyrusFilePointer < 0) { PAPY3PRINTERRMSG (); return -1;}*/ if (papyrusFilePointer < 0) { PAPY3PRINTERRMSG (); return (int)papyrusFilePointer;} /* get a pointer to the group 2 (File Meta Information) */ gr = Papy3GetGroup2 (papyrusFilePointer); /* fill the necessary elements of this group */ /* SOP instance UID of this data set */ strcpy (myStringPtr, "64.572.218.916"); Papy3PutElement (gr, papMediaStorageSOPInstanceUIDGr, &myStringPtr); /* who is the creator of this wonderfull file ? */ strcpy (myStringPtr, "PAPYRUS 3.0"); Papy3PutElement (gr, papSourceApplicationEntityTitleGr, &myStringPtr); for (i = 1; i <= inNbDicomImages; i++) ReadDicomFile (inDicomFilename[i], papyrusFilePointer); /* close the file */ err = Papy3WriteAndCloseFile (papyrusFilePointer, TRUE); if (err < 0) { PAPY3PRINTERRMSG (); return -1;} /* efree3 ((void **)&dicomPath);*/ } /* endof Dicom2Papyrus */ /********************************************************************************/ /* */ /* Papyrus2Jpeg : convert Papyrus3 file into Jpeg format */ /* return : */ /* */ /********************************************************************************/ int Papyrus2Jpeg (char *inPapyrusFilename, char *outJpegBaseFilename, short aRefNum, int *inTabImage, int inJpegWidth, int inJpegHeight, enum EPap_Compression inCompression, int inQuality) { char jpegFilename[512]; PapyUChar *theCompPixP, *image; PapyUShort *pixel, *rgbPixel; int imageHeight, imageWidth, imageDepth, isSigned, planarConf; float pixOffset = 0.0, pixSlope = 1.0; int pixMin = 0, pixMax = 0, windowWidth = 1, windowLevel = 0; int pixMinCalib = 0, pixMaxCalib = 0; PapyShort fpOrig; int nbImagesOrig, noImage, numPlans = 1; UValue_T *val, *tmpVal; int err, valType; PapyULong i, j, nbVal, imageSize, bytesInImage; SElement *group; long longWW, longWL; struct color thisClut[256]; int dimImageJpeg; /* keep it in order to use it when computing the jpeg filename */ dimImageJpeg = inJpegWidth; /* open the original file a la Papyrus 3 */ fpOrig = Papy3FileOpen (inPapyrusFilename, (PAPY_FILE) 0, TRUE, 0); /* test if the file has been opened correctly */ if (fpOrig < 0) return (int) fpOrig; nbImagesOrig = (int) Papy3GetNbImages (fpOrig); for (noImage = 1; noImage <= nbImagesOrig; noImage++) { /* selected image */ if (inTabImage[noImage - 1] == 1) { /* goto the image */ Papy3GotoNumber (fpOrig, noImage, DataSetID); /* then goto group 0x0028 */ if ((err = Papy3GotoGroupNb (fpOrig, 0x0028)) == 0) { /* read group 0x0028 from the file */ if ((err = Papy3GroupRead (fpOrig, &group)) > 0) { /* rows */ val = Papy3GetElement (group, papRowsGr, &nbVal, &valType); imageHeight = (int) val->us; if (inJpegHeight == 0) inJpegHeight = imageHeight; /* columns */ val = Papy3GetElement (group, papColumnsGr, &nbVal, &valType); imageWidth = (int) val->us; if (inJpegWidth == 0) inJpegWidth = imageWidth; /* depth */ val = Papy3GetElement (group, papBitsAllocatedGr, &nbVal, &valType); imageDepth = (int) val->us; /* image size */ imageSize = (PapyULong)imageHeight * (PapyULong)imageWidth; bytesInImage = imageSize * ((long) imageDepth / 8L); /* pixel representation */ val = Papy3GetElement (group, papPixelRepresentationGr, &nbVal, &valType); if (val != NULL && val->us == 1) isSigned = TRUE; /* planar configuration */ val = Papy3GetElement (group, papPlanarConfigurationGr, &nbVal, &valType); if (val != NULL) planarConf = (int) val->us; /* pixmin */ val = Papy3GetElement (group, papSmallestImagePixelValueGr, &nbVal, &valType); if (val != NULL) { pixMin = (int) val->us; if (imageDepth == 8 && pixMin > 255) pixMin = 255; } /* pixmax */ val = Papy3GetElement (group, papLargestImagePixelValueGr, &nbVal, &valType); if (val != NULL) { pixMax = (int) val->us; if (imageDepth == 8 && pixMax > 255) pixMax = 255; } /* offset */ val = Papy3GetElement (group, papRescaleInterceptGr, &nbVal, &valType); if (val != NULL) { tmpVal = val; /* get the last offset of the image */ for (i = 1L; i < nbVal; i++) tmpVal++; pixOffset = (float)atof ((char *)(tmpVal->a)); if (pixOffset < 0) pixOffset = -(pixOffset); } /* slope */ val = Papy3GetElement (group, papRescaleSlopeGr, &nbVal, &valType); if (val != NULL) { tmpVal = val; /* get the last slope of the image */ for (i = 1L; i < nbVal; i++) tmpVal++; pixSlope = (float)atof ((char *)(tmpVal->a)); } /* window level */ val = Papy3GetElement (group, papWindowCenterGr, &nbVal, &valType); if (val != NULL) { tmpVal = val; /* get the last window level of the image */ for (i = 1L; i < nbVal; i++) tmpVal++; longWL = (long)atof (tmpVal->a); /* compute the calibrated value */ windowLevel = (int)((longWL * pixSlope) - pixOffset); } /* if ...val not NULL */ /* window width */ val = Papy3GetElement (group, papWindowWidthGr, &nbVal, &valType); if (val != NULL) { tmpVal = val; /* get the last window width of the image */ for (i = 1L; i < nbVal; i++) tmpVal++; longWW = (long)atof (tmpVal->a); windowWidth = (int)longWW; } /* if ...val not NULL */ /* look for the presence of an eventual Color Palette */ if (gArrPhotoInterpret [fpOrig] == PALETTE) { PapyUShort clutEntryR, clutEntryG, clutEntryB; PapyUShort clutDepthR, clutDepthG, clutDepthB; /* initialisation */ clutEntryR = clutEntryG = clutEntryB = 0; clutDepthR = clutDepthG = clutDepthB = 0; InitClut (0, thisClut); /* read the RED descriptor of the color lookup table */ val = Papy3GetElement (group, papRedPaletteColorLookupTableDescriptorGr, &nbVal, &valType); tmpVal = val; if (val != NULL) { clutEntryR = tmpVal->us; tmpVal++;tmpVal++; clutDepthR = tmpVal->us; } /* if ...read Red palette color descriptor */ /* read the GREEN descriptor of the color lookup table */ val = Papy3GetElement (group, papGreenPaletteColorLookupTableDescriptorGr, &nbVal, &valType); if (val != NULL) { clutEntryG = val->us; tmpVal = val + 2; clutDepthG = tmpVal->us; } /* if ...read Green palette color descriptor */ /* read the BLUE descriptor of the color lookup table */ val = Papy3GetElement (group, papBluePaletteColorLookupTableDescriptorGr, &nbVal, &valType); if (val != NULL) { clutEntryB = val->us; tmpVal = val + 2; clutDepthB = tmpVal->us; } /* if ...read Blue palette color descriptor */ /* EXTRACT THE PALETTE data only if there is 256 entries and depth is 16 bits */ if (clutEntryR == 256 && clutEntryG == 256 && clutEntryB == 256 && clutDepthR == 16 && clutDepthG == 16 && clutDepthB == 16) { /* extract the RED palette clut data */ val = Papy3GetElement (group, papRedPaletteCLUTDataGr, &nbVal, &valType); if (val != NULL) { for (j = 0, tmpVal = val; j < clutEntryR; j++, tmpVal++) (thisClut[j]).r = (int) (tmpVal->us/256); } /* endif */ /* extract the GREEN palette clut data */ val = Papy3GetElement (group, papGreenPaletteCLUTDataGr, &nbVal, &valType); if (val != NULL) for (j = 0, tmpVal = val; j < clutEntryG; j++, tmpVal++) (thisClut[j]).g = (int) (tmpVal->us/256); /* extract the BLUE palette clut data */ val = Papy3GetElement (group, papBluePaletteCLUTDataGr, &nbVal, &valType); if (val != NULL) for (j = 0, tmpVal = val; j < clutEntryB; j++, tmpVal++) (thisClut[j]).b = (int) (tmpVal->us/256); } /* if ...the palette has 256 entries and thus we extract the clut datas */ } /* endif ...extraction of the color palette */ else InitClut (-1, thisClut); /* free group 28 */ err = Papy3GroupFree (&group, TRUE); } /* endif ...group 28 read */ } /* endif ...group 28 found */ /* goto the image */ Papy3GotoNumber (fpOrig, noImage, DataSetID); /* then goto group 0x7FE0 */ if ((err = Papy3GotoGroupNb (fpOrig, 0x7FE0)) == 0) { /* read group 0x7FE0 from the file */ if ((err = Papy3GroupRead (fpOrig, &group)) > 0) { /* PIXEL DATA */ pixel = (PapyUShort *)Papy3GetPixelData (fpOrig, noImage, group, ImagePixel); /* if it is a YBR image convert it to a RGB image */ if (gArrPhotoInterpret [fpOrig] == YBR_FULL || gArrPhotoInterpret [fpOrig] == YBR_FULL_422 || gArrPhotoInterpret [fpOrig] == YBR_PARTIAL_422) { rgbPixel = (PapyUShort *) ConvertYbrToRgb ( (PapyUChar *) pixel, imageWidth, imageHeight, gArrPhotoInterpret [fpOrig], (char) planarConf); efree3 ((void **) &pixel); pixel = rgbPixel; numPlans = 3; } /* if ...YBR image */ /* if it is a RGB or a converted to RGB image, convert it to an indexed image */ if (gArrPhotoInterpret [fpOrig] == RGB || gArrPhotoInterpret [fpOrig] == YBR_FULL || gArrPhotoInterpret [fpOrig] == YBR_FULL_422 || gArrPhotoInterpret [fpOrig] == YBR_PARTIAL_422) { numPlans = 3; /* make the rgbPixel point to what it needs to */ /*rgbPixel = pixel;*/ /* allocate room for the indexed resulting image */ /*pixel = (PapyUShort *) ecalloc3 ((PapyULong)imageSize, (PapyULong) sizeof (PapyUShort)); */ /* interlaced image */ if (planarConf == 0 || gArrPhotoInterpret [fpOrig] == YBR_FULL || gArrPhotoInterpret [fpOrig] == YBR_FULL_422 || gArrPhotoInterpret [fpOrig] == YBR_PARTIAL_422) /* SetRGBImage ((PapyUChar *) rgbPixel, imageWidth, imageHeight, TRUE); */ ;/*ConvertRGBToIndexed((PapyUChar *) pixel, (PapyUChar *) rgbPixel, imageWidth, imageHeight, thisClut); */ /* contiguous plane */ else { PapyUChar *Rplane, *Gplane, *Bplane; Rplane = (PapyUChar *) rgbPixel; Gplane = Rplane + (imageWidth * imageHeight); Bplane = Gplane + (imageWidth * imageHeight); /* SetRGBImage (Rplane, Gplane, Bplane, imageWidth, imageHeight, TRUE); */ ;/*ConvertRGBPixToIndexed((PapyUChar *) pixel, Rplane, Gplane, Bplane, imageWidth, imageHeight, thisClut);*/ } /* else ...contiguous plane */ /* frees the no more needed memory */ /*efree3 ((void **) &rgbPixel);*/ } /* endif ...RGB image */ /* **************** 8 bits image **************** */ if (imageDepth == 8) { /* if min and max values of the image not in the file : computes them */ if (pixMin == pixMax || isSigned) { pixMin = 0; pixMax = 255; }/* endif ...compute min and max val of the image */ /* if ww and wl not in the file, computes them */ if (windowWidth == 1 && windowLevel == 0) { windowWidth = 256; windowLevel = windowWidth / 2; } /* if ...we have to compute ww and wl */ /* test if the image is stored with inverted pixel values */ if (gArrPhotoInterpret [fpOrig] == MONOCHROME1) { PapyULong theLLoop; PapyUChar *theUCharPix; PapyUShort invertPix; theUCharPix = (PapyUChar *) pixel; invertPix=(PapyUShort)pixMax+(PapyUShort)pixMin; for (theLLoop = 0L; theLLoop < imageSize; theLLoop++) { *theUCharPix = invertPix- *theUCharPix; theUCharPix++; } /* for ...image inversion */ } /* endif ...inversion de l'image */ } /* then ...8 bits images */ /* **************** 12 or 16 bits image **************** */ else if (imageDepth == 12 || imageDepth == 16) { /* if no min and max image value in the file */ if (pixMin == pixMax || isSigned) { /* compute the max allowed value of the pixel given the bits stored */ long maxPixValAllowed = 1; for (i = 0; i < imageDepth; i++) maxPixValAllowed *= 2; maxPixValAllowed -= 1; /* different ways of computing the values given the pixel representation field */ if (isSigned) { PapyShort *signImage; PapyShort *tmpSh; PapyUShort *tmpUSh; if (maxPixValAllowed > 32766) maxPixValAllowed = 32766; signImage = (PapyShort *) pixel; tmpSh = signImage; pixMin = (int) *signImage; if (*signImage > maxPixValAllowed) { pixMax = maxPixValAllowed; pixMin = maxPixValAllowed; }/* endif */ else { pixMax = (int) *signImage; pixMin = pixMax; }/* else */ for (nbVal = 0L; nbVal < imageSize; nbVal++, tmpSh++) { /* cut the too big values */ if ((int) *tmpSh > maxPixValAllowed) *tmpSh = (short)maxPixValAllowed; /* look for the min and max pixel values */ if ((int) *tmpSh < pixMin && (int) *tmpSh <= maxPixValAllowed) pixMin = (int) *tmpSh; if ((int) *tmpSh > pixMax && (int) *tmpSh <= maxPixValAllowed) pixMax = (int) *tmpSh; } /* for ...extract min and max val from the file */ /* we can set a correct offset to have positiv pixel values */ pixOffset += (float) -pixMin; /* then offset all the pixel values to get a positiv image */ for (nbVal = 0, tmpSh = signImage, tmpUSh = pixel; nbVal < imageSize; nbVal++, tmpSh++, tmpUSh++) *tmpUSh = (PapyUShort) ((PapyShort) *tmpSh - pixMin); pixMax -= pixMin; pixMin = 0; } /* endif ...signed pixel values */ /* else unsigned pixel values */ else { PapyUShort *tmpSh; tmpSh = pixel; if (*pixel > (PapyUShort) maxPixValAllowed) { pixMax = (int) maxPixValAllowed; pixMin = (int) maxPixValAllowed; } /* endif */ else { pixMax = (int) *pixel; pixMin = pixMax; } /* else */ for (nbVal = 0L; nbVal < imageSize; nbVal++, tmpSh++) { /* cut the too big values */ if (*tmpSh > (unsigned short) maxPixValAllowed) *tmpSh = (unsigned short) maxPixValAllowed; /* look for the min and max pixel values */ if ((int) *tmpSh < pixMin && (long) *tmpSh <= maxPixValAllowed) pixMin = (int) *tmpSh; if ((int) *tmpSh > pixMax && (long) *tmpSh <= maxPixValAllowed) pixMax = (int) *tmpSh; } /* for ...extract min and max val from the file */ } /* else ...unsigned pixel values */ } /* endif ...have to compute min and max values from the file */ /* if ww and wl not in the file, computes them */ if (windowWidth == 1 && windowLevel == 0) { pixMinCalib = (int) (((float) pixMin * pixSlope) - pixOffset); pixMaxCalib = (int) (((float) pixMax * pixSlope) - pixOffset); windowWidth = pixMaxCalib - pixMinCalib + 1; windowLevel = ((windowWidth / 2) + pixMinCalib); } /* if ...we have to compute ww and wl */ /* test if the image is stored with inverted pixel values */ if (gArrPhotoInterpret [fpOrig] == MONOCHROME1) { PapyULong theLLoop; PapyUShort *theUShortPix = pixel; PapyUShort fInvertPix = (PapyUShort)pixMax+(PapyUShort)pixMin; for (theLLoop = 0L; theLLoop < imageSize; theLLoop++) { *theUShortPix = fInvertPix - *theUShortPix; theUShortPix++; } /* for ...image inversion */ } /* endif ...inversion de l'image */ } /* else ...12 or 16 bits images */ /* free group 7FE0 */ err = Papy3GroupFree (&group, TRUE); } /* endif ...group 7FE0 read */ } /* endif ...group 7FE0 found */ /* we do allow only to compress 8bits images. so if 16 bits, please convert first */ if (imageDepth > 8 && inCompression == JPEG_LOSSY) { image = Compute8bitsImage ((PapyUShort *)pixel, imageHeight, imageWidth, imageDepth, pixMin, pixMax); imageDepth = 8; } else image = (PapyUChar *)pixel; /* Attention voir pour resize 16 bits et 3 * 8 bits*/ /* resize image */ if (imageHeight != inJpegHeight || imageWidth != inJpegWidth) image=TI_taille(image, imageWidth, imageHeight, inJpegWidth, inJpegHeight, imageDepth, numPlans, &bytesInImage); sprintf(jpegFilename,"%s.%d_%d.jpg",outJpegBaseFilename, dimImageJpeg, noImage); /*MAL added: when converting Papyrus file (in order to have same name as in cache anubis ) Anubis convert from Dicom and not from Papyrus ! */ /* sprintf(jpegFilename,"%s.%d.%d_1.jpg",outJpegBaseFilename, noImage, dimImageJpeg);*/ if (inCompression == JPEG_LOSSY) { err = (int)JPEGLossyEncodeImage (fpOrig, inQuality, (PapyUChar *) jpegFilename, (PapyUChar *) image, (PapyUChar **) &theCompPixP, (PapyULong *) &bytesInImage, (int) inJpegHeight, (int) inJpegWidth, 8, TRUE); if (err < 0) return err; } else if (inCompression == JPEG_LOSSLESS) JPEGLosslessEncodeImage ((PapyUShort *) image, (PapyUChar **) &theCompPixP, (PapyULong *) &bytesInImage, (int) inJpegWidth, (int) inJpegHeight, (int) imageDepth); #ifdef MAYO_WAVE { err = (int)WaveletEncodeImage (10, 5, (PapyUChar *) image, (PapyUChar **) &theCompPixP, (PapyULong *) &bytesInImage,(int) inJpegHeight, (int) inJpegWidth, (int) imageDepth, (enum EModality) gFileModality[inFileNb] ); if (err != 0) return (-1); } #endif /* MAYO_WAVE */ } /* if selected image */ }/* loop on all images of the papyrus or dicom file */ } /* endof Papyrus2Jpeg */ Papyrus3/PapyDataSetRead3.c0000755000175000017500000010203310044175456012736 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyDataSetRead3.c */ /* Function : contains the functions that will manage the reading of */ /* the Data Sets and the modules. */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 07.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifdef Mac #pragma segment papy3 #endif /* ------------------------- includes -----------------------------------------*/ #include #include #ifndef Papyrus3H #include "Papyrus3.h" #endif /********************************************************************************/ /* */ /* ExtractGroup28Information : Extracts some elements from the group 28 */ /* that will be needed further. */ /* return : standard error message. */ /* */ /********************************************************************************/ PapyShort ExtractGroup28Information (PapyShort inFileNb) { char thePhotoInterpret [16]; PapyShort theErr; int theElemType, theNbIm = 1; PapyULong theNbVal; UValue_T *theValP; SElement *theGroup28P; /* goto group 28 and read it */ if ((theErr = Papy3GotoGroupNb (inFileNb, 0x0028)) < 0) RETURN (theErr); if ((theErr = Papy3GroupRead (inFileNb, &theGroup28P)) < 0) RETURN (theErr); /* *** save the value of the needed elements *** */ /* extract number of frames only if DICOM file */ if (gIsPapyFile [inFileNb] == DICOM10 || gIsPapyFile [inFileNb] == DICOM_NOT10) { theValP = Papy3GetElement (theGroup28P, papNumberofFramesGr, &theNbVal, &theElemType); if (theValP != NULL) sscanf (theValP->a, "%d", &theNbIm); gArrNbImages [inFileNb] = (PapyShort) theNbIm; } /* if */ /* number of ROWS */ gx0028Rows [inFileNb] = theGroup28P [papRowsGr].value->us; /* number of COLUMNS */ gx0028Columns [inFileNb] = theGroup28P [papColumnsGr].value->us; /* the image format */ if (theGroup28P [papImageFormatGr].nb_val > 0L) gx0028ImageFormat [inFileNb] = PapyStrDup (theGroup28P [papImageFormatGr].value->a); /* the BITS ALLOCATED */ if (theGroup28P [papBitsAllocatedGr].nb_val > 0L) { gx0028BitsAllocated [inFileNb] = theGroup28P [papBitsAllocatedGr].value->us; /* 24 bits images (RGB) should be seen as 8 bits allocated by channel... */ if (gx0028BitsAllocated [inFileNb] == 24) gx0028BitsAllocated [inFileNb] = 8; } /* if */ /* the BITS STORED */ if (theGroup28P [papBitsStoredGr].nb_val > 0L) gx0028BitsStored [inFileNb] = theGroup28P [papBitsStoredGr].value->us; /* the photometric interpretation */ theValP = Papy3GetElement (theGroup28P, papPhotometricInterpretationGr, &theNbVal, &theElemType); if (theValP != NULL) strcpy (thePhotoInterpret, theValP->a); else /* default value */ strcpy (thePhotoInterpret, "MONOCHROME2"); /* free the group 28 */ theErr = Papy3GroupFree (&theGroup28P, TRUE); /* set the PAPYRUS global var according to the extracted value */ if (strcmp (thePhotoInterpret, "MONOCHROME1") == 0) gArrPhotoInterpret [inFileNb] = MONOCHROME1; else if (strcmp (thePhotoInterpret, "MONOCHROME2") == 0) gArrPhotoInterpret [inFileNb] = MONOCHROME2; else if (strcmp (thePhotoInterpret, "PALETTE COLOR") == 0) gArrPhotoInterpret [inFileNb] = PALETTE; else if (strcmp (thePhotoInterpret, "RGB") == 0) gArrPhotoInterpret [inFileNb] = RGB; else if (strcmp (thePhotoInterpret, "HSV") == 0) gArrPhotoInterpret [inFileNb] = HSV; else if (strcmp (thePhotoInterpret, "ARGB") == 0) gArrPhotoInterpret [inFileNb] = ARGB; else if (strcmp (thePhotoInterpret, "CMYK") == 0) gArrPhotoInterpret [inFileNb] = CMYK; else if (strcmp (thePhotoInterpret, "YBR_FULL") == 0) gArrPhotoInterpret [inFileNb] = YBR_FULL; else if (strcmp (thePhotoInterpret, "YBR_FULL_422") == 0) gArrPhotoInterpret [inFileNb] = YBR_FULL_422; else if (strcmp (thePhotoInterpret, "YBR_PARTIAL_422") == 0) gArrPhotoInterpret [inFileNb] = YBR_PARTIAL_422; RETURN (papNoError); } /* endofmethod ExtractGroup28Information */ /********************************************************************************/ /* */ /* ExtractFileMetaInformation3 : Extracts the file meta information for the*/ /* given file. It reads group2 and extract the modality as well as the */ /* transfert syntax that will be used in the rest of the file */ /* return : standard error message. */ /* */ /********************************************************************************/ PapyShort ExtractFileMetaInformation3 (PapyShort inFileNb) { int found, i; PapyShort theErr; PapyULong theNbVal; PapyLong theFilePos; int theElemType, theElength; SElement *theGroup2P = NULL, *theGroupTmpP; UValue_T *theValP; /* Read group 0x0002 */ if ((theErr = Papy3GroupRead (inFileNb, &theGroup2P)) < 0) {theErr = Papy3GroupFree (&theGroup2P, TRUE); RETURN (papReadGroup);} /* extract the transfert syntax used for the rest of the file */ theValP = Papy3GetElement (theGroup2P, papTransferSyntaxUIDGr, &theNbVal, &theElemType); if (theValP == NULL) {theErr = Papy3GroupFree (&theGroup2P, TRUE); RETURN (papElemOfTypeOneNotFilled);} /* 1.2.840.10008.1.20 is to avoid a bug with the old files... */ if (strcmp (theValP->a, "1.2.840.10008.1.2") == 0 || strcmp (theValP->a, "1.2.840.10008.1.20") == 0) { gArrTransfSyntax [inFileNb] = LITTLE_ENDIAN_IMPL; gArrCompression [inFileNb] = NONE; } else if (strcmp (theValP->a, "1.2.840.10008.1.2.1") == 0) { gArrTransfSyntax [inFileNb] = LITTLE_ENDIAN_EXPL; gArrCompression [inFileNb] = NONE; } else if (strcmp (theValP->a, "1.2.840.10008.1.2.2") == 0) { gArrTransfSyntax [inFileNb] = BIG_ENDIAN_EXPL; gArrCompression [inFileNb] = NONE; } else if (strcmp (theValP->a, "1.2.840.10008.1.2.5") == 0) { gArrTransfSyntax [inFileNb] = LITTLE_ENDIAN_EXPL; gArrCompression [inFileNb] = RLE; } else if ((strcmp (theValP->a, "1.2.840.10008.1.2.4.70") == 0) || (strcmp (theValP->a, "1.2.840.10008.1.2.4.57") == 0) || (strcmp (theValP->a, "1.2.840.10008.1.2.4.58") == 0)) { gArrTransfSyntax [inFileNb] = LITTLE_ENDIAN_EXPL; gArrCompression [inFileNb] = JPEG_LOSSLESS; } else if (strcmp (theValP->a, "1.2.840.10008.1.2.4.51") == 0) { gArrTransfSyntax [inFileNb] = LITTLE_ENDIAN_EXPL; gArrCompression [inFileNb] = JPEG_LOSSY; } else if (strcmp (theValP->a, "1.2.840.10008.1.2.4.50") == 0) { gArrTransfSyntax [inFileNb] = LITTLE_ENDIAN_EXPL; gArrCompression [inFileNb] = JPEG_LOSSY; } else if (strcmp (theValP->a, "1.2.756.777.1.2.4.70") == 0) /* PAPYRUS defined transfert syntax */ { gArrTransfSyntax [inFileNb] = LITTLE_ENDIAN_IMPL; gArrCompression [inFileNb] = JPEG_LOSSLESS; } #ifdef MAYO_WAVE /* WARNING this is defined in DICOM as JPEG-LS lossless image compression */ /* whereas 1.2.840.10008.1.2.4.81 is JPEG-LS Lossy (near-Lossless) image compression */ else if (strcmp (theValP->a, "1.2.840.10008.1.2.4.80") == 0) { gArrTransfSyntax [inFileNb] = LITTLE_ENDIAN_EXPL; gArrCompression [inFileNb] = MAYO_WAVELET; } #endif else { theErr = Papy3GroupFree (&theGroup2P, TRUE); RETURN (papSyntaxNotImplemented); } /* extract the SOP Class UID in order to know the modality of the file */ theValP = Papy3GetElement (theGroup2P, papMediaStorageSOPClassUIDGr, &theNbVal, &theElemType); /* find the modality */ found = FALSE; i = 0; if (theValP != NULL) { /* DICOMDIR defined SOP Class UID */ if (gIsPapyFile [inFileNb] == DICOMDIR) if (strcmp (theValP->a, "1.2.840.10008.1.3.10") == 0) { /* free group 2 as we do not need it anymore */ theErr = Papy3GroupFree (&theGroup2P, TRUE); RETURN (theErr); } /* if */ else RETURN (papNotPapyrusFile); /* avoid a bug with the old version of PAPYRUS ( < 3.3) */ theElength = strlen (theValP->a); if (theValP->a [theElength - 1] == '0' && strcmp (theValP->a, gArrUIDs [NM_IM]) != 0 ) theValP->a [theElength - 1] = '\0'; while (!found && i < END_MODALITY) { if (strcmp (theValP->a, gArrUIDs [(int) i]) == 0) { found = TRUE; /* set the modality of the file */ gFileModality [inFileNb] = (int)i; } else i++; } /* while */ } /* if ...there is a value for getting the modality in group 2 */ /* if theValP NULL or not found or untrustable file (...) */ /* look for the element 0x0008:0x0060 modality */ /*if ((theValP == NULL) || (!found) || gIsPapyFile [inFileNb] == DICOM10)*/ if (!found) { i = 0; /* keep the position in the file */ theErr = Papy3FTell (gPapyFile [inFileNb], &theFilePos); /* reset the file pointer to its previous position */ theErr = Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, 132L); /* goto group 8 and read it */ if ((theErr = Papy3GotoGroupNb (inFileNb, 0x0008)) < 0) { Papy3GroupFree (&theGroup2P, TRUE); RETURN (theErr); } if ((theErr = Papy3GroupRead (inFileNb, &theGroupTmpP)) < 0) { Papy3GroupFree (&theGroup2P, TRUE); RETURN (theErr); } /* extract the modality */ theValP = Papy3GetElement (theGroupTmpP, papModalityGr, &theNbVal, &theElemType); if (theValP != NULL) ExtractModality (theValP, inFileNb); /* else this file will not live */ else { /* free the group 8 */ theErr = Papy3GroupFree (&theGroupTmpP, TRUE); theErr = Papy3GroupFree (&theGroup2P, TRUE); RETURN (papElemOfTypeOneNotFilled); } /* free the group 8 */ theErr = Papy3GroupFree (&theGroupTmpP, TRUE); /* reset the file pointer to its previous position */ theErr = Papy3FSeek (gPapyFile [inFileNb], SEEK_SET, theFilePos); } /* if ...theValP is NULL or unknown UID */ /* free group 2 as we do not need it anymore */ theErr = Papy3GroupFree (&theGroup2P, TRUE); RETURN (theErr); } /* endof ExtractFileMetaInformation3 */ /********************************************************************************/ /* */ /* ExtractPapyDataSetInformation3 : Extracts the data sets relativ */ /* information i.e. the number of images, and the offsets to the data sets */ /* and the pixel datas for a PAPYRUS 3 file. */ /* return : standard error message. */ /* */ /********************************************************************************/ PapyShort ExtractPapyDataSetInformation3 (PapyShort inFileNb) { PapyShort theErr, i; PapyUShort theElemCreator, theElemNb; PapyULong theNbVal, theSavedFilePos, theItemLength, theULong; int theElemType; SElement *theGroupP; UValue_T *theValP; /* move the file pointer to group 41 */ if ((theErr = Papy3GotoGroupNb (inFileNb, 0x0041)) < 0) RETURN (theErr); /* find the creator element number for the PAPYRUS 3.0 elements */ if ((theElemCreator = Papy3FindOwnerRange (inFileNb, 0x0041, "PAPYRUS 3.0")) == 0) RETURN (papNotFound); /* look for the position of the pointer and the image sequence */ /* save the current file pos */ Papy3FTell (gPapyFile [inFileNb], (PapyLong *) &theSavedFilePos); /* elem (0x0041, 0x??10) = pointer sequence */ theElemNb = theElemCreator << 8; theElemNb |= 0x0010; if ((theErr = Papy3GotoElemNb (inFileNb, 0x0041, theElemNb, &theULong)) < 0) RETURN (theErr); Papy3FTell (gPapyFile [inFileNb], (PapyLong *) &gOffsetToPtrSeq [inFileNb]); /* elem (0x0041, 0x??50) = image sequence */ theElemNb = theElemCreator << 8; theElemNb |= 0x0050; if ((theErr = Papy3GotoElemNb (inFileNb, 0x0041, theElemNb, &theULong)) < 0) RETURN (theErr); Papy3FTell (gPapyFile [inFileNb], (PapyLong *) &gOffsetToImageSeq [inFileNb]); /* reset the file pointer to the begining of group 41 */ Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) theSavedFilePos); /* read THE group 41 and stores it */ if ((theErr = Papy3GroupRead (inFileNb, &gArrGroup41 [inFileNb])) < 0) RETURN (papReadGroup); /* extracts the number of images in the file */ theValP = Papy3GetElement (gArrGroup41 [inFileNb], papNumberofimagesGr, &theNbVal, &theElemType); gArrNbImages [inFileNb] = theValP->us; /* allocate room for the offsets to the data set and pixel data of the file */ gRefImagePointer [inFileNb] = (PapyULong *) ecalloc3 ((PapyULong) gArrNbImages [inFileNb], (PapyULong) sizeof (PapyULong)); gRefPixelOffset [inFileNb] = (PapyULong *) ecalloc3 ((PapyULong) gArrNbImages [inFileNb], (PapyULong) sizeof (PapyULong)); /* allocate room for the SOP instance UID of the images */ gImageSOPinstUID [inFileNb] = (char **) ecalloc3 ((PapyULong) gArrNbImages [inFileNb], (PapyULong) sizeof (char *)); /* extraction of the offsets to the data set(s) and the image(s) */ /* so points to the first element of the pointer sequence */ if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_IMPL) Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) (gOffsetToPtrSeq [inFileNb] + 8L)); else if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL) Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) (gOffsetToPtrSeq [inFileNb] + 12L)); /* extract the offset to data set and the image and the UID for each image */ for (i = 0; i < gArrNbImages [inFileNb]; i++) { /* extract the length of this item of the pointer sequence */ theItemLength = Papy3ExtractItemLength (inFileNb); if ((int) theItemLength < 0) RETURN ((int) theItemLength); Papy3FTell (gPapyFile [inFileNb], (PapyLong *) &theULong); theItemLength += theULong; /* move the file pointer to the group 41 of the pointer sequence */ if ((theErr = Papy3GotoGroupNb (inFileNb, 0x0041)) < 0) RETURN (theErr); /* read the group */ if ((theErr = Papy3GroupRead (inFileNb, &theGroupP)) < 0) RETURN (theErr); /* extract the offset to the data set */ theValP = Papy3GetElement (theGroupP, papImagePointerGr, &theNbVal, &theElemType); *(gRefImagePointer [inFileNb] + i) = theValP->ul; /* extract the offset to the pixel datas */ theValP = Papy3GetElement (theGroupP, papPixelOffsetGr, &theNbVal, &theElemType); *(gRefPixelOffset [inFileNb] + i) = theValP->ul; /* extract the SOP instance UID of the image */ theValP = Papy3GetElement (theGroupP, papReferencedImageSOPClassUIDGr, &theNbVal, &theElemType); if (theValP != NULL) *(gImageSOPinstUID [inFileNb] + i) = (char *) PapyStrDup (theValP->a); /* free the group */ theErr = Papy3GroupFree (&theGroupP, TRUE); /* go to the end of this item of the pointer sequence */ Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) theItemLength); } /* for ...extraction of the offsets to data set and the images */ RETURN (theErr); } /* endof ExtractPapyDataSetInformation3 */ /********************************************************************************/ /* */ /* ExtractDicomDataSetInformation3 : Extracts the data sets relativ */ /* information i.e. the offsets to the data sets and the pixel datas for */ /* a DICOM file. */ /* return : standard error message. */ /* */ /********************************************************************************/ PapyShort ExtractDicomDataSetInformation3 (PapyShort inFileNb) { PapyShort theErr, i; PapyULong theULong; PapyULong theOffsetDataSet, theOffsetImage; /* move the file pointer to group 0x7FE0 */ if ((theErr = Papy3GotoGroupNb (inFileNb, 0x7FE0)) < 0) RETURN (theErr); /* look for the position of the image pixel element */ /* elem (0x7FE0, 0x0010) = image pixel */ if ((theErr = Papy3GotoElemNb (inFileNb, 0x7FE0, 0x0010, &theULong)) < 0) RETURN (theErr); /* get the position of the element */ Papy3FTell (gPapyFile [inFileNb], (PapyLong *) &theOffsetImage); /* add something depending on the transfert syntax */ if (gArrTransfSyntax [inFileNb] == LITTLE_ENDIAN_EXPL || gArrTransfSyntax [inFileNb] == BIG_ENDIAN_EXPL) theOffsetImage += 12L; else theOffsetImage += 8L; /* set the position of the unique data set */ /* part 10 compliant DICOM file */ if (gIsPapyFile [inFileNb] == DICOM10) theOffsetDataSet = 132L; /* non-part 10 DICOM file */ else if (gIsPapyFile [inFileNb] == DICOM_NOT10) theOffsetDataSet = 0L; /* allocate room for the offsets to the data set and pixel data of the file */ gRefImagePointer [inFileNb] = (PapyULong *) ecalloc3 ((PapyULong) gArrNbImages [inFileNb], (PapyULong) sizeof (PapyULong)); gRefPixelOffset [inFileNb] = (PapyULong *) ecalloc3 ((PapyULong) gArrNbImages [inFileNb], (PapyULong) sizeof (PapyULong)); /* put the offset to data set and the image for each image */ for (i = 0; i < gArrNbImages [inFileNb]; i++) { /* put the offset to the data set */ *(gRefImagePointer [inFileNb] + i) = theOffsetDataSet; /* put the offset to the pixel datas */ *(gRefPixelOffset [inFileNb] + i) = theOffsetImage; } /* for ...putting the offsets to data set and the images */ return 0; } /* endof ExtractDicomDataSetInformation3 */ /********************************************************************************/ /* */ /* Papy3GetModule : Get the specified module from the specified data set. */ /* Beware : this routine DO NOT extract the pixel data from the file for */ /* optimization reasons. To get the image, get the module, the call the */ /* Papy3GetPixelData routine. */ /* return : the read module or NULL. */ /* */ /********************************************************************************/ Module * CALLINGCONV Papy3GetModule (PapyShort inFileNb, PapyShort inImageNb, int inModuleID) { int i, j, theElemType, theEnumTag, found, theOddGroup; int *theListOfGroupsP, *theFooP, theElem = FALSE; PapyShort theErr; PapyUShort theElemTag, theElemCreator, theTmpTag; PapyULong theItemLength, theNbVal, theLoopVal; UValue_T *theValP, *theTmpValP; SElement *theGrP, *theTmpGrP, *theZouzouteP; Module *theModuleP, *theElemP; /* if it is a PAPYRUS 3 file */ switch (gIsPapyFile [inFileNb]) { case DICOMDIR : /* DICOMDIR file */ case DICOM10 : /* DICOM file */ /* it is a basic part 10 DICOM file so jump past the file preamble */ if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, 132L) != 0) return NULL; break; case PAPYRUS3 : /* PAPYRUS 3 file */ /* a usefull test */ if (inImageNb > gArrNbImages [inFileNb] || inModuleID > END_MODULE) return NULL; /* position the file pointer at the right position */ switch (inModuleID) { case GeneralPatientSummary : case GeneralVisitSummary : case GeneralStudySummary : case GeneralSeriesSummary : /* go to the begining of the first group of the summaries */ if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, 132L) != 0) return NULL; if ((theErr = Papy3GotoGroupNb (inFileNb, 0x0008)) < 0) return NULL; break; case ImageIdentification : case IconImage : case ImagePointer : case PixelOffset : /* it is one of the pointer sequence module, so go to the given ptr sequence */ if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) gOffsetToPtrSeq [inFileNb] + 8L) != 0) return NULL; /* look for the given item of the ptr seq */ for (i = 1; i < inImageNb; i++) { theItemLength = Papy3ExtractItemLength (inFileNb); if ((int) theItemLength < 0) return NULL; if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_CUR, (PapyLong) theItemLength) != 0) return NULL; } /* for */ /* then points to the first element of the item */ if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_CUR, (PapyLong) 8L) != 0) return NULL; break; case InternalImagePointerSequence : /* get the whole pointer sequence so points to the begining of the ptr seq */ if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) gOffsetToPtrSeq [inFileNb]) != 0) return NULL; break; case ImageSequencePap : /* get the whole image sequence, so points to the begining of the image seq */ if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) gOffsetToImageSeq [inFileNb]) != 0) return NULL; break; default : /* it is a module of the specified data set, so go to the begining of it */ if ((theErr = Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, (PapyLong) *(gRefImagePointer [inFileNb] + inImageNb - 1))) < 0) return NULL; break; } /* switch ...positioning the file pointer at the right place */ break; /* PAPYRUS file */ case DICOM_NOT10 : /* non-part 10 DICOM file */ /* it is a basic non-part 10 DICOM file so set the file pointer at the begining */ if (Papy3FSeek (gPapyFile [inFileNb], (int) SEEK_SET, 0L) != 0) return NULL; break; default : /* do nothing */ break; } /* switch ...file type */ /* creation of the module */ theModuleP = CreateModule3 (inModuleID); /* initialize the lists of groups contained in the module to empty */ theListOfGroupsP = (int *) ecalloc3 ((PapyULong) END_GROUP, (PapyULong) sizeof (int)); theFooP = NULL; /* scan the module to find its group composition */ LookForGroupsInModule3 (theModuleP, inModuleID, theFooP, theListOfGroupsP); /* loop on the groups */ for (i = 0; i < END_GROUP; i++) { /* read only the needed groups */ if (theListOfGroupsP [i] == 1) { /* look for the group */ if ((theErr = Papy3GotoGroupNb (inFileNb, (PapyShort) (gArrGroup [i].number))) == 0) { /* test wether it is an odd group number or not */ if (gArrGroup [i].number % 2 != 0) { theOddGroup = TRUE; /* look for the owner range of the PAPYRUS 3.0 elements */ theElemCreator = Papy3FindOwnerRange (inFileNb, gArrGroup [i].number, "PAPYRUS 3.0"); } /* if ...odd group number */ else theOddGroup = FALSE; /* read the group */ if ((theErr = Papy3GroupRead (inFileNb, &theGrP)) < 0) {Papy3ModuleFree (&theModuleP, inModuleID, TRUE); efree3 ((void **) &theListOfGroupsP); return NULL;} theElemP = theModuleP; /* test each element of the module to see if it belongs to the group */ for (j = 0; j < gArrModule [inModuleID]; j++, theElemP++) { /* does the element belongs to the group ? */ if (theElemP->group == theGrP->group) { /* locate the enum place of the element given its tag */ theTmpGrP = theGrP; found = FALSE; theEnumTag = 0; theElemTag = theElemP->element; /* if it is an odd group number */ if (theOddGroup && theElemTag >= 0x0100) { /* convert the element range to the one extracted from the file */ /* 0xaabb -> 0x00bb */ theTmpTag = theElemTag << 8; theTmpTag = theTmpTag >> 8; /* put the theElemP creator in the 2 most significant bytes... */ /* 0x00cc -> 0xcc00 */ theElemTag = theElemCreator << 8; /* ...and the element tag in the 2 less significant bytes */ /* 0xccbb */ theElemTag |= theTmpTag; } /* if ...odd group number */ while (!found && (theEnumTag <= (long) gArrGroup [i].size)) { if (theTmpGrP->element == theElemTag) found = TRUE; else { theEnumTag++; theTmpGrP++; } /* else */ } /* while */ /* if it is the pixel data element do not read it */ if (found && !(theElemP->group == 0x7FE0 && theElemTag == 0x0010)) { /* extract the element */ theValP = Papy3GetElement (theGrP, theEnumTag, &theNbVal, &theElemType); /* put the element in the module */ if (theValP != NULL) { /* test that it has found at least one element */ if (!theElem) theElem = TRUE; /* loop on the values of the element */ for (theLoopVal = 0L, theTmpValP = theValP; theLoopVal < theNbVal; theLoopVal++, theTmpValP++) { /* depending on the VR of the element put it to the group */ switch (theElemType) { case SS : Papy3PutElement (theModuleP, j, &(theTmpValP->ss)); break; case USS : case AT : Papy3PutElement (theModuleP, j, &(theTmpValP->us)); break; case OB : Papy3PutImage (inFileNb, theModuleP, j, (PapyUShort *) theTmpValP->a, 0, 0, 8, (theGrP + theEnumTag)->length); break; case OW : Papy3PutImage (inFileNb, theModuleP, j, theTmpValP->ow, 0, 0, 16, (theGrP + theEnumTag)->length); break; case SL : Papy3PutElement (theModuleP, j, &(theTmpValP->sl)); break; case UL : Papy3PutElement (theModuleP, j, &(theTmpValP->ul)); break; case FL : Papy3PutElement (theModuleP, j, &(theTmpValP->fl)); break; case FD : Papy3PutElement (theModuleP, j, &(theTmpValP->fd)); break; case AE : case AS : case CS : case DA : case DS : case DT : case IS : case LO : case LT : case PN : case SH : case ST : case TM : case UI : case UT : Papy3PutElement (theModuleP, j, &(theTmpValP->a)); break; case UN : Papy3PutUnknown (theModuleP, j, theTmpValP->a, (theGrP + theEnumTag)->length); break; case SQ : Papy3PutElement (theModuleP, j, &(theTmpValP->sq)); break; } /* switch */ } /* for ...loop on the values of the element */ } /* if ...the element exists */ } /* if ...the element is not pixel data */ else /* it is the pixel data element */ { /* put the element length and number of value if any */ theZouzouteP = theGrP + theEnumTag; theElemP->nb_val = theZouzouteP->nb_val; theElemP->length = theZouzouteP->length; } /* else ...pixel data element */ } /* if ...the element belongs to this group */ } /* for ...loop on the elements of the module */ /* free the group */ /* first free the unused SQ element from the group */ theErr = Papy3FreeSQElement (&theGrP, theModuleP, inModuleID); theErr = Papy3GroupFree (&theGrP, FALSE); } /* if ...the group exists */ } /* if ...group has to be read */ } /* for ...reading of the needed groups */ /* delete the lists of groups number of the module */ efree3 ((void **) &theListOfGroupsP); /* if no element found we have to assume the module is empty ... */ if (!theElem) { Papy3ModuleFree (&theModuleP, inModuleID, TRUE); return NULL; } /* if */ else return theModuleP; } /* endof Papy3GetModule */ Papyrus3/PapyMemorySystemMac3.h0000755000175000017500000000724310044203006013706 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ #ifdef __cplusplus extern "C" { #endif extern PapyShort Papy3FOpenMem (char *, char, PAPY_FILE, PAPY_FILE *, void *); extern int Papy3FCloseMem (PAPY_FILE *); extern PapyShort Papy3FReadMem (PAPY_FILE, PapyULong *, PapyULong, void **, Boolean); extern int Papy3FTellMem (PAPY_FILE, PapyLong *); extern int Papy3FSeekMem (PAPY_FILE, int, PapyLong); extern Ptr Papy3GetMemPtr( PAPY_FILE vRefNum, long *pos, long *size, long *ActCount); extern PapyShort Papy3LoadFileMem( PAPY_FILE vRefNum); #ifdef __cplusplus } #endif Papyrus3/Makefile.sun40000755000175000017500000000246607535143454012101 0ustar # @(#)Makefile 1.3 16/11/94 DSTDIR= .. MANDIR= $(DSTDIR)/man INCDIR= $(DSTDIR)/include JPEGDIRLL= JpegDir/JpegLossless JPEGDIRLY= JpegDir/JpegLossy #MAYODIR= Mayo BINDIR= $(DSTDIR)/test LIBDIR= $(DSTDIR)/$(ARCH)/lib LINTLIBDIR= $(LIBDIR)/lint #CPPFLAGS= -I$(INCDIR) -I. -I../.. -I$(JPEGDIRLL) -I$(JPEGDIRLY) -I$(MAYODIR) -DXTFUNCPROTO -DMAYO_WAVE -g CPPFLAGS= -I$(INCDIR) -I. -I../.. -I$(JPEGDIRLL) -I$(JPEGDIRLY) -DXTFUNCPROTO -g CFLAGS= -g LINTFLAGS= -hb SOURCES= PapyError3.c \ PapyFileSystemUnix3.c \ PapyFiles3.c \ PapyGetGlobalVar3.c \ PapyInit3.c \ PapyInitGroups3.c \ PapyInitModules3.c \ PapyRead3.c \ PapyDataSetRead3.c \ PapyList3.c \ PapyVars3.c \ PapyWrite3.c \ PapyDataSetWrite3.c \ PapyEallocUnix3.c \ PapyWild3.c \ PapyWildexit3.c \ PapyUtils3.c LIBRARY= libP.a OBJECTS= $(SOURCES:%.c=$(ARCH)/%.o) $(LIBDIR)/$(LIBRARY): $(OBJECTS) ar rv $@ $? ranlib $@ cd JpegDir/JpegLossless;make -f Makefile.sun4; cd JpegDir/JpegLossy;make -f Makefile.sun4 # cd Mayo;make -f Makefile.sun4; # cd DicomDirLib;make -f Makefile.sun4; lint: $(SOURCES) $(LINT.c) $(SOURCES) .KEEP_STATE: .INIT: $(LIBDIR) $(ARCH) $(LIBDIR) $(ARCH) : test -d $@ || mkdir -p $@ $(ARCH)/%.o: %.c $(COMPILE.cc) $< -o $@ Papyrus3/Papyrus3.µ0000755000175000017500000012430607370224530012055 0ustar cool(¡¶¢Þè?CodeWarrior ProjectPapyrus3:Custom KeywordsPapyrus3:Access PathsPapyrus3:Target SettingsPapyrus3:File MappingsPapyrus3:Build ExtrasPapyrus3:Debugger TargetPapyrus3:68K CodeGenPapyrus3:68K DisassemblerPapyrus3:68K LinkerPapyrus3:68K ProjectPapyrus3:C/C++ CompilerPapyrus3:C/C++ WarningsPapyrus3:CFM68KPapyrus3:FTP PanelPapyrus3:IR OptimizerPapyrus3:Java LanguagePapyrus3:Java OutputPapyrus3:Java ProjectPapyrus3:JavaDoc ProjectPapyrus3:MacOS Merge PanelPapyrus3:PPC CodeGenPapyrus3:PPC DisassemblerPapyrus3:PPC LinkerPapyrus3:PPC PEFPapyrus3:PPC ProjectPapyrus3:PPCAsm PanelPapyrus3:Rez CompilerPapyrus3:WinRC CompilerPapyrus3:x86 CodeGenPapyrus3:x86 Exceptions PanelPapyrus3:x86 LinkerPapyrus3:x86 ProjectProject File ListPapyrus3:Source TreesPapyrus3:Debugger RuntimePapyrus3:Remote DebugPapyrus3:Auto-targetPapyrus3:68K Global OptimizerPapyrus3:Java Command LinePapyrus3:Java MRJAppBuilderPapyrus3:Output FlagsPapyrus3:Packager PanelPapyrus3:PPC Global OptimizerPapyrus3:x86 DisassemblerPapyrus3:x86 Global Optimizer  A`˜A= &ioElem [papRTBeaÿÿÿÿPapyrus3First Segment:a.outLib Import 68KMPW Import 68KBalloon HelpMW C/C++ 68KRezPEF Import 68KJpegLossy.libMacOS 68K LinkerCustom KeywordsAccess PathsTarget SettingsFile MappingsBuild ExtrasDebugger Target68K CodeGen68K Disassembler68K Linker68K ProjectC/C++ CompilerC/C++ WarningsCFM68KFTP PanelIR OptimizerRez CompilerJpegLossless.libPapyDataSetWrite3.cPapyEallocMac3.cPapyError3.cPapyErrorMacros3.hPapyFileSystemMac3.cPapyGetGlobalVar3.cPapyInit3.cPapyInitGroups3.cPapyInitModules3.cPapyList3.cPapyMemorySystemMac3.cPapyUtils3.cPapyVars3.cPapyWild3.cPapyWildexit3.cPapyDataSetRead3.cLib Import PPCMW C/C++ PPCPPCAsmXCOFF Import PPCPEF Import PPCMacOS PPC LinkerPPC CodeGenPPC DisassemblerPPC LinkerPPC PEFPPC ProjectPPCAsm Panel:Papyrus3.libSource TreesDebugger RuntimeOutput FlagsPackager PanelPPC Global OptimizerPapyFiles3.cPapyRead3.cPapyWrite3.c       MacHeadersPPCJavaClasses.jarZIP MWZP/H_uŽ£½ Ñ æ þ  &9Of{‘ªÅÚô.DZr‡¥¹ Î!à"ö#$&%;&Y't()¦*¾+Ü,ö-% $ " &'()*#!+,  -<IVZ i w ˆ ˜ ¥µÃÐàìý#29CP]n‚“  ³!È"Ü#è$ú% &'0(=)I*U+e,x-‡.”/›0¬1»2Ì3Ø4é5ô6ü789#:0;A<N=]>r?@‹A8  : , 1-;<+> !"#$%&?'()*@023=456.79 /!" # $ % & '()*+,?@A  @:ÿÿÿÿ:::JPEG_libs:JPEG_lossy:JpegLossy:ÿÿÿÿ@:::JPEG_libs:JPEG_lossless:ÿÿÿÿ@::Dicomdir:ÿÿÿÿ:::JPEG_libs:JPEG_lossy:ÿÿÿÿ@:ÿÿÿÿ@:MacOS Support:ÿÿÿÿ@:MSL:werks Standard Library:MSL C:ÿÿÿÿ@ MacOS PPC LinkerPapyrus3:NoneMMPr@TEXT.cRunTSScriptJava LinkerAPPL`Appl`COŒkMW JavaClssMW JavaJjrf.jrfMWCD`RSRC`TEXT.bhBalloon HelpTEXT.cRunTSScriptTEXT.htmlTEXT.javaMW JavaTEXT.mfTEXT.rRezZIP MW JavaZipFMW Javadocu`rsrc`.auJAR Importer@.classMW Java.gifJAR Importer@.jarMW Java.javaMW Java.jpegJAR Importer@.zipMW JavaMacOS 68K LinkerAPPL`Appl`MMLBLib Import 68KMPLFLib Import 68KMWCD`OBJ MPW Import 68KPLob`RSRC`TEXT.bhBalloon HelpTEXT.cMW C/C++ 68KTEXT.c++MW C/C++ 68KTEXT.ccMW C/C++ 68KTEXT.cpMW C/C++ 68KTEXT.cppMW C/C++ 68KTEXT.expTEXT.hMW C/C++ 68KTEXT.pchMW C/C++ 68K€TEXT.pch++MW C/C++ 68K€TEXT.rRezTEXT.segdocu`rsrc`shlbPEF Import 68KstubPEF Import 68K.docP.oMPW Import 68K.ppob`.rsrc`MacOS MergeAPPL`Appl`RSRC`TEXT.bhBalloon HelpTEXT.cRunTSScriptTEXT.rRezrsrc`shlbMacOS PPC LinkerAPPL`Appl`MMLBLib Import PPCMPLFLib Import PPCMWCD`RSRC`TEXT.bhBalloon HelpTEXT.cMW C/C++ PPCTEXT.c++MW C/C++ PPCTEXT.ccMW C/C++ PPCTEXT.cpMW C/C++ PPCTEXT.cppMW C/C++ PPCTEXT.expTEXT.hMW C/C++ PPCTEXT.pchMW C/C++ PPC€TEXT.pch++MW C/C++ PPC€TEXT.rRezTEXT.sPPCAsmXCOFXCOFF Import PPCdocu`rsrc`shlbPEF Import PPCstubPEF Import PPC.docP.oXCOFF Import PPC.ppob`.rsrc`Win32 x86 LinkerTEXT.cMW C/C++ x86TEXT.c++MW C/C++ x86TEXT.ccMW C/C++ x86TEXT.cpMW C/C++ x86TEXT.cppMW C/C++ x86TEXT.defTEXT.hMW C/C++ x86TEXT.pchMW C/C++ x86€TEXT.pch++MW C/C++ x86€TEXT.rcMW WinRCTEXT.resWinRes Import.docP.libLib Import x86.objObj Import x86main a.out????APPL€XÀ????U {€__start DFLTMetrowerks JavaInternet ExplorerMSIEhttp://java.sun.com/products/jdk/1.1/docs/api/ Merge Out????APPLDLGXckidProjWSPC__start Papyrus3.lib????????????P'CODE' 'DATA' 'PICT' NONAME.EXE@-@-P >0˜€2: ;   <=34>5678  ¸ÙØj¶9·ÌãälòROOTGRUPsourcesFILEFILEFILEFILEFILEFILEFILEFILE FILE FILE FILE FILE FILEFILEFILEFILEFILEFILEGRUP LibrariesFILEFILEï„ï…ïAïBïNïOQÍðé`PYpQÒ°û@é`QÒPYpQûpé`PYpmainQûp°Ïàé`QûpMRJApplicationR5 Ðé`@à|RR5ðR7 ,A‚œTR*R5àR7 macsexpiR5àR6pR7 R5àmacsexpi@àˆ@à„R5k°§°íÀ,A‚œRQR> macsevnt@á @áR?k°°íÀR?а R>PR?@RQ €R> R@« ˆÞü p~`R> NÊ€« Ðq‚n;m;»R????APPLRR:@é`R:P R4PR9 R*@R< R*macssubm@àL@àHR:ðR< <ðR*R:àR< macsexpiR:àR;pR< R:àmacsexpi@àX@àTR:k°¢°íÀ<ðR9PR:à@R< *R:àR; R< R:àR*@R=`R*macssubm@à@@à<R;ÐðR=`R<°¡`R*R< R=`macsexpiR< R<@pR=`R< macsexpi@àL@àHR;Ðk°¡píÀR<°¡`R:R< @R=`*R< R<Ð R=`R< R*@R> R*macssubm@à4@à0RðR> ÿ¹ÿºR*R=`R> macsexpiR=`R=€pR> R=`macsexpi@à@@à<R=k° 0íÀÿ¹ÿºR;ÐR=`@R> *R=`R> R> R=`R)ððRQR)ðmacsindc@á @áR>P RQR)ðR> R@macsexpiR> R>ÀpR@R> macsexpi@à4@à0R>Pk°žðíÀR=R> ðRQ,ÄR> R?PÐRQmacsevntR> R?p°RQR> macsevnt@á @áR?k°°íÀR?а R>PR?@RQ €R> R@« ˆÞü p~`R> NÊ€« Ðq‚n;m;»(mstrDmstlDmstn DmstrèD€mstlèÄ€mstnèDmtpl H€mtps ( mtsl ÈmtpiDPmtlo prefÝDÐprefa¹/prefÖ=5(Èpref6ŒSYpref$ïT` prefïn prefg . pref%S”pref“š W€pref‰9 ¢>prefóK àpref³ô X†Úprefb¾ Z`Žpref•,SM pref`_îpref+¦î2pref²“`þ€pref×øi~prefçÊl’bpref~Š pref‚T 8 pref‚1lôÊprefL~m¾prefä'nÖ¨prefÅ´Rð.pref¤žo~ prefwÿS"prefqŠprefÕ…qžprefýfq¸’pref&¼rJjprefðg Ø(mstiès•,mpsièuÁmtglèrÁ(mstiwÝPLst(¨!rémallrñ¤maplxÝprefA…"}ípref4ê#‚ýprefºß$4prefO#%8 prefaõ&†prefû\'‹ Üprefö(šçØpref]ì)œÊprefå*S@ prefKt+›¿pref‚,r´ prefy~-œÁ motiPapyrus3/PapyEnumMiscModules3.h0000755000175000017500000003451010044172226013667 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyEnumMiscModules3.h */ /* Function : contains the declarations of the modules that are not */ /* in the image modules */ /* Authors : Christian Girard */ /* */ /* History : 08.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* */ /********************************************************************************/ #ifndef PapyEnumMiscModulesH #define PapyEnumMiscModulesH /* Module : Basic Annotation Presentation */ enum { papAnnotationPosition, papTextString, papEndBasicAnnotationPresentation }; /* Module : Basic Film Box Presentation */ enum { papImageDisplayFormat, papAnnotationDisplayFormatID, papFilmOrientation, papFilmSizeID, papMagnificationTypeBFBP, papSmoothingTypeBFBP, papBorderDensity, papEmptyImageDensity, papMinDensity, papMaxDensity, papTrim, papConfigurationInformation, papEndBasicFilmBoxPresentation }; /* Module : Basic Film Box Relationship */ enum { papReferencedFilmSessionSequence, papReferencedImageBoxSequenceBFBR, papReferencedBasicAnnotationBoxSequence, papEndBasicFilmBoxRelationship }; /* Module : Basic Film Session Presentation */ enum { papNumberofCopies, papPrintPriorityBFSP, papMediumType, papFilmDestination, papFilmSessionLabel, papMemoryAllocation, papEndBasicFilmSessionPresentation }; /* Module : File Reference */ enum { papReferencedSOPClassUID, papReferencedSOPInstanceUID, papReferencedFileName, papReferencedFilePath, papEndFileReference }; /* Module : Identifying Image Sequence */ enum { papImageIdentifierSequence, papEndIdentifyingImageSequence }; /* Module : LUT Identification */ enum { papLUTNumber, papReferencedImageSequenceLI, papEndLUTIdentification }; /* Module : Patient Demographic */ enum { papPatientsAddress, papRegionofResidence, papCountryofResidence, papPatientsTelephoneNumbers, papPatientsBirthDatePD, papPatientsBirthTimePD, papEthnicGroupPD, papPatientsSexPD, papPatientsSizePD, papPatientsWeightPD, papMilitaryRank, papBranchofService, papPatientsInsurancePlanCodeSequence, papPatientsReligiousPreference, papPatientCommentsPD, papEndPatientDemographic }; /* Module : Patient Identification */ enum { papPatientsNamePI, papPatientIDPI, papIssuerofPatientID, papOtherPatientIDs, papOtherPatientNamesPI, papPatientsBirthName, papPatientsMothersBirthName, papMedicalRecordLocator, papEndPatientIdentification }; /* Module : Patient Medical */ enum { papPatientState, papPregnancyStatus, papMedicalAlerts, papContrastAllergies, papSpecialNeeds, papLastMenstrualDate, papSmokingStatus, papAdditionalPatientHistory, papEndPatientMedical }; /* Module : Patient Relationship */ enum { papReferencedVisitSequencePR, papReferencedStudySequencePR, papReferencedPatientAliasSequence, papEndPatientRelationship }; /* Module : Patient Summary */ enum { papPatientsNamePS, papPatientIDPS, papEndPatientSummary }; /* Module : Printer */ enum { papPrinterStatus, papPrinterStatusInfo, papPrinterNameP, papManufacturerP, papManufacturerModelName, papDeviceSerialNumberP, papSoftwareVersionsP, papDateOfLastCalibration, papTimeOfLastCalibration, papEndPrinter }; /* Module : Print Job */ enum { papExecutionStatus, papExecutionStatusInfo, papCreationDate, papCreationTime, papPrintPriorityPJ, papPrinterNamePJ, papOriginator, papEndPrintJob }; /* Module : Result Identification */ enum { papResultsID, papResultsIDIssuer, papEndResultIdentification }; /* Module : Results Impression */ enum { papImpressions, papResultsComments, papEndResultsImpression }; /* Module : Result Relationship */ enum { papReferencedStudySequenceRR, papReferencedInterpretationSequence, papEndResultRelationship }; /* Module : Study Acquisition */ enum { papStudyArrivalDate, papStudyArrivalTime, papStudyDateSA, papStudyTimeSA, papStudyCompletionDate, papStudyCompletionTime, papStudyVerifiedDate, papStudyVerifiedTime, papSeriesinStudy, papAcquisitionsinStudy, papEndStudyAcquisition }; /* Module : Study Classification */ enum { papStudyStatusID, papStudyPriorityID, papStudyComments, papEndStudyClassification }; /* Module : Study Component Acquisition */ enum { papModalitySCA, papStudyDescriptionSCA, papProcedureCodeSequence, papPerformingPhysiciansNameSCA, papStudyComponentStatusID, papEndStudyComponentAcquisition }; /* Module : Study Component */ enum { papStudyIDSC, papStudyInstanceUIDSC, papReferencedSeriesSequenceSC, papEndStudyComponent }; /* Module : Study Component Relationship */ enum { papReferencedStudySequenceSCR, papEndStudyComponentRelationship }; /* Module : Study Content */ enum { papStudyIDSCt, papStudyInstanceUIDSCt, papReferencedSeriesSequenceSCt, papEndStudyContent }; /* Module : Study Identification */ enum { papStudyIDSI, papStudyIDIssuer, papOtherStudyNumbers, papEndStudyIdentification }; /* Module : Study Read */ enum { papNameofPhysiciansReadingStudySR, papStudyReadDate, papStudyReadTime, papEndStudyRead }; /* Module : Study Relationship */ enum { papReferencedVisitSequenceSR, papReferencedPatientSequenceSR, papReferencedResultsSequenceSR, papReferencedStudyComponentSequenceSR, papStudyInstanceUIDSR, papAccessionNumberSR, papEndStudyRelationship }; /* Module : Study Scheduling */ enum { papScheduledStudyStartDate, papScheduledStudyStartTime, papScheduledStudyStopDate, papScheduledStudyStopTime, papScheduledStudyLocation, papScheduledStudyLocationAETitle, papReasonforStudy, papRequestingPhysician, papRequestingService, papRequestedProcedureDescription, papRequestedProcedureCodeSequence, papRequestedContrastAgent, papEndStudyScheduling }; /* Module : US Frame of Reference */ enum { papRegionLocationMinx0, papRegionLocationMiny0, papRegionLocationMaxx1, papRegionLocationMaxy1, papPhysicalUnitsXDirection, papPhysicalUnitsYDirection, papPhysicalDeltaX, papPhysicalDeltaY, papReferencePixelx0, papReferencePixely0, papRefPixelPhysicalValueX, papRefPixelPhysicalValueY, papEndUSFrameofReference }; /* Module : Visit Admission */ enum { papAdmittingDate, papAdmittingTime, papRouteofAdmissions, papAdmittingDiagnosisDescription, papAdmittingDiagnosisCodeSequence, papReferringPhysiciansNameVA, papAddress, papReferringPhysiciansPhoneNumbers, papEndVisitAdmission }; /* Module : Visit Discharge */ enum { papDischargeDate, papDischargeTime, papDescription, papDischargeDiagnosisCodeSequence, papEndVisitDischarge }; /* Module : Visit Identification */ enum { papInstitutionNameVI, papInstitutionAddressVI, papInstitutionCodeSequence, papAdmissionID, papIssuerofAdmissionID, papEndVisitIdentification }; /* Module : Visit Relationship */ enum { papReferencedStudySequenceVR, papReferencedPatientSequenceVR, papEndVisitRelationship }; /* Module : Visit Scheduling */ enum { papScheduledAdmissionDate, papScheduledAdmissionTime, papScheduledDischargeDate, papScheduledDischargeTime, papScheduledPatientInstitutionResidence, papEndVisitScheduling }; /* Module : Visit Status */ enum { papVisitStatusID, papCurrentPatientLocationVS, papPatientsInstitutionResidenceVS, papVisitComments, papEndVisitStatus }; /* Module : Interpretation Approval */ enum { papInterpretationApproverSequence, papInterpretationDiagnosisDescription, papInterpretationDiagnosisCodesSequence, papResultsDistributionListSequence, papEndInterpretationApproval }; /* Module : Interpretation Transcription */ enum { papInterpretationTranscriptionDate, papInterpretationTranscriptionTime, papInterpretationTranscriber, papInterpretationText, papInterpretationAuthor, papEndInterpretationTranscription }; /* Module : Interpretation State */ enum { papInterpretationTypeID, papInterpretationStatusID, papEndInterpretationState }; /* Module : Interpretation Recording */ enum { papInterpretationRecordedDate, papInterpretationRecordedTime, papInterpretationRecorder, papReferencetoRecordedSound, papEndInterpretationRecording }; /* Module : Interpretation Identification */ enum { papInterpretationID, papInterpretationIDIssuer, papEndInterpretationIdentification }; /* Module : Interpretation Relationship */ enum { papReferencedResultsSequenceIR, papEndInterpretationRelationship }; /* Module : Image Overlay Box Relationship */ enum { papReferencedImageBoxSequenceOBR, papEndImageOverlayBoxRelationship }; /* Module : Image Box Relationship */ enum { papReferencedImageSequenceBR, papReferencedImageOverlayBoxSequence, papReferencedVOILUTSequence, papEndImageBoxRelationship }; /* Module : Image Box Pixel Presentation */ enum { papImagePosition, papPolarity, papMagnificationTypeIBPP, papSmoothingTypeIBPP, papRequestedImageSize, papPreformattedGrayscaleImageSequence, papPreformattedColorImageSequence, papEndImageBoxPixelPresentation }; /* Module : Image Overlay Box Presentation */ enum { papReferencedOverlayPlaneSequence, papOverlayMagnificationType, papOverlaySmoothingType, papOverlayForegroundDensity, papOverlayMode, papThresholdDensity, papEndImageOverlayBoxPresentation }; /* Module : External Visit Reference Sequence */ enum { papReferencedVisitSequenceEVRS, papEndExternalVisitReferenceSequence }; /* Module : External Study File Reference Sequence */ enum { papReferencedStudySequenceESFRS, papEndExternalStudyFileReferenceSequence }; /* Module : External Patient File Reference Sequence*/ enum { papReferencedPatientSequenceEPFRS, papEndExternalPatientFileReferenceSequence }; /* Module : External Papyrus_File Reference Sequence*/ enum { papExternalPAPYRUSFileReferenceSequence, papEndExternalPapyrus_FileReferenceSequence }; /* Module : Basic Film Session Relationship */ enum { papReferencedFilmBoxSequence, papEndBasicFilmSessionRelationship }; #endif /* PapyEnumMiscModulesH */ Papyrus3/Papyrus3.dsp0000755000175000017500000001307707535143454012007 0ustar # Microsoft Developer Studio Project File - Name="Papyrus3" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=Papyrus3 - Win32 Release !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "Papyrus3.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "Papyrus3.mak" CFG="Papyrus3 - Win32 Release" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "Papyrus3 - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "Papyrus3 - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName ""$/osiris/Papyrus3", YXGAAAAA" # PROP Scc_LocalPath "." CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "Papyrus3 - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir ".\Release" # PROP BASE Intermediate_Dir ".\Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir ".\Release" # PROP Intermediate_Dir ".\Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /G3 /Zp1 /W3 /O2 /I "\osiris\papyrus3" /I "\osiris\papyrus3\jpglless" /I "\osiris\papyrus3\jpglossy" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "STRICT" /D "_WIN16_" /D "FILENAME83" /D "PAPY3_VAR" /YX /c # ADD CPP /nologo /Zp1 /W3 /GX /O2 /I "DicomDir\\" /I "JpegDir\Jpglless\\" /I "JpegDir\Jpglossy\\" /I "..\Papyrus2\\" /D "NDEBUG" /D "_WINDOWS" /D "STRICT" /D "PAPY3_VAR" /D "_MBCS" /D "WIN32" /YX /FD /c # ADD BASE RSC /l 0x40c # ADD RSC /l 0x40c BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ELSEIF "$(CFG)" == "Papyrus3 - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir ".\Debug" # PROP BASE Intermediate_Dir ".\Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir ".\Debug" # PROP Intermediate_Dir ".\Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /Zp1 /W3 /Gm /Zi /Od /Gf /Gy /I "\osiris\papyrus3" /I "\osiris\papyrus3\jpglless" /I "\osiris\papyrus3\jpglossy" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "_WIN16_" /D "FILENAME83" /D "PAPY3_VAR" /YX /c # ADD CPP /nologo /Zp1 /W3 /Gm /GX /Zi /Od /I "DicomDir\\" /I "JpegDir\Jpglless\\" /I "JpegDir\Jpglossy\\" /I "..\Papyrus2\\" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "PAPY3_VAR" /D "_MBCS" /D "WIN32" /FR /YX /FD /c # ADD BASE RSC /l 0x40c # ADD RSC /l 0x40c BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ENDIF # Begin Target # Name "Papyrus3 - Win32 Release" # Name "Papyrus3 - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90" # Begin Source File SOURCE=.\PapyConvertFile3.c # End Source File # Begin Source File SOURCE=.\PapyDataSetRead3.c # End Source File # Begin Source File SOURCE=.\PapyDataSetWrite3.c # End Source File # Begin Source File SOURCE=.\PapyEallocPC3.cpp # End Source File # Begin Source File SOURCE=.\PapyError3.c # End Source File # Begin Source File SOURCE=.\PapyFiles3.c # End Source File # Begin Source File SOURCE=.\PapyFileSystemPC3.c # End Source File # Begin Source File SOURCE=.\PapyGetGlobalVar3.c # End Source File # Begin Source File SOURCE=.\PapyInit3.c # End Source File # Begin Source File SOURCE=.\PapyInitGroups3.c # End Source File # Begin Source File SOURCE=.\PapyInitModules3.c # End Source File # Begin Source File SOURCE=.\PapyList3.c # End Source File # Begin Source File SOURCE=.\PapyRead3.c # End Source File # Begin Source File SOURCE=.\PapyUtils3.c # End Source File # Begin Source File SOURCE=.\PapyVars3.c # End Source File # Begin Source File SOURCE=.\PapyWild3.c # End Source File # Begin Source File SOURCE=.\PapyWildexit3.c # End Source File # Begin Source File SOURCE=.\PapyWrite3.c # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd" # Begin Source File SOURCE=.\PapyEalloc3.h # End Source File # Begin Source File SOURCE=.\PapyEnumGroups3.h # End Source File # Begin Source File SOURCE=.\PapyEnumImageGroups3.h # End Source File # Begin Source File SOURCE=.\PapyEnumImagesModules3.h # End Source File # Begin Source File SOURCE=.\PapyEnumModules3.h # End Source File # Begin Source File SOURCE=.\PapyError3.h # End Source File # Begin Source File SOURCE=.\PapyErrorMacros3.h # End Source File # Begin Source File SOURCE=.\PapyFileSystem3.h # End Source File # Begin Source File SOURCE=.\PapyGlobalVar3.h # End Source File # Begin Source File SOURCE=.\PapyInitModules3.h # End Source File # Begin Source File SOURCE=.\PapyPrivFunctionDef3.h # End Source File # Begin Source File SOURCE=.\PapyPubFunctionDef3.h # End Source File # Begin Source File SOURCE=.\PAPYRUS3.h # End Source File # Begin Source File SOURCE=.\PapyTypeDef3.h # End Source File # Begin Source File SOURCE=.\PapyWild3.h # End Source File # End Group # Begin Group "Resource Files" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe" # End Group # End Target # End Project Papyrus3/PapyPubFunctionDef3.h0000755000175000017500000002723210044175722013500 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyPubFunctionDef3.h */ /* Function : contains the declarations of the public functions */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 01.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef PapyPubFunctionDef3H #define PapyPubFunctionDef3H /* --- functions definitions --- */ /* --- PapyDataSetRead3 --- */ extern EXPORT32 Module* EXPORT Papy3GetModule (PapyShort, PapyShort, int); /* --- PapyDataSetWrite3 --- */ extern EXPORT32 SElement* EXPORT Papy3GetGroup2 (PapyShort); extern EXPORT32 Item* EXPORT Papy3CreateDataSet (PapyShort); extern EXPORT32 PapyShort EXPORT Papy3InsertItemToSequence (Module *, int, enum EKind_Obj, void *, int); extern EXPORT32 void EXPORT Papy3LinkModuleToDS (Item *, Module *, int); extern EXPORT32 void EXPORT Papy3LinkGroupToDS (Item *, SElement *, int); extern EXPORT32 Module* EXPORT Papy3CreateModule (Item *, int); extern EXPORT32 Module* EXPORT Papy3FindModule (Item *, int); extern EXPORT32 PapyShort EXPORT Papy3CloseDataSet (PapyShort, Item *, int, int); /* --- PapyFiles3 --- */ extern EXPORT32 PapyShort EXPORT FindFreeFile3 (); extern EXPORT32 PapyShort EXPORT Papy3FileOpen (char *, PAPY_FILE, int, void* ); extern EXPORT32 PapyShort EXPORT Papy3FileCreate (char *, PAPY_FILE, PapyUShort, enum ETransf_Syntax, enum EPap_Compression, enum EModality, int, int, void*); extern EXPORT32 PapyShort EXPORT Papy3FileClose (PapyShort, int); extern EXPORT32 PapyShort EXPORT Papy3WriteAndCloseFile (PapyShort, int); extern EXPORT32 PapyShort EXPORT Papy3GetNextGroupNb (PapyShort); extern EXPORT32 PapyShort EXPORT Papy3SkipNextGroup (PapyShort); extern EXPORT32 PapyShort EXPORT Papy3GotoGroupNb (PapyShort, PapyShort); extern EXPORT32 PapyUShort EXPORT Papy3FindOwnerRange (PapyShort, PapyUShort, char *); extern EXPORT32 PapyShort EXPORT Papy3GotoElemNb (PapyShort, PapyUShort, PapyUShort, PapyULong *); extern EXPORT32 PapyULong EXPORT Papy3ExtractItemLength (PapyShort); /* --- PapyConvertFiles3 --- */ extern EXPORT32 int EXPORT Papyrus2Papyrus (char *, char *, PAPY_FILE, int, int *); extern EXPORT32 int EXPORT Papyrus2Dicom (char *, char *, PAPY_FILE, int, int *); extern EXPORT32 int EXPORT Dicom2Papyrus (char *, int, char **, int, enum EModality); extern EXPORT32 int EXPORT GetPapyFileType (char *, int *, int *, enum EModality *); extern EXPORT32 int EXPORT Papyrus2Jpeg (char *, char *, short, int *, int, int, enum EPap_Compression, int); /*extern EXPORT32 int EXPORT OldPapyrus2Jpeg (char *, char *, short, int, int *, int, int);*/ /* --- PapyInit3 --- */ extern EXPORT32 PapyShort EXPORT Papy3AddOwner (PapyShort, char *); extern EXPORT32 PapyShort EXPORT Papy3Init (); extern EXPORT32 void EXPORT Papy3FreeDataSetModules (); extern EXPORT32 PapyShort EXPORT Dicom2PapyInit (); extern EXPORT32 enum EModality EXPORT SetModality (char *); extern EXPORT32 void EXPORT SetCompression (enum EPap_Compression); extern EXPORT32 void EXPORT SetCompressionFactor (int); extern EXPORT32 void EXPORT SetZoomFactor (float); extern EXPORT32 void EXPORT SetWindowingValue (int, int); extern EXPORT32 void EXPORT SetSubSamplingFactor (float); extern EXPORT32 void EXPORT SetCropingPoints (float, float, float, float); extern EXPORT32 SElement* EXPORT Papy3GroupCreate (int); extern EXPORT32 PapyShort EXPORT Papy3ClearElement (SElement *, PapyShort, int); extern EXPORT32 PapyShort EXPORT Papy3GroupFree (SElement **, int); extern EXPORT32 PapyShort EXPORT Papy3ModuleFree (SElement **, int, int); extern EXPORT32 PapyShort EXPORT Papy3ImageFree (SElement *); /* --- functions of the list handler (PapyList3) --- */ extern Papy_List* InsertFirstInList (Papy_List **, Object *); extern Papy_List* InsertLastInList (Papy_List **, Object *); extern Papy_List* InsertInListAt (Papy_List **, Object *, PapyShort); extern Papy_List* InsertGroupInList (Papy_List **, Object *); extern PapyShort DeleteFirstInList (PapyShort, Papy_List **, int, int, int); extern PapyShort DeleteLastInList (PapyShort, Papy_List **, int, int, int); extern PapyShort DeleteList (PapyShort, Papy_List **, int, int, int); /* --- PapyRead3 --- */ extern EXPORT32 UValue_T* EXPORT Papy3GetElement (SElement*, int, PapyULong *, int *); extern EXPORT32 PapyUShort* EXPORT Papy3GetPixelData (PapyShort, int, SElement *, int); extern EXPORT32 PapyShort EXPORT Papy3GroupRead (PapyShort, SElement **); /* --- PapyUtils3 --- */ extern EXPORT32 void EXPORT Papy3SetIconSize (PapyUShort); extern EXPORT32 PapyUShort EXPORT Papy3GetIconSize (); extern char * PapyStrDup (char *); extern EXPORT32 PapyShort EXPORT Papy3GotoUID (PapyShort, char *, enum EDataSet_Image); extern EXPORT32 PapyShort EXPORT Papy3GotoNumber (PapyShort, PapyShort, enum EDataSet_Image); extern EXPORT32 PapyShort EXPORT Papy3CheckValidOwnerId (PapyShort, unsigned char *, PapyULong *, PapyUShort, PapyULong, SElement *); extern EXPORT32 int EXPORT Papy3ToEnumGroup (PapyUShort); extern EXPORT32 PapyUShort EXPORT Papy3EnumToElemNb (SElement *, int); extern EXPORT32 PapyShort EXPORT Papy3ElemTagToEnumNb (PapyUShort, PapyUShort, int *, int *); extern EXPORT32 void ExtractDicomdirFromPath (char *, char *); extern EXPORT32 void ExtractModality (UValue_T *val, PapyShort fileNb); extern EXPORT32 void EXPORT Pap2ToPap3Date (char *, char *); extern EXPORT32 void EXPORT Pap2ToPap3Time (char *, char *); extern EXPORT32 void EXPORT Pap2ToPap3Name (char *, char *); extern EXPORT32 PapyUChar * EXPORT ConvertYbrToRgb (PapyUChar *, int, int, enum EPhoto_Interpret, char); /* --- PapyWrite3 --- */ extern EXPORT32 PapyShort EXPORT Papy3PutElement (SElement *, int, void *); extern EXPORT32 PapyShort EXPORT Papy3PutIcon (PapyShort, PapyShort, PapyUChar *); extern EXPORT32 PapyShort EXPORT Papy3PutImage (PapyShort, SElement *, int, PapyUShort *, PapyUShort, PapyUShort, PapyUShort, PapyULong); extern EXPORT32 PapyShort EXPORT Papy3PutUnknown (SElement *, int, PapyChar *, PapyULong); extern EXPORT32 PapyShort EXPORT Papy3GroupWrite (PapyShort, SElement *, int); extern EXPORT32 PapyShort EXPORT JPEGLossyEncodeImage (PapyShort, int , PapyUChar *, PapyUChar *, PapyUChar **, PapyULong *,int , int , int , int); /* --- PapyError3 --- */ extern EXPORT32 void EXPORT PAPY3PRINTERRMSG (); /* functions for getting global vars (PapyGetGlobalVar3) */ extern EXPORT32 PAPY_FILE EXPORT Papy3GetFile (PapyShort); extern EXPORT32 int EXPORT Papy3GetCurrTmpFilename(PapyShort); extern EXPORT32 PapyShort EXPORT Papy3GetNbImages (PapyShort); extern EXPORT32 enum ETransf_Syntax EXPORT Papy3GetTransfSyntax (PapyShort); extern EXPORT32 int EXPORT Papy3GetModality (PapyShort); extern EXPORT32 PapyShort EXPORT Papy3GetNbElemInModule (int); extern EXPORT32 int EXPORT Papy3GetFileKind (int); extern EXPORT32 char* EXPORT Papy3GetToolkitVersion (); extern EXPORT32 enum EPap_Compression EXPORT Papy3GetCompression (PapyShort); #endif /* PapyPubFunctionDef3H */ Papyrus3/PapyMemSystem.h0000755000175000017500000001556110044205642012462 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyMemSystem.h */ /* Function : contains calls for asynchronous read */ /* Authors : Olivier Baujard */ /* */ /* History : 03.1997 version 3.1 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* */ /********************************************************************************/ #ifndef PapyMemSystem3H #define PapyMemSystem3H /* ------------------------- includes ------------------------------------------*/ #include #include /* _beginthread, _endthread */ #include #ifdef __cplusplus extern "C" { int __cdecl _close(int); long __cdecl _lseek(int, long, int); int __cdecl _open(const char *, int, ...); int __cdecl _read(int, void *, unsigned int); int __cdecl _write(int, void *, unsigned int); char* __cdecl sprintf(char*, char *, ...); } #endif #ifdef __cplusplus /* C++ PapyMemSystem class and functions */ class PapyMemSystem { public: PapyMemSystem(); ~PapyMemSystem(); int Open(char* aFilename,long aLength,long aChunkSize=10240L); void Close(); int Read(char* aBuffer,int aLength); long Seek(int aPosition,long anOffset); int WaitSomethingToRead(); int WaitPlaceToWrite(); int IsMemoryAllocated(); static void ReadMemory(void* aPapyMemSystem); // function used in thread private: char* theBuffer; // Buffer to read from long theLength; // Length of buffer long theChunkSize; // Length of an element chunk read in thread char* theFilename; // Filename to read from unsigned long theReadingThread; // Handle to thread reading from filename to fill buffer char* theFirstPosition; // Starting position of buffer char* theLastPosition; // Last position in buffer char* theCurrentRead; // Current position of buffer reading cursor char* theCurrentWrite; // Current position of file reading cursor HANDLE theReadEvent; // Event to synchronize file reading HANDLE theReadMutex; // Mutex to synchronize buffer reading HANDLE theWriteMutex; // Mutex to synchronize file reading HANDLE theBooleanMutex; // Mutex to synchronize file reading short theBoolean; // boolean to check if end of buffer has been reach by all threads }; extern "C" { int OpenMemSystem(char* aFilename,long aLength,long aChunk); int ReadMemSystem(char* aBuffer,int aLength); int SeekMemSystem(int aPosition,long anOffset); int IsAllocated(); void CloseMemSystem(); } #endif #ifndef __cplusplus /* C API to PapyMemSystem class */ void* CreatePapyMemSystem(); int OpenPapyMemSystem(void* aPapyMemSystem,char* aFilename,long aLength,long aChunk); void ClosePapyMemSystem(void* aPapyMemSystem); int ReadPapyMemSystem(void* aPapyMemSystem,char* aBuffer,int aLength); int SeekPapyMemSystem(void* aPapyMemSystem,int aPosition,long anOffset); int IsMemoryAllocated(void* aPapyMemSystem); void DeletePapyMemSystem(void* aPapyMemSystem); int OpenMemSystem(char* aFilename,long aLength,long aChunk); int ReadMemSystem(char* aBuffer,int aLength); int SeekMemSystem(int aPosition,long anOffset); int IsAllocated(); void CloseMemSystem(); #endif #endif Papyrus3/PapyEnumGroups3.h0000755000175000017500000001261610044173020012716 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyEnumGroups3.h */ /* Function : contains the declarations of the groups names and of the */ /* elements names */ /* Authors : Christian Girard */ /* */ /* History : 04.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef PapyEnumGroups3H #define PapyEnumGroups3H #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyEnumImageGroups3H #include "PapyEnumImageGroups3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyEnumImageGroups3H #include "PAPEIG3.h" #endif #endif /* FILENAME83 defined */ /* enumeration of the groups */ enum groups { Group2, Group4, Group8, Group10, Group18, Group20, Group28, Group32, Group38, Group3A, Group40, Group41, Group50, Group54, Group60, Group70, Group88, Group100, Group2000, Group2010, Group2020, Group2030, Group2040, Group2050, Group2100, Group2110, Group2120, Group2130, Group3002, Group3004, Group3006, Group3008, Group300A, Group300C, Group300E, Group4000, Group4008, Group5000, Group5400, Group6000, UINOVERLAY, Group7FE0, END_GROUP }; #endif Papyrus3/PapyEallocPC3.cpp0000755000175000017500000002341510044174636012604 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyEalloc3.c */ /* Function : contains all the allocating stuff */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* Olivier Baujard */ /* */ /* History : 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ /* ------------------------- includes ---------------------------------------*/ #include #include #include #include #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif extern "C" { #include "PapyWild3.h" } #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PAPYDEF3.h" #endif #include "PAPWILD3.h" #endif /* FILENAME83 defined */ #include #ifdef DLL #define __huge #define __far #define GB_ALLOC #endif /********************************************************************************/ /* */ /* efree3 : free the allocated memory and put the pointer to NULL */ /* */ /********************************************************************************/ /* modify it to have the pointer on the pointer to really put it to NULL */ extern "C" void efree3 (void **p) { #ifdef GB_ALLOC HGLOBAL hglb; DWORD dw; if (*p == NULL) return; hglb = GlobalHandle (*p); GlobalUnlock (hglb); GlobalFree (hglb); *p = NULL; #else /* free (*p); */ char* ptr=(char*)*p; delete [] ptr; *p = NULL; #endif } /* endof efree3 */ /********************************************************************************/ /* */ /* checkvp3 : check if the new allocated did not failed */ /* return : the validated pointer if OK */ /* else exit the program */ /* */ /********************************************************************************/ extern "C" void * checkvp3 (void *pointer) { if (pointer == NULL) wildrexit ("allocating memory"); return pointer; } /* endof checkvp3 */ /********************************************************************************/ /* */ /* emalloc3 : checked version of malloc */ /* return : the validated pointer if OK */ /* */ /********************************************************************************/ extern "C" void *emalloc3 (PapyULong size) { #ifdef GB_ALLOC void __huge* ptr; HGLOBAL hglb; hglb = GlobalAlloc (GHND, size); assert (hglb != NULL); ptr = GlobalLock (hglb); return checkvp3 (ptr); #else /* return checkvp3 (malloc ((size_t)size)); */ char* pp=new char[size]; memset(pp,0,size); return checkvp3((void*)pp); #endif } /* endof emalloc3 */ /********************************************************************************/ /* */ /* ecalloc3 : checked version of calloc */ /* return : the validated pointer if OK */ /* */ /********************************************************************************/ extern "C" void *ecalloc3 (PapyULong nelem, PapyULong elsize) { #ifdef GB_ALLOC void __far* ptr; HGLOBAL hglb; unsigned long size; size = nelem * elsize; if (size == 0L) return NULL; hglb = GlobalAlloc (GHND, size); assert (hglb != NULL); ptr = GlobalLock (hglb); return checkvp3 (ptr); #else /* return checkvp3 (calloc ((size_t)nelem, (size_t)elsize)); */ char* pp=new char[nelem*elsize]; memset(pp,0,nelem*elsize); return checkvp3((void*)pp); #endif } /* endof ecalloc3 */ /********************************************************************************/ /* */ /* erealloc3 : checked version of realloc */ /* return : the validated pointer if OK */ /* */ /********************************************************************************/ extern "C" void *erealloc3 (void* ptr, PapyULong size,PapyULong size2) { #ifdef GB_ALLOC HGLOBAL hglb; DWORD dw; hglb = GlobalHandle (ptr); GlobalUnlock (hglb); hglb = GlobalReAlloc (hglb, size, GMEM_ZEROINIT | GMEM_MOVEABLE); ptr = GlobalLock (hglb); return checkvp3 (ptr); #else /* return checkvp3 (realloc (ptr, (size_t)size)); */ char* p=new char[(unsigned int)size]; memset(p,0,size); memcpy(p,(char*)ptr,size2); efree3(&ptr); return checkvp3 ((void*)p); #endif } /* endof erealloc3 */ Papyrus3/PapyWildexit3.c0000755000175000017500000002130010044201634012367 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyWildexit3.c */ /* Function : contains all program exit points */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 04.1991 version 1.1 */ /* 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ /* ------------------------- includes ---------------------------------------*/ #include #include #ifndef FILENAME83 /* this is for the normal machines ... */ #include "PapyWild3.h" #else /* FILENAME83 defined for the DOS machines */ #include "PAPWILD3.h" #endif /* FILENAME83 defined */ #ifndef EXIT_FAILURE #define EXIT_FAILURE -1 #endif #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #endif static void (* EX_funcp) (); static int ExitEnabled = 1; /*******************************************************************************/ /* */ /* ActiveExitWhenError : */ /* */ /*******************************************************************************/ void ActiveExitWhenError () { ExitEnabled = 1; } /* endof ActiveExitWhenError */ /*******************************************************************************/ /* */ /* UnactiveExitWhenError : */ /* */ /*******************************************************************************/ void UnactiveExitWhenError () { ExitEnabled = 0; } /* endof UnactiveWhenError */ /*******************************************************************************/ /* */ /* exset : */ /* */ /*******************************************************************************/ void exset (void (* funcp) ()) { EX_funcp = funcp; } /* endof exset */ /*******************************************************************************/ /* */ /* wild2exit : */ /* */ /*******************************************************************************/ void wild2exit (char *inString1P, char *inString2P) { /* ** We should try to arrange for functions registerd using atexit ** to be called before the output we generate goes to stderr. ** For now. . . */ if (EX_funcp != NULL) EX_funcp (); if (ExitEnabled) { wild3 (inString1P, inString2P); #ifndef DLL exit (EXIT_FAILURE); #else abort (); #endif } /*NOTREACHED*/ } /* endof wild2exit */ /*******************************************************************************/ /* */ /* wildexit : */ /* */ /*******************************************************************************/ void wildexit (char *inStringP) { wild2exit (inStringP, (char *) NULL); /*NOTREACHED*/ } /* endof wildexit */ /*******************************************************************************/ /* */ /* wildcexit : */ /* */ /*******************************************************************************/ void wildcexit (char *inStringP) { wild2exit ("call of", inStringP); /*NOTREACHED*/ } /* endof wildcexit */ /*******************************************************************************/ /* */ /* wildrexit : */ /* */ /*******************************************************************************/ void wildrexit (char *inStringP) { wild2exit ("result from", inStringP); /*NOTREACHED*/ } /* endof wildrexit */ /*******************************************************************************/ /* */ /* tameexit : */ /* */ /*******************************************************************************/ void tameexit () { if (EX_funcp != NULL) EX_funcp (); if (ExitEnabled) #ifndef DLL exit (EXIT_SUCCESS); #else abort (); #endif /*NOTREACHED*/ } /* endof tameexit */ Papyrus3/PapyEnumImageGroups3.h0000755000175000017500000014710610044172704013674 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyEnumImageGroups3.h */ /* Function : contains the declarations of the groups names and of the */ /* elements names */ /* Authors : Christian Girard */ /* */ /* History : 04.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef PapyEnumImageGroups3H #define PapyEnumImageGroups3H /* Group2 */ enum { papGroupLength, papFileMetaInformationVersionGr, papMediaStorageSOPClassUIDGr, papMediaStorageSOPInstanceUIDGr, papTransferSyntaxUIDGr, papImplementationClassUIDGr, papImplementationVersionNameGr, papSourceApplicationEntityTitleGr, papPrivateInformationCreatorUIDGr, papPrivateInformationGr, papEndGroup2 }; /* Group4 */ enum { papFilesetIDGr = 1, papFileIDofFilesetDescriptorFileGr, papFormatofFilesetDescriptorFileGr, papOffsetofTheFirstDirectoryRecordGr, papOffsetofTheLastDirectoryRecordGr, papFilesetConsistencyFlagGr, papDirectoryRecordSequenceGr, papOffsetofNextDirectoryRecordGr, papRecordInuseGr, papOffsetofReferencedLowerLevelDirectoryEntityGr, papDirectoryRecordTypeGr, papPrivateRecordUIDGr, papReferencedFileIDGr, papMRDRDirectoryRecordOffsetGr, papReferencedSOPClassUIDinFileGr, papReferencedSOPInstanceUIDinFileGr, papReferencedTransferSyntaxUIDinFileGr, papNumberOfReferencesGr, papEndGroup4 }; /* Group8 */ enum { papLengthtoEndGr = 1, papSpecificCharacterSetGr, papImageTypeGr, papRecognitionCodeGr, papInstanceCreationDateGr, papInstanceCreationTimeGr, papInstanceCreatorUIDGr, papSOPClassUIDGr, papSOPInstanceUIDGr, papStudyDateGr, papSeriesDateGr, papAcquisitionDateGr, papImageDateGr, papOverlayDateGr, papCurveDateGr, papAcquisitionDatetimeGr, papStudyTimeGr, papSeriesTimeGr, papAcquisitionTimeGr, papImageTimeGr, papOverlayTimeGr, papCurveTimeGr, papDataSetTypeGr, papDataSetSubtypeGr, papNuclearMedicineSeriesTypeGr, papAccessionNumberGr, papQueryRetrieveLevelGr, papRetrieveAETitleGr, papInstanceAvailabilityGr, papFailedSOPInstanceUIDListGr, papModalityGr, papModalitiesInStudyGr, papConversionTypeGr, papPresentationIndentTypeGr, papManufacturerGr, papInstitutionNameGr, papInstitutionAddressGr, papInstitutionCodeSequenceGr, papReferringPhysiciansNameGr, papReferringPhysiciansAddressGr, papReferringPhysiciansTelephoneNumbersGr, papCodeValueGr, papCodingSchemeDesignatorGr, papCodingSchemeVersionGr, papCodeMeaningGr, papMappingResourceGr, papContextGroupVersionGr, papContextgroupLocalVersionGr, papCodeSetExtensionFlagGr, papPrivateCodingSchemeCreatorUIDGr, papCodeSetExtensionCreatorUIDGr, papContextIdentifierGr, papTimezoneOffsetFromUTCGr, papNetworkIDGr, papStationNameGr, papStudyDescriptionGr, papProcedureCodeSequenceGr, papSeriesDescriptionGr, papInstitutionalDepartmentNameGr, papPhysiciansOfRecordGr, papPerformingPhysiciansNameGr, papNameofPhysiciansReadingStudyGr, papOperatorsNameGr, papAdmittingDiagnosesDescriptionGr, papAdmittingDiagnosisCodeSequenceGr, papManufacturersModelNameGr, papReferencedResultsSequenceGr, papReferencedStudySequenceGr, papReferencedStudyComponentSequenceGr, papReferencedSeriesSequenceGr, papReferencedPatientSequenceGr, papReferencedVisitSequenceGr, papReferencedOverlaySequenceGr, papReferencedImageSequenceGr, papReferencedCurveSequenceGr, papReferencedSOPClassUID8Gr, papReferencedSOPInstanceUID8Gr, papSOPClassesSupporedGr, papReferencedFrameNumberGr, papReferencedCalibrationSequenceGr, papTransactionUIDGr, papFailureReasonGr, papFailedSOPSequenceGr, papReferencedSOPSequenceGr, papLossyImageCompression8Gr, papDerivationDescriptionGr, papSourceImageSequenceGr, papStageNameGr, papStageNumberGr, papNumberofStagesGr, papViewNameGr, papViewNumberGr, papNumberofEventTimersGr, papNumberofViewsinStageGr, papEventElapsedTimesGr, papEventTimerNamesGr, papStartTrimGr, papStopTrimGr, papRecommendedDisplayFrameRateGr, papTransducerPositionGr, papTransducerOrientationGr, papAnatomicStructureGr, papAnatomicRegionSequenceGr, papAnatomicRegionModifierSequenceGr, papPrimaryAnatomicStructureSequenceGr, papAnatomicStructureSpaceOrRegionSequenceGr, papPrimaryAnatomicStructureModifierSequenceGr, papTransducerPositionSequenceGr, papTransducerPositionModifierSequenceGr, papTransducerOrientationSequenceGr, papTransducerOrientationModifierSequenceGr, papComments8Gr, papEndGroup8 }; /* Group10 */ enum { papPatientsNameGr = 1, papPatientIDGr, papIssuerofPatientIDGr, papPatientsBirthDateGr, papPatientsBirthTimeGr, papPatientsSexGr, papPatientsInsurancePlanCodeSequenceGr, papOtherPatientIDsGr, papOtherPatientNamesGr, papPatientsBirthNameGr, papPatientsAgeGr, papPatientsSizeGr, papPatientsWeightGr, papPatientsAddressGr, papInsurancePlanIdentificationGr, papPatientsMothersBirthNameGr, papMilitaryRankGr, papBranchofServiceGr, papMedicalRecordLocatorGr, papMedicalAlertsGr, papContrastAllergiesGr, papCountryofResidenceGr, papRegionofResidenceGr, papPatientsTelephoneNumbersGr, papEthnicGroupGr, papOccupationGr, papSmokingStatusGr, papAdditionalPatientHistoryGr, papPregnancyStatusGr, papLastMenstrualDateGr, papPatientsReligiousPreferenceGr, papPatientCommentsGr, papEndGroup10 }; /* Group18 */ enum { papContrastBolusAgentGr = 1, papContrastBolusAgentSequenceGr, papContrastBolusAdministrationRouteSequenceGr, papBodyPartExaminedGr, papScanningSequenceGr, papSequenceVariantGr, papScanOptionsGr, papMRAcquisitionTypeGr, papSequenceNameGr, papAngioFlagGr, papInterventionDrugInformationSequenceGr, papInterventionDrugStopTimeGr, papInterventionDrugDoseGr, papInterventionDrugCodeSequenceGr, papAdditionalDrugSequenceGr, papRadionuclideGr, papRadiopharmaceuticalGr, papEnergyWindowCenterlineGr, papEnergyWindowTotalWidthGr, papInterventionDrugNameGr, papInterventionDrugStartTimeGr, papInterventionalTherapySequenceGr, papTherapyTypeGr, papInterventionalStatusGr, papTherapyDescriptionGr, papCineRateGr, papSliceThicknessGr, papKVPGr, papCountsAccumulatedGr, papAcquisitionTerminationConditionGr, papEffectiveSeriesDurationGr, papAcquisitionStartConditionGr, papAcquisitionStartConditionDataGr, papAcquisitionTerminationConditionDataGr, papRepetitionTimeGr, papEchoTimeGr, papInversionTimeGr, papNumberofAveragesGr, papImagingFrequencyGr, papImagedNucleusGr, papEchoNumbersGr, papMagneticFieldStrengthGr, papSpacingBetweenSlicesGr, papNumberofPhaseEncodingStepsGr, papDataCollectionDiameterGr, papEchoTrainLengthGr, papPercentSamplingGr, papPercentPhaseFieldofViewGr, papPixelBandwidthGr, papDeviceSerialNumberGr, papPlateIDGr, papSecondaryCaptureDeviceIDGr, papHardcopyCreationDeviceIDGr, papDateofSecondaryCaptureGr, papTimeofSecondaryCaptureGr, papSecondaryCaptureDeviceManufacturerGr, papHardcopyDeviceManufacturerGr, papSecondaryCaptureDeviceManufacturersModelNameGr, papSecondaryCaptureDeviceSoftwareVersionsGr, papHardcopyDeviceSoftwareVersionsGr, papHardcopyDeviceManufacturersModelNameGr, papSoftwareVersionsGr, papVideoImageFormatAcquiredGr, papDigitalImageFormatAcquiredGr, papProtocolNameGr, papContrastBolusRouteGr, papContrastBolusVolumeGr, papContrastBolusStartTimeGr, papContrastBolusStopTimeGr, papContrastBolusTotalDoseGr, papSyringecountsGr, papContrastFlowRatesGr, papContrastFlowDurationsGr, papContrastBolusIngredientGr, papContrastBolusIngredientConcentrationGr, papSpatialResolutionGr, papTriggerTimeGr, papTriggerSourceorTypeGr, papNominalIntervalGr, papFrameTimeGr, papFramingTypeGr, papFrameTimeVectorGr, papFrameDelayGr, papImageTriggerDelayGr, papMultiplexgroupTimeOffsetGr, papTriggerTimeOffsetGr, papSynchronizationTriggerGr, papSynchronizationChannelGr, papTriggerSamplePositionGr, papRadiopharmaceuticalRouteGr, papRadiopharmaceuticalVolumeGr, papRadiopharmaceuticalStartTimeGr, papRadiopharmaceuticalStopTimeGr, papRadionuclideTotalDoseGr, papRadionuclideHalfLifeGr, papRadionuclidePositronFractionGr, papRadiopharmaceuticalSpecificactivityGr, papBeatRejectionFlagGr, papLowRRValueGr, papHighRRValueGr, papIntervalsAcquiredGr, papIntervalsRejectedGr, papPVCRejectionGr, papSkipBeatsGr, papHeartRateGr, papCardiacNumberofImagesGr, papTriggerWindowGr, papReconstructionDiameterGr, papDistanceSourcetoDetectorGr, papDistanceSourcetoPatientGr, papEstimatedRadiographicMagnificationFactorGr, papGantryDetectorTiltGr, papGantryDetectorSlewGr, papTableHeightGr, papTableTraverseGr, papTableMotionGr, papTableVerticalIncrementGr, papTableLateralIncrementGr, papTableLongitudinalIncrementGr, papTableAngleGr, papTableTypeGr, papRotationDirectionGr, papAngularPositionGr, papRadialPositionGr, papScanArcGr, papAngularStepGr, papCenterofRotationOffsetGr, papRotationOffsetGr, papFieldofViewShapeGr, papFieldofViewDimensionsGr, papExposureTimeGr, papXrayTubeCurrentGr, papExposureGr, papExposureinmAsGr, papAveragePulseWidthGr, papRadiationSettingGr, papRectificationTypeGr, papRadiationModeGr, papImageAreaDoseProductGr, papFilterTypeGr, papTypeofFiltersGr, papIntensifierSizeGr, papImagerPixelSpacingGr, papGridGr, papGeneratorPowerGr, papCollimatorgridNameGr, papCollimatorTypeGr, papFocalDistanceGr, papXFocusCenterGr, papYFocusCenterGr, papFocalSpotsGr, papAnodeTargetMaterialGr, papBodyPartThicknessGr, papCompressionForceGr, papDateofLastCalibrationGr, papTimeofLastCalibrationGr, papConvolutionKernelGr, papUpperLowerPixelValuesGr, papActualFrameDurationGr, papCountRateGr, papPreferredPlaybackSequencingGr, papReceivingCoilGr, papTransmittingCoilGr, papPlateTypeGr, papPhosphorTypeGr, papScanVelocityGr, papWholeBodyTechniqueGr, papScanLengthGr, papAcquisitionMatrixGr, papPhaseEncodingDirectionGr, papFlipAngleGr, papVariableFlipAngleFlagGr, papSARGr, papdBdtGr, papAcquisitionDeviceProcessingDescriptionGr, papAcquisitionDeviceProcessingCodeGr, papCassetteOrientationGr, papCassetteSizeGr, papExposuresonPlateGr, papRelativeXrayExposureGr, papColumnAngulationGr, papTornoLayerHeightGr, papTornoAngleGr, papTornoTimeGr, papTornoTypeGr, papTornoClassGr, papNumberofTornosynthesisSourceImagesGr, papPositionerMotionGr, papPositionerTypeGr, papPositionerPrimaryAngleGr, papPositionerSecondaryAngleGr, papPositionerPrimaryAngleIncrementGr, papPositionerSecondaryAngleIncrementGr, papDetectorPrimaryAngleGr, papDetectorSecondaryAngleGr, papShutterShapeGr, papShutterLeftVerticalEdgeGr, papShutterRightVerticalEdgeGr, papShutterUpperHorizontalEdgeGr, papShutterLowerHorizontalEdgeGr, papCenterofCircularShutterGr, papRadiusofCircularShutterGr, papVerticesofthePolygonalShutterGr, papShutterPaddingValueGr, papShutterOverlayGroupGr, papCollimatorShapeGr, papCollimatorLeftVerticalEdgeGr, papCollimatorRightVerticalEdgeGr, papCollimatorUpperHorizontalEdgeGr, papCollimatorLowerHorizontalEdgeGr, papCenterofCircularCollimatorGr, papRadiusofCircularCollimatorGr, papVerticesofthePolygonalCollimatorGr, papAcquisitionTimeSynchronizedGr, papTimeSourceGr, papTimeDistributionProtocolGr, papPageNumberVectorGr, papFrameLabelVectorGr, papFramePrimaryAngleVectorGr, papFrameSecondaryAngleVectorGr, papSliceLocationVectorGr, papDisplayWindowLabelVectorGr, papNominalScannedPixelSpacingGr, papDigitizingDeviceTransportDirectionGr, papRotationOfScannedFilmGr, papComments18Gr, papOutputPowerGr, papTransducerDataGr, papFocusDepthGr, papPreprocessingFunctionGr, papPostprocessingFunctionGr, papMechanicalIndexGr, papThermalIndexGr, papCranialThermalIndexGr, papSoftTissueThermalIndexGr, papSoftTissuefocusThermalIndexGr, papSoftTissuesurfaceThermalIndexGr, papDynamicRangeGr, papTotalGainGr, papDepthofScanFieldGr, papPatientPositionGr, papViewPositionGr, papProjectionEponymousNameCodeSequenceGr, papImageTransformationMatrixGr, papImageTranslationVectorGr, papSensitivityGr, papSequenceofUltrasoundRegionsGr, papRegionSpatialFormatGr, papRegionDataTypeGr, papRegionFlagsGr, papRegionLocationMinX0Gr, papRegionLocationMinY0Gr, papRegionLocationMaxX1Gr, papRegionLocationMaxY1Gr, papReferencePixelX0Gr, papReferencePixelY0Gr, papPhysicalUnitsXDirectionGr, papPhysicalUnitsYDirectionGr, papReferencePixelPhysicalValueXGr, papReferencePixelPhysicalValueYGr, papPhysicalDeltaXGr, papPhysicalDeltaYGr, papTransducerFrequencyGr, papTransducerTypeGr, papPulseRepetitionFrequencyGr, papDopplerCorrectionAngleGr, papSterringAngleGr, papDopplerSampleVolumeXPositionGr, papDopplerSampleVolumeYPositionGr, papTMLinePositionX0Gr, papTMLinePositionY0Gr, papTMLinePositionX1Gr, papTMLinePositionY1Gr, papPixelComponentOrganizationGr, papPixelComponentMaskGr, papPixelComponentRangeStartGr, papPixelComponentRangeStopGr, papPixelComponentPhysicalUnitsGr, papPixelComponentDataTypeGr, papNumberofTableBreakPointsGr, papTableofXBreakPointsGr, papTableofYBreakPointsGr, papNumberofTableEntriesGr, papTableofPixelValuesGr, papTableofParameterValuesGr, papDetectorConditionsNominalFlagGr, papDetectorTemperatureGr, papDetectorTypeGr, papDetectorConfigurationGr, papDetectorDescriptionGr, papDetectorModeGr, papDetectorIDGr, papDateofLastDetectorCalibrationGr, papTimeofLastDetectorCalibrationGr, papExposuresonDetectorSinceLastCalibrationGr, papExposuresonDetectorSinceManufacturedGr, papDetectorTimeSinceLastExposureGr, papDetectorActiveTimeGr, papDetectorActivationOffsetFromExposureGr, papDetectorBinningGr, papDetectorElementPhysicalSizeGr, papDetectorElementSpacingGr, papDetectorActiveShapeGr, papDetectorActiveDimensionsGr, papDetectorActiveOriginGr, papFieldofViewOriginGr, papFieldofViewRotationGr, papFieldofViewHorizontalFlipGr, papGridAbsorbingMaterialGr, papGridSpacingMaterialGr, papGridThicknessGr, papGridPitchGr, papGridAspectRatioGr, papGridPeriodGr, papGridFocalDistanceGr, papFilterMaterialGr, papFilterThicknessMinimumGr, papFilterThicknessMaximumGr, papExposureControlModeGr, papExposureControlModeDescriptionGr, papExposureStatusGr, papPhototimerSettingGr, papExposureTimeInMSGr, papXRayTubeCurrentInMAGr, papEndGroup18 }; /* Group20 */ enum { papStudyInstanceUIDGr = 1, papSeriesInstanceUIDGr, papStudyIDGr, papSeriesNumberGr, papAcquisitionNumberGr, papImageNumberGr, papIsotopeNumberGr, papPhaseNumberGr, papIntervalNumberGr, papTimeSlotNumberGr, papAngleNumberGr, papItemNumberGr, papPatientOrientationGr, papOverlayNumberGr, papCurveNumberGr, papLUTNumberGr, papImagePosition20Gr, papImagePositionPatientGr, papImageOrientationGr, papImageOrientationPatientGr, papLocationGr, papFrameofReferenceUIDGr, papLateralityGr, papImageLateralityGr, papImageGeometryTypeGr, papMaskingImageGr, papTemporalPositionIdentifierGr, papNumberofTemporalPositionsGr, papTemporalResolutionGr, papSeriesinStudyGr, papAcquisitionsinSeriesGr, papImagesinAcquisitionGr, papImagesinSeriesGr, papAcquisitioninStudyGr, papImagesinStudyGr, papReferenceGr, papPositionReferenceIndicatorGr, papSliceLocationGr, papOtherStudyNumbersGr, papNumberofPatientRelatedStudiesGr, papNumberofPatientRelatedSeriesGr, papNumberofPatientRelatedImagesGr, papNumberofStudyRelatedSeriesGr, papNumberofStudyRelatedImagesGr, papNumberofSeriesRelatedImagesGr, papSourceImageIDsGr, papModifyingDeviceIDGr, papModifiedImageIDGr, papModifiedImageDateGr, papModifyingDeviceManufacturerGr, papModifiedImageTimeGr, papModifiedImageDescriptionGr, papImageCommentsGr, papOriginalImageIdentificationGr, papOriginalImageIdentificationNomenclatureGr, papEndGroup20 }; /* Group28 */ enum { papSamplesperPixelGr = 1, papPhotometricInterpretationGr, papImageDimensionsGr, papPlanarConfigurationGr, papNumberofFramesGr, papFrameIncrementPointerGr, papRowsGr, papColumnsGr, papPlanesGr, papUltrasoundColorDataPresentGr, papPixelSpacingGr, papZoomFactorGr, papZoomCenterGr, papPixelAspectRatioGr, papImageFormatGr, papManipulatedImageGr, papCorrectedImageGr, papCompressionCodeGr, papBitsAllocatedGr, papBitsStoredGr, papHighBitGr, papPixelRepresentationGr, papSmallestValidPixelValueGr, papLargestValidPixelValueGr, papSmallestImagePixelValueGr, papLargestImagePixelValueGr, papSmallestPixelValueinSeriesGr, papLargestPixelValueinSeriesGr, papSmallestImagePixelValueinPlaneGr, papLargestImagePixelValueinPlaneGr, papPixelPaddingValueGr, papImageLocationGr, papQualityControlImageGr, papBurnedInAnnotationGr, papPixelIntensityRelationshipGr, papPixelIntensityRelationshipSignGr, papWindowCenterGr, papWindowWidthGr, papRescaleInterceptGr, papRescaleSlopeGr, papRescaleTypeGr, papWindowCenterWidthExplanationGr, papGrayScaleGr, papRecommendedViewingModeGr, papGrayLookupTableDescriptorGr, papRedPaletteColorLookupTableDescriptorGr, papGreenPaletteColorLookupTableDescriptorGr, papBluePaletteColorLookupTableDescriptorGr, papPaletteColorLookupTableUIDGr, papGrayLookupTableDataGr, papRedPaletteCLUTDataGr, papGreenPaletteCLUTDataGr, papBluePaletteCLUTDataGr, papSegmentedRedPaletteColorLookupTableDataGr, papSegmentedGreenPaletteColorLookupTableDataGr, papSegmentedBluePaletteColorLookupTableDataGr, papImplantPresentGr, papPartialViewGr, papPartialViewDescriptionGr, papLossyImageCompressionGr, papLossyImageCompressionRatioGr, papModalityLUTSequenceGr, papLUTDescriptorGr, papLUTExplanationGr, papModalityLUTTypeGr, papLUTDataGr, papVOILUTSequenceGr, papSoftcopyVOILUTSequenceGr, papComments28Gr, papBiPlaneAcquisitionSequenceGr, papRepresentativeFrameNumberGr, papFrameNumbersofInterestGr, papFramesofInterestDescriptionGr, papMaskPointersGr, papRWavePointerGr, papMaskSubtractionSequenceGr, papMaskOperationGr, papApplicableFrameRangeGr, papMaskFrameNumbersGr, papContrastFrameAveragingGr, papMaskSubpixelShiftGr, papTIDOffsetGr, papMaskOperationExplanationGr, papEndGroup28 }; /* Group32 */ enum { papStudyStatusIDGr = 1, papStudyPriorityIDGr, papStudyIDIssuerGr, papStudyVerifiedDateGr, papStudyVerifiedTimeGr, papStudyReadDateGr, papStudyReadTimeGr, papScheduledStudyStartDateGr, papScheduledStudyStartTimeGr, papScheduledStudyStopDateGr, papScheduledStudyStopTimeGr, papScheduledStudyLocationGr, papScheduledStudyLocationAETitlesGr, papReasonforStudyGr, papRequestingPhysicianGr, papRequestingServiceGr, papStudyArrivalDateGr, papStudyArrivalTimeGr, papStudyCompletionDateGr, papStudyCompletionTimeGr, papStudyComponentStatusIDGr, papRequestedProcedureDescriptionGr, papRequestedProcedureCodeSequenceGr, papRequestedContrastAgentGr, papStudyCommentsGr, papEndGroup32 }; /* Group38 */ enum { papReferencedPatientAliasSequenceGr = 1, papVisitStatusIDGr, papAdmissionIDGr, papIssuerofAdmissionIDGr, papRouteofAdmissionsGr, papScheduledAdmissionDateGr, papScheduledAdmissionTimeGr, papScheduledDischargeDateGr, papScheduledDischargeTimeGr, papScheduledPatientInstitutionResidenceGr, papAdmittingDateGr, papAdmittingTimeGr, papDischargeDateGr, papDischargeTimeGr, papDischargeDiagnosisDescriptionGr, papDischargeDiagnosisCodeSequenceGr, papSpecialNeedsGr, papCurrentPatientLocationGr, papPatientsInstitutionResidenceGr, papPatientStateGr, papVisitCommentsGr, papEndGroup38 }; /* Group3A */ enum { papWaveformOriginalityGr = 1, papNumberOfWaveformChannelsGr, papNumberOfWaveformSamplesGr, papSamplingFrequencyGr, papMultiplexGroupLabelGr, papChannelDefinitionSequenceGr, papWaveformChannelNumberGr, papChannelLabelGr, papChannelStatusGr, papChannelSourceSequenceGr, papChannelSourceModifiersSequenceGr, papSourceWaveformSequenceGr, papChannelDerivationDescriptionGr, papChannelSensitivityGr, papChannelSensitivityUnitsSequenceGr, papChannelSensitivityCorrectionFactorGr, papChannelBaselineGr, papChannelTimeSkewGr, papChannelSampleSkewGr, papChannelOffsetGr, papWaveformBitsStoredGr, papFilterLowFrequencyGr, papFilterHighFrequencyGr, papNotchFilterFrequencyGr, papNotchFilterBandwidthGr, papEndGroup3A }; /* Group40 */ enum { papScheduledStationAETitleGr = 1, papScheduledProcedureStepStartDateGr, papScheduledProcedureStepStartTimeGr, papScheduledProcedureStepEndDateGr, papScheduledProcedureStepEndTimeGr, papScheduledPerformingPhysiciansNameGr, papScheduledProcedureStepDescriptionGr, papScheduledActionItemCodeSequenceGr, papScheduledProcedureStepIDGr, papStageCodeSequenceGr, papScheduledStationNameGr, papScheduledProcedureStepLocationGr, papPreMedicationGr, papScheduledProcedureStepStatusGr, papScheduledProcedureStepSequenceGr, papReferencedStandaloneSOPInstanceSequenceGr, papPerformedStationAETitleGr, papPerformedStationNameGr, papPerformedLocationGr, papPerformedProcedureStepStartDateGr, papPerformedProcedureStepStartTimeGr, papPerformedProcedureStepEndDateGr, papPerformedProcedureStepEndTimeGr, papPerformedProcedureStepStatusGr, papPerformedProcedureStepIDGr, papPerformedProcedureStepDescriptionGr, papPerformedProcedureStepTypeGr, papPerformedActionItemSequenceGr, papScheduledStepAttributesSequenceGr, papRequestedAttributesSequenceGr, papCommentsOnThePerformedProcedureStepsGr, papQuantitySequenceGr, papQuantityGr, papMeasuringUnitsSequenceGr, papBillingItemSequenceGr, papTotalTimeOfFluoroscopyGr, papTotalNumberOfExposuresGr, papEntranceDoseGr, papExposedAreaGr, papDistanceSourcetoEntranceGr, papDistanceSourcetoSupportGr, papCommentsonRadiationDoseGr, papXRayOutputGr, papHalfValueLayerGr, papOrganDoseGr, papOrganExposedGr, papBillingProcedureStepSequenceGr, papFilmConsumptionSequenceGr, papBillingSuppliesAndDevicesSequenceGr, papReferencedProcedureStepSequenceGr, papPerformedSeriesSequenceGr, papCommentsontheScheduledProcedureStepGr, papSpecimenAccessionNumberGr, papSpecimenSequenceGr, papSpecimenIdentifierGr, papAcquisitionContextSequenceGr, papAcquisitionContextDescriptionGr, papSpecimenTypeCodeSequenceGr, papSlideIdentifierGr, papImageCenterPointCoordinatesSequenceGr, papXOffsetInSlideCoordinateSystemGr, papYOffsetInSlideCoordinateSystemGr, papZOffsetInSlideCoordinateSystemGr, papPixelSpacingSequenceGr, papCoordinateSystemAxisCodeSequenceGr, papMeasurementUnitsCodeSequenceGr, papRequestedProcedureIDGr, papReasonfortheRequestedProcedureGr, papRequestedProcedurePriorityGr, papPatientTransportArrangementsGr, papRequestedProcedureLocationGr, papPlacerOrderNumberProcedureGr, papFillerOrderNumberProcedureGr, papConfidentialityCodeGr, papReportingPriorityGr, papNamesofIntendedRecipientsofResultsGr, papRequestedProcedureCommentsGr, papReasonfortheImagingServiceRequestGr, papIssueDateofImagingServiceRequestGr, papIssueTimeofImagingServiceRequestGr, papPlacerOrderNumberImagingServiceRequestGr, papFillerOrderNumberImagingServiceRequestGr, papOrderEnteredByGr, papOrderEnterersLocationGr, papOrderCallbackPhoneNumberGr, papImagingServiceRequestCommentsGr, papConfidentialityConstraintonPatientDataDescriptionGr, papEntranceDoseInMyGyGr, papRelationshipTypeGr, papVerifyingOrganizationGr, papVerificationDateTimeGr, papObservationDateTimeGr, papValueTypeGr, papConceptNameCodeSequenceGr, papContinuityOfContentGr, papVerifyingObserverSequenceGr, papVerifyingObserverNameGr, papVerifyingObserverIdentificationCodeSequenceGr, papReferencedWaveformChannelsGr, papDateTimeGr, papDateGr, papTimeGr, papPersonNameGr, papUIDGr, papTemporalRangeTypeGr, papReferencedSamplePositionsGr, papReferencesFrameNumbersGr, papReferencedTimeOffsetsGr, papReferencedDatetimeGr, papTextValueGr, papConceptCodeSequenceGr, papAnnotationGroupNumberGr, papModifierCodeSequenceGr, papMeasuredValueSequenceGr, papNumericValueGr, papPredecessorDocumentsSequenceGr, papReferencedRequestSequenceGr, papPerformedProcedureCodeSequenceGr, papCurentRequestedProcedureEvidenceSequenceGr, papPertinentOtherEvidenceSequenceGr, papCompletionFlagGr, papCompletionFlagDescriptionGr, papVerificationFlagGr, papContentTemplateSequenceGr, papIdenticalDocumentsSequenceGr, papContentSequenceGr, papAnnotationSequenceGr, papTemplateIdentifierGr, papTemplateVersionGr, papTemplateLocalVersionGr, papTemplateExtensionFlagGr, paptemplateExtensionOrganizationUIDGr, paptemplateExtensionCreatorUIDGr, papReferencedContentItemIdentifierGr, papEndGroup40 }; /* Group41 */ enum { papOwnerIDGr = 1, papComments41Gr, papPointerSequenceGr, papImagePointerGr, papPixelOffsetGr, papImageIdentifierSequenceGr, papExternalPAPYRUSFileReferenceSequenceGr, papNumberofimagesGr, papReferencedSOPClassUID41Gr, papReferencedSOPInstanceUID41Gr, papReferencedFileNameGr, papReferencedFilePathGr, papReferencedImageSOPClassUIDGr, papReferencedImageSOPInstanceUIDGr, papImageSequenceGr, papEndGroup41 }; /* Group50 */ enum { papCalibrationObjectGr = 1, papDeviceSequenceGr, papDeviceLengthGr, papDeviceDiameterGr, papDeviceDiameterUnitsGr, papDeviceVolumeGr, papIntermarkerDistanceGr, papDeviceDescriptionGr, papEndGroup50 }; /* Group54 */ enum { papEnergyWindowVectorGr = 1, papNumberofEnergyWindowsGr, papEnergyWindowInformationSequenceGr, papEnergyWindowRangeSequenceGr, papEnergyWindowLowerLimitGr, papEnergyWindowUpperLimitGr, papRadiopharmaceuticalInformationSequenceGr, papResidualSyringeCountsGr, papEnergyWindowNameGr, papDetectorVectorGr, papNumberofDetectorsGr, papDetectorInformationSequenceGr, papPhaseVectorGr, papNumberofPhasesGr, papPhaseInformationSequenceGr, papNumberofFramesinPhaseGr, papPhaseDelayGr, papPauseBetweenFramesGr, papRotationVectorGr, papNumberofRotationsGr, papRotationInformationSequenceGr, papNumberofFramesinRotationGr, papRRIntervalVectorGr, papNumberofRRIntervalsGr, papGatedInformationSequenceGr, papDataInformationSequenceGr, papTimeSlotVectorGr, papNumberofTimeSlotsGr, papTimeSlotInformationSequenceGr, papTimeSlotTimeGr, papSliceVectorGr, papNumberofSlicesGr, papAngularViewVectorGr, papTimeSliceVectorGr, papNumberOfTimeSlicesGr, papStartAngleGr, papTypeofDetectorMotionGr, papTriggerVectorGr, papNumberofTriggersinPhaseGr, papViewCodeSequenceGr, papViewModifierCodeSequenceGr, papRadionuclideCodeSequenceGr, papAdministrationRouteCodeSequenceGr, papRadiopharmaceuticalCodeSequenceGr, papCalibrationDataSequenceGr, papEnergyWindowNumberGr, papImageIDGr, papPatientOrientationCodeSequenceGr, papPatientOrientationModifierCodeSequenceGr, papPatientGantryRelationshipCodeSequenceGr, papSeriesTypeGr, papUnitsGr, papCountsSourceGr, papReprojectionMethodGr, papRandomsCorrectionMethodGr, papAttenuationCorrectionMethodGr, papDecayCorrectionGr, papReconstructionMethodGr, papDetectorLinesOfResponseUsedGr, papScatterCorrectionMethodGr, papAxialAcceptanceGr, papAxialMashGr, papTransverseMashGr, papDetectorElementSizeGr, papCoincidenceWindowWidthGr, papSecondaryCountsTypeGr, papFrameReferenceTimeGr, papPrimaryCountsAccumulatedGr, papSecondaryCountsAccumulatedGr, papSliceSensitivityFactorGr, papDecayFactorGr, papDoseCalibrationFactorGr, papScatterFractionFactorGr, papDeadTimeFactorGr, papImageIndexGr, papCountsIncludedGr, papDeadTimeCorrectionFlagGr, papEndGroup54 }; /* Group60 */ enum { papHistogramSequenceGr = 1, papHistogramNumberofBinsGr, papHistogramFirstBinValueGr, papHistogramLastBinValueGr, papHistogramBinWidthGr, papHistogramExplanationGr, papHistogramDataGr, papEndGroup60 }; /* Group70 */ enum { papGraphicAnnotationSequenceGr = 1, papGraphicLayerGr, papBoundingBoxAnnotationUnitsGr, papAnchorPointAnnotationUnitsGr, papGraphicAnnotationUnitsGr, papUnformattedTexValueGr, papTextObjectSequenceGr, papBoundingBoxTopLeftHandCornerGr, papBoundingBoxBottomRightHandCornerGr, papBoundingBoxTextHorizontalJustificationGr, papAnchorPoint70Gr, papAnchorPointVisibilityGr, papGraphicDimensionsGr, papNumberOfGraphicPointsGr, papGraphicDataGr, papGraphicTypeGr, papGraphicFilledGr, papImageHorizontalFlipGr, papImageRotationGr, papDisplayedAreaTopLeftHandCornerGr, papDisplayedAreaBottomRightHandCornerGr, papDisplayedAreaSelectionSequenceGr, papGraphicLayerSequenceGr, papGraphicLayerOrderGr, papGraphicLayerRecommendedDisplayGrayscaleValueGr, papGraphicLayerRecommendedDisplayRGBValueGr, papGraphicLayerDescriptionGr, papPresentationLabelGr, papPresentationDescriptionGr, papPresentationCreationDateGr, papPresentationCreationTimeGr, papPresentationCreatorsNameGr, papPresentationSizeModeGr, papPresentationPixelSpacingGr, papPresentationPixelAspectRationGr, papPresentationPixelMagnificationRatioGr, papEndGroup70 }; /* Group88 */ enum { papStorageMediaFilesetIDGr = 1, papStorageMediaFilesetUIDGr, papIconImageSequenceGr, papTopicTitleGr, papTopicSubjectGr, papTopicAuthorGr, papTopicKeyWordsGr, papEndGroup88 }; /* Group100 */ enum { papSOPInstanceStatusGr = 1, papSOPAuthorizationDateAndTimeGr, papSOPAuthorizationCommentGr, papAuthorizationEquipmentCertificationNumberGr, papEndGroup100 }; /* Group2000 */ enum { papNumberOfCopiesGr = 1, papPrinterConfigurationSequenceGr, papPrintPriorityGr, papMediumTypeGr, papFilmDestinationGr, papFilmSessionLabelGr, papMemoryAllocationGr, papMaximumMemoryAllocationGr, papColorImagePrintingFlagGr, papCollationFlagGr, papAnnotationFlagGr, papImageOverlayFlagGr, papPresentationLUTFlagGr, papImageBoxPresentationLUTFlagGr, papMemoryBitDepthGr, papPrintingBitDepthGr, papMediaInstalledSequenceGr, papOtherMediaInstalledSequenceGr, papSupportedImageDisplayFormatsSequenceGr, papReferencedFilmBoxSequenceGr, papReferencedStoredPrintSequenceGr, papEndGroup2000 }; /* Group2010 */ enum { papImageDisplayFormatGr = 1, papAnnotationDisplayFormatIDGr, papFilmOrientationGr, papFilmSizeIDGr, papMagnificationTypeGr, papSmoothingTypeGr, papDefaultMagnificationTypeGr, papOtherMagnificationTypesAvailableGr, papDefaultSmoothingTypeGr, papOtherSmoothingTypesAvailableGr, papBorderDensityGr, papEmptyImageDensityGr, papMinDensityGr, papMaxDensityGr, papTrimGr, papConfigurationInformationGr, papConfigurationInformationDescriptionGr, papMaximumCollatedFilmsGr, papIlluminationGr, papReflectedAmbientLightGr, papPrinterPixelSpacingGr, papReferencedFilmSessionSequenceGr, papReferencedImageBoxSequence2010Gr, papReferencedBasicAnnotationBoxSequenceGr, papEndGroup2010 }; /* Group2020 */ enum { papImagePosition2020Gr = 1, papPolarityGr, papRequestedImageSizeGr, papRequestedDecimateCropBehaviorGr, papRequestedResolutionIDGr, papRequestedImageSizeFlagGr, papDecimateCropResultGr, papPreformattedGrayscaleImageSequenceGr, papPreformattedColorImageSequenceGr, papReferencedImageOverlayBoxSequenceGr, papReferencedVOILUTBoxSequenceGr, papEndGroup2020 }; /* Group2030 */ enum { papAnnotationPositionGr = 1, papTextStringGr, papEndGroup2030 }; /* Group2040 */ enum { papReferencedOverlayPlaneSequenceGr = 1, papOverlayPixelDataSequenceGr, papReferencedOverlayPlaneGroupsGr, papOverlayMagnificationTypeGr, papOverlayMagnificationGr, papOverlaySmoothingTypeGr, papOverlayOrImageMagnificationGr, papMagnifyToNumberOfColumnsGr, papOverlayForegroundDensityGr, papOverlayBackgroundDensityGr, papOverlayModeGr, papThresholdDensityGr, papReferencedImageBoxSequence2040Gr, papEndGroup2040 }; /* Group2050 */ enum { papPresentationLUTSequenceGr, papPresentationLUTShapeGr, papReferencedPresentationLUTSequenceGr, papEndGroup2050 }; /* Group2100 */ enum { papExecutionStatusGr = 1, papExecutionStatusInfoGr, papCreationDateGr, papCreationTimeGr, papOriginatorGr, papDestinationAEGr, papReferencedPrintJobSequenceGr, papNumberOfFilmsGr, papEndGroup2100 }; /* Group2110 */ enum { papPrinterStatusGr = 1, papPrinterStatusInfoGr, papPrinterNameGr, papPrintQueueIDGr, papEndGroup2110 }; /* Group2120 */ enum { papQueueStatusGr = 1, papPrintJobDescriptionSequenceGr, papreferencedPrintJobSequenceGr, papEndGroup2120 }; /* Group2130 */ enum { papPrintManagementCapabilitiesSequenceGr = 1, papPrintCharacteristicsSequenceGr, papFilmBoxContentSequenceGr, papImageBoxContentSequenceGr, papAnnotationContentSequenceGr, papImageOverlayBoxContentSequenceGr, papPresentationLUTContentSequenceGr, papProposedStudySequenceGr, papOrigianlImageSequenceGr, papEndGroup2130 }; /* Group3002 */ enum { papRTImageLabelGr, papRTImageNameGr, papRTImageDescriptionGr, papReportedValuesOriginGr, papRTImagePlaneGr, papXRayImageReceptortranslationGr, papXRayImageReceptorAngleGr, papRTImageOrientationGr, papImagePlanePixelSpacingGr, papRTImagePositionGr, papRadiationMachineNameGr, papRadiationMachineSADGr, papRadiationMachineSSDGr, papRTImageSIDGr, papSourcetoReferenceObjectDistanceGr, papFractionNumberGr, papExposureSequenceGr, papMetersetExposureGr, papDiaphragmPositionGr, papEndGroup3002 }; /* Group3004 */ enum { papDVHTypeGr, papDoseUnitsGr, papDoseTypeGr, papDoseCommentGr, papNormalizationPointGr, papDoseSummationTypeGr, papGridFrameOffsetVectorGr, papDoseGridScalingGr, papRTDoseROISequenceGr, papDoseValueGr, papDVHNormalizationPointGr, papDVHNormalizationDoseValueGr, papDVHSequenceGr, papDVHDoseScalingGr, papDVHVolumeUnitsGr, papDVHNumberofBinsGr, papDVHDataGr, papDVHReferencedROISequenceGr, papDVHROIContributionTypeGr, papDVHMinimumDoseGr, papDVHMaximumDoseGr, papDVHMeanDoseGr, papEndGroup3004 }; /* Group3006 */ enum { papStructureSetLabelGr, papStructureSetNameGr, papStructureSetDescriptionGr, papStructureSetDateGr, papStructureSetTimeGr, papReferencedFrameofReferenceSequenceGr, papRTReferencedStudySequenceGr, papRTReferencedSeriesSequenceGr, papContourImageSequenceGr, papStructureSetROISequenceGr, papROINumberGr, papReferencedFrameofReferenceUIDGr, papROINameGr, papROIDescriptionGr, papROIDisplayColorGr, papROIVolumeGr, papRTRelatedROISequenceGr, papRTROIRelationshipGr, papROIGenerationAlgorithmGr, papROIGenerationDescriptionGr, papROIContourSequenceGr, papContourSequenceGr, papContourGeometricTypeGr, papContourSlabThicknessGr, papContourOffsetVectorGr, papNumberofContourPointsGr, papContourNumberGr, papAttachedContoursGr, papContourDataGr, papRTROIObservationsSequenceGr, papObservationNumberGr, papReferencedROINumberGr, papROIObservationLabelGr, papRTROIIdentificationCodeSequenceGr, papROIObservationDescriptionGr, papRelatedRTROIObservationsSequenceGr, papRTROIInterpretedTypeGr, papROIInterpreterGr, papROIPhysicalPropertiesSequenceGr, papROIPhysicalPropertyGr, papROIPhysicalPropertyValueGr, papFrameofReferenceRelationshipSequenceGr, papRelatedFrameofReferenceUIDGr, papFrameofReferenceTransformationTypeGr, papFrameofReferenceTransformationMatrixGr, papFrameofReferenceTransformationCommentGr, papEndGroup3006 }; /* Group3008 */ enum { papMeasuredDoseReferenceSequenceGr = 1, papMeasuredDoseDescriptionGr, papMeasuredDoseTypeGr, papMeasuredDoseValueGr, papTreatmentSessionBeamSequenceGr, papCurrentFractionNumberGr, papTreatmentControlPointDateGr, papTreatmentControlPointTimeGr, papTreatmentControlTerminationStatusGr, papTreatmentControlTerminationCodeGr, papTreatmentVerificationStatusGr, papReferencedTreatmentRecordSequenceGr, papSpecifiedPrimaryMetersetGr, papSpecifiedSecondaryMetersetGr, papDeliveredPrimaryMetersetGr, papDeliveredSecondaryMetersetGr, papSpecifiedTreatmentTimeGr, papDeliveredTreatmentTimeGr, papControlPointDeliverySequenceGr, papSpecifiedMetersetGr, papDeliveredMetersetGr, papDoseRateDeliveredGr, papTreatmentSummaryCalculatedDoseReferenceSequenceGr, papCumulativeDoseToDoseReferenceGr, papFirstTreatmentDateGr, papMostRecentTreatmentDateGr, papNumberOfFractionsDeliveredGr, papOverrideSequenceGr, papOverrideParameterPointerGr, papMeasuredDoseReferenceNumberGr, papOverrideReasonGr, papCalculatedDoseReferenceSequenceGr, papCalculatedDoseReferenceNumberGr, papCalculatedDoseReferenceDescriptionGr, papCalculatedDoseReferenceDoseValueGr, papStartMetersetGr, papEndMetersetGr, papReferencedMeasuredDoseReferenceSequenceGr, papReferencedMeasuredDoseReferenceNumberGr, papReferencedCalculatedDoseReferenceSequenceGr, papReferencedCalculatedDoseReferenceNumberGr, papBeamLimitingDeviceLeafPairsSequenceGr, papRecordedWedgeSequenceGr, papRecordedCompensatorSequenceGr, papRecordedBlockSequenceGr, papRecordedSourceSequenceGr, papSourceSerialNumberGr, papTreatmentSessionApplicationSetupSequenceGr, papApplicationSetupCheckGr, papRecordedBrachyAccessoryDeviceSequenceGr, papreferencedBrachyAccessoryDeviceNumberGr, papRecordedChannelSequenceGr, papSpecifiedChannelTotalTimeGr, papDeliveredChannelTotalTimeGr, papSpecifiedNumberOfPulsesGr, papDeliveredNumberOfPulsesGr, papSpecifiedPulseRepetitionIntervalGr, papDeliveredPulseRepetitionIntervalGr, papRecordedSourceApplicatorSequenceGr, papReferencedSourceApplicatorNumberGr, papRecordedChannelShieldSequenceGr, papReferencedCahnnelShieldNumberGr, papBrachyControlPointDeliveredSequenceGr, papSafePositionExitDateGr, papSafePositionExitTimeGr, papSafePositionReturnDateGr, papSafePositionReturnTimeGr, papCurrentTreatmentStatusGr, papTreatmentStatusCommentGr, papFractionGropSummarySequenceGr, papReferencedFractionNumberGr, papFractionGroupTypeGr, papBeamStopperPositionGr, papFractionStatusSummarySequenceGr, papTreatmentDateGr, papTreatmentTimeGr, papEndGroup3008 }; /* Group300A */ enum { papRTPlanLabelGr = 1, papRTPlanNameGr, papRTPlanDescriptionGr, papRTPlanDateGr, papRTPlanTimeGr, papTreatmentProtocolsGr, papTreatmentIntentGr, papTreatmentSitesGr, papRTPlanGeometryGr, papPrescriptionDescriptionGr, papDoseReferenceSequenceGr, papDoseReferenceNumberGr, papDoseReferenceStructureTypeGr, papNominalBeamEnergyUnitGr, papDoseReferenceDescriptionGr, papDoseReferencePointCoordinatesGr, papNominalPriorDoseGr, papDoseReferenceTypeGr, papConstraintWeightGr, papDeliveryWarningDoseGr, papDeliveryMaximumDoseGr, papTargetMinimumDoseGr, papTargetPrescriptionDoseGr, papTargetMaximumDoseGr, papTargetUnderdoseVolumeFractionGr, papOrganatRiskFullvolumeDoseGr, papOrganatRiskLimitDoseGr, papOrganatRiskMaximumDoseGr, papOrganatRiskOverdoseVolumeFractionGr, papToleranceTableSequenceGr, papToleranceTableNumberGr, papToleranceTableLabelGr, papGantryAngleToleranceGr, papBeamLimitingDeviceAngleToleranceGr, papBeamLimitingDeviceToleranceSequenceGr, papBeamLimitingDevicePositionToleranceGr, papPatientSupportAngleToleranceGr, papTableTopEccentricAngleToleranceGr, papTableTopVerticalPositionToleranceGr, papTableTopLongitudinalPositionToleranceGr, papTableTopLateralPositionToleranceGr, papRTPlanRelationshipGr, papFractionGroupSequenceGr, papFractionGroupNumberGr, papNumberofFractionsPlannedGr, papNumberofFractionsPerDayGr, papRepeatFractionCycleLengthGr, papFractionPatternGr, papNumberofBeamsGr, papBeamDoseSpecificationPointGr, papBeamDoseGr, papBeamMetersetGr, papNumberofBrachyApplicationSetupsGr, papBrachyApplicationSetupDoseSpecificationPointGr, papBrachyApplicationSetupDoseGr, papBeamSequenceGr, papTreatmentMachineNameGr, papPrimaryDosimeterUnitGr, papSourceAxisDistanceGr, papBeamLimitingDeviceSequenceGr, papRTBeamLimitingDeviceTypeGr, papSourcetoBeamLimitingDeviceDistanceGr, papNumberofLeafJawPairsGr, papLeafPositionBoundariesGr, papBeamNumberGr, papBeamNameGr, papBeamDescriptionGr, papBeamTypeGr, papRadiationTypeGr, papHighDoseTechniqueTypeGr, papReferenceImageNumberGr, papPlannedVerificationImageSequenceGr, papImagingDeviceSpecificAcquisitionParametersGr, papTreatmentDeliveryTypeGr, papNumberofWedgesGr, papWedgeSequenceGr, papWedgeNumberGr, papWedgeTypeGr, papWedgeIDGr, papWedgeAngleGr, papWedgeFactorGr, papWedgeOrientationGr, papSourcetoWedgeTrayDistanceGr, papNumberofCompensatorsGr, papMaterialIDGr, papTotalCompensatorTrayFactorGr, papCompensatorSequenceGr, papCompensatorNumberGr, papCompensatorIDGr, papSourcetoCompensatorTrayDistanceGr, papCompensatorRowsGr, papCompensatorColumnsGr, papCompensatorPixelSpacingGr, papCompensatorPositionGr, papCompensatorTransmissionDataGr, papCompensatorThicknessDataGr, papNumberofBoliGr, papCompensatorTypeGr, papNumberofBlocksGr, papTotalBlockTrayFactorGr, papBlockSequenceGr, papBlockTrayIDGr, papSourcetoBlockTrayDistanceGr, papBlockTypeGr, papBlockDivergenceGr, papBlockNumberGr, papBlockNameGr, papBlockThicknessGr, papBlockTransmissionGr, papBlockNumberofPointsGr, papBlockDataGr, papApplicatorSequenceGr, papApplicatorIDGr, papApplicatorTypeGr, papApplicatorDescriptionGr, papCumulativeDoseReferenceCoefficientGr, papFinalCumulativeMetersetWeightGr, papNumberofControlPointsGr, papControlPointSequenceGr, papControlPointIndexGr, papNominalBeamEnergyGr, papDoseRateSetGr, papWedgePositionSequenceGr, papWedgePositionGr, papBeamLimitingDevicePositionSequenceGr, papLeafJawPositionsGr, papGantryAngleGr, papGantryRotationDirectionGr, papBeamLimitingDeviceAngleGr, papBeamLimitingDeviceRotationDirectionGr, papPatientSupportAngleGr, papPatientSupportRotationDirectionGr, papTableTopEccentricAxisDistanceGr, papTableTopEccentricAngleGr, papTableTopEccentricRotationDirectionGr, papTableTopVerticalPositionGr, papTableTopLongitudinalPositionGr, papTableTopLateralPositionGr, papIsocenterPositionGr, papSurfaceEntryPointGr, papSourcetoSurfaceDistanceGr, papCumulativeMetersetWeightGr, papPatientSetupSequenceGr, papPatientSetupNumberGr, papPatientAdditionalPositionGr, papFixationDeviceSequenceGr, papFixationDeviceTypeGr, papFixationDeviceLabelGr, papFixationDeviceDescriptionGr, papFixationDevicePositionGr, papShieldingDeviceSequenceGr, papShieldingDeviceTypeGr, papShieldingDeviceLabelGr, papShieldingDeviceDescriptionGr, papShieldingDevicePositionGr, papSetupTechniqueGr, papSetupTechniqueDescriptionGr, papSetupDeviceSequenceGr, papSetupDeviceTypeGr, papSetupDeviceLabelGr, papSetupDeviceDescriptionGr, papSetupDeviceParameterGr, papSetupReferenceDescriptionGr, papTableTopVerticalSetupDisplacementGr, papTableTopLongitudinalSetupDisplacementGr, papTableTopLateralSetupDisplacementGr, papBrachyTreatmentTechniqueGr, papBrachyTreatmentTypeGr, papTreatmentMachineSequenceGr, papSourceSequenceGr, papSourceNumberGr, papSourceTypeGr, papSourceManufacturerGr, papActiveSourceDiameterGr, papActiveSourceLengthGr, papSourceEncapsulationNominalThicknessGr, papSourceEncapsulationNominalTransmissionGr, papSourceIsotopeNameGr, papSourceIsotopeHalfLifeGr, papReferenceAirKermaRateGr, papAirKermaRateReferenceDateGr, papAirKermaRateReferenceTimeGr, papApplicationSetupSequenceGr, papApplicationSetupTypeGr, papApplicationSetupNumberGr, papApplicationSetupNameGr, papApplicationSetupManufacturerGr, papTemplateNumberGr, papTemplateTypeGr, papTemplateNameGr, papTotalReferenceAirKermaGr, papBrachyAccessoryDeviceSequenceGr, papBrachyAccessoryDeviceNumberGr, papBrachyAccessoryDeviceIDGr, papBrachyAccessoryDeviceTypeGr, papBrachyAccessoryDeviceNameGr, papBrachyAccessoryDeviceNominalThicknessGr, papBrachyAccessoryDeviceNominalTransmissionGr, papChannelSequenceGr, papChannelNumberGr, papChannelLengthGr, papChannelTotalTimeGr, papSourceMovementTypeGr, papNumberofPulsesGr, papPulseRepetitionIntervalGr, papSourceApplicatorNumberGr, papSourceApplicatorIDGr, papSourceApplicatorTypeGr, papSourceApplicatorNameGr, papSourceApplicatorLengthGr, papSourceApplicatorManufacturerGr, papSourceApplicatorWallNominalThicknessGr, papSourceApplicatorWallNominalTransmissionGr, papSourceApplicatorStepSizeGr, papTransferTubeNumberGr, papTransferTubeLengthGr, papChannelShieldSequenceGr, papChannelShieldNumberGr, papChannelShieldIDGr, papChannelShieldNameGr, papChannelShieldNominalThicknessGr, papChannelShieldNominalTransmissionGr, papFinalCumulativeTimeWeightGr, papBrachyControlPointSequenceGr, papControlPointRelativePositionGr, papControlPoint3DPositionGr, papCumulativeTimeWeightGr, papEndGroup300A }; /* Group300C */ enum { papReferencedRTPlanSequenceGr, papReferencedBeamSequenceGr, papReferencedBeamNumberGr, papReferencedReferenceImageNumberGr, papStartCumulativeMetersetWeightGr, papEndCumulativeMetersetWeightGr, papReferencedBrachyApplicationSetupSequenceGr, papReferencedBrachyApplicationSetupNumberGr, papReferencedSourceNumberGr, papReferencedFractionGroupSequenceGr, papReferencedFractionGroupNumberGr, papReferencedVerificationImageSequenceGr, papReferencedReferenceImageSequenceGr, papReferencedDoseReferenceSequenceGr, papReferencedDoseReferenceNumberGr, papBrachyReferencedDoseReferenceSequenceGr, papReferencedStructureSetSequenceGr, papReferencedPatientSetupNumberGr, papReferencedDoseSequenceGr, papReferencedToleranceTableNumberGr, papReferencedBolusSequenceGr, papReferencedWedgeNumberGr, papReferencedCompensatorNumberGr, papReferencedBlockNumberGr, papReferencedControlPointIndexGr, papEndGroup300C }; /* Group300E */ enum { papApprovalStatusGr, papReviewDateGr, papReviewTimeGr, papReviewerNameGr, papEndGroup300E }; /* Group4000 */ enum { papArbitraryGr = 1, papCommentsGr, papEndGroup4000 }; /* Group4008 */ enum { papResultsIDGr = 1, papResultsIDIssuerGr, papReferencedInterpretationSequenceGr, papInterpretationRecordedDateGr, papInterpretationRecordedTimeGr, papInterpretationRecorderGr, papReferencetoRecordedSoundGr, papInterpretationTranscriptionDateGr, papInterpretationTranscriptionTimeGr, papInterpretationTranscriberGr, papInterpretationTextGr, papInterpretationAuthorGr, papInterpretationApproverSequenceGr, papInterpretationApprovalDateGr, papInterpretationApprovalTimeGr, papPhysicianApprovingInterpretationGr, papInterpretationDiagnosisDescriptionGr, papDiagnosisCodeSequenceGr, papResultsDistributionListSequenceGr, papDistributionNameGr, papDistributionAddressGr, papInterpretationIDGr, papInterpretationIDIssuerGr, papInterpretationTypeIDGr, papInterpretationStatusIDGr, papImpressionsGr, papResultsCommentsGr, papEndGroup4008 }; /* Group5000 */ enum { papCurveDimensionsGr = 1, papNumberofPointsGr, papTypeofDataGr, papCurveDescriptionGr, papAxisUnitsGr, papAxisLabelsGr, papDataValueRepresentationGr, papMinimumCoordinateValueGr, papMaximumCoordinateValueGr, papCurveRangeGr, papCurveDataDescriptorGr, papCoordinateStartValueGr, papCoordinateStepValueGr, papCurveActivationLayerGr, papAudioTypeGr, papAudioSampleFormatGr, papNumberofChannelsGr, papNumberofSamplesGr, papSampleRateGr, papTotalTimeGr, papAudioSampleDataGr, papAudioCommentsGr, papCurveLabelGr, papReferencedOverlaySequence5000Gr, papReferencedOverlayGroupGr, papCurveDataGr, papEndGroup5000 }; /* Group5400 */ enum { papWaveformSequenceGr = 1, papChannelMinimumValueGr, papChannelMaximumValueGr, papWaveformBitsAllocatedGr, papWaveformSampleInterpretationGr, papWaveformPaddingValueGr, papWaveformDataGr, papEndGroup5400 }; /* Group6000 */ enum { papOverlayRows6000Gr = 1, papOverlayColumns6000Gr, papOverlayPlanesGr, papNumberofFramesinOverlayGr, papOverlayDescriptionGr, papOverlayTypeGr, papOverlaySubtypeGr, papOriginGr, papImageFrameOriginGr, papOverlayPlaneOriginGr, papCompressionCode6000Gr, papOverlayBitsAllocatedGr, papBitPositionGr, papOverlayFormatGr, papOverlayLocationGr, papOverlayActivationLayerGr, papOverlayDescriptorGrayGr, papOverlayDescriptorRedGr, papOverlayDescriptorGreenGr, papOverlayDescriptorBlueGr, papOverlaysGrayGr, papOverlaysRedGr, papOverlaysGreenGr, papOverlaysBlueGr, papROIAreaGr, papROIMeanGr, papROIStandardDeviationGr, papOverlayLabelGr, papOverlayDataGr, papComments6000Gr, papEndGroup6000 }; /* UINOVERLAY Group 6XXX (odd) */ enum { /* papGroupLength */ /* papOwnerId */ papOverlayIdGr = 2, papLinkedOverlaysGr, papOverlayRowsGr, papOverlayColumnsGr, papUINOverlayTypeGr, papOverlayOriginGr, papEditableGr, papOverlayFontGr, papOverlayStyleGr, papOverlayFontSizeGr, papOverlayColorGr, papShadowSizeGr, papFillPatternGr, papOverlayPenSizeGr, papLabelGr, papPostItTextGr, papAnchorPointGr, papRoiTypeGr, papAttachedAnnotationGr, papContourPointsGr, papInfoIntGr, papInfoFloatGr, papMaskDataGr, papUINOverlaySequenceGr, papEndUINOverlay }; /* Group7FE0 */ enum { papPixelDataGr = 1, papEndGroup7FE0 }; #endif Papyrus3/Papyrus3.plg0000755000175000017500000003670607535143454012007 0ustar 
    Build Log
    

    
--------------------Configuration: Jpglless - Win32 Debug--------------------

    

    Command Lines
    
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B0.tmp" with contents
[
/nologo /Zp1 /MLd /W3 /Gm /Zi /Od /I "..\..\..\Papyrus3\\" /I ".." /D "_WINDOWS" /D "STRICT" /D "_DEBUG" /D "WIN32" /FR".\Debug/" /Fp".\Debug/Jlless.pch" /YX /Fo".\Debug/" /Fd".\PAPYRUS3.PDB" /FD /c 
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLless\decompoptimise.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLless\huffcoptimisebug.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLless\huffdoptimise.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLless\JPEGUTIL.C"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLless\MCU.C"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLless\pmreadoptimise.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLless\pnmtoljpoptimisebug.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLless\PREDICT.C"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLless\READ.C"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLless\WRITE.C"
]
Creating command line "cl.exe @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B0.tmp" 
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B1.tmp" with contents
[
/nologo /out:".\Debug\Jlless.lib" 
.\Debug\decompoptimise.obj
.\Debug\huffcoptimisebug.obj
.\Debug\huffdoptimise.obj
.\Debug\JPEGUTIL.OBJ
.\Debug\MCU.OBJ
.\Debug\pmreadoptimise.obj
.\Debug\pnmtoljpoptimisebug.obj
.\Debug\PREDICT.OBJ
.\Debug\READ.OBJ
.\Debug\WRITE.OBJ
]
Creating command line "link.exe -lib @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B1.tmp"

    Output Window
    
Compiling...
decompoptimise.c
huffcoptimisebug.c
huffdoptimise.c
C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLless\huffdoptimise.c(888) : warning C4554: '>>' : check operator precedence for possible error; use parentheses to clarify precedence
JPEGUTIL.C
MCU.C
pmreadoptimise.c
pnmtoljpoptimisebug.c
PREDICT.C
READ.C
WRITE.C
Creating library...

    
--------------------Configuration: Jpglossy - Win32 Debug--------------------

    

    Command Lines
    
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B2.tmp" with contents
[
/nologo /Zp1 /MLd /W3 /Gm /Zi /Od /I "..\.." /I ".." /D "_DEBUG" /D "STRICT" /D "WIN32" /D "_WINDOWS" /FR".\Debug/" /Fp".\Debug/Jlossy.pch" /YX /Fo".\Debug/" /Fd".\PAPYRUS3.PDB" /FD /c 
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcapimin.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcapistd.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jccoefct.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jccolor.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcdctmgr.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jchuff.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcinit.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcmainct.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcmarker.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcmaster.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcomapi.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcparam.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcphuff.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcprepct.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jcsample.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jctrans.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdapimin.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdapistd.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdatadst.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdatasrc.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdcoefct.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdcolor.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jddctmgr.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdhuff.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdinput.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdmainct.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdmarker.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdmaster.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdmerge.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdphuff.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdpostct.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdsample.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jdtrans.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jerror.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jfdctflt.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jfdctfst.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jfdctint.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jidctflt.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jidctfst.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jidctint.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jidctred.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jmemmgr.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jmemnobs.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jquant1.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jquant2.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\jutils.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdbmp.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdcolmap.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdgif.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdppm.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdrle.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdswitch.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\rdtarga.c"
"C:\NewOsiris\NewCode\Papyrus3\JpegDir\JpgLossy\wrrle.c"
]
Creating command line "cl.exe @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B2.tmp" 
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B3.tmp" with contents
[
/nologo /out:".\Debug\Jlossy.lib" 
.\Debug\jcapimin.obj
.\Debug\jcapistd.obj
.\Debug\jccoefct.obj
.\Debug\jccolor.obj
.\Debug\jcdctmgr.obj
.\Debug\jchuff.obj
.\Debug\jcinit.obj
.\Debug\jcmainct.obj
.\Debug\jcmarker.obj
.\Debug\jcmaster.obj
.\Debug\jcomapi.obj
.\Debug\jcparam.obj
.\Debug\jcphuff.obj
.\Debug\jcprepct.obj
.\Debug\jcsample.obj
.\Debug\jctrans.obj
.\Debug\jdapimin.obj
.\Debug\jdapistd.obj
.\Debug\jdatadst.obj
.\Debug\jdatasrc.obj
.\Debug\jdcoefct.obj
.\Debug\jdcolor.obj
.\Debug\jddctmgr.obj
.\Debug\jdhuff.obj
.\Debug\jdinput.obj
.\Debug\jdmainct.obj
.\Debug\jdmarker.obj
.\Debug\jdmaster.obj
.\Debug\jdmerge.obj
.\Debug\jdphuff.obj
.\Debug\jdpostct.obj
.\Debug\jdsample.obj
.\Debug\jdtrans.obj
.\Debug\jerror.obj
.\Debug\jfdctflt.obj
.\Debug\jfdctfst.obj
.\Debug\jfdctint.obj
.\Debug\jidctflt.obj
.\Debug\jidctfst.obj
.\Debug\jidctint.obj
.\Debug\jidctred.obj
.\Debug\jmemmgr.obj
.\Debug\jmemnobs.obj
.\Debug\jquant1.obj
.\Debug\jquant2.obj
.\Debug\jutils.obj
.\Debug\rdbmp.obj
.\Debug\rdcolmap.obj
.\Debug\rdgif.obj
.\Debug\rdppm.obj
.\Debug\rdrle.obj
.\Debug\rdswitch.obj
.\Debug\rdtarga.obj
.\Debug\wrrle.obj
]
Creating command line "link.exe -lib @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B3.tmp"

    Output Window
    
Compiling...
jcapimin.c
jcapistd.c
jccoefct.c
jccolor.c
jcdctmgr.c
jchuff.c
jcinit.c
jcmainct.c
jcmarker.c
jcmaster.c
jcomapi.c
jcparam.c
jcphuff.c
jcprepct.c
jcsample.c
jctrans.c
jdapimin.c
jdapistd.c
jdatadst.c
jdatasrc.c
jdcoefct.c
jdcolor.c
jddctmgr.c
jdhuff.c
jdinput.c
jdmainct.c
jdmarker.c
jdmaster.c
jdmerge.c
jdphuff.c
jdpostct.c
jdsample.c
jdtrans.c
jerror.c
jfdctflt.c
jfdctfst.c
jfdctint.c
jidctflt.c
jidctfst.c
jidctint.c
jidctred.c
jmemmgr.c
jmemnobs.c
jquant1.c
jquant2.c
jutils.c
rdbmp.c
rdcolmap.c
rdgif.c
rdppm.c
rdrle.c
rdswitch.c
rdtarga.c
wrrle.c
Creating library...

    
--------------------Configuration: dicomdir - Win32 Debug--------------------

    

    Command Lines
    
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B6.tmp" with contents
[
/nologo /MLd /W3 /Gm /GX /ZI /Od /I ".." /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /Fp"dicomdir___Win32_Debug/dicomdir.pch" /YX /Fo"dicomdir___Win32_Debug/" /Fd"dicomdir___Win32_Debug/" /FD /GZ  /c 
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirDataSetRead.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirDataSetWrite.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirFiles.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirInit.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\DicomDirInitRecords.c"
"C:\NewOsiris\NewCode\Papyrus3\DicomDir\OGlobalDicomFunc.cpp"
]
Creating command line "cl.exe @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B6.tmp" 
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B7.tmp" with contents
[
/nologo /out:"dicomdir___Win32_Debug\dicomdir.lib" 
.\dicomdir___Win32_Debug\DicomDirDataSetRead.obj
.\dicomdir___Win32_Debug\DicomDirDataSetWrite.obj
.\dicomdir___Win32_Debug\DicomDirFiles.obj
.\dicomdir___Win32_Debug\DicomDirInit.obj
.\dicomdir___Win32_Debug\DicomDirInitRecords.obj
.\dicomdir___Win32_Debug\OGlobalDicomFunc.obj
]
Creating command line "link.exe -lib @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B7.tmp"

    Output Window
    
Compiling...
DicomDirDataSetRead.c
DicomDirDataSetWrite.c
DicomDirFiles.c
DicomDirInit.c
DicomDirInitRecords.c
OGlobalDicomFunc.cpp
Creating library...

    
--------------------Configuration: Papyrus3 - Win32 Debug--------------------

    

    Command Lines
    
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B8.tmp" with contents
[
/nologo /Zp1 /MLd /W3 /Gm /GX /Zi /Od /I "DicomDir\\" /I "JpegDir\Jpglless\\" /I "JpegDir\Jpglossy\\" /I "..\Papyrus2\\" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "PAPY3_VAR" /D "_MBCS" /D "WIN32" /FR".\Debug/" /Fp".\Debug/Papyrus3.pch" /YX /Fo".\Debug/" /Fd".\Debug/" /FD /c 
"C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyDataSetRead3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyDataSetWrite3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyEallocPC3.cpp"
"C:\NewOsiris\NewCode\Papyrus3\PapyError3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyFiles3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyFileSystemPC3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyGetGlobalVar3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyInit3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyInitGroups3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyInitModules3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyList3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyRead3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyUtils3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyVars3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyWild3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyWildexit3.c"
"C:\NewOsiris\NewCode\Papyrus3\PapyWrite3.c"
]
Creating command line "cl.exe @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B8.tmp" 
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B9.tmp" with contents
[
/nologo /out:".\Debug\Papyrus3.lib" 
.\Debug\PapyConvertFile3.obj
.\Debug\PapyDataSetRead3.obj
.\Debug\PapyDataSetWrite3.obj
.\Debug\PapyEallocPC3.obj
.\Debug\PapyError3.obj
.\Debug\PapyFiles3.obj
.\Debug\PapyFileSystemPC3.obj
.\Debug\PapyGetGlobalVar3.obj
.\Debug\PapyInit3.obj
.\Debug\PapyInitGroups3.obj
.\Debug\PapyInitModules3.obj
.\Debug\PapyList3.obj
.\Debug\PapyRead3.obj
.\Debug\PapyUtils3.obj
.\Debug\PapyVars3.obj
.\Debug\PapyWild3.obj
.\Debug\PapyWildexit3.obj
.\Debug\PapyWrite3.obj
.\JpegDir\JpgLless\Debug\Jlless.lib
.\JpegDir\JpgLossy\Debug\Jlossy.lib
.\dicomdir\dicomdir___Win32_Debug\dicomdir.lib
]
Creating command line "link.exe -lib @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP3B9.tmp"

    Output Window
    
Compiling...
PapyConvertFile3.c
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(920) : warning C4101: 'dicomPath' : unreferenced local variable
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(1295) : warning C4018: '<' : signed/unsigned mismatch
PapyDataSetRead3.c
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(191) : warning C4715: 'GetPapyFileType' : not all control paths return a value
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(561) : warning C4761: integral size mismatch in argument; conversion supplied
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(581) : warning C4761: integral size mismatch in argument; conversion supplied
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(645) : warning C4715: 'Papyrus2Papyrus' : not all control paths return a value
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(742) : warning C4761: integral size mismatch in argument; conversion supplied
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(758) : warning C4715: 'Papyrus2Dicom' : not all control paths return a value
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(903) : warning C4715: 'ReadDicomFile' : not all control paths return a value
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(967) : warning C4715: 'Dicom2Papyrus' : not all control paths return a value
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(1011) : warning C4761: integral size mismatch in argument; conversion supplied
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(1185) : warning C4761: integral size mismatch in argument; conversion supplied
C:\NewOsiris\NewCode\Papyrus3\PapyConvertFile3.c(1460) : warning C4715: 'Papyrus2Jpeg' : not all control paths return a value
PapyDataSetWrite3.c
PapyEallocPC3.cpp
PapyError3.c
PapyFiles3.c
PapyFileSystemPC3.c
C:\Program Files\Microsoft Visual Studio\VC98\INCLUDE\winsock.h(125) : warning C4005: '_IO' : macro redefinition
        JpegDir\Jpglless\io.h(53) : see previous definition of '_IO'
C:\NewOsiris\NewCode\Papyrus3\PapyFileSystemPC3.c(66) : warning C4013: '_open' undefined; assuming extern returning int
C:\NewOsiris\NewCode\Papyrus3\PapyFileSystemPC3.c(68) : warning C4013: '_close' undefined; assuming extern returning int
C:\NewOsiris\NewCode\Papyrus3\PapyFileSystemPC3.c(108) : warning C4013: '_lseek' undefined; assuming extern returning int
C:\NewOsiris\NewCode\Papyrus3\PapyFileSystemPC3.c(164) : warning C4013: '_read' undefined; assuming extern returning int
C:\NewOsiris\NewCode\Papyrus3\PapyFileSystemPC3.c(187) : warning C4013: '_write' undefined; assuming extern returning int
C:\NewOsiris\NewCode\Papyrus3\PapyFileSystemPC3.c(210) : warning C4013: '_tell' undefined; assuming extern returning int
PapyGetGlobalVar3.c
C:\NewOsiris\NewCode\Papyrus3\PapyFileSystemPC3.c(312) : warning C4715: 'Papy3DGetNbFiles' : not all control paths return a value
PapyInit3.c
PapyInitGroups3.c
C:\NewOsiris\NewCode\Papyrus3\PapyInit3.c(258) : warning C4715: 'SetModality' : not all control paths return a value
PapyInitModules3.c
PapyList3.c
PapyRead3.c
PapyUtils3.c
PapyVars3.c
C:\NewOsiris\NewCode\Papyrus3\PapyUtils3.c(136) : warning C4761: integral size mismatch in argument; conversion supplied
C:\NewOsiris\NewCode\Papyrus3\PapyUtils3.c(136) : warning C4761: integral size mismatch in argument; conversion supplied
PapyWild3.c
PapyWildexit3.c
PapyWrite3.c
C:\NewOsiris\NewCode\Papyrus3\PapyWrite3.c(409) : warning C4047: 'initializing' : 'int ' differs in levels of indirection from 'void *'
C:\NewOsiris\NewCode\Papyrus3\PapyWrite3.c(499) : warning C4700: local variable 'theVRefNum' used without having been initialized
C:\NewOsiris\NewCode\Papyrus3\PapyWrite3.c(731) : warning C4761: integral size mismatch in argument; conversion supplied
C:\NewOsiris\NewCode\Papyrus3\PapyWrite3.c(864) : warning C4761: integral size mismatch in argument; conversion supplied
C:\NewOsiris\NewCode\Papyrus3\PapyWrite3.c(1045) : warning C4761: integral size mismatch in argument; conversion supplied
C:\NewOsiris\NewCode\Papyrus3\PapyWrite3.c(1766) : warning C4761: integral size mismatch in argument; conversion supplied
Creating library...




    Results
    
Papyrus3.lib - 0 error(s), 31 warning(s)
    Papyrus3/PapyInitGroups3.c0000755000175000017500000154210110044203320012703 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyInitGroups3.c */ /* Function : contains the groups initialisation functions */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifdef Mac #pragma segment papy3InitGroup #endif /* ------------------------- includes ---------------------------------------*/ #include #ifndef Papyrus3H #include "Papyrus3.h" #endif /********************************************************************************/ /* */ /* init_group2 : initializes the elements of the group 2 */ /* */ /********************************************************************************/ void init_group2 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0002; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFileMetaInformationVersionGr]; theWrkP->group = 0x0002; theWrkP->element = 0x0001; theWrkP->length = 0L; theWrkP->vr = OB; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMediaStorageSOPClassUIDGr]; theWrkP->group = 0x0002; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMediaStorageSOPInstanceUIDGr]; theWrkP->group = 0x0002; theWrkP->element = 0x0003; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransferSyntaxUIDGr]; theWrkP->group = 0x0002; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImplementationClassUIDGr]; theWrkP->group = 0x0002; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImplementationVersionNameGr]; theWrkP->group = 0x0002; theWrkP->element = 0x0013; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceApplicationEntityTitleGr]; theWrkP->group = 0x0002; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = AE; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateInformationCreatorUIDGr]; theWrkP->group = 0x0002; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateInformationGr]; theWrkP->group = 0x0002; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = OB; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group2 */ /********************************************************************************/ /* */ /* init_group4 : initializes the elements of the group 4 */ /* */ /********************************************************************************/ void init_group4 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0004; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilesetIDGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1130; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFileIDofFilesetDescriptorFileGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1141; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-8"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFormatofFilesetDescriptorFileGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1142; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofTheFirstDirectoryRecordGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1200; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofTheLastDirectoryRecordGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1202; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilesetConsistencyFlagGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1212; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordSequenceGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1220; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofNextDirectoryRecordGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordInuseGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1410; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofReferencedLowerLevelDirectoryEntityGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1420; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordTypeGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1430; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateRecordUIDGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1432; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileIDGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-8"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRDRDirectoryRecordOffsetGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1504; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUIDinFileGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUIDinFileGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTransferSyntaxUIDinFileGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1512; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberOfReferencesGr]; theWrkP->group = 0x0004; theWrkP->element = 0x1600; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group4 */ /********************************************************************************/ /* */ /* init_group8 : initializes the elements of the group 8 */ /* */ /********************************************************************************/ void init_group8 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0008; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLengthtoEndGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0001; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSetGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTypeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecognitionCodeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = AE; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstanceCreationDateGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstanceCreationTimeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0013; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstanceCreatorUIDGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSOPClassUIDGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSOPInstanceUIDGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0018; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyDateGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesDateGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionDateGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageDateGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0023; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDateGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0024; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveDateGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0025; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionDatetimeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x002A; theWrkP->length = 0L; theWrkP->vr = DT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyTimeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesTimeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0031; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionTimeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTimeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0033; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayTimeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0034; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveTimeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0035; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDataSetTypeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDataSetSubtypeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0041; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNuclearMedicineSeriesTypeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0042; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAccessionNumberGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papQueryRetrieveLevelGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0052; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRetrieveAETitleGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0054; theWrkP->length = 0L; theWrkP->vr = AE; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstanceAvailabilityGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0056; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFailedSOPInstanceUIDListGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0058; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModalityGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModalitiesInStudyGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0061; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConversionTypeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0064; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationIndentTypeGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0068; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papManufacturerGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstitutionNameGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstitutionAddressGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0081; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstitutionCodeSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0082; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferringPhysiciansNameGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0090; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferringPhysiciansAddressGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0092; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferringPhysiciansTelephoneNumbersGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0094; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCodeValueGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCodingSchemeDesignatorGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCodingSchemeVersionGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCodeMeaningGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0104; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMappingResourceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0105; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContextGroupVersionGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0106; theWrkP->length = 0L; theWrkP->vr = DT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContextgroupLocalVersionGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0107; theWrkP->length = 0L; theWrkP->vr = DT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCodeSetExtensionFlagGr]; theWrkP->group = 0x0008; theWrkP->element = 0x010B; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrivateCodingSchemeCreatorUIDGr]; theWrkP->group = 0x0008; theWrkP->element = 0x010C; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCodeSetExtensionCreatorUIDGr]; theWrkP->group = 0x0008; theWrkP->element = 0x010D; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContextIdentifierGr]; theWrkP->group = 0x0008; theWrkP->element = 0x010F; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimezoneOffsetFromUTCGr]; theWrkP->group = 0x0008; theWrkP->element = 0x0201; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNetworkIDGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = RET; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStationNameGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyDescriptionGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papProcedureCodeSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1032; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesDescriptionGr]; theWrkP->group = 0x0008; theWrkP->element = 0x103E; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstitutionalDepartmentNameGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhysiciansOfRecordGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1048; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformingPhysiciansNameGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNameofPhysiciansReadingStudyGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1060; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOperatorsNameGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1070; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdmittingDiagnosesDescriptionGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1080; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdmittingDiagnosisCodeSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1084; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papManufacturersModelNameGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1090; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedResultsSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedStudySequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedStudyComponentSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1111; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSeriesSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1115; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedPatientSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1120; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedVisitSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1125; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedOverlaySequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1130; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1140; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedCurveSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1145; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUID8Gr]; theWrkP->group = 0x0008; theWrkP->element = 0x1150; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUID8Gr]; theWrkP->group = 0x0008; theWrkP->element = 0x1155; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSOPClassesSupporedGr]; theWrkP->group = 0x0008; theWrkP->element = 0x115A; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFrameNumberGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1160; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedCalibrationSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1170; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransactionUIDGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1195; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFailureReasonGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1197; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFailedSOPSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1198; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x1199; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLossyImageCompression8Gr]; theWrkP->group = 0x0008; theWrkP->element = 0x2110; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDerivationDescriptionGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2111; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceImageSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2112; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStageNameGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2120; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStageNumberGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2122; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofStagesGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2124; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewNameGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2127; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewNumberGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2128; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofEventTimersGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2129; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofViewsinStageGr]; theWrkP->group = 0x0008; theWrkP->element = 0x212A; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEventElapsedTimesGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2130; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEventTimerNamesGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2132; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStartTrimGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2142; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStopTrimGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2143; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecommendedDisplayFrameRateGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2144; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerPositionGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2200; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerOrientationGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2204; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnatomicStructureGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2208; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnatomicRegionSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2218; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnatomicRegionModifierSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2220; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrimaryAnatomicStructureSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2228; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnatomicStructureSpaceOrRegionSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2229; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrimaryAnatomicStructureModifierSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2230; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerPositionSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2240; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerPositionModifierSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2242; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerOrientationSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2244; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerOrientationModifierSequenceGr]; theWrkP->group = 0x0008; theWrkP->element = 0x2246; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papComments8Gr]; theWrkP->group = 0x0008; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group8 */ /********************************************************************************/ /* */ /* init_group10 : initializes the elements of the group 10 */ /* */ /********************************************************************************/ void init_group10 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0010; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsNameGr]; theWrkP->group = 0x0010; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientIDGr]; theWrkP->group = 0x0010; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIssuerofPatientIDGr]; theWrkP->group = 0x0010; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsBirthDateGr]; theWrkP->group = 0x0010; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsBirthTimeGr]; theWrkP->group = 0x0010; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsSexGr]; theWrkP->group = 0x0010; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsInsurancePlanCodeSequenceGr]; theWrkP->group = 0x0010; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOtherPatientIDsGr]; theWrkP->group = 0x0010; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOtherPatientNamesGr]; theWrkP->group = 0x0010; theWrkP->element = 0x1001; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsBirthNameGr]; theWrkP->group = 0x0010; theWrkP->element = 0x1005; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsAgeGr]; theWrkP->group = 0x0010; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = AS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsSizeGr]; theWrkP->group = 0x0010; theWrkP->element = 0x1020; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsWeightGr]; theWrkP->group = 0x0010; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsAddressGr]; theWrkP->group = 0x0010; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInsurancePlanIdentificationGr]; theWrkP->group = 0x0010; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsMothersBirthNameGr]; theWrkP->group = 0x0010; theWrkP->element = 0x1060; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMilitaryRankGr]; theWrkP->group = 0x0010; theWrkP->element = 0x1080; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBranchofServiceGr]; theWrkP->group = 0x0010; theWrkP->element = 0x1081; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMedicalRecordLocatorGr]; theWrkP->group = 0x0010; theWrkP->element = 0x1090; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMedicalAlertsGr]; theWrkP->group = 0x0010; theWrkP->element = 0x2000; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastAllergiesGr]; theWrkP->group = 0x0010; theWrkP->element = 0x2110; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCountryofResidenceGr]; theWrkP->group = 0x0010; theWrkP->element = 0x2150; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRegionofResidenceGr]; theWrkP->group = 0x0010; theWrkP->element = 0x2152; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsTelephoneNumbersGr]; theWrkP->group = 0x0010; theWrkP->element = 0x2154; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEthnicGroupGr]; theWrkP->group = 0x0010; theWrkP->element = 0x2160; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOccupationGr]; theWrkP->group = 0x0010; theWrkP->element = 0x2180; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSmokingStatusGr]; theWrkP->group = 0x0010; theWrkP->element = 0x21A0; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdditionalPatientHistoryGr]; theWrkP->group = 0x0010; theWrkP->element = 0x21B0; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPregnancyStatusGr]; theWrkP->group = 0x0010; theWrkP->element = 0x21C0; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLastMenstrualDateGr]; theWrkP->group = 0x0010; theWrkP->element = 0x21D0; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsReligiousPreferenceGr]; theWrkP->group = 0x0010; theWrkP->element = 0x21F0; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientCommentsGr]; theWrkP->group = 0x0010; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group10 */ /********************************************************************************/ /* */ /* init_group18 : initializes the elements of the group 18 */ /* */ /********************************************************************************/ void init_group18 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0018; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusAgentGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusAgentSequenceGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusAdministrationRouteSequenceGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBodyPartExaminedGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0015; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScanningSequenceGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSequenceVariantGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScanOptionsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRAcquisitionTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0023; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSequenceNameGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0024; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAngioFlagGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0025; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterventionDrugInformationSequenceGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0026; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterventionDrugStopTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0027; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterventionDrugDoseGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0028; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterventionDrugCodeSequenceGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0029; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdditionalDrugSequenceGr]; theWrkP->group = 0x0018; theWrkP->element = 0x002A; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadionuclideGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiopharmaceuticalGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0031; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowCenterlineGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowTotalWidthGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0033; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterventionDrugNameGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0034; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterventionDrugStartTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0035; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterventionalTherapySequenceGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0036; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTherapyTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0037; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterventionalStatusGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0038; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTherapyDescriptionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0039; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCineRateGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSliceThicknessGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papKVPGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCountsAccumulatedGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionTerminationConditionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0071; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEffectiveSeriesDurationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0072; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionStartConditionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0073; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionStartConditionDataGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0074; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionTerminationConditionDataGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0075; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRepetitionTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEchoTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0081; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInversionTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0082; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofAveragesGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0083; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagingFrequencyGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0084; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagedNucleusGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0085; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEchoNumbersGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0086; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMagneticFieldStrengthGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0087; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpacingBetweenSlicesGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0088; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofPhaseEncodingStepsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0089; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDataCollectionDiameterGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0090; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEchoTrainLengthGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0091; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPercentSamplingGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0093; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPercentPhaseFieldofViewGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0094; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelBandwidthGr]; theWrkP->group = 0x0018; theWrkP->element = 0x0095; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeviceSerialNumberGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPlateIDGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1004; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSecondaryCaptureDeviceIDGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHardcopyCreationDeviceIDGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1011; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDateofSecondaryCaptureGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1012; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeofSecondaryCaptureGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1014; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSecondaryCaptureDeviceManufacturerGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1016; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHardcopyDeviceManufacturerGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1017; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSecondaryCaptureDeviceManufacturersModelNameGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1018; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSecondaryCaptureDeviceSoftwareVersionsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1019; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHardcopyDeviceSoftwareVersionsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x101A; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHardcopyDeviceManufacturersModelNameGr]; theWrkP->group = 0x0018; theWrkP->element = 0x101B; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSoftwareVersionsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVideoImageFormatAcquiredGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1022; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDigitalImageFormatAcquiredGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1023; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papProtocolNameGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusRouteGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusVolumeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1041; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusStartTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1042; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusStopTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1043; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusTotalDoseGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1044; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSyringecountsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1045; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastFlowRatesGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1046; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastFlowDurationsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1047; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusIngredientGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1048; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusIngredientConcentrationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1049; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpatialResolutionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTriggerTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1060; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTriggerSourceorTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1061; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNominalIntervalGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1062; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1063; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFramingTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1064; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameTimeVectorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1065; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameDelayGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1066; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTriggerDelayGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1067; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMultiplexgroupTimeOffsetGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1068; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTriggerTimeOffsetGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1069; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSynchronizationTriggerGr]; theWrkP->group = 0x0018; theWrkP->element = 0x106A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSynchronizationChannelGr]; theWrkP->group = 0x0018; theWrkP->element = 0x106C; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTriggerSamplePositionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x106E; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiopharmaceuticalRouteGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1070; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiopharmaceuticalVolumeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1071; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiopharmaceuticalStartTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1072; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiopharmaceuticalStopTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1073; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadionuclideTotalDoseGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1074; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadionuclideHalfLifeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1075; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadionuclidePositronFractionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1076; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiopharmaceuticalSpecificactivityGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1077; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeatRejectionFlagGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1080; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLowRRValueGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1081; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighRRValueGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1082; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIntervalsAcquiredGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1083; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIntervalsRejectedGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1084; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPVCRejectionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1085; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSkipBeatsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1086; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHeartRateGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1088; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCardiacNumberofImagesGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1090; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTriggerWindowGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1094; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReconstructionDiameterGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoDetectorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoPatientGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1111; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEstimatedRadiographicMagnificationFactorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1114; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGantryDetectorTiltGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1120; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGantryDetectorSlewGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1121; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableHeightGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1130; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTraverseGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1131; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableMotionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1134; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableVerticalIncrementGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1135; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableLateralIncrementGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1136; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableLongitudinalIncrementGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1137; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableAngleGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1138; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x113A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRotationDirectionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1140; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAngularPositionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1141; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadialPositionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1142; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScanArcGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1143; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAngularStepGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1144; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCenterofRotationOffsetGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1145; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRotationOffsetGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1146; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewShapeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1147; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewDimensionsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1149; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1150; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXrayTubeCurrentGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1151; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1152; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureinmAsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1153; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAveragePulseWidthGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1154; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiationSettingGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1155; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRectificationTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1156; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiationModeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x115A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageAreaDoseProductGr]; theWrkP->group = 0x0018; theWrkP->element = 0x115E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1160; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTypeofFiltersGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1161; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIntensifierSizeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1162; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagerPixelSpacingGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1164; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1166; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGeneratorPowerGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1170; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorgridNameGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1180; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1181; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFocalDistanceGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1182; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXFocusCenterGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1183; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papYFocusCenterGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1184; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFocalSpotsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1190; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnodeTargetMaterialGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1191; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBodyPartThicknessGr]; theWrkP->group = 0x0018; theWrkP->element = 0x11A0; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompressionForceGr]; theWrkP->group = 0x0018; theWrkP->element = 0x11A2; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDateofLastCalibrationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1200; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeofLastCalibrationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1201; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConvolutionKernelGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1210; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papUpperLowerPixelValuesGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1240; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papActualFrameDurationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1242; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCountRateGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1243; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPreferredPlaybackSequencingGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1244; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReceivingCoilGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1250; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransmittingCoilGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1251; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPlateTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1260; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhosphorTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1261; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScanVelocityGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1300; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWholeBodyTechniqueGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1301; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScanLengthGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1302; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionMatrixGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1310; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "4"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhaseEncodingDirectionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1312; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFlipAngleGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1314; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVariableFlipAngleFlagGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1315; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSARGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1316; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papdBdtGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1318; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionDeviceProcessingDescriptionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionDeviceProcessingCodeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1401; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCassetteOrientationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1402; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCassetteSizeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1403; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposuresonPlateGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1404; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRelativeXrayExposureGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1405; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papColumnAngulationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1450; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTornoLayerHeightGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1460; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTornoAngleGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1470; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTornoTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1480; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTornoTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1490; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTornoClassGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1491; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofTornosynthesisSourceImagesGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1495; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionerMotionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionerTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1508; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionerPrimaryAngleGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionerSecondaryAngleGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionerPrimaryAngleIncrementGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1520; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionerSecondaryAngleIncrementGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1521; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorPrimaryAngleGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1530; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorSecondaryAngleGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1531; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShutterShapeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1600; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShutterLeftVerticalEdgeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1602; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShutterRightVerticalEdgeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1604; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShutterUpperHorizontalEdgeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1606; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShutterLowerHorizontalEdgeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1608; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCenterofCircularShutterGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1610; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiusofCircularShutterGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1612; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVerticesofthePolygonalShutterGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1620; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2-2n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShutterPaddingValueGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1622; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShutterOverlayGroupGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1623; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorShapeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1700; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorLeftVerticalEdgeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1702; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorRightVerticalEdgeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1704; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorUpperHorizontalEdgeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1706; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorLowerHorizontalEdgeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1708; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCenterofCircularCollimatorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1710; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiusofCircularCollimatorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1712; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVerticesofthePolygonalCollimatorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1720; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2-2n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionTimeSynchronizedGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1800; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "2-2n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeSourceGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1801; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "2-2n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeDistributionProtocolGr]; theWrkP->group = 0x0018; theWrkP->element = 0x1802; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "2-2n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPageNumberVectorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x2001; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameLabelVectorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x2002; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFramePrimaryAngleVectorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x2003; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameSecondaryAngleVectorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x2004; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSliceLocationVectorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x2005; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDisplayWindowLabelVectorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x2006; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNominalScannedPixelSpacingGr]; theWrkP->group = 0x0018; theWrkP->element = 0x2010; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDigitizingDeviceTransportDirectionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x2020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRotationOfScannedFilmGr]; theWrkP->group = 0x0018; theWrkP->element = 0x2030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papComments18Gr]; theWrkP->group = 0x0018; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOutputPowerGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5000; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerDataGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5010; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFocusDepthGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5012; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPreprocessingFunctionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPostprocessingFunctionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5021; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMechanicalIndexGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5022; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papThermalIndexGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5024; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCranialThermalIndexGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5026; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSoftTissueThermalIndexGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5027; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSoftTissuefocusThermalIndexGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5028; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSoftTissuesurfaceThermalIndexGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5029; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDynamicRangeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5030; theWrkP->length = 0L; theWrkP->vr = RET; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTotalGainGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5040; theWrkP->length = 0L; theWrkP->vr = RET; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDepthofScanFieldGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5050; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientPositionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5100; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewPositionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5101; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papProjectionEponymousNameCodeSequenceGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5104; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTransformationMatrixGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5210; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "6"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTranslationVectorGr]; theWrkP->group = 0x0018; theWrkP->element = 0x5212; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSensitivityGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6000; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSequenceofUltrasoundRegionsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6011; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRegionSpatialFormatGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6012; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRegionDataTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6014; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRegionFlagsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6016; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRegionLocationMinX0Gr]; theWrkP->group = 0x0018; theWrkP->element = 0x6018; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRegionLocationMinY0Gr]; theWrkP->group = 0x0018; theWrkP->element = 0x601A; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRegionLocationMaxX1Gr]; theWrkP->group = 0x0018; theWrkP->element = 0x601C; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRegionLocationMaxY1Gr]; theWrkP->group = 0x0018; theWrkP->element = 0x601E; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencePixelX0Gr]; theWrkP->group = 0x0018; theWrkP->element = 0x6020; theWrkP->length = 0L; theWrkP->vr = SL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencePixelY0Gr]; theWrkP->group = 0x0018; theWrkP->element = 0x6022; theWrkP->length = 0L; theWrkP->vr = SL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhysicalUnitsXDirectionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6024; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhysicalUnitsYDirectionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6026; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencePixelPhysicalValueXGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6028; theWrkP->length = 0L; theWrkP->vr = FD; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencePixelPhysicalValueYGr]; theWrkP->group = 0x0018; theWrkP->element = 0x602A; theWrkP->length = 0L; theWrkP->vr = FD; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhysicalDeltaXGr]; theWrkP->group = 0x0018; theWrkP->element = 0x602C; theWrkP->length = 0L; theWrkP->vr = FD; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhysicalDeltaYGr]; theWrkP->group = 0x0018; theWrkP->element = 0x602E; theWrkP->length = 0L; theWrkP->vr = FD; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerFrequencyGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6030; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6031; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPulseRepetitionFrequencyGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6032; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDopplerCorrectionAngleGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6034; theWrkP->length = 0L; theWrkP->vr = FD; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSterringAngleGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6036; theWrkP->length = 0L; theWrkP->vr = FD; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDopplerSampleVolumeXPositionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6038; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDopplerSampleVolumeYPositionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x603A; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTMLinePositionX0Gr]; theWrkP->group = 0x0018; theWrkP->element = 0x603C; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTMLinePositionY0Gr]; theWrkP->group = 0x0018; theWrkP->element = 0x603E; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTMLinePositionX1Gr]; theWrkP->group = 0x0018; theWrkP->element = 0x6040; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTMLinePositionY1Gr]; theWrkP->group = 0x0018; theWrkP->element = 0x6042; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelComponentOrganizationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6044; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelComponentMaskGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6046; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelComponentRangeStartGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6048; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelComponentRangeStopGr]; theWrkP->group = 0x0018; theWrkP->element = 0x604A; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelComponentPhysicalUnitsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x604C; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelComponentDataTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x604E; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofTableBreakPointsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6050; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableofXBreakPointsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6052; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableofYBreakPointsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6054; theWrkP->length = 0L; theWrkP->vr = FD; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofTableEntriesGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6056; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableofPixelValuesGr]; theWrkP->group = 0x0018; theWrkP->element = 0x6058; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableofParameterValuesGr]; theWrkP->group = 0x0018; theWrkP->element = 0x605A; theWrkP->length = 0L; theWrkP->vr = FL; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorConditionsNominalFlagGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7000; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorTemperatureGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7001; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorTypeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorConfigurationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorDescriptionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7006; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorModeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7008; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorIDGr]; theWrkP->group = 0x0018; theWrkP->element = 0x700A; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDateofLastDetectorCalibrationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x700C; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeofLastDetectorCalibrationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x700E; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposuresonDetectorSinceLastCalibrationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7010; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposuresonDetectorSinceManufacturedGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7011; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorTimeSinceLastExposureGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7012; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorActiveTimeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7014; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorActivationOffsetFromExposureGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7016; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorBinningGr]; theWrkP->group = 0x0018; theWrkP->element = 0x701A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorElementPhysicalSizeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7020; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorElementSpacingGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7022; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorActiveShapeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7024; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorActiveDimensionsGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7026; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorActiveOriginGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7028; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewOriginGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewRotationGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7032; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewHorizontalFlipGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7034; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridAbsorbingMaterialGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7040; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridSpacingMaterialGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7041; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridThicknessGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7042; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridPitchGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7044; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridAspectRatioGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7046; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridPeriodGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7048; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridFocalDistanceGr]; theWrkP->group = 0x0018; theWrkP->element = 0x704C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterMaterialGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7050; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterThicknessMinimumGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7052; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterThicknessMaximumGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7054; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureControlModeGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureControlModeDescriptionGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7062; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureStatusGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7064; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhototimerSettingGr]; theWrkP->group = 0x0018; theWrkP->element = 0x7065; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureTimeInMSGr]; theWrkP->group = 0x0018; theWrkP->element = 0x8150; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXRayTubeCurrentInMAGr]; theWrkP->group = 0x0018; theWrkP->element = 0x8151; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group18 */ /********************************************************************************/ /* */ /* init_group20 : initializes the elements of the group 20 */ /* */ /********************************************************************************/ void init_group20 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0020; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyInstanceUIDGr]; theWrkP->group = 0x0020; theWrkP->element = 0x000D; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesInstanceUIDGr]; theWrkP->group = 0x0020; theWrkP->element = 0x000E; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyIDGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesNumberGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionNumberGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageNumberGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0013; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIsotopeNumberGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhaseNumberGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0015; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIntervalNumberGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeSlotNumberGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0017; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAngleNumberGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0018; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papItemNumberGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0019; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientOrientationGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayNumberGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveNumberGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0024; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLUTNumberGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0026; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagePosition20Gr]; theWrkP->group = 0x0020; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagePositionPatientGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageOrientationGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0035; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageOrientationPatientGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0037; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "6"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLocationGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameofReferenceUIDGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0052; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLateralityGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageLateralityGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0062; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageGeometryTypeGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaskingImageGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTemporalPositionIdentifierGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofTemporalPositionsGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0105; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTemporalResolutionGr]; theWrkP->group = 0x0020; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesinStudyGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionsinSeriesGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1001; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagesinAcquisitionGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1002; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagesinSeriesGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1003; theWrkP->length = 0L; theWrkP->vr = RET; theWrkP->vm = "0"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitioninStudyGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1004; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagesinStudyGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1005; theWrkP->length = 0L; theWrkP->vr = RET; theWrkP->vm = "0"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferenceGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1020; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionReferenceIndicatorGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSliceLocationGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1041; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOtherStudyNumbersGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1070; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofPatientRelatedStudiesGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1200; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofPatientRelatedSeriesGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1202; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofPatientRelatedImagesGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1204; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofStudyRelatedSeriesGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1206; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofStudyRelatedImagesGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1208; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofSeriesRelatedImagesGr]; theWrkP->group = 0x0020; theWrkP->element = 0x1209; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceImageIDsGr]; theWrkP->group = 0x0020; theWrkP->element = 0x3100; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModifyingDeviceIDGr]; theWrkP->group = 0x0020; theWrkP->element = 0x3401; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModifiedImageIDGr]; theWrkP->group = 0x0020; theWrkP->element = 0x3402; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModifiedImageDateGr]; theWrkP->group = 0x0020; theWrkP->element = 0x3403; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModifyingDeviceManufacturerGr]; theWrkP->group = 0x0020; theWrkP->element = 0x3404; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModifiedImageTimeGr]; theWrkP->group = 0x0020; theWrkP->element = 0x3405; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModifiedImageDescriptionGr]; theWrkP->group = 0x0020; theWrkP->element = 0x3406; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageCommentsGr]; theWrkP->group = 0x0020; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOriginalImageIdentificationGr]; theWrkP->group = 0x0020; theWrkP->element = 0x5000; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOriginalImageIdentificationNomenclatureGr]; theWrkP->group = 0x0020; theWrkP->element = 0x5002; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group20 */ /********************************************************************************/ /* */ /* init_group28 : initializes the elements of the group 28 */ /* */ /********************************************************************************/ void init_group28 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0028; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSamplesperPixelGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretationGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageDimensionsGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPlanarConfigurationGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofFramesGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameIncrementPointerGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRowsGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papColumnsGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPlanesGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papUltrasoundColorDataPresentGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelSpacingGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papZoomFactorGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0031; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papZoomCenterGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelAspectRatioGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0034; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageFormatGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papManipulatedImageGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCorrectedImageGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0051; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompressionCodeGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsStoredGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighBitGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelRepresentationGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSmallestValidPixelValueGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0104; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLargestValidPixelValueGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0105; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSmallestImagePixelValueGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0106; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLargestImagePixelValueGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0107; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSmallestPixelValueinSeriesGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0108; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLargestPixelValueinSeriesGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0109; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSmallestImagePixelValueinPlaneGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLargestImagePixelValueinPlaneGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0111; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelPaddingValueGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0120; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageLocationGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = SS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papQualityControlImageGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0300; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBurnedInAnnotationGr]; theWrkP->group = 0x0028; theWrkP->element = 0x0301; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelIntensityRelationshipGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelIntensityRelationshipSignGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1041; theWrkP->length = 0L; theWrkP->vr = SS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWindowCenterGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWindowWidthGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1051; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleInterceptGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1052; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleSlopeGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1053; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleTypeGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1054; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWindowCenterWidthExplanationGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1055; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGrayScaleGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1080; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecommendedViewingModeGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1090; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGrayLookupTableDescriptorGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRedPaletteColorLookupTableDescriptorGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGreenPaletteColorLookupTableDescriptorGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBluePaletteColorLookupTableDescriptorGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPaletteColorLookupTableUIDGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1199; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGrayLookupTableDataGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1200; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRedPaletteCLUTDataGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1201; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGreenPaletteCLUTDataGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1202; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBluePaletteCLUTDataGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1203; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSegmentedRedPaletteColorLookupTableDataGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1221; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSegmentedGreenPaletteColorLookupTableDataGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1222; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSegmentedBluePaletteColorLookupTableDataGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1223; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImplantPresentGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1300; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPartialViewGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1350; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPartialViewDescriptionGr]; theWrkP->group = 0x0028; theWrkP->element = 0x1351; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLossyImageCompressionGr]; theWrkP->group = 0x0028; theWrkP->element = 0x2110; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLossyImageCompressionRatioGr]; theWrkP->group = 0x0028; theWrkP->element = 0x2112; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModalityLUTSequenceGr]; theWrkP->group = 0x0028; theWrkP->element = 0x3000; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLUTDescriptorGr]; theWrkP->group = 0x0028; theWrkP->element = 0x3002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLUTExplanationGr]; theWrkP->group = 0x0028; theWrkP->element = 0x3003; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModalityLUTTypeGr]; theWrkP->group = 0x0028; theWrkP->element = 0x3004; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLUTDataGr]; theWrkP->group = 0x0028; theWrkP->element = 0x3006; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVOILUTSequenceGr]; theWrkP->group = 0x0028; theWrkP->element = 0x3010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSoftcopyVOILUTSequenceGr]; theWrkP->group = 0x0028; theWrkP->element = 0x3110; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papComments28Gr]; theWrkP->group = 0x0028; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBiPlaneAcquisitionSequenceGr]; theWrkP->group = 0x0028; theWrkP->element = 0x5000; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRepresentativeFrameNumberGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameNumbersofInterestGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6020; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFramesofInterestDescriptionGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6022; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaskPointersGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6030; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRWavePointerGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6040; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaskSubtractionSequenceGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6100; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaskOperationGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6101; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papApplicableFrameRangeGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "2-2n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaskFrameNumbersGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6110; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastFrameAveragingGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6112; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaskSubpixelShiftGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6114; theWrkP->length = 0L; theWrkP->vr = FL; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTIDOffsetGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6120; theWrkP->length = 0L; theWrkP->vr = SS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaskOperationExplanationGr]; theWrkP->group = 0x0028; theWrkP->element = 0x6190; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Group28 */ /********************************************************************************/ /* */ /* init_group32 : initializes the elements of the group 32 */ /* */ /********************************************************************************/ void init_group32 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0032; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyStatusIDGr]; theWrkP->group = 0x0032; theWrkP->element = 0x000A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyPriorityIDGr]; theWrkP->group = 0x0032; theWrkP->element = 0x000C; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyIDIssuerGr]; theWrkP->group = 0x0032; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyVerifiedDateGr]; theWrkP->group = 0x0032; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyVerifiedTimeGr]; theWrkP->group = 0x0032; theWrkP->element = 0x0033; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyReadDateGr]; theWrkP->group = 0x0032; theWrkP->element = 0x0034; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyReadTimeGr]; theWrkP->group = 0x0032; theWrkP->element = 0x0035; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStudyStartDateGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStudyStartTimeGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1001; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStudyStopDateGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStudyStopTimeGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1011; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStudyLocationGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStudyLocationAETitlesGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1021; theWrkP->length = 0L; theWrkP->vr = AE; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReasonforStudyGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestingPhysicianGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1032; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestingServiceGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1033; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyArrivalDateGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyArrivalTimeGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1041; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyCompletionDateGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyCompletionTimeGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1051; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyComponentStatusIDGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1055; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedProcedureDescriptionGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1060; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedProcedureCodeSequenceGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1064; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedContrastAgentGr]; theWrkP->group = 0x0032; theWrkP->element = 0x1070; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyCommentsGr]; theWrkP->group = 0x0032; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group32 */ /********************************************************************************/ /* */ /* init_group38 : initializes the elements of the group 38 */ /* */ /********************************************************************************/ void init_group38 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0038; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedPatientAliasSequenceGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVisitStatusIDGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdmissionIDGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIssuerofAdmissionIDGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRouteofAdmissionsGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledAdmissionDateGr]; theWrkP->group = 0x0038; theWrkP->element = 0x001A; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledAdmissionTimeGr]; theWrkP->group = 0x0038; theWrkP->element = 0x001B; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledDischargeDateGr]; theWrkP->group = 0x0038; theWrkP->element = 0x001C; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledDischargeTimeGr]; theWrkP->group = 0x0038; theWrkP->element = 0x001D; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledPatientInstitutionResidenceGr]; theWrkP->group = 0x0038; theWrkP->element = 0x001E; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdmittingDateGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdmittingTimeGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDischargeDateGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDischargeTimeGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDischargeDiagnosisDescriptionGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDischargeDiagnosisCodeSequenceGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0044; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecialNeedsGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurrentPatientLocationGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0300; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsInstitutionResidenceGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0400; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientStateGr]; theWrkP->group = 0x0038; theWrkP->element = 0x0500; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVisitCommentsGr]; theWrkP->group = 0x0038; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group38 */ /********************************************************************************/ /* */ /* init_group3A : initializes the elements of the group 3A */ /* */ /********************************************************************************/ void init_group3A (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x003A; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWaveformOriginalityGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberOfWaveformChannelsGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberOfWaveformSamplesGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSamplingFrequencyGr]; theWrkP->group = 0x003A; theWrkP->element = 0x001A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMultiplexGroupLabelGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelDefinitionSequenceGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWaveformChannelNumberGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0202; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelLabelGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0203; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelStatusGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0205; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelSourceSequenceGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0208; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelSourceModifiersSequenceGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0209; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceWaveformSequenceGr]; theWrkP->group = 0x003A; theWrkP->element = 0x020A; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelDerivationDescriptionGr]; theWrkP->group = 0x003A; theWrkP->element = 0x020C; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelSensitivityGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0210; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelSensitivityUnitsSequenceGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0211; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelSensitivityCorrectionFactorGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0212; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelBaselineGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0213; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelTimeSkewGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0214; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelSampleSkewGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0215; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelOffsetGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0218; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWaveformBitsStoredGr]; theWrkP->group = 0x003A; theWrkP->element = 0x021A; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterLowFrequencyGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0220; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterHighFrequencyGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0221; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNotchFilterFrequencyGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0222; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNotchFilterBandwidthGr]; theWrkP->group = 0x003A; theWrkP->element = 0x0223; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group3A */ /********************************************************************************/ /* */ /* init_group40 : initializes the elements of the group 40 */ /* */ /********************************************************************************/ void init_group40 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0040; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStationAETitleGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0001; theWrkP->length = 0L; theWrkP->vr = AE; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledProcedureStepStartDateGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledProcedureStepStartTimeGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0003; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledProcedureStepEndDateGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledProcedureStepEndTimeGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledPerformingPhysiciansNameGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledProcedureStepDescriptionGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0007; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledActionItemCodeSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledProcedureStepIDGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStageCodeSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x000A; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStationNameGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledProcedureStepLocationGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPreMedicationGr]; theWrkP->group = 0x0040; theWrkP->element = 0x00012; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledProcedureStepStatusGr]; theWrkP->group = 0x0040; theWrkP->element = 0x00020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledProcedureStepSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedStandaloneSOPInstanceSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0220; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedStationAETitleGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0241; theWrkP->length = 0L; theWrkP->vr = AE; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedStationNameGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0242; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedLocationGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0243; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedProcedureStepStartDateGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0244; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedProcedureStepStartTimeGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0245; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedProcedureStepEndDateGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0250; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedProcedureStepEndTimeGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0251; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedProcedureStepStatusGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0252; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedProcedureStepIDGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0253; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedProcedureStepDescriptionGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0254; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedProcedureStepTypeGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0255; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedActionItemSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0260; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStepAttributesSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0270; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedAttributesSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0275; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCommentsOnThePerformedProcedureStepsGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0280; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papQuantitySequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0293; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papQuantityGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0294; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMeasuringUnitsSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0295; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBillingItemSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0296; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTotalTimeOfFluoroscopyGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0300; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTotalNumberOfExposuresGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0301; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEntranceDoseGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0302; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposedAreaGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0303; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoEntranceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0306; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoSupportGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0307; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCommentsonRadiationDoseGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0310; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXRayOutputGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0312; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHalfValueLayerGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0314; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrganDoseGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0316; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrganExposedGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0318; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBillingProcedureStepSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0320; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilmConsumptionSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0321; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBillingSuppliesAndDevicesSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0324; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedProcedureStepSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0330; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedSeriesSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0340; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCommentsontheScheduledProcedureStepGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0400; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecimenAccessionNumberGr]; theWrkP->group = 0x0040; theWrkP->element = 0x050A; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecimenSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0550; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecimenIdentifierGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0551; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionContextSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0555; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionContextDescriptionGr]; theWrkP->group = 0x0040; theWrkP->element = 0x0556; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecimenTypeCodeSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x059A; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSlideIdentifierGr]; theWrkP->group = 0x0040; theWrkP->element = 0x06FA; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageCenterPointCoordinatesSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x071A; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXOffsetInSlideCoordinateSystemGr]; theWrkP->group = 0x0040; theWrkP->element = 0x072A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papYOffsetInSlideCoordinateSystemGr]; theWrkP->group = 0x0040; theWrkP->element = 0x073A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papZOffsetInSlideCoordinateSystemGr]; theWrkP->group = 0x0040; theWrkP->element = 0x074A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelSpacingSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x08D8; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCoordinateSystemAxisCodeSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x08DA; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMeasurementUnitsCodeSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0x08EA; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedProcedureIDGr]; theWrkP->group = 0x0040; theWrkP->element = 0x1001; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReasonfortheRequestedProcedureGr]; theWrkP->group = 0x0040; theWrkP->element = 0x1002; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedProcedurePriorityGr]; theWrkP->group = 0x0040; theWrkP->element = 0x1003; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientTransportArrangementsGr]; theWrkP->group = 0x0040; theWrkP->element = 0x1004; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedProcedureLocationGr]; theWrkP->group = 0x0040; theWrkP->element = 0x1005; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPlacerOrderNumberProcedureGr]; theWrkP->group = 0x0040; theWrkP->element = 0x1006; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFillerOrderNumberProcedureGr]; theWrkP->group = 0x0040; theWrkP->element = 0x1007; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConfidentialityCodeGr]; theWrkP->group = 0x0040; theWrkP->element = 0x1008; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReportingPriorityGr]; theWrkP->group = 0x0040; theWrkP->element = 0x1009; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNamesofIntendedRecipientsofResultsGr]; theWrkP->group = 0x0040; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedProcedureCommentsGr]; theWrkP->group = 0x0040; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReasonfortheImagingServiceRequestGr]; theWrkP->group = 0x0040; theWrkP->element = 0x2001; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIssueDateofImagingServiceRequestGr]; theWrkP->group = 0x0040; theWrkP->element = 0x2004; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIssueTimeofImagingServiceRequestGr]; theWrkP->group = 0x0040; theWrkP->element = 0x2005; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrderEnteredByGr]; theWrkP->group = 0x0040; theWrkP->element = 0x2008; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrderEnterersLocationGr]; theWrkP->group = 0x0040; theWrkP->element = 0x2009; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrderCallbackPhoneNumberGr]; theWrkP->group = 0x0040; theWrkP->element = 0x2010; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPlacerOrderNumberImagingServiceRequestGr]; theWrkP->group = 0x0040; theWrkP->element = 0x2016; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFillerOrderNumberImagingServiceRequestGr]; theWrkP->group = 0x0040; theWrkP->element = 0x2017; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagingServiceRequestCommentsGr]; theWrkP->group = 0x0040; theWrkP->element = 0x2400; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConfidentialityConstraintonPatientDataDescriptionGr]; theWrkP->group = 0x0040; theWrkP->element = 0x3001; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEntranceDoseInMyGyGr]; theWrkP->group = 0x0040; theWrkP->element = 0x8302; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRelationshipTypeGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA010; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVerifyingOrganizationGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA027; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVerificationDateTimeGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA030; theWrkP->length = 0L; theWrkP->vr = DT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papObservationDateTimeGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA032; theWrkP->length = 0L; theWrkP->vr = DT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papValueTypeGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConceptNameCodeSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA043; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContinuityOfContentGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA050; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVerifyingObserverSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA073; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVerifyingObserverNameGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA075; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVerifyingObserverIdentificationCodeSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA088; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedWaveformChannelsGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA0B0; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "2-2n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDateTimeGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA120; theWrkP->length = 0L; theWrkP->vr = DT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDateGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA121; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA122; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPersonNameGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA123; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papUIDGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA124; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTemporalRangeTypeGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA130; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSamplePositionsGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA132; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencesFrameNumbersGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA136; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTimeOffsetsGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA138; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedDatetimeGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA13A; theWrkP->length = 0L; theWrkP->vr = DT; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTextValueGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA160; theWrkP->length = 0L; theWrkP->vr = UT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConceptCodeSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA168; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnnotationGroupNumberGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA180; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModifierCodeSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA195; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMeasuredValueSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA300; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumericValueGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA30A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPredecessorDocumentsSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA360; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedRequestSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA370; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformedProcedureCodeSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA372; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurentRequestedProcedureEvidenceSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA375; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPertinentOtherEvidenceSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA385; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompletionFlagGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA491; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompletionFlagDescriptionGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA492; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVerificationFlagGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA493; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContentTemplateSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA504; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIdenticalDocumentsSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA525; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContentSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xA730; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnnotationSequenceGr]; theWrkP->group = 0x0040; theWrkP->element = 0xB020; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTemplateIdentifierGr]; theWrkP->group = 0x0040; theWrkP->element = 0xDB00; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTemplateVersionGr]; theWrkP->group = 0x0040; theWrkP->element = 0xDB06; theWrkP->length = 0L; theWrkP->vr = DT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTemplateLocalVersionGr]; theWrkP->group = 0x0040; theWrkP->element = 0xDB07; theWrkP->length = 0L; theWrkP->vr = DT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTemplateExtensionFlagGr]; theWrkP->group = 0x0040; theWrkP->element = 0xDB0B; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [paptemplateExtensionOrganizationUIDGr]; theWrkP->group = 0x0040; theWrkP->element = 0xDB0C; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [paptemplateExtensionCreatorUIDGr]; theWrkP->group = 0x0040; theWrkP->element = 0xDB0D; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedContentItemIdentifierGr]; theWrkP->group = 0x0040; theWrkP->element = 0xDB73; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group40 */ /********************************************************************************/ /* */ /* init_group41 : initializes the elements of the group 41 */ /* */ /********************************************************************************/ void init_group41 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0041; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOwnerIDGr]; theWrkP->group = 0x0041; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 1; theWrkP->value = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); theWrkP->value->a = (char *) ecalloc3 ((PapyULong) 12, (PapyULong) sizeof (char)); strcpy (theWrkP->value->a, "PAPYRUS 3.0"); theWrkP = &ioElem [papComments41Gr]; theWrkP->group = 0x0041; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPointerSequenceGr]; theWrkP->group = 0x0041; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagePointerGr]; theWrkP->group = 0x0041; theWrkP->element = 0x1011; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelOffsetGr]; theWrkP->group = 0x0041; theWrkP->element = 0x1012; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageIdentifierSequenceGr]; theWrkP->group = 0x0041; theWrkP->element = 0x1013; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExternalPAPYRUSFileReferenceSequenceGr]; theWrkP->group = 0x0041; theWrkP->element = 0x1014; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofimagesGr]; theWrkP->group = 0x0041; theWrkP->element = 0x1015; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUID41Gr]; theWrkP->group = 0x0041; theWrkP->element = 0x1021; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUID41Gr]; theWrkP->group = 0x0041; theWrkP->element = 0x1022; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileNameGr]; theWrkP->group = 0x0041; theWrkP->element = 0x1031; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFilePathGr]; theWrkP->group = 0x0041; theWrkP->element = 0x1032; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageSOPClassUIDGr]; theWrkP->group = 0x0041; theWrkP->element = 0x1041; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageSOPInstanceUIDGr]; theWrkP->group = 0x0041; theWrkP->element = 0x1042; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageSequenceGr]; theWrkP->group = 0x0041; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group41 */ /********************************************************************************/ /* */ /* init_group50 : initializes the elements of the group 50 */ /* */ /********************************************************************************/ void init_group50 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0050; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCalibrationObjectGr]; theWrkP->group = 0x0050; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeviceSequenceGr]; theWrkP->group = 0x0050; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeviceLengthGr]; theWrkP->group = 0x0050; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeviceDiameterGr]; theWrkP->group = 0x0050; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeviceDiameterUnitsGr]; theWrkP->group = 0x0050; theWrkP->element = 0x0017; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeviceVolumeGr]; theWrkP->group = 0x0050; theWrkP->element = 0x0018; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIntermarkerDistanceGr]; theWrkP->group = 0x0050; theWrkP->element = 0x0019; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeviceDescriptionGr]; theWrkP->group = 0x0050; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group50 */ /********************************************************************************/ /* */ /* init_group54 : initializes the elements of the group 54 */ /* */ /********************************************************************************/ void init_group54 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0054; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowVectorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofEnergyWindowsGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowInformationSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowRangeSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0013; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowLowerLimitGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowUpperLimitGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0015; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiopharmaceuticalInformationSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papResidualSyringeCountsGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0017; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowNameGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0018; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorVectorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofDetectorsGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorInformationSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhaseVectorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofPhasesGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0031; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhaseInformationSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofFramesinPhaseGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0033; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhaseDelayGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0036; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPauseBetweenFramesGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0038; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRotationVectorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofRotationsGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0051; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRotationInformationSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0052; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofFramesinRotationGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0053; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRRIntervalVectorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofRRIntervalsGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0061; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGatedInformationSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0062; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDataInformationSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0063; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeSlotVectorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofTimeSlotsGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0071; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeSlotInformationSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0072; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeSlotTimeGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0073; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSliceVectorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofSlicesGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0081; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAngularViewVectorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0090; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeSliceVectorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberOfTimeSlicesGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStartAngleGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTypeofDetectorMotionGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0202; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTriggerVectorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0210; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofTriggersinPhaseGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0211; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewCodeSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0220; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewModifierCodeSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0222; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadionuclideCodeSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0300; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdministrationRouteCodeSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0302; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiopharmaceuticalCodeSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0304; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCalibrationDataSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0306; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowNumberGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0308; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageIDGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0400; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientOrientationCodeSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0410; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientOrientationModifierCodeSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0412; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientGantryRelationshipCodeSequenceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x0414; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesTypeGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papUnitsGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1001; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCountsSourceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1002; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReprojectionMethodGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRandomsCorrectionMethodGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAttenuationCorrectionMethodGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1101; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDecayCorrectionGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1102; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReconstructionMethodGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1103; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorLinesOfResponseUsedGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1104; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScatterCorrectionMethodGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1105; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAxialAcceptanceGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1200; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAxialMashGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1201; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransverseMashGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1202; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorElementSizeGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1203; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCoincidenceWindowWidthGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1210; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSecondaryCountsTypeGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1220; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameReferenceTimeGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1300; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrimaryCountsAccumulatedGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1310; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSecondaryCountsAccumulatedGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1311; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSliceSensitivityFactorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1320; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDecayFactorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1321; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseCalibrationFactorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1322; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScatterFractionFactorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1323; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeadTimeFactorGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1324; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageIndexGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1330; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCountsIncludedGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeadTimeCorrectionFlagGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1401; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Group54 */ /********************************************************************************/ /* */ /* init_group60 : initializes the elements of the group 60 */ /* */ /********************************************************************************/ void init_group60 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papHistogramSequenceGr]; theWrkP->group = 0x0060; theWrkP->element = 0x3000; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHistogramNumberofBinsGr]; theWrkP->group = 0x0060; theWrkP->element = 0x3002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHistogramFirstBinValueGr]; theWrkP->group = 0x0060; theWrkP->element = 0x3004; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHistogramLastBinValueGr]; theWrkP->group = 0x0060; theWrkP->element = 0x3006; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHistogramBinWidthGr]; theWrkP->group = 0x0060; theWrkP->element = 0x3008; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHistogramExplanationGr]; theWrkP->group = 0x0060; theWrkP->element = 0x3010; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHistogramDataGr]; theWrkP->group = 0x0060; theWrkP->element = 0x3020; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group60 */ /********************************************************************************/ /* */ /* init_group88 : initializes the elements of the group 70 */ /* */ /********************************************************************************/ void init_group70 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0070; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGraphicAnnotationSequenceGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0001; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGraphicLayerGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBoundingBoxAnnotationUnitsGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0003; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnchorPointAnnotationUnitsGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGraphicAnnotationUnitsGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papUnformattedTexValueGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTextObjectSequenceGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBoundingBoxTopLeftHandCornerGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = FL; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBoundingBoxBottomRightHandCornerGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = FL; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBoundingBoxTextHorizontalJustificationGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnchorPoint70Gr]; theWrkP->group = 0x0070; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = FL; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnchorPointVisibilityGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0015; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGraphicDimensionsGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberOfGraphicPointsGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGraphicDataGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = FL; theWrkP->vm = "2-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGraphicTypeGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0023; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGraphicFilledGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0024; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageHorizontalFlipGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0041; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageRotationGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0042; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDisplayedAreaTopLeftHandCornerGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0052; theWrkP->length = 0L; theWrkP->vr = SL; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDisplayedAreaBottomRightHandCornerGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0053; theWrkP->length = 0L; theWrkP->vr = SL; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDisplayedAreaSelectionSequenceGr]; theWrkP->group = 0x0070; theWrkP->element = 0x005A; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGraphicLayerSequenceGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGraphicLayerOrderGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0062; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGraphicLayerRecommendedDisplayGrayscaleValueGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0066; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGraphicLayerRecommendedDisplayRGBValueGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0067; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGraphicLayerDescriptionGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0068; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationLabelGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationDescriptionGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0081; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationCreationDateGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0082; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationCreationTimeGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0083; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationCreatorsNameGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0084; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationSizeModeGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationPixelSpacingGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationPixelAspectRationGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationPixelMagnificationRatioGr]; theWrkP->group = 0x0070; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = FL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group70 */ /********************************************************************************/ /* */ /* init_group88 : initializes the elements of the group 88 */ /* */ /********************************************************************************/ void init_group88 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0088; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStorageMediaFilesetIDGr]; theWrkP->group = 0x0088; theWrkP->element = 0x0130; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStorageMediaFilesetUIDGr]; theWrkP->group = 0x0088; theWrkP->element = 0x0140; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIconImageSequenceGr]; theWrkP->group = 0x0088; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTopicTitleGr]; theWrkP->group = 0x0088; theWrkP->element = 0x0904; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTopicSubjectGr]; theWrkP->group = 0x0088; theWrkP->element = 0x0906; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTopicAuthorGr]; theWrkP->group = 0x0088; theWrkP->element = 0x0910; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTopicKeyWordsGr]; theWrkP->group = 0x0088; theWrkP->element = 0x0912; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-32"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group88 */ /********************************************************************************/ /* */ /* init_group100 : initializes the elements of the group 100 */ /* */ /********************************************************************************/ void init_group100 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x0100; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSOPInstanceStatusGr]; theWrkP->group = 0x0100; theWrkP->element = 0x0410; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSOPAuthorizationDateAndTimeGr]; theWrkP->group = 0x0100; theWrkP->element = 0x0420; theWrkP->length = 0L; theWrkP->vr = DT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSOPAuthorizationCommentGr]; theWrkP->group = 0x0100; theWrkP->element = 0x0424; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAuthorizationEquipmentCertificationNumberGr]; theWrkP->group = 0x0100; theWrkP->element = 0x0426; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group100 */ /********************************************************************************/ /* */ /* init_group2000 : initializes the elements of the group 2000 */ /* */ /********************************************************************************/ void init_group2000 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x2000; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberOfCopiesGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrinterConfigurationSequenceGr]; theWrkP->group = 0x2000; theWrkP->element = 0x001E; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrintPriorityGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMediumTypeGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilmDestinationGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilmSessionLabelGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMemoryAllocationGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaximumMemoryAllocationGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0061; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papColorImagePrintingFlagGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0062; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollationFlagGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0063; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnnotationFlagGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0065; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageOverlayFlagGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0067; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationLUTFlagGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0069; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageBoxPresentationLUTFlagGr]; theWrkP->group = 0x2000; theWrkP->element = 0x006A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMemoryBitDepthGr]; theWrkP->group = 0x2000; theWrkP->element = 0x00A0; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrintingBitDepthGr]; theWrkP->group = 0x2000; theWrkP->element = 0x00A1; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMediaInstalledSequenceGr]; theWrkP->group = 0x2000; theWrkP->element = 0x00A2; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOtherMediaInstalledSequenceGr]; theWrkP->group = 0x2000; theWrkP->element = 0x00A4; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSupportedImageDisplayFormatsSequenceGr]; theWrkP->group = 0x2000; theWrkP->element = 0x00A8; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFilmBoxSequenceGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0500; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedStoredPrintSequenceGr]; theWrkP->group = 0x2000; theWrkP->element = 0x0510; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group2000 */ /********************************************************************************/ /* */ /* init_group2010 : initializes the elements of the group 2010 */ /* */ /********************************************************************************/ void init_group2010 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x2010; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageDisplayFormatGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnnotationDisplayFormatIDGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilmOrientationGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilmSizeIDGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMagnificationTypeGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSmoothingTypeGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDefaultMagnificationTypeGr]; theWrkP->group = 0x2010; theWrkP->element = 0x00A6; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOtherMagnificationTypesAvailableGr]; theWrkP->group = 0x2010; theWrkP->element = 0x00A7; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDefaultSmoothingTypeGr]; theWrkP->group = 0x2010; theWrkP->element = 0x00A8; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOtherSmoothingTypesAvailableGr]; theWrkP->group = 0x2010; theWrkP->element = 0x00A9; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBorderDensityGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEmptyImageDensityGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMinDensityGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0120; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaxDensityGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0130; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTrimGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0140; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConfigurationInformationGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0150; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConfigurationInformationDescriptionGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0152; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaximumCollatedFilmsGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0154; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIlluminationGr]; theWrkP->group = 0x2010; theWrkP->element = 0x015E; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReflectedAmbientLightGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0160; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrinterPixelSpacingGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0376; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFilmSessionSequenceGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0500; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageBoxSequence2010Gr]; theWrkP->group = 0x2010; theWrkP->element = 0x0510; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedBasicAnnotationBoxSequenceGr]; theWrkP->group = 0x2010; theWrkP->element = 0x0520; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group2010 */ /********************************************************************************/ /* */ /* init_group2020 : initializes the elements of the group 2020 */ /* */ /********************************************************************************/ void init_group2020 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x2020; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagePosition2020Gr]; theWrkP->group = 0x2020; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPolarityGr]; theWrkP->group = 0x2020; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedImageSizeGr]; theWrkP->group = 0x2020; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedDecimateCropBehaviorGr]; theWrkP->group = 0x2020; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedResolutionIDGr]; theWrkP->group = 0x2020; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedImageSizeFlagGr]; theWrkP->group = 0x2020; theWrkP->element = 0x00A0; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDecimateCropResultGr]; theWrkP->group = 0x2020; theWrkP->element = 0x00A2; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPreformattedGrayscaleImageSequenceGr]; theWrkP->group = 0x2020; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPreformattedColorImageSequenceGr]; theWrkP->group = 0x2020; theWrkP->element = 0x0111; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageOverlayBoxSequenceGr]; theWrkP->group = 0x2020; theWrkP->element = 0x0130; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedVOILUTBoxSequenceGr]; theWrkP->group = 0x2020; theWrkP->element = 0x0140; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group2020 */ /********************************************************************************/ /* */ /* init_group2030 : initializes the elements of the group 2030 */ /* */ /********************************************************************************/ void init_group2030 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x2030; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnnotationPositionGr]; theWrkP->group = 0x2030; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTextStringGr]; theWrkP->group = 0x2030; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group2030 */ /********************************************************************************/ /* */ /* init_group2040 : initializes the elements of the group 2040 */ /* */ /********************************************************************************/ void init_group2040 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x2040; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedOverlayPlaneSequenceGr]; theWrkP->group = 0x2040; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedOverlayPlaneGroupsGr]; theWrkP->group = 0x2040; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-99"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayPixelDataSequenceGr]; theWrkP->group = 0x2040; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayMagnificationTypeGr]; theWrkP->group = 0x2040; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayMagnificationGr]; theWrkP->group = 0x2040; theWrkP->element = 0x0062; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaySmoothingTypeGr]; theWrkP->group = 0x2040; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayOrImageMagnificationGr]; theWrkP->group = 0x2040; theWrkP->element = 0x0072; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMagnifyToNumberOfColumnsGr]; theWrkP->group = 0x2040; theWrkP->element = 0x0074; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayForegroundDensityGr]; theWrkP->group = 0x2040; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayBackgroundDensityGr]; theWrkP->group = 0x2040; theWrkP->element = 0x0082; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayModeGr]; theWrkP->group = 0x2040; theWrkP->element = 0x0090; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papThresholdDensityGr]; theWrkP->group = 0x2040; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageBoxSequence2040Gr]; theWrkP->group = 0x2040; theWrkP->element = 0x0500; theWrkP->length = 0L; theWrkP->vr = RET; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group2040 */ /********************************************************************************/ /* */ /* init_group2050 : initializes the elements of the group 2050 */ /* */ /********************************************************************************/ void init_group2050 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPresentationLUTSequenceGr]; theWrkP->group = 0x2050; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationLUTShapeGr]; theWrkP->group = 0x2050; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedPresentationLUTSequenceGr]; theWrkP->group = 0x2050; theWrkP->element = 0x0500; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group2050 */ /********************************************************************************/ /* */ /* init_group2100 : initializes the elements of the group 2100 */ /* */ /********************************************************************************/ void init_group2100 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x2100; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExecutionStatusGr]; theWrkP->group = 0x2100; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExecutionStatusInfoGr]; theWrkP->group = 0x2100; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCreationDateGr]; theWrkP->group = 0x2100; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCreationTimeGr]; theWrkP->group = 0x2100; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOriginatorGr]; theWrkP->group = 0x2100; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = AE; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDestinationAEGr]; theWrkP->group = 0x2100; theWrkP->element = 0x0140; theWrkP->length = 0L; theWrkP->vr = AE; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOwnerIDGr]; theWrkP->group = 0x2100; theWrkP->element = 0x0160; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberOfFilmsGr]; theWrkP->group = 0x2100; theWrkP->element = 0x0170; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedPrintJobSequenceGr]; theWrkP->group = 0x2100; theWrkP->element = 0x0500; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group2100 */ /********************************************************************************/ /* */ /* init_group2110 : initializes the elements of the group 2110 */ /* */ /********************************************************************************/ void init_group2110 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x2110; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrinterStatusGr]; theWrkP->group = 0x2110; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrinterStatusInfoGr]; theWrkP->group = 0x2110; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrinterNameGr]; theWrkP->group = 0x2110; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrintQueueIDGr]; theWrkP->group = 0x2110; theWrkP->element = 0x0099; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group2110 */ /********************************************************************************/ /* */ /* init_group2120 : initializes the elements of the group 2120 */ /* */ /********************************************************************************/ void init_group2120 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x2120; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papQueueStatusGr]; theWrkP->group = 0x2120; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrintJobDescriptionSequenceGr]; theWrkP->group = 0x2120; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papreferencedPrintJobSequenceGr]; theWrkP->group = 0x2120; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group2120 */ /********************************************************************************/ /* */ /* init_group2130 : initializes the elements of the group 2130 */ /* */ /********************************************************************************/ void init_group2130 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x2130; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrintManagementCapabilitiesSequenceGr]; theWrkP->group = 0x2130; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrintCharacteristicsSequenceGr]; theWrkP->group = 0x2130; theWrkP->element = 0x0015; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilmBoxContentSequenceGr]; theWrkP->group = 0x2130; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageBoxContentSequenceGr]; theWrkP->group = 0x2130; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnnotationContentSequenceGr]; theWrkP->group = 0x2130; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageOverlayBoxContentSequenceGr]; theWrkP->group = 0x2130; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationLUTContentSequenceGr]; theWrkP->group = 0x2130; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papProposedStudySequenceGr]; theWrkP->group = 0x2130; theWrkP->element = 0x00A0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrigianlImageSequenceGr]; theWrkP->group = 0x2130; theWrkP->element = 0x00C0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group2130 */ /********************************************************************************/ /* */ /* init_group3002 : initializes the elements of the group 3002 */ /* */ /********************************************************************************/ void init_group3002 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x3002; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImageLabelGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImageNameGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0003; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImageDescriptionGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReportedValuesOriginGr]; theWrkP->group = 0x3002; theWrkP->element = 0x000A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImagePlaneGr]; theWrkP->group = 0x3002; theWrkP->element = 0x000C; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXRayImageReceptortranslationGr]; theWrkP->group = 0x3002; theWrkP->element = 0x000D; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXRayImageReceptorAngleGr]; theWrkP->group = 0x3002; theWrkP->element = 0x000E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImageOrientationGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "6"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagePlanePixelSpacingGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImagePositionGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiationMachineNameGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiationMachineSADGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiationMachineSSDGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0024; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImageSIDGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0026; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourcetoReferenceObjectDistanceGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0028; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFractionNumberGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0029; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureSequenceGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMetersetExposureGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDiaphragmPositionGr]; theWrkP->group = 0x3002; theWrkP->element = 0x0034; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "4"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group3002 */ /********************************************************************************/ /* */ /* init_group3004 : initializes the elements of the group 3004 */ /* */ /********************************************************************************/ void init_group3004 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x3004; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHTypeGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0001; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseUnitsGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseTypeGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseCommentGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNormalizationPointGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseSummationTypeGr]; theWrkP->group = 0x3004; theWrkP->element = 0x000A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridFrameOffsetVectorGr]; theWrkP->group = 0x3004; theWrkP->element = 0x000C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseGridScalingGr]; theWrkP->group = 0x3004; theWrkP->element = 0x000E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTDoseROISequenceGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseValueGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHNormalizationPointGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHNormalizationDoseValueGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0042; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHSequenceGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHDoseScalingGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0052; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHVolumeUnitsGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0054; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHNumberofBinsGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0056; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHDataGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0058; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2-2n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHReferencedROISequenceGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHROIContributionTypeGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0062; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHMinimumDoseGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHMaximumDoseGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0072; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHMeanDoseGr]; theWrkP->group = 0x3004; theWrkP->element = 0x0074; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group3004 */ /********************************************************************************/ /* */ /* init_group3006 : initializes the elements of the group 3006 */ /* */ /********************************************************************************/ void init_group3006 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papStructureSetLabelGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStructureSetNameGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStructureSetDescriptionGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStructureSetDateGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStructureSetTimeGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFrameofReferenceSequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTReferencedStudySequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTReferencedSeriesSequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContourImageSequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStructureSetROISequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROINumberGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFrameofReferenceUIDGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0024; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROINameGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0026; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIDescriptionGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0028; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIDisplayColorGr]; theWrkP->group = 0x3006; theWrkP->element = 0x002A; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIVolumeGr]; theWrkP->group = 0x3006; theWrkP->element = 0x002C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTRelatedROISequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTROIRelationshipGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0033; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIGenerationAlgorithmGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0036; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIGenerationDescriptionGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0038; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIContourSequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0039; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContourSequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContourGeometricTypeGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0042; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContourSlabThicknessGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0044; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContourOffsetVectorGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0045; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofContourPointsGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0046; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContourNumberGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0048; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAttachedContoursGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0049; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContourDataGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3-3n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTROIObservationsSequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papObservationNumberGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0082; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedROINumberGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0084; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIObservationLabelGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0085; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTROIIdentificationCodeSequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0086; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIObservationDescriptionGr]; theWrkP->group = 0x3006; theWrkP->element = 0x0088; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRelatedRTROIObservationsSequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x00A0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTROIInterpretedTypeGr]; theWrkP->group = 0x3006; theWrkP->element = 0x00A4; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIInterpreterGr]; theWrkP->group = 0x3006; theWrkP->element = 0x00A6; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIPhysicalPropertiesSequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x00B0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIPhysicalPropertyGr]; theWrkP->group = 0x3006; theWrkP->element = 0x00B2; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIPhysicalPropertyValueGr]; theWrkP->group = 0x3006; theWrkP->element = 0x00B4; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameofReferenceRelationshipSequenceGr]; theWrkP->group = 0x3006; theWrkP->element = 0x00C0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRelatedFrameofReferenceUIDGr]; theWrkP->group = 0x3006; theWrkP->element = 0x00C2; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameofReferenceTransformationTypeGr]; theWrkP->group = 0x3006; theWrkP->element = 0x00C4; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameofReferenceTransformationMatrixGr]; theWrkP->group = 0x3006; theWrkP->element = 0x00C6; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "16"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameofReferenceTransformationCommentGr]; theWrkP->group = 0x3006; theWrkP->element = 0x00C8; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group3006 */ /********************************************************************************/ /* */ /* init_group3008 : initializes the elements of the group 3008 */ /* */ /********************************************************************************/ void init_group3008 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x3008; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMeasuredDoseReferenceSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMeasuredDoseDescriptionGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMeasuredDoseTypeGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMeasuredDoseValueGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentSessionBeamSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurrentFractionNumberGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentControlPointDateGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0024; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentControlPointTimeGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0025; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentControlTerminationStatusGr]; theWrkP->group = 0x3008; theWrkP->element = 0x002A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentControlTerminationCodeGr]; theWrkP->group = 0x3008; theWrkP->element = 0x002B; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentVerificationStatusGr]; theWrkP->group = 0x3008; theWrkP->element = 0x002C; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedTreatmentRecordSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecifiedPrimaryMetersetGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecifiedSecondaryMetersetGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0033; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeliveredPrimaryMetersetGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0036; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeliveredSecondaryMetersetGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0037; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecifiedTreatmentTimeGr]; theWrkP->group = 0x3008; theWrkP->element = 0x003A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeliveredTreatmentTimeGr]; theWrkP->group = 0x3008; theWrkP->element = 0x003B; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papControlPointDeliverySequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecifiedMetersetGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0042; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeliveredMetersetGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0044; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseRateDeliveredGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0048; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentSummaryCalculatedDoseReferenceSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCumulativeDoseToDoseReferenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0052; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFirstTreatmentDateGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0054; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMostRecentTreatmentDateGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0056; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberOfFractionsDeliveredGr]; theWrkP->group = 0x3008; theWrkP->element = 0x005A; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverrideSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverrideParameterPointerGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0062; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMeasuredDoseReferenceNumberGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0064; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverrideReasonGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0066; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCalculatedDoseReferenceSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCalculatedDoseReferenceNumberGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0072; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCalculatedDoseReferenceDescriptionGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0074; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCalculatedDoseReferenceDoseValueGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0076; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStartMetersetGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0078; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEndMetersetGr]; theWrkP->group = 0x3008; theWrkP->element = 0x007A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedMeasuredDoseReferenceSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedMeasuredDoseReferenceNumberGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0082; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedCalculatedDoseReferenceSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0090; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedCalculatedDoseReferenceNumberGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0092; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamLimitingDeviceLeafPairsSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x00A0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordedWedgeSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x00B0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordedCompensatorSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x00C0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordedBlockSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x00D0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordedSourceSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceSerialNumberGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0105; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentSessionApplicationSetupSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papApplicationSetupCheckGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0116; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordedBrachyAccessoryDeviceSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0120; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papreferencedBrachyAccessoryDeviceNumberGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0122; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordedChannelSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0130; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecifiedChannelTotalTimeGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0132; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeliveredChannelTotalTimeGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0134; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecifiedNumberOfPulsesGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0136; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeliveredNumberOfPulsesGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0138; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecifiedPulseRepetitionIntervalGr]; theWrkP->group = 0x3008; theWrkP->element = 0x013A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeliveredPulseRepetitionIntervalGr]; theWrkP->group = 0x3008; theWrkP->element = 0x013C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordedSourceApplicatorSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0140; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSourceApplicatorNumberGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0142; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecordedChannelShieldSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0150; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedCahnnelShieldNumberGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0152; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyControlPointDeliveredSequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0160; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSafePositionExitDateGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0162; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSafePositionExitTimeGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0164; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSafePositionReturnDateGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0166; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSafePositionReturnTimeGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0168; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurrentTreatmentStatusGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentStatusCommentGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0202; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFractionGropSummarySequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0220; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFractionNumberGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0223; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFractionGroupTypeGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0224; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamStopperPositionGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0230; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFractionStatusSummarySequenceGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0240; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentDateGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0250; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentTimeGr]; theWrkP->group = 0x3008; theWrkP->element = 0x0251; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group3008 */ /********************************************************************************/ /* */ /* init_group300A : initializes the elements of the group 300A */ /* */ /********************************************************************************/ void init_group300A (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x300A; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanLabelGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanNameGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0003; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanDescriptionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanDateGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanTimeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0007; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentProtocolsGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentIntentGr]; theWrkP->group = 0x300A; theWrkP->element = 0x000A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentSitesGr]; theWrkP->group = 0x300A; theWrkP->element = 0x000B; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanGeometryGr]; theWrkP->group = 0x300A; theWrkP->element = 0x000C; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrescriptionDescriptionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x000E; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseReferenceSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseReferenceNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseReferenceStructureTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNominalBeamEnergyUnitGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0015; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseReferenceDescriptionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseReferencePointCoordinatesGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0018; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNominalPriorDoseGr]; theWrkP->group = 0x300A; theWrkP->element = 0x001A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseReferenceTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConstraintWeightGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeliveryWarningDoseGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeliveryMaximumDoseGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0023; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTargetMinimumDoseGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0025; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTargetPrescriptionDoseGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0026; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTargetMaximumDoseGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0027; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTargetUnderdoseVolumeFractionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0028; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrganatRiskFullvolumeDoseGr]; theWrkP->group = 0x300A; theWrkP->element = 0x002A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrganatRiskLimitDoseGr]; theWrkP->group = 0x300A; theWrkP->element = 0x002B; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrganatRiskMaximumDoseGr]; theWrkP->group = 0x300A; theWrkP->element = 0x002C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrganatRiskOverdoseVolumeFractionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x002D; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papToleranceTableSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papToleranceTableNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0042; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papToleranceTableLabelGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0043; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGantryAngleToleranceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0044; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamLimitingDeviceAngleToleranceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0046; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamLimitingDeviceToleranceSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0048; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamLimitingDevicePositionToleranceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x004A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientSupportAngleToleranceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x004C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopEccentricAngleToleranceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x004E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopVerticalPositionToleranceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0051; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopLongitudinalPositionToleranceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0052; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopLateralPositionToleranceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0053; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanRelationshipGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0055; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFractionGroupSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFractionGroupNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0071; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofFractionsPlannedGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0078; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofFractionsPerDayGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0079; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRepeatFractionCycleLengthGr]; theWrkP->group = 0x300A; theWrkP->element = 0x007A; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFractionPatternGr]; theWrkP->group = 0x300A; theWrkP->element = 0x007B; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofBeamsGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamDoseSpecificationPointGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0082; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamDoseGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0084; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamMetersetGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0086; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofBrachyApplicationSetupsGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00A0; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyApplicationSetupDoseSpecificationPointGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00A2; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyApplicationSetupDoseGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00A4; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00B0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentMachineNameGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00B2; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrimaryDosimeterUnitGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00B3; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceAxisDistanceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00B4; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamLimitingDeviceSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00B6; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTBeamLimitingDeviceTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00B8; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourcetoBeamLimitingDeviceDistanceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00BA; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofLeafJawPairsGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00BC; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLeafPositionBoundariesGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00BE; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00C0; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamNameGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00C2; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamDescriptionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00C3; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00C4; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiationTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00C6; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighDoseTechniqueTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00C7; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferenceImageNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00C8; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPlannedVerificationImageSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00CA; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagingDeviceSpecificAcquisitionParametersGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00CC; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentDeliveryTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00CE; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofWedgesGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00D0; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWedgeSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00D1; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWedgeNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00D2; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWedgeTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00D3; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWedgeIDGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00D4; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWedgeAngleGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00D5; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWedgeFactorGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00D6; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWedgeOrientationGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00D8; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourcetoWedgeTrayDistanceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00DA; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofCompensatorsGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00E0; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaterialIDGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00E1; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTotalCompensatorTrayFactorGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00E2; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompensatorSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00E3; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompensatorNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00E4; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompensatorIDGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00E5; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourcetoCompensatorTrayDistanceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00E6; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompensatorRowsGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00E7; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompensatorColumnsGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00E8; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompensatorPixelSpacingGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00E9; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompensatorPositionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00EA; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompensatorTransmissionDataGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00EB; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompensatorThicknessDataGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00EC; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofBoliGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00ED; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompensatorTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00EE; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofBlocksGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00F0; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTotalBlockTrayFactorGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00F2; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBlockSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00F4; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBlockTrayIDGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00F5; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourcetoBlockTrayDistanceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00F6; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBlockTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00F8; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBlockDivergenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00FA; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBlockNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00FC; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBlockNameGr]; theWrkP->group = 0x300A; theWrkP->element = 0x00FE; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBlockThicknessGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBlockTransmissionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBlockNumberofPointsGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0104; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBlockDataGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0106; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2-2n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papApplicatorSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0107; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papApplicatorIDGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0108; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papApplicatorTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0109; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papApplicatorDescriptionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x010A; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCumulativeDoseReferenceCoefficientGr]; theWrkP->group = 0x300A; theWrkP->element = 0x010C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFinalCumulativeMetersetWeightGr]; theWrkP->group = 0x300A; theWrkP->element = 0x010E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofControlPointsGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papControlPointSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0111; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papControlPointIndexGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0112; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNominalBeamEnergyGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0114; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseRateSetGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0115; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWedgePositionSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0116; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWedgePositionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0118; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamLimitingDevicePositionSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x011A; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLeafJawPositionsGr]; theWrkP->group = 0x300A; theWrkP->element = 0x011C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2-2n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGantryAngleGr]; theWrkP->group = 0x300A; theWrkP->element = 0x011E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGantryRotationDirectionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x011F; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamLimitingDeviceAngleGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0120; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamLimitingDeviceRotationDirectionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0121; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientSupportAngleGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0122; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientSupportRotationDirectionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0123; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopEccentricAxisDistanceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0124; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopEccentricAngleGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0125; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopEccentricRotationDirectionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0126; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopVerticalPositionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0128; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopLongitudinalPositionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0129; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopLateralPositionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x012A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIsocenterPositionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x012C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSurfaceEntryPointGr]; theWrkP->group = 0x300A; theWrkP->element = 0x012E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourcetoSurfaceDistanceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0130; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCumulativeMetersetWeightGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0134; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientSetupSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0180; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientSetupNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0182; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientAdditionalPositionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0184; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFixationDeviceSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0190; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFixationDeviceTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0192; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFixationDeviceLabelGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0194; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFixationDeviceDescriptionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0196; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFixationDevicePositionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0198; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShieldingDeviceSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01A0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShieldingDeviceTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01A2; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShieldingDeviceLabelGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01A4; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShieldingDeviceDescriptionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01A6; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShieldingDevicePositionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01A8; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSetupTechniqueGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01B0; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSetupTechniqueDescriptionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01B2; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSetupDeviceSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01B4; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSetupDeviceTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01B6; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSetupDeviceLabelGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01B8; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSetupDeviceDescriptionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01BA; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSetupDeviceParameterGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01BC; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSetupReferenceDescriptionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01D0; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopVerticalSetupDisplacementGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01D2; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopLongitudinalSetupDisplacementGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01D4; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopLateralSetupDisplacementGr]; theWrkP->group = 0x300A; theWrkP->element = 0x01D6; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyTreatmentTechniqueGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyTreatmentTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0202; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentMachineSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0206; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0210; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0212; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0214; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceManufacturerGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0216; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papActiveSourceDiameterGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0218; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papActiveSourceLengthGr]; theWrkP->group = 0x300A; theWrkP->element = 0x021A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceEncapsulationNominalThicknessGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0222; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceEncapsulationNominalTransmissionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0224; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceIsotopeNameGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0226; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceIsotopeHalfLifeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0228; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferenceAirKermaRateGr]; theWrkP->group = 0x300A; theWrkP->element = 0x022A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAirKermaRateReferenceDateGr]; theWrkP->group = 0x300A; theWrkP->element = 0x022C; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAirKermaRateReferenceTimeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x022E; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papApplicationSetupSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0230; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papApplicationSetupTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0232; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papApplicationSetupNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0234; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papApplicationSetupNameGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0236; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papApplicationSetupManufacturerGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0238; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTemplateNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0240; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTemplateTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0242; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTemplateNameGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0244; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTotalReferenceAirKermaGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0250; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyAccessoryDeviceSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0260; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyAccessoryDeviceNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0262; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyAccessoryDeviceIDGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0263; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyAccessoryDeviceTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0264; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyAccessoryDeviceNameGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0266; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyAccessoryDeviceNominalThicknessGr]; theWrkP->group = 0x300A; theWrkP->element = 0x026A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyAccessoryDeviceNominalTransmissionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x026C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0280; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0282; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelLengthGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0284; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelTotalTimeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0286; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceMovementTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0288; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofPulsesGr]; theWrkP->group = 0x300A; theWrkP->element = 0x028A; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPulseRepetitionIntervalGr]; theWrkP->group = 0x300A; theWrkP->element = 0x028C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceApplicatorNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0290; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceApplicatorIDGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0291; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceApplicatorTypeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0292; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceApplicatorNameGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0294; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceApplicatorLengthGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0296; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceApplicatorManufacturerGr]; theWrkP->group = 0x300A; theWrkP->element = 0x0298; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceApplicatorWallNominalThicknessGr]; theWrkP->group = 0x300A; theWrkP->element = 0x029C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceApplicatorWallNominalTransmissionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x029E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceApplicatorStepSizeGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02A0; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransferTubeNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02A2; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransferTubeLengthGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02A4; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelShieldSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02B0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelShieldNumberGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02B2; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelShieldIDGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02B3; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelShieldNameGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02B4; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelShieldNominalThicknessGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02B8; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelShieldNominalTransmissionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02BA; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFinalCumulativeTimeWeightGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02C8; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyControlPointSequenceGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02D0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papControlPointRelativePositionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02D2; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papControlPoint3DPositionGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02D4; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCumulativeTimeWeightGr]; theWrkP->group = 0x300A; theWrkP->element = 0x02D6; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group300A */ /********************************************************************************/ /* */ /* init_group300C : initializes the elements of the group 300C */ /* */ /********************************************************************************/ void init_group300C (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedRTPlanSequenceGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedBeamSequenceGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedBeamNumberGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedReferenceImageNumberGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0007; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStartCumulativeMetersetWeightGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEndCumulativeMetersetWeightGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedBrachyApplicationSetupSequenceGr]; theWrkP->group = 0x300C; theWrkP->element = 0x000A; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedBrachyApplicationSetupNumberGr]; theWrkP->group = 0x300C; theWrkP->element = 0x000C; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSourceNumberGr]; theWrkP->group = 0x300C; theWrkP->element = 0x000E; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFractionGroupSequenceGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFractionGroupNumberGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedVerificationImageSequenceGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedReferenceImageSequenceGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0042; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedDoseReferenceSequenceGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedDoseReferenceNumberGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0051; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyReferencedDoseReferenceSequenceGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0055; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedStructureSetSequenceGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedPatientSetupNumberGr]; theWrkP->group = 0x300C; theWrkP->element = 0x006A; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedDoseSequenceGr]; theWrkP->group = 0x300C; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedToleranceTableNumberGr]; theWrkP->group = 0x300C; theWrkP->element = 0x00A0; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedBolusSequenceGr]; theWrkP->group = 0x300C; theWrkP->element = 0x00B0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedWedgeNumberGr]; theWrkP->group = 0x300C; theWrkP->element = 0x00C0; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedCompensatorNumberGr]; theWrkP->group = 0x300C; theWrkP->element = 0x00D0; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedBlockNumberGr]; theWrkP->group = 0x300C; theWrkP->element = 0x00E0; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedControlPointIndexGr]; theWrkP->group = 0x300C; theWrkP->element = 0x00F0; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group300C */ /********************************************************************************/ /* */ /* init_group300E : initializes the elements of the group 300E */ /* */ /********************************************************************************/ void init_group300E (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papApprovalStatusGr]; theWrkP->group = 0x300E; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReviewDateGr]; theWrkP->group = 0x300E; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReviewTimeGr]; theWrkP->group = 0x300E; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReviewerNameGr]; theWrkP->group = 0x300E; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group300E */ /********************************************************************************/ /* */ /* init_group4000 : initializes the elements of the group 4000 */ /* */ /********************************************************************************/ void init_group4000 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x4000; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = RET; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papArbitraryGr]; theWrkP->group = 0x4000; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = RET; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCommentsGr]; theWrkP->group = 0x4000; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = RET; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group4000 */ /********************************************************************************/ /* */ /* init_group4008 : initializes the elements of the group 4008 */ /* */ /********************************************************************************/ void init_group4008 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x4008; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papResultsIDGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papResultsIDIssuerGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0042; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedInterpretationSequenceGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationRecordedDateGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationRecordedTimeGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationRecorderGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencetoRecordedSoundGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationTranscriptionDateGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0108; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationTranscriptionTimeGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0109; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationTranscriberGr]; theWrkP->group = 0x4008; theWrkP->element = 0x010A; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationTextGr]; theWrkP->group = 0x4008; theWrkP->element = 0x010B; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationAuthorGr]; theWrkP->group = 0x4008; theWrkP->element = 0x010C; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationApproverSequenceGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0111; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationApprovalDateGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0112; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationApprovalTimeGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0113; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhysicianApprovingInterpretationGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0114; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationDiagnosisDescriptionGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0115; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDiagnosisCodeSequenceGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0117; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papResultsDistributionListSequenceGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0118; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistributionNameGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0119; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistributionAddressGr]; theWrkP->group = 0x4008; theWrkP->element = 0x011A; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationIDGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationIDIssuerGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0202; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationTypeIDGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0210; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationStatusIDGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0212; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImpressionsGr]; theWrkP->group = 0x4008; theWrkP->element = 0x0300; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papResultsCommentsGr]; theWrkP->group = 0x4008; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group4008 */ /********************************************************************************/ /* */ /* init_group5000 : initializes the elements of the group 5000 */ /* */ /********************************************************************************/ void init_group5000 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x5000; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveDimensionsGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofPointsGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTypeofDataGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveDescriptionGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAxisUnitsGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAxisLabelsGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDataValueRepresentationGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMinimumCoordinateValueGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0104; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaximumCoordinateValueGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0105; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveRangeGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0106; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveDataDescriptorGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCoordinateStartValueGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0112; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCoordinateStepValueGr]; theWrkP->group = 0x5000; theWrkP->element = 0x0114; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveActivationLayerGr]; theWrkP->group = 0x5000; theWrkP->element = 0x1001; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAudioTypeGr]; theWrkP->group = 0x5000; theWrkP->element = 0x2000; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAudioSampleFormatGr]; theWrkP->group = 0x5000; theWrkP->element = 0x2002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofChannelsGr]; theWrkP->group = 0x5000; theWrkP->element = 0x2004; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofSamplesGr]; theWrkP->group = 0x5000; theWrkP->element = 0x2006; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSampleRateGr]; theWrkP->group = 0x5000; theWrkP->element = 0x2008; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTotalTimeGr]; theWrkP->group = 0x5000; theWrkP->element = 0x200A; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAudioSampleDataGr]; theWrkP->group = 0x5000; theWrkP->element = 0x200C; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAudioCommentsGr]; theWrkP->group = 0x5000; theWrkP->element = 0x200E; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveLabelGr]; theWrkP->group = 0x5000; theWrkP->element = 0x2500; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedOverlaySequence5000Gr]; theWrkP->group = 0x5000; theWrkP->element = 0x2600; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedOverlayGroupGr]; theWrkP->group = 0x5000; theWrkP->element = 0x2610; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveDataGr]; theWrkP->group = 0x5000; theWrkP->element = 0x3000; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group5000 */ /********************************************************************************/ /* */ /* init_group5400 : initializes the elements of the group 5400 */ /* */ /********************************************************************************/ void init_group5400 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x5400; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWaveformSequenceGr]; theWrkP->group = 0x5400; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelMinimumValueGr]; theWrkP->group = 0x5400; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = OB; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papChannelMaximumValueGr]; theWrkP->group = 0x5400; theWrkP->element = 0x0112; theWrkP->length = 0L; theWrkP->vr = OB; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWaveformBitsAllocatedGr]; theWrkP->group = 0x5400; theWrkP->element = 0x1004; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWaveformSampleInterpretationGr]; theWrkP->group = 0x5400; theWrkP->element = 0x1006; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWaveformPaddingValueGr]; theWrkP->group = 0x5400; theWrkP->element = 0x100A; theWrkP->length = 0L; theWrkP->vr = OB; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWaveformDataGr]; theWrkP->group = 0x5400; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = OB; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group5400 */ /********************************************************************************/ /* */ /* init_group6000 : initializes the elements of the group 6000 */ /* */ /********************************************************************************/ void init_group6000 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x6000; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayRows6000Gr]; theWrkP->group = 0x6000; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayColumns6000Gr]; theWrkP->group = 0x6000; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayPlanesGr]; theWrkP->group = 0x6000; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofFramesinOverlayGr]; theWrkP->group = 0x6000; theWrkP->element = 0x0015; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDescriptionGr]; theWrkP->group = 0x6000; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayTypeGr]; theWrkP->group = 0x6000; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaySubtypeGr]; theWrkP->group = 0x6000; theWrkP->element = 0x0045; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOriginGr]; theWrkP->group = 0x6000; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageFrameOriginGr]; theWrkP->group = 0x6000; theWrkP->element = 0x0051; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayPlaneOriginGr]; theWrkP->group = 0x6000; theWrkP->element = 0x0052; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompressionCode6000Gr]; theWrkP->group = 0x6000; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayBitsAllocatedGr]; theWrkP->group = 0x6000; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitPositionGr]; theWrkP->group = 0x6000; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayFormatGr]; theWrkP->group = 0x6000; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayLocationGr]; theWrkP->group = 0x6000; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayActivationLayerGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1001; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDescriptorGrayGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDescriptorRedGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDescriptorGreenGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDescriptorBlueGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaysGrayGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1200; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaysRedGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1201; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaysGreenGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1202; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaysBlueGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1203; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIAreaGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1301; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIMeanGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1302; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIStandardDeviationGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1303; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayLabelGr]; theWrkP->group = 0x6000; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDataGr]; theWrkP->group = 0x6000; theWrkP->element = 0x3000; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papComments6000Gr]; theWrkP->group = 0x6000; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group6000 */ /******************************************************************************/ /* */ /* init_uinoverlay : initializes the elements of the group 6XXX (odd) */ /* */ /******************************************************************************/ void init_uinoverlay (SElement ioElem []) { SElement *theWrkP; /* group 6XXX (odd) */ theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x6001; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOwnerIDGr]; theWrkP->group = 0x6001; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 1; theWrkP->value = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); theWrkP->value->a = (char *) ecalloc3 ((PapyULong) 12, (PapyULong) sizeof (char)); strcpy (theWrkP->value->a, "PAPYRUS 3.0"); theWrkP = &ioElem [papOverlayIdGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLinkedOverlaysGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1001; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1-n"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayRowsGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayColumnsGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1011; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papUINOverlayTypeGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayOriginGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEditableGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1060; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayFontGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1070; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayStyleGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1072; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayFontSizeGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1074; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayColorGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1076; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShadowSizeGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1078; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFillPatternGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1080; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayPenSizeGr]; theWrkP->group = 0x6001; theWrkP->element = 0x1082; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLabelGr]; theWrkP->group = 0x6001; theWrkP->element = 0x10A0; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPostItTextGr]; theWrkP->group = 0x6001; theWrkP->element = 0x10A2; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnchorPointGr]; theWrkP->group = 0x6001; theWrkP->element = 0x10A4; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRoiTypeGr]; theWrkP->group = 0x6001; theWrkP->element = 0x10B0; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAttachedAnnotationGr]; theWrkP->group = 0x6001; theWrkP->element = 0x10B2; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInfoIntGr]; theWrkP->group = 0x6001; theWrkP->element = 0x10B3; theWrkP->length = 0L; theWrkP->vr = SL; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInfoFloatGr]; theWrkP->group = 0x6001; theWrkP->element = 0x10B4; theWrkP->length = 0L; theWrkP->vr = FL; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContourPointsGr]; theWrkP->group = 0x6001; theWrkP->element = 0x10BA; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaskDataGr]; theWrkP->group = 0x6001; theWrkP->element = 0x10BC; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papUINOverlaySequenceGr]; theWrkP->group = 0x6001; theWrkP->element = 0x10C0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_uinoverlay */ /********************************************************************************/ /* */ /* init_group7FE0 : initializes the elements of the group 7FE0 */ /* */ /********************************************************************************/ void init_group7FE0 (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGroupLength]; theWrkP->group = 0x7FE0; theWrkP->element = 0x0000; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelDataGr]; theWrkP->group = 0x7FE0; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_group7FE0 */ Papyrus3/PapyList3.c0000755000175000017500000003750510044203124011523 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyList3.c */ /* Function : Generic list handler for handling the list of modules, */ /* objects and sequences in Papyrus 3 */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifdef Mac #pragma segment papy3 #endif /* ------------------------- includes ---------------------------------------*/ #include #include #ifndef Papyrus3H #include "Papyrus3.h" #endif /********************************************************************************/ /* */ /* InsertFirstInList : Create a new Item at the first place in the list */ /* and insert the given Object in it. */ /* return : The created cell if OK, NULL otherwise */ /* */ /********************************************************************************/ Papy_List * InsertFirstInList (Papy_List **ioListP, Object *inElemToInsertP) { Papy_List *theNewCellP; /* create the new cell and put the Object in */ if ((theNewCellP = (Papy_List *) emalloc3 ((PapyULong) sizeof (Papy_List))) == NULL) return NULL; theNewCellP->object = inElemToInsertP; theNewCellP->next = (*ioListP); /* change the head pointer */ *ioListP = theNewCellP; return theNewCellP; } /* endof InsertFirstInList */ /********************************************************************************/ /* */ /* InsertLastInList : Create a new Item at the last place in the list */ /* and insert the given Object in it. */ /* return : The created cell if OK, NULL otherwise */ /* */ /********************************************************************************/ Papy_List * InsertLastInList (Papy_List **ioListP, Object *inElemToInsertP) { Papy_List *theWrkP, *theNewCellP; /* create the new cell and put the Object in */ if ((theNewCellP = (Papy_List *) emalloc3 ((PapyULong) sizeof (Papy_List))) == NULL) return NULL; theNewCellP->object = inElemToInsertP; theNewCellP->next = NULL; /* if the ioListP is empty */ if (*ioListP == NULL) *ioListP = theNewCellP; else { /* look for the last cell */ theWrkP = *ioListP; while (theWrkP->next != NULL) theWrkP = theWrkP->next; /* insert the new element */ theWrkP->next = theNewCellP; } /* else */ return theNewCellP; } /* endof InsertLastInList */ /********************************************************************************/ /* */ /* InsertInListAt : Create a new Item after the specified cell in the list */ /* and insert the given Object in it. */ /* return : The created cell if OK, NULL otherwise */ /* */ /********************************************************************************/ Papy_List * InsertInListAt (Papy_List **ioListP, Object *inElemToInsertP, PapyShort inPos) { Papy_List *theWrkP, *theNewCellP; PapyShort i; /* create the new cell and put the Object in */ if ((theNewCellP = (Papy_List *) emalloc3 ((PapyULong) sizeof (Papy_List))) == NULL) return NULL; theNewCellP->object = inElemToInsertP; theNewCellP->next = NULL; /* if the ioListP is empty */ if (*ioListP == NULL || inPos == 0) { theNewCellP->next = NULL; *ioListP = theNewCellP; } else { /* look for the insertion point */ theWrkP = *ioListP; for (i = 1; i < inPos; i++) { if (theWrkP == NULL) return NULL; theWrkP = theWrkP->next; } /* for */ /* insert the new element */ theNewCellP->next = theWrkP->next; theWrkP->next = theNewCellP; } /* else */ return theNewCellP; } /* endof InsertInListAt */ /********************************************************************************/ /* */ /* InsertGroupInList : Create a new Item containing a group. The insertion */ /* criteria is that the group numbers are increasing. */ /* return : The created cell if OK, NULL otherwise */ /* */ /********************************************************************************/ Papy_List * InsertGroupInList (Papy_List **ioListP, Object *inElemToInsertP) { Papy_List *theWrk1P, *theWrk2P, *theNewCellP; /* verify it is a group */ if (inElemToInsertP->whoAmI != papGroup) return NULL; /* create the new cell and put the Object in */ if ((theNewCellP = (Papy_List *) emalloc3 ((PapyULong) sizeof (Papy_List))) == NULL) return NULL; theNewCellP->object = inElemToInsertP; theNewCellP->next = NULL; /* if the ioListP is empty */ if ((*ioListP == NULL) || ((*ioListP)->object->group->group > theNewCellP->object->group->group)) { theNewCellP->next = *ioListP; *ioListP = theNewCellP; } else { /* look for the insertion point, i.e. compares the group numbers */ theWrk1P = *ioListP; theWrk2P = *ioListP; while ((theWrk1P != NULL) && (theWrk1P->object->group->group < theNewCellP->object->group->group)) { theWrk2P = theWrk1P; theWrk1P = theWrk1P->next; } /* while */ /* insert the new element */ theNewCellP->next = theWrk1P; theWrk2P->next = theNewCellP; } /* else */ return theNewCellP; } /* endof InsertGroupInList */ /********************************************************************************/ /* */ /* FreeCell : Deletes the given item as well as its content. Deletes the */ /* content selectively depending on the values of the parameters.This */ /* allows to reuse the modules, the groups and the sequences in multiple */ /* data sets. */ /* return : papNoError if OK, standard error message otherwise. */ /* */ /********************************************************************************/ PapyShort FreeCell (PapyShort inFileNb, Papy_List **ioToFreeP, int inDelAll, int inDelGroup, int inDelSeq) { PapyShort theErr = 0; /* free the content of the cell if the toDel parameter is set to TRUE */ if (inDelAll) switch ((*ioToFreeP)->object->whoAmI) { case papItem : DeleteList (inFileNb, (Papy_List **) &((*ioToFreeP)->object->item), inDelAll, inDelGroup, inDelSeq); break; case papModule : theErr = Papy3ModuleFree (&((*ioToFreeP)->object->module), (*ioToFreeP)->object->objID, inDelSeq); if (theErr < 0) RETURN (theErr); break; case papRecord : theErr = Papy3RecordFree (&((*ioToFreeP)->object->record), (*ioToFreeP)->object->objID, inDelSeq); if (theErr < 0) RETURN (theErr); break; case papGroup : if (inDelGroup) if ((theErr = Papy3GroupFree (&((*ioToFreeP)->object->group), inDelSeq)) < 0) RETURN (theErr); break; case papTmpFile : { char *tmpFilename, myStr [32]; /* build the name of the temp file containing the data set */ /* it will look like <> */ tmpFilename = (char *) ecalloc3 ((PapyULong) 256, (PapyULong) sizeof (char)); strcpy (tmpFilename, gPapFilename [inFileNb]); Papy3FPrint (myStr, "%d", (*ioToFreeP)->object->objID); strcat (myStr, ".dcm"); strcat (myStr, "\0"); if ((*ioToFreeP)->object->objID < 10) strcat (tmpFilename, "000"); else if ((*ioToFreeP)->object->objID < 100) strcat (tmpFilename, "00"); else if ((*ioToFreeP)->object->objID < 1000) strcat (tmpFilename, "0"); strcat (tmpFilename, myStr); /* delete the tmp file only if the result is a PAPYRUS file */ if (gIsPapyFile [inFileNb] == PAPYRUS3) { if ((theErr = Papy3FDelete (tmpFilename, (*ioToFreeP)->object->file)) != 0) RETURN (papDeleteFile); } /* if ...PAPYRUS file */ efree3 ((void **) &tmpFilename); if ((*ioToFreeP)->object->file != NULL) efree3 ((void **) &((*ioToFreeP)->object->file)); } break; default : break; } /* switch ...type of the content of the object */ /* make all the pointers of the object point to NULL */ (*ioToFreeP)->object->item = NULL; (*ioToFreeP)->object->module = NULL; (*ioToFreeP)->object->group = NULL; (*ioToFreeP)->object->tmpFileLength = 0L; /* free the cell */ efree3 ((void **) &((*ioToFreeP)->object)); efree3 ((void **) ioToFreeP); RETURN (theErr); } /* endof FreeCell */ /********************************************************************************/ /* */ /* DeleteFirstInList : Deletes the first element of the list. */ /* return : papNoError if OK, listError in case of an error. */ /* */ /********************************************************************************/ PapyShort DeleteFirstInList (PapyShort inFileNb, Papy_List **ioListP, int inDelAll, int inDelGroup, int inDelSeq) { Papy_List *theWrkP; PapyShort theErr = 0; if (*ioListP == NULL) return theErr; /* change the head pointer */ theWrkP = *ioListP; *ioListP = (*ioListP)->next; /* free the cell and its content */ theErr = FreeCell (inFileNb, &theWrkP, inDelAll, inDelGroup, inDelSeq); RETURN (theErr); } /* endof DeleteFirstInList */ /********************************************************************************/ /* */ /* DeleteLastInList : Deletes the last element of the list. */ /* return : papNoError if OK, listError in case of an error. */ /* */ /********************************************************************************/ PapyShort DeleteLastInList (PapyShort inFileNb, Papy_List **ioListP, int inDelAll, int inDelGroup, int inDelSeq) { Papy_List *theWrk1P, *theWrk2P; PapyShort theErr = 0; if (*ioListP == NULL) return theErr; /* search the last cell of the list */ theWrk1P = *ioListP; theWrk2P = NULL; while (theWrk1P->next != NULL) { theWrk2P = theWrk1P; theWrk1P = theWrk1P->next; } /* while */ if (theWrk2P != NULL) theWrk2P->next = NULL; else *ioListP = NULL; /* free the cell and its content */ theErr = FreeCell (inFileNb, &theWrk1P, inDelAll, inDelGroup, inDelSeq); RETURN (theErr); } /* endof DeleteLastInList */ /********************************************************************************/ /* */ /* DeleteList : Deletes the list as well as its elements. Begins by the */ /* first element and loop to the end of the list. */ /* return : papNoError if OK, listError in case of an error. */ /* */ /********************************************************************************/ PapyShort DeleteList (PapyShort inFileNb, Papy_List **ioListP, int inDelAll, int inDelGroup, int inDelSeq) { Papy_List *toFree, *theWrkP; PapyShort theErr = 0; if (*ioListP == NULL) return theErr; /* loop on the elements of the list and frees them begining by the first one */ toFree = *ioListP; while (toFree != NULL) { theWrkP = toFree->next; /* free the cell and its content */ if ((theErr = FreeCell (inFileNb, &toFree, inDelAll, inDelGroup, inDelSeq)) < 0) RETURN (theErr); toFree = theWrkP; } /* while ...loop on the elements of the list */ *ioListP = NULL; RETURN (theErr); } /* endof DeleteList */ Papyrus3/PapyError3.c0000755000175000017500000002433410044205604011702 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyError3.c */ /* Function : error management */ /* Authors : Jean-Francois Vurlod */ /* Christian Girard */ /* Marianne Logean */ /* */ /* History : 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #include #ifndef FILENAME83 /* this is for the normal machines ... */ #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif #ifndef PapyError3H #include "PapyError3.h" #endif #else /* FILENAME83 defined for the DOS machines */ #ifndef PapyTypeDef3H #include "PAPYDEF3.h" #endif #ifndef PapyError3H #include "PAPERR3.h" #endif #endif /* FILENAME83 defined */ #define kMax_Error_Level 10 static char sERRMSG[] = "Error detected in library Papyrus 3"; static int sExitWhenError = TRUE; static int sCrtErrLevel = -1; EPapyError3 gPapyErrNo = papNoError; EPapyError3 gFirstError = papNoError; int gPapyErrLigne [kMax_Error_Level]; char *gPapyErrFileP [kMax_Error_Level]; /* enumeration of the error messages */ char *PapyErrorList [] = { /* 0 */"No error", /* -1 */"See the error # in the var gPapyErrNo", /* -2 */"Not implemented", /* -3 */"Standard C library error", /* -4 */"Not enough memory", /* -5 */"UID unknow", /* -6 */"Read group failed", /* -7 */"Write group failed", /* -8 */"Overlay is not in the interval [0x6000,0x601E]", /* -9 */"UINOverlay is not in the interval [0x6001,0x6FFF]", /*-10 */"All element of type 1 must be filled", /*-11 */"Missing a group 0x0008", /*-12 */"Image file name not defined", /*-13 */"The length of the string is not even", /*-14 */"Internal problem in Value", /*-15 */"Internal problem in Ascii", /*-16 */"Internal problem in Def", /*-17 */"You want to write too many images", /*-18 */"Enum group", /*-19 */"Array index is greater than the size of the array", /*-20 */"Create a papyrus file with 0 image", /*-21 */"The maximum number of open file as been reached", /*-22 */"The file already exist", /*-23 */"File creation failed", /*-24 */"Opening file in read only mode failed", /*-25 */"Reserved 25", /*-26 */"Reserved 26", /*-27 */"Reserved 27", /*-28 */"Reserved 28", /*-29 */"Not found", /*-30 */"Open file", /*-31 */"Close file", /*-32 */"Reading data in the file failed", /*-33 */"Write file", /*-34 */"The filename is not correct", /*-35 */"Positioning pointer in the file failed", /*-36 */"Wrong element number", /*-37 */"Wrong element size", /*-38 */"Group error", /*-39 */"Group number", /*-40 */"Bad argument", /*-41 */"Error in list", /*-42 */"This transfert syntax is not implemented", /*-43 */"This compression algorithm is not yet implemented ", /*-44 */"Unknown imaging modality", /*-45 */"Mandatory module missing", /*-46 */"Not a Papyrus file", /*-47 */"Deleting file failed", /*-48 */"A wrong value has been found in the file", /*-49 */"The version of this file is newer than the version of the PAPYRUS toolkit" }; static char *sPapyErrorDecoP = "=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n"; /******************************************************************************/ /* */ /* PapyPrintErrMsg3 : this function prints the error messages to the */ /* standard error device */ /* return : / */ /* */ /******************************************************************************/ void PapyPrintErrMsg3 (char *inFileP, PapyShort inLine) { #ifndef DLL PapyShort i, theMax, theNb = 0; fprintf (stderr, sPapyErrorDecoP); if (sCrtErrLevel >= 0) { fprintf (stderr, "%s\n", sERRMSG); fprintf (stderr, "File : %s\nLine : %d\n", inFileP, inLine); if (sCrtErrLevel >= kMax_Error_Level) { fprintf (stderr, "... .. .\n"); theMax = kMax_Error_Level - 1; } else theMax = sCrtErrLevel; for (i = theMax; i >= 0; i--) { static char StrEmpty [] = ""; theNb += 2; fprintf(stderr,"%*sFile : %s\n%*sLine : %d\n", theNb, StrEmpty, gPapyErrFileP [i], theNb, StrEmpty, gPapyErrLigne [i]); } /* for */ if ((gPapyErrNo > papLastErrorNb) && (gPapyErrNo <= 0)) fprintf (stderr, "\nError : %s\n", PapyErrorList [-gPapyErrNo]); else fprintf (stderr, "\nError : %d\n", gPapyErrNo); } /* if ...sCrtErrLevel >= 0 */ else fprintf (stderr, "No e%s\n", &sERRMSG [1]); fprintf (stderr, sPapyErrorDecoP); #endif } /* endof PapyPrintErrMsg3 */ /******************************************************************************/ /* */ /* PAPY3PRINTERRMSG : this function interfaces the error messages for */ /* Papy3PrintErrMsg */ /* return : / */ /* */ /******************************************************************************/ void CALLINGCONV PAPY3PRINTERRMSG () { #if qDebug PapyPrintErrMsg3 (__FILE__, __LINE__); #endif } /******************************************************************************/ /* */ /* Papy3CheckError : this function checks in which file and in which line */ /* the given error has occurred */ /* return : / */ /* */ /******************************************************************************/ void Papy3CheckError (int inCodeErr, char *inFileP, int inLine) { if (inCodeErr > 0) { sCrtErrLevel = -1; return; } gPapyErrNo = (EPapyError3) inCodeErr; if (gPapyErrNo) { sCrtErrLevel++; if (sCrtErrLevel < kMax_Error_Level) { if (!sCrtErrLevel) gFirstError = gPapyErrNo; gPapyErrLigne [sCrtErrLevel] = inLine; gPapyErrFileP [sCrtErrLevel] = inFileP; } } else sCrtErrLevel = -1; } /* endof Papy3CheckError */ Papyrus3/PapyTypeDef3.h0000755000175000017500000002560410044200232012147 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyTypeDef3.h */ /* Function : contains the declarations of the constants, the enumerated */ /* types, the structures and the type definition for the */ /* PAPYRUS toolkit. */ /* Authors : Christian Girard */ /* */ /* History : 03.1996 version 3.3 */ /* 01.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef PapyTypeDef3H #define PapyTypeDef3H #include /* BEWARE : Mac must be defined only if we are on a Mac architecture. */ #ifndef unix #ifndef hpux #ifndef __alpha #ifndef _WINDOWS #ifndef Mac #define Mac #endif #endif #endif #endif #endif #ifdef DLL #ifdef WIN32 #define EXPORT #define EXPORT32 __declspec (dllexport ) #define CALLINGCONV #else /* WIN32 not defined */ #define EXPORT _export _far _pascal #define EXPORT32 #define CALLINGCONV _far _pascal #endif /* WIN32 */ #else /* DLL not defined */ #define EXPORT #define EXPORT32 #define CALLINGCONV #endif /* DLL */ /* --- constants needed by the file managers --- */ #ifndef SEEK_END #define SEEK_END 2 #endif #ifndef SEEK_CUR #define SEEK_CUR 1 #endif #ifndef SEEK_SET #define SEEK_SET 0 #endif #ifdef unix #define NULLFILE NULL #else #define NULLFILE -1 #endif /* --- boolean definitions --- */ #ifndef TRUE #define TRUE 1 #endif #ifndef FALSE #define FALSE 0 #endif /* --- Constant definitions --- */ #ifndef _WINDOWS #define kMax_file_open 100 #else #define kMax_file_open 20 /* Limitation on the PCs to 20 open files... */ #endif #define kMax_tmp_file 10000 #define kLength_length 12 #define kMax_overlay 0x601E /* overlay groups are from 0x6000 to 0x601E (even) */ #define kMax_UIN_overlay 0x6FFF /* UINOverlays are from 0x6001 to 0x6FFF (odd) */ /* --- basic types definitions --- */ /* will ensure cross-plateform interoperability */ typedef unsigned char PapyUChar; /* 8 bits unsigned char */ typedef char PapyChar; /* 8 bits signed char */ typedef short PapyShort; /* 16 bits short int */ typedef unsigned short PapyUShort; /* 16 bits unsigned short int */ #ifdef __alpha typedef int PapyLong; /* 32 bits long int */ typedef unsigned int PapyULong; /* 32 bits unsigned long int */ #else typedef long PapyLong; /* 32 bits long int */ typedef unsigned long PapyULong; /* 32 bits unsigned long int */ #endif typedef float PapyFloat; /* 32 bits float */ typedef double PapyFloatDouble; /* 64 bits float double */ #ifdef Mac typedef PapyShort PAPY_FILE; /* the pointer to a PAPYRUS file */ #else #ifdef _WINDOWS typedef int PAPY_FILE; /* Windows file handle */ #else /* unix */ typedef FILE * PAPY_FILE; /* ANSI FILE pointer */ #endif /* _WINDOWS */ #endif /* Mac */ /* --- Enumerated types --- */ /* Definition of the DICOM transfert syntaxes */ enum ETransf_Syntax {LITTLE_ENDIAN_IMPL, LITTLE_ENDIAN_EXPL, BIG_ENDIAN_EXPL}; /* The type of the file */ enum EFile_Type {DICOM10, PAPYRUS3, DICOM_NOT10, DICOMDIR, PAPYRUS2, other}; /* Definition of the different compression used */ enum EPap_Compression {NONE, JPEG_LOSSLESS, JPEG_LOSSY, RLE, MAYO_WAVELET}; /* Definition of the photometric interpretation */ enum EPhoto_Interpret {MONOCHROME1, MONOCHROME2, PALETTE, RGB, HSV, ARGB, CMYK, YBR_FULL, YBR_FULL_422, YBR_PARTIAL_422}; enum EDataSet_Image {DataSetID, ImageID}; /* enumeration of the different imaging modalities */ enum EModality {CR_IM, CT_IM, MR_IM, NM_IM, US_IM, US_MF_IM, SEC_CAPT_IM, DX_IM, MG_IM, IO_IM, PX_IM, RF_IM, PET_IM, VLE_IM, VLM_IM, VLS_IM, VLP_IM, MFSBSC_IM, MFGBSC_IM, MFGWSC_IM, MFTCSC_IM, END_MODALITY}; /* is the module mandatory, conditional or user optional for a given modality ? */ enum EUsage {M, C, U}; /* the different value representation defined in DICOM */ enum EV_R_T {AE, AS, AT, CS, DA, DS, DT, FL, FD, IS, LO, LT, OB, OW, PN, SH, SL, SQ, SS, ST, TM, UI, UL, UN, USS, UT, RET}; /* the DICOM defined types for the elements */ enum EType_T {T1, T1C, T2, T2C, T3}; /* what kind of Object is it ? */ enum EKind_Obj {papItem, papModule, papGroup, papTmpFile, papRecord}; /* enum needed by UINOverlays */ enum E_ROI {RECTANGLE, ANNOTATION, GRAPHIC}; enum E_Font {TIMES, HELVETICA}; enum E_Style {NORMAL, BOLD, ITALIC, BOLDITALIC}; enum E_Color {WHITE, BLACK, RED, GREEN, BLUE, CYAN, MAGENTA, YELLOW}; /* Not used in the toolkit: enum E_Editable {EDIT, FIXED}; enum E_Opacity {NONE, OPAQUE, TRANSPARENT}; enum E_Shape {MASK, RECT, ELLIPSE, POLY}; was FOR */ /* --- Structures and type definitions --- */ struct SPapy_List_; typedef union UValue_T_ { PapyShort ss; /* SS */ PapyUShort us; /* US, AT */ PapyUShort * ow; /* OW */ PapyLong sl; /* SL */ PapyULong ul; /* UL */ PapyFloat fl; /* FL */ PapyFloatDouble fd; /* FD */ char * a; /* AE, AS, CS, DA, DS, DT, IS, LO, LT, OB, PN, SH, ST, TM, UI, UN, UT */ struct SPapy_List_ *sq; /* SQ */ } UValue_T; typedef struct SElement_ /* structure of an element */ { PapyUShort group; PapyUShort element; PapyULong length; enum EV_R_T vr; /* Value Representation */ char *vm; /* Value Multiplicity */ enum EType_T type_t; /* EType_T (mandatory, cond., optional) */ PapyULong nb_val; UValue_T *value; } SElement; typedef struct SGroup_ /* assigns a number for each group */ { PapyUShort number; PapyULong size; } SGroup; typedef struct SShadowOwner_ /* keep the allowed elements of the shadow-groups */ { char *str_value; } SShadowOwner; typedef struct SImageList_ /* keeps references to images */ { PapyShort file; /* the reference to the file */ PapyShort image; /* the number of the image */ } SImageList; /* --- types specific to PAPYRUS 3 --- */ typedef SElement Module; /* the Module is defined the same way as an SElement */ typedef SElement Record; /* the Record is defined the same way as an SElement */ typedef struct SObject_ /* the Object can be either a ... */ { enum EKind_Obj whoAmI; /* what kind of object is it ? */ int objID; /* only way to identify a group or a module */ struct SPapy_List_ *item; Module *module; SElement *group; Record *record; PapyULong tmpFileLength; /* the length of the temporary file */ void *file; /* will store tmp file */ } Object; struct SPapy_List_ { Object *object; struct SPapy_List_ *next; }; typedef struct SPapy_List_ Papy_List; typedef Papy_List Item; typedef Papy_List Sequence; typedef struct SData_Set_ { int moduleName; int usage; /*enum EUsage usage;*/ } Data_Set; #endif /* PapyTypeDef3H */ Papyrus3/PapyEnumMiscGroups3.h0000755000175000017500000003032010044172376013537 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyEnumMiscGroups3.h */ /* Function : contains the declarations of the groups names and of the */ /* elements names */ /* Authors : Christian Girard */ /* */ /* History : 04.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* */ /********************************************************************************/ #ifndef PapyEnumMiscGroups3H #define PapyEnumMiscGroups3H /* Group32 */ enum { papStudyStatusIDGr = 1, papStudyPriorityIDGr, papStudyIDIssuerGr, papStudyVerifiedDateGr, papStudyVerifiedTimeGr, papStudyReadDateGr, papStudyReadTimeGr, papScheduledStudyStartDateGr, papScheduledStudyStartTimeGr, papScheduledStudyStopDateGr, papScheduledStudyStopTimeGr, papScheduledStudyLocationGr, papScheduledStudyLocationAETitlesGr, papReasonforStudyGr, papRequestingPhysicianGr, papRequestingServiceGr, papStudyArrivalDateGr, papStudyArrivalTimeGr, papStudyCompletionDateGr, papStudyCompletionTimeGr, papStudyComponentStatusIDGr, papRequestedProcedureDescriptionGr, papRequestedProcedureCodeSequenceGr, papRequestedContrastAgentGr, papStudyCommentsGr, papEndGroup32 }; /* Group38 */ enum { papReferencedPatientAliasSequenceGr = 1, papVisitStatusIDGr, papAdmissionIDGr, papIssuerofAdmissionIDGr, papRouteofAdmissionsGr, papScheduledAdmissionDateGr, papScheduledAdmissionTimeGr, papScheduledDischargeDateGr, papScheduledDischargeTimeGr, papScheduledPatientInstitutionResidenceGr, papAdmittingDateGr, papAdmittingTimeGr, papDischargeDateGr, papDischargeTimeGr, papDischargeDiagnosisDescriptionGr, papDischargeDiagnosisCodeSequenceGr, papSpecialNeedsGr, papCurrentPatientLocationGr, papPatientsInstitutionResidenceGr, papPatientStateGr, papVisitCommentsGr, papEndGroup38 }; /* Group40 */ enum { papScheduledStationAETitleGr = 1, papScheduledProcedureStepStartDateGr, papScheduledProcedureStepStartTimeGr, papScheduledProcedureStepEndDateGr, papScheduledProcedureStepEndTimeGr, papScheduledPerformingPhysiciansNameGr, papScheduledProcedureStepDescriptionGr, papScheduledActionItemCodeSequenceGr, papScheduledProcedureStepIDGr, papScheduledStationNameGr, papScheduledProcedureStepLocationGr, papPreMedicationGr, papScheduledProcedureStepSequenceGr, papCommentsontheScheduledProcedureStepGr, papRequestedProcedureIDGr, papReasonfortheRequestedProcedureGr, papRequestedProcedurePriorityGr, papPatientTransportArrangementsGr, papRequestedProcedureLocationGr, papPlacerOrderNumberProcedureGr, papFillerOrderNumberProcedureGr, papConfidentialityCodeGr, papReportingPriorityGr, papNamesofIntendedRecipientsofResultsGr, papRequestedProcedureCommentsGr, papReasonfortheImagingServiceRequestGr, papIssueDateofImagingServiceRequestGr, papIssueTimeofImagingServiceRequestGr, papPlacerOrderNumberImagingServiceRequestGr, papFillerOrderNumberImagingServiceRequestGr, papOrderEnteredByGr, papOrderEnterersLocationGr, papOrderCallbackPhoneNumberGr, papImagingServiceRequestCommentsGr, papConfidentialityConstraintonPatientDataDescriptionGr, papEndGroup40 }; /* Group50 */ enum { papCalibrationObjectGr = 1, papDeviceSequenceGr, papDeviceLengthGr, papDeviceDiameterGr, papDeviceDiameterUnitsGr, papDeviceVolumeGr, papIntermarkerDistanceGr, papDeviceDescriptionGr, papEndGroup50 }; /* Group54 */ enum { papEnergyWindowVectorGr = 1, papNumberofEnergyWindowsGr, papEnergyWindowInformationSequenceGr, papEnergyWindowRangeSequenceGr, papEnergyWindowLowerLimitGr, papEnergyWindowUpperLimitGr, papRadiopharmaceuticalInformationSequenceGr, papResidualSyringeCountsGr, papEnergyWindowNameGr, papDetectorVectorGr, papNumberofDetectorsGr, papDetectorInformationSequenceGr, papPhaseVectorGr, papNumberofPhasesGr, papPhaseInformationSequenceGr, papNumberofFramesinPhaseGr, papPhaseDelayGr, papPauseBetweenFramesGr, papRotationVectorGr, papNumberofRotationsGr, papRotationInformationSequenceGr, papNumberofFramesinRotationGr, papRRIntervalVectorGr, papNumberofRRIntervalsGr, papGatedInformationSequenceGr, papDataInformationSequenceGr, papTimeSlotVectorGr, papNumberofTimeSlotsGr, papTimeSlotInformationSequenceGr, papTimeSlotTimeGr, papSliceVectorGr, papNumberofSlicesGr, papAngularViewVectorGr, papTimeSliceVectorGr, papStartAngleGr, papTypeofDetectorMotionGr, papTriggerVectorGr, papNumberofTriggersinPhaseGr, papViewCodeSequenceGr, papViewAngulationModifierCodeSequenceGr, papRadionuclideCodeSequenceGr, papRadiopharmaceuticalRouteCodeSequenceGr, papRadiopharmaceuticalCodeSequenceGr, papCalibrationDataSequenceGr, papEnergyWindowNumberGr, papImageIDGr, papPatientOrientationCodeSequenceGr, papPatientOrientationModifierCodeSequenceGr, papPatientGantryRelationshipCodeSequenceGr, papEndGroup54 }; /* Group88 */ enum { papStorageMediaFilesetIDGr = 1, papStorageMediaFilesetUIDGr, papIconImageSequenceGr, papTopicTitleGr, papTopicSubjectGr, papTopicAuthorGr, papTopicKeyWordsGr, papEndGroup88 }; /* Group2000 */ enum { papNumberOfCopiesGr = 1, papPrintPriorityGr, papMediumTypeGr, papFilmDestinationGr, papFilmSessionLabelGr, papMemoryAllocationGr, papReferencedFilmBoxSequenceGr, papEndGroup2000 }; /* Group2010 */ enum { papImageDisplayFormatGr = 1, papAnnotationDisplayFormatIDGr, papFilmOrientationGr, papFilmSizeIDGr, papMagnificationTypeGr, papSmoothingTypeGr, papBorderDensityGr, papEmptyImageDensityGr, papMinDensityGr, papMaxDensityGr, papTrimGr, papConfigurationInformationGr, papReferencedFilmSessionSequenceGr, papReferencedImageBoxSequence2010Gr, papReferencedBasicAnnotationBoxSequenceGr, papEndGroup2010 }; /* Group2020 */ enum { papImagePosition2020Gr = 1, papPolarityGr, papRequestedImageSizeGr, papPreformattedGrayscaleImageSequenceGr, papPreformattedColorImageSequenceGr, papReferencedImageOverlayBoxSequenceGr, papReferencedVOILUTBoxSequenceGr, papEndGroup2020 }; /* Group2030 */ enum { papAnnotationPositionGr = 1, papTextStringGr, papEndGroup2030 }; /* Group2040 */ enum { papReferencedOverlayPlaneSequenceGr = 1, papReferencedOverlayPlaneGroupsGr, papOverlayMagnificationTypeGr, papOverlaySmoothingTypeGr, papOverlayForegroundDensityGr, papOverlayModeGr, papThresholdDensityGr, papReferencedImageBoxSequence2040Gr, papEndGroup2040 }; /* Group2100 */ enum { papExecutionStatusGr = 1, papExecutionStatusInfoGr, papCreationDateGr, papCreationTimeGr, papOriginatorGr, papReferencedPrintJobSequenceGr, papEndGroup2100 }; /* Group2110 */ enum { papPrinterStatusGr = 1, papPrinterStatusInfoGr, papPrinterNameGr, papPrintQueueIDGr, papEndGroup2110 }; /* Group4000 */ enum { papArbitraryGr = 1, papCommentsGr, papEndGroup4000 }; /* Group4008 */ enum { papResultsIDGr = 1, papResultsIDIssuerGr, papReferencedInterpretationSequenceGr, papInterpretationRecordedDateGr, papInterpretationRecordedTimeGr, papInterpretationRecorderGr, papReferencetoRecordedSoundGr, papInterpretationTranscriptionDateGr, papInterpretationTranscriptionTimeGr, papInterpretationTranscriberGr, papInterpretationTextGr, papInterpretationAuthorGr, papInterpretationApproverSequenceGr, papInterpretationApprovalDateGr, papInterpretationApprovalTimeGr, papPhysicianApprovingInterpretationGr, papInterpretationDiagnosisDescriptionGr, papDiagnosisCodeSequenceGr, papResultsDistributionListSequenceGr, papDistributionNameGr, papDistributionAddressGr, papInterpretationIDGr, papInterpretationIDIssuerGr, papInterpretationTypeIDGr, papInterpretationStatusIDGr, papImpressionsGr, papResultsCommentsGr, papEndGroup4008 }; /* Group5000 */ enum { papCurveDimensionsGr = 1, papNumberofPointsGr, papTypeofDataGr, papCurveDescriptionGr, papAxisUnitsGr, papAxisLabelsGr, papDataValueRepresentationGr, papMinimumCoordinateValueGr, papMaximumCoordinateValueGr, papCurveRangeGr, papCurveDataDescriptorGr, papCoordinateStartValueGr, papCoordinateStepValueGr, papAudioTypeGr, papAudioSampleFormatGr, papNumberofChannelsGr, papNumberofSamplesGr, papSampleRateGr, papTotalTimeGr, papAudioSampleDataGr, papAudioCommentsGr, papCurveLabelGr, papReferencedOverlaySequence5000Gr, papReferencedOverlayGroupGr, papCurveDataGr, papEndGroup5000 }; #endif Papyrus3/PapyInitModules3.h0000755000175000017500000005211610044203200013037 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyInitModules3.h */ /* Function : declaration of the init fct.declaration of the init fct. */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef PapyInitModules3H #define PapyInitModules3H #endif /* ------------------------- includes ------------------------------------------*/ #ifndef Papyrus3H #include "Papyrus3.h" #endif /* ------------------------- functions definition ------------------------------*/ #ifdef _NO_PROTO extern void init_group2(); extern void init_group4(); extern void init_group8(); extern void init_group10(); extern void init_group18(); extern void init_group20(); extern void init_group28(); extern void init_group32(); extern void init_group38(); extern void init_group3A(); extern void init_group40(); extern void init_group41(); extern void init_group50(); extern void init_group54(); extern void init_group60(); extern void init_group70(); extern void init_group88(); extern void init_group100(); extern void init_group2000(); extern void init_group2010(); extern void init_group2020(); extern void init_group2030(); extern void init_group2040(); extern void init_group2050(); extern void init_group2100(); extern void init_group2110(); extern void init_group2120(); extern void init_group2130(); extern void init_group3002(); extern void init_group3004(); extern void init_group3006(); extern void init_group3008(); extern void init_group300A(); extern void init_group300C(); extern void init_group300E(); extern void init_group4000(); extern void init_group4008(); extern void init_group5000(); extern void init_group5400(); extern void init_group6000(); extern void init_group7FE0(); extern void init_uinoverlay (); extern void init_AcquisitionContext (); extern void init_Approval (); extern void init_Audio (); extern void init_BasicAnnotationPresentation (); extern void init_BasicFilmBoxPresentation (); extern void init_BasicFilmBoxRelationship (); extern void init_BasicFilmSessionPresentation (); extern void init_BasicFilmSessionRelationship (); extern void init_BiPlaneImage (); extern void init_BiPlaneOverlay (); extern void init_BiPlaneSequence (); extern void init_Cine (); extern void init_ContrastBolus (); extern void init_CRImage (); extern void init_CRSeries (); extern void init_CTImage (); extern void init_Curve (); extern void init_CurveIdentification (); extern void init_Device (); extern void init_DirectoryInformation (); extern void init_DisplayShutter (); extern void init_DXAnatomyImaged (); extern void init_DXImage (); extern void init_DXDetector (); extern void init_DXPositioning (); extern void init_DXSeries (); extern void init_ExternalPapyrus_FileReferenceSequence (); extern void init_ExternalPatientFileReferenceSequence (); extern void init_ExternalStudyFileReferenceSequence (); extern void init_ExternalVisitReferenceSequence (); extern void init_FileReference (); extern void init_FileSetIdentification (); extern void init_FrameOfReference (); extern void init_FramePointers (); extern void init_GeneralEquipment (); extern void init_GeneralPatientSummary (); extern void init_GeneralSeriesSummary (); extern void init_GeneralVisitSummary (); extern void init_GeneralImage (); extern void init_GeneralSeries (); extern void init_GeneralStudy (); extern void init_GeneralStudySummary (); extern void init_IconImage (); extern void init_IdentifyingImageSequence (); extern void init_ImageBoxPixelPresentation (); extern void init_ImageBoxRelationship (); extern void init_ImageHistogram (); extern void init_ImageIdentification (); extern void init_ImageOverlayBoxPresentation (); extern void init_ImageOverlayBoxRelationship (); extern void init_ImagePlane (); extern void init_ImagePointer (); extern void init_ImageSequence (); extern void init_ImagePixel (); extern void init_InternalImagePointerSequence (); extern void init_InterpretationApproval (); extern void init_InterpretationIdentification (); extern void init_InterpretationRecording (); extern void init_InterpretationRelationship (); extern void init_InterpretationState (); extern void init_InterpretationTranscription (); extern void init_IntraOralImage (); extern void init_IntraOralSeries (); extern void init_LUTIdentification (); extern void init_MammographyImage (); extern void init_MammographySeries (); extern void init_Mask (); extern void init_ModalityLUT (); extern void init_MRImage (); extern void init_Multi_frameOverlay (); extern void init_Multi_Frame (); extern void init_NMDetector (); extern void init_NMImage (); extern void init_NMImagePixel (); extern void init_NMIsotope (); extern void init_NMMultiFrame (); extern void init_NMMulti_gatedAcquisitionImage (); extern void init_NMPhase (); extern void init_NMReconstruction (); extern void init_NMSeries (); extern void init_NMTomoAcquisition (); extern void init_OverlayIdentification (); extern void init_OverlayPlane (); extern void init_PaletteColorLookup (); extern void init_PatientDemographic (); extern void init_PatientIdentification (); extern void init_PatientMedical (); extern void init_Patient () ; extern void init_PatientRelationship (); extern void init_PatientStudy (); extern void init_PatientSummary (); extern void init_PETCurve (); extern void init_PETImage (); extern void init_PETIsotope (); extern void init_PETMultiGatedAcquisition (); extern void init_PETSeries (); extern void init_PixelOffset (); extern void init_Printer (); extern void init_PrintJob (); extern void init_ResultIdentification (); extern void init_ResultsImpression (); extern void init_ResultRelationship (); extern void init_RFTomographyAcquisition (); extern void init_ROIContour (); extern void init_RTBeams (); extern void init_RTBrachyApplicationSetups (); extern void init_RTDose (); extern void init_RTDoseROI (); extern void init_RTDVH (); extern void init_RTFractionScheme (); extern void init_RTGeneralPlan (); extern void init_RTImage (); extern void init_RTPatientSetup (); extern void init_RTPrescription (); extern void init_RTROIObservations (); extern void init_RTSeries (); extern void init_RTToleranceTables (); extern void init_StructureSet (); extern void init_SCImageEquipment (); extern void init_SCImage (); extern void init_SCMultiFrameImage (); extern void init_SCMultiFrameVector (); extern void init_SlideCoordinates (); extern void init_SOPCommon (); extern void init_SpecimenIdentification (); extern void init_StudyAcquisition (); extern void init_StudyClassification (); extern void init_StudyComponentAcquisition (); extern void init_StudyComponent (); extern void init_StudyComponentRelationship (); extern void init_StudyContent (); extern void init_StudyIdentification (); extern void init_StudyRead (); extern void init_StudyRelationship (); extern void init_StudyScheduling (); extern void init_Therapy (); extern void init_UINOverlaySequence (); extern void init_USImage (); extern void init_USFrameofReference (); extern void init_USRegionCalibration (); extern void init_VisitAdmission (); extern void init_VisitDischarge (); extern void init_VisitIdentification (); extern void init_VisitRelationship (); extern void init_VisitScheduling (); extern void init_VisitStatus (); extern void init_VLImage (); extern void init_VOILUT (); extern void init_XRayAcquisition (); extern void init_XRayAcquisitionDose (); extern void init_XRayCollimator (); extern void init_XRayFiltration (); extern void init_XRayGeneration (); extern void init_XRayGrid (); extern void init_XRayImage (); extern void init_XRayTable (); extern void init_XRayTomographyAcquisition (); extern void init_XRFPositioner (); #else extern void init_group2(SElement[]); extern void init_group4(SElement[]); extern void init_group8(SElement[]); extern void init_group10(SElement[]); extern void init_group18(SElement[]); extern void init_group20(SElement[]); extern void init_group28(SElement[]); extern void init_group32(SElement[]); extern void init_group38(SElement[]); extern void init_group3A(SElement[]); extern void init_group40(SElement[]); extern void init_group41(SElement[]); extern void init_group50(SElement[]); extern void init_group54(SElement[]); extern void init_group60(SElement[]); extern void init_group70(SElement[]); extern void init_group88(SElement[]); extern void init_group100(SElement[]); extern void init_group2000(SElement[]); extern void init_group2010(SElement[]); extern void init_group2020(SElement[]); extern void init_group2030(SElement[]); extern void init_group2040(SElement[]); extern void init_group2050(SElement[]); extern void init_group2100(SElement[]); extern void init_group2110(SElement[]); extern void init_group2120(SElement[]); extern void init_group2130(SElement[]); extern void init_group3002(SElement[]); extern void init_group3004(SElement[]); extern void init_group3006(SElement[]); extern void init_group3008(SElement[]); extern void init_group300A(SElement[]); extern void init_group300C(SElement[]); extern void init_group300E(SElement[]); extern void init_group4000(SElement[]); extern void init_group4008(SElement[]); extern void init_group5000(SElement[]); extern void init_group5400(SElement[]); extern void init_group6000(SElement[]); extern void init_group7FE0(SElement[]); extern void init_uinoverlay (SElement[]); extern void init_AcquisitionContext (SElement[]); extern void init_Approval (SElement[]); extern void init_Audio (SElement[]); extern void init_BasicAnnotationPresentation (SElement[]); extern void init_BasicFilmBoxPresentation (SElement[]); extern void init_BasicFilmBoxRelationship (SElement[]); extern void init_BasicFilmSessionPresentation (SElement[]); extern void init_BasicFilmSessionRelationship (SElement[]); extern void init_BiPlaneImage (SElement[]); extern void init_BiPlaneOverlay (SElement[]); extern void init_BiPlaneSequence (SElement[]); extern void init_Cine (SElement[]); extern void init_ContrastBolus (SElement[]); extern void init_CRImage (SElement[]); extern void init_CRSeries (SElement[]); extern void init_CTImage (SElement[]); extern void init_Curve (SElement[]); extern void init_CurveIdentification (SElement[]); extern void init_Device (SElement[]); extern void init_DirectoryInformation (SElement[]); extern void init_DisplayShutter (SElement[]); extern void init_DXAnatomyImaged (SElement[]); extern void init_DXImage (SElement[]); extern void init_DXDetector (SElement[]); extern void init_DXPositioning (SElement[]); extern void init_DXSeries (SElement[]); extern void init_ExternalVisitReferenceSequence (SElement[]); extern void init_ExternalStudyFileReferenceSequence (SElement[]); extern void init_ExternalPatientFileReferenceSequence (SElement[]); extern void init_ExternalPapyrus_FileReferenceSequence (SElement[]); extern void init_FileReference (SElement[]); extern void init_FileSetIdentification (SElement[]); extern void init_FrameOfReference (SElement[]); extern void init_FramePointers (SElement[]); extern void init_GeneralEquipment (SElement[]); extern void init_GeneralPatientSummary (SElement[]); extern void init_GeneralSeries (SElement[]); extern void init_GeneralSeriesSummary (SElement[]); extern void init_GeneralVisitSummary (SElement[]); extern void init_GeneralImage (SElement[]); extern void init_GeneralStudy (SElement[]); extern void init_GeneralStudySummary (SElement[]); extern void init_IconImage (SElement[]); extern void init_IdentifyingImageSequence (SElement[]); extern void init_ImageBoxPixelPresentation (SElement[]); extern void init_ImageBoxRelationship (SElement[]); extern void init_ImageHistogram (SElement[]); extern void init_ImageIdentification (SElement[]); extern void init_ImageOverlayBoxPresentation (SElement[]); extern void init_ImageOverlayBoxRelationship (SElement[]); extern void init_ImagePixel (SElement[]); extern void init_ImagePlane (SElement[]); extern void init_ImagePointer (SElement[]); extern void init_ImageSequence (SElement[]); extern void init_InterpretationApproval (SElement[]); extern void init_InterpretationIdentification (SElement[]); extern void init_InterpretationRecording (SElement[]); extern void init_InterpretationRelationship (SElement[]); extern void init_InterpretationState (SElement[]); extern void init_InterpretationTranscription (SElement[]); extern void init_InternalImagePointerSequence (SElement[]); extern void init_IntraOralImage (SElement[]); extern void init_IntraOralSeries (SElement[]); extern void init_LUTIdentification (SElement[]); extern void init_MammographyImage (SElement[]); extern void init_MammographySeries (SElement[]); extern void init_Mask (SElement[]); extern void init_ModalityLUT (SElement[]); extern void init_MRImage (SElement[]); extern void init_Multi_frameOverlay (SElement[]); extern void init_Multi_Frame (SElement[]); extern void init_NMDetector (SElement[]); extern void init_NMImage (SElement[]); extern void init_NMImagePixel (SElement[]); extern void init_NMIsotope (SElement[]); extern void init_NMMultiFrame (SElement[]); extern void init_NMMulti_gatedAcquisitionImage (SElement[]); extern void init_NMPhase (SElement[]); extern void init_NMReconstruction (SElement[]); extern void init_NMSeries (SElement[]); extern void init_NMTomoAcquisition (SElement[]); extern void init_OverlayIdentification (SElement[]); extern void init_OverlayPlane (SElement[]); extern void init_PaletteColorLookup (SElement[]); extern void init_PatientDemographic (SElement[]); extern void init_PatientIdentification (SElement[]); extern void init_PatientMedical (SElement[]); extern void init_Patient (SElement[]) ; extern void init_PatientRelationship (SElement[]); extern void init_PatientStudy (SElement[]); extern void init_PatientSummary (SElement[]); extern void init_PETCurve (SElement[]); extern void init_PETImage (SElement[]); extern void init_PETIsotope (SElement[]); extern void init_PETMultiGatedAcquisition (SElement[]); extern void init_PETSeries (SElement[]); extern void init_PixelOffset (SElement[]); extern void init_Printer (SElement[]); extern void init_PrintJob (SElement[]); extern void init_ResultIdentification (SElement[]); extern void init_ResultsImpression (SElement[]); extern void init_ResultRelationship (SElement[]); extern void init_RFTomographyAcquisition (SElement[]); extern void init_ROIContour (SElement[]); extern void init_RTBeams (SElement[]); extern void init_RTBrachyApplicationSetups (SElement[]); extern void init_RTDose (SElement[]); extern void init_RTDoseROI (SElement[]); extern void init_RTDVH (SElement[]); extern void init_RTFractionScheme (SElement[]); extern void init_RTGeneralPlan (SElement[]); extern void init_RTImage (SElement[]); extern void init_RTPatientSetup (SElement[]); extern void init_RTPrescription (SElement[]); extern void init_RTROIObservations (SElement[]); extern void init_RTSeries (SElement[]); extern void init_RTToleranceTables (SElement[]); extern void init_StructureSet (SElement[]); extern void init_SCImageEquipment (SElement[]); extern void init_SCImage (SElement[]); extern void init_SCMultiFrameImage (SElement[]); extern void init_SCMultiFrameVector (SElement[]); extern void init_SlideCoordinates (SElement[]); extern void init_SOPCommon (SElement[]); extern void init_SpecimenIdentification (SElement[]); extern void init_StudyAcquisition (SElement[]); extern void init_StudyClassification (SElement[]); extern void init_StudyComponentAcquisition (SElement[]); extern void init_StudyComponent (SElement[]); extern void init_StudyComponentRelationship (SElement[]); extern void init_StudyContent (SElement[]); extern void init_StudyIdentification (SElement[]); extern void init_StudyRead (SElement[]); extern void init_StudyRelationship (SElement[]); extern void init_StudyScheduling (SElement[]); extern void init_Therapy (SElement[]); extern void init_UINOverlaySequence (SElement[]); extern void init_USImage (SElement[]); extern void init_USFrameofReference (SElement[]); extern void init_USRegionCalibration (SElement[]); extern void init_VisitAdmission (SElement[]); extern void init_VisitDischarge (SElement[]); extern void init_VisitIdentification (SElement[]); extern void init_VisitRelationship (SElement[]); extern void init_VisitScheduling (SElement[]); extern void init_VisitStatus (SElement[]); extern void init_VLImage (SElement[]); extern void init_VOILUT (SElement[]); extern void init_XRayAcquisition (SElement[]); extern void init_XRayAcquisitionDose (SElement[]); extern void init_XRayCollimator (SElement[]); extern void init_XRayFiltration (SElement[]); extern void init_XRayGeneration (SElement[]); extern void init_XRayGrid (SElement[]); extern void init_XRayImage (SElement[]); extern void init_XRayTable (SElement[]); extern void init_XRayTomographyAcquisition (SElement[]); extern void init_XRFPositioner (SElement[]); #endif Papyrus3/PapyEallocMac3.c0000755000175000017500000002132410044175100012422 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyEalloc3.c */ /* Function : contains all the allocating stuff */ /* Authors : Matthieu Funk */ /* Christian Girard */ /* Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 04.1991 version 1.1 */ /* 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* */ /********************************************************************************/ /* ------------------------- includes ---------------------------------------*/ #include #include #include #include #ifndef PapyTypeDef3H #include "PapyTypeDef3.h" #endif /********************************************************************************/ /* */ /* checkvp3 : check if the new allocated did not failed */ /* return : the validated pointer if OK */ /* else exit the program */ /* */ /********************************************************************************/ static void * checkvp3 (void *ioPointer) { if (ioPointer == NULL) wildrexit ("allocating memory"); return ioPointer; } /* endof checkvp3 */ /********************************************************************************/ /* */ /* emalloc3 : checked version of malloc */ /* return : the validated pointer if OK */ /* */ /********************************************************************************/ void * emalloc3 (PapyULong inElemSize) { return checkvp3 (NewPtr ((size_t) inElemSize)); } /* endof emalloc3 */ /********************************************************************************/ /* */ /* ecalloc3 : checked version of calloc */ /* return : the validated pointer if OK */ /* */ /********************************************************************************/ void * ecalloc3 (PapyULong inNelem, PapyULong inElemSize) { return checkvp3 (NewPtr (((size_t) inNelem * (size_t) inElemSize))); } /* endof ecalloc3 */ /********************************************************************************/ /* */ /* erealloc3 : checked version of realloc */ /* return : the validated pointer if OK */ /* */ /********************************************************************************/ void * erealloc3 (void *inPtr, PapyULong inNewSize, PapyULong inOldSize) { /* return checkvp3 (realloc ((char *) ptr, (size_t) size));*/ void *theP; Size thePtrSize; inOldSize = inOldSize; /* dummy instruction for dummy programmers... */ theP = NewPtr (inNewSize); thePtrSize = GetPtrSize (inPtr); memmove (theP, inPtr, (size_t) thePtrSize); DisposePtr ((Ptr) inPtr); return theP; } /* endof erealloc3 */ /********************************************************************************/ /* */ /* efree3 : free the allocated memory and put the pointer to NULL */ /* */ /********************************************************************************/ /* modify it to have the pointer on the pointer to really put it to NULL */ void efree3 (void **ioPtr) { if ((*ioPtr) != NULL) DisposePtr ((Ptr) *ioPtr); *ioPtr = NULL; } /* endof efree3 */ Papyrus3/PapyInitModules3.c0000755000175000017500000127176410044203250013054 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyInitModules3.c */ /* Function : declaration of the init fct.declaration of the init fct. */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifdef Mac #pragma segment papy3InitModule #endif /* ------------------------- includes ---------------------------------------*/ #include #ifndef Papyrus3H #include "Papyrus3.h" #endif /********************************************************************************/ /* */ /* init_AcquisitionContext : initializes the elements of the module */ /* Acquisition Context */ /* */ /********************************************************************************/ void init_AcquisitionContext (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papAcquisitionContextSequenceAC]; theWrkP->group = 0x0040; theWrkP->element = 0x0555; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionContextDescriptionAC]; theWrkP->group = 0x0040; theWrkP->element = 0x0556; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Acquisition Context */ /********************************************************************************/ /* */ /* init_Approval : initializes the elements of the module */ /* Approval */ /* */ /********************************************************************************/ void init_Approval (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papApprovalStatus]; theWrkP->group = 0x300E; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReviewDate]; theWrkP->group = 0x300E; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReviewTime]; theWrkP->group = 0x300E; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReviewerName]; theWrkP->group = 0x300E; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Approval */ /********************************************************************************/ /* */ /* init_Audio : initializes the elements of the module */ /* Audio */ /* */ /********************************************************************************/ void init_Audio (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papAudioType]; theWrkP->group = 0x5000; theWrkP->element = 0x2000; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAudioSampleFormat]; theWrkP->group = 0x5000; theWrkP->element = 0x2002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofChannels]; theWrkP->group = 0x5000; theWrkP->element = 0x2004; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofSamples]; theWrkP->group = 0x5000; theWrkP->element = 0x2006; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSampleRate]; theWrkP->group = 0x5000; theWrkP->element = 0x2008; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTotalTime]; theWrkP->group = 0x5000; theWrkP->element = 0x200A; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAudioSampleData]; theWrkP->group = 0x5000; theWrkP->element = 0x200C; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageSequenceAudio]; theWrkP->group = 0x0008; theWrkP->element = 0x1140; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAudioComments]; theWrkP->group = 0x5000; theWrkP->element = 0x200E; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Audio */ /********************************************************************************/ /* */ /* init_BasicAnnotationPresentation : initializes the elements of the module*/ /* Basic Annotation Presentation */ /* */ /********************************************************************************/ void init_BasicAnnotationPresentation (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papAnnotationPosition]; theWrkP->group = 0x2030; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTextString]; theWrkP->group = 0x2030; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Basic Annotation Presentation */ /********************************************************************************/ /* */ /* init_BasicFilmBoxPresentation : initializes the elements of the module */ /* Basic Film Box Presentation */ /* */ /********************************************************************************/ void init_BasicFilmBoxPresentation (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImageDisplayFormat]; theWrkP->group = 0x2010; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnnotationDisplayFormatID]; theWrkP->group = 0x2010; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilmOrientation]; theWrkP->group = 0x2010; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilmSizeID]; theWrkP->group = 0x2010; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMagnificationTypeBFBP]; theWrkP->group = 0x2010; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSmoothingTypeBFBP]; theWrkP->group = 0x2010; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBorderDensity]; theWrkP->group = 0x2010; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEmptyImageDensity]; theWrkP->group = 0x2010; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMinDensity]; theWrkP->group = 0x2010; theWrkP->element = 0x0120; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaxDensity]; theWrkP->group = 0x2010; theWrkP->element = 0x0130; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTrim]; theWrkP->group = 0x2010; theWrkP->element = 0x0140; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConfigurationInformation]; theWrkP->group = 0x2010; theWrkP->element = 0x0150; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Basic Film Box Presentation */ /********************************************************************************/ /* */ /* init_BasicFilmBoxRelationship : initializes the elements of the module */ /* Basic Film Box Relationship */ /* */ /********************************************************************************/ void init_BasicFilmBoxRelationship (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedFilmSessionSequence]; theWrkP->group = 0x2010; theWrkP->element = 0x0500; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageBoxSequenceBFBR]; theWrkP->group = 0x2010; theWrkP->element = 0x0510; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedBasicAnnotationBoxSequence]; theWrkP->group = 0x2010; theWrkP->element = 0x0520; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Basic Film Box Relationship */ /********************************************************************************/ /* */ /* init_BasicFilmSessionPresentation : initializes the elements of the module*/ /* Basic File Session Presentation */ /* */ /********************************************************************************/ void init_BasicFilmSessionPresentation (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papNumberofCopies]; theWrkP->group = 0x2000; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrintPriorityBFSP]; theWrkP->group = 0x2000; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMediumType]; theWrkP->group = 0x2000; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilmDestination]; theWrkP->group = 0x2000; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilmSessionLabel]; theWrkP->group = 0x2000; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMemoryAllocation]; theWrkP->group = 0x2000; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaximumMemoryAllocation]; theWrkP->group = 0x2000; theWrkP->element = 0x0061; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Basic Film Session Presentation */ /********************************************************************************/ /* */ /* init_BasicFilmSessionRelationship : initializes the elements of the module */ /* Basic Film Session Relationship */ /* */ /********************************************************************************/ void init_BasicFilmSessionRelationship (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedFilmBoxSequence]; theWrkP->group = 0x2000; theWrkP->element = 0x0500; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0L; theWrkP->value = NULL; } /* endof init_Basic Film Session Relationship */ /********************************************************************************/ /* */ /* init_BiPlaneImage : initializes the elements of the module */ /* Bi-Plane Image */ /* */ /********************************************************************************/ void init_BiPlaneImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papSmallestImagePixelValueinPlane]; theWrkP->group = 0x0028; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLargestImagePixelValueinPlane]; theWrkP->group = 0x0028; theWrkP->element = 0x0111; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_BiPlaneImage */ /********************************************************************************/ /* */ /* init_BiPlaneOverlay : initializes the elements of the module */ /* Bi-Plane Overlay */ /* */ /********************************************************************************/ void init_BiPlaneOverlay (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOverlayPlanes]; theWrkP->group = 0x6000; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayPlaneOrigin]; theWrkP->group = 0x6000; theWrkP->element = 0x0052; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_BiPlane Overlay */ /********************************************************************************/ /* */ /* init_BiPlaneSequence : initializes the elements of the module */ /* Bi-Plane Sequence */ /* */ /********************************************************************************/ void init_BiPlaneSequence (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPlanes]; theWrkP->group = 0x0028; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBiPlaneAcquisitionSequence]; theWrkP->group = 0x0028; theWrkP->element = 0x5000; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_BiPlaneSequence */ /********************************************************************************/ /* */ /* init_Cine : initializes the elements of the module */ /* Cine */ /* */ /********************************************************************************/ void init_Cine (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPreferredPlaybackSequencing]; theWrkP->group = 0x0018; theWrkP->element = 0x1244; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameTimeC]; theWrkP->group = 0x0018; theWrkP->element = 0x1063; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameTimeVector]; theWrkP->group = 0x0018; theWrkP->element = 0x1065; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStartTrim]; theWrkP->group = 0x0008; theWrkP->element = 0x2142; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStopTrim]; theWrkP->group = 0x0008; theWrkP->element = 0x2143; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecommendedDisplayFrameRate]; theWrkP->group = 0x0008; theWrkP->element = 0x2144; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCineRate]; theWrkP->group = 0x0018; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameDelay]; theWrkP->group = 0x0018; theWrkP->element = 0x1066; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEffectiveDuration]; theWrkP->group = 0x0018; theWrkP->element = 0x0072; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papActualFrameDurationC]; theWrkP->group = 0x0018; theWrkP->element = 0x1242; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Cine */ /********************************************************************************/ /* */ /* init_ContrastBolus : initializes the elements of the module */ /* Contrast Bolus */ /* */ /********************************************************************************/ void init_ContrastBolus (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papContrastBolusAgent]; theWrkP->group = 0x0018; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusAgentSequence]; theWrkP->group = 0x0018; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusRoute]; theWrkP->group = 0x0018; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusAdministrationRouteSequence]; theWrkP->group = 0x0018; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusVolume]; theWrkP->group = 0x0018; theWrkP->element = 0x1041; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusStartTime]; theWrkP->group = 0x0018; theWrkP->element = 0x1042; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusStopTime]; theWrkP->group = 0x0018; theWrkP->element = 0x1043; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusTotalDose]; theWrkP->group = 0x0018; theWrkP->element = 0x1044; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastFlowRates]; theWrkP->group = 0x0018; theWrkP->element = 0x1046; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastFlowDurations]; theWrkP->group = 0x0018; theWrkP->element = 0x1047; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusIngredient]; theWrkP->group = 0x0018; theWrkP->element = 0x1048; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastBolusIngredientConcentration]; theWrkP->group = 0x0018; theWrkP->element = 0x1049; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Contrast Bolus */ /********************************************************************************/ /* */ /* init_CRImage : initializes the elements of the module */ /* CR Image */ /* */ /********************************************************************************/ void init_CRImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papKVPCRI]; theWrkP->group = 0x0018; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPlateID]; theWrkP->group = 0x0018; theWrkP->element = 0x1004; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoDetectorCRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoPatientCRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1111; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureTimeCRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1150; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXrayTubeCurrentCRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1151; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureCRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1152; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagerPixelSpacingCRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1164; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGeneratorPowerCRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1170; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionDeviceProcessingDescription]; theWrkP->group = 0x0018; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionDeviceProcessingCode]; theWrkP->group = 0x0018; theWrkP->element = 0x1401; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCassetteOrientation]; theWrkP->group = 0x0018; theWrkP->element = 0x1402; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCassetteSize]; theWrkP->group = 0x0018; theWrkP->element = 0x1403; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposuresonPlate]; theWrkP->group = 0x0018; theWrkP->element = 0x1404; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRelativeXrayExposure]; theWrkP->group = 0x0018; theWrkP->element = 0x1405; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSensitivity]; theWrkP->group = 0x0018; theWrkP->element = 0x6000; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_CR Image */ /********************************************************************************/ /* */ /* init_CRSeries : initializes the elements of the module */ /* CR Series */ /* */ /********************************************************************************/ void init_CRSeries (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papBodyPartExaminedCRS]; theWrkP->group = 0x0018; theWrkP->element = 0x0015; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewPosition]; theWrkP->group = 0x0018; theWrkP->element = 0x5101; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterTypeCRS]; theWrkP->group = 0x0018; theWrkP->element = 0x1160; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorgridnameCRS]; theWrkP->group = 0x0018; theWrkP->element = 0x1180; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFocalSpotCRS]; theWrkP->group = 0x0018; theWrkP->element = 0x1190; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPlateType]; theWrkP->group = 0x0018; theWrkP->element = 0x1260; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhosphorType]; theWrkP->group = 0x0018; theWrkP->element = 0x1261; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_CR Series */ /********************************************************************************/ /* */ /* init_CTImage : initializes the elements of the module */ /* CT Image */ /* */ /********************************************************************************/ void init_CTImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImageTypeCTI]; theWrkP->group = 0x0008; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSamplesperPixelCTI]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretationCTI]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedCTI]; theWrkP->group = 0x0028; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsStoredCTI]; theWrkP->group = 0x0028; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighBitCTI]; theWrkP->group = 0x0028; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleInterceptCTI]; theWrkP->group = 0x0028; theWrkP->element = 0x1052; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleSlopeCTI]; theWrkP->group = 0x0028; theWrkP->element = 0x1053; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papKVPCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionNumberCTI]; theWrkP->group = 0x0020; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScanOptionsCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDataCollectionDiameter]; theWrkP->group = 0x0018; theWrkP->element = 0x0090; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReconstructionDiameterCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoDetectorCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoPatientCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1111; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGantryDetectorTiltCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1120; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableHeightCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1130; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRotationDirectionCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1140; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureTimeCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1150; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXrayTubeCurrentCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1151; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1152; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterTypeCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1160; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGeneratorPowerCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1170; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFocalSpotCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1190; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConvolutionKernelCTI]; theWrkP->group = 0x0018; theWrkP->element = 0x1210; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_CT Image */ /********************************************************************************/ /* */ /* init_Curve : initializes the elements of the module */ /* Curve */ /* */ /********************************************************************************/ void init_Curve (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papCurveDimensions]; theWrkP->group = 0x5000; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofPoints]; theWrkP->group = 0x5000; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTypeofData]; theWrkP->group = 0x5000; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDataValueRepresentation]; theWrkP->group = 0x5000; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveData]; theWrkP->group = 0x5000; theWrkP->element = 0x3000; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveDescription]; theWrkP->group = 0x5000; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAxisUnits]; theWrkP->group = 0x5000; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAxisLabels]; theWrkP->group = 0x5000; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMinimumCoordinateValue]; theWrkP->group = 0x5000; theWrkP->element = 0x0104; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMaximumCoordinateValue]; theWrkP->group = 0x5000; theWrkP->element = 0x0105; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveRange]; theWrkP->group = 0x5000; theWrkP->element = 0x0106; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveDataDescriptor]; theWrkP->group = 0x5000; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCoordinateStartValue]; theWrkP->group = 0x5000; theWrkP->element = 0x0112; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCoordinateStepValue]; theWrkP->group = 0x5000; theWrkP->element = 0x0114; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveLabel]; theWrkP->group = 0x5000; theWrkP->element = 0x2500; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedOverlaySequence5000]; theWrkP->group = 0x5000; theWrkP->element = 0x2600; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Curve */ /********************************************************************************/ /* */ /* init_CurveIdentification : initializes the elements of the module */ /* Curve Identification */ /* */ /********************************************************************************/ void init_CurveIdentification (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papCurveNumber]; theWrkP->group = 0x0020; theWrkP->element = 0x0024; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveDate]; theWrkP->group = 0x0008; theWrkP->element = 0x0025; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveTime]; theWrkP->group = 0x0008; theWrkP->element = 0x0035; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageSequenceCI]; theWrkP->group = 0x0008; theWrkP->element = 0x1140; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedOverlaySequenceCI]; theWrkP->group = 0x0008; theWrkP->element = 0x1130; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedCurveSequenceCI]; theWrkP->group = 0x0008; theWrkP->element = 0x1145; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Curve Identification */ /********************************************************************************/ /* */ /* init_Device : initializes the elements of the module */ /* Device */ /* */ /********************************************************************************/ void init_Device (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papDeviceSequence]; theWrkP->group = 0x0050; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Device */ /********************************************************************************/ /* */ /* init_DirectoryInformation : initializes the elements of the module */ /* Directory Information */ /* */ /********************************************************************************/ void init_DirectoryInformation (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOffsetofTheFirstDirectoryRecord]; theWrkP->group = 0x0004; theWrkP->element = 0x1200; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOffsetofTheLastDirectoryRecord]; theWrkP->group = 0x0004; theWrkP->element = 0x1202; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilesetConsistencyFlag]; theWrkP->group = 0x0004; theWrkP->element = 0x1212; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDirectoryRecordSequence]; theWrkP->group = 0x0004; theWrkP->element = 0x1220; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Directory Information */ /********************************************************************************/ /* */ /* init_DisplayShutter : initializes the elements of the module */ /* Display Shutter */ /* */ /********************************************************************************/ void init_DisplayShutter (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papShutterShapeDS]; theWrkP->group = 0x0018; theWrkP->element = 0x1600; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-3"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShutterLeftVerticalEdgeDS]; theWrkP->group = 0x0018; theWrkP->element = 0x1602; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShutterRightVerticalEdgeDS]; theWrkP->group = 0x0018; theWrkP->element = 0x1604; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShutterUpperHorizontalEdgeDS]; theWrkP->group = 0x0018; theWrkP->element = 0x1606; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papShutterLowerHorizontalEdgeDS]; theWrkP->group = 0x0018; theWrkP->element = 0x1608; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCenterofCircularShutterDS]; theWrkP->group = 0x0018; theWrkP->element = 0x1610; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiusofCircularShutterDS]; theWrkP->group = 0x0018; theWrkP->element = 0x1612; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVerticesofthePolygonalShutterDS]; theWrkP->group = 0x0018; theWrkP->element = 0x1620; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2-2n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Display Shutter */ /********************************************************************************/ /* */ /* init_DXAnatomyImaged : initializes the elements of the module */ /* DX Anatomy Imaged */ /* */ /********************************************************************************/ void init_DXAnatomyImaged (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImageLateralityDXAI]; theWrkP->group = 0x0020; theWrkP->element = 0x0062; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnatomicRegionSequenceDXAI]; theWrkP->group = 0x0008; theWrkP->element = 0x2218; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrimaryAnatomicStructureSequenceDXAI]; theWrkP->group = 0x0008; theWrkP->element = 0x2228; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_DX Anatomy Imaged */ /********************************************************************************/ /* */ /* init_DXDetector : initializes the elements of the module */ /* DX Detector */ /* */ /********************************************************************************/ void init_DXDetector (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papDetectorTypeDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorConfigurationDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorDescriptionDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7006; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorModeDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7008; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorIDDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x700A; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDateofLastDetectorCalibrationDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x700C; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeofLastDetectorCalibrationDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x700E; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposuresonDetectorSinceLastCalibrationDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7010; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposuresonDetectorSinceManufacturedDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7011; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorTimeSinceLastExposureDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7012; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorActiveTimeDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7014; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorActivationOffsetFromExposureDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7016; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorBinningDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x701A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorConditionsNominalFlagDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7000; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorTemperatureDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7001; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSensitivityDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x6000; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewShapeDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x1147; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewDimensionsDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x1149; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewOriginDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewRotationDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7032; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewHorizontalFlipDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7034; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagerPixelSpacingDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x1164; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorElementPhysicalSizeDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7020; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorElementSpacingDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7022; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorActiveShapeDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7024; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorActiveDimensionsDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7026; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorActiveOriginDXD]; theWrkP->group = 0x0018; theWrkP->element = 0x7028; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_DX Detector */ /********************************************************************************/ /* */ /* init_DXImage : initializes the elements of the module */ /* DX Image */ /* */ /********************************************************************************/ void init_DXImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImageTypeDXI]; theWrkP->group = 0x0008; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSamplesperPixelDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretationDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsStoredDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighBitDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelRepresentationDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelIntensityRelationshipDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelIntensityRelationshipSignDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x1041; theWrkP->length = 0L; theWrkP->vr = SS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleInterceptDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x1052; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleSlopeDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x1053; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleTypeDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x1054; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationLUTShapeDXI]; theWrkP->group = 0x2050; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLossyImageCompressionDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x2110; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLossyImageCompressionRatioDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x2112; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDerivationDescriptionDXI]; theWrkP->group = 0x0008; theWrkP->element = 0x2111; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionDeviceProcessingDescriptionDXI]; theWrkP->group = 0x0018; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionDeviceProcessingCodeDXI]; theWrkP->group = 0x0018; theWrkP->element = 0x1401; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientOrientationDXI]; theWrkP->group = 0x0020; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "2"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCalibrationObjectDXI]; theWrkP->group = 0x0050; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBurnedInAnnotationDXI]; theWrkP->group = 0x0028; theWrkP->element = 0x0301; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_DX Image */ /********************************************************************************/ /* */ /* init_DXPositioning : initializes the elements of the module */ /* DX Positioning */ /* */ /********************************************************************************/ void init_DXPositioning (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papProjectionEponymousNameCodeSequenceDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x5104; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientPositionDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x5100; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewPositionDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x5101; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewCodeSequenceDXP]; theWrkP->group = 0x0054; theWrkP->element = 0x0220; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewModifierCodeSequenceDXP]; theWrkP->group = 0x0054; theWrkP->element = 0x0222; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientOrientationCodeSequenceDXP]; theWrkP->group = 0x0054; theWrkP->element = 0x0410; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientOrientationModifierCodeSequenceDXP]; theWrkP->group = 0x0054; theWrkP->element = 0x0412; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientGantryRelationshipCodeSequenceDXP]; theWrkP->group = 0x0054; theWrkP->element = 0x0414; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoPatientDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x1111; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoDetectorDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEstimatedRadiographicMagnificationFactorDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x1114; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionerTypeDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x1508; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionerPrimaryAngleDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionerSecondaryAngleDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorPrimaryAngleDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x1530; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorSecondaryAngleDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x1531; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papColumnAngulationDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x1450; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTypeDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x113A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableAngleDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x1138; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBodyPartThicknessDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x11A0; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompressionForceDXP]; theWrkP->group = 0x0018; theWrkP->element = 0x11A2; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_DX Positioning */ /********************************************************************************/ /* */ /* init_DXSeries : initializes the elements of the module */ /* DX Series */ /* */ /********************************************************************************/ void init_DXSeries (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papModalityDX]; theWrkP->group = 0x0008; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedStudyComponentSequence]; theWrkP->group = 0x0008; theWrkP->element = 0x1111; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationIndentType]; theWrkP->group = 0x0008; theWrkP->element = 0x0068; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_DX Series */ /********************************************************************************/ /* */ /* init_ExternalPapyrus_FileReferenceSequence : initializes the elements */ /* of the module External Papyrus_File Reference Sequence */ /* */ /********************************************************************************/ void init_ExternalPapyrus_FileReferenceSequence (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papExternalPAPYRUSFileReferenceSequence]; theWrkP->group = 0x0041; theWrkP->element = 0x1014; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "M"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_External Papyrus_File Reference Sequence */ /********************************************************************************/ /* */ /* init_ExternalPatientFileReferenceSequence : initializes the elements of the module*/ /* External Patient File Reference Sequence */ /* */ /********************************************************************************/ void init_ExternalPatientFileReferenceSequence (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedPatientSequenceEPFRS]; theWrkP->group = 0x0008; theWrkP->element = 0x1120; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_External Patient File Reference Sequence */ /********************************************************************************/ /* */ /* init_ExternalStudyFileReferenceSequence : initializes the elements of the module*/ /* External Study File Reference Sequence */ /* */ /********************************************************************************/ void init_ExternalStudyFileReferenceSequence (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedStudySequenceESFRS]; theWrkP->group = 0x0008; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_External Study File Reference Sequence */ /********************************************************************************/ /* */ /* init_ExternalVisitReferenceSequence : initializes the elements of the module*/ /* External Visit Reference Sequence */ /* */ /********************************************************************************/ void init_ExternalVisitReferenceSequence (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedVisitSequenceEVRS]; theWrkP->group = 0x0008; theWrkP->element = 0x1125; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_External Visit Reference Sequence */ /********************************************************************************/ /* */ /* init_FileReference : initializes the elements of the module */ /* File Reference */ /* */ /********************************************************************************/ void init_FileReference (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedSOPClassUID]; theWrkP->group = 0x0041; theWrkP->element = 0x1021; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "M"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUID]; theWrkP->group = 0x0041; theWrkP->element = 0x1022; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "M"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFileName]; theWrkP->group = 0x0041; theWrkP->element = 0x1031; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "M"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFilePath]; theWrkP->group = 0x0041; theWrkP->element = 0x1032; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "M"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_File Reference */ /********************************************************************************/ /* */ /* init_FileSetIdentification : initializes the elements of the module */ /* File Set Identification */ /* */ /********************************************************************************/ void init_FileSetIdentification (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papFilesetID]; theWrkP->group = 0x0004; theWrkP->element = 0x1130; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFileIDofFilesetDescriptorFile]; theWrkP->group = 0x0004; theWrkP->element = 0x1141; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFormatofFilesetDescriptorFile]; theWrkP->group = 0x0004; theWrkP->element = 0x1142; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0L; theWrkP->value = NULL; } /* endof init_File Set Identification */ /********************************************************************************/ /* */ /* init_FrameOfReference : initializes the elements of the module */ /* Frame Of Reference */ /* */ /********************************************************************************/ void init_FrameOfReference (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papFrameofReferenceUID]; theWrkP->group = 0x0020; theWrkP->element = 0x0052; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionReferenceIndicator]; theWrkP->group = 0x0020; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Frame Of Reference */ /********************************************************************************/ /* */ /* init_FramePointers : initializes the elements of the module */ /* Frame Pointers */ /* */ /********************************************************************************/ void init_FramePointers (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papRepresentativeFrameNumber]; theWrkP->group = 0x0028; theWrkP->element = 0x6010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameNumbersofInterest]; theWrkP->group = 0x0028; theWrkP->element = 0x6020; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFramesofInterestDescription]; theWrkP->group = 0x0028; theWrkP->element = 0x6022; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_FramePointers */ /********************************************************************************/ /* */ /* init_GeneralEquipment : initializes the elements of the module */ /* General Equipment */ /* */ /********************************************************************************/ void init_GeneralEquipment (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papManufacturerGE]; theWrkP->group = 0x0008; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstitutionNameGE]; theWrkP->group = 0x0008; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstitutionAddressGE]; theWrkP->group = 0x0008; theWrkP->element = 0x0081; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStationName]; theWrkP->group = 0x0008; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstitutionalDepartmentName]; theWrkP->group = 0x0008; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papManufacturersModelName]; theWrkP->group = 0x0008; theWrkP->element = 0x1090; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeviceSerialNumberGE]; theWrkP->group = 0x0018; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSoftwareVersionsGE]; theWrkP->group = 0x0018; theWrkP->element = 0x1020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpatialResolution]; theWrkP->group = 0x0018; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDateofLastCalibration]; theWrkP->group = 0x0018; theWrkP->element = 0x1200; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeofLastCalibration]; theWrkP->group = 0x0018; theWrkP->element = 0x1201; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelPaddingValue]; theWrkP->group = 0x0028; theWrkP->element = 0x0120; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_General Equipment */ /********************************************************************************/ /* */ /* init_GeneralImage : initializes the elements of the module */ /* General Image */ /* */ /********************************************************************************/ void init_GeneralImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papInstanceNumberGI]; theWrkP->group = 0x0020; theWrkP->element = 0x0013; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientOrientation]; theWrkP->group = 0x0020; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "2"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageDate]; theWrkP->group = 0x0008; theWrkP->element = 0x0023; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTime]; theWrkP->group = 0x0008; theWrkP->element = 0x0033; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTypeGI]; theWrkP->group = 0x0008; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionNumberGI]; theWrkP->group = 0x0020; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionDate]; theWrkP->group = 0x0008; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionTime]; theWrkP->group = 0x0008; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageSequenceGI]; theWrkP->group = 0x0008; theWrkP->element = 0x1140; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDerivationDescription]; theWrkP->group = 0x0008; theWrkP->element = 0x2111; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceImageSequence]; theWrkP->group = 0x0008; theWrkP->element = 0x2112; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagesinAcquisition]; theWrkP->group = 0x0020; theWrkP->element = 0x1002; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageComments]; theWrkP->group = 0x0020; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLossyImageCompressionGI]; theWrkP->group = 0x0028; theWrkP->element = 0x2110; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_General Image */ /********************************************************************************/ /* */ /* init_GeneralPatientSummary : initializes the elements of the module */ /* General Patient Summary */ /* */ /********************************************************************************/ void init_GeneralPatientSummary (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPatientsNameGPS]; theWrkP->group = 0x0010; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsID]; theWrkP->group = 0x0010; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "M"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsBirthDateGPS]; theWrkP->group = 0x0010; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsSexGPS]; theWrkP->group = 0x0010; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsHeight]; theWrkP->group = 0x0010; theWrkP->element = 0x1020; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "M"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsWeightGPS]; theWrkP->group = 0x0010; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_General Patient Summary */ /********************************************************************************/ /* */ /* init_GeneralSeries : initializes the elements of the module */ /* General Series */ /* */ /********************************************************************************/ void init_GeneralSeries (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papModalityGS]; theWrkP->group = 0x0008; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesInstanceUIDGS]; theWrkP->group = 0x0020; theWrkP->element = 0x000E; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesNumberGS]; theWrkP->group = 0x0020; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLaterality]; theWrkP->group = 0x0020; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesDate]; theWrkP->group = 0x0008; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesTime]; theWrkP->group = 0x0008; theWrkP->element = 0x0031; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformingPhysiciansNameGS]; theWrkP->group = 0x0008; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papProtocolName]; theWrkP->group = 0x0018; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesDescription]; theWrkP->group = 0x0008; theWrkP->element = 0x103E; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOperatorsName]; theWrkP->group = 0x0008; theWrkP->element = 0x1070; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedStudyComponentSequenceGS]; theWrkP->group = 0x0008; theWrkP->element = 0x1111; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBodyPartExaminedGS]; theWrkP->group = 0x0018; theWrkP->element = 0x0015; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientPosition]; theWrkP->group = 0x0018; theWrkP->element = 0x5100; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSmallestPixelValueinSeries]; theWrkP->group = 0x0028; theWrkP->element = 0x0108; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLargestPixelValueinSeries]; theWrkP->group = 0x0028; theWrkP->element = 0x0109; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_General Series */ /********************************************************************************/ /* */ /* init_GeneralSeriesSummary : initializes the elements of the module */ /* General Series Summary */ /* */ /********************************************************************************/ void init_GeneralSeriesSummary (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papModalityGSS]; theWrkP->group = 0x0008; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesInstanceUIDGSS]; theWrkP->group = 0x0020; theWrkP->element = 0x000E; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesNumberGSS]; theWrkP->group = 0x0020; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofimages]; theWrkP->group = 0x0041; theWrkP->element = 0x1015; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_General Series Summary */ /********************************************************************************/ /* */ /* init_GeneralStudy : initializes the elements of the module */ /* General Study */ /* */ /********************************************************************************/ void init_GeneralStudy (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papStudyInstanceUIDGS]; theWrkP->group = 0x0020; theWrkP->element = 0x000D; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyDateGS]; theWrkP->group = 0x0008; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyTimeGS]; theWrkP->group = 0x0008; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferringPhysiciansNameGS]; theWrkP->group = 0x0008; theWrkP->element = 0x0090; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyIDGS]; theWrkP->group = 0x0020; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAccessionNumberGS]; theWrkP->group = 0x0008; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyDescriptionGS]; theWrkP->group = 0x0008; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhysiciansOfRecordGS]; theWrkP->group = 0x0008; theWrkP->element = 0x1048; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNameofPhysiciansReadingStudyGS]; theWrkP->group = 0x0008; theWrkP->element = 0x1060; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedStudySequenceGS]; theWrkP->group = 0x0008; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_General Study */ /********************************************************************************/ /* */ /* init_GeneralStudySummary : initializes the elements of the module */ /* General Study Summary */ /* */ /********************************************************************************/ void init_GeneralStudySummary (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papStudyDateGSS]; theWrkP->group = 0x0008; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyTimeGSS]; theWrkP->group = 0x0008; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyUID]; theWrkP->group = 0x0020; theWrkP->element = 0x000D; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyIDGSS]; theWrkP->group = 0x0020; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAccessionnumberGSS]; theWrkP->group = 0x0008; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferringPhysiciansNameGSS]; theWrkP->group = 0x0008; theWrkP->element = 0x0090; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_General Study Summary */ /********************************************************************************/ /* */ /* init_GeneralVisitSummary : initializes the elements of the module */ /* General Visit Summary */ /* */ /********************************************************************************/ void init_GeneralVisitSummary (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papCurrentPatientLocationGVS]; theWrkP->group = 0x0038; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsInstitutionResidenceGVS]; theWrkP->group = 0x0038; theWrkP->element = 0x0300; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstitutionNameVS]; theWrkP->group = 0x0008; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_General Visit Summary */ /********************************************************************************/ /* */ /* init_IconImage : initializes the elements of the module */ /* Icon Image */ /* */ /********************************************************************************/ void init_IconImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papSamplesperPixelII]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretationII]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRowsII]; theWrkP->group = 0x0028; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papColumnsII]; theWrkP->group = 0x0028; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedII]; theWrkP->group = 0x0028; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsStoredII]; theWrkP->group = 0x0028; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighBitII]; theWrkP->group = 0x0028; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelRepresentationII]; theWrkP->group = 0x0028; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRedPaletteColorLookupTableDescriptors]; theWrkP->group = 0x0028; theWrkP->element = 0x1101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGreenPaletteColorLookupTableDescriptors]; theWrkP->group = 0x0028; theWrkP->element = 0x1102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBluePaletteColorLookupTableDescriptors]; theWrkP->group = 0x0028; theWrkP->element = 0x1103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRedPaletteColorLookupTableDataII]; theWrkP->group = 0x0028; theWrkP->element = 0x1201; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGreenPaletteColorLookupTableDataII]; theWrkP->group = 0x0028; theWrkP->element = 0x1202; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBluePaletteColorLookupTableDataII]; theWrkP->group = 0x0028; theWrkP->element = 0x1203; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelDataII]; theWrkP->group = 0x7FE0; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Icon Image */ /********************************************************************************/ /* */ /* init_IdentifyingImageSequence : initializes the elements of the module */ /* Identifying Image Sequence */ /* */ /********************************************************************************/ void init_IdentifyingImageSequence (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImageIdentifierSequence]; theWrkP->group = 0x0041; theWrkP->element = 0x1013; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "M"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* end of init_Identifying Image Sequence */ /********************************************************************************/ /* */ /* init_ImageBoxPixelPresentation : initializes the elements of the module */ /* Image Box Pixel Presentation */ /* */ /********************************************************************************/ void init_ImageBoxPixelPresentation (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImagePosition]; theWrkP->group = 0x2020; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPolarity]; theWrkP->group = 0x2020; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMagnificationTypeIBPP]; theWrkP->group = 0x2010; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSmoothingTypeIBPP]; theWrkP->group = 0x2010; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedImageSize]; theWrkP->group = 0x2020; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPreformattedGrayscaleImageSequence]; theWrkP->group = 0x2020; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPreformattedColorImageSequence]; theWrkP->group = 0x2020; theWrkP->element = 0x0111; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageOverlayBoxSequenceIBP]; theWrkP->group = 0x2020; theWrkP->element = 0x0130; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPClassUID8]; theWrkP->group = 0x0008; theWrkP->element = 0x1150; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSOPInstanceUID8]; theWrkP->group = 0x0008; theWrkP->element = 0x1155; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Image Box Pixel Presentation */ /********************************************************************************/ /* */ /* init_ImageBoxRelationship : initializes the elements of the module */ /* Image Box Relationship */ /* */ /********************************************************************************/ void init_ImageBoxRelationship (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedImageSequenceBR]; theWrkP->group = 0x0008; theWrkP->element = 0x1140; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageOverlayBoxSequence]; theWrkP->group = 0x2020; theWrkP->element = 0x0130; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedVOILUTSequence]; theWrkP->group = 0x2020; theWrkP->element = 0x0140; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Image Box Relationship */ /********************************************************************************/ /* */ /* init_ImageHistogram : initializes the elements of the module */ /* Image Histogram */ /* */ /********************************************************************************/ void init_ImageHistogram (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papHistogramSequenceIH]; theWrkP->group = 0x0060; theWrkP->element = 0x3000; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Image Histogram */ /********************************************************************************/ /* */ /* init_ImageIdentification : initializes the elements of the module */ /* Image Identification */ /* */ /********************************************************************************/ void init_ImageIdentification (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedImageSOPClassUIDII]; theWrkP->group = 0x0041; theWrkP->element = 0x1041; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "M"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageSOPInstanceUID]; theWrkP->group = 0x0041; theWrkP->element = 0x1042; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "M"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageNumberII]; theWrkP->group = 0x0020; theWrkP->element = 0x0013; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Image Identification */ /********************************************************************************/ /* */ /* init_ImageOverlayBoxPresentation : initializes the elements of the module*/ /* Image Overlay Box Presentation */ /* */ /********************************************************************************/ void init_ImageOverlayBoxPresentation (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedOverlayPlaneSequence]; theWrkP->group = 0x2040; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayMagnificationType]; theWrkP->group = 0x2040; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaySmoothingType]; theWrkP->group = 0x2040; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayForegroundDensity]; theWrkP->group = 0x2040; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayMode]; theWrkP->group = 0x2040; theWrkP->element = 0x0090; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papThresholdDensity]; theWrkP->group = 0x2040; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Image Overlay Box Presentation */ /********************************************************************************/ /* */ /* init_ImageOverlayBoxRelationship : initializes the elements of the module*/ /* Image Overlay Box Relationship */ /* */ /********************************************************************************/ void init_ImageOverlayBoxRelationship (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedImageBoxSequenceOBR]; theWrkP->group = 0x2010; theWrkP->element = 0x0510; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Image Overlay Box Relationship */ /********************************************************************************/ /* */ /* init_ImagePixel : initializes the elements of the module */ /* Image Pixel */ /* */ /********************************************************************************/ void init_ImagePixel (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papSamplesperPixelIP]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretationIP]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRows]; theWrkP->group = 0x0028; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papColumns]; theWrkP->group = 0x0028; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedIP]; theWrkP->group = 0x0028; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsStoredIP]; theWrkP->group = 0x0028; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighBitIP]; theWrkP->group = 0x0028; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelRepresentationIP]; theWrkP->group = 0x0028; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelData]; theWrkP->group = 0x7FE0; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPlanarConfiguration]; theWrkP->group = 0x0028; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelAspectRatio]; theWrkP->group = 0x0028; theWrkP->element = 0x0034; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSmallestImagePixelValue]; theWrkP->group = 0x0028; theWrkP->element = 0x0106; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLargestImagePixelValue]; theWrkP->group = 0x0028; theWrkP->element = 0x0107; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRedPaletteColorLookupTableDescriptor]; theWrkP->group = 0x0028; theWrkP->element = 0x1101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGreenPaletteColorLookupTableDescriptor]; theWrkP->group = 0x0028; theWrkP->element = 0x1102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBluePaletteColorLookupTableDescriptor]; theWrkP->group = 0x0028; theWrkP->element = 0x1103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRedPaletteColorLookupTableData]; theWrkP->group = 0x0028; theWrkP->element = 0x1201; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGreenPaletteColorLookupTableData]; theWrkP->group = 0x0028; theWrkP->element = 0x1202; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBluePaletteColorLookupTableData]; theWrkP->group = 0x0028; theWrkP->element = 0x1203; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Image Pixel */ /********************************************************************************/ /* */ /* init_ImagePlane : initializes the elements of the module */ /* Image Plane */ /* */ /********************************************************************************/ void init_ImagePlane (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPixelSpacing]; theWrkP->group = 0x0028; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageOrientationPatient]; theWrkP->group = 0x0020; theWrkP->element = 0x0037; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "6"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagePositionPatient]; theWrkP->group = 0x0020; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSliceThickness]; theWrkP->group = 0x0018; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSliceLocation]; theWrkP->group = 0x0020; theWrkP->element = 0x1041; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Image Plane */ /********************************************************************************/ /* */ /* init_ImagePointer : initializes the elements of the module */ /* Image Pointer */ /* */ /********************************************************************************/ void init_ImagePointer (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImagePointer]; theWrkP->group = 0x0041; theWrkP->element = 0x1011; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Image Pointer */ /********************************************************************************/ /* */ /* init_ImageSequence : initializes the elements of the module */ /* Image Sequence */ /* */ /********************************************************************************/ void init_ImageSequence (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImageSequence]; theWrkP->group = 0x0041; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "M"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Image Sequence */ /********************************************************************************/ /* */ /* init_InternalImagePointerSequence : initializes the elements of the module*/ /* Internal Image Pointer Sequence */ /* */ /********************************************************************************/ void init_InternalImagePointerSequence (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPointerSequence]; theWrkP->group = 0x0041; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "M"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Internal Image Pointer Sequence */ /********************************************************************************/ /* */ /* init_InterpretationApproval : initializes the elements of the module */ /* Interpretation Approval */ /* */ /********************************************************************************/ void init_InterpretationApproval (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papInterpretationApproverSequence]; theWrkP->group = 0x4008; theWrkP->element = 0x0111; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationDiagnosisDescription]; theWrkP->group = 0x4008; theWrkP->element = 0x0115; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationDiagnosisCodesSequence]; theWrkP->group = 0x4008; theWrkP->element = 0x0117; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papResultsDistributionListSequence]; theWrkP->group = 0x4008; theWrkP->element = 0x0118; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Interpretation Approval */ /********************************************************************************/ /* */ /* init_InterpretationIdentification : initializes the elements of the module*/ /* Interpretation Identification */ /* */ /********************************************************************************/ void init_InterpretationIdentification (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papInterpretationID]; theWrkP->group = 0x4008; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationIDIssuer]; theWrkP->group = 0x4008; theWrkP->element = 0x0202; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Interpretation Identification */ /********************************************************************************/ /* */ /* init_InterpretationRecording : initializes the elements of the module */ /* Interpretation Recording */ /* */ /********************************************************************************/ void init_InterpretationRecording (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papInterpretationRecordedDate]; theWrkP->group = 0x4008; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationRecordedTime]; theWrkP->group = 0x4008; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationRecorder]; theWrkP->group = 0x4008; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencetoRecordedSound]; theWrkP->group = 0x4008; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Interpretation Recording */ /********************************************************************************/ /* */ /* init_InterpretationRelationship : initializes the elements of the module*/ /* Interpretation Relationship */ /* */ /********************************************************************************/ void init_InterpretationRelationship (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedResultsSequenceIR]; theWrkP->group = 0x0008; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Interpretation Relationship */ /********************************************************************************/ /* */ /* init_InterpretationState : initializes the elements of the module */ /* Interpretation State */ /* */ /********************************************************************************/ void init_InterpretationState (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papInterpretationTypeID]; theWrkP->group = 0x4008; theWrkP->element = 0x0210; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationStatusID]; theWrkP->group = 0x4008; theWrkP->element = 0x0212; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Interpretation State */ /********************************************************************************/ /* */ /* init_InterpretationTranscription : initializes the elements of the module*/ /* Interpretation Transcription */ /* */ /********************************************************************************/ void init_InterpretationTranscription (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papInterpretationTranscriptionDate]; theWrkP->group = 0x4008; theWrkP->element = 0x0108; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationTranscriptionTime]; theWrkP->group = 0x4008; theWrkP->element = 0x0109; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationTranscriber]; theWrkP->group = 0x4008; theWrkP->element = 0x010A; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationText]; theWrkP->group = 0x4008; theWrkP->element = 0x010B; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterpretationAuthor]; theWrkP->group = 0x4008; theWrkP->element = 0x010C; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Interpretation Transcription */ /********************************************************************************/ /* */ /* init_IntraOralImage : initializes the elements of the module */ /* Intra-Oral Image */ /* */ /********************************************************************************/ void init_IntraOralImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPositionerTypeIOI]; theWrkP->group = 0x0018; theWrkP->element = 0x1508; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageLateralityIOI]; theWrkP->group = 0x0020; theWrkP->element = 0x0062; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnatomicRegionSequenceIOI]; theWrkP->group = 0x0008; theWrkP->element = 0x2218; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnatomicRegionModifierSequenceIOI]; theWrkP->group = 0x0008; theWrkP->element = 0x2220; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrimaryAnatomicStructureSequenceIOI]; theWrkP->group = 0x0008; theWrkP->element = 0x2228; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_IntraOral Image */ /********************************************************************************/ /* */ /* init_IntraOralSeries : initializes the elements of the module */ /* Intra-Oral Series */ /* */ /********************************************************************************/ void init_IntraOralSeries (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papModalityIOS]; theWrkP->group = 0x0008; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_IntraOral Series */ /********************************************************************************/ /* */ /* init_LUTIdentification : initializes the elements of the module */ /* LUT Identification */ /* */ /********************************************************************************/ void init_LUTIdentification (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papLUTNumber]; theWrkP->group = 0x0020; theWrkP->element = 0x0026; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageSequenceLI]; theWrkP->group = 0x0008; theWrkP->element = 0x1140; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_LUT Identification */ /********************************************************************************/ /* */ /* init_MammographyImage : initializes the elements of the module */ /* Mammography Image */ /* */ /********************************************************************************/ void init_MammographyImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPositionerTypeMI]; theWrkP->group = 0x0018; theWrkP->element = 0x1508; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionerPrimaryAngleMI]; theWrkP->group = 0x0018; theWrkP->element = 0x1510; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPositionerSecondaryAngleMI]; theWrkP->group = 0x0018; theWrkP->element = 0x1511; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageLateralityMI]; theWrkP->group = 0x0020; theWrkP->element = 0x0062; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrganExposedMI]; theWrkP->group = 0x0040; theWrkP->element = 0x0318; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnatomicRegionSequenceMI]; theWrkP->group = 0x0008; theWrkP->element = 0x2218; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewCodeSequenceMI]; theWrkP->group = 0x0054; theWrkP->element = 0x0220; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewModifierCodeSequenceMI]; theWrkP->group = 0x0054; theWrkP->element = 0x0222; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Mammography Image */ /********************************************************************************/ /* */ /* init_MammographySeries : initializes the elements of the module */ /* Mammography Series */ /* */ /********************************************************************************/ void init_MammographySeries (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papModalityMS]; theWrkP->group = 0x0008; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Mammography Series */ /********************************************************************************/ /* */ /* init_Mask : initializes the elements of the module */ /* Mask */ /* */ /********************************************************************************/ void init_Mask (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papMaskSubtractionSequence]; theWrkP->group = 0x0028; theWrkP->element = 0x6100; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRecommendedViewingMode]; theWrkP->group = 0x0028; theWrkP->element = 0x1090; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Mask */ /********************************************************************************/ /* */ /* init_ModalityLUT : initializes the elements of the module */ /* Modality LUT */ /* */ /********************************************************************************/ void init_ModalityLUT (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papModalityLUTSequence]; theWrkP->group = 0x0028; theWrkP->element = 0x3000; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleInterceptML]; theWrkP->group = 0x0028; theWrkP->element = 0x1052; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleSlopeML]; theWrkP->group = 0x0028; theWrkP->element = 0x1053; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleType]; theWrkP->group = 0x0028; theWrkP->element = 0x1054; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Modality LUT */ /********************************************************************************/ /* */ /* init_MRImage : initializes the elements of the module */ /* MR Image */ /* */ /********************************************************************************/ void init_MRImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImageTypeMRI]; theWrkP->group = 0x0008; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSamplesperPixelMRI]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretationMRI]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedMRI]; theWrkP->group = 0x0028; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScanningSequence]; theWrkP->group = 0x0018; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSequenceVariant]; theWrkP->group = 0x0018; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScanOptionsMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMRAcquisitionTypeMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x0023; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRepetitionTime]; theWrkP->group = 0x0018; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEchoTime]; theWrkP->group = 0x0018; theWrkP->element = 0x0081; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEchoTrainLength]; theWrkP->group = 0x0018; theWrkP->element = 0x0091; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInversionTime]; theWrkP->group = 0x0018; theWrkP->element = 0x0082; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTriggerTimeMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1060; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSequenceName]; theWrkP->group = 0x0018; theWrkP->element = 0x0024; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAngioFlag]; theWrkP->group = 0x0018; theWrkP->element = 0x0025; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofAverages]; theWrkP->group = 0x0018; theWrkP->element = 0x0083; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagingFrequency]; theWrkP->group = 0x0018; theWrkP->element = 0x0084; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagedNucleus]; theWrkP->group = 0x0018; theWrkP->element = 0x0085; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEchoNumber]; theWrkP->group = 0x0018; theWrkP->element = 0x0086; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMagneticFieldStrength]; theWrkP->group = 0x0018; theWrkP->element = 0x0087; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpacingBetweenSlices]; theWrkP->group = 0x0018; theWrkP->element = 0x0088; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofPhaseEncodingSteps]; theWrkP->group = 0x0018; theWrkP->element = 0x0089; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPercentSampling]; theWrkP->group = 0x0018; theWrkP->element = 0x0093; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPercentPhaseFieldofView]; theWrkP->group = 0x0018; theWrkP->element = 0x0094; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelBandwidth]; theWrkP->group = 0x0018; theWrkP->element = 0x0095; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNominalIntervalMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1062; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeatRejectionFlagMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1080; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLowRRValueMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1081; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighRRValueMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1082; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIntervalsAcquiredMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1083; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIntervalsRejectedMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1084; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPVCRejectionMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1085; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSkipBeatsMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1086; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHeartRateMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1088; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCardiacNumberofImagesMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1090; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTriggerWindow]; theWrkP->group = 0x0018; theWrkP->element = 0x1094; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReconstructionDiameterMRI]; theWrkP->group = 0x0018; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReceivingCoil]; theWrkP->group = 0x0018; theWrkP->element = 0x1250; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransmittingCoil]; theWrkP->group = 0x0018; theWrkP->element = 0x1251; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionMatrix]; theWrkP->group = 0x0018; theWrkP->element = 0x1310; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "4"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhaseEncodingDirection]; theWrkP->group = 0x0018; theWrkP->element = 0x1312; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFlipAngle]; theWrkP->group = 0x0018; theWrkP->element = 0x1314; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSAR]; theWrkP->group = 0x0018; theWrkP->element = 0x1316; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVariableFlipAngleFlag]; theWrkP->group = 0x0018; theWrkP->element = 0x1315; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papdBdt]; theWrkP->group = 0x0018; theWrkP->element = 0x1318; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTemporalPositionIdentifier]; theWrkP->group = 0x0020; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofTemporalPositions]; theWrkP->group = 0x0020; theWrkP->element = 0x0105; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTemporalResolution]; theWrkP->group = 0x0020; theWrkP->element = 0x0110; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_MR Image */ /********************************************************************************/ /* */ /* init_Multi_Frame : initializes the elements of the module */ /* Multi_Frame */ /* */ /********************************************************************************/ void init_Multi_Frame (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papNumberofFrames]; theWrkP->group = 0x0028; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameIncrementPointerMF]; theWrkP->group = 0x0028; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Multi_Frame */ /********************************************************************************/ /* */ /* init_Multi_frameOverlay : initializes the elements of the module */ /* Mult_frame Overlay */ /* */ /********************************************************************************/ void init_Multi_frameOverlay (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papNumberofFramesinOverlay]; theWrkP->group = 0x6000; theWrkP->element = 0x0015; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageFrameOrigin]; theWrkP->group = 0x6000; theWrkP->element = 0x0051; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Multi_frame Overlay */ /********************************************************************************/ /* */ /* init_NMDetector : initializes the elements of the module */ /* NM Detector */ /* */ /********************************************************************************/ void init_NMDetector (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papDetectorInformationSequence]; theWrkP->group = 0x0054; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_NM Detector */ /********************************************************************************/ /* */ /* init_NMImage : initializes the elements of the module */ /* NM Image */ /* */ /********************************************************************************/ void init_NMImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImageType]; theWrkP->group = 0x0008; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageID]; theWrkP->group = 0x0054; theWrkP->element = 0x0400; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLossyImageCompressionNMI]; theWrkP->group = 0x0028; theWrkP->element = 0x2110; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCountsAccumulated]; theWrkP->group = 0x0018; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionTerminationCondition]; theWrkP->group = 0x0018; theWrkP->element = 0x0071; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableHeightNMI]; theWrkP->group = 0x0018; theWrkP->element = 0x1130; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTraverseNMI]; theWrkP->group = 0x0018; theWrkP->element = 0x1131; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papActualFrameDurationNMI]; theWrkP->group = 0x0018; theWrkP->element = 0x1242; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCountRate]; theWrkP->group = 0x0018; theWrkP->element = 0x1243; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPreprocessingFunctionNMI]; theWrkP->group = 0x0018; theWrkP->element = 0x5020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCorrectedImage]; theWrkP->group = 0x0028; theWrkP->element = 0x0051; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWholeBodyTechnique]; theWrkP->group = 0x0018; theWrkP->element = 0x1301; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScanVelocity]; theWrkP->group = 0x0018; theWrkP->element = 0x1300; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScanLength]; theWrkP->group = 0x0018; theWrkP->element = 0x1302; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedOverlaySequenceNMI]; theWrkP->group = 0x0008; theWrkP->element = 0x1130; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedCurveSequenceNMI]; theWrkP->group = 0x0008; theWrkP->element = 0x1145; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTriggerSourceorType]; theWrkP->group = 0x0018; theWrkP->element = 0x1061; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnatomicRegionSequence]; theWrkP->group = 0x0008; theWrkP->element = 0x2218; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrimaryAnatomicStructureSequence]; theWrkP->group = 0x0008; theWrkP->element = 0x2228; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_NM Image */ /********************************************************************************/ /* */ /* init_NMImagePixel : initializes the elements of the module */ /* NM Image Pixel */ /* */ /********************************************************************************/ void init_NMImagePixel (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papSamplesperPixel]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretation]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocated]; theWrkP->group = 0x0028; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsStored]; theWrkP->group = 0x0028; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighBit]; theWrkP->group = 0x0028; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelSpacingNM]; theWrkP->group = 0x0028; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_NM Image Pixel*/ /********************************************************************************/ /* */ /* init_NMIsotope : initializes the elements of the module */ /* NM Isotope */ /* */ /********************************************************************************/ void init_NMIsotope (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papEnergyWindowInformationSequence]; theWrkP->group = 0x0054; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiopharmaceuticalInformationSequence]; theWrkP->group = 0x0054; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterventionDrugInformationSequence]; theWrkP->group = 0x0018; theWrkP->element = 0x0026; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_NM Isotope*/ /********************************************************************************/ /* */ /* init_NMMultiFrame : initializes the elements of the module */ /* NM Multi Frame */ /* */ /********************************************************************************/ void init_NMMultiFrame (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papFrameIncrementPointer]; theWrkP->group = 0x0028; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowVector]; theWrkP->group = 0x0054; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofEnergyWindows]; theWrkP->group = 0x0054; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorVector]; theWrkP->group = 0x0054; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofDetectors]; theWrkP->group = 0x0054; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhaseVector]; theWrkP->group = 0x0054; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofPhases]; theWrkP->group = 0x0054; theWrkP->element = 0x0031; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRotationVector]; theWrkP->group = 0x0054; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofRotations]; theWrkP->group = 0x0054; theWrkP->element = 0x0051; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRRIntervalVector]; theWrkP->group = 0x0054; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofRRIntervals]; theWrkP->group = 0x0054; theWrkP->element = 0x0061; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeSlotVector]; theWrkP->group = 0x0054; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofTimeSlots]; theWrkP->group = 0x0054; theWrkP->element = 0x0071; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSliceVector]; theWrkP->group = 0x0054; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofSlices]; theWrkP->group = 0x0054; theWrkP->element = 0x0081; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAngularViewVector]; theWrkP->group = 0x0054; theWrkP->element = 0x0090; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeSliceVector]; theWrkP->group = 0x0054; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_NM Multi Frame */ /********************************************************************************/ /* */ /* init_NMMulti_gatedAcquisitionImage : initializes the elements of the module*/ /* NM Multi_gated Acquisition Image */ /* */ /********************************************************************************/ void init_NMMulti_gatedAcquisitionImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papBeatRejectionFlagNMAI]; theWrkP->group = 0x0018; theWrkP->element = 0x1080; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPVCRejectionNMAI]; theWrkP->group = 0x0018; theWrkP->element = 0x1085; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSkipBeatsNMAI]; theWrkP->group = 0x0018; theWrkP->element = 0x1086; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHeartRateNMAI]; theWrkP->group = 0x0018; theWrkP->element = 0x1088; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGatedInformationSequenceNMAI]; theWrkP->group = 0x0054; theWrkP->element = 0x0062; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_NM Multi_gated Acquisition Image */ /********************************************************************************/ /* */ /* init_NMPhase : initializes the elements of the module */ /* NM Phase */ /* */ /********************************************************************************/ void init_NMPhase (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPhaseInformationSequence]; theWrkP->group = 0x0054; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_NM Phase */ /********************************************************************************/ /* */ /* init_NMReconstruction : initializes the elements of the module */ /* NM Reconstruction */ /* */ /********************************************************************************/ void init_NMReconstruction (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papSpacingBetweenSlicesNM]; theWrkP->group = 0x0018; theWrkP->element = 0x0088; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReconstructionDiameter]; theWrkP->group = 0x0018; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConvolutionKernel]; theWrkP->group = 0x0018; theWrkP->element = 0x1210; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSliceThicknessNM]; theWrkP->group = 0x0018; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSliceLocationNM]; theWrkP->group = 0x0020; theWrkP->element = 0x1041; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_NM Reconstruction */ /********************************************************************************/ /* */ /* init_NMSeries : initializes the elements of the module */ /* NM Series */ /* */ /********************************************************************************/ void init_NMSeries (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPatientOrientationCodeSequence]; theWrkP->group = 0x0054; theWrkP->element = 0x0410; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientGantryRelationshipCodeSequence]; theWrkP->group = 0x0054; theWrkP->element = 0x0414; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_NM Series */ /********************************************************************************/ /* */ /* init_NMTomoAcquisition : initializes the elements of the module */ /* NM Tomo Acquisition */ /* */ /********************************************************************************/ void init_NMTomoAcquisition (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papRotationInformationSequence]; theWrkP->group = 0x0054; theWrkP->element = 0x0052; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTypeofDetectorMotion]; theWrkP->group = 0x0054; theWrkP->element = 0x0202; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_NM TomoAcquisition */ /********************************************************************************/ /* */ /* init_OverlayIdentification : initializes the elements of the module */ /* Overlay Identification */ /* */ /********************************************************************************/ void init_OverlayIdentification (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOverlayNumber]; theWrkP->group = 0x0020; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDate]; theWrkP->group = 0x0008; theWrkP->element = 0x0024; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayTime]; theWrkP->group = 0x0008; theWrkP->element = 0x0034; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageSequenceOI]; theWrkP->group = 0x0008; theWrkP->element = 0x1140; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Overlay Identification */ /********************************************************************************/ /* */ /* init_OverlayPlane : initializes the elements of the module */ /* Overlay Plane */ /* */ /********************************************************************************/ void init_OverlayPlane (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papRowsOP]; theWrkP->group = 0x6000; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papColumnsOP]; theWrkP->group = 0x6000; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayType]; theWrkP->group = 0x6000; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrigin]; theWrkP->group = 0x6000; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SS; theWrkP->vm = "2"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedOP]; theWrkP->group = 0x6000; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitPosition]; theWrkP->group = 0x6000; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayData]; theWrkP->group = 0x6000; theWrkP->element = 0x3000; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDescription]; theWrkP->group = 0x6000; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaySubtypeOP]; theWrkP->group = 0x6000; theWrkP->element = 0x0045; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayLabel]; theWrkP->group = 0x6000; theWrkP->element = 0x1500; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIArea]; theWrkP->group = 0x6000; theWrkP->element = 0x1301; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIMean]; theWrkP->group = 0x6000; theWrkP->element = 0x1302; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papROIStandardDeviation]; theWrkP->group = 0x6000; theWrkP->element = 0x1303; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDescriptorGray]; theWrkP->group = 0x6000; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDescriptorRed]; theWrkP->group = 0x6000; theWrkP->element = 0x1101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDescriptorGreen]; theWrkP->group = 0x6000; theWrkP->element = 0x1102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlayDescriptorBlue]; theWrkP->group = 0x6000; theWrkP->element = 0x1103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaysGray]; theWrkP->group = 0x6000; theWrkP->element = 0x1200; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaysRed]; theWrkP->group = 0x6000; theWrkP->element = 0x1201; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaysGreen]; theWrkP->group = 0x6000; theWrkP->element = 0x1202; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaysBlue]; theWrkP->group = 0x6000; theWrkP->element = 0x1203; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = RET; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Overlay Plane */ /********************************************************************************/ /* */ /* init_PaletteColorLookup : initializes the elements of the module */ /* Palette Color Lookup */ /* */ /********************************************************************************/ void init_PaletteColorLookup (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papRedPaletteColorLookupTableDescriptorPCL]; theWrkP->group = 0x0028; theWrkP->element = 0x1101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGreenPaletteColorLookupTableDescriptorPCL]; theWrkP->group = 0x0028; theWrkP->element = 0x1102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBluePaletteColorLookupTableDescriptorPCL]; theWrkP->group = 0x0028; theWrkP->element = 0x1103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "3"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPaletteColorLookupTableUID]; theWrkP->group = 0x0028; theWrkP->element = 0x1199; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRedPaletteCLUTData]; theWrkP->group = 0x0028; theWrkP->element = 0x1201; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGreenPaletteCLUTData]; theWrkP->group = 0x0028; theWrkP->element = 0x1202; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBluePaletteCLUTData]; theWrkP->group = 0x0028; theWrkP->element = 0x1203; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSegmentedRedPaletteColorLookupTableData]; theWrkP->group = 0x0028; theWrkP->element = 0x1221; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSegmentedGreenPaletteColorLookupTableData]; theWrkP->group = 0x0028; theWrkP->element = 0x1222; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSegmentedBluePaletteColorLookupTableData]; theWrkP->group = 0x0028; theWrkP->element = 0x1223; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Palette Color Lookup */ /********************************************************************************/ /* */ /* init_Patient : initializes the elements of the module */ /* Patient */ /* */ /********************************************************************************/ void init_Patient (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPatientsNameP]; theWrkP->group = 0x0010; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientIDP]; theWrkP->group = 0x0010; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsBirthDateP]; theWrkP->group = 0x0010; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsSexP]; theWrkP->group = 0x0010; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedPatientSequenceP]; theWrkP->group = 0x0008; theWrkP->element = 0x1120; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsBirthTimeP]; theWrkP->group = 0x0010; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOtherPatientID]; theWrkP->group = 0x0010; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOtherPatientNamesP]; theWrkP->group = 0x0010; theWrkP->element = 0x1001; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEthnicGroupP]; theWrkP->group = 0x0010; theWrkP->element = 0x2160; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientCommentsP]; theWrkP->group = 0x0010; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Patient */ /********************************************************************************/ /* */ /* init_PatientDemographic : initializes the elements of the module */ /* Patient Demographic */ /* */ /********************************************************************************/ void init_PatientDemographic (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPatientsAddress]; theWrkP->group = 0x0010; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRegionofResidence]; theWrkP->group = 0x0010; theWrkP->element = 0x2152; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCountryofResidence]; theWrkP->group = 0x0010; theWrkP->element = 0x2150; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsTelephoneNumbers]; theWrkP->group = 0x0010; theWrkP->element = 0x2154; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsBirthDatePD]; theWrkP->group = 0x0010; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsBirthTimePD]; theWrkP->group = 0x0010; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEthnicGroupPD]; theWrkP->group = 0x0010; theWrkP->element = 0x2160; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsSexPD]; theWrkP->group = 0x0010; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsSizePD]; theWrkP->group = 0x0010; theWrkP->element = 0x1020; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsWeightPD]; theWrkP->group = 0x0010; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMilitaryRank]; theWrkP->group = 0x0010; theWrkP->element = 0x1080; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBranchofService]; theWrkP->group = 0x0010; theWrkP->element = 0x1081; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsInsurancePlanCodeSequence]; theWrkP->group = 0x0010; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsReligiousPreference]; theWrkP->group = 0x0010; theWrkP->element = 0x21F0; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientCommentsPD]; theWrkP->group = 0x0010; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Patient Demographic */ /********************************************************************************/ /* */ /* init_PatientIdentification : initializes the elements of the module */ /* Patient Identification */ /* */ /********************************************************************************/ void init_PatientIdentification (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPatientsNamePI]; theWrkP->group = 0x0010; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientIDPI]; theWrkP->group = 0x0010; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIssuerofPatientID]; theWrkP->group = 0x0010; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOtherPatientIDs]; theWrkP->group = 0x0010; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOtherPatientNamesPI]; theWrkP->group = 0x0010; theWrkP->element = 0x1001; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsBirthName]; theWrkP->group = 0x0010; theWrkP->element = 0x1005; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsMothersBirthName]; theWrkP->group = 0x0010; theWrkP->element = 0x1060; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMedicalRecordLocator]; theWrkP->group = 0x0010; theWrkP->element = 0x1090; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Patient Identification */ /********************************************************************************/ /* */ /* init_PatientMedical : initializes the elements of the module */ /* Patient Medical */ /* */ /********************************************************************************/ void init_PatientMedical (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPatientState]; theWrkP->group = 0x0038; theWrkP->element = 0x0500; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPregnancyStatus]; theWrkP->group = 0x0010; theWrkP->element = 0x21C0; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMedicalAlerts]; theWrkP->group = 0x0010; theWrkP->element = 0x2000; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContrastAllergies]; theWrkP->group = 0x0010; theWrkP->element = 0x2110; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecialNeeds]; theWrkP->group = 0x0038; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLastMenstrualDate]; theWrkP->group = 0x0010; theWrkP->element = 0x21D0; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSmokingStatus]; theWrkP->group = 0x0010; theWrkP->element = 0x21A0; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdditionalPatientHistory]; theWrkP->group = 0x0010; theWrkP->element = 0x21B0; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Patient Medical */ /********************************************************************************/ /* */ /* init_PatientRelationship : initializes the elements of the module */ /* Patient Relationship */ /* */ /********************************************************************************/ void init_PatientRelationship (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedVisitSequencePR]; theWrkP->group = 0x0008; theWrkP->element = 0x1125; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedStudySequencePR]; theWrkP->group = 0x0008; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedPatientAliasSequence]; theWrkP->group = 0x0038; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Patient Relationship */ /********************************************************************************/ /* */ /* init_PatientStudy : initializes the elements of the module */ /* Patient Study */ /* */ /********************************************************************************/ void init_PatientStudy (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papAdmittingDiagnosesDescription]; theWrkP->group = 0x0008; theWrkP->element = 0x1080; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsAge]; theWrkP->group = 0x0010; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = AS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsSizePS]; theWrkP->group = 0x0010; theWrkP->element = 0x1020; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsWeightPS]; theWrkP->group = 0x0010; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOccupation]; theWrkP->group = 0x0010; theWrkP->element = 0x2180; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdditionalPatientsHistory]; theWrkP->group = 0x0010; theWrkP->element = 0x21B0; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Patient Study */ /********************************************************************************/ /* */ /* init_PETCurve : initializes the elements of the module */ /* PET Curve */ /* */ /********************************************************************************/ void init_PETCurve (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papCurveDimensionsPC]; theWrkP->group = 0x5000; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTypeofDataPC]; theWrkP->group = 0x5000; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurveDataPC]; theWrkP->group = 0x5000; theWrkP->element = 0x3000; theWrkP->length = 0L; theWrkP->vr = OW; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAxisUnitsPC]; theWrkP->group = 0x5000; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeadTimeCorrectionFlag]; theWrkP->group = 0x0054; theWrkP->element = 0x1401; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCountsIncluded]; theWrkP->group = 0x0054; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPreprocessingFunction]; theWrkP->group = 0x0018; theWrkP->element = 0x5020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_PETCurve */ /********************************************************************************/ /* */ /* init_PETImage : initializes the elements of the module */ /* PET Image */ /* */ /********************************************************************************/ void init_PETImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImageTypePI]; theWrkP->group = 0x0008; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSamplesPerPixelPI]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretationPI]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedPI]; theWrkP->group = 0x0028; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsStoredPI]; theWrkP->group = 0x0028; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighBitPI]; theWrkP->group = 0x0028; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleInterceptPI]; theWrkP->group = 0x0028; theWrkP->element = 0x1052; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleSlopePI]; theWrkP->group = 0x0028; theWrkP->element = 0x1053; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameReferenceTime]; theWrkP->group = 0x0054; theWrkP->element = 0x1300; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTriggerTime]; theWrkP->group = 0x0018; theWrkP->element = 0x1060; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameTime]; theWrkP->group = 0x0018; theWrkP->element = 0x1063; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLowRRValue]; theWrkP->group = 0x0018; theWrkP->element = 0x1081; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighRRValue]; theWrkP->group = 0x0018; theWrkP->element = 0x1082; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLossyImageCompression]; theWrkP->group = 0x0028; theWrkP->element = 0x2110; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageIndex]; theWrkP->group = 0x0054; theWrkP->element = 0x1330; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionDatePI]; theWrkP->group = 0x0008; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionTimePI]; theWrkP->group = 0x0008; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papActualFrameDuration]; theWrkP->group = 0x0018; theWrkP->element = 0x1242; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNominalInterval]; theWrkP->group = 0x0018; theWrkP->element = 0x1062; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIntervalsAcquired]; theWrkP->group = 0x0018; theWrkP->element = 0x1083; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIntervalsRejected]; theWrkP->group = 0x0018; theWrkP->element = 0x1084; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrimaryCountsAccumulated]; theWrkP->group = 0x0054; theWrkP->element = 0x1310; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSecondaryCountsAccumulated]; theWrkP->group = 0x0054; theWrkP->element = 0x1311; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSliceSensitivityFactor]; theWrkP->group = 0x0054; theWrkP->element = 0x1320; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDecayFactor]; theWrkP->group = 0x0054; theWrkP->element = 0x1321; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseCalibrationFactor]; theWrkP->group = 0x0054; theWrkP->element = 0x1322; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScatterFractionFactor]; theWrkP->group = 0x0054; theWrkP->element = 0x1323; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeadTimeFactor]; theWrkP->group = 0x0054; theWrkP->element = 0x1324; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedOverlaySequence]; theWrkP->group = 0x0008; theWrkP->element = 0x1130; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedCurveSequence]; theWrkP->group = 0x0008; theWrkP->element = 0x1145; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnatomicRegionSequencePI]; theWrkP->group = 0x0008; theWrkP->element = 0x2218; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrimaryAnatomicStructureSequencePI]; theWrkP->group = 0x0008; theWrkP->element = 0x2228; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_PETImage */ /********************************************************************************/ /* */ /* init_PETIsotope : initializes the elements of the module */ /* PET Isotope */ /* */ /********************************************************************************/ void init_PETIsotope (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papRadiopharmaceuticalInformationSequencePI]; theWrkP->group = 0x0054; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInterventionDrugInformationSequencePI]; theWrkP->group = 0x0018; theWrkP->element = 0x0026; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_PETIsotope */ /********************************************************************************/ /* */ /* init_PETMultiGatedAcquisition : initializes the elements of the module */ /* PET Multi-gated Acquisition */ /* */ /********************************************************************************/ void init_PETMultiGatedAcquisition (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papBeatRejectionFlag]; theWrkP->group = 0x0018; theWrkP->element = 0x1080; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTriggerSourceOrType]; theWrkP->group = 0x0018; theWrkP->element = 0x1061; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPVCRejection]; theWrkP->group = 0x0018; theWrkP->element = 0x1085; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSkipBeats]; theWrkP->group = 0x0018; theWrkP->element = 0x1086; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHeartRate]; theWrkP->group = 0x0018; theWrkP->element = 0x1088; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFramingType]; theWrkP->group = 0x0018; theWrkP->element = 0x1064; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_PETMultiGatedAcquisition */ /********************************************************************************/ /* */ /* init_PatientSummary : initializes the elements of the module */ /* Patient Summary */ /* */ /********************************************************************************/ void init_PatientSummary (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPatientsNamePS]; theWrkP->group = 0x0010; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientIDPS]; theWrkP->group = 0x0010; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Patient Summary */ /********************************************************************************/ /* */ /* init_PETSeries : initializes the elements of the module */ /* PET Series */ /* */ /********************************************************************************/ void init_PETSeries (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papSeriesDatePET]; theWrkP->group = 0x00081; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesTimePET]; theWrkP->group = 0x0008; theWrkP->element = 0x0031; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papUnits]; theWrkP->group = 0x0054; theWrkP->element = 0x1001; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCountsSource]; theWrkP->group = 0x0054; theWrkP->element = 0x1002; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesTypeGr]; theWrkP->group = 0x0054; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReprojectionMethod]; theWrkP->group = 0x0054; theWrkP->element = 0x1004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofRRIntervalsPET]; theWrkP->group = 0x0054; theWrkP->element = 0x0061; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofTimeSlotsPET]; theWrkP->group = 0x0054; theWrkP->element = 0x0071; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofSlicesPET]; theWrkP->group = 0x0054; theWrkP->element = 0x0081; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofRotationsPET]; theWrkP->group = 0x0054; theWrkP->element = 0x0051; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRandomsCorrectionMethod]; theWrkP->group = 0x0054; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAttenuationCorrectionMethod]; theWrkP->group = 0x0054; theWrkP->element = 0x1101; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScatterCorrectionMethod]; theWrkP->group = 0x0054; theWrkP->element = 0x1105; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDecayCorrection]; theWrkP->group = 0x0054; theWrkP->element = 0x1102; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReconstructionDiameterPET]; theWrkP->group = 0x0018; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConvolutionKernelPET]; theWrkP->group = 0x0018; theWrkP->element = 0x1210; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReconstructionMethod]; theWrkP->group = 0x0054; theWrkP->element = 0x1103; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorLinesOfResponseUsed]; theWrkP->group = 0x0054; theWrkP->element = 0x1104; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionStartCondition]; theWrkP->group = 0x0018; theWrkP->element = 0x0073; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionStartConditionData]; theWrkP->group = 0x0018; theWrkP->element = 0x0074; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionTerminationConditionPET]; theWrkP->group = 0x0018; theWrkP->element = 0x0071; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionTerminationConditionData]; theWrkP->group = 0x0018; theWrkP->element = 0x0075; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewShape]; theWrkP->group = 0x0018; theWrkP->element = 0x1147; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewDimensions]; theWrkP->group = 0x0018; theWrkP->element = 0x1149; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGantryDetectorTilt]; theWrkP->group = 0x0018; theWrkP->element = 0x1120; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGantryDetectorSlew]; theWrkP->group = 0x0018; theWrkP->element = 0x1121; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTypeofDetectorMotionPET]; theWrkP->group = 0x0054; theWrkP->element = 0x0202; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorType]; theWrkP->group = 0x0018; theWrkP->element = 0x1181; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorgridName]; theWrkP->group = 0x0018; theWrkP->element = 0x1180; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAxialAcceptance]; theWrkP->group = 0x0054; theWrkP->element = 0x1200; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAxialMash]; theWrkP->group = 0x0054; theWrkP->element = 0x1201; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransverseMash]; theWrkP->group = 0x0054; theWrkP->element = 0x1202; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDetectorElementSize]; theWrkP->group = 0x0054; theWrkP->element = 0x1203; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCoincidenceWindowWidth]; theWrkP->group = 0x0054; theWrkP->element = 0x1210; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowRangeSequence]; theWrkP->group = 0x0054; theWrkP->element = 0x0013; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowLowerLimit]; theWrkP->group = 0x0054; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEnergyWindowUpperLimit]; theWrkP->group = 0x0054; theWrkP->element = 0x0015; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSecondaryCountsType]; theWrkP->group = 0x0054; theWrkP->element = 0x1220; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_PETSeries */ /********************************************************************************/ /* */ /* init_PixelOffset : initializes the elements of the module */ /* Pixel Offset */ /* */ /********************************************************************************/ void init_PixelOffset (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPixelOffset]; theWrkP->group = 0x0041; theWrkP->element = 0x1012; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Pixel Offset */ /********************************************************************************/ /* */ /* init_Printer : initializes the elements of the module */ /* Printer */ /* */ /********************************************************************************/ void init_Printer (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPrinterStatus]; theWrkP->group = 0x2110; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrinterStatusInfo]; theWrkP->group = 0x2110; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrinterNameP]; theWrkP->group = 0x2110; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papManufacturerP]; theWrkP->group = 0x0008; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papManufacturerModelName]; theWrkP->group = 0x0008; theWrkP->element = 0x1090; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDeviceSerialNumberP]; theWrkP->group = 0x0018; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSoftwareVersionsP]; theWrkP->group = 0x0018; theWrkP->element = 0x1020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDateOfLastCalibration]; theWrkP->group = 0x0018; theWrkP->element = 0x1200; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeOfLastCalibration]; theWrkP->group = 0x0018; theWrkP->element = 0x1201; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Printer */ /********************************************************************************/ /* */ /* init_PrintJob : initializes the elements of the module */ /* Print Job */ /* */ /********************************************************************************/ void init_PrintJob (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papExecutionStatus]; theWrkP->group = 0x2100; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExecutionStatusInfo]; theWrkP->group = 0x2100; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCreationDate]; theWrkP->group = 0x2100; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCreationTime]; theWrkP->group = 0x2100; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrintPriorityPJ]; theWrkP->group = 0x2000; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrinterNamePJ]; theWrkP->group = 0x2110; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOriginator]; theWrkP->group = 0x2100; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = AE; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Print Job */ /********************************************************************************/ /* */ /* init_ResultIdentification : initializes the elements of the module */ /* Result Identification */ /* */ /********************************************************************************/ void init_ResultIdentification (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papResultsID]; theWrkP->group = 0x4008; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papResultsIDIssuer]; theWrkP->group = 0x4008; theWrkP->element = 0x0042; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Result Identification */ /********************************************************************************/ /* */ /* init_ResultsImpression : initializes the elements of the module */ /* Results Impression */ /* */ /********************************************************************************/ void init_ResultsImpression (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImpressions]; theWrkP->group = 0x4008; theWrkP->element = 0x0300; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papResultsComments]; theWrkP->group = 0x4008; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Results Impression */ /********************************************************************************/ /* */ /* init_ResultRelationship : initializes the elements of the module */ /* Result Relationship */ /* */ /********************************************************************************/ void init_ResultRelationship (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedStudySequenceRR]; theWrkP->group = 0x0008; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedInterpretationSequence]; theWrkP->group = 0x4008; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Result Relationship */ /********************************************************************************/ /* */ /* init_RFTomographyAcquisition : initializes the elements of the module */ /* RF Tomography Acquisition module */ /* */ /********************************************************************************/ void init_RFTomographyAcquisition (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papTornoLayerHeight]; theWrkP->group = 0x0018; theWrkP->element = 0x1460; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTornoAngle]; theWrkP->group = 0x0018; theWrkP->element = 0x1470; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTornoTime]; theWrkP->group = 0x0018; theWrkP->element = 0x1480; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RFTomographyAcquisition */ /********************************************************************************/ /* */ /* init_ROIContour : initializes the elements of the module */ /* ROI Contour */ /* */ /********************************************************************************/ void init_ROIContour (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papROIContourSequence]; theWrkP->group = 0x3006; theWrkP->element = 0x0039; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papContourNumber]; theWrkP->group = 0x3006; theWrkP->element = 0x0048; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAttachedContours]; theWrkP->group = 0x3006; theWrkP->element = 0x0049; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_ROI Contour */ /********************************************************************************/ /* */ /* init_RTBeams : initializes the elements of the module */ /* RT Beams */ /* */ /********************************************************************************/ void init_RTBeams (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papBeamSequence]; theWrkP->group = 0x300A; theWrkP->element = 0x00B0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighDoseTechniqueType]; theWrkP->group = 0x300A; theWrkP->element = 0x00C7; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompensatorNumber]; theWrkP->group = 0x300A; theWrkP->element = 0x00E4; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCompensatorType]; theWrkP->group = 0x300A; theWrkP->element = 0x00EE; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT Beams */ /********************************************************************************/ /* */ /* init_RTBrachyApplicationSetups : initializes the elements of the module */ /* RT Brachy Application Setups */ /* */ /********************************************************************************/ void init_RTBrachyApplicationSetups (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papBrachyTreatmentTechnique]; theWrkP->group = 0x300A; theWrkP->element = 0x0200; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBrachyTreatmentType]; theWrkP->group = 0x300A; theWrkP->element = 0x0202; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentMachineSequence]; theWrkP->group = 0x300A; theWrkP->element = 0x0206; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourceSequence]; theWrkP->group = 0x300A; theWrkP->element = 0x0210; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papApplicationSetupSequence]; theWrkP->group = 0x300A; theWrkP->element = 0x0230; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT Brachy Application Setups */ /********************************************************************************/ /* */ /* init_RTDose : initializes the elements of the module */ /* RT Dose */ /* */ /********************************************************************************/ void init_RTDose (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papSamplesperPixelRTD]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretationRTD]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedRTD]; theWrkP->group = 0x0028; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsStoredRTD]; theWrkP->group = 0x0028; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighBitRTD]; theWrkP->group = 0x0028; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelRepresentationRTD]; theWrkP->group = 0x0028; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseUnitsRTD]; theWrkP->group = 0x3004; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseTypeRTD]; theWrkP->group = 0x3004; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstanceNumber]; theWrkP->group = 0x0020; theWrkP->element = 0x0013; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseCommentRTD]; theWrkP->group = 0x3004; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNormalizationPointRTD]; theWrkP->group = 0x3004; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseSummationTypeRTD]; theWrkP->group = 0x3004; theWrkP->element = 0x000A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedRTPlanSequenceRTD]; theWrkP->group = 0x300C; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridFrameOffsetVectorRTD]; theWrkP->group = 0x3004; theWrkP->element = 0x000C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseGridScalingRTD]; theWrkP->group = 0x3004; theWrkP->element = 0x000E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT Dose*/ /********************************************************************************/ /* */ /* init_RTDoseROI : initializes the elements of the module */ /* RT Dose ROI */ /* */ /********************************************************************************/ void init_RTDoseROI (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papRTDoseROISequence]; theWrkP->group = 0x3004; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT Dose ROI*/ /********************************************************************************/ /* */ /* init_RTDVH : initializes the elements of the module */ /* RT DVH */ /* */ /********************************************************************************/ void init_RTDVH (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedStructureSetSequence]; theWrkP->group = 0x300C; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHNormalizationPoint]; theWrkP->group = 0x3004; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHNormalizationDoseValue]; theWrkP->group = 0x3004; theWrkP->element = 0x0042; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDVHSequence]; theWrkP->group = 0x3004; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT DVH*/ /********************************************************************************/ /* */ /* init_RTFractionScheme : initializes the elements of the module */ /* RT Fraction Scheme */ /* */ /********************************************************************************/ void init_RTFractionScheme (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papFractionGroupSequence]; theWrkP->group = 0x300A; theWrkP->element = 0x0070; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT Fraction Scheme*/ /********************************************************************************/ /* */ /* init_RTGeneralPlan : initializes the elements of the module */ /* RT General Plan */ /* */ /********************************************************************************/ void init_RTGeneralPlan (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papRTPlanLabel]; theWrkP->group = 0x300A; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanName]; theWrkP->group = 0x300A; theWrkP->element = 0x0003; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanDescription]; theWrkP->group = 0x300A; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanInstanceNumber]; theWrkP->group = 0x0020; theWrkP->element = 0x0013; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOperatorsNameRTGP]; theWrkP->group = 0x0008; theWrkP->element = 0x1070; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanDate]; theWrkP->group = 0x300A; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanTime]; theWrkP->group = 0x300A; theWrkP->element = 0x0007; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentProtocols]; theWrkP->group = 0x300A; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentIntent]; theWrkP->group = 0x300A; theWrkP->element = 0x000A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTreatmentSites]; theWrkP->group = 0x300A; theWrkP->element = 0x000B; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTPlanGeometry]; theWrkP->group = 0x300A; theWrkP->element = 0x000C; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedStructureSetSequenceRTGP]; theWrkP->group = 0x300C; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedDoseSequence]; theWrkP->group = 0x300C; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedRTPlanSequence]; theWrkP->group = 0x300C; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT General Plan*/ /********************************************************************************/ /* */ /* init_RTImage : initializes the elements of the module */ /* RT Image */ /* */ /********************************************************************************/ void init_RTImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papSamplesperPixelRTI]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretationRTI]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedRTI]; theWrkP->group = 0x0028; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsStoredRTI]; theWrkP->group = 0x0028; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighBitRTI]; theWrkP->group = 0x0028; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelRepresentationRTI]; theWrkP->group = 0x0028; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImageLabelRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImageNameRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0003; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImageDescriptionRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOperatorsNameRTI]; theWrkP->group = 0x0008; theWrkP->element = 0x1070; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTypeRTI]; theWrkP->group = 0x0008; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papConversionTypeRTI]; theWrkP->group = 0x0008; theWrkP->element = 0x0064; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReportedValuesOriginRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x000A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImagePlaneRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x000C; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXRayImageReceptortranslation]; theWrkP->group = 0x3002; theWrkP->element = 0x000D; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXRayImageReceptorAngleRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x000E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImageOrientationRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "6"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagePlanePixelSpacingRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImagePositionRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiationMachineNameRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrimaryDosimeterUnitRTI]; theWrkP->group = 0x300A; theWrkP->element = 0x00B3; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiationMachineSADRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiationMachineSSDRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0024; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRTImageSIDRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0026; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSourcetoReferenceObjectDistanceRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0028; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedRTPlanSequenceRTI]; theWrkP->group = 0x300C; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedBeamNumberRTI]; theWrkP->group = 0x300C; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFractionGroupNumberRTI]; theWrkP->group = 0x300C; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFractionNumberRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0029; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStartCumulativeMetersetWeightRTI]; theWrkP->group = 0x300C; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEndCumulativeMetersetWeightRTI]; theWrkP->group = 0x300C; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureSequenceRTI]; theWrkP->group = 0x3002; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGantryAngleRTI]; theWrkP->group = 0x300A; theWrkP->element = 0x011E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDiaphragmPosition]; theWrkP->group = 0x3002; theWrkP->element = 0x0034; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "4"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeamLimitingDeviceAngleRTI]; theWrkP->group = 0x300A; theWrkP->element = 0x0120; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientSupportAngleRTI]; theWrkP->group = 0x300A; theWrkP->element = 0x0122; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopEccentricAxisDistanceRTI]; theWrkP->group = 0x300A; theWrkP->element = 0x0124; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopEccentricAngleRTI]; theWrkP->group = 0x300A; theWrkP->element = 0x0125; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopVerticalPositionRTI]; theWrkP->group = 0x300A; theWrkP->element = 0x0128; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopLongitudinalPositionRTI]; theWrkP->group = 0x300A; theWrkP->element = 0x0129; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableTopLateralPositionRTI]; theWrkP->group = 0x300A; theWrkP->element = 0x012A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT Image*/ /********************************************************************************/ /* */ /* init_RTPatientSetup : initializes the elements of the module */ /* RT Patient Setup */ /* */ /********************************************************************************/ void init_RTPatientSetup (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPatientSetupSequence]; theWrkP->group = 0x300A; theWrkP->element = 0x0180; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT Patient Setup*/ /********************************************************************************/ /* */ /* init_RTPrescription : initializes the elements of the module */ /* RT Prescription */ /* */ /********************************************************************************/ void init_RTPrescription (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papPrescriptionDescription]; theWrkP->group = 0x300A; theWrkP->element = 0x000E; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDoseReferenceSequence]; theWrkP->group = 0x300A; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT Prescription*/ /********************************************************************************/ /* */ /* init_RTROIObservations : initializes the elements of the module */ /* RT ROI Observations */ /* */ /********************************************************************************/ void init_RTROIObservations (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papRTROIObservationsSequence]; theWrkP->group = 0x3006; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT ROI Observations*/ /********************************************************************************/ /* */ /* init_RTSeries : initializes the elements of the module */ /* RT Series */ /* */ /********************************************************************************/ void init_RTSeries (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papModalityRTS]; theWrkP->group = 0x0008; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesInstanceUIDRTS]; theWrkP->group = 0x0020; theWrkP->element = 0x000E; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesNumberRTS]; theWrkP->group = 0x0020; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesDescriptionRTS]; theWrkP->group = 0x0008; theWrkP->element = 0x103E; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedStudyComponentSequenceRTS]; theWrkP->group = 0x0008; theWrkP->element = 0x1111; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT Series*/ /********************************************************************************/ /* */ /* init_RTToleranceTables : initializes the elements of the module */ /* RT Tolerance Tables */ /* */ /********************************************************************************/ void init_RTToleranceTables (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papToleranceTableSequence]; theWrkP->group = 0x300A; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_RT Tolerance Tables*/ /********************************************************************************/ /* */ /* init_StructureSet : initializes the elements of the module */ /* Structure Set */ /* */ /********************************************************************************/ void init_StructureSet (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papStructureSetLabel]; theWrkP->group = 0x3006; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStructureSetName]; theWrkP->group = 0x3006; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStructureSetDescription]; theWrkP->group = 0x3006; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStructureSetDate]; theWrkP->group = 0x3006; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStructureSetTime]; theWrkP->group = 0x3006; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedFrameofReferenceSequence]; theWrkP->group = 0x3006; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStructureSetROISequence]; theWrkP->group = 0x3006; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Structure Set*/ /********************************************************************************/ /* */ /* init_SCImage : initializes the elements of the module */ /* SC Image */ /* */ /********************************************************************************/ void init_SCImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papDateofSecondaryCapture]; theWrkP->group = 0x0018; theWrkP->element = 0x1012; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimeofSecondaryCapture]; theWrkP->group = 0x0018; theWrkP->element = 0x1014; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_SC Image */ /********************************************************************************/ /* */ /* init_SCImageEquipment : initializes the elements of the module */ /* SC Image Equipment */ /* */ /********************************************************************************/ void init_SCImageEquipment (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papConversionType]; theWrkP->group = 0x0008; theWrkP->element = 0x0064; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModalitySIE]; theWrkP->group = 0x0008; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSecondaryCaptureDeviceID]; theWrkP->group = 0x0018; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSecondaryCaptureDeviceManufacturer]; theWrkP->group = 0x0018; theWrkP->element = 0x1016; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSecondaryCaptureDeviceManufacturersModelName]; theWrkP->group = 0x0018; theWrkP->element = 0x1018; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSecondaryCaptureDeviceSoftwareVersion]; theWrkP->group = 0x0018; theWrkP->element = 0x1019; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVideoImageFormatAcquired]; theWrkP->group = 0x0018; theWrkP->element = 0x1022; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDigitalImageFormatAcquired]; theWrkP->group = 0x0018; theWrkP->element = 0x1023; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_SC Image Equipment */ /********************************************************************************/ /* */ /* init_SCMultiFrameImage : initializes the elements of the module */ /* SC Multi-Frame Image Module */ /* */ /********************************************************************************/ void init_SCMultiFrameImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papZoomFactor]; theWrkP->group = 0x0028; theWrkP->element = 0x0031; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPresentationLUTShape]; theWrkP->group = 0x2050; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIllumination]; theWrkP->group = 0x2010; theWrkP->element = 0x015E; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReflectedAmbientLight]; theWrkP->group = 0x2010; theWrkP->element = 0x0160; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleIntercept]; theWrkP->group = 0x0028; theWrkP->element = 0x1052; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleSlope]; theWrkP->group = 0x0028; theWrkP->element = 0x1053; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRescaleTypeSCMF]; theWrkP->group = 0x0028; theWrkP->element = 0x1054; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameIncrementPointerSCMF]; theWrkP->group = 0x0028; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNominalScannedPixelSpacing]; theWrkP->group = 0x0018; theWrkP->element = 0x2010; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDigitizingDeviceTransportDirection]; theWrkP->group = 0x0018; theWrkP->element = 0x2020; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRotationOfScannedFilm]; theWrkP->group = 0x0018; theWrkP->element = 0x2030; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_SCMultiFrameImage */ /********************************************************************************/ /* */ /* init_SCMultiFrameVector : initializes the elements of the module */ /* SC Multi-Frame Vector Module */ /* */ /********************************************************************************/ void init_SCMultiFrameVector (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papFrameTimeVectorSCMFV]; theWrkP->group = 0x0018; theWrkP->element = 0x1065; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPageNumberVector]; theWrkP->group = 0x0018; theWrkP->element = 0x2001; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameLabelVector]; theWrkP->group = 0x0018; theWrkP->element = 0x2002; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFramePrimaryAngleVector]; theWrkP->group = 0x0018; theWrkP->element = 0x2003; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameSecondaryAngleVector]; theWrkP->group = 0x0018; theWrkP->element = 0x2004; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSliceLocationVector]; theWrkP->group = 0x0018; theWrkP->element = 0x2005; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDisplayWindowLabelVector]; theWrkP->group = 0x0018; theWrkP->element = 0x2006; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_SCMultiFrameVector */ /********************************************************************************/ /* */ /* init_SlideCoordinates : initializes the elements of the module */ /* Slide Coordinates */ /* */ /********************************************************************************/ void init_SlideCoordinates (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImageCenterPointCoordinatesSequence]; theWrkP->group = 0x0040; theWrkP->element = 0x071A; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXOffsetInSlideCoordinateSystem]; theWrkP->group = 0x0040; theWrkP->element = 0x072A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papYOffsetInSlideCoordinateSystem]; theWrkP->group = 0x0040; theWrkP->element = 0x073A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papZOffsetInSlideCoordinateSystem]; theWrkP->group = 0x0040; theWrkP->element = 0x074A; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelSpacingSequence]; theWrkP->group = 0x0040; theWrkP->element = 0x08D8; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_SlideCoordinates */ /********************************************************************************/ /* */ /* init_SOPCommon : initializes the elements of the module */ /* SOP Common */ /* */ /********************************************************************************/ void init_SOPCommon (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papSOPClassUID]; theWrkP->group = 0x0008; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSOPInstanceUID]; theWrkP->group = 0x0008; theWrkP->element = 0x0018; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecificCharacterSet]; theWrkP->group = 0x0008; theWrkP->element = 0x0005; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstanceCreationDate]; theWrkP->group = 0x0008; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstanceCreationTime]; theWrkP->group = 0x0008; theWrkP->element = 0x0013; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstanceCreatorUID]; theWrkP->group = 0x0008; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTimezoneOffsetFromUTC]; theWrkP->group = 0x0008; theWrkP->element = 0x0201; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_SOP Common */ /********************************************************************************/ /* */ /* init_SpecimenIdentification : initializes the elements of the module */ /* Specimen Identification */ /* */ /********************************************************************************/ void init_SpecimenIdentification (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papSpecimenAccessionNumber]; theWrkP->group = 0x0040; theWrkP->element = 0x050A; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSpecimenSequence]; theWrkP->group = 0x0040; theWrkP->element = 0x0550; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Specimen Identification */ /********************************************************************************/ /* */ /* init_StudyAcquisition : initializes the elements of the module */ /* Study Acquisition */ /* */ /********************************************************************************/ void init_StudyAcquisition (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papStudyArrivalDate]; theWrkP->group = 0x0032; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyArrivalTime]; theWrkP->group = 0x0032; theWrkP->element = 0x1041; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyDateSA]; theWrkP->group = 0x0008; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyTimeSA]; theWrkP->group = 0x0008; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papModalitiesInStudy]; theWrkP->group = 0x0008; theWrkP->element = 0x0061; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyCompletionDate]; theWrkP->group = 0x0032; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyCompletionTime]; theWrkP->group = 0x0032; theWrkP->element = 0x1051; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyVerifiedDate]; theWrkP->group = 0x0032; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyVerifiedTime]; theWrkP->group = 0x0032; theWrkP->element = 0x0033; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSeriesinStudy]; theWrkP->group = 0x0020; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionsinStudy]; theWrkP->group = 0x0020; theWrkP->element = 0x1004; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Study Acquisition */ /********************************************************************************/ /* */ /* init_StudyClassification : initializes the elements of the module */ /* Study Classification */ /* */ /********************************************************************************/ void init_StudyClassification (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papStudyStatusID]; theWrkP->group = 0x0032; theWrkP->element = 0x000A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyPriorityID]; theWrkP->group = 0x0032; theWrkP->element = 0x000C; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyComments]; theWrkP->group = 0x0032; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Study Classification */ /********************************************************************************/ /* */ /* init_StudyComponent : initializes the elements of the module */ /* Study Component */ /* */ /********************************************************************************/ void init_StudyComponent (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papStudyIDSC]; theWrkP->group = 0x0020; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyInstanceUIDSC]; theWrkP->group = 0x0020; theWrkP->element = 0x000D; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSeriesSequenceSC]; theWrkP->group = 0x0008; theWrkP->element = 0x1115; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Study Component */ /********************************************************************************/ /* */ /* init_StudyComponentAcquisition : initializes the elements of the module */ /* Study Component Acquisition */ /* */ /********************************************************************************/ void init_StudyComponentAcquisition (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papModalitySCA]; theWrkP->group = 0x0008; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyDescriptionSCA]; theWrkP->group = 0x0008; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papProcedureCodeSequence]; theWrkP->group = 0x0008; theWrkP->element = 0x1032; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPerformingPhysiciansNameSCA]; theWrkP->group = 0x0008; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyComponentStatusID]; theWrkP->group = 0x0032; theWrkP->element = 0x1055; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Study Component Acquisition */ /********************************************************************************/ /* */ /* init_StudyComponentRelationship : initializes the elements of the module*/ /* Study Component Relationship */ /* */ /********************************************************************************/ void init_StudyComponentRelationship (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedStudySequenceSCR]; theWrkP->group = 0x0008; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Study Component Relationship */ /********************************************************************************/ /* */ /* init_StudyContent : initializes the elements of the module */ /* Study Content */ /* */ /********************************************************************************/ void init_StudyContent (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papStudyIDSCt]; theWrkP->group = 0x0020; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyInstanceUIDSCt]; theWrkP->group = 0x0020; theWrkP->element = 0x000D; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedSeriesSequenceSCt]; theWrkP->group = 0x0008; theWrkP->element = 0x1115; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Study Content */ /********************************************************************************/ /* */ /* init_StudyIdentification : initializes the elements of the module */ /* Study Identification */ /* */ /********************************************************************************/ void init_StudyIdentification (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papStudyIDSI]; theWrkP->group = 0x0020; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyIDIssuer]; theWrkP->group = 0x0032; theWrkP->element = 0x0012; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOtherStudyNumbers]; theWrkP->group = 0x0020; theWrkP->element = 0x1070; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Study Identification */ /********************************************************************************/ /* */ /* init_StudyRead : initializes the elements of the module */ /* Study Read */ /* */ /********************************************************************************/ void init_StudyRead (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papNameofPhysiciansReadingStudySR]; theWrkP->group = 0x0008; theWrkP->element = 0x1060; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyReadDate]; theWrkP->group = 0x0032; theWrkP->element = 0x0034; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyReadTime]; theWrkP->group = 0x0032; theWrkP->element = 0x0035; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Study Read */ /********************************************************************************/ /* */ /* init_StudyRelationship : initializes the elements of the module */ /* Study Relationship */ /* */ /********************************************************************************/ void init_StudyRelationship (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedVisitSequenceSR]; theWrkP->group = 0x0008; theWrkP->element = 0x1125; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedPatientSequenceSR]; theWrkP->group = 0x0008; theWrkP->element = 0x1120; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedResultsSequenceSR]; theWrkP->group = 0x0008; theWrkP->element = 0x1100; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedStudyComponentSequenceSR]; theWrkP->group = 0x0008; theWrkP->element = 0x1111; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStudyInstanceUIDSR]; theWrkP->group = 0x0020; theWrkP->element = 0x000D; theWrkP->length = 0L; theWrkP->vr = UI; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAccessionNumberSR]; theWrkP->group = 0x0008; theWrkP->element = 0x0050; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Study Relationship */ /********************************************************************************/ /* */ /* init_StudyScheduling : initializes the elements of the module */ /* Study Scheduling */ /* */ /********************************************************************************/ void init_StudyScheduling (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papScheduledStudyStartDate]; theWrkP->group = 0x0032; theWrkP->element = 0x1000; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStudyStartTime]; theWrkP->group = 0x0032; theWrkP->element = 0x1001; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStudyStopDate]; theWrkP->group = 0x0032; theWrkP->element = 0x1010; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStudyStopTime]; theWrkP->group = 0x0032; theWrkP->element = 0x1011; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStudyLocation]; theWrkP->group = 0x0032; theWrkP->element = 0x1020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledStudyLocationAETitle]; theWrkP->group = 0x0032; theWrkP->element = 0x1021; theWrkP->length = 0L; theWrkP->vr = AE; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReasonforStudy]; theWrkP->group = 0x0032; theWrkP->element = 0x1030; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestingPhysician]; theWrkP->group = 0x0032; theWrkP->element = 0x1032; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestingService]; theWrkP->group = 0x0032; theWrkP->element = 0x1033; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedProcedureDescription]; theWrkP->group = 0x0032; theWrkP->element = 0x1060; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedProcedureCodeSequence]; theWrkP->group = 0x0032; theWrkP->element = 0x1064; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRequestedContrastAgent]; theWrkP->group = 0x0032; theWrkP->element = 0x1070; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Study Scheduling */ /********************************************************************************/ /* */ /* init_Therapy: initializes the elements of the module */ /* Therapy */ /* */ /********************************************************************************/ void init_Therapy (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papInterventionalTherapySequenceTH]; theWrkP->group = 0x0018; theWrkP->element = 0x0036; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Therapy */ /********************************************************************************/ /* */ /* init_UINOverlaySequence : initializes the elements of the module */ /* UIN Overlay Sequence */ /* */ /********************************************************************************/ void init_UINOverlaySequence (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papOwnerID]; theWrkP->group = 0x6001; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 1L; theWrkP->value = (UValue_T *) emalloc3 ((PapyULong) sizeof (UValue_T)); theWrkP->value->a = (char *) ecalloc3 ((PapyULong) 12, (PapyULong) sizeof (char)); strcpy (theWrkP->value->a, "PAPYRUS 3.0"); theWrkP = &ioElem [papUINOverlaySequence]; theWrkP->group = 0x6001; theWrkP->element = 0x10C0; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0L; theWrkP->value = NULL; } /* endof init_UIN Overlay Sequence */ /********************************************************************************/ /* */ /* init_USFrameofReference : initializes the elements of the module */ /* USS Frame of Reference */ /* */ /********************************************************************************/ void init_USFrameofReference (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papRegionLocationMinx0]; theWrkP->group = 0x0018; theWrkP->element = 0x6018; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRegionLocationMiny0]; theWrkP->group = 0x0018; theWrkP->element = 0x601A; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRegionLocationMaxx1]; theWrkP->group = 0x0018; theWrkP->element = 0x601C; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRegionLocationMaxy1]; theWrkP->group = 0x0018; theWrkP->element = 0x601E; theWrkP->length = 0L; theWrkP->vr = UL; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhysicalUnitsXDirection]; theWrkP->group = 0x0018; theWrkP->element = 0x6024; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhysicalUnitsYDirection]; theWrkP->group = 0x0018; theWrkP->element = 0x6026; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhysicalDeltaX]; theWrkP->group = 0x0018; theWrkP->element = 0x602C; theWrkP->length = 0L; theWrkP->vr = FD; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhysicalDeltaY]; theWrkP->group = 0x0018; theWrkP->element = 0x602E; theWrkP->length = 0L; theWrkP->vr = FD; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencePixelx0]; theWrkP->group = 0x0018; theWrkP->element = 0x6020; theWrkP->length = 0L; theWrkP->vr = SL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencePixely0]; theWrkP->group = 0x0018; theWrkP->element = 0x6022; theWrkP->length = 0L; theWrkP->vr = SL; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRefPixelPhysicalValueX]; theWrkP->group = 0x0018; theWrkP->element = 0x6028; theWrkP->length = 0L; theWrkP->vr = FD; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRefPixelPhysicalValueY]; theWrkP->group = 0x0018; theWrkP->element = 0x602A; theWrkP->length = 0L; theWrkP->vr = FD; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_US Frame of Reference */ /********************************************************************************/ /* */ /* init_USImage : initializes the elements of the module */ /* USS Image */ /* */ /********************************************************************************/ void init_USImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papSamplesperPixelUSI]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretationUSI]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedUSI]; theWrkP->group = 0x0028; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsStoredUSI]; theWrkP->group = 0x0028; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighBitUSI]; theWrkP->group = 0x0028; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPlanarConfigurationUSI]; theWrkP->group = 0x0028; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelRepresentationUSI]; theWrkP->group = 0x0028; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFrameIncrementPointerUSI]; theWrkP->group = 0x0028; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTypeUSI]; theWrkP->group = 0x0008; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLossyImageCompressionUSI]; theWrkP->group = 0x0028; theWrkP->element = 0x2110; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofStages]; theWrkP->group = 0x0008; theWrkP->element = 0x2124; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofViewsinStage]; theWrkP->group = 0x0008; theWrkP->element = 0x212A; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papUltrasoundColorDataPresent]; theWrkP->group = 0x0028; theWrkP->element = 0x0014; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedOverlaySequenceUSI]; theWrkP->group = 0x0008; theWrkP->element = 0x1130; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedCurveSequenceUSI]; theWrkP->group = 0x0008; theWrkP->element = 0x1145; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "0-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStageName]; theWrkP->group = 0x0008; theWrkP->element = 0x2120; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStageCodeSequence]; theWrkP->group = 0x0040; theWrkP->element = 0x000A; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papStageNumber]; theWrkP->group = 0x0008; theWrkP->element = 0x2122; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewName]; theWrkP->group = 0x0008; theWrkP->element = 0x2127; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papViewNumber]; theWrkP->group = 0x0008; theWrkP->element = 0x2128; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofEventTimers]; theWrkP->group = 0x0008; theWrkP->element = 0x2129; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEventElapsedTimes]; theWrkP->group = 0x0008; theWrkP->element = 0x2130; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEventTimerNames]; theWrkP->group = 0x0008; theWrkP->element = 0x2132; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnatomicRegionSequenceUSI]; theWrkP->group = 0x0008; theWrkP->element = 0x2218; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrimaryAnatomicStructureSequenceUSI]; theWrkP->group = 0x0008; theWrkP->element = 0x2228; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerPositionSequence]; theWrkP->group = 0x0008; theWrkP->element = 0x2240; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerOrientationSequence]; theWrkP->group = 0x0008; theWrkP->element = 0x2244; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTriggerTimeUSI]; theWrkP->group = 0x0018; theWrkP->element = 0x1060; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNominalIntervalUSI]; theWrkP->group = 0x0018; theWrkP->element = 0x1062; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBeatRejectionFlagUSI]; theWrkP->group = 0x0018; theWrkP->element = 0x1080; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLowRRValueUSI]; theWrkP->group = 0x0018; theWrkP->element = 0x1081; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighRRValueUSI]; theWrkP->group = 0x0018; theWrkP->element = 0x1082; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHeartRateUSI]; theWrkP->group = 0x0018; theWrkP->element = 0x1088; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOutputPower]; theWrkP->group = 0x0018; theWrkP->element = 0x5000; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerData]; theWrkP->group = 0x0018; theWrkP->element = 0x5010; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTransducerType]; theWrkP->group = 0x0018; theWrkP->element = 0x6031; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFocusDepth]; theWrkP->group = 0x0018; theWrkP->element = 0x5012; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPreprocessingFunctionUSI]; theWrkP->group = 0x0018; theWrkP->element = 0x5020; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papMechanicalIndex]; theWrkP->group = 0x0018; theWrkP->element = 0x5022; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBoneThermalIndex]; theWrkP->group = 0x0018; theWrkP->element = 0x5024; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCranialThermalIndex]; theWrkP->group = 0x0018; theWrkP->element = 0x5026; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSoftTissueThermalIndex]; theWrkP->group = 0x0018; theWrkP->element = 0x5027; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSoftTissuefocusThermalIndex]; theWrkP->group = 0x0018; theWrkP->element = 0x5028; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSoftTissuesurfaceThermalIndex]; theWrkP->group = 0x0018; theWrkP->element = 0x5029; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDepthofScanField]; theWrkP->group = 0x0018; theWrkP->element = 0x5050; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTransformationMatrix]; theWrkP->group = 0x0018; theWrkP->element = 0x5210; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "6"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTranslationVector]; theWrkP->group = 0x0018; theWrkP->element = 0x5212; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "3"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOverlaySubtype]; theWrkP->group = 0x6000; theWrkP->element = 0x0045; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_US Image */ /********************************************************************************/ /* */ /* init_USRegionCalibration : initializes the elements of the module */ /* USS Region Calibration */ /* */ /********************************************************************************/ void init_USRegionCalibration (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papSequenceofUltrasoundRegions]; theWrkP->group = 0x0018; theWrkP->element = 0x6011; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_US Region Calibration */ /********************************************************************************/ /* */ /* init_VisitAdmission : initializes the elements of the module */ /* Visit Admission */ /* */ /********************************************************************************/ void init_VisitAdmission (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papAdmittingDate]; theWrkP->group = 0x0038; theWrkP->element = 0x0020; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdmittingTime]; theWrkP->group = 0x0038; theWrkP->element = 0x0021; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRouteofAdmissions]; theWrkP->group = 0x0038; theWrkP->element = 0x0016; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdmittingDiagnosisDescription]; theWrkP->group = 0x0008; theWrkP->element = 0x1080; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdmittingDiagnosisCodeSequence]; theWrkP->group = 0x0008; theWrkP->element = 0x1084; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferringPhysiciansNameVA]; theWrkP->group = 0x0008; theWrkP->element = 0x0090; theWrkP->length = 0L; theWrkP->vr = PN; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAddress]; theWrkP->group = 0x0008; theWrkP->element = 0x0092; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferringPhysiciansPhoneNumbers]; theWrkP->group = 0x0008; theWrkP->element = 0x0094; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Visit Admission */ /********************************************************************************/ /* */ /* init_VisitDischarge : initializes the elements of the module */ /* Visit Discharge */ /* */ /********************************************************************************/ void init_VisitDischarge (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papDischargeDate]; theWrkP->group = 0x0038; theWrkP->element = 0x0030; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDischargeTime]; theWrkP->group = 0x0038; theWrkP->element = 0x0032; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDescription]; theWrkP->group = 0x0038; theWrkP->element = 0x0040; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDischargeDiagnosisCodeSequence]; theWrkP->group = 0x0038; theWrkP->element = 0x0044; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Visit Discharge */ /********************************************************************************/ /* */ /* init_VisitIdentification : initializes the elements of the module */ /* Visit Identification */ /* */ /********************************************************************************/ void init_VisitIdentification (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papInstitutionNameVI]; theWrkP->group = 0x0008; theWrkP->element = 0x0080; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstitutionAddressVI]; theWrkP->group = 0x0008; theWrkP->element = 0x0081; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papInstitutionCodeSequence]; theWrkP->group = 0x0008; theWrkP->element = 0x0082; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAdmissionID]; theWrkP->group = 0x0038; theWrkP->element = 0x0010; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIssuerofAdmissionID]; theWrkP->group = 0x0038; theWrkP->element = 0x0011; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Visit Identification */ /********************************************************************************/ /* */ /* init_VisitRelationship : initializes the elements of the module */ /* Visit Relationship */ /* */ /********************************************************************************/ void init_VisitRelationship (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papReferencedStudySequenceVR]; theWrkP->group = 0x0008; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedPatientSequenceVR]; theWrkP->group = 0x0008; theWrkP->element = 0x1120; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Visit Relationship */ /********************************************************************************/ /* */ /* init_VisitScheduling : initializes the elements of the module */ /* Visit Scheduling */ /* */ /********************************************************************************/ void init_VisitScheduling (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papScheduledAdmissionDate]; theWrkP->group = 0x0038; theWrkP->element = 0x001A; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledAdmissionTime]; theWrkP->group = 0x0038; theWrkP->element = 0x001B; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledDischargeDate]; theWrkP->group = 0x0038; theWrkP->element = 0x001C; theWrkP->length = 0L; theWrkP->vr = DA; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledDischargeTime]; theWrkP->group = 0x0038; theWrkP->element = 0x001D; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScheduledPatientInstitutionResidence]; theWrkP->group = 0x0038; theWrkP->element = 0x001E; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Visit Scheduling */ /********************************************************************************/ /* */ /* init_VisitStatus : initializes the elements of the module */ /* Visit Status */ /* */ /********************************************************************************/ void init_VisitStatus (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papVisitStatusID]; theWrkP->group = 0x0038; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCurrentPatientLocationVS]; theWrkP->group = 0x0038; theWrkP->element = 0x0300; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPatientsInstitutionResidenceVS]; theWrkP->group = 0x0038; theWrkP->element = 0x0400; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVisitComments]; theWrkP->group = 0x0038; theWrkP->element = 0x4000; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_Visit Status */ /********************************************************************************/ /* */ /* init_VLImage : initializes the elements of the module */ /* VL Image */ /* */ /********************************************************************************/ void init_VLImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papImageTypeVL]; theWrkP->group = 0x0008; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretationVL]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedVL]; theWrkP->group = 0x0028; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsStoredVL]; theWrkP->group = 0x0028; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighBitVL]; theWrkP->group = 0x0028; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelRepresentationVL]; theWrkP->group = 0x0028; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSamplesperPixelVL]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPlanarConfigurationVL]; theWrkP->group = 0x0028; theWrkP->element = 0x0006; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTimeVL]; theWrkP->group = 0x0008; theWrkP->element = 0x0033; theWrkP->length = 0L; theWrkP->vr = TM; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLossyImageCompressionVL]; theWrkP->group = 0x0028; theWrkP->element = 0x2110; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageSequenceVL]; theWrkP->group = 0x0008; theWrkP->element = 0x1140; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_VLImage */ /********************************************************************************/ /* */ /* init_VOILUT : initializes the elements of the module */ /* VOI LUT */ /* */ /********************************************************************************/ void init_VOILUT (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papVOILUTSequence]; theWrkP->group = 0x0028; theWrkP->element = 0x3010; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWindowCenter]; theWrkP->group = 0x0028; theWrkP->element = 0x1050; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWindowWidth]; theWrkP->group = 0x0028; theWrkP->element = 0x1051; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papWindowCenterWidthExplanation]; theWrkP->group = 0x0028; theWrkP->element = 0x1055; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_VOI LUT */ /********************************************************************************/ /* */ /* init_XRayAcquisition : initializes the elements of the module */ /* XRay Acquisition */ /* */ /********************************************************************************/ void init_XRayAcquisition (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papKVP]; theWrkP->group = 0x0018; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiationSetting]; theWrkP->group = 0x0018; theWrkP->element = 0x1155; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXrayTubeCurrent]; theWrkP->group = 0x0018; theWrkP->element = 0x1151; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureTime]; theWrkP->group = 0x0018; theWrkP->element = 0x1150; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposure]; theWrkP->group = 0x0018; theWrkP->element = 0x1152; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGrid]; theWrkP->group = 0x0018; theWrkP->element = 0x1166; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAveragePulseWidth]; theWrkP->group = 0x0018; theWrkP->element = 0x1154; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiationMode]; theWrkP->group = 0x0018; theWrkP->element = 0x115A; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTypeofFilters]; theWrkP->group = 0x0018; theWrkP->element = 0x1161; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papIntensifierSize]; theWrkP->group = 0x0018; theWrkP->element = 0x1162; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewShapeXRA]; theWrkP->group = 0x0018; theWrkP->element = 0x1147; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFieldofViewDimensionsXRA]; theWrkP->group = 0x0018; theWrkP->element = 0x1149; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1-2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImagerPixelSpacing]; theWrkP->group = 0x0018; theWrkP->element = 0x1164; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFocalSpots]; theWrkP->group = 0x0018; theWrkP->element = 0x1190; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageAreaDoseProduct]; theWrkP->group = 0x0018; theWrkP->element = 0x115E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_XRay Acquisition */ /********************************************************************************/ /* */ /* init_XRayAcquisitionDose : initializes the elements of the module */ /* XRay Acquisition Dose */ /* */ /********************************************************************************/ void init_XRayAcquisitionDose (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papKVPXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXrayTubeCurrentXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x1151; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureTimeXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x1150; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x1152; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoDetectorXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoPatientXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x1111; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageAreaDoseProductXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x115E; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBodyPartThicknessXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x11A0; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEntranceDoseXRAD]; theWrkP->group = 0x0040; theWrkP->element = 0x0302; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposedAreaXRAD]; theWrkP->group = 0x0040; theWrkP->element = 0x0303; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoEntranceXRAD]; theWrkP->group = 0x0040; theWrkP->element = 0x0306; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCommentsonRadiationDoseXRAD]; theWrkP->group = 0x0040; theWrkP->element = 0x0310; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXRayOutputXRAD]; theWrkP->group = 0x0040; theWrkP->element = 0x0312; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHalfValueLayerXRAD]; theWrkP->group = 0x0040; theWrkP->element = 0x0314; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrganDoseXRAD]; theWrkP->group = 0x0040; theWrkP->element = 0x0316; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papOrganExposedXRAD]; theWrkP->group = 0x0040; theWrkP->element = 0x0318; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnodeTargetMaterialXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x1191; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterMaterialXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x7050; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterThicknessMinimumXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x7052; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterThicknessMaximumXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x7054; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRectificationTypeXRAD]; theWrkP->group = 0x0018; theWrkP->element = 0x1156; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_XRay Acquisition Dose */ /********************************************************************************/ /* */ /* init_XRayCollimator : initializes the elements of the module */ /* XRay Collimator */ /* */ /********************************************************************************/ void init_XRayCollimator (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papCollimatorShape]; theWrkP->group = 0x0018; theWrkP->element = 0x1700; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-3"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorLeftVerticalEdge]; theWrkP->group = 0x0018; theWrkP->element = 0x1702; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorRightVerticalEdge]; theWrkP->group = 0x0018; theWrkP->element = 0x1704; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorUpperHorizontalEdge]; theWrkP->group = 0x0018; theWrkP->element = 0x1706; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCollimatorLowerHorizontalEdge]; theWrkP->group = 0x0018; theWrkP->element = 0x1708; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCenterofCircularCollimator]; theWrkP->group = 0x0018; theWrkP->element = 0x1710; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRadiusofCircularCollimator]; theWrkP->group = 0x0018; theWrkP->element = 0x1712; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papVerticesofthePolygonalCollimator]; theWrkP->group = 0x0018; theWrkP->element = 0x1720; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2-2n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_XRay Collimator */ /********************************************************************************/ /* */ /* init_XRayFiltration : initializes the elements of the module */ /* XRay Filtration */ /* */ /********************************************************************************/ void init_XRayFiltration (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papFilterTypeXRF]; theWrkP->group = 0x0018; theWrkP->element = 0x1160; theWrkP->length = 0L; theWrkP->vr = SH; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterMaterialXRF]; theWrkP->group = 0x0018; theWrkP->element = 0x7050; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterThicknessMinimumXRF]; theWrkP->group = 0x0018; theWrkP->element = 0x7052; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFilterThicknessMaximumXRF]; theWrkP->group = 0x0018; theWrkP->element = 0x7054; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_XRay Filtration */ /********************************************************************************/ /* */ /* init_XRayGeneration : initializes the elements of the module */ /* XRay Generation */ /* */ /********************************************************************************/ void init_XRayGeneration (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papKVPXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x0060; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papXrayTubeCurrentXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x1151; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureTimeXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x1150; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x1152; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureinmAsXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x1153; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureControlModeXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x7060; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureControlModeDescriptionXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x7062; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papExposureStatusXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x7064; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhototimerSettingXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x7065; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papFocalSpotsXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x1190; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnodeTargetMaterialXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x1191; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRectificationTypeXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x1156; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_XRay Generation */ /********************************************************************************/ /* */ /* init_XRayGrid : initializes the elements of the module */ /* XRay Grid */ /* */ /********************************************************************************/ void init_XRayGrid (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papGridXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x1166; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridAbsorbingMaterialXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x7040; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridSpacingMaterialXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x7041; theWrkP->length = 0L; theWrkP->vr = LT; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridThicknessXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x7042; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridPitchXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x7044; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridAspectRatioXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x7046; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "2"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridPeriodXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x7048; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papGridFocalDistanceXRG]; theWrkP->group = 0x0018; theWrkP->element = 0x704C; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_XRay Grid */ /********************************************************************************/ /* */ /* init_XRayImage : initializes the elements of the module */ /* XRay Image */ /* */ /********************************************************************************/ void init_XRayImage (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papFrameIncrementPointerXR]; theWrkP->group = 0x0028; theWrkP->element = 0x0009; theWrkP->length = 0L; theWrkP->vr = AT; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papLossyImageCompressionXR]; theWrkP->group = 0x0028; theWrkP->element = 0x2110; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papImageTypeXR]; theWrkP->group = 0x0008; theWrkP->element = 0x0008; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelIntensityRelationshipXR]; theWrkP->group = 0x0028; theWrkP->element = 0x1040; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papSamplesperPixelXR]; theWrkP->group = 0x0028; theWrkP->element = 0x0002; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPhotometricInterpretationXR]; theWrkP->group = 0x0028; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsAllocatedXR]; theWrkP->group = 0x0028; theWrkP->element = 0x0100; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papBitsStoredXR]; theWrkP->group = 0x0028; theWrkP->element = 0x0101; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papHighBitXR]; theWrkP->group = 0x0028; theWrkP->element = 0x0102; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPixelRepresentationXR]; theWrkP->group = 0x0028; theWrkP->element = 0x0103; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papScanOptionsXR]; theWrkP->group = 0x0018; theWrkP->element = 0x0022; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAnatomicRegionSequenceXR]; theWrkP->group = 0x0008; theWrkP->element = 0x2218; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papPrimaryAnatomicStructureSequenceXR]; theWrkP->group = 0x0008; theWrkP->element = 0x2228; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papRWavePointerXR]; theWrkP->group = 0x0028; theWrkP->element = 0x6040; theWrkP->length = 0L; theWrkP->vr = USS; theWrkP->vm = "1-n"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papReferencedImageSequenceXR]; theWrkP->group = 0x0008; theWrkP->element = 0x1140; theWrkP->length = 0L; theWrkP->vr = SQ; theWrkP->vm = "1-n"; theWrkP->type_t = T1C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDerivationDescriptionXR]; theWrkP->group = 0x0008; theWrkP->element = 0x2111; theWrkP->length = 0L; theWrkP->vr = ST; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papAcquisitionDeviceProcessingDescriptionXR]; theWrkP->group = 0x0018; theWrkP->element = 0x1400; theWrkP->length = 0L; theWrkP->vr = LO; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papCalibrationObjectXR]; theWrkP->group = 0x0050; theWrkP->element = 0x0004; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_XRay Image */ /********************************************************************************/ /* */ /* init_XRayTable : initializes the elements of the module */ /* XRay Table */ /* */ /********************************************************************************/ void init_XRayTable (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papTableMotion]; theWrkP->group = 0x0018; theWrkP->element = 0x1134; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T2; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableVerticalIncrement]; theWrkP->group = 0x0018; theWrkP->element = 0x1135; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableLongitudinalIncrement]; theWrkP->group = 0x0018; theWrkP->element = 0x1137; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableLateralIncrement]; theWrkP->group = 0x0018; theWrkP->element = 0x1136; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1-n"; theWrkP->type_t = T2C; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTableAngle]; theWrkP->group = 0x0018; theWrkP->element = 0x1138; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_XRay Table */ /********************************************************************************/ /* */ /* init_XRayTomographyAcquisition : initializes the elements of the module */ /* XRay Tomography Acquisition */ /* */ /********************************************************************************/ void init_XRayTomographyAcquisition (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papTornoTypeXRTA]; theWrkP->group = 0x0018; theWrkP->element = 0x1490; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTornoClassXRTA]; theWrkP->group = 0x0018; theWrkP->element = 0x1491; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTornoLayerHeightXRTA]; theWrkP->group = 0x0018; theWrkP->element = 0x1460; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T1; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTornoAngleXRTA]; theWrkP->group = 0x0018; theWrkP->element = 0x1470; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papTornoTimeXRTA]; theWrkP->group = 0x0018; theWrkP->element = 0x1480; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papNumberofTornosynthesisSourceImagesXRTA]; theWrkP->group = 0x0018; theWrkP->element = 0x1495; theWrkP->length = 0L; theWrkP->vr = IS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_XRay Tomography Acquisition */ /********************************************************************************/ /* */ /* init_XRFPositioner : initializes the elements of the module */ /* XRF Positioner Module */ /* */ /********************************************************************************/ void init_XRFPositioner (SElement ioElem []) { SElement *theWrkP; theWrkP = &ioElem [papDistanceSourceToDetector]; theWrkP->group = 0x0018; theWrkP->element = 0x1110; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papDistanceSourcetoPatient]; theWrkP->group = 0x0018; theWrkP->element = 0x1111; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papEstimatedRadiographicMagnificationFactor]; theWrkP->group = 0x0018; theWrkP->element = 0x1114; theWrkP->length = 0L; theWrkP->vr = DS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; theWrkP = &ioElem [papColumnAngulation]; theWrkP->group = 0x0018; theWrkP->element = 0x1450; theWrkP->length = 0L; theWrkP->vr = CS; theWrkP->vm = "1"; theWrkP->type_t = T3; theWrkP->nb_val = 0; theWrkP->value = NULL; } /* endof init_XRFPositioner */ Papyrus3/PapyMemSystem.cpp0000755000175000017500000002556310044205700013013 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyMemSystem.cpp */ /* Function : contains calls for asynchronous read */ /* Authors : Olivier Baujard */ /* */ /* History : 03.1997 version 3.1 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* */ /********************************************************************************/ #include "PapyMemSystem.h" #include PapyMemSystem::PapyMemSystem() { theFilename=NULL; theBuffer=theCurrentWrite=theCurrentRead=theFirstPosition=theLastPosition=NULL; theLength=0L; theChunkSize=0L; theReadingThread=0; theReadEvent=NULL; theReadMutex=NULL; theWriteMutex=NULL; theBooleanMutex=NULL; theBoolean=0; } PapyMemSystem::~PapyMemSystem() { Close(); } int PapyMemSystem::Open(char* aFilename,long aLength,long aChunkSize) { Close(); strcpy(theFilename=new char[strlen(aFilename)+1],aFilename); theFilename[strlen(aFilename)]=0; theBuffer=new char[theLength=aLength]; memset(theBuffer,0,theLength); theChunkSize=aChunkSize; theCurrentRead=theCurrentWrite=theFirstPosition=theBuffer; theLastPosition=theBuffer+theLength; if ((theReadEvent=CreateEvent(NULL,FALSE,FALSE,NULL))==NULL) { Close(); return -1; } if ((theReadMutex=CreateMutex(NULL,FALSE,NULL))==NULL) { Close(); return -1; } if ((theWriteMutex=CreateMutex(NULL,FALSE,NULL))==NULL) { Close(); return -1; } if ((theBooleanMutex=CreateMutex(NULL,FALSE,NULL))==NULL) { Close(); return -1; } if ((theReadingThread=_beginthread(ReadMemory,0,this))==-1) { Close(); } return theReadingThread; } void PapyMemSystem::Close() { if (theBuffer) { delete [] theBuffer; } theBuffer=theCurrentWrite=theCurrentRead=theFirstPosition=theLastPosition=NULL; if (theFilename) { delete [] theFilename; } theFilename=NULL; if (theReadMutex) { CloseHandle(theReadMutex); } theReadMutex=NULL; if (theWriteMutex) { CloseHandle(theWriteMutex); } theWriteMutex=NULL; if (theBooleanMutex) { CloseHandle(theBooleanMutex); } theBooleanMutex=NULL; if (theReadEvent) { CloseHandle(theReadEvent); } theReadEvent=NULL; theLength=0; theReadingThread=0; theBoolean=0; } long PapyMemSystem::Seek(int aPosition,long anOffset) { long theResult; switch (aPosition) { case SEEK_SET: theCurrentRead=theFirstPosition+anOffset; break; case SEEK_CUR: theCurrentRead=theCurrentRead+anOffset; break; case SEEK_END: theCurrentRead=theLastPosition-anOffset; break; } theResult=theCurrentRead-theFirstPosition; return theResult; } int PapyMemSystem::IsMemoryAllocated() { return (theBuffer) ? 1 : 0; } int PapyMemSystem::WaitSomethingToRead() // wait for bytes available to read from buffer { int availableBytes=0; do { WaitForSingleObject(theReadMutex,INFINITE); WaitForSingleObject(theWriteMutex,INFINITE); if (theBoolean==0) { availableBytes=theCurrentWrite-theCurrentRead; } else { availableBytes=theLastPosition-theCurrentRead; } ReleaseMutex(theReadMutex); ReleaseMutex(theWriteMutex); } while (availableBytes<=0); return availableBytes; } int PapyMemSystem::Read(char* aBuffer,int aLength) { int bytesAvailable=0; int toRead=0; int bytesRead=0; int theRemainingLength=aLength; do { bytesAvailable=WaitSomethingToRead(); toRead=(bytesAvailable>=theRemainingLength) ? theRemainingLength : bytesAvailable; WaitForSingleObject(theReadMutex,INFINITE); memcpy(aBuffer,theCurrentRead,toRead); aBuffer+=toRead; theCurrentRead+=toRead; bytesRead+=toRead; theRemainingLength-=toRead; if (theCurrentRead==theLastPosition) { theCurrentRead=theFirstPosition; WaitForSingleObject(theBooleanMutex,INFINITE); theBoolean=0; ReleaseMutex(theBooleanMutex); } ReleaseMutex(theReadMutex); } while (bytesRead!=aLength); return aLength; } int PapyMemSystem::WaitPlaceToWrite() // wait for bytes available to write in buffer { int availableBytes=0; do { WaitForSingleObject(theReadMutex,INFINITE); WaitForSingleObject(theWriteMutex,INFINITE); if (theBoolean) { availableBytes=theCurrentRead-theCurrentWrite; } else { availableBytes=theLastPosition-theCurrentWrite; } ReleaseMutex(theReadMutex); ReleaseMutex(theWriteMutex); } while (availableBytes<=0); return availableBytes; } void PapyMemSystem::ReadMemory(void* aPapyMemSystem) { PapyMemSystem* thePapyMemSystem=(PapyMemSystem*)aPapyMemSystem; _fmode=_O_BINARY; int theFile=_open(thePapyMemSystem->theFilename,_O_RDONLY); _lseek(theFile,0L,SEEK_SET); int bytesWrite=0; do { int theChunkSize=thePapyMemSystem->theChunkSize; int bytesAvailable=thePapyMemSystem->WaitPlaceToWrite(); int toWrite=(bytesAvailabletheCurrentWrite,INFINITE); _read(theFile,(void*)(thePapyMemSystem->theCurrentWrite),toWrite); thePapyMemSystem->theCurrentWrite+=toWrite; if (thePapyMemSystem->theCurrentWrite==thePapyMemSystem->theLastPosition) { WaitForSingleObject(thePapyMemSystem->theBooleanMutex,INFINITE); thePapyMemSystem->theBoolean=1; ReleaseMutex(thePapyMemSystem->theBooleanMutex); thePapyMemSystem->theCurrentWrite=thePapyMemSystem->theFirstPosition; } ReleaseMutex(thePapyMemSystem->theWriteMutex); bytesWrite+=toWrite; } while (bytesWrite!=thePapyMemSystem->theLength); _close(theFile); _endthread(); } extern "C" void* CreatePapyMemSystem() { return new PapyMemSystem(); } extern "C" int OpenPapyMemSystem(void* aPapyMemSystem,char* aFilename,long aLength,long aChunk) { return ((PapyMemSystem*)aPapyMemSystem)->Open(aFilename,aLength,aChunk); } extern "C" void ClosePapyMemSystem(void* aPapyMemSystem) { ((PapyMemSystem*)aPapyMemSystem)->Close(); } extern "C" int ReadPapyMemSystem(void* aPapyMemSystem,char* aBuffer,int aLength) { return ((PapyMemSystem*)aPapyMemSystem)->Read(aBuffer,aLength); } extern "C" int SeekPapyMemSystem(void* aPapyMemSystem,int aPosition,long anOffset) { return ((PapyMemSystem*)aPapyMemSystem)->Seek(aPosition,anOffset); } extern "C" int IsMemoryAllocated(void* aPapyMemSystem) { return ((PapyMemSystem*)aPapyMemSystem)->IsMemoryAllocated(); } extern "C" void DeletePapyMemSystem(void* aPapyMemSystem) { delete ((PapyMemSystem*)aPapyMemSystem); } PapyMemSystem* aPapyMemSystem=NULL; extern "C" int OpenMemSystem(char* aFilename,long aLength,long aChunk) { aPapyMemSystem=(PapyMemSystem*)CreatePapyMemSystem(); return OpenPapyMemSystem(aPapyMemSystem,aFilename,aLength,aChunk); } extern "C" int ReadMemSystem(char* aBuffer,int aLength) { return (aPapyMemSystem) ? ReadPapyMemSystem(aPapyMemSystem,aBuffer,aLength) : -1; } extern "C" int SeekMemSystem(int aPosition,long anOffset) { return (aPapyMemSystem) ? SeekPapyMemSystem(aPapyMemSystem,aPosition,anOffset) :-1; } extern "C" int IsAllocated() { return (aPapyMemSystem) ? IsMemoryAllocated(aPapyMemSystem) : 0; } extern "C" void CloseMemSystem() { if (aPapyMemSystem) DeletePapyMemSystem(aPapyMemSystem); aPapyMemSystem=NULL; } Papyrus3/TESTS/0000777000175000017500000000000010047676624010446 5ustar Papyrus3/TESTS/.DS_Store0000777000175000017500000001400410047676624012133 0ustar Bud1%  @€ @€ @€ @ E%DSDB`€ @€ @€ @Papyrus3/TESTS/Makefile.SunOS_5.50000755000175000017500000000156207535143454013504 0ustar # ARCH= SunOS_5.5 DSTDIR= ../.. MANDIR= $(DSTDIR)/man INCDIR= $(DSTDIR)/include BINDIR= $(DSTDIR)/test LIBDIR= $(DSTDIR)/$(ARCH)/lib SRCLIBPPDIR= $(DSTDIR)/$(ARCH)/lib LINTLIBDIR= $(LIBDIR)/lint CPPFLAGS= -I$(INCDIR) -I.. -DSYSV -D_cplusplus -D_NO_LONGLONG -g CFLAGS= -g LINTFLAGS= -hbac SOURCES= \ TestWrite.c \ TestRead.c OBJECTS= $(SOURCES:%.c=$(VARIANT)%.o) PROG= $(SOURCES:%.c=%) LIBRARY= $(LIBDIR)/libP.a VAR= $(TARGET_ARCH:-%=%) VARIANT= $(VAR)/ .KEEP_STATE: .INIT: $(VAR) all: $(PROG) $(PROG): $$(OBJECTS) $(LINK.cc) -Bstatic -g -o $(VARIANT)$@ $(VARIANT)$@.o \ $(LIBDIR)/libP.a $(LIBDIR)/libJpglless.a \ $(LIBDIR)/libJpglossy.a $(LIBDIR)/libDicomDir.a -lm $(LIBRARY): FORCE cd $(SRCLIBPDIR); make FORCE: $(VAR): test -d $@ || mkdir $@ $$(VARIANT)%.o: %.c $(COMPILE.cc) $< -o $@ Papyrus3/TESTS/TestRead.c0000755000175000017500000001513310044171130012302 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : TestRead.c */ /* Function : Main for read testing the Papyrus toolkit 3.0. */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 07.1994 version 3.0 */ /* 03.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* */ /********************************************************************************/ #define MAIN #include #include "Papyrus3.h" main (int argc, char *argv[]) { char patName[256], firstPhysician [256], secondPhysician [256]; int itemType; PapyUShort *theImage; PapyShort fileNb, imageNb, err; PapyULong nbVal, i; Module *module; UValue_T *val, *tmp; SElement *group; /* initialisation of the Papyrus toolkit v3.6 */ Papy3Init (); /* open the test file */ fileNb = Papy3FileOpen (argv [1], (PAPY_FILE) 0, TRUE, 0); if (fileNb < 0) { PAPY3PRINTERRMSG (); exit(1); } imageNb = 1; /* first image */ /* get the Patient module */ module = Papy3GetModule (fileNb, (PapyShort)imageNb, Patient); /* get the patients name */ val = Papy3GetElement (module, papPatientsNameP, &nbVal, &itemType); if (val != NULL) strcpy (patName, val->a); /* free the module and the associated sequences */ Papy3ModuleFree (&module, Patient, TRUE); /* get the General Study module */ module = Papy3GetModule (fileNb, (PapyShort)imageNb, GeneralStudy); /* IMPORTANT!!: this is an example of how to get multiple values!! */ val = Papy3GetElement (module, papReferringPhysiciansNameGS, &nbVal, &itemType); if (val != NULL) { strcpy (firstPhysician, val->a); /* this allows to get the next value */ tmp = val; /* get the second Physician Name */ for (i = 1L; i < nbVal; i++) tmp ++; strcpy (secondPhysician, tmp->a); } /* free the module and the associated sequences */ Papy3ModuleFree (&module, GeneralStudy, TRUE); /* position the file pointer to the begining of the data set */ err = Papy3GotoNumber (fileNb, (PapyShort)imageNb, DataSetID); /* then goto group 0x7FE0 */ if ((err = Papy3GotoGroupNb (fileNb, 0x7FE0)) == 0) { /* read group 0x7FE0 from the file */ if ((err = Papy3GroupRead (fileNb, &group)) > 0) { /* PIXEL DATA */ theImage = (PapyUShort *)Papy3GetPixelData (fileNb, imageNb, group, ImagePixel); /* free group 7FE0 */ err = Papy3GroupFree (&group, TRUE); } /* endif ...group 7FE0 read */ } /* endif ...group 7FE0 found */ /* close and free the file and the associated allocated memory */ Papy3FileClose (fileNb, TRUE); /* free the allocated global value in the toolkit */ Papy3FreeDataSetModules (); } /* end of main */ Papyrus3/TESTS/Makefile.sun40000755000175000017500000000147207535143454012777 0ustar # DSTDIR= ../.. MANDIR= $(DSTDIR)/man INCDIR= $(DSTDIR)/include BINDIR= $(DSTDIR)/test LIBDIR= $(DSTDIR)/$(ARCH)/lib SRCLIBPPDIR= $(DSTDIR)/$(ARCH)/lib LINTLIBDIR= $(LIBDIR)/lint CPPFLAGS= -I$(INCDIR) -I.. -DXTFUNCPROTO -g CFLAGS= -g LINTFLAGS= -hbac SOURCES= \ TestRead.c OBJECTS= $(SOURCES:%.c=$(VARIANT)%.o) PROG= $(SOURCES:%.c=%) LIBRARY= $(LIBDIR)/libP.a VAR= $(TARGET_ARCH:-%=%) VARIANT= $(VAR)/ .KEEP_STATE: .INIT: $(VAR) all: $(PROG) $(PROG): $$(OBJECTS) $(LINK.cc) -Bstatic -g -o $(VARIANT)$@ $(VARIANT)$@.o \ $(LIBDIR)/libP.a $(LIBDIR)/libJpglossy.a \ $(LIBDIR)/libJpglless.a $(LIBDIR)/libDicomDir.a -lm $(LIBRARY): FORCE cd $(SRCLIBPDIR); make FORCE: $(VAR): test -d $@ || mkdir $@ $$(VARIANT)%.o: %.c $(COMPILE.cc) $< -o $@ Papyrus3/TESTS/TestRead.dsp0000755000175000017500000001060407535143454012667 0ustar # Microsoft Developer Studio Project File - Name="TestRead" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=TestRead - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "TestRead.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "TestRead.mak" CFG="TestRead - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "TestRead - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "TestRead - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "TestRead - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /W3 /GX /O2 /I ".." /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WINDOWS" /YX /FD /c # ADD BASE RSC /l 0x100c /d "NDEBUG" # ADD RSC /l 0x100c /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib Papyrus3.lib /nologo /subsystem:console /machine:I386 !ELSEIF "$(CFG)" == "TestRead - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "TestRead___Win32_Debug" # PROP BASE Intermediate_Dir "TestRead___Win32_Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I ".." /D "_DEBUG" /D "_WINDOWS" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD BASE RSC /l 0x100c /d "_DEBUG" # ADD RSC /l 0x100c /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib Papyrus3.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\Debug" !ENDIF # Begin Target # Name "TestRead - Win32 Release" # Name "TestRead - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\TestRead.c # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # End Group # Begin Group "Resource Files" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" # End Group # End Target # End Project Papyrus3/TESTS/TestWrite.c0000755000175000017500000003603410044171500012525 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : TestWrite.c */ /* Function : Main for write testing the Papyrus toolkit 3.0. */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 06.1994 version 3.0 */ /* 10.1998 version 3.5 */ /* 04.2001 version 3.7 */ /* */ /********************************************************************************/ #include #include "Papyrus3.h" main (int argc, char *argv[]) { PapyShort fp; PapyUShort us; Item *dataSet1, *dataSet2; Module *module; SElement *gr2; enum VR_T theVR; char *myChar; unsigned short *image, *imWrk; unsigned char *imageC, *imWrkC; int i; argv [0] = wildname (argv [0]); /* initialisation of the Papyrus 3.0 toolkit */ Papy3Init (); /* creation of the test file */ fp = Papy3FileCreate ("test.papy", 0, 2, LITTLE_ENDIAN_EXPL, JPEG_LOSSLESS, CR_IM, TRUE, PAPYRUS3, NULL); if (fp < 0) wildexit("test.papy already exist"); /* get a pointer to the group 2 */ gr2 = Papy3GetGroup2 (fp); /* fill in the necessary elements of group 2 */ /* SOP instance UID of the media storage */ myChar = (char *) ecalloc3 ((size_t) 255, (size_t) sizeof (char)); strcpy (myChar, "some Media Storage SOP Instance UID"); Papy3PutElement (gr2, papMediaStorageSOPInstanceUIDGr, (void *)&myChar); /* who is the creator of this wonderfull file ? */ strcpy (myChar, "PAPYRUS 3.0"); Papy3PutElement (gr2, papSourceApplicationEntityTitleGr, &myChar); /* create the first data set object */ dataSet1 = Papy3CreateDataSet (fp); /* -------- creation of the Patient module -------- */ module = Papy3CreateModule (dataSet1, Patient); /* put some necessary elements in this module */ strcpy (myChar, "Schiffer^Claudia"); Papy3PutElement (module, papPatientsNameP, &myChar); strcpy (myChar, "65 60 90 123"); Papy3PutElement (module, papPatientIDP, &myChar); strcpy (myChar, "19650623"); Papy3PutElement (module, papPatientsBirthDateP, &myChar); strcpy (myChar, "F"); Papy3PutElement (module, papPatientsSexP, &myChar); /* -------- creation of the General Study module -------- */ module = Papy3CreateModule (dataSet1, GeneralStudy); /* fill some element of the General Study module */ strcpy (myChar, "41.22.333.444.555.666.00.1"); Papy3PutElement (module, papStudyInstanceUIDGS, &myChar); strcpy (myChar, "19940623"); Papy3PutElement (module, papStudyDateGS, &myChar); strcpy (myChar, "174042"); Papy3PutElement (module, papStudyTimeGS, &myChar); /* IMPORTANT!! This is an example of putting a multiple value to a PAPYRUS file!! */ strcpy (myChar, "Girard^Christian"); Papy3PutElement (module, papReferringPhysiciansNameGS, &myChar); strcpy (myChar, "Einstein^Albert"); Papy3PutElement (module, papReferringPhysiciansNameGS, &myChar); /* -------- creation of the General Series module -------- */ module = Papy3CreateModule (dataSet1, GeneralSeries); /* fill some element of the General Series module */ strcpy (myChar , "CR"); Papy3PutElement (module, papModalityGS, &myChar); strcpy (myChar , "This is the series identifier..."); Papy3PutElement (module, papSeriesInstanceUIDGS, &myChar); strcpy (myChar , "10"); Papy3PutElement (module, papSeriesNumberGS, &myChar); /* -------- creation of the CR Series module -------- */ module = Papy3CreateModule (dataSet1, CRSeries); /* fill some element of the CR Series module */ strcpy (myChar , "BREAST"); Papy3PutElement (module, papBodyPartExaminedCRS, &myChar); strcpy (myChar , "AP"); Papy3PutElement (module, papViewPosition, &myChar); /* -------- creation of the general equipment module -------- */ module = Papy3CreateModule (dataSet1, GeneralEquipment); /* fill some element of the general equipment module */ strcpy (myChar , "Si mince...."); Papy3PutElement (module, papManufacturerGE, &myChar); /* -------- creation of the general image module -------- */ module = Papy3CreateModule (dataSet1, GeneralImage); /* fill some element of the general image module */ strcpy (myChar , "1"); Papy3PutElement (module, papInstanceNumberGI, &myChar); /* -------- creation of the image pixel module -------- */ module = Papy3CreateModule (dataSet1, ImagePixel); /* fill some element of the image pixel module */ us = 1; Papy3PutElement (module, papSamplesperPixelIP, &us); strcpy (myChar , "MONOCHROME2"); Papy3PutElement (module, papPhotometricInterpretationIP, &myChar); us = 64; Papy3PutElement (module, papRows, &us); Papy3PutElement (module, papColumns, &us); us = 16; Papy3PutElement (module, papBitsAllocatedIP, &us); Papy3PutElement (module, papBitsStoredIP, &us); Papy3PutElement (module, papHighBitIP, &us); us = 0; Papy3PutElement (module, papSmallestImagePixelValue, &us); us = 4095; Papy3PutElement (module, papLargestImagePixelValue, &us); us = 0; Papy3PutElement (module, papPixelRepresentationIP, &us); /* creation of the test image */ image = (unsigned short *) ecalloc3 ((PapyULong) 4096, (PapyULong) (sizeof (unsigned short))); imWrk = image; for (i = 0; i < 4096; i++) { *imWrk = i; imWrk++; } /* for */ Papy3PutImage (fp, module, papPixelData, (PapyUShort *) image, 64, 64, 16, 0L); /* -------- creation of the CR image module -------- */ module = Papy3CreateModule (dataSet1, CRImage); /* fill some element of the CR image module */ strcpy (myChar , "plate ID"); Papy3PutElement (module, papPlateID, &myChar); /* -------- creation of the SOP Common module -------- */ module = Papy3CreateModule (dataSet1, SOPCommon); /* fill some element of the CR image module */ strcpy (myChar , "1.2.840.10008.5.1.4.1.1.1"); Papy3PutElement (module, papSOPClassUID, &myChar); strcpy (myChar , "1.2.840.10008.5.1.4.1.1.1.333.444.55"); Papy3PutElement (module, papSOPInstanceUID, &myChar); /* -------- close the data set and frees the modules -------- */ Papy3CloseDataSet (fp, dataSet1, TRUE, FALSE); /* free the allocated image */ efree3 ((void **)&image); /******************************************************/ /* create the second data set object */ dataSet2 = Papy3CreateDataSet (fp); /* -------- creation of the Patient module -------- */ module = Papy3CreateModule (dataSet2, Patient); /* put some necessary elements in this module */ strcpy (myChar, "Schiffer^Claudia"); Papy3PutElement (module, papPatientsNameP, &myChar); strcpy (myChar, "65 60 90 123"); Papy3PutElement (module, papPatientIDP, &myChar); strcpy (myChar, "19650623"); Papy3PutElement (module, papPatientsBirthDateP, &myChar); strcpy (myChar, "F"); Papy3PutElement (module, papPatientsSexP, &myChar); /* -------- creation of the General Study module -------- */ module = Papy3CreateModule (dataSet2, GeneralStudy); /* fill some element of the General Study module */ strcpy (myChar, "41.22.333.444.555.666.00.1"); Papy3PutElement (module, papStudyInstanceUIDGS, &myChar); strcpy (myChar, "19940623"); Papy3PutElement (module, papStudyDateGS, &myChar); strcpy (myChar, "174042"); Papy3PutElement (module, papStudyTimeGS, &myChar); /* IMPORTANT!! This is an example of putting a multiple value to a PAPYRUS file!! */ strcpy (myChar, "Girard^Christian"); Papy3PutElement (module, papReferringPhysiciansNameGS, &myChar); strcpy (myChar, "Einstein^Albert"); Papy3PutElement (module, papReferringPhysiciansNameGS, &myChar); /* -------- creation of the General Series module -------- */ module = Papy3CreateModule (dataSet2, GeneralSeries); /* fill some element of the General Series module */ strcpy (myChar , "CR"); Papy3PutElement (module, papModalityGS, &myChar); strcpy (myChar , "This is the series identifier..."); Papy3PutElement (module, papSeriesInstanceUIDGS, &myChar); strcpy (myChar , "10"); Papy3PutElement (module, papSeriesNumberGS, &myChar); /* -------- creation of the CR Series module -------- */ module = Papy3CreateModule (dataSet2, CRSeries); /* fill some element of the CR Series module */ strcpy (myChar , "BREAST"); Papy3PutElement (module, papBodyPartExaminedCRS, &myChar); strcpy (myChar , "AP"); Papy3PutElement (module, papViewPosition, &myChar); /* -------- creation of the general equipment module -------- */ module = Papy3CreateModule (dataSet2, GeneralEquipment); /* fill some element of the general equipment module */ strcpy (myChar , "Si mince...."); Papy3PutElement (module, papManufacturerGE, &myChar); /* -------- creation of the general image module -------- */ module = Papy3CreateModule (dataSet2, GeneralImage); /* fill some element of the general image module */ strcpy (myChar , "2"); Papy3PutElement (module, papInstanceNumberGI, &myChar); /* -------- creation of the image pixel module -------- */ module = Papy3CreateModule (dataSet2, ImagePixel); /* fill some element of the image pixel module */ us = 1; Papy3PutElement (module, papSamplesperPixelIP, &us); strcpy (myChar , "MONOCHROME2"); Papy3PutElement (module, papPhotometricInterpretationIP, &myChar); us = 64; Papy3PutElement (module, papRows, &us); Papy3PutElement (module, papColumns, &us); us = 8; Papy3PutElement (module, papBitsAllocatedIP, &us); Papy3PutElement (module, papBitsStoredIP, &us); Papy3PutElement (module, papHighBitIP, &us); us = 0; Papy3PutElement (module, papSmallestImagePixelValue, &us); us = 255; Papy3PutElement (module, papLargestImagePixelValue, &us); us = 0; Papy3PutElement (module, papPixelRepresentationIP, &us); /* creation of the test image */ imageC = (unsigned char *) ecalloc3 ((PapyULong) 4096, (PapyULong) (sizeof (unsigned char))); imWrkC = imageC; for (i = 0; i < 4096; i++) { *imWrkC = 250; imWrkC++; } /* for */ Papy3PutImage (fp, module, papPixelData, (PapyUShort *) imageC, 64, 64, 8, 0L); /* -------- creation of the CR image module -------- */ module = Papy3CreateModule (dataSet2, CRImage); /* fill some element of the CR image module */ strcpy (myChar , "plate ID"); Papy3PutElement (module, papPlateID, &myChar); /* -------- creation of the SOP Common module -------- */ module = Papy3CreateModule (dataSet2, SOPCommon); /* fill some element of the CR image module */ strcpy (myChar , "1.2.840.10008.5.1.4.1.1.1"); Papy3PutElement (module, papSOPClassUID, &myChar); strcpy (myChar , "1.2.840.10008.5.1.4.1.1.1.333.444.55"); Papy3PutElement (module, papSOPInstanceUID, &myChar); /* -------- close the data set and frees the modules -------- */ Papy3CloseDataSet (fp, dataSet2, TRUE, FALSE); /* free the allocated image */ efree3 ((void **)&imageC); /* -------- close and free the file and the associated allocated memory -------- */ Papy3WriteAndCloseFile (fp, TRUE); /* free the allocated global value in the toolkit */ Papy3FreeDataSetModules (); } /* end of main */ Papyrus3/TESTS/TestWrite.dsp0000755000175000017500000001060407535143454013106 0ustar # Microsoft Developer Studio Project File - Name="TestWrite" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Console Application" 0x0103 CFG=TestWrite - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "TestWrite.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "TestWrite.mak" CFG="TestWrite - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "TestWrite - Win32 Release" (based on "Win32 (x86) Console Application") !MESSAGE "TestWrite - Win32 Debug" (based on "Win32 (x86) Console Application") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "TestWrite - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c # ADD CPP /nologo /W3 /GX /O2 /I ".." /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WINDOWS" /YX /FD /c # ADD BASE RSC /l 0x100c /d "NDEBUG" # ADD RSC /l 0x100c /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib Papyrus3.lib /nologo /subsystem:console /machine:I386 /libpath:"..\Release" !ELSEIF "$(CFG)" == "TestWrite - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" # PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c # ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I ".." /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WINDOWS" /YX /FD /GZ /c # ADD BASE RSC /l 0x100c /d "_DEBUG" # ADD RSC /l 0x100c /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept # ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib Papyrus3.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\Debug" !ENDIF # Begin Target # Name "TestWrite - Win32 Release" # Name "TestWrite - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\TestWrite.c # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # End Group # Begin Group "Resource Files" # PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" # End Group # End Target # End Project Papyrus3/TESTS/TestRead.dsw0000755000175000017500000000103307535143454012672 0ustar Microsoft Developer Studio Workspace File, Format Version 6.00 # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! ############################################################################### Project: "TestRead"=.\TestRead.dsp - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Global: Package=<5> {{{ }}} Package=<3> {{{ }}} ############################################################################### Papyrus3/TESTS/TestRead.plg0000755000175000017500000000262007535143454012662 0ustar 
    Build Log
    

    
--------------------Configuration: TestRead - Win32 Debug--------------------

    

    Command Lines
    
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP177.tmp" with contents
[
/nologo /MLd /W3 /Gm /GX /ZI /Od /I ".." /D "_DEBUG" /D "_WINDOWS" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /Fp"Debug/TestRead.pch" /YX /Fo"Debug/" /Fd"Debug/" /FD /GZ /c 
"C:\Papyrus3\TESTS\TestRead.c"
]
Creating command line "cl.exe @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP177.tmp" 
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP178.tmp" with contents
[
kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib Papyrus3.lib /nologo /subsystem:console /incremental:yes /pdb:"Debug/TestRead.pdb" /debug /machine:I386 /out:"Debug/TestRead.exe" /pdbtype:sept /libpath:"..\Debug" 
.\Debug\TestRead.obj
]
Creating command line "link.exe @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP178.tmp"

    Output Window
    
Compiling...
TestRead.c
c:\papyrus3\tests\testread.c(42) : warning C4013: 'exit' undefined; assuming extern returning int
Linking...




    Results
    
TestRead.exe - 0 error(s), 1 warning(s)
    Papyrus3/TESTS/TestWrite.dsw0000755000175000017500000000103507535143454013113 0ustar Microsoft Developer Studio Workspace File, Format Version 6.00 # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! ############################################################################### Project: "TestWrite"=.\TestWrite.dsp - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Global: Package=<5> {{{ }}} Package=<3> {{{ }}} ############################################################################### Papyrus3/TESTS/TestWrite.plg0000755000175000017500000000261707535143454013107 0ustar 
    Build Log
    

    
--------------------Configuration: TestWrite - Win32 Debug--------------------

    

    Command Lines
    
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP15E.tmp" with contents
[
/nologo /MLd /W3 /Gm /GX /ZI /Od /I ".." /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "_WINDOWS" /Fp"Debug/TestWrite.pch" /YX /Fo"Debug/" /Fd"Debug/" /FD /GZ /c 
"C:\PAPYRUS3\TESTS\TestWrite.c"
]
Creating command line "cl.exe @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP15E.tmp" 
Creating temporary file "C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP15F.tmp" with contents
[
kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib Papyrus3.lib /nologo /subsystem:console /incremental:yes /pdb:"Debug/TestWrite.pdb" /debug /machine:I386 /out:"Debug/TestWrite.exe" /pdbtype:sept /libpath:"..\Debug" 
.\Debug\TestWrite.obj
]
Creating command line "link.exe @C:\DOCUME~1\mal.HUG\LOCALS~1\Temp\RSP15F.tmp"

    Output Window
    
Compiling...
TestWrite.c
C:\PAPYRUS3\TESTS\TestWrite.c(28) : warning C4101: 'theVR' : unreferenced local variable
Linking...




    Results
    
TestWrite.exe - 0 error(s), 1 warning(s)
    Papyrus3/PapyGlobalVar3.h0000755000175000017500000006421310044204066012470 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyGlobalVar3.h */ /* Function : contains the declarations of global variables */ /* Authors : Christian Girard */ /* Marianne Logean */ /* */ /* History : 12.1990 version 1.0 */ /* 04.1991 version 1.1 */ /* 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #ifndef PapyGlobalVar3H #define PapyGlobalVar3H #ifdef FILENAME83 #undef FILENAME83 #endif /* --- global variables --- */ /* compatibility variables to ensure the version of the PAPYRUS toolkit */ /* is able to read a given file */ /* which version of the PAPYRUS toolkit are we running ? */ WHERE3 char gPapyrusVersion [6]; /* is my file compatible with this version of the PAPYRUS toolkit */ WHERE3 char gPapyrusCompatibility [2]; /* the version of this particular PAPYRUS file */ WHERE3 float gPapyrusFileVersion [kMax_file_open]; /* has the PAPYRUS toolkit been initialized or not ? */ WHERE3 int gIsPapy3Inited; /* Papyrus file pointers to the currently open files */ WHERE3 PAPY_FILE gPapyFile [kMax_file_open]; /* What is the type of the fiel we are dealing with ? */ /* DICOM10, PAPYRUS3, DICOM_NOT10, DICOMDIR */ WHERE3 enum EFile_Type gIsPapyFile [kMax_file_open]; /* the current name (incremental) to give to a tmp or DICOM file */ WHERE3 int gCurrTmpFilename [kMax_file_open]; /* filename for each open file in write mode */ WHERE3 char *gPapFilename [kMax_file_open]; /* nb of images in each file */ WHERE3 PapyShort gArrNbImages [kMax_file_open]; /* pointer to the list of icons (only valid if Papyrus compressed images */ WHERE3 PapyUChar **gArrIcons [kMax_file_open]; /* pointers to the group 41 of each file in read mode */ WHERE3 SElement *gArrGroup41 [kMax_file_open]; /* the syntax used in each open file */ WHERE3 enum ETransf_Syntax gArrTransfSyntax [kMax_file_open]; /* the compression used for the images of each file */ WHERE3 enum EPap_Compression gArrCompression [kMax_file_open]; /* the photometric interpretation of the images of each file */ WHERE3 enum EPhoto_Interpret gArrPhotoInterpret [kMax_file_open]; /* the pointers on the memory structure of the files */ WHERE3 Item *gArrMemFile [kMax_file_open]; /* pointers to the file summaries objects */ WHERE3 Item *gPatientSummaryItem [kMax_file_open]; /* pointers to the begining of the pointer sequences item */ WHERE3 Item *gPtrSequenceItem [kMax_file_open]; /* pointers to the begining of the image sequences item */ WHERE3 Item *gImageSequenceItem [kMax_file_open]; WHERE3 SGroup gArrGroup [END_GROUP]; WHERE3 PapyShort gArrModule [END_MODULE]; /* for each modality defined, store the enumeration of the modules and their usage */ WHERE3 Data_Set *gArrModalities [END_MODALITY]; WHERE3 int gArrModuleNb [END_MODALITY]; /* for each modality stores the associated UID */ WHERE3 char *gArrUIDs [END_MODALITY]; /* store the modality of each file */ WHERE3 int gFileModality [kMax_file_open]; /* is the file in read or write mode ? */ WHERE3 PapyShort gReadOrWrite [kMax_file_open]; /* the current overlay group number */ WHERE3 PapyUShort gCurrentOverlay [kMax_file_open]; /* the current UINoverlay group number */ WHERE3 PapyUShort gCurrentUINOverlay [kMax_file_open]; /* nb of allowed element in shadow group */ WHERE3 PapyUShort gNbShadowOwner [kMax_file_open]; /* list of allowed elements */ WHERE3 SShadowOwner *gShadowOwner [kMax_file_open]; /* backward references */ WHERE3 char *gx0028ImageFormat [kMax_file_open]; WHERE3 PapyUShort gx0028Rows [kMax_file_open]; WHERE3 PapyUShort gx0028Columns [kMax_file_open]; WHERE3 PapyUShort gx0028BitsAllocated [kMax_file_open]; WHERE3 PapyUShort gx0028BitsStored [kMax_file_open]; /* variables needed for the creation of the pointer sequence */ /* Image Identification Module */ WHERE3 char *gRefSOPClassUID [kMax_file_open]; WHERE3 char *gRefSOPInstanceUID; WHERE3 char *gRefImageNb; /* Icon Image Module */ WHERE3 PapyUShort gRefRows; WHERE3 PapyUShort gRefColumns; WHERE3 PapyUShort gRefBitsAllocated; WHERE3 PapyUShort gRefBitsStored; WHERE3 PapyUShort gRefHighBit; WHERE3 PapyUShort gRefIsSigned; WHERE3 PapyUShort gRefPixMin; WHERE3 PapyUShort gRefPixMax; WHERE3 PapyLong gRefWW; WHERE3 PapyLong gRefWL; WHERE3 PapyUShort *gRefPixelData; WHERE3 PapyUShort gIconSize; /* the size of the icon image */ /* the compression used for the images of the converted file */ WHERE3 enum EPap_Compression gCompression; WHERE3 int gCompressionFactor; WHERE3 float gZoomFactor; WHERE3 float gSubSamplingFactor; WHERE3 float gLeftX; WHERE3 float gTopY; WHERE3 float gRightX; WHERE3 float gBottomY; WHERE3 int gWindowWidth; WHERE3 int gWindowLevel; /* Image Pointer Module & Pixel Offset Module */ /* referenced SOP instance UID of each image of each file */ WHERE3 char **gImageSOPinstUID [kMax_file_open]; /* offset to the data set for each data set of each file */ WHERE3 PapyULong *gRefImagePointer [kMax_file_open]; /* offset to the pixel data element of each data set of each file */ WHERE3 PapyULong *gRefPixelOffset [kMax_file_open]; /* position of insertion of the value of gRefImagePointer (write) */ WHERE3 PapyULong *gPosImagePointer [kMax_file_open]; /* position of insertion of the value of gRefPixelOffset (write) */ WHERE3 PapyULong *gPosPixelOffset [kMax_file_open]; /* offset to the Pointer Sequence (read) */ WHERE3 PapyULong gOffsetToPtrSeq [kMax_file_open]; /* offset to the Image Sequence (read) */ WHERE3 PapyULong gOffsetToImageSeq [kMax_file_open]; /* offset to the First Patient : 0x0004:0x1200 */ WHERE3 PapyULong gPosFirstPatientOffset [kMax_file_open]; WHERE3 PapyULong gRefFirstPatientOffset [kMax_file_open]; /* offset to the Last Patient : 0x0004:0x1202 */ WHERE3 PapyULong gPosLastPatientOffset [kMax_file_open]; WHERE3 PapyULong gRefLastPatientOffset [kMax_file_open]; /* offset of the Next Directory Record of the same Directory Entity */ WHERE3 PapyULong *gPosNextDirRecordOffset [kMax_file_open]; WHERE3 PapyULong *gRefNextDirRecordOffset [kMax_file_open]; /* offset of the First Directory Record of the Referenced Lower Level Directory */ WHERE3 PapyULong *gPosLowerLevelDirRecordOffset [kMax_file_open]; WHERE3 PapyULong *gRefLowerLevelDirRecordOffset [kMax_file_open]; /* the current file number (for the indexes) */ WHERE3 PapyShort gCurrFile; /* module names */ WHERE3 char *sModule_Acquisition_Context; WHERE3 char *sModule_Approval; WHERE3 char *sModule_Audio; WHERE3 char *sModule_Basic_Annotation_Presentation; WHERE3 char *sModule_Basic_Film_Box_Presentation; WHERE3 char *sModule_Basic_Film_Box_Relationship; WHERE3 char *sModule_Basic_Film_Session_Presentation; WHERE3 char *sModule_Basic_Film_Session_Relationship; WHERE3 char *sModule_BiPlane_Image; WHERE3 char *sModule_BiPlane_Overlay; WHERE3 char *sModule_BiPlane_Sequence; WHERE3 char *sModule_Cine; WHERE3 char *sModule_Contrast_Bolus; WHERE3 char *sModule_CR_Image; WHERE3 char *sModule_CR_Series; WHERE3 char *sModule_CT_Image; WHERE3 char *sModule_Curve; WHERE3 char *sModule_Curve_Identification; WHERE3 char *sModule_Device; WHERE3 char *sModule_Directory_Information; WHERE3 char *sModule_Display_Shutter; WHERE3 char *sModule_DX_Anatomy_Imaged; WHERE3 char *sModule_DX_Detector; WHERE3 char *sModule_DX_Image; WHERE3 char *sModule_DX_Positioning; WHERE3 char *sModule_DX_Series; WHERE3 char *sModule_External_Papyrus_File_Reference_Sequence; WHERE3 char *sModule_External_Patient_File_Reference_Sequence; WHERE3 char *sModule_External_Study_File_Reference_Sequence; WHERE3 char *sModule_External_Visit_Reference_Sequence; WHERE3 char *sModule_File_Reference; WHERE3 char *sModule_File_Set_Identification; WHERE3 char *sModule_Frame_Of_Reference; WHERE3 char *sModule_Frame_Pointers; WHERE3 char *sModule_General_Equipment; WHERE3 char *sModule_General_Image; WHERE3 char *sModule_General_Patient_Summary; WHERE3 char *sModule_General_Series; WHERE3 char *sModule_General_Series_Summary; WHERE3 char *sModule_General_Study; WHERE3 char *sModule_General_Study_Summary; WHERE3 char *sModule_General_Visit_Summary; WHERE3 char *sModule_Icon_Image; WHERE3 char *sModule_Identifying_Image_Sequence; WHERE3 char *sModule_Image_Box_Pixel_Presentation; WHERE3 char *sModule_Image_Box_Relationship; WHERE3 char *sModule_Image_Histogram; WHERE3 char *sModule_Image_Identification; WHERE3 char *sModule_Image_Overlay_Box_Presentation; WHERE3 char *sModule_Image_Overlay_Box_Relationship; WHERE3 char *sModule_Image_Pixel; WHERE3 char *sModule_Image_Plane; WHERE3 char *sModule_Image_Pointer; WHERE3 char *sModule_Image_Sequence; WHERE3 char *sModule_Internal_Image_Pointer_Sequence; WHERE3 char *sModule_Interpretation_Approval; WHERE3 char *sModule_Interpretation_Identification; WHERE3 char *sModule_Interpretation_Recording; WHERE3 char *sModule_Interpretation_Relationship; WHERE3 char *sModule_Interpretation_State; WHERE3 char *sModule_Interpretation_Transcription; WHERE3 char *sModule_Intra_Oral_Image; WHERE3 char *sModule_Intra_Oral_Series; WHERE3 char *sModule_LUT_Identification; WHERE3 char *sModule_Mammography_Image; WHERE3 char *sModule_Mammography_Series; WHERE3 char *sModule_Mask; WHERE3 char *sModule_Modality_LUT; WHERE3 char *sModule_MR_Image; WHERE3 char *sModule_Multi_Frame; WHERE3 char *sModule_Multi_frame_Overlay; WHERE3 char *sModule_NM_Detector; WHERE3 char *sModule_NM_Image; WHERE3 char *sModule_NM_Image_Pixel; WHERE3 char *sModule_NM_Isotope; WHERE3 char *sModule_NM_Multi_Frame; WHERE3 char *sModule_NM_Multi_gated_Acquisition_Image; WHERE3 char *sModule_NM_Phase; WHERE3 char *sModule_NM_Reconstruction; WHERE3 char *sModule_NM_Series; WHERE3 char *sModule_NM_Tomo_Acquisition; WHERE3 char *sModule_Overlay_Identification; WHERE3 char *sModule_Overlay_Plane; WHERE3 char *sModule_Palette_Color_Lookup; WHERE3 char *sModule_Patient; WHERE3 char *sModule_Patient_Demographic; WHERE3 char *sModule_Patient_Identification; WHERE3 char *sModule_Patient_Medical; WHERE3 char *sModule_Patient_Relationship; WHERE3 char *sModule_Patient_Study; WHERE3 char *sModule_Patient_Summary; WHERE3 char *sModule_PET_Curve; WHERE3 char *sModule_PET_Image; WHERE3 char *sModule_PET_Isotope; WHERE3 char *sModule_PET_Multi_Gated_Acquisition; WHERE3 char *sModule_PET_Series; WHERE3 char *sModule_Pixel_Offset; WHERE3 char *sModule_Printer; WHERE3 char *sModule_Print_Job; WHERE3 char *sModule_Result_Identification; WHERE3 char *sModule_Results_Impression; WHERE3 char *sModule_Result_Relationship; WHERE3 char *sModule_RF_Tomography_Acquisition; WHERE3 char *sModule_ROI_Contour; WHERE3 char *sModule_RT_Beams; WHERE3 char *sModule_RT_Brachy_Application_Setups; WHERE3 char *sModule_RT_Dose; WHERE3 char *sModule_RT_Dose_ROI; WHERE3 char *sModule_RT_DVH; WHERE3 char *sModule_RT_Fraction_Scheme; WHERE3 char *sModule_RT_General_Plan; WHERE3 char *sModule_RT_Image; WHERE3 char *sModule_RT_Patient_Setup; WHERE3 char *sModule_RT_Prescription; WHERE3 char *sModule_RT_ROI_Observations; WHERE3 char *sModule_RT_Series; WHERE3 char *sModule_RT_Tolerance_Tables; WHERE3 char *sModule_SC_Image; WHERE3 char *sModule_SC_Image_Equipment; WHERE3 char *sModule_SC_Multi_Frame_Image; WHERE3 char *sModule_SC_Multi_Frame_Vector; WHERE3 char *sModule_Slice_Coordinates; WHERE3 char *sModule_SOP_Common; WHERE3 char *sModule_Specimen_Identification; WHERE3 char *sModule_Structure_Set; WHERE3 char *sModule_Study_Acquisition; WHERE3 char *sModule_Study_Classification; WHERE3 char *sModule_Study_Component; WHERE3 char *sModule_Study_Component_Acquisition; WHERE3 char *sModule_Study_Component_Relationship; WHERE3 char *sModule_Study_Content; WHERE3 char *sModule_Study_Identification; WHERE3 char *sModule_Study_Read; WHERE3 char *sModule_Study_Relationship; WHERE3 char *sModule_Study_Scheduling; WHERE3 char *sModule_Therapy; WHERE3 char *sModule_UIN_Overlay_Sequence; WHERE3 char *sModule_US_Frame_of_Reference; WHERE3 char *sModule_US_Image; WHERE3 char *sModule_US_Region_Calibration; WHERE3 char *sModule_Visit_Admission; WHERE3 char *sModule_Visit_Discharge; WHERE3 char *sModule_Visit_Identification; WHERE3 char *sModule_Visit_Relationship; WHERE3 char *sModule_Visit_Scheduling; WHERE3 char *sModule_Visit_Status; WHERE3 char *sModule_VL_Image; WHERE3 char *sModule_VOI_LUT; WHERE3 char *sModule_XRay_Acquisition; WHERE3 char *sModule_XRay_Acquisition_Dose; WHERE3 char *sModule_XRay_Collimator; WHERE3 char *sModule_XRay_Filtration; WHERE3 char *sModule_XRay_Generation; WHERE3 char *sModule_XRay_Grid; WHERE3 char *sModule_XRay_Image; WHERE3 char *sModule_XRay_Table; WHERE3 char *sModule_XRay_Tomography_Acquisition; WHERE3 char *sModule_XRF_Positioner; /* labels of the elements of all modules */ WHERE3 char *sLabel_Acquisition_Context [3]; WHERE3 char *sLabel_Audio [10]; WHERE3 char *sLabel_BasicAnnotationPresentation [3]; WHERE3 char *sLabel_BasicFilmBoxPresentation [13]; WHERE3 char *sLabel_BasicFilmBoxRelationship [4]; WHERE3 char *sLabel_BasicFilmSessionPresentation [7]; WHERE3 char *sLabel_BasicFilmSessionRelationship [2]; WHERE3 char *sLabel_BiPlaneImage [3]; WHERE3 char *sLabel_BiPlaneOverlay [3]; WHERE3 char *sLabel_BiPlaneSequence [3]; WHERE3 char *sLabel_Cine [11]; WHERE3 char *sLabel_Contrast_Bolus [13]; WHERE3 char *sLabel_CR_Image [16]; WHERE3 char *sLabel_CR_Series [8]; WHERE3 char *sLabel_CT_Image [26]; WHERE3 char *sLabel_Curve [17]; WHERE3 char *sLabel_Curve_Identification [7]; WHERE3 char *sLabel_Device [2]; WHERE3 char *sLabel_Directory_Information [5]; WHERE3 char *sLabel_Display_Shutter [9]; WHERE3 char *sLabel_DX_Anatomy_Imaged [4]; WHERE3 char *sLabel_DX_Detector [28]; WHERE3 char *sLabel_DX_Image [22]; WHERE3 char *sLabel_DX_Positioning [22]; WHERE3 char *sLabel_DX_Series [4]; WHERE3 char *sLabel_External_Papyrus_File_Reference_Sequence [2]; WHERE3 char *sLabel_External_Patient_File_Reference_Sequence [2]; WHERE3 char *sLabel_External_Study_File_Reference_Sequence [2]; WHERE3 char *sLabel_External_Visit_Reference_Sequence [2]; WHERE3 char *sLabel_File_Reference [5]; WHERE3 char *sLabel_File_Set_Identification [4]; WHERE3 char *sLabel_Frame_Of_Reference [3]; WHERE3 char *sLabel_Frame_Pointers [4]; WHERE3 char *sLabel_General_Equipment [13]; WHERE3 char *sLabel_General_Image [15]; WHERE3 char *sLabel_General_Patient_Summary [7]; WHERE3 char *sLabel_General_Series [16]; WHERE3 char *sLabel_General_Series_Summary [5]; WHERE3 char *sLabel_General_Study [11]; WHERE3 char *sLabel_General_Study_Summary [7]; WHERE3 char *sLabel_General_Visit_Summary [4]; WHERE3 char *sLabel_Icon_Image [16]; WHERE3 char *sLabel_Identifying_Image_Sequence [2]; WHERE3 char *sLabel_Image_Box_Pixel_Presentation [8]; WHERE3 char *sLabel_Image_Box_Relationship [4]; WHERE3 char *sLabel_Image_Histogram [2]; WHERE3 char *sLabel_Image_Identification [4]; WHERE3 char *sLabel_Image_Overlay_Box_Presentation [7]; WHERE3 char *sLabel_Image_Overlay_Box_Relationship [2]; WHERE3 char *sLabel_Image_Pixel [20]; WHERE3 char *sLabel_Image_Plane [6]; WHERE3 char *sLabel_Image_Pointer [2]; WHERE3 char *sLabel_Image_Sequence [2]; WHERE3 char *sLabel_Internal_Image_Pointer_Sequence [2]; WHERE3 char *sLabel_Interpretation_Approval [5]; WHERE3 char *sLabel_Interpretation_Identification [3]; WHERE3 char *sLabel_Interpretation_Recording [5]; WHERE3 char *sLabel_Interpretation_Relationship [2]; WHERE3 char *sLabel_Interpretation_State [3]; WHERE3 char *sLabel_Interpretation_Transcription [6]; WHERE3 char *sLabel_Intra_Oral_Image [6]; WHERE3 char *sLabel_Intra_Oral_Series [2]; WHERE3 char *sLabel_LUT_Identification [3]; WHERE3 char *sLabel_Mammography_Image [9]; WHERE3 char *sLabel_Mammography_Series [2]; WHERE3 char *sLabel_Mask [3]; WHERE3 char *sLabel_Modality_LUT [5]; WHERE3 char *sLabel_MR_Image [49]; WHERE3 char *sLabel_Multi_Frame [3]; WHERE3 char *sLabel_Multi_frame_Overlay [3]; WHERE3 char *sLabel_NM_Detector [2]; WHERE3 char *sLabel_NM_Image [20]; WHERE3 char *sLabel_NM_Image_Pixel [7]; WHERE3 char *sLabel_NM_Isotope [4]; WHERE3 char *sLabel_NM_Multi_Frame [18]; WHERE3 char *sLabel_NM_Multi_gated_Acquisition_Image [6]; WHERE3 char *sLabel_NM_Phase [2]; WHERE3 char *sLabel_NM_Reconstruction [6]; WHERE3 char *sLabel_NM_Series [3]; WHERE3 char *sLabel_NM_Tomo_Acquisition [3]; WHERE3 char *sLabel_Overlay_Identification [5]; WHERE3 char *sLabel_Overlay_Plane [22]; WHERE3 char *sLabel_Palette_Color_Lookup [11]; WHERE3 char *sLabel_Patient [11]; WHERE3 char *sLabel_Patient_Demographic [16]; WHERE3 char *sLabel_Patient_Identification [9]; WHERE3 char *sLabel_Patient_Medical [9]; WHERE3 char *sLabel_Patient_Relationship [4]; WHERE3 char *sLabel_Patient_Study [7]; WHERE3 char *sLabel_Patient_Summary [3]; WHERE3 char *sLabel_Pixel_Offset [2]; WHERE3 char *sLabel_Printer [10]; WHERE3 char *sLabel_Print_Job [8]; WHERE3 char *sLabel_Result_Identification [3]; WHERE3 char *sLabel_Results_Impression [3]; WHERE3 char *sLabel_Result_Relationship [3]; WHERE3 char *sLabel_SC_Image [3]; WHERE3 char *sLabel_SC_Image_Equipment [9]; WHERE3 char *sLabel_SOP_Common [7]; WHERE3 char *sLabel_Specimen_Identification [3]; WHERE3 char *sLabel_Study_Acquisition [11]; WHERE3 char *sLabel_Study_Classification [4]; WHERE3 char *sLabel_Study_Component [4]; WHERE3 char *sLabel_Study_Component_Acquisition [6]; WHERE3 char *sLabel_Study_Component_Relationship [2]; WHERE3 char *sLabel_Study_Content [4]; WHERE3 char *sLabel_Study_Identification [4]; WHERE3 char *sLabel_Study_Read [4]; WHERE3 char *sLabel_Study_Relationship [7]; WHERE3 char *sLabel_Study_Scheduling [13]; WHERE3 char *sLabel_Therapy [2]; WHERE3 char *sLabel_UIN_Overlay_Sequence [3]; WHERE3 char *sLabel_US_Frame_of_Reference [13]; WHERE3 char *sLabel_US_Image [47]; WHERE3 char *sLabel_US_Region_Calibration [2]; WHERE3 char *sLabel_Visit_Admission [9]; WHERE3 char *sLabel_Visit_Discharge [5]; WHERE3 char *sLabel_Visit_Identification [6]; WHERE3 char *sLabel_Visit_Relationship [3]; WHERE3 char *sLabel_Visit_Scheduling [6]; WHERE3 char *sLabel_Visit_Status [5]; WHERE3 char *sLabel_VOI_LUT [5]; WHERE3 char *sLabel_XRay_Acquisition [16]; WHERE3 char *sLabel_XRay_Acquisition_Dose [22]; WHERE3 char *sLabel_XRay_Collimator [9]; WHERE3 char *sLabel_XRay_Filtration [5]; WHERE3 char *sLabel_XRay_Generation [13]; WHERE3 char *sLabel_XRay_Grid [9]; WHERE3 char *sLabel_XRay_Image [19]; WHERE3 char *sLabel_XRay_Table [6]; WHERE3 char *sLabel_XRay_Tomography_Acquisition [7]; #endif /* PapyGlobalVar3H */ Papyrus3/PapyVars3.c0000755000175000017500000001145010044200440011510 0ustar /********************************************************************************/ /* */ /* Papyrus 3 library. */ /* This library constitutes a DICOM file system which helps reading and writing */ /* DICOM files and DICOMDIR files. */ /* */ /* Copyright (C) 2004 - Service of Medical Informatics - */ /* University Hospitals of Geneva (HUG), Geneva, Switzerland */ /* */ /* This library is a free software; you can redistribute it and/or modify it */ /* under the terms of the GNU Lesser General Public License as published by the */ /* Free Software Foundation; either version 2.1 of the License, or */ /* (at your option) any later version. */ /* */ /* This library is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* See the GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ /* along with this library; if not, write to */ /* the Free Software Foundation, Inc., */ /* 59 Temple Place, Suite 330, */ /* Boston, MA 02111-1307 USA */ /* */ /* You can contact us for more information at osiris@sim.hcuge.ch */ /* or by writing to Papyrus, */ /* Unite d'Imagerie Numerique / Service d'Informatique Medicale / HUG, */ /* 24, Micheli-du-Crest street, 1211 Geneva 14, Switzerland. */ /* */ /* The University Hopitals of Geneva, hereby disclaims all copyright interest */ /* in the library `Papyrus' (a library for reading and writing DICOM files). */ /* */ /* Geneva, april 2004 */ /* Antoine Geissbuhler, head of the Service of Medical Informatics, */ /* University Hospitals of Geneva, Switzerland */ /* */ /********************************************************************************/ /********************************************************************************/ /* */ /* Project : P A P Y R U S Toolkit */ /* File : PapyVars3.c */ /* Function : Global variables */ /* Authors : Jean-Francois Vurlod */ /* Marianne Logean */ /* */ /* History : 12.1991 version 1.2 */ /* 06.1993 version 2.0 */ /* 06.1994 version 3.0 */ /* 06.1995 version 3.1 */ /* 02.1996 version 3.3 */ /* 02.1999 version 3.6 */ /* 04.2001 version 3.7 */ /* 09.2001 version 3.7 on CVS */ /* 10.2001 version 3.71 MAJ Dicom par CHG */ /* */ /********************************************************************************/ #include #ifndef PAPY3_VAR #define PAPY3_VAR #endif #ifndef Papyrus3H #include "Papyrus3.h" #endif Papyrus3/Makefile.PC0000755000175000017500000000222407535143454011502 0ustar # @(#)Makefile 1.3 5/3/91 ARCH= Solaris DSTDIR= .. MANDIR= $(DSTDIR)/man JPEGDIRLL= JpegDir/JpgLless JPEGDIRLY= JpegDir/JpgLossy MAYODIR= Mayo BINDIR= $(DSTDIR)/test LIBDIR= $(DSTDIR)/$(ARCH)/lib LINTLIBDIR= $(LIBDIR)/lint INCPAPYRUS2DIR= ../Papyrus2 LIBPAPYRUS2DIR= ../Papyrus2/$(ARCH)/lib CPPFLAGS= -I. -I../.. -I$(INCPAPYRUS2DIR) -I$(JPEGDIRLL) -I$(JPEGDIRLY) -D_NO_LONGLONG CFLAGS= -g LINTFLAGS= -hb SOURCES= \ PapyConvertFile3.c \ PapyError3.c \ PapyFileSystemUnix3.c \ PapyFiles3.c \ PapyGetGlobalVar3.c \ PapyInit3.c \ PapyInitGroups3.c \ PapyInitModules3.c \ PapyRead3.c \ PapyDataSetRead3.c \ PapyList3.c \ PapyVars3.c \ PapyWrite3.c \ PapyDataSetWrite3.c \ PapyEallocUnix3.c \ PapyWild3.c \ PapyWildexit3.c \ PapyUtils3.c LIBRARY= libP.a OBJECTS= $(SOURCES:%.c=$(ARCH)/%.o) $(LIBDIR)/$(LIBRARY): $(OBJECTS) ar rv $@ $? cd JpegDir/JpgLless;make; cd JpegDir/JpgLossy;make lint: $(SOURCES) $(LINT.c) $(SOURCES) .KEEP_STATE: .INIT: $(LIBDIR) $(ARCH) $(LIBDIR) $(ARCH) : test -d $@ || mkdir -p $@ $(ARCH)/%.o: %.c $(COMPILE.c) $< -o $@