Update ChangeLog

Change-Id: I89a9c8cf6793c38e2b13d6e0557414fb05620eec

ChangeLog

@@ -1,3 +1,21 @@
+abc0604 Merge "update NEWS" into 0.2.0
+57cf313 update NEWS
+25f585c bump version to 0.2.1
+fed7c04 libwebp: validate chunk size in ParseOptionalChunks
+552cd9b cwebp (windows): fix alpha image import on XP
+b14fea9 autoconf/libwebp: enable dll builds for mingw
+4a8fb27 [cd]webp: always output windows errors
+d662158 fix double to float conversion warning
+72b96a6 cwebp: fix jpg encodes on XP
+734f762 VP8LAllocateHistogramSet: fix overflow in size calculation
+f9cb58f GetHistoBits: fix integer overflow
+b30add2 EncodeImageInternal: fix uninitialized free
+3de58d7 fix the -g/O3 discrepancy for 32bit compile
+77aa7d5 fix the BITS=8 case
+e5970bd Make *InitSSE2() functions be empty on non-SSE2 platform
+ef5cc47 make *InitSSE2() functions be empty on non-SSE2 platform
+c4ea259 make VP8DspInitNEON() public
+4238bc0 Update ChangeLog (v0.2.0)
 c655380 dec/io.c: cosmetics
 fe1958f RGBA4444: harmonize lossless/lossy alpha values
 681cb30 fix RGBA4444 output w/fancy upsampling

NEWS

@@ -1,3 +1,8 @@
+- 10/30/12: version 0.2.1
+  * Various security related fixes
+  * cwebp.exe: fix import errors on Windows XP
+  * enable DLL builds for mingw targets
+
 - 8/3/12: version 0.2.0
   * Add support for ARGB -> YUVA conversion for lossless decoder
     New functions: WebPINewYUVA, WebPIDecGetYUVA

README

@@ -4,7 +4,7 @@
           \__\__/\____/\_____/__/ ____  ___
                 / _/ /    \    \ /  _ \/ _/
                /  \_/   / /   \ \   __/  \__
