% June 2001 %
% %
% %
-% Copyright 1999-2014 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2018 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 %
% obtain a copy of the License at %
% %
-% http://www.imagemagick.org/script/license.php %
+% https://www.imagemagick.org/script/license.php %
% %
% Unless required by applicable law or agreed to in writing, software %
% distributed under the License is distributed on an "AS IS" BASIS, %
#include "MagickCore/profile.h"
#include "MagickCore/property.h"
#include "MagickCore/quantum-private.h"
+#include "MagickCore/semaphore.h"
#include "MagickCore/static.h"
#include "MagickCore/statistic.h"
#include "MagickCore/string_.h"
%
% The format of the IsJ2K method is:
%
-% MagickBooleanType IsJP2(const unsigned char *magick,const size_t length)
+% MagickBooleanType IsJ2K(const unsigned char *magick,const size_t length)
%
% A description of each parameter follows:
%
*/
static MagickBooleanType IsJP2(const unsigned char *magick,const size_t length)
{
- if (length < 12)
+ if (length < 4)
return(MagickFalse);
- if (memcmp(magick,"\x00\x00\x00\x0c\x6a\x50\x20\x20\x0d\x0a\x87\x0a",12) == 0)
- return(MagickTrue);
- if (memcmp(magick,"\x0d\x0a\x87\x0a",12) == 0)
+ if (memcmp(magick,"\x0d\x0a\x87\x0a",4) == 0)
return(MagickTrue);
- return(MagickFalse);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-% I s J P C %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% IsJPC()() returns MagickTrue if the image format type, identified by the
-% magick string, is JPC.
-%
-% The format of the IsJPC method is:
-%
-% MagickBooleanType IsJPC(const unsigned char *magick,const size_t length)
-%
-% A description of each parameter follows:
-%
-% o magick: compare image format pattern against these bytes.
-%
-% o length: Specifies the length of the magick string.
-%
-*/
-static MagickBooleanType IsJPC(const unsigned char *magick,const size_t length)
-{
if (length < 12)
return(MagickFalse);
if (memcmp(magick,"\x00\x00\x00\x0c\x6a\x50\x20\x20\x0d\x0a\x87\x0a",12) == 0)
return(MagickTrue);
- if (memcmp(magick,"\x0d\x0a\x87\x0a",12) == 0)
- return(MagickTrue);
return(MagickFalse);
}
\f
ssize_t
y;
+ unsigned char
+ sans[4];
+
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
- assert(exception->signature == MagickSignature);
+ assert(exception->signature == MagickCoreSignature);
image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
/*
Initialize JP2 codec.
*/
+ if (ReadBlob(image,4,sans) != 4)
+ {
+ image=DestroyImageList(image);
+ return((Image *) NULL);
+ }
+ (void) SeekBlob(image,SEEK_SET,0);
if (LocaleCompare(image_info->magick,"JPT") == 0)
jp2_codec=opj_create_decompress(OPJ_CODEC_JPT);
else
- if (LocaleCompare(image_info->magick,"J2K") == 0)
+ if (IsJ2K(sans,4) != MagickFalse)
jp2_codec=opj_create_decompress(OPJ_CODEC_J2K);
else
jp2_codec=opj_create_decompress(OPJ_CODEC_JP2);
opj_stream_set_write_function(jp2_stream,JP2WriteHandler);
opj_stream_set_seek_function(jp2_stream,JP2SeekHandler);
opj_stream_set_skip_function(jp2_stream,JP2SkipHandler);
- opj_stream_set_user_data(jp2_stream,image);
+ opj_stream_set_user_data(jp2_stream,image,NULL);
opj_stream_set_user_data_length(jp2_stream,GetBlobSize(image));
if (opj_read_header(jp2_stream,jp2_codec,&jp2_image) == 0)
{
- opj_stream_set_user_data(jp2_stream,NULL);
- opj_stream_destroy_v3(jp2_stream);
+ opj_stream_destroy(jp2_stream);
opj_destroy_codec(jp2_codec);
ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
}
+ jp2_status=1;
if ((image->columns != 0) && (image->rows != 0))
{
/*
Extract an area from the image.
*/
- jp2_status=opj_set_decode_area(jp2_codec,jp2_image,image->extract_info.x,
- image->extract_info.y,image->extract_info.x+image->columns,
- image->extract_info.y+image->rows);
+ jp2_status=opj_set_decode_area(jp2_codec,jp2_image,
+ (OPJ_INT32) image->extract_info.x,(OPJ_INT32) image->extract_info.y,
+ (OPJ_INT32) (image->extract_info.x+(ssize_t) image->columns),
+ (OPJ_INT32) (image->extract_info.y+(ssize_t) image->rows));
if (jp2_status == 0)
{
- opj_stream_set_user_data(jp2_stream,NULL);
- opj_stream_destroy_v3(jp2_stream);
+ opj_stream_destroy(jp2_stream);
opj_destroy_codec(jp2_codec);
opj_image_destroy(jp2_image);
ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
}
}
- if ((opj_decode(jp2_codec,jp2_stream,jp2_image) == 0) ||
- (opj_end_decompress(jp2_codec,jp2_stream) == 0))
+ if ((image_info->number_scenes != 0) && (image_info->scene != 0))
+ jp2_status=opj_get_decoded_tile(jp2_codec,jp2_stream,jp2_image,
+ (unsigned int) image_info->scene-1);
+ else
+ if (image->ping == MagickFalse)
+ {
+ jp2_status=opj_decode(jp2_codec,jp2_stream,jp2_image);
+ if (jp2_status != 0)
+ jp2_status=opj_end_decompress(jp2_codec,jp2_stream);
+ }
+ if (jp2_status == 0)
{
- opj_stream_set_user_data(jp2_stream,NULL);
- opj_stream_destroy_v3(jp2_stream);
+ opj_stream_destroy(jp2_stream);
opj_destroy_codec(jp2_codec);
opj_image_destroy(jp2_image);
ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
}
- opj_stream_set_user_data(jp2_stream,NULL);
- opj_stream_destroy_v3(jp2_stream);
+ opj_stream_destroy(jp2_stream);
for (i=0; i < (ssize_t) jp2_image->numcomps; i++)
{
- if ((jp2_image->comps[i].dx == 0) || (jp2_image->comps[i].dy == 0))
+ if ((jp2_image->comps[0].dx == 0) || (jp2_image->comps[0].dy == 0) ||
+ (jp2_image->comps[0].dx != jp2_image->comps[i].dx) ||
+ (jp2_image->comps[0].dy != jp2_image->comps[i].dy) ||
+ (jp2_image->comps[0].prec != jp2_image->comps[i].prec) ||
+ (jp2_image->comps[0].sgnd != jp2_image->comps[i].sgnd) ||
+ ((image->ping == MagickFalse) && (jp2_image->comps[i].data == NULL)))
{
- opj_stream_set_user_data(jp2_stream,NULL);
opj_destroy_codec(jp2_codec);
opj_image_destroy(jp2_image);
ThrowReaderException(CoderError,"IrregularChannelGeometryNotSupported")
image->columns=(size_t) jp2_image->comps[0].w;
image->rows=(size_t) jp2_image->comps[0].h;
image->depth=jp2_image->comps[0].prec;
+ status=SetImageExtent(image,image->columns,image->rows,exception);
+ if (status == MagickFalse)
+ return(DestroyImageList(image));
image->compression=JPEG2000Compression;
- if (jp2_image->numcomps <= 2)
- {
- SetImageColorspace(image,GRAYColorspace,exception);
- if (jp2_image->numcomps > 1)
- image->alpha_trait=BlendPixelTrait;
- }
+ if (jp2_image->numcomps == 1)
+ SetImageColorspace(image,GRAYColorspace,exception);
+ else
+ if (jp2_image->color_space == 2)
+ {
+ SetImageColorspace(image,GRAYColorspace,exception);
+ if (jp2_image->numcomps > 1)
+ image->alpha_trait=BlendPixelTrait;
+ }
+ else
+ if (jp2_image->color_space == 3)
+ SetImageColorspace(image,Rec601YCbCrColorspace,exception);
if (jp2_image->numcomps > 3)
image->alpha_trait=BlendPixelTrait;
- for (i=0; i < (ssize_t) jp2_image->numcomps; i++)
- if ((jp2_image->comps[i].dx > 1) || (jp2_image->comps[i].dy > 1))
- SetImageColorspace(image,YUVColorspace,exception);
if (jp2_image->icc_profile_buf != (unsigned char *) NULL)
{
StringInfo
if (profile != (StringInfo *) NULL)
SetImageProfile(image,"icc",profile,exception);
}
+ if (image->ping != MagickFalse)
+ {
+ opj_destroy_codec(jp2_codec);
+ opj_image_destroy(jp2_image);
+ opj_destroy_cstr_index(&codestream_index);
+ return(GetFirstImageInList(image));
+ }
for (y=0; y < (ssize_t) image->rows; y++)
{
register Quantum
- *restrict q;
+ *magick_restrict q;
register ssize_t
x;
{
case 0:
{
+ if (jp2_image->numcomps == 1)
+ {
+ SetPixelGray(image,ClampToQuantum(pixel),q);
+ SetPixelAlpha(image,OpaqueAlpha,q);
+ break;
+ }
SetPixelRed(image,ClampToQuantum(pixel),q);
SetPixelGreen(image,ClampToQuantum(pixel),q);
SetPixelBlue(image,ClampToQuantum(pixel),q);
opj_destroy_codec(jp2_codec);
opj_image_destroy(jp2_image);
opj_destroy_cstr_index(&codestream_index);
+ (void) CloseBlob(image);
return(GetFirstImageInList(image));
}
#endif
ModuleExport size_t RegisterJP2Image(void)
{
char
- version[MaxTextExtent];
+ version[MagickPathExtent];
MagickInfo
*entry;
*version='\0';
#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
- (void) FormatLocaleString(version,MaxTextExtent,"%s",opj_version());
+ (void) FormatLocaleString(version,MagickPathExtent,"%s",opj_version());
#endif
- entry=SetMagickInfo("JP2");
- entry->description=ConstantString("JPEG-2000 File Format Syntax");
+ entry=AcquireMagickInfo("JP2","JP2","JPEG-2000 File Format Syntax");
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jp2");
- entry->module=ConstantString("JP2");
entry->magick=(IsImageFormatHandler *) IsJP2;
- entry->adjoin=MagickFalse;
- entry->seekable_stream=MagickTrue;
- entry->thread_support=NoThreadSupport;
+ entry->flags^=CoderAdjoinFlag;
+ entry->flags|=CoderDecoderSeekableStreamFlag;
+ entry->flags|=CoderEncoderSeekableStreamFlag;
#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadJP2Image;
entry->encoder=(EncodeImageHandler *) WriteJP2Image;
#endif
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("J2K");
- entry->description=ConstantString("JPEG-2000 Code Stream Syntax");
+ entry=AcquireMagickInfo("JP2","J2C","JPEG-2000 Code Stream Syntax");
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jp2");
- entry->module=ConstantString("JP2");
entry->magick=(IsImageFormatHandler *) IsJ2K;
- entry->adjoin=MagickFalse;
- entry->seekable_stream=MagickTrue;
- entry->thread_support=NoThreadSupport;
+ entry->flags^=CoderAdjoinFlag;
+ entry->flags|=CoderDecoderSeekableStreamFlag;
+ entry->flags|=CoderEncoderSeekableStreamFlag;
#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadJP2Image;
entry->encoder=(EncodeImageHandler *) WriteJP2Image;
#endif
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("JPT");
- entry->description=ConstantString("JPEG-2000 File Format Syntax");
+ entry=AcquireMagickInfo("JP2","J2K","JPEG-2000 Code Stream Syntax");
+ if (*version != '\0')
+ entry->version=ConstantString(version);
+ entry->mime_type=ConstantString("image/jp2");
+ entry->magick=(IsImageFormatHandler *) IsJ2K;
+ entry->flags^=CoderAdjoinFlag;
+ entry->flags|=CoderDecoderSeekableStreamFlag;
+ entry->flags|=CoderEncoderSeekableStreamFlag;
+#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
+ entry->decoder=(DecodeImageHandler *) ReadJP2Image;
+ entry->encoder=(EncodeImageHandler *) WriteJP2Image;
+#endif
+ (void) RegisterMagickInfo(entry);
+ entry=AcquireMagickInfo("JP2","JPM","JPEG-2000 File Format Syntax");
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jp2");
- entry->module=ConstantString("JP2");
entry->magick=(IsImageFormatHandler *) IsJP2;
- entry->adjoin=MagickFalse;
- entry->seekable_stream=MagickTrue;
- entry->thread_support=NoThreadSupport;
+ entry->flags^=CoderAdjoinFlag;
+ entry->flags|=CoderDecoderSeekableStreamFlag;
+ entry->flags|=CoderEncoderSeekableStreamFlag;
#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadJP2Image;
entry->encoder=(EncodeImageHandler *) WriteJP2Image;
#endif
(void) RegisterMagickInfo(entry);
- entry=SetMagickInfo("JPC");
- entry->description=ConstantString("JPEG-2000 Code Stream Syntax");
+ entry=AcquireMagickInfo("JP2","JPT","JPEG-2000 File Format Syntax");
if (*version != '\0')
entry->version=ConstantString(version);
entry->mime_type=ConstantString("image/jp2");
- entry->module=ConstantString("JP2");
- entry->magick=(IsImageFormatHandler *) IsJPC;
- entry->adjoin=MagickFalse;
- entry->seekable_stream=MagickTrue;
- entry->thread_support=NoThreadSupport;
+ entry->magick=(IsImageFormatHandler *) IsJP2;
+ entry->flags^=CoderAdjoinFlag;
+ entry->flags|=CoderDecoderSeekableStreamFlag;
+ entry->flags|=CoderEncoderSeekableStreamFlag;
+#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
+ entry->decoder=(DecodeImageHandler *) ReadJP2Image;
+ entry->encoder=(EncodeImageHandler *) WriteJP2Image;
+#endif
+ (void) RegisterMagickInfo(entry);
+ entry=AcquireMagickInfo("JP2","JPC","JPEG-2000 Code Stream Syntax");
+ if (*version != '\0')
+ entry->version=ConstantString(version);
+ entry->mime_type=ConstantString("image/jp2");
+ entry->magick=(IsImageFormatHandler *) IsJP2;
+ entry->flags^=CoderAdjoinFlag;
+ entry->flags|=CoderDecoderSeekableStreamFlag;
+ entry->flags|=CoderEncoderSeekableStreamFlag;
#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
entry->decoder=(DecodeImageHandler *) ReadJP2Image;
entry->encoder=(EncodeImageHandler *) WriteJP2Image;
{
(void) UnregisterMagickInfo("JPC");
(void) UnregisterMagickInfo("JPT");
+ (void) UnregisterMagickInfo("JPM");
(void) UnregisterMagickInfo("JP2");
(void) UnregisterMagickInfo("J2K");
}
ssize_t
y;
- size_t
+ unsigned int
channels;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
- assert(exception->signature == MagickSignature);
+ assert(exception->signature == MagickCoreSignature);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
*/
opj_set_default_encoder_parameters(¶meters);
for (i=1; i < 6; i++)
- if (((1UL << (i+2)) > image->columns) && ((1UL << (i+2)) > image->rows))
+ if (((size_t) (1UL << (i+2)) > image->columns) &&
+ ((size_t) (1UL << (i+2)) > image->rows))
break;
parameters.numresolution=i;
option=GetImageOption(image_info,"jp2:number-resolutions");
parameters.tcp_numlayers=1;
parameters.tcp_rates[0]=0; /* lossless */
parameters.cp_disto_alloc=1;
- if (image->quality != 0)
+ if ((image_info->quality != 0) && (image_info->quality != 100))
{
- parameters.tcp_distoratio[0]=(double) image->quality;
+ parameters.tcp_distoratio[0]=(double) image_info->quality;
parameters.cp_fixed_quality=OPJ_TRUE;
}
if (image_info->extract != (char *) NULL)
Set tile size.
*/
flags=ParseAbsoluteGeometry(image_info->extract,&geometry);
- parameters.cp_tdx=geometry.width;
- parameters.cp_tdy=geometry.width;
+ parameters.cp_tdx=(int) geometry.width;
+ parameters.cp_tdy=(int) geometry.width;
if ((flags & HeightValue) != 0)
- parameters.cp_tdy=geometry.height;
+ parameters.cp_tdy=(int) geometry.height;
if ((flags & XValue) != 0)
parameters.cp_tx0=geometry.x;
if ((flags & YValue) != 0)
p=option;
for (i=0; sscanf(p,"%f",¶meters.tcp_rates[i]) == 1; i++)
{
- if (i > 100)
+ if (i >= 100)
break;
while ((*p != '\0') && (*p != ','))
p++;
¶meters.subsampling_dx,¶meters.subsampling_dy);
property=GetImageProperty(image,"comment",exception);
if (property != (const char *) NULL)
- parameters.cp_comment=ConstantString(property);
+ parameters.cp_comment=(char *) property;
channels=3;
jp2_colorspace=OPJ_CLRSPC_SRGB;
if (image->colorspace == YUVColorspace)
}
else
{
- if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,sRGBColorspace,exception);
if (IsGrayColorspace(image->colorspace) != MagickFalse)
{
channels=1;
jp2_colorspace=OPJ_CLRSPC_GRAY;
}
- if (image->alpha_trait == BlendPixelTrait)
+ else
+ (void) TransformImageColorspace(image,sRGBColorspace,exception);
+ if (image->alpha_trait != UndefinedPixelTrait)
channels++;
}
parameters.tcp_mct=channels == 3 ? 1 : 0;
ResetMagickMemory(jp2_info,0,sizeof(jp2_info));
for (i=0; i < (ssize_t) channels; i++)
{
- jp2_info[i].prec=image->depth;
- jp2_info[i].bpp=image->depth;
+ jp2_info[i].prec=(OPJ_UINT32) image->depth;
+ jp2_info[i].bpp=(OPJ_UINT32) image->depth;
if ((image->depth == 1) &&
((LocaleCompare(image_info->magick,"JPT") == 0) ||
(LocaleCompare(image_info->magick,"JP2") == 0)))
jp2_info[i].sgnd=0;
jp2_info[i].dx=parameters.subsampling_dx;
jp2_info[i].dy=parameters.subsampling_dy;
- jp2_info[i].w=image->columns;
- jp2_info[i].h=image->rows;
+ jp2_info[i].w=(OPJ_UINT32) image->columns;
+ jp2_info[i].h=(OPJ_UINT32) image->rows;
}
- jp2_image=opj_image_create(channels,jp2_info,jp2_colorspace);
+ jp2_image=opj_image_create((OPJ_UINT32) channels,jp2_info,jp2_colorspace);
if (jp2_image == (opj_image_t *) NULL)
ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
jp2_image->x0=parameters.image_offset_x0;
jp2_image->y0=parameters.image_offset_y0;
- jp2_image->x1=2*parameters.image_offset_x0+(image->columns-1)*
- parameters.subsampling_dx+1;
- jp2_image->y1=2*parameters.image_offset_y0+(image->rows-1)*
- parameters.subsampling_dx+1;
+ jp2_image->x1=(unsigned int) (2*parameters.image_offset_x0+(image->columns-1)*
+ parameters.subsampling_dx+1);
+ jp2_image->y1=(unsigned int) (2*parameters.image_offset_y0+(image->rows-1)*
+ parameters.subsampling_dx+1);
if ((image->depth == 12) &&
((image->columns == 2048) || (image->rows == 1080) ||
(image->columns == 4096) || (image->rows == 2160)))
CinemaProfileCompliance(jp2_image,¶meters);
+ if (channels == 4)
+ jp2_image->comps[3].alpha=1;
+ else
+ if ((channels == 2) && (jp2_colorspace == OPJ_CLRSPC_GRAY))
+ jp2_image->comps[1].alpha=1;
/*
Convert to JP2 pixels.
*/
{
if (jp2_colorspace == OPJ_CLRSPC_GRAY)
{
- *q=(int) (scale*GetPixelLuma(image,p));
+ *q=(int) (scale*GetPixelGray(image,p));
break;
}
*q=(int) (scale*GetPixelRed(image,p));
opj_stream_set_write_function(jp2_stream,JP2WriteHandler);
opj_stream_set_seek_function(jp2_stream,JP2SeekHandler);
opj_stream_set_skip_function(jp2_stream,JP2SkipHandler);
- opj_stream_set_user_data(jp2_stream,image);
+ opj_stream_set_user_data(jp2_stream,image,NULL);
if (jp2_stream == (opj_stream_t *) NULL)
ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
jp2_status=opj_start_compress(jp2_codec,jp2_image,jp2_stream);
if ((opj_encode(jp2_codec,jp2_stream) == 0) ||
(opj_end_compress(jp2_codec,jp2_stream) == 0))
{
- opj_stream_set_user_data(jp2_stream,NULL);
- opj_stream_destroy_v3(jp2_stream);
+ opj_stream_destroy(jp2_stream);
opj_destroy_codec(jp2_codec);
opj_image_destroy(jp2_image);
ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
/*
Free resources.
*/
- opj_stream_set_user_data(jp2_stream,NULL);
- opj_stream_destroy_v3(jp2_stream);
+ opj_stream_destroy(jp2_stream);
opj_destroy_codec(jp2_codec);
opj_image_destroy(jp2_image);
(void) CloseBlob(image);
projects / imagemagick / blobdiff