Update libwebp to 0.4.0

third_party/libwebp/enc/vp8l.c

 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // main entry for the lossless encoder.
 //
 // Author: Vikas Arora (vikaas.arora@gmail.com)
 //
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "./backward_references.h"
 #include "./vp8enci.h"
 #include "./vp8li.h"
 #include "../dsp/lossless.h"
 #include "../utils/bit_writer.h"
 #include "../utils/huffman_encode.h"
 #include "../utils/utils.h"
 #include "../webp/format_constants.h"
 
-#if defined(__cplusplus) || defined(c_plusplus)
-extern "C" {
-#endif
-
 #define PALETTE_KEY_RIGHT_SHIFT   22  // Key for 1K buffer.
 #define MAX_HUFF_IMAGE_SIZE       (16 * 1024 * 1024)
 #define MAX_COLORS_FOR_GRAPH      64
 
 // -----------------------------------------------------------------------------
 // Palette
 
 static int CompareColors(const void* p1, const void* p2) {
   const uint32_t a = *(const uint32_t*)p1;
   const uint32_t b = *(const uint32_t*)p2;
@@ skipping 119 matching lines @@
       enc->use_predict_ = 1;
       enc->use_cross_color_ = 1;
     } else {
       double non_pred_entropy, pred_entropy;
       if (!AnalyzeEntropy(pic->argb, pic->width, pic->height, pic->argb_stride,
                           &non_pred_entropy, &pred_entropy)) {
         return 0;
       }
       if (pred_entropy < 0.95 * non_pred_entropy) {
         enc->use_predict_ = 1;
-        // TODO(vikasa): Observed some correlation of cross_color transform with
-        // predict. Need to investigate this further and add separate heuristic
-        // for setting use_cross_color flag.
         enc->use_cross_color_ = 1;
       }
     }
   }
 
   return 1;
 }
 
 static int GetHuffBitLengthsAndCodes(
     const VP8LHistogramSet* const histogram_image,
@@ skipping 260 matching lines @@
       static const int order[] = { 1, 2, 0, 3 };
       int k;
       for (k = 0; k < 4; ++k) {
         const int code = PixOrCopyLiteral(v, order[k]);
         WriteHuffmanCode(bw, codes + k, code);
       }
     } else {
       int bits, n_bits;
       int code, distance;
 
-      PrefixEncode(v->len, &code, &n_bits, &bits);
+      VP8LPrefixEncode(v->len, &code, &n_bits, &bits);
       WriteHuffmanCode(bw, codes, 256 + code);
       VP8LWriteBits(bw, n_bits, bits);
 
       distance = PixOrCopyDistance(v);
-      PrefixEncode(distance, &code, &n_bits, &bits);
+      VP8LPrefixEncode(distance, &code, &n_bits, &bits);
       WriteHuffmanCode(bw, codes + 4, code);
       VP8LWriteBits(bw, n_bits, bits);
     }
     x += PixOrCopyLength(v);
     while (x >= width) {
       x -= width;
       ++y;
     }
   }
 }
@@ skipping 225 matching lines @@
   }
   return 1;
 }
 
 static int ApplyCrossColorFilter(const VP8LEncoder* const enc,
                                  int width, int height, int quality,
                                  VP8LBitWriter* const bw) {
   const int ccolor_transform_bits = enc->transform_bits_;
   const int transform_width = VP8LSubSampleSize(width, ccolor_transform_bits);
   const int transform_height = VP8LSubSampleSize(height, ccolor_transform_bits);
-  const int step = (quality == 0) ? 32 : 8;
+  const int step = (quality < 25) ? 32 : (quality > 50) ? 8 : 16;
 
   VP8LColorSpaceTransform(width, height, ccolor_transform_bits, step,
                           enc->argb_, enc->transform_data_);
   VP8LWriteBits(bw, 1, TRANSFORM_PRESENT);
   VP8LWriteBits(bw, 2, CROSS_COLOR_TRANSFORM);
   assert(ccolor_transform_bits >= 2);
   VP8LWriteBits(bw, 3, ccolor_transform_bits - 2);
   if (!EncodeImageNoHuffman(bw, enc->transform_data_,
                             transform_width, transform_height, quality)) {
     return 0;
@@ skipping 104 matching lines @@
   int i, x, y;
   int use_LUT = 1;
   for (i = 0; i < palette_size; ++i) {
     if ((palette[i] & 0xffff00ffu) != 0) {
       use_LUT = 0;
       break;
     }
   }
 
   if (use_LUT) {
-    int inv_palette[MAX_PALETTE_SIZE] = { 0 };
+    uint8_t inv_palette[MAX_PALETTE_SIZE] = { 0 };
     for (i = 0; i < palette_size; ++i) {
       const int color = (palette[i] >> 8) & 0xff;
       inv_palette[color] = i;
     }
     for (y = 0; y < height; ++y) {
       for (x = 0; x < width; ++x) {
         const int color = (src[x] >> 8) & 0xff;
         row[x] = inv_palette[color];
       }
       VP8LBundleColorMap(row, width, xbits, dst);
@@ skipping 47 matching lines @@
   if (palette_size <= 4) {
     xbits = (palette_size <= 2) ? 3 : 2;
   } else {
     xbits = (palette_size <= 16) ? 1 : 0;
   }
 
   err = AllocateTransformBuffer(enc, VP8LSubSampleSize(width, xbits), height);
   if (err != VP8_ENC_OK) goto Error;
   dst = enc->argb_;
 
-  row = WebPSafeMalloc((uint64_t)width, sizeof(*row));
+  row = (uint8_t*)WebPSafeMalloc((uint64_t)width, sizeof(*row));
   if (row == NULL) return VP8_ENC_ERROR_OUT_OF_MEMORY;
 
   ApplyPalette(src, dst, pic->argb_stride, enc->current_width_,
                palette, palette_size, width, height, xbits, row);
 
   // Save palette to bitstream.
   VP8LWriteBits(bw, 1, TRANSFORM_PRESENT);
   VP8LWriteBits(bw, 2, COLOR_INDEXING_TRANSFORM);
   assert(palette_size >= 1);
   VP8LWriteBits(bw, 8, palette_size - 1);
@@ skipping 43 matching lines @@
 
 static VP8LEncoder* VP8LEncoderNew(const WebPConfig* const config,
                                    const WebPPicture* const picture) {
   VP8LEncoder* const enc = (VP8LEncoder*)calloc(1, sizeof(*enc));
   if (enc == NULL) {
     WebPEncodingSetError(picture, VP8_ENC_ERROR_OUT_OF_MEMORY);
     return NULL;
   }
   enc->config_ = config;
   enc->pic_ = picture;
+
+  VP8LDspInit();
+
   return enc;
 }
 
 static void VP8LEncoderDelete(VP8LEncoder* enc) {
   free(enc->argb_);
   free(enc);
 }
 
 // -----------------------------------------------------------------------------
 // Main call
@@ skipping 191 matching lines @@
   VP8LBitWriterDestroy(&bw);
   if (err != VP8_ENC_OK) {
     WebPEncodingSetError(picture, err);
     return 0;
   }
   return 1;
 }
 
 //------------------------------------------------------------------------------
 
-#if defined(__cplusplus) || defined(c_plusplus)
-}    // extern "C"
-#endif