granicus.if.org Git - imagemagick/blob - coders/jp2.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                              JJJ  PPPP    222                               %
   7 %                               J   P   P  2   2                              %
   8 %                               J   PPPP     22                               %
   9 %                            J  J   P       2                                 %
  10 %                             JJ    P      22222                              %
  11 %                                                                             %
  12 %                                                                             %
  13 %                     Read/Write JPEG-2000 Image Format                       %
  14 %                                                                             %
  15 %                                   Cristy                                    %
  16 %                                Nathan Brown                                 %
  17 %                                 June 2001                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2017 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    https://www.imagemagick.org/script/license.php                           %
  27 %                                                                             %
  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.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40   Include declarations.
  41 */
  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)
  73 #include <openjpeg.h>
  74 #endif
  75 \f
  76 /*
  77   Forward declarations.
  78 */
  79 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
  80 static MagickBooleanType
  81   WriteJP2Image(const ImageInfo *,Image *,ExceptionInfo *);
  82 #endif
  83 \f
  84 /*
  85 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  86 %                                                                             %
  87 %                                                                             %
  88 %                                                                             %
  89 %   I s J 2 K                                                                 %
  90 %                                                                             %
  91 %                                                                             %
  92 %                                                                             %
  93 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  94 %
  95 %  IsJ2K() returns MagickTrue if the image format type, identified by the
  96 %  magick string, is J2K.
  97 %
  98 %  The format of the IsJ2K method is:
  99 %
 100 %      MagickBooleanType IsJ2K(const unsigned char *magick,const size_t length)
 101 %
 102 %  A description of each parameter follows:
 103 %
 104 %    o magick: compare image format pattern against these bytes.
 105 %
 106 %    o length: Specifies the length of the magick string.
 107 %
 108 */
 109 static MagickBooleanType IsJ2K(const unsigned char *magick,const size_t length)
 110 {
 111   if (length < 4)
 112     return(MagickFalse);
 113   if (memcmp(magick,"\xff\x4f\xff\x51",4) == 0)
 114     return(MagickTrue);
 115   return(MagickFalse);
 116 }
 117 \f
 118 /*
 119 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 120 %                                                                             %
 121 %                                                                             %
 122 %                                                                             %
 123 %   I s J P 2                                                                 %
 124 %                                                                             %
 125 %                                                                             %
 126 %                                                                             %
 127 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 128 %
 129 %  IsJP2() returns MagickTrue if the image format type, identified by the
 130 %  magick string, is JP2.
 131 %
 132 %  The format of the IsJP2 method is:
 133 %
 134 %      MagickBooleanType IsJP2(const unsigned char *magick,const size_t length)
 135 %
 136 %  A description of each parameter follows:
 137 %
 138 %    o magick: compare image format pattern against these bytes.
 139 %
 140 %    o length: Specifies the length of the magick string.
 141 %
 142 */
 143 static MagickBooleanType IsJP2(const unsigned char *magick,const size_t length)
 144 {
 145   if (length < 4)
 146     return(MagickFalse);
 147   if (memcmp(magick,"\x0d\x0a\x87\x0a",4) == 0)
 148     return(MagickTrue);
 149   if (length < 12)
 150     return(MagickFalse);
 151   if (memcmp(magick,"\x00\x00\x00\x0c\x6a\x50\x20\x20\x0d\x0a\x87\x0a",12) == 0)
 152     return(MagickTrue);
 153   return(MagickFalse);
 154 }
 155 \f
 156 /*
 157 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 158 %                                                                             %
 159 %                                                                             %
 160 %                                                                             %
 161 %   R e a d J P 2 I m a g e                                                   %
 162 %                                                                             %
 163 %                                                                             %
 164 %                                                                             %
 165 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 166 %
 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.
 171 %
 172 %  JP2 support is originally written by Nathan Brown, nathanbrown@letu.edu.
 173 %
 174 %  The format of the ReadJP2Image method is:
 175 %
 176 %      Image *ReadJP2Image(const ImageInfo *image_info,
 177 %        ExceptionInfo *exception)
 178 %
 179 %  A description of each parameter follows:
 180 %
 181 %    o image_info: the image info.
 182 %
 183 %    o exception: return any errors or warnings in this structure.
 184 %
 185 */
 186 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
 187 static void JP2ErrorHandler(const char *message,void *client_data)
 188 {
 189   ExceptionInfo
 190     *exception;
 191
 192   exception=(ExceptionInfo *) client_data;
 193   (void) ThrowMagickException(exception,GetMagickModule(),CoderError,
 194     message,"`%s'","OpenJP2");
 195 }
 196
 197 static OPJ_SIZE_T JP2ReadHandler(void *buffer,OPJ_SIZE_T length,void *context)
 198 {
 199   Image
 200     *image;
 201
 202   ssize_t
 203     count;
 204
 205   image=(Image *) context;
 206   count=ReadBlob(image,(ssize_t) length,(unsigned char *) buffer);
 207   if (count == 0)
 208     return((OPJ_SIZE_T) -1);
 209   return((OPJ_SIZE_T) count);
 210 }
 211
 212 static OPJ_BOOL JP2SeekHandler(OPJ_OFF_T offset,void *context)
 213 {
 214   Image
 215     *image;
 216
 217   image=(Image *) context;
 218   return(SeekBlob(image,offset,SEEK_SET) < 0 ? OPJ_FALSE : OPJ_TRUE);
 219 }
 220
 221 static OPJ_OFF_T JP2SkipHandler(OPJ_OFF_T offset,void *context)
 222 {
 223   Image
 224     *image;
 225
 226   image=(Image *) context;
 227   return(SeekBlob(image,offset,SEEK_CUR) < 0 ? -1 : offset);
 228 }
 229
 230 static void JP2WarningHandler(const char *message,void *client_data)
 231 {
 232   ExceptionInfo
 233     *exception;
 234
 235   exception=(ExceptionInfo *) client_data;
 236   (void) ThrowMagickException(exception,GetMagickModule(),CoderWarning,
 237     message,"`%s'","OpenJP2");
 238 }
 239
 240 static OPJ_SIZE_T JP2WriteHandler(void *buffer,OPJ_SIZE_T length,void *context)
 241 {
 242   Image
 243     *image;
 244
 245   ssize_t
 246     count;
 247
 248   image=(Image *) context;
 249   count=WriteBlob(image,(ssize_t) length,(unsigned char *) buffer);
 250   return((OPJ_SIZE_T) count);
 251 }
 252
 253 static Image *ReadJP2Image(const ImageInfo *image_info,ExceptionInfo *exception)
 254 {
 255   const char
 256     *option;
 257
 258   Image
 259     *image;
 260
 261   int
 262     jp2_status;
 263
 264   MagickBooleanType
 265     status;
 266
 267   opj_codec_t
 268     *jp2_codec;
 269
 270   opj_codestream_index_t
 271     *codestream_index = (opj_codestream_index_t *) NULL;
 272
 273   opj_dparameters_t
 274     parameters;
 275
 276   opj_image_t
 277     *jp2_image;
 278
 279   opj_stream_t
 280     *jp2_stream;
 281
 282   register ssize_t
 283     i;
 284
 285   ssize_t
 286     y;
 287
 288   unsigned char
 289     sans[4];
 290
 291   /*
 292     Open image file.
 293   */
 294   assert(image_info != (const ImageInfo *) NULL);
 295   assert(image_info->signature == MagickCoreSignature);
 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 == MagickCoreSignature);
 301   image=AcquireImage(image_info,exception);
 302   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 303   if (status == MagickFalse)
 304     {
 305       image=DestroyImageList(image);
 306       return((Image *) NULL);
 307     }
 308   /*
 309     Initialize JP2 codec.
 310   */
 311   if (ReadBlob(image,4,sans) != 4)
 312     {
 313       image=DestroyImageList(image);
 314       return((Image *) NULL);
 315     }
 316   (void) SeekBlob(image,SEEK_SET,0);
 317   if (LocaleCompare(image_info->magick,"JPT") == 0)
 318     jp2_codec=opj_create_decompress(OPJ_CODEC_JPT);
 319   else
 320     if (IsJ2K(sans,4) != MagickFalse)
 321       jp2_codec=opj_create_decompress(OPJ_CODEC_J2K);
 322     else
 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(&parameters);
 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,&parameters) == 0)
 334     {
 335       opj_destroy_codec(jp2_codec);
 336       ThrowReaderException(DelegateError,"UnableToManageJP2Stream");
 337     }
 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)
 346     {
 347       opj_stream_destroy(jp2_stream);
 348       opj_destroy_codec(jp2_codec);
 349       ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
 350     }
 351   jp2_status=1;
 352   if ((image->columns != 0) && (image->rows != 0))
 353     {
 354       /*
 355         Extract an area from the image.
 356       */
 357       jp2_status=opj_set_decode_area(jp2_codec,jp2_image,
 358         (OPJ_INT32) image->extract_info.x,(OPJ_INT32) image->extract_info.y,
 359         (OPJ_INT32) (image->extract_info.x+(ssize_t) image->columns),
 360         (OPJ_INT32) (image->extract_info.y+(ssize_t) image->rows));
 361       if (jp2_status == 0)
 362         {
 363           opj_stream_destroy(jp2_stream);
 364           opj_destroy_codec(jp2_codec);
 365           opj_image_destroy(jp2_image);
 366           ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
 367         }
 368     }
 369    if ((image_info->number_scenes != 0) && (image_info->scene != 0))
 370     jp2_status=opj_get_decoded_tile(jp2_codec,jp2_stream,jp2_image,
 371       (unsigned int) image_info->scene-1);
 372   else
 373     if (image->ping == MagickFalse)
 374       {
 375         jp2_status=opj_decode(jp2_codec,jp2_stream,jp2_image);
 376         if (jp2_status != 0)
 377           jp2_status=opj_end_decompress(jp2_codec,jp2_stream);
 378       }
 379   if (jp2_status == 0)
 380     {
 381       opj_stream_destroy(jp2_stream);
 382       opj_destroy_codec(jp2_codec);
 383       opj_image_destroy(jp2_image);
 384       ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
 385     }
 386   opj_stream_destroy(jp2_stream);
 387   for (i=0; i < (ssize_t) jp2_image->numcomps; i++)
 388   {
 389     if ((jp2_image->comps[0].dx == 0) || (jp2_image->comps[0].dy == 0) ||
 390         (jp2_image->comps[0].dx != jp2_image->comps[i].dx) ||
 391         (jp2_image->comps[0].dy != jp2_image->comps[i].dy) ||
 392         (jp2_image->comps[0].prec != jp2_image->comps[i].prec) ||
 393         (jp2_image->comps[0].sgnd != jp2_image->comps[i].sgnd))
 394       {
 395         opj_destroy_codec(jp2_codec);
 396         opj_image_destroy(jp2_image);
 397         ThrowReaderException(CoderError,"IrregularChannelGeometryNotSupported")
 398       }
 399   }
 400   /*
 401     Convert JP2 image.
 402   */
 403   image->columns=(size_t) jp2_image->comps[0].w;
 404   image->rows=(size_t) jp2_image->comps[0].h;
 405   image->depth=jp2_image->comps[0].prec;
 406   status=SetImageExtent(image,image->columns,image->rows,exception);
 407   if (status == MagickFalse)
 408     return(DestroyImageList(image));
 409   image->compression=JPEG2000Compression;
 410   if (jp2_image->color_space == 2)
 411     {
 412       SetImageColorspace(image,GRAYColorspace,exception);
 413       if (jp2_image->numcomps > 1)
 414         image->alpha_trait=BlendPixelTrait;
 415     }
 416   else
 417     if (jp2_image->color_space == 3)
 418       SetImageColorspace(image,Rec601YCbCrColorspace,exception);
 419   if (jp2_image->numcomps > 3)
 420     image->alpha_trait=BlendPixelTrait;
 421   if (jp2_image->icc_profile_buf != (unsigned char *) NULL)
 422     {
 423       StringInfo
 424         *profile;
 425
 426       profile=BlobToStringInfo(jp2_image->icc_profile_buf,
 427         jp2_image->icc_profile_len);
 428       if (profile != (StringInfo *) NULL)
 429         SetImageProfile(image,"icc",profile,exception);
 430     }
 431   if (image->ping != MagickFalse)
 432     {
 433       opj_destroy_codec(jp2_codec);
 434       opj_image_destroy(jp2_image);
 435       opj_destroy_cstr_index(&codestream_index);
 436       return(GetFirstImageInList(image));
 437     }
 438   for (y=0; y < (ssize_t) image->rows; y++)
 439   {
 440     register Quantum
 441       *magick_restrict q;
 442
 443     register ssize_t
 444       x;
 445
 446     q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
 447     if (q == (Quantum *) NULL)
 448       break;
 449     for (x=0; x < (ssize_t) image->columns; x++)
 450     {
 451       register ssize_t
 452         i;
 453
 454       for (i=0; i < (ssize_t) jp2_image->numcomps; i++)
 455       {
 456         double
 457           pixel,
 458           scale;
 459
 460         scale=QuantumRange/(double) ((1UL << jp2_image->comps[i].prec)-1);
 461         pixel=scale*(jp2_image->comps[i].data[y/jp2_image->comps[i].dy*
 462           image->columns/jp2_image->comps[i].dx+x/jp2_image->comps[i].dx]+
 463           (jp2_image->comps[i].sgnd ? 1UL << (jp2_image->comps[i].prec-1) : 0));
 464         switch (i)
 465         {
 466            case 0:
 467            {
 468              SetPixelRed(image,ClampToQuantum(pixel),q);
 469              SetPixelGreen(image,ClampToQuantum(pixel),q);
 470              SetPixelBlue(image,ClampToQuantum(pixel),q);
 471              SetPixelAlpha(image,OpaqueAlpha,q);
 472              break;
 473            }
 474            case 1:
 475            {
 476              if (jp2_image->numcomps == 2)
 477                {
 478                  SetPixelAlpha(image,ClampToQuantum(pixel),q);
 479                  break;
 480                }
 481              SetPixelGreen(image,ClampToQuantum(pixel),q);
 482              break;
 483            }
 484            case 2:
 485            {
 486              SetPixelBlue(image,ClampToQuantum(pixel),q);
 487              break;
 488            }
 489            case 3:
 490            {
 491              SetPixelAlpha(image,ClampToQuantum(pixel),q);
 492              break;
 493            }
 494         }
 495       }
 496       q+=GetPixelChannels(image);
 497     }
 498     if (SyncAuthenticPixels(image,exception) == MagickFalse)
 499       break;
 500     status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 501       image->rows);
 502     if (status == MagickFalse)
 503       break;
 504   }
 505   /*
 506     Free resources.
 507   */
 508   opj_destroy_codec(jp2_codec);
 509   opj_image_destroy(jp2_image);
 510   opj_destroy_cstr_index(&codestream_index);
 511   (void) CloseBlob(image);
 512   return(GetFirstImageInList(image));
 513 }
 514 #endif
 515 \f
 516 /*
 517 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 518 %                                                                             %
 519 %                                                                             %
 520 %                                                                             %
 521 %   R e g i s t e r J P 2 I m a g e                                           %
 522 %                                                                             %
 523 %                                                                             %
 524 %                                                                             %
 525 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 526 %
 527 %  RegisterJP2Image() adds attributes for the JP2 image format to the list of
 528 %  supported formats.  The attributes include the image format tag, a method
 529 %  method to read and/or write the format, whether the format supports the
 530 %  saving of more than one frame to the same file or blob, whether the format
 531 %  supports native in-memory I/O, and a brief description of the format.
 532 %
 533 %  The format of the RegisterJP2Image method is:
 534 %
 535 %      size_t RegisterJP2Image(void)
 536 %
 537 */
 538 ModuleExport size_t RegisterJP2Image(void)
 539 {
 540   char
 541     version[MagickPathExtent];
 542
 543   MagickInfo
 544     *entry;
 545
 546   *version='\0';
 547 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
 548   (void) FormatLocaleString(version,MagickPathExtent,"%s",opj_version());
 549 #endif
 550   entry=AcquireMagickInfo("JP2","JP2","JPEG-2000 File Format Syntax");
 551   if (*version != '\0')
 552     entry->version=ConstantString(version);
 553   entry->mime_type=ConstantString("image/jp2");
 554   entry->magick=(IsImageFormatHandler *) IsJP2;
 555   entry->flags^=CoderAdjoinFlag;
 556   entry->flags|=CoderDecoderSeekableStreamFlag;
 557   entry->flags|=CoderEncoderSeekableStreamFlag;
 558 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
 559   entry->decoder=(DecodeImageHandler *) ReadJP2Image;
 560   entry->encoder=(EncodeImageHandler *) WriteJP2Image;
 561 #endif
 562   (void) RegisterMagickInfo(entry);
 563   entry=AcquireMagickInfo("JP2","J2C","JPEG-2000 Code Stream Syntax");
 564   if (*version != '\0')
 565     entry->version=ConstantString(version);
 566   entry->mime_type=ConstantString("image/jp2");
 567   entry->magick=(IsImageFormatHandler *) IsJ2K;
 568   entry->flags^=CoderAdjoinFlag;
 569   entry->flags|=CoderDecoderSeekableStreamFlag;
 570   entry->flags|=CoderEncoderSeekableStreamFlag;
 571 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
 572   entry->decoder=(DecodeImageHandler *) ReadJP2Image;
 573   entry->encoder=(EncodeImageHandler *) WriteJP2Image;
 574 #endif
 575   (void) RegisterMagickInfo(entry);
 576   entry=AcquireMagickInfo("JP2","J2K","JPEG-2000 Code Stream Syntax");
 577   if (*version != '\0')
 578     entry->version=ConstantString(version);
 579   entry->mime_type=ConstantString("image/jp2");
 580   entry->magick=(IsImageFormatHandler *) IsJ2K;
 581   entry->flags^=CoderAdjoinFlag;
 582   entry->flags|=CoderDecoderSeekableStreamFlag;
 583   entry->flags|=CoderEncoderSeekableStreamFlag;
 584 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
 585   entry->decoder=(DecodeImageHandler *) ReadJP2Image;
 586   entry->encoder=(EncodeImageHandler *) WriteJP2Image;
 587 #endif
 588   (void) RegisterMagickInfo(entry);
 589   entry=AcquireMagickInfo("JP2","JPM","JPEG-2000 File Format Syntax");
 590   if (*version != '\0')
 591     entry->version=ConstantString(version);
 592   entry->mime_type=ConstantString("image/jp2");
 593   entry->magick=(IsImageFormatHandler *) IsJP2;
 594   entry->flags^=CoderAdjoinFlag;
 595   entry->flags|=CoderDecoderSeekableStreamFlag;
 596   entry->flags|=CoderEncoderSeekableStreamFlag;
 597 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
 598   entry->decoder=(DecodeImageHandler *) ReadJP2Image;
 599   entry->encoder=(EncodeImageHandler *) WriteJP2Image;
 600 #endif
 601   (void) RegisterMagickInfo(entry);
 602   entry=AcquireMagickInfo("JP2","JPT","JPEG-2000 File Format Syntax");
 603   if (*version != '\0')
 604     entry->version=ConstantString(version);
 605   entry->mime_type=ConstantString("image/jp2");
 606   entry->magick=(IsImageFormatHandler *) IsJP2;
 607   entry->flags^=CoderAdjoinFlag;
 608   entry->flags|=CoderDecoderSeekableStreamFlag;
 609   entry->flags|=CoderEncoderSeekableStreamFlag;
 610 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
 611   entry->decoder=(DecodeImageHandler *) ReadJP2Image;
 612   entry->encoder=(EncodeImageHandler *) WriteJP2Image;
 613 #endif
 614   (void) RegisterMagickInfo(entry);
 615   entry=AcquireMagickInfo("JP2","JPC","JPEG-2000 Code Stream Syntax");
 616   if (*version != '\0')
 617     entry->version=ConstantString(version);
 618   entry->mime_type=ConstantString("image/jp2");
 619   entry->magick=(IsImageFormatHandler *) IsJP2;
 620   entry->flags^=CoderAdjoinFlag;
 621   entry->flags|=CoderDecoderSeekableStreamFlag;
 622   entry->flags|=CoderEncoderSeekableStreamFlag;
 623 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
 624   entry->decoder=(DecodeImageHandler *) ReadJP2Image;
 625   entry->encoder=(EncodeImageHandler *) WriteJP2Image;
 626 #endif
 627   (void) RegisterMagickInfo(entry);
 628   return(MagickImageCoderSignature);
 629 }
 630 \f
 631 /*
 632 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 633 %                                                                             %
 634 %                                                                             %
 635 %                                                                             %
 636 %   U n r e g i s t e r J P 2 I m a g e                                       %
 637 %                                                                             %
 638 %                                                                             %
 639 %                                                                             %
 640 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 641 %
 642 %  UnregisterJP2Image() removes format registrations made by the JP2 module
 643 %  from the list of supported formats.
 644 %
 645 %  The format of the UnregisterJP2Image method is:
 646 %
 647 %      UnregisterJP2Image(void)
 648 %
 649 */
 650 ModuleExport void UnregisterJP2Image(void)
 651 {
 652   (void) UnregisterMagickInfo("JPC");
 653   (void) UnregisterMagickInfo("JPT");
 654   (void) UnregisterMagickInfo("JPM");
 655   (void) UnregisterMagickInfo("JP2");
 656   (void) UnregisterMagickInfo("J2K");
 657 }
 658 \f
 659 #if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
 660 /*
 661 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 662 %                                                                             %
 663 %                                                                             %
 664 %                                                                             %
 665 %   W r i t e J P 2 I m a g e                                                 %
 666 %                                                                             %
 667 %                                                                             %
 668 %                                                                             %
 669 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 670 %
 671 %  WriteJP2Image() writes an image in the JPEG 2000 image format.
 672 %
 673 %  JP2 support originally written by Nathan Brown, nathanbrown@letu.edu
 674 %
 675 %  The format of the WriteJP2Image method is:
 676 %
 677 %      MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image,
 678 %        ExceptionInfo *exception)
 679 %
 680 %  A description of each parameter follows.
 681 %
 682 %    o image_info: the image info.
 683 %
 684 %    o image:  The image.
 685 %
 686 */
 687
 688 static void CinemaProfileCompliance(const opj_image_t *jp2_image,
 689   opj_cparameters_t *parameters)
 690 {
 691   /*
 692     Digital Cinema 4K profile compliant codestream.
 693   */
 694   parameters->tile_size_on=OPJ_FALSE;
 695   parameters->cp_tdx=1;
 696   parameters->cp_tdy=1;
 697   parameters->tp_flag='C';
 698   parameters->tp_on=1;
 699   parameters->cp_tx0=0;
 700   parameters->cp_ty0=0;
 701   parameters->image_offset_x0=0;
 702   parameters->image_offset_y0=0;
 703   parameters->cblockw_init=32;
 704   parameters->cblockh_init=32;
 705   parameters->csty|=0x01;
 706   parameters->prog_order=OPJ_CPRL;
 707   parameters->roi_compno=(-1);
 708   parameters->subsampling_dx=1;
 709   parameters->subsampling_dy=1;
 710   parameters->irreversible=1;
 711   if ((jp2_image->comps[0].w == 2048) || (jp2_image->comps[0].h == 1080))
 712     {
 713       /*
 714         Digital Cinema 2K.
 715       */
 716       parameters->cp_cinema=OPJ_CINEMA2K_24;
 717       parameters->cp_rsiz=OPJ_CINEMA2K;
 718       parameters->max_comp_size=1041666;
 719       if (parameters->numresolution > 6)
 720         parameters->numresolution=6;
 721
 722     }
 723   if ((jp2_image->comps[0].w == 4096) || (jp2_image->comps[0].h == 2160))
 724     {
 725       /*
 726         Digital Cinema 4K.
 727       */
 728       parameters->cp_cinema=OPJ_CINEMA4K_24;
 729       parameters->cp_rsiz=OPJ_CINEMA4K;
 730       parameters->max_comp_size=1041666;
 731       if (parameters->numresolution < 1)
 732         parameters->numresolution=1;
 733       if (parameters->numresolution > 7)
 734         parameters->numresolution=7;
 735       parameters->numpocs=2;
 736       parameters->POC[0].tile=1;
 737       parameters->POC[0].resno0=0;
 738       parameters->POC[0].compno0=0;
 739       parameters->POC[0].layno1=1;
 740       parameters->POC[0].resno1=parameters->numresolution-1;
 741       parameters->POC[0].compno1=3;
 742       parameters->POC[0].prg1=OPJ_CPRL;
 743       parameters->POC[1].tile=1;
 744       parameters->POC[1].resno0=parameters->numresolution-1;
 745       parameters->POC[1].compno0=0;
 746       parameters->POC[1].layno1=1;
 747       parameters->POC[1].resno1=parameters->numresolution;
 748       parameters->POC[1].compno1=3;
 749       parameters->POC[1].prg1=OPJ_CPRL;
 750     }
 751   parameters->tcp_numlayers=1;
 752   parameters->tcp_rates[0]=((float) (jp2_image->numcomps*jp2_image->comps[0].w*
 753     jp2_image->comps[0].h*jp2_image->comps[0].prec))/(parameters->max_comp_size*
 754     8*jp2_image->comps[0].dx*jp2_image->comps[0].dy);
 755   parameters->cp_disto_alloc=1;
 756 }
 757
 758 static MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image,
 759   ExceptionInfo *exception)
 760 {
 761   const char
 762     *option,
 763     *property;
 764
 765   int
 766     jp2_status;
 767
 768   MagickBooleanType
 769     status;
 770
 771   opj_codec_t
 772     *jp2_codec;
 773
 774   OPJ_COLOR_SPACE
 775     jp2_colorspace;
 776
 777   opj_cparameters_t
 778     parameters;
 779
 780   opj_image_cmptparm_t
 781     jp2_info[5];
 782
 783   opj_image_t
 784     *jp2_image;
 785
 786   opj_stream_t
 787     *jp2_stream;
 788
 789   register ssize_t
 790     i;
 791
 792   ssize_t
 793     y;
 794
 795   unsigned int
 796     channels;
 797
 798   /*
 799     Open image file.
 800   */
 801   assert(image_info != (const ImageInfo *) NULL);
 802   assert(image_info->signature == MagickCoreSignature);
 803   assert(image != (Image *) NULL);
 804   assert(image->signature == MagickCoreSignature);
 805   if (image->debug != MagickFalse)
 806     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 807   assert(exception != (ExceptionInfo *) NULL);
 808   assert(exception->signature == MagickCoreSignature);
 809   status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
 810   if (status == MagickFalse)
 811     return(status);
 812   /*
 813     Initialize JPEG 2000 API.
 814   */
 815   opj_set_default_encoder_parameters(&parameters);
 816   for (i=1; i < 6; i++)
 817     if (((size_t) (1UL << (i+2)) > image->columns) &&
 818         ((size_t) (1UL << (i+2)) > image->rows))
 819       break;
 820   parameters.numresolution=i;
 821   option=GetImageOption(image_info,"jp2:number-resolutions");
 822   if (option != (const char *) NULL)
 823     parameters.numresolution=StringToInteger(option);
 824   parameters.tcp_numlayers=1;
 825   parameters.tcp_rates[0]=0;  /* lossless */
 826   parameters.cp_disto_alloc=1;
 827   if ((image_info->quality != 0) && (image_info->quality != 100))
 828     {
 829       parameters.tcp_distoratio[0]=(double) image_info->quality;
 830       parameters.cp_fixed_quality=OPJ_TRUE;
 831     }
 832   if (image_info->extract != (char *) NULL)
 833     {
 834       RectangleInfo
 835         geometry;
 836
 837       int
 838         flags;
 839
 840       /*
 841         Set tile size.
 842       */
 843       flags=ParseAbsoluteGeometry(image_info->extract,&geometry);
 844       parameters.cp_tdx=(int) geometry.width;
 845       parameters.cp_tdy=(int) geometry.width;
 846       if ((flags & HeightValue) != 0)
 847         parameters.cp_tdy=(int) geometry.height;
 848       if ((flags & XValue) != 0)
 849         parameters.cp_tx0=geometry.x;
 850       if ((flags & YValue) != 0)
 851         parameters.cp_ty0=geometry.y;
 852       parameters.tile_size_on=OPJ_TRUE;
 853     }
 854   option=GetImageOption(image_info,"jp2:quality");
 855   if (option != (const char *) NULL)
 856     {
 857       register const char
 858         *p;
 859
 860       /*
 861         Set quality PSNR.
 862       */
 863       p=option;
 864       for (i=0; sscanf(p,"%f",&parameters.tcp_distoratio[i]) == 1; i++)
 865       {
 866         if (i > 100)
 867           break;
 868         while ((*p != '\0') && (*p != ','))
 869           p++;
 870         if (*p == '\0')
 871           break;
 872         p++;
 873       }
 874       parameters.tcp_numlayers=i+1;
 875       parameters.cp_fixed_quality=OPJ_TRUE;
 876     }
 877   option=GetImageOption(image_info,"jp2:progression-order");
 878   if (option != (const char *) NULL)
 879     {
 880       if (LocaleCompare(option,"LRCP") == 0)
 881         parameters.prog_order=OPJ_LRCP;
 882       if (LocaleCompare(option,"RLCP") == 0)
 883         parameters.prog_order=OPJ_RLCP;
 884       if (LocaleCompare(option,"RPCL") == 0)
 885         parameters.prog_order=OPJ_RPCL;
 886       if (LocaleCompare(option,"PCRL") == 0)
 887         parameters.prog_order=OPJ_PCRL;
 888       if (LocaleCompare(option,"CPRL") == 0)
 889         parameters.prog_order=OPJ_CPRL;
 890     }
 891   option=GetImageOption(image_info,"jp2:rate");
 892   if (option != (const char *) NULL)
 893     {
 894       register const char
 895         *p;
 896
 897       /*
 898         Set compression rate.
 899       */
 900       p=option;
 901       for (i=0; sscanf(p,"%f",&parameters.tcp_rates[i]) == 1; i++)
 902       {
 903         if (i >= 100)
 904           break;
 905         while ((*p != '\0') && (*p != ','))
 906           p++;
 907         if (*p == '\0')
 908           break;
 909         p++;
 910       }
 911       parameters.tcp_numlayers=i+1;
 912       parameters.cp_disto_alloc=OPJ_TRUE;
 913     }
 914   if (image_info->sampling_factor != (const char *) NULL)
 915     (void) sscanf(image_info->sampling_factor,"%d,%d",
 916       &parameters.subsampling_dx,&parameters.subsampling_dy);
 917   property=GetImageProperty(image,"comment",exception);
 918   if (property != (const char *) NULL)
 919     parameters.cp_comment=ConstantString(property);
 920   channels=3;
 921   jp2_colorspace=OPJ_CLRSPC_SRGB;
 922   if (image->colorspace == YUVColorspace)
 923     {
 924       jp2_colorspace=OPJ_CLRSPC_SYCC;
 925       parameters.subsampling_dx=2;
 926     }
 927   else
 928     {
 929       if (IsGrayColorspace(image->colorspace) != MagickFalse)
 930         {
 931           channels=1;
 932           jp2_colorspace=OPJ_CLRSPC_GRAY;
 933         }
 934       else
 935         (void) TransformImageColorspace(image,sRGBColorspace,exception);
 936       if (image->alpha_trait != UndefinedPixelTrait)
 937         channels++;
 938     }
 939   parameters.tcp_mct=channels == 3 ? 1 : 0;
 940   ResetMagickMemory(jp2_info,0,sizeof(jp2_info));
 941   for (i=0; i < (ssize_t) channels; i++)
 942   {
 943     jp2_info[i].prec=(OPJ_UINT32) image->depth;
 944     jp2_info[i].bpp=(OPJ_UINT32) image->depth;
 945     if ((image->depth == 1) &&
 946         ((LocaleCompare(image_info->magick,"JPT") == 0) ||
 947          (LocaleCompare(image_info->magick,"JP2") == 0)))
 948       {
 949         jp2_info[i].prec++;  /* OpenJPEG returns exception for depth @ 1 */
 950         jp2_info[i].bpp++;
 951       }
 952     jp2_info[i].sgnd=0;
 953     jp2_info[i].dx=parameters.subsampling_dx;
 954     jp2_info[i].dy=parameters.subsampling_dy;
 955     jp2_info[i].w=(OPJ_UINT32) image->columns;
 956     jp2_info[i].h=(OPJ_UINT32) image->rows;
 957   }
 958   jp2_image=opj_image_create((OPJ_UINT32) channels,jp2_info,jp2_colorspace);
 959   if (jp2_image == (opj_image_t *) NULL)
 960     ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
 961   jp2_image->x0=parameters.image_offset_x0;
 962   jp2_image->y0=parameters.image_offset_y0;
 963   jp2_image->x1=(unsigned int) (2*parameters.image_offset_x0+(image->columns-1)*
 964     parameters.subsampling_dx+1);
 965   jp2_image->y1=(unsigned int) (2*parameters.image_offset_y0+(image->rows-1)*
 966     parameters.subsampling_dx+1);
 967   if ((image->depth == 12) &&
 968       ((image->columns == 2048) || (image->rows == 1080) ||
 969        (image->columns == 4096) || (image->rows == 2160)))
 970     CinemaProfileCompliance(jp2_image,&parameters);
 971   if (channels == 4)
 972     jp2_image->comps[3].alpha=1;
 973   else
 974    if ((channels == 2) && (jp2_colorspace == OPJ_CLRSPC_GRAY))
 975      jp2_image->comps[1].alpha=1;
 976   /*
 977     Convert to JP2 pixels.
 978   */
 979   for (y=0; y < (ssize_t) image->rows; y++)
 980   {
 981     register const Quantum
 982       *p;
 983
 984     ssize_t
 985       x;
 986
 987     p=GetVirtualPixels(image,0,y,image->columns,1,exception);
 988     if (p == (const Quantum *) NULL)
 989       break;
 990     for (x=0; x < (ssize_t) image->columns; x++)
 991     {
 992       for (i=0; i < (ssize_t) channels; i++)
 993       {
 994         double
 995           scale;
 996
 997         register int
 998           *q;
 999
1000         scale=(double) ((1UL << jp2_image->comps[i].prec)-1)/QuantumRange;
1001         q=jp2_image->comps[i].data+(y/jp2_image->comps[i].dy*
1002           image->columns/jp2_image->comps[i].dx+x/jp2_image->comps[i].dx);
1003         switch (i)
1004         {
1005           case 0:
1006           {
1007             if (jp2_colorspace == OPJ_CLRSPC_GRAY)
1008               {
1009                 *q=(int) (scale*GetPixelLuma(image,p));
1010                 break;
1011               }
1012             *q=(int) (scale*GetPixelRed(image,p));
1013             break;
1014           }
1015           case 1:
1016           {
1017             if (jp2_colorspace == OPJ_CLRSPC_GRAY)
1018               {
1019                 *q=(int) (scale*GetPixelAlpha(image,p));
1020                 break;
1021               }
1022             *q=(int) (scale*GetPixelGreen(image,p));
1023             break;
1024           }
1025           case 2:
1026           {
1027             *q=(int) (scale*GetPixelBlue(image,p));
1028             break;
1029           }
1030           case 3:
1031           {
1032             *q=(int) (scale*GetPixelAlpha(image,p));
1033             break;
1034           }
1035         }
1036       }
1037       p+=GetPixelChannels(image);
1038     }
1039     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1040       image->rows);
1041     if (status == MagickFalse)
1042       break;
1043   }
1044   if (LocaleCompare(image_info->magick,"JPT") == 0)
1045     jp2_codec=opj_create_compress(OPJ_CODEC_JPT);
1046   else
1047     if (LocaleCompare(image_info->magick,"J2K") == 0)
1048       jp2_codec=opj_create_compress(OPJ_CODEC_J2K);
1049     else
1050       jp2_codec=opj_create_compress(OPJ_CODEC_JP2);
1051   opj_set_warning_handler(jp2_codec,JP2WarningHandler,exception);
1052   opj_set_error_handler(jp2_codec,JP2ErrorHandler,exception);
1053   opj_setup_encoder(jp2_codec,&parameters,jp2_image);
1054   jp2_stream=opj_stream_create(OPJ_J2K_STREAM_CHUNK_SIZE,OPJ_FALSE);
1055   opj_stream_set_read_function(jp2_stream,JP2ReadHandler);
1056   opj_stream_set_write_function(jp2_stream,JP2WriteHandler);
1057   opj_stream_set_seek_function(jp2_stream,JP2SeekHandler);
1058   opj_stream_set_skip_function(jp2_stream,JP2SkipHandler);
1059   opj_stream_set_user_data(jp2_stream,image,NULL);
1060   if (jp2_stream == (opj_stream_t *) NULL)
1061     ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
1062   jp2_status=opj_start_compress(jp2_codec,jp2_image,jp2_stream);
1063   if (jp2_status == 0)
1064     ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
1065   if ((opj_encode(jp2_codec,jp2_stream) == 0) ||
1066       (opj_end_compress(jp2_codec,jp2_stream) == 0))
1067     {
1068       opj_stream_destroy(jp2_stream);
1069       opj_destroy_codec(jp2_codec);
1070       opj_image_destroy(jp2_image);
1071       ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
1072     }
1073   /*
1074     Free resources.
1075   */
1076   opj_stream_destroy(jp2_stream);
1077   opj_destroy_codec(jp2_codec);
1078   opj_image_destroy(jp2_image);
1079   (void) CloseBlob(image);
1080   return(MagickTrue);
1081 }
1082 #endif