Attachment #221563 for bug #306679

Lines 1-6 Link Here

(-)digikam-1.1.0.medium/libs/jpegutils/jinclude.h (-1 / +4 lines)
		1	/* Copied from jpeg-8 source. dilfridge */
		2
1	/*	3	/*
		4	* jinclude.h
2	*	5	*
3	* Copyright (C) 1991-1994, Thomas G. Lane. <tgl@netcom.com>	6	* Copyright (C) 1991-1994, Thomas G. Lane.
4	* This file is part of the Independent JPEG Group's software.	7	* This file is part of the Independent JPEG Group's software.
5	* For conditions of distribution and use, see the accompanying README file.	8	* For conditions of distribution and use, see the accompanying README file.
6	*	9	*

Lines 1-6 Link Here

(-)digikam-1.1.0.medium/libs/jpegutils/jpegint.h (-15 / +33 lines)
		1	/* Copied from jpeg-8 source. dilfridge */
		2
1	/*	3	/*
		4	* jpegint.h
2	*	5	*
3	* Copyright (C) 1991-1997, Thomas G. Lane. <tgl@netcom.com>	6	* Copyright (C) 1991-1997, Thomas G. Lane.
		7	* Modified 1997-2009 by Guido Vollbeding.
4	* This file is part of the Independent JPEG Group's software.	8	* This file is part of the Independent JPEG Group's software.
5	* For conditions of distribution and use, see the accompanying README file.	9	* For conditions of distribution and use, see the accompanying README file.
6	*	10	*
Lines 98-111 Link Here
98	};	102	};
99		103
100	/* Forward DCT (also controls coefficient quantization) */	104	/* Forward DCT (also controls coefficient quantization) */
		105	typedef JMETHOD(void, forward_DCT_ptr,
		106	(j_compress_ptr cinfo, jpeg_component_info * compptr,
		107	JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
		108	JDIMENSION start_row, JDIMENSION start_col,
		109	JDIMENSION num_blocks));
		110
101	struct jpeg_forward_dct {	111	struct jpeg_forward_dct {
102	JMETHOD(void, start_pass, (j_compress_ptr cinfo));	112	JMETHOD(void, start_pass, (j_compress_ptr cinfo));
103	/* perhaps this should be an array??? */	113	/* It is useful to allow each component to have a separate FDCT method. */
104	JMETHOD(void, forward_DCT, (j_compress_ptr cinfo,	114	forward_DCT_ptr forward_DCT[MAX_COMPONENTS];
105	jpeg_component_info * compptr,
106	JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
107	JDIMENSION start_row, JDIMENSION start_col,
108	JDIMENSION num_blocks));
109	};	115	};
110		116
111	/* Entropy encoding */	117	/* Entropy encoding */
Lines 209-218 Link Here
209	JMETHOD(void, start_pass, (j_decompress_ptr cinfo));	215	JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
210	JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,	216	JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
211	JBLOCKROW *MCU_data));	217	JBLOCKROW *MCU_data));
212
213	/* This is here to share code between baseline and progressive decoders; */
214	/* other modules probably should not use it */
215	boolean insufficient_data; /* set TRUE after emitting warning */
216	};	218	};
217		219
218	/* Inverse DCT (also performs dequantization) */	220	/* Inverse DCT (also performs dequantization) */
Lines 302-308 Link Here
302	#define jinit_downsampler jIDownsampler	304	#define jinit_downsampler jIDownsampler
303	#define jinit_forward_dct jIFDCT	305	#define jinit_forward_dct jIFDCT
304	#define jinit_huff_encoder jIHEncoder	306	#define jinit_huff_encoder jIHEncoder
305	#define jinit_phuff_encoder jIPHEncoder	307	#define jinit_arith_encoder jIAEncoder
306	#define jinit_marker_writer jIMWriter	308	#define jinit_marker_writer jIMWriter
307	#define jinit_master_decompress jIDMaster	309	#define jinit_master_decompress jIDMaster
308	#define jinit_d_main_controller jIDMainC	310	#define jinit_d_main_controller jIDMainC
Lines 311-317 Link Here
311	#define jinit_input_controller jIInCtlr	313	#define jinit_input_controller jIInCtlr
312	#define jinit_marker_reader jIMReader	314	#define jinit_marker_reader jIMReader
313	#define jinit_huff_decoder jIHDecoder	315	#define jinit_huff_decoder jIHDecoder
314	#define jinit_phuff_decoder jIPHDecoder	316	#define jinit_arith_decoder jIADecoder
315	#define jinit_inverse_dct jIIDCT	317	#define jinit_inverse_dct jIIDCT
316	#define jinit_upsampler jIUpsampler	318	#define jinit_upsampler jIUpsampler
317	#define jinit_color_deconverter jIDColor	319	#define jinit_color_deconverter jIDColor
Lines 326-331 Link Here
326	#define jzero_far jZeroFar	328	#define jzero_far jZeroFar
327	#define jpeg_zigzag_order jZIGTable	329	#define jpeg_zigzag_order jZIGTable
328	#define jpeg_natural_order jZAGTable	330	#define jpeg_natural_order jZAGTable
		331	#define jpeg_natural_order7 jZAGTable7
		332	#define jpeg_natural_order6 jZAGTable6
		333	#define jpeg_natural_order5 jZAGTable5
		334	#define jpeg_natural_order4 jZAGTable4
		335	#define jpeg_natural_order3 jZAGTable3
		336	#define jpeg_natural_order2 jZAGTable2
		337	#define jpeg_aritab jAriTab
329	#endif /* NEED_SHORT_EXTERNAL_NAMES */	338	#endif /* NEED_SHORT_EXTERNAL_NAMES */
330		339
331		340
Lines 343-349 Link Here
343	EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo));	352	EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo));
344	EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo));	353	EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo));
345	EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo));	354	EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo));
346	EXTERN(void) jinit_phuff_encoder JPP((j_compress_ptr cinfo));	355	EXTERN(void) jinit_arith_encoder JPP((j_compress_ptr cinfo));
347	EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo));	356	EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo));
348	/* Decompression module initialization routines */	357	/* Decompression module initialization routines */
349	EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo));	358	EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo));
Lines 356-362 Link Here
356	EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo));	365	EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo));
357	EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo));	366	EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo));
358	EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo));	367	EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo));
359	EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo));	368	EXTERN(void) jinit_arith_decoder JPP((j_decompress_ptr cinfo));
360	EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo));	369	EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo));
361	EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo));	370	EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo));
362	EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo));	371	EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo));
Lines 380-385 Link Here
380	extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */	389	extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */
381	#endif	390	#endif
382	extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */	391	extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */
		392	extern const int jpeg_natural_order7[]; /* zz to natural order for 7x7 block */
		393	extern const int jpeg_natural_order6[]; /* zz to natural order for 6x6 block */
		394	extern const int jpeg_natural_order5[]; /* zz to natural order for 5x5 block */
		395	extern const int jpeg_natural_order4[]; /* zz to natural order for 4x4 block */
		396	extern const int jpeg_natural_order3[]; /* zz to natural order for 3x3 block */
		397	extern const int jpeg_natural_order2[]; /* zz to natural order for 2x2 block */
		398
		399	/* Arithmetic coding probability estimation tables in jaricom.c */
		400	extern const INT32 jpeg_aritab[];
383		401
384	/* Suppress undefined-structure complaints if necessary. */	402	/* Suppress undefined-structure complaints if necessary. */
385		403




The Independent JPEG Group's JPEG software
==========================================

README for release 8 of 10-Jan-2010
===================================

This distribution contains the eighth public release of the Independent JPEG
Group's free JPEG software.  You are welcome to redistribute this software and
to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.

This software is the work of Tom Lane, Guido Vollbeding, Philip Gladstone,
Bill Allombert, Jim Boucher, Lee Crocker, Bob Friesenhahn, Ben Jackson,
Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi, Ge' Weijers,
and other members of the Independent JPEG Group.

IJG is not affiliated with the official ISO JPEG standards committee.


DOCUMENTATION ROADMAP
=====================

This file contains the following sections:

OVERVIEW            General description of JPEG and the IJG software.
LEGAL ISSUES        Copyright, lack of warranty, terms of distribution.
REFERENCES          Where to learn more about JPEG.
ARCHIVE LOCATIONS   Where to find newer versions of this software.
ACKNOWLEDGMENTS     Special thanks.
FILE FORMAT WARS    Software *not* to get.
TO DO               Plans for future IJG releases.

Other documentation files in the distribution are:

User documentation:
  install.txt       How to configure and install the IJG software.
  usage.txt         Usage instructions for cjpeg, djpeg, jpegtran,
                    rdjpgcom, and wrjpgcom.
  *.1               Unix-style man pages for programs (same info as usage.txt).
  wizard.txt        Advanced usage instructions for JPEG wizards only.
  change.log        Version-to-version change highlights.
Programmer and internal documentation:
  libjpeg.txt       How to use the JPEG library in your own programs.
  example.c         Sample code for calling the JPEG library.
  structure.txt     Overview of the JPEG library's internal structure.
  filelist.txt      Road map of IJG files.
  coderules.txt     Coding style rules --- please read if you contribute code.

Please read at least the files install.txt and usage.txt.  Some information
can also be found in the JPEG FAQ (Frequently Asked Questions) article.  See
ARCHIVE LOCATIONS below to find out where to obtain the FAQ article.

If you want to understand how the JPEG code works, we suggest reading one or
more of the REFERENCES, then looking at the documentation files (in roughly
the order listed) before diving into the code.


OVERVIEW
========

This package contains C software to implement JPEG image encoding, decoding,
and transcoding.  JPEG (pronounced "jay-peg") is a standardized compression
method for full-color and gray-scale images.

This software implements JPEG baseline, extended-sequential, and progressive
compression processes.  Provision is made for supporting all variants of these
processes, although some uncommon parameter settings aren't implemented yet.
We have made no provision for supporting the hierarchical or lossless
processes defined in the standard.

We provide a set of library routines for reading and writing JPEG image files,
plus two sample applications "cjpeg" and "djpeg", which use the library to
perform conversion between JPEG and some other popular image file formats.
The library is intended to be reused in other applications.

In order to support file conversion and viewing software, we have included
considerable functionality beyond the bare JPEG coding/decoding capability;
for example, the color quantization modules are not strictly part of JPEG
decoding, but they are essential for output to colormapped file formats or
colormapped displays.  These extra functions can be compiled out of the
library if not required for a particular application.

We have also included "jpegtran", a utility for lossless transcoding between
different JPEG processes, and "rdjpgcom" and "wrjpgcom", two simple
applications for inserting and extracting textual comments in JFIF files.

The emphasis in designing this software has been on achieving portability and
flexibility, while also making it fast enough to be useful.  In particular,
the software is not intended to be read as a tutorial on JPEG.  (See the
REFERENCES section for introductory material.)  Rather, it is intended to
be reliable, portable, industrial-strength code.  We do not claim to have
achieved that goal in every aspect of the software, but we strive for it.

We welcome the use of this software as a component of commercial products.
No royalty is required, but we do ask for an acknowledgement in product
documentation, as described under LEGAL ISSUES.


LEGAL ISSUES
============

In plain English:

1. We don't promise that this software works.  (But if you find any bugs,
   please let us know!)
2. You can use this software for whatever you want.  You don't have to pay us.
3. You may not pretend that you wrote this software.  If you use it in a
   program, you must acknowledge somewhere in your documentation that
   you've used the IJG code.

In legalese:

The authors make NO WARRANTY or representation, either express or implied,
with respect to this software, its quality, accuracy, merchantability, or
fitness for a particular purpose.  This software is provided "AS IS", and you,
its user, assume the entire risk as to its quality and accuracy.

This software is copyright (C) 1991-2010, Thomas G. Lane, Guido Vollbeding.
All Rights Reserved except as specified below.

Permission is hereby granted to use, copy, modify, and distribute this
software (or portions thereof) for any purpose, without fee, subject to these
conditions:
(1) If any part of the source code for this software is distributed, then this
README file must be included, with this copyright and no-warranty notice
unaltered; and any additions, deletions, or changes to the original files
must be clearly indicated in accompanying documentation.
(2) If only executable code is distributed, then the accompanying
documentation must state that "this software is based in part on the work of
the Independent JPEG Group".
(3) Permission for use of this software is granted only if the user accepts
full responsibility for any undesirable consequences; the authors accept
NO LIABILITY for damages of any kind.

These conditions apply to any software derived from or based on the IJG code,
not just to the unmodified library.  If you use our work, you ought to
acknowledge us.

Permission is NOT granted for the use of any IJG author's name or company name
in advertising or publicity relating to this software or products derived from
it.  This software may be referred to only as "the Independent JPEG Group's
software".

We specifically permit and encourage the use of this software as the basis of
commercial products, provided that all warranty or liability claims are
assumed by the product vendor.


ansi2knr.c is included in this distribution by permission of L. Peter Deutsch,
sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA.
ansi2knr.c is NOT covered by the above copyright and conditions, but instead
by the usual distribution terms of the Free Software Foundation; principally,
that you must include source code if you redistribute it.  (See the file
ansi2knr.c for full details.)  However, since ansi2knr.c is not needed as part
of any program generated from the IJG code, this does not limit you more than
the foregoing paragraphs do.

The Unix configuration script "configure" was produced with GNU Autoconf.
It is copyright by the Free Software Foundation but is freely distributable.
The same holds for its supporting scripts (config.guess, config.sub,
ltmain.sh).  Another support script, install-sh, is copyright by X Consortium
but is also freely distributable.

