/*

% Copyright (C) 2003-2026 GraphicsMagick Group

% Copyright (C) 2002 ImageMagick Studio

%

% This program is covered by multiple licenses, which are described in

% Copyright.txt. You should have received a copy of Copyright.txt with this

% package; otherwise see http://www.graphicsmagick.org/www/Copyright.html.

%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%                              JJJ  PPPP    222                               %

%                               J   P   P  2   2                              %

%                               J   PPPP     22                               %

%                            J  J   P       2                                 %

%                             JJ    P      22222                              %

%                                                                             %

%                                                                             %

%                    Read/Write JPEG-2000 Image Format.                       %

%                                                                             %

%                                                                             %

%                                John Cristy                                  %

%                                Nathan Brown                                 %

%                                 June 2001                                   %

%                              Bob Friesenhahn                                %

%                               February 2003                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%

*/

/*

  Include declarations.

*/

#include "magick/studio.h"

#include "magick/analyze.h"

#include "magick/blob.h"

#include "magick/pixel_cache.h"

#include "magick/log.h"

#include "magick/magick.h"

#include "magick/monitor.h"

#include "magick/profile.h"

#include "magick/resource.h"

#include "magick/utility.h"

#include "magick/static.h"

#if defined(HasJP2)

#  if !defined(uchar)

#    define uchar  unsigned char

#  endif

#  if !defined(ushort)

#    define ushort  unsigned short

#  endif

#  if !defined(uint)

#    define uint  unsigned int

#  endif

#  if !defined(longlong)

#    define longlong  long long

#  endif

#  if !defined(ulonglong)

#    define ulonglong  unsigned long long

#  endif

#  ifdef __VMS

#    define JAS_VERSION 1.700.0

#    define PACKAGE jasper

#    define VERSION 1.700.0

#  endif /* ifdef __VMS */

#  undef PACKAGE_NAME

#  undef PACKAGE_STRING

#  undef PACKAGE_TARNAME

#  undef PACKAGE_VERSION

#  include "jasper/jasper.h"

#  undef PACKAGE_NAME

#  undef PACKAGE_STRING

#  undef PACKAGE_TARNAME

#  undef PACKAGE_VERSION

/*

  Old JasPer uses non-persistent '!defined(EXCLUDE_FOO_SUPPORT)' and

  modern JasPer uses persistent 'if defined(JAS_INCLUDE_FOO_CODEC)'

  in jas_image.h

*/

#  if defined(EXCLUDE_JP2_SUPPORT)

#    undef HAVE_JP2_DECODE

#  endif

#  if defined(EXCLUDE_JPC_SUPPORT)

#    undef HAVE_JPC_DECODE

#  endif

#  if defined(EXCLUDE_PGX_SUPPORT)

#    undef HAVE_PGX_DECODE

#  endif

#if defined(HAVE_JAS_INIT_LIBRARY)

# define HAVE_JAS_STREAM_IO_V3

#endif

#if 0

/* Development JasPer 3.0.0 jas_init_library() is not yet ready for our purposes */

#if !(defined(MAGICK_ENABLE_JAS_INIT_LIBRARY) && MAGICK_ENABLE_JAS_INIT_LIBRARY)

#undef HAVE_JAS_INIT_LIBRARY

#endif /* if !(defined(MAGICK_ENABLE_JAS_INIT_LIBRARY) && MAGICK_ENABLE_JAS_INIT_LIBRARY) */

#endif

#if defined(HAVE_PTHREAD) || defined(MSWINDOWS) || defined(HAVE_OPENMP)

#  define JP2_HAVE_THREADS 1

#else

#  define JP2_HAVE_THREADS 0

#endif

/*

  Forward declarations.

*/

static unsigned int

  WriteJP2Image(const ImageInfo *,Image *);

static MagickBool jasper_initialized=MagickFalse;

