OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 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 |
OLD | NEW |