Revert "OpenJPEG: update to 2.1 from 1.5"
[blender.git] / extern / libopenjpeg / tcd.h
index 360923b1512296b41fb6b841415deb23ba7a6aad..e3f93adc37f4e6c0570816eead7d1e907e0f6f00 100644 (file)
@@ -1,18 +1,10 @@
 /*
- * The copyright in this software is being made available under the 2-clauses 
- * BSD License, included below. This software may be subject to other third 
- * party and contributor rights, including patent rights, and no such rights
- * are granted under this license.
- *
- * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium
- * Copyright (c) 2002-2014, Professor Benoit Macq
+ * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
+ * Copyright (c) 2002-2007, Professor Benoit Macq
  * Copyright (c) 2001-2003, David Janssens
  * Copyright (c) 2002-2003, Yannick Verschueren
- * Copyright (c) 2003-2007, Francois-Olivier Devaux 
- * Copyright (c) 2003-2014, Antonin Descampe
+ * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
  * Copyright (c) 2005, Herve Drolon, FreeImage Team
- * Copyright (c) 2008, 2011-2012, Centre National d'Etudes Spatiales (CNES), FR 
- * Copyright (c) 2012, CS Systemes d'Information, France
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 @file tcd.h
 @brief Implementation of a tile coder/decoder (TCD)
 
-The functions in TCD.C encode or decode each tile independently from
-each other. The functions in TCD.C are used by other functions in J2K.C.
+The functions in TCD.C have for goal to encode or decode each tile independently from
+each other. The functions in TCD.C are used by some function in J2K.C.
 */
 
 /** @defgroup TCD TCD - Implementation of a tile coder/decoder */
 /*@{*/
 
 /**
-FIXME DOC
+FIXME: documentation
 */
 typedef struct opj_tcd_seg {
-       OPJ_BYTE ** data;
-       OPJ_UINT32 dataindex;
-       OPJ_UINT32 numpasses;
-       OPJ_UINT32 real_num_passes;
-       OPJ_UINT32 len;
-       OPJ_UINT32 maxpasses;
-       OPJ_UINT32 numnewpasses;
-       OPJ_UINT32 newlen;
+  unsigned char** data;
+  int dataindex;
+  int numpasses;
+  int len;
+  int maxpasses;
+  int numnewpasses;
+  int newlen;
 } opj_tcd_seg_t;
 
 /**
-FIXME DOC
+FIXME: documentation
 */
 typedef struct opj_tcd_pass {
-       OPJ_UINT32 rate;
-       OPJ_FLOAT64 distortiondec;
-       OPJ_UINT32 len;
-       OPJ_UINT32 term : 1;
+  int rate;
+  double distortiondec;
+  int term, len;
 } opj_tcd_pass_t;
 
 /**
-FIXME DOC
+FIXME: documentation
 */
 typedef struct opj_tcd_layer {
-       OPJ_UINT32 numpasses;           /* Number of passes in the layer */
-       OPJ_UINT32 len;                         /* len of information */
-       OPJ_FLOAT64 disto;                      /* add for index (Cfr. Marcela) */
-       OPJ_BYTE *data;                         /* data */
+  int numpasses;               /* Number of passes in the layer */
+  int len;                     /* len of information */
+  double disto;                        /* add for index (Cfr. Marcela) */
+  unsigned char *data;         /* data */
 } opj_tcd_layer_t;
 
 /**
-FIXME DOC
+FIXME: documentation
 */
 typedef struct opj_tcd_cblk_enc {
-       OPJ_BYTE* data;                                 /* Data */
-       opj_tcd_layer_t* layers;                /* layer information */
-       opj_tcd_pass_t* passes;         /* information about the passes */
-       OPJ_INT32 x0, y0, x1, y1;               /* dimension of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
-       OPJ_UINT32 numbps;
-       OPJ_UINT32 numlenbits;
-       OPJ_UINT32 numpasses;                   /* number of pass already done for the code-blocks */
-       OPJ_UINT32 numpassesinlayers;   /* number of passes in the layer */
-       OPJ_UINT32 totalpasses;                 /* total number of passes */
+  unsigned char* data; /* Data */
+  opj_tcd_layer_t* layers;     /* layer information */
+  opj_tcd_pass_t* passes;      /* information about the passes */
+  int x0, y0, x1, y1;          /* dimension of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
+  int numbps;
+  int numlenbits;
+  int numpasses;               /* number of pass already done for the code-blocks */
+  int numpassesinlayers;       /* number of passes in the layer */
+  int totalpasses;             /* total number of passes */
 } opj_tcd_cblk_enc_t;
 
