OLD | NEW |
| (Empty) |
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 | |
OLD | NEW |