libwebp: update snapshot to v0.2.0-rc1

third_party/libwebp/enc/analysis.c

-// Copyright 2011 Google Inc.
+// Copyright 2011 Google Inc. All Rights Reserved.
 //
 // This code is licensed under the same terms as WebM:
 //  Software License Agreement:  http://www.webmproject.org/license/software/
 //  Additional IP Rights Grant:  http://www.webmproject.org/license/additional/
 // -----------------------------------------------------------------------------
 //
 // Macroblock analysis
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 
-#include "vp8enci.h"
-#include "cost.h"
+#include "./vp8enci.h"
+#include "./cost.h"
+#include "../utils/utils.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
 #define MAX_ITERS_K_MEANS  6
 
 static int ClipAlpha(int alpha) {
   return alpha < 0 ? 0 : alpha > 255 ? 255 : alpha;
 }
 
 //------------------------------------------------------------------------------
 // Smooth the segment map by replacing isolated block by the majority of its
 // neighbours.
 
 static void SmoothSegmentMap(VP8Encoder* const enc) {
   int n, x, y;
   const int w = enc->mb_w_;
   const int h = enc->mb_h_;
   const int majority_cnt_3_x_3_grid = 5;
-  uint8_t* tmp = (uint8_t*)malloc(w * h * sizeof(uint8_t));
+  uint8_t* const tmp = (uint8_t*)WebPSafeMalloc((uint64_t)w * h, sizeof(*tmp));
+  assert((uint64_t)(w * h) == (uint64_t)w * h);   // no overflow, as per spec
 
   if (tmp == NULL) return;
   for (y = 1; y < h - 1; ++y) {
     for (x = 1; x < w - 1; ++x) {
       int cnt[NUM_MB_SEGMENTS] = { 0 };
       const VP8MBInfo* const mb = &enc->mb_info_[x + w * y];
       int majority_seg = mb->segment_;
       // Check the 8 neighbouring segment values.
       cnt[mb[-w - 1].segment_]++;  // top-left
       cnt[mb[-w + 0].segment_]++;  // top
@@ skipping 56 matching lines @@
       p[0] * (VP8BitCost(0, probas[0]) + VP8BitCost(0, probas[1])) +
       p[1] * (VP8BitCost(0, probas[0]) + VP8BitCost(1, probas[1])) +
       p[2] * (VP8BitCost(1, probas[0]) + VP8BitCost(0, probas[2])) +
       p[3] * (VP8BitCost(1, probas[0]) + VP8BitCost(1, probas[2]));
   } else {
     enc->segment_hdr_.update_map_ = 0;
     enc->segment_hdr_.size_ = 0;
   }
 }
 
-static inline int clip(int v, int m, int M) {
+static WEBP_INLINE int clip(int v, int m, int M) {
   return v < m ? m : v > M ? M : v;
 }
 
 static void SetSegmentAlphas(VP8Encoder* const enc,
                              const int centers[NUM_MB_SEGMENTS],
                              int mid) {
   const int nb = enc->segment_hdr_.num_segments_;
   int min = centers[0], max = centers[0];
   int n;
 
@@ skipping 12 matching lines @@
     enc->dqm_[n].beta_ = clip(beta, 0, 255);
   }
 }
 
 //------------------------------------------------------------------------------
 // Simplified k-Means, to assign Nb segments based on alpha-histogram
 
 static void AssignSegments(VP8Encoder* const enc, const int alphas[256]) {
   const int nb = enc->segment_hdr_.num_segments_;
   int centers[NUM_MB_SEGMENTS];
-  int weighted_average;
+  int weighted_average = 0;
   int map[256];
   int a, n, k;
   int min_a = 0, max_a = 255, range_a;
   // 'int' type is ok for histo, and won't overflow
   int accum[NUM_MB_SEGMENTS], dist_accum[NUM_MB_SEGMENTS];
 
   // bracket the input
   for (n = 0; n < 256 && alphas[n] == 0; ++n) {}
   min_a = n;
   for (n = 255; n > min_a && alphas[n] == 0; --n) {}
@@ skipping 40 matching lines @@
         total_weight += accum[n];
       }
     }
     weighted_average = (weighted_average + total_weight / 2) / total_weight;
     if (displaced < 5) break;   // no need to keep on looping...
   }
 
   // Map each original value to the closest centroid
   for (n = 0; n < enc->mb_w_ * enc->mb_h_; ++n) {
     VP8MBInfo* const mb = &enc->mb_info_[n];
-    const int a = mb->alpha_;
-    mb->segment_ = map[a];
-    mb->alpha_ = centers[map[a]];     // just for the record.
+    const int alpha = mb->alpha_;
+    mb->segment_ = map[alpha];
+    mb->alpha_ = centers[map[alpha]];     // just for the record.
   }
 
   if (nb > 1) {
     const int smooth = (enc->config_->preprocessing & 1);
     if (smooth) SmoothSegmentMap(enc);
   }
 
   SetSegmentProbas(enc);                             // Assign final proba
   SetSegmentAlphas(enc, centers, weighted_average);  // pick some alphas.
 }
@@ skipping 24 matching lines @@
       best_alpha = alpha;
       best_mode = mode;
     }
   }
   VP8SetIntra16Mode(it, best_mode);
   return best_alpha;
 }
 
 static int MBAnalyzeBestIntra4Mode(VP8EncIterator* const it,
                                    int best_alpha) {
-  int modes[16];
+  uint8_t modes[16];
   const int max_mode = (it->enc_->method_ >= 3) ? MAX_INTRA4_MODE : NUM_BMODES;
   int i4_alpha = 0;
   VP8IteratorStartI4(it);
   do {
     int mode;
     int best_mode_alpha = -1;
     const uint8_t* const src = it->yuv_in_ + Y_OFF + VP8Scan[it->i4_];
 
     VP8MakeIntra4Preds(it);
     for (mode = 0; mode < max_mode; ++mode) {
@@ skipping 65 matching lines @@
 // Main analysis loop:
 // Collect all susceptibilities for each macroblock and record their
 // distribution in alphas[]. Segments is assigned a-posteriori, based on
 // this histogram.
 // We also pick an intra16 prediction mode, which shouldn't be considered
 // final except for fast-encode settings. We can also pick some intra4 modes
 // and decide intra4/intra16, but that's usually almost always a bad choice at
 // this stage.
 
 int VP8EncAnalyze(VP8Encoder* const enc) {
+  int ok = 1;
   int alphas[256] = { 0 };
   VP8EncIterator it;
 
   VP8IteratorInit(enc, &it);
   enc->uv_alpha_ = 0;
   do {
     VP8IteratorImport(&it);
     MBAnalyze(&it, alphas, &enc->uv_alpha_);
+    ok = VP8IteratorProgress(&it, 20);
     // Let's pretend we have perfect lossless reconstruction.
-  } while (VP8IteratorNext(&it, it.yuv_in_));
+  } while (ok && VP8IteratorNext(&it, it.yuv_in_));
   enc->uv_alpha_ /= enc->mb_w_ * enc->mb_h_;
-  AssignSegments(enc, alphas);
+  if (ok) AssignSegments(enc, alphas);
 
-  return 1;
+  return ok;
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }    // extern "C"
 #endif