-
 typedef struct opj_tcd_cblk_dec {
-       OPJ_BYTE * data;                                /* Data */
-       opj_tcd_seg_t* segs;                    /* segments information */
-       OPJ_INT32 x0, y0, x1, y1;               /* position of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
-       OPJ_UINT32 numbps;
-       OPJ_UINT32 numlenbits;
-    OPJ_UINT32 data_max_size;          /* Size of allocated data buffer */
-       OPJ_UINT32 data_current_size;   /* Size of used data buffer */
-       OPJ_UINT32 numnewpasses;                /* number of pass added to the code-blocks */
-       OPJ_UINT32 numsegs;                             /* number of segments */
-       OPJ_UINT32 real_num_segs;
-       OPJ_UINT32 m_current_max_segs;
+  unsigned char* data; /* Data */
+  opj_tcd_seg_t* segs;         /* segments informations */
+       int x0, y0, x1, y1;             /* dimension of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
+  int numbps;
+  int numlenbits;
+  int len;                     /* length */
+  int numnewpasses;            /* number of pass added to the code-blocks */
+  int numsegs;                 /* number of segments */
 } opj_tcd_cblk_dec_t;
 
 /**
-FIXME DOC
+FIXME: documentation
 */
 typedef struct opj_tcd_precinct {
-       OPJ_INT32 x0, y0, x1, y1;               /* dimension of the precinct : left upper corner (x0, y0) right low corner (x1,y1) */
-       OPJ_UINT32 cw, ch;                              /* number of precinct in width and height */
-       union{                                                  /* code-blocks information */
-               opj_tcd_cblk_enc_t* enc;
-               opj_tcd_cblk_dec_t* dec;
-       } cblks;
-       OPJ_UINT32 block_size;                  /* size taken by cblks (in bytes) */
-       opj_tgt_tree_t *incltree;           /* inclusion tree */
-       opj_tgt_tree_t *imsbtree;           /* IMSB tree */
+  int x0, y0, x1, y1;          /* dimension of the precinct : left upper corner (x0, y0) right low corner (x1,y1) */
+  int cw, ch;                  /* number of precinct in width and heigth */
+  union{               /* code-blocks informations */
+         opj_tcd_cblk_enc_t* enc;
+         opj_tcd_cblk_dec_t* dec;
+  } cblks;
+  opj_tgt_tree_t *incltree;            /* inclusion tree */
+  opj_tgt_tree_t *imsbtree;            /* IMSB tree */
 } opj_tcd_precinct_t;
 
 /**
-FIXME DOC
+FIXME: documentation
 */
 typedef struct opj_tcd_band {
-       OPJ_INT32 x0, y0, x1, y1;               /* dimension of the subband : left upper corner (x0, y0) right low corner (x1,y1) */
-       OPJ_UINT32 bandno;
-       opj_tcd_precinct_t *precincts;  /* precinct information */
-       OPJ_UINT32 precincts_data_size; /* size of data taken by precincts */
-       OPJ_INT32 numbps;
-       OPJ_FLOAT32 stepsize;
+  int x0, y0, x1, y1;          /* dimension of the subband : left upper corner (x0, y0) right low corner (x1,y1) */
+  int bandno;
+  opj_tcd_precinct_t *precincts;       /* precinct information */
+  int numbps;
+  float stepsize;
 } opj_tcd_band_t;
 
 /**
-FIXME DOC
+FIXME: documentation
 */
 typedef struct opj_tcd_resolution {
-       OPJ_INT32 x0, y0, x1, y1;               /* dimension of the resolution level : left upper corner (x0, y0) right low corner (x1,y1) */
-       OPJ_UINT32 pw, ph;
-       OPJ_UINT32 numbands;                    /* number sub-band for the resolution level */
-       opj_tcd_band_t bands[3];                /* subband information */
+  int x0, y0, x1, y1;          /* dimension of the resolution level : left upper corner (x0, y0) right low corner (x1,y1) */
+  int pw, ph;
+  int numbands;                        /* number sub-band for the resolution level */
+  opj_tcd_band_t bands[3];             /* subband information */
 } opj_tcd_resolution_t;
 
 /**
-FIXME DOC
+FIXME: documentation
 */
