libwebp-0.5.2-rc2

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.
@@ skipping 16 matching lines @@
 
 #include "./delta_palettization.h"
 
 #define PALETTE_KEY_RIGHT_SHIFT   22  // Key for 1K buffer.
 // Maximum number of histogram images (sub-blocks).
 #define MAX_HUFF_IMAGE_SIZE       2600
 
 // Palette reordering for smaller sum of deltas (and for smaller storage).
 
 static int PaletteCompareColorsForQsort(const void* p1, const void* p2) {
-  const uint32_t a = WebPMemToUint32(p1);
-  const uint32_t b = WebPMemToUint32(p2);
+  const uint32_t a = WebPMemToUint32((uint8_t*)p1);
+  const uint32_t b = WebPMemToUint32((uint8_t*)p2);
   assert(a != b);
   return (a < b) ? -1 : 1;
 }
 
 static WEBP_INLINE uint32_t PaletteComponentDistance(uint32_t v) {
   return (v <= 128) ? v : (256 - v);
 }
 
 // Computes a value that is related to the entropy created by the
 // palette entry diff.
@@ skipping 168 matching lines @@
           const int hash = ((pix + (pix >> 19)) * 0x39c5fba7) >> 24;
           ++histo[kHistoPalette * 256 + (hash & 0xff)];
         }
       }
       prev_row = curr_row;
       curr_row += argb_stride;
     }
     {
       double entropy_comp[kHistoTotal];
       double entropy[kNumEntropyIx];
-      EntropyIx k;
-      EntropyIx last_mode_to_analyze =
-          use_palette ? kPalette : kSpatialSubGreen;
+      int k;
+      int last_mode_to_analyze = use_palette ? kPalette : kSpatialSubGreen;
       int j;
       // Let's add one zero to the predicted histograms. The zeros are removed
       // too efficiently by the pix_diff == 0 comparison, at least one of the
       // zeros is likely to exist.
       ++histo[kHistoRedPredSubGreen * 256];
       ++histo[kHistoBluePredSubGreen * 256];
       ++histo[kHistoRedPred * 256];
       ++histo[kHistoGreenPred * 256];
       ++histo[kHistoBluePred * 256];
       ++histo[kHistoAlphaPred * 256];
@@ skipping 16 matching lines @@
       entropy[kSpatialSubGreen] = entropy_comp[kHistoAlphaPred] +
           entropy_comp[kHistoRedPredSubGreen] +
           entropy_comp[kHistoGreenPred] +
           entropy_comp[kHistoBluePredSubGreen];
       // Palette mode seems more efficient in a breakeven case. Bias with 1.0.
       entropy[kPalette] = entropy_comp[kHistoPalette] - 1.0;
 
       *min_entropy_ix = kDirect;
       for (k = kDirect + 1; k <= last_mode_to_analyze; ++k) {
         if (entropy[*min_entropy_ix] > entropy[k]) {
-          *min_entropy_ix = k;
+          *min_entropy_ix = (EntropyIx)k;
         }
       }
       *red_and_blue_always_zero = 1;
       // Let's check if the histogram of the chosen entropy mode has
       // non-zero red and blue values. If all are zero, we can later skip
       // the cross color optimization.
       {
         static const uint8_t kHistoPairs[5][2] = {
           { kHistoRed, kHistoBlue },
           { kHistoRedPred, kHistoBluePred },
@@ skipping 1317 matching lines @@
   if (bw.error_) err = VP8_ENC_ERROR_OUT_OF_MEMORY;
   VP8LBitWriterWipeOut(&bw);
   if (err != VP8_ENC_OK) {
     WebPEncodingSetError(picture, err);
     return 0;
   }
   return 1;
 }
 
 //------------------------------------------------------------------------------