bug fix in call to calc_xi macro

transferal of stream to span not required in assemble_codestream anymore.
assemble_codestream and bwc_compress return the size of the compressed data.
user provided buffer is used.

include/library/private/bitstream.h

@@ -92,7 +92,7 @@
   \************************************************************************************************/
   uint64       bytes_used                 (bitstream             const  *const  stream);
   //==========|==========================|======================|======|======|=====================
-  bitstream*   init_stream                (uchar                        *const  memory, 
+  bitstream*   init_bitstream             (uchar                        *const  memory,
                                            uint32                const          size, 
                                            char                  const          instr);
   //==========|==========================|======================|======|======|=====================
@@ -117,8 +117,10 @@
   //==========|==========================|======================|======|======|=====================
   uchar        get_bit                    (bitstream                    *const  stream);
   //==========|==========================|======================|======|======|=====================
-  uchar        terminate_stream           (bitstream                           *stream, 
+  uchar        shrink_to_fit              (bitstream                    *const  stream);
-                                           bwc_stream                   *const  packed_stream);
   //==========|==========================|======================|======|======|=====================
-  void         release_packed_stream      (bwc_stream                   *const  stream);
+  uchar        transfer_to_span           (bitstream                    *const  stream,
+                                           bwc_span                     *const  span);
+  //==========|==========================|======================|======|======|=====================
+  void         release_packed_stream      (bwc_span                     *const  stream);
 #endif

include/library/private/codestream.h

@@ -89,16 +89,18 @@
   ||            |    |__| |__] |___ | |___    |    |__| | \| |___  |  | |__| | \| ___]            ||
   ||                                                                                              ||
   \************************************************************************************************/
-  uchar        assemble_main_header       (bwc_field                    *const  field);
+  uchar        assemble_main_header       (bwc_codec                    *const  codec);
   //==========|==========================|======================|======|======|=====================
-  uchar        codestream_write_aux       (bwc_stream                   *const  header, 
+  uchar        codestream_write_aux       (bwc_span                     *const  header, 
-                                           bwc_stream                   *const  aux);
+                                           bwc_span                     *const  aux);
   //==========|==========================|======================|======|======|=====================
-  uchar        codestream_write_com       (bwc_stream                   *const  header,
+  uchar        codestream_write_com       (bwc_span                     *const  header,
-                                           bwc_stream                   *const  com);
+                                           bwc_span                     *const  com);
   //==========|==========================|======================|======|======|=====================
-  bwc_stream*  assemble_codestream        (bwc_field                    *const  field);
+  size_t       assemble_codestream        (bwc_codec                    *const  codec,
+                                           bwc_stream                   *const  stream);
   //==========|==========================|======================|======|======|=====================
-  bwc_field*   parse_codestream           (bwc_data                     *const  data,
+  bwc_codec*   parse_codestream           (bwc_codec                    *const  codec,
+                                           bwc_stream                   *const  stream,
                                            uint8                         const  layer);
 #endif

include/library/private/constants.h

@@ -114,8 +114,14 @@
   \*----------------------------------------------------------------------------------------------*/
   typedef enum
   {
-    bwc_type_half,
+    bwc_precision_half = 2,
-    bwc_type_single,
+    bwc_precision_single = 4,
-    bwc_type_double,
+    bwc_precision_double = 8,
-  } bwc_type;
+  } bwc_precision;
+
+  typedef enum
+  {
+    comp,
+    decomp,
+  } bwc_mode;
 #endif

include/library/private/dwt.h

@@ -157,13 +157,13 @@
   \************************************************************************************************/
   uchar        initialize_gain_lut        ();
   //==========|==========================|======================|======|=======|====================
-  bwc_float    get_dwt_energy_gain        (bwc_field                    *const  field, 
+  bwc_float    get_dwt_energy_gain        (bwc_codec                    *const  codec, 
                                            uchar                 const          highband_flag, 
                                            uint16                const          level);
   //==========|==========================|======================|======|=======|====================
-  uchar        forward_wavelet_transform  (bwc_field                    *const  field, 
+  uchar        forward_wavelet_transform  (bwc_codec                    *const  codec, 
                                            bwc_parameter                *const  parameter);
   //==========|==========================|======================|======|=======|====================
-  uchar        inverse_wavelet_transform  (bwc_field                    *const  field, 
+  uchar        inverse_wavelet_transform  (bwc_codec                    *const  codec, 
                                            bwc_parameter                *const  parameter);
 #endif

include/library/private/libbwc.h

@@ -64,92 +64,95 @@
   ||                                                                                              ||
   \************************************************************************************************/
   //==========|==========================|======================|======|=======|====================
-  bwc_data*    bwc_initialize_data        (double                       *const  field,
+  bwc_stream*  bwc_init_stream            (void                         *const  inpbuf,
-                                           uint64                const          nX,
+                                           void                         *const  outbuf,
-                                           uint64                const          nY,
+                                           bwc_mode              const          mode);
-                                           uint64                const          nZ,
-                                           uint16                const          nTS,
-                                           uint8                 const          nPar,
-                                           char                         *const  file_extension);
   //==========|==========================|======================|======|=======|====================
-  uchar        bwc_set_com                (bwc_data                     *const  data,
+  uchar        bwc_set_com                (bwc_stream                   *const  stream,
                                            char                  const  *const  com, 
                                            uint16                const          size);
   //==========|==========================|======================|======|=======|====================
-  uchar        bwc_set_aux                (bwc_data                     *const  data,
+  uchar        bwc_set_aux                (bwc_stream                   *const  stream,
                                            char                  const  *const  aux, 
                                            uint32                const          size);
   //==========|==========================|======================|======|=======|====================
-  void         bwc_add_param              (bwc_data                     *const  data, 
+  uchar        create_codec               (bwc_codec                    *const  codec);
-                                           char                         *const  name,
-                                           uint8                 const          precision);
   //==========|==========================|======================|======|=======|====================
-  void         bwc_get_data               (bwc_data                     *const  data,
+  bwc_codec*   configure_codec            (bwc_codec                    *const  codec,
-                                           uchar                        *const  buffer,
+                                           uint64                const          nX,
-                                           uint64                const          size);
+                                           uint64                const          nY,
+                                           uint64                const          nZ,
+                                           uint64                const          nTS,
+                                           uint8                 const          nPar,
+                                           bwc_precision         const          prec);
   //==========|==========================|======================|======|=======|====================
-  void         bwc_free_data              (bwc_data                     *const  data);
+  bwc_codec*   bwc_alloc_coder            (uint64                const          nX,
+                                           uint64                const          nY,
+                                           uint64                const          nZ,
+                                           uint64                const          nTS,
+                                           uint8                 const          nPar,
+                                           bwc_precision         const          prec);
   //==========|==========================|======================|======|=======|====================
-  uchar        create_field               (bwc_field                    *const  field);
+  bwc_codec*   bwc_alloc_decoder          ();
   //==========|==========================|======================|======|=======|====================
-  void         bwc_kill_compression       (bwc_field                    *const  field);
+  void         bwc_free_codec             (bwc_codec                    *const  codec);
   //==========|==========================|======================|======|=======|====================
-  bwc_field*   bwc_initialize_field       (bwc_data                     *const  data);
+  void         bwc_set_error_resilience   (bwc_codec                    *const  codec);
   //==========|==========================|======================|======|=======|====================
-  void         bwc_set_error_resilience   (bwc_field                    *const  field);
+  void         set_quant_style            (bwc_codec                    *const  codec, 
-  //==========|==========================|======================|======|=======|====================
-  void         set_quant_style            (bwc_field                    *const  field, 
                                            bwc_quant_st          const          quantization_style);
   //==========|==========================|======================|======|=======|====================
-  void         set_quant_step_size        (bwc_field                    *const  field,
+  void         set_quant_step_size        (bwc_codec                    *const  codec,
                                            double                const          delta);
   //==========|==========================|======================|======|=======|====================
-  void         set_progression            (bwc_field                    *const  field,
+  void         set_progression            (bwc_codec                    *const  codec,
                                            bwc_prog_ord          const          progression);
   //==========|==========================|======================|======|=======|====================
-  void         set_kernels                (bwc_field                    *const  field,
+  void         set_kernels                (bwc_codec                    *const  codec,
                                            bwc_dwt_filter        const          KernelX,
                                            bwc_dwt_filter        const          KernelY,
                                            bwc_dwt_filter        const          KernelZ,
                                            bwc_dwt_filter        const          KernelTS);
   //==========|==========================|======================|======|=======|====================
-  void         bwc_set_decomp             (bwc_field                    *const  field,
+  void         bwc_set_decomp             (bwc_codec                    *const  codec,
                                            uint8                 const          decompX,
                                            uint8                 const          decompY,
                                            uint8                 const          decompZ,
                                            uint8                 const          decompTS);
   //==========|==========================|======================|======|=======|====================
-  void         bwc_set_precincts          (bwc_field                    *const  field,
+  void         bwc_set_precincts          (bwc_codec                    *const  codec,
                                            uint8                 const          pX,
                                            uint8                 const          pY,
                                            uint8                 const          pZ,
                                            uint8                 const          pTS);
   //==========|==========================|======================|======|=======|====================
-  void         bwc_set_codeblocks         (bwc_field                    *const  field,
+  void         bwc_set_codeblocks         (bwc_codec                    *const  codec,
                                            uint8                 const          cbX,
                                            uint8                 const          cbY,
                                            uint8                 const          cbZ,
                                            uint8                 const          cbTS);
   //==========|==========================|======================|======|=======|====================
-  void         bwc_set_qm                 (bwc_field                    *const  field,
+  void         bwc_set_qm                 (bwc_codec                    *const  codec,
                                            uint8                 const          Qm);
   //==========|==========================|======================|======|=======|====================
-  void         bwc_set_tiles              (bwc_field                    *const  field, 
+  void         bwc_set_tiles              (bwc_codec                    *const  codec, 
                                            uint64                const          tilesX,
                                            uint64                const          tilesY,
                                            uint64                const          tilesZ,
                                            uint64                const          tilesTS,
                                            bwc_tile_instr        const          instr);
   //==========|==========================|======================|======|=======|====================
-  uchar        bwc_create_compression     (bwc_field                    *const  field,
+  uchar        bwc_create_compression     (bwc_codec                    *const  codec,
+                                           bwc_stream                   *const  data,
                                            char                         *const  rate_control);
   //==========|==========================|======================|======|=======|====================
-  uchar        bwc_compress               (bwc_field                    *const  field,
+  size_t       bwc_compress               (bwc_codec                    *const  codec,
-                                           bwc_data                     *const  data);
+                                           bwc_stream                   *const  data);
   //==========|==========================|======================|======|=======|====================
-  bwc_field*   bwc_create_decompression   (bwc_data                     *const  data,
+  uchar        bwc_create_decompression   (bwc_codec                    *const  codec,
+                                           bwc_stream                   *const  stream,
                                            uint8                 const          layer);
   //==========|==========================|======================|======|=======|====================
-  uchar        bwc_decompress             (bwc_field                    *const  field,
+  uchar        bwc_decompress             (bwc_codec                    *const  codec,
-                                           bwc_data                     *const  data);
+                                           bwc_stream                   *const  stream);
 #endif

include/library/private/tier1.h

@@ -16,7 +16,7 @@
 ||  ------------                                                                                  ||
 ||                                                                                                ||
 ||        This file describes a set of functions that can be used to de-/encode bwc               ||
-||        codeblocks described by the bwc_field structure according to the embedded block         ||
+||        codeblocks described by the bwc_codec structure according to the embedded block         ||
 ||        coding paradigm described by the JPEG 2000 standard. For more information please        ||
 ||        refere to JPEG2000 by D. S. Taubman and M. W. Marcellin.                                ||
 ||                                                                                                ||
@@ -156,11 +156,11 @@
   ||            |    |__| |__] |___ | |___    |    |__| | \| |___  |  | |__| | \| ___]            ||
   ||                                                                                              ||
   \************************************************************************************************/
-  uchar        t1_encode                  (bwc_field                    *const  field,
+  uchar        t1_encode                  (bwc_codec                    *const  codec,
                                            bwc_tile                     *const  tile,
                                            bwc_parameter                *const  parameter);
   //==========|==========================|======================|======|=======|====================
-  uchar        t1_decode                  (bwc_field                    *const  field,
+  uchar        t1_decode                  (bwc_codec                    *const  codec,
                                            bwc_tile                     *const  tile,
                                            bwc_parameter                *const  parameter);
 

include/library/private/tier2.h

@@ -16,7 +16,7 @@
 ||  ------------                                                                                  ||
 ||                                                                                                ||
 ||        This file describes a set of functions that can be used to de-/encode bwc               ||
-||        codeblocks described by the bwc_field structure according to the embedded block         ||
+||        codeblocks described by the bwc_codec structure according to the embedded block         ||
 ||        coding paradigm described by the JPEG 2000 standard. For more information please        ||
 ||        refere to JPEG2000 by D. S. Taubman and M. W. Marcellin.                                ||
 ||                                                                                                ||
@@ -76,10 +76,10 @@
   ||            |    |__| |__] |___ | |___    |    |__| | \| |___  |  | |__| | \| ___]            ||
   ||                                                                                              ||
   \************************************************************************************************/
-  uchar        t2_encode                  (bwc_field                    *const  field,
+  uchar        t2_encode                  (bwc_codec                    *const  codec,
                                            bwc_tile                     *const  tile);
   //==========|==========================|======================|======|=======|====================
-  uchar        parse_packet               (bwc_field                    *const  field,
+  uchar        parse_packet               (bwc_codec                    *const  codec,
                                            bwc_tile                     *const  tile,
                                            bwc_packet                   *const  packet,
                                            uint64                const          body_size);

include/library/private/types.h

@@ -99,7 +99,7 @@
 
     uchar                      *access;                   // Pointer used to parse packed stream.
     uchar                      *memory;                   // Memory handle for the packed stream.
-  } bwc_stream;
+  } bwc_span;
 
   /*----------------------------------------------------------------------------------------------*\
   !                                                                                                !
@@ -138,29 +138,6 @@
     bwc_tagtree_node           *nodes;                    // Pointer to the tagtree nodes.
   } bwc_tagtree;
 
-
-  /*----------------------------------------------------------------------------------------------*\
-  !                                                                                                !
-  !   DESCRIPTION:                                                                                 !
-  !   ------------                                                                                 !
-  !                                                                                                !
-  !         This structure defines a linked list which stores the size, index, and bit pre-        !
-  !         cision  The string name is used to store the parameter name supplied by the            !
-  !         function caller.                                                                       !
-  !                                                                                                !
-  \*----------------------------------------------------------------------------------------------*/
-  typedef struct opt
-  {
-    char                        name[24];                 // Parameter name.
-    uint8                       id;                       // Parameter index.
-
-    uint64                      size;                     // Parameter size after sub-sampling.
-    uint8                       precision;                // Parameter precision.
-
-    struct opt                 *next;                     // Next element in linked-list.
-    struct opt                 *root;                     // Linked-list root.
-  } bwc_cmd_opts_ll;
-
   /*----------------------------------------------------------------------------------------------*\
   !                                                                                                !
   !   DESCRIPTION:                                                                                 !
@@ -178,12 +155,8 @@
 
     uint8                       nPar;                     // Number of parameters.
 
-    uint8                       precision;                // Flag defining codec precision.
+    bwc_precision               data_prec;                // Data type of uncompressed field data.
-
+    bwc_precision               codec_prec;               // Encoder/decoder bit precision.
-    uint8                       codec_prec;               // Encoder/decoder bit precision.
-    char                        f_ext[20];                // Uncompressed data set file extension.
-
-    bwc_cmd_opts_ll            *parameter;                // Command options linked-list.
   } bwc_gl_inf;
 
   /*----------------------------------------------------------------------------------------------*\
@@ -197,22 +170,17 @@
   \*----------------------------------------------------------------------------------------------*/
   typedef struct
   {
-    bwc_gl_inf                  info;                     // Gloabal info structure.
-    FILE                       *fp;                       // File point to (un)compr. data-set.
-
     struct codestream
     {
-      bwc_stream               *data;                     // Data codestream block.
+      bwc_span               *aux;                      // Auxiliary info. codestream block.
-      bwc_stream               *aux;                      // Auxiliary info. codestream block.
+      bwc_span               *com;                      // Comment codestream block.
-      bwc_stream               *com;                      // Comment codestream block.
     }codestream;
 
-    struct field
+    void                     *inp;                      // User managed buffer for input
-    {
+    void                     *out;                      // User managed buffer for output
-      double                   *d;                        // Double precision numerical data-set.
+
-      float                    *f;                        // Single precision numerical data-set.
+    bwc_mode                  mode;                     // Flag to signal (de-)compression
-    }field;
+  } bwc_stream;
-  } bwc_data;
 
   /*----------------------------------------------------------------------------------------------*\
   !                                                                                                !
@@ -420,8 +388,8 @@
   \*----------------------------------------------------------------------------------------------*/
   typedef struct
   {
-    bwc_stream                  header;                   // Packed stream header.
+    bwc_span                  header;                   // Packed stream header.
-    bwc_stream                  body;                     // Packed stream body.
+    bwc_span                  body;                     // Packed stream body.
     uint8                       e;                        // Indicator for packet cb. contributions.
 
     uint32                      size;                     // Codestream packet size.
@@ -528,14 +496,9 @@
   \*----------------------------------------------------------------------------------------------*/
   typedef struct
   {
-    uint64                      size;                     // Parameter size.
-    char                       *name;                     // Parameter name.
-
     uint64                      X0, Y0, Z0, TS0;          // Tile parameter starting point.
     uint64                      X1, Y1, Z1, TS1;          // Tile parameter end point.
 
-    uint8                       precision;                // Tile parameter precision.
-
     bwc_float                   parameter_min;            // Min. value of tile parameter.
     bwc_float                   parameter_max;            // Max. value of tile parameter.
   } bwc_param_inf;
@@ -710,12 +673,11 @@
   \*----------------------------------------------------------------------------------------------*/
   typedef struct
   {
-    bwc_gl_inf                 *info;                     // Gloabal info structure
+    bwc_gl_inf                  info;                     // Global info structure
     bwc_gl_ctrl                 control;                  // Global control structure
 
     bwc_tile                   *tile;                     // Structure defining bwc tile.
 
-    bwc_stream                  *aux;                      // Auxiliary info. codestream block.
+    bwc_mode                    mode;                     // Flag to signal (de-)compression
-    bwc_stream                  *com;                      // Comment codestream block.
+  } bwc_codec;
-  } bwc_field;
 #endif

src/interfaces/fortran/bwc.F90

@@ -48,10 +48,10 @@ module bwc
   !|                               | | \| |___ |___ |__| |__/ |___                                |!
   !|                                                                                              |!
   !************************************************************************************************!
-  use, intrinsic :: iso_c_binding, only: C_PTR, C_INT64_T, C_INT32_T, C_INT16_T, C_INT8_T, &
+  use, intrinsic :: iso_c_binding, only: c_ptr, c_int64_t, c_int32_t, c_int16_t, c_int8_t, &
-                                         C_INT, C_DOUBLE,  C_CHAR,    C_SIGNED_CHAR
+                                         c_int, c_double,  c_char,    c_signed_char
-  IMPLICIT NONE
+  implicit none
-  PRIVATE
+  private
 
   !************************************************************************************************!
   !|                          ____ ____ _  _ ____ ___ ____ _  _ ___ ____                          |!
@@ -59,25 +59,25 @@ module bwc
   !|                          |___ |__| | \| ___]  |  |  | | \|  |  ___]                          |!
   !|                                                                                              |!
   !************************************************************************************************!
-  ENUM, BIND(C)
+  enum, bind(c)
     enumerator ::   bwc_dwt_9_7     = 0, &
                     bwc_dwt_5_3     = 1, &
                     bwc_dwt_haar    = 2
-  END ENUM
+  end enum
   !*==============================================================================================*!
-  ENUM, BIND(C)
+  enum, bind(c)
-    enumerator ::   bwc_prog_LRCP   = 0
+    enumerator ::   bwc_prog_lrcp   = 0
-  END ENUM
+  end enum
   !*==============================================================================================*!
-  ENUM, BIND(C)
+  enum, bind(c)
     enumerator ::   bwc_qt_none     = 0, &
                     bwc_qt_derived  = 1
-  END ENUM
+  end enum
   !*==============================================================================================*!
-  ENUM, BIND(C)
+  enum, bind(c)
     enumerator ::   bwc_tile_sizeof = 0, &
                     bwc_tile_numbof = 1
-  END ENUM
+  end enum
 
   !************************************************************************************************!
   !|            ___  _  _ ___  _    _ ____    ____ _  _ _  _ ____ ___ _ ____ _  _ ____            |!
@@ -86,294 +86,113 @@ module bwc
   !|                                                                                              |!
   !************************************************************************************************!
   interface
-    function initialize_data_f(field, nX, nY, nZ, nTS, nPar, file_extension) result(data) &
+    function init_stream_f(inpbuf, outbuf, mode) result(stream) &
-             BIND(C, NAME="bwc_initialize_data")
+             bind(c, name="bwc_init_stream")
-      IMPORT
+      import
-      !*-----------------------*!
+      type(c_ptr)                           ::  stream
-      ! DEFINE POINTERS:        !
+      type(c_ptr),                  value   ::  inpbuf
-      !*-----------------------*!
+      type(c_ptr),                  value   ::  outbuf
-      TYPE(C_PTR),                  VALUE   ::  field
+      integer(kind=c_int),          value   ::  mode
-      TYPE(C_PTR)                           ::  data
+    end function init_stream_f
-      
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT16_T),      VALUE   ::  nX, nY, nZ
-      INTEGER(KIND=C_INT8_T),       VALUE   ::  nTS, nPar
-      
-      !*-----------------------*!
-      ! DEFINE CHAR VARIABLES:  !
-      !*-----------------------*!
-      CHARACTER(KIND=C_CHAR)                ::  file_extension(*)
-    end function initialize_data_f
     !*============================================================================================*!
-    subroutine add_param_f(data, name, sample, dim, precision) &
+    function alloc_coder_f(nx, ny, nz, nts, npar, prec) result(codec) &
-               BIND(C, NAME="bwc_add_param")
+             bind(c, name="bwc_alloc_coder")
-      IMPORT
+      import
-      !*-----------------------*!
+      type(c_ptr)                           ::  codec
-      ! DEFINE POINTERS:        !
+      integer(kind=c_int64_t),      value   ::  nx, ny, nz, nts
-      !*-----------------------*!
+      integer(kind=c_int8_t),       value   ::  npar
-      TYPE(C_PTR),                  VALUE   ::  data
+      integer(kind=c_int),          value   ::  prec
-      
+    end function alloc_coder_f
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT16_T),      VALUE   ::  sample
-      INTEGER(KIND=C_INT8_T),       VALUE   ::  precision
-      INTEGER(KIND=C_SIGNED_CHAR),  VALUE   ::  dim
-      
-      !*-----------------------*!
-      ! DEFINE CHAR VARIABLES:  !
-      !*-----------------------*!
-      CHARACTER(KIND=C_CHAR)                ::  name(*)
-    end subroutine add_param_f
     !*============================================================================================*!
-    subroutine get_data_f(data, buffer, size) &
+    function alloc_decoder_f() result(codec) &
-               BIND(C, NAME="bwc_get_data")
+             bind(c, name="bwc_alloc_decoder")
-      IMPORT
+      import
-      !*-----------------------*!
+      type(c_ptr)                           ::  codec
-      ! DEFINE POINTERS:        !
+    end function alloc_decoder_f
-      !*-----------------------*!
-      TYPE(C_PTR),                  VALUE   ::  data
-      TYPE(C_PTR),                  VALUE   ::  buffer
-      
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT64_T),      Value   ::  size
-    end subroutine get_data_f
     !*============================================================================================*!
-    subroutine free_data_f(data) &
+    subroutine free_codec_f(codec) &
-               BIND(C, NAME="bwc_free_data")
+               bind(c, name="bwc_free_codec")
-      IMPORT
+      import
-      !*-----------------------*!
+      type(c_ptr),                  value   ::  codec
-      ! DEFINE POINTERS:        !
+    end subroutine free_codec_f
-      !*-----------------------*!
-      TYPE(C_PTR),                  VALUE   ::  data
-    end subroutine free_data_f
     !*============================================================================================*!
-    subroutine kill_compression_f(field) &
+    subroutine set_error_resilience_f(codec) &
-               BIND(C, NAME="bwc_kill_compression")
+               bind(c, name="bwc_set_error_resilience")
-      IMPORT
+      import
-      !*-----------------------*!
+      type(c_ptr),                  value   ::  codec
-      ! DEFINE POINTERS:        !
-      !*-----------------------*!
-      TYPE(C_PTR),                  VALUE   ::  field
-    end subroutine kill_compression_f
-    !*============================================================================================*!
-    function initialize_field_f(data) result(field) &
-             BIND(C, NAME="bwc_initialize_field")
-      IMPORT
-      !*-----------------------*!
-      ! DEFINE POINTERS:        !
-      !*-----------------------*!
-      TYPE(C_PTR),                  VALUE   ::  data
-      TYPE(C_PTR)                           ::  field
-    end function initialize_field_f
-    !*============================================================================================*!
-    subroutine set_error_resilience_f(field) &
-               BIND(C, NAME="bwc_set_error_resilience")
-      IMPORT
-      !*-----------------------*!
-      ! DEFINE POINTERS:        !
-      !*-----------------------*!
-      TYPE(C_PTR),                  VALUE   ::  field
     end subroutine set_error_resilience_f
     !*============================================================================================*!
-    subroutine set_quantization_style_f(field, quantization_style) &
+    subroutine set_decomp_f(codec, decompx, decompy, decompz, decompts) &
-               BIND(C, NAME="bwc_set_quantization_style")
+               bind(c, name="bwc_set_decomp")
-      IMPORT
+      import
-      !*-----------------------*!
+      type(c_ptr),                  value   ::  codec
-      ! DEFINE POINTERS:        !
+      integer(kind=c_int8_t),       value   ::  decompx, decompy
-      !*-----------------------*!
+      integer(kind=c_int8_t),       value   ::  decompz, decompts
-      TYPE(C_PTR),                  VALUE   ::  field
-
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT),          VALUE   ::  quantization_style
-    end subroutine set_quantization_style_f
-    !*============================================================================================*!
-    subroutine set_quantization_step_size_f(field, delta) &
-               BIND(C, NAME="bwc_set_quantization_step_size")
-      IMPORT
-      !*-----------------------*!
-      ! DEFINE POINTERS:        !
-      !*-----------------------*!
-      TYPE(C_PTR),                  VALUE   ::  field
-
-      !*-----------------------*!
-      ! DEFINE FLOAT VARIABLES: !
-      !*-----------------------*!
-      REAL(KIND=C_DOUBLE),          VALUE   ::  delta
-    end subroutine set_quantization_step_size_f
-    !*============================================================================================*!
-    subroutine set_progression_f(field, progression) &
-               BIND(C, NAME="bwc_set_progression")
-      IMPORT
-      !*-----------------------*!
-      ! DEFINE POINTERS:        !
-      !*-----------------------*!
-      TYPE(C_PTR),                  VALUE   ::  field
-
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT),          VALUE   ::  progression
-    end subroutine set_progression_f
-    !*============================================================================================*!
-    subroutine set_kernels_f(field, KernelX, KernelY, KernelZ, KernelTS) &
-               BIND(C, NAME="bwc_set_kernels")
-      IMPORT
-      !*-----------------------*!
-      ! DEFINE POINTERS:        !
-      !*-----------------------*!
-      TYPE(C_PTR),                  VALUE   ::  field
-
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT),          VALUE   ::  KernelX, KernelY
-      INTEGER(KIND=C_INT),          VALUE   ::  KernelZ, KernelTS
-    end subroutine set_kernels_f
-    !*============================================================================================*!
-    subroutine set_decomp_f(field, decompX, decompY, decompZ, decompTS) &
-               BIND(C, NAME="bwc_set_decomp")
-      IMPORT
-      !*-----------------------*!
-      ! DEFINE POINTERS:        !
-      !*-----------------------*!
-      TYPE(C_PTR),                  VALUE   ::  field
-
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT8_T),       VALUE   ::  decompX, decompY
-      INTEGER(KIND=C_INT8_T),       VALUE   ::  decompZ, decompTS
     end subroutine set_decomp_f
     !*============================================================================================*!
-    subroutine set_precincts_f(field, pX, pY, pZ, pTS) &
+    subroutine set_precincts_f(codec, px, py, pz, pts) &
-               BIND(C, NAME="bwc_set_precincts")
+               bind(c, name="bwc_set_precincts")
-      IMPORT
+      import
-      !*-----------------------*!
+      type(c_ptr),                  value   ::  codec
-      ! DEFINE POINTERS:        !
+      integer(kind=c_int8_t),       value   ::  px, py
-      !*-----------------------*!
+      integer(kind=c_int8_t),       value   ::  pz, pts
-      TYPE(C_PTR),                  VALUE   ::  field
-
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT8_T),       VALUE   ::  pX, pY
-      INTEGER(KIND=C_INT8_T),       VALUE   ::  pZ, pTS
     end subroutine set_precincts_f
     !*============================================================================================*!
-    subroutine set_codeblocks_f(field, cbX, cbY, cbZ, cbTS) &
+    subroutine set_codeblocks_f(codec, cbx, cby, cbz, cbts) &
-               BIND(C, NAME="bwc_set_codeblocks")
+               bind(c, name="bwc_set_codeblocks")
-      IMPORT
+      import
-      !*-----------------------*!
+      type(c_ptr),                  value   ::  codec
-      ! DEFINE POINTERS:        !
+      integer(kind=c_int8_t),       value   ::  cbx, cby
-      !*-----------------------*!
+      integer(kind=c_int8_t),       value   ::  cbz, cbts
-      TYPE(C_PTR),                  VALUE   ::  field
-
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT8_T),       VALUE   ::  cbX, cbY
-      INTEGER(KIND=C_INT8_T),       VALUE   ::  cbZ, cbTS
     end subroutine set_codeblocks_f
     !*============================================================================================*!
-    subroutine set_qm_f(field, Qm) &
+    subroutine set_qm_f(codec, qm) &
-               BIND(C, NAME="bwc_set_qm")
+               bind(c, name="bwc_set_qm")
-      IMPORT
+      import
-      !*-----------------------*!
+      type(c_ptr),                  value   ::  codec
-      ! DEFINE POINTERS:        !
+      integer(kind=c_int8_t),       value   ::  qm
-      !*-----------------------*!
-      TYPE(C_PTR),                  VALUE   ::  field
-
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT8_T),       VALUE   ::  Qm
     end subroutine set_qm_f
     !*============================================================================================*!
-    subroutine set_tiles_f(field, tilesX, tilesY, tilesZ, tilesTS, instr) &
+    subroutine set_tiles_f(codec, tilesx, tilesy, tilesz, tilests, instr) &
-               BIND(C, NAME="bwc_set_tiles")
+               bind(c, name="bwc_set_tiles")
-      IMPORT
+      import
-      !*-----------------------*!
+      type(c_ptr),                  value   ::  codec
-      ! DEFINE POINTERS:        !
+      integer(kind=c_int64_t),      value   ::  tilesx, tilesy, tilesz, tilests
-      !*-----------------------*!
+      integer(kind=c_int),          value   ::  instr
-      TYPE(C_PTR),                  VALUE   ::  field
-
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT64_T),      VALUE   ::  tilesX, tilesY, tilesZ
-      INTEGER(KIND=C_INT16_T),      VALUE   ::  tilesTS
-      INTEGER(KIND=C_INT),          VALUE   ::  instr
     end subroutine set_tiles_f
     !*============================================================================================*!
