% July 1992 %
% %
% %
-% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "MagickCore/static.h"
#include "MagickCore/string_.h"
#include "MagickCore/string-private.h"
+#include "MagickCore/token.h"
#include "MagickCore/utility.h"
+#include "MagickCore/xml-tree.h"
+#include "MagickCore/xml-tree-private.h"
#include <setjmp.h>
#if defined(MAGICKCORE_JPEG_DELEGATE)
#define JPEG_INTERNAL_OPTIONS
#if defined(__MINGW32__)
# define XMD_H 1 /* Avoid conflicting typedef for INT32 */
-typedef unsigned char boolean;
-#define HAVE_BOOLEAN
#endif
#undef HAVE_STDLIB_H
#include "jpeglib.h"
#define ICC_PROFILE "ICC_PROFILE"
#define IPTC_MARKER (JPEG_APP0+13)
#define XML_MARKER (JPEG_APP0+1)
-#define MaxBufferExtent 8192
+#define MaxBufferExtent 16384
\f
/*
Typedef declarations.
start_of_blob;
} SourceManager;
#endif
+
+typedef struct _QuantizationTable
+{
+ char
+ *slot,
+ *description;
+
+ size_t
+ width,
+ height;
+
+ double
+ divisor;
+
+ unsigned int
+ *levels;
+} QuantizationTable;
\f
/*
Forward declarations.
MaxBufferExtent,source->buffer);
if (source->manager.bytes_in_buffer == 0)
{
- if (source->start_of_blob != 0)
+ if (source->start_of_blob != FALSE)
ERREXIT(cinfo,JERR_INPUT_EMPTY);
WARNMS(cinfo,JWRN_JPEG_EOF);
source->buffer[0]=(JOCTET) 0xff;
return(MagickFalse);
}
-static MagickBooleanType JPEGErrorHandler(j_common_ptr jpeg_info)
+static void JPEGErrorHandler(j_common_ptr jpeg_info)
{
char
message[JMSG_LENGTH_MAX];
ErrorManager
*error_manager;
+ ExceptionInfo
+ *exception;
+
Image
*image;
*message='\0';
error_manager=(ErrorManager *) jpeg_info->client_data;
image=error_manager->image;
+ exception=error_manager->exception;
(jpeg_info->err->format_message)(jpeg_info,message);
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"[%s] JPEG Trace: \"%s\"",image->filename,message);
if (error_manager->finished != MagickFalse)
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- CorruptImageWarning,(char *) message,"`%s'",image->filename);
+ (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageWarning,
+ (char *) message,"`%s'",image->filename);
else
- (void) ThrowMagickException(&image->exception,GetMagickModule(),
- CorruptImageError,(char *) message,"`%s'",image->filename);
+ (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
+ (char *) message,"`%s'",image->filename);
longjmp(error_manager->error_recovery,1);
}
static MagickBooleanType JPEGWarningHandler(j_common_ptr jpeg_info,int level)
{
+#define JPEGExcessiveWarnings 1000
+
char
message[JMSG_LENGTH_MAX];
Process warning message.
*/
(jpeg_info->err->format_message)(jpeg_info,message);
- if ((jpeg_info->err->num_warnings == 0) ||
- (jpeg_info->err->trace_level >= 3))
- ThrowBinaryException(CorruptImageWarning,(char *) message,
- image->filename);
- jpeg_info->err->num_warnings++;
+ if (jpeg_info->err->num_warnings++ > JPEGExcessiveWarnings)
+ JPEGErrorHandler(jpeg_info);
+ ThrowBinaryException(CorruptImageWarning,(char *) message,
+ image->filename);
}
else
if ((image->debug != MagickFalse) &&
for (p=comment; i-- >= 0; p++)
*p=(char) GetCharacter(jpeg_info);
*p='\0';
- (void) SetImageProperty(image,"comment",comment);
+ (void) SetImageProperty(image,"comment",comment,exception);
comment=DestroyString(comment);
return(MagickTrue);
}
}
else
{
- status=SetImageProfile(image,"icc",profile);
+ status=SetImageProfile(image,"icc",profile,exception);
profile=DestroyStringInfo(profile);
if (status == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
}
else
{
- status=SetImageProfile(image,"8bim",profile);
+ status=SetImageProfile(image,"8bim",profile,exception);
profile=DestroyStringInfo(profile);
if (status == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
previous_profile=GetImageProfile(image,name);
if (previous_profile != (const StringInfo *) NULL)
{
- ssize_t
+ size_t
length;
length=GetStringInfoLength(profile);
GetStringInfoDatum(previous_profile),
GetStringInfoLength(previous_profile));
}
- status=SetImageProfile(image,name,profile);
+ status=SetImageProfile(image,name,profile,exception);
profile=DestroyStringInfo(profile);
if (status == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
static void TerminateSource(j_decompress_ptr cinfo)
{
- cinfo=cinfo;
+ (void) cinfo;
}
static void JPEGSourceManager(j_decompress_ptr cinfo,Image *image)
}
}
-static void JPEGSetImageSamplingFactor(struct jpeg_decompress_struct *jpeg_info, Image *image)
+static void JPEGSetImageSamplingFactor(struct jpeg_decompress_struct *jpeg_info, Image *image,ExceptionInfo *exception)
{
char
sampling_factor[MaxTextExtent];
break;
}
}
- (void) SetImageProperty(image,"jpeg:sampling-factor",sampling_factor);
+ (void) SetImageProperty(image,"jpeg:sampling-factor",sampling_factor,
+ exception);
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"Sampling Factors: %s",
sampling_factor);
}
assert(exception->signature == MagickSignature);
debug=IsEventLogging();
(void) debug;
- image=AcquireImage(image_info);
+ image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
number_pixels=(MagickSizeType) image->columns*image->rows;
if (number_pixels != 0)
return(GetFirstImageInList(image));
- InheritException(exception,&image->exception);
return(DestroyImage(image));
}
jpeg_info.client_data=(void *) &error_manager;
(image_info->colorspace == Rec601YCbCrColorspace) ||
(image_info->colorspace == Rec709YCbCrColorspace))
jpeg_info.out_color_space=JCS_YCbCr;
- if (IsITUFaxImage(image) != MagickFalse)
- {
- image->colorspace=LabColorspace;
- jpeg_info.out_color_space=JCS_YCbCr;
- }
- else
- if (jpeg_info.out_color_space == JCS_CMYK)
- image->colorspace=CMYKColorspace;
/*
Set image resolution.
*/
if ((jpeg_info.saw_JFIF_marker != 0) && (jpeg_info.X_density != 1) &&
(jpeg_info.Y_density != 1))
{
- image->x_resolution=(double) jpeg_info.X_density;
- image->y_resolution=(double) jpeg_info.Y_density;
+ image->resolution.x=(double) jpeg_info.X_density;
+ image->resolution.y=(double) jpeg_info.Y_density;
units=(size_t) jpeg_info.density_unit;
}
if (units == 1)
image->compression=JPEGCompression;
image->interlace=JPEGInterlace;
#endif
- if ((image_info->colors > 8) && (image_info->colors <= 256))
+ option=GetImageOption(image_info,"jpeg:colors");
+ if (option != (const char *) NULL)
{
/*
- Let the JPEG library quantize for us.
+ Let the JPEG library quantize the image.
*/
jpeg_info.quantize_colors=MagickTrue;
- jpeg_info.desired_number_of_colors=(int) image_info->colors;
+ jpeg_info.desired_number_of_colors=(int) StringToUnsignedLong(option);
}
option=GetImageOption(image_info,"jpeg:block-smoothing");
- if (option != (const char *) NULL)
- {
- jpeg_info.do_block_smoothing=MagickFalse;
- if (IsMagickTrue(option) != MagickFalse)
- jpeg_info.do_block_smoothing=MagickTrue;
- }
+ jpeg_info.do_block_smoothing=IsStringTrue(option);
+ jpeg_info.dct_method=JDCT_FLOAT;
option=GetImageOption(image_info,"jpeg:dct-method");
if (option != (const char *) NULL)
switch (*option)
}
}
option=GetImageOption(image_info,"jpeg:fancy-upsampling");
- if (option != (const char *) NULL)
- {
- jpeg_info.do_fancy_upsampling=MagickFalse;
- if (IsMagickTrue(option) != MagickFalse)
- jpeg_info.do_fancy_upsampling=MagickTrue;
- }
+ jpeg_info.do_fancy_upsampling=IsStringTrue(option);
(void) jpeg_start_decompress(&jpeg_info);
image->columns=jpeg_info.output_width;
image->rows=jpeg_info.output_height;
image->depth=(size_t) jpeg_info.data_precision;
- if (jpeg_info.out_color_space == JCS_YCbCr)
- image->colorspace=YCbCrColorspace;
- if (jpeg_info.out_color_space == JCS_CMYK)
- image->colorspace=CMYKColorspace;
- if ((image_info->colors != 0) && (image_info->colors <= 256))
- if (AcquireImageColormap(image,image_info->colors,exception) == MagickFalse)
+ switch (jpeg_info.out_color_space)
+ {
+ case JCS_RGB:
+ default:
+ {
+ SetImageColorspace(image,sRGBColorspace,exception);
+ break;
+ }
+ case JCS_GRAYSCALE:
+ {
+ SetImageColorspace(image,GRAYColorspace,exception);
+ break;
+ }
+ case JCS_YCbCr:
+ {
+ SetImageColorspace(image,YCbCrColorspace,exception);
+ break;
+ }
+ case JCS_CMYK:
+ {
+ SetImageColorspace(image,CMYKColorspace,exception);
+ break;
+ }
+ }
+ if (IsITUFaxImage(image) != MagickFalse)
+ {
+ SetImageColorspace(image,LabColorspace,exception);
+ jpeg_info.out_color_space=JCS_YCbCr;
+ }
+ option=GetImageOption(image_info,"jpeg:colors");
+ if (option != (const char *) NULL)
+ if (AcquireImageColormap(image,StringToUnsignedLong(option),exception)
+ == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if ((jpeg_info.output_components == 1) &&
(jpeg_info.quantize_colors == MagickFalse))
(int) jpeg_info.output_width,(int) jpeg_info.output_height);
}
JPEGSetImageQuality(&jpeg_info,image);
- JPEGSetImageSamplingFactor(&jpeg_info,image);
+ JPEGSetImageSamplingFactor(&jpeg_info,image,exception);
(void) FormatLocaleString(value,MaxTextExtent,"%.20g",(double)
jpeg_info.out_color_space);
- (void) SetImageProperty(image,"jpeg:colorspace",value);
+ (void) SetImageProperty(image,"jpeg:colorspace",value,exception);
if (image_info->ping != MagickFalse)
{
jpeg_destroy_decompress(&jpeg_info);
if (jpeg_info.out_color_space == JCS_GRAYSCALE)
for (i=0; i < (ssize_t) image->colors; i++)
{
- image->colormap[i].red=ScaleCharToQuantum(jpeg_info.colormap[0][i]);
+ image->colormap[i].red=(double) ScaleCharToQuantum(
+ jpeg_info.colormap[0][i]);
image->colormap[i].green=image->colormap[i].red;
image->colormap[i].blue=image->colormap[i].red;
image->colormap[i].alpha=OpaqueAlpha;
else
for (i=0; i < (ssize_t) image->colors; i++)
{
- image->colormap[i].red=ScaleCharToQuantum(jpeg_info.colormap[0][i]);
- image->colormap[i].green=ScaleCharToQuantum(jpeg_info.colormap[1][i]);
- image->colormap[i].blue=ScaleCharToQuantum(jpeg_info.colormap[2][i]);
+ image->colormap[i].red=(double) ScaleCharToQuantum(
+ jpeg_info.colormap[0][i]);
+ image->colormap[i].green=(double) ScaleCharToQuantum(
+ jpeg_info.colormap[1][i]);
+ image->colormap[i].blue=(double) ScaleCharToQuantum(
+ jpeg_info.colormap[2][i]);
image->colormap[i].alpha=OpaqueAlpha;
}
}
pixel=(size_t) GETJSAMPLE(*p);
else
pixel=(size_t) ((GETJSAMPLE(*p) ^ 0x80) << 4);
- index=ConstrainColormapIndex(image,pixel);
+ index=ConstrainColormapIndex(image,pixel,exception);
SetPixelIndex(image,index,q);
- SetPixelPacket(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
p++;
q+=GetPixelChannels(image);
}
if (jpeg_info.output_components == 1)
for (x=0; x < (ssize_t) image->columns; x++)
{
- index=ConstrainColormapIndex(image,(size_t) GETJSAMPLE(*p));
+ index=ConstrainColormapIndex(image,(size_t) GETJSAMPLE(*p),exception);
SetPixelIndex(image,index,q);
- SetPixelPacket(image,image->colormap+(ssize_t) index,q);
+ SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
p++;
q+=GetPixelChannels(image);
}
%
*/
+static QuantizationTable *DestroyQuantizationTable(QuantizationTable *table)
+{
+ assert(table != (QuantizationTable *) NULL);
+ if (table->slot != (char *) NULL)
+ table->slot=DestroyString(table->slot);
+ if (table->description != (char *) NULL)
+ table->description=DestroyString(table->description);
+ if (table->levels != (unsigned int *) NULL)
+ table->levels=(unsigned int *) RelinquishMagickMemory(table->levels);
+ table=(QuantizationTable *) RelinquishMagickMemory(table);
+ return(table);
+}
+
static boolean EmptyOutputBuffer(j_compress_ptr cinfo)
{
DestinationManager
return(TRUE);
}
+static QuantizationTable *GetQuantizationTable(const char *filename,
+ const char *slot,ExceptionInfo *exception)
+{
+ char
+ *p,
+ *xml;
+
+ const char
+ *attribute,
+ *content;
+
+ double
+ value;
+
+ register ssize_t
+ i;
+
+ ssize_t
+ j;
+
+ QuantizationTable
+ *table;
+
+ size_t
+ length;
+
+ XMLTreeInfo
+ *description,
+ *levels,
+ *quantization_tables,
+ *table_iterator;
+
+ (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),
+ "Loading quantization tables \"%s\" ...",filename);
+ table=(QuantizationTable *) NULL;
+ xml=FileToString(filename,~0,exception);
+ if (xml == (char *) NULL)
+ return(table);
+ quantization_tables=NewXMLTree(xml,exception);
+ if (quantization_tables == (XMLTreeInfo *) NULL)
+ {
+ xml=DestroyString(xml);
+ return(table);
+ }
+ for (table_iterator=GetXMLTreeChild(quantization_tables,"table");
+ table_iterator != (XMLTreeInfo *) NULL;
+ table_iterator=GetNextXMLTreeTag(table_iterator))
+ {
+ attribute=GetXMLTreeAttribute(table_iterator,"slot");
+ if ((attribute != (char *) NULL) && (LocaleCompare(slot,attribute) == 0))
+ break;
+ attribute=GetXMLTreeAttribute(table_iterator,"alias");
+ if ((attribute != (char *) NULL) && (LocaleCompare(slot,attribute) == 0))
+ break;
+ }
+ if (table_iterator == (XMLTreeInfo *) NULL)
+ {
+ xml=DestroyString(xml);
+ return(table);
+ }
+ description=GetXMLTreeChild(table_iterator,"description");
+ if (description == (XMLTreeInfo *) NULL)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "XmlMissingElement", "<description>, slot \"%s\"",slot);
+ quantization_tables=DestroyXMLTree(quantization_tables);
+ xml=DestroyString(xml);
+ return(table);
+ }
+ levels=GetXMLTreeChild(table_iterator,"levels");
+ if (levels == (XMLTreeInfo *) NULL)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "XmlMissingElement", "<levels>, slot \"%s\"", slot);
+ quantization_tables=DestroyXMLTree(quantization_tables);
+ xml=DestroyString(xml);
+ return(table);
+ }
+ table=(QuantizationTable *) AcquireMagickMemory(sizeof(*table));
+ if (table == (QuantizationTable *) NULL)
+ ThrowFatalException(ResourceLimitFatalError,
+ "UnableToAcquireQuantizationTable");
+ table->slot=(char *) NULL;
+ table->description=(char *) NULL;
+ table->levels=(unsigned int *) NULL;
+ attribute=GetXMLTreeAttribute(table_iterator,"slot");
+ if (attribute != (char *) NULL)
+ table->slot=ConstantString(attribute);
+ content=GetXMLTreeContent(description);
+ if (content != (char *) NULL)
+ table->description=ConstantString(content);
+ attribute=GetXMLTreeAttribute(levels,"width");
+ if (attribute == (char *) NULL)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "XmlMissingAttribute", "<levels width>, slot \"%s\"",slot);
+ quantization_tables=DestroyXMLTree(quantization_tables);
+ table=DestroyQuantizationTable(table);
+ xml=DestroyString(xml);
+ return(table);
+ }
+ table->width=StringToUnsignedLong(attribute);
+ if (table->width == 0)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "XmlInvalidAttribute", "<levels width>, table \"%s\"",slot);
+ quantization_tables=DestroyXMLTree(quantization_tables);
+ table=DestroyQuantizationTable(table);
+ xml=DestroyString(xml);
+ return(table);
+ }
+ attribute=GetXMLTreeAttribute(levels,"height");
+ if (attribute == (char *) NULL)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "XmlMissingAttribute", "<levels height>, table \"%s\"",slot);
+ quantization_tables=DestroyXMLTree(quantization_tables);
+ table=DestroyQuantizationTable(table);
+ xml=DestroyString(xml);
+ return(table);
+ }
+ table->height=StringToUnsignedLong(attribute);
+ if (table->height == 0)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "XmlInvalidAttribute", "<levels height>, table \"%s\"",slot);
+ quantization_tables=DestroyXMLTree(quantization_tables);
+ table=DestroyQuantizationTable(table);
+ xml=DestroyString(xml);
+ return(table);
+ }
+ attribute=GetXMLTreeAttribute(levels,"divisor");
+ if (attribute == (char *) NULL)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "XmlMissingAttribute", "<levels divisor>, table \"%s\"",slot);
+ quantization_tables=DestroyXMLTree(quantization_tables);
+ table=DestroyQuantizationTable(table);
+ xml=DestroyString(xml);
+ return(table);
+ }
+ table->divisor=InterpretLocaleValue(attribute,(char **) NULL);
+ if (table->divisor == 0.0)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "XmlInvalidAttribute", "<levels divisor>, table \"%s\"",slot);
+ quantization_tables=DestroyXMLTree(quantization_tables);
+ table=DestroyQuantizationTable(table);
+ xml=DestroyString(xml);
+ return(table);
+ }
+ content=GetXMLTreeContent(levels);
+ if (content == (char *) NULL)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "XmlMissingContent", "<levels>, table \"%s\"",slot);
+ quantization_tables=DestroyXMLTree(quantization_tables);
+ table=DestroyQuantizationTable(table);
+ xml=DestroyString(xml);
+ return(table);
+ }
+ length=(size_t) table->width*table->height;
+ if (length < 64)
+ length=64;
+ table->levels=(unsigned int *) AcquireQuantumMemory(length,
+ sizeof(*table->levels));
+ if (table->levels == (unsigned int *) NULL)
+ ThrowFatalException(ResourceLimitFatalError,
+ "UnableToAcquireQuantizationTable");
+ for (i=0; i < (ssize_t) (table->width*table->height); i++)
+ {
+ table->levels[i]=(unsigned int) (InterpretLocaleValue(content,&p)/
+ table->divisor+0.5);
+ while (isspace((int) ((unsigned char) *p)) != 0)
+ p++;
+ if (*p == ',')
+ p++;
+ content=p;
+ }
+ value=InterpretLocaleValue(content,&p);
+ (void) value;
+ if (p != content)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
+ "XmlInvalidContent", "<level> too many values, table \"%s\"",slot);
+ quantization_tables=DestroyXMLTree(quantization_tables);
+ table=DestroyQuantizationTable(table);
+ xml=DestroyString(xml);
+ return(table);
+ }
+ for (j=i; j < 64; j++)
+ table->levels[j]=table->levels[j-1];
+ quantization_tables=DestroyXMLTree(quantization_tables);
+ xml=DestroyString(xml);
+ return(table);
+}
+
static void InitializeDestination(j_compress_ptr cinfo)
{
DestinationManager
/*
Add namespace to XMP profile.
*/
- xmp_profile=StringToStringInfo("http://ns.adobe.com/xap/1.0/");
+ xmp_profile=StringToStringInfo("http://ns.adobe.com/xap/1.0/ ");
ConcatenateStringInfo(xmp_profile,profile);
GetStringInfoDatum(xmp_profile)[28]='\0';
for (i=0; i < (ssize_t) GetStringInfoLength(xmp_profile); i+=65533L)
ErrorManager
error_manager;
+ int
+ quality;
+
JSAMPLE
*jpeg_pixels;
}
default:
{
- if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
break;
}
}
jpeg_info.density_unit=(UINT8) 1;
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
- "Image resolution: %.20g,%.20g",floor(image->x_resolution+0.5),
- floor(image->y_resolution+0.5));
- if ((image->x_resolution != 0.0) && (image->y_resolution != 0.0))
+ "Image resolution: %.20g,%.20g",floor(image->resolution.x+0.5),
+ floor(image->resolution.y+0.5));
+ if ((image->resolution.x != 0.0) && (image->resolution.y != 0.0))
{
/*
Set image resolution.
*/
jpeg_info.write_JFIF_header=MagickTrue;
- jpeg_info.X_density=(UINT16) floor(image->x_resolution+0.5);
- jpeg_info.Y_density=(UINT16) floor(image->y_resolution+0.5);
+ jpeg_info.X_density=(UINT16) floor(image->resolution.x+0.5);
+ jpeg_info.Y_density=(UINT16) floor(image->resolution.y+0.5);
if (image->units == PixelsPerInchResolution)
jpeg_info.density_unit=(UINT8) 1;
if (image->units == PixelsPerCentimeterResolution)
jpeg_info.density_unit=(UINT8) 2;
}
+ jpeg_info.dct_method=JDCT_FLOAT;
option=GetImageOption(image_info,"jpeg:dct-method");
if (option != (const char *) NULL)
switch (*option)
}
option=GetImageOption(image_info,"jpeg:optimize-coding");
if (option != (const char *) NULL)
- {
- jpeg_info.optimize_coding=MagickFalse;
- if (IsMagickTrue(option) != MagickFalse)
- jpeg_info.optimize_coding=MagickTrue;
- }
+ jpeg_info.optimize_coding=IsStringTrue(option);
else
{
MagickSizeType
Perform optimization only if available memory resources permit it.
*/
status=AcquireMagickResource(MemoryResource,length);
- if (status != MagickFalse)
- jpeg_info.optimize_coding=MagickTrue;
RelinquishMagickResource(MemoryResource,length);
+ jpeg_info.optimize_coding=status;
}
}
#if (JPEG_LIB_VERSION >= 61) && defined(C_PROGRESSIVE_SUPPORTED)
Search for compression quality that does not exceed image extent.
*/
jpeg_info->quality=0;
- extent=(MagickSizeType) SiPrefixToDouble(option,100.0);
+ extent=(MagickSizeType) SiPrefixToDoubleInterval(option,100.0);
(void) DeleteImageOption(jpeg_info,"jpeg:extent");
(void) AcquireUniqueFilename(jpeg_image->filename);
maximum=101;
}
jpeg_info=DestroyImageInfo(jpeg_info);
}
+ quality=92;
if ((image_info->compression != LosslessJPEGCompression) &&
(image->quality <= 100))
{
- if (image->quality == UndefinedCompressionQuality)
- jpeg_set_quality(&jpeg_info,92,MagickTrue);
- else
- jpeg_set_quality(&jpeg_info,(int) image->quality,MagickTrue);
+ if (image->quality != UndefinedCompressionQuality)
+ quality=(int) image->quality;
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"Quality: %.20g",
(double) image->quality);
else
{
#if !defined(C_LOSSLESS_SUPPORTED)
- jpeg_set_quality(&jpeg_info,100,MagickTrue);
+ quality=100;
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"Quality: 100");
#else
}
#endif
}
+ jpeg_set_quality(&jpeg_info,quality,MagickTrue);
+#if (JPEG_LIB_VERSION >= 70)
+ option=GetImageOption(image_info,"quality");
+ if (option != (const char *) NULL)
+ {
+ GeometryInfo
+ geometry_info;
+
+ int
+ flags;
+
+ /*
+ Set quality scaling for luminance and chrominance separately.
+ */
+ flags=ParseGeometry(option,&geometry_info);
+ if (((flags & RhoValue) != 0) && ((flags & SigmaValue) != 0))
+ {
+ jpeg_info.q_scale_factor[0]=jpeg_quality_scaling((int)
+ (geometry_info.rho+0.5));
+ jpeg_info.q_scale_factor[1]=jpeg_quality_scaling((int)
+ (geometry_info.sigma+0.5));
+ jpeg_default_qtables(&jpeg_info,MagickTrue);
+ }
+ }
+#endif
sampling_factor=(const char *) NULL;
- value=GetImageProperty(image,"jpeg:sampling-factor");
+ value=GetImageProperty(image,"jpeg:sampling-factor",exception);
+ if (value == (char *) NULL)
+ value=GetImageOption(image_info,"jpeg:sampling-factor");
if (value != (char *) NULL)
{
sampling_factor=value;
jpeg_info.comp_info[i].h_samp_factor=1;
jpeg_info.comp_info[i].v_samp_factor=1;
}
+ option=GetImageOption(image_info,"jpeg:q-table");
+ if (option != (const char *) NULL)
+ {
+ QuantizationTable
+ *table;
+
+ /*
+ Custom quantization tables.
+ */
+ table=GetQuantizationTable(option,"0",exception);
+ if (table != (QuantizationTable *) NULL)
+ {
+ jpeg_add_quant_table(&jpeg_info,0,table->levels,jpeg_quality_scaling(
+ quality),0);
+ table=DestroyQuantizationTable(table);
+ }
+ table=GetQuantizationTable(option,"1",exception);
+ if (table != (QuantizationTable *) NULL)
+ {
+ jpeg_add_quant_table(&jpeg_info,1,table->levels,jpeg_quality_scaling(
+ quality),0);
+ table=DestroyQuantizationTable(table);
+ }
+ table=GetQuantizationTable(option,"2",exception);
+ if (table != (QuantizationTable *) NULL)
+ {
+ jpeg_add_quant_table(&jpeg_info,2,table->levels,jpeg_quality_scaling(
+ quality),0);
+ table=DestroyQuantizationTable(table);
+ }
+ table=GetQuantizationTable(option,"3",exception);
+ if (table != (QuantizationTable *) NULL)
+ {
+ jpeg_add_quant_table(&jpeg_info,3,table->levels,jpeg_quality_scaling(
+ quality),0);
+ table=DestroyQuantizationTable(table);
+ }
+ }
jpeg_start_compress(&jpeg_info,MagickTrue);
if (image->debug != MagickFalse)
{
/*
Write JPEG profiles.
*/
- value=GetImageProperty(image,"comment");
+ value=GetImageProperty(image,"comment",exception);
if (value != (char *) NULL)
for (i=0; i < (ssize_t) strlen(value); i+=65533L)
jpeg_write_marker(&jpeg_info,JPEG_COM,(unsigned char *) value+i,
q=jpeg_pixels;
for (x=0; x < (ssize_t) image->columns; x++)
{
- *q++=(JSAMPLE) (ScaleQuantumToShort(GetPixelIntensity(image,p)) >>
- 4);
+ *q++=(JSAMPLE) (ScaleQuantumToShort(GetPixelIntensity(image,p)) >> 4);
p+=GetPixelChannels(image);
}
(void) jpeg_write_scanlines(&jpeg_info,scanline,1);
projects / imagemagick / blobdiff