Home | History | Annotate | Download | only in vda 
      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 // Note: ported from Chromium commit head: 2de6929
      5 
      6 #include "base/logging.h"
      7 #include "h264_bit_reader.h"
      8 
      9 namespace media {
     10 
     11 H264BitReader::H264BitReader()
     12     : data_(NULL),
     13       bytes_left_(0),
     14       curr_byte_(0),
     15       num_remaining_bits_in_curr_byte_(0),
     16       prev_two_bytes_(0),
     17       emulation_prevention_bytes_(0) {}
     18 
     19 H264BitReader::~H264BitReader() = default;
     20 
     21 bool H264BitReader::Initialize(const uint8_t* data, off_t size) {
     22   DCHECK(data);
     23 
     24   if (size < 1)
     25     return false;
     26 
     27   data_ = data;
     28   bytes_left_ = size;
     29   num_remaining_bits_in_curr_byte_ = 0;
     30   // Initially set to 0xffff to accept all initial two-byte sequences.
     31   prev_two_bytes_ = 0xffff;
     32   emulation_prevention_bytes_ = 0;
     33 
     34   return true;
     35 }
     36 
     37 bool H264BitReader::UpdateCurrByte() {
     38   if (bytes_left_ < 1)
     39     return false;
     40 
     41   // Emulation prevention three-byte detection.
     42   // If a sequence of 0x000003 is found, skip (ignore) the last byte (0x03).
     43   if (*data_ == 0x03 && (prev_two_bytes_ & 0xffff) == 0) {
     44     // Detected 0x000003, skip last byte.
     45     ++data_;
     46     --bytes_left_;
     47     ++emulation_prevention_bytes_;
     48     // Need another full three bytes before we can detect the sequence again.
     49     prev_two_bytes_ = 0xffff;
     50 
     51     if (bytes_left_ < 1)
     52       return false;
     53   }
     54 
     55   // Load a new byte and advance pointers.
     56   curr_byte_ = *data_++ & 0xff;
     57   --bytes_left_;
     58   num_remaining_bits_in_curr_byte_ = 8;
     59 
     60   prev_two_bytes_ = ((prev_two_bytes_ & 0xff) << 8) | curr_byte_;
     61 
     62   return true;
     63 }
     64 
     65 // Read |num_bits| (1 to 31 inclusive) from the stream and return them
     66 // in |out|, with first bit in the stream as MSB in |out| at position
     67 // (|num_bits| - 1).
     68 bool H264BitReader::ReadBits(int num_bits, int* out) {
     69   int bits_left = num_bits;
     70   *out = 0;
     71   DCHECK(num_bits <= 31);
     72 
     73   while (num_remaining_bits_in_curr_byte_ < bits_left) {
     74     // Take all that's left in current byte, shift to make space for the rest.
     75     *out |= (curr_byte_ << (bits_left - num_remaining_bits_in_curr_byte_));
     76     bits_left -= num_remaining_bits_in_curr_byte_;
     77 
     78     if (!UpdateCurrByte())
     79       return false;
     80   }
     81 
     82   *out |= (curr_byte_ >> (num_remaining_bits_in_curr_byte_ - bits_left));
     83   *out &= ((1u << num_bits) - 1u);
     84   num_remaining_bits_in_curr_byte_ -= bits_left;
     85 
     86   return true;
     87 }
     88 
     89 off_t H264BitReader::NumBitsLeft() {
     90   return (num_remaining_bits_in_curr_byte_ + bytes_left_ * 8);
     91 }
     92 
     93 bool H264BitReader::HasMoreRBSPData() {
     94   // Make sure we have more bits, if we are at 0 bits in current byte and
     95   // updating current byte fails, we don't have more data anyway.
     96   if (num_remaining_bits_in_curr_byte_ == 0 && !UpdateCurrByte())
     97     return false;
     98 
     99   // If there is no more RBSP data, then |curr_byte_| contains the stop bit and
    100   // zero padding. Check to see if there is other data instead.
    101   // (We don't actually check for the stop bit itself, instead treating the
    102   // invalid case of all trailing zeros identically).
    103   if ((curr_byte_ & ((1 << (num_remaining_bits_in_curr_byte_ - 1)) - 1)) != 0)
    104     return true;
    105 
    106   // While the spec disallows it (7.4.1: "The last byte of the NAL unit shall
    107   // not be equal to 0x00"), some streams have trailing null bytes anyway. We
    108   // don't handle emulation prevention sequences because HasMoreRBSPData() is
    109   // not used when parsing slices (where cabac_zero_word elements are legal).
    110   for (off_t i = 0; i < bytes_left_; i++) {
    111     if (data_[i] != 0)
    112       return true;
    113   }
    114 
    115   bytes_left_ = 0;
    116   return false;
    117 }
    118 
    119 size_t H264BitReader::NumEmulationPreventionBytesRead() {
    120   return emulation_prevention_bytes_;
    121 }
    122 
    123 }  // namespace media
    124