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_, ®_, 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 153