The IJG distribution formerly included code to read and write GIF files.
To avoid entanglement with the Unisys LZW patent, GIF reading support has
been removed altogether, and the GIF writer has been simplified to produce
"uncompressed GIFs".  This technique does not use the LZW algorithm; the
resulting GIF files are larger than usual, but are readable by all standard
GIF decoders.

We are required to state that
    "The Graphics Interchange Format(c) is the Copyright property of
    CompuServe Incorporated.  GIF(sm) is a Service Mark property of
    CompuServe Incorporated."


REFERENCES
==========

We recommend reading one or more of these references before trying to
understand the innards of the JPEG software.

The best short technical introduction to the JPEG compression algorithm is
	Wallace, Gregory K.  "The JPEG Still Picture Compression Standard",
	Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
(Adjacent articles in that issue discuss MPEG motion picture compression,
applications of JPEG, and related topics.)  If you don't have the CACM issue
handy, a PostScript file containing a revised version of Wallace's article is
available at http://www.ijg.org/files/wallace.ps.gz.  The file (actually
a preprint for an article that appeared in IEEE Trans. Consumer Electronics)
omits the sample images that appeared in CACM, but it includes corrections
and some added material.  Note: the Wallace article is copyright ACM and IEEE,
and it may not be used for commercial purposes.

A somewhat less technical, more leisurely introduction to JPEG can be found in
"The Data Compression Book" by Mark Nelson and Jean-loup Gailly, published by
M&T Books (New York), 2nd ed. 1996, ISBN 1-55851-434-1.  This book provides
good explanations and example C code for a multitude of compression methods
including JPEG.  It is an excellent source if you are comfortable reading C
code but don't know much about data compression in general.  The book's JPEG
sample code is far from industrial-strength, but when you are ready to look
at a full implementation, you've got one here...

The best currently available description of JPEG is the textbook "JPEG Still
Image Data Compression Standard" by William B. Pennebaker and Joan L.
Mitchell, published by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1.
Price US$59.95, 638 pp.  The book includes the complete text of the ISO JPEG
standards (DIS 10918-1 and draft DIS 10918-2).
Although this is by far the most detailed and comprehensive exposition of
JPEG publicly available, we point out that it is still missing an explanation
of the most essential properties and algorithms of the underlying DCT
technology.
If you think that you know about DCT-based JPEG after reading this book,
then you are in delusion.  The real fundamentals and corresponding potential
of DCT-based JPEG are not publicly known so far, and that is the reason for
all the mistaken developments taking place in the image coding domain.

The original JPEG standard is divided into two parts, Part 1 being the actual
specification, while Part 2 covers compliance testing methods.  Part 1 is
titled "Digital Compression and Coding of Continuous-tone Still Images,
Part 1: Requirements and guidelines" and has document numbers ISO/IEC IS
10918-1, ITU-T T.81.  Part 2 is titled "Digital Compression and Coding of
Continuous-tone Still Images, Part 2: Compliance testing" and has document
numbers ISO/IEC IS 10918-2, ITU-T T.83.
IJG JPEG 8 introduces an implementation of the JPEG SmartScale extension
which is specified in a contributed document at ITU and ISO with title "ITU-T
JPEG-Plus Proposal for Extending ITU-T T.81 for Advanced Image Coding", April
2006, Geneva, Switzerland.  The latest version of the document is Revision 3.

The JPEG standard does not specify all details of an interchangeable file
format.  For the omitted details we follow the "JFIF" conventions, revision
1.02.  JFIF 1.02 has been adopted as an Ecma International Technical Report
and thus received a formal publication status.  It is available as a free
download in PDF format from
http://www.ecma-international.org/publications/techreports/E-TR-098.htm.
A PostScript version of the JFIF document is available at
http://www.ijg.org/files/jfif.ps.gz.  There is also a plain text version at
http://www.ijg.org/files/jfif.txt.gz, but it is missing the figures.

The TIFF 6.0 file format specification can be obtained by FTP from
ftp://ftp.sgi.com/graphics/tiff/TIFF6.ps.gz.  The JPEG incorporation scheme
found in the TIFF 6.0 spec of 3-June-92 has a number of serious problems.
IJG does not recommend use of the TIFF 6.0 design (TIFF Compression tag 6).
Instead, we recommend the JPEG design proposed by TIFF Technical Note #2
(Compression tag 7).  Copies of this Note can be obtained from
http://www.ijg.org/files/.  It is expected that the next revision
of the TIFF spec will replace the 6.0 JPEG design with the Note's design.
Although IJG's own code does not support TIFF/JPEG, the free libtiff library
uses our library to implement TIFF/JPEG per the Note.


ARCHIVE LOCATIONS
=================

The "official" archive site for this software is www.ijg.org.
The most recent released version can always be found there in
directory "files".  This particular version will be archived as
http://www.ijg.org/files/jpegsrc.v8.tar.gz, and in Windows-compatible
"zip" archive format as http://www.ijg.org/files/jpegsr8.zip.

The JPEG FAQ (Frequently Asked Questions) article is a source of some
general information about JPEG.
It is available on the World Wide Web at http://www.faqs.org/faqs/jpeg-faq/
and other news.answers archive sites, including the official news.answers
archive at rtfm.mit.edu: ftp://rtfm.mit.edu/pub/usenet/news.answers/jpeg-faq/.
If you don't have Web or FTP access, send e-mail to mail-server@rtfm.mit.edu
with body
	send usenet/news.answers/jpeg-faq/part1
	send usenet/news.answers/jpeg-faq/part2


ACKNOWLEDGMENTS
===============

Thank to Juergen Bruder for providing me with a copy of the common DCT
algorithm article, only to find out that I had come to the same result
in a more direct and comprehensible way with a more generative approach.

Thank to Istvan Sebestyen and Joan L. Mitchell for inviting me to the
ITU JPEG (Study Group 16) meeting in Geneva, Switzerland.

Thank to Thomas Wiegand and Gary Sullivan for inviting me to the
Joint Video Team (MPEG & ITU) meeting in Geneva, Switzerland.

Thank to John Korejwa and Massimo Ballerini for inviting me to
fruitful consultations in Boston, MA and Milan, Italy.

Thank to Hendrik Elstner, Roland Fassauer, Simone Zuck, Guenther
Maier-Gerber, and Walter Stoeber for corresponding business development.

Thank to Nico Zschach and Dirk Stelling of the technical support team
at the Digital Images company in Halle for providing me with extra
equipment for configuration tests.

Thank to Richard F. Lyon (then of Foveon Inc.) for fruitful
communication about JPEG configuration in Sigma Photo Pro software.

Thank to Andrew Finkenstadt for hosting the ijg.org site.

Last but not least special thank to Thomas G. Lane for the original
design and development of this singular software package.


FILE FORMAT WARS
================

The ISO JPEG standards committee actually promotes different formats like
"JPEG 2000" or "JPEG XR" which are incompatible with original DCT-based
JPEG and which are based on faulty technologies.  IJG therefore does not
and will not support such momentary mistakes (see REFERENCES).
We have little or no sympathy for the promotion of these formats.  Indeed,
one of the original reasons for developing this free software was to help
force convergence on common, interoperable format standards for JPEG files.
Don't use an incompatible file format!
(In any case, our decoder will remain capable of reading existing JPEG
image files indefinitely.)


TO DO
=====

Version 8.0 is the first release of a new generation JPEG standard
to overcome the limitations of the original JPEG specification.
More features are being prepared for coming releases...

Please send bug reports, offers of help, etc. to jpeg-info@uc.ag.




/* Copied from jpeg-8 - dilfridge 
 * Modifications, following the earlier jpeg-6 version of this code: 
 *  * removed all includes 
 *  * added include transupp.h
 *  * added namespace Digicam bracket around all code
 */

/*
 * transupp.c
 *
 * Copyright (C) 1997-2009, Thomas G. Lane, Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *

namespace Digikam
{


#if TRANSFORMS_SUPPORTED

/*
 * Lossless image transformation routines.  These routines work on DCT
 * coefficient arrays and thus do not require any lossy decompression
 * or recompression of the image.
 * Thanks to Guido Vollbeding for the initial design and code of this feature,
 * and to Ben Jackson for introducing the cropping feature.
 *
 * Horizontal flipping is done in-place, using a single top-to-bottom
 * pass through the virtual source array.  It will thus be much the

 * arrays for most of the transforms.  That could result in much thrashing
 * if the image is larger than main memory.
 *
 * If cropping or trimming is involved, the destination arrays may be smaller
 * than the source arrays.  Note it is not possible to do horizontal flip
 * in-place when a nonzero Y crop offset is specified, since we'd have to move
 * data from one block row to another but the virtual array manager doesn't
 * guarantee we can touch more than one row at a time.  So in that case,
 * we have to use a separate destination array.
 *
 * Some notes about the operating environment of the individual transform
 * routines:
 * 1. Both the source and destination virtual arrays are allocated from the

 *    and we may as well take that as the effective iMCU size.
 * 4. When "trim" is in effect, the destination's dimensions will be the
 *    trimmed values but the source's will be untrimmed.
 * 5. When "crop" is in effect, the destination's dimensions will be the
 *    cropped values but the source's will be uncropped.  Each transform
 *    routine is responsible for picking up source data starting at the
 *    correct X and Y offset for the crop region.  (The X and Y offsets
 *    passed to the transform routines are measured in iMCU blocks of the
 *    destination.)
 * 6. All the routines assume that the source and destination buffers are
 *    padded out to a full iMCU boundary.  This is true, although for the
 *    source buffer it is an undocumented property of jdcoefct.c.
 * Notes 2,3,4 boil down to this: generally we should use the destination's
 * dimensions and ignore the source's.
 */


LOCAL(void)
do_crop (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
	 JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
	 jvirt_barray_ptr *src_coef_arrays,
	 jvirt_barray_ptr *dst_coef_arrays)
/* Crop.  This is only used when no rotate/flip is requested with the crop. */
{
  JDIMENSION dst_blk_y, x_crop_blocks, y_crop_blocks;
  int ci, offset_y;
  JBLOCKARRAY src_buffer, dst_buffer;
  jpeg_component_info *compptr;

  /* We simply have to copy the right amount of data (the destination's
   * image size) starting at the given X and Y offsets in the source.
   */
  for (ci = 0; ci < dstinfo->num_components; ci++) {
    compptr = dstinfo->comp_info + ci;
    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
	 dst_blk_y += compptr->v_samp_factor) {
      dst_buffer = (*srcinfo->mem->access_virt_barray)
	((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
	 (JDIMENSION) compptr->v_samp_factor, TRUE);
      src_buffer = (*srcinfo->mem->access_virt_barray)
	((j_common_ptr) srcinfo, src_coef_arrays[ci],
	 dst_blk_y + y_crop_blocks,
	 (JDIMENSION) compptr->v_samp_factor, FALSE);
      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
	jcopy_block_row(src_buffer[offset_y] + x_crop_blocks,
			dst_buffer[offset_y],
			compptr->width_in_blocks);
      }
    }
  }
}


LOCAL(void)
do_flip_h_no_crop (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
		   JDIMENSION x_crop_offset,
		   jvirt_barray_ptr *src_coef_arrays)
/* Horizontal flip; done in-place, so no separate dest array is required.
 * NB: this only works when y_crop_offset is zero.
 */
{
  JDIMENSION MCU_cols, comp_width, blk_x, blk_y, x_crop_blocks;
  int ci, k, offset_y;
  JBLOCKARRAY buffer;
  JCOEFPTR ptr1, ptr2;

   * mirroring by changing the signs of odd-numbered columns.
   * Partial iMCUs at the right edge are left untouched.
   */
  MCU_cols = srcinfo->output_width /
    (dstinfo->max_h_samp_factor * dstinfo->min_DCT_h_scaled_size);

  for (ci = 0; ci < dstinfo->num_components; ci++) {
    compptr = dstinfo->comp_info + ci;
    comp_width = MCU_cols * compptr->h_samp_factor;
    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
    for (blk_y = 0; blk_y < compptr->height_in_blocks;
	 blk_y += compptr->v_samp_factor) {
      buffer = (*srcinfo->mem->access_virt_barray)
	((j_common_ptr) srcinfo, src_coef_arrays[ci], blk_y,
	 (JDIMENSION) compptr->v_samp_factor, TRUE);
      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
	/* Do the mirroring */
	for (blk_x = 0; blk_x * 2 < comp_width; blk_x++) {
	  ptr1 = buffer[offset_y][blk_x];
	  ptr2 = buffer[offset_y][comp_width - blk_x - 1];
	  /* this unrolled loop doesn't need to know which row it's on... */
	  for (k = 0; k < DCTSIZE2; k += 2) {
	    temp1 = *ptr1;	/* swap even column */
	    temp2 = *ptr2;
	    *ptr1++ = temp2;
	    *ptr2++ = temp1;
	    temp1 = *ptr1;	/* swap odd column with sign change */
	    temp2 = *ptr2;
	    *ptr1++ = -temp2;
	    *ptr2++ = -temp1;
	  }
	}
	if (x_crop_blocks > 0) {
	  /* Now left-justify the portion of the data to be kept.
	   * We can't use a single jcopy_block_row() call because that routine
	   * depends on memcpy(), whose behavior is unspecified for overlapping
	   * source and destination areas.  Sigh.
	   */
	  for (blk_x = 0; blk_x < compptr->width_in_blocks; blk_x++) {
	    jcopy_block_row(buffer[offset_y] + blk_x + x_crop_blocks,
			    buffer[offset_y] + blk_x,
			    (JDIMENSION) 1);
	  }
	}
      }
    }
  }
}