-               \____/____/\_____/_____/____/v0.2.0
+               \____/____/\_____/_____/____/v0.2.1
 
 Description:
 ============

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT([libwebp], [0.2.0],
+AC_INIT([libwebp], [0.2.1],
         [http://code.google.com/p/webp/issues],,
         [http://developers.google.com/speed/webp])
 AC_CANONICAL_TARGET

examples/cwebp.c

@@ -95,14 +95,12 @@ static int ReadYUV(FILE* in_file, WebPPicture* const pic) {
 
 #ifdef HAVE_WINCODEC_H
 
-#define IFS(fn)                \
-  do {                         \
-     if (SUCCEEDED(hr))        \
-     {                         \
-        hr = (fn);             \
-        if (FAILED(hr) && verbose)           \
-          fprintf(stderr, #fn " failed %08x\n", hr);  \
-     }                         \
+#define IFS(fn)                                                     \
+  do {                                                              \
+     if (SUCCEEDED(hr)) {                                           \
+        hr = (fn);                                                  \
+        if (FAILED(hr)) fprintf(stderr, #fn " failed %08x\n", hr);  \
+     }                                                              \
   } while (0)
 
 // modified version of DEFINE_GUID from guiddef.h.
@@ -115,6 +113,12 @@ static int ReadYUV(FILE* in_file, WebPPicture* const pic) {
 #define MAKE_REFGUID(x) &(x)
 #endif
 
+typedef struct WICFormatImporter {
+  const GUID* pixel_format;
+  int bytes_per_pixel;
+  int (*import)(WebPPicture* const, const uint8_t* const, int);
+} WICFormatImporter;
+
 static HRESULT OpenInputStream(const char* filename, IStream** ppStream) {
   HRESULT hr = S_OK;
   IFS(SHCreateStreamOnFileA(filename, STGM_READ, ppStream));
@@ -125,6 +129,31 @@ static HRESULT OpenInputStream(const char* filename, IStream** ppStream) {
 
 static HRESULT ReadPictureWithWIC(const char* filename,
                                   WebPPicture* const pic, int keep_alpha) {
+  // From Microsoft SDK 7.0a -- wincodec.h
+  // Create local copies for compatibility when building against earlier
+  // versions of the SDK.
+  WEBP_DEFINE_GUID(GUID_WICPixelFormat24bppBGR_,
+                   0x6fddc324, 0x4e03, 0x4bfe,
+                   0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0c);
+  WEBP_DEFINE_GUID(GUID_WICPixelFormat24bppRGB_,
+                   0x6fddc324, 0x4e03, 0x4bfe,
+                   0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0d);
+  WEBP_DEFINE_GUID(GUID_WICPixelFormat32bppBGRA_,
+                   0x6fddc324, 0x4e03, 0x4bfe,
+                   0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0f);
+  WEBP_DEFINE_GUID(GUID_WICPixelFormat32bppRGBA_,
+                   0xf5c7ad2d, 0x6a8d, 0x43dd,
+                   0xa7, 0xa8, 0xa2, 0x99, 0x35, 0x26, 0x1a, 0xe9);
+  const WICFormatImporter alphaFormatImporters[] = {
+    { &GUID_WICPixelFormat32bppBGRA_, 4, WebPPictureImportBGRA },
+    { &GUID_WICPixelFormat32bppRGBA_, 4, WebPPictureImportRGBA },
+    { NULL, 0, NULL },
+  };
+  const WICFormatImporter nonAlphaFormatImporters[] = {
+    { &GUID_WICPixelFormat24bppBGR_, 3, WebPPictureImportBGR },
+    { &GUID_WICPixelFormat24bppRGB_, 3, WebPPictureImportRGB },
+    { NULL, 0, NULL },
+  };
   HRESULT hr = S_OK;
   IWICBitmapFrameDecode* pFrame = NULL;
   IWICFormatConverter* pConverter = NULL;
@@ -135,6 +164,7 @@ static HRESULT ReadPictureWithWIC(const char* filename,
   UINT width = 0, height = 0;
   BYTE* rgb = NULL;
   WICPixelFormatGUID srcPixelFormat = { 0 };
+  const WICFormatImporter* importer = NULL;
   GUID srcContainerFormat = { 0 };
   const GUID* alphaContainers[] = {
     &GUID_ContainerFormatBmp,
@@ -143,18 +173,6 @@ static HRESULT ReadPictureWithWIC(const char* filename,
   };
   int has_alpha = 0;
   int i, stride;
-  // From Microsoft SDK 7.0a
-  // Create local copies for compatibility when building against earlier
-  // versions of the SDK.
-  WEBP_DEFINE_GUID(GUID_WICPixelFormat24bppRGB_,
-                   0x6fddc324, 0x4e03, 0x4bfe,
-                   0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0d);
-  WEBP_DEFINE_GUID(GUID_WICPixelFormat32bppRGBA_,
-                   0xf5c7ad2d, 0x6a8d, 0x43dd,
-                   0xa7, 0xa8, 0xa2, 0x99, 0x35, 0x26, 0x1a, 0xe9);
-  WEBP_DEFINE_GUID(GUID_WICPixelFormat32bppBGRA_,
-                   0x6fddc324, 0x4e03, 0x4bfe,
-                   0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0f);
 
   IFS(CoInitialize(NULL));
   IFS(CoCreateInstance(MAKE_REFGUID(CLSID_WICImagingFactory), NULL,
@@ -179,32 +197,45 @@ static HRESULT ReadPictureWithWIC(const char* filename,
   IFS(IWICBitmapFrameDecode_GetPixelFormat(pFrame, &srcPixelFormat));
   IFS(IWICBitmapDecoder_GetContainerFormat(pDecoder, &srcContainerFormat));
 
-  has_alpha = keep_alpha;
-  for (i = 0;
-       has_alpha && i < sizeof(alphaContainers)/sizeof(alphaContainers[0]);
-       ++i) {
-    if (IsEqualGUID(MAKE_REFGUID(srcContainerFormat),
-                    MAKE_REFGUID(*alphaContainers[i]))) {
-      has_alpha =
-          IsEqualGUID(MAKE_REFGUID(srcPixelFormat),
-                      MAKE_REFGUID(GUID_WICPixelFormat32bppRGBA_)) ||
-          IsEqualGUID(MAKE_REFGUID(srcPixelFormat),
-                      MAKE_REFGUID(GUID_WICPixelFormat32bppBGRA_));
-      break;
+  if (keep_alpha) {
+    for (i = 0;
+         i < sizeof(alphaContainers) / sizeof(alphaContainers[0]);
+         ++i) {
+      if (IsEqualGUID(MAKE_REFGUID(srcContainerFormat),
+                      MAKE_REFGUID(*alphaContainers[i]))) {
+        has_alpha =
+            IsEqualGUID(MAKE_REFGUID(srcPixelFormat),
+                        MAKE_REFGUID(GUID_WICPixelFormat32bppRGBA_)) ||
+            IsEqualGUID(MAKE_REFGUID(srcPixelFormat),
+                        MAKE_REFGUID(GUID_WICPixelFormat32bppBGRA_));
+        break;
+      }
     }
   }
 
   // Prepare for pixel format conversion (if necessary).
   IFS(IWICImagingFactory_CreateFormatConverter(pFactory, &pConverter));
+
+  for (importer = has_alpha ? alphaFormatImporters : nonAlphaFormatImporters;
+       hr == S_OK && importer->import != NULL; ++importer) {
+    BOOL canConvert;
+    const HRESULT cchr = IWICFormatConverter_CanConvert(
+        pConverter,
+        MAKE_REFGUID(srcPixelFormat),
+        MAKE_REFGUID(*importer->pixel_format),
+        &canConvert);
+    if (SUCCEEDED(cchr) && canConvert) break;
+  }
+  if (importer->import == NULL) hr = E_FAIL;
+
   IFS(IWICFormatConverter_Initialize(pConverter, (IWICBitmapSource*)pFrame,
-          has_alpha ? MAKE_REFGUID(GUID_WICPixelFormat32bppRGBA_)
-                    : MAKE_REFGUID(GUID_WICPixelFormat24bppRGB_),
+          importer->pixel_format,
           WICBitmapDitherTypeNone,
           NULL, 0.0, WICBitmapPaletteTypeCustom));
 
   // Decode.
   IFS(IWICFormatConverter_GetSize(pConverter, &width, &height));
-  stride = (has_alpha ? 4 : 3) * width * sizeof(*rgb);
+  stride = importer->bytes_per_pixel * width * sizeof(*rgb);
   if (SUCCEEDED(hr)) {
     rgb = (BYTE*)malloc(stride * height);
     if (rgb == NULL)
@@ -218,8 +249,7 @@ static HRESULT ReadPictureWithWIC(const char* filename,
     int ok;
     pic->width = width;
     pic->height = height;
-    ok = has_alpha ? WebPPictureImportRGBA(pic, rgb, stride)
-                   : WebPPictureImportRGB(pic, rgb, stride);
+    ok = importer->import(pic, rgb, stride);
     if (!ok)
       hr = E_FAIL;
   }

examples/dwebp.c

@@ -67,14 +67,12 @@ typedef enum {
 
 #ifdef HAVE_WINCODEC_H
 
-#define IFS(fn)                \
-  do {                         \
-     if (SUCCEEDED(hr))        \
-     {                         \
-        hr = (fn);             \
-        if (FAILED(hr) && verbose)           \
-          fprintf(stderr, #fn " failed %08x\n", hr);  \
-     }                         \
+#define IFS(fn)                                                     \
+  do {                                                              \
+     if (SUCCEEDED(hr)) {                                           \
+        hr = (fn);                                                  \
+        if (FAILED(hr)) fprintf(stderr, #fn " failed %08x\n", hr);  \
+     }                                                              \
   } while (0)
 
 #ifdef __cplusplus

src/Makefile.am

@@ -20,7 +20,11 @@ libwebp_la_LIBADD += dsp/libwebpdsp.la
 libwebp_la_LIBADD += enc/libwebpencode.la
 libwebp_la_LIBADD += utils/libwebputils.la
 
-libwebp_la_LDFLAGS = -version-info 4:0:0
+# Use '-no-undefined' to declare that libwebp does not depend on any libraries
+# other than the ones listed on the command line, i.e., after linking, it will
+# not have unresolved symbols. Some platforms (Windows among them) require all
+# symbols in shared libraries to be resolved at library creation.
+libwebp_la_LDFLAGS = -no-undefined -version-info 4:1:0
 libwebpincludedir = $(includedir)/webp
 
 pkgconfig_DATA = libwebp.pc

src/dec/vp8i.h

@@ -28,7 +28,7 @@ extern "C" {
 // version numbers
 #define DEC_MAJ_VERSION 0
 #define DEC_MIN_VERSION 2
-#define DEC_REV_VERSION 0
+#define DEC_REV_VERSION 1
 
 #define ONLY_KEYFRAME_CODE      // to remove any code related to P-Frames
 

src/dec/webp.c

@@ -76,6 +76,9 @@ static VP8StatusCode ParseRIFF(const uint8_t** const data,
       if (size < TAG_SIZE + CHUNK_HEADER_SIZE) {
         return VP8_STATUS_BITSTREAM_ERROR;
       }
+      if (size > MAX_CHUNK_PAYLOAD) {
+        return VP8_STATUS_BITSTREAM_ERROR;
+      }
       // We have a RIFF container. Skip it.
       *riff_size = size;
       *data += RIFF_HEADER_SIZE;
@@ -177,6 +180,9 @@ static VP8StatusCode ParseOptionalChunks(const uint8_t** const data,
     }
 
     chunk_size = get_le32(buf + TAG_SIZE);
+    if (chunk_size > MAX_CHUNK_PAYLOAD) {
+      return VP8_STATUS_BITSTREAM_ERROR;          // Not a valid chunk size.
+    }
     // For odd-sized chunk-payload, there's one byte padding at the end.
     disk_chunk_size = (CHUNK_HEADER_SIZE + chunk_size + 1) & ~1;
     total_size += disk_chunk_size;

src/dsp/dec_neon.c

@@ -12,14 +12,14 @@
 
 #include "./dsp.h"
 
-#if defined(WEBP_USE_NEON)
-
-#include "../dec/vp8i.h"
-
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
+#if defined(WEBP_USE_NEON)
+
+#include "../dec/vp8i.h"
+
 #define QRegs "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",                  \
               "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
 
@@ -311,19 +311,24 @@ static void TransformTwoNEON(const int16_t* in, uint8_t* dst, int do_two) {
   }
 }
 
+#endif   // WEBP_USE_NEON
+
+//------------------------------------------------------------------------------
+// Entry point
+
 extern void VP8DspInitNEON(void);
 
 void VP8DspInitNEON(void) {
+#if defined(WEBP_USE_NEON)
   VP8Transform = TransformTwoNEON;
 
   VP8SimpleVFilter16 = SimpleVFilter16NEON;
   VP8SimpleHFilter16 = SimpleHFilter16NEON;
   VP8SimpleVFilter16i = SimpleVFilter16iNEON;
   VP8SimpleHFilter16i = SimpleHFilter16iNEON;
+#endif   // WEBP_USE_NEON
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }    // extern "C"
 #endif
-
-#endif   // WEBP_USE_NEON

src/dsp/dec_sse2.c

@@ -12,15 +12,15 @@
 
 #include "./dsp.h"
 
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
 #if defined(WEBP_USE_SSE2)
 
 #include <emmintrin.h>
 #include "../dec/vp8i.h"
 
-#if defined(__cplusplus) || defined(c_plusplus)
-extern "C" {
-#endif
-
 //------------------------------------------------------------------------------
 // Transforms (Paragraph 14.4)
 
@@ -876,9 +876,15 @@ static void HFilter8iSSE2(uint8_t* u, uint8_t* v, int stride,
   Store16x4(u, v, stride, &p1, &p0, &q0, &q1);
 }
 
+#endif   // WEBP_USE_SSE2
+
+//------------------------------------------------------------------------------
+// Entry point
+
 extern void VP8DspInitSSE2(void);
 
 void VP8DspInitSSE2(void) {
+#if defined(WEBP_USE_SSE2)
   VP8Transform = TransformSSE2;
 
   VP8VFilter16 = VFilter16SSE2;
@@ -894,10 +900,9 @@ void VP8DspInitSSE2(void) {
   VP8SimpleHFilter16 = SimpleHFilter16SSE2;
   VP8SimpleVFilter16i = SimpleVFilter16iSSE2;
   VP8SimpleHFilter16i = SimpleHFilter16iSSE2;
+#endif   // WEBP_USE_SSE2
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }    // extern "C"
 #endif
-
-#endif   // WEBP_USE_SSE2

src/dsp/enc_sse2.c

@@ -11,16 +11,16 @@
 
 #include "./dsp.h"
 
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
 #if defined(WEBP_USE_SSE2)
 #include <stdlib.h>  // for abs()
 #include <emmintrin.h>
 
 #include "../enc/vp8enci.h"
 
-#if defined(__cplusplus) || defined(c_plusplus)
-extern "C" {
-#endif
-
 //------------------------------------------------------------------------------
 // Compute susceptibility based on DCT-coeff histograms:
 // the higher, the "easier" the macroblock is to compress.
@@ -819,8 +819,15 @@ static int QuantizeBlockSSE2(int16_t in[16], int16_t out[16],
   }
 }
 
+#endif   // WEBP_USE_SSE2
+
+//------------------------------------------------------------------------------
+// Entry point
+
 extern void VP8EncDspInitSSE2(void);
+
 void VP8EncDspInitSSE2(void) {
+#if defined(WEBP_USE_SSE2)
   VP8CollectHistogram = CollectHistogramSSE2;
   VP8EncQuantizeBlock = QuantizeBlockSSE2;
   VP8ITransform = ITransformSSE2;
@@ -828,10 +835,9 @@ void VP8EncDspInitSSE2(void) {
   VP8SSE4x4 = SSE4x4SSE2;
   VP8TDisto4x4 = Disto4x4SSE2;
   VP8TDisto16x16 = Disto16x16SSE2;
+#endif   // WEBP_USE_SSE2
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }    // extern "C"
 #endif
-
-#endif   // WEBP_USE_SSE2

src/dsp/upsampling_sse2.c

@@ -11,6 +11,10 @@
 
 #include "./dsp.h"
 
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
 #if defined(WEBP_USE_SSE2)
 
 #include <assert.h>
@@ -18,10 +22,6 @@
 #include <string.h>
 #include "./yuv.h"
 
-#if defined(__cplusplus) || defined(c_plusplus)
-extern "C" {
-#endif
-
 #ifdef FANCY_UPSAMPLING
 
 // We compute (9*a + 3*b + 3*c + d + 8) / 16 as follows
@@ -184,26 +184,32 @@ SSE2_UPSAMPLE_FUNC(UpsampleBgraLinePairSSE2, VP8YuvToBgra, 4)
 #undef CONVERT2RGB
 #undef SSE2_UPSAMPLE_FUNC
 
+#endif  // FANCY_UPSAMPLING
+
+#endif   // WEBP_USE_SSE2
+
 //------------------------------------------------------------------------------
 
 extern WebPUpsampleLinePairFunc WebPUpsamplers[/* MODE_LAST */];
 
 void WebPInitUpsamplersSSE2(void) {
+#if defined(WEBP_USE_SSE2)
   WebPUpsamplers[MODE_RGB]  = UpsampleRgbLinePairSSE2;
   WebPUpsamplers[MODE_RGBA] = UpsampleRgbaLinePairSSE2;
   WebPUpsamplers[MODE_BGR]  = UpsampleBgrLinePairSSE2;
   WebPUpsamplers[MODE_BGRA] = UpsampleBgraLinePairSSE2;
+#endif   // WEBP_USE_SSE2
 }
 
 void WebPInitPremultiplySSE2(void) {
+#if defined(WEBP_USE_SSE2)
   WebPUpsamplers[MODE_rgbA] = UpsampleRgbaLinePairSSE2;
   WebPUpsamplers[MODE_bgrA] = UpsampleBgraLinePairSSE2;
+#endif   // WEBP_USE_SSE2
 }
 
-#endif  // FANCY_UPSAMPLING
-
 #if defined(__cplusplus) || defined(c_plusplus)
 }    // extern "C"
 #endif
 
-#endif   // WEBP_USE_SSE2
+

src/enc/backward_references.c

@@ -459,8 +459,8 @@ static int BackwardReferencesHashChainDistanceOnly(
   const int quality = 100;
   const int pix_count = xsize * ysize;
   const int use_color_cache = (cache_bits > 0);
-  double* const cost =
-      (double*)WebPSafeMalloc((uint64_t)pix_count, sizeof(*cost));
+  float* const cost =
+      (float*)WebPSafeMalloc((uint64_t)pix_count, sizeof(*cost));
   CostModel* cost_model = (CostModel*)malloc(sizeof(*cost_model));
   HashChain* hash_chain = (HashChain*)malloc(sizeof(*hash_chain));
   VP8LColorCache hashers;
@@ -481,7 +481,7 @@ static int BackwardReferencesHashChainDistanceOnly(
     goto Error;
   }
 
-  for (i = 0; i < pix_count; ++i) cost[i] = 1e100;
+  for (i = 0; i < pix_count; ++i) cost[i] = 1e38f;
 
   // We loop one pixel at a time, but store all currently best points to
   // non-processed locations from this point.
@@ -509,10 +509,9 @@ static int BackwardReferencesHashChainDistanceOnly(
             prev_cost + GetDistanceCost(cost_model, code);
         int k;
         for (k = 1; k < len; ++k) {
-          const double cost_val =
-              distance_cost + GetLengthCost(cost_model, k);
+          const double cost_val = distance_cost + GetLengthCost(cost_model, k);
           if (cost[i + k] > cost_val) {
-            cost[i + k] = cost_val;
+            cost[i + k] = (float)cost_val;
             dist_array[i + k] = k + 1;
           }
         }
@@ -554,7 +553,7 @@ static int BackwardReferencesHashChainDistanceOnly(
         cost_val += GetLiteralCost(cost_model, argb[i]) * mul1;
       }
       if (cost[i] > cost_val) {
-        cost[i] = cost_val;
+        cost[i] = (float)cost_val;
         dist_array[i] = 1;  // only one is inserted.
       }
       if (use_color_cache) VP8LColorCacheInsert(&hashers, argb[i]);

src/enc/histogram.c

@@ -55,9 +55,9 @@ VP8LHistogramSet* VP8LAllocateHistogramSet(int size, int cache_bits) {
   int i;
   VP8LHistogramSet* set;
   VP8LHistogram* bulk;
-  const uint64_t total_size = (uint64_t)sizeof(*set)
-                            + size * sizeof(*set->histograms)
-                            + size * sizeof(**set->histograms);
+  const uint64_t total_size = sizeof(*set)
+                            + (uint64_t)size * sizeof(*set->histograms)
+                            + (uint64_t)size * sizeof(**set->histograms);
   uint8_t* memory = (uint8_t*)WebPSafeMalloc(total_size, sizeof(*memory));
   if (memory == NULL) return NULL;
 

src/enc/vp8enci.h

@@ -27,7 +27,7 @@ extern "C" {
 // version numbers
 #define ENC_MAJ_VERSION 0
 #define ENC_MIN_VERSION 2
-#define ENC_REV_VERSION 0
+#define ENC_REV_VERSION 1
 
 // size of histogram used by CollectHistogram.
 #define MAX_COEFF_THRESH   64

src/enc/vp8l.c

@@ -529,7 +529,12 @@ static int EncodeImageInternal(VP8LBitWriter* const bw,
                                 sizeof(*histogram_symbols));
   assert(histogram_bits >= MIN_HUFFMAN_BITS);
   assert(histogram_bits <= MAX_HUFFMAN_BITS);
-  if (histogram_image == NULL || histogram_symbols == NULL) goto Error;
+
+  if (histogram_image == NULL || histogram_symbols == NULL) {
+    free(histogram_image);
+    free(histogram_symbols);
+    return 0;
+  }
 
   // Calculate backward references from ARGB image.
   if (!VP8LGetBackwardReferences(width, height, argb, quality, cache_bits,
@@ -898,13 +903,13 @@ static int GetHistoBits(const WebPConfig* const config,
                         const WebPPicture* const pic) {
   const int width = pic->width;
   const int height = pic->height;
-  const size_t hist_size = sizeof(VP8LHistogram);
+  const uint64_t hist_size = sizeof(VP8LHistogram);
   // Make tile size a function of encoding method (Range: 0 to 6).
   int histo_bits = 7 - config->method;
   while (1) {
-    const size_t huff_image_size = VP8LSubSampleSize(width, histo_bits) *
-                                   VP8LSubSampleSize(height, histo_bits) *
-                                   hist_size;
+    const uint64_t huff_image_size = VP8LSubSampleSize(width, histo_bits) *
+                                     VP8LSubSampleSize(height, histo_bits) *
+                                     hist_size;
     if (huff_image_size <= MAX_HUFF_IMAGE_SIZE) break;
     ++histo_bits;
   }

src/utils/bit_reader.h

@@ -93,6 +93,8 @@ static WEBP_INLINE void VP8LoadNewBytes(VP8BitReader* const br) {
 #elif (BITS == 16)
     // gcc will recognize a 'rorw $8, ...' here:
     bits = (bit_t)(in_bits >> 8) | ((in_bits & 0xff) << 8);
+#else   // BITS == 8
+    bits = (bit_t)in_bits;
 #endif
 #else    // LITTLE_ENDIAN
     bits = (bit_t)in_bits;