Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
Open Source Computer Vision Library https://opencv.org/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
91 Commits
6 Branches
128 Tags
3.0 GiB
 
 
 
 
 
 
Tag: Branch: Tree: 2d6580faab
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2d6580faab'
${ noResults }
opencv/3rdparty/libtiff/tif_ojpeg.c

2641 lines
108 KiB
Raw Blame History

/* $Id: tif_ojpeg.c,v 1.1 2005-06-17 13:54:52 vp153 Exp $ */
#include "tiffiop.h"
#ifdef OJPEG_SUPPORT
/* JPEG Compression support, as per the original TIFF 6.0 specification.
WARNING: KLUDGE ALERT! 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 is an unsupported hack
that was created solely in order to read (but NOT write!) a few old,
unconverted images still present on some users' computer systems. The code
isn't pretty or robust, and it won't read every "old format" JPEG-in-TIFF
file (see Samuel Leffler's draft "TIFF Technical Note No. 2" for a long and
incomplete list of known problems), but it seems to work well enough in the
few cases of practical interest to the author; so, "caveat emptor"! This
file should NEVER be enhanced to write new images using anything other than
the latest approved JPEG-in-TIFF encapsulation method, implemented by the
"tif_jpeg.c" file elsewhere in this library.
This file interfaces with Release 6B of the JPEG Library written by theu
Independent JPEG Group, which you can find on the Internet at:
ftp://ftp.uu.net:/graphics/jpeg/.
The "C" Preprocessor macros, "[CD]_LOSSLESS_SUPPORTED", are defined by your
JPEG Library Version 6B only if you have applied a (massive!) patch by Ken
Murchison of Oceana Matrix Ltd. <ken@oceana.com> to support lossless Huffman
encoding (TIFF "JPEGProc" tag value = 14). This patch can be found on the
Internet at: ftp://ftp.oceana.com/pub/ljpeg-6b.tar.gz.
Some old files produced by the Wang Imaging application for Microsoft Windows
apparently can be decoded only with a special patch to the JPEG Library,
which defines a subroutine named "jpeg_reset_huff_decode()" in its "jdhuff.c"
module (the "jdshuff.c" module, if Ken Murchison's patch has been applied).
Unfortunately the patch differs slightly in each case, and some TIFF Library
have reported problems finding the code, so both versions appear below; you
should carefully extract and apply only the version that applies to your JPEG
Library!
Contributed by Scott Marovich <marovich@hpl.hp.com> with considerable help
from Charles Auer <Bumble731@msn.com> to unravel the mysteries of image files
created by the Wang Imaging application for Microsoft Windows.
*/
#if 0 /* Patch for JPEG Library WITHOUT lossless Huffman coding */
*** jdhuff.c.orig Mon Oct 20 17:51:10 1997
--- jdhuff.c Sun Nov 11 17:33:58 2001
***************
*** 648,651 ****
--- 648,683 ----
for (i = 0; i < NUM_HUFF_TBLS; i++) {
entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
}
}
+
+ /*
+ * BEWARE OF KLUDGE: This subroutine is a hack for decoding illegal JPEG-in-
+ * TIFF encapsulations produced by Microsoft's Wang Imaging
+ * for Windows application with the public-domain TIFF Library. Based upon an
+ * examination of selected output files, this program apparently divides a JPEG
+ * bit-stream into consecutive horizontal TIFF "strips", such that the JPEG
+ * encoder's/decoder's DC coefficients for each image component are reset before
+ * each "strip". Moreover, a "strip" is not necessarily encoded in a multiple
+ * of 8 bits, so one must sometimes discard 1-7 bits at the end of each "strip"
+ * for alignment to the next input-Byte storage boundary. IJG JPEG Library
+ * decoder state is not normally exposed to client applications, so this sub-
+ * routine provides the TIFF Library with a "hook" to make these corrections.
+ * It should be called after "jpeg_start_decompress()" and before
+ * "jpeg_finish_decompress()", just before decoding each "strip" using
+ * "jpeg_read_raw_data()" or "jpeg_read_scanlines()".
+ *
+ * This kludge is not sanctioned or supported by the Independent JPEG Group, and
+ * future changes to the IJG JPEG Library might invalidate it. Do not send bug
+ * reports about this code to IJG developers. Instead, contact the author for
+ * advice: Scott B. Marovich <marovich@hpl.hp.com>, Hewlett-Packard Labs, 6/01.
+ */
+ GLOBAL(void)
+ jpeg_reset_huff_decode (register j_decompress_ptr cinfo)
+ { register huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
+ register int ci = 0;
+
+ /* Discard encoded input bits, up to the next Byte boundary */
+ entropy->bitstate.bits_left &= ~7;
+ /* Re-initialize DC predictions to 0 */
+ do entropy->saved.last_dc_val[ci] = 0; while (++ci < cinfo->comps_in_scan);
+ }
#endif /* Patch for JPEG Library WITHOUT lossless Huffman coding */
#if 0 /* Patch for JPEG Library WITH lossless Huffman coding */
*** jdshuff.c.orig Mon Mar 11 16:44:54 2002
--- jdshuff.c Mon Mar 11 16:44:54 2002
***************
*** 357,360 ****
--- 357,393 ----
for (i = 0; i < NUM_HUFF_TBLS; i++) {
entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
}
}
+
+ /*
+ * BEWARE OF KLUDGE: This subroutine is a hack for decoding illegal JPEG-in-
+ * TIFF encapsulations produced by Microsoft's Wang Imaging
+ * for Windows application with the public-domain TIFF Library. Based upon an
+ * examination of selected output files, this program apparently divides a JPEG
+ * bit-stream into consecutive horizontal TIFF "strips", such that the JPEG
+ * encoder's/decoder's DC coefficients for each image component are reset before
+ * each "strip". Moreover, a "strip" is not necessarily encoded in a multiple
+ * of 8 bits, so one must sometimes discard 1-7 bits at the end of each "strip"
+ * for alignment to the next input-Byte storage boundary. IJG JPEG Library
+ * decoder state is not normally exposed to client applications, so this sub-
+ * routine provides the TIFF Library with a "hook" to make these corrections.
+ * It should be called after "jpeg_start_decompress()" and before
+ * "jpeg_finish_decompress()", just before decoding each "strip" using
+ * "jpeg_read_raw_data()" or "jpeg_read_scanlines()".
+ *
+ * This kludge is not sanctioned or supported by the Independent JPEG Group, and
+ * future changes to the IJG JPEG Library might invalidate it. Do not send bug
+ * reports about this code to IJG developers. Instead, contact the author for
+ * advice: Scott B. Marovich <marovich@hpl.hp.com>, Hewlett-Packard Labs, 6/01.
+ */
+ GLOBAL(void)
+ jpeg_reset_huff_decode (register j_decompress_ptr cinfo)
+ { register shuff_entropy_ptr entropy = (shuff_entropy_ptr)
+ ((j_lossy_d_ptr)cinfo->codec)->entropy_private;
+ register int ci = 0;
+
+ /* Discard encoded input bits, up to the next Byte boundary */
+ entropy->bitstate.bits_left &= ~7;
+ /* Re-initialize DC predictions to 0 */
+ do entropy->saved.last_dc_val[ci] = 0; while (++ci < cinfo->comps_in_scan);
+ }
#endif /* Patch for JPEG Library WITH lossless Huffman coding */
#include <setjmp.h>
#include <stdio.h>
#ifdef FAR
#undef FAR /* Undefine FAR to avoid conflict with JPEG definition */
#endif
#define JPEG_INTERNALS /* Include "jpegint.h" for "DSTATE_*" symbols */
#define JPEG_CJPEG_DJPEG /* Include all Version 6B+ "jconfig.h" options */
#undef INLINE
#include "jpeglib.h"
#undef JPEG_CJPEG_DJPEG
#undef JPEG_INTERNALS
/* Hack for files produced by Wang Imaging application on Microsoft Windows */
extern void jpeg_reset_huff_decode(j_decompress_ptr);
/* On some machines, it may be worthwhile to use "_setjmp()" or "sigsetjmp()"
instead of "setjmp()". These macros make it easier:
*/
#define SETJMP(jbuf)setjmp(jbuf)
#define LONGJMP(jbuf,code)longjmp(jbuf,code)
#define JMP_BUF jmp_buf
#define TIFFTAG_WANG_PAGECONTROL 32934
/* Bit-vector offsets for keeping track of TIFF records that we've parsed. */
#define FIELD_JPEGPROC FIELD_CODEC
#define FIELD_JPEGIFOFFSET (FIELD_CODEC+1)
#define FIELD_JPEGIFBYTECOUNT (FIELD_CODEC+2)
#define FIELD_JPEGRESTARTINTERVAL (FIELD_CODEC+3)
#define FIELD_JPEGTABLES (FIELD_CODEC+4) /* New, post-6.0 JPEG-in-TIFF tag! */
#define FIELD_JPEGLOSSLESSPREDICTORS (FIELD_CODEC+5)
#define FIELD_JPEGPOINTTRANSFORM (FIELD_CODEC+6)
#define FIELD_JPEGQTABLES (FIELD_CODEC+7)
#define FIELD_JPEGDCTABLES (FIELD_CODEC+8)
#define FIELD_JPEGACTABLES (FIELD_CODEC+9)
#define FIELD_WANG_PAGECONTROL (FIELD_CODEC+10)
#define FIELD_JPEGCOLORMODE (FIELD_CODEC+11)
typedef struct jpeg_destination_mgr jpeg_destination_mgr;
typedef struct jpeg_source_mgr jpeg_source_mgr;
typedef struct jpeg_error_mgr jpeg_error_mgr;
/* State variable for each open TIFF file that uses "libjpeg" for JPEG
decompression. (Note: This file should NEVER perform JPEG compression
except in the manner implemented by the "tif_jpeg.c" file, elsewhere in this
library; see comments above.) JPEG Library internal state is recorded in a
"jpeg_{de}compress_struct", while a "jpeg_common_struct" records a few items
common to both compression and expansion. The "cinfo" field containing JPEG
Library state MUST be the 1st member of our own state variable, so that we
can safely "cast" pointers back and forth.
*/
typedef struct /* This module's private, per-image state variable */
{
union /* JPEG Library state variable; this MUST be our 1st field! */
{
struct jpeg_compress_struct c;
struct jpeg_decompress_struct d;
struct jpeg_common_struct comm;
} cinfo;
jpeg_error_mgr err; /* JPEG Library error manager */
JMP_BUF exit_jmpbuf; /* ...for catching JPEG Library failures */
# ifdef never
/* (The following two fields could be a "union", but they're small enough that
it's not worth the effort.)
*/
jpeg_destination_mgr dest; /* Destination for compressed data */
# endif
jpeg_source_mgr src; /* Source of expanded data */
JSAMPARRAY ds_buffer[MAX_COMPONENTS]; /* ->Temporary downsampling buffers */
TIFF *tif; /* Reverse pointer, needed by some code */
TIFFVGetMethod vgetparent; /* "Super class" methods... */
TIFFVSetMethod vsetparent;
TIFFStripMethod defsparent;
TIFFTileMethod deftparent;
void *jpegtables; /* ->"New" JPEG tables, if we synthesized any */
uint32 is_WANG, /* <=> Wang Imaging for Microsoft Windows output file? */
jpegtables_length; /* Length of "new" JPEG tables, if they exist */
tsize_t bytesperline; /* No. of decompressed Bytes per scan line */
int jpegquality, /* Compression quality level */
jpegtablesmode, /* What to put in JPEGTables */
samplesperclump,
scancount; /* No. of scan lines accumulated */
J_COLOR_SPACE photometric; /* IJG JPEG Library's photometry code */
unsigned char h_sampling, /* Luminance sampling factors */
v_sampling,
jpegcolormode; /* Who performs RGB <-> YCbCr conversion? */
/* JPEGCOLORMODE_RAW <=> TIFF Library or its client */
/* JPEGCOLORMODE_RGB <=> JPEG Library */
/* These fields are added to support TIFFGetField */
uint16 jpegproc;
uint32 jpegifoffset;
uint32 jpegifbytecount;
uint32 jpegrestartinterval;
void* jpeglosslesspredictors;
uint16 jpeglosslesspredictors_length;
void* jpegpointtransform;
uint32 jpegpointtransform_length;
void* jpegqtables;
uint32 jpegqtables_length;
void* jpegdctables;
uint32 jpegdctables_length;
void* jpegactables;
uint32 jpegactables_length;
} OJPEGState;
#define OJState(tif)((OJPEGState*)(tif)->tif_data)
static const TIFFFieldInfo ojpegFieldInfo[]=/* JPEG-specific TIFF-record tags */
{
/* This is the current JPEG-in-TIFF metadata-encapsulation tag, and its
treatment in this file is idiosyncratic. It should never appear in a
"source" image conforming to the TIFF Version 6.0 specification, so we
arrange to report an error if it appears. But in order to support possible
future conversion of "old" JPEG-in-TIFF encapsulations to "new" ones, we
might wish to synthesize an equivalent value to be returned by the TIFF
Library's "getfield" method. So, this table tells the TIFF Library to pass
these records to us in order to filter them below.
*/
{
TIFFTAG_JPEGTABLES ,TIFF_VARIABLE2,TIFF_VARIABLE2,
TIFF_UNDEFINED,FIELD_JPEGTABLES ,FALSE,TRUE ,"JPEGTables"
},
/* These tags are defined by the TIFF Version 6.0 specification and are now
obsolete. This module reads them from an old "source" image, but it never
writes them to a new "destination" image.
*/
{
TIFFTAG_JPEGPROC ,1 ,1 ,
TIFF_SHORT ,FIELD_JPEGPROC ,FALSE,FALSE,"JPEGProc"
},
{
TIFFTAG_JPEGIFOFFSET ,1 ,1 ,
TIFF_LONG ,FIELD_JPEGIFOFFSET ,FALSE,FALSE,"JPEGInterchangeFormat"
},
{
TIFFTAG_JPEGIFBYTECOUNT ,1 ,1 ,
TIFF_LONG ,FIELD_JPEGIFBYTECOUNT ,FALSE,FALSE,"JPEGInterchangeFormatLength"
},
{
TIFFTAG_JPEGRESTARTINTERVAL ,1 ,1 ,
TIFF_SHORT ,FIELD_JPEGRESTARTINTERVAL ,FALSE,FALSE,"JPEGRestartInterval"
},
{
TIFFTAG_JPEGLOSSLESSPREDICTORS,TIFF_VARIABLE,TIFF_VARIABLE,
TIFF_SHORT ,FIELD_JPEGLOSSLESSPREDICTORS,FALSE,TRUE ,"JPEGLosslessPredictors"
},
{
TIFFTAG_JPEGPOINTTRANSFORM ,TIFF_VARIABLE,TIFF_VARIABLE,
TIFF_SHORT ,FIELD_JPEGPOINTTRANSFORM ,FALSE,TRUE ,"JPEGPointTransforms"
},
{
TIFFTAG_JPEGQTABLES ,TIFF_VARIABLE,TIFF_VARIABLE,
TIFF_LONG ,FIELD_JPEGQTABLES ,FALSE,TRUE ,"JPEGQTables"
},
{
TIFFTAG_JPEGDCTABLES ,TIFF_VARIABLE,TIFF_VARIABLE,
TIFF_LONG ,FIELD_JPEGDCTABLES ,FALSE,TRUE ,"JPEGDCTables"
},
{
TIFFTAG_JPEGACTABLES ,TIFF_VARIABLE,TIFF_VARIABLE,
TIFF_LONG ,FIELD_JPEGACTABLES ,FALSE,TRUE ,"JPEGACTables"
},
{
TIFFTAG_WANG_PAGECONTROL ,TIFF_VARIABLE,1 ,
TIFF_LONG ,FIELD_WANG_PAGECONTROL ,FALSE,FALSE,"WANG PageControl"
},
/* This is a pseudo tag intended for internal use only by the TIFF Library and
its clients, which should never appear in an input/output image file. It
specifies whether the TIFF Library (or its client) should do YCbCr <-> RGB
color-space conversion (JPEGCOLORMODE_RAW <=> 0) or whether we should ask
the JPEG Library to do it (JPEGCOLORMODE_RGB <=> 1).
*/
{
TIFFTAG_JPEGCOLORMODE ,0 ,0 ,
TIFF_ANY ,FIELD_PSEUDO ,FALSE,FALSE,"JPEGColorMode"
}
};
static const char JPEGLib_name[]={"JPEG Library"},
bad_bps[]={"%u BitsPerSample not allowed for JPEG"},
bad_photometry[]={"PhotometricInterpretation %u not allowed for JPEG"},
bad_subsampling[]={"invalid YCbCr subsampling factor(s)"},
# ifdef never
no_write_frac[]={"fractional scan line discarded"},
# endif
no_read_frac[]={"fractional scan line not read"},
no_jtable_space[]={"No space for JPEGTables"};
/* The following diagnostic subroutines interface with and replace default
subroutines in the JPEG Library. Our basic strategy is to use "setjmp()"/
"longjmp()" in order to return control to the TIFF Library when the JPEG
library detects an error, and to use TIFF Library subroutines for displaying
diagnostic messages to a client application.
*/
static void
TIFFojpeg_error_exit(register j_common_ptr cinfo)
{
char buffer[JMSG_LENGTH_MAX];
int code = cinfo->err->msg_code;
if (((OJPEGState *)cinfo)->is_WANG) {
if (code == JERR_SOF_DUPLICATE || code == JERR_SOI_DUPLICATE)
return; /* ignore it */
}
(*cinfo->err->format_message)(cinfo,buffer);
TIFFError(JPEGLib_name,buffer); /* Display error message */
jpeg_abort(cinfo); /* Clean up JPEG Library state */
LONGJMP(((OJPEGState *)cinfo)->exit_jmpbuf,1); /* Return to TIFF client */
}
static void
TIFFojpeg_output_message(register j_common_ptr cinfo)
{ char buffer[JMSG_LENGTH_MAX];
/* This subroutine is invoked only for warning messages, since the JPEG
Library's "error_exit" method does its own thing and "trace_level" is never
set > 0.
*/
(*cinfo->err->format_message)(cinfo,buffer);
TIFFWarning(JPEGLib_name,buffer);
}
/* The following subroutines, which also interface with the JPEG Library, exist
mainly in limit the side effects of "setjmp()" and convert JPEG normal/error
conditions into TIFF Library return codes.
*/
#define CALLJPEG(sp,fail,op)(SETJMP((sp)->exit_jmpbuf)?(fail):(op))
#define CALLVJPEG(sp,op)CALLJPEG(sp,0,((op),1))
#ifdef never
static int
TIFFojpeg_create_compress(register OJPEGState *sp)
{
sp->cinfo.c.err = jpeg_std_error(&sp->err); /* Initialize error handling */
sp->err.error_exit = TIFFojpeg_error_exit;
sp->err.output_message = TIFFojpeg_output_message;
return CALLVJPEG(sp,jpeg_create_compress(&sp->cinfo.c));
}
/* The following subroutines comprise a JPEG Library "destination" data manager
by directing compressed data from the JPEG Library to a TIFF Library output
buffer.
*/
static void
std_init_destination(register j_compress_ptr cinfo){} /* "Dummy" stub */
static boolean
std_empty_output_buffer(register j_compress_ptr cinfo)
{
# define sp ((OJPEGState *)cinfo)
register TIFF *tif = sp->tif;
tif->tif_rawcc = tif->tif_rawdatasize; /* Entire buffer has been filled */
TIFFFlushData1(tif);
sp->dest.next_output_byte = (JOCTET *)tif->tif_rawdata;
sp->dest.free_in_buffer = (size_t)tif->tif_rawdatasize;
return TRUE;
# undef sp
}
static void
std_term_destination(register j_compress_ptr cinfo)
{
# define sp ((OJPEGState *)cinfo)
register TIFF *tif = sp->tif;
/* NB: The TIFF Library does the final buffer flush. */
tif->tif_rawcp = (tidata_t)sp->dest.next_output_byte;
tif->tif_rawcc = tif->tif_rawdatasize - (tsize_t)sp->dest.free_in_buffer;
# undef sp
}
/* Alternate destination manager to output JPEGTables field: */
static void
tables_init_destination(register j_compress_ptr cinfo)
{
# define sp ((OJPEGState *)cinfo)
/* The "jpegtables_length" field is the allocated buffer size while building */
sp->dest.next_output_byte = (JOCTET *)sp->jpegtables;
sp->dest.free_in_buffer = (size_t)sp->jpegtables_length;
# undef sp
}
static boolean
tables_empty_output_buffer(register j_compress_ptr cinfo)
{ void *newbuf;
# define sp ((OJPEGState *)cinfo)
/* The entire buffer has been filled, so enlarge it by 1000 bytes. */
if (!( newbuf = _TIFFrealloc( (tdata_t)sp->jpegtables
, (tsize_t)(sp->jpegtables_length + 1000)
)
)
) ERREXIT1(cinfo,JERR_OUT_OF_MEMORY,100);
sp->dest.next_output_byte = (JOCTET *)newbuf + sp->jpegtables_length;
sp->dest.free_in_buffer = (size_t)1000;
sp->jpegtables = newbuf;
sp->jpegtables_length += 1000;
return TRUE;
# undef sp
}
static void
tables_term_destination(register j_compress_ptr cinfo)
{
# define sp ((OJPEGState *)cinfo)
/* Set tables length to no. of Bytes actually emitted. */
sp->jpegtables_length -= sp->dest.free_in_buffer;
# undef sp
}
/*ARGSUSED*/ static int
TIFFojpeg_tables_dest(register OJPEGState *sp, TIFF *tif)
{
/* Allocate a working buffer for building tables. The initial size is 1000
Bytes, which is usually adequate.
*/
if (sp->jpegtables) _TIFFfree(sp->jpegtables);
if (!(sp->jpegtables = (void*)
_TIFFmalloc((tsize_t)(sp->jpegtables_length = 1000))
)
)
{
sp->jpegtables_length = 0;
TIFFError("TIFFojpeg_tables_dest",no_jtable_space);
return 0;
};
sp->cinfo.c.dest = &sp->dest;
sp->dest.init_destination = tables_init_destination;
sp->dest.empty_output_buffer = tables_empty_output_buffer;
sp->dest.term_destination = tables_term_destination;
return 1;
}
#else /* well, hardly ever */
static int
_notSupported(register TIFF *tif)
{ const TIFFCodec *c = TIFFFindCODEC(tif->tif_dir.td_compression);
TIFFError(tif->tif_name,"%s compression not supported",c->name);
return 0;
}
#endif /* never */
/* The following subroutines comprise a JPEG Library "source" data manager by
by directing compressed data to the JPEG Library from a TIFF Library input
buffer.
*/
static void
std_init_source(register j_decompress_ptr cinfo)
{
# define sp ((OJPEGState *)cinfo)
register TIFF *tif = sp->tif;
if (sp->src.bytes_in_buffer == 0)
{
sp->src.next_input_byte = (const JOCTET *)tif->tif_rawdata;
sp->src.bytes_in_buffer = (size_t)tif->tif_rawcc;
};
# undef sp
}
static boolean
std_fill_input_buffer(register j_decompress_ptr cinfo)
{ static const JOCTET dummy_EOI[2]={0xFF,JPEG_EOI};
# define sp ((OJPEGState *)cinfo)
/* Control should never get here, since an entire strip/tile is read into
memory before the decompressor is called; thus, data should have been
supplied by the "init_source" method. ...But, sometimes things fail.
*/
WARNMS(cinfo,JWRN_JPEG_EOF);
sp->src.next_input_byte = dummy_EOI; /* Insert a fake EOI marker */
sp->src.bytes_in_buffer = sizeof dummy_EOI;
return TRUE;
# undef sp
}
static void
std_skip_input_data(register j_decompress_ptr cinfo, long num_bytes)
{
# define sp ((OJPEGState *)cinfo)
if (num_bytes > 0)
{
if (num_bytes > (long)sp->src.bytes_in_buffer) /* oops: buffer overrun */
(void)std_fill_input_buffer(cinfo);
else
{
sp->src.next_input_byte += (size_t)num_bytes;
sp->src.bytes_in_buffer -= (size_t)num_bytes;
}
}
# undef sp
}
/*ARGSUSED*/ static void
std_term_source(register j_decompress_ptr cinfo){} /* "Dummy" stub */
/* Allocate temporary I/O buffers for downsampled data, using values computed in
"jpeg_start_{de}compress()". We use the JPEG Library's allocator so that
buffers will be released automatically when done with a strip/tile. This is
also a handy place to compute samplesperclump, bytesperline, etc.
*/
static int
alloc_downsampled_buffers(TIFF *tif,jpeg_component_info *comp_info,
int num_components)
{ register OJPEGState *sp = OJState(tif);
sp->samplesperclump = 0;
if (num_components > 0)
{ tsize_t size = sp->cinfo.comm.is_decompressor
# ifdef D_LOSSLESS_SUPPORTED
? sp->cinfo.d.min_codec_data_unit
# else
? DCTSIZE
# endif
# ifdef C_LOSSLESS_SUPPORTED
: sp->cinfo.c.data_unit;
# else
: DCTSIZE;
# endif
int ci = 0;
register jpeg_component_info *compptr = comp_info;
do
{ JSAMPARRAY buf;
sp->samplesperclump +=
compptr->h_samp_factor * compptr->v_samp_factor;
# if defined(C_LOSSLESS_SUPPORTED) || defined(D_LOSSLESS_SUPPORTED)
if (!(buf = CALLJPEG(sp,0,(*sp->cinfo.comm.mem->alloc_sarray)(&sp->cinfo.comm,JPOOL_IMAGE,compptr->width_in_data_units*size,compptr->v_samp_factor*size))))
# else
if (!(buf = CALLJPEG(sp,0,(*sp->cinfo.comm.mem->alloc_sarray)(&sp->cinfo.comm,JPOOL_IMAGE,compptr->width_in_blocks*size,compptr->v_samp_factor*size))))
# endif
return 0;
sp->ds_buffer[ci] = buf;
}
while (++compptr,++ci < num_components);
};
return 1;
}
#ifdef never
/* JPEG Encoding begins here. */
/*ARGSUSED*/ static int
OJPEGEncode(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s)
{ tsize_t rows; /* No. of unprocessed rows in file */
register OJPEGState *sp = OJState(tif);
/* Encode a chunk of pixels, where returned data is NOT down-sampled (the
standard case). The data is expected to be written in scan-line multiples.
*/
if (cc % sp->bytesperline) TIFFWarning(tif->tif_name,no_write_frac);
if ( (cc /= bytesperline) /* No. of complete rows in caller's buffer */
> (rows = sp->cinfo.c.image_height - sp->cinfo.c.next_scanline)
) cc = rows;
while (--cc >= 0)
{
if ( CALLJPEG(sp,-1,jpeg_write_scanlines(&sp->cinfo.c,(JSAMPARRAY)&buf,1))
!= 1
) return 0;
++tif->tif_row;
buf += sp->bytesperline;
};
return 1;
}
/*ARGSUSED*/ static int
OJPEGEncodeRaw(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s)
{ tsize_t rows; /* No. of unprocessed rows in file */
JDIMENSION lines_per_MCU, size;
register OJPEGState *sp = OJState(tif);
/* Encode a chunk of pixels, where returned data is down-sampled as per the
sampling factors. The data is expected to be written in scan-line
multiples.
*/
cc /= sp->bytesperline;
if (cc % sp->bytesperline) TIFFWarning(tif->tif_name,no_write_frac);
if ( (cc /= bytesperline) /* No. of complete rows in caller's buffer */
> (rows = sp->cinfo.c.image_height - sp->cinfo.c.next_scanline)
) cc = rows;
# ifdef C_LOSSLESS_SUPPORTED
lines_per_MCU = sp->cinfo.c.max_samp_factor*(size = sp->cinfo.d.data_unit);
# else
lines_per_MCU = sp->cinfo.c.max_samp_factor*(size = DCTSIZE);
# endif
while (--cc >= 0)
{ int ci = 0, clumpoffset = 0;
register jpeg_component_info *compptr = sp->cinfo.c.comp_info;
/* The fastest way to separate the data is to make 1 pass over the scan
line for each row of each component.
*/
do
{ int ypos = 0;
do
{ int padding;
register JSAMPLE *inptr = (JSAMPLE*)buf + clumpoffset,
*outptr =
sp->ds_buffer[ci][sp->scancount*compptr->v_samp_factor+ypos];
/* Cb,Cr both have sampling factors 1, so this is correct */
register int clumps_per_line =
sp->cinfo.c.comp_info[1].downsampled_width,
xpos;
padding = (int)
# ifdef C_LOSSLESS_SUPPORTED
( compptr->width_in_data_units * size
# else
( compptr->width_in_blocks * size
# endif
- clumps_per_line * compptr->h_samp_factor
);
if (compptr->h_samp_factor == 1) /* Cb & Cr fast path */
do *outptr++ = *inptr;
while ((inptr += sp->samplesperclump),--clumps_per_line > 0);
else /* general case */
do
{
xpos = 0;
do *outptr++ = inptr[xpos];
while (++xpos < compptr->h_samp_factor);
}
while ((inptr += sp->samplesperclump),--clumps_per_line > 0);
xpos = 0; /* Pad each scan line as needed */
do outptr[0] = outptr[-1]; while (++outptr,++xpos < padding);
clumpoffset += compptr->h_samp_factor;
}
while (++ypos < compptr->v_samp_factor);
}
while (++compptr,++ci < sp->cinfo.c.num_components);
if (++sp->scancount >= size)
{
if ( CALLJPEG(sp,-1,jpeg_write_raw_data(&sp->cinfo.c,sp->ds_buffer,lines_per_MCU))
!= lines_per_MCU
) return 0;
sp->scancount = 0;
};
++tif->tif_row++
buf += sp->bytesperline;
};
return 1;
}
static int
OJPEGSetupEncode(register TIFF *tif)
{ static const char module[]={"OJPEGSetupEncode"};
uint32 segment_height, segment_width;
int status = 1; /* Assume success by default */
register OJPEGState *sp = OJState(tif);
# define td (&tif->tif_dir)
/* Verify miscellaneous parameters. This will need work if the TIFF Library
ever supports different depths for different components, or if the JPEG
Library ever supports run-time depth selection. Neither seems imminent.
*/
if (td->td_bitspersample != 8)
{
TIFFError(module,bad_bps,td->td_bitspersample);
status = 0;
};
/* The TIFF Version 6.0 specification and IJG JPEG Library accept different
sets of color spaces, so verify that our image belongs to the common subset
and map its photometry code, then initialize to handle subsampling and
optional JPEG Library YCbCr <-> RGB color-space conversion.
*/
switch (td->td_photometric)
{
case PHOTOMETRIC_YCBCR :
/* ISO IS 10918-1 requires that JPEG subsampling factors be 1-4, but
TIFF Version 6.0 is more restrictive: only 1, 2, and 4 are allowed.
*/
if ( ( td->td_ycbcrsubsampling[0] == 1
|| td->td_ycbcrsubsampling[0] == 2
|| td->td_ycbcrsubsampling[0] == 4
)
&& ( td->td_ycbcrsubsampling[1] == 1
|| td->td_ycbcrsubsampling[1] == 2
|| td->td_ycbcrsubsampling[1] == 4
)
)
sp->cinfo.c.raw_data_in =
( (sp->h_sampling = td->td_ycbcrsubsampling[0]) << 3
| (sp->v_sampling = td->td_ycbcrsubsampling[1])
) != 011;
else
{
TIFFError(module,bad_subsampling);
status = 0;
};
/* A ReferenceBlackWhite field MUST be present, since the default value
is inapproriate for YCbCr. Fill in the proper value if the
application didn't set it.
*/
if (!TIFFFieldSet(tif,FIELD_REFBLACKWHITE))
{ float refbw[6];
long top = 1L << td->td_bitspersample;
refbw[0] = 0;
refbw[1] = (float)(top-1L);
refbw[2] = (float)(top>>1);
refbw[3] = refbw[1];
refbw[4] = refbw[2];
refbw[5] = refbw[1];
TIFFSetField(tif,TIFFTAG_REFERENCEBLACKWHITE,refbw);
};
sp->cinfo.c.jpeg_color_space = JCS_YCbCr;
if (sp->jpegcolormode == JPEGCOLORMODE_RGB)
{
sp->cinfo.c.raw_data_in = FALSE;
sp->in_color_space = JCS_RGB;
break;
};
goto L2;
case PHOTOMETRIC_MINISBLACK:
sp->cinfo.c.jpeg_color_space = JCS_GRAYSCALE;
goto L1;
case PHOTOMETRIC_RGB :
sp->cinfo.c.jpeg_color_space = JCS_RGB;
goto L1;
case PHOTOMETRIC_SEPARATED :
sp->cinfo.c.jpeg_color_space = JCS_CMYK;
L1: sp->jpegcolormode = JPEGCOLORMODE_RAW; /* No JPEG Lib. conversion */
L2: sp->cinfo.d.in_color_space = sp->cinfo.d.jpeg_color-space;
break;
default :
TIFFError(module,bad_photometry,td->td_photometric);
status = 0;
};
tif->tif_encoderow = tif->tif_encodestrip = tif->tif_encodetile =
sp->cinfo.c.raw_data_in ? OJPEGEncodeRaw : OJPEGEncode;
if (isTiled(tif))
{ tsize_t size;
# ifdef C_LOSSLESS_SUPPORTED
if ((size = sp->v_sampling*sp->cinfo.c.data_unit) < 16) size = 16;
# else
if ((size = sp->v_sampling*DCTSIZE) < 16) size = 16;
# endif
if ((segment_height = td->td_tilelength) % size)
{
TIFFError(module,"JPEG tile height must be multiple of %d",size);
status = 0;
};
# ifdef C_LOSSLESS_SUPPORTED
if ((size = sp->h_sampling*sp->cinfo.c.data_unit) < 16) size = 16;
# else
if ((size = sp->h_sampling*DCTSIZE) < 16) size = 16;
# endif
if ((segment_width = td->td_tilewidth) % size)
{
TIFFError(module,"JPEG tile width must be multiple of %d",size);
status = 0;
};
sp->bytesperline = TIFFTileRowSize(tif);
}
else
{ tsize_t size;
# ifdef C_LOSSLESS_SUPPORTED
if ((size = sp->v_sampling*sp->cinfo.c.data_unit) < 16) size = 16;
# else
if ((size = sp->v_sampling*DCTSIZE) < 16) size = 16;
# endif
if (td->td_rowsperstrip < (segment_height = td->td_imagelength))
{
if (td->td_rowsperstrip % size)
{
TIFFError(module,"JPEG RowsPerStrip must be multiple of %d",size);
status = 0;
};
segment_height = td->td_rowsperstrip;
};
segment_width = td->td_imagewidth;
sp->bytesperline = tif->tif_scanlinesize;
};
if (segment_width > 65535 || segment_height > 65535)
{
TIFFError(module,"Strip/tile too large for JPEG");
status = 0;
};
/* Initialize all JPEG parameters to default values. Note that the JPEG
Library's "jpeg_set_defaults()" method needs legal values for the
"in_color_space" and "input_components" fields.
*/
sp->cinfo.c.input_components = 1; /* Default for JCS_UNKNOWN */
if (!CALLVJPEG(sp,jpeg_set_defaults(&sp->cinfo.c))) status = 0;
switch (sp->jpegtablesmode & (JPEGTABLESMODE_HUFF|JPEGTABLESMODE_QUANT))
{ register JHUFF_TBL *htbl;
register JQUANT_TBL *qtbl;
case 0 :
sp->cinfo.c.optimize_coding = TRUE;
case JPEGTABLESMODE_HUFF :
if (!CALLVJPEG(sp,jpeg_set_quality(&sp->cinfo.c,sp->jpegquality,FALSE)))
return 0;
if (qtbl = sp->cinfo.c.quant_tbl_ptrs[0]) qtbl->sent_table = FALSE;
if (qtbl = sp->cinfo.c.quant_tbl_ptrs[1]) qtbl->sent_table = FALSE;
goto L3;
case JPEGTABLESMODE_QUANT :
sp->cinfo.c.optimize_coding = TRUE;
/* We do not support application-supplied JPEG tables, so mark the field
"not present".
*/
L3: TIFFClrFieldBit(tif,FIELD_JPEGTABLES);
break;
case JPEGTABLESMODE_HUFF|JPEGTABLESMODE_QUANT:
if ( !CALLVJPEG(sp,jpeg_set_quality(&sp->cinfo.c,sp->jpegquality,FALSE))
|| !CALLVJPEG(sp,jpeg_suppress_tables(&sp->cinfo.c,TRUE))
)
{
status = 0;
break;
};
if (qtbl = sp->cinfo.c.quant_tbl_ptrs[0]) qtbl->sent_table = FALSE;
if (htbl = sp->cinfo.c.dc_huff_tbl_ptrs[0]) htbl->sent_table = FALSE;
if (htbl = sp->cinfo.c.ac_huff_tbl_ptrs[0]) htbl->sent_table = FALSE;
if (sp->cinfo.c.jpeg_color_space == JCS_YCbCr)
{
if (qtbl = sp->cinfo.c.quant_tbl_ptrs[1])
qtbl->sent_table = FALSE;
if (htbl = sp->cinfo.c.dc_huff_tbl_ptrs[1])
htbl->sent_table = FALSE;
if (htbl = sp->cinfo.c.ac_huff_tbl_ptrs[1])
htbl->sent_table = FALSE;
};
if ( TIFFojpeg_tables_dest(sp,tif)
&& CALLVJPEG(sp,jpeg_write_tables(&sp->cinfo.c))
)
{
/* Mark the field "present". We can't use "TIFFSetField()" because
"BEENWRITING" is already set!
*/
TIFFSetFieldBit(tif,FIELD_JPEGTABLES);
tif->tif_flags |= TIFF_DIRTYDIRECT;
}
else status = 0;
};
if ( sp->cinfo.c.raw_data_in
&& !alloc_downsampled_buffers(tif,sp->cinfo.c.comp_info,
sp->cinfo.c.num_components)
) status = 0;
if (status == 0) return 0; /* If TIFF errors, don't bother to continue */
/* Grab parameters that are same for all strips/tiles. */
sp->dest.init_destination = std_init_destination;
sp->dest.empty_output_buffer = std_empty_output_buffer;
sp->dest.term_destination = std_term_destination;
sp->cinfo.c.dest = &sp->dest;
sp->cinfo.c.data_precision = td->td_bitspersample;
sp->cinfo.c.write_JFIF_header = /* Don't write extraneous markers */
sp->cinfo.c.write_Adobe_marker = FALSE;
sp->cinfo.c.image_width = segment_width;
sp->cinfo.c.image_height = segment_height;
sp->cinfo.c.comp_info[0].h_samp_factor =
sp->cinfo.c.comp_info[0].v_samp_factor = 1;
return CALLVJPEG(sp,jpeg_start_compress(&sp->cinfo.c,FALSE));
# undef td
}
static int
OJPEGPreEncode(register TIFF *tif,tsample_t s)
{ register OJPEGState *sp = OJState(tif);
# define td (&tif->tif_dir)
/* If we are about to write the first row of an image plane, which should
coincide with a JPEG "scan", reset the JPEG Library's compressor. Otherwise
let the compressor run "as is" and return a "success" status without further
ado.
*/
if ( (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip)
% td->td_stripsperimage
== 0
)
{
if ( (sp->cinfo.c.comp_info[0].component_id = s) == 1)
&& sp->cinfo.c.jpeg_color_space == JCS_YCbCr
)
{
sp->cinfo.c.comp_info[0].quant_tbl_no =
sp->cinfo.c.comp_info[0].dc_tbl_no =
sp->cinfo.c.comp_info[0].ac_tbl_no = 1;
sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling;
sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling;
/* Scale expected strip/tile size to match a downsampled component. */
sp->cinfo.c.image_width = TIFFhowmany(segment_width,sp->h_sampling);
sp->cinfo.c.image_height=TIFFhowmany(segment_height,sp->v_sampling);
};
sp->scancount = 0; /* Mark subsampling buffer(s) empty */
};
return 1;
# undef td
}
static int
OJPEGPostEncode(register TIFF *tif)
{ register OJPEGState *sp = OJState(tif);
/* Finish up at the end of a strip or tile. */
if (sp->scancount > 0) /* emit partial buffer of down-sampled data */
{ JDIMENSION n;
# ifdef C_LOSSLESS_SUPPORTED
if ( sp->scancount < sp->cinfo.c.data_unit
&& sp->cinfo.c.num_components > 0
)
# else
if (sp->scancount < DCTSIZE && sp->cinfo.c.num_components > 0)
# endif
{ int ci = 0, /* Pad the data vertically */
# ifdef C_LOSSLESS_SUPPORTED
size = sp->cinfo.c.data_unit;
# else
size = DCTSIZE;
# endif
register jpeg_component_info *compptr = sp->cinfo.c.comp_info;
do
# ifdef C_LOSSLESS_SUPPORTED
{ tsize_t row_width = compptr->width_in_data_units
# else
tsize_t row_width = compptr->width_in_blocks
# endif
*size*sizeof(JSAMPLE);
int ypos = sp->scancount*compptr->v_samp_factor;
do _TIFFmemcpy( (tdata_t)sp->ds_buffer[ci][ypos]
, (tdata_t)sp->ds_buffer[ci][ypos-1]
, row_width
);
while (++ypos < compptr->v_samp_factor*size);
}
while (++compptr,++ci < sp->cinfo.c.num_components);
};
n = sp->cinfo.c.max_v_samp_factor*size;
if (CALLJPEG(sp,-1,jpeg_write_raw_data(&sp->cinfo.c,sp->ds_buffer,n)) != n)
return 0;
};
return CALLVJPEG(sp,jpeg_finish_compress(&sp->cinfo.c));
}
#endif /* never */
/* JPEG Decoding begins here. */
/*ARGSUSED*/ static int
OJPEGDecode(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s)
{ tsize_t bytesperline = isTiled(tif)
? TIFFTileRowSize(tif)
: tif->tif_scanlinesize,
rows; /* No. of unprocessed rows in file */
register OJPEGState *sp = OJState(tif);
/* Decode a chunk of pixels, where the input data has not NOT been down-
sampled, or else the TIFF Library's client has used the "JPEGColorMode" TIFF
pseudo-tag to request that the JPEG Library do color-space conversion; this
is the normal case. The data is expected to be read in scan-line multiples,
and this subroutine is called for both pixel-interleaved and separate color
planes.
WARNING: Unlike "OJPEGDecodeRawContig()", below, the no. of Bytes in each
decoded row is calculated here as "bytesperline" instead of
using "sp->bytesperline", which might be a little smaller. This can
occur for an old tiled image whose width isn't a multiple of 8 pixels.
That's illegal according to the TIFF Version 6 specification, but some
test files, like "zackthecat.tif", were built that way. In those cases,
we want to embed the image's true width in our caller's buffer (which is
presumably allocated according to the expected tile width) by
effectively "padding" it with unused Bytes at the end of each row.
*/
if ( (cc /= bytesperline) /* No. of complete rows in caller's buffer */
> (rows = sp->cinfo.d.output_height - sp->cinfo.d.output_scanline)
) cc = rows;
while (--cc >= 0)
{
if ( CALLJPEG(sp,-1,jpeg_read_scanlines(&sp->cinfo.d,(JSAMPARRAY)&buf,1))
!= 1
) return 0;
buf += bytesperline;
++tif->tif_row;
};
/* BEWARE OF KLUDGE: If our input file was produced by Microsoft's Wang
Imaging for Windows application, the DC coefficients of
each JPEG image component (Y,Cb,Cr) must be reset at the end of each TIFF
"strip", and any JPEG data bits remaining in the current Byte of the
decoder's input buffer must be discarded. To do so, we create an "ad hoc"
interface in the "jdhuff.c" module of IJG JPEG Library Version 6 (module
"jdshuff.c", if Ken Murchison's lossless-Huffman patch is applied), and we
invoke that interface here after decoding each "strip".
*/
if (sp->is_WANG) jpeg_reset_huff_decode(&sp->cinfo.d);
return 1;
}
/*ARGSUSED*/ static int
OJPEGDecodeRawContig(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s)
{ tsize_t rows; /* No. of unprocessed rows in file */
JDIMENSION lines_per_MCU, size;
register OJPEGState *sp = OJState(tif);
/* Decode a chunk of pixels, where the input data has pixel-interleaved color
planes, some of which have been down-sampled, but the TIFF Library's client
has NOT used the "JPEGColorMode" TIFF pseudo-tag to request that the JPEG
Library do color-space conversion. In other words, we must up-sample/
expand/duplicate image components according to the image's sampling factors,
without changing its color space. The data is expected to be read in scan-
line multiples.
*/
if ( (cc /= sp->bytesperline) /* No. of complete rows in caller's buffer */
> (rows = sp->cinfo.d.output_height - sp->cinfo.d.output_scanline)
) cc = rows;
lines_per_MCU = sp->cinfo.d.max_v_samp_factor
# ifdef D_LOSSLESS_SUPPORTED
* (size = sp->cinfo.d.min_codec_data_unit);
# else
* (size = DCTSIZE);
# endif
while (--cc >= 0)
{ int clumpoffset, ci;
register jpeg_component_info *compptr;
if (sp->scancount >= size) /* reload downsampled-data buffers */
{
if ( CALLJPEG(sp,-1,jpeg_read_raw_data(&sp->cinfo.d,sp->ds_buffer,lines_per_MCU))
!= lines_per_MCU
) return 0;
sp->scancount = 0;
};
/* The fastest way to separate the data is: make 1 pass over the scan
line for each row of each component.
*/
clumpoffset = ci = 0;
compptr = sp->cinfo.d.comp_info;
do
{ int ypos = 0;
if (compptr->h_samp_factor == 1) /* fast path */
do
{ register JSAMPLE *inptr =
sp->ds_buffer[ci][sp->scancount*compptr->v_samp_factor+ypos],
*outptr = (JSAMPLE *)buf + clumpoffset;
register int clumps_per_line = compptr->downsampled_width;
do *outptr = *inptr++;
while ((outptr += sp->samplesperclump),--clumps_per_line > 0);
}
while ( (clumpoffset += compptr->h_samp_factor)
, ++ypos < compptr->v_samp_factor
);
else /* general case */
do
{ register JSAMPLE *inptr =
sp->ds_buffer[ci][sp->scancount*compptr->v_samp_factor+ypos],
*outptr = (JSAMPLE *)buf + clumpoffset;
register int clumps_per_line = compptr->downsampled_width;
do
{ register int xpos = 0;
do outptr[xpos] = *inptr++;
while (++xpos < compptr->h_samp_factor);
}
while ((outptr += sp->samplesperclump),--clumps_per_line > 0);
}
while ( (clumpoffset += compptr->h_samp_factor)
, ++ypos < compptr->v_samp_factor
);
}
while (++compptr,++ci < sp->cinfo.d.num_components);
++sp->scancount;
buf += sp->bytesperline;
++tif->tif_row;
};
/* BEWARE OF KLUDGE: If our input file was produced by Microsoft's Wang
Imaging for Windows application, the DC coefficients of
each JPEG image component (Y,Cb,Cr) must be reset at the end of each TIFF
"strip", and any JPEG data bits remaining in the current Byte of the
decoder's input buffer must be discarded. To do so, we create an "ad hoc"
interface in the "jdhuff.c" module of IJG JPEG Library Version 6 (module
"jdshuff.c", if Ken Murchison's lossless-Huffman patch is applied), and we
invoke that interface here after decoding each "strip".
*/
if (sp->is_WANG) jpeg_reset_huff_decode(&sp->cinfo.d);
return 1;
}
/*ARGSUSED*/ static int
OJPEGDecodeRawSeparate(TIFF *tif,register tidata_t buf,tsize_t cc,tsample_t s)
{ tsize_t rows; /* No. of unprocessed rows in file */
JDIMENSION lines_per_MCU,
size, /* ...of MCU */
v; /* Component's vertical up-sampling ratio */
register OJPEGState *sp = OJState(tif);
register jpeg_component_info *compptr = sp->cinfo.d.comp_info + s;
/* Decode a chunk of pixels, where the input data has separate color planes,
some of which have been down-sampled, but the TIFF Library's client has NOT
used the "JPEGColorMode" TIFF pseudo-tag to request that the JPEG Library
do color-space conversion. The data is expected to be read in scan-line
multiples.
*/
v = sp->cinfo.d.max_v_samp_factor/compptr->v_samp_factor;
if ( (cc /= compptr->downsampled_width) /* No. of rows in caller's buffer */
> (rows = (sp->cinfo.d.output_height-sp->cinfo.d.output_scanline+v-1)/v)
) cc = rows; /* No. of rows of "clumps" to read */
lines_per_MCU = sp->cinfo.d.max_v_samp_factor
# ifdef D_LOSSLESS_SUPPORTED
* (size = sp->cinfo.d.min_codec_data_unit);
# else
* (size = DCTSIZE);
# endif
L: if (sp->scancount >= size) /* reload downsampled-data buffers */
{
if ( CALLJPEG(sp,-1,jpeg_read_raw_data(&sp->cinfo.d,sp->ds_buffer,lines_per_MCU))
!= lines_per_MCU
) return 0;
sp->scancount = 0;
};
rows = 0;
do
{ register JSAMPLE *inptr =
sp->ds_buffer[s][sp->scancount*compptr->v_samp_factor + rows];
register int clumps_per_line = compptr->downsampled_width;
do *buf++ = *inptr++; while (--clumps_per_line > 0); /* Copy scanline */
tif->tif_row += v;
if (--cc <= 0) return 1; /* End of caller's buffer? */
}
while (++rows < compptr->v_samp_factor);
++sp->scancount;
goto L;
}
/* "OJPEGSetupDecode()" temporarily forces the JPEG Library to use the following
subroutine as a "dummy" input reader in order to fool the library into
thinking that it has read the image's first "Start of Scan" (SOS) marker, so
that it initializes accordingly.
*/
/*ARGSUSED*/ METHODDEF(int)
fake_SOS_marker(j_decompress_ptr cinfo){return JPEG_REACHED_SOS;}
/*ARGSUSED*/ METHODDEF(int)
suspend(j_decompress_ptr cinfo){return JPEG_SUSPENDED;}
/* The JPEG Library's "null" color-space converter actually re-packs separate
color planes (it's native image representation) into a pixel-interleaved,
contiguous plane. But if our TIFF Library client is tryng to process a
PLANARCONFIG_SEPARATE image, we don't want that; so here are modifications of
code in the JPEG Library's "jdcolor.c" file, which simply copy Bytes to a
color plane specified by the current JPEG "scan".
*/
METHODDEF(void)
ycc_rgb_convert(register j_decompress_ptr cinfo,JSAMPIMAGE in,JDIMENSION row,
register JSAMPARRAY out,register int nrows)
{ typedef struct /* "jdcolor.c" color-space conversion state */
{
/* WARNING: This declaration is ugly and dangerous! It's supposed to be
private to the JPEG Library's "jdcolor.c" module, but we also
need it here. Since the library's copy might change without notice, be
sure to keep this one synchronized or the following code will break!
*/
struct jpeg_color_deconverter pub; /* Public fields */
/* Private state for YCC->RGB conversion */
int *Cr_r_tab, /* ->Cr to R conversion table */
*Cb_b_tab; /* ->Cb to B conversion table */
INT32 *Cr_g_tab, /* ->Cr to G conversion table */
*Cb_g_tab; /* ->Cb to G conversion table */
} *my_cconvert_ptr;
my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
JSAMPARRAY irow0p = in[0] + row;
register JSAMPLE *range_limit = cinfo->sample_range_limit;
register JSAMPROW outp, Y;
switch (cinfo->output_scan_number - 1)
{ JSAMPARRAY irow1p, irow2p;
register INT32 *table0, *table1;
SHIFT_TEMPS
case RGB_RED : irow2p = in[2] + row;
table0 = (INT32 *)cconvert->Cr_r_tab;
while (--nrows >= 0)
{ register JSAMPROW Cr = *irow2p++;
register int i = cinfo->output_width;
Y = *irow0p++;
outp = *out++;
while (--i >= 0)
*outp++ = range_limit[*Y++ + table0[*Cr++]];
};
return;
case RGB_GREEN: irow1p = in[1] + row;
irow2p = in[2] + row;
table0 = cconvert->Cb_g_tab;
table1 = cconvert->Cr_g_tab;
while (--nrows >= 0)
{ register JSAMPROW Cb = *irow1p++,
Cr = *irow2p++;
register int i = cinfo->output_width;
Y = *irow0p++;
outp = *out++;
while (--i >= 0)
*outp++ =
range_limit[ *Y++
+ RIGHT_SHIFT(table0[*Cb++]+table1[*Cr++],16)
];
};
return;
case RGB_BLUE : irow1p = in[1] + row;
table0 = (INT32 *)cconvert->Cb_b_tab;
while (--nrows >= 0)
{ register JSAMPROW Cb = *irow1p++;
register int i = cinfo->output_width;
Y = *irow0p++;
outp = *out++;
while (--i >= 0)
*outp++ = range_limit[*Y++ + table0[*Cb++]];
}
}
}
METHODDEF(void)
null_convert(register j_decompress_ptr cinfo,JSAMPIMAGE in,JDIMENSION row,
register JSAMPARRAY out,register int nrows)
{ register JSAMPARRAY irowp = in[cinfo->output_scan_number - 1] + row;
while (--nrows >= 0) _TIFFmemcpy(*out++,*irowp++,cinfo->output_width);
}
static int
OJPEGSetupDecode(register TIFF *tif)
{ static char module[]={"OJPEGSetupDecode"};
J_COLOR_SPACE jpeg_color_space, /* Color space of JPEG-compressed image */
out_color_space; /* Color space of decompressed image */
uint32 segment_width;
int status = 1; /* Assume success by default */
boolean downsampled_output=FALSE, /* <=> Want JPEG Library's "raw" image? */
is_JFIF; /* <=> JFIF image? */
register OJPEGState *sp = OJState(tif);
# define td (&tif->tif_dir)
/* Verify miscellaneous parameters. This will need work if the TIFF Library
ever supports different depths for different components, or if the JPEG
Library ever supports run-time depth selection. Neither seems imminent.
*/
if (td->td_bitspersample != sp->cinfo.d.data_precision)
{
TIFFError(module,bad_bps,td->td_bitspersample);
status = 0;
};
/* The TIFF Version 6.0 specification and IJG JPEG Library accept different
sets of color spaces, so verify that our image belongs to the common subset
and map its photometry code, then initialize to handle subsampling and
optional JPEG Library YCbCr <-> RGB color-space conversion.
*/
switch (td->td_photometric)
{
case PHOTOMETRIC_YCBCR :
/* ISO IS 10918-1 requires that JPEG subsampling factors be 1-4, but
TIFF Version 6.0 is more restrictive: only 1, 2, and 4 are allowed.
*/
if ( ( td->td_ycbcrsubsampling[0] == 1
|| td->td_ycbcrsubsampling[0] == 2
|| td->td_ycbcrsubsampling[0] == 4
)
&& ( td->td_ycbcrsubsampling[1] == 1
|| td->td_ycbcrsubsampling[1] == 2
|| td->td_ycbcrsubsampling[1] == 4
)
)
downsampled_output =
(
(sp->h_sampling = td->td_ycbcrsubsampling[0]) << 3
| (sp->v_sampling = td->td_ycbcrsubsampling[1])
) != 011;
else
{
TIFFError(module,bad_subsampling);
status = 0;
};
jpeg_color_space = JCS_YCbCr;
if (sp->jpegcolormode == JPEGCOLORMODE_RGB)
{
downsampled_output = FALSE;
out_color_space = JCS_RGB;
break;
};
goto L2;
case PHOTOMETRIC_MINISBLACK:
jpeg_color_space = JCS_GRAYSCALE;
goto L1;
case PHOTOMETRIC_RGB :
jpeg_color_space = JCS_RGB;
goto L1;
case PHOTOMETRIC_SEPARATED :
jpeg_color_space = JCS_CMYK;
L1: sp->jpegcolormode = JPEGCOLORMODE_RAW; /* No JPEG Lib. conversion */
L2: out_color_space = jpeg_color_space;
break;
default :
TIFFError(module,bad_photometry,td->td_photometric);
status = 0;
};
if (status == 0) return 0; /* If TIFF errors, don't bother to continue */
/* Set parameters that are same for all strips/tiles. */
sp->cinfo.d.src = &sp->src;
sp->src.init_source = std_init_source;
sp->src.fill_input_buffer = std_fill_input_buffer;
sp->src.skip_input_data = std_skip_input_data;
sp->src.resync_to_restart = jpeg_resync_to_restart;
sp->src.term_source = std_term_source;
/* BOGOSITY ALERT! The Wang Imaging application for Microsoft Windows produces
images containing "JPEGInterchangeFormat[Length]" TIFF
records that resemble JFIF-in-TIFF encapsulations but, in fact, violate the
TIFF Version 6 specification in several ways; nevertheless, we try to handle
them gracefully because there are apparently a lot of them around. The
purported "JFIF" data stream in one of these files vaguely resembles a JPEG
"tables only" data stream, except that there's no trailing EOI marker. The
rest of the JPEG data stream lies in a discontiguous file region, identified
by the 0th Strip offset (which is *also* illegal!), where it begins with an
SOS marker and apparently continues to the end of the file. There is no
trailing EOI marker here, either.
*/
is_JFIF = !sp->is_WANG && TIFFFieldSet(tif,FIELD_JPEGIFOFFSET);
/* Initialize decompression parameters that won't be overridden by JPEG Library
defaults set during the "jpeg_read_header()" call, below.
*/
segment_width = td->td_imagewidth;
if (isTiled(tif))
{
if (sp->is_WANG) /* we don't know how to handle it */
{
TIFFError(module,"Tiled Wang image not supported");
return 0;
};
/* BOGOSITY ALERT! "TIFFTileRowSize()" seems to work fine for modern JPEG-
in-TIFF encapsulations where the image width--like the
tile width--is a multiple of 8 or 16 pixels. But image widths and
heights are aren't restricted to 8- or 16-bit multiples, and we need
the exact Byte count of decompressed scan lines when we call the JPEG
Library. At least one old file ("zackthecat.tif") in the TIFF Library
test suite has widths and heights slightly less than the tile sizes, and
it apparently used the bogus computation below to determine the number
of Bytes per scan line (was this due to an old, broken version of
"TIFFhowmany()"?). Before we get here, "OJPEGSetupDecode()" verified
that our image uses 8-bit samples, so the following check appears to
return the correct answer in all known cases tested to date.
*/
if (is_JFIF || (segment_width & 7) == 0)
sp->bytesperline = TIFFTileRowSize(tif); /* Normal case */
else
{
/* Was the file-encoder's segment-width calculation bogus? */
segment_width = (segment_width/sp->h_sampling + 1) * sp->h_sampling;
sp->bytesperline = segment_width * td->td_samplesperpixel;
}
}
else sp->bytesperline = TIFFVStripSize(tif,1);
/* BEWARE OF KLUDGE: If we have JPEG Interchange File Format (JFIF) image,
then we want to read "metadata" in the bit-stream's
header and validate it against corresponding information in TIFF records.
But if we have a *really old* JPEG file that's not JFIF, then we simply
assign TIFF-record values to JPEG Library variables without checking.
*/
if (is_JFIF) /* JFIF image */
{ unsigned char *end_of_data;
int subsampling_factors;
register unsigned char *p;
register int i;
/* WARNING: Although the image file contains a JFIF bit stream, it might
also contain some old TIFF records causing "OJPEGVSetField()"
to have allocated quantization or Huffman decoding tables. But when the
JPEG Library reads and parses the JFIF header below, it reallocate these
tables anew without checking for "dangling" pointers, thereby causing a
memory "leak". We have enough information to potentially deallocate the
old tables here, but unfortunately JPEG Library Version 6B uses a "pool"
allocator for small objects, with no deallocation procedure; instead, it
reclaims a whole pool when an image is closed/destroyed, so well-behaved
TIFF client applications (i.e., those which close their JPEG images as
soon as they're no longer needed) will waste memory for a short time but
recover it eventually. But ill-behaved TIFF clients (i.e., those which
keep many JPEG images open gratuitously) can exhaust memory prematurely.
If the JPEG Library ever implements a deallocation procedure, insert
this clean-up code:
*/
# ifdef someday
if (sp->jpegtablesmode & JPEGTABLESMODE_QUANT) /* free quant. tables */
{ register int i = 0;
do
{ register JQUANT_TBL *q;
if (q = sp->cinfo.d.quant_tbl_ptrs[i])
{
jpeg_free_small(&sp->cinfo.comm,q,sizeof *q);
sp->cinfo.d.quant_tbl_ptrs[i] = 0;
}
}
while (++i < NUM_QUANT_TBLS);
};
if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF) /* free Huffman tables */
{ register int i = 0;
do
{ register JHUFF_TBL *h;
if (h = sp->cinfo.d.dc_huff_tbl_ptrs[i])
{
jpeg_free_small(&sp->cinfo.comm,h,sizeof *h);
sp->cinfo.d.dc_huff_tbl_ptrs[i] = 0;
};
if (h = sp->cinfo.d.ac_huff_tbl_ptrs[i])
{
jpeg_free_small(&sp->cinfo.comm,h,sizeof *h);
sp->cinfo.d.ac_huff_tbl_ptrs[i] = 0;
}
}
while (++i < NUM_HUFF_TBLS);
};
# endif /* someday */
/* Since we might someday wish to try rewriting "old format" JPEG-in-TIFF
encapsulations in "new format" files, try to synthesize the value of a
modern "JPEGTables" TIFF record by scanning the JPEG data from just past
the "Start of Information" (SOI) marker until something other than a
legitimate "table" marker is found, as defined in ISO IS 10918-1
Appending B.2.4; namely:
-- Define Quantization Table (DQT)
-- Define Huffman Table (DHT)
-- Define Arithmetic Coding table (DAC)
-- Define Restart Interval (DRI)
-- Comment (COM)
-- Application data (APPn)
For convenience, we also accept "Expansion" (EXP) markers, although they
are apparently not a part of normal "table" data.
*/
sp->jpegtables = p = (unsigned char *)sp->src.next_input_byte;
end_of_data = p + sp->src.bytes_in_buffer;
p += 2;
while (p < end_of_data && p[0] == 0xFF)
switch (p[1])
{
default : goto L;
case 0xC0: /* SOF0 */
case 0xC1: /* SOF1 */
case 0xC2: /* SOF2 */
case 0xC3: /* SOF3 */
case 0xC4: /* DHT */
case 0xC5: /* SOF5 */
case 0xC6: /* SOF6 */
case 0xC7: /* SOF7 */
case 0xC9: /* SOF9 */
case 0xCA: /* SOF10 */
case 0xCB: /* SOF11 */
case 0xCC: /* DAC */
case 0xCD: /* SOF13 */
case 0xCE: /* SOF14 */
case 0xCF: /* SOF15 */
case 0xDB: /* DQT */
case 0xDD: /* DRI */
case 0xDF: /* EXP */
case 0xE0: /* APP0 */
case 0xE1: /* APP1 */
case 0xE2: /* APP2 */
case 0xE3: /* APP3 */
case 0xE4: /* APP4 */
case 0xE5: /* APP5 */
case 0xE6: /* APP6 */
case 0xE7: /* APP7 */
case 0xE8: /* APP8 */
case 0xE9: /* APP9 */
case 0xEA: /* APP10 */
case 0xEB: /* APP11 */
case 0xEC: /* APP12 */
case 0xED: /* APP13 */
case 0xEE: /* APP14 */
case 0xEF: /* APP15 */
case 0xFE: /* COM */
p += (p[2] << 8 | p[3]) + 2;
};
L: if (p - (unsigned char *)sp->jpegtables > 2) /* fake "JPEGTables" */
{
/* In case our client application asks, pretend that this image file
contains a modern "JPEGTables" TIFF record by copying to a buffer
the initial part of the JFIF bit-stream that we just scanned, from
the SOI marker through the "metadata" tables, then append an EOI
marker and flag the "JPEGTables" TIFF record as "present".
*/
sp->jpegtables_length = p - (unsigned char*)sp->jpegtables + 2;
p = sp->jpegtables;
if (!(sp->jpegtables = _TIFFmalloc(sp->jpegtables_length)))
{
TIFFError(module,no_jtable_space);
return 0;
};
_TIFFmemcpy(sp->jpegtables,p,sp->jpegtables_length-2);
p = (unsigned char *)sp->jpegtables + sp->jpegtables_length;
p[-2] = 0xFF; p[-1] = JPEG_EOI; /* Append EOI marker */
TIFFSetFieldBit(tif,FIELD_JPEGTABLES);
tif->tif_flags |= TIFF_DIRTYDIRECT;
}
else sp->jpegtables = 0; /* Don't simulate "JPEGTables" */
if ( CALLJPEG(sp,-1,jpeg_read_header(&sp->cinfo.d,TRUE))
!= JPEG_HEADER_OK
) return 0;
if ( sp->cinfo.d.image_width != segment_width
|| sp->cinfo.d.image_height != td->td_imagelength
)
{
TIFFError(module,"Improper JPEG strip/tile size");
return 0;
};
if (sp->cinfo.d.num_components != td->td_samplesperpixel)
{
TIFFError(module,"Improper JPEG component count");
return 0;
};
if (sp->cinfo.d.data_precision != td->td_bitspersample)
{
TIFFError(module,"Improper JPEG data precision");
return 0;
};
/* Check that JPEG image components all have the same subsampling factors
declared (or defaulted) in the TIFF file, since TIFF Version 6.0 is more
restrictive than JPEG: Only the 0th component may have horizontal and
vertical subsampling factors other than <1,1>.
*/
subsampling_factors = sp->h_sampling << 3 | sp->v_sampling;
i = 0;
do
{
if ( ( sp->cinfo.d.comp_info[i].h_samp_factor << 3
| sp->cinfo.d.comp_info[i].v_samp_factor
)
!= subsampling_factors
)
{
TIFFError(module,"Improper JPEG subsampling factors");
return 0;
};
subsampling_factors = 011; /* Required for image components > 0 */
}
while (++i < sp->cinfo.d.num_components);
}
else /* not JFIF image */
{ int (*save)(j_decompress_ptr cinfo) = sp->cinfo.d.marker->read_markers;
register int i;
/* We're not assuming that this file's JPEG bit stream has any header
"metadata", so fool the JPEG Library into thinking that we read a
"Start of Input" (SOI) marker and a "Start of Frame" (SOFx) marker, then
force it to read a simulated "Start of Scan" (SOS) marker when we call
"jpeg_read_header()" below. This should cause the JPEG Library to
establish reasonable defaults.
*/
sp->cinfo.d.marker->saw_SOI = /* Pretend we saw SOI marker */
sp->cinfo.d.marker->saw_SOF = TRUE; /* Pretend we saw SOF marker */
sp->cinfo.d.marker->read_markers =
sp->is_WANG ? suspend : fake_SOS_marker;
sp->cinfo.d.global_state = DSTATE_INHEADER;
sp->cinfo.d.Se = DCTSIZE2-1; /* Suppress JPEG Library warning */
sp->cinfo.d.image_width = segment_width;
sp->cinfo.d.image_height = td->td_imagelength;
/* The following color-space initialization, including the complicated
"switch"-statement below, essentially duplicates the logic used by the
JPEG Library's "jpeg_init_colorspace()" subroutine during compression.
*/
sp->cinfo.d.num_components = td->td_samplesperpixel;
sp->cinfo.d.comp_info = (jpeg_component_info *)
(*sp->cinfo.d.mem->alloc_small)
( &sp->cinfo.comm
, JPOOL_IMAGE
, sp->cinfo.d.num_components * sizeof *sp->cinfo.d.comp_info
);
i = 0;
do
{
sp->cinfo.d.comp_info[i].component_index = i;
sp->cinfo.d.comp_info[i].component_needed = TRUE;
sp->cinfo.d.cur_comp_info[i] = &sp->cinfo.d.comp_info[i];
}
while (++i < sp->cinfo.d.num_components);
switch (jpeg_color_space)
{
case JCS_UNKNOWN :
i = 0;
do
{
sp->cinfo.d.comp_info[i].component_id = i;
sp->cinfo.d.comp_info[i].h_samp_factor =
sp->cinfo.d.comp_info[i].v_samp_factor = 1;
}
while (++i < sp->cinfo.d.num_components);
break;
case JCS_GRAYSCALE:
sp->cinfo.d.comp_info[0].component_id =
sp->cinfo.d.comp_info[0].h_samp_factor =
sp->cinfo.d.comp_info[0].v_samp_factor = 1;
break;
case JCS_RGB :
sp->cinfo.d.comp_info[0].component_id = 'R';
sp->cinfo.d.comp_info[1].component_id = 'G';
sp->cinfo.d.comp_info[2].component_id = 'B';
i = 0;
do sp->cinfo.d.comp_info[i].h_samp_factor =
sp->cinfo.d.comp_info[i].v_samp_factor = 1;
while (++i < sp->cinfo.d.num_components);
break;
case JCS_CMYK :
sp->cinfo.d.comp_info[0].component_id = 'C';
sp->cinfo.d.comp_info[1].component_id = 'M';
sp->cinfo.d.comp_info[2].component_id = 'Y';
sp->cinfo.d.comp_info[3].component_id = 'K';
i = 0;
do sp->cinfo.d.comp_info[i].h_samp_factor =
sp->cinfo.d.comp_info[i].v_samp_factor = 1;
while (++i < sp->cinfo.d.num_components);
break;
case JCS_YCbCr :
i = 0;
do
{
sp->cinfo.d.comp_info[i].component_id = i+1;
sp->cinfo.d.comp_info[i].h_samp_factor =
sp->cinfo.d.comp_info[i].v_samp_factor = 1;
sp->cinfo.d.comp_info[i].quant_tbl_no =
sp->cinfo.d.comp_info[i].dc_tbl_no =
sp->cinfo.d.comp_info[i].ac_tbl_no = i > 0;
}
while (++i < sp->cinfo.d.num_components);
sp->cinfo.d.comp_info[0].h_samp_factor = sp->h_sampling;
sp->cinfo.d.comp_info[0].v_samp_factor = sp->v_sampling;
};
sp->cinfo.d.comps_in_scan = td->td_planarconfig == PLANARCONFIG_CONTIG
? sp->cinfo.d.num_components
: 1;
i = CALLJPEG(sp,-1,jpeg_read_header(&sp->cinfo.d,!sp->is_WANG));
sp->cinfo.d.marker->read_markers = save; /* Restore input method */
if (sp->is_WANG) /* produced by Wang Imaging on Microsoft Windows */
{
if (i != JPEG_SUSPENDED) return 0;
/* BOGOSITY ALERT! Files prooduced by the Wang Imaging application for
Microsoft Windows are a special--and, technically
illegal--case. A JPEG SOS marker and rest of the data stream should
be located at the end of the file, in a position identified by the
0th Strip offset.
*/
i = td->td_nstrips - 1;
sp->src.next_input_byte = tif->tif_base + td->td_stripoffset[0];
sp->src.bytes_in_buffer = td->td_stripoffset[i] -
td->td_stripoffset[0] + td->td_stripbytecount[i];
i = CALLJPEG(sp,-1,jpeg_read_header(&sp->cinfo.d,TRUE));
};
if (i != JPEG_HEADER_OK) return 0;
};
/* Some of our initialization must wait until the JPEG Library is initialized
above, in order to override its defaults.
*/
if ( (sp->cinfo.d.raw_data_out = downsampled_output)
&& !alloc_downsampled_buffers(tif,sp->cinfo.d.comp_info,
sp->cinfo.d.num_components)
) return 0;
sp->cinfo.d.jpeg_color_space = jpeg_color_space;
sp->cinfo.d.out_color_space = out_color_space;
sp->cinfo.d.dither_mode = JDITHER_NONE; /* Reduce image "noise" */
sp->cinfo.d.two_pass_quantize = FALSE;
/* If the image consists of separate, discontiguous TIFF "samples" (= color
planes, hopefully = JPEG "scans"), then we must use the JPEG Library's
"buffered image" mode to decompress the entire image into temporary buffers,
because the JPEG Library must parse the entire JPEG bit-stream in order to
be satsified that it has a complete set of color components for each pixel,
but the TIFF Library must allow our client to extract 1 component at a time.
Initializing the JPEG Library's "buffered image" mode is tricky: First, we
start its decompressor, then we tell the decompressor to "consume" (i.e.,
buffer) the entire bit-stream.
WARNING: Disabling "fancy" up-sampling seems to slightly reduce "noise" for
certain old Wang Imaging files, but it absolutely *must* be
enabled if the image has separate color planes, since in that case, the JPEG
Library doesn't use an "sp->cinfo.d.cconvert" structure (so de-referencing
this pointer below will cause a fatal crash) but writing our own code to up-
sample separate color planes is too much work for right now. Maybe someday?
*/
sp->cinfo.d.do_fancy_upsampling = /* Always let this default (to TRUE)? */
sp->cinfo.d.buffered_image = td->td_planarconfig == PLANARCONFIG_SEPARATE;
if (!CALLJPEG(sp,0,jpeg_start_decompress(&sp->cinfo.d))) return 0;
if (sp->cinfo.d.buffered_image) /* separate color planes */
{
if (sp->cinfo.d.raw_data_out)
tif->tif_decoderow = tif->tif_decodestrip = tif->tif_decodetile =
OJPEGDecodeRawSeparate;
else
{
tif->tif_decoderow = tif->tif_decodestrip = tif->tif_decodetile =
OJPEGDecode;
/* In JPEG Library Version 6B, color-space conversion isn't implemented
for separate color planes, so we must do it ourself if our TIFF
client doesn't want to:
*/
sp->cinfo.d.cconvert->color_convert =
sp->cinfo.d.jpeg_color_space == sp->cinfo.d.out_color_space
? null_convert : ycc_rgb_convert;
};
L3: switch (CALLJPEG(sp,0,jpeg_consume_input(&sp->cinfo.d)))
{
default : goto L3;
/* If no JPEG "End of Information" (EOI) marker is found when bit-
stream parsing ends, check whether we have enough data to proceed
before reporting an error.
*/
case JPEG_SUSPENDED : if ( sp->cinfo.d.input_scan_number
*sp->cinfo.d.image_height
+ sp->cinfo.d.input_iMCU_row
*sp->cinfo.d.max_v_samp_factor
# ifdef D_LOSSLESS_SUPPORTED
*sp->cinfo.d.data_units_in_MCU
*sp->cinfo.d.min_codec_data_unit
# else
*sp->cinfo.d.blocks_in_MCU
*DCTSIZE
# endif
< td->td_samplesperpixel
*sp->cinfo.d.image_height
)
{
TIFFError(tif->tif_name,
"Premature end of JPEG bit-stream");
return 0;
}
case JPEG_REACHED_EOI: ;
}
}
else /* pixel-interleaved color planes */
tif->tif_decoderow = tif->tif_decodestrip = tif->tif_decodetile =
downsampled_output ? OJPEGDecodeRawContig : OJPEGDecode;
return 1;
# undef td
}
static int
OJPEGPreDecode(register TIFF *tif,tsample_t s)
{ register OJPEGState *sp = OJState(tif);
# define td (&tif->tif_dir)
/* If we are about to read the first row of an image plane (hopefully, these
are coincident with JPEG "scans"!), reset the JPEG Library's decompressor
appropriately. Otherwise, let the decompressor run "as is" and return a
"success" status without further ado.
*/
if ( (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip)
% td->td_stripsperimage
== 0
)
{
if ( sp->cinfo.d.buffered_image
&& !CALLJPEG(sp,0,jpeg_start_output(&sp->cinfo.d,s+1))
) return 0;
sp->cinfo.d.output_scanline = 0;
/* Mark subsampling buffers "empty". */
# ifdef D_LOSSLESS_SUPPORTED
sp->scancount = sp->cinfo.d.min_codec_data_unit;
# else
sp->scancount = DCTSIZE;
# endif
};
return 1;
# undef td
}
/*ARGSUSED*/ static void
OJPEGPostDecode(register TIFF *tif,tidata_t buf,tsize_t cc)
{ register OJPEGState *sp = OJState(tif);
# define td (&tif->tif_dir)
/* The JPEG Library decompressor has reached the end of a strip/tile. If this
is the end of a TIFF image "sample" (= JPEG "scan") in a file with separate
components (color planes), then end the "scan". If it ends the image's last
sample/scan, then also stop the JPEG Library's decompressor.
*/
if (sp->cinfo.d.output_scanline >= sp->cinfo.d.output_height)
{
if (sp->cinfo.d.buffered_image)
CALLJPEG(sp,-1,jpeg_finish_output(&sp->cinfo.d)); /* End JPEG scan */
if ( (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip)
>= td->td_nstrips-1
) CALLJPEG(sp,0,jpeg_finish_decompress(&sp->cinfo.d));
}
# undef td
}
static int
OJPEGVSetField(register TIFF *tif,ttag_t tag,va_list ap)
{
uint32 v32;
register OJPEGState *sp = OJState(tif);
# define td (&tif->tif_dir)
toff_t tiffoff=0;
uint32 bufoff=0;
uint32 code_count=0;
int i2=0;
int k2=0;
switch (tag)
{
/* If a "ReferenceBlackWhite" TIFF tag appears in the file explicitly, undo
any modified default definition that we might have installed below, then
install the real one.
*/
case TIFFTAG_REFERENCEBLACKWHITE : if (td->td_refblackwhite)
{
_TIFFfree(td->td_refblackwhite);
td->td_refblackwhite = 0;
};
default : return
(*sp->vsetparent)(tif,tag,ap);
/* BEWARE OF KLUDGE: Some old-format JPEG-in-TIFF files, including those
produced by the Wang Imaging application for Micro-
soft Windows, illegally omit a "ReferenceBlackWhite" TIFF tag, even
though the TIFF specification's default is intended for the RGB color
space and is inappropriate for the YCbCr color space ordinarily used for
JPEG images. Since many TIFF client applications request the value of
this tag immediately after a TIFF image directory is parsed, and before
any other code in this module receives control, we are forced to fix
this problem very early in image-file processing. Fortunately, legal
TIFF files are supposed to store their tags in numeric order, so a
mandatory "PhotometricInterpretation" tag should always appear before
an optional "ReferenceBlackWhite" tag. Hence, we slyly peek ahead when
we discover the desired photometry, by installing modified black and
white reference levels.
*/
case TIFFTAG_PHOTOMETRIC :
if ( (v32 = (*sp->vsetparent)(tif,tag,ap))
&& td->td_photometric == PHOTOMETRIC_YCBCR
)
{
if ( (td->td_refblackwhite = _TIFFmalloc(6*sizeof(float))) )
{ register long top = 1 << td->td_bitspersample;
td->td_refblackwhite[0] = 0;
td->td_refblackwhite[1] = td->td_refblackwhite[3] =
td->td_refblackwhite[5] = top - 1;
td->td_refblackwhite[2] = td->td_refblackwhite[4] = top >> 1;
}
else
{
TIFFError(tif->tif_name,
"Cannot set default reference black and white levels");
v32 = 0;
};
}
return v32;
/* BEWARE OF KLUDGE: According to Charles Auer <Bumble731@msn.com>, if our
input is a multi-image (multi-directory) JPEG-in-TIFF
file is produced by the Wang Imaging application on Microsoft Windows,
for some reason the first directory excludes the vendor-specific "WANG
PageControl" tag (32934) that we check below, so the only other way to
identify these directories is apparently to look for a software-
identification tag with the substring, "Wang Labs". Single-image files
can apparently pass both tests, which causes no harm here, but what a
mess this is!
*/
case TIFFTAG_SOFTWARE :
{
char *software;
v32 = (*sp->vsetparent)(tif,tag,ap);
if( TIFFGetField( tif, TIFFTAG_SOFTWARE, &software )
&& strstr( software, "Wang Labs" ) )
sp->is_WANG = 1;
return v32;
}
case TIFFTAG_JPEGPROC :
case TIFFTAG_JPEGIFOFFSET :
case TIFFTAG_JPEGIFBYTECOUNT :
case TIFFTAG_JPEGRESTARTINTERVAL :
case TIFFTAG_JPEGLOSSLESSPREDICTORS:
case TIFFTAG_JPEGPOINTTRANSFORM :
case TIFFTAG_JPEGQTABLES :
case TIFFTAG_JPEGDCTABLES :
case TIFFTAG_JPEGACTABLES :
case TIFFTAG_WANG_PAGECONTROL :
case TIFFTAG_JPEGCOLORMODE : ;
};
v32 = va_arg(ap,uint32); /* No. of values in this TIFF record */
/* This switch statement is added for OJPEGVSetField */
if(v32 !=0){
switch(tag){
case TIFFTAG_JPEGPROC:
sp->jpegproc=v32;
break;
case TIFFTAG_JPEGIFOFFSET:
sp->jpegifoffset=v32;
break;
case TIFFTAG_JPEGIFBYTECOUNT:
sp->jpegifbytecount=v32;
break;
case TIFFTAG_JPEGRESTARTINTERVAL:
sp->jpegrestartinterval=v32;
break;
case TIFFTAG_JPEGLOSSLESSPREDICTORS:
sp->jpeglosslesspredictors_length=v32;
break;
case TIFFTAG_JPEGPOINTTRANSFORM:
sp->jpegpointtransform_length=v32;
break;
case TIFFTAG_JPEGQTABLES:
sp->jpegqtables_length=v32;
break;
case TIFFTAG_JPEGACTABLES:
sp->jpegactables_length=v32;
break;
case TIFFTAG_JPEGDCTABLES:
sp->jpegdctables_length=v32;
break;
default:
break;
}
}
/* BEWARE: The following actions apply only if we are reading a "source" TIFF
image to be decompressed for a client application program. If we
ever enhance this file's CODEC to write "destination" JPEG-in-TIFF images,
we'll need an "if"- and another "switch"-statement below, because we'll
probably want to store these records' values in some different places. Most
of these need not be parsed here in order to decode JPEG bit stream, so we
set boolean flags to note that they have been seen, but we otherwise ignore
them.
*/
switch (tag)
{ JHUFF_TBL **h;
/* Validate the JPEG-process code. */
case TIFFTAG_JPEGPROC :
switch (v32)
{
default : TIFFError(tif->tif_name,
"Unknown JPEG process");
return 0;
# ifdef C_LOSSLESS_SUPPORTED
/* Image uses (lossy) baseline sequential coding. */
case JPEGPROC_BASELINE: sp->cinfo.d.process = JPROC_SEQUENTIAL;
sp->cinfo.d.data_unit = DCTSIZE;
break;
/* Image uses (lossless) Huffman coding. */
case JPEGPROC_LOSSLESS: sp->cinfo.d.process = JPROC_LOSSLESS;
sp->cinfo.d.data_unit = 1;
# else /* not C_LOSSLESS_SUPPORTED */
case JPEGPROC_LOSSLESS: TIFFError(JPEGLib_name,
"Does not support lossless Huffman coding");
return 0;
case JPEGPROC_BASELINE: ;
# endif /* C_LOSSLESS_SUPPORTED */
};
break;
/* The TIFF Version 6.0 specification says that if the value of a TIFF
"JPEGInterchangeFormat" record is 0, then we are to behave as if this
record were absent; i.e., the data does *not* represent a JPEG Inter-
change Format File (JFIF), so don't even set the boolean "I've been
here" flag below. Otherwise, the field's value represents the file
offset of the JPEG SOI marker.
*/
case TIFFTAG_JPEGIFOFFSET :
if (v32)
{
sp->src.next_input_byte = tif->tif_base + v32;
break;
};
return 1;
case TIFFTAG_JPEGIFBYTECOUNT :
sp->src.bytes_in_buffer = v32;
break;
/* The TIFF Version 6.0 specification says that if the JPEG "Restart"
marker interval is 0, then the data has no "Restart" markers; i.e., we
must behave as if this TIFF record were absent. So, don't even set the
boolean "I've been here" flag below.
*/
/*
* Instead, set the field bit so TIFFGetField can get whether or not
* it was set.
*/
case TIFFTAG_JPEGRESTARTINTERVAL :
if (v32)
sp->cinfo.d.restart_interval = v32;
break;
/* The TIFF Version 6.0 specification says that this tag is supposed to be
a vector containing a value for each image component, but for lossless
Huffman coding (the only JPEG process defined by the specification for
which this tag should be needed), ISO IS 10918-1 uses only a single
value, equivalent to the "Ss" field in a JPEG bit-stream's "Start of
Scan" (SOS) marker. So, we extract the first vector element and ignore
the rest. (I hope this is correct!)
*/
case TIFFTAG_JPEGLOSSLESSPREDICTORS:
if (v32)
{
sp->cinfo.d.Ss = *va_arg(ap,uint16 *);
sp->jpeglosslesspredictors =
_TIFFmalloc(sp->jpeglosslesspredictors_length
* sizeof(uint16));
if(sp->jpeglosslesspredictors==NULL){return(0);}
for(i2=0;i2<sp->jpeglosslesspredictors_length;i2++){
((uint16*)sp->jpeglosslesspredictors)[i2] =
((uint16*)sp->cinfo.d.Ss)[i2];
}
sp->jpeglosslesspredictors_length*=sizeof(uint16);
break;
};
return v32;
/* The TIFF Version 6.0 specification says that this tag is supposed to be
a vector containing a value for each image component, but for lossless
Huffman coding (the only JPEG process defined by the specification for
which this tag should be needed), ISO IS 10918-1 uses only a single
value, equivalent to the "Al" field in a JPEG bit-stream's "Start of
Scan" (SOS) marker. So, we extract the first vector element and ignore
the rest. (I hope this is correct!)
*/
case TIFFTAG_JPEGPOINTTRANSFORM :
if (v32)
{
sp->cinfo.d.Al = *va_arg(ap,uint16 *);
sp->jpegpointtransform =
_TIFFmalloc(sp->jpegpointtransform_length*sizeof(uint16));
if(sp->jpegpointtransform==NULL){return(0);}
for(i2=0;i2<sp->jpegpointtransform_length;i2++) {
((uint16*)sp->jpegpointtransform)[i2] =
((uint16*)sp->cinfo.d.Al)[i2];
}
sp->jpegpointtransform_length*=sizeof(uint16);
break;
}
return v32;
/* We have a vector of offsets to quantization tables, so load 'em! */
case TIFFTAG_JPEGQTABLES :
if (v32)
{ uint32 *v;
int i;
if (v32 > NUM_QUANT_TBLS)
{
TIFFError(tif->tif_name,"Too many quantization tables");
return 0;
};
i = 0;
v = va_arg(ap,uint32 *);
sp->jpegqtables=_TIFFmalloc(64*sp->jpegqtables_length);
if(sp->jpegqtables==NULL){return(0);}
tiffoff = TIFFSeekFile(tif, 0, SEEK_CUR);
bufoff=0;
for(i2=0;i2<sp->jpegqtables_length;i2++){
TIFFSeekFile(tif, v[i2], SEEK_SET);
TIFFReadFile(tif, &(((unsigned char*)(sp->jpegqtables))[bufoff]),
64);
bufoff+=64;
}
sp->jpegqtables_length=bufoff;
TIFFSeekFile(tif, tiffoff, SEEK_SET);
do /* read quantization table */
{ register UINT8 *from = tif->tif_base + *v++;
register UINT16 *to;
register int j = DCTSIZE2;
if (!( sp->cinfo.d.quant_tbl_ptrs[i]
= CALLJPEG(sp,0,jpeg_alloc_quant_table(&sp->cinfo.comm))
)
)
{
TIFFError(JPEGLib_name,"No space for quantization table");
return 0;
};
to = sp->cinfo.d.quant_tbl_ptrs[i]->quantval;
do *to++ = *from++; while (--j > 0);
}
while (++i < v32);
sp->jpegtablesmode |= JPEGTABLESMODE_QUANT;
};
break;
/* We have a vector of offsets to DC Huffman tables, so load 'em! */
case TIFFTAG_JPEGDCTABLES :
h = sp->cinfo.d.dc_huff_tbl_ptrs;
goto L;
/* We have a vector of offsets to AC Huffman tables, so load 'em! */
case TIFFTAG_JPEGACTABLES :
h = sp->cinfo.d.ac_huff_tbl_ptrs;
L: if (v32)
{ uint32 *v;
int i;
if (v32 > NUM_HUFF_TBLS)
{
TIFFError(tif->tif_name,"Too many Huffman tables");
return 0;
};
v = va_arg(ap,uint32 *);
if(tag == TIFFTAG_JPEGDCTABLES) {
sp->jpegdctables=_TIFFmalloc(272*sp->jpegdctables_length);
if(sp->jpegdctables==NULL){return(0);}
tiffoff = TIFFSeekFile(tif, 0, SEEK_CUR);
bufoff=0;
code_count=0;
for(i2=0;i2<sp->jpegdctables_length;i2++){
TIFFSeekFile(tif, v[i2], SEEK_SET);
TIFFReadFile(tif,
&(((unsigned char*)(sp->jpegdctables))[bufoff]),
16);
code_count=0;
for(k2=0;k2<16;k2++){
code_count+=((unsigned char*)(sp->jpegdctables))[k2+bufoff];
}
TIFFReadFile(tif,
&(((unsigned char*)(sp->jpegdctables))[bufoff+16]),
code_count);
bufoff+=16;
bufoff+=code_count;
}
sp->jpegdctables_length=bufoff;
TIFFSeekFile(tif, tiffoff, SEEK_SET);
}
if(tag==TIFFTAG_JPEGACTABLES){
sp->jpegactables=_TIFFmalloc(272*sp->jpegactables_length);
if(sp->jpegactables==NULL){return(0);}
tiffoff = TIFFSeekFile(tif, 0, SEEK_CUR);
bufoff=0;
code_count=0;
for(i2=0;i2<sp->jpegactables_length;i2++){
TIFFSeekFile(tif, v[i2], SEEK_SET);
TIFFReadFile(tif, &(((unsigned char*)(sp->jpegactables))[bufoff]), 16);
code_count=0;
for(k2=0;k2<16;k2++){
code_count+=((unsigned char*)(sp->jpegactables))[k2+bufoff];
}
TIFFReadFile(tif, &(((unsigned char*)(sp->jpegactables))[bufoff+16]), code_count);
bufoff+=16;
bufoff+=code_count;
}
sp->jpegactables_length=bufoff;
TIFFSeekFile(tif, tiffoff, SEEK_SET);
}
i = 0;
do /* copy each Huffman table */
{ int size = 0;
register UINT8 *from = tif->tif_base + *v++, *to;
register int j = sizeof (*h)->bits;
/* WARNING: This code relies on the fact that an image file not
"memory mapped" was read entirely into a single
buffer by "TIFFInitOJPEG()", so we can do a fast memory-to-
memory copy here. Each table consists of 16 Bytes, which are
suffixed to a 0 Byte when copied, followed by a variable
number of Bytes whose length is the sum of the first 16.
*/
if (!( *h
= CALLJPEG(sp,0,jpeg_alloc_huff_table(&sp->cinfo.comm))
)
)
{
TIFFError(JPEGLib_name,"No space for Huffman table");
return 0;
};
to = (*h++)->bits;
*to++ = 0;
while (--j > 0) size += *to++ = *from++; /* Copy 16 Bytes */
if (size > sizeof (*h)->huffval/sizeof *(*h)->huffval)
{
TIFFError(tif->tif_name,"Huffman table too big");
return 0;
};
if ((j = size) > 0) do *to++ = *from++; while (--j > 0);
while (++size <= sizeof (*h)->huffval/sizeof *(*h)->huffval)
*to++ = 0; /* Zero the rest of the table for cleanliness */
}
while (++i < v32);
sp->jpegtablesmode |= JPEGTABLESMODE_HUFF;
};
break;
/* The following vendor-specific TIFF tag occurs in (highly illegal) files
produced by the Wang Imaging application for Microsoft Windows. These
can apparently have several "pages", in which case this tag specifies
the offset of a "page control" structure, which we don't currently know
how to handle. 0 indicates a 1-page image with no "page control", which
we make a feeble effort to handle.
*/
case TIFFTAG_WANG_PAGECONTROL :
if (v32 == 0) v32 = -1;
sp->is_WANG = v32;
tag = TIFFTAG_JPEGPROC+FIELD_WANG_PAGECONTROL-FIELD_JPEGPROC;
break;
/* This pseudo tag indicates whether our caller is expected to do YCbCr <->
RGB color-space conversion (JPEGCOLORMODE_RAW <=> 0) or whether we must
ask the JPEG Library to do it (JPEGCOLORMODE_RGB <=> 1).
*/
case TIFFTAG_JPEGCOLORMODE :
sp->jpegcolormode = v32;
/* Mark the image to indicate whether returned data is up-sampled, so
that "TIFF{Strip,Tile}Size()" reflect the true amount of data present.
*/
v32 = tif->tif_flags; /* Save flags temporarily */
tif->tif_flags &= ~TIFF_UPSAMPLED;
if ( td->td_photometric == PHOTOMETRIC_YCBCR
&& (td->td_ycbcrsubsampling[0]<<3 | td->td_ycbcrsubsampling[1])
!= 011
&& sp->jpegcolormode == JPEGCOLORMODE_RGB
) tif->tif_flags |= TIFF_UPSAMPLED;
/* If the up-sampling state changed, re-calculate tile size. */
if ((tif->tif_flags ^ v32) & TIFF_UPSAMPLED)
{
tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1;
tif->tif_flags |= TIFF_DIRTYDIRECT;
};
return 1;
};
TIFFSetFieldBit(tif,tag-TIFFTAG_JPEGPROC+FIELD_JPEGPROC);
return 1;
# undef td
}
static int
OJPEGVGetField(register TIFF *tif,ttag_t tag,va_list ap)
{ register OJPEGState *sp = OJState(tif);
switch (tag)
{
/* If this file has managed to synthesize a set of consolidated "metadata"
tables for the current (post-TIFF Version 6.0 specification) JPEG-in-
TIFF encapsulation strategy, then tell our caller about them; otherwise,
keep mum.
*/
case TIFFTAG_JPEGTABLES :
if (sp->jpegtables_length) /* we have "new"-style JPEG tables */
{
*va_arg(ap,uint32 *) = sp->jpegtables_length;
*va_arg(ap,char **) = sp->jpegtables;
return 1;
};
/* This pseudo tag indicates whether our caller is expected to do YCbCr <->
RGB color-space conversion (JPEGCOLORMODE_RAW <=> 0) or whether we must
ask the JPEG Library to do it (JPEGCOLORMODE_RGB <=> 1).
*/
case TIFFTAG_JPEGCOLORMODE :
*va_arg(ap,uint32 *) = sp->jpegcolormode;
return 1;
/* The following tags are defined by the TIFF Version 6.0 specification
and are obsolete. If our caller asks for information about them, do not
return anything, even if we parsed them in an old-format "source" image.
*/
case TIFFTAG_JPEGPROC :
*va_arg(ap, uint16*)=sp->jpegproc;
return(1);
break;
case TIFFTAG_JPEGIFOFFSET :
*va_arg(ap, uint32*)=sp->jpegifoffset;
return(1);
break;
case TIFFTAG_JPEGIFBYTECOUNT :
*va_arg(ap, uint32*)=sp->jpegifbytecount;
return(1);
break;
case TIFFTAG_JPEGRESTARTINTERVAL :
*va_arg(ap, uint32*)=sp->jpegrestartinterval;
return(1);
break;
case TIFFTAG_JPEGLOSSLESSPREDICTORS:
*va_arg(ap, uint32*)=sp->jpeglosslesspredictors_length;
*va_arg(ap, void**)=sp->jpeglosslesspredictors;
return(1);
break;
case TIFFTAG_JPEGPOINTTRANSFORM :
*va_arg(ap, uint32*)=sp->jpegpointtransform_length;
*va_arg(ap, void**)=sp->jpegpointtransform;
return(1);
break;
case TIFFTAG_JPEGQTABLES :
*va_arg(ap, uint32*)=sp->jpegqtables_length;
*va_arg(ap, void**)=sp->jpegqtables;
return(1);
break;
case TIFFTAG_JPEGDCTABLES :
*va_arg(ap, uint32*)=sp->jpegdctables_length;
*va_arg(ap, void**)=sp->jpegdctables;
return(1);
break;
case TIFFTAG_JPEGACTABLES :
*va_arg(ap, uint32*)=sp->jpegactables_length;
*va_arg(ap, void**)=sp->jpegactables;
return(1);
break;
};
return (*sp->vgetparent)(tif,tag,ap);
}
static void
OJPEGPrintDir(register TIFF *tif,FILE *fd,long flags)
{ register OJPEGState *sp = OJState(tif);
if ( ( flags
& (TIFFPRINT_JPEGQTABLES|TIFFPRINT_JPEGDCTABLES|TIFFPRINT_JPEGACTABLES)
)
&& sp->jpegtables_length
)
fprintf(fd," JPEG Table Data: <present>, %lu bytes\n",
sp->jpegtables_length);
}
static uint32
OJPEGDefaultStripSize(register TIFF *tif,register uint32 s)
{ register OJPEGState *sp = OJState(tif);
# define td (&tif->tif_dir)
if ((s = (*sp->defsparent)(tif,s)) < td->td_imagelength)
{ register tsize_t size = sp->cinfo.comm.is_decompressor
# ifdef D_LOSSLESS_SUPPORTED
? sp->cinfo.d.min_codec_data_unit
# else
? DCTSIZE
# endif
# ifdef C_LOSSLESS_SUPPORTED
: sp->cinfo.c.data_unit;
# else
: DCTSIZE;
# endif
size = TIFFroundup(size,16);
s = TIFFroundup(s,td->td_ycbcrsubsampling[1]*size);
};
return s;
# undef td
}
static void
OJPEGDefaultTileSize(register TIFF *tif,register uint32 *tw,register uint32 *th)
{ register OJPEGState *sp = OJState(tif);
register tsize_t size;
# define td (&tif->tif_dir)
size = sp->cinfo.comm.is_decompressor
# ifdef D_LOSSLESS_SUPPORTED
? sp->cinfo.d.min_codec_data_unit
# else
? DCTSIZE
# endif
# ifdef C_LOSSLESS_SUPPORTED
: sp->cinfo.c.data_unit;
# else
: DCTSIZE;
# endif
size = TIFFroundup(size,16);
(*sp->deftparent)(tif,tw,th);
*tw = TIFFroundup(*tw,td->td_ycbcrsubsampling[0]*size);
*th = TIFFroundup(*th,td->td_ycbcrsubsampling[1]*size);
# undef td
}
static void
OJPEGCleanUp(register TIFF *tif)
{ register OJPEGState *sp;
if ( (sp = OJState(tif)) )
{
CALLVJPEG(sp,jpeg_destroy(&sp->cinfo.comm)); /* Free JPEG Lib. vars. */
if (sp->jpegtables) {_TIFFfree(sp->jpegtables);sp->jpegtables=0;}
if (sp->jpeglosslesspredictors) {
_TIFFfree(sp->jpeglosslesspredictors);
sp->jpeglosslesspredictors = 0;
}
if (sp->jpegpointtransform) {
_TIFFfree(sp->jpegpointtransform);
sp->jpegpointtransform=0;
}
if (sp->jpegqtables) {_TIFFfree(sp->jpegqtables);sp->jpegqtables=0;}
if (sp->jpegactables) {_TIFFfree(sp->jpegactables);sp->jpegactables=0;}
if (sp->jpegdctables) {_TIFFfree(sp->jpegdctables);sp->jpegdctables=0;}
/* If the image file isn't "memory mapped" and we read it all into a
single, large memory buffer, free the buffer now.
*/
if (!isMapped(tif) && tif->tif_base) /* free whole-file buffer */
{
_TIFFfree(tif->tif_base);
tif->tif_base = 0;
tif->tif_size = 0;
};
_TIFFfree(sp); /* Release local variables */
tif->tif_data = 0;
}
}
int
TIFFInitOJPEG(register TIFF *tif,int scheme)
{ register OJPEGState *sp;
# define td (&tif->tif_dir)
# ifndef never
/* This module supports a decompression-only CODEC, which is intended strictly
for viewing old image files using the obsolete JPEG-in-TIFF encapsulation
specified by the TIFF Version 6.0 specification. It does not, and never
should, support compression for new images. If a client application asks us
to, refuse and complain loudly!
*/
if (tif->tif_mode != O_RDONLY) return _notSupported(tif);
# endif /* never */
if (!isMapped(tif))
{
/* BEWARE OF KLUDGE: If our host operating-system doesn't let an image
file be "memory mapped", then we want to read the
entire file into a single (possibly large) memory buffer as if it had
been "memory mapped". Although this is likely to waste space, because
analysis of the file's content might cause parts of it to be read into
smaller buffers duplicatively, it appears to be the lesser of several
evils. Very old JPEG-in-TIFF encapsulations aren't guaranteed to be
JFIF bit streams, or to have a TIFF "JPEGTables" record or much other
"metadata" to help us locate the decoding tables and entropy-coded data,
so we're likely do a lot of random-access grokking around, and we must
ultimately tell the JPEG Library to sequentially scan much of the file
anyway. This is all likely to be easier if we use "brute force" to
read the entire file, once, and don't use incremental disc I/O. If our
client application tries to process a file so big that we can't buffer
it entirely, then tough shit: we'll give up and exit!
*/
if (!(tif->tif_base = _TIFFmalloc(tif->tif_size=TIFFGetFileSize(tif))))
{
TIFFError(tif->tif_name,"Cannot allocate file buffer");
return 0;
};
if (!SeekOK(tif,0) || !ReadOK(tif,tif->tif_base,tif->tif_size))
{
TIFFError(tif->tif_name,"Cannot read file");
return 0;
}
};
/* Allocate storage for this module's per-file variables. */
if (!(tif->tif_data = (tidata_t)_TIFFmalloc(sizeof *sp)))
{
TIFFError("TIFFInitOJPEG","No space for JPEG state block");
return 0;
};
(sp = OJState(tif))->tif = tif; /* Initialize reverse pointer */
sp->cinfo.d.err = jpeg_std_error(&sp->err); /* Initialize error handling */
sp->err.error_exit = TIFFojpeg_error_exit;
sp->err.output_message = TIFFojpeg_output_message;
if (!CALLVJPEG(sp,jpeg_create_decompress(&sp->cinfo.d))) return 0;
/* Install CODEC-specific tag information and override default TIFF Library
"method" subroutines with our own, CODEC-specific methods. Like all good
members of an object-class, we save some of these subroutine pointers for
"fall back" in case our own methods fail.
*/
_TIFFMergeFieldInfo(tif,ojpegFieldInfo,
sizeof ojpegFieldInfo/sizeof *ojpegFieldInfo);
sp->defsparent = tif->tif_defstripsize;
sp->deftparent = tif->tif_deftilesize;
sp->vgetparent = tif->tif_tagmethods.vgetfield;
sp->vsetparent = tif->tif_tagmethods.vsetfield;
tif->tif_defstripsize = OJPEGDefaultStripSize;
tif->tif_deftilesize = OJPEGDefaultTileSize;
tif->tif_tagmethods.vgetfield = OJPEGVGetField;
tif->tif_tagmethods.vsetfield = OJPEGVSetField;
tif->tif_tagmethods.printdir = OJPEGPrintDir;
# ifdef never
tif->tif_setupencode = OJPEGSetupEncode;
tif->tif_preencode = OJPEGPreEncode;
tif->tif_postencode = OJPEGPostEncode;
# else /* well, hardly ever */
tif->tif_setupencode = tif->tif_postencode = _notSupported;
tif->tif_preencode = (TIFFPreMethod)_notSupported;
# endif /* never */
tif->tif_setupdecode = OJPEGSetupDecode;
tif->tif_predecode = OJPEGPreDecode;
tif->tif_postdecode = OJPEGPostDecode;
tif->tif_cleanup = OJPEGCleanUp;
/* If the image file doesn't have "JPEGInterchangeFormat[Length]" TIFF records
to guide us, we have few clues about where its encapsulated JPEG bit stream
is located, so establish intelligent defaults: If the Image File Directory
doesn't immediately follow the TIFF header, assume that the JPEG data lies
in between; otherwise, assume that it follows the Image File Directory.
*/
if (tif->tif_header.tiff_diroff > sizeof tif->tif_header)
{
sp->src.next_input_byte = tif->tif_base + sizeof tif->tif_header;
sp->src.bytes_in_buffer = tif->tif_header.tiff_diroff
- sizeof tif->tif_header;
}
else /* this case is ugly! */
{ uint32 maxoffset = tif->tif_size;
uint16 dircount;
/* Calculate the offset to the next Image File Directory, if there is one,
or to the end of the file, if not. Then arrange to read the file from
the end of the Image File Directory to that offset.
*/
if (tif->tif_nextdiroff) maxoffset = tif->tif_nextdiroff; /* Not EOF */
_TIFFmemcpy(&dircount,(const tdata_t)
(sp->src.next_input_byte = tif->tif_base+tif->tif_header.tiff_diroff),
sizeof dircount);
if (tif->tif_flags & TIFF_SWAB) TIFFSwabShort(&dircount);
sp->src.next_input_byte += dircount*sizeof(TIFFDirEntry)
+ sizeof maxoffset + sizeof dircount;
sp->src.bytes_in_buffer = tif->tif_base - sp->src.next_input_byte
+ maxoffset;
};
/* IJG JPEG Library Version 6B can be configured for either 8- or 12-bit sample
precision, but we assume that "old JPEG" TIFF clients only need 8 bits.
*/
sp->cinfo.d.data_precision = 8;
# ifdef C_LOSSLESS_SUPPORTED
/* If the "JPEGProc" TIFF tag is missing from the Image File Dictionary, the
JPEG Library will use its (lossy) baseline sequential process by default.
*/
sp->cinfo.d.data_unit = DCTSIZE;
# endif /* C_LOSSLESS_SUPPORTED */
/* Initialize other CODEC-specific variables requiring default values. */
tif->tif_flags |= TIFF_NOBITREV; /* No bit-reversal within data bytes */
sp->h_sampling = sp->v_sampling = 1; /* No subsampling by default */
sp->is_WANG = 0; /* Assume not a MS Windows Wang Imaging file by default */
sp->jpegtables = 0; /* No "new"-style JPEG tables synthesized yet */
sp->jpegtables_length = 0;
sp->jpegquality = 75; /* Default IJG quality */
sp->jpegcolormode = JPEGCOLORMODE_RAW;
sp->jpegtablesmode = 0; /* No tables found yet */
sp->jpeglosslesspredictors=0;
sp->jpeglosslesspredictors_length=0;
sp->jpegpointtransform=0;
sp->jpegpointtransform_length=0;
sp->jpegqtables=0;
sp->jpegqtables_length=0;
sp->jpegdctables=0;
sp->jpegdctables_length=0;
sp->jpegactables=0;
sp->jpegactables_length=0;
return 1;
# undef td
}
#endif /* OJPEG_SUPPORT */
/* vim: set ts=8 sts=8 sw=8 noet: */