static const char jasper_enc_options[][11] =

  {

    "cblkheight",

    "cblkwidth",

    "debug",

    "eph",

    "ilyrrates",

    "imgareatlx",

    "imgareatly",

    "lazy",

    "mode",

    "nomct",

    "numgbits",

    "numrlvls",

    "prcheight",

    "prcwidth",

    "prg",

    "pterm",

    "rate",

    "resetprob",

    "segsym",

    "sop",

    "termall",

    "tilegrdtlx",

    "tilegrdtly",

    "tileheight",

    "tilewidth",

    "vcausal"

  };

static const char jasper_dec_options[][12] =

  {

    "allow_trunc",

    "debug",

    "max_samples",

    "maxlyrs",

    "maxpkts",

    "version"

  };

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   I s J P 2                                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method IsJP2 returns True if the image format type, identified by the

%  magick string, is JP2.

%

%  The format of the IsJP2 method is:

%

%      unsigned int IsJP2(const unsigned char *magick,const size_t length)

%

%  A description of each parameter follows:

%

%    o status:  Method IsJP2 returns True if the image format type is JP2.

%

%    o magick: This string is generally the first few bytes of an image file

%      or blob.

%

%    o length: Specifies the length of the magick string.

%

%

*/

static unsigned int IsJP2(const unsigned char *magick,const size_t length)

