static int write_jpeg(struct image_writer_ctx *ctx, mp_image_t *image, FILE *fp)
{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
cinfo.err = jpeg_std_error(&jerr);
jerr.error_exit = write_jpeg_error_exit;
jmp_buf error_return_jmpbuf;
cinfo.client_data = &error_return_jmpbuf;
if (setjmp(cinfo.client_data)) {
jpeg_destroy_compress(&cinfo);
return 0;
}
jpeg_create_compress(&cinfo);
jpeg_stdio_dest(&cinfo, fp);
cinfo.image_width = image->width;
cinfo.image_height = image->height;
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
cinfo.write_JFIF_header = TRUE;
cinfo.JFIF_major_version = 1;
cinfo.JFIF_minor_version = 2;
cinfo.density_unit = 1; /* 0=unknown, 1=dpi, 2=dpcm */
/* Image DPI is determined by Y_density, so we leave that at
jpeg_dpi if possible and crunch X_density instead (PAR > 1) */
// NOTE: write_image never passes anamorphic images currently
cinfo.X_density = ctx->opts->jpeg_dpi*image->width/image->w;
cinfo.Y_density = ctx->opts->jpeg_dpi*image->height/image->h;
cinfo.write_Adobe_marker = TRUE;
jpeg_set_defaults(&cinfo);
jpeg_set_quality(&cinfo, ctx->opts->jpeg_quality, ctx->opts->jpeg_baseline);
cinfo.optimize_coding = ctx->opts->jpeg_optimize;
cinfo.smoothing_factor = ctx->opts->jpeg_smooth;
if (ctx->opts->jpeg_progressive)
jpeg_simple_progression(&cinfo);
jpeg_start_compress(&cinfo, TRUE);
while (cinfo.next_scanline < cinfo.image_height) {
JSAMPROW row_pointer[1];
row_pointer[0] = image->planes[0] +
cinfo.next_scanline * image->stride[0];
jpeg_write_scanlines(&cinfo, row_pointer,1);
}
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
return 1;
}
ImageBuffer compress_jpeg(ImageConf imageConf, uint8_t * buffer, int out_width, int out_height)
{
ImageBuffer f;
f.buffer = NULL;
f.size = 0;
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
JSAMPROW row_pointer[1];
int row_stride;
unsigned long outlen = OUTPUT_BUF_SIZE;
unsigned char *outbuffer = malloc(outlen);
if ( !buffer )
{
printf("Error buffer null\n");
return f;
}
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
jpeg_mem_dest (&cinfo, &outbuffer, &outlen);
cinfo.image_width = out_width;
cinfo.image_height = out_height;
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&cinfo);
cinfo.write_JFIF_header = TRUE;
cinfo.JFIF_major_version = 1;
cinfo.JFIF_minor_version = 2;
cinfo.density_unit = 1;
cinfo.write_Adobe_marker = TRUE;
jpeg_set_quality(&cinfo, imageConf.quality, imageConf.baseline);
cinfo.optimize_coding = imageConf.optimize;
cinfo.smoothing_factor = imageConf.smooth;
jpeg_simple_progression(&cinfo);
jpeg_start_compress(&cinfo, TRUE);
row_stride = out_width * 3;
while (cinfo.next_scanline < cinfo.image_height)
{
row_pointer[0] = &buffer[cinfo.next_scanline * row_stride];
(void)jpeg_write_scanlines(&cinfo, row_pointer,1);
}
my_mem_dest_ptr dest = (my_mem_dest_ptr) cinfo.dest;
jpeg_finish_compress(&cinfo);
f.buffer = outbuffer;
f.size = outlen;
jpeg_destroy_compress(&cinfo);
return f;
}
static int write_jpeg(VInfo *ji, uint8_t *buffer, int quality, FILE *x) {
uint8_t *line;
int n, y = 0, i, line_width;
struct jpeg_compress_struct cjpeg;
struct jpeg_error_mgr jerr;
JSAMPROW row_ptr[1];
line = malloc(ji->out_width * 3);
if (!line) {
dlog(DLOG_CRIT, "IMF: OUT OF MEMORY, Exiting...\n");
exit(1);
}
cjpeg.err = jpeg_std_error(&jerr);
jpeg_create_compress (&cjpeg);
cjpeg.image_width = ji->out_width;
cjpeg.image_height = ji->out_height;
cjpeg.input_components = 3;
//cjpeg.smoothing_factor = 0; // 0..100
cjpeg.in_color_space = JCS_RGB;
jpeg_set_defaults (&cjpeg);
jpeg_set_quality (&cjpeg, quality, TRUE);
cjpeg.dct_method = quality > 90? JDCT_DEFAULT : JDCT_FASTEST;
jpeg_simple_progression(&cjpeg);
jpeg_stdio_dest (&cjpeg, x);
jpeg_start_compress (&cjpeg, TRUE);
row_ptr[0] = line;
line_width = ji->out_width * 3;
n = 0;
for (y = 0; y < ji->out_height; y++)
{
for (i = 0; i< line_width; i += 3)
{
line[i] = buffer[n];
line[i+1] = buffer[n+1];
line[i+2] = buffer[n+2];
n += 3;
}
jpeg_write_scanlines (&cjpeg, row_ptr, 1);
}
jpeg_finish_compress (&cjpeg);
jpeg_destroy_compress (&cjpeg);
free(line);
return(0);
}
// Take a buffer in RGBA format, has to skip 4th uchar
int encodeJPEG(unsigned char *inputbuffer, int width, int height, unsigned char **outputbuffer, unsigned long *outputsize, int quality) {
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
JSAMPROW row_pointer[1];
unsigned char *buf;
if (quality > 100)
quality = 100;
// convert RGBA to RGB
buf = malloc(sizeof(unsigned char)*width*height*3);
size_t i;
unsigned char* p = buf;
for(i=0;i<width*height*4; i++) {
if (i % 4 == 0)
continue;
*p = inputbuffer[i];
p++;
}
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
jpeg_mem_dest(&cinfo, outputbuffer, outputsize);
cinfo.image_width = width;
cinfo.image_height = height;
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&cinfo);
jpeg_set_quality(&cinfo,quality,TRUE);
jpeg_simple_progression(&cinfo);
cinfo.optimize_coding = TRUE;
jpeg_start_compress(&cinfo, TRUE);
while (cinfo.next_scanline < cinfo.image_height) {
row_pointer[0] = &buf[cinfo.next_scanline * width * 3];
jpeg_write_scanlines(&cinfo, row_pointer, 1);
}
free(buf);
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
return 0;
}
static int
out_write_jpegheader( void )
{
size_t y;
for( y = 0; y < frm_h; y++ )
row_pointers[y] = &pix_rgb[ ( greyscale ? 1 : 3 ) * y * frm_w ];
cinfo.err = jpeg_std_error( &jerr );
jpeg_create_compress( &cinfo );
cinfo.image_height = frm_h;
cinfo.image_width = frm_w;
cinfo.input_components = greyscale ? 1 : 3;
cinfo.in_color_space = greyscale ? JCS_GRAYSCALE : JCS_RGB;
jpeg_set_defaults( &cinfo );
cinfo.dct_method = jpg_dctfloat ? JDCT_FLOAT :
( jpg_idctfast ? JDCT_IFAST : JDCT_ISLOW );
cinfo.optimize_coding = jpg_optimize ? TRUE : FALSE;
cinfo.smoothing_factor = jpg_smooth < 0 || jpg_smooth > 100 ?
0 : jpg_smooth;
cinfo.write_JFIF_header = TRUE;
if( out_t != TYPE_JPEG )
jpeg_set_colorspace( &cinfo, JCS_YCbCr );
if( greyscale ) /* override AVI YCbCr... */
jpeg_set_colorspace( &cinfo, JCS_GRAYSCALE );
if( progressive )
jpeg_simple_progression( &cinfo );
jpeg_set_quality( &cinfo,
( jpg_quality < 0 || jpg_quality > 100 ? 75 : jpg_quality ),
0 );
if( out_t == TYPE_AVI )
jpeg_avi_mem_dest( &cinfo, &mem_dest, &mem_size );
else
jpeg_stdio_dest( &cinfo, out );
if( jpeg_header_ok >= 0 )
printi( 1, "out_write_jpegheader(): W=%d H=%d\n", frm_w, frm_h );
jpeg_header_ok = 1;
return 0;
}
jpeg_set_defaults (j_compress_ptr cinfo)
{
int i;
/* Safety check to ensure start_compress not called yet. */
if (cinfo->global_state != CSTATE_START)
ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
/* Allocate comp_info array large enough for maximum component count.
* Array is made permanent in case application wants to compress
* multiple images at same param settings.
*/
if (cinfo->comp_info == NULL)
cinfo->comp_info = (jpeg_component_info *)
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
MAX_COMPONENTS * SIZEOF(jpeg_component_info));
/* Initialize everything not dependent on the color space */
#if JPEG_LIB_VERSION >= 70
cinfo->scale_num = 1; /* 1:1 scaling */
cinfo->scale_denom = 1;
#endif
cinfo->data_precision = BITS_IN_JSAMPLE;
/* Set up two quantization tables using default quality of 75 */
jpeg_set_quality(cinfo, 75, TRUE);
/* Set up two Huffman tables */
std_huff_tables(cinfo);
/* Initialize default arithmetic coding conditioning */
for (i = 0; i < NUM_ARITH_TBLS; i++) {
cinfo->arith_dc_L[i] = 0;
cinfo->arith_dc_U[i] = 1;
cinfo->arith_ac_K[i] = 5;
}
#ifdef C_PROGRESSIVE_SUPPORTED
cinfo->scan_info = NULL;
cinfo->num_scans = 0;
if (!cinfo->use_moz_defaults) {
/* Default is no multiple-scan output */
cinfo->scan_info = NULL;
cinfo->num_scans = 0;
}
#else
/* Default is no multiple-scan output */
cinfo->scan_info = NULL;
cinfo->num_scans = 0;
#endif
/* Expect normal source image, not raw downsampled data */
cinfo->raw_data_in = FALSE;
/* Use Huffman coding, not arithmetic coding, by default */
cinfo->arith_code = FALSE;
#ifdef ENTROPY_OPT_SUPPORTED
if (cinfo->use_moz_defaults)
/* By default, do extra passes to optimize entropy coding */
cinfo->optimize_coding = TRUE;
else
/* By default, don't do extra passes to optimize entropy coding */
cinfo->optimize_coding = FALSE;
#else
/* By default, don't do extra passes to optimize entropy coding */
cinfo->optimize_coding = FALSE;
#endif
/* The standard Huffman tables are only valid for 8-bit data precision.
* If the precision is higher, force optimization on so that usable
* tables will be computed. This test can be removed if default tables
* are supplied that are valid for the desired precision.
*/
if (cinfo->data_precision > 8)
cinfo->optimize_coding = TRUE;
/* By default, use the simpler non-cosited sampling alignment */
cinfo->CCIR601_sampling = FALSE;
#if JPEG_LIB_VERSION >= 70
/* By default, apply fancy downsampling */
cinfo->do_fancy_downsampling = TRUE;
#endif
/* No input smoothing */
cinfo->smoothing_factor = 0;
/* DCT algorithm preference */
cinfo->dct_method = JDCT_DEFAULT;
/* No restart markers */
cinfo->restart_interval = 0;
cinfo->restart_in_rows = 0;
/* Fill in default JFIF marker parameters. Note that whether the marker
* will actually be written is determined by jpeg_set_colorspace.
*
* By default, the library emits JFIF version code 1.01.
* An application that wants to emit JFIF 1.02 extension markers should set
* JFIF_minor_version to 2. We could probably get away with just defaulting
* to 1.02, but there may still be some decoders in use that will complain
* about that; saying 1.01 should minimize compatibility problems.
*/
cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
cinfo->JFIF_minor_version = 1;
cinfo->density_unit = 0; /* Pixel size is unknown by default */
cinfo->X_density = 1; /* Pixel aspect ratio is square by default */
cinfo->Y_density = 1;
/* Choose JPEG colorspace based on input space, set defaults accordingly */
jpeg_default_colorspace(cinfo);
cinfo->one_dc_scan = TRUE;
#ifdef C_PROGRESSIVE_SUPPORTED
if (cinfo->use_moz_defaults) {
cinfo->optimize_scans = TRUE;
jpeg_simple_progression(cinfo);
} else
cinfo->optimize_scans = FALSE;
#endif
cinfo->trellis_quant = cinfo->use_moz_defaults;
cinfo->lambda_log_scale1 = 16.0;
cinfo->lambda_log_scale2 = 15.5;
cinfo->use_lambda_weight_tbl = TRUE;
cinfo->use_scans_in_trellis = FALSE;
cinfo->trellis_freq_split = 8;
cinfo->trellis_num_loops = 1;
cinfo->trellis_q_opt = FALSE;
}
BGD_DECLARE(void) gdImageJpegCtx(gdImagePtr im, gdIOCtx *outfile, int quality)
{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
int i, j, jidx;
/* volatile so we can gdFree it on return from longjmp */
volatile JSAMPROW row = 0;
JSAMPROW rowptr[1];
jmpbuf_wrapper jmpbufw;
JDIMENSION nlines;
char comment[255];
#ifdef JPEG_DEBUG
gd_error_ex(GD_DEBUG, "gd-jpeg: gd JPEG version %s\n", GD_JPEG_VERSION);
gd_error_ex(GD_DEBUG, "gd-jpeg: JPEG library version %d, %d-bit sample values\n", JPEG_LIB_VERSION, BITS_IN_JSAMPLE);
if (!im->trueColor) {
for(i = 0; i < im->colorsTotal; i++) {
if(!im->open[i]) {
gd_error_ex(GD_DEBUG, "gd-jpeg: gd colormap index %d: (%d, %d, %d)\n", i, im->red[i], im->green[i], im->blue[i]);
}
}
}
#endif /* JPEG_DEBUG */
memset(&cinfo, 0, sizeof(cinfo));
memset(&jerr, 0, sizeof(jerr));
cinfo.err = jpeg_std_error(&jerr);
cinfo.client_data = &jmpbufw;
if(setjmp(jmpbufw.jmpbuf) != 0) {
/* we're here courtesy of longjmp */
if(row) {
gdFree(row);
}
return;
}
cinfo.err->emit_message = jpeg_emit_message;
cinfo.err->error_exit = fatal_jpeg_error;
jpeg_create_compress(&cinfo);
cinfo.image_width = im->sx;
cinfo.image_height = im->sy;
cinfo.input_components = 3; /* # of color components per pixel */
cinfo.in_color_space = JCS_RGB; /* colorspace of input image */
jpeg_set_defaults(&cinfo);
cinfo.density_unit = 1;
cinfo.X_density = im->res_x;
cinfo.Y_density = im->res_y;
if(quality >= 0) {
jpeg_set_quality(&cinfo, quality, TRUE);
}
/* If user requests interlace, translate that to progressive JPEG */
if(gdImageGetInterlaced(im)) {
#ifdef JPEG_DEBUG
gd_error_ex(GD_DEBUG, "gd-jpeg: interlace set, outputting progressive JPEG image\n");
#endif
jpeg_simple_progression(&cinfo);
}
jpeg_gdIOCtx_dest(&cinfo, outfile);
row = (JSAMPROW)gdCalloc(1, cinfo.image_width * cinfo.input_components * sizeof(JSAMPLE));
if(row == 0) {
gd_error("gd-jpeg: error: unable to allocate JPEG row structure: gdCalloc returns NULL\n");
jpeg_destroy_compress(&cinfo);
return;
}
rowptr[0] = row;
jpeg_start_compress(&cinfo, TRUE);
sprintf(comment, "CREATOR: gd-jpeg v%s (using IJG JPEG v%d),", GD_JPEG_VERSION, JPEG_LIB_VERSION);
if(quality >= 0) {
sprintf (comment + strlen(comment), " quality = %d\n", quality);
} else {
strcat(comment + strlen(comment), " default quality\n");
}
jpeg_write_marker(&cinfo, JPEG_COM, (unsigned char *) comment, (unsigned int)strlen(comment));
if(im->trueColor) {
#if BITS_IN_JSAMPLE == 12
gd_error(
"gd-jpeg: error: jpeg library was compiled for 12-bit\n"
"precision. This is mostly useless, because JPEGs on the web are\n"
"8-bit and such versions of the jpeg library won't read or write\n"
"them. GD doesn't support these unusual images. Edit your\n"
"jmorecfg.h file to specify the correct precision and completely\n"
"'make clean' and 'make install' libjpeg again. Sorry.\n"
);
goto error;
#endif /* BITS_IN_JSAMPLE == 12 */
for(i = 0; i < im->sy; i++) {
for(jidx = 0, j = 0; j < im->sx; j++) {
int val = im->tpixels[i][j];
row[jidx++] = gdTrueColorGetRed(val);
row[jidx++] = gdTrueColorGetGreen(val);
row[jidx++] = gdTrueColorGetBlue(val);
}
nlines = jpeg_write_scanlines(&cinfo, rowptr, 1);
if(nlines != 1) {
gd_error("gd_jpeg: warning: jpeg_write_scanlines returns %u -- expected 1\n", nlines);
}
}
} else {
for(i = 0; i < im->sy; i++) {
for(jidx = 0, j = 0; j < im->sx; j++) {
int idx = im->pixels[i][j];
/*
* NB: Although gd RGB values are ints, their max value is
* 255 (see the documentation for gdImageColorAllocate())
* -- perfect for 8-bit JPEG encoding (which is the norm)
*/
#if BITS_IN_JSAMPLE == 8
row[jidx++] = im->red[idx];
row[jidx++] = im->green[idx];
row[jidx++] = im->blue[idx];
#elif BITS_IN_JSAMPLE == 12
row[jidx++] = im->red[idx] << 4;
row[jidx++] = im->green[idx] << 4;
row[jidx++] = im->blue[idx] << 4;
#else
#error IJG JPEG library BITS_IN_JSAMPLE value must be 8 or 12
#endif
}
nlines = jpeg_write_scanlines(&cinfo, rowptr, 1);
if(nlines != 1) {
gd_error("gd_jpeg: warning: jpeg_write_scanlines"
" returns %u -- expected 1\n", nlines);
}
}
}
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
gdFree(row);
}
/*!
* \brief pixWriteStreamJpeg()
*
* \param[in] fp file stream
* \param[in] pixs any depth; cmap is OK
* \param[in] quality 1 - 100; 75 is default value; 0 is also default
* \param[in] progressive 0 for baseline sequential; 1 for progressive
* \return 0 if OK, 1 on error
*
* <pre>
* Notes:
* (1) Progressive encoding gives better compression, at the
* expense of slower encoding and decoding.
* (2) Standard chroma subsampling is 2x2 on both the U and V
* channels. For highest quality, use no subsampling; this
* option is set by pixSetChromaSampling(pix, 0).
* (3) The only valid pixel depths in leptonica are 1, 2, 4, 8, 16
* and 32 bpp. However, it is possible, and in some cases desirable,
* to write out a jpeg file using an rgb pix that has 24 bpp.
* This can be created by appending the raster data for a 24 bpp
* image (with proper scanline padding) directly to a 24 bpp
* pix that was created without a data array.
* (4) There are two compression paths in this function:
* * Grayscale image, no colormap: compress as 8 bpp image.
* * rgb full color image: copy each line into the color
* line buffer, and compress as three 8 bpp images.
* (5) Under the covers, the jpeg library transforms rgb to a
* luminance-chromaticity triple, each component of which is
* also 8 bits, and compresses that. It uses 2 Huffman tables,
* a higher resolution one (with more quantization levels)
* for luminosity and a lower resolution one for the chromas.
* </pre>
*/
l_int32
pixWriteStreamJpeg(FILE *fp,
PIX *pixs,
l_int32 quality,
l_int32 progressive)
{
l_int32 xres, yres;
l_int32 i, j, k;
l_int32 w, h, d, wpl, spp, colorflag, rowsamples;
l_uint32 *ppixel, *line, *data;
JSAMPROW rowbuffer;
PIX *pix;
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
const char *text;
jmp_buf jmpbuf; /* must be local to the function */
PROCNAME("pixWriteStreamJpeg");
if (!fp)
return ERROR_INT("stream not open", procName, 1);
if (!pixs)
return ERROR_INT("pixs not defined", procName, 1);
if (quality <= 0)
quality = 75; /* default */
/* If necessary, convert the pix so that it can be jpeg compressed.
* The colormap is removed based on the source, so if the colormap
* has only gray colors, the image will be compressed with spp = 1. */
pixGetDimensions(pixs, &w, &h, &d);
pix = NULL;
if (pixGetColormap(pixs) != NULL) {
L_INFO("removing colormap; may be better to compress losslessly\n",
procName);
pix = pixRemoveColormap(pixs, REMOVE_CMAP_BASED_ON_SRC);
} else if (d >= 8 && d != 16) { /* normal case; no rewrite */
pix = pixClone(pixs);
} else if (d < 8 || d == 16) {
L_INFO("converting from %d to 8 bpp\n", procName, d);
pix = pixConvertTo8(pixs, 0); /* 8 bpp, no cmap */
} else {
L_ERROR("unknown pix type with d = %d and no cmap\n", procName, d);
return 1;
}
if (!pix)
return ERROR_INT("pix not made", procName, 1);
rewind(fp);
rowbuffer = NULL;
/* Modify the jpeg error handling to catch fatal errors */
cinfo.err = jpeg_std_error(&jerr);
cinfo.client_data = (void *)&jmpbuf;
jerr.error_exit = jpeg_error_catch_all_1;
if (setjmp(jmpbuf)) {
LEPT_FREE(rowbuffer);
pixDestroy(&pix);
return ERROR_INT("internal jpeg error", procName, 1);
}
/* Initialize the jpeg structs for compression */
jpeg_create_compress(&cinfo);
jpeg_stdio_dest(&cinfo, fp);
cinfo.image_width = w;
cinfo.image_height = h;
/* Set the color space and number of components */
d = pixGetDepth(pix);
if (d == 8) {
colorflag = 0; /* 8 bpp grayscale; no cmap */
cinfo.input_components = 1;
cinfo.in_color_space = JCS_GRAYSCALE;
} else { /* d == 32 || d == 24 */
colorflag = 1; /* rgb */
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
}
jpeg_set_defaults(&cinfo);
/* Setting optimize_coding to TRUE seems to improve compression
* by approx 2-4 percent, and increases comp time by approx 20%. */
cinfo.optimize_coding = FALSE;
/* Set resolution in pixels/in (density_unit: 1 = in, 2 = cm) */
xres = pixGetXRes(pix);
yres = pixGetYRes(pix);
if ((xres != 0) && (yres != 0)) {
cinfo.density_unit = 1; /* designates pixels per inch */
cinfo.X_density = xres;
cinfo.Y_density = yres;
}
/* Set the quality and progressive parameters */
jpeg_set_quality(&cinfo, quality, TRUE);
if (progressive)
jpeg_simple_progression(&cinfo);
/* Set the chroma subsampling parameters. This is done in
* YUV color space. The Y (intensity) channel is never subsampled.
* The standard subsampling is 2x2 on both the U and V channels.
* Notation on this is confusing. For a nice illustrations, see
* http://en.wikipedia.org/wiki/Chroma_subsampling
* The standard subsampling is written as 4:2:0.
* We allow high quality where there is no subsampling on the
* chroma channels: denoted as 4:4:4. */
if (pixs->special == L_NO_CHROMA_SAMPLING_JPEG) {
cinfo.comp_info[0].h_samp_factor = 1;
cinfo.comp_info[0].v_samp_factor = 1;
cinfo.comp_info[1].h_samp_factor = 1;
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1;
cinfo.comp_info[2].v_samp_factor = 1;
}
jpeg_start_compress(&cinfo, TRUE);
if ((text = pixGetText(pix)))
jpeg_write_marker(&cinfo, JPEG_COM, (const JOCTET *)text, strlen(text));
/* Allocate row buffer */
spp = cinfo.input_components;
rowsamples = spp * w;
if ((rowbuffer = (JSAMPROW)LEPT_CALLOC(sizeof(JSAMPLE), rowsamples))
== NULL) {
pixDestroy(&pix);
return ERROR_INT("calloc fail for rowbuffer", procName, 1);
}
data = pixGetData(pix);
wpl = pixGetWpl(pix);
for (i = 0; i < h; i++) {
line = data + i * wpl;
if (colorflag == 0) { /* 8 bpp gray */
for (j = 0; j < w; j++)
rowbuffer[j] = GET_DATA_BYTE(line, j);
} else { /* colorflag == 1 */
if (d == 24) { /* See note 3 above; special case of 24 bpp rgb */
jpeg_write_scanlines(&cinfo, (JSAMPROW *)&line, 1);
} else { /* standard 32 bpp rgb */
ppixel = line;
for (j = k = 0; j < w; j++) {
rowbuffer[k++] = GET_DATA_BYTE(ppixel, COLOR_RED);
rowbuffer[k++] = GET_DATA_BYTE(ppixel, COLOR_GREEN);
rowbuffer[k++] = GET_DATA_BYTE(ppixel, COLOR_BLUE);
ppixel++;
}
}
}
if (d != 24)
jpeg_write_scanlines(&cinfo, &rowbuffer, 1);
}
jpeg_finish_compress(&cinfo);
pixDestroy(&pix);
LEPT_FREE(rowbuffer);
jpeg_destroy_compress(&cinfo);
return 0;
}
/*
* Class: org_apache_harmony_x_imageio_plugins_jpeg_JPEGImageWriter
* Method: encode
* Signature: ([BIIIIIIIZ[[IJ)Z
*/
JNIEXPORT jboolean JNICALL
Java_org_apache_harmony_x_imageio_plugins_jpeg_JPEGImageWriter_encode(JNIEnv *env,
jobject callerObj, jbyteArray arr, jint srcWidth, jint width, jint height, jint deltaX,
jint in_cs, jint out_cs, jint numBands, jboolean progressive, jobjectArray dqts, jlong handle)
{
JSAMPROW row_pointer;
struct jpeg_compress_struct * cinfo;
enc_error_mgr_ptr err_mgr;
int i, j;
int cur_scanline;
unsigned char * native_buffer;
unsigned char * rowPtr;
jboolean optimizeHuffman = FALSE;
row_pointer = (JSAMPROW) malloc(width * numBands);
if (!row_pointer) {
throwNewOutOfMemoryError(env, "Unable to allocate memory for IJG structures");
return FALSE;
}
cinfo = (struct jpeg_compress_struct *) (IDATA)handle;
err_mgr = (enc_error_mgr_ptr) cinfo->err;
if (setjmp(err_mgr->jmp_buffer)) {
if (!(*env)->ExceptionOccurred(env)) {
char msg_buffer[JMSG_LENGTH_MAX];
cinfo->err->format_message((j_common_ptr)cinfo, msg_buffer);
throwNewExceptionByName(env, "javax/imageio/IIOException",
msg_buffer);
}
if (row_pointer) {
free(row_pointer);
}
return FALSE;
}
cinfo->image_width = width;
cinfo->image_height = height;
cinfo->input_components = numBands;
cinfo->in_color_space = in_cs;
jpeg_set_defaults(cinfo);
jpeg_set_colorspace(cinfo, out_cs);
cinfo->optimize_coding = optimizeHuffman;
//-- TRUE - for pure abbrivated images (wo tables) creation
//-- if you want to write some tables set "sent_table = FALSE" after
//-- this call for the table to be emitted.
//jpeg_suppress_tables(&cinfo, TRUE);
jpeg_suppress_tables(cinfo, FALSE);
setupDQTs(env, cinfo, dqts);
//-- only simple progression sequence
if (progressive) {
jpeg_simple_progression(cinfo);
}
//-- TRUE forces all "sent_table = FALSE" so all tables will be written
jpeg_start_compress(cinfo, TRUE);
//-- use this for tables-only files and abbrivated images.
//-- If using jpeg_suppress_tables(&cinfo, TRUE):
//-- Only DQT sent_table = FALSE right now -> so DQT will be written but not DHT.
//-- uncomment when custom huffman tables be used.
//jpeg_start_compress(&cinfo, FALSE);
cur_scanline = 0;
while (cinfo->next_scanline < cinfo->image_height) {
(*env)->CallVoidMethod(env, callerObj, getScanlineID, cur_scanline);
// checking for an exception in the java method
if ((*env)->ExceptionOccurred(env)) {
//c_struct->exception_in_callback = TRUE;
cinfo->err->error_exit((j_common_ptr) cinfo);
}
native_buffer = (JOCTET*) (*env)->GetPrimitiveArrayCritical(env, arr, NULL);
// subsampling and copying to internal array
rowPtr = row_pointer;
for (i = 0; i < srcWidth * numBands; i += numBands * deltaX) {
for (j = 0; j < numBands; j++) {
*rowPtr++ = native_buffer[i + j];
}
}
(*env)->ReleasePrimitiveArrayCritical(env, arr, native_buffer, 0);
jpeg_write_scanlines(cinfo, &row_pointer, 1);
cur_scanline++;
}
jpeg_finish_compress(cinfo);
free(row_pointer);
return TRUE;
}
void Jpegoptim(sLONG_PTR *pResult, PackagePtr pParams)
{
C_LONGINT Param2_Options;
C_LONGINT Param3_Quality;
int quality = -1;
int save_exif = 0;
int save_iptc = 0;
int save_com = 0;
int save_icc = 0;
int save_xmp = 0;
struct jpeg_decompress_struct dinfo;
struct jpeg_compress_struct cinfo;
struct my_error_mgr jcerr, jderr;
Param2_Options.fromParamAtIndex(pParams, 2);
unsigned int o = Param2_Options.getIntValue();
if(o)
{
save_exif = !(o & JPEG_STRIP_EXIF);
save_iptc = !(o & JPEG_STRIP_IPTC);
save_com = !(o & JPEG_STRIP_COM );
save_icc = !(o & JPEG_STRIP_ICC );
save_xmp = !(o & JPEG_STRIP_XMP );
}
Param3_Quality.fromParamAtIndex(pParams, 3);
unsigned int q = Param3_Quality.getIntValue();
if ((q >= 1) && (q <= 101))
{
quality = (q-1);
}
jvirt_barray_ptr *coef_arrays = NULL;
JSAMPARRAY buf = NULL;
/* get jpeg data */
std::vector<unsigned char>pictureData;
std::string type(".jpeg");
if(getPictureDataForType(pParams, 1, pictureData, type))
{
/* initialize decompression object */
dinfo.err = jpeg_std_error(&jderr.pub);
jpeg_create_decompress(&dinfo);
jderr.pub.error_exit=my_error_exit;
jderr.pub.output_message=my_output_message;
jderr.jump_set = 0;
/* initialize compression object */
cinfo.err = jpeg_std_error(&jcerr.pub);
jpeg_create_compress(&cinfo);
jcerr.pub.error_exit=my_error_exit;
jcerr.pub.output_message=my_output_message;
jcerr.jump_set = 0;
if (setjmp(jderr.setjmp_buffer))
{
/* error handler for decompress */
jpeg_abort_decompress(&dinfo);
jderr.jump_set=0;
} else {
jderr.jump_set=1;
}
/* prepare to decompress */
jpeg_save_markers(&dinfo, JPEG_COM, 0xffff);
for (int j=0;j<=15;j++)
jpeg_save_markers(&dinfo, JPEG_APP0+j, 0xffff);
jpeg_mem_src(&dinfo, &pictureData[0], pictureData.size());
jpeg_read_header(&dinfo, TRUE);
jpeg_start_decompress(&dinfo);
if(quality == -1)
{
coef_arrays = jpeg_read_coefficients(&dinfo);
}else
{
buf = (JSAMPARRAY)malloc(sizeof(JSAMPROW)*dinfo.output_height);
for (int j=0;j<dinfo.output_height;j++) {
buf[j]=(JSAMPROW)malloc(sizeof(JSAMPLE)*dinfo.output_width*dinfo.out_color_components);
}
while (dinfo.output_scanline < dinfo.output_height)
{
PA_YieldAbsolute();
jpeg_read_scanlines(&dinfo,&buf[dinfo.output_scanline], dinfo.output_height-dinfo.output_scanline);
}
}
if (setjmp(jcerr.setjmp_buffer))
{
/* error handler for compress failures */
jpeg_abort_compress(&cinfo);
jpeg_abort_decompress(&dinfo);
jcerr.jump_set=0;
} else {
jcerr.jump_set=1;
}
size_t outbuffersize = pictureData.size() + 32768;
unsigned char *outbuffer = (unsigned char *)malloc(outbuffersize);
if(outbuffer)
{
jpeg_memory_dest(&cinfo, &outbuffer, &outbuffersize, 65536);
if(quality == -1)
{
jpeg_copy_critical_parameters(&dinfo, &cinfo);
jpeg_simple_progression(&cinfo);
cinfo.optimize_coding = TRUE;
}else
{
cinfo.in_color_space=dinfo.out_color_space;
cinfo.input_components=dinfo.output_components;
cinfo.image_width=dinfo.image_width;
cinfo.image_height=dinfo.image_height;
jpeg_set_defaults(&cinfo);
jpeg_set_quality(&cinfo,quality,TRUE);
jpeg_simple_progression(&cinfo);
cinfo.optimize_coding = TRUE;
jpeg_start_compress(&cinfo,TRUE);
}
write_markers(&dinfo,&cinfo,
save_exif,
save_iptc,
save_com,
save_icc,
save_xmp);
if(quality == -1)
{
jpeg_write_coefficients(&cinfo, coef_arrays);
}else
{
while (cinfo.next_scanline < cinfo.image_height)
{
PA_YieldAbsolute();
jpeg_write_scanlines(&cinfo,&buf[cinfo.next_scanline], dinfo.output_height);
}
}
jpeg_finish_decompress(&dinfo);
if(quality != -1)
{
jpeg_finish_compress(&cinfo);
FREE_LINE_BUF(buf,dinfo.output_height);
}
jpeg_destroy_decompress(&dinfo);
jpeg_destroy_compress(&cinfo);
PA_Picture picture = PA_CreatePicture((void *)outbuffer, outbuffersize);
*(PA_Picture*) pResult = picture;
free(outbuffer);
}
}
}
long WriteJPEG( void* pJPEGWriter, void* pOStm,
long nWidth, long nHeight, long bGreys,
long nQualityPercent, void* pCallbackData )
{
struct jpeg_compress_struct cinfo;
struct my_error_mgr jerr;
void* pScanline;
long nY;
// declare bCompCreated, bRet volatile because of gcc
// warning: variable 'bCompCreated' might be clobbered by `longjmp' or `vfork'
volatile long bCompCreated = 0;
volatile long bRet = 0;
if ( setjmp( jerr.setjmp_buffer ) )
goto Exit;
cinfo.err = jpeg_std_error( &jerr.pub );
jerr.pub.error_exit = my_error_exit;
jerr.pub.output_message = my_output_message;
jpeg_create_compress( &cinfo );
bCompCreated = 1;
jpeg_svstream_dest( &cinfo, pOStm );
cinfo.image_width = (JDIMENSION) nWidth;
cinfo.image_height = (JDIMENSION) nHeight;
if ( bGreys )
{
cinfo.input_components = 1;
cinfo.in_color_space = JCS_GRAYSCALE;
}
else
{
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
}
jpeg_set_defaults( &cinfo );
jpeg_set_quality( &cinfo, (int) nQualityPercent, sal_False );
if ( ( nWidth > 128 ) || ( nHeight > 128 ) )
jpeg_simple_progression( &cinfo );
jpeg_start_compress( &cinfo, sal_True );
for( nY = 0; nY < nHeight; nY++ )
{
pScanline = GetScanline( pJPEGWriter, nY );
if( pScanline )
jpeg_write_scanlines( &cinfo, (JSAMPARRAY) &pScanline, 1 );
if( JPEGCallback( pCallbackData, nY * 100L / nHeight ) )
goto Exit;
}
bRet = 1;
jpeg_finish_compress(&cinfo);
Exit:
if ( bCompCreated )
jpeg_destroy_compress( &cinfo );
return bRet;
}
parse_switches (j_compress_ptr cinfo, int argc, char **argv,
int last_file_arg_seen, boolean for_real)
/* Parse optional switches.
* Returns argv[] index of first file-name argument (== argc if none).
* Any file names with indexes <= last_file_arg_seen are ignored;
* they have presumably been processed in a previous iteration.
* (Pass 0 for last_file_arg_seen on the first or only iteration.)
* for_real is FALSE on the first (dummy) pass; we may skip any expensive
* processing.
*/
{
int argn;
char * arg;
boolean simple_progressive;
char * scansarg = NULL; /* saves -scans parm if any */
/* Set up default JPEG parameters. */
simple_progressive = FALSE;
outfilename = NULL;
copyoption = JCOPYOPT_DEFAULT;
transformoption.transform = JXFORM_NONE;
transformoption.trim = FALSE;
transformoption.force_grayscale = FALSE;
cinfo->err->trace_level = 0;
/* Scan command line options, adjust parameters */
for (argn = 1; argn < argc; argn++) {
arg = argv[argn];
if (*arg != '-') {
/* Not a switch, must be a file name argument */
if (argn <= last_file_arg_seen) {
outfilename = NULL; /* -outfile applies to just one input file */
continue; /* ignore this name if previously processed */
}
break; /* else done parsing switches */
}
arg++; /* advance past switch marker character */
if (keymatch(arg, "arithmetic", 1)) {
/* Use arithmetic coding. */
#ifdef C_ARITH_CODING_SUPPORTED
cinfo->arith_code = TRUE;
#else
fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "copy", 1)) {
/* Select which extra markers to copy. */
if (++argn >= argc) /* advance to next argument */
usage();
if (keymatch(argv[argn], "none", 1)) {
copyoption = JCOPYOPT_NONE;
} else if (keymatch(argv[argn], "comments", 1)) {
copyoption = JCOPYOPT_COMMENTS;
} else if (keymatch(argv[argn], "all", 1)) {
copyoption = JCOPYOPT_ALL;
} else
usage();
} else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
/* Enable debug printouts. */
/* On first -d, print version identification */
static boolean printed_version = FALSE;
if (! printed_version) {
fprintf(stderr, "Independent JPEG Group's JPEGTRAN, version %s\n%s\n",
JVERSION, JCOPYRIGHT);
printed_version = TRUE;
}
cinfo->err->trace_level++;
} else if (keymatch(arg, "flip", 1)) {
/* Mirror left-right or top-bottom. */
if (++argn >= argc) /* advance to next argument */
usage();
if (keymatch(argv[argn], "horizontal", 1))
select_transform(JXFORM_FLIP_H);
else if (keymatch(argv[argn], "vertical", 1))
select_transform(JXFORM_FLIP_V);
else
usage();
} else if (keymatch(arg, "grayscale", 1) || keymatch(arg, "greyscale",1)) {
/* Force to grayscale. */
#if TRANSFORMS_SUPPORTED
transformoption.force_grayscale = TRUE;
#else
select_transform(JXFORM_NONE); /* force an error */
#endif
} else if (keymatch(arg, "maxmemory", 3)) {
/* Maximum memory in Kb (or Mb with 'm'). */
long lval;
char ch = 'x';
if (++argn >= argc) /* advance to next argument */
usage();
if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
usage();
if (ch == 'm' || ch == 'M')
lval *= 1000L;
cinfo->mem->max_memory_to_use = lval * 1000L;
} else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) {
/* Enable entropy parm optimization. */
#ifdef ENTROPY_OPT_SUPPORTED
cinfo->optimize_coding = TRUE;
#else
fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "outfile", 4)) {
/* Set output file name. */
if (++argn >= argc) /* advance to next argument */
usage();
outfilename = argv[argn]; /* save it away for later use */
} else if (keymatch(arg, "progressive", 1)) {
/* Select simple progressive mode. */
#ifdef C_PROGRESSIVE_SUPPORTED
simple_progressive = TRUE;
/* We must postpone execution until num_components is known. */
#else
fprintf(stderr, "%s: sorry, progressive output was not compiled\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "restart", 1)) {
/* Restart interval in MCU rows (or in MCUs with 'b'). */
long lval;
char ch = 'x';
if (++argn >= argc) /* advance to next argument */
usage();
if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
usage();
if (lval < 0 || lval > 65535L)
usage();
if (ch == 'b' || ch == 'B') {
cinfo->restart_interval = (unsigned int) lval;
cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */
} else {
cinfo->restart_in_rows = (int) lval;
/* restart_interval will be computed during startup */
}
} else if (keymatch(arg, "rotate", 2)) {
/* Rotate 90, 180, or 270 degrees (measured clockwise). */
if (++argn >= argc) /* advance to next argument */
usage();
if (keymatch(argv[argn], "90", 2))
select_transform(JXFORM_ROT_90);
else if (keymatch(argv[argn], "180", 3))
select_transform(JXFORM_ROT_180);
else if (keymatch(argv[argn], "270", 3))
select_transform(JXFORM_ROT_270);
else
usage();
} else if (keymatch(arg, "scans", 1)) {
/* Set scan script. */
#ifdef C_MULTISCAN_FILES_SUPPORTED
if (++argn >= argc) /* advance to next argument */
usage();
scansarg = argv[argn];
/* We must postpone reading the file in case -progressive appears. */
#else
fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "transpose", 1)) {
/* Transpose (across UL-to-LR axis). */
select_transform(JXFORM_TRANSPOSE);
} else if (keymatch(arg, "transverse", 6)) {
/* Transverse transpose (across UR-to-LL axis). */
select_transform(JXFORM_TRANSVERSE);
} else if (keymatch(arg, "trim", 3)) {
/* Trim off any partial edge MCUs that the transform can't handle. */
transformoption.trim = TRUE;
} else {
usage(); /* bogus switch */
}
}
/* Post-switch-scanning cleanup */
if (for_real) {
#ifdef C_PROGRESSIVE_SUPPORTED
if (simple_progressive) /* process -progressive; -scans can override */
jpeg_simple_progression(cinfo);
#endif
#ifdef C_MULTISCAN_FILES_SUPPORTED
if (scansarg != NULL) /* process -scans if it was present */
if (! read_scan_script(cinfo, scansarg))
usage();
#endif
}
return argn; /* return index of next arg (file name) */
}
csPtr<iDataBuffer> csJNGImageIO::Save (iImage *Image,
iImageIO::FileFormatDescription *, const char* extraoptions)
{
// we need to get a RGB/RGBA version of the image.
switch (Image->GetFormat() & CS_IMGFMT_MASK)
{
case CS_IMGFMT_PALETTED8:
//imgRGBA = Image->Clone ();
//imgRGBA->SetFormat (CS_IMGFMT_TRUECOLOR | (Image->GetFormat() & CS_IMGFMT_ALPHA));
// act like JPEG plugin; reject paletted image so no
// unwanted/unnoticed conversions take place.
return 0;
break;
case CS_IMGFMT_TRUECOLOR:
imgRGBA = csRef<iImage>(Image);
break;
default:
// unknown format
return 0;
}
// compression options
int quality = 80;
bool progressive = false;
bool alpha_jpeg = false;
int alpha_png_compress = 6;
int alpha_jpeg_quality = -1;
/*
parse output options.
options are a comma-separated list and can be either
'option' or 'option=value'.
supported options:
compress=# image color compression, 0..100 higher values give smaller files
but uglier results.
progressive progressive encoding.
jng_lossy_alpha use lossy JPEG compression for alpha channel (instead of
default lossles PNG)
jng_alpha_compress alpha channel compression, 0..100
Impact of higher value depends on alpha channel type.
JPEG - smaller files, uglier results.
PNG - smaller files, longer time to encode.
Note: defaults to value for image color compression if lossy alpha
is selected.
examples:
compress=50
progressive,compress=30
*/
csImageLoaderOptionsParser optparser (extraoptions);
optparser.GetBool ("progressive", progressive);
if (optparser.GetInt ("compress", quality))
{
quality = 100 - quality;
if (quality < 0) quality = 0;
if (quality > 100) quality = 100;
if (alpha_jpeg_quality == -1) alpha_jpeg_quality = quality;
}
if (optparser.GetBool ("jng_lossy_alpha", alpha_jpeg))
{
if (alpha_jpeg_quality == -1) alpha_jpeg_quality = quality;
}
if (optparser.GetInt ("jng_alpha_compress", alpha_png_compress))
{
alpha_jpeg_quality = 100 - alpha_png_compress;
if (alpha_jpeg_quality < 0) alpha_jpeg_quality = 0;
if (alpha_jpeg_quality > 100) alpha_jpeg_quality = 100;
alpha_png_compress /= 10;
if (alpha_png_compress < 0) alpha_png_compress = 0;
if (alpha_png_compress > 9) alpha_png_compress = 9;
}
mng_handle handle = mng_initialize ( mng_ptr(this), cb_alloc,
cb_free, MNG_NULL);
if (!handle)
{
Report (object_reg, CS_REPORTER_SEVERITY_WARNING,
"failed to initialize libmng");
return 0;
}
if ((mng_setcb_openstream (handle, cb_openstream) != MNG_NOERROR) ||
(mng_setcb_closestream (handle, cb_closestream) != MNG_NOERROR) ||
(mng_setcb_writedata (handle, cb_writedata) != MNG_NOERROR))
{
ReportLibmngError (object_reg, handle, "failed to set libmng callbacks");
mng_cleanup (&handle);
return 0;
}
outfile = new csMemFile ();
if (mng_create (handle) != MNG_NOERROR)
{
ReportLibmngError (object_reg, handle, "failed to create new jng");
mng_cleanup (&handle);
delete outfile;
imgRGBA = 0;
return 0;
}
bool has_alpha = (imgRGBA->GetFormat() & CS_IMGFMT_ALPHA) != 0;
if (mng_putchunk_jhdr (handle, imgRGBA->GetWidth(), imgRGBA->GetHeight(),
has_alpha ? MNG_COLORTYPE_JPEGCOLORA
: MNG_COLORTYPE_JPEGCOLOR,
MNG_BITDEPTH_JPEG8, MNG_COMPRESSION_BASELINEJPEG,
progressive ? MNG_INTERLACE_PROGRESSIVE
: MNG_INTERLACE_SEQUENTIAL,
has_alpha?8:0, has_alpha?(alpha_jpeg?8:0):0,
0, 0) != MNG_NOERROR)
{
ReportLibmngError (object_reg, handle, "failed to put JHDR chunk");
mng_cleanup (&handle);
delete outfile;
imgRGBA = 0;
return 0;
}
// @@@ chunk data generation.
// lots of stuff needs to be done manually.
// should be changed as libmng evolves.
// write out alpha channel
if (has_alpha)
{
// extract the alpha channel from the image
int pixels = imgRGBA->GetWidth() * imgRGBA->GetHeight();
uint8 *alpha = new uint8 [pixels];
uint8 *alphaptr = alpha;
csRGBpixel *imgdata = (csRGBpixel*)imgRGBA->GetImageData();
while (pixels>0)
{
*alphaptr++ = (imgdata++)->alpha;
pixels--;
}
if (alpha_jpeg)
{
// compress the alpha data as JPEG and write it out.
uint8* volatile row = 0;
struct jpg_datastore ds;
struct jpeg_compress_struct cinfo;
struct my_error_mgr jerr;
cinfo.err = jpeg_std_error (&jerr.pub);
jerr.pub.error_exit = my_error_exit;
if (setjmp (jerr.setjmp_buffer))
{
Report (object_reg, CS_REPORTER_SEVERITY_WARNING,
"failed to JPEG compress alpha data");
mng_cleanup (&handle);
delete outfile;
delete [] row;
delete[] alpha;
jpeg_destroy_compress (&cinfo);
imgRGBA = 0;
return 0;
}
jpeg_create_compress (&cinfo);
jpeg_buffer_dest (&cinfo, &ds);
cinfo.image_width = imgRGBA->GetWidth ();
cinfo.image_height = imgRGBA->GetHeight ();
cinfo.input_components = 1;
cinfo.in_color_space = JCS_GRAYSCALE;
row = new uint8[cinfo.image_width];
jpeg_set_defaults (&cinfo);
jpeg_set_quality (&cinfo, alpha_jpeg_quality, true);
jpeg_start_compress (&cinfo, true);
JSAMPROW row_pointer[1];
uint8 *image = alpha;
row_pointer[0] = (JSAMPLE*)&row[0];
while (cinfo.next_scanline < cinfo.image_height)
{
for (size_t i=0; i < cinfo.image_width; i++)
row[i] = image[cinfo.next_scanline * cinfo.image_width + i];
jpeg_write_scanlines (&cinfo, row_pointer, 1);
}
jpeg_finish_compress (&cinfo);
jpeg_destroy_compress (&cinfo);
delete [] row;
// funny, mng_putchunk_jdaa is missing from libmng
//if (mng_putchunk_jdaa (handle, ds.len, ds.data) != MNG_NOERROR)
if (mng_putchunk_unknown (handle, MNG_UINT_JDAA,
(mng_uint32)ds.len, ds.data) != MNG_NOERROR)
{
ReportLibmngError (object_reg, handle, "failed to put JDAA chunk");
mng_cleanup (&handle);
delete outfile;
delete[] alpha;
imgRGBA = 0;
return 0;
}
}
else
{
// generate the IDAT chunk data
// we use the "Up" filter.
uint8* chunkdata = new uint8[(imgRGBA->GetWidth() + 1) * imgRGBA->GetHeight()];
uint8* lastline = new uint8[imgRGBA->GetWidth()];
uint8* chunkptr = chunkdata;
alphaptr = alpha;
memset (lastline, 0, imgRGBA->GetWidth());
int lines = imgRGBA->GetHeight();
while (lines > 0)
{
*chunkptr++ = 2;
int pix = 0;
while (pix<imgRGBA->GetWidth())
{
*chunkptr++ = *alphaptr - lastline[pix];
lastline[pix] = *alphaptr++;
pix++;
}
lines--;
}
delete[] lastline;
// now compress the data
z_stream zs;
zs.zalloc = (alloc_func) 0;
zs.zfree = (free_func) 0;
zs.next_in = (Byte *) chunkdata;
zs.avail_in = (imgRGBA->GetWidth() + 1) * imgRGBA->GetHeight();
if (deflateInit (&zs, alpha_png_compress) != Z_OK)
{
Report (object_reg, CS_REPORTER_SEVERITY_WARNING,
"deflateInit() failed");
mng_cleanup (&handle);
delete outfile;
delete[] chunkdata;
delete[] alpha;
imgRGBA = 0;
return 0;
}
char buff[0x8000];
while (1)
{
zs.next_out = (Byte *)buff;
zs.avail_out = sizeof (buff);
int rc = deflate (&zs, Z_FINISH); /* Do actual compression */
size_t size = sizeof (buff) - zs.avail_out;
// create a chuk w/compressed data.
if (mng_putchunk_idat (handle, (mng_uint32)size, &buff) != MNG_NOERROR)
{
ReportLibmngError (object_reg, handle, "failed to put IDAT chunk");
deflateEnd (&zs);
mng_cleanup (&handle);
delete outfile;
delete[] chunkdata;
delete[] alpha;
imgRGBA = 0;
return 0;
}
if (rc == Z_STREAM_END)
break; /* finished */
}
deflateEnd (&zs);
delete[] chunkdata;
}
delete[] alpha;
}
// compress the color data as JPEG and write it out.
csRGBcolor* volatile row = 0;
struct jpg_datastore ds;
struct jpeg_compress_struct cinfo;
struct my_error_mgr jerr;
cinfo.err = jpeg_std_error (&jerr.pub);
jerr.pub.error_exit = my_error_exit;
if (setjmp (jerr.setjmp_buffer))
{
Report (object_reg, CS_REPORTER_SEVERITY_WARNING,
"failed to JPEG compress color data");
mng_cleanup (&handle);
delete outfile;
delete [] row;
jpeg_destroy_compress (&cinfo);
imgRGBA = 0;
return 0;
}
jpeg_create_compress (&cinfo);
jpeg_buffer_dest (&cinfo, &ds);
cinfo.image_width = imgRGBA->GetWidth ();
cinfo.image_height = imgRGBA->GetHeight ();
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
row = new csRGBcolor[cinfo.image_width];
jpeg_set_defaults (&cinfo);
jpeg_set_quality (&cinfo, quality, true);
if (progressive) jpeg_simple_progression (&cinfo);
jpeg_start_compress (&cinfo, true);
JSAMPROW row_pointer[1];
JSAMPLE *image = (JSAMPLE*)csPackRGB::PackRGBpixelToRGB
((csRGBpixel*)Image->GetImageData (),
Image->GetWidth () * Image->GetHeight ());
row_pointer[0] = (JSAMPLE*)&row[0];
while (cinfo.next_scanline < cinfo.image_height)
{
row_pointer[0] =
(JSAMPLE*)&image[cinfo.next_scanline * cinfo.image_width * 3];
jpeg_write_scanlines (&cinfo, row_pointer, 1);
}
jpeg_finish_compress (&cinfo);
jpeg_destroy_compress (&cinfo);
delete [] row;
if (mng_putchunk_jdat (handle, (mng_uint32)ds.len, ds.data) != MNG_NOERROR)
{
ReportLibmngError (object_reg, handle, "failed to put JDAT chunk");
mng_cleanup (&handle);
delete outfile;
imgRGBA = 0;
return 0;
}
imgRGBA = 0;
if (mng_putchunk_iend (handle) != MNG_NOERROR)
{
ReportLibmngError (object_reg, handle, "failed to put IEND chunk");
mng_cleanup (&handle);
delete outfile;
return 0;
}
if (mng_write (handle) != MNG_NOERROR)
{
ReportLibmngError (object_reg, handle, "failed to write out JNG data");
mng_cleanup (&handle);
delete outfile;
return 0;
}
mng_cleanup (&handle);
csRef<iDataBuffer> db (outfile->GetAllData ());
delete outfile;
return csPtr<iDataBuffer> (db);
}
// Internal function used to save the Jpeg.
ILboolean iSaveJpegInternal()
{
struct jpeg_compress_struct JpegInfo;
struct jpeg_error_mgr Error;
JSAMPROW row_pointer[1];
ILimage *TempImage;
ILubyte *TempData;
ILenum Type = 0;
if (iCurImage == NULL) {
ilSetError(IL_ILLEGAL_OPERATION);
return IL_FALSE;
}
/*if (iGetHint(IL_COMPRESSION_HINT) == IL_USE_COMPRESSION)
Quality = 85; // Not sure how low we should dare go...
else
Quality = 99;*/
if ((iCurImage->Format != IL_RGB && iCurImage->Format != IL_LUMINANCE) || iCurImage->Bpc != 1) {
TempImage = iConvertImage(iCurImage, IL_RGB, IL_UNSIGNED_BYTE);
if (TempImage == NULL) {
return IL_FALSE;
}
}
else {
TempImage = iCurImage;
}
if (TempImage->Origin == IL_ORIGIN_LOWER_LEFT) {
TempData = iGetFlipped(TempImage);
if (TempData == NULL) {
if (TempImage != iCurImage)
ilCloseImage(TempImage);
return IL_FALSE;
}
}
else {
TempData = TempImage->Data;
}
JpegInfo.err = jpeg_std_error(&Error);
// Now we can initialize the JPEG compression object.
jpeg_create_compress(&JpegInfo);
//jpeg_stdio_dest(&JpegInfo, JpegFile);
devil_jpeg_write_init(&JpegInfo);
JpegInfo.image_width = TempImage->Width; // image width and height, in pixels
JpegInfo.image_height = TempImage->Height;
JpegInfo.input_components = TempImage->Bpp; // # of color components per pixel
// John Villar's addition
if (TempImage->Bpp == 1)
JpegInfo.in_color_space = JCS_GRAYSCALE;
else
JpegInfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&JpegInfo);
/*#ifndef IL_USE_JPEGLIB_UNMODIFIED
Type = iGetInt(IL_JPG_SAVE_FORMAT);
if (Type == IL_EXIF) {
JpegInfo.write_JFIF_header = FALSE;
JpegInfo.write_EXIF_header = TRUE;
}
else if (Type == IL_JFIF) {
JpegInfo.write_JFIF_header = TRUE;
JpegInfo.write_EXIF_header = FALSE;
} //EXIF not present in libjpeg...
#else*/
Type = Type;
JpegInfo.write_JFIF_header = TRUE;
//#endif//IL_USE_JPEGLIB_UNMODIFIED
// Set the quality output
jpeg_set_quality(&JpegInfo, iGetInt(IL_JPG_QUALITY), IL_TRUE);
// Sets progressive saving here
if (ilGetBoolean(IL_JPG_PROGRESSIVE))
jpeg_simple_progression(&JpegInfo);
jpeg_start_compress(&JpegInfo, IL_TRUE);
//row_stride = image_width * 3; // JSAMPLEs per row in image_buffer
while (JpegInfo.next_scanline < JpegInfo.image_height) {
// jpeg_write_scanlines expects an array of pointers to scanlines.
// Here the array is only one element long, but you could pass
// more than one scanline at a time if that's more convenient.
row_pointer[0] = &TempData[JpegInfo.next_scanline * TempImage->Bps];
(void) jpeg_write_scanlines(&JpegInfo, row_pointer, 1);
}
// Step 6: Finish compression
jpeg_finish_compress(&JpegInfo);
// Step 7: release JPEG compression object
// This is an important step since it will release a good deal of memory.
jpeg_destroy_compress(&JpegInfo);
if (TempImage->Origin == IL_ORIGIN_LOWER_LEFT)
ifree(TempData);
if (TempImage != iCurImage)
ilCloseImage(TempImage);
return IL_TRUE;
}
int imFileFormatJPEG::WriteImageInfo()
{
this->file_color_mode = imColorModeSpace(this->user_color_mode);
this->file_color_mode |= IM_TOPDOWN;
if (imColorModeDepth(this->file_color_mode) > 1)
this->file_color_mode |= IM_PACKED;
this->file_data_type = IM_BYTE;
/* Step 3: set parameters for compression */
this->cinfo.image_width = this->width; /* image width and height, in pixels */
this->cinfo.image_height = this->height;
this->cinfo.input_components = imColorModeDepth(this->file_color_mode);
switch (imColorModeSpace(this->user_color_mode))
{
case IM_BINARY:
this->convert_bpp = -1; // expand 1 to 255
case IM_GRAY:
this->cinfo.in_color_space = JCS_GRAYSCALE;
break;
case IM_RGB:
this->cinfo.in_color_space = JCS_RGB;
break;
case IM_CMYK:
this->cinfo.in_color_space = JCS_CMYK;
break;
case IM_YCBCR:
this->cinfo.in_color_space = JCS_YCbCr;
break;
default:
this->cinfo.in_color_space = JCS_UNKNOWN;
break;
}
if (setjmp(this->jerr.setjmp_buffer))
return IM_ERR_ACCESS;
jpeg_set_defaults(&this->cinfo);
imAttribTable* attrib_table = AttribTable();
int* auto_ycbcr = (int*)attrib_table->Get("AutoYCbCr");
if (auto_ycbcr && *auto_ycbcr == 0 &&
this->cinfo.in_color_space == JCS_RGB)
{
jpeg_set_colorspace(&this->cinfo, JCS_RGB);
}
int* interlaced = (int*)attrib_table->Get("Interlaced");
if (interlaced && *interlaced)
jpeg_simple_progression(&this->cinfo);
int* quality = (int*)attrib_table->Get("JPEGQuality");
if (quality)
jpeg_set_quality(&this->cinfo, *quality, TRUE);
char* res_unit = (char*)attrib_table->Get("ResolutionUnit");
if (res_unit)
{
float* xres = (float*)attrib_table->Get("XResolution");
float* yres = (float*)attrib_table->Get("YResolution");
if (xres && yres)
{
if (imStrEqual(res_unit, "DPI"))
this->cinfo.density_unit = 1;
else
this->cinfo.density_unit = 2;
this->cinfo.X_density = (UINT16)*xres;
this->cinfo.Y_density = (UINT16)*yres;
}
}
/* Step 4: Start compressor */
jpeg_start_compress(&this->cinfo, TRUE);
int desc_size;
char* desc = (char*)attrib_table->Get("Description", NULL, &desc_size);
if (desc)
jpeg_write_marker(&this->cinfo, JPEG_COM, (JOCTET*)desc, desc_size-1);
#ifdef USE_EXIF
iWriteExifAttrib(attrib_table);
#endif
return IM_ERR_NONE;
}
int
NITFWriteJPEGBlock( GDALDataset *poSrcDS, VSILFILE *fp,
int nBlockXOff, int nBlockYOff,
int nBlockXSize, int nBlockYSize,
int bProgressive, int nQuality,
const GByte* pabyAPP6, int nRestartInterval,
GDALProgressFunc pfnProgress, void * pProgressData )
{
GDALDataType eDT = poSrcDS->GetRasterBand(1)->GetRasterDataType();
#if defined(JPEG_DUAL_MODE_8_12) && !defined(NITFWriteJPEGBlock)
if( eDT == GDT_UInt16 )
{
return NITFWriteJPEGBlock_12(poSrcDS, fp,
nBlockXOff, nBlockYOff,
nBlockXSize, nBlockYSize,
bProgressive, nQuality,
pabyAPP6, nRestartInterval,
pfnProgress, pProgressData );
}
#endif
int nBands = poSrcDS->GetRasterCount();
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
int anBandList[3] = {1,2,3};
/* -------------------------------------------------------------------- */
/* Initialize JPG access to the file. */
/* -------------------------------------------------------------------- */
struct jpeg_compress_struct sCInfo;
struct jpeg_error_mgr sJErr;
sCInfo.err = jpeg_std_error( &sJErr );
jpeg_create_compress( &sCInfo );
jpeg_vsiio_dest( &sCInfo, fp );
sCInfo.image_width = nBlockXSize;
sCInfo.image_height = nBlockYSize;
sCInfo.input_components = nBands;
if( nBands == 1 )
{
sCInfo.in_color_space = JCS_GRAYSCALE;
}
else
{
sCInfo.in_color_space = JCS_RGB;
}
jpeg_set_defaults( &sCInfo );
#if defined(JPEG_LIB_MK1_OR_12BIT)
if( eDT == GDT_UInt16 )
{
sCInfo.data_precision = 12;
}
else
{
sCInfo.data_precision = 8;
}
#endif
GDALDataType eWorkDT;
#ifdef JPEG_LIB_MK1
sCInfo.bits_in_jsample = sCInfo.data_precision;
eWorkDT = GDT_UInt16; /* Always force to 16 bit for JPEG_LIB_MK1 */
#else
eWorkDT = eDT;
#endif
sCInfo.write_JFIF_header = FALSE;
/* Set the restart interval */
if (nRestartInterval < 0)
{
/* nRestartInterval < 0 means that we will guess the value */
/* so we set it at the maximum allowed by MIL-STD-188-198 */
/* that is to say the number of MCU per row-block */
nRestartInterval = nBlockXSize / 8;
}
if (nRestartInterval > 0)
sCInfo.restart_interval = nRestartInterval;
jpeg_set_quality( &sCInfo, nQuality, TRUE );
if( bProgressive )
jpeg_simple_progression( &sCInfo );
jpeg_start_compress( &sCInfo, TRUE );
/* -------------------------------------------------------------------- */
/* Emits APP6 NITF application segment (required by MIL-STD-188-198) */
/* -------------------------------------------------------------------- */
if (pabyAPP6)
{
/* 0xe6 = APP6 marker */
jpeg_write_marker( &sCInfo, 0xe6, (const JOCTET*) pabyAPP6, 23);
}
/* -------------------------------------------------------------------- */
/* Loop over image, copying image data. */
/* -------------------------------------------------------------------- */
GByte *pabyScanline;
CPLErr eErr = CE_None;
int nWorkDTSize = GDALGetDataTypeSize(eWorkDT) / 8;
pabyScanline = (GByte *) CPLMalloc( nBands * nBlockXSize * nWorkDTSize );
double nTotalPixels = (double)nXSize * nYSize;
int nBlockXSizeToRead = nBlockXSize;
if (nBlockXSize * nBlockXOff + nBlockXSize > nXSize)
{
nBlockXSizeToRead = nXSize - nBlockXSize * nBlockXOff;
}
int nBlockYSizeToRead = nBlockYSize;
if (nBlockYSize * nBlockYOff + nBlockYSize > nYSize)
{
nBlockYSizeToRead = nYSize - nBlockYSize * nBlockYOff;
}
bool bClipWarn = false;
for( int iLine = 0; iLine < nBlockYSize && eErr == CE_None; iLine++ )
{
JSAMPLE *ppSamples;
if (iLine < nBlockYSizeToRead)
{
eErr = poSrcDS->RasterIO( GF_Read, nBlockXSize * nBlockXOff, iLine + nBlockYSize * nBlockYOff, nBlockXSizeToRead, 1,
pabyScanline, nBlockXSizeToRead, 1, eWorkDT,
nBands, anBandList,
nBands*nWorkDTSize, nBands * nBlockXSize * nWorkDTSize, nWorkDTSize, NULL );
#if !defined(JPEG_LIB_MK1_OR_12BIT)
/* Repeat the last pixel till the end of the line */
/* to minimize discontinuity */
if (nBlockXSizeToRead < nBlockXSize)
{
for (int iBand = 0; iBand < nBands; iBand++)
{
GByte bVal = pabyScanline[nBands * (nBlockXSizeToRead - 1) + iBand];
for(int iX = nBlockXSizeToRead; iX < nBlockXSize; iX ++)
{
pabyScanline[nBands * iX + iBand ] = bVal;
}
}
}
#endif
}
// clamp 16bit values to 12bit.
if( eDT == GDT_UInt16 )
{
GUInt16 *panScanline = (GUInt16 *) pabyScanline;
int iPixel;
for( iPixel = 0; iPixel < nXSize*nBands; iPixel++ )
{
if( panScanline[iPixel] > 4095 )
{
panScanline[iPixel] = 4095;
if( !bClipWarn )
{
bClipWarn = true;
CPLError( CE_Warning, CPLE_AppDefined,
"One or more pixels clipped to fit 12bit domain for jpeg output." );
}
}
}
}
ppSamples = (JSAMPLE *) pabyScanline;
if( eErr == CE_None )
jpeg_write_scanlines( &sCInfo, &ppSamples, 1 );
double nCurPixels = (double)nBlockYOff * nBlockYSize * nXSize +
(double)nBlockXOff * nBlockYSize * nBlockXSize + (iLine + 1) * nBlockXSizeToRead;
if( eErr == CE_None
&& !pfnProgress( nCurPixels / nTotalPixels, NULL, pProgressData ) )
{
eErr = CE_Failure;
CPLError( CE_Failure, CPLE_UserInterrupt,
"User terminated CreateCopy()" );
}
}
/* -------------------------------------------------------------------- */
/* Cleanup and close. */
/* -------------------------------------------------------------------- */
CPLFree( pabyScanline );
if( eErr == CE_None )
jpeg_finish_compress( &sCInfo );
jpeg_destroy_compress( &sCInfo );
return eErr == CE_None;
}
int
ImagingJpegEncode(Imaging im, ImagingCodecState state, UINT8* buf, int bytes)
{
JPEGENCODERSTATE* context = (JPEGENCODERSTATE*) state->context;
int ok;
if (setjmp(context->error.setjmp_buffer)) {
/* JPEG error handler */
jpeg_destroy_compress(&context->cinfo);
state->errcode = IMAGING_CODEC_BROKEN;
return -1;
}
if (!state->state) {
/* Setup compression context (very similar to the decoder) */
context->cinfo.err = jpeg_std_error(&context->error.pub);
context->error.pub.error_exit = error;
jpeg_create_compress(&context->cinfo);
jpeg_buffer_dest(&context->cinfo, &context->destination);
context->extra_offset = 0;
/* Ready to encode */
state->state = 1;
}
/* Load the destination buffer */
context->destination.pub.next_output_byte = buf;
context->destination.pub.free_in_buffer = bytes;
switch (state->state) {
case 1:
context->cinfo.image_width = state->xsize;
context->cinfo.image_height = state->ysize;
switch (state->bits) {
case 8:
context->cinfo.input_components = 1;
context->cinfo.in_color_space = JCS_GRAYSCALE;
break;
case 24:
context->cinfo.input_components = 3;
if (strcmp(im->mode, "YCbCr") == 0)
context->cinfo.in_color_space = JCS_YCbCr;
else
context->cinfo.in_color_space = JCS_RGB;
break;
case 32:
context->cinfo.input_components = 4;
context->cinfo.in_color_space = JCS_CMYK;
break;
default:
state->errcode = IMAGING_CODEC_CONFIG;
return -1;
}
/* Compressor configuration */
jpeg_set_defaults(&context->cinfo);
/* Use custom quantization tables */
if (context->qtables) {
int i;
int quality = 100;
if (context->quality > 0) {
quality = context->quality;
}
for (i = 0; i < sizeof(context->qtables)/sizeof(unsigned int); i++) {
// TODO: Should add support for none baseline
jpeg_add_quant_table(&context->cinfo, i, context->qtables[i],
quality, TRUE);
}
} else if (context->quality > 0) {
jpeg_set_quality(&context->cinfo, context->quality, 1);
}
/* Set subsampling options */
switch (context->subsampling)
{
case 0: /* 1x1 1x1 1x1 (4:4:4) : None */
{
context->cinfo.comp_info[0].h_samp_factor = 1;
context->cinfo.comp_info[0].v_samp_factor = 1;
context->cinfo.comp_info[1].h_samp_factor = 1;
context->cinfo.comp_info[1].v_samp_factor = 1;
context->cinfo.comp_info[2].h_samp_factor = 1;
context->cinfo.comp_info[2].v_samp_factor = 1;
break;
}
case 1: /* 2x1, 1x1, 1x1 (4:2:2) : Medium */
{
context->cinfo.comp_info[0].h_samp_factor = 2;
context->cinfo.comp_info[0].v_samp_factor = 1;
context->cinfo.comp_info[1].h_samp_factor = 1;
context->cinfo.comp_info[1].v_samp_factor = 1;
context->cinfo.comp_info[2].h_samp_factor = 1;
context->cinfo.comp_info[2].v_samp_factor = 1;
break;
}
case 2: /* 2x2, 1x1, 1x1 (4:1:1) : High */
{
context->cinfo.comp_info[0].h_samp_factor = 2;
context->cinfo.comp_info[0].v_samp_factor = 2;
context->cinfo.comp_info[1].h_samp_factor = 1;
context->cinfo.comp_info[1].v_samp_factor = 1;
context->cinfo.comp_info[2].h_samp_factor = 1;
context->cinfo.comp_info[2].v_samp_factor = 1;
break;
}
default:
{
/* Use the lib's default */
break;
}
}
if (context->progressive)
jpeg_simple_progression(&context->cinfo);
context->cinfo.smoothing_factor = context->smooth;
context->cinfo.optimize_coding = (boolean) context->optimize;
if (context->xdpi > 0 && context->ydpi > 0) {
context->cinfo.density_unit = 1; /* dots per inch */
context->cinfo.X_density = context->xdpi;
context->cinfo.Y_density = context->ydpi;
}
switch (context->streamtype) {
case 1:
/* tables only -- not yet implemented */
state->errcode = IMAGING_CODEC_CONFIG;
return -1;
case 2:
/* image only */
jpeg_suppress_tables(&context->cinfo, TRUE);
jpeg_start_compress(&context->cinfo, FALSE);
/* suppress extra section */
context->extra_offset = context->extra_size;
//add exif header
if (context->rawExifLen > 0)
jpeg_write_marker(&context->cinfo, JPEG_APP0+1, (unsigned char*)context->rawExif, context->rawExifLen);
break;
default:
/* interchange stream */
jpeg_start_compress(&context->cinfo, TRUE);
//add exif header
if (context->rawExifLen > 0)
jpeg_write_marker(&context->cinfo, JPEG_APP0+1, (unsigned char*)context->rawExif, context->rawExifLen);
break;
}
state->state++;
/* fall through */
case 2:
if (context->extra) {
/* copy extra buffer to output buffer */
unsigned int n = context->extra_size - context->extra_offset;
if (n > context->destination.pub.free_in_buffer)
n = context->destination.pub.free_in_buffer;
memcpy(context->destination.pub.next_output_byte,
context->extra + context->extra_offset, n);
context->destination.pub.next_output_byte += n;
context->destination.pub.free_in_buffer -= n;
context->extra_offset += n;
if (context->extra_offset >= context->extra_size)
state->state++;
else
break;
} else
state->state++;
case 3:
ok = 1;
while (state->y < state->ysize) {
state->shuffle(state->buffer,
(UINT8*) im->image[state->y + state->yoff] +
state->xoff * im->pixelsize, state->xsize);
ok = jpeg_write_scanlines(&context->cinfo, &state->buffer, 1);
if (ok != 1)
break;
state->y++;
}
if (ok != 1)
break;
state->state++;
/* fall through */
case 4:
/* Finish compression */
if (context->destination.pub.free_in_buffer < 100)
break;
jpeg_finish_compress(&context->cinfo);
/* Clean up */
if (context->extra)
free(context->extra);
jpeg_destroy_compress(&context->cinfo);
/* if (jerr.pub.num_warnings) return BROKEN; */
state->errcode = IMAGING_CODEC_END;
break;
}
/* Return number of bytes in output buffer */
return context->destination.pub.next_output_byte - buf;
}
static gint
gegl_buffer_export_jpg (GeglBuffer *gegl_buffer,
const gchar *path,
gint quality,
gint smoothing,
gboolean optimize,
gboolean progressive,
gboolean grayscale,
gint src_x,
gint src_y,
gint width,
gint height)
{
FILE *fp;
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
JSAMPROW row_pointer[1];
const Babl *format;
if (!strcmp (path, "-"))
{
fp = stdout;
}
else
{
fp = fopen (path, "wb");
}
if (!fp)
{
return -1;
}
cinfo.err = jpeg_std_error (&jerr);
jpeg_create_compress (&cinfo);
jpeg_stdio_dest (&cinfo, fp);
cinfo.image_width = width;
cinfo.image_height = height;
if (!grayscale)
{
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
}
else
{
cinfo.input_components = 1;
cinfo.in_color_space = JCS_GRAYSCALE;
}
jpeg_set_defaults (&cinfo);
jpeg_set_quality (&cinfo, quality, TRUE);
cinfo.smoothing_factor = smoothing;
cinfo.optimize_coding = optimize;
if (progressive)
jpeg_simple_progression (&cinfo);
/* Use 1x1,1x1,1x1 MCUs and no subsampling */
cinfo.comp_info[0].h_samp_factor = 1;
cinfo.comp_info[0].v_samp_factor = 1;
if (!grayscale)
{
cinfo.comp_info[1].h_samp_factor = 1;
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1;
cinfo.comp_info[2].v_samp_factor = 1;
}
/* No restart markers */
cinfo.restart_interval = 0;
cinfo.restart_in_rows = 0;
jpeg_start_compress (&cinfo, TRUE);
if (!grayscale)
{
format = babl_format ("R'G'B' u8");
row_pointer[0] = g_malloc (width * 3);
}
else
{
format = babl_format ("Y' u8");
row_pointer[0] = g_malloc (width);
}
while (cinfo.next_scanline < cinfo.image_height) {
GeglRectangle rect;
rect.x = src_x;
rect.y = src_y + cinfo.next_scanline;
rect.width = width;
rect.height = 1;
gegl_buffer_get (gegl_buffer, &rect, 1.0, format,
row_pointer[0], GEGL_AUTO_ROWSTRIDE,
GEGL_ABYSS_NONE);
jpeg_write_scanlines (&cinfo, row_pointer, 1);
}
jpeg_finish_compress (&cinfo);
jpeg_destroy_compress (&cinfo);
g_free (row_pointer[0]);
if (stdout != fp)
fclose (fp);
return 0;
}
bool JpegEncoder::write( const Mat& img, const std::vector<int>& params )
{
m_last_error.clear();
struct fileWrapper
{
FILE* f;
fileWrapper() : f(0) {}
~fileWrapper() { if(f) fclose(f); }
};
volatile bool result = false;
fileWrapper fw;
int width = img.cols, height = img.rows;
std::vector<uchar> out_buf(1 << 12);
AutoBuffer<uchar> _buffer;
uchar* buffer;
struct jpeg_compress_struct cinfo;
JpegErrorMgr jerr;
JpegDestination dest;
jpeg_create_compress(&cinfo);
cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = error_exit;
if( !m_buf )
{
fw.f = fopen( m_filename.c_str(), "wb" );
if( !fw.f )
goto _exit_;
jpeg_stdio_dest( &cinfo, fw.f );
}
else
{
dest.dst = m_buf;
dest.buf = &out_buf;
jpeg_buffer_dest( &cinfo, &dest );
dest.pub.next_output_byte = &out_buf[0];
dest.pub.free_in_buffer = out_buf.size();
}
if( setjmp( jerr.setjmp_buffer ) == 0 )
{
cinfo.image_width = width;
cinfo.image_height = height;
int _channels = img.channels();
int channels = _channels > 1 ? 3 : 1;
cinfo.input_components = channels;
cinfo.in_color_space = channels > 1 ? JCS_RGB : JCS_GRAYSCALE;
int quality = 95;
int progressive = 0;
int optimize = 0;
int rst_interval = 0;
int luma_quality = -1;
int chroma_quality = -1;
for( size_t i = 0; i < params.size(); i += 2 )
{
if( params[i] == CV_IMWRITE_JPEG_QUALITY )
{
quality = params[i+1];
quality = MIN(MAX(quality, 0), 100);
}
if( params[i] == CV_IMWRITE_JPEG_PROGRESSIVE )
{
progressive = params[i+1];
}
if( params[i] == CV_IMWRITE_JPEG_OPTIMIZE )
{
optimize = params[i+1];
}
if( params[i] == CV_IMWRITE_JPEG_LUMA_QUALITY )
{
if (params[i+1] >= 0)
{
luma_quality = MIN(MAX(params[i+1], 0), 100);
quality = luma_quality;
if (chroma_quality < 0)
{
chroma_quality = luma_quality;
}
}
}
if( params[i] == CV_IMWRITE_JPEG_CHROMA_QUALITY )
{
if (params[i+1] >= 0)
{
chroma_quality = MIN(MAX(params[i+1], 0), 100);
}
}
if( params[i] == CV_IMWRITE_JPEG_RST_INTERVAL )
{
rst_interval = params[i+1];
rst_interval = MIN(MAX(rst_interval, 0), 65535L);
}
}
jpeg_set_defaults( &cinfo );
cinfo.restart_interval = rst_interval;
jpeg_set_quality( &cinfo, quality,
TRUE /* limit to baseline-JPEG values */ );
if( progressive )
jpeg_simple_progression( &cinfo );
if( optimize )
cinfo.optimize_coding = TRUE;
#if JPEG_LIB_VERSION >= 70
if (luma_quality >= 0 && chroma_quality >= 0)
{
cinfo.q_scale_factor[0] = jpeg_quality_scaling(luma_quality);
cinfo.q_scale_factor[1] = jpeg_quality_scaling(chroma_quality);
if ( luma_quality != chroma_quality )
{
/* disable subsampling - ref. Libjpeg.txt */
cinfo.comp_info[0].v_samp_factor = 1;
cinfo.comp_info[0].h_samp_factor = 1;
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[1].h_samp_factor = 1;
}
jpeg_default_qtables( &cinfo, TRUE );
}
#endif // #if JPEG_LIB_VERSION >= 70
jpeg_start_compress( &cinfo, TRUE );
if( channels > 1 )
_buffer.allocate(width*channels);
buffer = _buffer;
for( int y = 0; y < height; y++ )
{
uchar *data = img.data + img.step*y, *ptr = data;
if( _channels == 3 )
{
icvCvt_BGR2RGB_8u_C3R( data, 0, buffer, 0, cvSize(width,1) );
ptr = buffer;
}
else if( _channels == 4 )
{
icvCvt_BGRA2BGR_8u_C4C3R( data, 0, buffer, 0, cvSize(width,1), 2 );
ptr = buffer;
}
jpeg_write_scanlines( &cinfo, &ptr, 1 );
}
jpeg_finish_compress( &cinfo );
result = true;
}
_exit_:
if(!result)
{
char jmsg_buf[JMSG_LENGTH_MAX];
jerr.pub.format_message((j_common_ptr)&cinfo, jmsg_buf);
m_last_error = jmsg_buf;
}
jpeg_destroy_compress( &cinfo );
return result;
}
/*!
* pixWriteStreamJpeg()
*
* Input: stream
* pix (8 or 32 bpp)
* quality (1 - 100; 75 is default value; 0 is also default)
* progressive (0 for baseline sequential; 1 for progressive)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) Under the covers, the library transforms rgb to a
* luminence-chromaticity triple, each component of which is
* also 8 bits, and compresses that. It uses 2 Huffman tables,
* a higher resolution one (with more quantization levels)
* for luminosity and a lower resolution one for the chromas.
* (2) Progressive encoding gives better compression, at the
* expense of slower encoding and decoding.
* (3) Standard chroma subsampling is 2x2 on both the U and V
* channels. For highest quality, use no subsampling. This
* option is set by l_jpegSetNoChromaSampling(1).
* (4) There are three possibilities:
* * Grayscale image, no colormap: compress as 8 bpp image.
* * rgb full color image: copy each line into the color
* line buffer, and compress as three 8 bpp images.
* * 8 bpp colormapped image: convert each line to three
* 8 bpp line images in the color line buffer, and
* compress as three 8 bpp images.
* (5) The only valid pixel depths in leptonica are 1, 2, 4, 8, 16
* and 32 bpp. However, it is possible, and in some cases desirable,
* to write out a jpeg file using an rgb pix that has 24 bpp.
* This can be created by appending the raster data for a 24 bpp
* image (with proper scanline padding) directly to a 24 bpp
* pix that was created without a data array. See note in
* pixWriteStreamPng() for an example.
*/
l_int32
pixWriteStreamJpeg(FILE *fp,
PIX *pix,
l_int32 quality,
l_int32 progressive)
{
l_uint8 byteval;
l_int32 xres, yres;
l_int32 i, j, k;
l_int32 w, h, d, wpl, spp, colorflg, rowsamples;
l_int32 *rmap, *gmap, *bmap;
l_uint32 *ppixel, *line, *data;
JSAMPROW rowbuffer;
PIXCMAP *cmap;
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
const char *text;
PROCNAME("pixWriteStreamJpeg");
if (!fp)
return ERROR_INT("stream not open", procName, 1);
if (!pix)
return ERROR_INT("pix not defined", procName, 1);
rewind(fp);
if (setjmp(jpeg_jmpbuf)) {
FREE(rowbuffer);
if (colorflg == 1) {
FREE(rmap);
FREE(gmap);
FREE(bmap);
}
return ERROR_INT("internal jpeg error", procName, 1);
}
rowbuffer = NULL;
rmap = NULL;
gmap = NULL;
bmap = NULL;
pixGetDimensions(pix, &w, &h, &d);
if (d != 8 && d != 24 && d != 32)
return ERROR_INT("bpp must be 8, 24 or 32", procName, 1);
if (quality <= 0)
quality = 75; /* default */
if (d == 32 || d == 24)
colorflg = 2; /* rgb; no colormap */
else if ((cmap = pixGetColormap(pix)) == NULL)
colorflg = 0; /* 8 bpp grayscale; no colormap */
else {
colorflg = 1; /* 8 bpp; colormap */
pixcmapToArrays(cmap, &rmap, &gmap, &bmap);
}
cinfo.err = jpeg_std_error(&jerr);
jerr.error_exit = jpeg_error_do_not_exit; /* catch error; do not exit! */
jpeg_create_compress(&cinfo);
jpeg_stdio_dest(&cinfo, fp);
cinfo.image_width = w;
cinfo.image_height = h;
if (colorflg == 0) {
cinfo.input_components = 1;
cinfo.in_color_space = JCS_GRAYSCALE;
}
else { /* colorflg == 1 or 2 */
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
}
jpeg_set_defaults(&cinfo);
/* Setting optimize_coding to TRUE seems to improve compression
* by approx 2-4 percent, and increases comp time by approx 20%. */
cinfo.optimize_coding = FALSE;
xres = pixGetXRes(pix);
yres = pixGetYRes(pix);
if ((xres != 0) && (yres != 0)) {
cinfo.density_unit = 1; /* designates pixels per inch */
cinfo.X_density = xres;
cinfo.Y_density = yres;
}
/* Set the quality and progressive parameters */
jpeg_set_quality(&cinfo, quality, TRUE);
if (progressive) {
jpeg_simple_progression(&cinfo);
}
/* Set the chroma subsampling parameters. This is done in
* YUV color space. The Y (intensity) channel is never subsampled.
* The standard subsampling is 2x2 on both the U and V channels.
* Notation on this is confusing. For a nice illustrations, see
* http://en.wikipedia.org/wiki/Chroma_subsampling
* The standard subsampling is written as 4:2:0.
* We allow high quality where there is no subsampling on the
* chroma channels: denoted as 4:4:4. */
if (var_JPEG_NO_CHROMA_SAMPLING == 1) {
cinfo.comp_info[0].h_samp_factor = 1;
cinfo.comp_info[0].v_samp_factor = 1;
cinfo.comp_info[1].h_samp_factor = 1;
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1;
cinfo.comp_info[2].v_samp_factor = 1;
}
jpeg_start_compress(&cinfo, TRUE);
if ((text = pixGetText(pix))) {
jpeg_write_marker(&cinfo, JPEG_COM, (const JOCTET *)text, strlen(text));
}
/* Allocate row buffer */
spp = cinfo.input_components;
rowsamples = spp * w;
if ((rowbuffer = (JSAMPROW)CALLOC(sizeof(JSAMPLE), rowsamples)) == NULL)
return ERROR_INT("calloc fail for rowbuffer", procName, 1);
data = pixGetData(pix);
wpl = pixGetWpl(pix);
for (i = 0; i < h; i++) {
line = data + i * wpl;
if (colorflg == 0) { /* 8 bpp gray */
for (j = 0; j < w; j++)
rowbuffer[j] = GET_DATA_BYTE(line, j);
}
else if (colorflg == 1) { /* 8 bpp colormapped */
for (j = 0; j < w; j++) {
byteval = GET_DATA_BYTE(line, j);
rowbuffer[3 * j + COLOR_RED] = rmap[byteval];
rowbuffer[3 * j + COLOR_GREEN] = gmap[byteval];
rowbuffer[3 * j + COLOR_BLUE] = bmap[byteval];
}
}
else { /* colorflg == 2 */
if (d == 24) { /* See note 4 above; special case of 24 bpp rgb */
jpeg_write_scanlines(&cinfo, (JSAMPROW *)&line, 1);
}
else { /* standard 32 bpp rgb */
ppixel = line;
for (j = k = 0; j < w; j++) {
rowbuffer[k++] = GET_DATA_BYTE(ppixel, COLOR_RED);
rowbuffer[k++] = GET_DATA_BYTE(ppixel, COLOR_GREEN);
rowbuffer[k++] = GET_DATA_BYTE(ppixel, COLOR_BLUE);
ppixel++;
}
}
}
if (d != 24)
jpeg_write_scanlines(&cinfo, &rowbuffer, 1);
}
jpeg_finish_compress(&cinfo);
FREE(rowbuffer);
if (colorflg == 1) {
FREE(rmap);
FREE(gmap);
FREE(bmap);
}
jpeg_destroy_compress(&cinfo);
return 0;
}
int main(int argc, char **argv)
{
struct jpeg_decompress_struct dinfo;
struct jpeg_compress_struct cinfo;
struct my_error_mgr jcerr,jderr;
JSAMPARRAY buf = NULL;
jvirt_barray_ptr *coef_arrays = NULL;
char marker_str[256];
char tmpfilename[MAXPATHLEN],tmpdir[MAXPATHLEN];
char newname[MAXPATHLEN], dest_path[MAXPATHLEN];
volatile int i;
int c,j, tmpfd, searchcount, searchdone;
int opt_index = 0;
long insize = 0, outsize = 0, lastsize = 0;
int oldquality;
double ratio;
struct stat file_stat;
jpeg_saved_marker_ptr cmarker;
unsigned char *outbuffer = NULL;
size_t outbuffersize;
char *outfname = NULL;
FILE *infile = NULL, *outfile = NULL;
int marker_in_count, marker_in_size;
int compress_err_count = 0;
int decompress_err_count = 0;
long average_count = 0;
double average_rate = 0.0, total_save = 0.0;
if (rcsid)
; /* so compiler won't complain about "unused" rcsid string */
umask(077);
signal(SIGINT,own_signal_handler);
signal(SIGTERM,own_signal_handler);
/* initialize decompression object */
dinfo.err = jpeg_std_error(&jderr.pub);
jpeg_create_decompress(&dinfo);
jderr.pub.error_exit=my_error_exit;
jderr.pub.output_message=my_output_message;
jderr.jump_set = 0;
/* initialize compression object */
cinfo.err = jpeg_std_error(&jcerr.pub);
jpeg_create_compress(&cinfo);
jcerr.pub.error_exit=my_error_exit;
jcerr.pub.output_message=my_output_message;
jcerr.jump_set = 0;
if (argc<2) {
if (!quiet_mode) fprintf(stderr,PROGRAMNAME ": file arguments missing\n"
"Try '" PROGRAMNAME " --help' for more information.\n");
exit(1);
}
/* parse command line parameters */
while(1) {
opt_index=0;
if ((c=getopt_long(argc,argv,"d:hm:nstqvfVpPoT:S:b",long_options,&opt_index))
== -1)
break;
switch (c) {
case 'm':
{
int tmpvar;
if (sscanf(optarg,"%d",&tmpvar) == 1) {
quality=tmpvar;
if (quality < 0) quality=0;
if (quality > 100) quality=100;
}
else
fatal("invalid argument for -m, --max");
}
break;
case 'd':
if (realpath(optarg,dest_path)==NULL || !is_directory(dest_path)) {
fatal("invalid argument for option -d, --dest");
}
strncat(dest_path,DIR_SEPARATOR_S,sizeof(dest_path)-strlen(dest_path)-1);
if (verbose_mode)
fprintf(stderr,"Destination directory: %s\n",dest_path);
dest=1;
break;
case 'v':
verbose_mode++;
break;
case 'h':
print_usage();
exit(0);
break;
case 'q':
quiet_mode=1;
break;
case 't':
totals_mode=1;
break;
case 'n':
noaction=1;
break;
case 'f':
force=1;
break;
case 'b':
csv=1;
quiet_mode=1;
break;
case '?':
break;
case 'V':
print_version();
exit(0);
break;
case 'o':
overwrite_mode=1;
break;
case 'p':
preserve_mode=1;
break;
case 'P':
preserve_perms=1;
break;
case 's':
save_exif=0;
save_iptc=0;
save_com=0;
save_icc=0;
save_xmp=0;
break;
case 'T':
{
int tmpvar;
if (sscanf(optarg,"%d",&tmpvar) == 1) {
threshold=tmpvar;
if (threshold < 0) threshold=0;
if (threshold > 100) threshold=100;
}
else fatal("invalid argument for -T, --threshold");
}
break;
case 'S':
{
unsigned int tmpvar;
if (sscanf(optarg,"%u",&tmpvar) == 1) {
if (tmpvar > 0 && tmpvar < 100 && optarg[strlen(optarg)-1] == '%' ) {
target_size=-tmpvar;
} else {
target_size=tmpvar;
}
quality=100;
}
else fatal("invalid argument for -S, --size");
}
break;
}
}
/* check for '-' option indicating input is from stdin... */
i=1;
while (argv[i]) {
if (argv[i][0]=='-' && argv[i][1]==0) stdin_mode=1;
i++;
}
if (stdin_mode) { stdout_mode=1; force=1; }
if (stdout_mode) { logs_to_stdout=0; }
if (all_normal && all_progressive)
fatal("cannot specify both --all-normal and --all-progressive");
if (verbose_mode) {
if (quality>=0 && target_size==0)
fprintf(stderr,"Image quality limit set to: %d\n",quality);
if (threshold>=0)
fprintf(stderr,"Compression threshold (%%) set to: %d\n",threshold);
if (all_normal)
fprintf(stderr,"All output files will be non-progressive\n");
if (all_progressive)
fprintf(stderr,"All output files will be progressive\n");
if (target_size > 0)
fprintf(stderr,"Target size for output files set to: %u Kbytes.\n",
target_size);
if (target_size < 0)
fprintf(stderr,"Target size for output files set to: %u%%\n",
-target_size);
}
/* loop to process the input files */
i=1;
do {
if (stdin_mode) {
infile=stdin;
set_filemode_binary(infile);
} else {
if (!argv[i][0]) continue;
if (argv[i][0]=='-') continue;
if (strlen(argv[i]) >= MAXPATHLEN) {
warn("skipping too long filename: %s",argv[i]);
continue;
}
if (!noaction) {
/* generate tmp dir & new filename */
if (dest) {
STRNCPY(tmpdir,dest_path,sizeof(tmpdir));
STRNCPY(newname,dest_path,sizeof(newname));
if (!splitname(argv[i],tmpfilename,sizeof(tmpfilename)))
fatal("splitname() failed for: %s",argv[i]);
strncat(newname,tmpfilename,sizeof(newname)-strlen(newname)-1);
} else {
if (!splitdir(argv[i],tmpdir,sizeof(tmpdir)))
fatal("splitdir() failed for: %s",argv[i]);
STRNCPY(newname,argv[i],sizeof(newname));
}
}
retry_point:
if (!is_file(argv[i],&file_stat)) {
if (is_directory(argv[i]))
warn("skipping directory: %s",argv[i]);
else
warn("skipping special file: %s",argv[i]);
continue;
}
if ((infile=fopen(argv[i],"rb"))==NULL) {
warn("cannot open file: %s", argv[i]);
continue;
}
}
if (setjmp(jderr.setjmp_buffer)) {
/* error handler for decompress */
jpeg_abort_decompress(&dinfo);
fclose(infile);
if (buf) FREE_LINE_BUF(buf,dinfo.output_height);
if (!quiet_mode || csv)
fprintf(LOG_FH,csv ? ",,,,,error\n" : " [ERROR]\n");
decompress_err_count++;
jderr.jump_set=0;
continue;
} else {
jderr.jump_set=1;
}
if (!retry && (!quiet_mode || csv)) {
fprintf(LOG_FH,csv ? "%s," : "%s ",(stdin_mode?"stdin":argv[i])); fflush(LOG_FH);
}
/* prepare to decompress */
global_error_counter=0;
jpeg_save_markers(&dinfo, JPEG_COM, 0xffff);
for (j=0;j<=15;j++)
jpeg_save_markers(&dinfo, JPEG_APP0+j, 0xffff);
jpeg_stdio_src(&dinfo, infile);
jpeg_read_header(&dinfo, TRUE);
/* check for Exif/IPTC/ICC/XMP markers */
marker_str[0]=0;
marker_in_count=0;
marker_in_size=0;
cmarker=dinfo.marker_list;
while (cmarker) {
marker_in_count++;
marker_in_size+=cmarker->data_length;
if (cmarker->marker == EXIF_JPEG_MARKER &&
!memcmp(cmarker->data,EXIF_IDENT_STRING,EXIF_IDENT_STRING_SIZE))
strncat(marker_str,"Exif ",sizeof(marker_str)-strlen(marker_str)-1);
if (cmarker->marker == IPTC_JPEG_MARKER)
strncat(marker_str,"IPTC ",sizeof(marker_str)-strlen(marker_str)-1);
if (cmarker->marker == ICC_JPEG_MARKER &&
!memcmp(cmarker->data,ICC_IDENT_STRING,ICC_IDENT_STRING_SIZE))
strncat(marker_str,"ICC ",sizeof(marker_str)-strlen(marker_str)-1);
if (cmarker->marker == XMP_JPEG_MARKER &&
!memcmp(cmarker->data,XMP_IDENT_STRING,XMP_IDENT_STRING_SIZE))
strncat(marker_str,"XMP ",sizeof(marker_str)-strlen(marker_str)-1);
cmarker=cmarker->next;
}
if (verbose_mode > 1)
fprintf(LOG_FH,"%d markers found in input file (total size %d bytes)\n",
marker_in_count,marker_in_size);
if (!retry && (!quiet_mode || csv)) {
fprintf(LOG_FH,csv ? "%dx%d,%dbit,%c," : "%dx%d %dbit %c ",(int)dinfo.image_width,
(int)dinfo.image_height,(int)dinfo.num_components*8,
(dinfo.progressive_mode?'P':'N'));
if (!csv) {
fprintf(LOG_FH,"%s",marker_str);
if (dinfo.saw_Adobe_marker) fprintf(LOG_FH,"Adobe ");
if (dinfo.saw_JFIF_marker) fprintf(LOG_FH,"JFIF ");
}
fflush(LOG_FH);
}
if ((insize=file_size(infile)) < 0)
fatal("failed to stat() input file");
/* decompress the file */
if (quality>=0 && !retry) {
jpeg_start_decompress(&dinfo);
/* allocate line buffer to store the decompressed image */
buf = malloc(sizeof(JSAMPROW)*dinfo.output_height);
if (!buf) fatal("not enough memory");
for (j=0;j<dinfo.output_height;j++) {
buf[j]=malloc(sizeof(JSAMPLE)*dinfo.output_width*
dinfo.out_color_components);
if (!buf[j]) fatal("not enough memory");
}
while (dinfo.output_scanline < dinfo.output_height) {
jpeg_read_scanlines(&dinfo,&buf[dinfo.output_scanline],
dinfo.output_height-dinfo.output_scanline);
}
} else {
coef_arrays = jpeg_read_coefficients(&dinfo);
}
if (!retry && !quiet_mode) {
if (global_error_counter==0) fprintf(LOG_FH," [OK] ");
else fprintf(LOG_FH," [WARNING] ");
fflush(LOG_FH);
}
if (dest && !noaction) {
if (file_exists(newname) && !overwrite_mode) {
warn("target file already exists: %s\n",newname);
jpeg_abort_decompress(&dinfo);
fclose(infile);
if (buf) FREE_LINE_BUF(buf,dinfo.output_height);
continue;
}
}
if (setjmp(jcerr.setjmp_buffer)) {
/* error handler for compress failures */
jpeg_abort_compress(&cinfo);
jpeg_abort_decompress(&dinfo);
fclose(infile);
if (!quiet_mode) fprintf(LOG_FH," [Compress ERROR]\n");
if (buf) FREE_LINE_BUF(buf,dinfo.output_height);
compress_err_count++;
jcerr.jump_set=0;
continue;
} else {
jcerr.jump_set=1;
}
lastsize = 0;
searchcount = 0;
searchdone = 0;
oldquality = 200;
binary_search_loop:
/* allocate memory buffer that should be large enough to store the output JPEG... */
if (outbuffer) free(outbuffer);
outbuffersize=insize + 32768;
outbuffer=malloc(outbuffersize);
if (!outbuffer) fatal("not enough memory");
/* setup custom "destination manager" for libjpeg to write to our buffer */
jpeg_memory_dest(&cinfo, &outbuffer, &outbuffersize, 65536);
if (quality>=0 && !retry) {
/* lossy "optimization" ... */
cinfo.in_color_space=dinfo.out_color_space;
cinfo.input_components=dinfo.output_components;
cinfo.image_width=dinfo.image_width;
cinfo.image_height=dinfo.image_height;
jpeg_set_defaults(&cinfo);
jpeg_set_quality(&cinfo,quality,TRUE);
if ( (dinfo.progressive_mode || all_progressive) && !all_normal )
jpeg_simple_progression(&cinfo);
cinfo.optimize_coding = TRUE;
j=0;
jpeg_start_compress(&cinfo,TRUE);
/* write markers */
write_markers(&dinfo,&cinfo);
/* write image */
while (cinfo.next_scanline < cinfo.image_height) {
jpeg_write_scanlines(&cinfo,&buf[cinfo.next_scanline],
dinfo.output_height);
}
} else {
/* lossless "optimization" ... */
jpeg_copy_critical_parameters(&dinfo, &cinfo);
if ( (dinfo.progressive_mode || all_progressive) && !all_normal )
jpeg_simple_progression(&cinfo);
cinfo.optimize_coding = TRUE;
/* write image */
jpeg_write_coefficients(&cinfo, coef_arrays);
/* write markers */
write_markers(&dinfo,&cinfo);
}
jpeg_finish_compress(&cinfo);
outsize=outbuffersize;
if (target_size != 0 && !retry) {
/* perform (binary) search to try to reach target file size... */
long osize = outsize/1024;
long isize = insize/1024;
long tsize = target_size;
if (tsize < 0) {
tsize=((-target_size)*insize/100)/1024;
if (tsize < 1) tsize=1;
}
if (osize == tsize || searchdone || searchcount >= 8 || tsize > isize) {
if (searchdone < 42 && lastsize > 0) {
if (abs(osize-tsize) > abs(lastsize-tsize)) {
if (verbose_mode) fprintf(LOG_FH,"(revert to %d)",oldquality);
searchdone=42;
quality=oldquality;
goto binary_search_loop;
}
}
if (verbose_mode) fprintf(LOG_FH," ");
} else {
int newquality;
int dif = floor((abs(oldquality-quality)/2.0)+0.5);
if (osize > tsize) {
newquality=quality-dif;
if (dif < 1) { newquality--; searchdone=1; }
if (newquality < 0) { newquality=0; searchdone=2; }
} else {
newquality=quality+dif;
if (dif < 1) { newquality++; searchdone=3; }
if (newquality > 100) { newquality=100; searchdone=4; }
}
oldquality=quality;
quality=newquality;
if (verbose_mode) fprintf(LOG_FH,"(try %d)",quality);
lastsize=osize;
searchcount++;
goto binary_search_loop;
}
}
if (buf) FREE_LINE_BUF(buf,dinfo.output_height);
jpeg_finish_decompress(&dinfo);
fclose(infile);
if (quality>=0 && outsize>=insize && !retry && !stdin_mode) {
if (verbose_mode) fprintf(LOG_FH,"(retry w/lossless) ");
retry=1;
goto retry_point;
}
retry=0;
ratio=(insize-outsize)*100.0/insize;
if (!quiet_mode || csv)
fprintf(LOG_FH,csv ? "%ld,%ld,%0.2f," : "%ld --> %ld bytes (%0.2f%%), ",insize,outsize,ratio);
average_count++;
average_rate+=(ratio<0 ? 0.0 : ratio);
if ((outsize < insize && ratio >= threshold) || force) {
total_save+=(insize-outsize)/1024.0;
if (!quiet_mode || csv) fprintf(LOG_FH,csv ? "optimized\n" : "optimized.\n");
if (noaction) continue;
if (stdout_mode) {
outfname=NULL;
set_filemode_binary(stdout);
if (fwrite(outbuffer,outbuffersize,1,stdout) != 1)
fatal("write failed to stdout");
} else {
if (preserve_perms && !dest) {
/* make backup of the original file */
snprintf(tmpfilename,sizeof(tmpfilename),"%s.jpegoptim.bak",newname);
if (verbose_mode > 1 && !quiet_mode)
fprintf(LOG_FH,"creating backup of original image as: %s\n",tmpfilename);
if (file_exists(tmpfilename))
fatal("backup file already exists: %s",tmpfilename);
if (copy_file(newname,tmpfilename))
fatal("failed to create backup of original file");
if ((outfile=fopen(newname,"wb"))==NULL)
fatal("error opening output file: %s", newname);
outfname=newname;
} else {
#ifdef HAVE_MKSTEMPS
/* rely on mkstemps() to create us temporary file safely... */
snprintf(tmpfilename,sizeof(tmpfilename),
"%sjpegoptim-%d-%d.XXXXXX.tmp", tmpdir, (int)getuid(), (int)getpid());
if ((tmpfd = mkstemps(tmpfilename,4)) < 0)
fatal("error creating temp file: mkstemps() failed");
if ((outfile=fdopen(tmpfd,"wb"))==NULL)
#else
/* if platform is missing mkstemps(), try to create at least somewhat "safe" temp file... */
snprintf(tmpfilename,sizeof(tmpfilename),
"%sjpegoptim-%d-%d.%d.tmp", tmpdir, (int)getuid(), (int)getpid(),time(NULL));
tmpfd=0;
if ((outfile=fopen(tmpfilename,"wb"))==NULL)
#endif
fatal("error opening temporary file: %s",tmpfilename);
outfname=tmpfilename;
}
if (verbose_mode > 1 && !quiet_mode)
fprintf(LOG_FH,"writing %lu bytes to file: %s\n",
(long unsigned int)outbuffersize, outfname);
if (fwrite(outbuffer,outbuffersize,1,outfile) != 1)
fatal("write failed to file: %s", outfname);
fclose(outfile);
}
if (outfname) {
if (preserve_mode) {
/* preserve file modification time */
struct utimbuf time_save;
time_save.actime=file_stat.st_atime;
time_save.modtime=file_stat.st_mtime;
if (utime(outfname,&time_save) != 0)
warn("failed to reset output file time/date");
}
if (preserve_perms && !dest) {
/* original file was already replaced, remove backup... */
if (delete_file(tmpfilename))
warn("failed to remove backup file: %s",tmpfilename);
} else {
/* make temp file to be the original file... */
/* preserve file mode */
if (chmod(outfname,(file_stat.st_mode & 0777)) != 0)
warn("failed to set output file mode");
/* preserve file group (and owner if run by root) */
if (chown(outfname,
(geteuid()==0 ? file_stat.st_uid : -1),
file_stat.st_gid) != 0)
warn("failed to reset output file group/owner");
if (verbose_mode > 1 && !quiet_mode)
fprintf(LOG_FH,"renaming: %s to %s\n",outfname,newname);
if (rename_file(outfname,newname)) fatal("cannot rename temp file");
}
}
} else {
if (!quiet_mode || csv) fprintf(LOG_FH,csv ? "skipped\n" : "skipped.\n");
}
} while (++i<argc && !stdin_mode);
if (totals_mode && !quiet_mode)
fprintf(LOG_FH,"Average ""compression"" (%ld files): %0.2f%% (%0.0fk)\n",
average_count, average_rate/average_count, total_save);
jpeg_destroy_decompress(&dinfo);
jpeg_destroy_compress(&cinfo);
return (decompress_err_count > 0 || compress_err_count > 0 ? 1 : 0);;
}
static uint32_t jpeg_write(uint8_t * name, uint8_t * buffer)
{
FILE *outfile;
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
JSAMPROW row_pointer[1];
int row_stride;
if ( !buffer ) return 1;
if ( (outfile = fopen(name, "wb") ) == NULL ) {
mp_msg(MSGT_VO, MSGL_ERR, "\n%s: %s\n", info.short_name,
MSGTR_VO_CantCreateFile);
mp_msg(MSGT_VO, MSGL_ERR, "%s: %s: %s\n",
info.short_name, MSGTR_VO_GenericError,
strerror(errno) );
exit_player(MSGTR_Exit_error);
}
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
jpeg_stdio_dest(&cinfo, outfile);
cinfo.image_width = image_width;
cinfo.image_height = image_height;
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&cinfo);
/* Important: Header info must be set AFTER jpeg_set_defaults() */
cinfo.write_JFIF_header = TRUE;
cinfo.JFIF_major_version = 1;
cinfo.JFIF_minor_version = 2;
cinfo.density_unit = 1; /* 0=unknown, 1=dpi, 2=dpcm */
/* Image DPI is determined by Y_density, so we leave that at
jpeg_dpi if possible and crunch X_density instead (PAR > 1) */
cinfo.X_density = jpeg_dpi*image_width/image_d_width;
cinfo.Y_density = jpeg_dpi*image_height/image_d_height;
cinfo.write_Adobe_marker = TRUE;
jpeg_set_quality(&cinfo,jpeg_quality, jpeg_baseline);
cinfo.optimize_coding = jpeg_optimize;
cinfo.smoothing_factor = jpeg_smooth;
if ( jpeg_progressive_mode ) {
jpeg_simple_progression(&cinfo);
}
jpeg_start_compress(&cinfo, TRUE);
row_stride = image_width * 3;
while (cinfo.next_scanline < cinfo.image_height) {
row_pointer[0] = &buffer[cinfo.next_scanline * row_stride];
(void)jpeg_write_scanlines(&cinfo, row_pointer,1);
}
jpeg_finish_compress(&cinfo);
fclose(outfile);
jpeg_destroy_compress(&cinfo);
return 0;
}
bool TCJpegImageFormat::saveFile(TCImage *image, FILE *file)
{
bool retValue = false;
bool canceled = false;
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
if (image->getDataFormat() != TCRgb8 && image->getDataFormat() != TCRgba8)
{
return false;
}
if (setup(cinfo, jerr))
{
std::vector<TCByte> row;
TCByte *imageData;
int rowSize;
int offset = 0;
int dir = 1;
TCByte *rowBytes = NULL;
TCJpegOptions *options =
(TCJpegOptions *)image->getCompressionOptions();
imageWidth = image->getWidth();
imageHeight = image->getHeight();
this->image = image;
// WARNING: Do NOT put any C++ objects that need destructors inside the
// following if statement. Doing so will result in a memory leak if any
// error occurs.
#ifdef WIN32
#pragma warning( push )
#pragma warning( disable : 4611 )
#endif // WIN32
if (setjmp(jumpBuf))
#ifdef WIN32
#pragma warning( pop )
#endif // WIN32
{
// If we get here, there was an error below.
// Note: jpeg_destroy_compress is called automatically by the JPEG
// library error handling code. We really are good to just exit.
return false;
}
jpeg_stdio_dest(&cinfo, file);
callProgressCallback(_UC("SavingJPG"), 0.0f);
cinfo.in_color_space = JCS_RGB;
cinfo.image_width = imageWidth;
cinfo.image_height = image->getHeight();
cinfo.input_components = 3;
imageData = image->getImageData();
rowSize = image->getRowSize();
if (image->getFlipped())
{
offset = rowSize * (imageHeight - 1);
dir = -1;
}
if (image->getDataFormat() == TCRgba8)
{
row.resize(image->getWidth() * 3);
rowBytes = &row[0];
}
jpeg_set_defaults(&cinfo);
jpeg_default_colorspace(&cinfo);
jpeg_set_quality(&cinfo, options->getQuality(), FALSE);
switch (options->getSubSampling())
{
case TCJpegOptions::SS420:
// 4:2:0
cinfo.comp_info[0].h_samp_factor = 2;
cinfo.comp_info[0].v_samp_factor = 2;
cinfo.comp_info[1].h_samp_factor = 1;
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1;
cinfo.comp_info[2].v_samp_factor = 1;
break;
case TCJpegOptions::SS422:
// 4:2:2
cinfo.comp_info[0].h_samp_factor = 2;
cinfo.comp_info[0].v_samp_factor = 1;
cinfo.comp_info[1].h_samp_factor = 1;
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1;
cinfo.comp_info[2].v_samp_factor = 1;
break;
case TCJpegOptions::SS444:
// 4:4:4
cinfo.comp_info[0].h_samp_factor = 1;
cinfo.comp_info[0].v_samp_factor = 1;
cinfo.comp_info[1].h_samp_factor = 1;
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1;
cinfo.comp_info[2].v_samp_factor = 1;
break;
}
if (options->getProgressive())
{
jpeg_simple_progression(&cinfo);
}
jpeg_start_compress(&cinfo, TRUE);
while (cinfo.next_scanline < cinfo.image_height && !canceled)
{
unsigned int result;
if (image->getDataFormat() == TCRgb8)
{
rowBytes = &imageData[offset];
}
else
{
int dstIndex = 0;
int srcIndex = offset;
// Convert RGBA to RGB.
for (unsigned int x = 0; x < imageWidth; x++)
{
rowBytes[dstIndex++] = imageData[srcIndex++];
rowBytes[dstIndex++] = imageData[srcIndex++];
rowBytes[dstIndex++] = imageData[srcIndex++];
srcIndex++;
}
}
result = jpeg_write_scanlines(&cinfo, &rowBytes, 1);
offset += result * rowSize * dir;
if (!callProgressCallback(NULL, (float)cinfo.next_scanline /
(float)cinfo.image_height))
{
canceled = true;
}
}
if (canceled)
{
jpeg_abort_compress(&cinfo);
}
else
{
jpeg_finish_compress(&cinfo);
retValue = true;
}
jpeg_destroy_compress(&cinfo);
}
callProgressCallback(NULL, 2.0f);
return retValue && !canceled;
}
parse_switches (j_compress_ptr cinfo, int argc, char **argv,
int last_file_arg_seen, boolean for_real)
{
int argn;
char * arg;
boolean simple_progressive;
char * scansarg = NULL;
simple_progressive = FALSE;
outfilename = NULL;
copyoption = JCOPYOPT_DEFAULT;
transformoption.transform = JXFORM_NONE;
transformoption.trim = FALSE;
transformoption.force_grayscale = FALSE;
cinfo->err->trace_level = 0;
for (argn = 1; argn < argc; argn++) {
arg = argv[argn];
if (*arg != '-') {
if (argn <= last_file_arg_seen) {
outfilename = NULL;
continue;
}
break;
}
arg++;
if (keymatch(arg, "arithmetic", 1)) {
#ifdef C_ARITH_CODING_SUPPORTED
cinfo->arith_code = TRUE;
#else
fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "copy", 1)) {
if (++argn >= argc)
usage();
if (keymatch(argv[argn], "none", 1)) {
copyoption = JCOPYOPT_NONE;
} else if (keymatch(argv[argn], "comments", 1)) {
copyoption = JCOPYOPT_COMMENTS;
} else if (keymatch(argv[argn], "all", 1)) {
copyoption = JCOPYOPT_ALL;
} else
usage();
} else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
static boolean printed_version = FALSE;
if (! printed_version) {
fprintf(stderr, "Independent JPEG Group's JPEGTRAN, version %s\n%s\n",
JVERSION, JCOPYRIGHT);
printed_version = TRUE;
}
cinfo->err->trace_level++;
} else if (keymatch(arg, "flip", 1)) {
if (++argn >= argc)
usage();
if (keymatch(argv[argn], "horizontal", 1))
select_transform(JXFORM_FLIP_H);
else if (keymatch(argv[argn], "vertical", 1))
select_transform(JXFORM_FLIP_V);
else
usage();
} else if (keymatch(arg, "grayscale", 1) || keymatch(arg, "greyscale",1)) {
#if TRANSFORMS_SUPPORTED
transformoption.force_grayscale = TRUE;
#else
select_transform(JXFORM_NONE);
#endif
} else if (keymatch(arg, "maxmemory", 3)) {
long lval;
char ch = 'x';
if (++argn >= argc)
usage();
if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
usage();
if (ch == 'm' || ch == 'M')
lval *= 1000L;
cinfo->mem->max_memory_to_use = lval * 1000L;
} else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) {
#ifdef ENTROPY_OPT_SUPPORTED
cinfo->optimize_coding = TRUE;
#else
fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "outfile", 4)) {
if (++argn >= argc)
usage();
outfilename = argv[argn];
} else if (keymatch(arg, "progressive", 1)) {
#ifdef C_PROGRESSIVE_SUPPORTED
simple_progressive = TRUE;
#else
fprintf(stderr, "%s: sorry, progressive output was not compiled\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "restart", 1)) {
long lval;
char ch = 'x';
if (++argn >= argc)
usage();
if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
usage();
if (lval < 0 || lval > 65535L)
usage();
if (ch == 'b' || ch == 'B') {
cinfo->restart_interval = (unsigned int) lval;
cinfo->restart_in_rows = 0;
} else {
cinfo->restart_in_rows = (int) lval;
}
} else if (keymatch(arg, "rotate", 2)) {
if (++argn >= argc)
usage();
if (keymatch(argv[argn], "90", 2))
select_transform(JXFORM_ROT_90);
else if (keymatch(argv[argn], "180", 3))
select_transform(JXFORM_ROT_180);
else if (keymatch(argv[argn], "270", 3))
select_transform(JXFORM_ROT_270);
else
usage();
} else if (keymatch(arg, "scans", 1)) {
#ifdef C_MULTISCAN_FILES_SUPPORTED
if (++argn >= argc)
usage();
scansarg = argv[argn];
#else
fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "transpose", 1)) {
select_transform(JXFORM_TRANSPOSE);
} else if (keymatch(arg, "transverse", 6)) {
select_transform(JXFORM_TRANSVERSE);
} else if (keymatch(arg, "trim", 3)) {
transformoption.trim = TRUE;
} else {
usage();
}
}
if (for_real) {
#ifdef C_PROGRESSIVE_SUPPORTED
if (simple_progressive)
jpeg_simple_progression(cinfo);
#endif
#ifdef C_MULTISCAN_FILES_SUPPORTED
if (scansarg != NULL)
if (! read_scan_script(cinfo, scansarg))
usage();
#endif
}
return argn;
}
parse_switches (j_compress_ptr cinfo, int argc, char **argv,
int last_file_arg_seen, boolean for_real)
/* Parse optional switches.
* Returns argv[] index of first file-name argument (== argc if none).
* Any file names with indexes <= last_file_arg_seen are ignored;
* they have presumably been processed in a previous iteration.
* (Pass 0 for last_file_arg_seen on the first or only iteration.)
* for_real is FALSE on the first (dummy) pass; we may skip any expensive
* processing.
*/
{
int argn;
char * arg;
boolean force_baseline;
boolean simple_progressive;
char * qualityarg = NULL; /* saves -quality parm if any */
char * qtablefile = NULL; /* saves -qtables filename if any */
char * qslotsarg = NULL; /* saves -qslots parm if any */
char * samplearg = NULL; /* saves -sample parm if any */
char * scansarg = NULL; /* saves -scans parm if any */
/* Set up default JPEG parameters. */
force_baseline = FALSE; /* by default, allow 16-bit quantizers */
#ifdef C_PROGRESSIVE_SUPPORTED
simple_progressive = cinfo->num_scans == 0 ? FALSE : TRUE;
#else
simple_progressive = FALSE;
#endif
is_targa = FALSE;
outfilename = NULL;
memdst = FALSE;
cinfo->err->trace_level = 0;
/* Scan command line options, adjust parameters */
for (argn = 1; argn < argc; argn++) {
arg = argv[argn];
if (*arg != '-') {
/* Not a switch, must be a file name argument */
if (argn <= last_file_arg_seen) {
outfilename = NULL; /* -outfile applies to just one input file */
continue; /* ignore this name if previously processed */
}
break; /* else done parsing switches */
}
arg++; /* advance past switch marker character */
if (keymatch(arg, "arithmetic", 1)) {
/* Use arithmetic coding. */
#ifdef C_ARITH_CODING_SUPPORTED
cinfo->arith_code = TRUE;
#else
fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "baseline", 1)) {
/* Force baseline-compatible output (8-bit quantizer values). */
force_baseline = TRUE;
} else if (keymatch(arg, "dct", 2)) {
/* Select DCT algorithm. */
if (++argn >= argc) { /* advance to next argument */
fprintf(stderr, "%s: missing argument for dct\n", progname);
usage();
}
if (keymatch(argv[argn], "int", 1)) {
cinfo->dct_method = JDCT_ISLOW;
} else if (keymatch(argv[argn], "fast", 2)) {
cinfo->dct_method = JDCT_IFAST;
} else if (keymatch(argv[argn], "float", 2)) {
cinfo->dct_method = JDCT_FLOAT;
} else
fprintf(stderr, "%s: invalid argument for dct\n", progname);
usage();
} else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
/* Enable debug printouts. */
/* On first -d, print version identification */
static boolean printed_version = FALSE;
if (! printed_version) {
fprintf(stderr, "%s version %s (build %s)\n",
PACKAGE_NAME, VERSION, BUILD);
fprintf(stderr, "%s\n\n", JCOPYRIGHT);
fprintf(stderr, "Emulating The Independent JPEG Group's software, version %s\n\n",
JVERSION);
printed_version = TRUE;
}
cinfo->err->trace_level++;
} else if (keymatch(arg, "fastcrush", 4)) {
cinfo->optimize_scans = FALSE;
} else if (keymatch(arg, "flat", 4)) {
cinfo->use_flat_quant_tbl = TRUE;
jpeg_set_quality(cinfo, 75, TRUE);
} else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {
/* Force a monochrome JPEG file to be generated. */
jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
} else if (keymatch(arg, "rgb", 3)) {
/* Force an RGB JPEG file to be generated. */
jpeg_set_colorspace(cinfo, JCS_RGB);
} else if (keymatch(arg, "lambda1", 7)) {
if (++argn >= argc) /* advance to next argument */
usage();
cinfo->lambda_log_scale1 = atof(argv[argn]);
} else if (keymatch(arg, "lambda2", 7)) {
if (++argn >= argc) /* advance to next argument */
usage();
cinfo->lambda_log_scale2 = atof(argv[argn]);
} else if (keymatch(arg, "maxmemory", 3)) {
/* Maximum memory in Kb (or Mb with 'm'). */
long lval;
char ch = 'x';
if (++argn >= argc) /* advance to next argument */
usage();
if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
usage();
if (ch == 'm' || ch == 'M')
lval *= 1000L;
cinfo->mem->max_memory_to_use = lval * 1000L;
} else if (keymatch(arg, "multidcscan", 3)) {
cinfo->one_dc_scan = FALSE;
} else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) {
/* Enable entropy parm optimization. */
#ifdef ENTROPY_OPT_SUPPORTED
cinfo->optimize_coding = TRUE;
#else
fprintf(stderr, "%s: sorry, entropy optimization was not compiled in\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "outfile", 4)) {
/* Set output file name. */
if (++argn >= argc) { /* advance to next argument */
fprintf(stderr, "%s: missing argument for outfile\n", progname);
usage();
}
outfilename = argv[argn]; /* save it away for later use */
} else if (keymatch(arg, "progressive", 1)) {
/* Select simple progressive mode. */
#ifdef C_PROGRESSIVE_SUPPORTED
simple_progressive = TRUE;
/* We must postpone execution until num_components is known. */
#else
fprintf(stderr, "%s: sorry, progressive output was not compiled in\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "memdst", 2)) {
/* Use in-memory destination manager */
#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
memdst = TRUE;
#else
fprintf(stderr, "%s: sorry, in-memory destination manager was not compiled in\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "quality", 1)) {
/* Quality ratings (quantization table scaling factors). */
if (++argn >= argc) { /* advance to next argument */
fprintf(stderr, "%s: missing argument for quality\n", progname);
usage();
}
qualityarg = argv[argn];
} else if (keymatch(arg, "qslots", 2)) {
/* Quantization table slot numbers. */
if (++argn >= argc) /* advance to next argument */
usage();
qslotsarg = argv[argn];
/* Must delay setting qslots until after we have processed any
* colorspace-determining switches, since jpeg_set_colorspace sets
* default quant table numbers.
*/
} else if (keymatch(arg, "qtables", 2)) {
/* Quantization tables fetched from file. */
if (++argn >= argc) /* advance to next argument */
usage();
qtablefile = argv[argn];
/* We postpone actually reading the file in case -quality comes later. */
} else if (keymatch(arg, "restart", 1)) {
/* Restart interval in MCU rows (or in MCUs with 'b'). */
long lval;
char ch = 'x';
if (++argn >= argc) /* advance to next argument */
usage();
if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
usage();
if (lval < 0 || lval > 65535L)
usage();
if (ch == 'b' || ch == 'B') {
cinfo->restart_interval = (unsigned int) lval;
cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */
} else {
cinfo->restart_in_rows = (int) lval;
/* restart_interval will be computed during startup */
}
} else if (keymatch(arg, "revert", 3)) {
/* revert to old JPEG default */
cinfo->use_moz_defaults = FALSE;
jpeg_set_defaults(cinfo);
} else if (keymatch(arg, "sample", 2)) {
/* Set sampling factors. */
if (++argn >= argc) /* advance to next argument */
usage();
samplearg = argv[argn];
/* Must delay setting sample factors until after we have processed any
* colorspace-determining switches, since jpeg_set_colorspace sets
* default sampling factors.
*/
} else if (keymatch(arg, "scans", 4)) {
/* Set scan script. */
#ifdef C_MULTISCAN_FILES_SUPPORTED
if (++argn >= argc) /* advance to next argument */
usage();
scansarg = argv[argn];
/* We must postpone reading the file in case -progressive appears. */
#else
fprintf(stderr, "%s: sorry, multi-scan output was not compiled in\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "smooth", 2)) {
/* Set input smoothing factor. */
int val;
if (++argn >= argc) /* advance to next argument */
usage();
if (sscanf(argv[argn], "%d", &val) != 1)
usage();
if (val < 0 || val > 100)
usage();
cinfo->smoothing_factor = val;
} else if (keymatch(arg, "targa", 1)) {
/* Input file is Targa format. */
is_targa = TRUE;
} else if (keymatch(arg, "notrellis", 1)) {
/* disable trellis quantization */
cinfo->trellis_quant = FALSE;
} else if (keymatch(arg, "tune-psnr", 6)) {
cinfo->use_flat_quant_tbl = TRUE;
cinfo->lambda_log_scale1 = 9.0;
cinfo->lambda_log_scale2 = 0.0;
cinfo->use_lambda_weight_tbl = FALSE;
jpeg_set_quality(cinfo, 75, TRUE);
} else if (keymatch(arg, "tune-ssim", 6)) {
cinfo->use_flat_quant_tbl = TRUE;
cinfo->lambda_log_scale1 = 12.0;
cinfo->lambda_log_scale2 = 13.5;
cinfo->use_lambda_weight_tbl = FALSE;
jpeg_set_quality(cinfo, 75, TRUE);
} else if (keymatch(arg, "tune-ms-ssim", 6)) {
cinfo->use_flat_quant_tbl = FALSE;
cinfo->lambda_log_scale1 = 14.25;
cinfo->lambda_log_scale2 = 12.75;
cinfo->use_lambda_weight_tbl = TRUE;
jpeg_set_quality(cinfo, 75, TRUE);
} else if (keymatch(arg, "tune-hvs-psnr", 6)) {
cinfo->use_flat_quant_tbl = FALSE;
cinfo->lambda_log_scale1 = 16.0;
cinfo->lambda_log_scale2 = 15.5;
cinfo->use_lambda_weight_tbl = TRUE;
jpeg_set_quality(cinfo, 75, TRUE);
} else {
fprintf(stderr, "%s: unknown option '%s'\n", progname, arg);
usage(); /* bogus switch */
}
}
/* Post-switch-scanning cleanup */
if (for_real) {
/* Set quantization tables for selected quality. */
/* Some or all may be overridden if -qtables is present. */
if (qualityarg != NULL) /* process -quality if it was present */
if (! set_quality_ratings(cinfo, qualityarg, force_baseline)) {
fprintf(stderr, "%s: can't set quality ratings\n", progname);
usage();
}
if (qtablefile != NULL) /* process -qtables if it was present */
if (! read_quant_tables(cinfo, qtablefile, force_baseline)) {
fprintf(stderr, "%s: can't read qtable file\n", progname);
usage();
}
if (qslotsarg != NULL) /* process -qslots if it was present */
if (! set_quant_slots(cinfo, qslotsarg))
usage();
if (samplearg != NULL) /* process -sample if it was present */
if (! set_sample_factors(cinfo, samplearg)) {
fprintf(stderr, "%s: can't set sample factors\n", progname);
usage();
}
#ifdef C_PROGRESSIVE_SUPPORTED
if (simple_progressive) /* process -progressive; -scans can override */
jpeg_simple_progression(cinfo);
#endif
#ifdef C_MULTISCAN_FILES_SUPPORTED
if (scansarg != NULL) /* process -scans if it was present */
if (! read_scan_script(cinfo, scansarg))
usage();
#endif
}
return argn; /* return index of next arg (file name) */
}
static int
ngx_http_video_thumbextractor_get_thumb(ngx_http_video_thumbextractor_loc_conf_t *cf, ngx_http_video_thumbextractor_file_info_t *info, int64_t second, ngx_uint_t width, ngx_uint_t height, caddr_t *out_buffer, size_t *out_len, ngx_pool_t *temp_pool, ngx_log_t *log)
{
int rc, videoStream, frameFinished = 0, frameDecoded = 0;
unsigned int i;
AVFormatContext *pFormatCtx = NULL;
AVCodecContext *pCodecCtx = NULL;
AVCodec *pCodec = NULL;
AVFrame *pFrame = NULL, *pFrameRGB = NULL;
uint8_t *buffer = NULL;
AVPacket packet;
size_t uncompressed_size;
float scale = 0.0, new_scale = 0.0, scale_sws = 0.0, scale_w = 0.0, scale_h = 0.0;
int sws_width = 0, sws_height = 0;
ngx_flag_t needs_crop = 0;
MagickWand *m_wand = NULL;
MagickBooleanType mrc;
unsigned char *bufferAVIO = NULL;
AVIOContext *pAVIOCtx = NULL;
char *filename = (char *) info->filename->data;
// Open video file
if ((info->fd = fopen(filename, "rb")) == NULL) {
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Couldn't open file %s", filename);
rc = EXIT_FAILURE;
goto exit;
}
// Get file size
fseek(info->fd, 0, SEEK_END);
info->size = ftell(info->fd) - info->offset;
fseek(info->fd, 0, SEEK_SET);
pFormatCtx = avformat_alloc_context();
bufferAVIO = (unsigned char *) av_malloc(NGX_HTTP_VIDEO_THUMBEXTRACTOR_BUFFER_SIZE * sizeof(unsigned char));
if ((pFormatCtx == NULL) || (bufferAVIO == NULL)) {
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Couldn't alloc AVIO buffer");
rc = NGX_ERROR;
goto exit;
}
pAVIOCtx = avio_alloc_context(bufferAVIO, NGX_HTTP_VIDEO_THUMBEXTRACTOR_BUFFER_SIZE, 0, info, ngx_http_video_thumbextractor_read_data_from_file, NULL, ngx_http_video_thumbextractor_seek_data_from_file);
if (pAVIOCtx == NULL) {
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Couldn't alloc AVIO context");
rc = NGX_ERROR;
goto exit;
}
pFormatCtx->pb = pAVIOCtx;
// Open video file
if ((rc = avformat_open_input(&pFormatCtx, filename, NULL, NULL)) != 0) {
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Couldn't open file %s, error: %d", filename, rc);
rc = (rc == AVERROR(NGX_ENOENT)) ? NGX_HTTP_VIDEO_THUMBEXTRACTOR_FILE_NOT_FOUND : NGX_ERROR;
goto exit;
}
// Retrieve stream information
#if LIBAVFORMAT_VERSION_INT <= AV_VERSION_INT(53, 5, 0)
if (av_find_stream_info(pFormatCtx) < 0) {
#else
if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
#endif
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Couldn't find stream information");
rc = NGX_ERROR;
goto exit;
}
if ((pFormatCtx->duration > 0) && ((((float_t) pFormatCtx->duration / AV_TIME_BASE) - second)) < 0.1) {
ngx_log_error(NGX_LOG_WARN, log, 0, "video thumb extractor module: seconds greater than duration");
rc = NGX_HTTP_VIDEO_THUMBEXTRACTOR_SECOND_NOT_FOUND;
goto exit;
}
// Find the first video stream
videoStream = -1;
for (i = 0; i < pFormatCtx->nb_streams; i++) {
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
videoStream = i;
break;
}
}
if (videoStream == -1) {
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Didn't find a video stream");
rc = NGX_ERROR;
goto exit;
}
// Get a pointer to the codec context for the video stream
pCodecCtx = pFormatCtx->streams[videoStream]->codec;
// Find the decoder for the video stream
if ((pCodec = avcodec_find_decoder(pCodecCtx->codec_id)) == NULL) {
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Codec %d not found", pCodecCtx->codec_id);
rc = NGX_ERROR;
goto exit;
}
// Open codec
#if LIBAVCODEC_VERSION_INT <= AV_VERSION_INT(53, 8, 0)
if ((rc = avcodec_open(pCodecCtx, pCodec)) < 0) {
#else
if ((rc = avcodec_open2(pCodecCtx, pCodec, NULL)) < 0) {
#endif
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Could not open codec, error %d", rc);
rc = NGX_ERROR;
goto exit;
}
if (height == 0) {
// keep original format
width = pCodecCtx->width;
height = pCodecCtx->height;
} else if (width == 0) {
// calculate width related with original aspect
width = height * pCodecCtx->width / pCodecCtx->height;
}
if ((width < 16) || (height < 16)) {
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Very small size requested, %d x %d", width, height);
rc = NGX_ERROR;
goto exit;
}
scale = (float) pCodecCtx->width / pCodecCtx->height;
new_scale = (float) width / height;
sws_width = width;
sws_height = height;
if (scale != new_scale) {
scale_w = (float) width / pCodecCtx->width;
scale_h = (float) height / pCodecCtx->height;
scale_sws = (scale_w > scale_h) ? scale_w : scale_h;
sws_width = pCodecCtx->width * scale_sws + 0.5;
sws_height = pCodecCtx->height * scale_sws + 0.5;
needs_crop = 1;
}
// Allocate video frame
pFrame = avcodec_alloc_frame();
// Allocate an AVFrame structure
pFrameRGB = avcodec_alloc_frame();
if ((pFrame == NULL) || (pFrameRGB == NULL)) {
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Could not alloc frame memory");
rc = NGX_ERROR;
goto exit;
}
// Determine required buffer size and allocate buffer
uncompressed_size = avpicture_get_size(PIX_FMT_RGB24, sws_width, sws_height) * sizeof(uint8_t);
buffer = (uint8_t *) av_malloc(uncompressed_size);
// Assign appropriate parts of buffer to image planes in pFrameRGB
// Note that pFrameRGB is an AVFrame, but AVFrame is a superset of AVPicture
avpicture_fill((AVPicture *) pFrameRGB, buffer, PIX_FMT_RGB24, sws_width, sws_height);
if ((rc = av_seek_frame(pFormatCtx, -1, second * AV_TIME_BASE, cf->next_time ? 0 : AVSEEK_FLAG_BACKWARD)) < 0) {
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Seek to an invalid time, error: %d", rc);
rc = NGX_HTTP_VIDEO_THUMBEXTRACTOR_SECOND_NOT_FOUND;
goto exit;
}
int64_t second_on_stream_time_base = second * pFormatCtx->streams[videoStream]->time_base.den / pFormatCtx->streams[videoStream]->time_base.num;
// Find the nearest frame
rc = NGX_HTTP_VIDEO_THUMBEXTRACTOR_SECOND_NOT_FOUND;
while (!frameFinished && av_read_frame(pFormatCtx, &packet) >= 0) {
// Is this a packet from the video stream?
if (packet.stream_index == videoStream) {
// Decode video frame
avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
// Did we get a video frame?
if (frameFinished) {
frameDecoded = 1;
if (!cf->only_keyframe && (pFrame->pkt_pts < second_on_stream_time_base)) {
frameFinished = 0;
}
}
}
// Free the packet that was allocated by av_read_frame
av_free_packet(&packet);
}
av_free_packet(&packet);
if (frameDecoded) {
// Convert the image from its native format to RGB
struct SwsContext *img_resample_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,
sws_width, sws_height, PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);
sws_scale(img_resample_ctx, (const uint8_t * const *) pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameRGB->data, pFrameRGB->linesize);
sws_freeContext(img_resample_ctx);
if (needs_crop) {
MagickWandGenesis();
mrc = MagickTrue;
if ((m_wand = NewMagickWand()) == NULL){
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Could not allocate MagickWand memory");
mrc = MagickFalse;
}
if (mrc == MagickTrue) {
mrc = MagickConstituteImage(m_wand, sws_width, sws_height, NGX_HTTP_VIDEO_THUMBEXTRACTOR_RGB, CharPixel, pFrameRGB->data[0]);
}
if (mrc == MagickTrue) {
mrc = MagickSetImageGravity(m_wand, CenterGravity);
}
if (mrc == MagickTrue) {
mrc = MagickCropImage(m_wand, width, height, (sws_width-width)/2, (sws_height-height)/2);
}
if (mrc == MagickTrue) {
mrc = MagickExportImagePixels(m_wand, 0, 0, width, height, NGX_HTTP_VIDEO_THUMBEXTRACTOR_RGB, CharPixel, pFrameRGB->data[0]);
}
/* Clean up */
if (m_wand) {
m_wand = DestroyMagickWand(m_wand);
}
MagickWandTerminus();
if (mrc != MagickTrue) {
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Error cropping image");
goto exit;
}
}
// Compress to jpeg
if (ngx_http_video_thumbextractor_jpeg_compress(cf, pFrameRGB->data[0], pCodecCtx->width, pCodecCtx->height, width, height, out_buffer, out_len, uncompressed_size, temp_pool) == 0) {
rc = NGX_OK;
}
}
exit:
if ((info->fd != NULL) && (fclose(info->fd) != 0)) {
ngx_log_error(NGX_LOG_ERR, log, 0, "video thumb extractor module: Couldn't close file %s", filename);
rc = EXIT_FAILURE;
}
/* destroy unneeded objects */
// Free the RGB image
if (buffer != NULL) av_free(buffer);
if (pFrameRGB != NULL) av_freep(&pFrameRGB);
// Free the YUV frame
if (pFrame != NULL) av_freep(&pFrame);
// Close the codec
if (pCodecCtx != NULL) avcodec_close(pCodecCtx);
// Close the video file
if (pFormatCtx != NULL) {
#if LIBAVFORMAT_VERSION_INT <= AV_VERSION_INT(53, 5, 0)
av_close_input_file(pFormatCtx);
#else
avformat_close_input(&pFormatCtx);
#endif
}
// Free AVIO context
if (pAVIOCtx != NULL) av_freep(pAVIOCtx);
return rc;
}
static void
ngx_http_video_thumbextractor_init_libraries(void)
{
// Register all formats and codecs
av_register_all();
av_log_set_level(AV_LOG_ERROR);
}
static uint32_t
ngx_http_video_thumbextractor_jpeg_compress(ngx_http_video_thumbextractor_loc_conf_t *cf, uint8_t * buffer, int in_width, int in_height, int out_width, int out_height, caddr_t *out_buffer, size_t *out_len, size_t uncompressed_size, ngx_pool_t *temp_pool)
{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
JSAMPROW row_pointer[1];
int row_stride;
int image_d_width = in_width;
int image_d_height = in_height;
if ( !buffer ) return 1;
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
ngx_http_video_thumbextractor_jpeg_memory_dest(&cinfo, out_buffer, out_len, uncompressed_size, temp_pool);
cinfo.image_width = out_width;
cinfo.image_height = out_height;
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&cinfo);
/* Important: Header info must be set AFTER jpeg_set_defaults() */
cinfo.write_JFIF_header = TRUE;
cinfo.JFIF_major_version = 1;
cinfo.JFIF_minor_version = 2;
cinfo.density_unit = 1; /* 0=unknown, 1=dpi, 2=dpcm */
/* Image DPI is determined by Y_density, so we leave that at
jpeg_dpi if possible and crunch X_density instead (PAR > 1) */
if (out_height * image_d_width > out_width * image_d_height) {
image_d_width = out_height * image_d_width / image_d_height;
image_d_height = out_height;
} else {
image_d_height = out_width * image_d_height / image_d_width;
image_d_width = out_width;
}
cinfo.X_density = cf->jpeg_dpi * out_width / image_d_width;
cinfo.Y_density = cf->jpeg_dpi * out_height / image_d_height;
cinfo.write_Adobe_marker = TRUE;
jpeg_set_quality(&cinfo, cf->jpeg_quality, cf->jpeg_baseline);
cinfo.optimize_coding = cf->jpeg_optimize;
cinfo.smoothing_factor = cf->jpeg_smooth;
if ( cf->jpeg_progressive_mode ) {
jpeg_simple_progression(&cinfo);
}
jpeg_start_compress(&cinfo, TRUE);
row_stride = out_width * 3;
while (cinfo.next_scanline < cinfo.image_height) {
row_pointer[0] = &buffer[cinfo.next_scanline * row_stride];
(void)jpeg_write_scanlines(&cinfo, row_pointer,1);
}
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
return 0;
}
typedef struct {
struct jpeg_destination_mgr pub; /* public fields */
unsigned char **buf;
size_t *size;
size_t uncompressed_size;
ngx_pool_t *pool;
} ngx_http_video_thumbextractor_jpeg_destination_mgr;
static void ngx_http_video_thumbextractor_init_destination (j_compress_ptr cinfo)
{
ngx_http_video_thumbextractor_jpeg_destination_mgr * dest = (ngx_http_video_thumbextractor_jpeg_destination_mgr *) cinfo->dest;
*(dest->buf) = ngx_palloc(dest->pool, dest->uncompressed_size);
*(dest->size) = dest->uncompressed_size;
dest->pub.next_output_byte = *(dest->buf);
dest->pub.free_in_buffer = dest->uncompressed_size;
}
parse_switches (j_compress_ptr cinfo, int argc, char **argv,
int last_file_arg_seen, jpegBoolean for_real)
/* Parse optional switches.
* Returns argv[] index of first file-name argument (== argc if none).
* Any file names with indexes <= last_file_arg_seen are ignored;
* they have presumably been processed in a previous iteration.
* (Pass 0 for last_file_arg_seen on the first or only iteration.)
* for_real is FALSE on the first (dummy) pass; we may skip any expensive
* processing.
*/
{
int argn;
char * arg;
int quality; /* -quality parameter */
int q_scale_factor; /* scaling percentage for -qtables */
jpegBoolean force_baseline;
jpegBoolean simple_progressive;
char * qtablefile = NULL; /* saves -qtables filename if any */
char * qslotsarg = NULL; /* saves -qslots parm if any */
char * samplearg = NULL; /* saves -sample parm if any */
char * scansarg = NULL; /* saves -scans parm if any */
/* Set up default JPEG parameters. */
/* Note that default -quality level need not, and does not,
* match the default scaling for an explicit -qtables argument.
*/
quality = 75; /* default -quality value */
q_scale_factor = 100; /* default to no scaling for -qtables */
force_baseline = FALSE; /* by default, allow 16-bit quantizers */
simple_progressive = FALSE;
is_targa = FALSE;
outfilename = NULL;
cinfo->err->trace_level = 0;
/* Scan command line options, adjust parameters */
for (argn = 1; argn < argc; argn++) {
arg = argv[argn];
if (*arg != '-') {
/* Not a switch, must be a file name argument */
if (argn <= last_file_arg_seen) {
outfilename = NULL; /* -outfile applies to just one input file */
continue; /* ignore this name if previously processed */
}
break; /* else done parsing switches */
}
arg++; /* advance past switch marker character */
if (keymatch(arg, "arithmetic", 1)) {
/* Use arithmetic coding. */
#ifdef C_ARITH_CODING_SUPPORTED
cinfo->arith_code = TRUE;
#else
fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "baseline", 1)) {
/* Force baseline output (8-bit quantizer values). */
force_baseline = TRUE;
} else if (keymatch(arg, "dct", 2)) {
/* Select DCT algorithm. */
if (++argn >= argc) /* advance to next argument */
usage();
if (keymatch(argv[argn], "int", 1)) {
cinfo->dct_method = JDCT_ISLOW;
} else if (keymatch(argv[argn], "fast", 2)) {
cinfo->dct_method = JDCT_IFAST;
} else if (keymatch(argv[argn], "float", 2)) {
cinfo->dct_method = JDCT_FLOAT;
} else
usage();
} else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
/* Enable debug printouts. */
/* On first -d, print version identification */
static jpegBoolean printed_version = FALSE;
if (! printed_version) {
fprintf(stderr, "Independent JPEG Group's CJPEG, version %s\n%s\n",
JVERSION, JCOPYRIGHT);
printed_version = TRUE;
}
cinfo->err->trace_level++;
} else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {
/* Force a monochrome JPEG file to be generated. */
jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
} else if (keymatch(arg, "maxmemory", 3)) {
/* Maximum memory in Kb (or Mb with 'm'). */
long lval;
char ch = 'x';
if (++argn >= argc) /* advance to next argument */
usage();
if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
usage();
if (ch == 'm' || ch == 'M')
lval *= 1000L;
cinfo->mem->max_memory_to_use = lval * 1000L;
} else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) {
/* Enable entropy parm optimization. */
#ifdef ENTROPY_OPT_SUPPORTED
cinfo->optimize_coding = TRUE;
#else
fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "outfile", 4)) {
/* Set output file name. */
if (++argn >= argc) /* advance to next argument */
usage();
outfilename = argv[argn]; /* save it away for later use */
} else if (keymatch(arg, "progressive", 1)) {
/* Select simple progressive mode. */
#ifdef C_PROGRESSIVE_SUPPORTED
simple_progressive = TRUE;
/* We must postpone execution until num_components is known. */
#else
fprintf(stderr, "%s: sorry, progressive output was not compiled\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "quality", 1)) {
/* Quality factor (quantization table scaling factor). */
if (++argn >= argc) /* advance to next argument */
usage();
if (sscanf(argv[argn], "%d", &quality) != 1)
usage();
/* Change scale factor in case -qtables is present. */
q_scale_factor = jpeg_quality_scaling(quality);
} else if (keymatch(arg, "qslots", 2)) {
/* Quantization table slot numbers. */
if (++argn >= argc) /* advance to next argument */
usage();
qslotsarg = argv[argn];
/* Must delay setting qslots until after we have processed any
* colorspace-determining switches, since jpeg_set_colorspace sets
* default quant table numbers.
*/
} else if (keymatch(arg, "qtables", 2)) {
/* Quantization tables fetched from file. */
if (++argn >= argc) /* advance to next argument */
usage();
qtablefile = argv[argn];
/* We postpone actually reading the file in case -quality comes later. */
} else if (keymatch(arg, "restart", 1)) {
/* Restart interval in MCU rows (or in MCUs with 'b'). */
long lval;
char ch = 'x';
if (++argn >= argc) /* advance to next argument */
usage();
if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
usage();
if (lval < 0 || lval > 65535L)
usage();
if (ch == 'b' || ch == 'B') {
cinfo->restart_interval = (unsigned int) lval;
cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */
} else {
cinfo->restart_in_rows = (int) lval;
/* restart_interval will be computed during startup */
}
} else if (keymatch(arg, "sample", 2)) {
/* Set sampling factors. */
if (++argn >= argc) /* advance to next argument */
usage();
samplearg = argv[argn];
/* Must delay setting sample factors until after we have processed any
* colorspace-determining switches, since jpeg_set_colorspace sets
* default sampling factors.
*/
} else if (keymatch(arg, "scans", 2)) {
/* Set scan script. */
#ifdef C_MULTISCAN_FILES_SUPPORTED
if (++argn >= argc) /* advance to next argument */
usage();
scansarg = argv[argn];
/* We must postpone reading the file in case -progressive appears. */
#else
fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "smooth", 2)) {
/* Set input smoothing factor. */
int val;
if (++argn >= argc) /* advance to next argument */
usage();
if (sscanf(argv[argn], "%d", &val) != 1)
usage();
if (val < 0 || val > 100)
usage();
cinfo->smoothing_factor = val;
} else if (keymatch(arg, "targa", 1)) {
/* Input file is Targa format. */
is_targa = TRUE;
} else {
usage(); /* bogus switch */
}
}
/* Post-switch-scanning cleanup */
if (for_real) {
/* Set quantization tables for selected quality. */
/* Some or all may be overridden if -qtables is present. */
jpeg_set_quality(cinfo, quality, force_baseline);
if (qtablefile != NULL) /* process -qtables if it was present */
if (! read_quant_tables(cinfo, qtablefile,
q_scale_factor, force_baseline))
usage();
if (qslotsarg != NULL) /* process -qslots if it was present */
if (! set_quant_slots(cinfo, qslotsarg))
usage();
if (samplearg != NULL) /* process -sample if it was present */
if (! set_sample_factors(cinfo, samplearg))
usage();
#ifdef C_PROGRESSIVE_SUPPORTED
if (simple_progressive) /* process -progressive; -scans can override */
jpeg_simple_progression(cinfo);
#endif
#ifdef C_MULTISCAN_FILES_SUPPORTED
if (scansarg != NULL) /* process -scans if it was present */
if (! read_scan_script(cinfo, scansarg))
usage();
#endif
}
return argn; /* return index of next arg (file name) */
}
static gboolean
_cairo_surface_write_as_jpeg (cairo_surface_t *image,
char **buffer,
gsize *buffer_size,
char **keys,
char **values,
GError **error)
{
struct jpeg_compress_struct cinfo;
struct error_handler_data jerr;
guchar *buf = NULL;
guchar *pixels = NULL;
volatile int quality = 85; /* default; must be between 0 and 100 */
volatile int smoothing = 0;
volatile gboolean optimize = FALSE;
#ifdef HAVE_PROGRESSIVE_JPEG
volatile gboolean progressive = FALSE;
#endif
int w, h = 0;
int rowstride = 0;
if (keys && *keys) {
char **kiter = keys;
char **viter = values;
while (*kiter) {
if (strcmp (*kiter, "quality") == 0) {
char *endptr = NULL;
quality = strtol (*viter, &endptr, 10);
if (endptr == *viter) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_BAD_OPTION,
"JPEG quality must be a value between 0 and 100; value '%s' could not be parsed.",
*viter);
return FALSE;
}
if (quality < 0 || quality > 100) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_BAD_OPTION,
"JPEG quality must be a value between 0 and 100; value '%d' is not allowed.",
quality);
return FALSE;
}
}
else if (strcmp (*kiter, "smooth") == 0) {
char *endptr = NULL;
smoothing = strtol (*viter, &endptr, 10);
if (endptr == *viter) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_BAD_OPTION,
"JPEG smoothing must be a value between 0 and 100; value '%s' could not be parsed.",
*viter);
return FALSE;
}
if (smoothing < 0 || smoothing > 100) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_BAD_OPTION,
"JPEG smoothing must be a value between 0 and 100; value '%d' is not allowed.",
smoothing);
return FALSE;
}
}
else if (strcmp (*kiter, "optimize") == 0) {
if (strcmp (*viter, "yes") == 0)
optimize = TRUE;
else if (strcmp (*viter, "no") == 0)
optimize = FALSE;
else {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_BAD_OPTION,
"JPEG optimize option must be 'yes' or 'no', value is: %s", *viter);
return FALSE;
}
}
#ifdef HAVE_PROGRESSIVE_JPEG
else if (strcmp (*kiter, "progressive") == 0) {
if (strcmp (*viter, "yes") == 0)
progressive = TRUE;
else if (strcmp (*viter, "no") == 0)
progressive = FALSE;
else {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_BAD_OPTION,
"JPEG progressive option must be 'yes' or 'no', value is: %s", *viter);
return FALSE;
}
}
#endif
else {
g_warning ("Bad option name '%s' passed to JPEG saver", *kiter);
return FALSE;
}
++kiter;
++viter;
}
}
rowstride = cairo_image_surface_get_stride (image);
w = cairo_image_surface_get_width (image);
h = cairo_image_surface_get_height (image);
pixels = _cairo_image_surface_flush_and_get_data (image);
g_return_val_if_fail (pixels != NULL, FALSE);
/* allocate a small buffer to convert image data */
buf = g_try_malloc (w * 3 * sizeof (guchar));
if (! buf) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
"Couldn't allocate memory for loading JPEG file");
return FALSE;
}
/* set up error handling */
cinfo.err = jpeg_std_error (&(jerr.pub));
jerr.pub.error_exit = fatal_error_handler;
jerr.pub.output_message = output_message_handler;
jerr.error = error;
if (sigsetjmp (jerr.setjmp_buffer, 1)) {
jpeg_destroy_compress (&cinfo);
g_free (buf);
return FALSE;
}
/* setup compress params */
jpeg_create_compress (&cinfo);
_jpeg_memory_dest (&cinfo, (void **)buffer, buffer_size);
cinfo.image_width = w;
cinfo.image_height = h;
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
/* set up jepg compression parameters */
jpeg_set_defaults (&cinfo);
jpeg_set_quality (&cinfo, quality, TRUE);
cinfo.smoothing_factor = smoothing;
cinfo.optimize_coding = optimize;
#ifdef HAVE_PROGRESSIVE_JPEG
if (progressive)
jpeg_simple_progression (&cinfo);
#endif /* HAVE_PROGRESSIVE_JPEG */
jpeg_start_compress (&cinfo, TRUE);
/* go one scanline at a time... and save */
while (cinfo.next_scanline < cinfo.image_height) {
JSAMPROW *jbuf;
/* convert scanline from RGBA to RGB packed */
_cairo_copy_line_as_rgba_big_endian (buf, pixels, w, FALSE);
/* write scanline */
jbuf = (JSAMPROW *)(&buf);
jpeg_write_scanlines (&cinfo, jbuf, 1);
pixels += rowstride;
}
/* finish off */
jpeg_finish_compress (&cinfo);
jpeg_destroy_compress (&cinfo);
g_free (buf);
return TRUE;
}
bool CxImageJPG::Encode(CxFile * hFile)
{
if (EncodeSafeCheck(hFile)) return false;
if (head.biClrUsed!=0 && !IsGrayScale()){
strcpy(info.szLastError,"JPEG can save only RGB or GreyScale images");
return false;
}
/* This struct contains the JPEG compression parameters and pointers to
* working space (which is allocated as needed by the JPEG library).
* It is possible to have several such structures, representing multiple
* compression/decompression processes, in existence at once. We refer
* to any one struct (and its associated working data) as a "JPEG object".
*/
struct jpeg_compress_struct cinfo;
/* This struct represents a JPEG error handler. It is declared separately
* because applications often want to supply a specialized error handler
* (see the second half of this file for an example). But here we just
* take the easy way out and use the standard error handler, which will
* print a message on stderr and call exit() if compression fails.
* Note that this struct must live as long as the main JPEG parameter
* struct, to avoid dangling-pointer problems.
*/
//struct jpeg_error_mgr jerr;
/* We use our private extension JPEG error handler. <CSC> */
struct ima_error_mgr jerr;
jerr.buffer=info.szLastError;
/* More stuff */
int row_stride; /* physical row width in image buffer */
JSAMPARRAY buffer; /* Output row buffer */
/* Step 1: allocate and initialize JPEG compression object */
/* We have to set up the error handler first, in case the initialization
* step fails. (Unlikely, but it could happen if you are out of memory.)
* This routine fills in the contents of struct jerr, and returns jerr's
* address which we place into the link field in cinfo.
*/
//cinfo.err = jpeg_std_error(&jerr); <CSC>
/* We set up the normal JPEG error routines, then override error_exit. */
cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = ima_jpeg_error_exit;
/* Establish the setjmp return context for my_error_exit to use. */
if (setjmp(jerr.setjmp_buffer)) {
/* If we get here, the JPEG code has signaled an error.
* We need to clean up the JPEG object, close the input file, and return.
*/
strcpy(info.szLastError, jerr.buffer); //<CSC>
jpeg_destroy_compress(&cinfo);
return 0;
}
/* Now we can initialize the JPEG compression object. */
jpeg_create_compress(&cinfo);
/* Step 2: specify data destination (eg, a file) */
/* Note: steps 2 and 3 can be done in either order. */
/* Here we use the library-supplied code to send compressed data to a
* stdio stream. You can also write your own code to do something else.
* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
* requires it in order to write binary files.
*/
//jpeg_stdio_dest(&cinfo, outfile);
CxFileJpg dest(hFile);
cinfo.dest = &dest;
/* Step 3: set parameters for compression */
/* First we supply a description of the input image.
* Four fields of the cinfo struct must be filled in:
*/
cinfo.image_width = GetWidth(); // image width and height, in pixels
cinfo.image_height = GetHeight();
if (IsGrayScale()){
cinfo.input_components = 1; // # of color components per pixel
cinfo.in_color_space = JCS_GRAYSCALE; /* colorspace of input image */
} else {
cinfo.input_components = 3; // # of color components per pixel
cinfo.in_color_space = JCS_RGB; /* colorspace of input image */
}
/* Now use the library's routine to set default compression parameters.
* (You must set at least cinfo.in_color_space before calling this,
* since the defaults depend on the source color space.)
*/
jpeg_set_defaults(&cinfo);
/* Now you can set any non-default parameters you wish to.
* Here we just illustrate the use of quality (quantization table) scaling:
*/
//jpeg_set_quality(&cinfo, info.nQuality, TRUE /* limit to baseline-JPEG values */);
#ifdef C_ARITH_CODING_SUPPORTED
if ((GetCodecOption() & ENCODE_ARITHMETIC) != 0)
cinfo.arith_code = TRUE;
#endif
#ifdef ENTRPY_OPT_SUPPORTED
if ((GetCodecOption() & ENCODE_OPTIMIZE) != 0)
cinfo.optimize_coding = TRUE;
#endif
if ((GetCodecOption() & ENCODE_GRAYSCALE) != 0)
jpeg_set_colorspace(&cinfo, JCS_GRAYSCALE);
if ((GetCodecOption() & ENCODE_SMOOTHING) != 0)
cinfo.smoothing_factor = m_nSmoothing;
jpeg_set_quality(&cinfo, GetJpegQuality(), (GetCodecOption() & ENCODE_BASELINE) != 0);
#ifdef C_PROGRESSIVE_SUPPORTED
if ((GetCodecOption() & ENCODE_PROGRESSIVE) != 0)
jpeg_simple_progression(&cinfo);
#endif
#ifdef C_LOSSLES_SUPPORTED
if ((GetCodecOption() & ENCODE_LOSSLESS) != 0)
jpeg_simple_lossless(&cinfo, m_nPredictor, m_nPointTransform);
#endif
cinfo.density_unit=1;
cinfo.X_density=(unsigned short)GetXDPI();
cinfo.Y_density=(unsigned short)GetYDPI();
/* Step 4: Start compressor */
/* TRUE ensures that we will write a complete interchange-JPEG file.
* Pass TRUE unless you are very sure of what you're doing.
*/
jpeg_start_compress(&cinfo, TRUE);
/* Step 5: while (scan lines remain to be written) */
/* jpeg_write_scanlines(...); */
/* Here we use the library's state variable cinfo.next_scanline as the
* loop counter, so that we don't have to keep track ourselves.
* To keep things simple, we pass one scanline per call; you can pass
* more if you wish, though.
*/
row_stride = info.dwEffWidth; /* JSAMPLEs per row in image_buffer */
//<DP> "8+row_stride" fix heap deallocation problem during debug???
buffer = (*cinfo.mem->alloc_sarray)
((j_common_ptr) &cinfo, JPOOL_IMAGE, 8+row_stride, 1);
CImageIterator iter(this);
iter.Upset();
while (cinfo.next_scanline < cinfo.image_height) {
// info.nProgress = (long)(100*cinfo.next_scanline/cinfo.image_height);
iter.GetRow(buffer[0], row_stride);
// not necessary if swapped red and blue definition in jmorecfg.h;ln322 <W. Morrison>
if (head.biClrUsed==0){ // swap R & B for RGB images
RGBtoBGR(buffer[0], row_stride); // Lance : 1998/09/01 : Bug ID: EXP-2.1.1-9
}
iter.PrevRow();
(void) jpeg_write_scanlines(&cinfo, buffer, 1);
}
/* Step 6: Finish compression */
jpeg_finish_compress(&cinfo);
/* Step 7: release JPEG compression object */
/* This is an important step since it will release a good deal of memory. */
jpeg_destroy_compress(&cinfo);
/* And we're done! */
return true;
}
gboolean
save_image (const gchar *filename,
gint32 image_ID,
gint32 drawable_ID,
gint32 orig_image_ID,
gboolean preview,
GError **error)
{
GimpImageType drawable_type;
GeglBuffer *buffer = NULL;
const Babl *format;
GimpParasite *parasite;
static struct jpeg_compress_struct cinfo;
static struct my_error_mgr jerr;
JpegSubsampling subsampling;
FILE * volatile outfile;
guchar *data;
guchar *src;
gboolean has_alpha;
gint rowstride, yend;
drawable_type = gimp_drawable_type (drawable_ID);
buffer = gimp_drawable_get_buffer (drawable_ID);
if (! preview)
gimp_progress_init_printf (_("Saving '%s'"),
gimp_filename_to_utf8 (filename));
/* Step 1: allocate and initialize JPEG compression object */
/* We have to set up the error handler first, in case the initialization
* step fails. (Unlikely, but it could happen if you are out of memory.)
* This routine fills in the contents of struct jerr, and returns jerr's
* address which we place into the link field in cinfo.
*/
cinfo.err = jpeg_std_error (&jerr.pub);
jerr.pub.error_exit = my_error_exit;
outfile = NULL;
/* Establish the setjmp return context for my_error_exit to use. */
if (setjmp (jerr.setjmp_buffer))
{
/* If we get here, the JPEG code has signaled an error.
* We need to clean up the JPEG object, close the input file, and return.
*/
jpeg_destroy_compress (&cinfo);
if (outfile)
fclose (outfile);
if (buffer)
g_object_unref (buffer);
return FALSE;
}
/* Now we can initialize the JPEG compression object. */
jpeg_create_compress (&cinfo);
/* Step 2: specify data destination (eg, a file) */
/* Note: steps 2 and 3 can be done in either order. */
/* Here we use the library-supplied code to send compressed data to a
* stdio stream. You can also write your own code to do something else.
* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
* requires it in order to write binary files.
*/
if ((outfile = g_fopen (filename, "wb")) == NULL)
{
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Could not open '%s' for writing: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
return FALSE;
}
jpeg_stdio_dest (&cinfo, outfile);
/* Get the input image and a pointer to its data.
*/
switch (drawable_type)
{
case GIMP_RGB_IMAGE:
/* # of color components per pixel */
cinfo.input_components = 3;
has_alpha = FALSE;
format = babl_format ("R'G'B' u8");
break;
case GIMP_GRAY_IMAGE:
/* # of color components per pixel */
cinfo.input_components = 1;
has_alpha = FALSE;
format = babl_format ("Y' u8");
break;
case GIMP_RGBA_IMAGE:
/* # of color components per pixel (minus the GIMP alpha channel) */
cinfo.input_components = 4 - 1;
has_alpha = TRUE;
format = babl_format ("R'G'B' u8");
break;
case GIMP_GRAYA_IMAGE:
/* # of color components per pixel (minus the GIMP alpha channel) */
cinfo.input_components = 2 - 1;
has_alpha = TRUE;
format = babl_format ("Y' u8");
break;
case GIMP_INDEXED_IMAGE:
default:
return FALSE;
}
/* Step 3: set parameters for compression */
/* First we supply a description of the input image.
* Four fields of the cinfo struct must be filled in:
*/
/* image width and height, in pixels */
cinfo.image_width = gegl_buffer_get_width (buffer);
cinfo.image_height = gegl_buffer_get_height (buffer);
/* colorspace of input image */
cinfo.in_color_space = (drawable_type == GIMP_RGB_IMAGE ||
drawable_type == GIMP_RGBA_IMAGE)
? JCS_RGB : JCS_GRAYSCALE;
/* Now use the library's routine to set default compression parameters.
* (You must set at least cinfo.in_color_space before calling this,
* since the defaults depend on the source color space.)
*/
jpeg_set_defaults (&cinfo);
jpeg_set_quality (&cinfo, (gint) (jsvals.quality + 0.5), jsvals.baseline);
if (jsvals.use_orig_quality && num_quant_tables > 0)
{
guint **quant_tables;
gint t;
/* override tables generated by jpeg_set_quality() with custom tables */
quant_tables = jpeg_restore_original_tables (image_ID, num_quant_tables);
if (quant_tables)
{
for (t = 0; t < num_quant_tables; t++)
{
jpeg_add_quant_table (&cinfo, t, quant_tables[t],
100, jsvals.baseline);
g_free (quant_tables[t]);
}
g_free (quant_tables);
}
}
if (arithc_supported)
{
cinfo.arith_code = jsvals.arithmetic_coding;
if (!jsvals.arithmetic_coding)
cinfo.optimize_coding = jsvals.optimize;
}
else
cinfo.optimize_coding = jsvals.optimize;
subsampling = (gimp_drawable_is_rgb (drawable_ID) ?
jsvals.subsmp : JPEG_SUBSAMPLING_1x1_1x1_1x1);
/* smoothing is not supported with nonstandard sampling ratios */
if (subsampling != JPEG_SUBSAMPLING_2x1_1x1_1x1 &&
subsampling != JPEG_SUBSAMPLING_1x2_1x1_1x1)
{
cinfo.smoothing_factor = (gint) (jsvals.smoothing * 100);
}
if (jsvals.progressive)
{
jpeg_simple_progression (&cinfo);
}
switch (subsampling)
{
case JPEG_SUBSAMPLING_2x2_1x1_1x1:
default:
cinfo.comp_info[0].h_samp_factor = 2;
cinfo.comp_info[0].v_samp_factor = 2;
cinfo.comp_info[1].h_samp_factor = 1;
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1;
cinfo.comp_info[2].v_samp_factor = 1;
break;
case JPEG_SUBSAMPLING_2x1_1x1_1x1:
cinfo.comp_info[0].h_samp_factor = 2;
cinfo.comp_info[0].v_samp_factor = 1;
cinfo.comp_info[1].h_samp_factor = 1;
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1;
cinfo.comp_info[2].v_samp_factor = 1;
break;
case JPEG_SUBSAMPLING_1x1_1x1_1x1:
cinfo.comp_info[0].h_samp_factor = 1;
cinfo.comp_info[0].v_samp_factor = 1;
cinfo.comp_info[1].h_samp_factor = 1;
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1;
cinfo.comp_info[2].v_samp_factor = 1;
break;
case JPEG_SUBSAMPLING_1x2_1x1_1x1:
cinfo.comp_info[0].h_samp_factor = 1;
cinfo.comp_info[0].v_samp_factor = 2;
cinfo.comp_info[1].h_samp_factor = 1;
cinfo.comp_info[1].v_samp_factor = 1;
cinfo.comp_info[2].h_samp_factor = 1;
cinfo.comp_info[2].v_samp_factor = 1;
break;
}
cinfo.restart_interval = 0;
cinfo.restart_in_rows = jsvals.restart;
switch (jsvals.dct)
{
case 0:
default:
cinfo.dct_method = JDCT_ISLOW;
break;
case 1:
cinfo.dct_method = JDCT_IFAST;
break;
case 2:
cinfo.dct_method = JDCT_FLOAT;
break;
}
{
gdouble xresolution;
gdouble yresolution;
gimp_image_get_resolution (orig_image_ID, &xresolution, &yresolution);
if (xresolution > 1e-5 && yresolution > 1e-5)
{
gdouble factor;
factor = gimp_unit_get_factor (gimp_image_get_unit (orig_image_ID));
if (factor == 2.54 /* cm */ ||
factor == 25.4 /* mm */)
{
cinfo.density_unit = 2; /* dots per cm */
xresolution /= 2.54;
yresolution /= 2.54;
}
else
{
cinfo.density_unit = 1; /* dots per inch */
}
cinfo.X_density = xresolution;
cinfo.Y_density = yresolution;
}
}
/* Step 4: Start compressor */
/* TRUE ensures that we will write a complete interchange-JPEG file.
* Pass TRUE unless you are very sure of what you're doing.
*/
jpeg_start_compress (&cinfo, TRUE);
/* Step 4.1: Write the comment out - pw */
if (image_comment && *image_comment)
{
#ifdef GIMP_UNSTABLE
g_print ("jpeg-save: saving image comment (%d bytes)\n",
(int) strlen (image_comment));
#endif
jpeg_write_marker (&cinfo, JPEG_COM,
(guchar *) image_comment, strlen (image_comment));
}
/* Step 4.2: store the color profile if there is one */
parasite = gimp_image_get_parasite (orig_image_ID, "icc-profile");
if (parasite)
{
jpeg_icc_write_profile (&cinfo,
gimp_parasite_data (parasite),
gimp_parasite_data_size (parasite));
gimp_parasite_free (parasite);
}
/* Step 5: while (scan lines remain to be written) */
/* jpeg_write_scanlines(...); */
/* Here we use the library's state variable cinfo.next_scanline as the
* loop counter, so that we don't have to keep track ourselves.
* To keep things simple, we pass one scanline per call; you can pass
* more if you wish, though.
*/
/* JSAMPLEs per row in image_buffer */
rowstride = cinfo.input_components * cinfo.image_width;
data = g_new (guchar, rowstride * gimp_tile_height ());
/* fault if cinfo.next_scanline isn't initially a multiple of
* gimp_tile_height */
src = NULL;
/*
* sg - if we preview, we want this to happen in the background -- do
* not duplicate code in the future; for now, it's OK
*/
if (preview)
{
PreviewPersistent *pp = g_new (PreviewPersistent, 1);
/* pass all the information we need */
pp->cinfo = cinfo;
pp->tile_height = gimp_tile_height();
pp->data = data;
pp->outfile = outfile;
pp->has_alpha = has_alpha;
pp->rowstride = rowstride;
pp->data = data;
pp->buffer = buffer;
pp->format = format;
pp->src = NULL;
pp->file_name = filename;
pp->abort_me = FALSE;
g_warn_if_fail (prev_p == NULL);
prev_p = pp;
pp->cinfo.err = jpeg_std_error(&(pp->jerr));
pp->jerr.error_exit = background_error_exit;
gtk_label_set_text (GTK_LABEL (preview_size),
_("Calculating file size..."));
pp->source_id = g_idle_add ((GSourceFunc) background_jpeg_save, pp);
/* background_jpeg_save() will cleanup as needed */
return TRUE;
}
while (cinfo.next_scanline < cinfo.image_height)
{
if ((cinfo.next_scanline % gimp_tile_height ()) == 0)
{
yend = cinfo.next_scanline + gimp_tile_height ();
yend = MIN (yend, cinfo.image_height);
gegl_buffer_get (buffer,
GEGL_RECTANGLE (0, cinfo.next_scanline,
cinfo.image_width,
(yend - cinfo.next_scanline)),
1.0,
format,
data,
GEGL_AUTO_ROWSTRIDE,
GEGL_ABYSS_NONE);
src = data;
}
jpeg_write_scanlines (&cinfo, (JSAMPARRAY) &src, 1);
src += rowstride;
if ((cinfo.next_scanline % 32) == 0)
gimp_progress_update ((gdouble) cinfo.next_scanline /
(gdouble) cinfo.image_height);
}
/* Step 6: Finish compression */
jpeg_finish_compress (&cinfo);
/* After finish_compress, we can close the output file. */
fclose (outfile);
/* Step 7: release JPEG compression object */
/* This is an important step since it will release a good deal of memory. */
jpeg_destroy_compress (&cinfo);
/* free the temporary buffer */
g_free (data);
/* And we're done! */
gimp_progress_update (1.0);
g_object_unref (buffer);
return TRUE;
}
