2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13 % Read/Write JPEG-2000 Image Format %
20 % Copyright 1999-2015 ImageMagick Studio LLC, a non-profit organization %
21 % dedicated to making software imaging solutions freely available. %
23 % You may not use this file except in compliance with the License. You may %
24 % obtain a copy of the License at %
26 % http://www.imagemagick.org/script/license.php %
28 % Unless required by applicable law or agreed to in writing, software %
29 % distributed under the License is distributed on an "AS IS" BASIS, %
30 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31 % See the License for the specific language governing permissions and %
32 % limitations under the License. %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
42 #include "MagickCore/studio.h"
43 #include "MagickCore/artifact.h"
44 #include "MagickCore/attribute.h"
45 #include "MagickCore/blob.h"
46 #include "MagickCore/blob-private.h"
47 #include "MagickCore/cache.h"
48 #include "MagickCore/colorspace.h"
49 #include "MagickCore/colorspace-private.h"
50 #include "MagickCore/color.h"
51 #include "MagickCore/color-private.h"
52 #include "MagickCore/exception.h"
53 #include "MagickCore/exception-private.h"
54 #include "MagickCore/image.h"
55 #include "MagickCore/image-private.h"
56 #include "MagickCore/list.h"
57 #include "MagickCore/magick.h"
58 #include "MagickCore/memory_.h"
59 #include "MagickCore/monitor.h"
60 #include "MagickCore/monitor-private.h"
61 #include "MagickCore/option.h"
62 #include "MagickCore/pixel-accessor.h"
63 #include "MagickCore/profile.h"
64 #include "MagickCore/property.h"
65 #include "MagickCore/quantum-private.h"
66 #include "MagickCore/semaphore.h"
67 #include "MagickCore/static.h"
68 #include "MagickCore/statistic.h"
69 #include "MagickCore/string_.h"
70 #include "MagickCore/string-private.h"
71 #include "MagickCore/module.h"
72 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
79 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
80 static MagickBooleanType
81 WriteJP2Image(const ImageInfo *,Image *,ExceptionInfo *);
85 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
93 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
95 % IsJ2K() returns MagickTrue if the image format type, identified by the
96 % magick string, is J2K.
98 % The format of the IsJ2K method is:
100 % MagickBooleanType IsJ2K(const unsigned char *magick,const size_t length)
102 % A description of each parameter follows:
104 % o magick: compare image format pattern against these bytes.
106 % o length: Specifies the length of the magick string.
109 static MagickBooleanType IsJ2K(const unsigned char *magick,const size_t length)
113 if (memcmp(magick,"\xff\x4f\xff\x51",4) == 0)
119 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
127 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
129 % IsJP2() returns MagickTrue if the image format type, identified by the
130 % magick string, is JP2.
132 % The format of the IsJP2 method is:
134 % MagickBooleanType IsJP2(const unsigned char *magick,const size_t length)
136 % A description of each parameter follows:
138 % o magick: compare image format pattern against these bytes.
140 % o length: Specifies the length of the magick string.
143 static MagickBooleanType IsJP2(const unsigned char *magick,const size_t length)
147 if (memcmp(magick,"\x0d\x0a\x87\x0a",4) == 0)
151 if (memcmp(magick,"\x00\x00\x00\x0c\x6a\x50\x20\x20\x0d\x0a\x87\x0a",12) == 0)
157 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
161 % R e a d J P 2 I m a g e %
165 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
167 % ReadJP2Image() reads a JPEG 2000 Image file (JP2) or JPEG 2000
168 % codestream (JPC) image file and returns it. It allocates the memory
169 % necessary for the new Image structure and returns a pointer to the new
170 % image or set of images.
172 % JP2 support is originally written by Nathan Brown, nathanbrown@letu.edu.
174 % The format of the ReadJP2Image method is:
176 % Image *ReadJP2Image(const ImageInfo *image_info,
177 % ExceptionInfo *exception)
179 % A description of each parameter follows:
181 % o image_info: the image info.
183 % o exception: return any errors or warnings in this structure.
186 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
187 static void JP2ErrorHandler(const char *message,void *client_data)
192 exception=(ExceptionInfo *) client_data;
193 (void) ThrowMagickException(exception,GetMagickModule(),CoderError,
194 message,"`%s'","OpenJP2");
197 static OPJ_SIZE_T JP2ReadHandler(void *buffer,OPJ_SIZE_T length,void *context)
205 image=(Image *) context;
206 count=ReadBlob(image,(ssize_t) length,(unsigned char *) buffer);
208 return((OPJ_SIZE_T) -1);
209 return((OPJ_SIZE_T) count);
212 static OPJ_BOOL JP2SeekHandler(OPJ_OFF_T offset,void *context)
217 image=(Image *) context;
218 return(SeekBlob(image,offset,SEEK_SET) < 0 ? OPJ_FALSE : OPJ_TRUE);
221 static OPJ_OFF_T JP2SkipHandler(OPJ_OFF_T offset,void *context)
226 image=(Image *) context;
227 return(SeekBlob(image,offset,SEEK_CUR) < 0 ? -1 : offset);
230 static void JP2WarningHandler(const char *message,void *client_data)
235 exception=(ExceptionInfo *) client_data;
236 (void) ThrowMagickException(exception,GetMagickModule(),CoderWarning,
237 message,"`%s'","OpenJP2");
240 static OPJ_SIZE_T JP2WriteHandler(void *buffer,OPJ_SIZE_T length,void *context)
248 image=(Image *) context;
249 count=WriteBlob(image,(ssize_t) length,(unsigned char *) buffer);
250 return((OPJ_SIZE_T) count);
253 static Image *ReadJP2Image(const ImageInfo *image_info,ExceptionInfo *exception)
270 opj_codestream_index_t
271 *codestream_index = (opj_codestream_index_t *) NULL;
294 assert(image_info != (const ImageInfo *) NULL);
295 assert(image_info->signature == MagickSignature);
296 if (image_info->debug != MagickFalse)
297 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
298 image_info->filename);
299 assert(exception != (ExceptionInfo *) NULL);
300 assert(exception->signature == MagickSignature);
301 image=AcquireImage(image_info,exception);
302 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
303 if (status == MagickFalse)
305 image=DestroyImageList(image);
306 return((Image *) NULL);
309 Initialize JP2 codec.
311 if (ReadBlob(image,4,sans) != 4)
313 image=DestroyImageList(image);
314 return((Image *) NULL);
316 (void) SeekBlob(image,SEEK_SET,0);
317 if (LocaleCompare(image_info->magick,"JPT") == 0)
318 jp2_codec=opj_create_decompress(OPJ_CODEC_JPT);
320 if (IsJ2K(sans,4) != MagickFalse)
321 jp2_codec=opj_create_decompress(OPJ_CODEC_J2K);
323 jp2_codec=opj_create_decompress(OPJ_CODEC_JP2);
324 opj_set_warning_handler(jp2_codec,JP2WarningHandler,exception);
325 opj_set_error_handler(jp2_codec,JP2ErrorHandler,exception);
326 opj_set_default_decoder_parameters(¶meters);
327 option=GetImageOption(image_info,"jp2:reduce-factor");
328 if (option != (const char *) NULL)
329 parameters.cp_reduce=StringToInteger(option);
330 option=GetImageOption(image_info,"jp2:quality-layers");
331 if (option != (const char *) NULL)
332 parameters.cp_layer=StringToInteger(option);
333 if (opj_setup_decoder(jp2_codec,¶meters) == 0)
335 opj_destroy_codec(jp2_codec);
336 ThrowReaderException(DelegateError,"UnableToManageJP2Stream");
338 jp2_stream=opj_stream_create(OPJ_J2K_STREAM_CHUNK_SIZE,1);
339 opj_stream_set_read_function(jp2_stream,JP2ReadHandler);
340 opj_stream_set_write_function(jp2_stream,JP2WriteHandler);
341 opj_stream_set_seek_function(jp2_stream,JP2SeekHandler);
342 opj_stream_set_skip_function(jp2_stream,JP2SkipHandler);
343 opj_stream_set_user_data(jp2_stream,image,NULL);
344 opj_stream_set_user_data_length(jp2_stream,GetBlobSize(image));
345 if (opj_read_header(jp2_stream,jp2_codec,&jp2_image) == 0)
347 opj_stream_destroy(jp2_stream);
348 opj_destroy_codec(jp2_codec);
349 ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
352 if ((image->columns != 0) && (image->rows != 0))
355 Extract an area from the image.
357 jp2_status=opj_set_decode_area(jp2_codec,jp2_image,image->extract_info.x,
358 image->extract_info.y,image->extract_info.x+(ssize_t) image->columns,
359 image->extract_info.y+(ssize_t) image->rows);
362 opj_stream_destroy(jp2_stream);
363 opj_destroy_codec(jp2_codec);
364 opj_image_destroy(jp2_image);
365 ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
368 if (image_info->number_scenes != 0)
369 jp2_status=opj_get_decoded_tile(jp2_codec,jp2_stream,jp2_image,
370 (unsigned int) image_info->scene);
372 if (image->ping == MagickFalse)
374 jp2_status=opj_decode(jp2_codec,jp2_stream,jp2_image);
376 jp2_status=opj_end_decompress(jp2_codec,jp2_stream);
380 opj_stream_destroy(jp2_stream);
381 opj_destroy_codec(jp2_codec);
382 opj_image_destroy(jp2_image);
383 ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
385 opj_stream_destroy(jp2_stream);
386 for (i=0; i < (ssize_t) jp2_image->numcomps; i++)
388 if ((jp2_image->comps[i].dx == 0) || (jp2_image->comps[i].dy == 0))
390 opj_destroy_codec(jp2_codec);
391 opj_image_destroy(jp2_image);
392 ThrowReaderException(CoderError,"IrregularChannelGeometryNotSupported")
398 image->columns=(size_t) jp2_image->comps[0].w;
399 image->rows=(size_t) jp2_image->comps[0].h;
400 image->depth=jp2_image->comps[0].prec;
401 image->compression=JPEG2000Compression;
402 if (jp2_image->numcomps <= 2)
404 SetImageColorspace(image,GRAYColorspace,exception);
405 if (jp2_image->numcomps > 1)
406 image->alpha_trait=BlendPixelTrait;
408 if (jp2_image->numcomps > 3)
409 image->alpha_trait=BlendPixelTrait;
410 for (i=0; i < (ssize_t) jp2_image->numcomps; i++)
411 if ((jp2_image->comps[i].dx > 1) || (jp2_image->comps[i].dy > 1))
412 SetImageColorspace(image,YUVColorspace,exception);
413 if (jp2_image->icc_profile_buf != (unsigned char *) NULL)
418 profile=BlobToStringInfo(jp2_image->icc_profile_buf,
419 jp2_image->icc_profile_len);
420 if (profile != (StringInfo *) NULL)
421 SetImageProfile(image,"icc",profile,exception);
423 if (image->ping != MagickFalse)
425 opj_destroy_codec(jp2_codec);
426 opj_image_destroy(jp2_image);
427 opj_destroy_cstr_index(&codestream_index);
428 return(GetFirstImageInList(image));
430 for (y=0; y < (ssize_t) image->rows; y++)
438 q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
439 if (q == (Quantum *) NULL)
441 for (x=0; x < (ssize_t) image->columns; x++)
446 for (i=0; i < (ssize_t) jp2_image->numcomps; i++)
452 scale=QuantumRange/(double) ((1UL << jp2_image->comps[i].prec)-1);
453 pixel=scale*(jp2_image->comps[i].data[y/jp2_image->comps[i].dy*
454 image->columns/jp2_image->comps[i].dx+x/jp2_image->comps[i].dx]+
455 (jp2_image->comps[i].sgnd ? 1UL << (jp2_image->comps[i].prec-1) : 0));
460 SetPixelRed(image,ClampToQuantum(pixel),q);
461 SetPixelGreen(image,ClampToQuantum(pixel),q);
462 SetPixelBlue(image,ClampToQuantum(pixel),q);
463 SetPixelAlpha(image,OpaqueAlpha,q);
468 if (jp2_image->numcomps == 2)
470 SetPixelAlpha(image,ClampToQuantum(pixel),q);
473 SetPixelGreen(image,ClampToQuantum(pixel),q);
478 SetPixelBlue(image,ClampToQuantum(pixel),q);
483 SetPixelAlpha(image,ClampToQuantum(pixel),q);
488 q+=GetPixelChannels(image);
490 if (SyncAuthenticPixels(image,exception) == MagickFalse)
492 status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
494 if (status == MagickFalse)
500 opj_destroy_codec(jp2_codec);
501 opj_image_destroy(jp2_image);
502 opj_destroy_cstr_index(&codestream_index);
503 return(GetFirstImageInList(image));
508 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
512 % R e g i s t e r J P 2 I m a g e %
516 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
518 % RegisterJP2Image() adds attributes for the JP2 image format to the list of
519 % supported formats. The attributes include the image format tag, a method
520 % method to read and/or write the format, whether the format supports the
521 % saving of more than one frame to the same file or blob, whether the format
522 % supports native in-memory I/O, and a brief description of the format.
524 % The format of the RegisterJP2Image method is:
526 % size_t RegisterJP2Image(void)
529 ModuleExport size_t RegisterJP2Image(void)
532 version[MaxTextExtent];
538 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
539 (void) FormatLocaleString(version,MaxTextExtent,"%s",opj_version());
541 entry=SetMagickInfo("JP2");
542 entry->description=ConstantString("JPEG-2000 File Format Syntax");
543 if (*version != '\0')
544 entry->version=ConstantString(version);
545 entry->mime_type=ConstantString("image/jp2");
546 entry->module=ConstantString("JP2");
547 entry->magick=(IsImageFormatHandler *) IsJP2;
548 entry->adjoin=MagickFalse;
549 entry->seekable_stream=MagickTrue;
550 entry->thread_support=NoThreadSupport;
551 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
552 entry->decoder=(DecodeImageHandler *) ReadJP2Image;
553 entry->encoder=(EncodeImageHandler *) WriteJP2Image;
555 (void) RegisterMagickInfo(entry);
556 entry=SetMagickInfo("J2C");
557 entry->description=ConstantString("JPEG-2000 Code Stream Syntax");
558 if (*version != '\0')
559 entry->version=ConstantString(version);
560 entry->mime_type=ConstantString("image/jp2");
561 entry->module=ConstantString("JP2");
562 entry->magick=(IsImageFormatHandler *) IsJ2K;
563 entry->adjoin=MagickFalse;
564 entry->seekable_stream=MagickTrue;
565 entry->thread_support=NoThreadSupport;
566 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
567 entry->decoder=(DecodeImageHandler *) ReadJP2Image;
568 entry->encoder=(EncodeImageHandler *) WriteJP2Image;
570 (void) RegisterMagickInfo(entry);
571 entry=SetMagickInfo("J2K");
572 entry->description=ConstantString("JPEG-2000 Code Stream Syntax");
573 if (*version != '\0')
574 entry->version=ConstantString(version);
575 entry->mime_type=ConstantString("image/jp2");
576 entry->module=ConstantString("JP2");
577 entry->magick=(IsImageFormatHandler *) IsJ2K;
578 entry->adjoin=MagickFalse;
579 entry->seekable_stream=MagickTrue;
580 entry->thread_support=NoThreadSupport;
581 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
582 entry->decoder=(DecodeImageHandler *) ReadJP2Image;
583 entry->encoder=(EncodeImageHandler *) WriteJP2Image;
585 (void) RegisterMagickInfo(entry);
586 entry=SetMagickInfo("JPM");
587 entry->description=ConstantString("JPEG-2000 File Format Syntax");
588 if (*version != '\0')
589 entry->version=ConstantString(version);
590 entry->mime_type=ConstantString("image/jp2");
591 entry->module=ConstantString("JP2");
592 entry->magick=(IsImageFormatHandler *) IsJP2;
593 entry->adjoin=MagickFalse;
594 entry->seekable_stream=MagickTrue;
595 entry->thread_support=NoThreadSupport;
596 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
597 entry->decoder=(DecodeImageHandler *) ReadJP2Image;
598 entry->encoder=(EncodeImageHandler *) WriteJP2Image;
600 (void) RegisterMagickInfo(entry);
601 entry=SetMagickInfo("JPT");
602 entry->description=ConstantString("JPEG-2000 File Format Syntax");
603 if (*version != '\0')
604 entry->version=ConstantString(version);
605 entry->mime_type=ConstantString("image/jp2");
606 entry->module=ConstantString("JP2");
607 entry->magick=(IsImageFormatHandler *) IsJP2;
608 entry->adjoin=MagickFalse;
609 entry->seekable_stream=MagickTrue;
610 entry->thread_support=NoThreadSupport;
611 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
612 entry->decoder=(DecodeImageHandler *) ReadJP2Image;
613 entry->encoder=(EncodeImageHandler *) WriteJP2Image;
615 (void) RegisterMagickInfo(entry);
616 entry=SetMagickInfo("JPC");
617 entry->description=ConstantString("JPEG-2000 Code Stream Syntax");
618 if (*version != '\0')
619 entry->version=ConstantString(version);
620 entry->mime_type=ConstantString("image/jp2");
621 entry->module=ConstantString("JP2");
622 entry->magick=(IsImageFormatHandler *) IsJP2;
623 entry->adjoin=MagickFalse;
624 entry->seekable_stream=MagickTrue;
625 entry->thread_support=NoThreadSupport;
626 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
627 entry->decoder=(DecodeImageHandler *) ReadJP2Image;
628 entry->encoder=(EncodeImageHandler *) WriteJP2Image;
630 (void) RegisterMagickInfo(entry);
631 return(MagickImageCoderSignature);
635 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
639 % U n r e g i s t e r J P 2 I m a g e %
643 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
645 % UnregisterJP2Image() removes format registrations made by the JP2 module
646 % from the list of supported formats.
648 % The format of the UnregisterJP2Image method is:
650 % UnregisterJP2Image(void)
653 ModuleExport void UnregisterJP2Image(void)
655 (void) UnregisterMagickInfo("JPC");
656 (void) UnregisterMagickInfo("JPT");
657 (void) UnregisterMagickInfo("JPM");
658 (void) UnregisterMagickInfo("JP2");
659 (void) UnregisterMagickInfo("J2K");
662 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
664 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
668 % W r i t e J P 2 I m a g e %
672 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
674 % WriteJP2Image() writes an image in the JPEG 2000 image format.
676 % JP2 support originally written by Nathan Brown, nathanbrown@letu.edu
678 % The format of the WriteJP2Image method is:
680 % MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image,
681 % ExceptionInfo *exception)
683 % A description of each parameter follows.
685 % o image_info: the image info.
687 % o image: The image.
691 static void CinemaProfileCompliance(const opj_image_t *jp2_image,
692 opj_cparameters_t *parameters)
695 Digital Cinema 4K profile compliant codestream.
697 parameters->tile_size_on=OPJ_FALSE;
698 parameters->cp_tdx=1;
699 parameters->cp_tdy=1;
700 parameters->tp_flag='C';
702 parameters->cp_tx0=0;
703 parameters->cp_ty0=0;
704 parameters->image_offset_x0=0;
705 parameters->image_offset_y0=0;
706 parameters->cblockw_init=32;
707 parameters->cblockh_init=32;
708 parameters->csty|=0x01;
709 parameters->prog_order=OPJ_CPRL;
710 parameters->roi_compno=(-1);
711 parameters->subsampling_dx=1;
712 parameters->subsampling_dy=1;
713 parameters->irreversible=1;
714 if ((jp2_image->comps[0].w == 2048) || (jp2_image->comps[0].h == 1080))
719 parameters->cp_cinema=OPJ_CINEMA2K_24;
720 parameters->cp_rsiz=OPJ_CINEMA2K;
721 parameters->max_comp_size=1041666;
722 if (parameters->numresolution > 6)
723 parameters->numresolution=6;
726 if ((jp2_image->comps[0].w == 4096) || (jp2_image->comps[0].h == 2160))
731 parameters->cp_cinema=OPJ_CINEMA4K_24;
732 parameters->cp_rsiz=OPJ_CINEMA4K;
733 parameters->max_comp_size=1041666;
734 if (parameters->numresolution < 1)
735 parameters->numresolution=1;
736 if (parameters->numresolution > 7)
737 parameters->numresolution=7;
738 parameters->numpocs=2;
739 parameters->POC[0].tile=1;
740 parameters->POC[0].resno0=0;
741 parameters->POC[0].compno0=0;
742 parameters->POC[0].layno1=1;
743 parameters->POC[0].resno1=parameters->numresolution-1;
744 parameters->POC[0].compno1=3;
745 parameters->POC[0].prg1=OPJ_CPRL;
746 parameters->POC[1].tile=1;
747 parameters->POC[1].resno0=parameters->numresolution-1;
748 parameters->POC[1].compno0=0;
749 parameters->POC[1].layno1=1;
750 parameters->POC[1].resno1=parameters->numresolution;
751 parameters->POC[1].compno1=3;
752 parameters->POC[1].prg1=OPJ_CPRL;
754 parameters->tcp_numlayers=1;
755 parameters->tcp_rates[0]=((float) (jp2_image->numcomps*jp2_image->comps[0].w*
756 jp2_image->comps[0].h*jp2_image->comps[0].prec))/(parameters->max_comp_size*
757 8*jp2_image->comps[0].dx*jp2_image->comps[0].dy);
758 parameters->cp_disto_alloc=1;
761 static MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image,
762 ExceptionInfo *exception)
804 assert(image_info != (const ImageInfo *) NULL);
805 assert(image_info->signature == MagickSignature);
806 assert(image != (Image *) NULL);
807 assert(image->signature == MagickSignature);
808 if (image->debug != MagickFalse)
809 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
810 assert(exception != (ExceptionInfo *) NULL);
811 assert(exception->signature == MagickSignature);
812 status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
813 if (status == MagickFalse)
816 Initialize JPEG 2000 API.
818 opj_set_default_encoder_parameters(¶meters);
819 for (i=1; i < 6; i++)
820 if (((1U << (i+2)) > image->columns) && ((1U << (i+2)) > image->rows))
822 parameters.numresolution=i;
823 option=GetImageOption(image_info,"jp2:number-resolutions");
824 if (option != (const char *) NULL)
825 parameters.numresolution=StringToInteger(option);
826 parameters.tcp_numlayers=1;
827 parameters.tcp_rates[0]=0; /* lossless */
828 parameters.cp_disto_alloc=1;
829 if (image->quality != 0)
831 parameters.tcp_distoratio[0]=(double) image->quality;
832 parameters.cp_fixed_quality=OPJ_TRUE;
834 if (image_info->extract != (char *) NULL)
845 flags=ParseAbsoluteGeometry(image_info->extract,&geometry);
846 parameters.cp_tdx=(int) geometry.width;
847 parameters.cp_tdy=(int) geometry.width;
848 if ((flags & HeightValue) != 0)
849 parameters.cp_tdy=(int) geometry.height;
850 if ((flags & XValue) != 0)
851 parameters.cp_tx0=geometry.x;
852 if ((flags & YValue) != 0)
853 parameters.cp_ty0=geometry.y;
854 parameters.tile_size_on=OPJ_TRUE;
856 option=GetImageOption(image_info,"jp2:quality");
857 if (option != (const char *) NULL)
866 for (i=0; sscanf(p,"%f",¶meters.tcp_distoratio[i]) == 1; i++)
870 while ((*p != '\0') && (*p != ','))
876 parameters.tcp_numlayers=i+1;
877 parameters.cp_fixed_quality=OPJ_TRUE;
879 option=GetImageOption(image_info,"jp2:progression-order");
880 if (option != (const char *) NULL)
882 if (LocaleCompare(option,"LRCP") == 0)
883 parameters.prog_order=OPJ_LRCP;
884 if (LocaleCompare(option,"RLCP") == 0)
885 parameters.prog_order=OPJ_RLCP;
886 if (LocaleCompare(option,"RPCL") == 0)
887 parameters.prog_order=OPJ_RPCL;
888 if (LocaleCompare(option,"PCRL") == 0)
889 parameters.prog_order=OPJ_PCRL;
890 if (LocaleCompare(option,"CPRL") == 0)
891 parameters.prog_order=OPJ_CPRL;
893 option=GetImageOption(image_info,"jp2:rate");
894 if (option != (const char *) NULL)
900 Set compression rate.
903 for (i=0; sscanf(p,"%f",¶meters.tcp_rates[i]) == 1; i++)
907 while ((*p != '\0') && (*p != ','))
913 parameters.tcp_numlayers=i+1;
914 parameters.cp_disto_alloc=OPJ_TRUE;
916 if (image_info->sampling_factor != (const char *) NULL)
917 (void) sscanf(image_info->sampling_factor,"%d,%d",
918 ¶meters.subsampling_dx,¶meters.subsampling_dy);
919 property=GetImageProperty(image,"comment",exception);
920 if (property != (const char *) NULL)
921 parameters.cp_comment=ConstantString(property);
923 jp2_colorspace=OPJ_CLRSPC_SRGB;
924 if (image->colorspace == YUVColorspace)
926 jp2_colorspace=OPJ_CLRSPC_SYCC;
927 parameters.subsampling_dx=2;
931 (void) TransformImageColorspace(image,sRGBColorspace,exception);
932 if (IsGrayColorspace(image->colorspace) != MagickFalse)
935 jp2_colorspace=OPJ_CLRSPC_GRAY;
937 if (image->alpha_trait == BlendPixelTrait)
940 parameters.tcp_mct=channels == 3 ? 1 : 0;
941 ResetMagickMemory(jp2_info,0,sizeof(jp2_info));
942 for (i=0; i < (ssize_t) channels; i++)
944 jp2_info[i].prec=image->depth;
945 jp2_info[i].bpp=image->depth;
946 if ((image->depth == 1) &&
947 ((LocaleCompare(image_info->magick,"JPT") == 0) ||
948 (LocaleCompare(image_info->magick,"JP2") == 0)))
950 jp2_info[i].prec++; /* OpenJPEG returns exception for depth @ 1 */
954 jp2_info[i].dx=parameters.subsampling_dx;
955 jp2_info[i].dy=parameters.subsampling_dy;
956 jp2_info[i].w=image->columns;
957 jp2_info[i].h=image->rows;
959 jp2_image=opj_image_create(channels,jp2_info,jp2_colorspace);
960 if (jp2_image == (opj_image_t *) NULL)
961 ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
962 jp2_image->x0=parameters.image_offset_x0;
963 jp2_image->y0=parameters.image_offset_y0;
964 jp2_image->x1=(unsigned int) (2*parameters.image_offset_x0+(image->columns-1)*
965 parameters.subsampling_dx+1);
966 jp2_image->y1=(unsigned int) (2*parameters.image_offset_y0+(image->rows-1)*
967 parameters.subsampling_dx+1);
968 if ((image->depth == 12) &&
969 ((image->columns == 2048) || (image->rows == 1080) ||
970 (image->columns == 4096) || (image->rows == 2160)))
971 CinemaProfileCompliance(jp2_image,¶meters);
973 Convert to JP2 pixels.
975 for (y=0; y < (ssize_t) image->rows; y++)
977 register const Quantum
983 p=GetVirtualPixels(image,0,y,image->columns,1,exception);
984 if (p == (const Quantum *) NULL)
986 for (x=0; x < (ssize_t) image->columns; x++)
988 for (i=0; i < (ssize_t) channels; i++)
996 scale=(double) ((1UL << jp2_image->comps[i].prec)-1)/QuantumRange;
997 q=jp2_image->comps[i].data+(y/jp2_image->comps[i].dy*
998 image->columns/jp2_image->comps[i].dx+x/jp2_image->comps[i].dx);
1003 if (jp2_colorspace == OPJ_CLRSPC_GRAY)
1005 *q=(int) (scale*GetPixelLuma(image,p));
1008 *q=(int) (scale*GetPixelRed(image,p));
1013 if (jp2_colorspace == OPJ_CLRSPC_GRAY)
1015 *q=(int) (scale*GetPixelAlpha(image,p));
1018 *q=(int) (scale*GetPixelGreen(image,p));
1023 *q=(int) (scale*GetPixelBlue(image,p));
1028 *q=(int) (scale*GetPixelAlpha(image,p));
1033 p+=GetPixelChannels(image);
1035 status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1037 if (status == MagickFalse)
1040 if (LocaleCompare(image_info->magick,"JPT") == 0)
1041 jp2_codec=opj_create_compress(OPJ_CODEC_JPT);
1043 if (LocaleCompare(image_info->magick,"J2K") == 0)
1044 jp2_codec=opj_create_compress(OPJ_CODEC_J2K);
1046 jp2_codec=opj_create_compress(OPJ_CODEC_JP2);
1047 opj_set_warning_handler(jp2_codec,JP2WarningHandler,exception);
1048 opj_set_error_handler(jp2_codec,JP2ErrorHandler,exception);
1049 opj_setup_encoder(jp2_codec,¶meters,jp2_image);
1050 jp2_stream=opj_stream_create(OPJ_J2K_STREAM_CHUNK_SIZE,OPJ_FALSE);
1051 opj_stream_set_read_function(jp2_stream,JP2ReadHandler);
1052 opj_stream_set_write_function(jp2_stream,JP2WriteHandler);
1053 opj_stream_set_seek_function(jp2_stream,JP2SeekHandler);
1054 opj_stream_set_skip_function(jp2_stream,JP2SkipHandler);
1055 opj_stream_set_user_data(jp2_stream,image,NULL);
1056 if (jp2_stream == (opj_stream_t *) NULL)
1057 ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
1058 jp2_status=opj_start_compress(jp2_codec,jp2_image,jp2_stream);
1059 if (jp2_status == 0)
1060 ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
1061 if ((opj_encode(jp2_codec,jp2_stream) == 0) ||
1062 (opj_end_compress(jp2_codec,jp2_stream) == 0))
1064 opj_stream_destroy(jp2_stream);
1065 opj_destroy_codec(jp2_codec);
1066 opj_image_destroy(jp2_image);
1067 ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
1072 opj_stream_destroy(jp2_stream);
1073 opj_destroy_codec(jp2_codec);
1074 opj_image_destroy(jp2_image);
1075 (void) CloseBlob(image);