-typedef struct opj_tcd_tilecomp
-{
-       OPJ_INT32 x0, y0, x1, y1;                               /* dimension of component : left upper corner (x0, y0) right low corner (x1,y1) */
-       OPJ_UINT32 numresolutions;                              /* number of resolutions level */
-       OPJ_UINT32 minimum_num_resolutions;             /* number of resolutions level to decode (at max)*/
-       opj_tcd_resolution_t *resolutions;      /* resolutions information */
-       OPJ_UINT32 resolutions_size;                    /* size of data for resolutions (in bytes) */
-       OPJ_INT32 *data;                                                /* data of the component */
-       OPJ_UINT32 data_size;                                   /* size of the data of the component */
-       OPJ_INT32 numpix;                                               /* add fixed_quality */
+typedef struct opj_tcd_tilecomp {
+  int x0, y0, x1, y1;          /* dimension of component : left upper corner (x0, y0) right low corner (x1,y1) */
+  int numresolutions;          /* number of resolutions level */
+  opj_tcd_resolution_t *resolutions;   /* resolutions information */
+  int *data;                   /* data of the component */
+  int numpix;                  /* add fixed_quality */
 } opj_tcd_tilecomp_t;
 
-
 /**
-FIXME DOC
+FIXME: documentation
 */
 typedef struct opj_tcd_tile {
-       OPJ_INT32 x0, y0, x1, y1;               /* dimension of the tile : left upper corner (x0, y0) right low corner (x1,y1) */
-       OPJ_UINT32 numcomps;                    /* number of components in tile */
-       opj_tcd_tilecomp_t *comps;      /* Components information */
-       OPJ_INT32 numpix;                               /* add fixed_quality */
-       OPJ_FLOAT64 distotile;                  /* add fixed_quality */
-       OPJ_FLOAT64 distolayer[100];    /* add fixed_quality */
-       OPJ_UINT32 packno;              /* packet number */
+  int x0, y0, x1, y1;          /* dimension of the tile : left upper corner (x0, y0) right low corner (x1,y1) */
+  int numcomps;                        /* number of components in tile */
+  opj_tcd_tilecomp_t *comps;   /* Components information */
+  int numpix;                  /* add fixed_quality */
+  double distotile;            /* add fixed_quality */
+  double distolayer[100];      /* add fixed_quality */
+  /** packet number */
+  int packno;
 } opj_tcd_tile_t;
 
 /**
-FIXME DOC
+FIXME: documentation
 */
-typedef struct opj_tcd_image
-{
-       opj_tcd_tile_t *tiles;          /* Tiles information */
-}
-opj_tcd_image_t;
-
+typedef struct opj_tcd_image {
+  int tw, th;                  /* number of tiles in width and heigth */
+  opj_tcd_tile_t *tiles;               /* Tiles information */
+} opj_tcd_image_t;
 
 /**
 Tile coder/decoder
 */
-typedef struct opj_tcd
-{
+typedef struct opj_tcd {
        /** Position of the tilepart flag in Progression order*/
-       OPJ_INT32 tp_pos;
+       int tp_pos;
        /** Tile part number*/
-       OPJ_UINT32 tp_num;
+       int tp_num;
        /** Current tile part number*/
-       OPJ_UINT32 cur_tp_num;
+       int cur_tp_num;
        /** Total number of tileparts of the current tile*/
-       OPJ_UINT32 cur_totnum_tp;
+       int cur_totnum_tp;
        /** Current Packet iterator number */
-       OPJ_UINT32 cur_pino;
+       int cur_pino;
+       /** codec context */
+       opj_common_ptr cinfo;
+
        /** info on each image tile */
        opj_tcd_image_t *tcd_image;
-       /** image header */
+       /** image */
        opj_image_t *image;
        /** coding parameters */
        opj_cp_t *cp;
+       /** pointer to the current encoded/decoded tile */
+       opj_tcd_tile_t *tcd_tile;
        /** coding/decoding parameters common to all tiles */
        opj_tcp_t *tcp;
        /** current encoded/decoded tile */
-       OPJ_UINT32 tcd_tileno;
-       /** tell if the tcd is a decoder. */
-       OPJ_UINT32 m_is_decoder : 1;
+       int tcd_tileno;
+       /** Time taken to encode a tile*/
+       double encoding_time;
 } opj_tcd_t;
 
 /** @name Exported functions */
@@ -225,126 +207,76 @@ typedef struct opj_tcd
 /**
 Dump the content of a tcd structure
 */
-/*void tcd_dump(FILE *fd, opj_tcd_t *tcd, opj_tcd_image_t *img);*/ /* TODO MSD shoul use the new v2 structures */ 
-
+void tcd_dump(FILE *fd, opj_tcd_t *tcd, opj_tcd_image_t *img);
 /**
 Create a new TCD handle
-@param p_is_decoder FIXME DOC
+@param cinfo Codec context info
 @return Returns a new TCD handle if successful returns NULL otherwise
 */
-opj_tcd_t* opj_tcd_create(OPJ_BOOL p_is_decoder);
-
+opj_tcd_t* tcd_create(opj_common_ptr cinfo);
 /**
 Destroy a previously created TCD handle
 @param tcd TCD handle to destroy
 */
-void opj_tcd_destroy(opj_tcd_t *tcd);
-
+void tcd_destroy(opj_tcd_t *tcd);
 /**
- * Initialize the tile coder and may reuse some memory.
- * @param      p_tcd           TCD handle.
- * @param      p_image         raw image.
- * @param      p_cp            coding parameters.
- *
- * @return true if the encoding values could be set (false otherwise).
+Initialize the tile coder (allocate the memory)
+@param tcd TCD handle
+@param image Raw image
+@param cp Coding parameters
+@param curtileno Number that identifies the tile that will be encoded
 */
-OPJ_BOOL opj_tcd_init( opj_tcd_t *p_tcd,
-                                               opj_image_t * p_image,
-                                               opj_cp_t * p_cp );
-
+void tcd_malloc_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int curtileno);
 /**
- * Allocates memory for decoding a specific tile.
- *
- * @param      p_tcd           the tile decoder.
- * @param      p_tile_no       the index of the tile received in sequence. This not necessarily lead to the
- * tile at index p_tile_no.
- *
- * @return     true if the remaining data is sufficient.
- */
-OPJ_BOOL opj_tcd_init_decode_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no);
-
-void opj_tcd_makelayer_fixed(opj_tcd_t *tcd, OPJ_UINT32 layno, OPJ_UINT32 final);
-
-void opj_tcd_rateallocate_fixed(opj_tcd_t *tcd);
-
-void opj_tcd_makelayer(        opj_tcd_t *tcd,
-                                               OPJ_UINT32 layno,
-                                               OPJ_FLOAT64 thresh,
-                                               OPJ_UINT32 final);
-
-OPJ_BOOL opj_tcd_rateallocate( opj_tcd_t *tcd,
-                                                               OPJ_BYTE *dest,
-                                                               OPJ_UINT32 * p_data_written,
-                                                               OPJ_UINT32 len,
-                                                               opj_codestream_info_t *cstr_info);
-
+Free the memory allocated for encoding
+@param tcd TCD handle
+*/
+void tcd_free_encode(opj_tcd_t *tcd);
 /**
- * Gets the maximum tile size that will be taken by the tile once decoded.
- */
-OPJ_UINT32 opj_tcd_get_decoded_tile_size (opj_tcd_t *p_tcd );
-
+Initialize the tile coder (reuses the memory allocated by tcd_malloc_encode)
+@param tcd TCD handle
+@param image Raw image
+@param cp Coding parameters
+@param curtileno Number that identifies the tile that will be encoded
+*/
+void tcd_init_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int curtileno);
 /**
- * Encodes a tile from the raw image into the given buffer.
- * @param      p_tcd                   Tile Coder handle
- * @param      p_tile_no               Index of the tile to encode.
- * @param      p_dest                  Destination buffer
- * @param      p_data_written  pointer to an int that is incremented by the number of bytes really written on p_dest
- * @param      p_len                   Maximum length of the destination buffer
- * @param      p_cstr_info             Codestream information structure
- * @return  true if the coding is successfull.
+Initialize the tile decoder
+@param tcd TCD handle
+@param image Raw image
+@param cp Coding parameters
 */
