source: ImageMagick/trunk/coders/jp2.c @ 17349

Revision 17349, 35.3 KB checked in by cristy, 25 hours ago (diff)
Line 
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-2015 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%    http://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
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
76/*
77  Forward declarations.
78*/
79#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
80static MagickBooleanType
81  WriteJP2Image(const ImageInfo *,Image *,ExceptionInfo *);
82#endif
83
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*/
109static 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
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*/
143static 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
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)
187static 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
197static 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
212static 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
221static 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
230static 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
240static 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
253static 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 == 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)
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,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);
360      if (jp2_status == 0)
361        {
362          opj_stream_destroy(jp2_stream);
363          opj_destroy_codec(jp2_codec);
364          opj_image_destroy(jp2_image);
365          ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
366        }
367    }
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);
371  else
372    if (image->ping == MagickFalse)
373      {
374        jp2_status=opj_decode(jp2_codec,jp2_stream,jp2_image);
375        if (jp2_status != 0)
376          jp2_status=opj_end_decompress(jp2_codec,jp2_stream);
377      }
378  if (jp2_status == 0)
379    {
380      opj_stream_destroy(jp2_stream);
381      opj_destroy_codec(jp2_codec);
382      opj_image_destroy(jp2_image);
383      ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
384    }
385  opj_stream_destroy(jp2_stream);
386  for (i=0; i < (ssize_t) jp2_image->numcomps; i++)
387  {
388    if ((jp2_image->comps[i].dx == 0) || (jp2_image->comps[i].dy == 0))
389      {
390        opj_destroy_codec(jp2_codec);
391        opj_image_destroy(jp2_image);
392        ThrowReaderException(CoderError,"IrregularChannelGeometryNotSupported")
393      }
394  }
395  /*
396    Convert JP2 image.
397  */
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  status=SetImageExtent(image,image->columns,image->rows,exception);
402  if (status == MagickFalse)
403    return(DestroyImageList(image));
404  image->compression=JPEG2000Compression;
405  if (jp2_image->numcomps <= 2)
406    {
407      SetImageColorspace(image,GRAYColorspace,exception);
408      if (jp2_image->numcomps > 1)
409        image->alpha_trait=BlendPixelTrait;
410    }
411  if (jp2_image->numcomps > 3)
412    image->alpha_trait=BlendPixelTrait;
413  for (i=0; i < (ssize_t) jp2_image->numcomps; i++)
414    if ((jp2_image->comps[i].dx > 1) || (jp2_image->comps[i].dy > 1))
415      SetImageColorspace(image,YUVColorspace,exception);
416  if (jp2_image->icc_profile_buf != (unsigned char *) NULL)
417    {
418      StringInfo
419        *profile;
420
421      profile=BlobToStringInfo(jp2_image->icc_profile_buf,
422        jp2_image->icc_profile_len);
423      if (profile != (StringInfo *) NULL)
424        SetImageProfile(image,"icc",profile,exception);
425    }
426  if (image->ping != MagickFalse)
427    {
428      opj_destroy_codec(jp2_codec);
429      opj_image_destroy(jp2_image);
430      opj_destroy_cstr_index(&codestream_index);
431      return(GetFirstImageInList(image));
432    }
433  for (y=0; y < (ssize_t) image->rows; y++)
434  {
435    register Quantum
436      *restrict q;
437
438    register ssize_t
439      x;
440
441    q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
442    if (q == (Quantum *) NULL)
443      break;
444    for (x=0; x < (ssize_t) image->columns; x++)
445    {
446      register ssize_t
447        i;
448
449      for (i=0; i < (ssize_t) jp2_image->numcomps; i++)
450      {
451        double
452          pixel,
453          scale;
454
455        scale=QuantumRange/(double) ((1UL << jp2_image->comps[i].prec)-1);
456        pixel=scale*(jp2_image->comps[i].data[y/jp2_image->comps[i].dy*
457          image->columns/jp2_image->comps[i].dx+x/jp2_image->comps[i].dx]+
458          (jp2_image->comps[i].sgnd ? 1UL << (jp2_image->comps[i].prec-1) : 0));
459        switch (i)
460        {
461           case 0:
462           {
463             SetPixelRed(image,ClampToQuantum(pixel),q);
464             SetPixelGreen(image,ClampToQuantum(pixel),q);
465             SetPixelBlue(image,ClampToQuantum(pixel),q);
466             SetPixelAlpha(image,OpaqueAlpha,q);
467             break;
468           }
469           case 1:
470           {
471             if (jp2_image->numcomps == 2)
472               {
473                 SetPixelAlpha(image,ClampToQuantum(pixel),q);
474                 break;
475               }
476             SetPixelGreen(image,ClampToQuantum(pixel),q);
477             break;
478           }
479           case 2:
480           {
481             SetPixelBlue(image,ClampToQuantum(pixel),q);
482             break;
483           }
484           case 3:
485           {
486             SetPixelAlpha(image,ClampToQuantum(pixel),q);
487             break;
488           }
489        }
490      }
491      q+=GetPixelChannels(image);
492    }
493    if (SyncAuthenticPixels(image,exception) == MagickFalse)
494      break;
495    status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
496      image->rows);
497    if (status == MagickFalse)
498      break;
499  }
500  /*
501    Free resources.
502  */
503  opj_destroy_codec(jp2_codec);
504  opj_image_destroy(jp2_image);
505  opj_destroy_cstr_index(&codestream_index);
506  return(GetFirstImageInList(image));
507}
508#endif
509
510/*
511%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
512%                                                                             %
513%                                                                             %
514%                                                                             %
515%   R e g i s t e r J P 2 I m a g e                                           %
516%                                                                             %
517%                                                                             %
518%                                                                             %
519%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
520%
521%  RegisterJP2Image() adds attributes for the JP2 image format to the list of
522%  supported formats.  The attributes include the image format tag, a method
523%  method to read and/or write the format, whether the format supports the
524%  saving of more than one frame to the same file or blob, whether the format
525%  supports native in-memory I/O, and a brief description of the format.
526%
527%  The format of the RegisterJP2Image method is:
528%
529%      size_t RegisterJP2Image(void)
530%
531*/
532ModuleExport size_t RegisterJP2Image(void)
533{
534  char
535    version[MaxTextExtent];
536
537  MagickInfo
538    *entry;
539
540  *version='\0';
541#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
542  (void) FormatLocaleString(version,MaxTextExtent,"%s",opj_version());
543#endif
544  entry=SetMagickInfo("JP2");
545  entry->description=ConstantString("JPEG-2000 File Format Syntax");
546  if (*version != '\0')
547    entry->version=ConstantString(version);
548  entry->mime_type=ConstantString("image/jp2");
549  entry->module=ConstantString("JP2");
550  entry->magick=(IsImageFormatHandler *) IsJP2;
551  entry->adjoin=MagickFalse;
552  entry->seekable_stream=MagickTrue;
553  entry->thread_support=NoThreadSupport;
554#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
555  entry->decoder=(DecodeImageHandler *) ReadJP2Image;
556  entry->encoder=(EncodeImageHandler *) WriteJP2Image;
557#endif
558  (void) RegisterMagickInfo(entry);
559  entry=SetMagickInfo("J2C");
560  entry->description=ConstantString("JPEG-2000 Code Stream Syntax");
561  if (*version != '\0')
562    entry->version=ConstantString(version);
563  entry->mime_type=ConstantString("image/jp2");
564  entry->module=ConstantString("JP2");
565  entry->magick=(IsImageFormatHandler *) IsJ2K;
566  entry->adjoin=MagickFalse;
567  entry->seekable_stream=MagickTrue;
568  entry->thread_support=NoThreadSupport;
569#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
570  entry->decoder=(DecodeImageHandler *) ReadJP2Image;
571  entry->encoder=(EncodeImageHandler *) WriteJP2Image;
572#endif
573  (void) RegisterMagickInfo(entry);
574  entry=SetMagickInfo("J2K");
575  entry->description=ConstantString("JPEG-2000 Code Stream Syntax");
576  if (*version != '\0')
577    entry->version=ConstantString(version);
578  entry->mime_type=ConstantString("image/jp2");
579  entry->module=ConstantString("JP2");
580  entry->magick=(IsImageFormatHandler *) IsJ2K;
581  entry->adjoin=MagickFalse;
582  entry->seekable_stream=MagickTrue;
583  entry->thread_support=NoThreadSupport;
584#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
585  entry->decoder=(DecodeImageHandler *) ReadJP2Image;
586  entry->encoder=(EncodeImageHandler *) WriteJP2Image;
587#endif
588  (void) RegisterMagickInfo(entry);
589  entry=SetMagickInfo("JPM");
590  entry->description=ConstantString("JPEG-2000 File Format Syntax");
591  if (*version != '\0')
592    entry->version=ConstantString(version);
593  entry->mime_type=ConstantString("image/jp2");
594  entry->module=ConstantString("JP2");
595  entry->magick=(IsImageFormatHandler *) IsJP2;
596  entry->adjoin=MagickFalse;
597  entry->seekable_stream=MagickTrue;
598  entry->thread_support=NoThreadSupport;
599#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
600  entry->decoder=(DecodeImageHandler *) ReadJP2Image;
601  entry->encoder=(EncodeImageHandler *) WriteJP2Image;
602#endif
603  (void) RegisterMagickInfo(entry);
604  entry=SetMagickInfo("JPT");
605  entry->description=ConstantString("JPEG-2000 File Format Syntax");
606  if (*version != '\0')
607    entry->version=ConstantString(version);
608  entry->mime_type=ConstantString("image/jp2");
609  entry->module=ConstantString("JP2");
610  entry->magick=(IsImageFormatHandler *) IsJP2;
611  entry->adjoin=MagickFalse;
612  entry->seekable_stream=MagickTrue;
613  entry->thread_support=NoThreadSupport;
614#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
615  entry->decoder=(DecodeImageHandler *) ReadJP2Image;
616  entry->encoder=(EncodeImageHandler *) WriteJP2Image;
617#endif
618  (void) RegisterMagickInfo(entry);
619  entry=SetMagickInfo("JPC");
620  entry->description=ConstantString("JPEG-2000 Code Stream Syntax");
621  if (*version != '\0')
622    entry->version=ConstantString(version);
623  entry->mime_type=ConstantString("image/jp2");
624  entry->module=ConstantString("JP2");
625  entry->magick=(IsImageFormatHandler *) IsJP2;
626  entry->adjoin=MagickFalse;
627  entry->seekable_stream=MagickTrue;
628  entry->thread_support=NoThreadSupport;
629#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
630  entry->decoder=(DecodeImageHandler *) ReadJP2Image;
631  entry->encoder=(EncodeImageHandler *) WriteJP2Image;
632#endif
633  (void) RegisterMagickInfo(entry);
634  return(MagickImageCoderSignature);
635}
636
637/*
638%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
639%                                                                             %
640%                                                                             %
641%                                                                             %
642%   U n r e g i s t e r J P 2 I m a g e                                       %
643%                                                                             %
644%                                                                             %
645%                                                                             %
646%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
647%
648%  UnregisterJP2Image() removes format registrations made by the JP2 module
649%  from the list of supported formats.
650%
651%  The format of the UnregisterJP2Image method is:
652%
653%      UnregisterJP2Image(void)
654%
655*/
656ModuleExport void UnregisterJP2Image(void)
657{
658  (void) UnregisterMagickInfo("JPC");
659  (void) UnregisterMagickInfo("JPT");
660  (void) UnregisterMagickInfo("JPM");
661  (void) UnregisterMagickInfo("JP2");
662  (void) UnregisterMagickInfo("J2K");
663}
664
665#if defined(MAGICKCORE_LIBOPENJP2_DELEGATE)
666/*
667%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
668%                                                                             %
669%                                                                             %
670%                                                                             %
671%   W r i t e J P 2 I m a g e                                                 %
672%                                                                             %
673%                                                                             %
674%                                                                             %
675%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
676%
677%  WriteJP2Image() writes an image in the JPEG 2000 image format.
678%
679%  JP2 support originally written by Nathan Brown, nathanbrown@letu.edu
680%
681%  The format of the WriteJP2Image method is:
682%
683%      MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image,
684%        ExceptionInfo *exception)
685%
686%  A description of each parameter follows.
687%
688%    o image_info: the image info.
689%
690%    o image:  The image.
691%
692*/
693
694static void CinemaProfileCompliance(const opj_image_t *jp2_image,
695  opj_cparameters_t *parameters)
696{
697  /*
698    Digital Cinema 4K profile compliant codestream.
699  */
700  parameters->tile_size_on=OPJ_FALSE;
701  parameters->cp_tdx=1;
702  parameters->cp_tdy=1;
703  parameters->tp_flag='C';
704  parameters->tp_on=1;
705  parameters->cp_tx0=0;
706  parameters->cp_ty0=0;
707  parameters->image_offset_x0=0;
708  parameters->image_offset_y0=0;
709  parameters->cblockw_init=32;
710  parameters->cblockh_init=32;
711  parameters->csty|=0x01;
712  parameters->prog_order=OPJ_CPRL;
713  parameters->roi_compno=(-1);
714  parameters->subsampling_dx=1;
715  parameters->subsampling_dy=1;
716  parameters->irreversible=1;
717  if ((jp2_image->comps[0].w == 2048) || (jp2_image->comps[0].h == 1080))
718    {
719      /*
720        Digital Cinema 2K.
721      */
722      parameters->cp_cinema=OPJ_CINEMA2K_24;
723      parameters->cp_rsiz=OPJ_CINEMA2K;
724      parameters->max_comp_size=1041666;
725      if (parameters->numresolution > 6)
726        parameters->numresolution=6;
727
728    }
729  if ((jp2_image->comps[0].w == 4096) || (jp2_image->comps[0].h == 2160))
730    {
731      /*
732        Digital Cinema 4K.
733      */
734      parameters->cp_cinema=OPJ_CINEMA4K_24;
735      parameters->cp_rsiz=OPJ_CINEMA4K;
736      parameters->max_comp_size=1041666;
737      if (parameters->numresolution < 1)
738        parameters->numresolution=1;
739      if (parameters->numresolution > 7)
740        parameters->numresolution=7;
741      parameters->numpocs=2;
742      parameters->POC[0].tile=1;
743      parameters->POC[0].resno0=0;
744      parameters->POC[0].compno0=0;
745      parameters->POC[0].layno1=1;
746      parameters->POC[0].resno1=parameters->numresolution-1;
747      parameters->POC[0].compno1=3;
748      parameters->POC[0].prg1=OPJ_CPRL;
749      parameters->POC[1].tile=1;
750      parameters->POC[1].resno0=parameters->numresolution-1;
751      parameters->POC[1].compno0=0;
752      parameters->POC[1].layno1=1;
753      parameters->POC[1].resno1=parameters->numresolution;
754      parameters->POC[1].compno1=3;
755      parameters->POC[1].prg1=OPJ_CPRL;
756    }
757  parameters->tcp_numlayers=1;
758  parameters->tcp_rates[0]=((float) (jp2_image->numcomps*jp2_image->comps[0].w*
759    jp2_image->comps[0].h*jp2_image->comps[0].prec))/(parameters->max_comp_size*
760    8*jp2_image->comps[0].dx*jp2_image->comps[0].dy);
761  parameters->cp_disto_alloc=1;
762}
763
764static MagickBooleanType WriteJP2Image(const ImageInfo *image_info,Image *image,
765  ExceptionInfo *exception)
766{
767  const char
768    *option,
769    *property;
770
771  int
772    jp2_status;
773
774  MagickBooleanType
775    status;
776
777  opj_codec_t
778    *jp2_codec;
779
780  OPJ_COLOR_SPACE
781    jp2_colorspace;
782
783  opj_cparameters_t
784    parameters;
785
786  opj_image_cmptparm_t
787    jp2_info[5];
788
789  opj_image_t
790    *jp2_image;
791
792  opj_stream_t
793    *jp2_stream;
794
795  register ssize_t
796    i;
797
798  ssize_t
799    y;
800
801  size_t
802    channels;
803
804  /*
805    Open image file.
806  */
807  assert(image_info != (const ImageInfo *) NULL);
808  assert(image_info->signature == MagickSignature);
809  assert(image != (Image *) NULL);
810  assert(image->signature == MagickSignature);
811  if (image->debug != MagickFalse)
812    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
813  assert(exception != (ExceptionInfo *) NULL);
814  assert(exception->signature == MagickSignature);
815  status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
816  if (status == MagickFalse)
817    return(status);
818  /*
819    Initialize JPEG 2000 API.
820  */
821  opj_set_default_encoder_parameters(&parameters);
822  for (i=1; i < 6; i++)
823    if (((1U << (i+2)) > image->columns) && ((1U << (i+2)) > image->rows))
824      break;
825  parameters.numresolution=i;
826  option=GetImageOption(image_info,"jp2:number-resolutions");
827  if (option != (const char *) NULL)
828    parameters.numresolution=StringToInteger(option);
829  parameters.tcp_numlayers=1;
830  parameters.tcp_rates[0]=0;  /* lossless */
831  parameters.cp_disto_alloc=1;
832  if (image->quality != 0)
833    {
834      parameters.tcp_distoratio[0]=(double) image->quality;
835      parameters.cp_fixed_quality=OPJ_TRUE;
836    }
837  if (image_info->extract != (char *) NULL)
838    {
839      RectangleInfo
840        geometry;
841
842      int
843        flags;
844
845      /*
846        Set tile size.
847      */
848      flags=ParseAbsoluteGeometry(image_info->extract,&geometry);
849      parameters.cp_tdx=(int) geometry.width;
850      parameters.cp_tdy=(int) geometry.width;
851      if ((flags & HeightValue) != 0)
852        parameters.cp_tdy=(int) geometry.height;
853      if ((flags & XValue) != 0)
854        parameters.cp_tx0=geometry.x;
855      if ((flags & YValue) != 0)
856        parameters.cp_ty0=geometry.y;
857      parameters.tile_size_on=OPJ_TRUE;
858    }
859  option=GetImageOption(image_info,"jp2:quality");
860  if (option != (const char *) NULL)
861    {
862      register const char
863        *p;
864
865      /*
866        Set quality PSNR.
867      */
868      p=option;
869      for (i=0; sscanf(p,"%f",&parameters.tcp_distoratio[i]) == 1; i++)
870      {
871        if (i > 100)
872          break;
873        while ((*p != '\0') && (*p != ','))
874          p++;
875        if (*p == '\0')
876          break;
877        p++;
878      }
879      parameters.tcp_numlayers=i+1;
880      parameters.cp_fixed_quality=OPJ_TRUE;
881    }
882  option=GetImageOption(image_info,"jp2:progression-order");
883  if (option != (const char *) NULL)
884    {
885      if (LocaleCompare(option,"LRCP") == 0)
886        parameters.prog_order=OPJ_LRCP;
887      if (LocaleCompare(option,"RLCP") == 0)
888        parameters.prog_order=OPJ_RLCP;
889      if (LocaleCompare(option,"RPCL") == 0)
890        parameters.prog_order=OPJ_RPCL;
891      if (LocaleCompare(option,"PCRL") == 0)
892        parameters.prog_order=OPJ_PCRL;
893      if (LocaleCompare(option,"CPRL") == 0)
894        parameters.prog_order=OPJ_CPRL;
895    }
896  option=GetImageOption(image_info,"jp2:rate");
897  if (option != (const char *) NULL)
898    {
899      register const char
900        *p;
901
902      /*
903        Set compression rate.
904      */
905      p=option;
906      for (i=0; sscanf(p,"%f",&parameters.tcp_rates[i]) == 1; i++)
907      {
908        if (i >= 100)
909          break;
910        while ((*p != '\0') && (*p != ','))
911          p++;
912        if (*p == '\0')
913          break;
914        p++;
915      }
916      parameters.tcp_numlayers=i+1;
917      parameters.cp_disto_alloc=OPJ_TRUE;
918    }
919  if (image_info->sampling_factor != (const char *) NULL)
920    (void) sscanf(image_info->sampling_factor,"%d,%d",
921      &parameters.subsampling_dx,&parameters.subsampling_dy);
922  property=GetImageProperty(image,"comment",exception);
923  if (property != (const char *) NULL)
924    parameters.cp_comment=ConstantString(property);
925  channels=3;
926  jp2_colorspace=OPJ_CLRSPC_SRGB;
927  if (image->colorspace == YUVColorspace)
928    {
929      jp2_colorspace=OPJ_CLRSPC_SYCC;
930      parameters.subsampling_dx=2;
931    }
932  else
933    {
934      (void) TransformImageColorspace(image,sRGBColorspace,exception);
935      if (IsGrayColorspace(image->colorspace) != MagickFalse)
936        {
937          channels=1;
938          jp2_colorspace=OPJ_CLRSPC_GRAY;
939        }
940      if (image->alpha_trait != UndefinedPixelTrait)
941        channels++;
942    }
943  parameters.tcp_mct=channels == 3 ? 1 : 0;
944  ResetMagickMemory(jp2_info,0,sizeof(jp2_info));
945  for (i=0; i < (ssize_t) channels; i++)
946  {
947    jp2_info[i].prec=image->depth;
948    jp2_info[i].bpp=image->depth;
949    if ((image->depth == 1) &&
950        ((LocaleCompare(image_info->magick,"JPT") == 0) ||
951         (LocaleCompare(image_info->magick,"JP2") == 0)))
952      {
953        jp2_info[i].prec++;  /* OpenJPEG returns exception for depth @ 1 */
954        jp2_info[i].bpp++;
955      }
956    jp2_info[i].sgnd=0;
957    jp2_info[i].dx=parameters.subsampling_dx;
958    jp2_info[i].dy=parameters.subsampling_dy;
959    jp2_info[i].w=image->columns;
960    jp2_info[i].h=image->rows;
961  }
962  jp2_image=opj_image_create(channels,jp2_info,jp2_colorspace);
963  if (jp2_image == (opj_image_t *) NULL)
964    ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
965  jp2_image->x0=parameters.image_offset_x0;
966  jp2_image->y0=parameters.image_offset_y0;
967  jp2_image->x1=(unsigned int) (2*parameters.image_offset_x0+(image->columns-1)*
968    parameters.subsampling_dx+1);
969  jp2_image->y1=(unsigned int) (2*parameters.image_offset_y0+(image->rows-1)*
970    parameters.subsampling_dx+1);
971  if ((image->depth == 12) &&
972      ((image->columns == 2048) || (image->rows == 1080) ||
973       (image->columns == 4096) || (image->rows == 2160)))
974    CinemaProfileCompliance(jp2_image,&parameters);
975  /*
976    Convert to JP2 pixels.
977  */
978  for (y=0; y < (ssize_t) image->rows; y++)
979  {
980    register const Quantum
981      *p;
982
983    ssize_t
984      x;
985
986    p=GetVirtualPixels(image,0,y,image->columns,1,exception);
987    if (p == (const Quantum *) NULL)
988      break;
989    for (x=0; x < (ssize_t) image->columns; x++)
990    {
991      for (i=0; i < (ssize_t) channels; i++)
992      {
993        double
994          scale;
995
996        register int
997          *q;
998
999        scale=(double) ((1UL << jp2_image->comps[i].prec)-1)/QuantumRange;
1000        q=jp2_image->comps[i].data+(y/jp2_image->comps[i].dy*
1001          image->columns/jp2_image->comps[i].dx+x/jp2_image->comps[i].dx);
1002        switch (i)
1003        {
1004          case 0:
1005          {
1006            if (jp2_colorspace == OPJ_CLRSPC_GRAY)
1007              {
1008                *q=(int) (scale*GetPixelLuma(image,p));
1009                break;
1010              }
1011            *q=(int) (scale*GetPixelRed(image,p));
1012            break;
1013          }
1014          case 1:
1015          {
1016            if (jp2_colorspace == OPJ_CLRSPC_GRAY)
1017              {
1018                *q=(int) (scale*GetPixelAlpha(image,p));
1019                break;
1020              }
1021            *q=(int) (scale*GetPixelGreen(image,p));
1022            break;
1023          }
1024          case 2:
1025          {
1026            *q=(int) (scale*GetPixelBlue(image,p));
1027            break;
1028          }
1029          case 3:
1030          {
1031            *q=(int) (scale*GetPixelAlpha(image,p));
1032            break;
1033          }
1034        }
1035      }
1036      p+=GetPixelChannels(image);
1037    }
1038    status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1039      image->rows);
1040    if (status == MagickFalse)
1041      break;
1042  }
1043  if (LocaleCompare(image_info->magick,"JPT") == 0)
1044    jp2_codec=opj_create_compress(OPJ_CODEC_JPT);
1045  else
1046    if (LocaleCompare(image_info->magick,"J2K") == 0)
1047      jp2_codec=opj_create_compress(OPJ_CODEC_J2K);
1048    else
1049      jp2_codec=opj_create_compress(OPJ_CODEC_JP2);
1050  opj_set_warning_handler(jp2_codec,JP2WarningHandler,exception);
1051  opj_set_error_handler(jp2_codec,JP2ErrorHandler,exception);
1052  opj_setup_encoder(jp2_codec,&parameters,jp2_image);
1053  jp2_stream=opj_stream_create(OPJ_J2K_STREAM_CHUNK_SIZE,OPJ_FALSE);
1054  opj_stream_set_read_function(jp2_stream,JP2ReadHandler);
1055  opj_stream_set_write_function(jp2_stream,JP2WriteHandler);
1056  opj_stream_set_seek_function(jp2_stream,JP2SeekHandler);
1057  opj_stream_set_skip_function(jp2_stream,JP2SkipHandler);
1058  opj_stream_set_user_data(jp2_stream,image,NULL);
1059  if (jp2_stream == (opj_stream_t *) NULL)
1060    ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
1061  jp2_status=opj_start_compress(jp2_codec,jp2_image,jp2_stream);
1062  if (jp2_status == 0)
1063    ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
1064  if ((opj_encode(jp2_codec,jp2_stream) == 0) ||
1065      (opj_end_compress(jp2_codec,jp2_stream) == 0))
1066    {
1067      opj_stream_destroy(jp2_stream);
1068      opj_destroy_codec(jp2_codec);
1069      opj_image_destroy(jp2_image);
1070      ThrowWriterException(DelegateError,"UnableToEncodeImageFile");
1071    }
1072  /*
1073    Free resources.
1074  */
1075  opj_stream_destroy(jp2_stream);
1076  opj_destroy_codec(jp2_codec);
1077  opj_image_destroy(jp2_image);
1078  (void) CloseBlob(image);
1079  return(MagickTrue);
1080}
1081#endif
Note: See TracBrowser for help on using the repository browser.