// Copyright 2014 The Chromium Authors. All rights reserved.
|
// Use of this source code is governed by a BSD-style license that can be
|
// found in the LICENSE file.
|
// Note: ported from Chromium commit head: 2de6929
|
|
#include "bit_reader_core.h"
|
|
#include <stdint.h>
|
|
#include "base/sys_byteorder.h"
|
|
namespace {
|
const int kRegWidthInBits = sizeof(uint64_t) * 8;
|
}
|
|
namespace media {
|
|
BitReaderCore::ByteStreamProvider::ByteStreamProvider() = default;
|
|
BitReaderCore::ByteStreamProvider::~ByteStreamProvider() = default;
|
|
BitReaderCore::BitReaderCore(ByteStreamProvider* byte_stream_provider)
|
: byte_stream_provider_(byte_stream_provider),
|
bits_read_(0),
|
nbits_(0),
|
reg_(0),
|
nbits_next_(0),
|
reg_next_(0) {
|
}
|
|
BitReaderCore::~BitReaderCore() = default;
|
|
bool BitReaderCore::ReadFlag(bool* flag) {
|
if (nbits_ == 0 && !Refill(1))
|
return false;
|
|
*flag = (reg_ & (UINT64_C(1) << (kRegWidthInBits - 1))) != 0;
|
reg_ <<= 1;
|
nbits_--;
|
bits_read_++;
|
return true;
|
}
|
|
int BitReaderCore::PeekBitsMsbAligned(int num_bits, uint64_t* out) {
|
// Try to have at least |num_bits| in the bit register.
|
if (nbits_ < num_bits)
|
Refill(num_bits);
|
|
*out = reg_;
|
return nbits_;
|
}
|
|
bool BitReaderCore::SkipBitsSmall(int num_bits) {
|
DCHECK_GE(num_bits, 0);
|
uint64_t dummy;
|
while (num_bits >= kRegWidthInBits) {
|
if (!ReadBitsInternal(kRegWidthInBits, &dummy))
|
return false;
|
num_bits -= kRegWidthInBits;
|
}
|
return ReadBitsInternal(num_bits, &dummy);
|
}
|
|
bool BitReaderCore::SkipBits(int num_bits) {
|
DCHECK_GE(num_bits, 0);
|
|
const int remaining_bits = nbits_ + nbits_next_;
|
if (remaining_bits >= num_bits)
|
return SkipBitsSmall(num_bits);
|
|
// Skip first the remaining available bits.
|
num_bits -= remaining_bits;
|
bits_read_ += remaining_bits;
|
nbits_ = 0;
|
reg_ = 0;
|
nbits_next_ = 0;
|
reg_next_ = 0;
|
|
// Next, skip an integer number of bytes.
|
const int nbytes = num_bits / 8;
|
if (nbytes > 0) {
|
const uint8_t* byte_stream_window;
|
const int window_size =
|
byte_stream_provider_->GetBytes(nbytes, &byte_stream_window);
|
DCHECK_GE(window_size, 0);
|
DCHECK_LE(window_size, nbytes);
|
if (window_size < nbytes) {
|
// Note that some bytes were consumed.
|
bits_read_ += 8 * window_size;
|
return false;
|
}
|
num_bits -= 8 * nbytes;
|
bits_read_ += 8 * nbytes;
|
}
|
|
// Skip the remaining bits.
|
return SkipBitsSmall(num_bits);
|
}
|
|
int BitReaderCore::bits_read() const {
|
return bits_read_;
|
}
|
|
bool BitReaderCore::ReadBitsInternal(int num_bits, uint64_t* out) {
|
DCHECK_GE(num_bits, 0);
|
|
if (num_bits == 0) {
|
*out = 0;
|
return true;
|
}
|
|
if (num_bits > nbits_ && !Refill(num_bits)) {
|
// Any subsequent ReadBits should fail:
|
// empty the current bit register for that purpose.
|
nbits_ = 0;
|
reg_ = 0;
|
return false;
|
}
|
|
bits_read_ += num_bits;
|
|
if (num_bits == kRegWidthInBits) {
|
// Special case needed since for example for a 64 bit integer "a"
|
// "a << 64" is not defined by the C/C++ standard.
|
*out = reg_;
|
reg_ = 0;
|
nbits_ = 0;
|
return true;
|
}
|
|
*out = reg_ >> (kRegWidthInBits - num_bits);
|
reg_ <<= num_bits;
|
nbits_ -= num_bits;
|
return true;
|
}
|
|
bool BitReaderCore::Refill(int min_nbits) {
|
DCHECK_LE(min_nbits, kRegWidthInBits);
|
|
// Transfer from the next to the current register.
|
RefillCurrentRegister();
|
if (min_nbits <= nbits_)
|
return true;
|
DCHECK_EQ(nbits_next_, 0);
|
DCHECK_EQ(reg_next_, 0u);
|
|
// Max number of bytes to refill.
|
int max_nbytes = sizeof(reg_next_);
|
|
// Refill.
|
const uint8_t* byte_stream_window;
|
int window_size =
|
byte_stream_provider_->GetBytes(max_nbytes, &byte_stream_window);
|
DCHECK_GE(window_size, 0);
|
DCHECK_LE(window_size, max_nbytes);
|
if (window_size == 0)
|
return false;
|
|
reg_next_ = 0;
|
memcpy(®_next_, byte_stream_window, window_size);
|
reg_next_ = base::NetToHost64(reg_next_);
|
nbits_next_ = window_size * 8;
|
|
// Transfer from the next to the current register.
|
RefillCurrentRegister();
|
|
return (nbits_ >= min_nbits);
|
}
|
|
void BitReaderCore::RefillCurrentRegister() {
|
// No refill possible if the destination register is full
|
// or the source register is empty.
|
if (nbits_ == kRegWidthInBits || nbits_next_ == 0)
|
return;
|
|
reg_ |= (reg_next_ >> nbits_);
|
|
int free_nbits = kRegWidthInBits - nbits_;
|
if (free_nbits >= nbits_next_) {
|
nbits_ += nbits_next_;
|
reg_next_ = 0;
|
nbits_next_ = 0;
|
return;
|
}
|
|
nbits_ += free_nbits;
|
reg_next_ <<= free_nbits;
|
nbits_next_ -= free_nbits;
|
}
|
|
} // namespace media
|