LOCAL(void)
do_flip_h (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
	   JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
	   jvirt_barray_ptr *src_coef_arrays,
	   jvirt_barray_ptr *dst_coef_arrays)
/* Horizontal flip in general cropping case */
{
  JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y;
  JDIMENSION x_crop_blocks, y_crop_blocks;
  int ci, k, offset_y;
  JBLOCKARRAY src_buffer, dst_buffer;
  JBLOCKROW src_row_ptr, dst_row_ptr;
  JCOEFPTR src_ptr, dst_ptr;
  jpeg_component_info *compptr;

  /* Here we must output into a separate array because we can't touch
   * different rows of a single virtual array simultaneously.  Otherwise,
   * this is essentially the same as the routine above.
   */
  MCU_cols = srcinfo->output_width /
    (dstinfo->max_h_samp_factor * dstinfo->min_DCT_h_scaled_size);

  for (ci = 0; ci < dstinfo->num_components; ci++) {
    compptr = dstinfo->comp_info + ci;
    comp_width = MCU_cols * compptr->h_samp_factor;
    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
	 dst_blk_y += compptr->v_samp_factor) {
      dst_buffer = (*srcinfo->mem->access_virt_barray)
	((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
	 (JDIMENSION) compptr->v_samp_factor, TRUE);
      src_buffer = (*srcinfo->mem->access_virt_barray)
	((j_common_ptr) srcinfo, src_coef_arrays[ci],
	 dst_blk_y + y_crop_blocks,
	 (JDIMENSION) compptr->v_samp_factor, FALSE);
      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
	dst_row_ptr = dst_buffer[offset_y];
	src_row_ptr = src_buffer[offset_y];
	for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
	  if (x_crop_blocks + dst_blk_x < comp_width) {
	    /* Do the mirrorable blocks */
	    dst_ptr = dst_row_ptr[dst_blk_x];
	    src_ptr = src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];
	    /* this unrolled loop doesn't need to know which row it's on... */
	    for (k = 0; k < DCTSIZE2; k += 2) {
	      *dst_ptr++ = *src_ptr++;	 /* copy even column */
	      *dst_ptr++ = - *src_ptr++; /* copy odd column with sign change */
	    }
	  } else {
	    /* Copy last partial block(s) verbatim */
	    jcopy_block_row(src_row_ptr + dst_blk_x + x_crop_blocks,
			    dst_row_ptr + dst_blk_x,
			    (JDIMENSION) 1);
	  }
	}
      }
    }
  }


LOCAL(void)
do_flip_v (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
	   JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
	   jvirt_barray_ptr *src_coef_arrays,
	   jvirt_barray_ptr *dst_coef_arrays)
/* Vertical flip */
{
  JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
  JDIMENSION x_crop_blocks, y_crop_blocks;
  int ci, i, j, offset_y;
  JBLOCKARRAY src_buffer, dst_buffer;
  JBLOCKROW src_row_ptr, dst_row_ptr;

   * of odd-numbered rows.
   * Partial iMCUs at the bottom edge are copied verbatim.
   */
  MCU_rows = srcinfo->output_height /
    (dstinfo->max_v_samp_factor * dstinfo->min_DCT_v_scaled_size);

  for (ci = 0; ci < dstinfo->num_components; ci++) {
    compptr = dstinfo->comp_info + ci;
    comp_height = MCU_rows * compptr->v_samp_factor;
    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
	 dst_blk_y += compptr->v_samp_factor) {
      dst_buffer = (*srcinfo->mem->access_virt_barray)
	((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
	 (JDIMENSION) compptr->v_samp_factor, TRUE);
      if (y_crop_blocks + dst_blk_y < comp_height) {
	/* Row is within the mirrorable area. */
	src_buffer = (*srcinfo->mem->access_virt_barray)
	  ((j_common_ptr) srcinfo, src_coef_arrays[ci],
	   comp_height - y_crop_blocks - dst_blk_y -
	   (JDIMENSION) compptr->v_samp_factor,
	   (JDIMENSION) compptr->v_samp_factor, FALSE);
      } else {
	/* Bottom-edge blocks will be copied verbatim. */
	src_buffer = (*srcinfo->mem->access_virt_barray)
	  ((j_common_ptr) srcinfo, src_coef_arrays[ci],
	   dst_blk_y + y_crop_blocks,
	   (JDIMENSION) compptr->v_samp_factor, FALSE);
      }
      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
	if (y_crop_blocks + dst_blk_y < comp_height) {
	  /* Row is within the mirrorable area. */
	  dst_row_ptr = dst_buffer[offset_y];
	  src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
	  src_row_ptr += x_crop_blocks;
	  for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
	       dst_blk_x++) {
	    dst_ptr = dst_row_ptr[dst_blk_x];
	    src_ptr = src_row_ptr[dst_blk_x];
	    for (i = 0; i < DCTSIZE; i += 2) {
	      /* copy even row */
	      for (j = 0; j < DCTSIZE; j++)
		*dst_ptr++ = *src_ptr++;
	      /* copy odd row with sign change */
	      for (j = 0; j < DCTSIZE; j++)
		*dst_ptr++ = - *src_ptr++;
	    }
	  }
	} else {
	  /* Just copy row verbatim. */
	  jcopy_block_row(src_buffer[offset_y] + x_crop_blocks,
			  dst_buffer[offset_y],
			  compptr->width_in_blocks);
	}
      }
    }
  }


LOCAL(void)
do_transpose (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
	      JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
	      jvirt_barray_ptr *src_coef_arrays,
	      jvirt_barray_ptr *dst_coef_arrays)
/* Transpose source into destination */
{
  JDIMENSION dst_blk_x, dst_blk_y, x_crop_blocks, y_crop_blocks;
  int ci, i, j, offset_x, offset_y;
  JBLOCKARRAY src_buffer, dst_buffer;
  JCOEFPTR src_ptr, dst_ptr;

   */
  for (ci = 0; ci < dstinfo->num_components; ci++) {
    compptr = dstinfo->comp_info + ci;
    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
	 dst_blk_y += compptr->v_samp_factor) {
      dst_buffer = (*srcinfo->mem->access_virt_barray)
	((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
	 (JDIMENSION) compptr->v_samp_factor, TRUE);
      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
	for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
	     dst_blk_x += compptr->h_samp_factor) {
	  src_buffer = (*srcinfo->mem->access_virt_barray)
	    ((j_common_ptr) srcinfo, src_coef_arrays[ci],
	     dst_blk_x + x_crop_blocks,
	     (JDIMENSION) compptr->h_samp_factor, FALSE);
	  for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
	    dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
	    src_ptr = src_buffer[offset_x][dst_blk_y + offset_y + y_crop_blocks];
	    for (i = 0; i < DCTSIZE; i++)
	      for (j = 0; j < DCTSIZE; j++)
		dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
	  }
	}
      }
    }
  }


LOCAL(void)
do_rot_90 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
	   JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
	   jvirt_barray_ptr *src_coef_arrays,
	   jvirt_barray_ptr *dst_coef_arrays)
/* 90 degree rotation is equivalent to
 *   1. Transposing the image;
 *   2. Horizontal mirroring.

 */
{
  JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y;
  JDIMENSION x_crop_blocks, y_crop_blocks;
  int ci, i, j, offset_x, offset_y;
  JBLOCKARRAY src_buffer, dst_buffer;
  JCOEFPTR src_ptr, dst_ptr;

   * at the (output) right edge properly.  They just get transposed and
   * not mirrored.
   */
  MCU_cols = srcinfo->output_height /
    (dstinfo->max_h_samp_factor * dstinfo->min_DCT_h_scaled_size);

  for (ci = 0; ci < dstinfo->num_components; ci++) {
    compptr = dstinfo->comp_info + ci;
    comp_width = MCU_cols * compptr->h_samp_factor;
    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
	 dst_blk_y += compptr->v_samp_factor) {
      dst_buffer = (*srcinfo->mem->access_virt_barray)
	((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
	 (JDIMENSION) compptr->v_samp_factor, TRUE);
      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
	for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
	     dst_blk_x += compptr->h_samp_factor) {
	  if (x_crop_blocks + dst_blk_x < comp_width) {
	    /* Block is within the mirrorable area. */
	    src_buffer = (*srcinfo->mem->access_virt_barray)
	      ((j_common_ptr) srcinfo, src_coef_arrays[ci],
	       comp_width - x_crop_blocks - dst_blk_x -
	       (JDIMENSION) compptr->h_samp_factor,
	       (JDIMENSION) compptr->h_samp_factor, FALSE);
	  } else {
	    /* Edge blocks are transposed but not mirrored. */
	    src_buffer = (*srcinfo->mem->access_virt_barray)
	      ((j_common_ptr) srcinfo, src_coef_arrays[ci],
	       dst_blk_x + x_crop_blocks,
	       (JDIMENSION) compptr->h_samp_factor, FALSE);
	  }
	  for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
	    dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
	    if (x_crop_blocks + dst_blk_x < comp_width) {
	      /* Block is within the mirrorable area. */
	      src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]
		[dst_blk_y + offset_y + y_crop_blocks];
	      for (i = 0; i < DCTSIZE; i++) {
		for (j = 0; j < DCTSIZE; j++)
		  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
		i++;
		for (j = 0; j < DCTSIZE; j++)
		  dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
	      }
	    } else {
	      /* Edge blocks are transposed but not mirrored. */
	      src_ptr = src_buffer[offset_x]
		[dst_blk_y + offset_y + y_crop_blocks];
	      for (i = 0; i < DCTSIZE; i++)
		for (j = 0; j < DCTSIZE; j++)
		  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
	    }
	  }
	}
      }
    }
  }


LOCAL(void)
do_rot_270 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
	    JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
	    jvirt_barray_ptr *src_coef_arrays,
	    jvirt_barray_ptr *dst_coef_arrays)
/* 270 degree rotation is equivalent to
 *   1. Horizontal mirroring;
 *   2. Transposing the image.

 */
{
  JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
  JDIMENSION x_crop_blocks, y_crop_blocks;
  int ci, i, j, offset_x, offset_y;
  JBLOCKARRAY src_buffer, dst_buffer;
  JCOEFPTR src_ptr, dst_ptr;

   * at the (output) bottom edge properly.  They just get transposed and
   * not mirrored.
   */
  MCU_rows = srcinfo->output_width /
    (dstinfo->max_v_samp_factor * dstinfo->min_DCT_v_scaled_size);

  for (ci = 0; ci < dstinfo->num_components; ci++) {
    compptr = dstinfo->comp_info + ci;
    comp_height = MCU_rows * compptr->v_samp_factor;
    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
	 dst_blk_y += compptr->v_samp_factor) {
      dst_buffer = (*srcinfo->mem->access_virt_barray)
	((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
	 (JDIMENSION) compptr->v_samp_factor, TRUE);
      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
	for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
	     dst_blk_x += compptr->h_samp_factor) {
	  src_buffer = (*srcinfo->mem->access_virt_barray)
	    ((j_common_ptr) srcinfo, src_coef_arrays[ci],
	     dst_blk_x + x_crop_blocks,
	     (JDIMENSION) compptr->h_samp_factor, FALSE);
	  for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
	    dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
	    if (y_crop_blocks + dst_blk_y < comp_height) {
	      /* Block is within the mirrorable area. */
	      src_ptr = src_buffer[offset_x]
		[comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];
	      for (i = 0; i < DCTSIZE; i++) {
		for (j = 0; j < DCTSIZE; j++) {
		  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
		  j++;
		  dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
		}
	      }
	    } else {
	      /* Edge blocks are transposed but not mirrored. */
	      src_ptr = src_buffer[offset_x]
		[dst_blk_y + offset_y + y_crop_blocks];
	      for (i = 0; i < DCTSIZE; i++)
		for (j = 0; j < DCTSIZE; j++)
		  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
	    }
	  }
	}
      }
    }
  }


LOCAL(void)
do_rot_180 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
	    JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
	    jvirt_barray_ptr *src_coef_arrays,
	    jvirt_barray_ptr *dst_coef_arrays)
