static BOOL
JPEGTransformFromHandle(FreeImageIO* src_io, fi_handle src_handle, FreeImageIO* dst_io, fi_handle dst_handle, FREE_IMAGE_JPEG_OPERATION operation, int* left, int* top, int* right, int* bottom, BOOL perfect) {
const BOOL onlyReturnCropRect = (dst_io == NULL) || (dst_handle == NULL);
const long stream_start = onlyReturnCropRect ? 0 : dst_io->tell_proc(dst_handle);
BOOL swappedDim = FALSE;
BOOL trimH = FALSE;
BOOL trimV = FALSE;
// Set up the jpeglib structures
jpeg_decompress_struct srcinfo;
jpeg_compress_struct dstinfo;
jpeg_error_mgr jsrcerr, jdsterr;
jvirt_barray_ptr *src_coef_arrays = NULL;
jvirt_barray_ptr *dst_coef_arrays = NULL;
// Support for copying optional markers from source to destination file
JCOPY_OPTION copyoption;
// Image transformation options
jpeg_transform_info transfoptions;
// Initialize structures
memset(&srcinfo, 0, sizeof(srcinfo));
memset(&jsrcerr, 0, sizeof(jsrcerr));
memset(&jdsterr, 0, sizeof(jdsterr));
memset(&dstinfo, 0, sizeof(dstinfo));
memset(&transfoptions, 0, sizeof(transfoptions));
// Copy all extra markers from source file
copyoption = JCOPYOPT_ALL;
// Set up default JPEG parameters
transfoptions.force_grayscale = FALSE;
transfoptions.crop = FALSE;
// Select the transform option
switch(operation) {
case FIJPEG_OP_FLIP_H: // horizontal flip
transfoptions.transform = JXFORM_FLIP_H;
trimH = TRUE;
break;
case FIJPEG_OP_FLIP_V: // vertical flip
transfoptions.transform = JXFORM_FLIP_V;
trimV = TRUE;
break;
case FIJPEG_OP_TRANSPOSE: // transpose across UL-to-LR axis
transfoptions.transform = JXFORM_TRANSPOSE;
swappedDim = TRUE;
break;
case FIJPEG_OP_TRANSVERSE: // transpose across UR-to-LL axis
transfoptions.transform = JXFORM_TRANSVERSE;
trimH = TRUE;
trimV = TRUE;
swappedDim = TRUE;
break;
case FIJPEG_OP_ROTATE_90: // 90-degree clockwise rotation
transfoptions.transform = JXFORM_ROT_90;
trimH = TRUE;
swappedDim = TRUE;
break;
case FIJPEG_OP_ROTATE_180: // 180-degree rotation
trimH = TRUE;
trimV = TRUE;
transfoptions.transform = JXFORM_ROT_180;
break;
case FIJPEG_OP_ROTATE_270: // 270-degree clockwise (or 90 ccw)
transfoptions.transform = JXFORM_ROT_270;
trimV = TRUE;
swappedDim = TRUE;
break;
default:
case FIJPEG_OP_NONE: // no transformation
transfoptions.transform = JXFORM_NONE;
break;
}
// (perfect == TRUE) ==> fail if there is non-transformable edge blocks
transfoptions.perfect = (perfect == TRUE) ? TRUE : FALSE;
// Drop non-transformable edge blocks: trim off any partial edge MCUs that the transform can't handle.
transfoptions.trim = TRUE;
try {
// Initialize the JPEG decompression object with default error handling
srcinfo.err = jpeg_std_error(&jsrcerr);
srcinfo.err->error_exit = ls_jpeg_error_exit;
srcinfo.err->output_message = ls_jpeg_output_message;
jpeg_create_decompress(&srcinfo);
// Initialize the JPEG compression object with default error handling
dstinfo.err = jpeg_std_error(&jdsterr);
dstinfo.err->error_exit = ls_jpeg_error_exit;
dstinfo.err->output_message = ls_jpeg_output_message;
jpeg_create_compress(&dstinfo);
// Specify data source for decompression
jpeg_freeimage_src(&srcinfo, src_handle, src_io);
// Enable saving of extra markers that we want to copy
jcopy_markers_setup(&srcinfo, copyoption);
// Read the file header
jpeg_read_header(&srcinfo, TRUE);
// crop option
char crop[64];
const BOOL hasCrop = getCropString(crop, left, top, right, bottom, swappedDim ? srcinfo.image_height : srcinfo.image_width, swappedDim ? srcinfo.image_width : srcinfo.image_height);
if(hasCrop) {
if(!jtransform_parse_crop_spec(&transfoptions, crop)) {
FreeImage_OutputMessageProc(FIF_JPEG, "Bogus crop argument %s", crop);
throw(1);
}
}
// Any space needed by a transform option must be requested before
// jpeg_read_coefficients so that memory allocation will be done right
// Prepare transformation workspace
// Fails right away if perfect flag is TRUE and transformation is not perfect
if( !jtransform_request_workspace(&srcinfo, &transfoptions) ) {
FreeImage_OutputMessageProc(FIF_JPEG, "Transformation is not perfect");
throw(1);
}
if(left || top) {
// compute left and top offsets, it's a bit tricky, taking into account both
// transform, which might have trimed the image,
// and crop itself, which is adjusted to lie on a iMCU boundary
const int fullWidth = swappedDim ? srcinfo.image_height : srcinfo.image_width;
const int fullHeight = swappedDim ? srcinfo.image_width : srcinfo.image_height;
int transformedFullWidth = fullWidth;
int transformedFullHeight = fullHeight;
if(trimH && transformedFullWidth/transfoptions.iMCU_sample_width > 0) {
transformedFullWidth = (transformedFullWidth/transfoptions.iMCU_sample_width) * transfoptions.iMCU_sample_width;
}
if(trimV && transformedFullHeight/transfoptions.iMCU_sample_height > 0) {
transformedFullHeight = (transformedFullHeight/transfoptions.iMCU_sample_height) * transfoptions.iMCU_sample_height;
}
const int trimmedWidth = fullWidth - transformedFullWidth;
const int trimmedHeight = fullHeight - transformedFullHeight;
if(left) {
*left = trimmedWidth + transfoptions.x_crop_offset * transfoptions.iMCU_sample_width;
}
if(top) {
*top = trimmedHeight + transfoptions.y_crop_offset * transfoptions.iMCU_sample_height;
}
}
if(right) {
*right = (left ? *left : 0) + transfoptions.output_width;
}
if(bottom) {
*bottom = (top ? *top : 0) + transfoptions.output_height;
}
// if only the crop rect is requested, we are done
if(onlyReturnCropRect) {
jpeg_destroy_compress(&dstinfo);
jpeg_destroy_decompress(&srcinfo);
return TRUE;
}
// Read source file as DCT coefficients
src_coef_arrays = jpeg_read_coefficients(&srcinfo);
// Initialize destination compression parameters from source values
jpeg_copy_critical_parameters(&srcinfo, &dstinfo);
// Adjust destination parameters if required by transform options;
// also find out which set of coefficient arrays will hold the output
dst_coef_arrays = jtransform_adjust_parameters(&srcinfo, &dstinfo, src_coef_arrays, &transfoptions);
// Note: we assume that jpeg_read_coefficients consumed all input
// until JPEG_REACHED_EOI, and that jpeg_finish_decompress will
// only consume more while (! cinfo->inputctl->eoi_reached).
// We cannot call jpeg_finish_decompress here since we still need the
// virtual arrays allocated from the source object for processing.
if(src_handle == dst_handle) {
dst_io->seek_proc(dst_handle, stream_start, SEEK_SET);
}
// Specify data destination for compression
jpeg_freeimage_dst(&dstinfo, dst_handle, dst_io);
// Start compressor (note no image data is actually written here)
jpeg_write_coefficients(&dstinfo, dst_coef_arrays);
// Copy to the output file any extra markers that we want to preserve
jcopy_markers_execute(&srcinfo, &dstinfo, copyoption);
// Execute image transformation, if any
jtransform_execute_transformation(&srcinfo, &dstinfo, src_coef_arrays, &transfoptions);
// Finish compression and release memory
jpeg_finish_compress(&dstinfo);
jpeg_destroy_compress(&dstinfo);
jpeg_finish_decompress(&srcinfo);
jpeg_destroy_decompress(&srcinfo);
}
catch(...) {
jpeg_destroy_compress(&dstinfo);
jpeg_destroy_decompress(&srcinfo);
return FALSE;
}
return TRUE;
}
static BOOL DLL_CALLCONV
Save(FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int page, int flags, void *data) {
if ((dib) && (handle)) {
try {
// Check dib format
const char *sError = "only 24-bit highcolor or 8-bit greyscale/palette bitmaps can be saved as JPEG";
FREE_IMAGE_COLOR_TYPE color_type = FreeImage_GetColorType(dib);
WORD bpp = (WORD)FreeImage_GetBPP(dib);
if ((bpp != 24) && (bpp != 8))
throw sError;
if(bpp == 8) {
// allow grey, reverse grey and palette
if ((color_type != FIC_MINISBLACK) && (color_type != FIC_MINISWHITE) && (color_type != FIC_PALETTE))
throw sError;
}
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
// Step 1: allocate and initialize JPEG compression object
cinfo.err = jpeg_std_error(&jerr);
jerr.error_exit = jpeg_error_exit;
jerr.output_message = jpeg_output_message;
// Now we can initialize the JPEG compression object
jpeg_create_compress(&cinfo);
// Step 2: specify data destination (eg, a file)
jpeg_freeimage_dst(&cinfo, handle, io);
// Step 3: set parameters for compression
cinfo.image_width = FreeImage_GetWidth(dib);
cinfo.image_height = FreeImage_GetHeight(dib);
switch(color_type) {
case FIC_MINISBLACK :
case FIC_MINISWHITE :
cinfo.in_color_space = JCS_GRAYSCALE;
cinfo.input_components = 1;
break;
default :
cinfo.in_color_space = JCS_RGB;
cinfo.input_components = 3;
break;
}
jpeg_set_defaults(&cinfo);
// progressive-JPEG support
if((flags & JPEG_PROGRESSIVE) == JPEG_PROGRESSIVE) {
jpeg_simple_progression(&cinfo);
}
// Set JFIF density parameters from the DIB data
cinfo.X_density = (UINT16) (0.5 + 0.0254 * FreeImage_GetDotsPerMeterX(dib));
cinfo.Y_density = (UINT16) (0.5 + 0.0254 * FreeImage_GetDotsPerMeterY(dib));
cinfo.density_unit = 1; // dots / inch
// set subsampling options if required
if(cinfo.in_color_space == JCS_RGB) {
if((flags & JPEG_SUBSAMPLING_411) == JPEG_SUBSAMPLING_411) {
// 4:1:1 (4x1 1x1 1x1) - CrH 25% - CbH 25% - CrV 100% - CbV 100%
// the horizontal color resolution is quartered
cinfo.comp_info[0].h_samp_factor = 4; // Y
cinfo.comp_info[0].v_samp_factor = 1;
cinfo.comp_info[1].h_samp_factor = 1; // Cb
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1; // Cr
cinfo.comp_info[2].v_samp_factor = 1;
} else if((flags & JPEG_SUBSAMPLING_420) == JPEG_SUBSAMPLING_420) {
// 4:2:0 (2x2 1x1 1x1) - CrH 50% - CbH 50% - CrV 50% - CbV 50%
// the chrominance resolution in both the horizontal and vertical directions is cut in half
cinfo.comp_info[0].h_samp_factor = 2; // Y
cinfo.comp_info[0].v_samp_factor = 2;
cinfo.comp_info[1].h_samp_factor = 1; // Cb
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1; // Cr
cinfo.comp_info[2].v_samp_factor = 1;
} else if((flags & JPEG_SUBSAMPLING_422) == JPEG_SUBSAMPLING_422){ //2x1 (low)
// 4:2:2 (2x1 1x1 1x1) - CrH 50% - CbH 50% - CrV 100% - CbV 100%
// half of the horizontal resolution in the chrominance is dropped (Cb & Cr),
// while the full resolution is retained in the vertical direction, with respect to the luminance
cinfo.comp_info[0].h_samp_factor = 2; // Y
cinfo.comp_info[0].v_samp_factor = 1;
cinfo.comp_info[1].h_samp_factor = 1; // Cb
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1; // Cr
cinfo.comp_info[2].v_samp_factor = 1;
}
else if((flags & JPEG_SUBSAMPLING_444) == JPEG_SUBSAMPLING_444){ //1x1 (no subsampling)
// 4:4:4 (1x1 1x1 1x1) - CrH 100% - CbH 100% - CrV 100% - CbV 100%
// the resolution of chrominance information (Cb & Cr) is preserved
// at the same rate as the luminance (Y) information
cinfo.comp_info[0].h_samp_factor = 1; // Y
cinfo.comp_info[0].v_samp_factor = 1;
cinfo.comp_info[1].h_samp_factor = 1; // Cb
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1; // Cr
cinfo.comp_info[2].v_samp_factor = 1;
}
}
// Step 4: set quality
// the first 7 bits are reserved for low level quality settings
// the other bits are high level (i.e. enum-ish)
int quality;
if ((flags & JPEG_QUALITYBAD) == JPEG_QUALITYBAD) {
quality = 10;
} else if ((flags & JPEG_QUALITYAVERAGE) == JPEG_QUALITYAVERAGE) {
quality = 25;
} else if ((flags & JPEG_QUALITYNORMAL) == JPEG_QUALITYNORMAL) {
quality = 50;
} else if ((flags & JPEG_QUALITYGOOD) == JPEG_QUALITYGOOD) {
quality = 75;
} else if ((flags & JPEG_QUALITYSUPERB) == JPEG_QUALITYSUPERB) {
quality = 100;
} else {
if ((flags & 0x7F) == 0) {
quality = 75;
} else {
quality = flags & 0x7F;
}
}
jpeg_set_quality(&cinfo, quality, TRUE); /* limit to baseline-JPEG values */
// Step 5: Start compressor
jpeg_start_compress(&cinfo, TRUE);
// Step 6: Write special markers
write_markers(&cinfo, dib);
// Step 7: while (scan lines remain to be written)
if(color_type == FIC_RGB) {
// 24-bit RGB image : need to swap red and blue channels
unsigned pitch = FreeImage_GetPitch(dib);
BYTE *target = (BYTE*)malloc(pitch * sizeof(BYTE));
if (target == NULL) {
throw FI_MSG_ERROR_MEMORY;
}
while (cinfo.next_scanline < cinfo.image_height) {
// get a copy of the scanline
memcpy(target, FreeImage_GetScanLine(dib, FreeImage_GetHeight(dib) - cinfo.next_scanline - 1), pitch);
#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
// swap R and B channels
BYTE *target_p = target;
for(unsigned x = 0; x < cinfo.image_width; x++) {
INPLACESWAP(target_p[0], target_p[2]);
target_p += 3;
}
#endif
// write the scanline
jpeg_write_scanlines(&cinfo, &target, 1);
}
free(target);
}
else if(color_type == FIC_MINISBLACK) {
// 8-bit standard greyscale images
while (cinfo.next_scanline < cinfo.image_height) {
JSAMPROW b = FreeImage_GetScanLine(dib, FreeImage_GetHeight(dib) - cinfo.next_scanline - 1);
jpeg_write_scanlines(&cinfo, &b, 1);
}
}
else if(color_type == FIC_PALETTE) {
// 8-bit palettized images are converted to 24-bit images
RGBQUAD *palette = FreeImage_GetPalette(dib);
BYTE *target = (BYTE*)malloc(cinfo.image_width * 3);
if (target == NULL) {
throw FI_MSG_ERROR_MEMORY;
}
while (cinfo.next_scanline < cinfo.image_height) {
BYTE *source = FreeImage_GetScanLine(dib, FreeImage_GetHeight(dib) - cinfo.next_scanline - 1);
FreeImage_ConvertLine8To24(target, source, cinfo.image_width, palette);
#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
// swap R and B channels
BYTE *target_p = target;
for(unsigned x = 0; x < cinfo.image_width; x++) {
INPLACESWAP(target_p[0], target_p[2]);
target_p += 3;
}
#endif
jpeg_write_scanlines(&cinfo, &target, 1);
}
free(target);
}
else if(color_type == FIC_MINISWHITE) {
// reverse 8-bit greyscale image, so reverse grey value on the fly
unsigned i;
BYTE reverse[256];
BYTE *target = (BYTE *)malloc(cinfo.image_width);
if (target == NULL) {
throw FI_MSG_ERROR_MEMORY;
}
for(i = 0; i < 256; i++) {
reverse[i] = (BYTE)(255 - i);
}
while(cinfo.next_scanline < cinfo.image_height) {
BYTE *source = FreeImage_GetScanLine(dib, FreeImage_GetHeight(dib) - cinfo.next_scanline - 1);
for(i = 0; i < cinfo.image_width; i++) {
target[i] = reverse[ source[i] ];
}
jpeg_write_scanlines(&cinfo, &target, 1);
}
free(target);
}
// Step 8: Finish compression
jpeg_finish_compress(&cinfo);
// Step 9: release JPEG compression object
jpeg_destroy_compress(&cinfo);
return TRUE;
} catch (const char *text) {
FreeImage_OutputMessageProc(s_format_id, text);
return FALSE;
} catch (FREE_IMAGE_FORMAT) {
return FALSE;
}
}
return FALSE;
}