/* $Header: /usr/people/sam/tiff/libtiff/RCS/tif_jpeg.c,v 1.25 1996/01/10 19:33:04 sam Rel $ */
/*
* Copyright (c) 1994-1996 Sam Leffler
* Copyright (c) 1994-1996 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifdef __WIN32__
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#define WIN32_LEAN_AND_MEAN
#endif
#include <assert.h>
#include <setjmp.h>
#include <stdio.h>
#include "jpeglib.h"
#include "jerror.h"
#include "tiffiop.h"
/*
* TIFF Library
*
* JPEG Compression support per TIFF Technical Note #2
* (*not* per the original TIFF 6.0 spec).
*
* This file is simply an interface to the libjpeg library written by
* the Independent JPEG Group. You need release 5 or later of the IJG
* code, which you can find on the Internet at ftp.uu.net:/graphics/jpeg/.
*
* Contributed by Tom Lane <tgl@sss.pgh.pa.us>.
*/
#undef EXTERN
#include "imgInt.h"
/*
* On some machines it may be worthwhile to use _setjmp or sigsetjmp
* in place of plain setjmp. These macros will make it easier.
*/
#define SETJMP(jbuf) setjmp(jbuf)
#define LONGJMP(jbuf,code) longjmp(jbuf,code)
#define JMP_BUF jmp_buf
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 block for each open TIFF file using
* libjpeg to do JPEG compression/decompression.
*
* libjpeg's visible state is either a jpeg_compress_struct
* or jpeg_decompress_struct depending on which way we
* are going. comm can be used to refer to the fields
* which are common to both.
*
* NB: cinfo is required to be the first member of JPEGState,
* so we can safely cast JPEGState* -> jpeg_xxx_struct*
* and vice versa!
*/
typedef struct {
union {
struct jpeg_compress_struct c;
struct jpeg_decompress_struct d;
struct jpeg_common_struct comm;
} cinfo; /* NB: must be first */
jpeg_error_mgr err; /* libjpeg error manager */
JMP_BUF exit_jmpbuf; /* for catching libjpeg failures */
/*
* The following two members could be a union, but
* they're small enough that it's not worth the effort.
*/
jpeg_destination_mgr dest; /* data dest for compression */
jpeg_source_mgr src; /* data source for decompression */
/* private state */
TIFF* tif; /* back link needed by some code */
uint16 photometric; /* copy of PhotometricInterpretation */
uint16 h_sampling; /* luminance sampling factors */
uint16 v_sampling;
tsize_t bytesperline; /* decompressed bytes per scanline */
/* pointers to intermediate buffers when processing downsampled data */
JSAMPARRAY ds_buffer[MAX_COMPONENTS];
int scancount; /* number of "scanlines" accumulated */
int samplesperclump;
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
TIFFStripMethod defsparent; /* super-class method */
TIFFTileMethod deftparent; /* super-class method */
/* pseudo-tag fields */
void* jpegtables; /* JPEGTables tag value, or NULL */
uint32 jpegtables_length; /* number of bytes in same */
int jpegquality; /* Compression quality level */
int jpegcolormode; /* Auto RGB<=>YCbCr convert? */
int jpegtablesmode; /* What to put in JPEGTables */
} JPEGState;
#define JState(tif) ((JPEGState*)(tif)->tif_data)
static int JPEGDecode _ANSI_ARGS_((TIFF*, tidata_t, tsize_t, tsample_t));
static int JPEGDecodeRaw _ANSI_ARGS_((TIFF*, tidata_t, tsize_t, tsample_t));
static int JPEGEncode _ANSI_ARGS_((TIFF*, tidata_t, tsize_t, tsample_t));
static int JPEGEncodeRaw _ANSI_ARGS_((TIFF*, tidata_t, tsize_t, tsample_t));
void ImgTIFFfree _ANSI_ARGS_((tdata_t data));
tdata_t ImgTIFFmalloc _ANSI_ARGS_((tsize_t size));
tdata_t ImgTIFFrealloc _ANSI_ARGS_((tdata_t data, tsize_t size));
tdata_t ImgTIFFmemcpy _ANSI_ARGS_((tdata_t, tdata_t, tsize_t));
void ImgTIFFError _ANSI_ARGS_(TCL_VARARGS(CONST char *, module));
int ImgTIFFPredictorInit _ANSI_ARGS_((TIFF *tif));
void ImgTIFFMergeFieldInfo _ANSI_ARGS_((TIFF* tif, CONST VOID *voidp, int i));
int ImgTIFFFlushData1 _ANSI_ARGS_((TIFF *tif));
void ImgTIFFNoPostDecode _ANSI_ARGS_((TIFF *, tidata_t, tsize_t));
tsize_t ImgTIFFTileRowSize _ANSI_ARGS_((TIFF *));
int ImgTIFFScanlineSize _ANSI_ARGS_((TIFF *));
void ImgTIFFsetByteArray _ANSI_ARGS_((VOID **, VOID*, long));
int ImgTIFFSetField _ANSI_ARGS_(TCL_VARARGS(TIFF *, tif));
tsize_t ImgTIFFTileSize _ANSI_ARGS_((TIFF*));
boolean Imgjpeg_resync_to_restart _ANSI_ARGS_((j_decompress_ptr, int));
JDIMENSION Imgjpeg_read_scanlines _ANSI_ARGS_((j_decompress_ptr,
JSAMPARRAY, JDIMENSION));
int Imgjpeg_set_colorspace _ANSI_ARGS_((j_compress_ptr, J_COLOR_SPACE));
int Imgjpeg_set_defaults _ANSI_ARGS_((j_compress_ptr));
int Imgjpeg_start_decompress _ANSI_ARGS_((j_decompress_ptr));
void Imgjpeg_destroy _ANSI_ARGS_((j_common_ptr));
struct jpeg_error_mgr * Imgjpeg_std_error _ANSI_ARGS_((struct jpeg_error_mgr *));
int Imgjpeg_CreateDecompress _ANSI_ARGS_((j_decompress_ptr, int, size_t));
JDIMENSION Imgjpeg_write_raw_data _ANSI_ARGS_((j_compress_ptr,
JSAMPIMAGE, JDIMENSION));
void Imgjpeg_suppress_tables _ANSI_ARGS_((j_compress_ptr, boolean));
void Imgjpeg_abort _ANSI_ARGS_((j_common_ptr));
int Imgjpeg_read_header _ANSI_ARGS_((j_decompress_ptr, int));
int Imgjpeg_start_compress _ANSI_ARGS_((j_compress_ptr, int));
void Imgjpeg_write_tables _ANSI_ARGS_((j_compress_ptr));
int Imgjpeg_finish_decompress _ANSI_ARGS_((j_decompress_ptr));
int Imgjpeg_CreateCompress _ANSI_ARGS_((j_compress_ptr, int, size_t));
int Imgjpeg_finish_compress _ANSI_ARGS_((j_compress_ptr));
JDIMENSION Imgjpeg_read_raw_data _ANSI_ARGS_((j_decompress_ptr,
JSAMPIMAGE, JDIMENSION));
int Imgjpeg_set_quality _ANSI_ARGS_((j_compress_ptr, int, int));
JDIMENSION Imgjpeg_write_scanlines _ANSI_ARGS_((j_compress_ptr,
JSAMPARRAY, JDIMENSION));
#define FIELD_JPEGTABLES (FIELD_CODEC+0)
static const TIFFFieldInfo jpegFieldInfo[] = {
{ TIFFTAG_JPEGTABLES, -1,-1, TIFF_UNDEFINED, FIELD_JPEGTABLES,
FALSE, TRUE, "JPEGTables" },
{ TIFFTAG_JPEGQUALITY, 0, 0, TIFF_ANY, FIELD_PSEUDO,
TRUE, FALSE, "" },
{ TIFFTAG_JPEGCOLORMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO,
FALSE, FALSE, "" },
{ TIFFTAG_JPEGTABLESMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO,
FALSE, FALSE, "" },
};
#define N(a) (sizeof (a) / sizeof (a[0]))
/*
* libjpeg interface layer.
*
* We use setjmp/longjmp to return control to libtiff
* when a fatal error is encountered within the JPEG
* library. We also direct libjpeg error and warning
* messages through the appropriate libtiff handlers.
*/
/*
* Error handling routines (these replace corresponding
* IJG routines from jerror.c). These are used for both
* compression and decompression.
*/
static void TIFFjpeg_error_exit _ANSI_ARGS_((j_common_ptr));
static void
TIFFjpeg_error_exit(cinfo)
j_common_ptr cinfo;
{
JPEGState *sp = (JPEGState *) cinfo; /* NB: cinfo assumed first */
char buffer[JMSG_LENGTH_MAX];
(*cinfo->err->format_message) (cinfo, buffer);
ImgTIFFError("JPEGLib", buffer); /* display the error message */
Imgjpeg_abort(cinfo); /* clean up libjpeg state */
LONGJMP(sp->exit_jmpbuf, 1); /* return to libtiff caller */
}
/*
* This routine is invoked only for warning messages,
* since error_exit does its own thing and trace_level
* is never set > 0.
*/
static void TIFFjpeg_output_message _ANSI_ARGS_((j_common_ptr));
static void
TIFFjpeg_output_message(cinfo)
j_common_ptr cinfo;
{
}
/*
* Interface routines. This layer of routines exists
* primarily to limit side-effects from using setjmp.
* Also, normal/error returns are converted into return
* values per libtiff practice.
*/
#define CALLJPEG(sp, fail, op) (SETJMP((sp)->exit_jmpbuf) ? (fail) : (op))
#define CALLVJPEG(sp, op) CALLJPEG(sp, 0, ((op),1))
static int TIFFjpeg_create_compress _ANSI_ARGS_((JPEGState*));
static int
TIFFjpeg_create_compress(sp)
JPEGState* sp;
{
/* initialize JPEG error handling */
sp->cinfo.c.err = Imgjpeg_std_error(&sp->err);
sp->err.error_exit = TIFFjpeg_error_exit;
sp->err.output_message = TIFFjpeg_output_message;
return CALLVJPEG(sp, Imgjpeg_CreateCompress(&sp->cinfo.c, JPEG_LIB_VERSION,
(size_t) sizeof(struct jpeg_compress_struct)));
}
static int TIFFjpeg_create_decompress _ANSI_ARGS_((JPEGState*));
static int
TIFFjpeg_create_decompress(sp)
JPEGState* sp;
{
/* initialize JPEG error handling */
sp->cinfo.d.err = Imgjpeg_std_error(&sp->err);
sp->err.error_exit = TIFFjpeg_error_exit;
sp->err.output_message = TIFFjpeg_output_message;
return CALLVJPEG(sp, Imgjpeg_CreateDecompress(&sp->cinfo.d, JPEG_LIB_VERSION,
(size_t) sizeof(struct jpeg_decompress_struct)));
}
static int TIFFjpeg_set_defaults _ANSI_ARGS_((JPEGState*));
static int
TIFFjpeg_set_defaults(sp)
JPEGState* sp;
{
return CALLVJPEG(sp, Imgjpeg_set_defaults(&sp->cinfo.c));
}
static int TIFFjpeg_set_colorspace _ANSI_ARGS_((JPEGState*, J_COLOR_SPACE));
static int
TIFFjpeg_set_colorspace(sp, colorspace)
JPEGState* sp;
J_COLOR_SPACE colorspace;
{
return CALLVJPEG(sp, Imgjpeg_set_colorspace(&sp->cinfo.c, colorspace));
}
static int TIFFjpeg_set_quality _ANSI_ARGS_((JPEGState*, int, boolean));
static int
TIFFjpeg_set_quality(sp, quality, force_baseline)
JPEGState* sp;
int quality;
boolean force_baseline;
{
return CALLVJPEG(sp,
Imgjpeg_set_quality(&sp->cinfo.c, quality, force_baseline));
}
static int TIFFjpeg_suppress_tables _ANSI_ARGS_((JPEGState*, boolean));
static int
TIFFjpeg_suppress_tables(sp, suppress)
JPEGState* sp;
boolean suppress;
{
return CALLVJPEG(sp, Imgjpeg_suppress_tables(&sp->cinfo.c, suppress));
}
static int TIFFjpeg_start_compress _ANSI_ARGS_((JPEGState*, boolean));
static int
TIFFjpeg_start_compress(sp, write_all_tables)
JPEGState* sp;
boolean write_all_tables;
{
return CALLVJPEG(sp,
Imgjpeg_start_compress(&sp->cinfo.c, write_all_tables));
}
static int TIFFjpeg_write_scanlines _ANSI_ARGS_((JPEGState*, JSAMPARRAY, int));
static int
TIFFjpeg_write_scanlines(sp, scanlines, num_lines)
JPEGState* sp;
JSAMPARRAY scanlines;
int num_lines;
{
return CALLJPEG(sp, -1, (int) Imgjpeg_write_scanlines(&sp->cinfo.c,
scanlines, (JDIMENSION) num_lines));
}
static int TIFFjpeg_write_raw_data _ANSI_ARGS_((JPEGState*, JSAMPIMAGE, int));
static int
TIFFjpeg_write_raw_data(sp, data, num_lines)
JPEGState* sp;
JSAMPIMAGE data;
int num_lines;
{
return CALLJPEG(sp, -1, (int) Imgjpeg_write_raw_data(&sp->cinfo.c,
data, (JDIMENSION) num_lines));
}
static int TIFFjpeg_finish_compress _ANSI_ARGS_((JPEGState* sp));
static int
TIFFjpeg_finish_compress(sp)
JPEGState* sp;
{
return CALLVJPEG(sp, Imgjpeg_finish_compress(&sp->cinfo.c));
}
static int TIFFjpeg_write_tables _ANSI_ARGS_((JPEGState*));
static int
TIFFjpeg_write_tables(sp)
JPEGState* sp;
{
return CALLVJPEG(sp, Imgjpeg_write_tables(&sp->cinfo.c));
}
static int TIFFjpeg_read_header _ANSI_ARGS_((JPEGState*, boolean));
static int
TIFFjpeg_read_header(sp, require_image)
JPEGState* sp;
boolean require_image;
{
return CALLJPEG(sp, -1, Imgjpeg_read_header(&sp->cinfo.d, require_image));
}
static int TIFFjpeg_start_decompress _ANSI_ARGS_((JPEGState*));
static int
TIFFjpeg_start_decompress(sp)
JPEGState* sp;
{
return CALLVJPEG(sp, Imgjpeg_start_decompress(&sp->cinfo.d));
}
static int TIFFjpeg_read_scanlines _ANSI_ARGS_((JPEGState*, JSAMPARRAY, int));
static int
TIFFjpeg_read_scanlines(sp, scanlines, max_lines)
JPEGState* sp;
JSAMPARRAY scanlines;
int max_lines;
{
return CALLJPEG(sp, -1, (int) Imgjpeg_read_scanlines(&sp->cinfo.d,
scanlines, (JDIMENSION) max_lines));
}
static int TIFFjpeg_read_raw_data _ANSI_ARGS_((JPEGState*, JSAMPIMAGE, int));
static int
TIFFjpeg_read_raw_data(sp, data, max_lines)
JPEGState* sp;
JSAMPIMAGE data;
int max_lines;
{
return CALLJPEG(sp, -1, (int) Imgjpeg_read_raw_data(&sp->cinfo.d,
data, (JDIMENSION) max_lines));
}
static int TIFFjpeg_finish_decompress _ANSI_ARGS_((JPEGState*));
static int
TIFFjpeg_finish_decompress(sp)
JPEGState* sp;
{
return CALLJPEG(sp, -1, (int) Imgjpeg_finish_decompress(&sp->cinfo.d));
}
static int TIFFjpeg_abort _ANSI_ARGS_((JPEGState*));
static int
TIFFjpeg_abort(sp)
JPEGState* sp;
{
return CALLVJPEG(sp, Imgjpeg_abort(&sp->cinfo.comm));
}
static int TIFFjpeg_destroy _ANSI_ARGS_((JPEGState*));
static int
TIFFjpeg_destroy(sp)
JPEGState* sp;
{
return CALLVJPEG(sp, Imgjpeg_destroy(&sp->cinfo.comm));
}
static JSAMPARRAY TIFFjpeg_alloc_sarray _ANSI_ARGS_((JPEGState*,
int, JDIMENSION, JDIMENSION));
static JSAMPARRAY
TIFFjpeg_alloc_sarray(sp, pool_id, samplesperrow, numrows)
JPEGState* sp;
int pool_id;
JDIMENSION samplesperrow;
JDIMENSION numrows;
{
return CALLJPEG(sp, (JSAMPARRAY) NULL,
(*sp->cinfo.comm.mem->alloc_sarray)
(&sp->cinfo.comm, pool_id, samplesperrow, numrows));
}
/*
* JPEG library destination data manager.
* These routines direct compressed data from libjpeg into the
* libtiff output buffer.
*/
static void std_init_destination _ANSI_ARGS_((j_compress_ptr));
static void
std_init_destination(cinfo)
j_compress_ptr cinfo;
{
JPEGState* sp = (JPEGState*) cinfo;
TIFF* tif = sp->tif;
sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata;
sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize;
}
static boolean std_empty_output_buffer _ANSI_ARGS_((j_compress_ptr));
static boolean
std_empty_output_buffer(cinfo)
j_compress_ptr cinfo;
{
JPEGState* sp = (JPEGState*) cinfo;
TIFF* tif = sp->tif;
/* the entire buffer has been filled */
tif->tif_rawcc = tif->tif_rawdatasize;
ImgTIFFFlushData1(tif);
sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata;
sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize;
return (TRUE);
}
static void std_term_destination _ANSI_ARGS_((j_compress_ptr));
static void
std_term_destination(cinfo)
j_compress_ptr cinfo;
{
JPEGState* sp = (JPEGState*) cinfo;
TIFF* tif = sp->tif;
tif->tif_rawcp = (tidata_t) sp->dest.next_output_byte;
tif->tif_rawcc =
tif->tif_rawdatasize - (tsize_t) sp->dest.free_in_buffer;
/* NB: libtiff does the final buffer flush */
}
static void TIFFjpeg_data_dest _ANSI_ARGS_((JPEGState*, TIFF*));
static void
TIFFjpeg_data_dest(sp, tif)
JPEGState* sp;
TIFF* tif;
{
(void) tif;
sp->cinfo.c.dest = &sp->dest;
sp->dest.init_destination = std_init_destination;
sp->dest.empty_output_buffer = std_empty_output_buffer;
sp->dest.term_destination = std_term_destination;
}
/*
* Alternate destination manager for outputting to JPEGTables field.
*/
static void tables_init_destination _ANSI_ARGS_((j_compress_ptr));
static void
tables_init_destination(cinfo)
j_compress_ptr cinfo;
{
JPEGState* sp = (JPEGState*) cinfo;
/* while building, jpegtables_length is allocated buffer size */
sp->dest.next_output_byte = (JOCTET*) sp->jpegtables;
sp->dest.free_in_buffer = (size_t) sp->jpegtables_length;
}
static boolean tables_empty_output_buffer _ANSI_ARGS_((j_compress_ptr));
static boolean
tables_empty_output_buffer(cinfo)
j_compress_ptr cinfo;
{
JPEGState* sp = (JPEGState*) cinfo;
void* newbuf;
/* the entire buffer has been filled; enlarge it by 1000 bytes */
newbuf = ImgTIFFrealloc((tdata_t) sp->jpegtables,
(tsize_t) (sp->jpegtables_length + 1000));
if (newbuf == NULL)
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);
}
static void tables_term_destination _ANSI_ARGS_((j_compress_ptr));
static void
tables_term_destination(cinfo)
j_compress_ptr cinfo;
{
JPEGState* sp = (JPEGState*) cinfo;
/* set tables length to number of bytes actually emitted */
sp->jpegtables_length -= sp->dest.free_in_buffer;
}
static int TIFFjpeg_tables_dest _ANSI_ARGS_((JPEGState*, TIFF*));
static int
TIFFjpeg_tables_dest(sp, tif)
JPEGState* sp;
TIFF* tif;
{
(void) tif;
/*
* Allocate a working buffer for building tables.
* Initial size is 1000 bytes, which is usually adequate.
*/
if (sp->jpegtables)
ImgTIFFfree(sp->jpegtables);
sp->jpegtables_length = 1000;
sp->jpegtables = (void*) ImgTIFFmalloc((tsize_t) sp->jpegtables_length);
if (sp->jpegtables == NULL) {
sp->jpegtables_length = 0;
ImgTIFFError("TIFFjpeg_tables_dest", "No space for JPEGTables");
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);
}
/*
* JPEG library source data manager.
* These routines supply compressed data to libjpeg.
*/
static void std_init_source _ANSI_ARGS_((j_decompress_ptr));
static void
std_init_source(cinfo)
j_decompress_ptr cinfo;
{
JPEGState* sp = (JPEGState*) cinfo;
TIFF* tif = sp->tif;
sp->src.next_input_byte = (const JOCTET*) tif->tif_rawdata;
sp->src.bytes_in_buffer = (size_t) tif->tif_rawcc;
}
static boolean std_fill_input_buffer _ANSI_ARGS_((j_decompress_ptr));
static boolean
std_fill_input_buffer(cinfo)
j_decompress_ptr cinfo;
{
JPEGState* sp = (JPEGState* ) cinfo;
static const JOCTET dummy_EOI[2] = { 0xFF, JPEG_EOI };
/*
* Should never get here since entire strip/tile is
* read into memory before the decompressor is called,
* and thus was supplied by init_source.
*/
WARNMS(cinfo, JWRN_JPEG_EOF);
/* insert a fake EOI marker */
sp->src.next_input_byte = dummy_EOI;
sp->src.bytes_in_buffer = 2;
return (TRUE);
}
static void std_skip_input_data _ANSI_ARGS_((j_decompress_ptr, long));
static void
std_skip_input_data(cinfo, num_bytes)
j_decompress_ptr cinfo;
long num_bytes;
{
JPEGState* sp = (JPEGState*) 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;
}
}
}
static void std_term_source _ANSI_ARGS_((j_decompress_ptr));
static void
std_term_source(cinfo)
j_decompress_ptr cinfo;
{
/* No work necessary here */
/* Or must we update tif->tif_rawcp, tif->tif_rawcc ??? */
/* (if so, need empty tables_term_source!) */
(void) cinfo;
}
static void TIFFjpeg_data_src _ANSI_ARGS_((JPEGState*, TIFF*));
static void
TIFFjpeg_data_src(sp, tif)
JPEGState* sp;
TIFF* tif;
{
(void) tif;
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 = Imgjpeg_resync_to_restart;
sp->src.term_source = std_term_source;
sp->src.bytes_in_buffer = 0; /* for safety */
sp->src.next_input_byte = NULL;
}
/*
* Alternate source manager for reading from JPEGTables.
* We can share all the code except for the init routine.
*/
static void tables_init_source _ANSI_ARGS_((j_decompress_ptr));
static void
tables_init_source(cinfo)
j_decompress_ptr cinfo;
{
JPEGState* sp = (JPEGState*) cinfo;
sp->src.next_input_byte = (const JOCTET*) sp->jpegtables;
sp->src.bytes_in_buffer = (size_t) sp->jpegtables_length;
}
static void TIFFjpeg_tables_src _ANSI_ARGS_((JPEGState*, TIFF*));
static void
TIFFjpeg_tables_src(sp, tif)
JPEGState* sp;
TIFF* tif;
{
TIFFjpeg_data_src(sp, tif);
sp->src.init_source = tables_init_source;
}
/*
* Allocate downsampled-data buffers needed for downsampled I/O.
* We use values computed in jpeg_start_compress or jpeg_start_decompress.
* We use libjpeg's allocator so that buffers will be released automatically
* when done with strip/tile.
* This is also a handy place to compute samplesperclump, bytesperline.
*/
static int alloc_downsampled_buffers _ANSI_ARGS_((TIFF*,
jpeg_component_info*, int));
static int
alloc_downsampled_buffers(tif, comp_info, num_components)
TIFF* tif;
jpeg_component_info* comp_info;
int num_components;
{
JPEGState* sp = JState(tif);
int ci;
jpeg_component_info* compptr;
JSAMPARRAY buf;
int samples_per_clump = 0;
for (ci = 0, compptr = comp_info; ci < num_components;
ci++, compptr++) {
samples_per_clump += compptr->h_samp_factor *
compptr->v_samp_factor;
buf = TIFFjpeg_alloc_sarray(sp, JPOOL_IMAGE,
compptr->width_in_blocks * DCTSIZE,
(JDIMENSION) (compptr->v_samp_factor*DCTSIZE));
if (buf == NULL)
return (0);
sp->ds_buffer[ci] = buf;
}
sp->samplesperclump = samples_per_clump;
/* Cb,Cr both have sampling factors 1 */
/* so downsampled width of Cb is # of clumps per line */
sp->bytesperline = sizeof(JSAMPLE) * samples_per_clump *
comp_info[1].downsampled_width;
return (1);
}
/*
* JPEG Decoding.
*/
static int JPEGSetupDecode _ANSI_ARGS_((TIFF* tif));
static int
JPEGSetupDecode(tif)
TIFF* tif;
{
JPEGState* sp = JState(tif);
TIFFDirectory *td = &tif->tif_dir;
assert(sp != NULL);
assert(sp->cinfo.comm.is_decompressor);
/* Read JPEGTables if it is present */
if (TIFFFieldSet(tif,FIELD_JPEGTABLES)) {
TIFFjpeg_tables_src(sp, tif);
if(TIFFjpeg_read_header(sp,FALSE) != JPEG_HEADER_TABLES_ONLY) {
ImgTIFFError("JPEGSetupDecode", "Bogus JPEGTables field");
return (0);
}
}
/* Grab parameters that are same for all strips/tiles */
sp->photometric = td->td_photometric;
switch (sp->photometric) {
case PHOTOMETRIC_YCBCR:
sp->h_sampling = td->td_ycbcrsubsampling[0];
sp->v_sampling = td->td_ycbcrsubsampling[1];
break;
default:
/* TIFF 6.0 forbids subsampling of all other color spaces */
sp->h_sampling = 1;
sp->v_sampling = 1;
break;
}
/* Set up for reading normal data */
TIFFjpeg_data_src(sp, tif);
tif->tif_postdecode = ImgTIFFNoPostDecode; /* override byte swapping */
return (1);
}
/*
* Set up for decoding a strip or tile.
*/
static int
#ifdef _USING_PROTOTYPES_
JPEGPreDecode (
TIFF* tif,
tsample_t s)
#else
JPEGPreDecode(tif, s)
TIFF* tif;
tsample_t s;
#endif
{
JPEGState *sp = JState(tif);
TIFFDirectory *td = &tif->tif_dir;
static char module[] = "JPEGPreDecode";
uint32 segment_width, segment_height;
int downsampled_output;
int ci;
assert(sp != NULL);
assert(sp->cinfo.comm.is_decompressor);
/*
* Reset decoder state from any previous strip/tile,
* in case application didn't read the whole strip.
*/
if (!TIFFjpeg_abort(sp))
return (0);
/*
* Read the header for this strip/tile.
*/
if (TIFFjpeg_read_header(sp, TRUE) != JPEG_HEADER_OK)
return (0);
/*
* Check image parameters and set decompression parameters.
*/
if (isTiled(tif)) {
segment_width = td->td_tilewidth;
segment_height = td->td_tilelength;
sp->bytesperline = ImgTIFFTileRowSize(tif);
} else {
segment_width = td->td_imagewidth;
segment_height = td->td_imagelength - tif->tif_row;
if (segment_height > td->td_rowsperstrip)
segment_height = td->td_rowsperstrip;
sp->bytesperline = ImgTIFFScanlineSize(tif);
}
if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) {
/*
* For PC 2, scale down the expected strip/tile size
* to match a downsampled component
*/
segment_width = TIFFhowmany(segment_width, sp->h_sampling);
segment_height = TIFFhowmany(segment_height, sp->v_sampling);
}
if (sp->cinfo.d.image_width != segment_width ||
sp->cinfo.d.image_height != segment_height) {
ImgTIFFError(module, "Improper JPEG strip/tile size");
return (0);
}
if (sp->cinfo.d.num_components !=
(td->td_planarconfig == PLANARCONFIG_CONTIG ?
td->td_samplesperpixel : 1)) {
ImgTIFFError(module, "Improper JPEG component count");
return (0);
}
if (sp->cinfo.d.data_precision != td->td_bitspersample) {
ImgTIFFError(module, "Improper JPEG data precision");
return (0);
}
if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
/* Component 0 should have expected sampling factors */
if (sp->cinfo.d.comp_info[0].h_samp_factor != sp->h_sampling ||
sp->cinfo.d.comp_info[0].v_samp_factor != sp->v_sampling) {
ImgTIFFError(module, "Improper JPEG sampling factors");
return (0);
}
/* Rest should have sampling factors 1,1 */
for (ci = 1; ci < sp->cinfo.d.num_components; ci++) {
if (sp->cinfo.d.comp_info[ci].h_samp_factor != 1 ||
sp->cinfo.d.comp_info[ci].v_samp_factor != 1) {
ImgTIFFError(module, "Improper JPEG sampling factors");
return (0);
}
}
} else {
/* PC 2's single component should have sampling factors 1,1 */
if (sp->cinfo.d.comp_info[0].h_samp_factor != 1 ||
sp->cinfo.d.comp_info[0].v_samp_factor != 1) {
ImgTIFFError(module, "Improper JPEG sampling factors");
return (0);
}
}
downsampled_output = FALSE;
if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
sp->photometric == PHOTOMETRIC_YCBCR &&
sp->jpegcolormode == JPEGCOLORMODE_RGB) {
/* Convert YCbCr to RGB */
sp->cinfo.d.jpeg_color_space = JCS_YCbCr;
sp->cinfo.d.out_color_space = JCS_RGB;
} else {
/* Suppress colorspace handling */
sp->cinfo.d.jpeg_color_space = JCS_UNKNOWN;
sp->cinfo.d.out_color_space = JCS_UNKNOWN;
if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
(sp->h_sampling != 1 || sp->v_sampling != 1))
downsampled_output = TRUE;
/* XXX what about up-sampling? */
}
if (downsampled_output) {
/* Need to use raw-data interface to libjpeg */
sp->cinfo.d.raw_data_out = TRUE;
tif->tif_decoderow = JPEGDecodeRaw;
tif->tif_decodestrip = JPEGDecodeRaw;
tif->tif_decodetile = JPEGDecodeRaw;
} else {
/* Use normal interface to libjpeg */
sp->cinfo.d.raw_data_out = FALSE;
tif->tif_decoderow = JPEGDecode;
tif->tif_decodestrip = JPEGDecode;
tif->tif_decodetile = JPEGDecode;
}
/* Start JPEG decompressor */
if (!TIFFjpeg_start_decompress(sp))
return (0);
/* Allocate downsampled-data buffers if needed */
if (downsampled_output) {
if (!alloc_downsampled_buffers(tif, sp->cinfo.d.comp_info,
sp->cinfo.d.num_components))
return (0);
sp->scancount = DCTSIZE; /* mark buffer empty */
}
return (1);
}
/*
* Decode a chunk of pixels.
* "Standard" case: returned data is not downsampled.
*/
static int
#ifdef _USING_PROTOTYPES_
JPEGDecode (
TIFF* tif,
tidata_t buf,
tsize_t cc,
tsample_t s)
#else
JPEGDecode(tif, buf, cc, s)
TIFF* tif;
tidata_t buf;
tsize_t cc;
tsample_t s;
#endif
{
JPEGState *sp = JState(tif);
tsize_t nrows;
JSAMPROW bufptr[1];
(void) s;
assert(sp != NULL);
/* data is expected to be read in multiples of a scanline */
nrows = cc / sp->bytesperline;
while (nrows-- > 0) {
bufptr[0] = (JSAMPROW) buf;
if (TIFFjpeg_read_scanlines(sp, bufptr, 1) != 1)
return (0);
if (nrows > 0)
tif->tif_row++;
buf += sp->bytesperline;
}
/* Close down the decompressor if we've finished the strip or tile. */
if (sp->cinfo.d.output_scanline == sp->cinfo.d.output_height) {
if (TIFFjpeg_finish_decompress(sp) != TRUE)
return (0);
}
return (1);
}
/*
* Decode a chunk of pixels.
* Returned data is downsampled per sampling factors.
*/
static int
#ifdef _USING_PROTOTYPES_
JPEGDecodeRaw (
TIFF* tif,
tidata_t buf,
tsize_t cc,
tsample_t s)
#else
JPEGDecodeRaw(tif, buf, cc, s)
TIFF* tif;
tidata_t buf;
tsize_t cc;
tsample_t s;
#endif
{
JPEGState *sp = JState(tif);
JSAMPLE* inptr;
JSAMPLE* outptr;
tsize_t nrows;
JDIMENSION clumps_per_line, nclump;
int clumpoffset, ci, xpos, ypos;
jpeg_component_info* compptr;
int samples_per_clump = sp->samplesperclump;
(void) s;
assert(sp != NULL);
/* data is expected to be read in multiples of a scanline */
nrows = cc / sp->bytesperline;
/* Cb,Cr both have sampling factors 1, so this is correct */
clumps_per_line = sp->cinfo.d.comp_info[1].downsampled_width;
while (nrows-- > 0) {
/* Reload downsampled-data buffer if needed */
if (sp->scancount >= DCTSIZE) {
int n = sp->cinfo.d.max_v_samp_factor * DCTSIZE;
if (TIFFjpeg_read_raw_data(sp, sp->ds_buffer, n) != n)
return (0);
sp->scancount = 0;
/* Close down the decompressor if done. */
if (sp->cinfo.d.output_scanline >=
sp->cinfo.d.output_height) {
if (TIFFjpeg_finish_decompress(sp) != TRUE)
return (0);
}
}
/*
* Fastest way to unseparate the data is to make one pass
* over the scanline for each row of each component.
*/
clumpoffset = 0; /* first sample in clump */
for (ci = 0, compptr = sp->cinfo.d.comp_info;
ci < sp->cinfo.d.num_components;
ci++, compptr++) {
int hsamp = compptr->h_samp_factor;
int vsamp = compptr->v_samp_factor;
for (ypos = 0; ypos < vsamp; ypos++) {
inptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos];
outptr = ((JSAMPLE*) buf) + clumpoffset;
if (hsamp == 1) {
/* fast path for at least Cb and Cr */
for (nclump = clumps_per_line; nclump-- > 0; ) {
outptr[0] = *inptr++;
outptr += samples_per_clump;
}
} else {
/* general case */
for (nclump = clumps_per_line; nclump-- > 0; ) {
for (xpos = 0; xpos < hsamp; xpos++)
outptr[xpos] = *inptr++;
outptr += samples_per_clump;
}
}
clumpoffset += hsamp;
}
}
sp->scancount++;
if (nrows > 0)
tif->tif_row++;
buf += sp->bytesperline;
}
return (1);
}
/*
* JPEG Encoding.
*/
static void unsuppress_quant_table _ANSI_ARGS_((JPEGState*, int));
static void
unsuppress_quant_table(sp, tblno)
JPEGState* sp;
int tblno;
{
JQUANT_TBL* qtbl;
if ((qtbl = sp->cinfo.c.quant_tbl_ptrs[tblno]) != NULL)
qtbl->sent_table = FALSE;
}
static void unsuppress_huff_table _ANSI_ARGS_((JPEGState*, int));
static void
unsuppress_huff_table(sp, tblno)
JPEGState* sp;
int tblno;
{
JHUFF_TBL* htbl;
if ((htbl = sp->cinfo.c.dc_huff_tbl_ptrs[tblno]) != NULL)
htbl->sent_table = FALSE;
if ((htbl = sp->cinfo.c.ac_huff_tbl_ptrs[tblno]) != NULL)
htbl->sent_table = FALSE;
}
static int prepare_JPEGTables _ANSI_ARGS_((TIFF*));
static int
prepare_JPEGTables(tif)
TIFF* tif;
{
JPEGState* sp = JState(tif);
/* Initialize quant tables for current quality setting */
if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))
return (0);
/* Mark only the tables we want for output */
/* NB: chrominance tables are currently used only with YCbCr */
if (!TIFFjpeg_suppress_tables(sp, TRUE))
return (0);
if (sp->jpegtablesmode & JPEGTABLESMODE_QUANT) {
unsuppress_quant_table(sp, 0);
if (sp->photometric == PHOTOMETRIC_YCBCR)
unsuppress_quant_table(sp, 1);
}
if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF) {
unsuppress_huff_table(sp, 0);
if (sp->photometric == PHOTOMETRIC_YCBCR)
unsuppress_huff_table(sp, 1);
}
/* Direct libjpeg output into jpegtables */
if (!TIFFjpeg_tables_dest(sp, tif))
return (0);
/* Emit tables-only datastream */
if (!TIFFjpeg_write_tables(sp))
return (0);
return (1);
}
static int JPEGSetupEncode _ANSI_ARGS_((TIFF* tif));
static int
JPEGSetupEncode(tif)
TIFF* tif;
{
JPEGState* sp = JState(tif);
TIFFDirectory *td = &tif->tif_dir;
static char module[] = "JPEGSetupEncode";
assert(sp != NULL);
assert(!sp->cinfo.comm.is_decompressor);
/*
* Initialize all JPEG parameters to default values.
* Note that jpeg_set_defaults needs legal values for
* in_color_space and input_components.
*/
sp->cinfo.c.in_color_space = JCS_UNKNOWN;
sp->cinfo.c.input_components = 1;
if (!TIFFjpeg_set_defaults(sp))
return (0);
/* Set per-file parameters */
sp->photometric = td->td_photometric;
switch (sp->photometric) {
case PHOTOMETRIC_YCBCR:
sp->h_sampling = td->td_ycbcrsubsampling[0];
sp->v_sampling = td->td_ycbcrsubsampling[1];
/*
* A ReferenceBlackWhite field *must* be present since the
* default value is inappropriate for YCbCr. Fill in the
* proper value if application didn't set it.
*/
#ifdef COLORIMETRY_SUPPORT
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];
ImgTIFFSetField(tif, TIFFTAG_REFERENCEBLACKWHITE, refbw);
}
#endif
break;
case PHOTOMETRIC_PALETTE: /* disallowed by Tech Note */
case PHOTOMETRIC_MASK:
ImgTIFFError(module,
"PhotometricInterpretation %d not allowed for JPEG",
(int) sp->photometric);
return (0);
default:
/* TIFF 6.0 forbids subsampling of all other color spaces */
sp->h_sampling = 1;
sp->v_sampling = 1;
break;
}
/* Verify miscellaneous parameters */
/*
* This would need work if libtiff ever supports different
* depths for different components, or if libjpeg ever supports
* run-time selection of depth. Neither is imminent.
*/
if (td->td_bitspersample != BITS_IN_JSAMPLE) {
ImgTIFFError(module, "BitsPerSample %d not allowed for JPEG",
(int) td->td_bitspersample);
return (0);
}
sp->cinfo.c.data_precision = td->td_bitspersample;
if (isTiled(tif)) {
if ((td->td_tilelength % (sp->v_sampling * DCTSIZE)) != 0) {
ImgTIFFError(module,
"JPEG tile height must be multiple of %d",
sp->v_sampling * DCTSIZE);
return (0);
}
if ((td->td_tilewidth % (sp->h_sampling * DCTSIZE)) != 0) {
ImgTIFFError(module,
"JPEG tile width must be multiple of %d",
sp->h_sampling * DCTSIZE);
return (0);
}
} else {
if (td->td_rowsperstrip < td->td_imagelength &&
(td->td_rowsperstrip % (sp->v_sampling * DCTSIZE)) != 0) {
ImgTIFFError(module,
"RowsPerStrip must be multiple of %d for JPEG",
sp->v_sampling * DCTSIZE);
return (0);
}
}
/* Create a JPEGTables field if appropriate */
if (sp->jpegtablesmode & (JPEGTABLESMODE_QUANT|JPEGTABLESMODE_HUFF)) {
if (!prepare_JPEGTables(tif))
return (0);
/* Mark the field present */
/* Can't use TIFFSetField since BEENWRITING is already set! */
TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
tif->tif_flags |= TIFF_DIRTYDIRECT;
} else {
/* We do not support application-supplied JPEGTables, */
/* so mark the field not present */
TIFFClrFieldBit(tif, FIELD_JPEGTABLES);
}
/* Direct libjpeg output to libtiff's output buffer */
TIFFjpeg_data_dest(sp, tif);
return (1);
}
/*
* Set encoding state at the start of a strip or tile.
*/
static int
#ifdef _USING_PROTOTYPES_
JPEGPreEncode (
TIFF* tif,
tsample_t s)
#else
JPEGPreEncode(tif, s)
TIFF* tif;
tsample_t s;
#endif
{
JPEGState *sp = JState(tif);
TIFFDirectory *td = &tif->tif_dir;
static char module[] = "JPEGPreEncode";
uint32 segment_width, segment_height;
int downsampled_input;
assert(sp != NULL);
assert(!sp->cinfo.comm.is_decompressor);
/*
* Set encoding parameters for this strip/tile.
*/
if (isTiled(tif)) {
segment_width = td->td_tilewidth;
segment_height = td->td_tilelength;
sp->bytesperline = ImgTIFFTileRowSize(tif);
} else {
segment_width = td->td_imagewidth;
segment_height = td->td_imagelength - tif->tif_row;
if (segment_height > td->td_rowsperstrip)
segment_height = td->td_rowsperstrip;
sp->bytesperline = ImgTIFFScanlineSize(tif);
}
if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) {
/* for PC 2, scale down the strip/tile size
* to match a downsampled component
*/
segment_width = TIFFhowmany(segment_width, sp->h_sampling);
segment_height = TIFFhowmany(segment_height, sp->v_sampling);
}
if (segment_width > 65535 || segment_height > 65535) {
ImgTIFFError(module, "Strip/tile too large for JPEG");
return (0);
}
sp->cinfo.c.image_width = segment_width;
sp->cinfo.c.image_height = segment_height;
downsampled_input = FALSE;
if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
sp->cinfo.c.input_components = td->td_samplesperpixel;
if (sp->photometric == PHOTOMETRIC_YCBCR) {
if (sp->jpegcolormode == JPEGCOLORMODE_RGB) {
sp->cinfo.c.in_color_space = JCS_RGB;
} else {
sp->cinfo.c.in_color_space = JCS_YCbCr;
if (sp->h_sampling != 1 || sp->v_sampling != 1)
downsampled_input = TRUE;
}
if (!TIFFjpeg_set_colorspace(sp, JCS_YCbCr))
return (0);
/*
* Set Y sampling factors;
* we assume jpeg_set_colorspace() set the rest to 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;
} else {
sp->cinfo.c.in_color_space = JCS_UNKNOWN;
if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN))
return (0);
/* jpeg_set_colorspace set all sampling factors to 1 */
}
} else {
sp->cinfo.c.input_components = 1;
sp->cinfo.c.in_color_space = JCS_UNKNOWN;
if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN))
return (0);
sp->cinfo.c.comp_info[0].component_id = s;
/* jpeg_set_colorspace() set sampling factors to 1 */
if (sp->photometric == PHOTOMETRIC_YCBCR && s > 0) {
sp->cinfo.c.comp_info[0].quant_tbl_no = 1;
sp->cinfo.c.comp_info[0].dc_tbl_no = 1;
sp->cinfo.c.comp_info[0].ac_tbl_no = 1;
}
}
/* ensure libjpeg won't write any extraneous markers */
sp->cinfo.c.write_JFIF_header = FALSE;
sp->cinfo.c.write_Adobe_marker = FALSE;
/* set up table handling correctly */
if (! (sp->jpegtablesmode & JPEGTABLESMODE_QUANT)) {
if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))
return (0);
unsuppress_quant_table(sp, 0);
unsuppress_quant_table(sp, 1);
}
if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF)
sp->cinfo.c.optimize_coding = FALSE;
else
sp->cinfo.c.optimize_coding = TRUE;
if (downsampled_input) {
/* Need to use raw-data interface to libjpeg */
sp->cinfo.c.raw_data_in = TRUE;
tif->tif_encoderow = JPEGEncodeRaw;
tif->tif_encodestrip = JPEGEncodeRaw;
tif->tif_encodetile = JPEGEncodeRaw;
} else {
/* Use normal interface to libjpeg */
sp->cinfo.c.raw_data_in = FALSE;
tif->tif_encoderow = JPEGEncode;
tif->tif_encodestrip = JPEGEncode;
tif->tif_encodetile = JPEGEncode;
}
/* Start JPEG compressor */
if (!TIFFjpeg_start_compress(sp, FALSE))
return (0);
/* Allocate downsampled-data buffers if needed */
if (downsampled_input) {
if (!alloc_downsampled_buffers(tif, sp->cinfo.c.comp_info,
sp->cinfo.c.num_components))
return (0);
}
sp->scancount = 0;
return (1);
}
/*
* Encode a chunk of pixels.
* "Standard" case: incoming data is not downsampled.
*/
static int JPEGEncode _ANSI_ARGS_((TIFF*, tidata_t, tsize_t, tsample_t));
static int
JPEGEncode(tif, buf, cc, s)
TIFF* tif;
tidata_t buf;
tsize_t cc;
tsample_t s;
{
JPEGState *sp = JState(tif);
tsize_t nrows;
JSAMPROW bufptr[1];
(void) s;
assert(sp != NULL);
/* data is expected to be supplied in multiples of a scanline */
nrows = cc / sp->bytesperline;
while (nrows-- > 0) {
bufptr[0] = (JSAMPROW) buf;
if (TIFFjpeg_write_scanlines(sp, bufptr, 1) != 1)
return (0);
if (nrows > 0)
tif->tif_row++;
buf += sp->bytesperline;
}
return (1);
}
/*
* Encode a chunk of pixels.
* Incoming data is expected to be downsampled per sampling factors.
*/
static int JPEGEncodeRaw _ANSI_ARGS_((TIFF*, tidata_t, tsize_t, tsample_t));
static int
JPEGEncodeRaw(tif, buf, cc, s)
TIFF* tif;
tidata_t buf;
tsize_t cc;
tsample_t s;
{
JPEGState *sp = JState(tif);
JSAMPLE* inptr;
JSAMPLE* outptr;
tsize_t nrows;
JDIMENSION clumps_per_line, nclump;
int clumpoffset, ci, xpos, ypos;
jpeg_component_info* compptr;
int samples_per_clump = sp->samplesperclump;
(void) s;
assert(sp != NULL);
/* data is expected to be supplied in multiples of a scanline */
nrows = cc / sp->bytesperline;
/* Cb,Cr both have sampling factors 1, so this is correct */
clumps_per_line = sp->cinfo.c.comp_info[1].downsampled_width;
while (nrows-- > 0) {
/*
* Fastest way to separate the data is to make one pass
* over the scanline for each row of each component.
*/
clumpoffset = 0; /* first sample in clump */
for (ci = 0, compptr = sp->cinfo.c.comp_info;
ci < sp->cinfo.c.num_components;
ci++, compptr++) {
int hsamp = compptr->h_samp_factor;
int vsamp = compptr->v_samp_factor;
int padding = (int) (compptr->width_in_blocks * DCTSIZE -
clumps_per_line * hsamp);
for (ypos = 0; ypos < vsamp; ypos++) {
inptr = ((JSAMPLE*) buf) + clumpoffset;
outptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos];
if (hsamp == 1) {
/* fast path for at least Cb and Cr */
for (nclump = clumps_per_line; nclump-- > 0; ) {
*outptr++ = inptr[0];
inptr += samples_per_clump;
}
} else {
/* general case */
for (nclump = clumps_per_line; nclump-- > 0; ) {
for (xpos = 0; xpos < hsamp; xpos++)
*outptr++ = inptr[xpos];
inptr += samples_per_clump;
}
}
/* pad each scanline as needed */
for (xpos = 0; xpos < padding; xpos++) {
*outptr = outptr[-1];
outptr++;
}
clumpoffset += hsamp;
}
}
sp->scancount++;
if (sp->scancount >= DCTSIZE) {
int n = sp->cinfo.c.max_v_samp_factor * DCTSIZE;
if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n)
return (0);
sp->scancount = 0;
}
if (nrows > 0)
tif->tif_row++;
buf += sp->bytesperline;
}
return (1);
}
/*
* Finish up at the end of a strip or tile.
*/
static int JPEGPostEncode _ANSI_ARGS_((TIFF* tif));
static int
JPEGPostEncode(tif)
TIFF* tif;
{
JPEGState *sp = JState(tif);
if (sp->scancount > 0) {
/*
* Need to emit a partial bufferload of downsampled data.
* Pad the data vertically.
*/
int ci, ypos, n;
jpeg_component_info* compptr;
for (ci = 0, compptr = sp->cinfo.c.comp_info;
ci < sp->cinfo.c.num_components;
ci++, compptr++) {
int vsamp = compptr->v_samp_factor;
tsize_t row_width = compptr->width_in_blocks * DCTSIZE
* sizeof(JSAMPLE);
for (ypos = sp->scancount * vsamp;
ypos < DCTSIZE * vsamp; ypos++) {
ImgTIFFmemcpy((tdata_t)sp->ds_buffer[ci][ypos],
(tdata_t)sp->ds_buffer[ci][ypos-1],
row_width);
}
}
n = sp->cinfo.c.max_v_samp_factor * DCTSIZE;
if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n)
return (0);
}
return (TIFFjpeg_finish_compress(JState(tif)));
}
static void JPEGCleanup _ANSI_ARGS_((TIFF*));
static void
JPEGCleanup(tif)
TIFF* tif;
{
if (tif->tif_data) {
JPEGState *sp = JState(tif);
TIFFjpeg_destroy(sp); /* release libjpeg resources */
if (sp->jpegtables) /* tag value */
ImgTIFFfree(sp->jpegtables);
ImgTIFFfree(tif->tif_data); /* release local state */
tif->tif_data = NULL;
}
}
static int JPEGVSetField _ANSI_ARGS_((TIFF* tif, ttag_t tag, va_list ap));
static int
JPEGVSetField(tif, tag, ap)
TIFF* tif;
ttag_t tag;
va_list ap;
{
JPEGState* sp = JState(tif);
TIFFDirectory* td = &tif->tif_dir;
uint32 v32;
switch (tag) {
case TIFFTAG_JPEGTABLES:
v32 = va_arg(ap, uint32);
if (v32 == 0) {
/* XXX */
return (0);
}
ImgTIFFsetByteArray(&sp->jpegtables, va_arg(ap, void*),
(long) v32);
sp->jpegtables_length = v32;
TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
break;
case TIFFTAG_JPEGQUALITY:
sp->jpegquality = va_arg(ap, int);
return (1); /* pseudo tag */
case TIFFTAG_JPEGCOLORMODE:
sp->jpegcolormode = va_arg(ap, int);
/*
* Mark whether returned data is up-sampled or not
* so TIFFStripSize and TIFFTileSize return values
* that reflect the true amount of data.
*/
tif->tif_flags &= ~TIFF_UPSAMPLED;
if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
if (td->td_photometric == PHOTOMETRIC_YCBCR &&
sp->jpegcolormode == JPEGCOLORMODE_RGB) {
tif->tif_flags |= TIFF_UPSAMPLED;
} else {
if (td->td_ycbcrsubsampling[0] != 1 ||
td->td_ycbcrsubsampling[1] != 1)
; /* XXX what about up-sampling? */
}
}
/*
* Must recalculate cached tile size
* in case sampling state changed.
*/
tif->tif_tilesize = ImgTIFFTileSize(tif);
return (1); /* pseudo tag */
case TIFFTAG_JPEGTABLESMODE:
sp->jpegtablesmode = va_arg(ap, int);
return (1); /* pseudo tag */
default:
return (*sp->vsetparent)(tif, tag, ap);
}
tif->tif_flags |= TIFF_DIRTYDIRECT;
return (1);
}
static int JPEGVGetField _ANSI_ARGS_((TIFF* tif, ttag_t tag, va_list ap));
static int
JPEGVGetField(tif, tag, ap)
TIFF* tif;
ttag_t tag;
va_list ap;
{
JPEGState* sp = JState(tif);
switch (tag) {
case TIFFTAG_JPEGTABLES:
/* u_short is bogus --- should be uint32 ??? */
/* TIFFWriteNormalTag needs fixed XXX */
*va_arg(ap, u_short*) = (u_short) sp->jpegtables_length;
*va_arg(ap, void**) = sp->jpegtables;
break;
case TIFFTAG_JPEGQUALITY:
*va_arg(ap, int*) = sp->jpegquality;
break;
case TIFFTAG_JPEGCOLORMODE:
*va_arg(ap, int*) = sp->jpegcolormode;
break;
case TIFFTAG_JPEGTABLESMODE:
*va_arg(ap, int*) = sp->jpegtablesmode;
break;
default:
return (*sp->vgetparent)(tif, tag, ap);
}
return (1);
}
static uint32 JPEGDefaultStripSize _ANSI_ARGS_((TIFF*, uint32));
static uint32
JPEGDefaultStripSize(tif, s)
TIFF* tif;
uint32 s;
{
JPEGState* sp = JState(tif);
TIFFDirectory *td = &tif->tif_dir;
s = (*sp->defsparent)(tif, s);
if (s < td->td_imagelength)
s = TIFFroundup(s, td->td_ycbcrsubsampling[1] * DCTSIZE);
return (s);
}
static void JPEGDefaultTileSize _ANSI_ARGS_((TIFF*, uint32*, uint32*));
static void
JPEGDefaultTileSize(tif, tw, th)
TIFF* tif;
uint32* tw;
uint32* th;
{
JPEGState* sp = JState(tif);
TIFFDirectory *td = &tif->tif_dir;
(*sp->deftparent)(tif, tw, th);
*tw = TIFFroundup(*tw, td->td_ycbcrsubsampling[0] * DCTSIZE);
*th = TIFFroundup(*th, td->td_ycbcrsubsampling[1] * DCTSIZE);
}
int
ImgInitTIFFjpeg(handle, scheme)
VOID* handle;
int scheme;
{
TIFF *tif = (TIFF *) handle;
JPEGState* sp;
assert(scheme == COMPRESSION_JPEG);
if (ImgLoadJpegLibrary() != TCL_OK) {
ImgTIFFError("TIFFInitJPEG", "cannot use JPEG compression for TIFF");
return 0;
}
/*
* Allocate state block so tag methods have storage to record values.
*/
tif->tif_data = (tidata_t) ImgTIFFmalloc(sizeof (JPEGState));
if (tif->tif_data == NULL) {
ImgTIFFError("TIFFInitJPEG", "No space for JPEG state block");
return (0);
}
sp = JState(tif);
sp->tif = tif; /* back link */
/*
* Merge codec-specific tag information and
* override parent get/set field methods.
*/
ImgTIFFMergeFieldInfo(tif, jpegFieldInfo, N(jpegFieldInfo));
sp->vgetparent = tif->tif_vgetfield;
tif->tif_vgetfield = JPEGVGetField; /* hook for codec tags */
sp->vsetparent = tif->tif_vsetfield;
tif->tif_vsetfield = JPEGVSetField; /* hook for codec tags */
/* Default values for codec-specific fields */
sp->jpegtables = NULL;
sp->jpegtables_length = 0;
sp->jpegquality = 75; /* Default IJG quality */
sp->jpegcolormode = JPEGCOLORMODE_RAW;
sp->jpegtablesmode = JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF;
/*
* Install codec methods.
*/
tif->tif_setupdecode = JPEGSetupDecode;
tif->tif_predecode = JPEGPreDecode;
tif->tif_decoderow = JPEGDecode;
tif->tif_decodestrip = JPEGDecode;
tif->tif_decodetile = JPEGDecode;
tif->tif_setupencode = JPEGSetupEncode;
tif->tif_preencode = JPEGPreEncode;
tif->tif_postencode = JPEGPostEncode;
tif->tif_encoderow = JPEGEncode;
tif->tif_encodestrip = JPEGEncode;
tif->tif_encodetile = JPEGEncode;
tif->tif_cleanup = JPEGCleanup;
sp->defsparent = tif->tif_defstripsize;
tif->tif_defstripsize = JPEGDefaultStripSize;
sp->deftparent = tif->tif_deftilesize;
tif->tif_deftilesize = JPEGDefaultTileSize;
tif->tif_flags |= TIFF_NOBITREV; /* no bit reversal, please */
/*
* Initialize libjpeg.
*/
if (tif->tif_mode == O_RDONLY) {
if (!TIFFjpeg_create_decompress(sp))
return (0);
} else {
if (!TIFFjpeg_create_compress(sp))
return (0);
}
return (1);
}