/* 180 degree rotation is equivalent to
 *   1. Vertical mirroring;
 *   2. Horizontal mirroring.

 */
{
  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
  JDIMENSION x_crop_blocks, y_crop_blocks;
  int ci, i, j, offset_y;
  JBLOCKARRAY src_buffer, dst_buffer;
  JBLOCKROW src_row_ptr, dst_row_ptr;
  JCOEFPTR src_ptr, dst_ptr;
  jpeg_component_info *compptr;

  MCU_cols = srcinfo->output_width /
    (dstinfo->max_h_samp_factor * dstinfo->min_DCT_h_scaled_size);
  MCU_rows = srcinfo->output_height /
    (dstinfo->max_v_samp_factor * dstinfo->min_DCT_v_scaled_size);

  for (ci = 0; ci < dstinfo->num_components; ci++) {
    compptr = dstinfo->comp_info + ci;
    comp_width = MCU_cols * compptr->h_samp_factor;
    comp_height = MCU_rows * compptr->v_samp_factor;
    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
	 dst_blk_y += compptr->v_samp_factor) {
      dst_buffer = (*srcinfo->mem->access_virt_barray)
	((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
	 (JDIMENSION) compptr->v_samp_factor, TRUE);
      if (y_crop_blocks + dst_blk_y < comp_height) {
	/* Row is within the vertically mirrorable area. */
	src_buffer = (*srcinfo->mem->access_virt_barray)
	  ((j_common_ptr) srcinfo, src_coef_arrays[ci],
	   comp_height - y_crop_blocks - dst_blk_y -
	   (JDIMENSION) compptr->v_samp_factor,
	   (JDIMENSION) compptr->v_samp_factor, FALSE);
      } else {
	/* Bottom-edge rows are only mirrored horizontally. */
	src_buffer = (*srcinfo->mem->access_virt_barray)
	  ((j_common_ptr) srcinfo, src_coef_arrays[ci],
	   dst_blk_y + y_crop_blocks,
	   (JDIMENSION) compptr->v_samp_factor, FALSE);
      }
      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
	dst_row_ptr = dst_buffer[offset_y];
	if (y_crop_blocks + dst_blk_y < comp_height) {
	  /* Row is within the mirrorable area. */
	  src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
	  for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
	    dst_ptr = dst_row_ptr[dst_blk_x];
	    if (x_crop_blocks + dst_blk_x < comp_width) {
	      /* Process the blocks that can be mirrored both ways. */
	      src_ptr = src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];
	      for (i = 0; i < DCTSIZE; i += 2) {
		/* For even row, negate every odd column. */
		for (j = 0; j < DCTSIZE; j += 2) {
		  *dst_ptr++ = *src_ptr++;
		  *dst_ptr++ = - *src_ptr++;
		}
		/* For odd row, negate every even column. */
		for (j = 0; j < DCTSIZE; j += 2) {
		  *dst_ptr++ = - *src_ptr++;
		  *dst_ptr++ = *src_ptr++;
		}
	      }
	    } else {
	      /* Any remaining right-edge blocks are only mirrored vertically. */
	      src_ptr = src_row_ptr[x_crop_blocks + dst_blk_x];
	      for (i = 0; i < DCTSIZE; i += 2) {
		for (j = 0; j < DCTSIZE; j++)
		  *dst_ptr++ = *src_ptr++;
		for (j = 0; j < DCTSIZE; j++)
		  *dst_ptr++ = - *src_ptr++;
	      }
	    }
	  }
	} else {
	  /* Remaining rows are just mirrored horizontally. */
	  src_row_ptr = src_buffer[offset_y];
	  for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
	    if (x_crop_blocks + dst_blk_x < comp_width) {
	      /* Process the blocks that can be mirrored. */
	      dst_ptr = dst_row_ptr[dst_blk_x];
	      src_ptr = src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];
	      for (i = 0; i < DCTSIZE2; i += 2) {
		*dst_ptr++ = *src_ptr++;
		*dst_ptr++ = - *src_ptr++;
	      }
	    } else {
	      /* Any remaining right-edge blocks are only copied. */
	      jcopy_block_row(src_row_ptr + dst_blk_x + x_crop_blocks,
			      dst_row_ptr + dst_blk_x,
			      (JDIMENSION) 1);
	    }
	  }
	}
    }
      }
    }
  }


LOCAL(void)
do_transverse (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
	       JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
	       jvirt_barray_ptr *src_coef_arrays,
	       jvirt_barray_ptr *dst_coef_arrays)
/* Transverse transpose is equivalent to
 *   1. 180 degree rotation;
 *   2. Transposition;

 */
{
  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
  JDIMENSION x_crop_blocks, y_crop_blocks;
  int ci, i, j, offset_x, offset_y;
  JBLOCKARRAY src_buffer, dst_buffer;
  JCOEFPTR src_ptr, dst_ptr;
  jpeg_component_info *compptr;

  MCU_cols = srcinfo->output_height /
    (dstinfo->max_h_samp_factor * dstinfo->min_DCT_h_scaled_size);
  MCU_rows = srcinfo->output_width /
    (dstinfo->max_v_samp_factor * dstinfo->min_DCT_v_scaled_size);

  for (ci = 0; ci < dstinfo->num_components; ci++) {
    compptr = dstinfo->comp_info + ci;
    comp_width = MCU_cols * compptr->h_samp_factor;
    comp_height = MCU_rows * compptr->v_samp_factor;
    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
	 dst_blk_y += compptr->v_samp_factor) {
      dst_buffer = (*srcinfo->mem->access_virt_barray)
	((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
	 (JDIMENSION) compptr->v_samp_factor, TRUE);
      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
	for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
	     dst_blk_x += compptr->h_samp_factor) {
	  if (x_crop_blocks + dst_blk_x < comp_width) {
	    /* Block is within the mirrorable area. */
	    src_buffer = (*srcinfo->mem->access_virt_barray)
	      ((j_common_ptr) srcinfo, src_coef_arrays[ci],
	       comp_width - x_crop_blocks - dst_blk_x -
	       (JDIMENSION) compptr->h_samp_factor,
	       (JDIMENSION) compptr->h_samp_factor, FALSE);
	  } else {
	    src_buffer = (*srcinfo->mem->access_virt_barray)
	      ((j_common_ptr) srcinfo, src_coef_arrays[ci],
	       dst_blk_x + x_crop_blocks,
	       (JDIMENSION) compptr->h_samp_factor, FALSE);
	  }
	  for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
	    dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
	    if (y_crop_blocks + dst_blk_y < comp_height) {
	      if (x_crop_blocks + dst_blk_x < comp_width) {
		/* Block is within the mirrorable area. */
		src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]
		  [comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];
		for (i = 0; i < DCTSIZE; i++) {
		  for (j = 0; j < DCTSIZE; j++) {
		    dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
		    j++;
		    dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
		  }
		  i++;
		  for (j = 0; j < DCTSIZE; j++) {
		    dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
		    j++;
		    dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
		  }
		}
	      } else {
		/* Right-edge blocks are mirrored in y only */
		src_ptr = src_buffer[offset_x]
		  [comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];
		for (i = 0; i < DCTSIZE; i++) {
		  for (j = 0; j < DCTSIZE; j++) {
		    dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
		    j++;
		    dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
		  }
		}
	      }
	    } else {
	      if (x_crop_blocks + dst_blk_x < comp_width) {
		/* Bottom-edge blocks are mirrored in x only */
		src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]
		  [dst_blk_y + offset_y + y_crop_blocks];
		for (i = 0; i < DCTSIZE; i++) {
		  for (j = 0; j < DCTSIZE; j++)
		    dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
		  i++;
		  for (j = 0; j < DCTSIZE; j++)
		    dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
		}
	      } else {
		/* At lower right corner, just transpose, no mirroring */
		src_ptr = src_buffer[offset_x]
		  [dst_blk_y + offset_y + y_crop_blocks];
		for (i = 0; i < DCTSIZE; i++)
		  for (j = 0; j < DCTSIZE; j++)
		    dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
	      }
	    }
	  }
	}
      }
    }
  }
}


/* Parse an unsigned integer: subroutine for jtransform_parse_crop_spec.
 * Returns TRUE if valid integer found, FALSE if not.
 * *strptr is advanced over the digit string, and *result is set to its value.
 */

LOCAL(boolean)
jt_read_integer (const char ** strptr, JDIMENSION * result)
{
  const char * ptr = *strptr;
  JDIMENSION val = 0;

  for (; isdigit(*ptr); ptr++) {
    val = val * 10 + (JDIMENSION) (*ptr - '0');
  }
  *result = val;
  if (ptr == *strptr)
    return FALSE;		/* oops, no digits */
  *strptr = ptr;
  return TRUE;
}


/* Parse a crop specification (written in X11 geometry style).
 * The routine returns TRUE if the spec string is valid, FALSE if not.
 *
 * The crop spec string should have the format
 *	<width>x<height>{+-}<xoffset>{+-}<yoffset>
 * where width, height, xoffset, and yoffset are unsigned integers.
 * Each of the elements can be omitted to indicate a default value.
 * (A weakness of this style is that it is not possible to omit xoffset
 * while specifying yoffset, since they look alike.)
 *
 * This code is loosely based on XParseGeometry from the X11 distribution.
 */

GLOBAL(boolean)
jtransform_parse_crop_spec (jpeg_transform_info *info, const char *spec)
{
  info->crop = FALSE;
  info->crop_width_set = JCROP_UNSET;
  info->crop_height_set = JCROP_UNSET;
  info->crop_xoffset_set = JCROP_UNSET;
  info->crop_yoffset_set = JCROP_UNSET;

  if (isdigit(*spec)) {
    /* fetch width */
    if (! jt_read_integer(&spec, &info->crop_width))
      return FALSE;
    info->crop_width_set = JCROP_POS;
  }
  if (*spec == 'x' || *spec == 'X') {	
    /* fetch height */
    spec++;
    if (! jt_read_integer(&spec, &info->crop_height))
      return FALSE;
    info->crop_height_set = JCROP_POS;
  }
  if (*spec == '+' || *spec == '-') {
    /* fetch xoffset */
    info->crop_xoffset_set = (*spec == '-') ? JCROP_NEG : JCROP_POS;
    spec++;
    if (! jt_read_integer(&spec, &info->crop_xoffset))
      return FALSE;
  }
  if (*spec == '+' || *spec == '-') {
    /* fetch yoffset */
    info->crop_yoffset_set = (*spec == '-') ? JCROP_NEG : JCROP_POS;
    spec++;
    if (! jt_read_integer(&spec, &info->crop_yoffset))
      return FALSE;
  }
  /* We had better have gotten to the end of the string. */
  if (*spec != '\0')
    return FALSE;
  info->crop = TRUE;
  return TRUE;
}


/* Trim off any partial iMCUs on the indicated destination edge */

LOCAL(void)
trim_right_edge (jpeg_transform_info *info, JDIMENSION full_width)
{
  JDIMENSION MCU_cols;

  MCU_cols = info->output_width / info->iMCU_sample_width;
  if (MCU_cols > 0 && info->x_crop_offset + MCU_cols ==
      full_width / info->iMCU_sample_width)
    info->output_width = MCU_cols * info->iMCU_sample_width;
}

LOCAL(void)
trim_bottom_edge (jpeg_transform_info *info, JDIMENSION full_height)
{
  JDIMENSION MCU_rows;

  MCU_rows = info->output_height / info->iMCU_sample_height;
  if (MCU_rows > 0 && info->y_crop_offset + MCU_rows ==
      full_height / info->iMCU_sample_height)
    info->output_height = MCU_rows * info->iMCU_sample_height;
}


/* Request any required workspace.
 *
 * This routine figures out the size that the output image will be
 * (which implies that all the transform parameters must be set before
 * it is called).
 *
 * We allocate the workspace virtual arrays from the source decompression
 * object, so that all the arrays (both the original data and the workspace)
 * will be taken into account while making memory management decisions.
 * Hence, this routine must be called after jpeg_read_header (which reads
 * the image dimensions) and before jpeg_read_coefficients (which realizes
 * the source's virtual arrays).
 *
 * This function returns FALSE right away if -perfect is given
 * and transformation is not perfect.  Otherwise returns TRUE.
 */

