% June 2001 %
% %
% %
-% Copyright 1999-2010 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 declarations.
*/
-#include "magick/studio.h"
-#include "magick/attribute.h"
-#include "magick/blob.h"
-#include "magick/blob-private.h"
-#include "magick/cache.h"
-#include "magick/colorspace.h"
-#include "magick/color.h"
-#include "magick/color-private.h"
-#include "magick/exception.h"
-#include "magick/exception-private.h"
-#include "magick/image.h"
-#include "magick/image-private.h"
-#include "magick/list.h"
-#include "magick/magick.h"
-#include "magick/memory_.h"
-#include "magick/monitor.h"
-#include "magick/monitor-private.h"
-#include "magick/option.h"
-#include "magick/profile.h"
-#include "magick/quantum-private.h"
-#include "magick/static.h"
-#include "magick/statistic.h"
-#include "magick/string_.h"
-#include "magick/module.h"
+#include "MagickCore/studio.h"
+#include "MagickCore/attribute.h"
+#include "MagickCore/blob.h"
+#include "MagickCore/blob-private.h"
+#include "MagickCore/cache.h"
+#include "MagickCore/colorspace.h"
+#include "MagickCore/colorspace-private.h"
+#include "MagickCore/color.h"
+#include "MagickCore/color-private.h"
+#include "MagickCore/exception.h"
+#include "MagickCore/exception-private.h"
+#include "MagickCore/image.h"
+#include "MagickCore/image-private.h"
+#include "MagickCore/list.h"
+#include "MagickCore/magick.h"
+#include "MagickCore/memory_.h"
+#include "MagickCore/monitor.h"
+#include "MagickCore/monitor-private.h"
+#include "MagickCore/option.h"
+#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/profile.h"
+#include "MagickCore/quantum-private.h"
+#include "MagickCore/static.h"
+#include "MagickCore/statistic.h"
+#include "MagickCore/string_.h"
+#include "MagickCore/module.h"
#if defined(MAGICKCORE_JP2_DELEGATE)
#ifndef JAS_IMAGE_CM_GRAY
#define JAS_IMAGE_CM_GRAY JAS_IMAGE_CS_GRAY
#if !defined(uint)
#define uint unsigned int
#endif
-#if !defined(longlong)
-#define longlong long long
+#if !defined(ssize_tssize_t)
+#define ssize_tssize_t long long
#endif
-#if !defined(ulonglong)
-#define ulonglong unsigned long long
+#if !defined(ussize_tssize_t)
+#define ussize_tssize_t unsigned long long
#endif
-#ifdef __VMS
-#define JAS_VERSION 1.700.0
-#define PACKAGE jasper
-#define VERSION 1.700.0
-#endif
#undef PACKAGE_NAME
#undef PACKAGE_STRING
#undef PACKAGE_TARNAME
*/
#if defined(MAGICKCORE_JP2_DELEGATE)
static MagickBooleanType
- WriteJP2Image(const ImageInfo *,Image *);
+ WriteJP2Image(const ImageInfo *,Image *,ExceptionInfo *);
static volatile MagickBooleanType
instantiate_jp2 = MagickFalse;
source=(StreamManager *) object;
(void) CloseBlob(source->image);
- source=(StreamManager *) RelinquishMagickMemory(source);
+ free(source);
+ source=(StreamManager *) NULL;
return(0);
}
jas_stream_t
*jp2_stream;
- long
- components[4],
- y;
-
MagickBooleanType
status;
pixel,
range[4];
- register long
+ register ssize_t
i,
x;
- register PixelPacket
+ register Quantum
*q;
- unsigned long
+ size_t
maximum_component_depth,
number_components,
x_step[4],
y_step[4];
+ ssize_t
+ components[4],
+ y;
+
/*
Open image file.
*/
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- image=AcquireImage(image_info);
+ image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image->columns=jas_image_width(jp2_image);
image->rows=jas_image_height(jp2_image);
image->compression=JPEG2000Compression;
- for (i=0; i < (long) number_components; i++)
+ if (number_components == 1)
+ image->colorspace=GRAYColorspace;
+ for (i=0; i < (ssize_t) number_components; i++)
{
- unsigned long
+ size_t
height,
width;
- width=(unsigned long) (jas_image_cmptwidth(jp2_image,components[i])*
+ width=(size_t) (jas_image_cmptwidth(jp2_image,components[i])*
jas_image_cmpthstep(jp2_image,components[i]));
- height=(unsigned long) (jas_image_cmptheight(jp2_image,components[i])*
+ height=(size_t) (jas_image_cmptheight(jp2_image,components[i])*
jas_image_cmptvstep(jp2_image,components[i]));
x_step[i]=(unsigned int) jas_image_cmpthstep(jp2_image,components[i]);
y_step[i]=(unsigned int) jas_image_cmptvstep(jp2_image,components[i]);
*/
image->matte=number_components > 3 ? MagickTrue : MagickFalse;
maximum_component_depth=0;
- for (i=0; i < (long) number_components; i++)
+ for (i=0; i < (ssize_t) number_components; i++)
{
maximum_component_depth=(unsigned int) MagickMax((size_t)
jas_image_cmptprec(jp2_image,components[i]),(size_t)
jas_image_destroy(jp2_image);
return(GetFirstImageInList(image));
}
- for (i=0; i < (long) number_components; i++)
- range[i]=GetQuantumRange((unsigned long) jas_image_cmptprec(jp2_image,
+ for (i=0; i < (ssize_t) number_components; i++)
+ range[i]=GetQuantumRange((size_t) jas_image_cmptprec(jp2_image,
components[i]));
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ if (q == (Quantum *) NULL)
break;
- for (i=0; i < (long) number_components; i++)
+ for (i=0; i < (ssize_t) number_components; i++)
(void) jas_image_readcmpt(jp2_image,(short) components[i],0,
- ((unsigned int) y)/y_step[i],((unsigned int) image->columns)/x_step[i],
- 1,pixels[i]);
+ (jas_image_coord_t) (y/y_step[i]),(jas_image_coord_t) (image->columns/
+ x_step[i]),1,pixels[i]);
switch (number_components)
{
case 1:
/*
Grayscale.
*/
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);
- q->red=(Quantum) ScaleAnyToQuantum((QuantumAny) pixel,range[0]);
- q->green=q->red;
- q->blue=q->red;
- q++;
+ SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);
+ q+=GetPixelChannels(image);
}
break;
}
/*
RGB.
*/
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);
- q->red=(Quantum) ScaleAnyToQuantum((QuantumAny) pixel,range[0]);
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[1],x/x_step[1]);
- q->green=(Quantum) ScaleAnyToQuantum((QuantumAny) pixel,range[1]);
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) pixel,range[1]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[2],x/x_step[2]);
- q->blue=(Quantum) ScaleAnyToQuantum((QuantumAny) pixel,range[2]);
- q++;
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) pixel,range[2]),q);
+ q+=GetPixelChannels(image);
}
break;
}
/*
RGBA.
*/
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);
- q->red=(Quantum) ScaleAnyToQuantum((QuantumAny) pixel,range[0]);
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[1],x/x_step[1]);
- q->green=(Quantum) ScaleAnyToQuantum((QuantumAny) pixel,range[1]);
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) pixel,range[1]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[2],x/x_step[2]);
- q->blue=(Quantum) ScaleAnyToQuantum((QuantumAny) pixel,range[2]);
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) pixel,range[2]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[3],x/x_step[3]);
- q->opacity=(Quantum) (QuantumRange-
- ScaleAnyToQuantum((QuantumAny) pixel,range[3]));
- q++;
+ SetPixelAlpha(image,ScaleAnyToQuantum((QuantumAny) pixel,range[3]),q);
+ q+=GetPixelChannels(image);
}
break;
}
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
break;
- status=SetImageProgress(image,LoadImageTag,y,image->rows);
+ status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
blob=(jas_stream_memobj_t *) icc_stream->obj_;
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
- "Profile: ICC, %lu bytes",(unsigned long) blob->len_);
- profile=AcquireStringInfo(blob->len_);
- SetStringInfoDatum(profile,blob->buf_);
+ "Profile: ICC, %.20g bytes",(double) blob->len_);
+ profile=BlobToStringInfo(blob->buf_,blob->len_);
+ if (profile == (StringInfo *) NULL)
+ ThrowReaderException(CorruptImageError,"MemoryAllocationFailed");
icc_profile=(StringInfo *) GetImageProfile(image,"icc");
if (icc_profile == (StringInfo *) NULL)
- (void) SetImageProfile(image,"icc",profile);
+ (void) SetImageProfile(image,"icc",profile,exception);
else
(void) ConcatenateStringInfo(icc_profile,profile);
profile=DestroyStringInfo(profile);
}
(void) jas_stream_close(jp2_stream);
jas_image_destroy(jp2_image);
- for (i=0; i < (long) number_components; i++)
+ for (i=0; i < (ssize_t) number_components; i++)
jas_matrix_destroy(pixels[i]);
return(GetFirstImageInList(image));
}
%
% The format of the RegisterJP2Image method is:
%
-% unsigned long RegisterJP2Image(void)
+% size_t RegisterJP2Image(void)
%
*/
-ModuleExport unsigned long RegisterJP2Image(void)
+ModuleExport size_t RegisterJP2Image(void)
{
MagickInfo
*entry;
%
% The format of the WriteJP2Image method is:
%
-% MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image)
+% MagickBooleanType WriteJP2Image(const ImageInfo *image_info,
+% Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows.
%
%
% o image: The image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-static MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image)
+static MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image,
+ ExceptionInfo *exception)
{
char
*key,
const char
*option;
- long
- format,
- y;
-
jas_image_cmptparm_t
component_info[4];
QuantumAny
range;
- register const PixelPacket
+ register const Quantum
*p;
- register long
+ register ssize_t
i,
x;
- unsigned long
+ size_t
number_components;
+ ssize_t
+ format,
+ y;
+
/*
Open image file.
*/
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
/*
- Intialize JPEG 2000 API.
+ Initialize JPEG 2000 API.
*/
- if (image->colorspace != RGBColorspace)
- (void) TransformImageColorspace(image,RGBColorspace);
+ if (IsRGBColorspace(image->colorspace) == MagickFalse)
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
jp2_stream=JP2StreamManager(image);
if (jp2_stream == (jas_stream_t *) NULL)
ThrowWriterException(DelegateError,"UnableToManageJP2Stream");
number_components=image->matte ? 4UL : 3UL;
if ((image_info->type != TrueColorType) &&
- IsGrayImage(image,&image->exception))
+ (IsImageGray(image,exception) != MagickFalse))
number_components=1;
if ((image->columns != (unsigned int) image->columns) ||
(image->rows != (unsigned int) image->rows))
ThrowWriterException(ImageError,"WidthOrHeightExceedsLimit");
(void) ResetMagickMemory(&component_info,0,sizeof(component_info));
- for (i=0; i < (long) number_components; i++)
+ for (i=0; i < (ssize_t) number_components; i++)
{
component_info[i].tlx=0;
component_info[i].tly=0;
/*
Convert to JPEG 2000 pixels.
*/
- for (i=0; i < (long) number_components; i++)
+ for (i=0; i < (ssize_t) number_components; i++)
{
pixels[i]=jas_matrix_create(1,(int) image->columns);
if (pixels[i] == (jas_matrix_t *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
}
}
- range=GetQuantumRange((unsigned long) component_info[0].prec);
- for (y=0; y < (long) image->rows; y++)
+ range=GetQuantumRange((size_t) component_info[0].prec);
+ for (y=0; y < (ssize_t) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
- if (p == (const PixelPacket *) NULL)
+ p=GetVirtualPixels(image,0,y,image->columns,1,exception);
+ if (p == (const Quantum *) NULL)
break;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
if (number_components == 1)
jas_matrix_setv(pixels[0],x,(jas_seqent_t) ScaleQuantumToAny(
- PixelIntensityToQuantum(p),range));
+ GetPixelIntensity(image,p),range));
else
{
- jas_matrix_setv(pixels[0],x,(jas_seqent_t)
- ScaleQuantumToAny(p->red,range));
- jas_matrix_setv(pixels[1],x,(jas_seqent_t)
- ScaleQuantumToAny(p->green,range));
- jas_matrix_setv(pixels[2],x,(jas_seqent_t)
- ScaleQuantumToAny(p->blue,range));
+ jas_matrix_setv(pixels[0],x,(jas_seqent_t) ScaleQuantumToAny(
+ GetPixelRed(image,p),range));
+ jas_matrix_setv(pixels[1],x,(jas_seqent_t) ScaleQuantumToAny(
+ GetPixelGreen(image,p),range));
+ jas_matrix_setv(pixels[2],x,(jas_seqent_t) ScaleQuantumToAny(
+ GetPixelBlue(image,p),range));
if (number_components > 3)
- jas_matrix_setv(pixels[3],x,(jas_seqent_t)
- ScaleQuantumToAny((Quantum) (QuantumRange-GetOpacityPixelComponent(p)),range));
+ jas_matrix_setv(pixels[3],x,(jas_seqent_t) ScaleQuantumToAny(
+ GetPixelAlpha(image,p),range));
}
- p++;
+ p+=GetPixelChannels(image);
}
- for (i=0; i < (long) number_components; i++)
+ for (i=0; i < (ssize_t) number_components; i++)
(void) jas_image_writecmpt(jp2_image,(short) i,0,(unsigned int) y,
(unsigned int) image->columns,1,pixels[i]);
- status=SetImageProgress(image,SaveImageTag,y,image->rows);
+ status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+ image->rows);
if (status == MagickFalse)
break;
}
(GetImageQuantumDepth(image,MagickTrue)/8);
target_size=(number_pixels*rate)+header_size;
rate=target_size/number_pixels;
- (void) FormatMagickString(option,MaxTextExtent,"rate=%.15g",rate);
+ (void) FormatLocaleString(option,MaxTextExtent,"rate=%g",rate);
(void) ConcatenateString(&options,option);
}
status=jas_image_encode(jp2_image,jp2_stream,format,options) != 0 ?
MagickTrue : MagickFalse;
+ if (options != (char *) NULL)
+ options=DestroyString(options);
(void) jas_stream_close(jp2_stream);
- for (i=0; i < (long) number_components; i++)
+ for (i=0; i < (ssize_t) number_components; i++)
jas_matrix_destroy(pixels[i]);
jas_image_destroy(jp2_image);
if (status != MagickFalse)
projects / imagemagick / blobdiff