media/base/bit_reader_core.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/base/bit_reader_core.h"
   6
   7 #include <base/port.h>
   8 #include <base/sys_byteorder.h>
   9
  10 namespace {
  11 const int kRegWidthInBits = sizeof(uint64) * 8;
  12 }
  13
  14 namespace media {
  15
  16 BitReaderCore::ByteStreamProvider::ByteStreamProvider() {
  17 }
  18
  19 BitReaderCore::ByteStreamProvider::~ByteStreamProvider() {
  20 }
  21
  22 BitReaderCore::BitReaderCore(ByteStreamProvider* byte_stream_provider)
  23     : byte_stream_provider_(byte_stream_provider),
  24       bits_read_(0),
  25       nbits_(0),
  26       reg_(0),
  27       nbits_next_(0),
  28       reg_next_(0) {
  29 }
  30
  31 BitReaderCore::~BitReaderCore() {
  32 }
  33
  34 bool BitReaderCore::ReadFlag(bool* flag) {
  35   if (nbits_ == 0 && !Refill(1))
  36     return false;
  37
  38   *flag = (reg_ & (GG_UINT64_C(1) << (kRegWidthInBits - 1))) != 0;
  39   reg_ <<= 1;
  40   nbits_--;
  41   bits_read_++;
  42   return true;
  43 }
  44
  45 int BitReaderCore::PeekBitsMsbAligned(int num_bits, uint64* out) {
  46   // Try to have at least |num_bits| in the bit register.
  47   if (nbits_ < num_bits)
  48     Refill(num_bits);
  49
  50   *out = reg_;
  51   return nbits_;
  52 }
  53
  54 bool BitReaderCore::SkipBitsSmall(int num_bits) {
  55   DCHECK_GE(num_bits, 0);
  56   uint64 dummy;
  57   while (num_bits >= kRegWidthInBits) {
  58     if (!ReadBitsInternal(kRegWidthInBits, &dummy))
  59       return false;
  60     num_bits -= kRegWidthInBits;
  61   }
  62   return ReadBitsInternal(num_bits, &dummy);
  63 }
  64
  65 bool BitReaderCore::SkipBits(int num_bits) {
  66   DCHECK_GE(num_bits, 0);
  67
  68   const int remaining_bits = nbits_ + nbits_next_;
  69   if (remaining_bits >= num_bits)
  70     return SkipBitsSmall(num_bits);
  71
  72   // Skip first the remaining available bits.
  73   num_bits -= remaining_bits;
  74   bits_read_ += remaining_bits;
  75   nbits_ = 0;
  76   reg_ = 0;
  77   nbits_next_ = 0;
  78   reg_next_ = 0;
  79
  80   // Next, skip an integer number of bytes.
  81   const int nbytes = num_bits / 8;
  82   if (nbytes > 0) {
  83     const uint8* byte_stream_window;
  84     const int window_size =
  85         byte_stream_provider_->GetBytes(nbytes, &byte_stream_window);
  86     DCHECK_GE(window_size, 0);
  87     DCHECK_LE(window_size, nbytes);
  88     if (window_size < nbytes)
  89       return false;
  90     num_bits -= 8 * nbytes;
  91     bits_read_ += 8 * nbytes;
  92   }
  93
  94   // Skip the remaining bits.
  95   return SkipBitsSmall(num_bits);
  96 }
  97
  98 int BitReaderCore::bits_read() const {
  99   return bits_read_;
 100 }
 101
 102 bool BitReaderCore::ReadBitsInternal(int num_bits, uint64* out) {
 103   DCHECK_GE(num_bits, 0);
 104
 105   if (num_bits == 0) {
 106     *out = 0;
 107     return true;
 108   }
 109
 110   if (num_bits > nbits_ && !Refill(num_bits)) {
 111     // Any subsequent ReadBits should fail:
 112     // empty the current bit register for that purpose.
 113     nbits_ = 0;
 114     reg_ = 0;
 115     return false;
 116   }
 117
 118   bits_read_ += num_bits;
 119
 120   if (num_bits == kRegWidthInBits) {
 121     // Special case needed since for example for a 64 bit integer "a"
 122     // "a << 64" is not defined by the C/C++ standard.
 123     *out = reg_;
 124     reg_ = 0;
 125     nbits_ = 0;
 126     return true;
 127   }
 128
 129   *out = reg_ >> (kRegWidthInBits - num_bits);
 130   reg_ <<= num_bits;
 131   nbits_ -= num_bits;
 132   return true;
 133 }
 134
 135 bool BitReaderCore::Refill(int min_nbits) {
 136   DCHECK_LE(min_nbits, kRegWidthInBits);
 137
 138   // Transfer from the next to the current register.
 139   RefillCurrentRegister();
 140   if (min_nbits <= nbits_)
 141     return true;
 142   DCHECK_EQ(nbits_next_, 0);
 143   DCHECK_EQ(reg_next_, 0u);
 144
 145   // Max number of bytes to refill.
 146   int max_nbytes = sizeof(reg_next_);
 147
 148   // Refill.
 149   const uint8* byte_stream_window;
 150   int window_size =
 151       byte_stream_provider_->GetBytes(max_nbytes, &byte_stream_window);
 152   DCHECK_GE(window_size, 0);
 153   DCHECK_LE(window_size, max_nbytes);
 154   if (window_size == 0)
 155     return false;
 156
 157   reg_next_ = 0;
 158   memcpy(&reg_next_, byte_stream_window, window_size);
 159   reg_next_ = base::NetToHost64(reg_next_);
 160   nbits_next_ = window_size * 8;
 161
 162   // Transfer from the next to the current register.
 163   RefillCurrentRegister();
 164
 165   return (nbits_ >= min_nbits);
 166 }
 167
 168 void BitReaderCore::RefillCurrentRegister() {
 169   // No refill possible if the destination register is full
 170   // or the source register is empty.
 171   if (nbits_ == kRegWidthInBits || nbits_next_ == 0)
 172     return;
 173
 174   reg_ |= (reg_next_ >> nbits_);
 175
 176   int free_nbits = kRegWidthInBits - nbits_;
 177   if (free_nbits >= nbits_next_) {
 178     nbits_ += nbits_next_;
 179     reg_next_ = 0;
 180     nbits_next_ = 0;
 181     return;
 182   }
 183
 184   nbits_ += free_nbits;
 185   reg_next_ <<= free_nbits;
 186   nbits_next_ -= free_nbits;
 187 }
 188
 189 }  // namespace media