Merge pull request #156 from szabadka/master

szabadka · web-flow · commit e09417e1a762 · 2017-03-31T17:38:36.000+02:00
Reduce guetzli memory usage by 30%
diff --git a/guetzli/butteraugli_comparator.cc b/guetzli/butteraugli_comparator.cc
@@ -25,12 +25,13 @@
 namespace guetzli {
 
 ButteraugliComparator::ButteraugliComparator(const int width, const int height,
-                                             const std::vector<uint8_t>& rgb,
+                                             const std::vector<uint8_t>* rgb,
                                              const float target_distance,
                                              ProcessStats* stats)
     : width_(width),
       height_(height),
       target_distance_(target_distance),
+      rgb_orig_(*rgb),
       rgb_linear_pregamma_(3, std::vector<float>(width_ * height_)),
       comparator_(width_, height_, kButteraugliStep),
       distance_(0.0),
@@ -40,51 +41,68 @@ ButteraugliComparator::ButteraugliComparator(const int width, const int height,
   for (int c = 0; c < 3; ++c) {
     for (int y = 0, ix = 0; y < height_; ++y) {
       for (int x = 0; x < width_; ++x, ++ix) {
-        rgb_linear_pregamma_[c][ix] = lut[rgb[3 * ix + c]];
+        rgb_linear_pregamma_[c][ix] = lut[rgb_orig_[3 * ix + c]];
       }
     }
   }
-  const int block_w = (width_ + 7) / 8;
-  const int block_h = (height_ + 7) / 8;
-  const int nblocks = block_w * block_h;
-  per_block_pregamma_.resize(nblocks);
-  for (int block_y = 0, bx = 0; block_y < block_h; ++block_y) {
-    for (int block_x = 0; block_x < block_w; ++block_x, ++bx) {
+  ::butteraugli::OpsinDynamicsImage(width_, height_, rgb_linear_pregamma_);
+}
+
+void ButteraugliComparator::Compare(const OutputImage& img) {
+  std::vector<std::vector<float> > rgb(3, std::vector<float>(width_ * height_));
+  img.ToLinearRGB(&rgb);
+  ::butteraugli::OpsinDynamicsImage(width_, height_, rgb);
+  comparator_.DiffmapOpsinDynamicsImage(rgb_linear_pregamma_, rgb, distmap_);
+  distance_ = ::butteraugli::ButteraugliScoreFromDiffmap(distmap_);
+  GUETZLI_LOG(stats_, " BA[100.00%%] D[%6.4f]", distance_);
+}
+
+void ButteraugliComparator::StartBlockComparisons() {
+  std::vector<std::vector<float> > dummy(3);
+  ::butteraugli::Mask(rgb_linear_pregamma_, rgb_linear_pregamma_,
+                      width_, height_,
+                      &mask_xyz_, &dummy);
+}
+
+void ButteraugliComparator::FinishBlockComparisons() {
+  mask_xyz_.clear();
+}
+
+void ButteraugliComparator::SwitchBlock(int block_x, int block_y,
+                                        int factor_x, int factor_y) {
+  block_x_ = block_x;
+  block_y_ = block_y;
+  factor_x_ = factor_x;
+  factor_y_ = factor_y;
+  per_block_pregamma_.resize(factor_x_ * factor_y_);
+  const double* lut = Srgb8ToLinearTable();
+  for (int off_y = 0, bx = 0; off_y < factor_y_; ++off_y) {
+    for (int off_x = 0; off_x < factor_x_; ++off_x, ++bx) {
       per_block_pregamma_[bx].resize(3, std::vector<float>(kDCTBlockSize));
+      int block_xx = block_x_ * factor_x_ + off_x;
+      int block_yy = block_y_ * factor_y_ + off_y;
       for (int iy = 0, i = 0; iy < 8; ++iy) {
         for (int ix = 0; ix < 8; ++ix, ++i) {
-          int x = std::min(8 * block_x + ix, width_ - 1);
-          int y = std::min(8 * block_y + iy, height_ - 1);
+          int x = std::min(8 * block_xx + ix, width_ - 1);
+          int y = std::min(8 * block_yy + iy, height_ - 1);
           int px = y * width_ + x;
           for (int c = 0; c < 3; ++c) {
-            per_block_pregamma_[bx][c][i] = rgb_linear_pregamma_[c][px];
+            per_block_pregamma_[bx][c][i] = lut[rgb_orig_[3 * px + c]];
           }
         }
       }
       ::butteraugli::OpsinDynamicsImage(8, 8, per_block_pregamma_[bx]);
     }
   }
-  ::butteraugli::OpsinDynamicsImage(width_, height_, rgb_linear_pregamma_);
-  std::vector<std::vector<float> > dummy(3);
-  ::butteraugli::Mask(rgb_linear_pregamma_, rgb_linear_pregamma_,
-                      width_, height_,
-                      &mask_xyz_, &dummy);
-}
-
-void ButteraugliComparator::Compare(const OutputImage& img) {
-  std::vector<std::vector<float> > rgb(3, std::vector<float>(width_ * height_));
-  img.ToLinearRGB(&rgb);
-  ::butteraugli::OpsinDynamicsImage(width_, height_, rgb);
-  comparator_.DiffmapOpsinDynamicsImage(rgb_linear_pregamma_, rgb, distmap_);
-  distance_ = ::butteraugli::ButteraugliScoreFromDiffmap(distmap_);
-  GUETZLI_LOG(stats_, " BA[100.00%%] D[%6.4f]", distance_);
 }
 
-double ButteraugliComparator::CompareBlock(
-    const OutputImage& img, int block_x, int block_y) const {
+double ButteraugliComparator::CompareBlock(const OutputImage& img,
+                                           int off_x, int off_y) const {
+  int block_x = block_x_ * factor_x_ + off_x;
+  int block_y = block_y_ * factor_y_ + off_y;
   int xmin = 8 * block_x;
   int ymin = 8 * block_y;
-  int block_ix = block_y * ((width_ + 7) / 8) + block_x;
+  int block_ix = off_y * factor_x_ + off_x;
   const std::vector<std::vector<float> >& rgb0_c =
       per_block_pregamma_[block_ix];
 
diff --git a/guetzli/butteraugli_comparator.h b/guetzli/butteraugli_comparator.h
@@ -32,13 +32,19 @@ constexpr int kButteraugliStep = 3;
 class ButteraugliComparator : public Comparator {
  public:
   ButteraugliComparator(const int width, const int height,
-                        const std::vector<uint8_t>& rgb,
+                        const std::vector<uint8_t>* rgb,
                         const float target_distance, ProcessStats* stats);
 
   void Compare(const OutputImage& img) override;
 
+  void StartBlockComparisons() override;
+  void FinishBlockComparisons() override;
+
+  void SwitchBlock(int block_x, int block_y,
+                   int factor_x, int factor_y) override;
+
   double CompareBlock(const OutputImage& img,
-                      int block_x, int block_y) const override;
+                      int off_x, int off_y) const override;
 
   double ScoreOutputSize(int size) const override;
 
@@ -60,6 +66,11 @@ class ButteraugliComparator : public Comparator {
   const int width_;
   const int height_;
   const float target_distance_;
+  const std::vector<uint8_t>& rgb_orig_;
+  int block_x_;
+  int block_y_;
+  int factor_x_;
+  int factor_y_;
   std::vector<std::vector<float>> rgb_linear_pregamma_;
   std::vector<std::vector<float>> mask_xyz_;
   std::vector<std::vector<std::vector<float>>> per_block_pregamma_;
diff --git a/guetzli/comparator.h b/guetzli/comparator.h
@@ -36,11 +36,22 @@ class Comparator {
   // baseline image.
   virtual void Compare(const OutputImage& img) = 0;
 
-  // Compares an 8x8 block of the baseline image with the same block of img and
-  // returns the resulting per-block distance. The interpretation of the
-  // returned distance depends on the comparator used.
+  // Must be called before any CompareBlock() calls can be called.
+  virtual void StartBlockComparisons() = 0;
+  // No more CompareBlock() calls can be called after this.
+  virtual void FinishBlockComparisons() = 0;
+
+  // Sets the coordinates of the current macro-block for the purpose of
+  // CompareBlock() calls.
+  virtual void SwitchBlock(int block_x, int block_y,
+                           int factor_x, int factor_y) = 0;
+
+  // Compares the 8x8 block with offsets (off_x, off_y) within the current
+  // macro-block of the baseline image with the same block of img and returns
+  // the resulting per-block distance. The interpretation of the returned
+  // distance depends on the comparator used.
   virtual double CompareBlock(const OutputImage& img,
-                              int block_x, int block_y) const = 0;
+                              int off_x, int off_y) const = 0;
 
   // Returns the combined score of the output image in the last Compare() call
   // (or the baseline image, if Compare() was not called yet), based on output
diff --git a/guetzli/guetzli.cc b/guetzli/guetzli.cc
@@ -34,7 +34,7 @@ constexpr int kDefaultJPEGQuality = 95;
 
 // An upper estimate of memory usage of Guetzli. The bound is
 // max(kLowerMemusaeMB * 1<<20, pixel_count * kBytesPerPixel)
-constexpr int kBytesPerPixel = 200;
+constexpr int kBytesPerPixel = 125;
 constexpr int kLowestMemusageMB = 100; // in MB
 
 constexpr int kDefaultMemlimitMB = 6000; // in MB
diff --git a/guetzli/processor.cc b/guetzli/processor.cc
@@ -64,13 +64,11 @@ class Processor {
       std::vector<CoeffData>* output_order);
   bool SelectQuantMatrix(const JPEGData& jpg_in, const bool downsample,
                          int best_q[3][kDCTBlockSize],
-                         OutputImage* img,
-                         GuetzliOutput* quantized_out);
+                         OutputImage* img);
   QuantData TryQuantMatrix(const JPEGData& jpg_in,
                            const float target_mul,
                            int q[3][kDCTBlockSize],
-                           OutputImage* img,
-                           GuetzliOutput* out);
+                           OutputImage* img);
   void MaybeOutput(const std::string& encoded_jpg);
   void DownsampleImage(OutputImage* img);
   void OutputJpeg(const JPEGData& in, std::string* out);
@@ -287,8 +285,7 @@ class QuantMatrixGenerator {
 QuantData Processor::TryQuantMatrix(const JPEGData& jpg_in,
                                     const float target_mul,
                                     int q[3][kDCTBlockSize],
-                                    OutputImage* img,
-                                    GuetzliOutput* out) {
+                                    OutputImage* img) {
   QuantData data;
   memcpy(data.q, q, sizeof(data.q));
   img->CopyFromJpegData(jpg_in);
@@ -311,39 +308,31 @@ QuantData Processor::TryQuantMatrix(const JPEGData& jpg_in,
   comparator_->Compare(*img);
   data.dist_ok = comparator_->DistanceOK(target_mul);
   data.jpg_size = encoded_jpg.size();
-  out->jpeg_data = encoded_jpg;
-  out->distmap = comparator_->distmap();
-  out->distmap_aggregate = comparator_->distmap_aggregate();
-  out->score = comparator_->ScoreOutputSize(encoded_jpg.size());
   MaybeOutput(encoded_jpg);
   return data;
 }
 
 bool Processor::SelectQuantMatrix(const JPEGData& jpg_in, const bool downsample,
                                   int best_q[3][kDCTBlockSize],
-                                  OutputImage* img,
-                                  GuetzliOutput* quantized_out) {
+                                  OutputImage* img) {
   QuantMatrixGenerator qgen(downsample, stats_);
   // Don't try to go up to exactly the target distance when selecting a
   // quantization matrix, since we will need some slack to do the frequency
   // masking later.
   const float target_mul_high = 0.97f;
   const float target_mul_low = 0.95f;
 
-  QuantData best = TryQuantMatrix(jpg_in, target_mul_high, best_q, img,
-                                  quantized_out);
+  QuantData best = TryQuantMatrix(jpg_in, target_mul_high, best_q, img);
   for (;;) {
     int q_next[3][kDCTBlockSize];
     if (!qgen.GetNext(q_next)) {
       break;
     }
 
-    GuetzliOutput out;
-    QuantData data = TryQuantMatrix(jpg_in, target_mul_high, q_next, img, &out);
+    QuantData data = TryQuantMatrix(jpg_in, target_mul_high, q_next, img);
     qgen.Add(data);
     if (CompareQuantData(data, best)) {
       best = data;
-      *quantized_out = out;
       if (data.dist_ok && !comparator_->DistanceOK(target_mul_low)) {
         break;
       }
@@ -398,6 +387,7 @@ void Processor::ComputeBlockZeroingOrder(
               return a.second < b.second; });
   coeff_t processed_block[kBlockSize];
   memcpy(processed_block, block, sizeof(processed_block));
+  comparator_->SwitchBlock(block_x, block_y, factor_x, factor_y);
   while (!input_order.empty()) {
     float best_err = 1e17f;
     int best_i = 0;
@@ -420,7 +410,7 @@ void Processor::ComputeBlockZeroingOrder(
           int block_xx = block_x * factor_x + ix;
           int block_yy = block_y * factor_y + iy;
           if (8 * block_xx < img->width() && 8 * block_yy < img->height()) {
-            float err = comparator_->CompareBlock(*img, block_xx, block_yy);
+            float err = comparator_->CompareBlock(*img, ix, iy);
             max_err = std::max(max_err, err);
           }
         }
@@ -548,7 +538,14 @@ void Processor::SelectFrequencyMasking(const JPEGData& jpg, OutputImage* img,
   const int block_height = (height + 8 * factor_y - 1) / (8 * factor_y);
   const int num_blocks = block_width * block_height;
 
-  std::vector<std::vector<CoeffData> > orders(num_blocks);
+  std::vector<int> candidate_coeff_offsets(num_blocks + 1);
+  std::vector<uint8_t> candidate_coeffs;
+  std::vector<float> candidate_coeff_errors;
+  candidate_coeffs.reserve(60 * num_blocks);
+  candidate_coeff_errors.reserve(60 * num_blocks);
+  std::vector<CoeffData> block_order;
+  block_order.reserve(3 * kDCTBlockSize);
+  comparator_->StartBlockComparisons();
   for (int block_y = 0, block_ix = 0; block_y < block_height; ++block_y) {
     for (int block_x = 0; block_x < block_width; ++block_x, ++block_ix) {
       coeff_t block[kBlockSize] = { 0 };
@@ -566,11 +563,18 @@ void Processor::SelectFrequencyMasking(const JPEGData& jpg, OutputImage* img,
                  kDCTBlockSize * sizeof(orig_block[0]));
         }
       }
+      block_order.clear();
       ComputeBlockZeroingOrder(block, orig_block, block_x, block_y, factor_x,
-                               factor_y, comp_mask, img,
-                               &orders[block_ix]);
+                               factor_y, comp_mask, img, &block_order);
+      candidate_coeff_offsets[block_ix] = candidate_coeffs.size();
+      for (size_t i = 0; i < block_order.size(); ++i) {
+        candidate_coeffs.push_back(block_order[i].idx);
+        candidate_coeff_errors.push_back(block_order[i].block_err);
+      }
     }
   }
+  comparator_->FinishBlockComparisons();
+  candidate_coeff_offsets[num_blocks] = candidate_coeffs.size();
 
   std::vector<JpegHistogram> ac_histograms(ncomp);
   int jpg_header_size, dc_size;
@@ -619,21 +623,24 @@ void Processor::SelectFrequencyMasking(const JPEGData& jpg, OutputImage* img,
         for (int block_y = 0, block_ix = 0; block_y < block_height; ++block_y) {
           for (int block_x = 0; block_x < block_width; ++block_x, ++block_ix) {
             const int last_index = last_indexes[block_ix];
-            const std::vector<CoeffData>& order = orders[block_ix];
+            const int offset = candidate_coeff_offsets[block_ix];
+            const int num_candidates =
+                candidate_coeff_offsets[block_ix + 1] - offset;
+            const float* candidate_errors = &candidate_coeff_errors[offset];
             const float max_err = max_block_error[block_ix];
             if (block_weight[block_ix] == 0) {
               continue;
             }
             if (direction > 0) {
-              for (size_t i = last_index; i < order.size(); ++i) {
-                float val = ((order[i].block_err - max_err) /
+              for (size_t i = last_index; i < num_candidates; ++i) {
+                float val = ((candidate_errors[i] - max_err) /
                              block_weight[block_ix]);
                 global_order.push_back(std::make_pair(block_ix, val));
               }
-              blocks_to_change += (static_cast<size_t>(last_index) < order.size() ? 1 : 0);
+              blocks_to_change += (last_index < num_candidates ? 1 : 0);
             } else {
               for (int i = last_index - 1; i >= 0; --i) {
-                float val = ((max_err - order[i].block_err) /
+                float val = ((max_err - candidate_errors[i]) /
                              block_weight[block_ix]);
                 global_order.push_back(std::make_pair(block_ix, val));
               }
@@ -686,8 +693,9 @@ void Processor::SelectFrequencyMasking(const JPEGData& jpg, OutputImage* img,
         const int block_x = block_ix % block_width;
         const int block_y = block_ix / block_width;
         const int last_idx = last_indexes[block_ix];
-        const std::vector<CoeffData>& order = orders[block_ix];
-        const int idx = order[last_idx + std::min(direction, 0)].idx;
+        const int offset = candidate_coeff_offsets[block_ix];
+        const uint8_t* candidates = &candidate_coeffs[offset];
+        const int idx = candidates[last_idx + std::min(direction, 0)];
         const int c = idx / kDCTBlockSize;
         const int k = idx % kDCTBlockSize;
         const int* quant = img->component(c).quant();
@@ -716,6 +724,8 @@ void Processor::SelectFrequencyMasking(const JPEGData& jpg, OutputImage* img,
           break;
         }
       }
+      size_t global_order_size = global_order.size();
+      std::vector<std::pair<int, float>>().swap(global_order);
 
       for (int i = 0; i < num_blocks; ++i) {
         max_block_error[i] += block_weight[i] * val_threshold * direction;
@@ -734,7 +744,7 @@ void Processor::SelectFrequencyMasking(const JPEGData& jpg, OutputImage* img,
                   "Blocks[%zd/%d/%d] ValThres[%.4f] Out[%7zd] EstErr[%.2f%%]",
                   stats_->counters[kNumItersCnt], img->FrameTypeStr().c_str(),
                   comp_mask, direction > 0 ? "up" : "down", changed_coeffs,
-                  global_order.size(), changed_blocks.size(),
+                  global_order_size, changed_blocks.size(),
                   blocks_to_change, num_blocks, val_threshold,
                   encoded_jpg.size(),
                   100.0 - (100.0 * est_jpg_size) / encoded_jpg.size());
@@ -827,9 +837,7 @@ bool Processor::ProcessJpegData(const Params& params, const JPEGData& jpg_in,
     }
     int best_q[3][kDCTBlockSize];
     memcpy(best_q, q_in, sizeof(best_q));
-    GuetzliOutput quantized_out;
-    if (!SelectQuantMatrix(jpg, downsample != 0, best_q,
-                           &img, &quantized_out)) {
+    if (!SelectQuantMatrix(jpg, downsample != 0, best_q, &img)) {
       for (int c = 0; c < 3; ++c) {
         for (int i = 0; i < kDCTBlockSize; ++i) {
           best_q[c][i] = 1;
@@ -881,7 +889,7 @@ bool Process(const Params& params, ProcessStats* stats,
   std::unique_ptr<ButteraugliComparator> comparator;
   if (jpg.width >= 32 && jpg.height >= 32) {
     comparator.reset(
-        new ButteraugliComparator(jpg.width, jpg.height, rgb,
+        new ButteraugliComparator(jpg.width, jpg.height, &rgb,
                                   params.butteraugli_target, stats));
   }
   bool ok = ProcessJpegData(params, jpg, comparator.get(), &out, stats);
@@ -905,7 +913,7 @@ bool Process(const Params& params, ProcessStats* stats,
   std::unique_ptr<ButteraugliComparator> comparator;
   if (jpg.width >= 32 && jpg.height >= 32) {
     comparator.reset(
-        new ButteraugliComparator(jpg.width, jpg.height, rgb,
+        new ButteraugliComparator(jpg.width, jpg.height, &rgb,
                                   params.butteraugli_target, stats));
   }
   bool ok = ProcessJpegData(params, jpg, comparator.get(), &out, stats);
diff --git a/third_party/butteraugli/butteraugli/butteraugli.cc b/third_party/butteraugli/butteraugli/butteraugli.cc
