Add support for Qfactor (#308)

* First pass at adding Qfactor

* Fixes

* Added chroma format

* Added tests

* Added 4:2:0 test

* Fix error codes

* Change *.hpp to *.h

* Assign type to param_qcd::comp_type

* Change set_qfactor() signature

Author: palemieux

src/apps/ojph_compress/ojph_compress.cpp

@@ -361,7 +361,7 @@ static
 bool get_arguments(int argc, char *argv[], char *&input_filename,
                    char *&output_filename, char *&progression_order,
                    char *&profile_string, ojph::ui32 &num_decompositions,
-                   float &quantization_step, bool &reversible,
+                   float &quantization_step, int &qfactor, bool &reversible,
                    int &employ_color_transform,
                    const int max_num_precincts, int &num_precincts,
                    ojph::size *precinct_size, ojph::size& block_size,
@@ -383,6 +383,7 @@ bool get_arguments(int argc, char *argv[], char *&input_filename,
   interpreter.reinterpret("-profile", profile_string);
   interpreter.reinterpret("-num_decomps", num_decompositions);
   interpreter.reinterpret("-qstep", quantization_step);
+  interpreter.reinterpret("-qfactor", qfactor);
   interpreter.reinterpret("-reversible", reversible);
   interpreter.reinterpret_to_bool("-colour_trans", employ_color_transform);
   interpreter.reinterpret("-num_comps", num_comps);
@@ -498,6 +499,7 @@ int main(int argc, char * argv[]) {
   char *com_string = NULL;
   ojph::ui32 num_decompositions = 5;
   float quantization_step = -1.0f;
+  int qfactor = -1;
   bool reversible = false;
   int employ_color_transform = -1;
 
@@ -542,6 +544,10 @@ int main(int argc, char * argv[]) {
     "               compression; quantization steps size for all subbands are\n"
     "               derived from this value. {The default value for 8bit\n"
     "               images is 0.0039}\n"
+    " -qfactor      (1...100) compression quality factor; 1 is worst\n"
+    "               quality and 100 is best quality. Only valid for\n"
+    "               images with 1 or 3 components. Cannot be used\n"
+    "               together with -qstep.\n"
     " -reversible   <true | false> If this is 'false', an irreversible or\n"
     "               lossy compression is employed, using the 9/7 wavelet\n"
     "               transform; if 'true', a reversible compression is\n"
@@ -622,7 +628,8 @@ int main(int argc, char * argv[]) {
   }
   if (!get_arguments(argc, argv, input_filename, output_filename,
                      prog_order, profile_string, num_decompositions,
-                     quantization_step, reversible, employ_color_transform,
+                     quantization_step, qfactor, reversible,
+                     employ_color_transform,
                      max_precinct_sizes, num_precincts, precinct_size,
                      block_size, dims, image_offset, tile_size, tile_offset,
                      max_num_comps, num_components,
@@ -634,6 +641,13 @@ int main(int argc, char * argv[]) {
     return -1;
   }
 
+  if (qfactor != -1 && quantization_step != -1.0f)
+    OJPH_ERROR(0x010000A1,
+      "-qfactor and -qstep cannot be used together\n");
+  if (qfactor != -1 && (qfactor < 1 || qfactor > 100))
+    OJPH_ERROR(0x010000A2,
+      "-qfactor must be between 1 and 100\n");
+
   clock_t begin = clock();
 
   try
@@ -686,6 +700,9 @@ int main(int argc, char * argv[]) {
         cod.set_reversible(reversible);
         if (!reversible && quantization_step != -1.0f)
           codestream.access_qcd().set_irrev_quant(quantization_step);
+        if (!reversible && qfactor != -1)
+          codestream.access_qcd().set_qfactor(0,
+            ojph::param_qcd::OJPH_COMP_Y, (ojph::ui8)qfactor);
         if (profile_string[0] != '\0')
           codestream.set_profile(profile_string);
         codestream.set_tilepart_divisions(tileparts_at_resolutions,
@@ -742,6 +759,12 @@ int main(int argc, char * argv[]) {
         cod.set_reversible(reversible);
         if (!reversible && quantization_step != -1.0f)
           codestream.access_qcd().set_irrev_quant(quantization_step);
+        if (!reversible && qfactor != -1) {
+          ojph::param_qcd qcd = codestream.access_qcd();
+          qcd.set_qfactor(0, ojph::param_qcd::OJPH_COMP_Y, (ojph::ui8)qfactor);
+          qcd.set_qfactor(1, ojph::param_qcd::OJPH_COMP_CB, (ojph::ui8)qfactor);
+          qcd.set_qfactor(2, ojph::param_qcd::OJPH_COMP_CR, (ojph::ui8)qfactor);
+        }
         codestream.set_planar(false);
         if (profile_string[0] != '\0')
           codestream.set_profile(profile_string);
@@ -820,7 +843,20 @@ int main(int argc, char * argv[]) {
             cod.set_color_transform(employ_color_transform == 1);
         }
         cod.set_reversible(reversible);
-        if (!reversible) {
+        if (!reversible && qfactor != -1) {
+          ojph::param_qcd qcd = codestream.access_qcd();
+          if (num_comps == 1) {
+            qcd.set_qfactor(0,
+              ojph::param_qcd::OJPH_COMP_Y, (ojph::ui8)qfactor);
+          } else {
+            qcd.set_qfactor(0,
+              ojph::param_qcd::OJPH_COMP_Y, (ojph::ui8)qfactor);
+            qcd.set_qfactor(1,
+              ojph::param_qcd::OJPH_COMP_CB, (ojph::ui8)qfactor);
+            qcd.set_qfactor(2,
+              ojph::param_qcd::OJPH_COMP_CR, (ojph::ui8)qfactor);
+          }
+        } else if (!reversible) {
           const float min_step = 1.0f / 16384.0f;
           if (quantization_step == -1.0f)
             quantization_step = min_step;
@@ -898,6 +934,24 @@ int main(int argc, char * argv[]) {
         cod.set_reversible(reversible);
         if (!reversible && quantization_step != -1)
           codestream.access_qcd().set_irrev_quant(quantization_step);
+        if (!reversible && qfactor != -1) {
+          if (num_comps != 1 && num_comps != 3)
+            OJPH_ERROR(0x010000A3,
+              "-qfactor is only supported for images with 1 or 3 "
+              "components\n");
+          ojph::param_qcd qcd = codestream.access_qcd();
+          if (num_comps == 1) {
+            qcd.set_qfactor(0,
+              ojph::param_qcd::OJPH_COMP_Y, (ojph::ui8)qfactor);
+          } else {
+            qcd.set_qfactor(0,
+              ojph::param_qcd::OJPH_COMP_Y, (ojph::ui8)qfactor);
+            qcd.set_qfactor(1,
+              ojph::param_qcd::OJPH_COMP_CB, (ojph::ui8)qfactor);
+            qcd.set_qfactor(2,
+              ojph::param_qcd::OJPH_COMP_CR, (ojph::ui8)qfactor);
+          }
+        }
         codestream.set_planar(false);
         if (profile_string[0] != '\0')
           codestream.set_profile(profile_string);
@@ -983,6 +1037,24 @@ int main(int argc, char * argv[]) {
         cod.set_reversible(reversible);
         if (!reversible && quantization_step != -1.0f)
           codestream.access_qcd().set_irrev_quant(quantization_step);
+        if (!reversible && qfactor != -1) {
+          if (num_components != 1 && num_components != 3)
+            OJPH_ERROR(0x010000A4,
+              "-qfactor is only supported for images with 1 or 3 "
+              "components\n");
+          ojph::param_qcd qcd = codestream.access_qcd();
+          if (num_components == 1) {
+            qcd.set_qfactor(0,
+              ojph::param_qcd::OJPH_COMP_Y, (ojph::ui8)qfactor);
+          } else {
+            qcd.set_qfactor(0,
+              ojph::param_qcd::OJPH_COMP_Y, (ojph::ui8)qfactor);
+            qcd.set_qfactor(1,
+              ojph::param_qcd::OJPH_COMP_CB, (ojph::ui8)qfactor);
+            qcd.set_qfactor(2,
+              ojph::param_qcd::OJPH_COMP_CR, (ojph::ui8)qfactor);
+          }
+        }
         codestream.set_planar(true);
         if (profile_string[0] != '\0')
           codestream.set_profile(profile_string);
@@ -1035,6 +1107,9 @@ int main(int argc, char * argv[]) {
         cod.set_reversible(reversible);
         if (!reversible && quantization_step != -1.0f)
           codestream.access_qcd().set_irrev_quant(quantization_step);
+        if (!reversible && qfactor != -1)
+          codestream.access_qcd().set_qfactor(0,
+            ojph::param_qcd::OJPH_COMP_Y, (ojph::ui8)qfactor);
         codestream.set_planar(true);
         if (profile_string[0] != '\0')
           codestream.set_profile(profile_string);
@@ -1075,6 +1150,24 @@ int main(int argc, char * argv[]) {
         cod.set_reversible(reversible);
         if (!reversible && quantization_step != -1)
           codestream.access_qcd().set_irrev_quant(quantization_step);
+        if (!reversible && qfactor != -1) {
+          if (num_comps != 1 && num_comps != 3)
+            OJPH_ERROR(0x010000A5,
+              "-qfactor is only supported for images with 1 or 3 "
+              "components\n");
+          ojph::param_qcd qcd = codestream.access_qcd();
+          if (num_comps == 1) {
+            qcd.set_qfactor(0,
+              ojph::param_qcd::OJPH_COMP_Y, (ojph::ui8)qfactor);
+          } else {
+            qcd.set_qfactor(0,
+              ojph::param_qcd::OJPH_COMP_Y, (ojph::ui8)qfactor);
+            qcd.set_qfactor(1,
+              ojph::param_qcd::OJPH_COMP_CB, (ojph::ui8)qfactor);
+            qcd.set_qfactor(2,
+              ojph::param_qcd::OJPH_COMP_CR, (ojph::ui8)qfactor);
+          }
+        }
         codestream.set_planar(false);
         if (profile_string[0] != '\0')
           codestream.set_profile(profile_string);

src/core/codestream/ojph_params.cpp

@@ -43,6 +43,7 @@
 #include "ojph_file.h"
 #include "ojph_params.h"
 
+#include "ojph_visual_weighting.h"
 #include "ojph_params_local.h"
 #include "ojph_message.h"
 
@@ -423,6 +424,11 @@ namespace ojph {
     state->set_delta(comp_idx, delta);
   }
 
+  //////////////////////////////////////////////////////////////////////////
+  void param_qcd::set_qfactor(ui32 comp_idx, comp_type ctype, ui8 qfactor) {
+    state->set_qfactor(comp_idx, ctype, qfactor);
+  }
+
   ////////////////////////////////////////////////////////////////////////////
   //
   //
@@ -1164,14 +1170,16 @@ namespace ojph {
 
       // initialize every QCC, creating one for every component that (a) cannot
       // use QCD and (b) does not already have a QCC
+      // NOTE: Qfactor always creates a QCC and QCD cannot be reused
       for (ui32 c = 0; c < num_comps; ++c)
       {
         param_qcd *qcc = this->get_qcc(c);
         const param_cod *coc = cod.get_coc(c);
 
+        // check if a QCC exists for the component
         if (qcc == this)
         {
-          // no QCC specified for the component, one is created only if QCD cannot be used
+          // if none exists, do not create one if QCD can be reused
           if (!this->is_qcc_needed(c, *coc, siz))
             continue;
 
@@ -1196,6 +1204,7 @@ namespace ojph {
       this->is_signed = siz.is_signed(comp_num);
       this->is_color_trans = cod.is_employing_color_transform();
       this->wavelet_kern = cod.get_wavelet_kern();
+      this->sampling = siz.get_downsampling(comp_num);
       this->num_subbands = 1 + 3 * this->num_decomps;
 
       if (this->wavelet_kern == param_cod::DWT_REV53)
@@ -1236,6 +1245,22 @@ namespace ojph {
       p->set_delta(delta);
     }
 
+    //////////////////////////////////////////////////////////////////////////
+    void param_qcd::set_qfactor(ui32 comp_idx, ojph::param_qcd::comp_type ctype, ui8 qfactor) {
+      if (this->top_qcd != NULL)
+        OJPH_ERROR(0x00040401, "This method is not implemented for QCC.");
+
+      if (qfactor < 1 || qfactor > 100)
+        OJPH_ERROR(0x00040403, "Qfactor must be between 1 and 100, but was set to %i.", qfactor);
+
+      param_qcd *p = get_qcc(comp_idx);
+      if (p == this)
+        p = add_qcc_object(comp_idx);
+
+      p->qfactor = qfactor;
+      p->ctype = ctype;
+    }
+
     //////////////////////////////////////////////////////////////////////////
     void param_qcd::set_rev_quant(ui32 num_decomps, ui32 bit_depth,
                                   bool is_employing_color_transform)
@@ -1289,6 +1314,40 @@ namespace ojph {
       int guard_bits = 1;
       Sqcd = (ui8)((guard_bits<<5)|0x2);//one guard bit, scalar quantization
 
+      // the following are used only when Qfactor is set
+      float qfactor_power = 0;
+      float delta_ref = 0;
+      float G_c = 1;
+      const open_htj2k::visual_weighting_params vp;
+      std::vector<double> W_b;
+      if (this->qfactor != QFACTOR_UNSET) {
+        const open_htj2k::q_scaling qs = open_htj2k::q_to_delta(this->qfactor, (ui8) this->bit_depth);
+        qfactor_power = (float) qs.qfactor_power;
+        const open_htj2k::color_transform ct = open_htj2k::resolve_color_transform(vp, this->is_color_trans);
+        int comp_index = (int)this->ctype;
+        delta_ref = (float) (qs.delta_Q * open_htj2k::color_gain(ct, 0));
+        G_c = (float) open_htj2k::color_gain(ct, comp_index);
+
+        // chroma_format 0 = 4:4:4, 1 = 4:2:0, 2 = 4:2:2
+        int sampling = 0;
+        if (this->sampling.x == 1 && this->sampling.y == 1)
+          { sampling = 0; }
+        else if (this->sampling.x == 2 && this->sampling.y == 2)
+          { sampling = 1; }
+        else if (this->sampling.x == 2 && this->sampling.y == 1)
+          { sampling = 2; }
+        else
+        {
+          OJPH_ERROR(0x00050161, "Qfactor can only be used on components with 4:4:4, 4:2:2 or 4:2:0 sampling");
+        }
+
+        if (this->ctype == ojph::param_qcd::OJPH_COMP_Y)
+          W_b = open_htj2k::luma_visual_weights((ui8) num_decomps, vp);
+        else
+          W_b = open_htj2k::chroma_visual_weights((ui8) num_decomps, vp, comp_index, sampling, ct);
+
+      }
+
       // LL, HL, LH, HH, HL, LH, HH...
       for (ui32 s = 0; s < (1 + num_decomps * 3); s++)
       {
@@ -1310,7 +1369,16 @@ namespace ojph {
           { w_g = gain_l * gain_h; }
         }
 
-        float delta_b = base_delta / w_g;
+        float delta_b;
+        if (this->qfactor == QFACTOR_UNSET)
+        {
+          delta_b = base_delta / w_g;
+        }
+        else
+        {
+          float w_b = (s == 0 || s > W_b.size()) ? (float) 1.0 : (float) pow(W_b[W_b.size() - s], qfactor_power);
+          delta_b = delta_ref / (w_g * w_b * G_c);
+        }
 
         int exp = 0, mantissa;
         while (delta_b < 1.0f)

src/core/codestream/ojph_params_local.h

@@ -691,6 +691,11 @@ namespace ojph {
         QCC_TILE  = 4   // not implemented
       };
 
+      ////////////////////////////////////////
+      enum qfactor_const : ui8 {
+        QFACTOR_UNSET = 0
+      };
+
     public:
       param_qcd(param_qcd* top_qcd = NULL, ui16 comp_idx = OJPH_QCD_DEFAULT)
       { avail = NULL; init(top_qcd, comp_idx); }
@@ -711,6 +716,7 @@ namespace ojph {
       bool is_qcc_needed(ui32 comp_num, const param_cod &cod, const param_siz &siz);
       void set_delta(float delta) { base_delta = delta; }
       void set_delta(ui32 comp_idx, float delta);
+      void set_qfactor(ui32 comp_idx, ojph::param_qcd::comp_type ctype, ui8 qfactor);
       ui32 get_num_guard_bits() const;
       ui32 get_MAGB() const;
       ui32 get_Kmax(const param_dfs* dfs, ui32 num_decompositions,
@@ -740,6 +746,9 @@ namespace ojph {
         memset(&SPqcd, 0, sizeof(SPqcd));
         num_subbands = 0;
         base_delta = -1.0f;
+        qfactor = QFACTOR_UNSET;
+        ctype = ojph::param_qcd::OJPH_COMP_Y;
+        sampling = ojph::point(1, 1);
         enabled = true;
         next = NULL;
         this->top_qcd = top_qcd;
@@ -788,11 +797,14 @@ namespace ojph {
       // variables used to generate the quantization step sizes
       float base_delta;   // base quantization step size -- all other
                           // step sizes are derived from it.
+      ui8 qfactor;
+      ojph::param_qcd::comp_type ctype;
       bool is_color_trans;
       ui32 num_decomps;
       ui32 bit_depth;
       bool is_signed;
       ui32 wavelet_kern;
+      ojph::point sampling;
 
     private: // QCC only variables
       ui16 comp_idx;