Home | History | Annotate | Download | only in base 
      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
    190