-    function create_compression_f(field, rate_control) result(error_flag) &
+    function create_compression_f(codec, stream, rate_control) result(error_flag) &
-             BIND(C, NAME="bwc_create_compression")
+             bind(c, name="bwc_create_compression")
-      IMPORT
+      import
-      !*-----------------------*!
+      integer(kind=c_int8_t)                ::  error_flag
-      ! DEFINE POINTERS:        !
+      type(c_ptr),                  value   ::  codec
-      !*-----------------------*!
+      type(c_ptr),                  value   ::  stream
-      TYPE(C_PTR),                  VALUE   ::  field
+      character(kind=c_char)                ::  rate_control(*)
-      
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT8_T)                ::  error_flag
-      
-      !*-----------------------*!
-      ! DEFINE CHAR VARIABLES:  !
-      !*-----------------------*!
-      CHARACTER(KIND=C_CHAR)                ::  rate_control(*)
     end function create_compression_f
     !*============================================================================================*!
-    function compress_f(field, data) result(error_flag) &
+    function compress_f(codec, stream) result(error_flag) &
-             BIND(C, NAME="bwc_compress")
+             bind(c, name="bwc_compress")
-      IMPORT
+      import
-      !*-----------------------*!
+      integer(kind=c_int8_t)                ::  error_flag
-      ! DEFINE POINTERS:        !
+      type(c_ptr),                  value   ::  codec
-      !*-----------------------*!
+      type(c_ptr),                  value   ::  stream
-      TYPE(C_PTR),                  VALUE   ::  field
-      TYPE(C_PTR),                  VALUE   ::  data
-
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT8_T)                ::  error_flag
     end function compress_f
     !*============================================================================================*!
-    function create_decompression_f(data, layer) result(field) &
+    function create_decompression_f(codec, stream, layer) result(error_flag) &
-             BIND(C, NAME="bwc_create_decompression")
+             bind(c, name="bwc_create_decompression")
-      IMPORT
+      import
-      !*-----------------------*!
+      integer(kind=c_int8_t)                ::  error_flag
-      ! DEFINE POINTERS:        !
+      type(c_ptr),                  value   ::  codec
-      !*-----------------------*!
+      type(c_ptr),                  value   ::  stream
-      TYPE(C_PTR)                           ::  field
+      integer(kind=c_int8_t),       value   ::  layer
-      TYPE(C_PTR),                  VALUE   ::  data
-
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT8_T),       VALUE   ::  layer
     end function create_decompression_f
     !*============================================================================================*!
-    function decompress_f(field, data) result(error_flag) &
+    function decompress_f(codec, stream) result(error_flag) &
-             BIND(C, NAME="bwc_decompress")
+             bind(c, name="bwc_decompress")
-      IMPORT
+      import
-      !*-----------------------*!
+      integer(kind=c_int8_t)                ::  error_flag
-      ! DEFINE POINTERS:        !
+      type(c_ptr),                  value   ::  codec
-      !*-----------------------*!
+      type(c_ptr),                  value   ::  stream
-      TYPE(C_PTR),                  VALUE   ::  field
-      TYPE(C_PTR),                  VALUE   ::  data
-
-      !*-----------------------*!
-      ! DEFINE INT VARIABLES:   !
-      !*-----------------------*!
-      INTEGER(KIND=C_INT8_T)                ::  error_flag
     end function decompress_f
   end interface
 
@@ -395,24 +214,17 @@ module bwc
   public ::   bwc_tile_sizeof,                  &
               bwc_tile_numbof 
 
-  public ::   bwc_initialize_data,              &
+  public ::   bwc_init_stream,                  &
-              bwc_get_data,                     &
+              bwc_alloc_coder,                  &
-              bwc_free_data
+              bwc_alloc_decoder,                &
-
+              bwc_free_codec
-  public ::   bwc_initialize_field,             &
-              bwc_add_param,                    &
-              bwc_kill_compression
 
   public ::   bwc_set_error_resilience,         &
-              bwc_set_quantization_style,       &
-              bwc_set_quantization_step_size,   &
-              bwc_set_progression,              &
-              bwc_set_kernels,                  &
               bwc_set_decomp,                   &
               bwc_set_precincts,                &
               bwc_set_codeblocks,               &
               bwc_set_qm,                       &
-              bwc_set_tiles,                    
+              bwc_set_tiles
 
   public ::   bwc_create_compression,           &
               bwc_compress,                     &

src/interfaces/python/bwc.py

@@ -84,55 +84,37 @@ const = _const()
 #|             |    |__| |__] |___ | |___    |    |__| | \| |___  |  | |__| | \| ___]             |#
 #|                                                                                                |#
 #**************************************************************************************************#
-def free_data(data):
+def init_stream(inpbuf, outbuf, mode):
-  fun = libbwc.bwc_free_data
+  fun = libbwc.bwc_init_stream
-  fun.restype  = None
-  fun.argtypes = [ctypes.c_void_p]
-  fun(data)
-#==================================================================================================#
-def initialize_data(data, nX, nY, nZ, nTS, nPar, file_extension):
-  fun = libbwc.bwc_initialize_data
   fun.restype  = ctypes.c_void_p
   fun.argtypes = [ndpointer(ctypes.c_double, flags="C_CONTIGUOUS"),
+                  ndpointer(ctypes.c_double, flags="C_CONTIGUOUS"),
+                  ctypes.c_char_p]
+  return ctypes.c_void_p(fun(inpbuf, outbuf, mode.encode('utf-8')))
+#==================================================================================================#
+def alloc_coder(nX, nY, nZ, nTS, nPar, prec):
+  fun = libbwc.bwc_alloc_coder
+  fun.restype  = ctypes.c_void_p
+  fun.argtypes = [ctypes.c_uint64,
                   ctypes.c_uint64,
                   ctypes.c_uint64,
-                  ctypes.c_uint64,
-                  ctypes.c_uint16,
                   ctypes.c_uint8,
                   ctypes.c_char_p]
-  return ctypes.c_void_p(fun(data, nX, nY, nZ, nTS, nPar, file_extension.encode('utf-8')))
+  return ctypes.c_void_p(fun(nX, nY, nZ, nTS, nPar, prec.encode('utf-8')))
 #==================================================================================================#
-def get_data(data, buffer, size):
+def alloc_decoder():
-  fun = libbwc.bwc_get_data
+  fun = libbwc.bwc_alloc_decoder
-  fun.restype  = None
-  fun.argtypes = [ctypes.c_void_p,
-                  ndpointer(ctypes.c_double, flags="C_CONTIGUOUS"),
-                  ctypes.c_uint64]
-  fun(data, buffer, size)
-#==================================================================================================#
-def add_param(data, name, sample, dim, precision):
-  fun = libbwc.bwc_add_param
-  fun.restype  = None
-  fun.argtypes = [ctypes.c_void_p,
-                  ctypes.c_char_p,
-                  ctypes.c_uint16,
-                  ctypes.c_uint8,
-                  ctypes.c_uint8]
-  fun(data, name.encode('utf-8'), sample, dim, precision)
-#==================================================================================================#
-def kill_compression(field):
-  fun = libbwc.bwc_kill_compression
-  fun.restype  = None
-  fun.argtypes = [ctypes.c_void_p]
-  fun(field)
-#==================================================================================================#
-def initialize_field(data):
-  fun = libbwc.bwc_initialize_field
   fun.restype  = ctypes.c_void_p
