% June 2001 %
% %
% %
-% 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 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(MAGICKCORE_JP2_DELEGATE)
static MagickBooleanType
- WriteJP2Image(const ImageInfo *,Image *);
+ WriteJP2Image(const ImageInfo *,Image *,ExceptionInfo *);
static volatile MagickBooleanType
instantiate_jp2 = MagickFalse;
i,
x;
- register PixelPacket
+ register Quantum
*q;
size_t
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;
+ if (number_components == 1)
+ image->colorspace=GRAYColorspace;
for (i=0; i < (ssize_t) number_components; i++)
{
size_t
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 < (ssize_t) number_components; i++)
(void) jas_image_readcmpt(jp2_image,(short) components[i],0,
for (x=0; x < (ssize_t) image->columns; x++)
{
pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);
- SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny) pixel,
- range[0]));
- SetGreenPixelComponent(q,GetRedPixelComponent(q));
- SetBluePixelComponent(q,GetRedPixelComponent(q));
- q++;
+ SetPixelGray(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);
+ q+=GetPixelChannels(image);
}
break;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);
- SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny) pixel,
- range[0]));
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[1],x/x_step[1]);
- SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny) pixel,
- range[1]));
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) pixel,range[1]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[2],x/x_step[2]);
- SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny) pixel,
- range[2]));
- q++;
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) pixel,range[2]),q);
+ q+=GetPixelChannels(image);
}
break;
}
for (x=0; x < (ssize_t) image->columns; x++)
{
pixel=(QuantumAny) jas_matrix_getv(pixels[0],x/x_step[0]);
- SetRedPixelComponent(q,ScaleAnyToQuantum((QuantumAny) pixel,
- range[0]));
+ SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) pixel,range[0]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[1],x/x_step[1]);
- SetGreenPixelComponent(q,ScaleAnyToQuantum((QuantumAny) pixel,
- range[1]));
+ SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) pixel,range[1]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[2],x/x_step[2]);
- SetBluePixelComponent(q,ScaleAnyToQuantum((QuantumAny) pixel,
- range[2]));
+ SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) pixel,range[2]),q);
pixel=(QuantumAny) jas_matrix_getv(pixels[3],x/x_step[3]);
- SetAlphaPixelComponent(q,ScaleAnyToQuantum((QuantumAny) pixel,
- range[3]));
- q++;
+ SetPixelAlpha(image,ScaleAnyToQuantum((QuantumAny) pixel,range[3]),q);
+ q+=GetPixelChannels(image);
}
break;
}
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Profile: ICC, %.20g bytes",(double) blob->len_);
- profile=AcquireStringInfo(blob->len_);
- SetStringInfoDatum(profile,blob->buf_);
+ 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);
%
% 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,
QuantumAny
range;
- register const PixelPacket
+ register const Quantum
*p;
register ssize_t
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) != MagickFalse))
+ (IsImageGray(image,exception) != MagickFalse))
number_components=1;
if ((image->columns != (unsigned int) image->columns) ||
(image->rows != (unsigned int) image->rows))
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 < (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(GetRedPixelComponent(p),range));
- jas_matrix_setv(pixels[1],x,(jas_seqent_t)
- ScaleQuantumToAny(GetGreenPixelComponent(p),range));
- jas_matrix_setv(pixels[2],x,(jas_seqent_t)
- ScaleQuantumToAny(GetBluePixelComponent(p),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) (GetAlphaPixelComponent(p)),range));
+ jas_matrix_setv(pixels[3],x,(jas_seqent_t) ScaleQuantumToAny(
+ GetPixelAlpha(image,p),range));
}
- p++;
+ p+=GetPixelChannels(image);
}
for (i=0; i < (ssize_t) number_components; i++)
(void) jas_image_writecmpt(jp2_image,(short) i,0,(unsigned int) y,
}
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 < (ssize_t) number_components; i++)
jas_matrix_destroy(pixels[i]);
projects / imagemagick / blobdiff