-OPJ_BOOL opj_tcd_encode_tile(   opj_tcd_t *p_tcd,
-                                                           OPJ_UINT32 p_tile_no,
-                                                           OPJ_BYTE *p_dest,
-                                                           OPJ_UINT32 * p_data_written,
-                                                           OPJ_UINT32 p_len,
-                                                           struct opj_codestream_info *p_cstr_info);
-
-
+void tcd_malloc_decode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp);
+void tcd_malloc_decode_tile(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int tileno, opj_codestream_info_t *cstr_info);
+void tcd_makelayer_fixed(opj_tcd_t *tcd, int layno, int final);
+void tcd_rateallocate_fixed(opj_tcd_t *tcd);
+void tcd_makelayer(opj_tcd_t *tcd, int layno, double thresh, int final);
+opj_bool tcd_rateallocate(opj_tcd_t *tcd, unsigned char *dest, int len, opj_codestream_info_t *cstr_info);
+/**
+Encode a tile from the raw image into a buffer
+@param tcd TCD handle
+@param tileno Number that identifies one of the tiles to be encoded
+@param dest Destination buffer
+@param len Length of destination buffer
+@param cstr_info Codestream information structure 
+@return 
+*/
+int tcd_encode_tile(opj_tcd_t *tcd, int tileno, unsigned char *dest, int len, opj_codestream_info_t *cstr_info);
 /**
 Decode a tile from a buffer into a raw image
 @param tcd TCD handle
 @param src Source buffer
 @param len Length of source buffer
 @param tileno Number that identifies one of the tiles to be decoded
-@param cstr_info  FIXME DOC
+@param cstr_info Codestream information structure
 */