-  fun.argtypes = [ctypes.c_void_p]
+  fun.argtypes = []
-  return ctypes.c_void_p(fun(data))
+  return ctypes.c_void_p(fun())
 #==================================================================================================#
-def set_codeblocks(field, cbX, cbY, cbZ, cbTS):
+def free_codec(codec):
+  fun = libbwc.bwc_free_codec
+  fun.restype  = None
+  fun.argtypes = [ctypes.c_void_p]
+  fun(codec)
+#==================================================================================================#
+def set_codeblocks(codec, cbX, cbY, cbZ, cbTS):
   fun = libbwc.bwc_set_codeblocks
   fun.restype  = None
   fun.argtypes = [ctypes.c_void_p,
@@ -140,9 +122,9 @@ def set_codeblocks(field, cbX, cbY, cbZ, cbTS):
                   ctypes.c_uint8,
                   ctypes.c_uint8,
                   ctypes.c_uint8]
-  fun(field, cbX, cbY, cbZ, cbTS)
+  fun(codec, cbX, cbY, cbZ, cbTS)
 #==================================================================================================#
-def set_decomp(field, decompX, decompY, decompZ, decompTS):
+def set_decomp(codec, decompX, decompY, decompZ, decompTS):
   fun = libbwc.bwc_set_decomp
   fun.restype  = None
   fun.argtypes = [ctypes.c_void_p,
@@ -150,16 +132,16 @@ def set_decomp(field, decompX, decompY, decompZ, decompTS):
                   ctypes.c_uint8,
                   ctypes.c_uint8,
                   ctypes.c_uint8]
-  fun(field, decompX, decompY, decompZ, decompTS)
+  fun(codec, decompX, decompY, decompZ, decompTS)
 #==================================================================================================#
-def set_qm(field, Qm):
+def set_qm(codec, Qm):
   fun = libbwc.bwc_set_qm
   fun.restype  = None
   fun.argtypes = [ctypes.c_void_p,
-                  ctypes.c_int8]
+                  ctypes.c_uint8]
-  fun(field, Qm)
+  fun(codec, Qm)
 #==================================================================================================#
-def set_tiles(field, tilesX, tilesY, tilesZ, tilesTS, instr):
+def set_tiles(codec, tilesX, tilesY, tilesZ, tilesTS, instr):
   fun = libbwc.bwc_set_tiles
   fun.restype  = None
   fun.argtypes = [ctypes.c_void_p,
@@ -168,9 +150,9 @@ def set_tiles(field, tilesX, tilesY, tilesZ, tilesTS, instr):
                   ctypes.c_uint64,
                   ctypes.c_uint64,
                   ctypes.c_char_p]
-  fun(field, tilesX, tilesY, tilesZ, tilesTS, instr.encode('utf-8'))
+  fun(codec, tilesX, tilesY, tilesZ, tilesTS, instr.encode('utf-8'))
 #==================================================================================================#
-def set_precincts(field, pX, pY, pZ, pTS):
+def set_precincts(codec, pX, pY, pZ, pTS):
   fun = libbwc.bwc_set_precincts
   fun.restype  = None
   fun.argtypes = [ctypes.c_void_p,
@@ -178,32 +160,34 @@ def set_precincts(field, pX, pY, pZ, pTS):
                   ctypes.c_uint8,
                   ctypes.c_uint8,
                   ctypes.c_uint8]
-  fun(field, pX, pY, pZ, pTS)
+  fun(codec, pX, pY, pZ, pTS)
 #==================================================================================================#
-def create_compression(field, rate_control):
+def create_compression(codec, stream, rate_control):
   fun = libbwc.bwc_create_compression
-  fun.restype  = None
+  fun.restype  = ctypes.c_uchar
   fun.argtypes = [ctypes.c_void_p,
+                  ctypes.c_void_p,
                   ctypes.c_char_p]
-  fun(field, rate_control.encode('utf-8'))
+  return ctypes.c_uchar(fun(codec, stream, rate_control.encode('utf-8')))
 #==================================================================================================#
-def compress(field, data):
+def compress(codec, stream):
   fun = libbwc.bwc_compress
-  fun.restype  = None
+  fun.restype  = ctypes.c_size_t
   fun.argtypes = [ctypes.c_void_p,
                   ctypes.c_void_p]
-  fun(field, data)
+  return ctypes.c_size_t(fun(codec, stream))
 #==================================================================================================#
-def create_decompression(field, data):
+def create_decompression(codec, stream, layer):
   fun = libbwc.bwc_create_decompression
-  fun.restype  = ctypes.c_void_p
+  fun.restype  = ctypes.c_uchar
   fun.argtypes = [ctypes.c_void_p,
+                  ctypes.c_void_p,
                   ctypes.c_uint8]
-  return ctypes.c_void_p(fun(field, data))
+  return ctypes.c_uchar(fun(codec, stream, layer))
 #==================================================================================================#
-def decompress(field, data):
+def decompress(codec, stream):
   fun = libbwc.bwc_decompress
-  fun.restype  = None
+  fun.restype  = ctypes.c_uchar
   fun.argtypes = [ctypes.c_void_p,
                   ctypes.c_void_p]
-  fun(field, data)
+  return ctypes.c_uchar(fun(codec, stream))

src/library/bitstream.c

@@ -107,8 +107,6 @@ bytes_used(bitstream const *const stream)
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: bitstream* bwc_init_stream(uchar* memory, uint32 size, char instr)                        !
-!   --------------                                                                                           !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
 !   ------------                                                                                             !