GLOBAL(boolean)
jtransform_request_workspace (j_decompress_ptr srcinfo,
			      jpeg_transform_info *info)
{
  jvirt_barray_ptr *coef_arrays;
  boolean need_workspace, transpose_it;
  jpeg_component_info *compptr;
  JDIMENSION xoffset, yoffset;
  JDIMENSION width_in_iMCUs, height_in_iMCUs;
  JDIMENSION width_in_blocks, height_in_blocks;
  int ci, h_samp_factor, v_samp_factor;

  /* Determine number of components in output image */
  if (info->force_grayscale &&
      srcinfo->jpeg_color_space == JCS_YCbCr &&
      srcinfo->num_components == 3)
    /* We'll only process the first component */
    info->num_components = 1;
  else
    /* Process all the components */
    info->num_components = srcinfo->num_components;

  /* Compute output image dimensions and related values. */
  jpeg_core_output_dimensions(srcinfo);

  /* Return right away if -perfect is given and transformation is not perfect.
   */
  if (info->perfect) {
    if (info->num_components == 1) {
      if (!jtransform_perfect_transform(srcinfo->output_width,
	  srcinfo->output_height,
	  srcinfo->min_DCT_h_scaled_size,
	  srcinfo->min_DCT_v_scaled_size,
	  info->transform))
	return FALSE;
    } else {
      if (!jtransform_perfect_transform(srcinfo->output_width,
	  srcinfo->output_height,
	  srcinfo->max_h_samp_factor * srcinfo->min_DCT_h_scaled_size,
	  srcinfo->max_v_samp_factor * srcinfo->min_DCT_v_scaled_size,
	  info->transform))
	return FALSE;
    }
  }

  /* If there is only one output component, force the iMCU size to be 1;
   * else use the source iMCU size.  (This allows us to do the right thing
   * when reducing color to grayscale, and also provides a handy way of
   * cleaning up "funny" grayscale images whose sampling factors are not 1x1.)
   */
  switch (info->transform) {
  case JXFORM_TRANSPOSE:
  case JXFORM_TRANSVERSE:
  case JXFORM_ROT_90:
  case JXFORM_ROT_270:
    info->output_width = srcinfo->output_height;
    info->output_height = srcinfo->output_width;
    if (info->num_components == 1) {
      info->iMCU_sample_width = srcinfo->min_DCT_v_scaled_size;
      info->iMCU_sample_height = srcinfo->min_DCT_h_scaled_size;
    } else {
      info->iMCU_sample_width =
	srcinfo->max_v_samp_factor * srcinfo->min_DCT_v_scaled_size;
      info->iMCU_sample_height =
	srcinfo->max_h_samp_factor * srcinfo->min_DCT_h_scaled_size;
    }
    break;
  default:
    info->output_width = srcinfo->output_width;
    info->output_height = srcinfo->output_height;
    if (info->num_components == 1) {
      info->iMCU_sample_width = srcinfo->min_DCT_h_scaled_size;
      info->iMCU_sample_height = srcinfo->min_DCT_v_scaled_size;
    } else {
      info->iMCU_sample_width =
	srcinfo->max_h_samp_factor * srcinfo->min_DCT_h_scaled_size;
      info->iMCU_sample_height =
	srcinfo->max_v_samp_factor * srcinfo->min_DCT_v_scaled_size;
    }
    break;
  }

  /* If cropping has been requested, compute the crop area's position and
   * dimensions, ensuring that its upper left corner falls at an iMCU boundary.
   */
  if (info->crop) {
    /* Insert default values for unset crop parameters */
    if (info->crop_xoffset_set == JCROP_UNSET)
      info->crop_xoffset = 0;	/* default to +0 */
    if (info->crop_yoffset_set == JCROP_UNSET)
      info->crop_yoffset = 0;	/* default to +0 */
    if (info->crop_xoffset >= info->output_width ||
	info->crop_yoffset >= info->output_height)
      ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);
    if (info->crop_width_set == JCROP_UNSET)
      info->crop_width = info->output_width - info->crop_xoffset;
    if (info->crop_height_set == JCROP_UNSET)
      info->crop_height = info->output_height - info->crop_yoffset;
    /* Ensure parameters are valid */
    if (info->crop_width <= 0 || info->crop_width > info->output_width ||
	info->crop_height <= 0 || info->crop_height > info->output_height ||
	info->crop_xoffset > info->output_width - info->crop_width ||
	info->crop_yoffset > info->output_height - info->crop_height)
      ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);
    /* Convert negative crop offsets into regular offsets */
    if (info->crop_xoffset_set == JCROP_NEG)
      xoffset = info->output_width - info->crop_width - info->crop_xoffset;
    else
      xoffset = info->crop_xoffset;
    if (info->crop_yoffset_set == JCROP_NEG)
      yoffset = info->output_height - info->crop_height - info->crop_yoffset;
    else
      yoffset = info->crop_yoffset;
    /* Now adjust so that upper left corner falls at an iMCU boundary */
    info->output_width =
      info->crop_width + (xoffset % info->iMCU_sample_width);
    info->output_height =
      info->crop_height + (yoffset % info->iMCU_sample_height);
    /* Save x/y offsets measured in iMCUs */
    info->x_crop_offset = xoffset / info->iMCU_sample_width;
    info->y_crop_offset = yoffset / info->iMCU_sample_height;
  } else {
    info->x_crop_offset = 0;
    info->y_crop_offset = 0;
  }

  /* Figure out whether we need workspace arrays,
   * and if so whether they are transposed relative to the source.
   */
  need_workspace = FALSE;
  transpose_it = FALSE;
  switch (info->transform) {
  case JXFORM_NONE:
    if (info->x_crop_offset != 0 || info->y_crop_offset != 0)
      need_workspace = TRUE;
    /* No workspace needed if neither cropping nor transforming */
    break;
  case JXFORM_FLIP_H:
    if (info->trim)
      trim_right_edge(info, srcinfo->output_width);
    if (info->y_crop_offset != 0)
      need_workspace = TRUE;
    /* do_flip_h_no_crop doesn't need a workspace array */
    break;
  case JXFORM_FLIP_V:
    if (info->trim)
      trim_bottom_edge(info, srcinfo->output_height);
    /* Need workspace arrays having same dimensions as source image. */
    need_workspace = TRUE;
     */
    coef_arrays = (jvirt_barray_ptr *)
      (*srcinfo->mem->alloc_small) ((j_common_ptr) srcinfo, JPOOL_IMAGE,
    SIZEOF(jvirt_barray_ptr) * info->num_components);
    for (ci = 0; ci < info->num_components; ci++) {
      compptr = srcinfo->comp_info + ci;
      coef_arrays[ci] = (*srcinfo->mem->request_virt_barray)
    ((j_common_ptr) srcinfo, JPOOL_IMAGE, false,
     (JDIMENSION) jround_up((long) compptr->width_in_blocks,
                (long) compptr->h_samp_factor),
     (JDIMENSION) jround_up((long) compptr->height_in_blocks,
                (long) compptr->v_samp_factor),
     (JDIMENSION) compptr->v_samp_factor);
    }
    break;
  case JXFORM_TRANSPOSE:
    /* transpose does NOT have to trim anything */
    /* Need workspace arrays having transposed dimensions. */
    need_workspace = TRUE;
    transpose_it = TRUE;
    break;
  case JXFORM_TRANSVERSE:
    if (info->trim) {
      trim_right_edge(info, srcinfo->output_height);
      trim_bottom_edge(info, srcinfo->output_width);
    }
    /* Need workspace arrays having transposed dimensions. */
    need_workspace = TRUE;
    transpose_it = TRUE;
    break;
  case JXFORM_ROT_90:
    if (info->trim)
      trim_right_edge(info, srcinfo->output_height);
    /* Need workspace arrays having transposed dimensions. */
    need_workspace = TRUE;
    transpose_it = TRUE;
    break;
  case JXFORM_ROT_180:
    if (info->trim) {
      trim_right_edge(info, srcinfo->output_width);
      trim_bottom_edge(info, srcinfo->output_height);
    }
    /* Need workspace arrays having same dimensions as source image. */
    need_workspace = TRUE;
    break;
  case JXFORM_ROT_270:
    if (info->trim)
      trim_bottom_edge(info, srcinfo->output_width);
    /* Need workspace arrays having transposed dimensions. */
    need_workspace = TRUE;
    transpose_it = TRUE;
    break;
  }

  /* Allocate workspace if needed.
   * Note that we allocate arrays padded out to the next iMCU boundary,
   * so that transform routines need not worry about missing edge blocks.
   */
  if (need_workspace) {
    coef_arrays = (jvirt_barray_ptr *)
      (*srcinfo->mem->alloc_small) ((j_common_ptr) srcinfo, JPOOL_IMAGE,
		SIZEOF(jvirt_barray_ptr) * info->num_components);
    width_in_iMCUs = (JDIMENSION)
      jdiv_round_up((long) info->output_width,
		    (long) info->iMCU_sample_width);
    height_in_iMCUs = (JDIMENSION)
      jdiv_round_up((long) info->output_height,
		    (long) info->iMCU_sample_height);
    for (ci = 0; ci < info->num_components; ci++) {
      compptr = srcinfo->comp_info + ci;
      if (info->num_components == 1) {
	/* we're going to force samp factors to 1x1 in this case */
	h_samp_factor = v_samp_factor = 1;
      } else if (transpose_it) {
	h_samp_factor = compptr->v_samp_factor;
	v_samp_factor = compptr->h_samp_factor;
      } else {
	h_samp_factor = compptr->h_samp_factor;
	v_samp_factor = compptr->v_samp_factor;
      }
      width_in_blocks = width_in_iMCUs * h_samp_factor;
      height_in_blocks = height_in_iMCUs * v_samp_factor;
      coef_arrays[ci] = (*srcinfo->mem->request_virt_barray)
	((j_common_ptr) srcinfo, JPOOL_IMAGE, FALSE,
	 width_in_blocks, height_in_blocks, (JDIMENSION) v_samp_factor);
                (long) compptr->v_samp_factor),
     (JDIMENSION) jround_up((long) compptr->width_in_blocks,
                (long) compptr->h_samp_factor),
     (JDIMENSION) compptr->h_samp_factor);
    }
    info->workspace_coef_arrays = coef_arrays;
  } else
    info->workspace_coef_arrays = NULL;

  return TRUE;
}



  int tblno, i, j, ci, itemp;
  jpeg_component_info *compptr;
  JQUANT_TBL *qtblptr;
  JDIMENSION jtemp;
  UINT16 qtemp;

  /* Transpose image dimensions */
  jtemp = dstinfo->image_width;
  dstinfo->image_width = dstinfo->image_height;
  dstinfo->image_height = jtemp;
  itemp = dstinfo->min_DCT_h_scaled_size;
  dstinfo->min_DCT_h_scaled_size = dstinfo->min_DCT_v_scaled_size;
  dstinfo->min_DCT_v_scaled_size = itemp;

  /* Transpose sampling factors */
  for (ci = 0; ci < dstinfo->num_components; ci++) {

    qtblptr = dstinfo->quant_tbl_ptrs[tblno];
    if (qtblptr != NULL) {
      for (i = 0; i < DCTSIZE; i++) {
	for (j = 0; j < i; j++) {
	  qtemp = qtblptr->quantval[i*DCTSIZE+j];
	  qtblptr->quantval[i*DCTSIZE+j] = qtblptr->quantval[j*DCTSIZE+i];
	  qtblptr->quantval[j*DCTSIZE+i] = qtemp;
	}
      }
    }
  }
}


/* Adjust Exif image parameters.
 *
 * We try to adjust the Tags ExifImageWidth and ExifImageHeight if possible.
 */

LOCAL(void)
adjust_exif_parameters (JOCTET FAR * data, unsigned int length,
			JDIMENSION new_width, JDIMENSION new_height)
{
  boolean is_motorola; /* Flag for byte order */
  unsigned int number_of_tags, tagnum;
  unsigned int firstoffset, offset;
  JDIMENSION new_value;

  if (length < 12) return; /* Length of an IFD entry */

  /* Discover byte order */
  if (GETJOCTET(data[0]) == 0x49 && GETJOCTET(data[1]) == 0x49)
    is_motorola = FALSE;
  else if (GETJOCTET(data[0]) == 0x4D && GETJOCTET(data[1]) == 0x4D)
    is_motorola = TRUE;
  else
    return;

  /* Check Tag Mark */
  if (is_motorola) {
    if (GETJOCTET(data[2]) != 0) return;
    if (GETJOCTET(data[3]) != 0x2A) return;
  } else {
    if (GETJOCTET(data[3]) != 0) return;
    if (GETJOCTET(data[2]) != 0x2A) return;
  }

  /* Get first IFD offset (offset to IFD0) */
  if (is_motorola) {
    if (GETJOCTET(data[4]) != 0) return;
    if (GETJOCTET(data[5]) != 0) return;
    firstoffset = GETJOCTET(data[6]);
    firstoffset <<= 8;
    firstoffset += GETJOCTET(data[7]);
  } else {
    if (GETJOCTET(data[7]) != 0) return;
    if (GETJOCTET(data[6]) != 0) return;
    firstoffset = GETJOCTET(data[5]);
    firstoffset <<= 8;
    firstoffset += GETJOCTET(data[4]);
  }
  if (firstoffset > length - 2) return; /* check end of data segment */
  if (MCU_cols > 0)        /* can't trim to 0 pixels */
    dstinfo->image_width = MCU_cols * (max_h_samp_factor * DCTSIZE);
}

  /* Get the number of directory entries contained in this IFD */
  if (is_motorola) {
    number_of_tags = GETJOCTET(data[firstoffset]);
    number_of_tags <<= 8;
    number_of_tags += GETJOCTET(data[firstoffset+1]);
  } else {
    number_of_tags = GETJOCTET(data[firstoffset+1]);
    number_of_tags <<= 8;
    number_of_tags += GETJOCTET(data[firstoffset]);
  }
  if (number_of_tags == 0) return;
  firstoffset += 2;

  /* Search for ExifSubIFD offset Tag in IFD0 */
  for (;;) {
    if (firstoffset > length - 12) return; /* check end of data segment */
    /* Get Tag number */
    if (is_motorola) {
      tagnum = GETJOCTET(data[firstoffset]);
      tagnum <<= 8;
      tagnum += GETJOCTET(data[firstoffset+1]);
    } else {
      tagnum = GETJOCTET(data[firstoffset+1]);
      tagnum <<= 8;
      tagnum += GETJOCTET(data[firstoffset]);
    }
    if (tagnum == 0x8769) break; /* found ExifSubIFD offset Tag */
    if (--number_of_tags == 0) return;
    firstoffset += 12;
  }

  /* Get the ExifSubIFD offset */
  if (is_motorola) {
    if (GETJOCTET(data[firstoffset+8]) != 0) return;
    if (GETJOCTET(data[firstoffset+9]) != 0) return;
    offset = GETJOCTET(data[firstoffset+10]);
    offset <<= 8;
    offset += GETJOCTET(data[firstoffset+11]);
  } else {
    if (GETJOCTET(data[firstoffset+11]) != 0) return;
    if (GETJOCTET(data[firstoffset+10]) != 0) return;
    offset = GETJOCTET(data[firstoffset+9]);
    offset <<= 8;
    offset += GETJOCTET(data[firstoffset+8]);
  }
  if (offset > length - 2) return; /* check end of data segment */

  /* Get the number of directory entries contained in this SubIFD */
  if (is_motorola) {
    number_of_tags = GETJOCTET(data[offset]);
    number_of_tags <<= 8;
    number_of_tags += GETJOCTET(data[offset+1]);
  } else {
    number_of_tags = GETJOCTET(data[offset+1]);
    number_of_tags <<= 8;
    number_of_tags += GETJOCTET(data[offset]);
  }
  if (number_of_tags < 2) return;
  offset += 2;

  /* Search for ExifImageWidth and ExifImageHeight Tags in this SubIFD */
  do {
    if (offset > length - 12) return; /* check end of data segment */
    /* Get Tag number */
    if (is_motorola) {
      tagnum = GETJOCTET(data[offset]);
      tagnum <<= 8;
      tagnum += GETJOCTET(data[offset+1]);
    } else {
      tagnum = GETJOCTET(data[offset+1]);
      tagnum <<= 8;
      tagnum += GETJOCTET(data[offset]);
    }
    if (tagnum == 0xA002 || tagnum == 0xA003) {
      if (tagnum == 0xA002)
	new_value = new_width; /* ExifImageWidth Tag */
      else
	new_value = new_height; /* ExifImageHeight Tag */
      if (is_motorola) {
	data[offset+2] = 0; /* Format = unsigned long (4 octets) */
	data[offset+3] = 4;
	data[offset+4] = 0; /* Number Of Components = 1 */
	data[offset+5] = 0;
	data[offset+6] = 0;
	data[offset+7] = 1;
	data[offset+8] = 0;
	data[offset+9] = 0;
	data[offset+10] = (JOCTET)((new_value >> 8) & 0xFF);
	data[offset+11] = (JOCTET)(new_value & 0xFF);
      } else {
	data[offset+2] = 4; /* Format = unsigned long (4 octets) */
	data[offset+3] = 0;
	data[offset+4] = 1; /* Number Of Components = 1 */
	data[offset+5] = 0;
	data[offset+6] = 0;
	data[offset+7] = 0;
	data[offset+8] = (JOCTET)(new_value & 0xFF);
	data[offset+9] = (JOCTET)((new_value >> 8) & 0xFF);
	data[offset+10] = 0;
	data[offset+11] = 0;
      }
    }
    offset += 12;
  } while (--number_of_tags);
}



 */

