Update libwebp to 0.4.0

third_party/libwebp/utils/bit_writer.c

 // Copyright 2011 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.
 // -----------------------------------------------------------------------------
 //
 // Bit writing and boolean coder
 //
 // Author: Skal (pascal.massimino@gmail.com)
 //         Vikas Arora (vikaas.arora@gmail.com)
 
 #include <assert.h>
 #include <string.h>   // for memcpy()
 #include <stdlib.h>
 #include "./bit_writer.h"
 
-#if defined(__cplusplus) || defined(c_plusplus)
-extern "C" {
-#endif
-
 //------------------------------------------------------------------------------
 // VP8BitWriter
 
 static int BitWriterResize(VP8BitWriter* const bw, size_t extra_size) {
   uint8_t* new_buf;
   size_t new_size;
   const uint64_t needed_size_64b = (uint64_t)bw->pos_ + extra_size;
   const size_t needed_size = (size_t)needed_size_64b;
   if (needed_size_64b != needed_size) {
     bw->error_ = 1;
     return 0;
   }
   if (needed_size <= bw->max_pos_) return 1;
   // If the following line wraps over 32bit, the test just after will catch it.
   new_size = 2 * bw->max_pos_;
   if (new_size < needed_size) new_size = needed_size;
   if (new_size < 1024) new_size = 1024;
   new_buf = (uint8_t*)malloc(new_size);
   if (new_buf == NULL) {
     bw->error_ = 1;
     return 0;
   }
-  memcpy(new_buf, bw->buf_, bw->pos_);
+  if (bw->pos_ > 0) {
+    assert(bw->buf_ != NULL);
+    memcpy(new_buf, bw->buf_, bw->pos_);
+  }
   free(bw->buf_);
   bw->buf_ = new_buf;
   bw->max_pos_ = new_size;
   return 1;
 }
 
 static void kFlush(VP8BitWriter* const bw) {
   const int s = 8 + bw->nb_bits_;
   const int32_t bits = bw->value_ >> s;
   assert(bw->nb_bits_ >= 0);
@@ skipping 189 matching lines @@
     uint32_t v = *(const uint32_t*)p;
     v |= bits << (bw->bit_pos_ & 7);
     *(uint32_t*)p = v;
     bw->bit_pos_ += n_bits;
   }
 #else  // BIG_ENDIAN
   {
     uint8_t* p = &bw->buf_[bw->bit_pos_ >> 3];
     const int bits_reserved_in_first_byte = bw->bit_pos_ & 7;
     const int bits_left_to_write = n_bits - 8 + bits_reserved_in_first_byte;
-    // implicit & 0xff is assumed for uint8_t arithmetics
+    // implicit & 0xff is assumed for uint8_t arithmetic
     *p++ |= bits << bits_reserved_in_first_byte;
     bits >>= 8 - bits_reserved_in_first_byte;
     if (bits_left_to_write >= 1) {
       *p++ = bits;
       bits >>= 8;
       if (bits_left_to_write >= 9) {
         *p++ = bits;
         bits >>= 8;
       }
     }
     assert(n_bits <= 25);
     *p = bits;
     bw->bit_pos_ += n_bits;
   }
 #endif
   if ((bw->bit_pos_ >> 3) > (bw->max_bytes_ - 8)) {
     const uint64_t extra_size = 32768ULL + bw->max_bytes_;
     if (extra_size != (size_t)extra_size ||
         !VP8LBitWriterResize(bw, (size_t)extra_size)) {
       bw->bit_pos_ = 0;
       bw->error_ = 1;
     }
   }
 }
 
 //------------------------------------------------------------------------------
 
-#if defined(__cplusplus) || defined(c_plusplus)
-}    // extern "C"
-#endif