-OPJ_BOOL opj_tcd_decode_tile(   opj_tcd_t *tcd,
-                                                           OPJ_BYTE *src,
-                                                           OPJ_UINT32 len,
-                                                           OPJ_UINT32 tileno,
-                                                           opj_codestream_index_t *cstr_info);
-
-
+opj_bool tcd_decode_tile(opj_tcd_t *tcd, unsigned char *src, int len, int tileno, opj_codestream_info_t *cstr_info);
 /**
- * Copies tile data from the system onto the given memory block.
- */
-OPJ_BOOL opj_tcd_update_tile_data (    opj_tcd_t *p_tcd,
-                                                                   OPJ_BYTE * p_dest,
-                                                                   OPJ_UINT32 p_dest_length );
-
-/**
- *
- */
-OPJ_UINT32 opj_tcd_get_encoded_tile_size ( opj_tcd_t *p_tcd );
-
-/**
- * Initialize the tile coder and may reuse some meory.
- *
- * @param      p_tcd           TCD handle.
- * @param      p_tile_no       current tile index to encode.
- *
- * @return true if the encoding values could be set (false otherwise).
+Free the memory allocated for decoding
+@param tcd TCD handle
 */
-OPJ_BOOL opj_tcd_init_encode_tile (    opj_tcd_t *p_tcd,
-                                                                   OPJ_UINT32 p_tile_no );
-
-/**
- * Copies tile data from the given memory block onto the system.
- */
-OPJ_BOOL opj_tcd_copy_tile_data (opj_tcd_t *p_tcd,
-                                 OPJ_BYTE * p_src,
-                                 OPJ_UINT32 p_src_length );
+void tcd_free_decode(opj_tcd_t *tcd);
+void tcd_free_decode_tile(opj_tcd_t *tcd, int tileno);
 
 /* ----------------------------------------------------------------------- */
 /*@}*/