libwebp: update to 0.4.2-rc2

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
@@ skipping 34 matching lines @@
   if (bw->pos_ > 0) {
     assert(bw->buf_ != NULL);
     memcpy(new_buf, bw->buf_, bw->pos_);
   }
   WebPSafeFree(bw->buf_);
   bw->buf_ = new_buf;
   bw->max_pos_ = new_size;
   return 1;
 }
 
-static void kFlush(VP8BitWriter* const bw) {
+static void Flush(VP8BitWriter* const bw) {
   const int s = 8 + bw->nb_bits_;
   const int32_t bits = bw->value_ >> s;
   assert(bw->nb_bits_ >= 0);
   bw->value_ -= bits << s;
   bw->nb_bits_ -= 8;
   if ((bits & 0xff) != 0xff) {
     size_t pos = bw->pos_;
     if (!BitWriterResize(bw, bw->run_ + 1)) {
       return;
     }
@@ skipping 45 matching lines @@
     bw->value_ += split + 1;
     bw->range_ -= split + 1;
   } else {
     bw->range_ = split;
   }
   if (bw->range_ < 127) {   // emit 'shift' bits out and renormalize
     const int shift = kNorm[bw->range_];
     bw->range_ = kNewRange[bw->range_];
     bw->value_ <<= shift;
     bw->nb_bits_ += shift;
-    if (bw->nb_bits_ > 0) kFlush(bw);
+    if (bw->nb_bits_ > 0) Flush(bw);
   }
   return bit;
 }
 
 int VP8PutBitUniform(VP8BitWriter* const bw, int bit) {
   const int split = bw->range_ >> 1;
   if (bit) {
     bw->value_ += split + 1;
     bw->range_ -= split + 1;
   } else {
     bw->range_ = split;
   }
   if (bw->range_ < 127) {
     bw->range_ = kNewRange[bw->range_];
     bw->value_ <<= 1;
     bw->nb_bits_ += 1;
-    if (bw->nb_bits_ > 0) kFlush(bw);
+    if (bw->nb_bits_ > 0) Flush(bw);
   }
   return bit;
 }
 
 void VP8PutValue(VP8BitWriter* const bw, int value, int nb_bits) {
   int mask;
   for (mask = 1 << (nb_bits - 1); mask; mask >>= 1)
     VP8PutBitUniform(bw, value & mask);
 }
 
@@ skipping 17 matching lines @@
   bw->pos_     = 0;
   bw->max_pos_ = 0;
   bw->error_   = 0;
   bw->buf_     = NULL;
   return (expected_size > 0) ? BitWriterResize(bw, expected_size) : 1;
 }
 
 uint8_t* VP8BitWriterFinish(VP8BitWriter* const bw) {
   VP8PutValue(bw, 0, 9 - bw->nb_bits_);
   bw->nb_bits_ = 0;   // pad with zeroes
-  kFlush(bw);
+  Flush(bw);
   return bw->buf_;
 }
 
 int VP8BitWriterAppend(VP8BitWriter* const bw,
                        const uint8_t* data, size_t size) {
   assert(data != NULL);
-  if (bw->nb_bits_ != -8) return 0;   // kFlush() must have been called
+  if (bw->nb_bits_ != -8) return 0;   // Flush() must have been called
   if (!BitWriterResize(bw, size)) return 0;
   memcpy(bw->buf_ + bw->pos_, data, size);
   bw->pos_ += size;
   return 1;
 }
 
 void VP8BitWriterWipeOut(VP8BitWriter* const bw) {
   if (bw != NULL) {
     WebPSafeFree(bw->buf_);
     memset(bw, 0, sizeof(*bw));
@@ skipping 104 matching lines @@
       *bw->cur_++ = (uint8_t)bw->bits_;
       bw->bits_ >>= 8;
       bw->used_ -= 8;
     }
     bw->used_ = 0;
   }
   return bw->buf_;
 }
 
 //------------------------------------------------------------------------------