{

  if (length < 9)

    return(False);

  if (memcmp(magick+4,"\152\120\040\040\015",5) == 0)

    return(True);

  return(False);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   I s J P C                                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method IsJPC returns True if the image format type, identified by the

%  magick string, is JPC.

%

%  The format of the IsJPC method is:

%

%      unsigned int IsJPC(const unsigned char *magick,const size_t length)

%

%  A description of each parameter follows:

%

%    o status:  Method IsJPC returns True if the image format type is JPC.

%

%    o magick: This string is generally the first few bytes of an image file

%      or blob.

%

%    o length: Specifies the length of the magick string.

%

%

*/

static unsigned int IsJPC(const unsigned char *magick,const size_t length)

{

  if (length < 2)

    return(False);

  if (memcmp(magick,"\377\117",2) == 0)

    return(True);

  return(False);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   I s P G X                                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method IsPGX returns True if the image format type, identified by the

%  magick string, is PGX. PGX is an uncompressed raster image file format

%  used in JPEG 2000 conformance testing. PGX file stores only a single

%  component, so it is limited to grayscale.

%

%  The format of the IsPGX method is:

%

%      unsigned int IsPGX(const unsigned char *magick,const size_t length)

%

%  A description of each parameter follows:

%

%    o status:  Method IsPGX returns True if the image format type is PGX.

%

%    o magick: This string is generally the first few bytes of an image file

%      or blob.

%

%    o length: Specifies the length of the magick string.

%

%

*/

static unsigned int IsPGX(const unsigned char *magick,const size_t length)

{

  if (length < 5)

    return(False);

  if ((memcmp(magick,"PG ML",5) == 0) || (memcmp(magick,"PG LM",5) == 0))

    return(True);

  return(False);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   R e a d J P 2 I m a g e                                                   %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method ReadJP2Image reads a JPEG 2000 Image file (JP2) or JPEG 2000

%  codestream (JPC) image file and returns it.  It allocates the memory

%  necessary for the new Image structure and returns a pointer to the new

%  image or set of images.

%

%  JP2 support is originally written by Nathan Brown, nathanbrown@letu.edu.

%

%  The format of the ReadJP2Image method is:

%

%      Image *ReadJP2Image(const ImageInfo *image_info,

%                          ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image:  Method ReadJP2Image returns a pointer to the image after

%      reading.  A null image is returned if there is a memory shortage or

%      if the image cannot be read.

%

%    o image_info: Specifies a pointer to a ImageInfo structure.

%

%    o exception: return any errors or warnings in this structure.

%

*/

typedef struct _StreamManager

{

  jas_stream_t

    *stream;

  Image

    *image;

} StreamManager;

/*

  I/O read/write callbacks changed

  Cnt argument changed from 'int' to 'unsigned' on 6/29/20 (2.0.19).

  Write write buf pointer changed from 'char *' to 'const char *' on 8/14/20

  Old interface:

  int (*read_)(jas_stream_obj_t *obj, char *buf, int cnt);

  int (*write_)(jas_stream_obj_t *obj, char *buf, int cnt);

  New interface:

  int (*read_)(jas_stream_obj_t *obj, char *buf, unsigned cnt);

  int (*write_)(jas_stream_obj_t *obj, const char *buf, unsigned cnt);

  In Jasper 3.0.0 the interface changed again:

  ssize_t (*read_)(jas_stream_obj_t *obj, char *buf, size_t cnt);

  ssize_t (*write_)(jas_stream_obj_t *obj, const char *buf, size_t cnt);

  We have yet to find a useful way to determine the version of the

  JasPer library using the C pre-processor.

 */

/* Read characters from a file object. */

/* ssize_t (*read_)(jas_stream_obj_t *obj, char *buf, size_t cnt); */

#if defined(HAVE_JAS_STREAM_IO_V3)

static ssize_t BlobRead(jas_stream_obj_t *obj, char *buf, size_t cnt)

#else

static int BlobRead(jas_stream_obj_t *obj, char *buf, unsigned cnt)

#endif

{

  size_t

    count;

  StreamManager

    *source = (StreamManager *) obj;

  count=ReadBlob(source->image,(size_t) cnt,(void *) buf);

#if defined(HAVE_JAS_STREAM_IO_V3)

  return (count);

#else

  if ((size_t)((int) count) != count)

    count = 0;

  return ((int) count);

#endif

}

/* Write characters to a file object. */

/* ssize_t (*write_)(jas_stream_obj_t *obj, const char *buf, size_t cnt); */

#if defined(HAVE_JAS_STREAM_IO_V3)

static ssize_t  BlobWrite(jas_stream_obj_t *obj, const char *buf, size_t cnt)

#else

static int BlobWrite(jas_stream_obj_t *obj, const char *buf, unsigned cnt)

#endif

{

  size_t

    count;

  StreamManager

    *source = (StreamManager *) obj;

  count=WriteBlob(source->image,(size_t) cnt,(void *) buf);

#if defined(HAVE_JAS_STREAM_IO_V3)

  return(count);

#else

  if ((size_t)((int) count) != count)

    count = 0;

  return ((int) count);

#endif

}

/* Set the position for a file object. */

/* long (*seek_)(jas_stream_obj_t *obj, long offset, int origin); */

static long BlobSeek(jas_stream_obj_t *obj,long offset,int origin)

{

  StreamManager

    *source = (StreamManager *) obj;

  return (SeekBlob(source->image,offset,origin));

}

/* Close a file object. */

/* int (*close_)(jas_stream_obj_t *obj); */

static int BlobClose(jas_stream_obj_t *obj)

{

  int status;

  StreamManager

    *source = (StreamManager *) obj;

  status = CloseBlob(source->image);

  jas_free(source);

  return (status == 0 ? EOF : 0);

}

static jas_stream_t *JP2StreamManager(jas_stream_ops_t *stream_ops, Image *image)

{

  jas_stream_t

    *stream;

  StreamManager

    *source;

  stream=(jas_stream_t *) jas_malloc(sizeof(jas_stream_t));

  if (stream == (jas_stream_t *) NULL)

    return((jas_stream_t *) NULL);

  (void) memset(stream,0,sizeof(jas_stream_t));

  stream->rwlimit_=(-1);

  stream->obj_=(jas_stream_obj_t *) jas_malloc(sizeof(StreamManager));

  if (stream->obj_ == (jas_stream_obj_t *) NULL)

    {

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "jas_malloc() failed!");

      jas_free(stream);

      return((jas_stream_t *) NULL);

    }

  stream->ops_=stream_ops;

  stream->openmode_=JAS_STREAM_READ | JAS_STREAM_WRITE | JAS_STREAM_BINARY;

  stream->bufbase_=stream->tinybuf_;

  stream->bufsize_=1;

  stream->bufstart_=(&stream->bufbase_[JAS_STREAM_MAXPUTBACK]);

  stream->ptr_=stream->bufstart_;

  stream->bufmode_|=JAS_STREAM_UNBUF & JAS_STREAM_BUFMODEMASK;

  source=(StreamManager *) stream->obj_;

  source->image=image;

  return(stream);

}

#if defined(HAVE_JAS_INIT_LIBRARY)

#  define JAS_CLEANUP_THREAD() jas_cleanup_thread()

#else

#  define JAS_CLEANUP_THREAD()

#endif

#define ThrowJP2ReaderException(code_,reason_,image_)                   \

  {                                                                     \

    for (component=0; component < (long) number_components; component++) \

      MagickFreeResourceLimitedMemory(Quantum *,channel_lut[component]); \

    if (pixels)                                                         \

      jas_matrix_destroy(pixels);                                       \

    if (jp2_stream)                                                     \

      (void) jas_stream_close(jp2_stream);                              \

    if (jp2_image)                                                      \

      jas_image_destroy(jp2_image);                                     \

    MagickFreeMemory(options);                                          \

    JAS_CLEANUP_THREAD();                                               \

    ThrowReaderException(code_,reason_,image_);                         \

  }

#define ThrowJP2WriterException(code_,reason_,image_)   \

  {                                                     \

    JAS_CLEANUP_THREAD();                               \

    ThrowWriterException(code_,reason_,image_);         \

  }

/*

  Initialize Jasper

*/

#if HAVE_JAS_INIT_LIBRARY

static void *alloc_rlm(struct jas_allocator_s *allocator, size_t size)

{

  char *p;

  (void) allocator;

  /* JasPer expects its allocator to return non-null for zero size */

  p=(char *) _MagickAllocateResourceLimitedMemoryLoc((size == 0 ? 1 : size),GetMagickModule());

  /* fprintf(stderr,"alloc_rlm(%p, %zu) -> %p\n", allocator, size, p); */

  return p;

}

static void free_rlm(struct jas_allocator_s *allocator, void *pointer)

{

  (void) allocator;

  /* fprintf(stderr,"free_rlm(%p, %p\n", allocator, pointer); */

  _MagickFreeResourceLimitedMemoryLoc(pointer,GetMagickModule());

}

static void *realloc_rlm(struct jas_allocator_s *allocator, void *pointer,

                         size_t new_size)

{

  char *p;

  (void) allocator;

  p =(char *) _MagickReallocateResourceLimitedMemoryLoc(pointer, 1,new_size,0,GetMagickModule());

  /* fprintf(stderr,"realloc_rlm(%p, %p, %zu) -> %p\n", allocator, pointer, new_size, p); */

  return p;

}

#endif /* if HAVE_JAS_INIT_LIBRARY */

static MagickPassFail initialize_jasper(ExceptionInfo *exception)

{

  (void) exception;

  if (!jasper_initialized)

    {

#if HAVE_JAS_INIT_LIBRARY

      {

        /* static jas_std_allocator_t allocator; */

        static jas_allocator_t allocator;

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "Initializing JasPer...");

        /*

          Configure the library using the default configuration settings.

        */

        jas_conf_clear();

        /*

          Provide our own resource-limited memory allocation

          functions.

          See src/libjasper/include/jasper/jas_malloc.h

        */

        /*

          Function to clean up the allocator when no longer needed.

          The allocator cannot be used after the clean-up operation is performed.

          This function pointer may be null, in which case the clean-up operation

          is treated as a no-op.

        */

        allocator.cleanup = 0;

        /*

          Function to allocate memory.

          This function should have behavior similar to malloc.

        */

        allocator.alloc = alloc_rlm;

        /*

          Function to deallocate memory.

          This function should have behavior similar to free.

        */

        allocator.free = free_rlm;

        /*

          Function to reallocate memory.

          This function should have behavior similar to realloc.

        */

        allocator.realloc = realloc_rlm;

        /* jas_std_allocator_init(&allocator); */ /* Uses JasPer allocators */

        jas_conf_set_allocator(&allocator); /* Assigns jas_allocator_t to jas_conf.allocator in library */

        /* jas_conf_set_debug_level(cmdopts->debug); */

        /*

          Tell JasPer how much memory it could ever be allowed to use.

        */

        {

          size_t max_mem_gm = (size_t) GetMagickResourceLimit(MemoryResource);

          size_t max_mem_jas = jas_get_total_mem_size();

          if (max_mem_jas == 0)

            max_mem_jas=max_mem_gm;

          jas_conf_set_max_mem_usage(Min(max_mem_jas,max_mem_gm));

        }

        /*

          Inform JasPer that app may be multi-threaded

        */

        jas_conf_set_multithread(JP2_HAVE_THREADS);

        /* Perform global initialization for the JasPer library. */

        if (jas_init_library() == 0)

          {

            jasper_initialized=MagickTrue;

            /* jas_set_debug_level(110); */

          }

        else

          {

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                  "jas_init_library() failed!");

          }

      }

#else

      {

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "Initializing JasPer...");

        if (jas_init() == 0)

          {

            jasper_initialized=MagickTrue;

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                "Initialized JasPer");

          }

        else

          {

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                  "jas_init() failed!");

          }

      }

