media/filters/h264_bitstream_buffer.cc

   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/filters/h264_bitstream_buffer.h"
   6
   7 #include "base/sys_byteorder.h"
   8
   9 namespace media {
  10
  11 H264BitstreamBuffer::H264BitstreamBuffer() : data_(NULL) {
  12   Reset();
  13 }
  14
  15 H264BitstreamBuffer::~H264BitstreamBuffer() {
  16   free(data_);
  17   data_ = NULL;
  18 }
  19
  20 void H264BitstreamBuffer::Reset() {
  21   free(data_);
  22   data_ = NULL;
  23
  24   capacity_ = 0;
  25   pos_ = 0;
  26   reg_ = 0;
  27
  28   Grow();
  29
  30   bits_left_in_reg_ = kRegBitSize;
  31 }
  32
  33 void H264BitstreamBuffer::Grow() {
  34   data_ = static_cast<uint8*>(realloc(data_, capacity_ + kGrowBytes));
  35   CHECK(data_) << "Failed growing the buffer";
  36   capacity_ += kGrowBytes;
  37 }
  38
  39 void H264BitstreamBuffer::FlushReg() {
  40   // Flush all bytes that have at least one bit cached, but not more
  41   // (on Flush(), reg_ may not be full).
  42   size_t bits_in_reg = kRegBitSize - bits_left_in_reg_;
  43   if (bits_in_reg == 0)
  44     return;
  45
  46   size_t bytes_in_reg = (bits_in_reg + 7) / 8;
  47   reg_ <<= (kRegBitSize - bits_in_reg);
  48
  49   // Convert to MSB and append as such to the stream.
  50   reg_ = base::HostToNet64(reg_);
  51
  52   // Make sure we have enough space. Grow() will CHECK() on allocation failure.
  53   if (pos_ + bytes_in_reg < capacity_)
  54     Grow();
  55
  56   memcpy(data_ + pos_, &reg_, bytes_in_reg);
  57   pos_ += bytes_in_reg;
  58
  59   reg_ = 0;
  60   bits_left_in_reg_ = kRegBitSize;
  61 }
  62
  63 void H264BitstreamBuffer::AppendU64(size_t num_bits, uint64 val) {
  64   CHECK_LE(num_bits, kRegBitSize);
  65
  66   while (num_bits > 0) {
  67     if (bits_left_in_reg_ == 0)
  68       FlushReg();
  69
  70     uint64 bits_to_write =
  71         num_bits > bits_left_in_reg_ ? bits_left_in_reg_ : num_bits;
  72     uint64 val_to_write = (val >> (num_bits - bits_to_write));
  73     if (bits_to_write < 64)
  74       val_to_write &= ((1ull << bits_to_write) - 1);
  75     reg_ <<= bits_to_write;
  76     reg_ |= val_to_write;
  77     num_bits -= bits_to_write;
  78     bits_left_in_reg_ -= bits_to_write;
  79   }
  80 }
  81
  82 void H264BitstreamBuffer::AppendBool(bool val) {
  83   if (bits_left_in_reg_ == 0)
  84     FlushReg();
  85
  86   reg_ <<= 1;
  87   reg_ |= (static_cast<uint64>(val) & 1);
  88   --bits_left_in_reg_;
  89 }
  90
  91 void H264BitstreamBuffer::AppendSE(int val) {
  92   if (val > 0)
  93     AppendUE(val * 2 - 1);
  94   else
  95     AppendUE(-val * 2);
  96 }
  97
  98 void H264BitstreamBuffer::AppendUE(unsigned int val) {
  99   size_t num_zeros = 0;
 100   unsigned int v = val + 1;
 101
 102   while (v > 1) {
 103     v >>= 1;
 104     ++num_zeros;
 105   }
 106
 107   AppendBits(num_zeros, 0);
 108   AppendBits(num_zeros + 1, val + 1);
 109 }
 110
 111 #define DCHECK_FINISHED()                                                      \
 112   DCHECK_EQ(bits_left_in_reg_, kRegBitSize) << "Pending bits not yet written " \
 113                                                "to the buffer, call "          \
 114                                                "FinishNALU() first."
 115
 116 void H264BitstreamBuffer::BeginNALU(H264NALU::Type nalu_type, int nal_ref_idc) {
 117   DCHECK_FINISHED();
 118
 119   DCHECK_LE(nalu_type, H264NALU::kEOStream);
 120   DCHECK_GE(nal_ref_idc, 0);
 121   DCHECK_LE(nal_ref_idc, 3);
 122
 123   AppendBits(32, 0x00000001);
 124   AppendBits(1, 0);  // forbidden_zero_bit
 125   AppendBits(2, nal_ref_idc);
 126   AppendBits(5, nalu_type);
 127 }
 128
 129 void H264BitstreamBuffer::FinishNALU() {
 130   // RBSP stop one bit.
 131   AppendBits(1, 1);
 132
 133   // Byte-alignment zero bits.
 134   AppendBits(bits_left_in_reg_ % 8, 0);
 135
 136   if (bits_left_in_reg_ != kRegBitSize)
 137     FlushReg();
 138 }
 139
 140 size_t H264BitstreamBuffer::BytesInBuffer() {
 141   DCHECK_FINISHED();
 142   return pos_;
 143 }
 144
 145 uint8* H264BitstreamBuffer::data() {
 146   DCHECK(data_);
 147   DCHECK_FINISHED();
 148
 149   return data_;
 150 }
 151
 152 }  // namespace media