src/content/common/gpu/media/h264_bit_reader.cc

   1 // Copyright (c) 2012 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 "content/common/gpu/media/h264_bit_reader.h"
   6 #include "base/logging.h"
   7
   8 namespace content {
   9
  10 H264BitReader::H264BitReader()
  11     : data_(NULL), bytes_left_(0), curr_byte_(0),
  12       num_remaining_bits_in_curr_byte_(0), prev_two_bytes_(0),
  13       emulation_prevention_bytes_(0) {
  14 }
  15
  16 H264BitReader::~H264BitReader() {}
  17
  18 bool H264BitReader::Initialize(const uint8* data, off_t size) {
  19   DCHECK(data);
  20
  21   if (size < 1)
  22     return false;
  23
  24   data_ = data;
  25   bytes_left_ = size;
  26   num_remaining_bits_in_curr_byte_ = 0;
  27   // Initially set to 0xffff to accept all initial two-byte sequences.
  28   prev_two_bytes_ = 0xffff;
  29   emulation_prevention_bytes_ = 0;
  30
  31   return true;
  32 }
  33
  34 bool H264BitReader::UpdateCurrByte() {
  35   if (bytes_left_ < 1)
  36     return false;
  37
  38   // Emulation prevention three-byte detection.
  39   // If a sequence of 0x000003 is found, skip (ignore) the last byte (0x03).
  40   if (*data_ == 0x03 && (prev_two_bytes_ & 0xffff) == 0) {
  41     // Detected 0x000003, skip last byte.
  42     ++data_;
  43     --bytes_left_;
  44     ++emulation_prevention_bytes_;
  45     // Need another full three bytes before we can detect the sequence again.
  46     prev_two_bytes_ = 0xffff;
  47
  48     if (bytes_left_ < 1)
  49       return false;
  50   }
  51
  52   // Load a new byte and advance pointers.
  53   curr_byte_ = *data_++ & 0xff;
  54   --bytes_left_;
  55   num_remaining_bits_in_curr_byte_ = 8;
  56
  57   prev_two_bytes_ = (prev_two_bytes_ << 8) | curr_byte_;
  58
  59   return true;
  60 }
  61
  62 // Read |num_bits| (1 to 31 inclusive) from the stream and return them
  63 // in |out|, with first bit in the stream as MSB in |out| at position
  64 // (|num_bits| - 1).
  65 bool H264BitReader::ReadBits(int num_bits, int *out) {
  66   int bits_left = num_bits;
  67   *out = 0;
  68   DCHECK(num_bits <= 31);
  69
  70   while (num_remaining_bits_in_curr_byte_ < bits_left) {
  71     // Take all that's left in current byte, shift to make space for the rest.
  72     *out |= (curr_byte_ << (bits_left - num_remaining_bits_in_curr_byte_));
  73     bits_left -= num_remaining_bits_in_curr_byte_;
  74
  75     if (!UpdateCurrByte())
  76       return false;
  77   }
  78
  79   *out |= (curr_byte_ >> (num_remaining_bits_in_curr_byte_ - bits_left));
  80   *out &= ((1 << num_bits) - 1);
  81   num_remaining_bits_in_curr_byte_ -= bits_left;
  82
  83   return true;
  84 }
  85
  86 off_t H264BitReader::NumBitsLeft() {
  87   return (num_remaining_bits_in_curr_byte_ + bytes_left_ * 8);
  88 }
  89
  90 bool H264BitReader::HasMoreRBSPData() {
  91   // Make sure we have more bits, if we are at 0 bits in current byte
  92   // and updating current byte fails, we don't have more data anyway.
  93   if (num_remaining_bits_in_curr_byte_ == 0 && !UpdateCurrByte())
  94       return false;
  95
  96   // On last byte?
  97   if (bytes_left_)
  98     return true;
  99
 100   // Last byte, look for stop bit;
 101   // We have more RBSP data if the last non-zero bit we find is not the
 102   // first available bit.
 103   return (curr_byte_ &
 104           ((1 << (num_remaining_bits_in_curr_byte_ - 1)) - 1)) != 0;
 105 }
 106
 107 size_t H264BitReader::NumEmulationPreventionBytesRead()
 108 {
 109   return emulation_prevention_bytes_;
 110 }
 111
 112 }  // namespace content