#endif  /* HAVE_JAS_INIT_LIBRARY */

      if (!jasper_initialized)

        {

          (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                "Failed to initialize JasPer!");

        }

    }

  return jasper_initialized ? MagickPass : MagickFail;

}

/*

  Cleanup Jasper

*/

static void cleanup_jasper(void)

{

  if (jasper_initialized)

    {

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "Destroying JasPer...");

#if HAVE_JAS_INIT_LIBRARY

      /* Perform global cleanup for the JasPer library. */

      jas_cleanup_library();

#else

      jas_cleanup();

#endif /* if HAVE_JAS_INIT_LIBRARY */

      jasper_initialized=MagickFalse;

    }

}

static Image *ReadJP2Image(const ImageInfo *image_info,

                           ExceptionInfo *exception)

{

  Image

    *image;

  long

    y;

  jas_image_t

    *jp2_image = (jas_image_t *) NULL;

  jas_matrix_t

    *pixels = (jas_matrix_t *) NULL;

  jas_stream_ops_t

    StreamOperators =

    {

      BlobRead,

      BlobWrite,

      BlobSeek,

      BlobClose

    };

  jas_stream_t

    *jp2_stream = (jas_stream_t *) NULL;

  register long

    x;

  register PixelPacket

    *q;

  magick_off_t

    pos;

  int

    component,

    components[4],

    number_components=0;

  Quantum

    *channel_lut[4];

  char

    option_keyval[MaxTextExtent],

    *options = NULL;

  unsigned int

    status;

  MagickBool

    jp2_hdr,

    jpc_hdr,

    pgx_hdr;

  /*

    Initialize Jasper

  */

  if (initialize_jasper(exception) != MagickPass)

    {

      return (Image *) NULL;

    }

#if HAVE_JAS_INIT_LIBRARY

  /*

    Perform any per-thread initialization for the JasPer library.

  */

  if (jas_init_thread())

    {

      /* Handle the initialization error. */

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "jas_init_thread() failed!");

      return (Image *) NULL;

    }

