Lines Matching refs:bw
26 static int BitWriterResize(VP8BitWriter* const bw, size_t extra_size) {
29 const uint64_t needed_size_64b = (uint64_t)bw->pos_ + extra_size;
32 bw->error_ = 1;
35 if (needed_size <= bw->max_pos_) return 1;
37 new_size = 2 * bw->max_pos_;
42 bw->error_ = 1;
45 if (bw->pos_ > 0) {
46 assert(bw->buf_ != NULL);
47 memcpy(new_buf, bw->buf_, bw->pos_);
49 WebPSafeFree(bw->buf_);
50 bw->buf_ = new_buf;
51 bw->max_pos_ = new_size;
55 static void kFlush(VP8BitWriter* const bw) {
56 const int s = 8 + bw->nb_bits_;
57 const int32_t bits = bw->value_ >> s;
58 assert(bw->nb_bits_ >= 0);
59 bw->value_ -= bits << s;
60 bw->nb_bits_ -= 8;
62 size_t pos = bw->pos_;
63 if (!BitWriterResize(bw, bw->run_ + 1)) {
67 if (pos > 0) bw->buf_[pos - 1]++;
69 if (bw->run_ > 0) {
71 for (; bw->run_ > 0; --bw->run_) bw->buf_[pos++] = value;
73 bw->buf_[pos++] = bits;
74 bw->pos_ = pos;
76 bw->run_++; // delay writing of bytes 0xff, pending eventual carry.
108 int VP8PutBit(VP8BitWriter* const bw, int bit, int prob) {
109 const int split = (bw->range_ * prob) >> 8;
111 bw->value_ += split + 1;
112 bw->range_ -= split + 1;
114 bw->range_ = split;
116 if (bw->range_ < 127) { // emit 'shift' bits out and renormalize
117 const int shift = kNorm[bw->range_];
118 bw->range_ = kNewRange[bw->range_];
119 bw->value_ <<= shift;
120 bw->nb_bits_ += shift;
121 if (bw->nb_bits_ > 0) kFlush(bw);
126 int VP8PutBitUniform(VP8BitWriter* const bw, int bit) {
127 const int split = bw->range_ >> 1;
129 bw->value_ += split + 1;
130 bw->range_ -= split + 1;
132 bw->range_ = split;
134 if (bw->range_ < 127) {
135 bw->range_ = kNewRange[bw->range_];
136 bw->value_ <<= 1;
137 bw->nb_bits_ += 1;
138 if (bw->nb_bits_ > 0) kFlush(bw);
143 void VP8PutValue(VP8BitWriter* const bw, int value, int nb_bits) {
146 VP8PutBitUniform(bw, value & mask);
149 void VP8PutSignedValue(VP8BitWriter* const bw, int value, int nb_bits) {
150 if (!VP8PutBitUniform(bw, value != 0))
153 VP8PutValue(bw, ((-value) << 1) | 1, nb_bits + 1);
155 VP8PutValue(bw, value << 1, nb_bits + 1);
161 int VP8BitWriterInit(VP8BitWriter* const bw, size_t expected_size) {
162 bw->range_ = 255 - 1;
163 bw->value_ = 0;
164 bw->run_ = 0;
165 bw->nb_bits_ = -8;
166 bw->pos_ = 0;
167 bw->max_pos_ = 0;
168 bw->error_ = 0;
169 bw->buf_ = NULL;
170 return (expected_size > 0) ? BitWriterResize(bw, expected_size) : 1;
173 uint8_t* VP8BitWriterFinish(VP8BitWriter* const bw) {
174 VP8PutValue(bw, 0, 9 - bw->nb_bits_);
175 bw->nb_bits_ = 0; // pad with zeroes
176 kFlush(bw);
177 return bw->buf_;
180 int VP8BitWriterAppend(VP8BitWriter* const bw,
183 if (bw->nb_bits_ != -8) return 0; // kFlush() must have been called
184 if (!BitWriterResize(bw, size)) return 0;
185 memcpy(bw->buf_ + bw->pos_, data, size);
186 bw->pos_ += size;
190 void VP8BitWriterWipeOut(VP8BitWriter* const bw) {
191 if (bw != NULL) {
192 WebPSafeFree(bw->buf_);
193 memset(bw, 0, sizeof(*bw));
209 static int VP8LBitWriterResize(VP8LBitWriter* const bw, size_t extra_size) {
212 const size_t max_bytes = bw->end_ - bw->buf_;
213 const size_t current_size = bw->cur_ - bw->buf_;
217 bw->error_ = 1;
227 bw->error_ = 1;
231 memcpy(allocated_buf, bw->buf_, current_size);
233 WebPSafeFree(bw->buf_);
234 bw->buf_ = allocated_buf;
235 bw->cur_ = bw->buf_ + current_size;
236 bw->end_ = bw->buf_ + allocated_size;
240 int VP8LBitWriterInit(VP8LBitWriter* const bw, size_t expected_size) {
241 memset(bw, 0, sizeof(*bw));
242 return VP8LBitWriterResize(bw, expected_size);
245 void VP8LBitWriterDestroy(VP8LBitWriter* const bw) {
246 if (bw != NULL) {
247 WebPSafeFree(bw->buf_);
248 memset(bw, 0, sizeof(*bw));
252 void VP8LWriteBits(VP8LBitWriter* const bw, int n_bits, uint32_t bits) {
255 assert(bw->used_ + n_bits <= 2 * VP8L_WRITER_MAX_BITS);
258 vp8l_atype_t lbits = bw->bits_;
259 int used = bw->used_;
274 if (bw->cur_ + VP8L_WRITER_BYTES > bw->end_) {
275 const uint64_t extra_size = (bw->end_ - bw->buf_) + MIN_EXTRA_SIZE;
277 !VP8LBitWriterResize(bw, (size_t)extra_size)) {
278 bw->cur_ = bw->buf_;
279 bw->error_ = 1;
283 *(vp8l_wtype_t*)bw->cur_ = (vp8l_wtype_t)WSWAP((vp8l_wtype_t)lbits);
284 bw->cur_ += VP8L_WRITER_BYTES;
289 bw->bits_ = lbits | ((vp8l_atype_t)bits << used);
290 bw->used_ = used + n_bits;
294 uint8_t* VP8LBitWriterFinish(VP8LBitWriter* const bw) {
296 if (VP8LBitWriterResize(bw, (bw->used_ + 7) >> 3)) {
297 while (bw->used_ > 0) {
298 *bw->cur_++ = (uint8_t)bw->bits_;
299 bw->bits_ >>= 8;
300 bw->used_ -= 8;
302 bw->used_ = 0;
304 return bw->buf_;