GLOBAL(jvirt_barray_ptr *)
jtransform_adjust_parameters (j_decompress_ptr srcinfo,
			      j_compress_ptr dstinfo,
			      jvirt_barray_ptr *src_coef_arrays,
			      jpeg_transform_info *info)
{
  /* If force-to-grayscale is requested, adjust destination parameters */
  if (info->force_grayscale) {
    /* First, ensure we have YCbCr or grayscale data, and that the source's
     * Y channel is full resolution.  (No reasonable person would make Y
     * be less than full resolution, so actually coping with that case
     * isn't worth extra code space.  But we check it to avoid crashing.)
     * provides an easy way of coercing a grayscale JPEG with funny sampling
     * factors to the customary 1,1.  (Some decoders fail on other factors.)
     */
    if (((dstinfo->jpeg_color_space == JCS_YCbCr &&
	  dstinfo->num_components == 3) ||
	 (dstinfo->jpeg_color_space == JCS_GRAYSCALE &&
	  dstinfo->num_components == 1)) &&
	srcinfo->comp_info[0].h_samp_factor == srcinfo->max_h_samp_factor &&
	srcinfo->comp_info[0].v_samp_factor == srcinfo->max_v_samp_factor) {
      /* We use jpeg_set_colorspace to make sure subsidiary settings get fixed
       * properly.  Among other things, it sets the target h_samp_factor &
       * v_samp_factor to 1, which typically won't match the source.
       * We have to preserve the source's quantization table number, however.
       */
      int sv_quant_tbl_no = dstinfo->comp_info[0].quant_tbl_no;
      jpeg_set_colorspace(dstinfo, JCS_GRAYSCALE);
      dstinfo->comp_info[0].quant_tbl_no = sv_quant_tbl_no;

      /* Sorry, can't do it */
      ERREXIT(dstinfo, JERR_CONVERSION_NOTIMPL);
    }
  } else if (info->num_components == 1) {
    /* For a single-component source, we force the destination sampling factors
     * to 1x1, with or without force_grayscale.  This is useful because some
     * decoders choke on grayscale images with other sampling factors.
     */
    dstinfo->comp_info[0].h_samp_factor = 1;
    dstinfo->comp_info[0].v_samp_factor = 1;
  }

  /* Correct the destination's image dimensions as necessary
   * for rotate/flip, resize, and crop operations.
   */
  dstinfo->jpeg_width = info->output_width;
  dstinfo->jpeg_height = info->output_height;

  /* Transpose destination image parameters */
  switch (info->transform) {
  case JXFORM_NONE:
    /* Nothing to do */
    break;
  case JXFORM_FLIP_H:
    if (info->trim)
      trim_right_edge(dstinfo);
    break;
  case JXFORM_FLIP_V:
    if (info->trim)
      trim_bottom_edge(dstinfo);
    break;
  case JXFORM_TRANSPOSE:
    transpose_critical_parameters(dstinfo);
    /* transpose does NOT have to trim anything */
    break;
  case JXFORM_TRANSVERSE:
    transpose_critical_parameters(dstinfo);
    if (info->trim) {
      trim_right_edge(dstinfo);
      trim_bottom_edge(dstinfo);
    }
    break;
  case JXFORM_ROT_90:
    transpose_critical_parameters(dstinfo);
    if (info->trim)
      trim_right_edge(dstinfo);
    break;
  case JXFORM_ROT_180:
    if (info->trim) {
      trim_right_edge(dstinfo);
      trim_bottom_edge(dstinfo);
    }
    break;
  case JXFORM_ROT_270:
    transpose_critical_parameters(dstinfo);
    if (info->trim)
      trim_bottom_edge(dstinfo);
    break;
  default:
    break;
  }

  /* Adjust Exif properties */
  if (srcinfo->marker_list != NULL &&
      srcinfo->marker_list->marker == JPEG_APP0+1 &&
      srcinfo->marker_list->data_length >= 6 &&
      GETJOCTET(srcinfo->marker_list->data[0]) == 0x45 &&
      GETJOCTET(srcinfo->marker_list->data[1]) == 0x78 &&
      GETJOCTET(srcinfo->marker_list->data[2]) == 0x69 &&
      GETJOCTET(srcinfo->marker_list->data[3]) == 0x66 &&
      GETJOCTET(srcinfo->marker_list->data[4]) == 0 &&
      GETJOCTET(srcinfo->marker_list->data[5]) == 0) {
    /* Suppress output of JFIF marker */
    dstinfo->write_JFIF_header = FALSE;
    /* Adjust Exif image parameters */
    if (dstinfo->jpeg_width != srcinfo->image_width ||
	dstinfo->jpeg_height != srcinfo->image_height)
      /* Align data segment to start of TIFF structure for parsing */
      adjust_exif_parameters(srcinfo->marker_list->data + 6,
	srcinfo->marker_list->data_length - 6,
	dstinfo->jpeg_width, dstinfo->jpeg_height);
  }

  /* Return the appropriate output data set */

 */

GLOBAL(void)
jtransform_execute_transform (j_decompress_ptr srcinfo,
			      j_compress_ptr dstinfo,
			      jvirt_barray_ptr *src_coef_arrays,
			      jpeg_transform_info *info)
{
  jvirt_barray_ptr *dst_coef_arrays = info->workspace_coef_arrays;

  /* Note: conditions tested here should match those in switch statement
   * in jtransform_request_workspace()
   */
  switch (info->transform) {
  case JXFORM_NONE:
    if (info->x_crop_offset != 0 || info->y_crop_offset != 0)
      do_crop(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
	      src_coef_arrays, dst_coef_arrays);
    break;
  case JXFORM_FLIP_H:
    if (info->y_crop_offset != 0)
      do_flip_h(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
		src_coef_arrays, dst_coef_arrays);
    else
      do_flip_h_no_crop(srcinfo, dstinfo, info->x_crop_offset,
			src_coef_arrays);
    break;
  case JXFORM_FLIP_V:
    do_flip_v(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
	      src_coef_arrays, dst_coef_arrays);
    break;
  case JXFORM_TRANSPOSE:
    do_transpose(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
		 src_coef_arrays, dst_coef_arrays);
    break;
  case JXFORM_TRANSVERSE:
    do_transverse(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
		  src_coef_arrays, dst_coef_arrays);
    break;
  case JXFORM_ROT_90:
    do_rot_90(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
	      src_coef_arrays, dst_coef_arrays);
    break;
  case JXFORM_ROT_180:
    do_rot_180(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
	       src_coef_arrays, dst_coef_arrays);
    break;
  case JXFORM_ROT_270:
    do_rot_270(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
	       src_coef_arrays, dst_coef_arrays);
    break;
  }
}

/* jtransform_perfect_transform
 *
 * Determine whether lossless transformation is perfectly
 * possible for a specified image and transformation.
 *
 * Inputs:
 *   image_width, image_height: source image dimensions.
 *   MCU_width, MCU_height: pixel dimensions of MCU.
 *   transform: transformation identifier.
 * Parameter sources from initialized jpeg_struct
 * (after reading source header):
 *   image_width = cinfo.image_width
 *   image_height = cinfo.image_height
 *   MCU_width = cinfo.max_h_samp_factor * cinfo.block_size
 *   MCU_height = cinfo.max_v_samp_factor * cinfo.block_size
 * Result:
 *   TRUE = perfect transformation possible
 *   FALSE = perfect transformation not possible
 *           (may use custom action then)
 */

GLOBAL(boolean)
jtransform_perfect_transform(JDIMENSION image_width, JDIMENSION image_height,
			     int MCU_width, int MCU_height,
			     JXFORM_CODE transform)
{
  boolean result = TRUE; /* initialize TRUE */

  switch (transform) {
  case JXFORM_FLIP_H:
  case JXFORM_ROT_270:
    if (image_width % (JDIMENSION) MCU_width)
      result = FALSE;
    break;
  case JXFORM_FLIP_V:
  case JXFORM_ROT_90:
    if (image_height % (JDIMENSION) MCU_height)
      result = FALSE;
    break;
  case JXFORM_TRANSVERSE:
  case JXFORM_ROT_180:
    if (image_width % (JDIMENSION) MCU_width)
      result = FALSE;
    if (image_height % (JDIMENSION) MCU_height)
      result = FALSE;
    break;
  default:
    break;
  }

  return result;
}

#endif /* TRANSFORMS_SUPPORTED */


GLOBAL(void)
jcopy_markers_execute (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
		       JCOPY_OPTION option)
{
  jpeg_saved_marker_ptr marker;


   */
  for (marker = srcinfo->marker_list; marker != NULL; marker = marker->next) {
    if (dstinfo->write_JFIF_header &&
	marker->marker == JPEG_APP0 &&
	marker->data_length >= 5 &&
	GETJOCTET(marker->data[0]) == 0x4A &&
	GETJOCTET(marker->data[1]) == 0x46 &&
	GETJOCTET(marker->data[2]) == 0x49 &&
	GETJOCTET(marker->data[3]) == 0x46 &&
	GETJOCTET(marker->data[4]) == 0)
      continue;			/* reject duplicate JFIF */
    if (dstinfo->write_Adobe_marker &&
	marker->marker == JPEG_APP0+14 &&
	marker->data_length >= 5 &&
	GETJOCTET(marker->data[0]) == 0x41 &&
	GETJOCTET(marker->data[1]) == 0x64 &&
	GETJOCTET(marker->data[2]) == 0x6F &&
	GETJOCTET(marker->data[3]) == 0x62 &&
	GETJOCTET(marker->data[4]) == 0x65)
      continue;			/* reject duplicate Adobe */
#ifdef NEED_FAR_POINTERS
    /* We could use jpeg_write_marker if the data weren't FAR... */
    {
      unsigned int i;
      jpeg_write_m_header(dstinfo, marker->marker, marker->data_length);
      for (i = 0; i < marker->data_length; i++)
	jpeg_write_m_byte(dstinfo, marker->data[i]);
    }
#else
    jpeg_write_marker(dstinfo, marker->marker,
		      marker->data, marker->data_length);
#endif
  }
}



} // namespace Digikam

Lines 1-7 Link Here

(-)digikam-1.1.0.medium/libs/jpegutils/transupp.h (-48 / +136 lines)
		1	/* Copied from jpeg-8
		2	* Modifications: see comments in code marked with dilfridge
		3	*/
		4
1	/*	5	/*
2	* transupp.h	6	* transupp.h
3	*	7	*
4	* Copyright (C) 1997, Thomas G. Lane. <tgl@netcom.com>	8	* Copyright (C) 1997-2009, Thomas G. Lane, Guido Vollbeding.
5	* This file is part of the Independent JPEG Group's software.	9	* This file is part of the Independent JPEG Group's software.
6	* For conditions of distribution and use, see the accompanying README file.	10	* For conditions of distribution and use, see the accompanying README file.
7	*	11	*
Lines 17-22 Link Here
17	* jpegtran.c for an example of correct usage.	21	* jpegtran.c for an example of correct usage.
18	*/	22	*/
19		23
		24	/* start inserted code - dilfridge */
		25
