| Index: core/src/fxcodec/fx_tiff/tiff_v403/tif_ojpeg.c
|
| diff --git a/core/src/fxcodec/fx_tiff/tiff_v403/tif_ojpeg.c b/core/src/fxcodec/fx_tiff/tiff_v403/tif_ojpeg.c
|
| deleted file mode 100644
|
| index dfd1403aa5d9003cbc11bf3d169c5bfa44b88636..0000000000000000000000000000000000000000
|
| --- a/core/src/fxcodec/fx_tiff/tiff_v403/tif_ojpeg.c
|
| +++ /dev/null
|
| @@ -1,2504 +0,0 @@
|
| -/* $Id: tif_ojpeg.c,v 1.56 2012-05-24 03:15:18 fwarmerdam Exp $ */
|
| -
|
| -/* WARNING: The type of JPEG encapsulation defined by the TIFF Version 6.0
|
| - specification is now totally obsolete and deprecated for new applications and
|
| - images. This file was was created solely in order to read unconverted images
|
| - still present on some users' computer systems. It will never be extended
|
| - to write such files. Writing new-style JPEG compressed TIFFs is implemented
|
| - in tif_jpeg.c.
|
| -
|
| - The code is carefully crafted to robustly read all gathered JPEG-in-TIFF
|
| - testfiles, and anticipate as much as possible all other... But still, it may
|
| - fail on some. If you encounter problems, please report them on the TIFF
|
| - mailing list and/or to Joris Van Damme <info@awaresystems.be>.
|
| -
|
| - Please read the file called "TIFF Technical Note #2" if you need to be
|
| - convinced this compression scheme is bad and breaks TIFF. That document
|
| - is linked to from the LibTiff site <http://www.remotesensing.org/libtiff/>
|
| - and from AWare Systems' TIFF section
|
| - <http://www.awaresystems.be/imaging/tiff.html>. It is also absorbed
|
| - in Adobe's specification supplements, marked "draft" up to this day, but
|
| - supported by the TIFF community.
|
| -
|
| - This file interfaces with Release 6B of the JPEG Library written by the
|
| - Independent JPEG Group. Previous versions of this file required a hack inside
|
| - the LibJpeg library. This version no longer requires that. Remember to
|
| - remove the hack if you update from the old version.
|
| -
|
| - Copyright (c) Joris Van Damme <info@awaresystems.be>
|
| - Copyright (c) AWare Systems <http://www.awaresystems.be/>
|
| -
|
| - The licence agreement for this file is the same as the rest of the LibTiff
|
| - library.
|
| -
|
| - IN NO EVENT SHALL JORIS VAN DAMME OR AWARE SYSTEMS BE LIABLE FOR
|
| - ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
|
| - OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
| - WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
|
| - LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
| - OF THIS SOFTWARE.
|
| -
|
| - Joris Van Damme and/or AWare Systems may be available for custom
|
| - developement. If you like what you see, and need anything similar or related,
|
| - contact <info@awaresystems.be>.
|
| -*/
|
| -
|
| -/* What is what, and what is not?
|
| -
|
| - This decoder starts with an input stream, that is essentially the JpegInterchangeFormat
|
| - stream, if any, followed by the strile data, if any. This stream is read in
|
| - OJPEGReadByte and related functions.
|
| -
|
| - It analyzes the start of this stream, until it encounters non-marker data, i.e.
|
| - compressed image data. Some of the header markers it sees have no actual content,
|
| - like the SOI marker, and APP/COM markers that really shouldn't even be there. Some
|
| - other markers do have content, and the valuable bits and pieces of information
|
| - in these markers are saved, checking all to verify that the stream is more or
|
| - less within expected bounds. This happens inside the OJPEGReadHeaderInfoSecStreamXxx
|
| - functions.
|
| -
|
| - Some OJPEG imagery contains no valid JPEG header markers. This situation is picked
|
| - up on if we've seen no SOF marker when we're at the start of the compressed image
|
| - data. In this case, the tables are read from JpegXxxTables tags, and the other
|
| - bits and pieces of information is initialized to its most basic value. This is
|
| - implemented in the OJPEGReadHeaderInfoSecTablesXxx functions.
|
| -
|
| - When this is complete, a good and valid JPEG header can be assembled, and this is
|
| - passed through to LibJpeg. When that's done, the remainder of the input stream, i.e.
|
| - the compressed image data, can be passed through unchanged. This is done in
|
| - OJPEGWriteStream functions.
|
| -
|
| - LibTiff rightly expects to know the subsampling values before decompression. Just like
|
| - in new-style JPEG-in-TIFF, though, or even more so, actually, the YCbCrsubsampling
|
| - tag is notoriously unreliable. To correct these tag values with the ones inside
|
| - the JPEG stream, the first part of the input stream is pre-scanned in
|
| - OJPEGSubsamplingCorrect, making no note of any other data, reporting no warnings
|
| - or errors, up to the point where either these values are read, or it's clear they
|
| - aren't there. This means that some of the data is read twice, but we feel speed
|
| - in correcting these values is important enough to warrant this sacrifice. Allthough
|
| - there is currently no define or other configuration mechanism to disable this behaviour,
|
| - the actual header scanning is build to robustly respond with error report if it
|
| - should encounter an uncorrected mismatch of subsampling values. See
|
| - OJPEGReadHeaderInfoSecStreamSof.
|
| -
|
| - The restart interval and restart markers are the most tricky part... The restart
|
| - interval can be specified in a tag. It can also be set inside the input JPEG stream.
|
| - It can be used inside the input JPEG stream. If reading from strile data, we've
|
| - consistenly discovered the need to insert restart markers in between the different
|
| - striles, as is also probably the most likely interpretation of the original TIFF 6.0
|
| - specification. With all this setting of interval, and actual use of markers that is not
|
| - predictable at the time of valid JPEG header assembly, the restart thing may turn
|
| - out the Achilles heel of this implementation. Fortunately, most OJPEG writer vendors
|
| - succeed in reading back what they write, which may be the reason why we've been able
|
| - to discover ways that seem to work.
|
| -
|
| - Some special provision is made for planarconfig separate OJPEG files. These seem
|
| - to consistently contain header info, a SOS marker, a plane, SOS marker, plane, SOS,
|
| - and plane. This may or may not be a valid JPEG configuration, we don't know and don't
|
| - care. We want LibTiff to be able to access the planes individually, without huge
|
| - buffering inside LibJpeg, anyway. So we compose headers to feed to LibJpeg, in this
|
| - case, that allow us to pass a single plane such that LibJpeg sees a valid
|
| - single-channel JPEG stream. Locating subsequent SOS markers, and thus subsequent
|
| - planes, is done inside OJPEGReadSecondarySos.
|
| -
|
| - The benefit of the scheme is... that it works, basically. We know of no other that
|
| - does. It works without checking software tag, or otherwise going about things in an
|
| - OJPEG flavor specific manner. Instead, it is a single scheme, that covers the cases
|
| - with and without JpegInterchangeFormat, with and without striles, with part of
|
| - the header in JpegInterchangeFormat and remainder in first strile, etc. It is forgiving
|
| - and robust, may likely work with OJPEG flavors we've not seen yet, and makes most out
|
| - of the data.
|
| -
|
| - Another nice side-effect is that a complete JPEG single valid stream is build if
|
| - planarconfig is not separate (vast majority). We may one day use that to build
|
| - converters to JPEG, and/or to new-style JPEG compression inside TIFF.
|
| -
|
| - A dissadvantage is the lack of random access to the individual striles. This is the
|
| - reason for much of the complicated restart-and-position stuff inside OJPEGPreDecode.
|
| - Applications would do well accessing all striles in order, as this will result in
|
| - a single sequential scan of the input stream, and no restarting of LibJpeg decoding
|
| - session.
|
| -*/
|
| -
|
| -
|
| -#define WIN32_LEAN_AND_MEAN
|
| -#define VC_EXTRALEAN
|
| -
|
| -#include "tiffiop.h"
|
| -#ifdef OJPEG_SUPPORT
|
| -
|
| -/* Configuration defines here are:
|
| - * JPEG_ENCAP_EXTERNAL: The normal way to call libjpeg, uses longjump. In some environments,
|
| - * like eg LibTiffDelphi, this is not possible. For this reason, the actual calls to
|
| - * libjpeg, with longjump stuff, are encapsulated in dedicated functions. When
|
| - * JPEG_ENCAP_EXTERNAL is defined, these encapsulating functions are declared external
|
| - * to this unit, and can be defined elsewhere to use stuff other then longjump.
|
| - * The default mode, without JPEG_ENCAP_EXTERNAL, implements the call encapsulators
|
| - * here, internally, with normal longjump.
|
| - * SETJMP, LONGJMP, JMP_BUF: On some machines/environments a longjump equivalent is
|
| - * conviniently available, but still it may be worthwhile to use _setjmp or sigsetjmp
|
| - * in place of plain setjmp. These macros will make it easier. It is useless
|
| - * to fiddle with these if you define JPEG_ENCAP_EXTERNAL.
|
| - * OJPEG_BUFFER: Define the size of the desired buffer here. Should be small enough so as to guarantee
|
| - * instant processing, optimal streaming and optimal use of processor cache, but also big
|
| - * enough so as to not result in significant call overhead. It should be at least a few
|
| - * bytes to accomodate some structures (this is verified in asserts), but it would not be
|
| - * sensible to make it this small anyway, and it should be at most 64K since it is indexed
|
| - * with uint16. We recommend 2K.
|
| - * EGYPTIANWALK: You could also define EGYPTIANWALK here, but it is not used anywhere and has
|
| - * absolutely no effect. That is why most people insist the EGYPTIANWALK is a bit silly.
|
| - */
|
| -
|
| -/* define LIBJPEG_ENCAP_EXTERNAL */
|
| -#define SETJMP(jbuf) setjmp(jbuf)
|
| -#define LONGJMP(jbuf,code) longjmp(jbuf,code)
|
| -#define JMP_BUF jmp_buf
|
| -#define OJPEG_BUFFER 2048
|
| -/* define EGYPTIANWALK */
|
| -
|
| -#define JPEG_MARKER_SOF0 0xC0
|
| -#define JPEG_MARKER_SOF1 0xC1
|
| -#define JPEG_MARKER_SOF3 0xC3
|
| -#define JPEG_MARKER_DHT 0xC4
|
| -#define JPEG_MARKER_RST0 0XD0
|
| -#define JPEG_MARKER_SOI 0xD8
|
| -#define JPEG_MARKER_EOI 0xD9
|
| -#define JPEG_MARKER_SOS 0xDA
|
| -#define JPEG_MARKER_DQT 0xDB
|
| -#define JPEG_MARKER_DRI 0xDD
|
| -#define JPEG_MARKER_APP0 0xE0
|
| -#define JPEG_MARKER_COM 0xFE
|
| -
|
| -#define FIELD_OJPEG_JPEGINTERCHANGEFORMAT (FIELD_CODEC+0)
|
| -#define FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH (FIELD_CODEC+1)
|
| -#define FIELD_OJPEG_JPEGQTABLES (FIELD_CODEC+2)
|
| -#define FIELD_OJPEG_JPEGDCTABLES (FIELD_CODEC+3)
|
| -#define FIELD_OJPEG_JPEGACTABLES (FIELD_CODEC+4)
|
| -#define FIELD_OJPEG_JPEGPROC (FIELD_CODEC+5)
|
| -#define FIELD_OJPEG_JPEGRESTARTINTERVAL (FIELD_CODEC+6)
|
| -
|
| -static const TIFFField ojpegFields[] = {
|
| - {TIFFTAG_JPEGIFOFFSET,1,1,TIFF_LONG8,0,TIFF_SETGET_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGINTERCHANGEFORMAT,TRUE,FALSE,"JpegInterchangeFormat",NULL},
|
| - {TIFFTAG_JPEGIFBYTECOUNT,1,1,TIFF_LONG8,0,TIFF_SETGET_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH,TRUE,FALSE,"JpegInterchangeFormatLength",NULL},
|
| - {TIFFTAG_JPEGQTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGQTABLES,FALSE,TRUE,"JpegQTables",NULL},
|
| - {TIFFTAG_JPEGDCTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGDCTABLES,FALSE,TRUE,"JpegDcTables",NULL},
|
| - {TIFFTAG_JPEGACTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGACTABLES,FALSE,TRUE,"JpegAcTables",NULL},
|
| - {TIFFTAG_JPEGPROC,1,1,TIFF_SHORT,0,TIFF_SETGET_UINT16,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGPROC,FALSE,FALSE,"JpegProc",NULL},
|
| - {TIFFTAG_JPEGRESTARTINTERVAL,1,1,TIFF_SHORT,0,TIFF_SETGET_UINT16,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGRESTARTINTERVAL,FALSE,FALSE,"JpegRestartInterval",NULL},
|
| -};
|
| -
|
| -#ifndef LIBJPEG_ENCAP_EXTERNAL
|
| -#include <setjmp.h>
|
| -#endif
|
| -
|
| -/* We undefine FAR to avoid conflict with JPEG definition */
|
| -
|
| -#ifdef FAR
|
| -#undef FAR
|
| -#endif
|
| -
|
| -/*
|
| - Libjpeg's jmorecfg.h defines INT16 and INT32, but only if XMD_H is
|
| - not defined. Unfortunately, the MinGW and Borland compilers include
|
| - a typedef for INT32, which causes a conflict. MSVC does not include
|
| - a conficting typedef given the headers which are included.
|
| -*/
|
| -#if defined(__BORLANDC__) || defined(__MINGW32__)
|
| -# define XMD_H 1
|
| -#endif
|
| -
|
| -/* Define "boolean" as unsigned char, not int, per Windows custom. */
|
| -#if defined(__WIN32__) && !defined(__MINGW32__)
|
| -# 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 */
|
| -#endif
|
| -
|
| -#ifndef _FX_JPEG_TURBO_
|
| - #include "../../libjpeg/jpeglib.h"
|
| - #include "../../libjpeg/jerror.h"
|
| -#else
|
| - #include "../../libjpeg-turbo/jpeglib.h"
|
| - #include "../../libjpeg-turbo/jerror.h"
|
| -#endif//_FX_JPEG_TURBO_
|
| -
|
| -typedef struct jpeg_error_mgr jpeg_error_mgr;
|
| -typedef struct jpeg_common_struct jpeg_common_struct;
|
| -typedef struct jpeg_decompress_struct jpeg_decompress_struct;
|
| -typedef struct jpeg_source_mgr jpeg_source_mgr;
|
| -
|
| -typedef enum {
|
| - osibsNotSetYet,
|
| - osibsJpegInterchangeFormat,
|
| - osibsStrile,
|
| - osibsEof
|
| -} OJPEGStateInBufferSource;
|
| -
|
| -typedef enum {
|
| - ososSoi,
|
| - ososQTable0,ososQTable1,ososQTable2,ososQTable3,
|
| - ososDcTable0,ososDcTable1,ososDcTable2,ososDcTable3,
|
| - ososAcTable0,ososAcTable1,ososAcTable2,ososAcTable3,
|
| - ososDri,
|
| - ososSof,
|
| - ososSos,
|
| - ososCompressed,
|
| - ososRst,
|
| - ososEoi
|
| -} OJPEGStateOutState;
|
| -
|
| -typedef struct {
|
| - TIFF* tif;
|
| - #ifndef LIBJPEG_ENCAP_EXTERNAL
|
| - JMP_BUF exit_jmpbuf;
|
| - #endif
|
| - TIFFVGetMethod vgetparent;
|
| - TIFFVSetMethod vsetparent;
|
| - TIFFPrintMethod printdir;
|
| - uint64 file_size;
|
| - uint32 image_width;
|
| - uint32 image_length;
|
| - uint32 strile_width;
|
| - uint32 strile_length;
|
| - uint32 strile_length_total;
|
| - uint8 samples_per_pixel;
|
| - uint8 plane_sample_offset;
|
| - uint8 samples_per_pixel_per_plane;
|
| - uint64 jpeg_interchange_format;
|
| - uint64 jpeg_interchange_format_length;
|
| - uint8 jpeg_proc;
|
| - uint8 subsamplingcorrect;
|
| - uint8 subsamplingcorrect_done;
|
| - uint8 subsampling_tag;
|
| - uint8 subsampling_hor;
|
| - uint8 subsampling_ver;
|
| - uint8 subsampling_force_desubsampling_inside_decompression;
|
| - uint8 qtable_offset_count;
|
| - uint8 dctable_offset_count;
|
| - uint8 actable_offset_count;
|
| - uint64 qtable_offset[3];
|
| - uint64 dctable_offset[3];
|
| - uint64 actable_offset[3];
|
| - uint8* qtable[4];
|
| - uint8* dctable[4];
|
| - uint8* actable[4];
|
| - uint16 restart_interval;
|
| - uint8 restart_index;
|
| - uint8 sof_log;
|
| - uint8 sof_marker_id;
|
| - uint32 sof_x;
|
| - uint32 sof_y;
|
| - uint8 sof_c[3];
|
| - uint8 sof_hv[3];
|
| - uint8 sof_tq[3];
|
| - uint8 sos_cs[3];
|
| - uint8 sos_tda[3];
|
| - struct {
|
| - uint8 log;
|
| - OJPEGStateInBufferSource in_buffer_source;
|
| - uint32 in_buffer_next_strile;
|
| - uint64 in_buffer_file_pos;
|
| - uint64 in_buffer_file_togo;
|
| - } sos_end[3];
|
| - uint8 readheader_done;
|
| - uint8 writeheader_done;
|
| - uint16 write_cursample;
|
| - uint32 write_curstrile;
|
| - uint8 libjpeg_session_active;
|
| - uint8 libjpeg_jpeg_query_style;
|
| - jpeg_error_mgr libjpeg_jpeg_error_mgr;
|
| - jpeg_decompress_struct libjpeg_jpeg_decompress_struct;
|
| - jpeg_source_mgr libjpeg_jpeg_source_mgr;
|
| - uint8 subsampling_convert_log;
|
| - uint32 subsampling_convert_ylinelen;
|
| - uint32 subsampling_convert_ylines;
|
| - uint32 subsampling_convert_clinelen;
|
| - uint32 subsampling_convert_clines;
|
| - uint32 subsampling_convert_ybuflen;
|
| - uint32 subsampling_convert_cbuflen;
|
| - uint32 subsampling_convert_ycbcrbuflen;
|
| - uint8* subsampling_convert_ycbcrbuf;
|
| - uint8* subsampling_convert_ybuf;
|
| - uint8* subsampling_convert_cbbuf;
|
| - uint8* subsampling_convert_crbuf;
|
| - uint32 subsampling_convert_ycbcrimagelen;
|
| - uint8** subsampling_convert_ycbcrimage;
|
| - uint32 subsampling_convert_clinelenout;
|
| - uint32 subsampling_convert_state;
|
| - uint32 bytes_per_line; /* if the codec outputs subsampled data, a 'line' in bytes_per_line */
|
| - uint32 lines_per_strile; /* and lines_per_strile means subsampling_ver desubsampled rows */
|
| - OJPEGStateInBufferSource in_buffer_source;
|
| - uint32 in_buffer_next_strile;
|
| - uint32 in_buffer_strile_count;
|
| - uint64 in_buffer_file_pos;
|
| - uint8 in_buffer_file_pos_log;
|
| - uint64 in_buffer_file_togo;
|
| - uint16 in_buffer_togo;
|
| - uint8* in_buffer_cur;
|
| - uint8 in_buffer[OJPEG_BUFFER];
|
| - OJPEGStateOutState out_state;
|
| - uint8 out_buffer[OJPEG_BUFFER];
|
| - uint8* skip_buffer;
|
| -} OJPEGState;
|
| -
|
| -static int OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap);
|
| -static int OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap);
|
| -static void OJPEGPrintDir(TIFF* tif, FILE* fd, long flags);
|
| -
|
| -static int OJPEGFixupTags(TIFF* tif);
|
| -static int OJPEGSetupDecode(TIFF* tif);
|
| -static int OJPEGPreDecode(TIFF* tif, uint16 s);
|
| -static int OJPEGPreDecodeSkipRaw(TIFF* tif);
|
| -static int OJPEGPreDecodeSkipScanlines(TIFF* tif);
|
| -static int OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
|
| -static int OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc);
|
| -static int OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc);
|
| -static void OJPEGPostDecode(TIFF* tif, uint8* buf, tmsize_t cc);
|
| -static int OJPEGSetupEncode(TIFF* tif);
|
| -static int OJPEGPreEncode(TIFF* tif, uint16 s);
|
| -static int OJPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
|
| -static int OJPEGPostEncode(TIFF* tif);
|
| -static void OJPEGCleanup(TIFF* tif);
|
| -
|
| -static void OJPEGSubsamplingCorrect(TIFF* tif);
|
| -static int OJPEGReadHeaderInfo(TIFF* tif);
|
| -static int OJPEGReadSecondarySos(TIFF* tif, uint16 s);
|
| -static int OJPEGWriteHeaderInfo(TIFF* tif);
|
| -static void OJPEGLibjpegSessionAbort(TIFF* tif);
|
| -
|
| -static int OJPEGReadHeaderInfoSec(TIFF* tif);
|
| -static int OJPEGReadHeaderInfoSecStreamDri(TIFF* tif);
|
| -static int OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif);
|
| -static int OJPEGReadHeaderInfoSecStreamDht(TIFF* tif);
|
| -static int OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id);
|
| -static int OJPEGReadHeaderInfoSecStreamSos(TIFF* tif);
|
| -static int OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif);
|
| -static int OJPEGReadHeaderInfoSecTablesDcTable(TIFF* tif);
|
| -static int OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif);
|
| -
|
| -static int OJPEGReadBufferFill(OJPEGState* sp);
|
| -static int OJPEGReadByte(OJPEGState* sp, uint8* byte);
|
| -static int OJPEGReadBytePeek(OJPEGState* sp, uint8* byte);
|
| -static void OJPEGReadByteAdvance(OJPEGState* sp);
|
| -static int OJPEGReadWord(OJPEGState* sp, uint16* word);
|
| -static int OJPEGReadBlock(OJPEGState* sp, uint16 len, void* mem);
|
| -static void OJPEGReadSkip(OJPEGState* sp, uint16 len);
|
| -
|
| -static int OJPEGWriteStream(TIFF* tif, void** mem, uint32* len);
|
| -static void OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32* len);
|
| -static void OJPEGWriteStreamQTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
|
| -static void OJPEGWriteStreamDcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
|
| -static void OJPEGWriteStreamAcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
|
| -static void OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32* len);
|
| -static void OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32* len);
|
| -static void OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32* len);
|
| -static int OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len);
|
| -static void OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32* len);
|
| -static void OJPEGWriteStreamEoi(TIFF* tif, void** mem, uint32* len);
|
| -
|
| -#ifdef LIBJPEG_ENCAP_EXTERNAL
|
| -extern int jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
|
| -extern int jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image);
|
| -extern int jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
|
| -extern int jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines);
|
| -extern int jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines);
|
| -extern void jpeg_encap_unwind(TIFF* tif);
|
| -#else
|
| -static int jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* j);
|
| -static int jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image);
|
| -static int jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
|
| -static int jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines);
|
| -static int jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines);
|
| -static void jpeg_encap_unwind(TIFF* tif);
|
| -#endif
|
| -
|
| -static void OJPEGLibjpegJpegErrorMgrOutputMessage(jpeg_common_struct* cinfo);
|
| -static void OJPEGLibjpegJpegErrorMgrErrorExit(jpeg_common_struct* cinfo);
|
| -static void OJPEGLibjpegJpegSourceMgrInitSource(jpeg_decompress_struct* cinfo);
|
| -static boolean OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct* cinfo);
|
| -static void OJPEGLibjpegJpegSourceMgrSkipInputData(jpeg_decompress_struct* cinfo, long num_bytes);
|
| -static boolean OJPEGLibjpegJpegSourceMgrResyncToRestart(jpeg_decompress_struct* cinfo, int desired);
|
| -static void OJPEGLibjpegJpegSourceMgrTermSource(jpeg_decompress_struct* cinfo);
|
| -
|
| -int
|
| -TIFFInitOJPEG(TIFF* tif, int scheme)
|
| -{
|
| - static const char module[]="TIFFInitOJPEG";
|
| - OJPEGState* sp;
|
| -
|
| - assert(scheme==COMPRESSION_OJPEG);
|
| -
|
| - /*
|
| - * Merge codec-specific tag information.
|
| - */
|
| - if (!_TIFFMergeFields(tif, ojpegFields, TIFFArrayCount(ojpegFields))) {
|
| - TIFFErrorExt(tif->tif_clientdata, module,
|
| - "Merging Old JPEG codec-specific tags failed");
|
| - return 0;
|
| - }
|
| -
|
| - /* state block */
|
| - sp = (OJPEGState*)_TIFFmalloc(sizeof(OJPEGState)); // // add (OJPEGState*) cast
|
| - if (sp == NULL)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"No space for OJPEG state block");
|
| - return(0);
|
| - }
|
| - _TIFFmemset(sp,0,sizeof(OJPEGState));
|
| - sp->tif=tif;
|
| - sp->jpeg_proc=1;
|
| - sp->subsampling_hor=2;
|
| - sp->subsampling_ver=2;
|
| - TIFFSetField(tif,TIFFTAG_YCBCRSUBSAMPLING,2,2);
|
| - /* tif codec methods */
|
| - tif->tif_fixuptags=OJPEGFixupTags;
|
| - tif->tif_setupdecode=OJPEGSetupDecode;
|
| - tif->tif_predecode=OJPEGPreDecode;
|
| - tif->tif_postdecode=OJPEGPostDecode;
|
| - tif->tif_decoderow=OJPEGDecode;
|
| - tif->tif_decodestrip=OJPEGDecode;
|
| - tif->tif_decodetile=OJPEGDecode;
|
| - tif->tif_setupencode=OJPEGSetupEncode;
|
| - tif->tif_preencode=OJPEGPreEncode;
|
| - tif->tif_postencode=OJPEGPostEncode;
|
| - tif->tif_encoderow=OJPEGEncode;
|
| - tif->tif_encodestrip=OJPEGEncode;
|
| - tif->tif_encodetile=OJPEGEncode;
|
| - tif->tif_cleanup=OJPEGCleanup;
|
| - tif->tif_data=(uint8*)sp;
|
| - /* tif tag methods */
|
| - sp->vgetparent=tif->tif_tagmethods.vgetfield;
|
| - tif->tif_tagmethods.vgetfield=OJPEGVGetField;
|
| - sp->vsetparent=tif->tif_tagmethods.vsetfield;
|
| - tif->tif_tagmethods.vsetfield=OJPEGVSetField;
|
| - sp->printdir=tif->tif_tagmethods.printdir;
|
| - tif->tif_tagmethods.printdir=OJPEGPrintDir;
|
| - /* Some OJPEG files don't have strip or tile offsets or bytecounts tags.
|
| - Some others do, but have totally meaningless or corrupt values
|
| - in these tags. In these cases, the JpegInterchangeFormat stream is
|
| - reliable. In any case, this decoder reads the compressed data itself,
|
| - from the most reliable locations, and we need to notify encapsulating
|
| - LibTiff not to read raw strips or tiles for us. */
|
| - tif->tif_flags|=TIFF_NOREADRAW;
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - switch(tag)
|
| - {
|
| - case TIFFTAG_JPEGIFOFFSET:
|
| - *va_arg(ap,uint64*)=(uint64)sp->jpeg_interchange_format;
|
| - break;
|
| - case TIFFTAG_JPEGIFBYTECOUNT:
|
| - *va_arg(ap,uint64*)=(uint64)sp->jpeg_interchange_format_length;
|
| - break;
|
| - case TIFFTAG_YCBCRSUBSAMPLING:
|
| - if (sp->subsamplingcorrect_done==0)
|
| - OJPEGSubsamplingCorrect(tif);
|
| - *va_arg(ap,uint16*)=(uint16)sp->subsampling_hor;
|
| - *va_arg(ap,uint16*)=(uint16)sp->subsampling_ver;
|
| - break;
|
| - case TIFFTAG_JPEGQTABLES:
|
| - *va_arg(ap,uint32*)=(uint32)sp->qtable_offset_count;
|
| - *va_arg(ap,void**)=(void*)sp->qtable_offset;
|
| - break;
|
| - case TIFFTAG_JPEGDCTABLES:
|
| - *va_arg(ap,uint32*)=(uint32)sp->dctable_offset_count;
|
| - *va_arg(ap,void**)=(void*)sp->dctable_offset;
|
| - break;
|
| - case TIFFTAG_JPEGACTABLES:
|
| - *va_arg(ap,uint32*)=(uint32)sp->actable_offset_count;
|
| - *va_arg(ap,void**)=(void*)sp->actable_offset;
|
| - break;
|
| - case TIFFTAG_JPEGPROC:
|
| - *va_arg(ap,uint16*)=(uint16)sp->jpeg_proc;
|
| - break;
|
| - case TIFFTAG_JPEGRESTARTINTERVAL:
|
| - *va_arg(ap,uint16*)=sp->restart_interval;
|
| - break;
|
| - default:
|
| - return (*sp->vgetparent)(tif,tag,ap);
|
| - }
|
| - return (1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap)
|
| -{
|
| - static const char module[]="OJPEGVSetField";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint32 ma;
|
| - uint64* mb;
|
| - uint32 n;
|
| - switch(tag)
|
| - {
|
| - case TIFFTAG_JPEGIFOFFSET:
|
| - sp->jpeg_interchange_format=(uint64)va_arg(ap,uint64);
|
| - break;
|
| - case TIFFTAG_JPEGIFBYTECOUNT:
|
| - sp->jpeg_interchange_format_length=(uint64)va_arg(ap,uint64);
|
| - break;
|
| - case TIFFTAG_YCBCRSUBSAMPLING:
|
| - sp->subsampling_tag=1;
|
| - sp->subsampling_hor=(uint8)va_arg(ap,uint16_vap);
|
| - sp->subsampling_ver=(uint8)va_arg(ap,uint16_vap);
|
| - tif->tif_dir.td_ycbcrsubsampling[0]=sp->subsampling_hor;
|
| - tif->tif_dir.td_ycbcrsubsampling[1]=sp->subsampling_ver;
|
| - break;
|
| - case TIFFTAG_JPEGQTABLES:
|
| - ma=(uint32)va_arg(ap,uint32);
|
| - if (ma!=0)
|
| - {
|
| - if (ma>3)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"JpegQTables tag has incorrect count");
|
| - return(0);
|
| - }
|
| - sp->qtable_offset_count=(uint8)ma;
|
| - mb=(uint64*)va_arg(ap,uint64*);
|
| - for (n=0; n<ma; n++)
|
| - sp->qtable_offset[n]=mb[n];
|
| - }
|
| - break;
|
| - case TIFFTAG_JPEGDCTABLES:
|
| - ma=(uint32)va_arg(ap,uint32);
|
| - if (ma!=0)
|
| - {
|
| - if (ma>3)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"JpegDcTables tag has incorrect count");
|
| - return(0);
|
| - }
|
| - sp->dctable_offset_count=(uint8)ma;
|
| - mb=(uint64*)va_arg(ap,uint64*);
|
| - for (n=0; n<ma; n++)
|
| - sp->dctable_offset[n]=mb[n];
|
| - }
|
| - break;
|
| - case TIFFTAG_JPEGACTABLES:
|
| - ma=(uint32)va_arg(ap,uint32);
|
| - if (ma!=0)
|
| - {
|
| - if (ma>3)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"JpegAcTables tag has incorrect count");
|
| - return(0);
|
| - }
|
| - sp->actable_offset_count=(uint8)ma;
|
| - mb=(uint64*)va_arg(ap,uint64*);
|
| - for (n=0; n<ma; n++)
|
| - sp->actable_offset[n]=mb[n];
|
| - }
|
| - break;
|
| - case TIFFTAG_JPEGPROC:
|
| - sp->jpeg_proc=(uint8)va_arg(ap,uint16_vap);
|
| - break;
|
| - case TIFFTAG_JPEGRESTARTINTERVAL:
|
| - sp->restart_interval=(uint16)va_arg(ap,uint16_vap);
|
| - break;
|
| - default:
|
| - return (*sp->vsetparent)(tif,tag,ap);
|
| - }
|
| - TIFFSetFieldBit(tif,TIFFFieldWithTag(tif,tag)->field_bit);
|
| - tif->tif_flags|=TIFF_DIRTYDIRECT;
|
| - return(1);
|
| -}
|
| -
|
| -static void
|
| -OJPEGPrintDir(TIFF* tif, FILE* fd, long flags)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint8 m;
|
| - (void)flags;
|
| - assert(sp!=NULL);
|
| - if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMAT))
|
| - fprintf(fd," JpegInterchangeFormat: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format);
|
| - if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH))
|
| - fprintf(fd," JpegInterchangeFormatLength: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format_length);
|
| - if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGQTABLES))
|
| - {
|
| - fprintf(fd," JpegQTables:");
|
| - for (m=0; m<sp->qtable_offset_count; m++)
|
| - fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->qtable_offset[m]);
|
| - fprintf(fd,"\n");
|
| - }
|
| - if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGDCTABLES))
|
| - {
|
| - fprintf(fd," JpegDcTables:");
|
| - for (m=0; m<sp->dctable_offset_count; m++)
|
| - fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->dctable_offset[m]);
|
| - fprintf(fd,"\n");
|
| - }
|
| - if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGACTABLES))
|
| - {
|
| - fprintf(fd," JpegAcTables:");
|
| - for (m=0; m<sp->actable_offset_count; m++)
|
| - fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->actable_offset[m]);
|
| - fprintf(fd,"\n");
|
| - }
|
| - if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGPROC))
|
| - fprintf(fd," JpegProc: %u\n",(unsigned int)sp->jpeg_proc);
|
| - if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGRESTARTINTERVAL))
|
| - fprintf(fd," JpegRestartInterval: %u\n",(unsigned int)sp->restart_interval);
|
| - if (sp->printdir)
|
| - (*sp->printdir)(tif, fd, flags);
|
| -}
|
| -
|
| -static int
|
| -OJPEGFixupTags(TIFF* tif)
|
| -{
|
| - (void) tif;
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGSetupDecode(TIFF* tif)
|
| -{
|
| - static const char module[]="OJPEGSetupDecode";
|
| - TIFFWarningExt(tif->tif_clientdata,module,"Depreciated and troublesome old-style JPEG compression mode, please convert to new-style JPEG compression and notify vendor of writing software");
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGPreDecode(TIFF* tif, uint16 s)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint32 m;
|
| - if (sp->subsamplingcorrect_done==0)
|
| - OJPEGSubsamplingCorrect(tif);
|
| - if (sp->readheader_done==0)
|
| - {
|
| - if (OJPEGReadHeaderInfo(tif)==0)
|
| - return(0);
|
| - }
|
| - if (sp->sos_end[s].log==0)
|
| - {
|
| - if (OJPEGReadSecondarySos(tif,s)==0)
|
| - return(0);
|
| - }
|
| - if isTiled(tif)
|
| - m=tif->tif_curtile;
|
| - else
|
| - m=tif->tif_curstrip;
|
| - if ((sp->writeheader_done!=0) && ((sp->write_cursample!=s) || (sp->write_curstrile>m)))
|
| - {
|
| - if (sp->libjpeg_session_active!=0)
|
| - OJPEGLibjpegSessionAbort(tif);
|
| - sp->writeheader_done=0;
|
| - }
|
| - if (sp->writeheader_done==0)
|
| - {
|
| - sp->plane_sample_offset=(uint8)s;
|
| - sp->write_cursample=s;
|
| - sp->write_curstrile=s*tif->tif_dir.td_stripsperimage;
|
| - if ((sp->in_buffer_file_pos_log==0) ||
|
| - (sp->in_buffer_file_pos-sp->in_buffer_togo!=sp->sos_end[s].in_buffer_file_pos))
|
| - {
|
| - sp->in_buffer_source=sp->sos_end[s].in_buffer_source;
|
| - sp->in_buffer_next_strile=sp->sos_end[s].in_buffer_next_strile;
|
| - sp->in_buffer_file_pos=sp->sos_end[s].in_buffer_file_pos;
|
| - sp->in_buffer_file_pos_log=0;
|
| - sp->in_buffer_file_togo=sp->sos_end[s].in_buffer_file_togo;
|
| - sp->in_buffer_togo=0;
|
| - sp->in_buffer_cur=0;
|
| - }
|
| - if (OJPEGWriteHeaderInfo(tif)==0)
|
| - return(0);
|
| - }
|
| - while (sp->write_curstrile<m)
|
| - {
|
| - if (sp->libjpeg_jpeg_query_style==0)
|
| - {
|
| - if (OJPEGPreDecodeSkipRaw(tif)==0)
|
| - return(0);
|
| - }
|
| - else
|
| - {
|
| - if (OJPEGPreDecodeSkipScanlines(tif)==0)
|
| - return(0);
|
| - }
|
| - sp->write_curstrile++;
|
| - }
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGPreDecodeSkipRaw(TIFF* tif)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint32 m;
|
| - m=sp->lines_per_strile;
|
| - if (sp->subsampling_convert_state!=0)
|
| - {
|
| - if (sp->subsampling_convert_clines-sp->subsampling_convert_state>=m)
|
| - {
|
| - sp->subsampling_convert_state+=m;
|
| - if (sp->subsampling_convert_state==sp->subsampling_convert_clines)
|
| - sp->subsampling_convert_state=0;
|
| - return(1);
|
| - }
|
| - m-=sp->subsampling_convert_clines-sp->subsampling_convert_state;
|
| - sp->subsampling_convert_state=0;
|
| - }
|
| - while (m>=sp->subsampling_convert_clines)
|
| - {
|
| - if (jpeg_read_raw_data_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),sp->subsampling_convert_ycbcrimage,sp->subsampling_ver*8)==0)
|
| - return(0);
|
| - m-=sp->subsampling_convert_clines;
|
| - }
|
| - if (m>0)
|
| - {
|
| - if (jpeg_read_raw_data_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),sp->subsampling_convert_ycbcrimage,sp->subsampling_ver*8)==0)
|
| - return(0);
|
| - sp->subsampling_convert_state=m;
|
| - }
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGPreDecodeSkipScanlines(TIFF* tif)
|
| -{
|
| - static const char module[]="OJPEGPreDecodeSkipScanlines";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint32 m;
|
| - if (sp->skip_buffer==NULL)
|
| - {
|
| - // add (uint8*) cast
|
| - sp->skip_buffer = (uint8*)_TIFFmalloc(sp->bytes_per_line);
|
| - if (sp->skip_buffer == NULL)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
|
| - return(0);
|
| - }
|
| - }
|
| - for (m=0; m<sp->lines_per_strile; m++)
|
| - {
|
| - if (jpeg_read_scanlines_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),&sp->skip_buffer,1)==0)
|
| - return(0);
|
| - }
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - (void)s;
|
| - if (sp->libjpeg_jpeg_query_style==0)
|
| - {
|
| - if (OJPEGDecodeRaw(tif,buf,cc)==0)
|
| - return(0);
|
| - }
|
| - else
|
| - {
|
| - if (OJPEGDecodeScanlines(tif,buf,cc)==0)
|
| - return(0);
|
| - }
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc)
|
| -{
|
| - static const char module[]="OJPEGDecodeRaw";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint8* m;
|
| - tmsize_t n;
|
| - uint8* oy;
|
| - uint8* ocb;
|
| - uint8* ocr;
|
| - uint8* p;
|
| - uint32 q;
|
| - uint8* r;
|
| - uint8 sx,sy;
|
| - if (cc%sp->bytes_per_line!=0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Fractional scanline not read");
|
| - return(0);
|
| - }
|
| - assert(cc>0);
|
| - m=buf;
|
| - n=cc;
|
| - do
|
| - {
|
| - if (sp->subsampling_convert_state==0)
|
| - {
|
| - if (jpeg_read_raw_data_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),sp->subsampling_convert_ycbcrimage,sp->subsampling_ver*8)==0)
|
| - return(0);
|
| - }
|
| - oy=sp->subsampling_convert_ybuf+sp->subsampling_convert_state*sp->subsampling_ver*sp->subsampling_convert_ylinelen;
|
| - ocb=sp->subsampling_convert_cbbuf+sp->subsampling_convert_state*sp->subsampling_convert_clinelen;
|
| - ocr=sp->subsampling_convert_crbuf+sp->subsampling_convert_state*sp->subsampling_convert_clinelen;
|
| - p=m;
|
| - for (q=0; q<sp->subsampling_convert_clinelenout; q++)
|
| - {
|
| - r=oy;
|
| - for (sy=0; sy<sp->subsampling_ver; sy++)
|
| - {
|
| - for (sx=0; sx<sp->subsampling_hor; sx++)
|
| - *p++=*r++;
|
| - r+=sp->subsampling_convert_ylinelen-sp->subsampling_hor;
|
| - }
|
| - oy+=sp->subsampling_hor;
|
| - *p++=*ocb++;
|
| - *p++=*ocr++;
|
| - }
|
| - sp->subsampling_convert_state++;
|
| - if (sp->subsampling_convert_state==sp->subsampling_convert_clines)
|
| - sp->subsampling_convert_state=0;
|
| - m+=sp->bytes_per_line;
|
| - n-=sp->bytes_per_line;
|
| - } while(n>0);
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc)
|
| -{
|
| - static const char module[]="OJPEGDecodeScanlines";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint8* m;
|
| - tmsize_t n;
|
| - if (cc%sp->bytes_per_line!=0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Fractional scanline not read");
|
| - return(0);
|
| - }
|
| - assert(cc>0);
|
| - m=buf;
|
| - n=cc;
|
| - do
|
| - {
|
| - if (jpeg_read_scanlines_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),&m,1)==0)
|
| - return(0);
|
| - m+=sp->bytes_per_line;
|
| - n-=sp->bytes_per_line;
|
| - } while(n>0);
|
| - return(1);
|
| -}
|
| -
|
| -static void
|
| -OJPEGPostDecode(TIFF* tif, uint8* buf, tmsize_t cc)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - (void)buf;
|
| - (void)cc;
|
| - sp->write_curstrile++;
|
| - if (sp->write_curstrile%tif->tif_dir.td_stripsperimage==0)
|
| - {
|
| - assert(sp->libjpeg_session_active!=0);
|
| - OJPEGLibjpegSessionAbort(tif);
|
| - sp->writeheader_done=0;
|
| - }
|
| -}
|
| -
|
| -static int
|
| -OJPEGSetupEncode(TIFF* tif)
|
| -{
|
| - static const char module[]="OJPEGSetupEncode";
|
| - TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
|
| - return(0);
|
| -}
|
| -
|
| -static int
|
| -OJPEGPreEncode(TIFF* tif, uint16 s)
|
| -{
|
| - static const char module[]="OJPEGPreEncode";
|
| - (void)s;
|
| - TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
|
| - return(0);
|
| -}
|
| -
|
| -static int
|
| -OJPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
|
| -{
|
| - static const char module[]="OJPEGEncode";
|
| - (void)buf;
|
| - (void)cc;
|
| - (void)s;
|
| - TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
|
| - return(0);
|
| -}
|
| -
|
| -static int
|
| -OJPEGPostEncode(TIFF* tif)
|
| -{
|
| - static const char module[]="OJPEGPostEncode";
|
| - TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
|
| - return(0);
|
| -}
|
| -
|
| -static void
|
| -OJPEGCleanup(TIFF* tif)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - if (sp!=0)
|
| - {
|
| - tif->tif_tagmethods.vgetfield=sp->vgetparent;
|
| - tif->tif_tagmethods.vsetfield=sp->vsetparent;
|
| - tif->tif_tagmethods.printdir=sp->printdir;
|
| - if (sp->qtable[0]!=0)
|
| - _TIFFfree(sp->qtable[0]);
|
| - if (sp->qtable[1]!=0)
|
| - _TIFFfree(sp->qtable[1]);
|
| - if (sp->qtable[2]!=0)
|
| - _TIFFfree(sp->qtable[2]);
|
| - if (sp->qtable[3]!=0)
|
| - _TIFFfree(sp->qtable[3]);
|
| - if (sp->dctable[0]!=0)
|
| - _TIFFfree(sp->dctable[0]);
|
| - if (sp->dctable[1]!=0)
|
| - _TIFFfree(sp->dctable[1]);
|
| - if (sp->dctable[2]!=0)
|
| - _TIFFfree(sp->dctable[2]);
|
| - if (sp->dctable[3]!=0)
|
| - _TIFFfree(sp->dctable[3]);
|
| - if (sp->actable[0]!=0)
|
| - _TIFFfree(sp->actable[0]);
|
| - if (sp->actable[1]!=0)
|
| - _TIFFfree(sp->actable[1]);
|
| - if (sp->actable[2]!=0)
|
| - _TIFFfree(sp->actable[2]);
|
| - if (sp->actable[3]!=0)
|
| - _TIFFfree(sp->actable[3]);
|
| - if (sp->libjpeg_session_active!=0)
|
| - OJPEGLibjpegSessionAbort(tif);
|
| - if (sp->subsampling_convert_ycbcrbuf!=0)
|
| - _TIFFfree(sp->subsampling_convert_ycbcrbuf);
|
| - if (sp->subsampling_convert_ycbcrimage!=0)
|
| - _TIFFfree(sp->subsampling_convert_ycbcrimage);
|
| - if (sp->skip_buffer!=0)
|
| - _TIFFfree(sp->skip_buffer);
|
| - _TIFFfree(sp);
|
| - tif->tif_data=NULL;
|
| - _TIFFSetDefaultCompressionState(tif);
|
| - }
|
| -}
|
| -
|
| -static void
|
| -OJPEGSubsamplingCorrect(TIFF* tif)
|
| -{
|
| - static const char module[]="OJPEGSubsamplingCorrect";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint8 mh;
|
| - uint8 mv;
|
| - _TIFFFillStriles( tif );
|
| -
|
| - assert(sp->subsamplingcorrect_done==0);
|
| - if ((tif->tif_dir.td_samplesperpixel!=3) || ((tif->tif_dir.td_photometric!=PHOTOMETRIC_YCBCR) &&
|
| - (tif->tif_dir.td_photometric!=PHOTOMETRIC_ITULAB)))
|
| - {
|
| - if (sp->subsampling_tag!=0)
|
| - TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag not appropriate for this Photometric and/or SamplesPerPixel");
|
| - sp->subsampling_hor=1;
|
| - sp->subsampling_ver=1;
|
| - sp->subsampling_force_desubsampling_inside_decompression=0;
|
| - }
|
| - else
|
| - {
|
| - sp->subsamplingcorrect_done=1;
|
| - mh=sp->subsampling_hor;
|
| - mv=sp->subsampling_ver;
|
| - sp->subsamplingcorrect=1;
|
| - OJPEGReadHeaderInfoSec(tif);
|
| - if (sp->subsampling_force_desubsampling_inside_decompression!=0)
|
| - {
|
| - sp->subsampling_hor=1;
|
| - sp->subsampling_ver=1;
|
| - }
|
| - sp->subsamplingcorrect=0;
|
| - if (((sp->subsampling_hor!=mh) || (sp->subsampling_ver!=mv)) && (sp->subsampling_force_desubsampling_inside_decompression==0))
|
| - {
|
| - if (sp->subsampling_tag==0)
|
| - TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag is not set, yet subsampling inside JPEG data [%d,%d] does not match default values [2,2]; assuming subsampling inside JPEG data is correct",sp->subsampling_hor,sp->subsampling_ver);
|
| - else
|
| - TIFFWarningExt(tif->tif_clientdata,module,"Subsampling inside JPEG data [%d,%d] does not match subsampling tag values [%d,%d]; assuming subsampling inside JPEG data is correct",sp->subsampling_hor,sp->subsampling_ver,mh,mv);
|
| - }
|
| - if (sp->subsampling_force_desubsampling_inside_decompression!=0)
|
| - {
|
| - if (sp->subsampling_tag==0)
|
| - TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag is not set, yet subsampling inside JPEG data does not match default values [2,2] (nor any other values allowed in TIFF); assuming subsampling inside JPEG data is correct and desubsampling inside JPEG decompression");
|
| - else
|
| - TIFFWarningExt(tif->tif_clientdata,module,"Subsampling inside JPEG data does not match subsampling tag values [%d,%d] (nor any other values allowed in TIFF); assuming subsampling inside JPEG data is correct and desubsampling inside JPEG decompression",mh,mv);
|
| - }
|
| - if (sp->subsampling_force_desubsampling_inside_decompression==0)
|
| - {
|
| - if (sp->subsampling_hor<sp->subsampling_ver)
|
| - TIFFWarningExt(tif->tif_clientdata,module,"Subsampling values [%d,%d] are not allowed in TIFF",sp->subsampling_hor,sp->subsampling_ver);
|
| - }
|
| - }
|
| - sp->subsamplingcorrect_done=1;
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadHeaderInfo(TIFF* tif)
|
| -{
|
| - static const char module[]="OJPEGReadHeaderInfo";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - assert(sp->readheader_done==0);
|
| - sp->image_width=tif->tif_dir.td_imagewidth;
|
| - sp->image_length=tif->tif_dir.td_imagelength;
|
| - if isTiled(tif)
|
| - {
|
| - sp->strile_width=tif->tif_dir.td_tilewidth;
|
| - sp->strile_length=tif->tif_dir.td_tilelength;
|
| - sp->strile_length_total=((sp->image_length+sp->strile_length-1)/sp->strile_length)*sp->strile_length;
|
| - }
|
| - else
|
| - {
|
| - sp->strile_width=sp->image_width;
|
| - sp->strile_length=tif->tif_dir.td_rowsperstrip;
|
| - sp->strile_length_total=sp->image_length;
|
| - }
|
| - if (tif->tif_dir.td_samplesperpixel==1)
|
| - {
|
| - sp->samples_per_pixel=1;
|
| - sp->plane_sample_offset=0;
|
| - sp->samples_per_pixel_per_plane=sp->samples_per_pixel;
|
| - sp->subsampling_hor=1;
|
| - sp->subsampling_ver=1;
|
| - }
|
| - else
|
| - {
|
| - if (tif->tif_dir.td_samplesperpixel!=3)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"SamplesPerPixel %d not supported for this compression scheme",sp->samples_per_pixel);
|
| - return(0);
|
| - }
|
| - sp->samples_per_pixel=3;
|
| - sp->plane_sample_offset=0;
|
| - if (tif->tif_dir.td_planarconfig==PLANARCONFIG_CONTIG)
|
| - sp->samples_per_pixel_per_plane=3;
|
| - else
|
| - sp->samples_per_pixel_per_plane=1;
|
| - }
|
| - if (sp->strile_length<sp->image_length)
|
| - {
|
| - if (sp->strile_length%(sp->subsampling_ver*8)!=0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Incompatible vertical subsampling and image strip/tile length");
|
| - return(0);
|
| - }
|
| - sp->restart_interval=((sp->strile_width+sp->subsampling_hor*8-1)/(sp->subsampling_hor*8))*(sp->strile_length/(sp->subsampling_ver*8));
|
| - }
|
| - if (OJPEGReadHeaderInfoSec(tif)==0)
|
| - return(0);
|
| - sp->sos_end[0].log=1;
|
| - sp->sos_end[0].in_buffer_source=sp->in_buffer_source;
|
| - sp->sos_end[0].in_buffer_next_strile=sp->in_buffer_next_strile;
|
| - sp->sos_end[0].in_buffer_file_pos=sp->in_buffer_file_pos-sp->in_buffer_togo;
|
| - sp->sos_end[0].in_buffer_file_togo=sp->in_buffer_file_togo+sp->in_buffer_togo;
|
| - sp->readheader_done=1;
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadSecondarySos(TIFF* tif, uint16 s)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint8 m;
|
| - assert(s>0);
|
| - assert(s<3);
|
| - assert(sp->sos_end[0].log!=0);
|
| - assert(sp->sos_end[s].log==0);
|
| - sp->plane_sample_offset=s-1;
|
| - while(sp->sos_end[sp->plane_sample_offset].log==0)
|
| - sp->plane_sample_offset--;
|
| - sp->in_buffer_source=sp->sos_end[sp->plane_sample_offset].in_buffer_source;
|
| - sp->in_buffer_next_strile=sp->sos_end[sp->plane_sample_offset].in_buffer_next_strile;
|
| - sp->in_buffer_file_pos=sp->sos_end[sp->plane_sample_offset].in_buffer_file_pos;
|
| - sp->in_buffer_file_pos_log=0;
|
| - sp->in_buffer_file_togo=sp->sos_end[sp->plane_sample_offset].in_buffer_file_togo;
|
| - sp->in_buffer_togo=0;
|
| - sp->in_buffer_cur=0;
|
| - while(sp->plane_sample_offset<s)
|
| - {
|
| - do
|
| - {
|
| - if (OJPEGReadByte(sp,&m)==0)
|
| - return(0);
|
| - if (m==255)
|
| - {
|
| - do
|
| - {
|
| - if (OJPEGReadByte(sp,&m)==0)
|
| - return(0);
|
| - if (m!=255)
|
| - break;
|
| - } while(1);
|
| - if (m==JPEG_MARKER_SOS)
|
| - break;
|
| - }
|
| - } while(1);
|
| - sp->plane_sample_offset++;
|
| - if (OJPEGReadHeaderInfoSecStreamSos(tif)==0)
|
| - return(0);
|
| - sp->sos_end[sp->plane_sample_offset].log=1;
|
| - sp->sos_end[sp->plane_sample_offset].in_buffer_source=sp->in_buffer_source;
|
| - sp->sos_end[sp->plane_sample_offset].in_buffer_next_strile=sp->in_buffer_next_strile;
|
| - sp->sos_end[sp->plane_sample_offset].in_buffer_file_pos=sp->in_buffer_file_pos-sp->in_buffer_togo;
|
| - sp->sos_end[sp->plane_sample_offset].in_buffer_file_togo=sp->in_buffer_file_togo+sp->in_buffer_togo;
|
| - }
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGWriteHeaderInfo(TIFF* tif)
|
| -{
|
| - static const char module[]="OJPEGWriteHeaderInfo";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint8** m;
|
| - uint32 n;
|
| - /* if a previous attempt failed, don't try again */
|
| - if (sp->libjpeg_session_active != 0)
|
| - return 0;
|
| - sp->out_state=ososSoi;
|
| - sp->restart_index=0;
|
| - jpeg_std_error(&(sp->libjpeg_jpeg_error_mgr));
|
| - sp->libjpeg_jpeg_error_mgr.output_message=OJPEGLibjpegJpegErrorMgrOutputMessage;
|
| - sp->libjpeg_jpeg_error_mgr.error_exit=OJPEGLibjpegJpegErrorMgrErrorExit;
|
| - sp->libjpeg_jpeg_decompress_struct.err=&(sp->libjpeg_jpeg_error_mgr);
|
| - sp->libjpeg_jpeg_decompress_struct.client_data=(void*)tif;
|
| - if (jpeg_create_decompress_encap(sp,&(sp->libjpeg_jpeg_decompress_struct))==0)
|
| - return(0);
|
| - sp->libjpeg_session_active=1;
|
| - sp->libjpeg_jpeg_source_mgr.bytes_in_buffer=0;
|
| - sp->libjpeg_jpeg_source_mgr.init_source=OJPEGLibjpegJpegSourceMgrInitSource;
|
| - sp->libjpeg_jpeg_source_mgr.fill_input_buffer=OJPEGLibjpegJpegSourceMgrFillInputBuffer;
|
| - sp->libjpeg_jpeg_source_mgr.skip_input_data=OJPEGLibjpegJpegSourceMgrSkipInputData;
|
| - sp->libjpeg_jpeg_source_mgr.resync_to_restart=OJPEGLibjpegJpegSourceMgrResyncToRestart;
|
| - sp->libjpeg_jpeg_source_mgr.term_source=OJPEGLibjpegJpegSourceMgrTermSource;
|
| - sp->libjpeg_jpeg_decompress_struct.src=&(sp->libjpeg_jpeg_source_mgr);
|
| - if (jpeg_read_header_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),1)==0)
|
| - return(0);
|
| - if ((sp->subsampling_force_desubsampling_inside_decompression==0) && (sp->samples_per_pixel_per_plane>1))
|
| - {
|
| - sp->libjpeg_jpeg_decompress_struct.raw_data_out=1;
|
| -#if JPEG_LIB_VERSION >= 70
|
| - sp->libjpeg_jpeg_decompress_struct.do_fancy_upsampling=FALSE;
|
| -#endif
|
| - sp->libjpeg_jpeg_query_style=0;
|
| - if (sp->subsampling_convert_log==0)
|
| - {
|
| - assert(sp->subsampling_convert_ycbcrbuf==0);
|
| - assert(sp->subsampling_convert_ycbcrimage==0);
|
| - sp->subsampling_convert_ylinelen=((sp->strile_width+sp->subsampling_hor*8-1)/(sp->subsampling_hor*8)*sp->subsampling_hor*8);
|
| - sp->subsampling_convert_ylines=sp->subsampling_ver*8;
|
| - sp->subsampling_convert_clinelen=sp->subsampling_convert_ylinelen/sp->subsampling_hor;
|
| - sp->subsampling_convert_clines=8;
|
| - sp->subsampling_convert_ybuflen=sp->subsampling_convert_ylinelen*sp->subsampling_convert_ylines;
|
| - sp->subsampling_convert_cbuflen=sp->subsampling_convert_clinelen*sp->subsampling_convert_clines;
|
| - sp->subsampling_convert_ycbcrbuflen=sp->subsampling_convert_ybuflen+2*sp->subsampling_convert_cbuflen;
|
| - sp->subsampling_convert_ycbcrbuf = (uint8*)_TIFFmalloc(sp->subsampling_convert_ycbcrbuflen); // add (uint8*) cast
|
| - if (sp->subsampling_convert_ycbcrbuf==0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
|
| - return(0);
|
| - }
|
| - sp->subsampling_convert_ybuf=sp->subsampling_convert_ycbcrbuf;
|
| - sp->subsampling_convert_cbbuf=sp->subsampling_convert_ybuf+sp->subsampling_convert_ybuflen;
|
| - sp->subsampling_convert_crbuf=sp->subsampling_convert_cbbuf+sp->subsampling_convert_cbuflen;
|
| - sp->subsampling_convert_ycbcrimagelen=3+sp->subsampling_convert_ylines+2*sp->subsampling_convert_clines;
|
| - sp->subsampling_convert_ycbcrimage = (uint8**)_TIFFmalloc(sp->subsampling_convert_ycbcrimagelen * sizeof(uint8*));// add (uint8**) cast
|
| - if (sp->subsampling_convert_ycbcrimage==0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
|
| - return(0);
|
| - }
|
| - m=sp->subsampling_convert_ycbcrimage;
|
| - *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3);
|
| - *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3+sp->subsampling_convert_ylines);
|
| - *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3+sp->subsampling_convert_ylines+sp->subsampling_convert_clines);
|
| - for (n=0; n<sp->subsampling_convert_ylines; n++)
|
| - *m++=sp->subsampling_convert_ybuf+n*sp->subsampling_convert_ylinelen;
|
| - for (n=0; n<sp->subsampling_convert_clines; n++)
|
| - *m++=sp->subsampling_convert_cbbuf+n*sp->subsampling_convert_clinelen;
|
| - for (n=0; n<sp->subsampling_convert_clines; n++)
|
| - *m++=sp->subsampling_convert_crbuf+n*sp->subsampling_convert_clinelen;
|
| - sp->subsampling_convert_clinelenout=((sp->strile_width+sp->subsampling_hor-1)/sp->subsampling_hor);
|
| - sp->subsampling_convert_state=0;
|
| - sp->bytes_per_line=sp->subsampling_convert_clinelenout*(sp->subsampling_ver*sp->subsampling_hor+2);
|
| - sp->lines_per_strile=((sp->strile_length+sp->subsampling_ver-1)/sp->subsampling_ver);
|
| - sp->subsampling_convert_log=1;
|
| - }
|
| - }
|
| - else
|
| - {
|
| - sp->libjpeg_jpeg_decompress_struct.jpeg_color_space=JCS_UNKNOWN;
|
| - sp->libjpeg_jpeg_decompress_struct.out_color_space=JCS_UNKNOWN;
|
| - sp->libjpeg_jpeg_query_style=1;
|
| - sp->bytes_per_line=sp->samples_per_pixel_per_plane*sp->strile_width;
|
| - sp->lines_per_strile=sp->strile_length;
|
| - }
|
| - if (jpeg_start_decompress_encap(sp,&(sp->libjpeg_jpeg_decompress_struct))==0)
|
| - return(0);
|
| - sp->writeheader_done=1;
|
| - return(1);
|
| -}
|
| -
|
| -static void
|
| -OJPEGLibjpegSessionAbort(TIFF* tif)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - assert(sp->libjpeg_session_active!=0);
|
| - jpeg_destroy((jpeg_common_struct*)(&(sp->libjpeg_jpeg_decompress_struct)));
|
| - sp->libjpeg_session_active=0;
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadHeaderInfoSec(TIFF* tif)
|
| -{
|
| - static const char module[]="OJPEGReadHeaderInfoSec";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint8 m;
|
| - uint16 n;
|
| - uint8 o;
|
| - if (sp->file_size==0)
|
| - sp->file_size=TIFFGetFileSize(tif);
|
| - if (sp->jpeg_interchange_format!=0)
|
| - {
|
| - if (sp->jpeg_interchange_format>=sp->file_size)
|
| - {
|
| - sp->jpeg_interchange_format=0;
|
| - sp->jpeg_interchange_format_length=0;
|
| - }
|
| - else
|
| - {
|
| - if ((sp->jpeg_interchange_format_length==0) || (sp->jpeg_interchange_format+sp->jpeg_interchange_format_length>sp->file_size))
|
| - sp->jpeg_interchange_format_length=sp->file_size-sp->jpeg_interchange_format;
|
| - }
|
| - }
|
| - sp->in_buffer_source=osibsNotSetYet;
|
| - sp->in_buffer_next_strile=0;
|
| - sp->in_buffer_strile_count=tif->tif_dir.td_nstrips;
|
| - sp->in_buffer_file_togo=0;
|
| - sp->in_buffer_togo=0;
|
| - do
|
| - {
|
| - if (OJPEGReadBytePeek(sp,&m)==0)
|
| - return(0);
|
| - if (m!=255)
|
| - break;
|
| - OJPEGReadByteAdvance(sp);
|
| - do
|
| - {
|
| - if (OJPEGReadByte(sp,&m)==0)
|
| - return(0);
|
| - } while(m==255);
|
| - switch(m)
|
| - {
|
| - case JPEG_MARKER_SOI:
|
| - /* this type of marker has no data, and should be skipped */
|
| - break;
|
| - case JPEG_MARKER_COM:
|
| - case JPEG_MARKER_APP0:
|
| - case JPEG_MARKER_APP0+1:
|
| - case JPEG_MARKER_APP0+2:
|
| - case JPEG_MARKER_APP0+3:
|
| - case JPEG_MARKER_APP0+4:
|
| - case JPEG_MARKER_APP0+5:
|
| - case JPEG_MARKER_APP0+6:
|
| - case JPEG_MARKER_APP0+7:
|
| - case JPEG_MARKER_APP0+8:
|
| - case JPEG_MARKER_APP0+9:
|
| - case JPEG_MARKER_APP0+10:
|
| - case JPEG_MARKER_APP0+11:
|
| - case JPEG_MARKER_APP0+12:
|
| - case JPEG_MARKER_APP0+13:
|
| - case JPEG_MARKER_APP0+14:
|
| - case JPEG_MARKER_APP0+15:
|
| - /* this type of marker has data, but it has no use to us (and no place here) and should be skipped */
|
| - if (OJPEGReadWord(sp,&n)==0)
|
| - return(0);
|
| - if (n<2)
|
| - {
|
| - if (sp->subsamplingcorrect==0)
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JPEG data");
|
| - return(0);
|
| - }
|
| - if (n>2)
|
| - OJPEGReadSkip(sp,n-2);
|
| - break;
|
| - case JPEG_MARKER_DRI:
|
| - if (OJPEGReadHeaderInfoSecStreamDri(tif)==0)
|
| - return(0);
|
| - break;
|
| - case JPEG_MARKER_DQT:
|
| - if (OJPEGReadHeaderInfoSecStreamDqt(tif)==0)
|
| - return(0);
|
| - break;
|
| - case JPEG_MARKER_DHT:
|
| - if (OJPEGReadHeaderInfoSecStreamDht(tif)==0)
|
| - return(0);
|
| - break;
|
| - case JPEG_MARKER_SOF0:
|
| - case JPEG_MARKER_SOF1:
|
| - case JPEG_MARKER_SOF3:
|
| - if (OJPEGReadHeaderInfoSecStreamSof(tif,m)==0)
|
| - return(0);
|
| - if (sp->subsamplingcorrect!=0)
|
| - return(1);
|
| - break;
|
| - case JPEG_MARKER_SOS:
|
| - if (sp->subsamplingcorrect!=0)
|
| - return(1);
|
| - assert(sp->plane_sample_offset==0);
|
| - if (OJPEGReadHeaderInfoSecStreamSos(tif)==0)
|
| - return(0);
|
| - break;
|
| - default:
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Unknown marker type %d in JPEG data",m);
|
| - return(0);
|
| - }
|
| - } while(m!=JPEG_MARKER_SOS);
|
| - if (sp->subsamplingcorrect)
|
| - return(1);
|
| - if (sp->sof_log==0)
|
| - {
|
| - if (OJPEGReadHeaderInfoSecTablesQTable(tif)==0)
|
| - return(0);
|
| - sp->sof_marker_id=JPEG_MARKER_SOF0;
|
| - for (o=0; o<sp->samples_per_pixel; o++)
|
| - sp->sof_c[o]=o;
|
| - sp->sof_hv[0]=((sp->subsampling_hor<<4)|sp->subsampling_ver);
|
| - for (o=1; o<sp->samples_per_pixel; o++)
|
| - sp->sof_hv[o]=17;
|
| - sp->sof_x=sp->strile_width;
|
| - sp->sof_y=sp->strile_length_total;
|
| - sp->sof_log=1;
|
| - if (OJPEGReadHeaderInfoSecTablesDcTable(tif)==0)
|
| - return(0);
|
| - if (OJPEGReadHeaderInfoSecTablesAcTable(tif)==0)
|
| - return(0);
|
| - for (o=1; o<sp->samples_per_pixel; o++)
|
| - sp->sos_cs[o]=o;
|
| - }
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadHeaderInfoSecStreamDri(TIFF* tif)
|
| -{
|
| - /* this could easilly cause trouble in some cases... but no such cases have occured sofar */
|
| - static const char module[]="OJPEGReadHeaderInfoSecStreamDri";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint16 m;
|
| - if (OJPEGReadWord(sp,&m)==0)
|
| - return(0);
|
| - if (m!=4)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DRI marker in JPEG data");
|
| - return(0);
|
| - }
|
| - if (OJPEGReadWord(sp,&m)==0)
|
| - return(0);
|
| - sp->restart_interval=m;
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif)
|
| -{
|
| - /* this is a table marker, and it is to be saved as a whole for exact pushing on the jpeg stream later on */
|
| - static const char module[]="OJPEGReadHeaderInfoSecStreamDqt";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint16 m;
|
| - uint32 na;
|
| - uint8* nb;
|
| - uint8 o;
|
| - if (OJPEGReadWord(sp,&m)==0)
|
| - return(0);
|
| - if (m<=2)
|
| - {
|
| - if (sp->subsamplingcorrect==0)
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
|
| - return(0);
|
| - }
|
| - if (sp->subsamplingcorrect!=0)
|
| - OJPEGReadSkip(sp,m-2);
|
| - else
|
| - {
|
| - m-=2;
|
| - do
|
| - {
|
| - if (m<65)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
|
| - return(0);
|
| - }
|
| - na = sizeof(uint32) + 69;
|
| - nb = (uint8*)_TIFFmalloc(na); // add (uint8*) cast
|
| - if (nb == 0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
|
| - return(0);
|
| - }
|
| - *(uint32*)nb=na;
|
| - nb[sizeof(uint32)]=255;
|
| - nb[sizeof(uint32)+1]=JPEG_MARKER_DQT;
|
| - nb[sizeof(uint32)+2]=0;
|
| - nb[sizeof(uint32)+3]=67;
|
| - if (OJPEGReadBlock(sp,65,&nb[sizeof(uint32)+4])==0) {
|
| - _TIFFfree(nb);
|
| - return(0);
|
| - }
|
| - o=nb[sizeof(uint32)+4]&15;
|
| - if (3<o)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
|
| - _TIFFfree(nb);
|
| - return(0);
|
| - }
|
| - if (sp->qtable[o]!=0)
|
| - _TIFFfree(sp->qtable[o]);
|
| - sp->qtable[o]=nb;
|
| - m-=65;
|
| - } while(m>0);
|
| - }
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadHeaderInfoSecStreamDht(TIFF* tif)
|
| -{
|
| - /* this is a table marker, and it is to be saved as a whole for exact pushing on the jpeg stream later on */
|
| - /* TODO: the following assumes there is only one table in this marker... but i'm not quite sure that assumption is guaranteed correct */
|
| - static const char module[]="OJPEGReadHeaderInfoSecStreamDht";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint16 m;
|
| - uint32 na;
|
| - uint8* nb;
|
| - uint8 o;
|
| - if (OJPEGReadWord(sp,&m)==0)
|
| - return(0);
|
| - if (m<=2)
|
| - {
|
| - if (sp->subsamplingcorrect==0)
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
|
| - return(0);
|
| - }
|
| - if (sp->subsamplingcorrect!=0)
|
| - {
|
| - OJPEGReadSkip(sp,m-2);
|
| - }
|
| - else
|
| - {
|
| - na = sizeof(uint32) + 2 + m;
|
| - nb = (uint8*)_TIFFmalloc(na); // add (uint8*) cast
|
| - if (nb == 0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
|
| - return(0);
|
| - }
|
| - *(uint32*)nb=na;
|
| - nb[sizeof(uint32)]=255;
|
| - nb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
|
| - nb[sizeof(uint32)+2]=(m>>8);
|
| - nb[sizeof(uint32)+3]=(m&255);
|
| - if (OJPEGReadBlock(sp,m-2,&nb[sizeof(uint32)+4])==0)
|
| - return(0);
|
| - o=nb[sizeof(uint32)+4];
|
| - if ((o&240)==0)
|
| - {
|
| - if (3<o)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
|
| - return(0);
|
| - }
|
| - if (sp->dctable[o]!=0)
|
| - _TIFFfree(sp->dctable[o]);
|
| - sp->dctable[o]=nb;
|
| - }
|
| - else
|
| - {
|
| - if ((o&240)!=16)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
|
| - return(0);
|
| - }
|
| - o&=15;
|
| - if (3<o)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
|
| - return(0);
|
| - }
|
| - if (sp->actable[o]!=0)
|
| - _TIFFfree(sp->actable[o]);
|
| - sp->actable[o]=nb;
|
| - }
|
| - }
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id)
|
| -{
|
| - /* this marker needs to be checked, and part of its data needs to be saved for regeneration later on */
|
| - static const char module[]="OJPEGReadHeaderInfoSecStreamSof";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint16 m;
|
| - uint16 n;
|
| - uint8 o;
|
| - uint16 p;
|
| - uint16 q;
|
| - if (sp->sof_log!=0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JPEG data");
|
| - return(0);
|
| - }
|
| - if (sp->subsamplingcorrect==0)
|
| - sp->sof_marker_id=marker_id;
|
| - /* Lf: data length */
|
| - if (OJPEGReadWord(sp,&m)==0)
|
| - return(0);
|
| - if (m<11)
|
| - {
|
| - if (sp->subsamplingcorrect==0)
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOF marker in JPEG data");
|
| - return(0);
|
| - }
|
| - m-=8;
|
| - if (m%3!=0)
|
| - {
|
| - if (sp->subsamplingcorrect==0)
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOF marker in JPEG data");
|
| - return(0);
|
| - }
|
| - n=m/3;
|
| - if (sp->subsamplingcorrect==0)
|
| - {
|
| - if (n!=sp->samples_per_pixel)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected number of samples");
|
| - return(0);
|
| - }
|
| - }
|
| - /* P: Sample precision */
|
| - if (OJPEGReadByte(sp,&o)==0)
|
| - return(0);
|
| - if (o!=8)
|
| - {
|
| - if (sp->subsamplingcorrect==0)
|
| - TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected number of bits per sample");
|
| - return(0);
|
| - }
|
| - /* Y: Number of lines, X: Number of samples per line */
|
| - if (sp->subsamplingcorrect)
|
| - OJPEGReadSkip(sp,4);
|
| - else
|
| - {
|
| - /* Y: Number of lines */
|
| - if (OJPEGReadWord(sp,&p)==0)
|
| - return(0);
|
| - if (((uint32)p<sp->image_length) && ((uint32)p<sp->strile_length_total))
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected height");
|
| - return(0);
|
| - }
|
| - sp->sof_y=p;
|
| - /* X: Number of samples per line */
|
| - if (OJPEGReadWord(sp,&p)==0)
|
| - return(0);
|
| - if (((uint32)p<sp->image_width) && ((uint32)p<sp->strile_width))
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected width");
|
| - return(0);
|
| - }
|
| - if ((uint32)p>sp->strile_width)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data image width exceeds expected image width");
|
| - return(0);
|
| - }
|
| - sp->sof_x=p;
|
| - }
|
| - /* Nf: Number of image components in frame */
|
| - if (OJPEGReadByte(sp,&o)==0)
|
| - return(0);
|
| - if (o!=n)
|
| - {
|
| - if (sp->subsamplingcorrect==0)
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOF marker in JPEG data");
|
| - return(0);
|
| - }
|
| - /* per component stuff */
|
| - /* TODO: double-check that flow implies that n cannot be as big as to make us overflow sof_c, sof_hv and sof_tq arrays */
|
| - for (q=0; q<n; q++)
|
| - {
|
| - /* C: Component identifier */
|
| - if (OJPEGReadByte(sp,&o)==0)
|
| - return(0);
|
| - if (sp->subsamplingcorrect==0)
|
| - sp->sof_c[q]=o;
|
| - /* H: Horizontal sampling factor, and V: Vertical sampling factor */
|
| - if (OJPEGReadByte(sp,&o)==0)
|
| - return(0);
|
| - if (sp->subsamplingcorrect!=0)
|
| - {
|
| - if (q==0)
|
| - {
|
| - sp->subsampling_hor=(o>>4);
|
| - sp->subsampling_ver=(o&15);
|
| - if (((sp->subsampling_hor!=1) && (sp->subsampling_hor!=2) && (sp->subsampling_hor!=4)) ||
|
| - ((sp->subsampling_ver!=1) && (sp->subsampling_ver!=2) && (sp->subsampling_ver!=4)))
|
| - sp->subsampling_force_desubsampling_inside_decompression=1;
|
| - }
|
| - else
|
| - {
|
| - if (o!=17)
|
| - sp->subsampling_force_desubsampling_inside_decompression=1;
|
| - }
|
| - }
|
| - else
|
| - {
|
| - sp->sof_hv[q]=o;
|
| - if (sp->subsampling_force_desubsampling_inside_decompression==0)
|
| - {
|
| - if (q==0)
|
| - {
|
| - if (o!=((sp->subsampling_hor<<4)|sp->subsampling_ver))
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected subsampling values");
|
| - return(0);
|
| - }
|
| - }
|
| - else
|
| - {
|
| - if (o!=17)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected subsampling values");
|
| - return(0);
|
| - }
|
| - }
|
| - }
|
| - }
|
| - /* Tq: Quantization table destination selector */
|
| - if (OJPEGReadByte(sp,&o)==0)
|
| - return(0);
|
| - if (sp->subsamplingcorrect==0)
|
| - sp->sof_tq[q]=o;
|
| - }
|
| - if (sp->subsamplingcorrect==0)
|
| - sp->sof_log=1;
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadHeaderInfoSecStreamSos(TIFF* tif)
|
| -{
|
| - /* this marker needs to be checked, and part of its data needs to be saved for regeneration later on */
|
| - static const char module[]="OJPEGReadHeaderInfoSecStreamSos";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint16 m;
|
| - uint8 n;
|
| - uint8 o;
|
| - assert(sp->subsamplingcorrect==0);
|
| - if (sp->sof_log==0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOS marker in JPEG data");
|
| - return(0);
|
| - }
|
| - /* Ls */
|
| - if (OJPEGReadWord(sp,&m)==0)
|
| - return(0);
|
| - if (m!=6+sp->samples_per_pixel_per_plane*2)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOS marker in JPEG data");
|
| - return(0);
|
| - }
|
| - /* Ns */
|
| - if (OJPEGReadByte(sp,&n)==0)
|
| - return(0);
|
| - if (n!=sp->samples_per_pixel_per_plane)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOS marker in JPEG data");
|
| - return(0);
|
| - }
|
| - /* Cs, Td, and Ta */
|
| - for (o=0; o<sp->samples_per_pixel_per_plane; o++)
|
| - {
|
| - /* Cs */
|
| - if (OJPEGReadByte(sp,&n)==0)
|
| - return(0);
|
| - sp->sos_cs[sp->plane_sample_offset+o]=n;
|
| - /* Td and Ta */
|
| - if (OJPEGReadByte(sp,&n)==0)
|
| - return(0);
|
| - sp->sos_tda[sp->plane_sample_offset+o]=n;
|
| - }
|
| - /* skip Ss, Se, Ah, en Al -> no check, as per Tom Lane recommendation, as per LibJpeg source */
|
| - OJPEGReadSkip(sp,3);
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif)
|
| -{
|
| - static const char module[]="OJPEGReadHeaderInfoSecTablesQTable";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint8 m;
|
| - uint8 n;
|
| - uint32 oa;
|
| - uint8* ob;
|
| - uint32 p;
|
| - if (sp->qtable_offset[0]==0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
|
| - return(0);
|
| - }
|
| - sp->in_buffer_file_pos_log=0;
|
| - for (m=0; m<sp->samples_per_pixel; m++)
|
| - {
|
| - if ((sp->qtable_offset[m]!=0) && ((m==0) || (sp->qtable_offset[m]!=sp->qtable_offset[m-1])))
|
| - {
|
| - for (n=0; n<m-1; n++)
|
| - {
|
| - if (sp->qtable_offset[m]==sp->qtable_offset[n])
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegQTables tag value");
|
| - return(0);
|
| - }
|
| - }
|
| - oa=sizeof(uint32)+69;
|
| - ob = (uint8*)_TIFFmalloc(oa); // add (uint8*) cast
|
| - if (ob==0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
|
| - return(0);
|
| - }
|
| - *(uint32*)ob=oa;
|
| - ob[sizeof(uint32)]=255;
|
| - ob[sizeof(uint32)+1]=JPEG_MARKER_DQT;
|
| - ob[sizeof(uint32)+2]=0;
|
| - ob[sizeof(uint32)+3]=67;
|
| - ob[sizeof(uint32)+4]=m;
|
| - TIFFSeekFile(tif,sp->qtable_offset[m],SEEK_SET);
|
| - p=(uint32)TIFFReadFile(tif,&ob[sizeof(uint32)+5],64);
|
| - if (p!=64)
|
| - return(0);
|
| - sp->qtable[m]=ob;
|
| - sp->sof_tq[m]=m;
|
| - }
|
| - else
|
| - sp->sof_tq[m]=sp->sof_tq[m-1];
|
| - }
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadHeaderInfoSecTablesDcTable(TIFF* tif)
|
| -{
|
| - static const char module[]="OJPEGReadHeaderInfoSecTablesDcTable";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint8 m;
|
| - uint8 n;
|
| - uint8 o[16];
|
| - uint32 p;
|
| - uint32 q;
|
| - uint32 ra;
|
| - uint8* rb;
|
| - if (sp->dctable_offset[0]==0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
|
| - return(0);
|
| - }
|
| - sp->in_buffer_file_pos_log=0;
|
| - for (m=0; m<sp->samples_per_pixel; m++)
|
| - {
|
| - if ((sp->dctable_offset[m]!=0) && ((m==0) || (sp->dctable_offset[m]!=sp->dctable_offset[m-1])))
|
| - {
|
| - for (n=0; n<m-1; n++)
|
| - {
|
| - if (sp->dctable_offset[m]==sp->dctable_offset[n])
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegDcTables tag value");
|
| - return(0);
|
| - }
|
| - }
|
| - TIFFSeekFile(tif,sp->dctable_offset[m],SEEK_SET);
|
| - p=(uint32)TIFFReadFile(tif,o,16);
|
| - if (p!=16)
|
| - return(0);
|
| - q=0;
|
| - for (n=0; n<16; n++)
|
| - q+=o[n];
|
| - ra=sizeof(uint32)+21+q;
|
| - rb = (uint8*)_TIFFmalloc(ra); // add (uint8*) cast
|
| - if (rb==0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
|
| - return(0);
|
| - }
|
| - *(uint32*)rb=ra;
|
| - rb[sizeof(uint32)]=255;
|
| - rb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
|
| - rb[sizeof(uint32)+2]=((19+q)>>8);
|
| - rb[sizeof(uint32)+3]=((19+q)&255);
|
| - rb[sizeof(uint32)+4]=m;
|
| - for (n=0; n<16; n++)
|
| - rb[sizeof(uint32)+5+n]=o[n];
|
| - p=(uint32)TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
|
| - if (p!=q)
|
| - return(0);
|
| - sp->dctable[m]=rb;
|
| - sp->sos_tda[m]=(m<<4);
|
| - }
|
| - else
|
| - sp->sos_tda[m]=sp->sos_tda[m-1];
|
| - }
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif)
|
| -{
|
| - static const char module[]="OJPEGReadHeaderInfoSecTablesAcTable";
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint8 m;
|
| - uint8 n;
|
| - uint8 o[16];
|
| - uint32 p;
|
| - uint32 q;
|
| - uint32 ra;
|
| - uint8* rb;
|
| - if (sp->actable_offset[0]==0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
|
| - return(0);
|
| - }
|
| - sp->in_buffer_file_pos_log=0;
|
| - for (m=0; m<sp->samples_per_pixel; m++)
|
| - {
|
| - if ((sp->actable_offset[m]!=0) && ((m==0) || (sp->actable_offset[m]!=sp->actable_offset[m-1])))
|
| - {
|
| - for (n=0; n<m-1; n++)
|
| - {
|
| - if (sp->actable_offset[m]==sp->actable_offset[n])
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegAcTables tag value");
|
| - return(0);
|
| - }
|
| - }
|
| - TIFFSeekFile(tif,sp->actable_offset[m],SEEK_SET);
|
| - p=(uint32)TIFFReadFile(tif,o,16);
|
| - if (p!=16)
|
| - return(0);
|
| - q=0;
|
| - for (n=0; n<16; n++)
|
| - q+=o[n];
|
| - ra=sizeof(uint32)+21+q;
|
| - rb = (uint8*)_TIFFmalloc(ra); // add (uint8*) cast
|
| - if (rb==0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
|
| - return(0);
|
| - }
|
| - *(uint32*)rb=ra;
|
| - rb[sizeof(uint32)]=255;
|
| - rb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
|
| - rb[sizeof(uint32)+2]=((19+q)>>8);
|
| - rb[sizeof(uint32)+3]=((19+q)&255);
|
| - rb[sizeof(uint32)+4]=(16|m);
|
| - for (n=0; n<16; n++)
|
| - rb[sizeof(uint32)+5+n]=o[n];
|
| - p=(uint32)TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
|
| - if (p!=q)
|
| - return(0);
|
| - sp->actable[m]=rb;
|
| - sp->sos_tda[m]=(sp->sos_tda[m]|m);
|
| - }
|
| - else
|
| - sp->sos_tda[m]=(sp->sos_tda[m]|(sp->sos_tda[m-1]&15));
|
| - }
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadBufferFill(OJPEGState* sp)
|
| -{
|
| - uint16 m;
|
| - tmsize_t n;
|
| - /* TODO: double-check: when subsamplingcorrect is set, no call to TIFFErrorExt or TIFFWarningExt should be made
|
| - * in any other case, seek or read errors should be passed through */
|
| - do
|
| - {
|
| - if (sp->in_buffer_file_togo!=0)
|
| - {
|
| - if (sp->in_buffer_file_pos_log==0)
|
| - {
|
| - TIFFSeekFile(sp->tif,sp->in_buffer_file_pos,SEEK_SET);
|
| - sp->in_buffer_file_pos_log=1;
|
| - }
|
| - m=OJPEG_BUFFER;
|
| - if ((uint64)m>sp->in_buffer_file_togo)
|
| - m=(uint16)sp->in_buffer_file_togo;
|
| - n=TIFFReadFile(sp->tif,sp->in_buffer,(tmsize_t)m);
|
| - if (n==0)
|
| - return(0);
|
| - assert(n>0);
|
| - assert(n<=OJPEG_BUFFER);
|
| - assert(n<65536);
|
| - assert((uint64)n<=sp->in_buffer_file_togo);
|
| - m=(uint16)n;
|
| - sp->in_buffer_togo=m;
|
| - sp->in_buffer_cur=sp->in_buffer;
|
| - sp->in_buffer_file_togo-=m;
|
| - sp->in_buffer_file_pos+=m;
|
| - break;
|
| - }
|
| - sp->in_buffer_file_pos_log=0;
|
| - switch(sp->in_buffer_source)
|
| - {
|
| - case osibsNotSetYet:
|
| - if (sp->jpeg_interchange_format!=0)
|
| - {
|
| - sp->in_buffer_file_pos=sp->jpeg_interchange_format;
|
| - sp->in_buffer_file_togo=sp->jpeg_interchange_format_length;
|
| - }
|
| - sp->in_buffer_source=osibsJpegInterchangeFormat;
|
| - break;
|
| - case osibsJpegInterchangeFormat:
|
| - sp->in_buffer_source=osibsStrile;
|
| - case osibsStrile:
|
| - if (!_TIFFFillStriles( sp->tif )
|
| - || sp->tif->tif_dir.td_stripoffset == NULL
|
| - || sp->tif->tif_dir.td_stripbytecount == NULL)
|
| - return 0;
|
| -
|
| - if (sp->in_buffer_next_strile==sp->in_buffer_strile_count)
|
| - sp->in_buffer_source=osibsEof;
|
| - else
|
| - {
|
| - sp->in_buffer_file_pos=sp->tif->tif_dir.td_stripoffset[sp->in_buffer_next_strile];
|
| - if (sp->in_buffer_file_pos!=0)
|
| - {
|
| - if (sp->in_buffer_file_pos>=sp->file_size)
|
| - sp->in_buffer_file_pos=0;
|
| - else if (sp->tif->tif_dir.td_stripbytecount==NULL)
|
| - sp->in_buffer_file_togo=sp->file_size-sp->in_buffer_file_pos;
|
| - else
|
| - {
|
| - if (sp->tif->tif_dir.td_stripbytecount == 0) {
|
| - TIFFErrorExt(sp->tif->tif_clientdata,sp->tif->tif_name,"Strip byte counts are missing");
|
| - return(0);
|
| - }
|
| - sp->in_buffer_file_togo=sp->tif->tif_dir.td_stripbytecount[sp->in_buffer_next_strile];
|
| - if (sp->in_buffer_file_togo==0)
|
| - sp->in_buffer_file_pos=0;
|
| - else if (sp->in_buffer_file_pos+sp->in_buffer_file_togo>sp->file_size)
|
| - sp->in_buffer_file_togo=sp->file_size-sp->in_buffer_file_pos;
|
| - }
|
| - }
|
| - sp->in_buffer_next_strile++;
|
| - }
|
| - break;
|
| - default:
|
| - return(0);
|
| - }
|
| - } while (1);
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadByte(OJPEGState* sp, uint8* byte)
|
| -{
|
| - if (sp->in_buffer_togo==0)
|
| - {
|
| - if (OJPEGReadBufferFill(sp)==0)
|
| - return(0);
|
| - assert(sp->in_buffer_togo>0);
|
| - }
|
| - *byte=*(sp->in_buffer_cur);
|
| - sp->in_buffer_cur++;
|
| - sp->in_buffer_togo--;
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadBytePeek(OJPEGState* sp, uint8* byte)
|
| -{
|
| - if (sp->in_buffer_togo==0)
|
| - {
|
| - if (OJPEGReadBufferFill(sp)==0)
|
| - return(0);
|
| - assert(sp->in_buffer_togo>0);
|
| - }
|
| - *byte=*(sp->in_buffer_cur);
|
| - return(1);
|
| -}
|
| -
|
| -static void
|
| -OJPEGReadByteAdvance(OJPEGState* sp)
|
| -{
|
| - assert(sp->in_buffer_togo>0);
|
| - sp->in_buffer_cur++;
|
| - sp->in_buffer_togo--;
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadWord(OJPEGState* sp, uint16* word)
|
| -{
|
| - uint8 m;
|
| - if (OJPEGReadByte(sp,&m)==0)
|
| - return(0);
|
| - *word=(m<<8);
|
| - if (OJPEGReadByte(sp,&m)==0)
|
| - return(0);
|
| - *word|=m;
|
| - return(1);
|
| -}
|
| -
|
| -static int
|
| -OJPEGReadBlock(OJPEGState* sp, uint16 len, void* mem)
|
| -{
|
| - uint16 mlen;
|
| - uint8* mmem;
|
| - uint16 n;
|
| - assert(len>0);
|
| - mlen=len;
|
| - mmem = (uint8*)mem; // add (uint8*) cast
|
| - do
|
| - {
|
| - if (sp->in_buffer_togo==0)
|
| - {
|
| - if (OJPEGReadBufferFill(sp)==0)
|
| - return(0);
|
| - assert(sp->in_buffer_togo>0);
|
| - }
|
| - n=mlen;
|
| - if (n>sp->in_buffer_togo)
|
| - n=sp->in_buffer_togo;
|
| - _TIFFmemcpy(mmem,sp->in_buffer_cur,n);
|
| - sp->in_buffer_cur+=n;
|
| - sp->in_buffer_togo-=n;
|
| - mlen-=n;
|
| - mmem+=n;
|
| - } while(mlen>0);
|
| - return(1);
|
| -}
|
| -
|
| -static void
|
| -OJPEGReadSkip(OJPEGState* sp, uint16 len)
|
| -{
|
| - uint16 m;
|
| - uint16 n;
|
| - m=len;
|
| - n=m;
|
| - if (n>sp->in_buffer_togo)
|
| - n=sp->in_buffer_togo;
|
| - sp->in_buffer_cur+=n;
|
| - sp->in_buffer_togo-=n;
|
| - m-=n;
|
| - if (m>0)
|
| - {
|
| - assert(sp->in_buffer_togo==0);
|
| - n=m;
|
| - if ((uint64)n>sp->in_buffer_file_togo)
|
| - n=(uint16)sp->in_buffer_file_togo;
|
| - sp->in_buffer_file_pos+=n;
|
| - sp->in_buffer_file_togo-=n;
|
| - sp->in_buffer_file_pos_log=0;
|
| - /* we don't skip past jpeginterchangeformat/strile block...
|
| - * if that is asked from us, we're dealing with totally bazurk
|
| - * data anyway, and we've not seen this happening on any
|
| - * testfile, so we might as well likely cause some other
|
| - * meaningless error to be passed at some later time
|
| - */
|
| - }
|
| -}
|
| -
|
| -static int
|
| -OJPEGWriteStream(TIFF* tif, void** mem, uint32* len)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - *len=0;
|
| - do
|
| - {
|
| - assert(sp->out_state<=ososEoi);
|
| - switch(sp->out_state)
|
| - {
|
| - case ososSoi:
|
| - OJPEGWriteStreamSoi(tif,mem,len);
|
| - break;
|
| - case ososQTable0:
|
| - OJPEGWriteStreamQTable(tif,0,mem,len);
|
| - break;
|
| - case ososQTable1:
|
| - OJPEGWriteStreamQTable(tif,1,mem,len);
|
| - break;
|
| - case ososQTable2:
|
| - OJPEGWriteStreamQTable(tif,2,mem,len);
|
| - break;
|
| - case ososQTable3:
|
| - OJPEGWriteStreamQTable(tif,3,mem,len);
|
| - break;
|
| - case ososDcTable0:
|
| - OJPEGWriteStreamDcTable(tif,0,mem,len);
|
| - break;
|
| - case ososDcTable1:
|
| - OJPEGWriteStreamDcTable(tif,1,mem,len);
|
| - break;
|
| - case ososDcTable2:
|
| - OJPEGWriteStreamDcTable(tif,2,mem,len);
|
| - break;
|
| - case ososDcTable3:
|
| - OJPEGWriteStreamDcTable(tif,3,mem,len);
|
| - break;
|
| - case ososAcTable0:
|
| - OJPEGWriteStreamAcTable(tif,0,mem,len);
|
| - break;
|
| - case ososAcTable1:
|
| - OJPEGWriteStreamAcTable(tif,1,mem,len);
|
| - break;
|
| - case ososAcTable2:
|
| - OJPEGWriteStreamAcTable(tif,2,mem,len);
|
| - break;
|
| - case ososAcTable3:
|
| - OJPEGWriteStreamAcTable(tif,3,mem,len);
|
| - break;
|
| - case ososDri:
|
| - OJPEGWriteStreamDri(tif,mem,len);
|
| - break;
|
| - case ososSof:
|
| - OJPEGWriteStreamSof(tif,mem,len);
|
| - break;
|
| - case ososSos:
|
| - OJPEGWriteStreamSos(tif,mem,len);
|
| - break;
|
| - case ososCompressed:
|
| - if (OJPEGWriteStreamCompressed(tif,mem,len)==0)
|
| - return(0);
|
| - break;
|
| - case ososRst:
|
| - OJPEGWriteStreamRst(tif,mem,len);
|
| - break;
|
| - case ososEoi:
|
| - OJPEGWriteStreamEoi(tif,mem,len);
|
| - break;
|
| - }
|
| - } while (*len==0);
|
| - return(1);
|
| -}
|
| -
|
| -static void
|
| -OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32* len)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - assert(OJPEG_BUFFER>=2);
|
| - sp->out_buffer[0]=255;
|
| - sp->out_buffer[1]=JPEG_MARKER_SOI;
|
| - *len=2;
|
| - *mem=(void*)sp->out_buffer;
|
| - sp->out_state++;
|
| -}
|
| -
|
| -static void
|
| -OJPEGWriteStreamQTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - if (sp->qtable[table_index]!=0)
|
| - {
|
| - *mem=(void*)(sp->qtable[table_index]+sizeof(uint32));
|
| - *len=*((uint32*)sp->qtable[table_index])-sizeof(uint32);
|
| - }
|
| - sp->out_state++;
|
| -}
|
| -
|
| -static void
|
| -OJPEGWriteStreamDcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - if (sp->dctable[table_index]!=0)
|
| - {
|
| - *mem=(void*)(sp->dctable[table_index]+sizeof(uint32));
|
| - *len=*((uint32*)sp->dctable[table_index])-sizeof(uint32);
|
| - }
|
| - sp->out_state++;
|
| -}
|
| -
|
| -static void
|
| -OJPEGWriteStreamAcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - if (sp->actable[table_index]!=0)
|
| - {
|
| - *mem=(void*)(sp->actable[table_index]+sizeof(uint32));
|
| - *len=*((uint32*)sp->actable[table_index])-sizeof(uint32);
|
| - }
|
| - sp->out_state++;
|
| -}
|
| -
|
| -static void
|
| -OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32* len)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - assert(OJPEG_BUFFER>=6);
|
| - if (sp->restart_interval!=0)
|
| - {
|
| - sp->out_buffer[0]=255;
|
| - sp->out_buffer[1]=JPEG_MARKER_DRI;
|
| - sp->out_buffer[2]=0;
|
| - sp->out_buffer[3]=4;
|
| - sp->out_buffer[4]=(sp->restart_interval>>8);
|
| - sp->out_buffer[5]=(sp->restart_interval&255);
|
| - *len=6;
|
| - *mem=(void*)sp->out_buffer;
|
| - }
|
| - sp->out_state++;
|
| -}
|
| -
|
| -static void
|
| -OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32* len)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint8 m;
|
| - assert(OJPEG_BUFFER>=2+8+sp->samples_per_pixel_per_plane*3);
|
| - assert(255>=8+sp->samples_per_pixel_per_plane*3);
|
| - sp->out_buffer[0]=255;
|
| - sp->out_buffer[1]=sp->sof_marker_id;
|
| - /* Lf */
|
| - sp->out_buffer[2]=0;
|
| - sp->out_buffer[3]=8+sp->samples_per_pixel_per_plane*3;
|
| - /* P */
|
| - sp->out_buffer[4]=8;
|
| - /* Y */
|
| - sp->out_buffer[5]=(sp->sof_y>>8);
|
| - sp->out_buffer[6]=(sp->sof_y&255);
|
| - /* X */
|
| - sp->out_buffer[7]=(sp->sof_x>>8);
|
| - sp->out_buffer[8]=(sp->sof_x&255);
|
| - /* Nf */
|
| - sp->out_buffer[9]=sp->samples_per_pixel_per_plane;
|
| - for (m=0; m<sp->samples_per_pixel_per_plane; m++)
|
| - {
|
| - /* C */
|
| - sp->out_buffer[10+m*3]=sp->sof_c[sp->plane_sample_offset+m];
|
| - /* H and V */
|
| - sp->out_buffer[10+m*3+1]=sp->sof_hv[sp->plane_sample_offset+m];
|
| - /* Tq */
|
| - sp->out_buffer[10+m*3+2]=sp->sof_tq[sp->plane_sample_offset+m];
|
| - }
|
| - *len=10+sp->samples_per_pixel_per_plane*3;
|
| - *mem=(void*)sp->out_buffer;
|
| - sp->out_state++;
|
| -}
|
| -
|
| -static void
|
| -OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32* len)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - uint8 m;
|
| - assert(OJPEG_BUFFER>=2+6+sp->samples_per_pixel_per_plane*2);
|
| - assert(255>=6+sp->samples_per_pixel_per_plane*2);
|
| - sp->out_buffer[0]=255;
|
| - sp->out_buffer[1]=JPEG_MARKER_SOS;
|
| - /* Ls */
|
| - sp->out_buffer[2]=0;
|
| - sp->out_buffer[3]=6+sp->samples_per_pixel_per_plane*2;
|
| - /* Ns */
|
| - sp->out_buffer[4]=sp->samples_per_pixel_per_plane;
|
| - for (m=0; m<sp->samples_per_pixel_per_plane; m++)
|
| - {
|
| - /* Cs */
|
| - sp->out_buffer[5+m*2]=sp->sos_cs[sp->plane_sample_offset+m];
|
| - /* Td and Ta */
|
| - sp->out_buffer[5+m*2+1]=sp->sos_tda[sp->plane_sample_offset+m];
|
| - }
|
| - /* Ss */
|
| - sp->out_buffer[5+sp->samples_per_pixel_per_plane*2]=0;
|
| - /* Se */
|
| - sp->out_buffer[5+sp->samples_per_pixel_per_plane*2+1]=63;
|
| - /* Ah and Al */
|
| - sp->out_buffer[5+sp->samples_per_pixel_per_plane*2+2]=0;
|
| - *len=8+sp->samples_per_pixel_per_plane*2;
|
| - *mem=(void*)sp->out_buffer;
|
| - sp->out_state++;
|
| -}
|
| -
|
| -static int
|
| -OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - if (sp->in_buffer_togo==0)
|
| - {
|
| - if (OJPEGReadBufferFill(sp)==0)
|
| - return(0);
|
| - assert(sp->in_buffer_togo>0);
|
| - }
|
| - *len=sp->in_buffer_togo;
|
| - *mem=(void*)sp->in_buffer_cur;
|
| - sp->in_buffer_togo=0;
|
| - if (sp->in_buffer_file_togo==0)
|
| - {
|
| - switch(sp->in_buffer_source)
|
| - {
|
| - case osibsStrile:
|
| - if (sp->in_buffer_next_strile<sp->in_buffer_strile_count)
|
| - sp->out_state=ososRst;
|
| - else
|
| - sp->out_state=ososEoi;
|
| - break;
|
| - case osibsEof:
|
| - sp->out_state=ososEoi;
|
| - break;
|
| - default:
|
| - break;
|
| - }
|
| - }
|
| - return(1);
|
| -}
|
| -
|
| -static void
|
| -OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32* len)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - assert(OJPEG_BUFFER>=2);
|
| - sp->out_buffer[0]=255;
|
| - sp->out_buffer[1]=JPEG_MARKER_RST0+sp->restart_index;
|
| - sp->restart_index++;
|
| - if (sp->restart_index==8)
|
| - sp->restart_index=0;
|
| - *len=2;
|
| - *mem=(void*)sp->out_buffer;
|
| - sp->out_state=ososCompressed;
|
| -}
|
| -
|
| -static void
|
| -OJPEGWriteStreamEoi(TIFF* tif, void** mem, uint32* len)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - assert(OJPEG_BUFFER>=2);
|
| - sp->out_buffer[0]=255;
|
| - sp->out_buffer[1]=JPEG_MARKER_EOI;
|
| - *len=2;
|
| - *mem=(void*)sp->out_buffer;
|
| -}
|
| -
|
| -#ifndef LIBJPEG_ENCAP_EXTERNAL
|
| -static int
|
| -jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo)
|
| -{
|
| - return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_create_decompress(cinfo),1));
|
| -}
|
| -#endif
|
| -
|
| -#ifndef LIBJPEG_ENCAP_EXTERNAL
|
| -static int
|
| -jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image)
|
| -{
|
| - return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_read_header(cinfo,require_image),1));
|
| -}
|
| -#endif
|
| -
|
| -#ifndef LIBJPEG_ENCAP_EXTERNAL
|
| -static int
|
| -jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo)
|
| -{
|
| - return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_start_decompress(cinfo),1));
|
| -}
|
| -#endif
|
| -
|
| -#ifndef LIBJPEG_ENCAP_EXTERNAL
|
| -static int
|
| -jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines)
|
| -{
|
| - return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_read_scanlines(cinfo,scanlines,max_lines),1));
|
| -}
|
| -#endif
|
| -
|
| -#ifndef LIBJPEG_ENCAP_EXTERNAL
|
| -static int
|
| -jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines)
|
| -{
|
| - return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_read_raw_data(cinfo,data,max_lines),1));
|
| -}
|
| -#endif
|
| -
|
| -#ifndef LIBJPEG_ENCAP_EXTERNAL
|
| -static void
|
| -jpeg_encap_unwind(TIFF* tif)
|
| -{
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - LONGJMP(sp->exit_jmpbuf,1);
|
| -}
|
| -#endif
|
| -
|
| -static void
|
| -OJPEGLibjpegJpegErrorMgrOutputMessage(jpeg_common_struct* cinfo)
|
| -{
|
| - char buffer[JMSG_LENGTH_MAX];
|
| - (*cinfo->err->format_message)(cinfo,buffer);
|
| - TIFFWarningExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg","%s",buffer);
|
| -}
|
| -
|
| -static void
|
| -OJPEGLibjpegJpegErrorMgrErrorExit(jpeg_common_struct* cinfo)
|
| -{
|
| - char buffer[JMSG_LENGTH_MAX];
|
| - (*cinfo->err->format_message)(cinfo,buffer);
|
| - TIFFErrorExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg","%s",buffer);
|
| - jpeg_encap_unwind((TIFF*)(cinfo->client_data));
|
| -}
|
| -
|
| -static void
|
| -OJPEGLibjpegJpegSourceMgrInitSource(jpeg_decompress_struct* cinfo)
|
| -{
|
| - (void)cinfo;
|
| -}
|
| -
|
| -static boolean
|
| -OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct* cinfo)
|
| -{
|
| - TIFF* tif=(TIFF*)cinfo->client_data;
|
| - OJPEGState* sp=(OJPEGState*)tif->tif_data;
|
| - void* mem=0;
|
| - uint32 len=0U;
|
| - if (OJPEGWriteStream(tif,&mem,&len)==0)
|
| - {
|
| - TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Premature end of JPEG data");
|
| - jpeg_encap_unwind(tif);
|
| - }
|
| - sp->libjpeg_jpeg_source_mgr.bytes_in_buffer = len;
|
| - sp->libjpeg_jpeg_source_mgr.next_input_byte = (const JOCTET * )mem; // add (const JOCTET * ) cast
|
| - return(1);
|
| -}
|
| -
|
| -static void
|
| -OJPEGLibjpegJpegSourceMgrSkipInputData(jpeg_decompress_struct* cinfo, long num_bytes)
|
| -{
|
| - TIFF* tif=(TIFF*)cinfo->client_data;
|
| - (void)num_bytes;
|
| - TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Unexpected error");
|
| - jpeg_encap_unwind(tif);
|
| -}
|
| -
|
| -static boolean
|
| -OJPEGLibjpegJpegSourceMgrResyncToRestart(jpeg_decompress_struct* cinfo, int desired)
|
| -{
|
| - TIFF* tif=(TIFF*)cinfo->client_data;
|
| - (void)desired;
|
| - TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Unexpected error");
|
| - jpeg_encap_unwind(tif);
|
| - return(0);
|
| -}
|
| -
|
| -static void
|
| -OJPEGLibjpegJpegSourceMgrTermSource(jpeg_decompress_struct* cinfo)
|
| -{
|
| - (void)cinfo;
|
| -}
|
| -
|
| -#endif
|
| -
|
| -
|
| -/*
|
| - * Local Variables:
|
| - * mode: c
|
| - * c-basic-offset: 8
|
| - * fill-column: 78
|
| - * End:
|
| - */
|
| -
|
|
|
Chromium Code Reviews
Issue 1392373004:
Rename lpng and tiff to third_party/ (Closed)
Base URL: https://pdfium.googlesource.com/pdfium.git@xfa