bit_reader_core.cc 4.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192
  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. #include "media/base/bit_reader_core.h"
  5. #include <stdint.h>
  6. #include <cstring>
  7. #include "base/sys_byteorder.h"
  8. namespace {
  9. const int kRegWidthInBits = sizeof(uint64_t) * 8;
  10. }
  11. namespace media {
  12. BitReaderCore::ByteStreamProvider::ByteStreamProvider() = default;
  13. BitReaderCore::ByteStreamProvider::~ByteStreamProvider() = default;
  14. BitReaderCore::BitReaderCore(ByteStreamProvider* byte_stream_provider)
  15. : byte_stream_provider_(byte_stream_provider),
  16. bits_read_(0),
  17. nbits_(0),
  18. reg_(0),
  19. nbits_next_(0),
  20. reg_next_(0) {
  21. }
  22. BitReaderCore::~BitReaderCore() = default;
  23. bool BitReaderCore::ReadFlag(bool* flag) {
  24. if (nbits_ == 0 && !Refill(1))
  25. return false;
  26. *flag = (reg_ & (UINT64_C(1) << (kRegWidthInBits - 1))) != 0;
  27. reg_ <<= 1;
  28. nbits_--;
  29. bits_read_++;
  30. return true;
  31. }
  32. int BitReaderCore::PeekBitsMsbAligned(int num_bits, uint64_t* out) {
  33. // Try to have at least |num_bits| in the bit register.
  34. if (nbits_ < num_bits)
  35. Refill(num_bits);
  36. *out = reg_;
  37. return nbits_;
  38. }
  39. bool BitReaderCore::SkipBitsSmall(int num_bits) {
  40. DCHECK_GE(num_bits, 0);
  41. uint64_t dummy;
  42. while (num_bits >= kRegWidthInBits) {
  43. if (!ReadBitsInternal(kRegWidthInBits, &dummy))
  44. return false;
  45. num_bits -= kRegWidthInBits;
  46. }
  47. return ReadBitsInternal(num_bits, &dummy);
  48. }
  49. bool BitReaderCore::SkipBits(int num_bits) {
  50. DCHECK_GE(num_bits, 0);
  51. const int remaining_bits = nbits_ + nbits_next_;
  52. if (remaining_bits >= num_bits)
  53. return SkipBitsSmall(num_bits);
  54. // Skip first the remaining available bits.
  55. num_bits -= remaining_bits;
  56. bits_read_ += remaining_bits;
  57. nbits_ = 0;
  58. reg_ = 0;
  59. nbits_next_ = 0;
  60. reg_next_ = 0;
  61. // Next, skip an integer number of bytes.
  62. const int nbytes = num_bits / 8;
  63. if (nbytes > 0) {
  64. const uint8_t* byte_stream_window;
  65. const int window_size =
  66. byte_stream_provider_->GetBytes(nbytes, &byte_stream_window);
  67. DCHECK_GE(window_size, 0);
  68. DCHECK_LE(window_size, nbytes);
  69. if (window_size < nbytes) {
  70. // Note that some bytes were consumed.
  71. bits_read_ += 8 * window_size;
  72. return false;
  73. }
  74. num_bits -= 8 * nbytes;
  75. bits_read_ += 8 * nbytes;
  76. }
  77. // Skip the remaining bits.
  78. return SkipBitsSmall(num_bits);
  79. }
  80. int BitReaderCore::bits_read() const {
  81. return bits_read_;
  82. }
  83. bool BitReaderCore::ReadBitsInternal(int num_bits, uint64_t* out) {
  84. DCHECK_GE(num_bits, 0);
  85. if (num_bits == 0) {
  86. *out = 0;
  87. return true;
  88. }
  89. if (num_bits > nbits_ && !Refill(num_bits)) {
  90. // Any subsequent ReadBits should fail:
  91. // empty the current bit register for that purpose.
  92. nbits_ = 0;
  93. reg_ = 0;
  94. *out = 0;
  95. return false;
  96. }
  97. bits_read_ += num_bits;
  98. if (num_bits == kRegWidthInBits) {
  99. // Special case needed since for example for a 64 bit integer "a"
  100. // "a << 64" is not defined by the C/C++ standard.
  101. *out = reg_;
  102. reg_ = 0;
  103. nbits_ = 0;
  104. return true;
  105. }
  106. *out = reg_ >> (kRegWidthInBits - num_bits);
  107. reg_ <<= num_bits;
  108. nbits_ -= num_bits;
  109. return true;
  110. }
  111. bool BitReaderCore::Refill(int min_nbits) {
  112. DCHECK_LE(min_nbits, kRegWidthInBits);
  113. // Transfer from the next to the current register.
  114. RefillCurrentRegister();
  115. if (min_nbits <= nbits_)
  116. return true;
  117. DCHECK_EQ(nbits_next_, 0);
  118. DCHECK_EQ(reg_next_, 0u);
  119. // Max number of bytes to refill.
  120. int max_nbytes = sizeof(reg_next_);
  121. // Refill.
  122. const uint8_t* byte_stream_window;
  123. int window_size =
  124. byte_stream_provider_->GetBytes(max_nbytes, &byte_stream_window);
  125. DCHECK_GE(window_size, 0);
  126. DCHECK_LE(window_size, max_nbytes);
  127. if (window_size == 0)
  128. return false;
  129. reg_next_ = 0;
  130. memcpy(&reg_next_, byte_stream_window, window_size);
  131. reg_next_ = base::NetToHost64(reg_next_);
  132. nbits_next_ = window_size * 8;
  133. // Transfer from the next to the current register.
  134. RefillCurrentRegister();
  135. return (nbits_ >= min_nbits);
  136. }
  137. void BitReaderCore::RefillCurrentRegister() {
  138. // No refill possible if the destination register is full
  139. // or the source register is empty.
  140. if (nbits_ == kRegWidthInBits || nbits_next_ == 0)
  141. return;
  142. reg_ |= (reg_next_ >> nbits_);
  143. int free_nbits = kRegWidthInBits - nbits_;
  144. if (free_nbits >= nbits_next_) {
  145. nbits_ += nbits_next_;
  146. reg_next_ = 0;
  147. nbits_next_ = 0;
  148. return;
  149. }
  150. nbits_ += free_nbits;
  151. reg_next_ <<= free_nbits;
  152. nbits_next_ -= free_nbits;
  153. }
  154. } // namespace media