20	#ifndef TRANSUPP_H	26	#ifndef TRANSUPP_H
21	#define TRANSUPP_H	27	#define TRANSUPP_H
22		28
Lines 26-67 Link Here
26	{	32	{
27	#include "jinclude.h"	33	#include "jinclude.h"
28	#include "jpeglib.h"	34	#include "jpeglib.h"
		35	#include <ctype.h> /* to declare isdigit() */
29	}	36	}
30		37
31	namespace Digikam	38	namespace Digikam
32	{	39	{
33		40
		41	/* end inserted code - dilfridge */
		42
34	/* If you happen not to want the image transform support, disable it here */	43	/* If you happen not to want the image transform support, disable it here */
35	#ifndef TRANSFORMS_SUPPORTED	44	#ifndef TRANSFORMS_SUPPORTED
36	#define TRANSFORMS_SUPPORTED 1 /* 0 disables transform code */	45	#define TRANSFORMS_SUPPORTED 1 /* 0 disables transform code */
37	#endif	46	#endif
38		47
39	/* Short forms of external names for systems with brain-damaged linkers. */
40
41	#ifdef NEED_SHORT_EXTERNAL_NAMES
42	#define jtransform_request_workspace jTrRequest
43	#define jtransform_adjust_parameters jTrAdjust
44	#define jtransform_execute_transformation jTrExec
45	#define jcopy_markers_setup jCMrkSetup
46	#define jcopy_markers_execute jCMrkExec
47	#endif /* NEED_SHORT_EXTERNAL_NAMES */
48
49
50	/*
51	* Codes for supported types of image transformations.
52	*/
53
54	typedef enum {
55	JXFORM_NONE, /* no transformation */
56	JXFORM_FLIP_H, /* horizontal flip */
57	JXFORM_FLIP_V, /* vertical flip */
58	JXFORM_TRANSPOSE, /* transpose across UL-to-LR axis */
59	JXFORM_TRANSVERSE, /* transpose across UR-to-LL axis */
60	JXFORM_ROT_90, /* 90-degree clockwise rotation */
61	JXFORM_ROT_180, /* 180-degree rotation */
62	JXFORM_ROT_270 /* 270-degree clockwise (or 90 ccw) */
63	} JXFORM_CODE;
64
65	/*	48	/*
66	* Although rotating and flipping data expressed as DCT coefficients is not	49	* Although rotating and flipping data expressed as DCT coefficients is not
67	* hard, there is an asymmetry in the JPEG format specification for images	50	* hard, there is an asymmetry in the JPEG format specification for images
Lines 89-94 Link Here
89	* (For example, -rot 270 -trim trims only the bottom edge, but -rot 90 -trim	72	* (For example, -rot 270 -trim trims only the bottom edge, but -rot 90 -trim
90	* followed by -rot 180 -trim trims both edges.)	73	* followed by -rot 180 -trim trims both edges.)
91	*	74	*
		75	* We also offer a lossless-crop option, which discards data outside a given
		76	* image region but losslessly preserves what is inside. Like the rotate and
		77	* flip transforms, lossless crop is restricted by the JPEG format: the upper
		78	* left corner of the selected region must fall on an iMCU boundary. If this
		79	* does not hold for the given crop parameters, we silently move the upper left
		80	* corner up and/or left to make it so, simultaneously increasing the region
		81	* dimensions to keep the lower right crop corner unchanged. (Thus, the
		82	* output image covers at least the requested region, but may cover more.)
		83	*
		84	* We also provide a lossless-resize option, which is kind of a lossless-crop
		85	* operation in the DCT coefficient block domain - it discards higher-order
		86	* coefficients and losslessly preserves lower-order coefficients of a
		87	* sub-block.
		88	*
		89	* Rotate/flip transform, resize, and crop can be requested together in a
		90	* single invocation. The crop is applied last --- that is, the crop region
		91	* is specified in terms of the destination image after transform/resize.
		92	*
92	* We also offer a "force to grayscale" option, which simply discards the	93	* We also offer a "force to grayscale" option, which simply discards the
93	* chrominance channels of a YCbCr image. This is lossless in the sense that	94	* chrominance channels of a YCbCr image. This is lossless in the sense that
94	* the luminance channel is preserved exactly. It's not the same kind of	95	* the luminance channel is preserved exactly. It's not the same kind of
Lines 97-129 Link Here
97	* be aware of the option to know how many components to work on.	98	* be aware of the option to know how many components to work on.
98	*/	99	*/
99		100
		101
		102	/* Short forms of external names for systems with brain-damaged linkers. */
		103
		104	#ifdef NEED_SHORT_EXTERNAL_NAMES
		105	#define jtransform_parse_crop_spec jTrParCrop
		106	#define jtransform_request_workspace jTrRequest
		107	#define jtransform_adjust_parameters jTrAdjust
		108	#define jtransform_execute_transform jTrExec
		109	#define jtransform_perfect_transform jTrPerfect
		110	#define jcopy_markers_setup jCMrkSetup
		111	#define jcopy_markers_execute jCMrkExec
		112	#endif /* NEED_SHORT_EXTERNAL_NAMES */
		113
		114
		115	/*
		116	* Codes for supported types of image transformations.
		117	*/
		118
		119	typedef enum {
		120	JXFORM_NONE, /* no transformation */
		121	JXFORM_FLIP_H, /* horizontal flip */
		122	JXFORM_FLIP_V, /* vertical flip */
		123	JXFORM_TRANSPOSE, /* transpose across UL-to-LR axis */
		124	JXFORM_TRANSVERSE, /* transpose across UR-to-LL axis */
		125	JXFORM_ROT_90, /* 90-degree clockwise rotation */
		126	JXFORM_ROT_180, /* 180-degree rotation */
		127	JXFORM_ROT_270 /* 270-degree clockwise (or 90 ccw) */
		128	} JXFORM_CODE;
		129
		130	/*
		131	* Codes for crop parameters, which can individually be unspecified,
		132	* positive, or negative. (Negative width or height makes no sense, though.)
		133	*/
		134
		135	typedef enum {
		136	JCROP_UNSET,
		137	JCROP_POS,
		138	JCROP_NEG
		139	} JCROP_CODE;
		140
		141	/*
		142	* Transform parameters struct.
		143	* NB: application must not change any elements of this struct after
		144	* calling jtransform_request_workspace.
		145	*/
		146
100	typedef struct {	147	typedef struct {
101	/* Options: set by caller */	148	/* Options: set by caller */
102	JXFORM_CODE transform; /* image transform operator */	149	JXFORM_CODE transform; /* image transform operator */
103	boolean trim; /* if TRUE, trim partial MCUs as needed */	150	boolean perfect; /* if TRUE, fail if partial MCUs are requested */
104	boolean force_grayscale; /* if TRUE, convert color image to grayscale */	151	boolean trim; /* if TRUE, trim partial MCUs as needed */
		152	boolean force_grayscale; /* if TRUE, convert color image to grayscale */
		153	boolean crop; /* if TRUE, crop source image */
		154
		155	/* Crop parameters: application need not set these unless crop is TRUE.
		156	* These can be filled in by jtransform_parse_crop_spec().
		157	*/
		158	JDIMENSION crop_width; /* Width of selected region */
		159	JCROP_CODE crop_width_set;
		160	JDIMENSION crop_height; /* Height of selected region */
		161	JCROP_CODE crop_height_set;
		162	JDIMENSION crop_xoffset; /* X offset of selected region */
		163	JCROP_CODE crop_xoffset_set; /* (negative measures from right edge) */
		164	JDIMENSION crop_yoffset; /* Y offset of selected region */
		165	JCROP_CODE crop_yoffset_set; /* (negative measures from bottom edge) */
105		166
106	/* Internal workspace: caller should not touch these */	167	/* Internal workspace: caller should not touch these */
107	int num_components; /* # of components in workspace */	168	int num_components; /* # of components in workspace */
108	jvirt_barray_ptr * workspace_coef_arrays; /* workspace for transformations */	169	jvirt_barray_ptr * workspace_coef_arrays; /* workspace for transformations */
		170	JDIMENSION output_width; /* cropped destination dimensions */
		171	JDIMENSION output_height;
		172	JDIMENSION x_crop_offset; /* destination crop offsets measured in iMCUs */
		173	JDIMENSION y_crop_offset;
		174	int iMCU_sample_width; /* destination iMCU size */
		175	int iMCU_sample_height;
109	} jpeg_transform_info;	176	} jpeg_transform_info;
110		177
111		178
112	#if TRANSFORMS_SUPPORTED	179	#if TRANSFORMS_SUPPORTED
113		180
		181	/* Parse a crop specification (written in X11 geometry style) */
		182	EXTERN(boolean) jtransform_parse_crop_spec
		183	JPP((jpeg_transform_info info, const char spec));
114	/* Request any required workspace */	184	/* Request any required workspace */
115	EXTERN(void) jtransform_request_workspace	185	EXTERN(boolean) jtransform_request_workspace
116	JPP((j_decompress_ptr srcinfo, jpeg_transform_info *info));	186	JPP((j_decompress_ptr srcinfo, jpeg_transform_info *info));
117	/* Adjust output image parameters */	187	/* Adjust output image parameters */
118	EXTERN(jvirt_barray_ptr *) jtransform_adjust_parameters	188	EXTERN(jvirt_barray_ptr *) jtransform_adjust_parameters
119	JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,	189	JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
120	jvirt_barray_ptr *src_coef_arrays,	190	jvirt_barray_ptr *src_coef_arrays,
121	jpeg_transform_info *info));	191	jpeg_transform_info *info));
122	/* Execute the actual transformation, if any */	192	/* Execute the actual transformation, if any */
123	EXTERN(void) jtransform_execute_transformation	193	EXTERN(void) jtransform_execute_transform
124	JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,	194	JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
125	jvirt_barray_ptr *src_coef_arrays,	195	jvirt_barray_ptr *src_coef_arrays,
126	jpeg_transform_info *info));	196	jpeg_transform_info *info));
		197	/* Determine whether lossless transformation is perfectly
		198	* possible for a specified image and transformation.
		199	*/
		200	EXTERN(boolean) jtransform_perfect_transform
		201	JPP((JDIMENSION image_width, JDIMENSION image_height,
		202	int MCU_width, int MCU_height,
		203	JXFORM_CODE transform));
		204
		205	/* jtransform_execute_transform used to be called
		206	* jtransform_execute_transformation, but some compilers complain about
		207	* routine names that long. This macro is here to avoid breaking any
		208	* old source code that uses the original name...
		209	*/
		210	#define jtransform_execute_transformation jtransform_execute_transform
127		211
128	#endif /* TRANSFORMS_SUPPORTED */	212	#endif /* TRANSFORMS_SUPPORTED */
129		213
Lines 133-153 Link Here
133	*/	217	*/
134		218
135	typedef enum {	219	typedef enum {
136	JCOPYOPT_NONE, /* copy no optional markers */	220	JCOPYOPT_NONE, /* copy no optional markers */
137	JCOPYOPT_COMMENTS, /* copy only comment (COM) markers */	221	JCOPYOPT_COMMENTS, /* copy only comment (COM) markers */
138	JCOPYOPT_ALL /* copy all optional markers */	222	JCOPYOPT_ALL /* copy all optional markers */
139	} JCOPY_OPTION;	223	} JCOPY_OPTION;
140		224
141	#define JCOPYOPT_DEFAULT JCOPYOPT_COMMENTS /* recommended default */	225	#define JCOPYOPT_DEFAULT JCOPYOPT_COMMENTS /* recommended default */
142		226
143	/* Setup decompression object to save desired markers in memory */	227	/* Setup decompression object to save desired markers in memory */
144	EXTERN(void) jcopy_markers_setup	228	EXTERN(void) jcopy_markers_setup
145	JPP((j_decompress_ptr srcinfo, JCOPY_OPTION option));	229	JPP((j_decompress_ptr srcinfo, JCOPY_OPTION option));
146	/* Copy markers saved in the given source object to the destination object */	230	/* Copy markers saved in the given source object to the destination object */
147	EXTERN(void) jcopy_markers_execute	231	EXTERN(void) jcopy_markers_execute
148	JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,	232	JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
149	JCOPY_OPTION option));	233	JCOPY_OPTION option));
150		234
		235	/* start inserted code - dilfridge */
		236
151	} // namespace DigiKam	237	} // namespace DigiKam
152		238
153	#endif // TRANSUPP_H	239	#endif // TRANSUPP_H
		240
		241	/* end inserted code - dilfridge */

Return to bug 306679

Line 0 Link Here

(-)digikam-1.1.0.medium/libs/jpegutils/libjpeg8.README (+325 lines)
		1	The Independent JPEG Group's JPEG software
		2	==========================================
		3
		4	README for release 8 of 10-Jan-2010
		5	===================================
		6
		7	This distribution contains the eighth public release of the Independent JPEG
		8	Group's free JPEG software. You are welcome to redistribute this software and
		9	to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.
		10
		11	This software is the work of Tom Lane, Guido Vollbeding, Philip Gladstone,
		12	Bill Allombert, Jim Boucher, Lee Crocker, Bob Friesenhahn, Ben Jackson,
		13	Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi, Ge' Weijers,
		14	and other members of the Independent JPEG Group.
		15
		16	IJG is not affiliated with the official ISO JPEG standards committee.
		17
		18
		19	DOCUMENTATION ROADMAP
		20	=====================
		21
		22	This file contains the following sections:
		23
		24	OVERVIEW General description of JPEG and the IJG software.
		25	LEGAL ISSUES Copyright, lack of warranty, terms of distribution.
		26	REFERENCES Where to learn more about JPEG.
		27	ARCHIVE LOCATIONS Where to find newer versions of this software.
		28	ACKNOWLEDGMENTS Special thanks.
		29	FILE FORMAT WARS Software not to get.
		30	TO DO Plans for future IJG releases.
		31
		32	Other documentation files in the distribution are:
		33
		34	User documentation:
		35	install.txt How to configure and install the IJG software.
		36	usage.txt Usage instructions for cjpeg, djpeg, jpegtran,
		37	rdjpgcom, and wrjpgcom.
		38	*.1 Unix-style man pages for programs (same info as usage.txt).
		39	wizard.txt Advanced usage instructions for JPEG wizards only.
		40	change.log Version-to-version change highlights.
		41	Programmer and internal documentation:
		42	libjpeg.txt How to use the JPEG library in your own programs.
		43	example.c Sample code for calling the JPEG library.
		44	structure.txt Overview of the JPEG library's internal structure.
		45	filelist.txt Road map of IJG files.
		46	coderules.txt Coding style rules --- please read if you contribute code.
		47
		48	Please read at least the files install.txt and usage.txt. Some information
		49	can also be found in the JPEG FAQ (Frequently Asked Questions) article. See
		50	ARCHIVE LOCATIONS below to find out where to obtain the FAQ article.
		51
		52	If you want to understand how the JPEG code works, we suggest reading one or
		53	more of the REFERENCES, then looking at the documentation files (in roughly
		54	the order listed) before diving into the code.
		55
		56
		57	OVERVIEW
		58	========
		59
		60	This package contains C software to implement JPEG image encoding, decoding,
		61	and transcoding. JPEG (pronounced "jay-peg") is a standardized compression
		62	method for full-color and gray-scale images.
		63
		64	This software implements JPEG baseline, extended-sequential, and progressive
