Bug fixes. There are other bugs for 32 lossless.

Author: aous72

src/core/codestream/ojph_bitbuffer_write.h

@@ -109,33 +109,25 @@ namespace ojph {
       }
     }
 
+    //////////////////////////////////////////////////////////////////////////
+    static inline
+    void bb_put_zeros(bit_write_buf *bbp, int num_zeros,
+                      mem_elastic_allocator *elastic,
+                      coded_lists*& cur_coded_list, ui32& ph_bytes)
+    {
+      for (int i = num_zeros; i > 0; --i)
+        bb_put_bit(bbp, 0, elastic, cur_coded_list, ph_bytes);
+    }
+
     //////////////////////////////////////////////////////////////////////////
     static inline
     void bb_put_bits(bit_write_buf *bbp, ui32 data, int num_bits,
                      mem_elastic_allocator *elastic,
                      coded_lists*& cur_coded_list, ui32& ph_bytes)
     {
-//      assert(num_bits <= 32);
-      for (int i = num_bits - 1; i >= 0; --i)
+      assert(num_bits <= 32);
+      for (int i = num_bits - 1; i >= 0; --i) 
         bb_put_bit(bbp, data >> i, elastic, cur_coded_list, ph_bytes);
-//      while (num_bits) {
-//        int tx_bits = num_bits < bbp->avail_bits ? num_bits : bbp->avail_bits;
-//        bbp->tmp |= (data >> (num_bits - tx_bits)) & ((1 << tx_bits) - 1);
-//        bbp->avail_bits -= tx_bits;
-//        if (bbp->avail_bits <= 0)
-//        {
-//          bbp->avail_bits = 8 - (bbp->tmp != 0xFF ? 0 : 1);
-//          bbp->buf[bbp->buf_size - bbp->avail_size] = (ui8)(bbp->tmp & 0xFF);
-//          bbp->tmp = 0;
-//          --bbp->avail_size;
-//          if (bbp->avail_size == 0)
-//          {
-//            bb_expand_buf(bbp, elastic, cur_coded_list->next_list);
-//            cur_coded_list = cur_coded_list->next_list;
-//            ph_bytes += bit_buffer::needed;
-//          }
-//        }
-//      }
     }
 
     //////////////////////////////////////////////////////////////////////////

src/core/codestream/ojph_params.cpp

@@ -952,16 +952,16 @@ namespace ojph {
       int s = 0;
       double bibo_l = bibo_gains::get_bibo_gain_l(num_decomps, true);
       ui32 X = (ui32) ceil(log(bibo_l * bibo_l) / M_LN2);
-      u8_SPqcd[s++] = (ui8)((B + X) << 3);
+      u8_SPqcd[s++] = (ui8)((B + X) << reversible_SPqcd_shift);
       for (ui32 d = num_decomps; d > 0; --d)
       {
         double bibo_l = bibo_gains::get_bibo_gain_l(d, true);
         double bibo_h = bibo_gains::get_bibo_gain_h(d - 1, true);
         X = (ui32) ceil(log(bibo_h * bibo_l) / M_LN2);
-        u8_SPqcd[s++] = (ui8)((B + X) << 3);
-        u8_SPqcd[s++] = (ui8)((B + X) << 3);
+        u8_SPqcd[s++] = (ui8)((B + X) << reversible_SPqcd_shift);
+        u8_SPqcd[s++] = (ui8)((B + X) << reversible_SPqcd_shift);
         X = (ui32) ceil(log(bibo_h * bibo_h) / M_LN2);
-        u8_SPqcd[s++] = (ui8)((B + X) << 3);
+        u8_SPqcd[s++] = (ui8)((B + X) << reversible_SPqcd_shift);
       }
     }
 
@@ -1017,8 +1017,11 @@ namespace ojph {
       ui32 B = 0;
       int irrev = Sqcd & 0x1F;
       if (irrev == 0) //reversible
-        for (ui32 i = 0; i < num_subbands; ++i)
-          B = ojph_max(B, (u8_SPqcd[i] >> 3) + get_num_guard_bits() - 1u);
+        for (ui32 i = 0; i < num_subbands; ++i) {
+          ui32 t = (u8_SPqcd[i] >> reversible_SPqcd_shift);
+          t += get_num_guard_bits() - 1u;
+          B = ojph_max(B, t);
+        }
       else if (irrev == 2) //scalar expounded
         for (ui32 i = 0; i < num_subbands; ++i)
         {
@@ -1088,9 +1091,9 @@ namespace ojph {
       }
 
       int irrev = Sqcd & 0x1F;
-      if (irrev == 0) //reversible; this is (10.22) from the J2K book
+      if (irrev == 0) // reversible; this is (10.22) from the J2K book
       {
-        num_bits += u8_SPqcd[idx] >> 3;
+        num_bits += u8_SPqcd[idx] >> reversible_SPqcd_shift;
         num_bits = num_bits == 0 ? 0 : num_bits - 1;
       }
       else if (irrev == 1)

src/core/codestream/ojph_params_local.h

@@ -590,7 +590,7 @@ namespace ojph {
     {
       friend ::ojph::param_qcd;
     public:
-      param_qcd()
+      param_qcd() : reversible_SPqcd_shift(3)
       { 
         Lqcd = 0;
         Sqcd = 0;
@@ -646,6 +646,7 @@ namespace ojph {
     protected:
       ui16 Lqcd;
       ui8 Sqcd;
+      const ui8 reversible_SPqcd_shift;
       union
       {
         ui8 u8_SPqcd[97];

src/core/codestream/ojph_precinct.cpp

@@ -221,7 +221,9 @@ namespace ojph {
               {
                 int num_zeros = *mmsb_tag.get(x>>levm1, y>>levm1, levm1);
                 num_zeros -= *mmsb_tag.get(x>>cur_lev, y>>cur_lev, cur_lev);
-                bb_put_bits(&bb, 1, num_zeros + 1,
+                bb_put_zeros(&bb, num_zeros,
+                  elastic, cur_coded_list, ph_bytes);
+                bb_put_bits(&bb, 1, 1,
                   elastic, cur_coded_list, ph_bytes);
                 *mmsb_tag_flags.get(x>>levm1, y>>levm1, levm1) = 1;
               }

src/core/coding/ojph_block_encoder.cpp

@@ -1021,8 +1021,21 @@ namespace ojph {
     {
       assert(num_passes == 1);
       (void)num_passes;                      //currently not used
-      const int ms_size = (16384*16+14)/15;  //more than enough
+      // 38 bits/sample + 1 color + 4 wavelet = 43 bits per sample.
+      // * 4096 samples / 8 bits per byte = 22016; then rounded up to the 
+      // nearest 1 kB, givin 22528.  This expanded further to take into 
+      // consideration stuffing at a max rate of 16 bits per 15 bits 
+      // (1 bit for every 15 bits of data); in reality, it is much smaller
+      // than this.
+      const int ms_size = (22528 * 16 + 14) / 15;  //more than enough
       ui8 ms_buf[ms_size];
+      // For each quad, we need at most, 7 bits for VLC and 12 bits for UVLC.
+      // So we have 1024 quads * 19 / 8, which is 2432.  This must be 
+      // multiplied by 16 / 15 to accommodate stuffing.  
+      // The mel is at most around 1 bit/quad, giving around 128 byte -- in
+      // practice there was on case where it got to 132 bytes.  Even 
+      // accounting for stuffing, it is smaller than 192.  Therefore,
+      // 3072 is more than enough
       const int mel_vlc_size = 3072;         //more than enough
       ui8 mel_vlc_buf[mel_vlc_size];
       const int mel_size = 192;