By default, Bugzilla does not search the list of RESOLVED bugs.
You can force it to do so by putting the upper-case word ALL in front of your search query, e.g.: ALL tdelibs
We recommend searching for bugs this way, as you may discover that your bug has already been resolved and fixed in a later release.

[patch] Fix rotated jpeg image save (2)

digikam-fix-rotated-jpeg-save-2.diff (text/plain), 88.53 KB, created by Slávek Banko on 2013-04-14 22:31:17 CDT

(hide)

Description: Fix rotated jpeg image save (2)

Filename:

MIME Type:

Creator: Slávek Banko

Created: 2013-04-14 22:31:17 CDT

Size: 88.53 KB

patch

obsolete

>diff --git a/digikam/libs/jpegutils/jpegint.h b/digikam/libs/jpegutils/jpegint.h >index 27546f3..4317b0d 100644 >--- a/digikam/libs/jpegutils/jpegint.h >+++ b/digikam/libs/jpegutils/jpegint.h >@@ -1,3 +1,421 @@ >+#if JPEG_LIB_VERSION >= 80 >+ >+/* >+ * jpegint.h >+ * >+ * Copyright (C) 1991-1997, Thomas G. Lane. >+ * Modified 1997-2009 by Guido Vollbeding. >+ * This file is part of the Independent JPEG Group's software. >+ * For conditions of distribution and use, see the accompanying README file. >+ * >+ * This file provides common declarations for the various JPEG modules. >+ * These declarations are considered internal to the JPEG library; most >+ * applications using the library shouldn't need to include this file. >+ */ >+ >+ >+/* Ensuring definition INT32 for jpegint.h */ >+#ifndef INT32 >+#define INT32 Q_INT32 >+#endif >+ >+/* Declarations for both compression & decompression */ >+ >+typedef enum { /* Operating modes for buffer controllers */ >+ JBUF_PASS_THRU, /* Plain stripwise operation */ >+ /* Remaining modes require a full-image buffer to have been created */ >+ JBUF_SAVE_SOURCE, /* Run source subobject only, save output */ >+ JBUF_CRANK_DEST, /* Run dest subobject only, using saved data */ >+ JBUF_SAVE_AND_PASS /* Run both subobjects, save output */ >+} J_BUF_MODE; >+ >+/* Values of global_state field (jdapi.c has some dependencies on ordering!) */ >+#define CSTATE_START 100 /* after create_compress */ >+#define CSTATE_SCANNING 101 /* start_compress done, write_scanlines OK */ >+#define CSTATE_RAW_OK 102 /* start_compress done, write_raw_data OK */ >+#define CSTATE_WRCOEFS 103 /* jpeg_write_coefficients done */ >+#define DSTATE_START 200 /* after create_decompress */ >+#define DSTATE_INHEADER 201 /* reading header markers, no SOS yet */ >+#define DSTATE_READY 202 /* found SOS, ready for start_decompress */ >+#define DSTATE_PRELOAD 203 /* reading multiscan file in start_decompress*/ >+#define DSTATE_PRESCAN 204 /* performing dummy pass for 2-pass quant */ >+#define DSTATE_SCANNING 205 /* start_decompress done, read_scanlines OK */ >+#define DSTATE_RAW_OK 206 /* start_decompress done, read_raw_data OK */ >+#define DSTATE_BUFIMAGE 207 /* expecting jpeg_start_output */ >+#define DSTATE_BUFPOST 208 /* looking for SOS/EOI in jpeg_finish_output */ >+#define DSTATE_RDCOEFS 209 /* reading file in jpeg_read_coefficients */ >+#define DSTATE_STOPPING 210 /* looking for EOI in jpeg_finish_decompress */ >+ >+ >+/* Declarations for compression modules */ >+ >+/* Master control module */ >+struct jpeg_comp_master { >+ JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo)); >+ JMETHOD(void, pass_startup, (j_compress_ptr cinfo)); >+ JMETHOD(void, finish_pass, (j_compress_ptr cinfo)); >+ >+ /* State variables made visible to other modules */ >+ boolean call_pass_startup; /* True if pass_startup must be called */ >+ boolean is_last_pass; /* True during last pass */ >+}; >+ >+/* Main buffer control (downsampled-data buffer) */ >+struct jpeg_c_main_controller { >+ JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); >+ JMETHOD(void, process_data, (j_compress_ptr cinfo, >+ JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, >+ JDIMENSION in_rows_avail)); >+}; >+ >+/* Compression preprocessing (downsampling input buffer control) */ >+struct jpeg_c_prep_controller { >+ JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); >+ JMETHOD(void, pre_process_data, (j_compress_ptr cinfo, >+ JSAMPARRAY input_buf, >+ JDIMENSION *in_row_ctr, >+ JDIMENSION in_rows_avail, >+ JSAMPIMAGE output_buf, >+ JDIMENSION *out_row_group_ctr, >+ JDIMENSION out_row_groups_avail)); >+}; >+ >+/* Coefficient buffer control */ >+struct jpeg_c_coef_controller { >+ JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode)); >+ JMETHOD(boolean, compress_data, (j_compress_ptr cinfo, >+ JSAMPIMAGE input_buf)); >+}; >+ >+/* Colorspace conversion */ >+struct jpeg_color_converter { >+ JMETHOD(void, start_pass, (j_compress_ptr cinfo)); >+ JMETHOD(void, color_convert, (j_compress_ptr cinfo, >+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf, >+ JDIMENSION output_row, int num_rows)); >+}; >+ >+/* Downsampling */ >+struct jpeg_downsampler { >+ JMETHOD(void, start_pass, (j_compress_ptr cinfo)); >+ JMETHOD(void, downsample, (j_compress_ptr cinfo, >+ JSAMPIMAGE input_buf, JDIMENSION in_row_index, >+ JSAMPIMAGE output_buf, >+ JDIMENSION out_row_group_index)); >+ >+ boolean need_context_rows; /* TRUE if need rows above & below */ >+}; >+ >+/* Forward DCT (also controls coefficient quantization) */ >+typedef JMETHOD(void, forward_DCT_ptr, >+ (j_compress_ptr cinfo, jpeg_component_info * compptr, >+ JSAMPARRAY sample_data, JBLOCKROW coef_blocks, >+ JDIMENSION start_row, JDIMENSION start_col, >+ JDIMENSION num_blocks)); >+ >+struct jpeg_forward_dct { >+ JMETHOD(void, start_pass, (j_compress_ptr cinfo)); >+ /* It is useful to allow each component to have a separate FDCT method. */ >+ forward_DCT_ptr forward_DCT[MAX_COMPONENTS]; >+}; >+ >+/* Entropy encoding */ >+struct jpeg_entropy_encoder { >+ JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics)); >+ JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data)); >+ JMETHOD(void, finish_pass, (j_compress_ptr cinfo)); >+}; >+ >+/* Marker writing */ >+struct jpeg_marker_writer { >+ JMETHOD(void, write_file_header, (j_compress_ptr cinfo)); >+ JMETHOD(void, write_frame_header, (j_compress_ptr cinfo)); >+ JMETHOD(void, write_scan_header, (j_compress_ptr cinfo)); >+ JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo)); >+ JMETHOD(void, write_tables_only, (j_compress_ptr cinfo)); >+ /* These routines are exported to allow insertion of extra markers */ >+ /* Probably only COM and APPn markers should be written this way */ >+ JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker, >+ unsigned int datalen)); >+ JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val)); >+}; >+ >+ >+/* Declarations for decompression modules */ >+ >+/* Master control module */ >+struct jpeg_decomp_master { >+ JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo)); >+ JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo)); >+ >+ /* State variables made visible to other modules */ >+ boolean is_dummy_pass; /* True during 1st pass for 2-pass quant */ >+}; >+ >+/* Input control module */ >+struct jpeg_input_controller { >+ JMETHOD(int, consume_input, (j_decompress_ptr cinfo)); >+ JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo)); >+ JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); >+ JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo)); >+ >+ /* State variables made visible to other modules */ >+ boolean has_multiple_scans; /* True if file has multiple scans */ >+ boolean eoi_reached; /* True when EOI has been consumed */ >+}; >+ >+/* Main buffer control (downsampled-data buffer) */ >+struct jpeg_d_main_controller { >+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); >+ JMETHOD(void, process_data, (j_decompress_ptr cinfo, >+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, >+ JDIMENSION out_rows_avail)); >+}; >+ >+/* Coefficient buffer control */ >+struct jpeg_d_coef_controller { >+ JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo)); >+ JMETHOD(int, consume_data, (j_decompress_ptr cinfo)); >+ JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo)); >+ JMETHOD(int, decompress_data, (j_decompress_ptr cinfo, >+ JSAMPIMAGE output_buf)); >+ /* Pointer to array of coefficient virtual arrays, or NULL if none */ >+ jvirt_barray_ptr *coef_arrays; >+}; >+ >+/* Decompression postprocessing (color quantization buffer control) */ >+struct jpeg_d_post_controller { >+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)); >+ JMETHOD(void, post_process_data, (j_decompress_ptr cinfo, >+ JSAMPIMAGE input_buf, >+ JDIMENSION *in_row_group_ctr, >+ JDIMENSION in_row_groups_avail, >+ JSAMPARRAY output_buf, >+ JDIMENSION *out_row_ctr, >+ JDIMENSION out_rows_avail)); >+}; >+ >+/* Marker reading & parsing */ >+struct jpeg_marker_reader { >+ JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo)); >+ /* Read markers until SOS or EOI. >+ * Returns same codes as are defined for jpeg_consume_input: >+ * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. >+ */ >+ JMETHOD(int, read_markers, (j_decompress_ptr cinfo)); >+ /* Read a restart marker --- exported for use by entropy decoder only */ >+ jpeg_marker_parser_method read_restart_marker; >+ >+ /* State of marker reader --- nominally internal, but applications >+ * supplying COM or APPn handlers might like to know the state. >+ */ >+ boolean saw_SOI; /* found SOI? */ >+ boolean saw_SOF; /* found SOF? */ >+ int next_restart_num; /* next restart number expected (0-7) */ >+ unsigned int discarded_bytes; /* # of bytes skipped looking for a marker */ >+}; >+ >+/* Entropy decoding */ >+struct jpeg_entropy_decoder { >+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); >+ JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo, >+ JBLOCKROW *MCU_data)); >+}; >+ >+/* Inverse DCT (also performs dequantization) */ >+typedef JMETHOD(void, inverse_DCT_method_ptr, >+ (j_decompress_ptr cinfo, jpeg_component_info * compptr, >+ JCOEFPTR coef_block, >+ JSAMPARRAY output_buf, JDIMENSION output_col)); >+ >+struct jpeg_inverse_dct { >+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); >+ /* It is useful to allow each component to have a separate IDCT method. */ >+ inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS]; >+}; >+ >+/* Upsampling (note that upsampler must also call color converter) */ >+struct jpeg_upsampler { >+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); >+ JMETHOD(void, upsample, (j_decompress_ptr cinfo, >+ JSAMPIMAGE input_buf, >+ JDIMENSION *in_row_group_ctr, >+ JDIMENSION in_row_groups_avail, >+ JSAMPARRAY output_buf, >+ JDIMENSION *out_row_ctr, >+ JDIMENSION out_rows_avail)); >+ >+ boolean need_context_rows; /* TRUE if need rows above & below */ >+}; >+ >+/* Colorspace conversion */ >+struct jpeg_color_deconverter { >+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo)); >+ JMETHOD(void, color_convert, (j_decompress_ptr cinfo, >+ JSAMPIMAGE input_buf, JDIMENSION input_row, >+ JSAMPARRAY output_buf, int num_rows)); >+}; >+ >+/* Color quantization or color precision reduction */ >+struct jpeg_color_quantizer { >+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan)); >+ JMETHOD(void, color_quantize, (j_decompress_ptr cinfo, >+ JSAMPARRAY input_buf, JSAMPARRAY output_buf, >+ int num_rows)); >+ JMETHOD(void, finish_pass, (j_decompress_ptr cinfo)); >+ JMETHOD(void, new_color_map, (j_decompress_ptr cinfo)); >+}; >+ >+ >+/* Miscellaneous useful macros */ >+ >+#undef MAX >+#define MAX(a,b) ((a) > (b) ? (a) : (b)) >+#undef MIN >+#define MIN(a,b) ((a) < (b) ? (a) : (b)) >+ >+ >+/* We assume that right shift corresponds to signed division by 2 with >+ * rounding towards minus infinity. This is correct for typical "arithmetic >+ * shift" instructions that shift in copies of the sign bit. But some >+ * C compilers implement >> with an unsigned shift. For these machines you >+ * must define RIGHT_SHIFT_IS_UNSIGNED. >+ * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity. >+ * It is only applied with constant shift counts. SHIFT_TEMPS must be >+ * included in the variables of any routine using RIGHT_SHIFT. >+ */ >+ >+#ifdef RIGHT_SHIFT_IS_UNSIGNED >+#define SHIFT_TEMPS INT32 shift_temp; >+#define RIGHT_SHIFT(x,shft) \ >+ ((shift_temp = (x)) < 0 ? \ >+ (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \ >+ (shift_temp >> (shft))) >+#else >+#define SHIFT_TEMPS >+#define RIGHT_SHIFT(x,shft) ((x) >> (shft)) >+#endif >+ >+ >+/* Short forms of external names for systems with brain-damaged linkers. */ >+ >+#ifdef NEED_SHORT_EXTERNAL_NAMES >+#define jinit_compress_master jICompress >+#define jinit_c_master_control jICMaster >+#define jinit_c_main_controller jICMainC >+#define jinit_c_prep_controller jICPrepC >+#define jinit_c_coef_controller jICCoefC >+#define jinit_color_converter jICColor >+#define jinit_downsampler jIDownsampler >+#define jinit_forward_dct jIFDCT >+#define jinit_huff_encoder jIHEncoder >+#define jinit_arith_encoder jIAEncoder >+#define jinit_marker_writer jIMWriter >+#define jinit_master_decompress jIDMaster >+#define jinit_d_main_controller jIDMainC >+#define jinit_d_coef_controller jIDCoefC >+#define jinit_d_post_controller jIDPostC >+#define jinit_input_controller jIInCtlr >+#define jinit_marker_reader jIMReader >+#define jinit_huff_decoder jIHDecoder >+#define jinit_arith_decoder jIADecoder >+#define jinit_inverse_dct jIIDCT >+#define jinit_upsampler jIUpsampler >+#define jinit_color_deconverter jIDColor >+#define jinit_1pass_quantizer jI1Quant >+#define jinit_2pass_quantizer jI2Quant >+#define jinit_merged_upsampler jIMUpsampler >+#define jinit_memory_mgr jIMemMgr >+#define jdiv_round_up jDivRound >+#define jround_up jRound >+#define jcopy_sample_rows jCopySamples >+#define jcopy_block_row jCopyBlocks >+#define jzero_far jZeroFar >+#define jpeg_zigzag_order jZIGTable >+#define jpeg_natural_order jZAGTable >+#define jpeg_natural_order7 jZAGTable7 >+#define jpeg_natural_order6 jZAGTable6 >+#define jpeg_natural_order5 jZAGTable5 >+#define jpeg_natural_order4 jZAGTable4 >+#define jpeg_natural_order3 jZAGTable3 >+#define jpeg_natural_order2 jZAGTable2 >+#define jpeg_aritab jAriTab >+#endif /* NEED_SHORT_EXTERNAL_NAMES */ >+ >+ >+/* Compression module initialization routines */ >+EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo)); >+EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo, >+ boolean transcode_only)); >+EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo, >+ boolean need_full_buffer)); >+EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo, >+ boolean need_full_buffer)); >+EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo, >+ boolean need_full_buffer)); >+EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo)); >+EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo)); >+EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo)); >+EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo)); >+EXTERN(void) jinit_arith_encoder JPP((j_compress_ptr cinfo)); >+EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo)); >+/* Decompression module initialization routines */ >+EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo)); >+EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo, >+ boolean need_full_buffer)); >+EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo, >+ boolean need_full_buffer)); >+EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo, >+ boolean need_full_buffer)); >+EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo)); >+EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo)); >+EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo)); >+EXTERN(void) jinit_arith_decoder JPP((j_decompress_ptr cinfo)); >+EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo)); >+EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo)); >+EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo)); >+EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo)); >+EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo)); >+EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo)); >+/* Memory manager initialization */ >+EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo)); >+ >+/* Utility routines in jutils.c */ >+EXTERN(long) jdiv_round_up JPP((long a, long b)); >+EXTERN(long) jround_up JPP((long a, long b)); >+EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row, >+ JSAMPARRAY output_array, int dest_row, >+ int num_rows, JDIMENSION num_cols)); >+EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row, >+ JDIMENSION num_blocks)); >+EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero)); >+/* Constant tables in jutils.c */ >+#if 0 /* This table is not actually needed in v6a */ >+extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */ >+#endif >+extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */ >+extern const int jpeg_natural_order7[]; /* zz to natural order for 7x7 block */ >+extern const int jpeg_natural_order6[]; /* zz to natural order for 6x6 block */ >+extern const int jpeg_natural_order5[]; /* zz to natural order for 5x5 block */ >+extern const int jpeg_natural_order4[]; /* zz to natural order for 4x4 block */ >+extern const int jpeg_natural_order3[]; /* zz to natural order for 3x3 block */ >+extern const int jpeg_natural_order2[]; /* zz to natural order for 2x2 block */ >+ >+/* Arithmetic coding probability estimation tables in jaricom.c */ >+extern const INT32 jpeg_aritab[]; >+ >+/* Suppress undefined-structure complaints if necessary. */ >+ >+#ifdef INCOMPLETE_TYPES_BROKEN >+#ifndef AM_MEMORY_MANAGER /* only jmemmgr.c defines these */ >+struct jvirt_sarray_control { long dummy; }; >+struct jvirt_barray_control { long dummy; }; >+#endif >+#endif /* INCOMPLETE_TYPES_BROKEN */ >+ >+ >+#else // JPEG_LIB_VERSION >= 80 >+ > /* > * > * Copyright (C) 1991-1997, Thomas G. Lane. <tgl@netcom.com> >@@ -389,3 +807,5 @@ struct jvirt_sarray_control { long dummy; }; > struct jvirt_barray_control { long dummy; }; > #endif > #endif /* INCOMPLETE_TYPES_BROKEN */ >+ >+#endif // JPEG_LIB_VERSION >= 80 >diff --git a/digikam/libs/jpegutils/jpegutils.cpp b/digikam/libs/jpegutils/jpegutils.cpp >index b83825f..44a89c4 100644 >--- a/digikam/libs/jpegutils/jpegutils.cpp >+++ b/digikam/libs/jpegutils/jpegutils.cpp >@@ -267,6 +267,7 @@ bool exifRotate(const TQString& file, const TQString& documentName) > > JCOPY_OPTION copyoption = JCOPYOPT_ALL; > jpeg_transform_info transformoption; >+ memset(&transformoption, 0, sizeof(jpeg_transform_info)); > > transformoption.force_grayscale = false; > transformoption.trim = false; >diff --git a/digikam/libs/jpegutils/transupp.cpp b/digikam/libs/jpegutils/transupp.cpp >index 1b58642..43fe36c 100644 >--- a/digikam/libs/jpegutils/transupp.cpp >+++ b/digikam/libs/jpegutils/transupp.cpp >@@ -1,3 +1,1601 @@ >+/* Although this file really shouldn't have access to the library internals, >+ * it's helpful to let it call jround_up() and jcopy_block_row(). >+ */ >+#define JPEG_INTERNALS >+ >+// LibJPEG includes. >+ >+extern "C" >+{ >+#include "jinclude.h" >+#include "jpeglib.h" >+} >+ >+#if JPEG_LIB_VERSION >= 80 >+ >+/* >+ * 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. >+ * >+ * This file contains image transformation routines and other utility code >+ * used by the jpegtran sample application. These are NOT part of the core >+ * JPEG library. But we keep these routines separate from jpegtran.c to >+ * ease the task of maintaining jpegtran-like programs that have other user >+ * interfaces. >+ */ >+ >+#include "transupp.h" /* My own external interface */ >+#include <ctype.h> /* to declare isdigit() */ >+ >+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 >+ * fastest option for images larger than main memory. >+ * >+ * The other routines require a set of destination virtual arrays, so they >+ * need twice as much memory as jpegtran normally does. The destination >+ * arrays are always written in normal scan order (top to bottom) because >+ * the virtual array manager expects this. The source arrays will be scanned >+ * in the corresponding order, which means multiple passes through the source >+ * arrays for most of the transforms. That could result in much thrashing >+ * if the image is larger than main memory. >+ * >+ * 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 >+ * source JPEG object, and therefore should be manipulated by calling the >+ * source's memory manager. >+ * 2. The destination's component count should be used. It may be smaller >+ * than the source's when forcing to grayscale. >+ * 3. Likewise the destination's sampling factors should be used. When >+ * forcing to grayscale the destination's sampling factors will be all 1, >+ * and we may as well take that as the effective iMCU size. >+ * 4. When "trim" is in effect, the destination's dimensions will be the >+ * trimmed values but the source's will be untrimmed. >+ * 5. 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. >+ */ >+ >+ >+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; >+ JCOEF temp1, temp2; >+ jpeg_component_info *compptr; >+ >+ /* Horizontal mirroring of DCT blocks is accomplished by swapping >+ * pairs of blocks in-place. Within a DCT block, we perform horizontal >+ * mirroring by changing the signs of odd-numbered columns. >+ * Partial iMCUs at the right edge are left untouched. >+ */ >+ MCU_cols = 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; >+ JCOEFPTR src_ptr, dst_ptr; >+ jpeg_component_info *compptr; >+ >+ /* We output into a separate array because we can't touch different >+ * rows of the source virtual array simultaneously. Otherwise, this >+ * is a pretty straightforward analog of horizontal flip. >+ * Within a DCT block, vertical mirroring is done by changing the signs >+ * of odd-numbered rows. >+ * Partial iMCUs at the bottom edge are copied verbatim. >+ */ >+ MCU_rows = 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; >+ jpeg_component_info *compptr; >+ >+ /* Transposing pixels within a block just requires transposing the >+ * DCT coefficients. >+ * Partial iMCUs at the edges require no special treatment; we simply >+ * process all the available DCT blocks for every component. >+ */ >+ for (ci = 0; ci < dstinfo->num_components; ci++) { >+ compptr = dstinfo->comp_info + ci; >+ 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. >+ * These two steps are merged into a single processing routine. >+ */ >+{ >+ 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; >+ jpeg_component_info *compptr; >+ >+ /* Because of the horizontal mirror step, we can't process partial iMCUs >+ * at the (output) right edge properly. They just get transposed and >+ * not mirrored. >+ */ >+ MCU_cols = 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. >+ * These two steps are merged into a single processing routine. >+ */ >+{ >+ 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; >+ jpeg_component_info *compptr; >+ >+ /* Because of the horizontal mirror step, we can't process partial iMCUs >+ * at the (output) bottom edge properly. They just get transposed and >+ * not mirrored. >+ */ >+ MCU_rows = 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. >+ * These two steps are merged into a single processing routine. >+ */ >+{ >+ JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y; >+ 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; >+ * or >+ * 1. Horizontal mirroring; >+ * 2. Transposition; >+ * 3. Horizontal mirroring. >+ * These steps are merged into a single processing routine. >+ */ >+{ >+ JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y; >+ 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; >+ 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); >+ } >+ info->workspace_coef_arrays = coef_arrays; >+ } else >+ info->workspace_coef_arrays = NULL; >+ >+ return TRUE; >+} >+ >+ >+/* Transpose destination image parameters */ >+ >+LOCAL(void) >+transpose_critical_parameters (j_compress_ptr dstinfo) >+{ >+ int tblno, i, j, ci, itemp; >+ jpeg_component_info *compptr; >+ JQUANT_TBL *qtblptr; >+ JDIMENSION 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++) { >+ compptr = dstinfo->comp_info + ci; >+ itemp = compptr->h_samp_factor; >+ compptr->h_samp_factor = compptr->v_samp_factor; >+ compptr->v_samp_factor = itemp; >+ } >+ >+ /* Transpose quantization tables */ >+ for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) { >+ qtblptr = dstinfo->quant_tbl_ptrs[tblno]; >+ if (qtblptr != NULL) { >+ for (i = 0; i < DCTSIZE; i++) { >+ for (j = 0; j < i; j++) { >+ qtemp = qtblptr->quantval[i*DCTSIZE+j]; >+ qtblptr->quantval[i*DCTSIZE+j] = qtblptr->quantval[j*DCTSIZE+i]; >+ qtblptr->quantval[j*DCTSIZE+i] = qtemp; >+ } >+ } >+ } >+ } >+} >+ >+ >+/* 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 */ >+ >+ /* 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); >+} >+ >+ >+/* Adjust output image parameters as needed. >+ * >+ * This must be called after jpeg_copy_critical_parameters() >+ * and before jpeg_write_coefficients(). >+ * >+ * The return value is the set of virtual coefficient arrays to be written >+ * (either the ones allocated by jtransform_request_workspace, or the >+ * original source data arrays). The caller will need to pass this value >+ * to jpeg_write_coefficients(). >+ */ >+ >+GLOBAL(jvirt_barray_ptr *) >+jtransform_adjust_parameters (j_decompress_ptr srcinfo, >+ j_compress_ptr dstinfo, >+ jvirt_barray_ptr *src_coef_arrays, >+ jpeg_transform_info *info) >+{ >+ /* If force-to-grayscale is requested, adjust destination parameters */ >+ if (info->force_grayscale) { >+ /* 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.) >+ */ >+ 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; >+ } else { >+ /* 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_TRANSPOSE: >+ case JXFORM_TRANSVERSE: >+ case JXFORM_ROT_90: >+ case JXFORM_ROT_270: >+ transpose_critical_parameters(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 */ >+ if (info->workspace_coef_arrays != NULL) >+ return info->workspace_coef_arrays; >+ return src_coef_arrays; >+} >+ >+ >+/* Execute the actual transformation, if any. >+ * >+ * This must be called *after* jpeg_write_coefficients, because it depends >+ * on jpeg_write_coefficients to have computed subsidiary values such as >+ * the per-component width and height fields in the destination object. >+ * >+ * Note that some transformations will modify the source data arrays! >+ */ >+ >+GLOBAL(void) >+jtransform_execute_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 */ >+ >+ >+/* Setup decompression object to save desired markers in memory. >+ * This must be called before jpeg_read_header() to have the desired effect. >+ */ >+ >+GLOBAL(void) >+jcopy_markers_setup (j_decompress_ptr srcinfo, JCOPY_OPTION option) >+{ >+#ifdef SAVE_MARKERS_SUPPORTED >+ int m; >+ >+ /* Save comments except under NONE option */ >+ if (option != JCOPYOPT_NONE) { >+ jpeg_save_markers(srcinfo, JPEG_COM, 0xFFFF); >+ } >+ /* Save all types of APPn markers iff ALL option */ >+ if (option == JCOPYOPT_ALL) { >+ for (m = 0; m < 16; m++) >+ jpeg_save_markers(srcinfo, JPEG_APP0 + m, 0xFFFF); >+ } >+#endif /* SAVE_MARKERS_SUPPORTED */ >+} >+ >+/* Copy markers saved in the given source object to the destination object. >+ * This should be called just after jpeg_start_compress() or >+ * jpeg_write_coefficients(). >+ * Note that those routines will have written the SOI, and also the >+ * JFIF APP0 or Adobe APP14 markers if selected. >+ */ >+ >+GLOBAL(void) >+jcopy_markers_execute (j_decompress_ptr srcinfo, j_compress_ptr dstinfo, >+ JCOPY_OPTION option) >+{ >+ jpeg_saved_marker_ptr marker; >+ >+ /* In the current implementation, we don't actually need to examine the >+ * option flag here; we just copy everything that got saved. >+ * But to avoid confusion, we do not output JFIF and Adobe APP14 markers >+ * if the encoder library already wrote one. >+ */ >+ for (marker = srcinfo->marker_list; marker != NULL; marker = marker->next) { >+ if (dstinfo->write_JFIF_header && >+ marker->marker == JPEG_APP0 && >+ marker->data_length >= 5 && >+ GETJOCTET(marker->data[0]) == 0x4A && >+ GETJOCTET(marker->data[1]) == 0x46 && >+ GETJOCTET(marker->data[2]) == 0x49 && >+ GETJOCTET(marker->data[3]) == 0x46 && >+ GETJOCTET(marker->data[4]) == 0) >+ continue; /* reject duplicate JFIF */ >+ if (dstinfo->write_Adobe_marker && >+ marker->marker == JPEG_APP0+14 && >+ marker->data_length >= 5 && >+ GETJOCTET(marker->data[0]) == 0x41 && >+ GETJOCTET(marker->data[1]) == 0x64 && >+ GETJOCTET(marker->data[2]) == 0x6F && >+ GETJOCTET(marker->data[3]) == 0x62 && >+ GETJOCTET(marker->data[4]) == 0x65) >+ continue; /* reject duplicate Adobe */ >+#ifdef NEED_FAR_POINTERS >+ /* We could use jpeg_write_marker if the data weren't FAR... */ >+ { >+ unsigned int i; >+ jpeg_write_m_header(dstinfo, marker->marker, marker->data_length); >+ for (i = 0; i < marker->data_length; i++) >+ jpeg_write_m_byte(dstinfo, marker->data[i]); >+ } >+#else >+ jpeg_write_marker(dstinfo, marker->marker, >+ marker->data, marker->data_length); >+#endif >+ } >+} >+ >+} // namespace Digikam >+ >+#else // JPEG_LIB_VERSION >= 80 >+ > /* > * transupp.c > * >@@ -12,19 +1610,6 @@ > * interfaces. > */ > >-/* Although this file really shouldn't have access to the library internals, >- * it's helpful to let it call jround_up() and jcopy_block_row(). >- */ >-#define JPEG_INTERNALS >- >-// LibJPEG includes. >- >-extern "C" >-{ >-#include "jinclude.h" >-#include "jpeglib.h" >-} >- > // Local includes. > > #include "transupp.h" /* My own external interface */ >@@ -938,3 +2523,5 @@ jcopy_markers_execute (j_decompress_ptr srcinfo, j_compress_ptr dstinfo, > } > > } // namespace Digikam >+ >+#endif // JPEG_LIB_VERSION >= 80 >diff --git a/digikam/libs/jpegutils/transupp.h b/digikam/libs/jpegutils/transupp.h >index 637e0a1..7dd3fad 100644 >--- a/digikam/libs/jpegutils/transupp.h >+++ b/digikam/libs/jpegutils/transupp.h >@@ -1,3 +1,229 @@ >+#if JPEG_LIB_VERSION >= 80 >+ >+/* >+ * transupp.h >+ * >+ * 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. >+ * >+ * This file contains declarations for image transformation routines and >+ * other utility code used by the jpegtran sample application. These are >+ * NOT part of the core JPEG library. But we keep these routines separate >+ * from jpegtran.c to ease the task of maintaining jpegtran-like programs >+ * that have other user interfaces. >+ * >+ * NOTE: all the routines declared here have very specific requirements >+ * about when they are to be executed during the reading and writing of the >+ * source and destination files. See the comments in transupp.c, or see >+ * jpegtran.c for an example of correct usage. >+ */ >+ >+#ifndef TRANSUPP_H >+#define TRANSUPP_H >+ >+namespace Digikam >+{ >+ >+/* If you happen not to want the image transform support, disable it here */ >+#ifndef TRANSFORMS_SUPPORTED >+#define TRANSFORMS_SUPPORTED 1 /* 0 disables transform code */ >+#endif >+ >+/* >+ * Although rotating and flipping data expressed as DCT coefficients is not >+ * hard, there is an asymmetry in the JPEG format specification for images >+ * whose dimensions aren't multiples of the iMCU size. The right and bottom >+ * image edges are padded out to the next iMCU boundary with junk data; but >+ * no padding is possible at the top and left edges. If we were to flip >+ * the whole image including the pad data, then pad garbage would become >+ * visible at the top and/or left, and real pixels would disappear into the >+ * pad margins --- perhaps permanently, since encoders & decoders may not >+ * bother to preserve DCT blocks that appear to be completely outside the >+ * nominal image area. So, we have to exclude any partial iMCUs from the >+ * basic transformation. >+ * >+ * Transpose is the only transformation that can handle partial iMCUs at the >+ * right and bottom edges completely cleanly. flip_h can flip partial iMCUs >+ * at the bottom, but leaves any partial iMCUs at the right edge untouched. >+ * Similarly flip_v leaves any partial iMCUs at the bottom edge untouched. >+ * The other transforms are defined as combinations of these basic transforms >+ * and process edge blocks in a way that preserves the equivalence. >+ * >+ * The "trim" option causes untransformable partial iMCUs to be dropped; >+ * this is not strictly lossless, but it usually gives the best-looking >+ * result for odd-size images. Note that when this option is active, >+ * the expected mathematical equivalences between the transforms may not hold. >+ * (For example, -rot 270 -trim trims only the bottom edge, but -rot 90 -trim >+ * followed by -rot 180 -trim trims both edges.) >+ * >+ * We also offer a lossless-crop option, which discards data outside a given >+ * image region but losslessly preserves what is inside. Like the rotate and >+ * flip transforms, lossless crop is restricted by the JPEG format: the upper >+ * left corner of the selected region must fall on an iMCU boundary. If this >+ * does not hold for the given crop parameters, we silently move the upper left >+ * corner up and/or left to make it so, simultaneously increasing the region >+ * dimensions to keep the lower right crop corner unchanged. (Thus, the >+ * output image covers at least the requested region, but may cover more.) >+ * >+ * We also provide a lossless-resize option, which is kind of a lossless-crop >+ * operation in the DCT coefficient block domain - it discards higher-order >+ * coefficients and losslessly preserves lower-order coefficients of a >+ * sub-block. >+ * >+ * Rotate/flip transform, resize, and crop can be requested together in a >+ * single invocation. The crop is applied last --- that is, the crop region >+ * is specified in terms of the destination image after transform/resize. >+ * >+ * We also offer a "force to grayscale" option, which simply discards the >+ * chrominance channels of a YCbCr image. This is lossless in the sense that >+ * the luminance channel is preserved exactly. It's not the same kind of >+ * thing as the rotate/flip transformations, but it's convenient to handle it >+ * as part of this package, mainly because the transformation routines have to >+ * be aware of the option to know how many components to work on. >+ */ >+ >+ >+/* Short forms of external names for systems with brain-damaged linkers. */ >+ >+#ifdef NEED_SHORT_EXTERNAL_NAMES >+#define jtransform_parse_crop_spec jTrParCrop >+#define jtransform_request_workspace jTrRequest >+#define jtransform_adjust_parameters jTrAdjust >+#define jtransform_execute_transform jTrExec >+#define jtransform_perfect_transform jTrPerfect >+#define jcopy_markers_setup jCMrkSetup >+#define jcopy_markers_execute jCMrkExec >+#endif /* NEED_SHORT_EXTERNAL_NAMES */ >+ >+ >+/* >+ * Codes for supported types of image transformations. >+ */ >+ >+typedef enum { >+ JXFORM_NONE, /* no transformation */ >+ JXFORM_FLIP_H, /* horizontal flip */ >+ JXFORM_FLIP_V, /* vertical flip */ >+ JXFORM_TRANSPOSE, /* transpose across UL-to-LR axis */ >+ JXFORM_TRANSVERSE, /* transpose across UR-to-LL axis */ >+ JXFORM_ROT_90, /* 90-degree clockwise rotation */ >+ JXFORM_ROT_180, /* 180-degree rotation */ >+ JXFORM_ROT_270 /* 270-degree clockwise (or 90 ccw) */ >+} JXFORM_CODE; >+ >+/* >+ * Codes for crop parameters, which can individually be unspecified, >+ * positive, or negative. (Negative width or height makes no sense, though.) >+ */ >+ >+typedef enum { >+ JCROP_UNSET, >+ JCROP_POS, >+ JCROP_NEG >+} JCROP_CODE; >+ >+/* >+ * Transform parameters struct. >+ * NB: application must not change any elements of this struct after >+ * calling jtransform_request_workspace. >+ */ >+ >+typedef struct { >+ /* Options: set by caller */ >+ JXFORM_CODE transform; /* image transform operator */ >+ boolean perfect; /* if TRUE, fail if partial MCUs are requested */ >+ boolean trim; /* if TRUE, trim partial MCUs as needed */ >+ boolean force_grayscale; /* if TRUE, convert color image to grayscale */ >+ boolean crop; /* if TRUE, crop source image */ >+ >+ /* Crop parameters: application need not set these unless crop is TRUE. >+ * These can be filled in by jtransform_parse_crop_spec(). >+ */ >+ JDIMENSION crop_width; /* Width of selected region */ >+ JCROP_CODE crop_width_set; >+ JDIMENSION crop_height; /* Height of selected region */ >+ JCROP_CODE crop_height_set; >+ JDIMENSION crop_xoffset; /* X offset of selected region */ >+ JCROP_CODE crop_xoffset_set; /* (negative measures from right edge) */ >+ JDIMENSION crop_yoffset; /* Y offset of selected region */ >+ JCROP_CODE crop_yoffset_set; /* (negative measures from bottom edge) */ >+ >+ /* Internal workspace: caller should not touch these */ >+ int num_components; /* # of components in workspace */ >+ jvirt_barray_ptr * workspace_coef_arrays; /* workspace for transformations */ >+ JDIMENSION output_width; /* cropped destination dimensions */ >+ JDIMENSION output_height; >+ JDIMENSION x_crop_offset; /* destination crop offsets measured in iMCUs */ >+ JDIMENSION y_crop_offset; >+ int iMCU_sample_width; /* destination iMCU size */ >+ int iMCU_sample_height; >+} jpeg_transform_info; >+ >+ >+#if TRANSFORMS_SUPPORTED >+ >+/* Parse a crop specification (written in X11 geometry style) */ >+EXTERN(boolean) jtransform_parse_crop_spec >+ JPP((jpeg_transform_info *info, const char *spec)); >+/* Request any required workspace */ >+EXTERN(boolean) jtransform_request_workspace >+ JPP((j_decompress_ptr srcinfo, jpeg_transform_info *info)); >+/* Adjust output image parameters */ >+EXTERN(jvirt_barray_ptr *) jtransform_adjust_parameters >+ JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo, >+ jvirt_barray_ptr *src_coef_arrays, >+ jpeg_transform_info *info)); >+/* Execute the actual transformation, if any */ >+EXTERN(void) jtransform_execute_transform >+ JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo, >+ jvirt_barray_ptr *src_coef_arrays, >+ jpeg_transform_info *info)); >+/* Determine whether lossless transformation is perfectly >+ * possible for a specified image and transformation. >+ */ >+EXTERN(boolean) jtransform_perfect_transform >+ JPP((JDIMENSION image_width, JDIMENSION image_height, >+ int MCU_width, int MCU_height, >+ JXFORM_CODE transform)); >+ >+/* jtransform_execute_transform used to be called >+ * jtransform_execute_transformation, but some compilers complain about >+ * routine names that long. This macro is here to avoid breaking any >+ * old source code that uses the original name... >+ */ >+#define jtransform_execute_transformation jtransform_execute_transform >+ >+#endif /* TRANSFORMS_SUPPORTED */ >+ >+ >+/* >+ * Support for copying optional markers from source to destination file. >+ */ >+ >+typedef enum { >+ JCOPYOPT_NONE, /* copy no optional markers */ >+ JCOPYOPT_COMMENTS, /* copy only comment (COM) markers */ >+ JCOPYOPT_ALL /* copy all optional markers */ >+} JCOPY_OPTION; >+ >+#define JCOPYOPT_DEFAULT JCOPYOPT_COMMENTS /* recommended default */ >+ >+/* Setup decompression object to save desired markers in memory */ >+EXTERN(void) jcopy_markers_setup >+ JPP((j_decompress_ptr srcinfo, JCOPY_OPTION option)); >+/* Copy markers saved in the given source object to the destination object */ >+EXTERN(void) jcopy_markers_execute >+ JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo, >+ JCOPY_OPTION option)); >+ >+ >+} // namespace DigiKam >+ >+#endif // TRANSUPP_H >+ >+#else // JPEG_LIB_VERSION >= 80 >+ > /* > * transupp.h > * >@@ -143,3 +369,5 @@ EXTERN(void) jcopy_markers_execute > } // namespace DigiKam > > #endif // TRANSUPP_H >+ >+#endif // JPEG_LIB_VERSION >= 80 View Attachment As Diff View Attachment As Raw

• • Home
  • | New
  • | Browse
  • | Search
  • |
    [?]
  • | Reports
  • | Help
  • | New Account
  • | Log In
    [x]
  • | Forgot Password
    Login: [x]