65	compression processes. Provision is made for supporting all variants of these
66	processes, although some uncommon parameter settings aren't implemented yet.
67	We have made no provision for supporting the hierarchical or lossless
68	processes defined in the standard.
69
70	We provide a set of library routines for reading and writing JPEG image files,
71	plus two sample applications "cjpeg" and "djpeg", which use the library to
72	perform conversion between JPEG and some other popular image file formats.
73	The library is intended to be reused in other applications.
74
75	In order to support file conversion and viewing software, we have included
76	considerable functionality beyond the bare JPEG coding/decoding capability;
77	for example, the color quantization modules are not strictly part of JPEG
78	decoding, but they are essential for output to colormapped file formats or
79	colormapped displays. These extra functions can be compiled out of the
80	library if not required for a particular application.
81
82	We have also included "jpegtran", a utility for lossless transcoding between
83	different JPEG processes, and "rdjpgcom" and "wrjpgcom", two simple
84	applications for inserting and extracting textual comments in JFIF files.
85
86	The emphasis in designing this software has been on achieving portability and
87	flexibility, while also making it fast enough to be useful. In particular,
88	the software is not intended to be read as a tutorial on JPEG. (See the
89	REFERENCES section for introductory material.) Rather, it is intended to
90	be reliable, portable, industrial-strength code. We do not claim to have
91	achieved that goal in every aspect of the software, but we strive for it.
92
93	We welcome the use of this software as a component of commercial products.
94	No royalty is required, but we do ask for an acknowledgement in product
95	documentation, as described under LEGAL ISSUES.
96
97
98	LEGAL ISSUES
99	============
100
101	In plain English:
102
103	1. We don't promise that this software works. (But if you find any bugs,
104	please let us know!)
105	2. You can use this software for whatever you want. You don't have to pay us.
106	3. You may not pretend that you wrote this software. If you use it in a
107	program, you must acknowledge somewhere in your documentation that
108	you've used the IJG code.
109
110	In legalese:
111
112	The authors make NO WARRANTY or representation, either express or implied,
113	with respect to this software, its quality, accuracy, merchantability, or
114	fitness for a particular purpose. This software is provided "AS IS", and you,
115	its user, assume the entire risk as to its quality and accuracy.
116
117	This software is copyright (C) 1991-2010, Thomas G. Lane, Guido Vollbeding.
118	All Rights Reserved except as specified below.
119
120	Permission is hereby granted to use, copy, modify, and distribute this
121	software (or portions thereof) for any purpose, without fee, subject to these
122	conditions:
123	(1) If any part of the source code for this software is distributed, then this
124	README file must be included, with this copyright and no-warranty notice
125	unaltered; and any additions, deletions, or changes to the original files
126	must be clearly indicated in accompanying documentation.
127	(2) If only executable code is distributed, then the accompanying
128	documentation must state that "this software is based in part on the work of
129	the Independent JPEG Group".
130	(3) Permission for use of this software is granted only if the user accepts
131	full responsibility for any undesirable consequences; the authors accept
132	NO LIABILITY for damages of any kind.
133
134	These conditions apply to any software derived from or based on the IJG code,
135	not just to the unmodified library. If you use our work, you ought to
136	acknowledge us.
137
138	Permission is NOT granted for the use of any IJG author's name or company name
139	in advertising or publicity relating to this software or products derived from
140	it. This software may be referred to only as "the Independent JPEG Group's
141	software".
142
143	We specifically permit and encourage the use of this software as the basis of
144	commercial products, provided that all warranty or liability claims are
145	assumed by the product vendor.
146
147
148	ansi2knr.c is included in this distribution by permission of L. Peter Deutsch,
149	sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA.
150	ansi2knr.c is NOT covered by the above copyright and conditions, but instead
151	by the usual distribution terms of the Free Software Foundation; principally,
152	that you must include source code if you redistribute it. (See the file
153	ansi2knr.c for full details.) However, since ansi2knr.c is not needed as part
154	of any program generated from the IJG code, this does not limit you more than
155	the foregoing paragraphs do.
156
157	The Unix configuration script "configure" was produced with GNU Autoconf.
158	It is copyright by the Free Software Foundation but is freely distributable.
159	The same holds for its supporting scripts (config.guess, config.sub,
160	ltmain.sh). Another support script, install-sh, is copyright by X Consortium
161	but is also freely distributable.
162
163	The IJG distribution formerly included code to read and write GIF files.
164	To avoid entanglement with the Unisys LZW patent, GIF reading support has
165	been removed altogether, and the GIF writer has been simplified to produce
166	"uncompressed GIFs". This technique does not use the LZW algorithm; the
167	resulting GIF files are larger than usual, but are readable by all standard
168	GIF decoders.
169
170	We are required to state that
171	"The Graphics Interchange Format(c) is the Copyright property of
172	CompuServe Incorporated. GIF(sm) is a Service Mark property of
173	CompuServe Incorporated."
174
175
176	REFERENCES
177	==========
178
179	We recommend reading one or more of these references before trying to
180	understand the innards of the JPEG software.
181
182	The best short technical introduction to the JPEG compression algorithm is
183	Wallace, Gregory K. "The JPEG Still Picture Compression Standard",
184	Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
185	(Adjacent articles in that issue discuss MPEG motion picture compression,
186	applications of JPEG, and related topics.) If you don't have the CACM issue
187	handy, a PostScript file containing a revised version of Wallace's article is
188	available at http://www.ijg.org/files/wallace.ps.gz. The file (actually
189	a preprint for an article that appeared in IEEE Trans. Consumer Electronics)
190	omits the sample images that appeared in CACM, but it includes corrections
191	and some added material. Note: the Wallace article is copyright ACM and IEEE,
192	and it may not be used for commercial purposes.
193
194	A somewhat less technical, more leisurely introduction to JPEG can be found in
195	"The Data Compression Book" by Mark Nelson and Jean-loup Gailly, published by
196	M&T Books (New York), 2nd ed. 1996, ISBN 1-55851-434-1. This book provides
197	good explanations and example C code for a multitude of compression methods
198	including JPEG. It is an excellent source if you are comfortable reading C
199	code but don't know much about data compression in general. The book's JPEG
200	sample code is far from industrial-strength, but when you are ready to look
201	at a full implementation, you've got one here...
202
203	The best currently available description of JPEG is the textbook "JPEG Still
204	Image Data Compression Standard" by William B. Pennebaker and Joan L.
205	Mitchell, published by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1.
206	Price US$59.95, 638 pp. The book includes the complete text of the ISO JPEG
207	standards (DIS 10918-1 and draft DIS 10918-2).
208	Although this is by far the most detailed and comprehensive exposition of
209	JPEG publicly available, we point out that it is still missing an explanation
210	of the most essential properties and algorithms of the underlying DCT
211	technology.
212	If you think that you know about DCT-based JPEG after reading this book,
213	then you are in delusion. The real fundamentals and corresponding potential
214	of DCT-based JPEG are not publicly known so far, and that is the reason for
215	all the mistaken developments taking place in the image coding domain.
216
217	The original JPEG standard is divided into two parts, Part 1 being the actual
218	specification, while Part 2 covers compliance testing methods. Part 1 is
219	titled "Digital Compression and Coding of Continuous-tone Still Images,
220	Part 1: Requirements and guidelines" and has document numbers ISO/IEC IS
221	10918-1, ITU-T T.81. Part 2 is titled "Digital Compression and Coding of
222	Continuous-tone Still Images, Part 2: Compliance testing" and has document
223	numbers ISO/IEC IS 10918-2, ITU-T T.83.
224	IJG JPEG 8 introduces an implementation of the JPEG SmartScale extension
225	which is specified in a contributed document at ITU and ISO with title "ITU-T
226	JPEG-Plus Proposal for Extending ITU-T T.81 for Advanced Image Coding", April
227	2006, Geneva, Switzerland. The latest version of the document is Revision 3.
228
229	The JPEG standard does not specify all details of an interchangeable file
230	format. For the omitted details we follow the "JFIF" conventions, revision
231	1.02. JFIF 1.02 has been adopted as an Ecma International Technical Report
232	and thus received a formal publication status. It is available as a free
233	download in PDF format from
234	http://www.ecma-international.org/publications/techreports/E-TR-098.htm.
235	A PostScript version of the JFIF document is available at
236	http://www.ijg.org/files/jfif.ps.gz. There is also a plain text version at
237	http://www.ijg.org/files/jfif.txt.gz, but it is missing the figures.
238
239	The TIFF 6.0 file format specification can be obtained by FTP from
240	ftp://ftp.sgi.com/graphics/tiff/TIFF6.ps.gz. The JPEG incorporation scheme
241	found in the TIFF 6.0 spec of 3-June-92 has a number of serious problems.
242	IJG does not recommend use of the TIFF 6.0 design (TIFF Compression tag 6).
243	Instead, we recommend the JPEG design proposed by TIFF Technical Note #2
244	(Compression tag 7). Copies of this Note can be obtained from
245	http://www.ijg.org/files/. It is expected that the next revision
246	of the TIFF spec will replace the 6.0 JPEG design with the Note's design.
247	Although IJG's own code does not support TIFF/JPEG, the free libtiff library
248	uses our library to implement TIFF/JPEG per the Note.
249
250
251	ARCHIVE LOCATIONS
252	=================
253
254	The "official" archive site for this software is www.ijg.org.
255	The most recent released version can always be found there in
256	directory "files". This particular version will be archived as
257	http://www.ijg.org/files/jpegsrc.v8.tar.gz, and in Windows-compatible
258	"zip" archive format as http://www.ijg.org/files/jpegsr8.zip.
259
260	The JPEG FAQ (Frequently Asked Questions) article is a source of some
261	general information about JPEG.
262	It is available on the World Wide Web at http://www.faqs.org/faqs/jpeg-faq/
263	and other news.answers archive sites, including the official news.answers
264	archive at rtfm.mit.edu: ftp://rtfm.mit.edu/pub/usenet/news.answers/jpeg-faq/.
265	If you don't have Web or FTP access, send e-mail to mail-server@rtfm.mit.edu
266	with body
267	send usenet/news.answers/jpeg-faq/part1
268	send usenet/news.answers/jpeg-faq/part2
269
270
271	ACKNOWLEDGMENTS
272	===============
273
274	Thank to Juergen Bruder for providing me with a copy of the common DCT
275	algorithm article, only to find out that I had come to the same result
276	in a more direct and comprehensible way with a more generative approach.
277
278	Thank to Istvan Sebestyen and Joan L. Mitchell for inviting me to the
279	ITU JPEG (Study Group 16) meeting in Geneva, Switzerland.
280
281	Thank to Thomas Wiegand and Gary Sullivan for inviting me to the
282	Joint Video Team (MPEG & ITU) meeting in Geneva, Switzerland.
283
284	Thank to John Korejwa and Massimo Ballerini for inviting me to
285	fruitful consultations in Boston, MA and Milan, Italy.
286
287	Thank to Hendrik Elstner, Roland Fassauer, Simone Zuck, Guenther
288	Maier-Gerber, and Walter Stoeber for corresponding business development.
289
290	Thank to Nico Zschach and Dirk Stelling of the technical support team
291	at the Digital Images company in Halle for providing me with extra
292	equipment for configuration tests.
293
294	Thank to Richard F. Lyon (then of Foveon Inc.) for fruitful
295	communication about JPEG configuration in Sigma Photo Pro software.
296
297	Thank to Andrew Finkenstadt for hosting the ijg.org site.
298
299	Last but not least special thank to Thomas G. Lane for the original
300	design and development of this singular software package.
301
302
303	FILE FORMAT WARS
304	================
305
306	The ISO JPEG standards committee actually promotes different formats like
307	"JPEG 2000" or "JPEG XR" which are incompatible with original DCT-based
308	JPEG and which are based on faulty technologies. IJG therefore does not
309	and will not support such momentary mistakes (see REFERENCES).
310	We have little or no sympathy for the promotion of these formats. Indeed,
311	one of the original reasons for developing this free software was to help
312	force convergence on common, interoperable format standards for JPEG files.
313	Don't use an incompatible file format!
314	(In any case, our decoder will remain capable of reading existing JPEG
315	image files indefinitely.)
316
317
318	TO DO
319	=====
320
321	Version 8.0 is the first release of a new generation JPEG standard
322	to overcome the limitations of the original JPEG specification.
323	More features are being prepared for coming releases...
324
325	Please send bug reports, offers of help, etc. to jpeg-info@uc.ag.