@@ -145,7 +143,7 @@ bytes_used(bitstream const *const stream)
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 bitstream* 
-init_stream(uchar* memory, uint32 size, char instr)
+init_bitstream(uchar* memory, uint32 size, char instr)
 {
   /*-----------------------*\
   ! DEFINE STRUCTS:         !
@@ -155,6 +153,7 @@ init_stream(uchar* memory, uint32 size, char instr)
   /*-----------------------*\
   ! DEFINE ASSERTIONS:      !
   \*-----------------------*/
+  assert(memory);
   assert(instr == 'c' || instr == 'd');
 
   /*--------------------------------------------------------*\
@@ -168,37 +167,11 @@ init_stream(uchar* memory, uint32 size, char instr)
     return NULL;
   }
 
-  /*--------------------------------------------------------*\
-  ! Evaluate if a valid memory handle has been passed by the !
-  ! function caller.                                         !
-  \*--------------------------------------------------------*/
-  if(!memory)
-  {
-    /*--------------------------------------------------------*\
-    ! If no valid memory handle has been passed, allocate a    !
-    ! memory block with the specifiec stream size.             !
-    \*--------------------------------------------------------*/
-    stream->memory = calloc(size, sizeof(uchar));
-    if(!stream->memory)
-    {
-      // memory allocation error
-      fprintf(stderr, MEMERROR);
-      return NULL;
-    }
-  }
-  else
-  {
-    /*--------------------------------------------------------*\
-    ! If a valid memory handle has been passed for decoding,   !
-    ! save the memory handle in the bwc stream structure.      !
-    \*--------------------------------------------------------*/
-    stream->memory = memory;
-  }
-  
   /*--------------------------------------------------------*\
   ! Initialize the byte buffer counter, stream size and size !
   ! increment for the current stream.                        !
   \*--------------------------------------------------------*/
+  stream->memory    = memory;
   stream->t         = (instr == 'c') ? 8 : 0;
   stream->Lmax      = size;
   stream->size_incr = (uint64)(size / 2);
@@ -247,11 +220,6 @@ init_stream(uchar* memory, uint32 size, char instr)
 void
 emit_chunck(bitstream *const stream, const uchar* chunck, const uint64 size)
 {
-  /*-----------------------*\
-  ! DEFINE INT VARIABLES:   !
-  \*-----------------------*/
-  uint64             Lreq; 
-
   /*-----------------------*\
   ! DEFINE ASSERTIONS:      !
   \*-----------------------*/
@@ -259,39 +227,16 @@ emit_chunck(bitstream *const stream, const uchar* chunck, const uint64 size)
   assert(chunck);
 
   /*--------------------------------------------------------*\
-  ! Evaluate the memory block size if the current chunck of  !
+  ! Check if an error was encountered in a previous writing  !
-  ! data is written to the stream.                           !
+  ! operation                                                !
-  \*--------------------------------------------------------*/
-  Lreq = (bytes_used(stream) + size);
-
-  /*--------------------------------------------------------*\
-  ! Check if the enough memory has been allocated for the    !
-  ! stream to store the additional data chunck.              !
-  \*--------------------------------------------------------*/
-  if(Lreq > stream->Lmax)
-  {
-    /*--------------------------------------------------------*\
-    ! If the stream is not large enough, check if this is due  !
-    ! to an error encountered in a previous writing operation  !
   \*--------------------------------------------------------*/
   if(!stream->error)
   {
     /*--------------------------------------------------------*\
-      ! If the error flag is not set, increase the stream size   !
+    ! Check if the enough memory has been allocated for the    !
-      ! until it is large enough to store the additional data    !
+    ! stream to store the additional symbol.                   !
-      ! chunck.                                                  !
     \*--------------------------------------------------------*/
-      while(Lreq > stream->Lmax)
+    if((bytes_used(stream) + size) > stream->Lmax)
-      {
-        stream->Lmax      += stream->size_incr + size;
-        stream->size_incr  = (uint64)(stream->Lmax / 2);
-      }
-
-      /*--------------------------------------------------------*\
-      ! Reallocate the stream data block.                        !
-      \*--------------------------------------------------------*/
-      stream->memory     = realloc(stream->memory, stream->Lmax);
-      if(!stream->memory)
     {
       // memory allocation error
       stream->error |= 1;
@@ -306,7 +251,6 @@ emit_chunck(bitstream *const stream, const uchar* chunck, const uint64 size)
     \*--------------------------------------------------------*/
     return;
   }
-  }
 
   /*--------------------------------------------------------*\
   ! Copy the additional data to the stream memory block.     !
@@ -370,29 +314,16 @@ emit_symbol(bitstream *const stream, const uint64 symbol, const uint8 size)
   assert(stream);
   
   /*--------------------------------------------------------*\
-  ! Check if the enough memory has been allocated for the    !
+  ! Check if an error was encountered in a previous writing  !
-  ! stream to store the additional symbol.                   !
+  ! operation                                                !
-  \*--------------------------------------------------------*/
-  if((bytes_used(stream) + size) > stream->Lmax)
-  {
-    /*--------------------------------------------------------*\
-    ! If the stream is not large enough, check if this is due  !
-    ! to an error encountered in a previous writing operation  !
   \*--------------------------------------------------------*/
   if(!stream->error)
   {
     /*--------------------------------------------------------*\
-      ! If the error flag is not set, increment the stream size  !
+    ! Check if the enough memory has been allocated for the    !
-      ! to store the additional symbol.                          !
+    ! stream to store the additional symbol.                   !
     \*--------------------------------------------------------*/
-      stream->Lmax      += stream->size_incr;
+    if((bytes_used(stream) + size) > stream->Lmax)
-      stream->size_incr  = (uint64)(stream->Lmax / 2);
-
-      /*--------------------------------------------------------*\
-      ! Reallocate the stream data block.                        !
-      \*--------------------------------------------------------*/
-      stream->memory     = realloc(stream->memory, stream->Lmax);
-      if(!stream->memory)
     {
       // memory allocation error
       stream->error |= 1;
@@ -407,7 +338,6 @@ emit_symbol(bitstream *const stream, const uint64 symbol, const uint8 size)
     \*--------------------------------------------------------*/
     return;
   }
-  }
 
   /*--------------------------------------------------------*\
   ! Copy the additional symbol to the stream memory block    !
@@ -868,48 +798,28 @@ flush_stream(bitstream *const stream)
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: void *test(void)                                                                          !
-!   --------------                                                                                           !
-!                                                                                                            !
 !   DESCRIPTION:                                                                                             !
 !   ------------                                                                                             !
-!                DESCRIPTION NEEDED                                                                          !
+!                Shrinks the bitstream memory to the actually filled range.                                  !
-!                                                                                                            !
-!   PARAMETERS:                                                                                              !
-!   -----------                                                                                              !
-!                Variable                    Type                    Description                             !
-!                --------                    ----                    -----------                             !
-!                -                           -                       -                                       !
 !                                                                                                            !
 !   RETURN VALUE:                                                                                            !
 !   -------------                                                                                            !
-!                Type                        Description                                                     !
+!                Returns 0 if successfull and 1 if memory could not be resized.                              !
-!                ----                        -----------                                                     !
-!                -                           -                                                               !
-!                                                                                                            !
-!   DEVELOPMENT HISTORY:                                                                                     !
-!   --------------------                                                                                     !
-!                                                                                                            !
-!                Date        Author             Change Id   Release     Description Of Change                !
-!                ----        ------             ---------   -------     ---------------------                !
-!                -           Patrick Vogler     B87D120     V 0.1.0     function created                     !
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 uchar
-terminate_stream(bitstream *stream, bwc_stream *const packed_stream)
+shrink_to_fit(bitstream *const stream)
 {
   /*-----------------------*\
   ! DEFINE ASSERTIONS:      !
   \*-----------------------*/
   assert(stream);
 
-  if(packed_stream)
-  {
   if(stream->error)
   {
     return 1;
   }
-    else if(stream->L != stream->Lmax)
+  else if(stream->L > stream->Lmax)
   {
     stream->Lmax   = stream->L;
     stream->memory = realloc(stream->memory, stream->Lmax);
@@ -921,23 +831,46 @@ terminate_stream(bitstream *stream, bwc_stream *const packed_stream)
       return 1;
     }
   }
-
-    packed_stream->memory   = stream->memory;
-    packed_stream->access   = stream->memory;
-    packed_stream->size     = stream->L;
-    packed_stream->position = 0;
-  }
-  else
-  {
-    free(stream->memory);
-  }
-  
-  free(stream);
   return 0;
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: void release_packed_stream(bwc_stream *stream)                                            !
+!   DESCRIPTION:                                                                                             !
+!   ------------                                                                                             !
+!                Swap memory pointer and size to span. Invalidates stream pointers.                          !
+!                                                                                                            !
+!   RETURN VALUE:                                                                                            !
+!   -------------                                                                                            !
+!                Returns 0 if successfull and 1 if stream had previous memory error.                         !
+!                                                                                                            !
+\*----------------------------------------------------------------------------------------------------------*/
+uchar
+transfer_to_span(bitstream *const stream, bwc_span *const span)
+{
+  /*-----------------------*\
+  ! DEFINE ASSERTIONS:      !
+  \*-----------------------*/
+  assert(stream);
+  assert(span);
+
+  if(stream->error)
+  {
+    return 1;
+  }
+
+  span->memory   = stream->memory;
+  span->access   = stream->memory;
+  span->size     = stream->L;
+  span->position = 0;
+
+  stream->memory = NULL;
+  stream->L = 0;
+
+  return 0;
+}
+
+/*----------------------------------------------------------------------------------------------------------*\
+!   FUNCTION NAME: void release_packed_stream(bwc_span *stream)                                            !
 !   --------------                                                                                           !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -949,7 +882,7 @@ terminate_stream(bitstream *stream, bwc_stream *const packed_stream)
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                stream                      bwc_stream            - Packed bitstream used to store parts of !
+!                stream                      bwc_span            - Packed bitstream used to store parts of !
 !                                                                    the bwc codestream.                     !
 !                                                                                                            !
 !   RETURN VALUE:                                                                                            !
@@ -967,7 +900,7 @@ terminate_stream(bitstream *stream, bwc_stream *const packed_stream)
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 void
-release_packed_stream(bwc_stream *stream)
+release_packed_stream(bwc_span *stream)
 {
   /*-----------------------*\
   ! DEFINE ASSERTIONS:      !

src/library/codestream.c

@@ -104,7 +104,7 @@ can_read(bitstream *const stream, const uint64 length)
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: void codestream_write_header(bitstream *const stream, bwc_field *const field)             !
+!   FUNCTION NAME: void codestream_write_header(bitstream *const stream, bwc_codec *const codec)             !
 !   --------------                                                                                           !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -116,7 +116,7 @@ can_read(bitstream *const stream, const uint64 length)
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
+!                codec                       bwc_codec*            - Structure defining the compression/     !
 !                                                                    decompression stage.                    !
 !                                                                                                            !
 !                stream                      bitstream*           - Structure used to assemble a bwc bit-    !
@@ -138,7 +138,8 @@ can_read(bitstream *const stream, const uint64 length)
 \*----------------------------------------------------------------------------------------------------------*/
 static void
 codestream_write_header(bitstream   *const stream,
-                        bwc_field   *const field)
+                        bwc_codec   *const codec,
+                        bwc_stream  *const data)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
@@ -155,33 +156,27 @@ codestream_write_header(bitstream   *const stream,
    \*-----------------------*/
    bwc_gl_ctrl      *control;
    bwc_gl_inf       *info;
-   bwc_tile         *tile;
+   bwc_span       *aux;
-   bwc_parameter    *parameter;
+   bwc_span       *com;
-   bwc_stream       *aux;
-   bwc_stream       *com;
    
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
    assert(stream);
-   assert(field);
+   assert(codec);
 
    /*--------------------------------------------------------*\
    ! Save the global as well as the subband control and info  !
    ! structure to temporary variables to make the code more   !
    ! readable.                                                !
    \*--------------------------------------------------------*/
-   info          =  field->info;
+   info          = &codec->info;
-   control       = &field->control;
+   control       = &codec->control;
 
-   tile          = &field->tile[0];
+   aux           = data->codestream.aux;
+   com           = data->codestream.com;
    
-   parameter     = &tile->parameter[0];
+   Linf = 31;
-
-   aux           = field->aux;
-   com           = field->com;
-   
-   Linf = 40 + info->nPar * 25;
    Lctr = 50 + control->nLayers * 4;
    Leoh = info->nPar * control->nTiles * 2 * PREC_BYTE;
    Lcss = control->codestreamSize;
@@ -193,16 +188,10 @@ codestream_write_header(bitstream   *const stream,
    emit_symbol(stream, info->nX,                                       8);
    emit_symbol(stream, info->nY,                                       8);
    emit_symbol(stream, info->nZ,                                       8);
-   emit_symbol(stream, info->nTS,                                      2);
+   emit_symbol(stream, info->nTS,                                      8);
    emit_symbol(stream, info->nPar,                                     1);
-   emit_symbol(stream, info->precision,                                1);
+   emit_symbol(stream, (uint8)info->data_prec,                         1);
-   emit_chunck(stream, (uchar*)info->f_ext,                            10);
+   emit_symbol(stream, (uint8)info->codec_prec,                        1);
-
-   for(p = 0; p < info->nPar; ++p)
-   {
-      emit_chunck(stream, (uchar*)parameter[p].info.name,             24);
-      emit_symbol(stream, parameter[p].info.precision,                 1);
-   }
 
    emit_symbol(stream, SGC,                                            2);
    emit_symbol(stream, Lctr,                                           2);
@@ -239,7 +228,7 @@ codestream_write_header(bitstream   *const stream,
    emit_symbol(stream, control->tileSizeX,                             8);
    emit_symbol(stream, control->tileSizeY,                             8);
    emit_symbol(stream, control->tileSizeZ,                             8);
-   emit_symbol(stream, control->tileSizeTS,                            2);
+   emit_symbol(stream, control->tileSizeTS,                            8);
 
    emit_symbol(stream, control->nLayers,                               1);
 
@@ -274,21 +263,21 @@ codestream_write_header(bitstream   *const stream,
       for(p = 0; p < info->nPar; ++p)
       {
 
-         emit_symbol(stream, *(uint64 *)&field->tile[t].
+         emit_symbol(stream, *(uint64 *)&codec->tile[t].
                                                 parameter[p].info.
                                                 parameter_min, PREC_BYTE);
-         emit_symbol(stream, *(uint64 *)&field->tile[t].
+         emit_symbol(stream, *(uint64 *)&codec->tile[t].
                                                 parameter[p].info.
                                                 parameter_max, PREC_BYTE);
 
-         field->tile[t].parameter[p].info.parameter_max  = -FLT_MAX;
+         codec->tile[t].parameter[p].info.parameter_max  = -FLT_MAX;
-         field->tile[t].parameter[p].info.parameter_min  =  FLT_MAX;
+         codec->tile[t].parameter[p].info.parameter_min  =  FLT_MAX;
       }
    }
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: uchar sequence_packets(bwc_field *const field, bwc_field *const field)                    !
+!   FUNCTION NAME: uchar sequence_packets(bwc_codec *const codec, bwc_tile *const tile)                      !
 !   --------------                                                                                           !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -299,7 +288,7 @@ codestream_write_header(bitstream   *const stream,
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
+!                codec                       bwc_codec*            - Structure defining the compression/     !
 !                                                                    decompression stage.                    !
 !                                                                                                            !
 !                tile                        bwc_tile*             - Structure defining a bwc tile.          !
@@ -319,7 +308,7 @@ codestream_write_header(bitstream   *const stream,
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 static uchar
-sequence_packets(bwc_field *const field, bwc_tile *const tile)
+sequence_packets(bwc_codec *const codec, bwc_tile *const tile)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
@@ -347,8 +336,8 @@ sequence_packets(bwc_field *const field, bwc_tile *const tile)
    ! sequence structure to temporary variables to make the    !
    ! code more readable.                                      !
    \*--------------------------------------------------------*/
-   control = &field->control;
+   control = &codec->control;
-   info    =  field->info;
+   info    = &codec->info;
 
    packet_sequence = tile->packet_sequence;
 
@@ -490,7 +479,7 @@ sequence_packets(bwc_field *const field, bwc_tile *const tile)
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: uchar sequence_packets(bwc_field *const field, bwc_field *const field)                    !
+!   FUNCTION NAME:                                                                                           !
 !   --------------                                                                                           !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -501,16 +490,11 @@ sequence_packets(bwc_field *const field, bwc_tile *const tile)
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
-!                                                                    decompression stage.                    !
-!                                                                                                            !
-!                tile                        bwc_tile*             - Structure defining a bwc tile.          !
 !                                                                                                            !
 !   RETURN VALUE:                                                                                            !
 !   -------------                                                                                            !
 !                Type                        Description                                                     !
 !                ----                        -----------                                                     !
-!                uchar                     - Returns an unsigned char for error handling.                    !
 !                                                                                                            !
 !   DEVELOPMENT HISTORY:                                                                                     !
 !   --------------------                                                                                     !
@@ -521,7 +505,7 @@ sequence_packets(bwc_field *const field, bwc_tile *const tile)
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 static void
-assemble_tile(bwc_field *const field, bwc_tile *const tile, bitstream *const stream)
+assemble_tile(bwc_codec *const codec, bwc_tile *const tile, bitstream *const stream)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
@@ -537,7 +521,7 @@ assemble_tile(bwc_field *const field, bwc_tile *const tile, bitstream *const str
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(tile);
    assert(stream);
 
@@ -546,7 +530,7 @@ assemble_tile(bwc_field *const field, bwc_tile *const tile, bitstream *const str
    ! sequence structure to temporary variables to make the    !
    ! code more readable.                                      !
    \*--------------------------------------------------------*/
-   control = &field->control;
+   control = &codec->control;
 
    emit_symbol(stream, SOT,                        2);
    emit_symbol(stream, 14,                         2);
@@ -613,14 +597,14 @@ assemble_tile(bwc_field *const field, bwc_tile *const tile, bitstream *const str
 !                -           Patrick Vogler     B87D120     V 0.1.0     function created                     !
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
-bwc_field*
+bwc_codec*
-parse_main_header(bwc_data *const data,bitstream *const stream)
+parse_main_header(bwc_codec *const codec, bwc_stream *const data, bitstream *const stream)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
    \*-----------------------*/
    uint64      buff_long, buffX, buffY, buffZ, buffTS;
-   uint64      nX, nY, nZ;
+   uint64      nX, nY, nZ, nTS;
    uint32      buff;
    uint32      bitrate;
    uint32      Lsax;
@@ -629,35 +613,34 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
    uint16      CSsgc;
    uint16      Linf, Lctr, Lcom, Leoh, Lunk;
    uint16      marker;
-   uint16      nTS;
    uint8       index, l;
    uint8       nPar, p;
-   uint8       codec_prec, precision;
+   bwc_precision data_prec, codec_prec;
 
    /*-----------------------*\
    ! DEFINE CHAR VARIABLES:  !
    \*-----------------------*/
-   char*       buffer_char;
    char        status;
 
    /*-----------------------*\
    ! DEFINE STRUCTS:         !
    \*-----------------------*/
-   bwc_field         *field;
    bwc_gl_ctrl       *control;
    bwc_gl_inf        *info;
    
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
+   assert(codec);
    assert(data);
    assert(stream);
    
    /*--------------------------------------------------------*\
-   ! Save the data info structure to a temporary variable to  !
+   ! Save the global control and info structure to temporary  !
-   ! make the code more readable.                             !
+   ! variables to make the code more readable.                !
    \*--------------------------------------------------------*/
-   info = &data->info;
+   info    = &codec->info;
+   control = &codec->control;
 
    status = CODESTREAM_OK;
    index  = 0;
@@ -708,41 +691,23 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
                break;
             }
 
-            info->nX        = nX         =         get_symbol(stream,  8);
+            nX         =                get_symbol(stream,  8);
-            info->nY        = nY         =         get_symbol(stream,  8);
+            nY         =                get_symbol(stream,  8);
-            info->nZ        = nZ         =         get_symbol(stream,  8);
+            nZ         =                get_symbol(stream,  8);
-            info->nTS       = nTS        = (uint16)get_symbol(stream,  2);
+            nTS        =                get_symbol(stream,  8);
-            info->nPar      = nPar       =  (uint8)get_symbol(stream,  1);
+            nPar       =         (uint8)get_symbol(stream,  1);
-            info->precision = codec_prec =  (uint8)get_symbol(stream,  1);
+            data_prec  = (bwc_precision)get_symbol(stream,  1);
+            codec_prec = (bwc_precision)get_symbol(stream,  1);
 
-            buffer_char       =  (char*)get_chunck(stream, 10);
+            info->codec_prec = codec_prec;
-            strncpy(info->f_ext, buffer_char, sizeof(buffer_char)/sizeof(*buffer_char));
-            free(buffer_char);
 
-            for(p = 0; p < nPar; ++p)
+            configure_codec(codec, nX, nY, nZ, nTS, nPar, data_prec);
-            {
+            if(!codec)
-               buffer_char = (char*)get_chunck(stream, 24);
-               precision   = (uint8)get_symbol(stream, 1);
-
-               bwc_add_param(data, buffer_char, precision);
-
-               free(buffer_char);
-            }
-
-            field = bwc_initialize_field(data);
-            if(!field)
             {
                status |= CODESTREAM_ERROR;
                break;
             }
 
-            /*--------------------------------------------------------*\
-            ! Save the global control and info structure to temporary  !
-            ! variables to make the code more readable.                !
-            \*--------------------------------------------------------*/
-            info    =  field->info = &data->info;
-            control = &field->control;
-
             control->codestreamSize = stream->Lmax;
 
             status |= CODESTREAM_SGI_READ;
@@ -755,7 +720,7 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
             {
                // Invalid Codestream
                fprintf(stderr, CSERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
@@ -766,7 +731,7 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
             {
                // Invalid Codestream
                fprintf(stderr, CSERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
@@ -777,14 +742,14 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
             buff_long  = get_symbol(stream, 1);
             if(CSsgc & (0x01 << 0))
             {
-               bwc_set_error_resilience(field);
+               bwc_set_error_resilience(codec);
             }
 
             buff_long = get_symbol(stream, 1);
 
             if(CSsgc & (0x01 << 1))
             {
-               set_quant_style(field, (bwc_quant_st)buff_long);
+               set_quant_style(codec, (bwc_quant_st)buff_long);
             }
 
             buff_long = get_symbol(stream, 1);
@@ -800,50 +765,50 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
             buff_long  = get_symbol(stream, 1);
             if(CSsgc & (0x01 << 3))
             {
-               set_progression(field, (uint8)buff_long);
+               set_progression(codec, (uint8)buff_long);
             }
 
             buff_long  = get_symbol(stream, 1);
             if(CSsgc & (0x01 << 4))
             {
-               set_kernels(field, (uint8)(0x03 & (buff_long >> 6)), (uint8)(0x03 & (buff_long >> 4)),
+               set_kernels(codec, (uint8)(0x03 & (buff_long >> 6)), (uint8)(0x03 & (buff_long >> 4)),
                                   (uint8)(0x03 & (buff_long >> 2)), (uint8)(0x03 &  buff_long));
             }
 
             buff_long  = get_symbol(stream, 4);
             if(CSsgc & (0x01 << 5))
             {
-               bwc_set_decomp(field, (uint8)(0xFF & (buff_long >> 24)), (uint8)(0xFF & (buff_long >>  16)),
+               bwc_set_decomp(codec, (uint8)(0xFF & (buff_long >> 24)), (uint8)(0xFF & (buff_long >>  16)),
                                      (uint8)(0xFF & (buff_long >>  8)), (uint8)(0xFF &  buff_long));
             }
             
             buff_long  = get_symbol(stream, 2);
             if(CSsgc & (0x01 << 6))
             {
-               bwc_set_precincts(field, (uint8)(0x0F & (buff_long >> 8)), (uint8)(0x0F & (buff_long >> 12)),
+               bwc_set_precincts(codec, (uint8)(0x0F & (buff_long >> 8)), (uint8)(0x0F & (buff_long >> 12)),
                                         (uint8)(0x0F &  buff_long),       (uint8)(0x0F & (buff_long >>  4)));
             }
 
             buff_long  = get_symbol(stream, 4);
             if(CSsgc & (0x01 << 7))
             {
-               bwc_set_codeblocks(field, (uint8)(0xFF & (buff_long >> 24)), (uint8)(0xFF & (buff_long >> 16)),
+               bwc_set_codeblocks(codec, (uint8)(0xFF & (buff_long >> 24)), (uint8)(0xFF & (buff_long >> 16)),
                                          (uint8)(0xFF & (buff_long >>  8)), (uint8)(0xFF &  buff_long));
             }
 
             buff_long  = get_symbol(stream, 1);
             if(CSsgc & (0x01 << 8))
             {
-               bwc_set_qm(field, (uint8)buff_long);
+               bwc_set_qm(codec, (uint8)buff_long);
             }
 
             buffX  = get_symbol(stream, 8);
             buffY  = get_symbol(stream, 8);
             buffZ  = get_symbol(stream, 8);
-            buffTS = get_symbol(stream, 2);
+            buffTS = get_symbol(stream, 8);
             if(CSsgc & (0x01 << 9))
             {
-               bwc_set_tiles(field, buffX, buffY, buffZ, (uint16)buffTS, bwc_tile_sizeof);
+               bwc_set_tiles(codec, buffX, buffY, buffZ, buffTS, bwc_tile_sizeof);
             }
 
             control->nLayers = get_symbol(stream, 1);
@@ -852,7 +817,7 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
             {
                // memory allocation error
                fprintf(stderr, MEMERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status|= CODESTREAM_ERROR;
                break;
             }
@@ -863,10 +828,10 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
                control->bitrate[l] = *(float *)&bitrate;
             }
 
-            create_field(field);
+            create_codec(codec);
-            if(!field)
+            if(!codec)
             {
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
@@ -881,7 +846,7 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
             {
                // Invalid Codestream
                fprintf(stderr, CSERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
@@ -891,17 +856,17 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
             {
                // Invalid Codestream
                fprintf(stderr, CSERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
 
-            data->codestream.aux = calloc(1, sizeof(bwc_stream));
+            data->codestream.aux = calloc(1, sizeof(bwc_span));
             if(!data->codestream.aux)
             {
                // memory allocation error
                fprintf(stderr, MEMERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
@@ -919,7 +884,7 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
             {
                // Invalid Codestream
                fprintf(stderr, CSERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
@@ -929,17 +894,17 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
             {
                // Invalid Codestream
                fprintf(stderr, CSERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
 
-            data->codestream.com = calloc(1, sizeof(bwc_stream));
+            data->codestream.com = calloc(1, sizeof(bwc_span));
             if(!data->codestream.com)
             {
                // memory allocation error
                fprintf(stderr, MEMERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
@@ -959,7 +924,7 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
                {
                   // Invalid Codestream
                   fprintf(stderr, CSERROR);
-                  bwc_kill_compression(field);
+                  bwc_free_codec(codec);
                   status |= CODESTREAM_ERROR;
                   break;
                }
@@ -969,12 +934,12 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
                {
                   // Invalid Codestream
                   fprintf(stderr, CSERROR);
-                  bwc_kill_compression(field);
+                  bwc_free_codec(codec);
                   status |= CODESTREAM_ERROR;
                   break;
                }
 
-               if(codec_prec == 8)
+               if(codec_prec == bwc_precision_double)
                {
                   /*--------------------------------------------------------*\
                   ! Loop through all tile parameters and...                  !
@@ -988,14 +953,14 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
                         ! header stream.                                           !
                         \*--------------------------------------------------------*/
                         buff_long = get_symbol(stream, sizeof(double));
-                        field->tile[t].parameter[p].info.parameter_min = (bwc_float)*(double*)&buff_long;
+                        codec->tile[t].parameter[p].info.parameter_min = (bwc_float)*(double*)&buff_long;
 
                         buff_long = get_symbol(stream, sizeof(double));
-                        field->tile[t].parameter[p].info.parameter_max = (bwc_float)*(double*)&buff_long;
+                        codec->tile[t].parameter[p].info.parameter_max = (bwc_float)*(double*)&buff_long;
                      }
                   }
                }
-               else if(codec_prec == 4)
+               else if(codec_prec == bwc_precision_single)
                {
                   /*--------------------------------------------------------*\
                   ! Loop through all tile parameters and...                  !
@@ -1009,20 +974,20 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
                         ! header stream.                                           !
                         \*--------------------------------------------------------*/
                         buff = get_symbol(stream, sizeof(float));
-                        field->tile[t].parameter[p].info.parameter_min = (bwc_float)*(float*)&buff;
+                        codec->tile[t].parameter[p].info.parameter_min = (bwc_float)*(float*)&buff;
 
                         buff = get_symbol(stream, sizeof(float));
-                        field->tile[t].parameter[p].info.parameter_max = (bwc_float)*(float*)&buff;
+                        codec->tile[t].parameter[p].info.parameter_max = (bwc_float)*(float*)&buff;
                      }
                   }
                }
-               return field;
+               return codec;
             }
             else
             {
                // Invalid Codestream
                fprintf(stderr, CSERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
             }
             break;
@@ -1034,7 +999,7 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
             {
                // Invalid Codestream
                fprintf(stderr, CSERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
@@ -1044,7 +1009,7 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
             {
                // Invalid Codestream
                fprintf(stderr, CSERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
@@ -1059,7 +1024,7 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: uchar sequence_packets(bwc_field *const field, bwc_field *const field)                    !
+!   FUNCTION NAME:                                                                                           !
 !   --------------                                                                                           !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -1070,16 +1035,11 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
-!                                                                    decompression stage.                    !
-!                                                                                                            !
-!                tile                        bwc_tile*             - Structure defining a bwc tile.          !
 !                                                                                                            !
 !   RETURN VALUE:                                                                                            !
 !   -------------                                                                                            !
 !                Type                        Description                                                     !
 !                ----                        -----------                                                     !
-!                uchar                     - Returns an unsigned char for error handling.                    !
 !                                                                                                            !
 !   DEVELOPMENT HISTORY:                                                                                     !
 !   --------------------                                                                                     !
@@ -1090,7 +1050,7 @@ parse_main_header(bwc_data *const data,bitstream *const stream)
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 static uchar
-parse_tile(bwc_field *const field, bitstream *const stream)
+parse_tile(bwc_codec *const codec, bitstream *const stream)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
@@ -1110,7 +1070,7 @@ parse_tile(bwc_field *const field, bitstream *const stream)
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(stream);
 
    /*--------------------------------------------------------*\
@@ -1118,7 +1078,7 @@ parse_tile(bwc_field *const field, bitstream *const stream)
    ! sequence structure to temporary variables to make the    !
    ! code more readable.                                      !
    \*--------------------------------------------------------*/
-   control = &field->control;
+   control = &codec->control;
 
    if(!can_read(stream, 2))
    {
@@ -1144,7 +1104,7 @@ parse_tile(bwc_field *const field, bitstream *const stream)
       return 1;
    }
 
-   tile                    = &field->tile[buf];
+   tile                    = &codec->tile[buf];
    tile->control.body_size = 
                  body_size = (uint64)get_symbol(stream, 8);
    
@@ -1160,7 +1120,7 @@ parse_tile(bwc_field *const field, bitstream *const stream)
       ! Sequence the packets according to the user specified op- !
       ! tion.                                                    !
       \*--------------------------------------------------------*/
-      if(sequence_packets(field, tile))
+      if(sequence_packets(codec, tile))
       {
          return 1;
       }
@@ -1198,7 +1158,7 @@ parse_tile(bwc_field *const field, bitstream *const stream)
 
          packet->header.memory = get_access(stream);
 
-         if(parse_packet(field, tile, packet, body_size))
+         if(parse_packet(codec, tile, packet, body_size))
          {
             return 1;
          }
@@ -1240,7 +1200,7 @@ parse_tile(bwc_field *const field, bitstream *const stream)
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 static uchar
-parse_body(bwc_field *const field, bitstream *const stream)
+parse_body(bwc_codec *const codec, bitstream *const stream)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
@@ -1256,7 +1216,7 @@ parse_body(bwc_field *const field, bitstream *const stream)
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    
    status = CODESTREAM_OK;
 
@@ -1274,7 +1234,7 @@ parse_body(bwc_field *const field, bitstream *const stream)
       {
          case SOT:
          {
-            if(parse_tile(field, stream))
+            if(parse_tile(codec, stream))
             {
                status |= CODESTREAM_ERROR;
             }
@@ -1307,7 +1267,7 @@ parse_body(bwc_field *const field, bitstream *const stream)
             {
                // Invalid Codestream
                fprintf(stderr, CSERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
@@ -1317,7 +1277,7 @@ parse_body(bwc_field *const field, bitstream *const stream)
             {
                // Invalid Codestream
                fprintf(stderr, CSERROR);
-               bwc_kill_compression(field);
+               bwc_free_codec(codec);
                status |= CODESTREAM_ERROR;
                break;
             }
@@ -1336,7 +1296,7 @@ parse_body(bwc_field *const field, bitstream *const stream)
 ||                                                                                                          ||
 \************************************************************************************************************/
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: bwc_stream* assemble_codestream(bwc_field *const field)                                   !
+!   FUNCTION NAME: bwc_span* assemble_codestream(bwc_codec *const codec, bwc_stream *const data)             !
 !   --------------                                                                                           !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -1347,14 +1307,14 @@ parse_body(bwc_field *const field, bitstream *const stream)
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
+!                codec                       bwc_codec*            - Structure defining the compression/     !
 !                                                                    decompression stage.                    !
 !                                                                                                            !
 !   RETURN VALUE:                                                                                            !
 !   -------------                                                                                            !
 !                Type                        Description                                                     !
 !                ----                        -----------                                                     !
-!                bwc_stream*               - Packed stream containing the compressed data set.               !
+!                bwc_span*                 - Packed stream containing the compressed data set.               !
 !                                                                                                            !
 !   DEVELOPMENT HISTORY:                                                                                     !
 !   --------------------                                                                                     !
@@ -1364,12 +1324,13 @@ parse_body(bwc_field *const field, bitstream *const stream)
 !                13.06.2019  Patrick Vogler     B87D120     V 0.1.0     function created                     !
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
-bwc_stream*
+size_t
-assemble_codestream(bwc_field *const field)
+assemble_codestream(bwc_codec *const codec, bwc_stream *const data)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
    \*-----------------------*/
+   size_t   compressed_size;
    uint64   i;
    
    /*-----------------------*\
@@ -1378,12 +1339,12 @@ assemble_codestream(bwc_field *const field)
    bwc_gl_ctrl       *control;
    bwc_tile          *tile;
    bitstream         *stream;
-   bwc_stream        *packed_stream;
    
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
+   assert(data);
 
    /*--------------------------------------------------------*\
    ! Save the global control and info structure to temporary  !
@@ -1391,7 +1352,7 @@ assemble_codestream(bwc_field *const field)
    ! the final codestream size with the number of header      !
    ! bytes.                                                   !
    \*--------------------------------------------------------*/
-   control = &field->control;
+   control = &codec->control;
 
    control->codestreamSize = control->headerSize + 2;
 
@@ -1405,15 +1366,15 @@ assemble_codestream(bwc_field *const field)
       ! Save the tile structure in a temporary variable to make  !
       ! the code more readable.                                  !
       \*--------------------------------------------------------*/
-      tile          = &field->tile[i];
+      tile          = &codec->tile[i];
 
       /*--------------------------------------------------------*\
       ! Sequence the packets according to the user specified op- !
       ! tion and iterate the size of the codestream.             !
       \*--------------------------------------------------------*/
-      if(sequence_packets(field, tile))
+      if(sequence_packets(codec, tile))
       {
-         return NULL;
+         return 0;
       }
       control->codestreamSize += tile->control.header_size + 
                                  tile->control.body_size;
@@ -1423,8 +1384,8 @@ assemble_codestream(bwc_field *const field)
    ! Initialize the final codestream and emit the header      !
    ! bytes.                                                   !
    \*--------------------------------------------------------*/
-   stream = init_stream(NULL, control->codestreamSize, 'c');
+   stream = init_bitstream(data->out, control->codestreamSize, 'c');
-   codestream_write_header(stream, field);
+   codestream_write_header(stream, codec, data);
 
    /*--------------------------------------------------------*\
    ! Walk through the tile structure and assemble the packed  !
@@ -1437,33 +1398,21 @@ assemble_codestream(bwc_field *const field)
       ! Save the tile structure in a temporary variable to make  !
       ! the code more readable.                                  !
       \*--------------------------------------------------------*/
-      tile          = &field->tile[i];
+      tile          = &codec->tile[i];
 
-      assemble_tile(field, tile, stream);
+      assemble_tile(codec, tile, stream);
    }
 
    emit_symbol(stream, EOC, 2);
 
-   packed_stream = calloc(1, sizeof(bwc_stream));
+   compressed_size = stream->L;
-   if(!packed_stream)
+   free(stream);
-   {
-      // memory allocation error
-      fprintf(stderr, MEMERROR);
-      return NULL;
-   }
 
-   if(terminate_stream(stream, packed_stream))
+   return compressed_size;
-   {
-      return NULL;
-   }
-   else
-   {
-      return packed_stream;
-   }
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: uchar parse_codestream(bwc_field *const field, bitstream *const stream)                   !
+!   FUNCTION NAME: uchar parse_codestream(bwc_codec *const codec, bitstream *const stream)                   !
 !   --------------                                                                                           !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -1474,7 +1423,7 @@ assemble_codestream(bwc_field *const field)
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
+!                codec                       bwc_codec*            - Structure defining the compression/     !
 !                                                                    decompression stage.                    !
 !                                                                                                            !
 !                stream                      bitstream*            - Structure used to assemble a bwc bit-   !
@@ -1494,32 +1443,32 @@ assemble_codestream(bwc_field *const field)
 !                05.08.2019  Patrick Vogler     B87D120     V 0.1.0     function created                     !
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
-bwc_field*
+bwc_codec*
-parse_codestream(bwc_data *const data, uint8 const layer)
+parse_codestream(bwc_codec *const codec, bwc_stream *const data, uint8 const layer)
 {
    /*-----------------------*\
    ! DEFINE STRUCTS:         !
    \*-----------------------*/
-   bwc_field         *field;
    bitstream         *stream;
    
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
    assert(data);
+   assert(codec);
 
    /*--------------------------------------------------------*\
    ! Initialize a bitstream used to parse the packed code-    !
    ! stream.                                                  !
    \*--------------------------------------------------------*/
-   stream = init_stream(data->codestream.data->memory, 10, 'd');
+   stream = init_bitstream(data->inp, 10, 'd');
 
    /*--------------------------------------------------------*\
-   ! Parse the main header and set up the field structure for !
+   ! Parse the main header and set up the codec structure for !
    ! the current decompression run.                           !
    \*--------------------------------------------------------*/
-   field = parse_main_header(data, stream);
+   parse_main_header(codec, data, stream);
-   if(!field)
+   if(!codec)
    {
       return NULL;
    }
@@ -1528,36 +1477,36 @@ parse_codestream(bwc_data *const data, uint8 const layer)
    ! Initialize the useLayer option to decompress the entire  !
    ! codestream.                                              !
    \*--------------------------------------------------------*/
-   field->control.useLayer = field->control.nLayers - 1;   
+   codec->control.useLayer = codec->control.nLayers - 1;
 
    /*--------------------------------------------------------*\
    ! Check if the layer index supplied by the function caller !
    ! is valid.                                                !
    \*--------------------------------------------------------*/
-   if(layer < field->control.nLayers && layer > 0)
+   if(layer < codec->control.nLayers && layer > 0)
    {
       /*--------------------------------------------------------*\
       ! Amend the use layer variable in the global control struc-!
       ! ture.                                                    !
       \*--------------------------------------------------------*/
-      field->control.useLayer = layer;
+      codec->control.useLayer = layer;
    }
 
    /*--------------------------------------------------------*\
    ! Parse the rest of the compressed codestream and load the !
-   ! body into the field structure.                           !
+   ! body into the codec structure.                           !
    \*--------------------------------------------------------*/
-   if(parse_body(field, stream))
+   if(parse_body(codec, stream))
    {
-      bwc_kill_compression(field);
+      bwc_free_codec(codec);
       return NULL;
    }
 
    /*--------------------------------------------------------*\
    ! Free the bitstream used to parse the codestream and re-  !
-   ! turn the field structure to the function caller.         !
+   ! turn the codec structure to the function caller.         !
    \*--------------------------------------------------------*/
    free(stream);
 
-   return field;
+   return codec;
 }

src/library/dwt.c

@@ -1421,7 +1421,7 @@ initialize_gain_lut()
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: bwc_float get_dwt_energy_gain(bwc_field *const field, uchar highband_flag, uint16 level)  !
+!   FUNCTION NAME: bwc_float get_dwt_energy_gain(bwc_codec *const codec, uchar highband_flag, uint16 level)  !
 !   --------------                                                                                           !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -1434,7 +1434,7 @@ initialize_gain_lut()
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
+!                codec                       bwc_codec*            - Structure defining the compression/     !
 !                                                                    decompression stage.                    !
 !                                                                                                            !
 !                highband_flag               uchar                 - Defines the subband for which Gb is     !
@@ -1459,7 +1459,7 @@ initialize_gain_lut()
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 bwc_float
-get_dwt_energy_gain(bwc_field *const field, uchar highband_flag, uint16 level)
+get_dwt_energy_gain(bwc_codec *const codec, uchar highband_flag, uint16 level)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
@@ -1480,15 +1480,15 @@ get_dwt_energy_gain(bwc_field *const field, uchar highband_flag, uint16 level)
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
-   assert(level <= field->control.nDecomp + 1);
+   assert(level <= codec->control.nDecomp + 1);
    assert(highband_flag <= DIM_ALL);
 
    /*--------------------------------------------------------*\
    ! Save the global control structure to a temporary varia-  !
    ! ble to make the code more readable.                      !
    \*--------------------------------------------------------*/
-   control = &field->control;
+   control = &codec->control;
 
    /*--------------------------------------------------------*\
    ! Evaluate the number of decompositions in each temporal & !
@@ -1576,7 +1576,7 @@ get_dwt_energy_gain(bwc_field *const field, uchar highband_flag, uint16 level)
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: uchar forward_discrete_wavelet_transform(bwc_field *const field,                          !
+!   FUNCTION NAME: uchar forward_discrete_wavelet_transform(bwc_codec *const codec,                          !
 !   --------------                                          bwc_parameter *const parameter)                  !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -1594,7 +1594,7 @@ get_dwt_energy_gain(bwc_field *const field, uchar highband_flag, uint16 level)
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
+!                codec                       bwc_codec*            - Structure defining the compression/     !
 !                                                                    decompression stage.                    !
 !                                                                                                            !
 !                parameter                   bwc_parameter*        - Structure defining a bwc parameter.     !
@@ -1614,28 +1614,22 @@ get_dwt_energy_gain(bwc_field *const field, uchar highband_flag, uint16 level)
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 uchar
-forward_wavelet_transform(bwc_field *const field, bwc_parameter *const parameter)
+forward_wavelet_transform(bwc_codec *const codec, bwc_parameter *const parameter)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
    \*-----------------------*/
-   uint64   incr_X, incr_Y, incr_Z;
+   uint64   incr_X, incr_Y, incr_Z, incr_TS;
-   uint64   rX0, rY0, rZ0;
+   uint64   rX0, rY0, rZ0, rTS0;
-   uint64   rX1, rY1, rZ1;
+   uint64   rX1, rY1, rZ1, rTS1;
-   uint64   width, height, depth;
+   uint64   width, height, depth, dt;
-   uint64   x, y, z;
+   uint64   x, y, z, t;
 
    int64    nThreads;
    int16    i;
    
    uint32   buff_size;
    
-   uint16   incr_TS;
-   uint16   rTS0;
-   uint16   rTS1;
-   uint16   dt;
-   uint16   t;
-   
    uint8    id;
    uint8    filter_tapsX, filter_tapsY, filter_tapsZ;
    uint8    filter_tapsTS;
@@ -1652,7 +1646,7 @@ forward_wavelet_transform(bwc_field *const field, bwc_parameter *const parameter
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(parameter);
 
    /*-----------------------*\
@@ -1670,7 +1664,7 @@ forward_wavelet_transform(bwc_field *const field, bwc_parameter *const parameter
    ! Save the global control and parameter info structure to  !
    ! temporary variables to make the code more readable.      !
    \*--------------------------------------------------------*/
-   control       = &field->control;
+   control       = &codec->control;
    param_info    = &parameter->info;
 
    /*--------------------------------------------------------*\
@@ -1777,8 +1771,8 @@ forward_wavelet_transform(bwc_field *const field, bwc_parameter *const parameter
          rY1  = (uint64)parameter->resolution[control->nDecomp - level].info.Y1;
          rZ0  = (uint64)parameter->resolution[control->nDecomp - level].info.Z0;
          rZ1  = (uint64)parameter->resolution[control->nDecomp - level].info.Z1;
-         rTS0 = (uint16)parameter->resolution[control->nDecomp - level].info.TS0;
+         rTS0 = (uint64)parameter->resolution[control->nDecomp - level].info.TS0;
-         rTS1 = (uint16)parameter->resolution[control->nDecomp - level].info.TS1;
+         rTS1 = (uint64)parameter->resolution[control->nDecomp - level].info.TS1;
 
          if(level < control->decompX  && (rX1 - rX0) > 1)
          {
@@ -2117,7 +2111,7 @@ forward_wavelet_transform(bwc_field *const field, bwc_parameter *const parameter
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: uchar inverse_discrete_wavelet_transform(bwc_field *const field,                          !
+!   FUNCTION NAME: uchar inverse_discrete_wavelet_transform(bwc_codec *const codec,                          !
 !   --------------                                          bwc_parameter *const parameter)                  !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -2135,7 +2129,7 @@ forward_wavelet_transform(bwc_field *const field, bwc_parameter *const parameter
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
+!                codec                       bwc_codec*            - Structure defining the compression/     !
 !                                                                    decompression stage.                    !
 !                                                                                                            !
 !                parameter                   bwc_parameter*        - Structure defining a bwc parameter.     !
@@ -2155,28 +2149,22 @@ forward_wavelet_transform(bwc_field *const field, bwc_parameter *const parameter
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 uchar
-inverse_wavelet_transform(bwc_field *const field, bwc_parameter *const parameter)
+inverse_wavelet_transform(bwc_codec *const codec, bwc_parameter *const parameter)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
    \*-----------------------*/
-   uint64   incr_X, incr_Y, incr_Z;
+   uint64   incr_X, incr_Y, incr_Z, incr_TS;
-   uint64   rX0, rY0, rZ0;
+   uint64   rX0, rY0, rZ0, rTS0;
-   uint64   rX1, rY1, rZ1;
+   uint64   rX1, rY1, rZ1, rTS1;
-   uint64   width, height, depth;
+   uint64   width, height, depth, dt;
-   uint64   x, y, z;
+   uint64   x, y, z, t;
    
    int64    nThreads;
    int64    i;
    
    uint32   buff_size;
    
-   uint16   incr_TS;
-   uint16   rTS0;
-   uint16   rTS1;
-   uint16   dt;
-   uint16   t;
-   
    uint8    id;
    uint8    filter_tapsX, filter_tapsY, filter_tapsZ;
    uint8    filter_tapsTS;
@@ -2193,7 +2181,7 @@ inverse_wavelet_transform(bwc_field *const field, bwc_parameter *const parameter
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(parameter);
 
    /*-----------------------*\
@@ -2211,7 +2199,7 @@ inverse_wavelet_transform(bwc_field *const field, bwc_parameter *const parameter
    ! Save the global control and parameter info structure to  !
    ! temporary variables to make the code more readable.      !
    \*--------------------------------------------------------*/
-   control    = &field->control;
+   control    = &codec->control;
    param_info = &parameter->info;
 
    /*--------------------------------------------------------*\
@@ -2318,8 +2306,8 @@ inverse_wavelet_transform(bwc_field *const field, bwc_parameter *const parameter
          rY1  = (uint64)parameter->resolution[control->nDecomp - level].info.Y1;
          rZ0  = (uint64)parameter->resolution[control->nDecomp - level].info.Z0;
          rZ1  = (uint64)parameter->resolution[control->nDecomp - level].info.Z1;
-         rTS0 = (uint16)parameter->resolution[control->nDecomp - level].info.TS0;
+         rTS0 = (uint64)parameter->resolution[control->nDecomp - level].info.TS0;
-         rTS1 = (uint16)parameter->resolution[control->nDecomp - level].info.TS1;
+         rTS1 = (uint64)parameter->resolution[control->nDecomp - level].info.TS1;
 
          if(level < control->decompTS && (rTS1 - rTS0) > 1)
          {

src/library/tier1.c

@@ -16,7 +16,7 @@
 ||  ------------                                                                                  ||
 ||                                                                                                ||
 ||        This file describes a set of functions that can be used to de-/encode bwc               ||
-||        codeblocks described by the bwc_field structure according to the embedded block         ||
+||        codeblocks described by the bwc_codec structure according to the embedded block         ||
 ||        coding paradigm described by the JPEG 2000 standard. For more information please        ||
 ||        refere to JPEG2000 by D. S. Taubman and M. W. Marcellin.                                ||
 ||                                                                                                ||
@@ -99,6 +99,76 @@
    mq_bit_encode(bitcoder, 0, CONTEXT_UNI);        \
 }
 
+#define calc_k_sig(stripe, bit_mask, k, l, k_h, k_v, k_d, k_sig)                                              \
+{                                                                                                             \
+   k_h = (stripe[k].stripe_l->sigma & bit_mask) + (stripe[k].stripe_r->sigma & bit_mask);                     \
+   k_v = ((bit_mask & (stripe[k].sigma >> 1)) + (bit_mask & (stripe[k].sigma << 1)));                         \
+   k_d = ((bit_mask & (stripe[k].stripe_l->sigma >> 1)) + (bit_mask & (stripe[k].stripe_l->sigma << 1)) +     \
+          (bit_mask & (stripe[k].stripe_r->sigma >> 1)) + (bit_mask & (stripe[k].stripe_r->sigma << 1)));     \
+   if(l == 3)                                                                                                 \
+   {                                                                                                          \
+      k_v += ((0x01 & stripe[k].stripe_u->sigma) << 3);                                                       \
+      k_d += ((0x01 & stripe[k].stripe_u->stripe_l->sigma) +                                                  \
+              (0x01 & stripe[k].stripe_u->stripe_r->sigma)) << 3;                                             \
+   }                                                                                                          \
+   else if(l == 0)                                                                                            \
+   {                                                                                                          \
+      k_v += ((0x08 & stripe[k].stripe_d->sigma) >> 3);                                                       \
+      k_d += ((0x08 & stripe[k].stripe_d->stripe_l->sigma) +                                                  \
+              (0x08 & stripe[k].stripe_d->stripe_r->sigma)) >> 3;                                             \
+   }                                                                                                          \
+   k_sig = ((15 * k_h + 5 * k_v + k_d) >> l);                                                                 \
+}
+
+#define calc_xi(stripe, bit_mask, k, l, xi_h, xi_v, SIG2XI)                                                   \
+{                                                                                                             \
+   xi_h = ((bit_mask & stripe[k].stripe_l->sigma)       | ((bit_mask & stripe[k].stripe_l->xi) << 2) |        \
+          ((bit_mask & stripe[k].stripe_r->sigma) << 1) | ((bit_mask & stripe[k].stripe_r->xi) << 3)) >> l;   \
+   xi_v = ((bit_mask & (stripe[k].sigma >> 1))       | ((bit_mask & (stripe[k].xi >> 1)) << 2) |              \
+          ((bit_mask & (stripe[k].sigma << 1)) << 1) | ((bit_mask & (stripe[k].xi << 1)) << 3)) >> l;         \
+   if(l == 3)                                                                                                 \
+   {                                                                                                          \
+      xi_v |= ((0x01 & stripe[k].stripe_u->sigma) | ((0x01 & stripe[k].stripe_u->xi) << 2));                  \
+   }                                                                                                          \
+   else if(l == 0)                                                                                            \
+   {                                                                                                          \
+      xi_v |= (((0x08 & stripe[k].stripe_d->sigma) >> 2) | (0x08 & stripe[k].stripe_d->xi));                  \
+   }                                                                                                          \
+   xi_h = SIG2XI[xi_h];                                                                                       \
+   xi_v = SIG2XI[xi_v];                                                                                       \
+}
+
+#define calc_k_mag(stripe, bit_mask, k, l, k_mag)                                                             \
+{                                                                                                             \
+   k_mag      = CONTEXT_MAG;                                                                                  \
+   if(stripe[k].delta & bit_mask)                                                                             \
+   {                                                                                                          \
+      k_mag += 2;                                                                                             \
+   }                                                                                                          \
+   else                                                                                                       \
+   {                                                                                                          \
+      if((bit_mask & (stripe[k].sigma >> 1))           || (bit_mask & (stripe[k].sigma << 1))            ||   \
+         (stripe[k].stripe_l->sigma & bit_mask)        || (stripe[k].stripe_r->sigma & bit_mask)         ||   \
+         (bit_mask & (stripe[k].stripe_l->sigma >> 1)) || (bit_mask & (stripe[k].stripe_l->sigma << 1))  ||   \
+         (bit_mask & (stripe[k].stripe_r->sigma >> 1)) || (bit_mask & (stripe[k].stripe_r->sigma << 1)))      \
+      {                                                                                                       \
+         k_mag += 1;                                                                                          \
+      }                                                                                                       \
+      else if((l == 3) && ((0x08 & (stripe[k].stripe_u->sigma << 3))                                          \
+                       ||  (0x08 & (stripe[k].stripe_u->stripe_l->sigma << 3))                                \
+                       ||  (0x08 & (stripe[k].stripe_u->stripe_r->sigma << 3))))                              \
+      {                                                                                                       \
+         k_mag += 1;                                                                                          \
+      }                                                                                                       \
+      else if((l == 0) && ((0x01 & (stripe[k].stripe_d->sigma >> 3))                                          \
+                       ||  (0x01 & (stripe[k].stripe_d->stripe_l->sigma >> 3))                                \
+                       ||  (0x01 & (stripe[k].stripe_d->stripe_r->sigma >> 3))))                              \
+      {                                                                                                       \
+         k_mag += 1;                                                                                          \
+      }                                                                                                       \
+   }                                                                                                          \
+}
+
 /************************************************************************************************************\
 ||           ____ _  _ ___ ____ ____ _  _ ____ _       ____ ____ _  _ ____ ___ ____ _  _ ___ ____           ||
 ||           |___  \/   |  |___ |__/ |\ | |__| |       |    |  | |\ | [__   |  |__| |\ |  |  [__            ||
@@ -398,9 +468,8 @@ cblkreset_inv(bwc_coder_stripe *const cblk, const uint64 width, const uint64 hei
    uint64   i;
    uint64   limit;
    uint64   cblk_stripe;
-   uint64   x, y, z;
+   uint64   x, y, z, t;
    int64    idx_u, idx_r, idx_d, idx_l;
-   uint16   t;
    uint8    s;
 
    /*-----------------------*\
@@ -533,15 +602,12 @@ cblkcopy_forward(bwc_coder_stripe *const destination, bwc_sample *const source,
    \*-----------------------*/
    bwc_raw  buff, sign_mask;
    uint64   bit_mask, limit;
-   uint64   cblk_width, cblk_height, cblk_depth, cblk_stripe;
+   uint64   cblk_width, cblk_height, cblk_depth, cblk_dt, cblk_stripe;
    uint64   incrX, incrY, incrZ;
-   uint64   i, x, y, z;
+   uint64   i, x, y, z, t;
-   uint64   X0, Y0, Z0;
+   uint64   X0, Y0, Z0, TS0;
-   uint64   X1, Y1, Z1;
+   uint64   X1, Y1, Z1, TS1;
    int64    idx_u, idx_r, idx_d, idx_l;
-   uint16   TS0, TS1; 
-   uint16   cblk_dt;
-   uint16   t;
    uint8    b, Kmax, s;
 
    /*-----------------------*\
@@ -775,15 +841,12 @@ cblkcopy_inverse(bwc_coder_stripe *const source,      bwc_sample *const destinat
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
    \*-----------------------*/
-   uint64   cblk_width, cblk_height, cblk_depth, cblk_stripe;
+   uint64   cblk_width, cblk_height, cblk_depth, cblk_dt, cblk_stripe;
    uint64   bit_shift, buff, limit;
    uint64   incrX, incrY, incrZ;
-   uint64   i, x, y, z;
+   uint64   i, x, y, z, t;
-   uint64   X0, Y0, Z0;
+   uint64   X0, Y0, Z0, TS0;
-   uint64   X1, Y1, Z1;
+   uint64   X1, Y1, Z1, TS1;
-   uint16   TS0, TS1; 
-   uint16   cblk_dt;
-   uint16   t;
    uint8    bitplane;
    uint8    codingpass;
    uint8    s;
@@ -1011,27 +1074,7 @@ significance_propagation_enc_pass(bwc_coder *const coder, const int8 b)
                {
                   if(!(stripe[k].sigma & bit_mask))
                   {
-                     k_h = (stripe[k].stripe_l->sigma & bit_mask) + (stripe[k].stripe_r->sigma & bit_mask);
+                     calc_k_sig(stripe, bit_mask, k, l, k_h, k_v, k_d, k_sig);
-
-                     k_v = ((bit_mask & (stripe[k].sigma >> 1)) + (bit_mask & (stripe[k].sigma << 1)));
-
-                     k_d = ((bit_mask & (stripe[k].stripe_l->sigma >> 1)) + (bit_mask & (stripe[k].stripe_l->sigma << 1)) +
-                            (bit_mask & (stripe[k].stripe_r->sigma >> 1)) + (bit_mask & (stripe[k].stripe_r->sigma << 1)));
-
-                     if(l == 3)
-                     {
-                        k_v += ((0x01 & stripe[k].stripe_u->sigma) << 3);
-                        k_d += ((0x01 & stripe[k].stripe_u->stripe_l->sigma) + 
-                                (0x01 & stripe[k].stripe_u->stripe_r->sigma)) << 3;
-                     }
-                     else if(l == 0)
-                     {
-                        k_v += ((0x08 & stripe[k].stripe_d->sigma) >> 3);
-                        k_d += ((0x08 & stripe[k].stripe_d->stripe_l->sigma) + 
-                                (0x08 & stripe[k].stripe_d->stripe_r->sigma)) >> 3;
-                     }
-
-                     k_sig = ((15 * k_h + 5 * k_v + k_d) >> l);
 
                      if(k_sig)
                      {
@@ -1039,24 +1082,7 @@ significance_propagation_enc_pass(bwc_coder *const coder, const int8 b)
                         
                         if(bit & bit_mask)
                         {
-                           xi_h = ((bit_mask & stripe[k].stripe_l->sigma)       | ((bit_mask & stripe[k].stripe_l->xi) << 2) |
+                           calc_xi(stripe, bit_mask, k, l, xi_h, xi_v, SIG2XI);
-                                  ((bit_mask & stripe[k].stripe_r->sigma) << 1) | ((bit_mask & stripe[k].stripe_r->xi) << 3)) >> l;
-                           
-                           xi_v = ((bit_mask & (stripe[k].sigma >> 1))       | ((bit_mask & (stripe[k].xi >> 1)) << 2) |
-                                  ((bit_mask & (stripe[k].sigma << 1)) << 1) | ((bit_mask & (stripe[k].xi << 1)) << 3)) >> l;
-
-                           if(l == 3)
-                           {
-                              xi_v |= ((0x01 & stripe[k].stripe_u->sigma) | ((0x01 & stripe[k].stripe_u->xi) << 2));
-                           }
-                           else if(l == 0)
-                           {
-                              xi_v |= (((0x08 & stripe[k].stripe_d->sigma) >> 2) | (0x08 & stripe[k].stripe_d->xi));
-                           }
-
-                           xi_h = SIG2XI[xi_h];
-                           xi_v = SIG2XI[xi_v];
-                     
                            mq_bit_encode(coder->bitcoder, (uchar)(((bit_mask & stripe[k].xi) >> l)^XI2CONT[(xi_h << 2) | xi_v][1]),
                                                                                                    XI2CONT[(xi_h << 2) | xi_v][0]);
 
@@ -1090,21 +1116,7 @@ significance_propagation_enc_pass(bwc_coder *const coder, const int8 b)
                {
                   if(!(stripe[k].sigma & bit_mask))
                   {
-                     k_h = (stripe[k].stripe_l->sigma & bit_mask) + (stripe[k].stripe_r->sigma & bit_mask);
+                     calc_k_sig(stripe, bit_mask, k, l, k_h, k_v, k_d, k_sig);
-
-                     k_v = ((bit_mask & (stripe[k].sigma >> 1)) + (bit_mask & (stripe[k].sigma << 1)));
-
-                     k_d = ((bit_mask & (stripe[k].stripe_l->sigma >> 1)) + (bit_mask & (stripe[k].stripe_l->sigma << 1)) +
-                            (bit_mask & (stripe[k].stripe_r->sigma >> 1)) + (bit_mask & (stripe[k].stripe_r->sigma << 1)));
-
-                     if(l == 3)
-                     {
-                        k_v += ((0x01 & stripe[k].stripe_u->sigma) << 3);
-                        k_d += ((0x01 & stripe[k].stripe_u->stripe_l->sigma) + 
-                                (0x01 & stripe[k].stripe_u->stripe_r->sigma)) << 3;
-                     }
-
-                     k_sig = ((15 * k_h + 5 * k_v + k_d) >> l);
 
                      if(k_sig && (stripe[k].sigma^bit_mask))
                      {
@@ -1112,20 +1124,7 @@ significance_propagation_enc_pass(bwc_coder *const coder, const int8 b)
                         
                         if(bit & bit_mask)
                         {
-                           xi_h = ((bit_mask & stripe[k].stripe_l->sigma)       | ((bit_mask & stripe[k].stripe_l->xi) << 2) |
+                           calc_xi(stripe, bit_mask, k, l, xi_h, xi_v, SIG2XI);
-                                  ((bit_mask & stripe[k].stripe_r->sigma) << 1) | ((bit_mask & stripe[k].stripe_r->xi) << 3)) >> l;
-                           
-                           xi_v = ((bit_mask & (stripe[k].sigma >> 1))       | ((bit_mask & (stripe[k].xi >> 1)) << 2) |
-                                  ((bit_mask & (stripe[k].sigma << 1)) << 1) | ((bit_mask & (stripe[k].xi << 1)) << 3)) >> l;
-
-                           if(l == 3)
-                           {
-                              xi_v |= ((0x01 & stripe[k].stripe_u->sigma) | ((0x01 & stripe[k].stripe_u->xi) << 2));
-                           }
-
-                           xi_h = SIG2XI[xi_h];
-                           xi_v = SIG2XI[xi_v];
-                     
                            mq_bit_encode(coder->bitcoder, (uchar)(((bit_mask & stripe[k].xi) >> l)^XI2CONT[(xi_h << 2) | xi_v][1]),
                                                                                                    XI2CONT[(xi_h << 2) | xi_v][0]);
 
@@ -1224,34 +1223,7 @@ magnitude_refinement_enc_pass(bwc_coder *const coder, const int8 b)
             {
                if(sig & bit_mask)
                {
-                  k_mag      = CONTEXT_MAG;
+                  calc_k_mag(stripe, bit_mask, k, l, k_mag);
-
-                  if(stripe[k].delta & bit_mask)
-                  {
-                     k_mag += 2;
-                  }
-                  else
-                  {
-                     if((bit_mask & (stripe[k].sigma >> 1))           || (bit_mask & (stripe[k].sigma << 1))            ||
-                        (stripe[k].stripe_l->sigma & bit_mask)        || (stripe[k].stripe_r->sigma & bit_mask)         ||
-                        (bit_mask & (stripe[k].stripe_l->sigma >> 1)) || (bit_mask & (stripe[k].stripe_l->sigma << 1))  ||
-                        (bit_mask & (stripe[k].stripe_r->sigma >> 1)) || (bit_mask & (stripe[k].stripe_r->sigma << 1)))
-                     {
-                        k_mag += 1;
-                     }
-                     else if((l == 3) && ((0x08 & (stripe[k].stripe_u->sigma << 3))
-                                      ||  (0x08 & (stripe[k].stripe_u->stripe_l->sigma << 3))
-                                      ||  (0x08 & (stripe[k].stripe_u->stripe_r->sigma << 3))))
-                     {
-                        k_mag += 1;
-                     }
-                     else if((l == 0) && ((0x01 & (stripe[k].stripe_d->sigma >> 3))
-                                      ||  (0x01 & (stripe[k].stripe_d->stripe_l->sigma >> 3))
-                                      ||  (0x01 & (stripe[k].stripe_d->stripe_r->sigma >> 3))))
-                     {
-                        k_mag += 1;
-                     }
-                  }
 
                   mq_bit_encode(coder->bitcoder, (uchar)((bit >> l) & 0x01), k_mag);
 
@@ -1272,28 +1244,7 @@ magnitude_refinement_enc_pass(bwc_coder *const coder, const int8 b)
             {  
                if(sig & bit_mask)
                {
-                  k_mag      = CONTEXT_MAG;
+                  calc_k_mag(stripe, bit_mask, k, l, k_mag);
-
-                  if(stripe[k].delta & bit_mask)
-                  {
-                     k_mag += 2;
-                  }
-                  else
-                  {
-                     if((bit_mask & (stripe[k].sigma >> 1))           || (bit_mask & (stripe[k].sigma << 1))            ||
-                        (stripe[k].stripe_l->sigma & bit_mask)        || (stripe[k].stripe_r->sigma & bit_mask)         ||
-                        (bit_mask & (stripe[k].stripe_l->sigma >> 1)) || (bit_mask & (stripe[k].stripe_l->sigma << 1))  ||
-                        (bit_mask & (stripe[k].stripe_r->sigma >> 1)) || (bit_mask & (stripe[k].stripe_r->sigma << 1)))
-                     {
-                        k_mag += 1;
-                     }
-                     else if((l == 3) && ((0x08 & (stripe[k].stripe_u->sigma << 3))
-                                      ||  (0x08 & (stripe[k].stripe_u->stripe_l->sigma << 3))
-                                      ||  (0x08 & (stripe[k].stripe_u->stripe_r->sigma << 3))))
-                     {
-                        k_mag += 1;
-                     }
-                  }
 
                   mq_bit_encode(coder->bitcoder, (uchar)((bit >> l) & 0x01), k_mag);
 
@@ -1345,6 +1296,7 @@ cleanup_enc_pass(bwc_coder *const coder, const int8 b)
    uint64   k, x;
    int64    mse;
    uint16   k_h, k_v, k_d;
+   uint16   k_sig;
    uint16   xi_h, xi_v;
    uint8    bit_mask, l;
    uint8    dist_shift, dist_corr;
@@ -1410,48 +1362,12 @@ cleanup_enc_pass(bwc_coder *const coder, const int8 b)
                   }
                   else
                   {
-                     k_h = (stripe[k].stripe_l->sigma & bit_mask) + (stripe[k].stripe_r->sigma & bit_mask);
+                     calc_k_sig(stripe, bit_mask, k, l, k_h, k_v, k_d, k_sig);
-
+                     mq_bit_encode(coder->bitcoder, (uchar)((bit >> l) & 0x01), coder->sig2context[k_sig]);
-                     k_v = ((bit_mask & (stripe[k].sigma >> 1)) + (bit_mask & (stripe[k].sigma << 1)));
-
-                     k_d = ((bit_mask & (stripe[k].stripe_l->sigma >> 1)) + (bit_mask & (stripe[k].stripe_l->sigma << 1)) +
-                            (bit_mask & (stripe[k].stripe_r->sigma >> 1)) + (bit_mask & (stripe[k].stripe_r->sigma << 1)));
-
-                     if(l == 3)
-                     {
-                        k_v += ((0x01 & stripe[k].stripe_u->sigma) << 3);
-                        k_d += ((0x01 & stripe[k].stripe_u->stripe_l->sigma) + 
-                                (0x01 & stripe[k].stripe_u->stripe_r->sigma)) << 3;
-                     }
-                     else if(l == 0)
-                     {
-                        k_v += ((0x08 & stripe[k].stripe_d->sigma) >> 3);
-                        k_d += ((0x08 & stripe[k].stripe_d->stripe_l->sigma) + 
-                                (0x08 & stripe[k].stripe_d->stripe_r->sigma)) >> 3;
-                     }
-
-                     mq_bit_encode(coder->bitcoder, (uchar)((bit >> l) & 0x01), coder->sig2context[(15 * k_h + 5 * k_v + k_d) >> l]);
                   }
                   if(bit & bit_mask)
                   {
-                     xi_h = ((bit_mask & stripe[k].stripe_l->sigma)       | ((bit_mask & stripe[k].stripe_l->xi) << 2) |
+                     calc_xi(stripe, bit_mask, k, l, xi_h, xi_v, SIG2XI);
-                            ((bit_mask & stripe[k].stripe_r->sigma) << 1) | ((bit_mask & stripe[k].stripe_r->xi) << 3)) >> l;
-                     
-                     xi_v = ((bit_mask & (stripe[k].sigma >> 1))       | ((bit_mask & (stripe[k].xi >> 1)) << 2) |
-                            ((bit_mask & (stripe[k].sigma << 1)) << 1) | ((bit_mask & (stripe[k].xi << 1)) << 3)) >> l;
-
-                     if(l == 3)
-                     {
-                        xi_v |= ((0x01 & stripe[k].stripe_u->sigma) | ((0x01 & stripe[k].stripe_u->xi) << 2));
-                     }
-                     else if(l == 0)
-                     {
-                        xi_v |= (((0x08 & stripe[k].stripe_d->sigma) >> 2) | (0x08 & stripe[k].stripe_d->xi));
-                     }
-
-                     xi_h = SIG2XI[xi_h];
-                     xi_v = SIG2XI[xi_v];
-
                      mq_bit_encode(coder->bitcoder, (uchar)(((bit_mask & stripe[k].xi) >> l)^XI2CONT[(xi_h << 2) | xi_v][1]),
                                                                                              XI2CONT[(xi_h << 2) | xi_v][0]);
 
@@ -1471,38 +1387,12 @@ cleanup_enc_pass(bwc_coder *const coder, const int8 b)
             {
                if(!(stripe[k].sigma & bit_mask) && !(stripe[k].pi & bit_mask))
                {
-                  k_h = (stripe[k].stripe_l->sigma & bit_mask) + (stripe[k].stripe_r->sigma & bit_mask);
+                  calc_k_sig(stripe, bit_mask, k, l, k_h, k_v, k_d, k_sig);
-
+                  mq_bit_encode(coder->bitcoder, (uchar)((bit >> l) & 0x01), coder->sig2context[k_sig]);
-                  k_v = ((bit_mask & (stripe[k].sigma >> 1)) + (bit_mask & (stripe[k].sigma << 1)));
-
-                  k_d = ((bit_mask & (stripe[k].stripe_l->sigma >> 1)) + (bit_mask & (stripe[k].stripe_l->sigma << 1)) +
-                         (bit_mask & (stripe[k].stripe_r->sigma >> 1)) + (bit_mask & (stripe[k].stripe_r->sigma << 1)));
-
-                  if(l == 3)
-                  {
-                     k_v += ((0x01 & stripe[k].stripe_u->sigma) << 3);
-                     k_d += ((0x01 & stripe[k].stripe_u->stripe_l->sigma) + 
-                             (0x01 & stripe[k].stripe_u->stripe_r->sigma)) << 3;
-                  }
-
-                  mq_bit_encode(coder->bitcoder, (uchar)((bit >> l) & 0x01), coder->sig2context[(15 * k_h + 5 * k_v + k_d) >> l]);
 
                   if(bit & bit_mask)
                   {
-                     xi_h = ((bit_mask & stripe[k].stripe_l->sigma)       | ((bit_mask & stripe[k].stripe_l->xi) << 2) |
+                     calc_xi(stripe, bit_mask, k, l, xi_h, xi_v, SIG2XI);
-                            ((bit_mask & stripe[k].stripe_r->sigma) << 1) | ((bit_mask & stripe[k].stripe_r->xi) << 3)) >> l;
-                     
-                     xi_v = ((bit_mask & (stripe[k].sigma >> 1))       | ((bit_mask & (stripe[k].xi >> 1)) << 2) |
-                            ((bit_mask & (stripe[k].sigma << 1)) << 1) | ((bit_mask & (stripe[k].xi << 1)) << 3)) >> l;
-
-                     if(l == 3)
-                     {
-                        xi_v |= ((0x01 & stripe[k].stripe_u->sigma) | ((0x01 & stripe[k].stripe_u->xi) << 2));
-                     }
-
-                     xi_h = SIG2XI[xi_h];
-                     xi_v = SIG2XI[xi_v];
-               
                      mq_bit_encode(coder->bitcoder, (uchar)(((bit_mask & stripe[k].xi) >> l)^XI2CONT[(xi_h << 2) | xi_v][1]),
                                                                                              XI2CONT[(xi_h << 2) | xi_v][0]);
 
@@ -1588,27 +1478,7 @@ significance_propagation_dec_pass(bwc_coder *const coder, const int8 b)
                {
                   if(!(stripe[k].sigma & bit_mask))
                   {
-                     k_h = (stripe[k].stripe_l->sigma & bit_mask) + (stripe[k].stripe_r->sigma & bit_mask);
+                     calc_k_sig(stripe, bit_mask, k, l, k_h, k_v, k_d, k_sig);
-
-                     k_v = ((bit_mask & (stripe[k].sigma >> 1)) + (bit_mask & (stripe[k].sigma << 1)));
-
-                     k_d = ((bit_mask & (stripe[k].stripe_l->sigma >> 1)) + (bit_mask & (stripe[k].stripe_l->sigma << 1)) +
-                            (bit_mask & (stripe[k].stripe_r->sigma >> 1)) + (bit_mask & (stripe[k].stripe_r->sigma << 1)));
-
-                     if(l == 3)
-                     {
-                        k_v += ((0x01 & stripe[k].stripe_u->sigma) << 3);
-                        k_d += ((0x01 & stripe[k].stripe_u->stripe_l->sigma) + 
-                                (0x01 & stripe[k].stripe_u->stripe_r->sigma)) << 3;
-                     }
-                     else if(l == 0)
-                     {
-                        k_v += ((0x08 & stripe[k].stripe_d->sigma) >> 3);
-                        k_d += ((0x08 & stripe[k].stripe_d->stripe_l->sigma) + 
-                                (0x08 & stripe[k].stripe_d->stripe_r->sigma)) >> 3;
-                     }
-
-                     k_sig = ((15 * k_h + 5 * k_v + k_d) >> l);
 
                      if(k_sig)
                      {
@@ -1618,23 +1488,7 @@ significance_propagation_dec_pass(bwc_coder *const coder, const int8 b)
                         {
                            stripe[k].bit[b] |= (bit << l);
 
-                           xi_h = ((bit_mask & stripe[k].stripe_l->sigma)       | ((bit_mask & stripe[k].stripe_l->xi) << 2) |
+                           calc_xi(stripe, bit_mask, k, l, xi_h, xi_v, SIG2XI);
-                                  ((bit_mask & stripe[k].stripe_r->sigma) << 1) | ((bit_mask & stripe[k].stripe_r->xi) << 3)) >> l;
-                           
-                           xi_v = ((bit_mask & (stripe[k].sigma >> 1))       | ((bit_mask & (stripe[k].xi >> 1)) << 2) |
-                                  ((bit_mask & (stripe[k].sigma << 1)) << 1) | ((bit_mask & (stripe[k].xi << 1)) << 3)) >> l;
-
-                           if(l == 3)
-                           {
-                              xi_v |= ((0x01 & stripe[k].stripe_u->sigma) | ((0x01 & stripe[k].stripe_u->xi) << 2));
-                           }
-                           else if(l == 0)
-                           {
-                              xi_v |= (((0x08 & stripe[k].stripe_d->sigma) >> 2) | (0x08 & stripe[k].stripe_d->xi));
-                           }
-
-                           xi_h = SIG2XI[xi_h];
-                           xi_v = SIG2XI[xi_v];
 
                            stripe[k].xi |= ((XI2CONT[(xi_h << 2) | xi_v][1] ^ mq_bit_decode(coder->bitcoder, XI2CONT[(xi_h << 2) | xi_v][0])) << l);
 
@@ -1667,21 +1521,7 @@ significance_propagation_dec_pass(bwc_coder *const coder, const int8 b)
                {
                   if(!(stripe[k].sigma & bit_mask))
                   {
-                     k_h = (stripe[k].stripe_l->sigma & bit_mask) + (stripe[k].stripe_r->sigma & bit_mask);
+                     calc_k_sig(stripe, bit_mask, k, l, k_h, k_v, k_d, k_sig);
-
-                     k_v = ((bit_mask & (stripe[k].sigma >> 1)) + (bit_mask & (stripe[k].sigma << 1)));
-
-                     k_d = ((bit_mask & (stripe[k].stripe_l->sigma >> 1)) + (bit_mask & (stripe[k].stripe_l->sigma << 1)) +
-                            (bit_mask & (stripe[k].stripe_r->sigma >> 1)) + (bit_mask & (stripe[k].stripe_r->sigma << 1)));
-
-                     if(l == 3)
-                     {
-                        k_v += ((0x01 & stripe[k].stripe_u->sigma) << 3);
-                        k_d += ((0x01 & stripe[k].stripe_u->stripe_l->sigma) + 
-                                (0x01 & stripe[k].stripe_u->stripe_r->sigma)) << 3;
-                     }
-
-                     k_sig = ((15 * k_h + 5 * k_v + k_d) >> l);
 
                      if(k_sig && (stripe[k].sigma^bit_mask))
                      {
@@ -1691,19 +1531,7 @@ significance_propagation_dec_pass(bwc_coder *const coder, const int8 b)
                         {
                            stripe[k].bit[b] |= (bit << l);
 
-                           xi_h = ((bit_mask & stripe[k].stripe_l->sigma)       | ((bit_mask & stripe[k].stripe_l->xi) << 2) |
+                           calc_xi(stripe, bit_mask, k, l, xi_h, xi_v, SIG2XI);
-                                  ((bit_mask & stripe[k].stripe_r->sigma) << 1) | ((bit_mask & stripe[k].stripe_r->xi) << 3)) >> l;
-                           
-                           xi_v = ((bit_mask & (stripe[k].sigma >> 1))       | ((bit_mask & (stripe[k].xi >> 1)) << 2) |
-                                  ((bit_mask & (stripe[k].sigma << 1)) << 1) | ((bit_mask & (stripe[k].xi << 1)) << 3)) >> l;
-
-                           if(l == 3)
-                           {
-                              xi_v |= ((0x01 & stripe[k].stripe_u->sigma) | ((0x01 & stripe[k].stripe_u->xi) << 2));
-                           }
-
-                           xi_h = SIG2XI[xi_h];
-                           xi_v = SIG2XI[xi_v];
                      
                            stripe[k].xi |= ((XI2CONT[(xi_h << 2) | xi_v][1] ^ mq_bit_decode(coder->bitcoder, XI2CONT[(xi_h << 2) | xi_v][0])) << l);
 
@@ -1796,34 +1624,7 @@ magnitude_refinement_dec_pass(bwc_coder *const coder, const int8 b)
             {
                if(sig & bit_mask)
                {
-                  k_mag      = CONTEXT_MAG;
+                  calc_k_mag(stripe, bit_mask, k, l, k_mag);
-
-                  if(stripe[k].delta & bit_mask)
-                  {
-                     k_mag += 2;
-                  }
-                  else
-                  {
-                     if((bit_mask & (stripe[k].sigma >> 1))           || (bit_mask & (stripe[k].sigma << 1))            ||
-                        (stripe[k].stripe_l->sigma & bit_mask)        || (stripe[k].stripe_r->sigma & bit_mask)         ||
-                        (bit_mask & (stripe[k].stripe_l->sigma >> 1)) || (bit_mask & (stripe[k].stripe_l->sigma << 1))  ||
-                        (bit_mask & (stripe[k].stripe_r->sigma >> 1)) || (bit_mask & (stripe[k].stripe_r->sigma << 1)))
-                     {
-                        k_mag += 1;
-                     }
-                     else if((l == 3) && ((0x08 & (stripe[k].stripe_u->sigma << 3))
-                                      ||  (0x08 & (stripe[k].stripe_u->stripe_l->sigma << 3))
-                                      ||  (0x08 & (stripe[k].stripe_u->stripe_r->sigma << 3))))
-                     {
-                        k_mag += 1;
-                     }
-                     else if((l == 0) && ((0x01 & (stripe[k].stripe_d->sigma >> 3))
-                                      ||  (0x01 & (stripe[k].stripe_d->stripe_l->sigma >> 3))
-                                      ||  (0x01 & (stripe[k].stripe_d->stripe_r->sigma >> 3))))
-                     {
-                        k_mag += 1;
-                     }
-                  }
 
                   stripe[k].bit[b] |= (mq_bit_decode(coder->bitcoder, k_mag) << l);
 
@@ -1843,28 +1644,7 @@ magnitude_refinement_dec_pass(bwc_coder *const coder, const int8 b)
             {  
                if(sig & bit_mask)
                {
-                  k_mag      = CONTEXT_MAG;
+                  calc_k_mag(stripe, bit_mask, k, l, k_mag);
-
-                  if(stripe[k].delta & bit_mask)
-                  {
-                     k_mag += 2;
-                  }
-                  else
-                  {
-                     if((bit_mask & (stripe[k].sigma >> 1))           || (bit_mask & (stripe[k].sigma << 1))            ||
-                        (stripe[k].stripe_l->sigma & bit_mask)        || (stripe[k].stripe_r->sigma & bit_mask)         ||
-                        (bit_mask & (stripe[k].stripe_l->sigma >> 1)) || (bit_mask & (stripe[k].stripe_l->sigma << 1))  ||
-                        (bit_mask & (stripe[k].stripe_r->sigma >> 1)) || (bit_mask & (stripe[k].stripe_r->sigma << 1)))
-                     {
-                        k_mag += 1;
-                     }
-                     else if((l == 3) && ((0x08 & (stripe[k].stripe_u->sigma << 3))
-                                      ||  (0x08 & (stripe[k].stripe_u->stripe_l->sigma << 3))
-                                      ||  (0x08 & (stripe[k].stripe_u->stripe_r->sigma << 3))))
-                     {
-                        k_mag += 1;
-                     }
-                  }
 
                   stripe[k].bit[b] |= (mq_bit_decode(coder->bitcoder, k_mag) << l);
 
@@ -1913,6 +1693,7 @@ cleanup_dec_pass(bwc_coder *const coder, const int8 b)
    uint64   i, j;
    uint64   k, x;
    uint16   k_h, k_v, k_d;
+   uint16   k_sig;
    uint16   xi_h, xi_v;
    uint8    bit_mask, l;
    uint8    bit;
@@ -1969,47 +1750,12 @@ cleanup_dec_pass(bwc_coder *const coder, const int8 b)
                   }
                   else
                   {
-                     k_h = (stripe[k].stripe_l->sigma & bit_mask) + (stripe[k].stripe_r->sigma & bit_mask);
+                     calc_k_sig(stripe, bit_mask, k, l, k_h, k_v, k_d, k_sig);
-
+                     bit |= (mq_bit_decode(coder->bitcoder, coder->sig2context[k_sig]) << l);
-                     k_v = ((bit_mask & (stripe[k].sigma >> 1)) + (bit_mask & (stripe[k].sigma << 1)));
-
-                     k_d = ((bit_mask & (stripe[k].stripe_l->sigma >> 1)) + (bit_mask & (stripe[k].stripe_l->sigma << 1)) +
-                            (bit_mask & (stripe[k].stripe_r->sigma >> 1)) + (bit_mask & (stripe[k].stripe_r->sigma << 1)));
-
-                     if(l == 3)
-                     {
-                        k_v += ((0x01 & stripe[k].stripe_u->sigma) << 3);
-                        k_d += ((0x01 & stripe[k].stripe_u->stripe_l->sigma) + 
-                                (0x01 & stripe[k].stripe_u->stripe_r->sigma)) << 3;
-                     }
-                     else if(l == 0)
-                     {
-                        k_v += ((0x08 & stripe[k].stripe_d->sigma) >> 3);
-                        k_d += ((0x08 & stripe[k].stripe_d->stripe_l->sigma) + 
-                                (0x08 & stripe[k].stripe_d->stripe_r->sigma)) >> 3;
-                     }
-
-                     bit |= (mq_bit_decode(coder->bitcoder, coder->sig2context[(15 * k_h + 5 * k_v + k_d) >> l]) << l);
                   }
                   if(bit & bit_mask)
                   {
-                     xi_h = ((bit_mask & stripe[k].stripe_l->sigma)       | ((bit_mask & stripe[k].stripe_l->xi) << 2) |
+                     calc_xi(stripe, bit_mask, k, l, xi_h, xi_v, SIG2XI);
-                            ((bit_mask & stripe[k].stripe_r->sigma) << 1) | ((bit_mask & stripe[k].stripe_r->xi) << 3)) >> l;
-                     
-                     xi_v = ((bit_mask & (stripe[k].sigma >> 1))       | ((bit_mask & (stripe[k].xi >> 1)) << 2) |
-                            ((bit_mask & (stripe[k].sigma << 1)) << 1) | ((bit_mask & (stripe[k].xi << 1)) << 3)) >> l;
-
-                     if(l == 3)
-                     {
-                        xi_v |= ((0x01 & stripe[k].stripe_u->sigma) | ((0x01 & stripe[k].stripe_u->xi) << 2));
-                     }
-                     else if(l == 0)
-                     {
-                        xi_v |= (((0x08 & stripe[k].stripe_d->sigma) >> 2) | (0x08 & stripe[k].stripe_d->xi));
-                     }
-
-                     xi_h = SIG2XI[xi_h];
-                     xi_v = SIG2XI[xi_v];
                
                      stripe[k].xi |= ((XI2CONT[(xi_h << 2) | xi_v][1] ^ mq_bit_decode(coder->bitcoder, XI2CONT[(xi_h << 2) | xi_v][0])) << l);
 
@@ -2031,37 +1777,12 @@ cleanup_dec_pass(bwc_coder *const coder, const int8 b)
             {
                if(!(stripe[k].sigma & bit_mask) && !(stripe[k].pi & bit_mask))
                {
-                  k_h = (stripe[k].stripe_l->sigma & bit_mask) + (stripe[k].stripe_r->sigma & bit_mask);
+                  calc_k_sig(stripe, bit_mask, k, l, k_h, k_v, k_d, k_sig);
-
+                  bit |= (mq_bit_decode(coder->bitcoder, coder->sig2context[k_sig]) << l);
-                  k_v = ((bit_mask & (stripe[k].sigma >> 1)) + (bit_mask & (stripe[k].sigma << 1)));
-
-                  k_d = ((bit_mask & (stripe[k].stripe_l->sigma >> 1)) + (bit_mask & (stripe[k].stripe_l->sigma << 1)) +
-                         (bit_mask & (stripe[k].stripe_r->sigma >> 1)) + (bit_mask & (stripe[k].stripe_r->sigma << 1)));
-
-                  if(l == 3)
-                  {
-                     k_v += ((0x01 & stripe[k].stripe_u->sigma) << 3);
-                     k_d += ((0x01 & stripe[k].stripe_u->stripe_l->sigma) + 
-                             (0x01 & stripe[k].stripe_u->stripe_r->sigma)) << 3;
-                  }
-
-                  bit |= (mq_bit_decode(coder->bitcoder, coder->sig2context[(15 * k_h + 5 * k_v + k_d) >> l]) << l);
 
                   if(bit & bit_mask)
                   {
-                     xi_h = ((bit_mask & stripe[k].stripe_l->sigma)       | ((bit_mask & stripe[k].stripe_l->xi) << 2) |
+                     calc_xi(stripe, bit_mask, k, l, xi_h, xi_v, SIG2XI);
-                            ((bit_mask & stripe[k].stripe_r->sigma) << 1) | ((bit_mask & stripe[k].stripe_r->xi) << 3)) >> l;
-                     
-                     xi_v = ((bit_mask & (stripe[k].sigma >> 1))       | ((bit_mask & (stripe[k].xi >> 1)) << 2) |
-                            ((bit_mask & (stripe[k].sigma << 1)) << 1) | ((bit_mask & (stripe[k].xi << 1)) << 3)) >> l;
-
-                     if(l == 3)
-                     {
-                        xi_v |= ((0x01 & stripe[k].stripe_u->sigma) | ((0x01 & stripe[k].stripe_u->xi) << 2));
-                     }
-
-                     xi_h = SIG2XI[xi_h];
-                     xi_v = SIG2XI[xi_v];
                
                      stripe[k].xi |= ((XI2CONT[(xi_h << 2) | xi_v][1] ^ mq_bit_decode(coder->bitcoder, XI2CONT[(xi_h << 2) | xi_v][0])) << l);
 
@@ -2274,12 +1995,12 @@ compute_convex_hull(bwc_encoded_cblk *const encoded_codeblock, double *const mse
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: bwc_encoded_cblk* encode_codeblock(bwc_field *const field, bwc_cblk_access *const access, !
+!   FUNCTION NAME: void encode_codeblock(bwc_codec *const codec, bwc_cblk_access *const access,              !
 !   --------------                                                        bwc_coder_stripe *const codeblock, !
 !                                                                                       const uint64  width, !
 !                                                                                       const uint64 height, !
 !                                                                                       const uint64  depth, !
-!                                                                                       const uint16     dt) !
+!                                                                                       const uint64     dt) !
 !                                                                                                            !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -2307,12 +2028,12 @@ compute_convex_hull(bwc_encoded_cblk *const encoded_codeblock, double *const mse
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 static void
-encode_codeblock(bwc_field *const field, bwc_cblk_access  *const access,
+encode_codeblock(bwc_codec *const codec, bwc_cblk_access  *const access,
                                       bwc_coder_stripe *const codeblock,
                                                     const uint64  width,
                                                     const uint64 height,
                                                     const uint64  depth,
-                                                    const uint16     dt)
+                                                    const uint64     dt)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
@@ -2340,7 +2061,7 @@ encode_codeblock(bwc_field *const field, bwc_cblk_access  *const access,
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(access);
    assert(codeblock);
    assert(access->subband->control.highband_flag <= 15);
@@ -2359,7 +2080,7 @@ encode_codeblock(bwc_field *const field, bwc_cblk_access  *const access,
    ! info and encoded block structure to temporary variables  !
    ! to make the code more readable.                          !
    \*--------------------------------------------------------*/
-   control       = &field->control;
+   control       = &codec->control;
 
    subb_ctrl     = &access->subband->control;
    subb_inf      = &access->subband->info;
@@ -2595,12 +2316,12 @@ encode_codeblock(bwc_field *const field, bwc_cblk_access  *const access,
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: bwc_encoded_cblk* encode_codeblock(bwc_field *const field, bwc_cblk_access *const access, !
+!   FUNCTION NAME: void decode_codeblock(bwc_codec *const codec, bwc_cblk_access *const access,              !
 !                                                                         bwc_coder_stripe *const codeblock, !
 !                                                                                       const uint64  width, !
 !                                                                                       const uint64 height, !
 !                                                                                       const uint64  depth, !
-!                                                                                       const uint16     dt) !
+!                                                                                       const uint64     dt) !
 !   --------------                                                                                           !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -2628,12 +2349,12 @@ encode_codeblock(bwc_field *const field, bwc_cblk_access  *const access,
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 static void
-decode_codeblock(bwc_field *const field, bwc_cblk_access *const access,
+decode_codeblock(bwc_codec *const codec, bwc_cblk_access *const access,
                                      bwc_coder_stripe *const codeblock,
                                                    const uint64  width,
                                                    const uint64 height,
                                                    const uint64  depth,
-                                                   const uint16     dt)
+                                                   const uint64     dt)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
@@ -2652,7 +2373,7 @@ decode_codeblock(bwc_field *const field, bwc_cblk_access *const access,
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(access);
    assert(codeblock);
    assert(access->subband->control.highband_flag <= 15);
@@ -2671,7 +2392,7 @@ decode_codeblock(bwc_field *const field, bwc_cblk_access *const access,
    ! structure to temporary variables to make the code more   !
    ! readable.                                                !
    \*--------------------------------------------------------*/
-   control       = &field->control;
+   control       = &codec->control;
 
    subb_ctrl     = &access->subband->control;
 
@@ -2828,20 +2549,19 @@ decode_codeblock(bwc_field *const field, bwc_cblk_access *const access,
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 uchar
-t1_encode(bwc_field *const field, bwc_tile *const tile, bwc_parameter *const parameter)
+t1_encode(bwc_codec *const codec, bwc_tile *const tile, bwc_parameter *const parameter)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
    \*-----------------------*/
    uint64   c;
-   uint64   cbSizeX, cbSizeY, cbSizeZ;
+   uint64   cbSizeX, cbSizeY, cbSizeZ, cbSizeTS;
    uint64   width, height, depth;
 
    int64    buff_size;
    int64    i, j;
    int64    nThreads;
 
-   uint16   cbSizeTS;
    uint16   slope_max, slope_min;
    int16    z;
 
@@ -2857,7 +2577,7 @@ t1_encode(bwc_field *const field, bwc_tile *const tile, bwc_parameter *const par
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(tile);
    assert(parameter);
 
@@ -2865,7 +2585,7 @@ t1_encode(bwc_field *const field, bwc_tile *const tile, bwc_parameter *const par
    ! Save the global control structure to a temporary varia-  !
    ! ble to make the code more readable.                      !
    \*--------------------------------------------------------*/
-   control = &field->control;
+   control = &codec->control;
 
    /*--------------------------------------------------------*\
    ! Save the minimum and maximum slope values for the cur-   !
@@ -3040,7 +2760,7 @@ t1_encode(bwc_field *const field, bwc_tile *const tile, bwc_parameter *const par
          ! truncation points (L) and possible slope values (S) in   !
          ! the bwc_encoded_cblk structure.                          !
          \*--------------------------------------------------------*/
-         encode_codeblock(field, &parameter->access[c], working_buffer, 
+         encode_codeblock(codec, &parameter->access[c], working_buffer, 
                                                         cbSizeX, cbSizeY,
                                                         cbSizeZ, cbSizeTS);
 
@@ -3131,21 +2851,19 @@ t1_encode(bwc_field *const field, bwc_tile *const tile, bwc_parameter *const par
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 uchar
-t1_decode(bwc_field *const field, bwc_tile *const tile, bwc_parameter *const parameter)
+t1_decode(bwc_codec *const codec, bwc_tile *const tile, bwc_parameter *const parameter)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
    \*-----------------------*/
    uint64   c;
-   uint64   cbSizeX, cbSizeY, cbSizeZ;
+   uint64   cbSizeX, cbSizeY, cbSizeZ, cbSizeTS;
    uint64   width, height, depth;
 
    int64    buff_size;
    int64    i, j;
    int64    nThreads;
 
-   uint16   cbSizeTS;
-
    /*-----------------------*\
    ! DEFINE STRUCTS:         !
    \*-----------------------*/
@@ -3159,7 +2877,7 @@ t1_decode(bwc_field *const field, bwc_tile *const tile, bwc_parameter *const par
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(tile);
    assert(parameter);
 
@@ -3167,7 +2885,7 @@ t1_decode(bwc_field *const field, bwc_tile *const tile, bwc_parameter *const par
    ! Save the global control structure to a temporary varia-  !
    ! ble to make the code more readable.                      !
    \*--------------------------------------------------------*/
-   control = &field->control;
+   control = &codec->control;
 
    /*--------------------------------------------------------*\
    ! Evaluate the width, height and depth of the current      !
@@ -3332,7 +3050,7 @@ t1_decode(bwc_field *const field, bwc_tile *const tile, bwc_parameter *const par
 
          if(codeblock->encoded_block->Z > 0)
          {
-            decode_codeblock(field, &parameter->access[c], working_buffer, 
+            decode_codeblock(codec, &parameter->access[c], working_buffer, 
                                                            cbSizeX, cbSizeY,
                                                            cbSizeZ, cbSizeTS);
          }

src/library/tier2.c

@@ -16,7 +16,7 @@
 ||  ------------                                                                                  ||
 ||                                                                                                ||
 ||        This file describes a set of functions that can be used to de-/encode bwc               ||
-||        codeblocks described by the bwc_field structure according to the embedded block         ||
+||        codeblocks described by the bwc_codec structure according to the embedded block         ||
 ||        coding paradigm described by the JPEG 2000 standard. For more information please        ||
 ||        refere to JPEG2000 by D. S. Taubman and M. W. Marcellin.                                ||
 ||                                                                                                ||
@@ -312,7 +312,7 @@ encode_length(bitstream *const header, bwc_codeblock *const codeblock,
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: void create_quality_layers(bwc_field *const field, bwc_tile *const tile)                  !
+!   FUNCTION NAME:                                                                                           !
 !   --------------                                                                                           !
 !                                                                                                            !
 !                                                                                                            !
@@ -385,9 +385,8 @@ decode_length(bitstream *const header, bwc_codeblock *const codeblock, int8 cons
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: int64 create_packet(bwc_field *const field, bwc_tile       *const tile,                   !
+!   FUNCTION NAME: int64 create_packet(bwc_tile *const tile, bwc_resolution *const resolution,               !
-!   --------------                                             bwc_resolution *const resolution,             !
+!   --------------                                           uint32          const prec_idx,                 !
-!                                                              uint32          const prec_idx,               !
 !                                                            int8            const q_layer,                  !
 !                                                            uchar           const est)                      !
 !                                                                                                            !
@@ -403,9 +402,6 @@ decode_length(bitstream *const header, bwc_codeblock *const codeblock, int8 cons
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
-!                                                                    decompression stage.                    !
-!                                                                                                            !
 !                tile                        bwc_tile*             - Structure defining a bwc tile.          !
 !                                                                                                            !
 !                resolution                  bwc_resolution*       - Structure defining a bwc resolution     !
@@ -435,8 +431,7 @@ decode_length(bitstream *const header, bwc_codeblock *const codeblock, int8 cons
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 static int32
-create_packet(bwc_field *const field, bwc_tile       *const tile, 
+create_packet(bwc_tile *const tile, bwc_resolution *const resolution,
-                                      bwc_resolution *const resolution,
                                     uint32          const prec_idx,
                                     int16           const q_layer,
                                     uchar           const est)
@@ -450,6 +445,7 @@ create_packet(bwc_field *const field, bwc_tile       *const tile,
    int16   *cp_contr;
    int16    delta_z;
    int8     m;
+   uchar   *memory;
 
    /*-----------------------*\
    ! DEFINE STRUCTS:         !
@@ -462,7 +458,6 @@ create_packet(bwc_field *const field, bwc_tile       *const tile,
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
    assert(tile);
    assert(resolution);
 
@@ -482,7 +477,14 @@ create_packet(bwc_field *const field, bwc_tile       *const tile,
       ! Initialize the stream that is used to assemble the pack- !
       ! et header.                                               !
       \*--------------------------------------------------------*/
-      header = init_stream(NULL, PACKET_HEADER_SIZE, 'c');
+      memory = calloc(PACKET_HEADER_SIZE, sizeof(uchar));
+      if(!memory)
+      {
+        // memory allocation error
+        fprintf(stderr, MEMERROR);
+        return -1;
+      }
+      header = init_bitstream(memory, PACKET_HEADER_SIZE, 'c');
       if(!header)
       {
          // memory allocation error
@@ -498,7 +500,7 @@ create_packet(bwc_field *const field, bwc_tile       *const tile,
       if(!est)
       {
          packet->body.access = 
-         packet->body.memory = calloc(packet->body.size, sizeof(bwc_stream));
+         packet->body.memory = calloc(packet->body.size, sizeof(bwc_span));
          if(!packet->body.memory)
          {
             // memory allocation error
@@ -644,7 +646,8 @@ create_packet(bwc_field *const field, bwc_tile       *const tile,
          }
 
          k = header->L;
-         terminate_stream(header, NULL);
+         free(header->memory);
+         free(header);
          return k;
       }
       /*--------------------------------------------------------*\
@@ -655,11 +658,13 @@ create_packet(bwc_field *const field, bwc_tile       *const tile,
       \*--------------------------------------------------------*/
       else
       {
-         if(terminate_stream(header, &packet->header))
+         if(shrink_to_fit(header))
          {
             // memory allocation error
             return -1;
          }
+         transfer_to_span(header, &packet->header);
+         free(header);
 
          packet->size = packet->body.size + packet->header.size;
 
@@ -706,7 +711,7 @@ create_packet(bwc_field *const field, bwc_tile       *const tile,
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: uchar create_packets(bwc_field *const field, bwc_tile *const tile)                        !
+!   FUNCTION NAME: uchar create_packets(bwc_codec *const codec, bwc_tile *const tile)                        !
 !   --------------                                                                                           !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -723,7 +728,7 @@ create_packet(bwc_field *const field, bwc_tile       *const tile,
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
+!                codec                       bwc_codec*            - Structure defining the compression/     !
 !                                                                    decompression stage.                    !
 !                                                                                                            !
 !                tile                        bwc_tile*             - Structure defining a bwc tile.          !
@@ -743,7 +748,7 @@ create_packet(bwc_field *const field, bwc_tile       *const tile,
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 static uchar
-create_packets(bwc_field *const field, bwc_tile *const tile)
+create_packets(bwc_codec *const codec, bwc_tile *const tile)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
@@ -764,15 +769,15 @@ create_packets(bwc_field *const field, bwc_tile *const tile)
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(tile);
 
    /*--------------------------------------------------------*\
    ! Save the global control and info structure to temporary  !
    ! variables to make the code more readable.                !
    \*--------------------------------------------------------*/
-   control = &field->control;
+   control = &codec->control;
-   info    =  field->info;
+   info    = &codec->info;
 
    /*--------------------------------------------------------*\
    ! Iterate overall quality layers for every precinct in all !
@@ -799,7 +804,7 @@ create_packets(bwc_field *const field, bwc_tile *const tile)
          {
             for(l = 0; l < control->nLayers; ++l)
             {
-               if(create_packet(field, tile, resolution, p, l, 0) < 0)
+               if(create_packet(tile, resolution, p, l, 0) < 0)
                {
                   // memory allocation error
                   return 1;
@@ -845,7 +850,7 @@ create_packets(bwc_field *const field, bwc_tile *const tile)
 
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: int64 create_quality_layer(bwc_field *const field, bwc_tile *const tile,                  !
+!   FUNCTION NAME: int64 create_quality_layer(bwc_codec *const codec, bwc_tile *const tile,                  !
 !   --------------                                                    uint16    const threshold,             !
 !                                                                     int16     const q_layer,               !
 !                                                                     uchar     const est)                   !
@@ -860,7 +865,7 @@ create_packets(bwc_field *const field, bwc_tile *const tile)
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
+!                codec                       bwc_codec*            - Structure defining the compression/     !
 !                                                                    decompression stage.                    !
 !                                                                                                            !
 !                tile                        bwc_tile*             - Structure defining a bwc tile.          !
@@ -888,7 +893,7 @@ create_packets(bwc_field *const field, bwc_tile *const tile)
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 static int64
-create_quality_layer(bwc_field *const field, bwc_tile *const tile,
+create_quality_layer(bwc_codec *const codec, bwc_tile *const tile,
                                              uint16    const threshold,
                                              int16     const q_layer,
                                              uchar     const est)
@@ -916,15 +921,15 @@ create_quality_layer(bwc_field *const field, bwc_tile *const tile,
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(tile);
 
    /*--------------------------------------------------------*\
    ! Save the global control and info structure to temporary  !
    ! variables to make the code more readable.                !
    \*--------------------------------------------------------*/
-   control = &field->control;
+   control = &codec->control;
-   info    =  field->info;
+   info    = &codec->info;
 
    for(j = 0, estimated_ql_size = 0; j < info->nPar; ++j)
    {
@@ -1056,7 +1061,7 @@ create_quality_layer(bwc_field *const field, bwc_tile *const tile,
 
          for(p = 0; p < resolution->control.number_of_precincts; ++p)
          {
-            estimated_ph_size = create_packet(field, tile, resolution, p, q_layer, est + 1);
+            estimated_ph_size = create_packet(tile, resolution, p, q_layer, est + 1);
 
             if(estimated_ph_size < 0)
             {
@@ -1075,7 +1080,7 @@ create_quality_layer(bwc_field *const field, bwc_tile *const tile,
 
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: void create_quality_layers(bwc_field *const field, bwc_tile *const tile)                  !
+!   FUNCTION NAME: void create_quality_layers(bwc_codec *const codec, bwc_tile *const tile)                  !
 !   --------------                                                                                           !
 !                                                                                                            !
 !                                                                                                            !
@@ -1087,7 +1092,7 @@ create_quality_layer(bwc_field *const field, bwc_tile *const tile,
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
+!                codec                       bwc_codec*            - Structure defining the compression/     !
 !                                                                    decompression stage.                    !
 !                                                                                                            !
 !                tile                        bwc_tile*             - Structure defining a bwc tile.          !
@@ -1107,7 +1112,7 @@ create_quality_layer(bwc_field *const field, bwc_tile *const tile,
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 static uchar
-create_quality_layers(bwc_field *const field, bwc_tile *const tile)
+create_quality_layers(bwc_codec *const codec, bwc_tile *const tile)
 {
    /*-----------------------*\
    ! DEFINE INT VARIABLES:   !
@@ -1131,15 +1136,15 @@ create_quality_layers(bwc_field *const field, bwc_tile *const tile)
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(tile);
 
    /*--------------------------------------------------------*\
    ! Save the global and tile control and info structure to   !
    ! temporary variables to make the code more readable.      !
    \*--------------------------------------------------------*/
-   control = &field->control;
+   control = &codec->control;
-   info    =  field->info;
+   info    = &codec->info;
 
    tile_control = &tile->control;
    tile_info    = &tile->info;
@@ -1189,7 +1194,7 @@ create_quality_layers(bwc_field *const field, bwc_tile *const tile)
          {
             slope = (slope_max + slope_min) >> 1;
             
-            estimated_ql_size = create_quality_layer(field, tile, slope, l, 1);
+            estimated_ql_size = create_quality_layer(codec, tile, slope, l, 1);
 
             if(estimated_ql_size >= 0)
             {
@@ -1234,7 +1239,7 @@ create_quality_layers(bwc_field *const field, bwc_tile *const tile)
          slope = 0;
       }
 
-      estimated_ql_size = create_quality_layer(field, tile, slope, l, 0);
+      estimated_ql_size = create_quality_layer(codec, tile, slope, l, 0);
 
       if(estimated_ql_size >= 0)
       {
@@ -1255,7 +1260,7 @@ create_quality_layers(bwc_field *const field, bwc_tile *const tile)
 ||                                                                                                          ||
 \************************************************************************************************************/
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: uchar   t2_encode(bwc_field *const field, bwc_tile *const tile)                           !
+!   FUNCTION NAME: uchar   t2_encode(bwc_codec *const codec, bwc_tile *const tile)                           !
 !   --------------                                                                                           !
 !                                                                                                            !
 !   DESCRIPTION:                                                                                             !
@@ -1269,7 +1274,7 @@ create_quality_layers(bwc_field *const field, bwc_tile *const tile)
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
+!                codec                       bwc_codec*            - Structure defining the compression/     !
 !                                                                    decompression stage.                    !
 !                                                                                                            !
 !                tile                        bwc_tile*             - Structure defining a bwc tile.          !
@@ -1289,19 +1294,19 @@ create_quality_layers(bwc_field *const field, bwc_tile *const tile)
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 uchar
-t2_encode(bwc_field *const field, bwc_tile *const tile)
+t2_encode(bwc_codec *const codec, bwc_tile *const tile)
 {
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(tile);
 
    /*--------------------------------------------------------*\
    ! Create the quality layers according to the bitrate val-  !
    ! ues provided by the user.                                !
    \*--------------------------------------------------------*/
-   if(create_quality_layers(field, tile))
+   if(create_quality_layers(codec, tile))
    {
       return 1;
    }
@@ -1310,7 +1315,7 @@ t2_encode(bwc_field *const field, bwc_tile *const tile)
    ! Create the data packets according to the quality layers  !
    ! evaluated in the previous step.                          !
    \*--------------------------------------------------------*/
-   if(create_packets(field, tile))
+   if(create_packets(codec, tile))
    {
       return 1;
    }
@@ -1319,7 +1324,7 @@ t2_encode(bwc_field *const field, bwc_tile *const tile)
 }
 
 /*----------------------------------------------------------------------------------------------------------*\
-!   FUNCTION NAME: uchar parse_packet(bwc_field *const field, bwc_tile   *const tile,                        !
+!   FUNCTION NAME: uchar parse_packet(bwc_codec *const codec, bwc_tile   *const tile,                        !
 !   --------------                                            bwc_packet *const packet,                      !
 !                                                             uint64      const body_size)                   !
 !                                                                                                            !
@@ -1332,7 +1337,7 @@ t2_encode(bwc_field *const field, bwc_tile *const tile)
 !   -----------                                                                                              !
 !                Variable                    Type                    Description                             !
 !                --------                    ----                    -----------                             !
-!                field                       bwc_field*            - Structure defining the compression/     !
+!                codec                       bwc_codec*            - Structure defining the compression/     !
 !                                                                    decompression stage.                    !
 !                                                                                                            !
 !                tile                        bwc_tile*             - Structure defining a bwc tile.          !
@@ -1356,7 +1361,7 @@ t2_encode(bwc_field *const field, bwc_tile *const tile)
 !                                                                                                            !
 \*----------------------------------------------------------------------------------------------------------*/
 uchar
-parse_packet(bwc_field *const field, bwc_tile   *const tile, 
+parse_packet(bwc_codec *const codec, bwc_tile   *const tile, 
                                      bwc_packet *const packet, 
                                      uint64      const body_size)
 {
@@ -1382,7 +1387,7 @@ parse_packet(bwc_field *const field, bwc_tile   *const tile,
    /*-----------------------*\
    ! DEFINE ASSERTIONS:      !
    \*-----------------------*/
-   assert(field);
+   assert(codec);
    assert(tile);
    assert(packet);
 
@@ -1392,7 +1397,7 @@ parse_packet(bwc_field *const field, bwc_tile   *const tile,
    ! Initialize the stream that is used to parse the packet   !
    ! codestream.                                              !
    \*--------------------------------------------------------*/
-   header = init_stream(packet->header.memory, body_size, 'd');
+   header = init_bitstream(packet->header.memory, body_size, 'd');
    if(!header)
    {
       // memory allocation error
@@ -1572,7 +1577,7 @@ parse_packet(bwc_field *const field, bwc_tile   *const tile,
    ! If the error resilience mode is active for the current   !
    ! codestream...                                            !
    \*--------------------------------------------------------*/
-   if(field->control.error_resilience)
+   if(codec->control.error_resilience)
    {
       /*--------------------------------------------------------*\
       ! check if the next symbol corresponds to the end of pack- !