int dt_imageio_jpeg_write_with_icc_profile(const char *filename, const uint8_t *in, const int width,
const int height, const int quality, const void *exif, int exif_len,
int imgid)
{
struct dt_imageio_jpeg_error_mgr jerr;
dt_imageio_jpeg_t jpg;
jpg.cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = dt_imageio_jpeg_error_exit;
if(setjmp(jerr.setjmp_buffer))
{
jpeg_destroy_compress(&(jpg.cinfo));
return 1;
}
jpeg_create_compress(&(jpg.cinfo));
FILE *f = fopen(filename, "wb");
if(!f) return 1;
jpeg_stdio_dest(&(jpg.cinfo), f);
jpg.cinfo.image_width = width;
jpg.cinfo.image_height = height;
jpg.cinfo.input_components = 3;
jpg.cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&(jpg.cinfo));
jpeg_set_quality(&(jpg.cinfo), quality, TRUE);
if(quality > 90) jpg.cinfo.comp_info[0].v_samp_factor = 1;
if(quality > 92) jpg.cinfo.comp_info[0].h_samp_factor = 1;
jpeg_start_compress(&(jpg.cinfo), TRUE);
if(imgid > 0)
{
cmsHPROFILE out_profile = dt_colorspaces_get_output_profile(imgid)->profile;
uint32_t len = 0;
cmsSaveProfileToMem(out_profile, 0, &len);
if(len > 0)
{
unsigned char buf[len];
cmsSaveProfileToMem(out_profile, buf, &len);
write_icc_profile(&(jpg.cinfo), buf, len);
}
}
if(exif && exif_len > 0 && exif_len < 65534) jpeg_write_marker(&(jpg.cinfo), JPEG_APP0 + 1, exif, exif_len);
uint8_t row[3 * width];
const uint8_t *buf;
while(jpg.cinfo.next_scanline < jpg.cinfo.image_height)
{
JSAMPROW tmp[1];
buf = in + jpg.cinfo.next_scanline * jpg.cinfo.image_width * 4;
for(int i = 0; i < width; i++)
for(int k = 0; k < 3; k++) row[3 * i + k] = buf[4 * i + k];
tmp[0] = row;
jpeg_write_scanlines(&(jpg.cinfo), tmp, 1);
}
jpeg_finish_compress(&(jpg.cinfo));
jpeg_destroy_compress(&(jpg.cinfo));
fclose(f);
return 0;
}
static
void DoEmbedProfile(const char* ProfileFile)
{
FILE* f;
size_t size, EmbedLen;
cmsUInt8Number* EmbedBuffer;
f = fopen(ProfileFile, "rb");
if (f == NULL) return;
size = cmsfilelength(f);
EmbedBuffer = (cmsUInt8Number*) malloc(size + 1);
EmbedLen = fread(EmbedBuffer, 1, size, f);
fclose(f);
EmbedBuffer[EmbedLen] = 0;
write_icc_profile (&Compressor, EmbedBuffer, EmbedLen);
free(EmbedBuffer);
}
int write_image(dt_imageio_module_data_t *jpg_tmp, const char *filename, const void *in_tmp, void *exif,
int exif_len, int imgid)
{
dt_imageio_jpeg_t *jpg = (dt_imageio_jpeg_t *)jpg_tmp;
const uint8_t *in = (const uint8_t *)in_tmp;
struct dt_imageio_jpeg_error_mgr jerr;
jpg->cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = dt_imageio_jpeg_error_exit;
if(setjmp(jerr.setjmp_buffer))
{
jpeg_destroy_compress(&(jpg->cinfo));
return 1;
}
jpeg_create_compress(&(jpg->cinfo));
FILE *f = fopen(filename, "wb");
if(!f) return 1;
jpeg_stdio_dest(&(jpg->cinfo), f);
jpg->cinfo.image_width = jpg->width;
jpg->cinfo.image_height = jpg->height;
jpg->cinfo.input_components = 3;
jpg->cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&(jpg->cinfo));
jpeg_set_quality(&(jpg->cinfo), jpg->quality, TRUE);
if(jpg->quality > 90) jpg->cinfo.comp_info[0].v_samp_factor = 1;
if(jpg->quality > 92) jpg->cinfo.comp_info[0].h_samp_factor = 1;
if(jpg->quality > 95) jpg->cinfo.dct_method = JDCT_FLOAT;
if(jpg->quality < 50) jpg->cinfo.dct_method = JDCT_IFAST;
if(jpg->quality < 80) jpg->cinfo.smoothing_factor = 20;
if(jpg->quality < 60) jpg->cinfo.smoothing_factor = 40;
if(jpg->quality < 40) jpg->cinfo.smoothing_factor = 60;
jpg->cinfo.optimize_coding = 1;
// according to specs density_unit = 0, X_density = 1, Y_density = 1 should be fine and valid since it
// describes an image with unknown unit and square pixels.
// however, some applications (like the Telekom cloud thingy) seem to be confused by that, so let's set
// these calues to the same as stored in exiv :/
int resolution = dt_conf_get_int("metadata/resolution");
if(resolution > 0)
{
jpg->cinfo.density_unit = 1;
jpg->cinfo.X_density = resolution;
jpg->cinfo.Y_density = resolution;
}
else
{
jpg->cinfo.density_unit = 0;
jpg->cinfo.X_density = 1;
jpg->cinfo.Y_density = 1;
}
jpeg_start_compress(&(jpg->cinfo), TRUE);
if(imgid > 0)
{
cmsHPROFILE out_profile = dt_colorspaces_create_output_profile(imgid);
uint32_t len = 0;
cmsSaveProfileToMem(out_profile, 0, &len);
if(len > 0)
{
unsigned char buf[len];
cmsSaveProfileToMem(out_profile, buf, &len);
write_icc_profile(&(jpg->cinfo), buf, len);
}
dt_colorspaces_cleanup_profile(out_profile);
}
if(exif && exif_len > 0 && exif_len < 65534)
jpeg_write_marker(&(jpg->cinfo), JPEG_APP0 + 1, exif, exif_len);
uint8_t row[3 * jpg->width];
const uint8_t *buf;
while(jpg->cinfo.next_scanline < jpg->cinfo.image_height)
{
JSAMPROW tmp[1];
buf = in + (size_t)jpg->cinfo.next_scanline * jpg->cinfo.image_width * 4;
for(int i = 0; i < jpg->width; i++)
for(int k = 0; k < 3; k++) row[3 * i + k] = buf[4 * i + k];
tmp[0] = row;
jpeg_write_scanlines(&(jpg->cinfo), tmp, 1);
}
jpeg_finish_compress(&(jpg->cinfo));
jpeg_destroy_compress(&(jpg->cinfo));
fclose(f);
return 0;
}
int
write_image (dt_imageio_module_data_t *jpg_tmp, const char *filename, const void *in_tmp, void *exif, int exif_len, int imgid)
{
dt_imageio_jpeg_t *jpg = (dt_imageio_jpeg_t*)jpg_tmp;
const uint8_t*in =(const uint8_t*)in_tmp;
struct dt_imageio_jpeg_error_mgr jerr;
jpg->cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = dt_imageio_jpeg_error_exit;
if (setjmp(jerr.setjmp_buffer))
{
jpeg_destroy_compress(&(jpg->cinfo));
return 1;
}
jpeg_create_compress(&(jpg->cinfo));
FILE *f = fopen(filename, "wb");
if(!f) return 1;
jpeg_stdio_dest(&(jpg->cinfo), f);
jpg->cinfo.image_width = jpg->width;
jpg->cinfo.image_height = jpg->height;
jpg->cinfo.input_components = 3;
jpg->cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&(jpg->cinfo));
jpeg_set_quality(&(jpg->cinfo), jpg->quality, TRUE);
if(jpg->quality > 90) jpg->cinfo.comp_info[0].v_samp_factor = 1;
if(jpg->quality > 92) jpg->cinfo.comp_info[0].h_samp_factor = 1;
if(jpg->quality > 95) jpg->cinfo.dct_method = JDCT_FLOAT;
if(jpg->quality < 50) jpg->cinfo.dct_method = JDCT_IFAST;
if(jpg->quality < 80) jpg->cinfo.smoothing_factor = 20;
if(jpg->quality < 60) jpg->cinfo.smoothing_factor = 40;
if(jpg->quality < 40) jpg->cinfo.smoothing_factor = 60;
jpg->cinfo.optimize_coding = 1;
jpeg_start_compress(&(jpg->cinfo), TRUE);
if(imgid > 0)
{
cmsHPROFILE out_profile = dt_colorspaces_create_output_profile(imgid);
uint32_t len = 0;
cmsSaveProfileToMem(out_profile, 0, &len);
if (len > 0)
{
unsigned char buf[len];
cmsSaveProfileToMem(out_profile, buf, &len);
write_icc_profile(&(jpg->cinfo), buf, len);
}
dt_colorspaces_cleanup_profile(out_profile);
}
if(exif && exif_len > 0 && exif_len < 65534)
jpeg_write_marker(&(jpg->cinfo), JPEG_APP0+1, exif, exif_len);
uint8_t row[3*jpg->width];
const uint8_t *buf;
while(jpg->cinfo.next_scanline < jpg->cinfo.image_height)
{
JSAMPROW tmp[1];
buf = in + (size_t)jpg->cinfo.next_scanline * jpg->cinfo.image_width * 4;
for(int i=0; i<jpg->width; i++) for(int k=0; k<3; k++) row[3*i+k] = buf[4*i+k];
tmp[0] = row;
jpeg_write_scanlines(&(jpg->cinfo), tmp, 1);
}
jpeg_finish_compress (&(jpg->cinfo));
jpeg_destroy_compress(&(jpg->cinfo));
fclose(f);
return 0;
}
bool KPWriteImage::write2JPEG(const QString& destPath)
{
FILE* file = fopen(QFile::encodeName(destPath), "wb");
if (!file)
{
kDebug( 51000 ) << "Failed to open JPEG file for writing" << endl;
return false;
}
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
// Init JPEG compressor.
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
jpeg_stdio_dest(&cinfo, file);
cinfo.image_width = d->width;
cinfo.image_height = d->height;
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&cinfo);
// B.K.O #149578: set encoder horizontal and vertical chroma subsampling
// factor to 2x1, 1x1, 1x1 (4:2:2) : Medium subsampling.
// See this page for details: http://en.wikipedia.org/wiki/Chroma_subsampling
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;
// B.K.O #154273: use 99 compresion level instead 100 to reduce output JPEG file size.
jpeg_set_quality(&cinfo, 99, true);
jpeg_start_compress(&cinfo, true);
// Write ICC color profile.
if (!d->iccProfile.isEmpty())
write_icc_profile (&cinfo, (JOCTET *)d->iccProfile.data(), d->iccProfile.size());
// Write image data
uchar* line = new uchar[d->width*3];
uchar* dstPtr = 0;
if (!d->sixteenBit) // 8 bits image.
{
uchar* srcPtr = (uchar*)d->data.data();
for (uint j=0; j < d->height; j++)
{
if (cancel())
{
delete [] line;
jpeg_destroy_compress(&cinfo);
fclose(file);
return false;
}
dstPtr = line;
for (uint i = 0; i < d->width; i++)
{
dstPtr[2] = srcPtr[0]; // Blue
dstPtr[1] = srcPtr[1]; // Green
dstPtr[0] = srcPtr[2]; // Red
d->hasAlpha ? srcPtr += 4 : srcPtr += 3;
dstPtr += 3;
}
jpeg_write_scanlines(&cinfo, &line, 1);
}
}
else // 16 bits image
{
unsigned short* srcPtr = (unsigned short*)d->data.data();
for (uint j=0; j < d->height; j++)
{
if (cancel())
{
delete [] line;
jpeg_destroy_compress(&cinfo);
fclose(file);
return false;
}
dstPtr = line;
for (uint i = 0; i < d->width; i++)
{
dstPtr[2] = (srcPtr[0] * 255UL)/65535UL; // Blue
dstPtr[1] = (srcPtr[1] * 255UL)/65535UL; // Green
dstPtr[0] = (srcPtr[2] * 255UL)/65535UL; // Red
d->hasAlpha ? srcPtr += 4 : srcPtr += 3;
dstPtr += 3;
}
jpeg_write_scanlines(&cinfo, &line, 1);
}
}
delete [] line;
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
fclose(file);
d->metadata.save(destPath);
return true;
}
static gint
save_image (char *filename,
gint32 image_ID,
gint32 drawable_ID)
{
GPixelRgn pixel_rgn;
TileDrawable *drawable;
GDrawableType drawable_type;
struct jpeg_compress_struct cinfo;
struct my_error_mgr jerr;
FILE *outfile;
guchar *temp, *t;
guchar *data;
guchar *src, *s;
char *name;
int has_alpha;
GimpExportReturnType export = GIMP_EXPORT_CANCEL;
gint32 e_image_ID = -1;
gint32 e_drawable_ID = -1;
GPrecisionType precision;
int rowstride, yend;
int i, j;
drawable = gimp_drawable_get (drawable_ID);
drawable_type = gimp_drawable_type (drawable_ID);
gimp_pixel_rgn_init (&pixel_rgn, drawable, 0, 0, drawable->width, drawable->height, FALSE, FALSE);
name = malloc (strlen (filename) + 11);
sprintf (name, "%s %s:",_("Saving"), filename);
gimp_progress_init (name);
free (name);
/* 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 (drawable)
gimp_drawable_detach (drawable);
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 = fopen (filename, "wb")) == NULL)
{
fprintf (stderr, "can't open %s\n", filename);
return FALSE;
}
jpeg_stdio_dest (&cinfo, outfile);
/* Get the input image and a pointer to its data.
*/
cinfo.input_components = gimp_drawable_num_channels(drawable_ID);
has_alpha = gimp_drawable_has_alpha(drawable_ID);
if(has_alpha)
--cinfo.input_components;
/* 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 = drawable->width;
cinfo.image_height = drawable->height;
/* colorspace of input image */
cinfo.in_color_space = gimp_drawable_color(drawable_ID)
? 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);
/* 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, (int) (jsvals.quality * 100), TRUE /* limit to baseline-JPEG values */);
cinfo.smoothing_factor = (int) (jsvals.smoothing * 100);
cinfo.optimize_coding = jsvals.optimize;
/* 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 4a: write icc profile
{
char *buffer = NULL;
int size = 0;
if (gimp_image_has_icc_profile (image_ID, ICC_IMAGE_PROFILE)) {
buffer = gimp_image_get_icc_profile_by_mem (image_ID, &size, ICC_IMAGE_PROFILE);
if (buffer) {
write_icc_profile (&cinfo, buffer, size);
printf ("%s:%d %s() embedded icc profile\n",__FILE__,__LINE__,__func__);
}
}
}
/* 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 = drawable->bpp * drawable->width;
temp = (guchar *) malloc (cinfo.image_width * cinfo.input_components * 4);
data = (guchar *) malloc (rowstride * gimp_tile_height ());
export = gimp_export_image (&image_ID, &drawable_ID, "Jpeg",
bool write(const pfs::Frame &frame, const JpegWriterParams& params,
const std::string& filename)
{
cmsUInt32Number cmsProfileSize = 0;
utils::ScopedCmsProfile hsRGB( cmsCreate_sRGBProfile() );
cmsSaveProfileToMem(hsRGB.data(), NULL, &cmsProfileSize); // get the size
std::vector<JOCTET> cmsOutputProfile(cmsProfileSize);
cmsSaveProfileToMem(hsRGB.data(), cmsOutputProfile.data(), &cmsProfileSize);
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr errorHandler;
jpeg_create_compress(&cinfo);
cinfo.err = jpeg_std_error(&errorHandler);
errorHandler.error_exit = my_writer_error_handler;
errorHandler.output_message = my_writer_output_message;
cinfo.image_width = frame.getWidth(); // image width and height, in pixels
cinfo.image_height = frame.getHeight();
cinfo.input_components = cinfo.num_components = 3; // # of color components per pixel
cinfo.in_color_space = JCS_RGB; // colorspace of input image
cinfo.jpeg_color_space = JCS_YCbCr;
cinfo.density_unit = 1; // dots/inch
cinfo.X_density = cinfo.Y_density = 72;
jpeg_set_defaults(&cinfo);
jpeg_set_colorspace(&cinfo, JCS_YCbCr);
// avoid subsampling on high quality factor
jpeg_set_quality(&cinfo, params.quality_, 1);
if ( params.quality_ >= 70 ) {
for (int i = 0; i < cinfo.num_components; i++) {
cinfo.comp_info[i].h_samp_factor = 1;
cinfo.comp_info[i].v_samp_factor = 1;
}
}
try
{
setupJpegDest(&cinfo, filename);
jpeg_start_compress(&cinfo, true);
const Channel* rChannel;
const Channel* gChannel;
const Channel* bChannel;
frame.getXYZChannels(rChannel, gChannel, bChannel);
write_icc_profile(&cinfo, cmsOutputProfile.data(), cmsProfileSize);
// If an exception is raised, this buffer gets automatically destructed!
std::vector<JSAMPLE> scanLineOut(cinfo.image_width * cinfo.num_components);
JSAMPROW scanLineOutArray[1] = { scanLineOut.data() };
while (cinfo.next_scanline < cinfo.image_height)
{
// copy line from Frame into scanLineOut
utils::transform(
rChannel->row_begin(cinfo.next_scanline),
rChannel->row_end(cinfo.next_scanline),
gChannel->row_begin(cinfo.next_scanline),
bChannel->row_begin(cinfo.next_scanline),
FixedStrideIterator<JSAMPLE*, 3>(scanLineOut.data()),
FixedStrideIterator<JSAMPLE*, 3>(scanLineOut.data() + 1),
FixedStrideIterator<JSAMPLE*, 3>(scanLineOut.data() + 2),
utils::chain(
colorspace::Normalizer(params.minLuminance_, params.maxLuminance_),
utils::CLAMP_F32,
Remapper<JSAMPLE>(params.luminanceMapping_)
)
);
jpeg_write_scanlines(&cinfo, scanLineOutArray, 1);
}
}
catch (const std::runtime_error& err)
{
std::clog << err.what() << std::endl;
jpeg_destroy_compress(&cinfo);
return false;
}
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
close();
return true;
}
