First commit - moving from LuaForge to SourceForge

1 files changed, 493 insertions, 0 deletions

diff --git a/src/im_format_jp2.cpp b/src/im_format_jp2.cpp
new file mode 100644
index 0000000..16e2c60
--- /dev/null
+++ b/src/im_format_jp2.cpp
@@ -0,0 +1,493 @@
+/** \file
+ * \brief JP2 File Format
+ *
+ * See Copyright Notice in im_lib.h
+ * See libJaper Copyright Notice in jasper.h
+ * $Id: im_format_jp2.cpp,v 1.1 2008/10/17 06:10:16 scuri Exp $
+ */
+
+#include "im_format.h"
+#include "im_format_jp2.h"
+#include "im_util.h"
+#include "im_counter.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "jasper/jasper.h"
+#include "jpc/jpc_enc.h"
+#include "jp2/jp2_cod.h"
+
+extern "C" 
+{
+  /* implemented in jas_binfile.c */
+  jas_stream_t *jas_binfile_open(const char *file_name, int is_new);
+}
+
+jas_seqent_t iJP2Bits2Int(jas_seqent_t v, int prec, int sgnd)
+{
+  v &= JAS_ONES(prec);
+  return  (sgnd && (v & (1 << (prec - 1)))) ? (v - (1 << prec)) : v;
+}
+
+/* this is based on jas_image_readcmpt */
+template <class T> 
+int iJP2ReadLine(jas_image_t *image, int row, int cmpno, T *data)
+{
+  jas_image_cmpt_t *cmpt = image->cmpts_[cmpno];
+
+  if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * row) * cmpt->cps_, SEEK_SET) < 0) 
+    return 0;
+
+  // this offset will convert from signed to unsigned
+  int offset = 0;
+  if (cmpt->sgnd_ && cmpt->prec_ > 1)
+    offset = 1 << (cmpt->prec_-1);
+
+  for (int j = 0; j < cmpt->width_; j++) 
+  {
+    jas_seqent_t v = 0;
+
+    for (int k = 0; k < cmpt->cps_; k++) 
+    {
+      int c = jas_stream_getc(cmpt->stream_);
+      if (c == EOF) 
+        return 0;
+
+      v = (v << 8) | (c & 0xff);
+    }
+
+    v = iJP2Bits2Int(v, cmpt->prec_, cmpt->sgnd_);
+
+    *data++ = (T)(v + offset);
+  }
+
+  return 1;
+}
+
+uint_fast32_t iJP2Int2Bits(jas_seqent_t v, int prec, int sgnd)
+{
+  uint_fast32_t ret;
+  ret = ((sgnd && v < 0) ? ((1 << prec) + v) : v) & JAS_ONES(prec);
+  return ret;
+}
+
+/* this is based on jas_image_writecmpt */
+template <class T> 
+int iJP2WriteLine(jas_image_t *image, int row, int cmpno, T *data)
+{
+  jas_image_cmpt_t *cmpt = image->cmpts_[cmpno];
+
+  if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * row) * cmpt->cps_, SEEK_SET) < 0) 
+    return 0;
+
+  for (int j = 0; j < cmpt->width_; j++) 
+  {
+    jas_seqent_t v = iJP2Int2Bits(*data++, cmpt->prec_, cmpt->sgnd_);
+
+    for (int k = 0; k < cmpt->cps_; k++) 
+    {
+      int c = (v >> (8 * (cmpt->cps_ - 1))) & 0xff;
+      if (jas_stream_putc(cmpt->stream_, (imbyte)c) == EOF) 
+        return 0;
+
+      v <<= 8;
+    }
+  }
+
+  return 1;
+}
+
+static const char* iJP2CompTable[1] = 
+{
+  "JPEG-2000",
+};
+
+class imFormatJP2: public imFormat
+{
+  int fmtid;
+  jas_stream_t *stream;
+  jas_image_t *image;
+
+public:
+  imFormatJP2()
+    :imFormat("JP2", 
+              "JPEG-2000 JP2 File Format", 
+              "*.jp2;*.jpc;*.j2c;*.j2k;", 
+              iJP2CompTable, 
+              1, 
+              0)
+    {
+      image = 0;
+    }
+  ~imFormatJP2() {}
+
+  int Open(const char* file_name);
+  int New(const char* file_name);
+  void Close();
+  void* Handle(int index);
+  int ReadImageInfo(int index);
+  int ReadImageData(void* data);
+  int WriteImageInfo();
+  int WriteImageData(void* data);
+  int CanWrite(const char* compression, int color_mode, int data_type) const;
+};
+
+static char* ijp2_message = NULL;
+static int ijp2_abort = 0;
+static int ijp2_counter = -1;
+
+static void iJP2ProgressProc(int done, int total, char *descr)
+{
+  (void)descr;
+  if (done == 0)
+  {
+    imCounterTotal(ijp2_counter, total, ijp2_message);
+    ijp2_message = NULL;
+  }
+
+  if (!imCounterIncTo(ijp2_counter, done))
+    ijp2_abort = 1;
+}
+
+static int iJP2AbortProc(void)
+{
+  return ijp2_abort;
+}
+
+void imFormatRegisterJP2(void)
+{
+  // Jasper library initialization
+  jas_init();
+
+  jas_set_progress_proc((jas_progress_proc_t)iJP2ProgressProc);
+  jas_set_test_abort_proc((jas_test_abort_proc_t)iJP2AbortProc);
+  
+  imFormatRegister(new imFormatJP2());
+}
+
+int imFormatJP2::Open(const char* file_name)
+{
+  this->stream = jas_binfile_open(file_name, 0);
+  if (this->stream == NULL)
+    return IM_ERR_OPEN;
+
+  this->fmtid = jas_image_getfmt(this->stream);
+  if (this->fmtid < 0)
+  {
+    jas_stream_close(this->stream);
+    return IM_ERR_FORMAT;
+  }
+
+  strcpy(this->compression, "JPEG-2000");
+  this->image_count = 1;
+
+  return IM_ERR_NONE;
+}
+
+int imFormatJP2::New(const char* file_name)
+{
+  this->stream = jas_binfile_open(file_name, 1);
+  if (this->stream == NULL)
+    return IM_ERR_OPEN;
+
+  strcpy(this->compression, "JPEG-2000");
+  this->image_count = 1;
+
+  return IM_ERR_NONE;
+}
+
+void imFormatJP2::Close()
+{
+  if (this->image)
+    jas_image_destroy(this->image);
+
+  jas_stream_close(this->stream);
+}
+
+void* imFormatJP2::Handle(int index)
+{
+  if (index == 0)
+    return (void*)this->stream->obj_;
+  else if (index == 1)
+    return (void*)this->image;
+  else if (index == 2)
+    return (void*)this->stream;
+  else
+    return NULL;
+}
+
+int imFormatJP2::ReadImageInfo(int index)
+{
+  (void)index;
+
+  // The counter is started because in Jasper all image reading is done here. BAD!
+  ijp2_counter = this->counter;
+  ijp2_abort = 0;
+  ijp2_message = "Reading JP2...";
+  this->image = jas_image_decode(this->stream, this->fmtid, 0);
+  ijp2_counter = -1;
+  if (!this->image)
+    return IM_ERR_ACCESS;
+
+  this->width = jas_image_width(this->image);
+  this->height = jas_image_height(this->image);
+
+  int clrspc_fam = jas_clrspc_fam(jas_image_clrspc(image));
+  switch(clrspc_fam)
+  {
+  case JAS_CLRSPC_FAM_GRAY:
+    this->file_color_mode = IM_GRAY;
+    break;
+  case JAS_CLRSPC_FAM_XYZ:
+    this->file_color_mode = IM_XYZ;
+    break;
+  case JAS_CLRSPC_FAM_RGB:
+    this->file_color_mode = IM_RGB;
+    break;
+  case JAS_CLRSPC_FAM_YCBCR:
+    this->file_color_mode = IM_YCBCR;
+    break;
+  case JAS_CLRSPC_FAM_LAB:
+    this->file_color_mode = IM_LAB;
+    break;
+  default: 
+    return IM_ERR_DATA;
+  }
+
+  this->file_data_type = IM_BYTE;
+  int prec = jas_image_cmptprec(image, 0);
+  if (prec > 8)
+    this->file_data_type = IM_USHORT;
+
+  if (prec < 8)
+    this->convert_bpp = -prec; // just expand to 0-255
+
+  if (prec == 1 && this->file_color_mode == IM_GRAY)
+    this->file_color_mode = IM_BINARY;
+
+  int cmpno = jas_image_getcmptbytype(this->image, JAS_IMAGE_CT_OPACITY);
+  if (cmpno != -1)
+    this->file_color_mode |= IM_ALPHA;
+
+  this->file_color_mode |= IM_TOPDOWN;
+
+  if (image->metadata.count > 0) 
+  {
+    imAttribTable* attrib_table = AttribTable();
+    
+    // First write GeoTIFF data
+    jas_metadata_box_t *metabox = &image->metadata.boxes[JAS_IMAGE_BOX_GEO]; 
+    if (metabox->size>0 && metabox->buf) 
+      attrib_table->Set("GeoTIFFBox", IM_BYTE, metabox->size, metabox->buf);
+
+    // Check if XMP is there
+    metabox = &image->metadata.boxes[JAS_IMAGE_BOX_XMP]; 
+    if (metabox->size>0 && metabox->buf) 
+      attrib_table->Set("XMLPacket", IM_BYTE, metabox->size, metabox->buf);
+  }
+
+  return IM_ERR_NONE;
+}
+
+int imFormatJP2::WriteImageInfo()
+{
+  this->file_data_type = this->user_data_type;
+  this->file_color_mode = imColorModeSpace(this->user_color_mode);
+  this->file_color_mode |= IM_TOPDOWN;
+
+  int prec = 8;
+  if (this->file_data_type == IM_USHORT)
+    prec = 16;
+
+  jas_clrspc_t clrspc;
+  switch (imColorModeSpace(this->user_color_mode))
+  {
+  case IM_BINARY:
+    prec = 1;    
+  case IM_GRAY:
+    clrspc = JAS_CLRSPC_SGRAY;
+    break;
+  case IM_RGB:   
+    clrspc = JAS_CLRSPC_SRGB;
+    break;
+  case IM_XYZ:
+    clrspc = JAS_CLRSPC_CIEXYZ;
+    break;
+  case IM_LAB:
+    clrspc = JAS_CLRSPC_CIELAB;
+    break;
+  case IM_YCBCR:
+    clrspc = JAS_CLRSPC_SYCBCR;
+    break;
+  default:
+    return IM_ERR_DATA;
+  }
+
+  if (imColorModeHasAlpha(this->user_color_mode))
+    this->file_color_mode |= IM_ALPHA;
+
+  int numcmpts = imColorModeDepth(this->file_color_mode);
+  
+  jas_image_cmptparm_t cmptparms[4];
+  for (int i = 0; i < numcmpts; i++) 
+  {
+    jas_image_cmptparm_t* cmptparm = &cmptparms[i];
+
+    cmptparm->tlx = 0;
+    cmptparm->tly = 0;
+    cmptparm->hstep = 1;
+    cmptparm->vstep = 1;
+    cmptparm->width = this->width;
+    cmptparm->height = this->height;
+    cmptparm->prec = prec;
+    cmptparm->sgnd = 0;
+  }
+
+  this->image = jas_image_create(numcmpts, cmptparms, clrspc);
+  if (!this->image)
+    return IM_ERR_DATA;
+
+  if (this->image->metadata.count > 0) 
+  {
+    const void* data;
+    int size;
+    imAttribTable* attrib_table = AttribTable();
+
+    // GeoTIFF first
+    data = attrib_table->Get("GeoTIFFBox", NULL, &size);
+    if (data)
+    {
+      jas_metadata_box_t *metabox = &image->metadata.boxes[JAS_IMAGE_BOX_GEO]; 
+      jas_box_alloc(metabox, size);
+      memcpy(metabox->buf, data, size);
+      memcpy(metabox->id, msi_uuid, sizeof(msi_uuid));
+    }
+   
+    // Adobe XMP
+    data = attrib_table->Get("XMLPacket", NULL, &size);
+    {
+      jas_metadata_box_t *metabox = &image->metadata.boxes[JAS_IMAGE_BOX_XMP]; 
+      jas_box_alloc(metabox, size);
+      memcpy(metabox->buf, data, size);
+      memcpy(metabox->id, xmp_uuid, sizeof(xmp_uuid));
+    }
+  }
+
+  return IM_ERR_NONE;
+}
+
+int imFormatJP2::ReadImageData(void* data)
+{
+  int count = imFileLineBufferCount(this);
+
+  imCounterTotal(this->counter, count, NULL);
+
+  int alpha_plane = -1;
+  if (imColorModeHasAlpha(this->user_color_mode) && imColorModeHasAlpha(this->file_color_mode))
+    alpha_plane = imColorModeDepth(this->file_color_mode) - 1;
+
+  int row = 0, plane = 0;
+  for (int i = 0; i < count; i++)
+  {
+    int cmpno;
+    if (plane == alpha_plane)
+      cmpno = jas_image_getcmptbytype(image, JAS_IMAGE_CT_OPACITY);
+    else
+      cmpno = jas_image_getcmptbytype(image, JAS_IMAGE_CT_COLOR(plane));
+
+    if (cmpno == -1)
+      return IM_ERR_DATA;
+
+    int ret = 1;
+    if (this->file_data_type == IM_BYTE)
+      ret = iJP2ReadLine(image, row, cmpno, (imbyte*)this->line_buffer);
+    else
+      ret = iJP2ReadLine(image, row, cmpno, (imushort*)this->line_buffer);
+
+    if (!ret)
+      return IM_ERR_ACCESS;
+
+    imFileLineBufferRead(this, data, row, plane);
+
+    if (!imCounterInc(this->counter))
+      return IM_ERR_COUNTER;
+
+    imFileLineBufferInc(this, &row, &plane);
+  }
+
+  return IM_ERR_NONE;
+}
+
+int imFormatJP2::WriteImageData(void* data)
+{
+  int count = imFileLineBufferCount(this);
+  imCounterTotal(this->counter, count, "Writing JP2...");  /* first time count */
+
+  int depth = imColorModeDepth(this->file_color_mode);
+  if (imColorModeHasAlpha(this->user_color_mode) && imColorModeHasAlpha(this->file_color_mode))
+  {
+    jas_image_setcmpttype(image, depth-1, JAS_IMAGE_CT_OPACITY);
+    depth--;
+  }
+
+  for (int d = 0; d < depth; d++)
+    jas_image_setcmpttype(image, d, JAS_IMAGE_CT_COLOR(d));
+
+  int row = 0, plane = 0;
+  for (int i = 0; i < count; i++)
+  {
+    imFileLineBufferWrite(this, data, row, plane);
+
+    int ret = 1;
+    if (this->file_data_type == IM_BYTE)
+      ret = iJP2WriteLine(image, row, plane, (imbyte*)this->line_buffer);
+    else
+      ret = iJP2WriteLine(image, row, plane, (imushort*)this->line_buffer);
+
+    if (!imCounterInc(this->counter))
+      return IM_ERR_COUNTER;
+
+    imFileLineBufferInc(this, &row, &plane);
+  }
+
+  char outopts[512] = "";
+  imAttribTable* attrib_table = AttribTable();
+
+  float* ratio = (float*)attrib_table->Get("CompressionRatio");
+  if (ratio)
+    sprintf(outopts, "rate=%g", (double)(1.0 / *ratio));
+
+  // The counter continuous because in Jasper all image writing is done here. BAD!
+  ijp2_counter = this->counter;
+  ijp2_abort = 0;
+  ijp2_message = NULL;  /* other counts */
+  int err = jas_image_encode(image, stream, 0 /*JP2 format always */, outopts);
+  ijp2_counter = -1;
+  if (err)
+    return IM_ERR_ACCESS;
+
+  jas_stream_flush(stream);
+
+  return IM_ERR_NONE;
+}
+
+int imFormatJP2::CanWrite(const char* compression, int color_mode, int data_type) const
+{
+  int color_space = imColorModeSpace(color_mode);
+
+  if (color_space == IM_MAP || color_space == IM_CMYK || 
+      color_space == IM_LUV)
+    return IM_ERR_DATA;                       
+                                              
+  if (data_type != IM_BYTE && data_type != IM_USHORT)
+    return IM_ERR_DATA;
+
+  if (!compression || compression[0] == 0)
+    return IM_ERR_NONE;
+
+  if (!imStrEqual(compression, "JPEG-2000"))
+    return IM_ERR_COMPRESS;
+
+  return IM_ERR_NONE;
+}