#endif /* if HAVE_JAS_INIT_LIBRARY */

  /*

    Open image file.

  */

  assert(image_info != (const ImageInfo *) NULL);

  assert(image_info->signature == MagickSignature);

  assert(exception != (ExceptionInfo *) NULL);

  assert(exception->signature == MagickSignature);

  (void) memset(channel_lut,0,sizeof(channel_lut));

  image=AllocateImage(image_info);

  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);

  if (status == False)

    ThrowJP2ReaderException(FileOpenError,UnableToOpenFile,image);

  (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                        "Requested format is \"%s\"",

                        image_info->magick);

  /*

    Get the header and auto-detect apparent format.

  */

  {

    size_t

      magick_length;

    unsigned char

      magick[16];

    const MagickInfo

      *magick_info;

    /* Get current seek position (normally 0) */

    pos=TellBlob(image);

    if (pos < 0)

      {

        ThrowJP2ReaderException(BlobError,UnableToObtainOffset,image);

      }

    /* Read header */

    if ((magick_length=ReadBlob(image,sizeof(magick),magick)) != sizeof(magick))

      {

        ThrowJP2ReaderException(CorruptImageError,UnexpectedEndOfFile,image);

      }

    /* Restore seek position */

    if (SeekBlob(image,pos,SEEK_SET) != pos)

      {

        ThrowJP2ReaderException(BlobError,UnableToSeekToOffset,image);

      }

    /* Inspect header to see what it might actually be */

    jp2_hdr=IsJP2(magick,sizeof(magick));

    jpc_hdr=IsJPC(magick,sizeof(magick));

    pgx_hdr=IsPGX(magick,sizeof(magick));

    /*

      If input format was previously auto-detected or specified, then

      assure that header matches what was specified.

    */

    if (((LocaleCompare(image_info->magick,"JP2") == 0) && !jp2_hdr) ||

        (((LocaleCompare(image_info->magick,"JPC") == 0) ||

          (LocaleCompare(image_info->magick,"J2C") == 0)) && !jpc_hdr) ||

        ((LocaleCompare(image_info->magick,"PGX") == 0) && !pgx_hdr))

      {

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "Not a \"%s\" file!", image_info->magick);

        ThrowJP2ReaderException(CorruptImageError,ImproperImageHeader,image);

      }

    /*

      Throw exception if header is not one we expect.

    */

    if (!jp2_hdr && !jpc_hdr && !pgx_hdr)

      {

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "Header is not a supported type for this coder");

        ThrowJP2ReaderException(CorruptImageError,ImproperImageHeader,image);

      }

    /*

      Check if we are allowed to decode this format.

    */

    if (((magick_info = GetMagickInfo(image_info->magick,exception)) ==

         (const MagickInfo *) NULL) ||

        (magick_info->decoder == (DecoderHandler) NULL))

      {

        ThrowJP2ReaderException(DelegateError,UnableToDecodeImageFile,image);

      }

  }

  /*

    Obtain a JP2 Stream.

  */

  jp2_stream=JP2StreamManager(&StreamOperators, image);

  if (jp2_stream == (jas_stream_t *) NULL)

    ThrowJP2ReaderException(DelegateError,UnableToManageJP2Stream,image);

  /*

    Support passing Jasper options.

  */

  {

    unsigned int

      i;

    MagickBool

      max_samples_specified = MagickFalse;

    for (i=0; i < ArraySize(jasper_dec_options); i++)

      {

        const char

          *option = jasper_dec_options[i];

        const char

          *value;

        if ((value=AccessDefinition(image_info,"jp2",option)) != NULL)

          {

            MagickFormatString(option_keyval,sizeof(option_keyval),"%s=%.1024s ",option,value);

            ConcatenateString(&options,option_keyval);

            if (LocaleCompare(option,"max_samples") == 0)

              max_samples_specified=MagickTrue;

            /* Setting debug mode seems to require extra assistance */

            if (LocaleCompare(option,"debug") == 0)

              jas_setdbglevel(atoi(value));

          }

      }

    /*

      If max_samples argument was not specified, then pass options

      argument which specifies "max_samples" to cap memory usage.

    */

    if (!max_samples_specified)

      {

        const magick_uintmax_t width_limit = (magick_uintmax_t) GetMagickResourceLimit(WidthResource);

        const magick_uintmax_t height_limit = (magick_uintmax_t) GetMagickResourceLimit(HeightResource);

        const magick_uintmax_t max_samples_rectangle = width_limit*height_limit;

        const magick_uintmax_t max_samples_pixels = (magick_uintmax_t) GetMagickResourceLimit(PixelsResource);

        const magick_uintmax_t max_samples = Min(max_samples_rectangle,max_samples_pixels);

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "max_samples limits: max_samples_rectangle = "

                              "%" MAGICK_UINTMAX_F "u, max_samples_pixels = %" MAGICK_UINTMAX_F "u",

                              max_samples_rectangle, max_samples_pixels);

        MagickFormatString(option_keyval,sizeof(option_keyval),"max_samples=%" MAGICK_UINTMAX_F "u ", max_samples*3);

        ConcatenateString(&options,option_keyval);

      }

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                          "JP2 options = \"%s\"", options);

  }

  /*

    Decode

  */

  {

    int

      jas_fmt = -1;

    const char *

      jas_fmt_str = NULL;

    if (jp2_hdr)

      jas_fmt_str = "jp2";

    else if (jpc_hdr)

      jas_fmt_str = "jpc";

    else if (pgx_hdr)

      jas_fmt_str = "pgx";

    if (jas_fmt_str != (const char *) NULL)

      {

        jas_fmt = jas_image_strtofmt(jas_fmt_str);

        if (-1 != jas_fmt)

          {

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                  "Decoding %s...", jas_fmt_str);

            jp2_image=jas_image_decode(jp2_stream,jas_fmt,options);

          }

        else

          {

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                  "JasPer does not support format %s!",

                                  jas_fmt_str);

          }

      }

  }

  MagickFreeMemory(options);

  if (jp2_image == (jas_image_t *) NULL)

    ThrowJP2ReaderException(DelegateError,UnableToDecodeImageFile,image);

  /*

    Validate that we can handle the image and obtain component

    indexes.

  */

  switch (jas_clrspc_fam(jas_image_clrspc(jp2_image)))

    {

    case JAS_CLRSPC_FAM_RGB:

      {

        if (((components[0]=

              jas_image_getcmptbytype(jp2_image,

                                      JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_R))) < 0) ||

            ((components[1]=

              jas_image_getcmptbytype(jp2_image,

                                      JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_G))) < 0) ||

            ((components[2]=

              jas_image_getcmptbytype(jp2_image,

                                      JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_RGB_B))) < 0))

          {

            ThrowJP2ReaderException(CorruptImageError,MissingImageChannel,image);

          }

        number_components=3;

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "Image is in RGB colorspace family");

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "RED is in channel %d, GREEN is in channel %d, BLUE is in channel %d",

                              components[0],components[1],components[2]);

        if((components[3]=jas_image_getcmptbytype(jp2_image,

                                                  JAS_IMAGE_CT_COLOR(JAS_IMAGE_CT_OPACITY))) > 0)

          {

            image->matte=MagickTrue;

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                  "OPACITY is in channel %d",components[3]);

            number_components++;

          }

        break;

      }

    case JAS_CLRSPC_FAM_GRAY:

      {

        if ((components[0]=

             jas_image_getcmptbytype(jp2_image,

                                     JAS_IMAGE_CT_COLOR(JAS_CLRSPC_CHANIND_GRAY_Y))) < 0)

          ThrowJP2ReaderException(CorruptImageError,MissingImageChannel,image);

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "Image is in GRAY colorspace family");

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "GRAY is in channel %d",components[0]);

        number_components=1;

        break;

      }

    case JAS_CLRSPC_FAM_YCBCR:

      {

        components[0]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_Y);

        components[1]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CB);

        components[2]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_YCBCR_CR);

        if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0))

          ThrowJP2ReaderException(CorruptImageError,MissingImageChannel,image);

        number_components=3;

        components[3]=jas_image_getcmptbytype(jp2_image,JAS_IMAGE_CT_OPACITY);

        if (components[3] > 0)

          {

            image->matte=True;

            number_components++;

          }

        image->colorspace=YCbCrColorspace;

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "Image is in YCBCR colorspace family");

        break;

      }

    default:

      {

        ThrowJP2ReaderException(CoderError,ColorspaceModelIsNotSupported,image);

      }

    }

  image->columns=jas_image_width(jp2_image);

  image->rows=jas_image_height(jp2_image);

  if (image->logging)

    {

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "columns=%lu rows=%lu components=%d",image->columns,image->rows,

                            number_components);

      for (component=0; component < number_components; component++)

        {

          (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                "Component %u:\n"

                                "    width                         = %ld\n" /* width */

                                "    height                        = %ld\n" /* height */

                                "    tl x,y coordinate             = %ld,%ld\n" /* x,y-coordinates of the top-left corner */

                                "    br x,y coordinate             = %ld,%ld\n" /* x,y-coordinates of the bottom-right corner */

                                "    horizontal subsampling factor = %ld\n" /* horizontal subsampling factor */

                                "    vertical subsampling factor   = %ld\n" /* vertical subsampling factor */

                                "    depth                         = %u\n"  /* depth */

                                "    signed sample data            = %d",   /* signedness of the sample data (true == signed) */

                                component,

                                (long) jas_image_cmptwidth(jp2_image,components[component]),

                                (long) jas_image_cmptheight(jp2_image,components[component]),

                                (long) jas_image_cmpttlx(jp2_image, components[component]),

                                (long) jas_image_cmpttly(jp2_image, components[component]),

                                (long) jas_image_cmptbrx(jp2_image, components[component]),

                                (long) jas_image_cmptbry(jp2_image, components[component]),

                                (long) jas_image_cmpthstep(jp2_image, components[component]),

                                (long) jas_image_cmptvstep(jp2_image, components[component]),

                                (unsigned int) jas_image_cmptprec(jp2_image,components[component]),

                                (int) jas_image_cmptsgnd(jp2_image, components[component]));

        }

    }

  for (component=0; component < number_components; component++)

    {

      if (((unsigned long) jas_image_cmptwidth(jp2_image,components[component]) != image->columns) ||

          ((unsigned long) jas_image_cmptheight(jp2_image,components[component]) != image->rows) ||

          (jas_image_cmpttlx(jp2_image, components[component]) != 0) ||

          (jas_image_cmpttly(jp2_image, components[component]) != 0) ||

          (jas_image_cmpthstep(jp2_image, components[component]) != 1) ||

          (jas_image_cmptvstep(jp2_image, components[component]) != 1))

        ThrowJP2ReaderException(CoderError,IrregularChannelGeometryNotSupported,image);

    }

  /* FIXME: It would be good to support signed data! */

  for (component=0; component < number_components; component++)

    {

      if ((jas_image_cmptsgnd(jp2_image, components[component]) != false))

        ThrowJP2ReaderException(CoderError,DataStorageTypeIsNotSupported,image);

    }

  image->matte=number_components > 3;

  for (component=0; component < number_components; component++)

    {

      unsigned int

        component_depth;

      component_depth=jas_image_cmptprec(jp2_image,components[component]);

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "Component[%d] depth is %u",component,component_depth);

      if (0 == component)

        image->depth=component_depth;

      else

        image->depth=Max(image->depth,component_depth);

    }

  (void) LogMagickEvent(CoderEvent,GetMagickModule(),