1 /* libFLAC - Free Lossless Audio Codec library
2 * Copyright (C) 2000-2009 Josh Coalson
3 * Copyright (C) 2011-2014 Xiph.Org Foundation
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * - Neither the name of the Xiph.org Foundation nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #ifdef HAVE_CONFIG_H
34 # include <config.h>
35 #endif
36
37 #include <stdlib.h>
38 #include <string.h>
39 #include "private/bitwriter.h"
40 #include "private/crc.h"
41 #include "private/macros.h"
42 #include "FLAC/assert.h"
43 #include "share/alloc.h"
44 #include "share/compat.h"
45 #include "share/endswap.h"
46
47 /* Things should be fastest when this matches the machine word size */
48 /* WATCHOUT: if you change this you must also change the following #defines down to SWAP_BE_WORD_TO_HOST below to match */
49 /* WATCHOUT: there are a few places where the code will not work unless uint32_t is >= 32 bits wide */
50 #define FLAC__BYTES_PER_WORD 4
51 #define FLAC__BITS_PER_WORD 32
52 #define FLAC__WORD_ALL_ONES ((FLAC__uint32)0xffffffff)
53 /* SWAP_BE_WORD_TO_HOST swaps bytes in a uint32_t (which is always big-endian) if necessary to match host byte order */
54 #if WORDS_BIGENDIAN
55 #define SWAP_BE_WORD_TO_HOST(x) (x)
56 #else
57 #define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_32(x)
58 #endif
59
60 /*
61 * The default capacity here doesn't matter too much. The buffer always grows
62 * to hold whatever is written to it. Usually the encoder will stop adding at
63 * a frame or metadata block, then write that out and clear the buffer for the
64 * next one.
65 */
66 static const unsigned FLAC__BITWRITER_DEFAULT_CAPACITY = 32768u / sizeof(uint32_t); /* size in words */
67 /* When growing, increment 4K at a time */
68 static const unsigned FLAC__BITWRITER_DEFAULT_INCREMENT = 4096u / sizeof(uint32_t); /* size in words */
69
70 #define FLAC__WORDS_TO_BITS(words) ((words) * FLAC__BITS_PER_WORD)
71 #define FLAC__TOTAL_BITS(bw) (FLAC__WORDS_TO_BITS((bw)->words) + (bw)->bits)
72
73 struct FLAC__BitWriter {
74 uint32_t *buffer;
75 uint32_t accum; /* accumulator; bits are right-justified; when full, accum is appended to buffer */
76 unsigned capacity; /* capacity of buffer in words */
77 unsigned words; /* # of complete words in buffer */
78 unsigned bits; /* # of used bits in accum */
79 };
80
81 /* * WATCHOUT: The current implementation only grows the buffer. */
82 #ifndef __SUNPRO_C
83 static
84 #endif
bitwriter_grow_(FLAC__BitWriter * bw,unsigned bits_to_add)85 FLAC__bool bitwriter_grow_(FLAC__BitWriter *bw, unsigned bits_to_add)
86 {
87 unsigned new_capacity;
88 uint32_t *new_buffer;
89
90 FLAC__ASSERT(0 != bw);
91 FLAC__ASSERT(0 != bw->buffer);
92
93 /* calculate total words needed to store 'bits_to_add' additional bits */
94 new_capacity = bw->words + ((bw->bits + bits_to_add + FLAC__BITS_PER_WORD - 1) / FLAC__BITS_PER_WORD);
95
96 /* it's possible (due to pessimism in the growth estimation that
97 * leads to this call) that we don't actually need to grow
98 */
99 if(bw->capacity >= new_capacity)
100 return true;
101
102 /* round up capacity increase to the nearest FLAC__BITWRITER_DEFAULT_INCREMENT */
103 if((new_capacity - bw->capacity) % FLAC__BITWRITER_DEFAULT_INCREMENT)
104 new_capacity += FLAC__BITWRITER_DEFAULT_INCREMENT - ((new_capacity - bw->capacity) % FLAC__BITWRITER_DEFAULT_INCREMENT);
105 /* make sure we got everything right */
106 FLAC__ASSERT(0 == (new_capacity - bw->capacity) % FLAC__BITWRITER_DEFAULT_INCREMENT);
107 FLAC__ASSERT(new_capacity > bw->capacity);
108 FLAC__ASSERT(new_capacity >= bw->words + ((bw->bits + bits_to_add + FLAC__BITS_PER_WORD - 1) / FLAC__BITS_PER_WORD));
109
110 new_buffer = safe_realloc_mul_2op_(bw->buffer, sizeof(uint32_t), /*times*/new_capacity);
111 if(new_buffer == 0)
112 return false;
113 bw->buffer = new_buffer;
114 bw->capacity = new_capacity;
115 return true;
116 }
117
118
119 /***********************************************************************
120 *
121 * Class constructor/destructor
122 *
123 ***********************************************************************/
124
FLAC__bitwriter_new(void)125 FLAC__BitWriter *FLAC__bitwriter_new(void)
126 {
127 FLAC__BitWriter *bw = calloc(1, sizeof(FLAC__BitWriter));
128 /* note that calloc() sets all members to 0 for us */
129 return bw;
130 }
131
FLAC__bitwriter_delete(FLAC__BitWriter * bw)132 void FLAC__bitwriter_delete(FLAC__BitWriter *bw)
133 {
134 FLAC__ASSERT(0 != bw);
135
136 FLAC__bitwriter_free(bw);
137 free(bw);
138 }
139
140 /***********************************************************************
141 *
142 * Public class methods
143 *
144 ***********************************************************************/
145
FLAC__bitwriter_init(FLAC__BitWriter * bw)146 FLAC__bool FLAC__bitwriter_init(FLAC__BitWriter *bw)
147 {
148 FLAC__ASSERT(0 != bw);
149
150 bw->words = bw->bits = 0;
151 bw->capacity = FLAC__BITWRITER_DEFAULT_CAPACITY;
152 bw->buffer = malloc(sizeof(uint32_t) * bw->capacity);
153 if(bw->buffer == 0)
154 return false;
155
156 return true;
157 }
158
FLAC__bitwriter_free(FLAC__BitWriter * bw)159 void FLAC__bitwriter_free(FLAC__BitWriter *bw)
160 {
161 FLAC__ASSERT(0 != bw);
162
163 if(0 != bw->buffer)
164 free(bw->buffer);
165 bw->buffer = 0;
166 bw->capacity = 0;
167 bw->words = bw->bits = 0;
168 }
169
FLAC__bitwriter_clear(FLAC__BitWriter * bw)170 void FLAC__bitwriter_clear(FLAC__BitWriter *bw)
171 {
172 bw->words = bw->bits = 0;
173 }
174
FLAC__bitwriter_dump(const FLAC__BitWriter * bw,FILE * out)175 void FLAC__bitwriter_dump(const FLAC__BitWriter *bw, FILE *out)
176 {
177 unsigned i, j;
178 if(bw == 0) {
179 fprintf(out, "bitwriter is NULL\n");
180 }
181 else {
182 fprintf(out, "bitwriter: capacity=%u words=%u bits=%u total_bits=%u\n", bw->capacity, bw->words, bw->bits, FLAC__TOTAL_BITS(bw));
183
184 for(i = 0; i < bw->words; i++) {
185 fprintf(out, "%08X: ", i);
186 for(j = 0; j < FLAC__BITS_PER_WORD; j++)
187 fprintf(out, "%01u", bw->buffer[i] & (1 << (FLAC__BITS_PER_WORD-j-1)) ? 1:0);
188 fprintf(out, "\n");
189 }
190 if(bw->bits > 0) {
191 fprintf(out, "%08X: ", i);
192 for(j = 0; j < bw->bits; j++)
193 fprintf(out, "%01u", bw->accum & (1 << (bw->bits-j-1)) ? 1:0);
194 fprintf(out, "\n");
195 }
196 }
197 }
198
FLAC__bitwriter_get_write_crc16(FLAC__BitWriter * bw,FLAC__uint16 * crc)199 FLAC__bool FLAC__bitwriter_get_write_crc16(FLAC__BitWriter *bw, FLAC__uint16 *crc)
200 {
201 const FLAC__byte *buffer;
202 size_t bytes;
203
204 FLAC__ASSERT((bw->bits & 7) == 0); /* assert that we're byte-aligned */
205
206 if(!FLAC__bitwriter_get_buffer(bw, &buffer, &bytes))
207 return false;
208
209 *crc = (FLAC__uint16)FLAC__crc16(buffer, bytes);
210 FLAC__bitwriter_release_buffer(bw);
211 return true;
212 }
213
FLAC__bitwriter_get_write_crc8(FLAC__BitWriter * bw,FLAC__byte * crc)214 FLAC__bool FLAC__bitwriter_get_write_crc8(FLAC__BitWriter *bw, FLAC__byte *crc)
215 {
216 const FLAC__byte *buffer;
217 size_t bytes;
218
219 FLAC__ASSERT((bw->bits & 7) == 0); /* assert that we're byte-aligned */
220
221 if(!FLAC__bitwriter_get_buffer(bw, &buffer, &bytes))
222 return false;
223
224 *crc = FLAC__crc8(buffer, bytes);
225 FLAC__bitwriter_release_buffer(bw);
226 return true;
227 }
228
FLAC__bitwriter_is_byte_aligned(const FLAC__BitWriter * bw)229 FLAC__bool FLAC__bitwriter_is_byte_aligned(const FLAC__BitWriter *bw)
230 {
231 return ((bw->bits & 7) == 0);
232 }
233
FLAC__bitwriter_get_input_bits_unconsumed(const FLAC__BitWriter * bw)234 unsigned FLAC__bitwriter_get_input_bits_unconsumed(const FLAC__BitWriter *bw)
235 {
236 return FLAC__TOTAL_BITS(bw);
237 }
238
FLAC__bitwriter_get_buffer(FLAC__BitWriter * bw,const FLAC__byte ** buffer,size_t * bytes)239 FLAC__bool FLAC__bitwriter_get_buffer(FLAC__BitWriter *bw, const FLAC__byte **buffer, size_t *bytes)
240 {
241 FLAC__ASSERT((bw->bits & 7) == 0);
242 /* double protection */
243 if(bw->bits & 7)
244 return false;
245 /* if we have bits in the accumulator we have to flush those to the buffer first */
246 if(bw->bits) {
247 FLAC__ASSERT(bw->words <= bw->capacity);
248 if(bw->words == bw->capacity && !bitwriter_grow_(bw, FLAC__BITS_PER_WORD))
249 return false;
250 /* append bits as complete word to buffer, but don't change bw->accum or bw->bits */
251 bw->buffer[bw->words] = SWAP_BE_WORD_TO_HOST(bw->accum << (FLAC__BITS_PER_WORD-bw->bits));
252 }
253 /* now we can just return what we have */
254 *buffer = (FLAC__byte*)bw->buffer;
255 *bytes = (FLAC__BYTES_PER_WORD * bw->words) + (bw->bits >> 3);
256 return true;
257 }
258
FLAC__bitwriter_release_buffer(FLAC__BitWriter * bw)259 void FLAC__bitwriter_release_buffer(FLAC__BitWriter *bw)
260 {
261 /* nothing to do. in the future, strict checking of a 'writer-is-in-
262 * get-mode' flag could be added everywhere and then cleared here
263 */
264 (void)bw;
265 }
266
FLAC__bitwriter_write_zeroes(FLAC__BitWriter * bw,unsigned bits)267 inline FLAC__bool FLAC__bitwriter_write_zeroes(FLAC__BitWriter *bw, unsigned bits)
268 {
269 unsigned n;
270
271 FLAC__ASSERT(0 != bw);
272 FLAC__ASSERT(0 != bw->buffer);
273
274 if(bits == 0)
275 return true;
276 /* slightly pessimistic size check but faster than "<= bw->words + (bw->bits+bits+FLAC__BITS_PER_WORD-1)/FLAC__BITS_PER_WORD" */
277 if(bw->capacity <= bw->words + bits && !bitwriter_grow_(bw, bits))
278 return false;
279 /* first part gets to word alignment */
280 if(bw->bits) {
281 n = flac_min(FLAC__BITS_PER_WORD - bw->bits, bits);
282 bw->accum <<= n;
283 bits -= n;
284 bw->bits += n;
285 if(bw->bits == FLAC__BITS_PER_WORD) {
286 bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum);
287 bw->bits = 0;
288 }
289 else
290 return true;
291 }
292 /* do whole words */
293 while(bits >= FLAC__BITS_PER_WORD) {
294 bw->buffer[bw->words++] = 0;
295 bits -= FLAC__BITS_PER_WORD;
296 }
297 /* do any leftovers */
298 if(bits > 0) {
299 bw->accum = 0;
300 bw->bits = bits;
301 }
302 return true;
303 }
304
FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter * bw,FLAC__uint32 val,unsigned bits)305 inline FLAC__bool FLAC__bitwriter_write_raw_uint32(FLAC__BitWriter *bw, FLAC__uint32 val, unsigned bits)
306 {
307 register unsigned left;
308
309 /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
310 FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
311
312 FLAC__ASSERT(0 != bw);
313 FLAC__ASSERT(0 != bw->buffer);
314
315 FLAC__ASSERT(bits <= 32);
316 if(bits == 0)
317 return true;
318
319 /* slightly pessimistic size check but faster than "<= bw->words + (bw->bits+bits+FLAC__BITS_PER_WORD-1)/FLAC__BITS_PER_WORD" */
320 if(bw->capacity <= bw->words + bits && !bitwriter_grow_(bw, bits))
321 return false;
322
323 left = FLAC__BITS_PER_WORD - bw->bits;
324 if(bits < left) {
325 bw->accum <<= bits;
326 bw->accum |= val;
327 bw->bits += bits;
328 }
329 else if(bw->bits) { /* WATCHOUT: if bw->bits == 0, left==FLAC__BITS_PER_WORD and bw->accum<<=left is a NOP instead of setting to 0 */
330 bw->accum <<= left;
331 bw->accum |= val >> (bw->bits = bits - left);
332 bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum);
333 bw->accum = val;
334 }
335 else {
336 bw->accum = val;
337 bw->bits = 0;
338 bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(val);
339 }
340
341 return true;
342 }
343
FLAC__bitwriter_write_raw_int32(FLAC__BitWriter * bw,FLAC__int32 val,unsigned bits)344 inline FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, unsigned bits)
345 {
346 /* zero-out unused bits */
347 if(bits < 32)
348 val &= (~(0xffffffff << bits));
349
350 return FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)val, bits);
351 }
352
FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter * bw,FLAC__uint64 val,unsigned bits)353 inline FLAC__bool FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, unsigned bits)
354 {
355 /* this could be a little faster but it's not used for much */
356 if(bits > 32) {
357 return
358 FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)(val>>32), bits-32) &&
359 FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)val, 32);
360 }
361 else
362 return FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)val, bits);
363 }
364
FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter * bw,FLAC__uint32 val)365 inline FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val)
366 {
367 /* this doesn't need to be that fast as currently it is only used for vorbis comments */
368
369 if(!FLAC__bitwriter_write_raw_uint32(bw, val & 0xff, 8))
370 return false;
371 if(!FLAC__bitwriter_write_raw_uint32(bw, (val>>8) & 0xff, 8))
372 return false;
373 if(!FLAC__bitwriter_write_raw_uint32(bw, (val>>16) & 0xff, 8))
374 return false;
375 if(!FLAC__bitwriter_write_raw_uint32(bw, val>>24, 8))
376 return false;
377
378 return true;
379 }
380
FLAC__bitwriter_write_byte_block(FLAC__BitWriter * bw,const FLAC__byte vals[],unsigned nvals)381 inline FLAC__bool FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], unsigned nvals)
382 {
383 unsigned i;
384
385 /* this could be faster but currently we don't need it to be since it's only used for writing metadata */
386 for(i = 0; i < nvals; i++) {
387 if(!FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)(vals[i]), 8))
388 return false;
389 }
390
391 return true;
392 }
393
FLAC__bitwriter_write_unary_unsigned(FLAC__BitWriter * bw,unsigned val)394 FLAC__bool FLAC__bitwriter_write_unary_unsigned(FLAC__BitWriter *bw, unsigned val)
395 {
396 if(val < 32)
397 return FLAC__bitwriter_write_raw_uint32(bw, 1, ++val);
398 else
399 return
400 FLAC__bitwriter_write_zeroes(bw, val) &&
401 FLAC__bitwriter_write_raw_uint32(bw, 1, 1);
402 }
403
FLAC__bitwriter_rice_bits(FLAC__int32 val,unsigned parameter)404 unsigned FLAC__bitwriter_rice_bits(FLAC__int32 val, unsigned parameter)
405 {
406 FLAC__uint32 uval;
407
408 FLAC__ASSERT(parameter < sizeof(unsigned)*8);
409
410 /* fold signed to unsigned; actual formula is: negative(v)? -2v-1 : 2v */
411 uval = (val<<1) ^ (val>>31);
412
413 return 1 + parameter + (uval >> parameter);
414 }
415
416 #if 0 /* UNUSED */
417 unsigned FLAC__bitwriter_golomb_bits_signed(int val, unsigned parameter)
418 {
419 unsigned bits, msbs, uval;
420 unsigned k;
421
422 FLAC__ASSERT(parameter > 0);
423
424 /* fold signed to unsigned */
425 if(val < 0)
426 uval = (unsigned)(((-(++val)) << 1) + 1);
427 else
428 uval = (unsigned)(val << 1);
429
430 k = FLAC__bitmath_ilog2(parameter);
431 if(parameter == 1u<<k) {
432 FLAC__ASSERT(k <= 30);
433
434 msbs = uval >> k;
435 bits = 1 + k + msbs;
436 }
437 else {
438 unsigned q, r, d;
439
440 d = (1 << (k+1)) - parameter;
441 q = uval / parameter;
442 r = uval - (q * parameter);
443
444 bits = 1 + q + k;
445 if(r >= d)
446 bits++;
447 }
448 return bits;
449 }
450
451 unsigned FLAC__bitwriter_golomb_bits_unsigned(unsigned uval, unsigned parameter)
452 {
453 unsigned bits, msbs;
454 unsigned k;
455
456 FLAC__ASSERT(parameter > 0);
457
458 k = FLAC__bitmath_ilog2(parameter);
459 if(parameter == 1u<<k) {
460 FLAC__ASSERT(k <= 30);
461
462 msbs = uval >> k;
463 bits = 1 + k + msbs;
464 }
465 else {
466 unsigned q, r, d;
467
468 d = (1 << (k+1)) - parameter;
469 q = uval / parameter;
470 r = uval - (q * parameter);
471
472 bits = 1 + q + k;
473 if(r >= d)
474 bits++;
475 }
476 return bits;
477 }
478 #endif /* UNUSED */
479
FLAC__bitwriter_write_rice_signed(FLAC__BitWriter * bw,FLAC__int32 val,unsigned parameter)480 FLAC__bool FLAC__bitwriter_write_rice_signed(FLAC__BitWriter *bw, FLAC__int32 val, unsigned parameter)
481 {
482 unsigned total_bits, interesting_bits, msbs;
483 FLAC__uint32 uval, pattern;
484
485 FLAC__ASSERT(0 != bw);
486 FLAC__ASSERT(0 != bw->buffer);
487 FLAC__ASSERT(parameter < 8*sizeof(uval));
488
489 /* fold signed to unsigned; actual formula is: negative(v)? -2v-1 : 2v */
490 uval = (val<<1) ^ (val>>31);
491
492 msbs = uval >> parameter;
493 interesting_bits = 1 + parameter;
494 total_bits = interesting_bits + msbs;
495 pattern = 1 << parameter; /* the unary end bit */
496 pattern |= (uval & ((1<<parameter)-1)); /* the binary LSBs */
497
498 if(total_bits <= 32)
499 return FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits);
500 else
501 return
502 FLAC__bitwriter_write_zeroes(bw, msbs) && /* write the unary MSBs */
503 FLAC__bitwriter_write_raw_uint32(bw, pattern, interesting_bits); /* write the unary end bit and binary LSBs */
504 }
505
FLAC__bitwriter_write_rice_signed_block(FLAC__BitWriter * bw,const FLAC__int32 * vals,unsigned nvals,unsigned parameter)506 FLAC__bool FLAC__bitwriter_write_rice_signed_block(FLAC__BitWriter *bw, const FLAC__int32 *vals, unsigned nvals, unsigned parameter)
507 {
508 const FLAC__uint32 mask1 = FLAC__WORD_ALL_ONES << parameter; /* we val|=mask1 to set the stop bit above it... */
509 const FLAC__uint32 mask2 = FLAC__WORD_ALL_ONES >> (31-parameter); /* ...then mask off the bits above the stop bit with val&=mask2*/
510 FLAC__uint32 uval;
511 unsigned left;
512 const unsigned lsbits = 1 + parameter;
513 unsigned msbits;
514
515 FLAC__ASSERT(0 != bw);
516 FLAC__ASSERT(0 != bw->buffer);
517 FLAC__ASSERT(parameter < 8*sizeof(uint32_t)-1);
518 /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */
519 FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32);
520
521 while(nvals) {
522 /* fold signed to unsigned; actual formula is: negative(v)? -2v-1 : 2v */
523 uval = *vals;
524 uval <<= 1;
525 uval ^= (*vals>>31);
526
527 msbits = uval >> parameter;
528
529 if(bw->bits && bw->bits + msbits + lsbits < FLAC__BITS_PER_WORD) { /* i.e. if the whole thing fits in the current uint32_t */
530 /* ^^^ if bw->bits is 0 then we may have filled the buffer and have no free uint32_t to work in */
531 bw->bits = bw->bits + msbits + lsbits;
532 uval |= mask1; /* set stop bit */
533 uval &= mask2; /* mask off unused top bits */
534 bw->accum <<= msbits + lsbits;
535 bw->accum |= uval;
536 }
537 else {
538 /* slightly pessimistic size check but faster than "<= bw->words + (bw->bits+msbits+lsbits+FLAC__BITS_PER_WORD-1)/FLAC__BITS_PER_WORD" */
539 /* OPT: pessimism may cause flurry of false calls to grow_ which eat up all savings before it */
540 if(bw->capacity <= bw->words + bw->bits + msbits + 1/*lsbits always fit in 1 uint32_t*/ && !bitwriter_grow_(bw, msbits+lsbits))
541 return false;
542
543 if(msbits) {
544 /* first part gets to word alignment */
545 if(bw->bits) {
546 left = FLAC__BITS_PER_WORD - bw->bits;
547 if(msbits < left) {
548 bw->accum <<= msbits;
549 bw->bits += msbits;
550 goto break1;
551 }
552 else {
553 bw->accum <<= left;
554 msbits -= left;
555 bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum);
556 bw->bits = 0;
557 }
558 }
559 /* do whole words */
560 while(msbits >= FLAC__BITS_PER_WORD) {
561 bw->buffer[bw->words++] = 0;
562 msbits -= FLAC__BITS_PER_WORD;
563 }
564 /* do any leftovers */
565 if(msbits > 0) {
566 bw->accum = 0;
567 bw->bits = msbits;
568 }
569 }
570 break1:
571 uval |= mask1; /* set stop bit */
572 uval &= mask2; /* mask off unused top bits */
573
574 left = FLAC__BITS_PER_WORD - bw->bits;
575 if(lsbits < left) {
576 bw->accum <<= lsbits;
577 bw->accum |= uval;
578 bw->bits += lsbits;
579 }
580 else {
581 /* if bw->bits == 0, left==FLAC__BITS_PER_WORD which will always
582 * be > lsbits (because of previous assertions) so it would have
583 * triggered the (lsbits<left) case above.
584 */
585 FLAC__ASSERT(bw->bits);
586 FLAC__ASSERT(left < FLAC__BITS_PER_WORD);
587 bw->accum <<= left;
588 bw->accum |= uval >> (bw->bits = lsbits - left);
589 bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum);
590 bw->accum = uval;
591 }
592 }
593 vals++;
594 nvals--;
595 }
596 return true;
597 }
598
599 #if 0 /* UNUSED */
600 FLAC__bool FLAC__bitwriter_write_golomb_signed(FLAC__BitWriter *bw, int val, unsigned parameter)
601 {
602 unsigned total_bits, msbs, uval;
603 unsigned k;
604
605 FLAC__ASSERT(0 != bw);
606 FLAC__ASSERT(0 != bw->buffer);
607 FLAC__ASSERT(parameter > 0);
608
609 /* fold signed to unsigned */
610 if(val < 0)
611 uval = (unsigned)(((-(++val)) << 1) + 1);
612 else
613 uval = (unsigned)(val << 1);
614
615 k = FLAC__bitmath_ilog2(parameter);
616 if(parameter == 1u<<k) {
617 unsigned pattern;
618
619 FLAC__ASSERT(k <= 30);
620
621 msbs = uval >> k;
622 total_bits = 1 + k + msbs;
623 pattern = 1 << k; /* the unary end bit */
624 pattern |= (uval & ((1u<<k)-1)); /* the binary LSBs */
625
626 if(total_bits <= 32) {
627 if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits))
628 return false;
629 }
630 else {
631 /* write the unary MSBs */
632 if(!FLAC__bitwriter_write_zeroes(bw, msbs))
633 return false;
634 /* write the unary end bit and binary LSBs */
635 if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, k+1))
636 return false;
637 }
638 }
639 else {
640 unsigned q, r, d;
641
642 d = (1 << (k+1)) - parameter;
643 q = uval / parameter;
644 r = uval - (q * parameter);
645 /* write the unary MSBs */
646 if(!FLAC__bitwriter_write_zeroes(bw, q))
647 return false;
648 /* write the unary end bit */
649 if(!FLAC__bitwriter_write_raw_uint32(bw, 1, 1))
650 return false;
651 /* write the binary LSBs */
652 if(r >= d) {
653 if(!FLAC__bitwriter_write_raw_uint32(bw, r+d, k+1))
654 return false;
655 }
656 else {
657 if(!FLAC__bitwriter_write_raw_uint32(bw, r, k))
658 return false;
659 }
660 }
661 return true;
662 }
663
664 FLAC__bool FLAC__bitwriter_write_golomb_unsigned(FLAC__BitWriter *bw, unsigned uval, unsigned parameter)
665 {
666 unsigned total_bits, msbs;
667 unsigned k;
668
669 FLAC__ASSERT(0 != bw);
670 FLAC__ASSERT(0 != bw->buffer);
671 FLAC__ASSERT(parameter > 0);
672
673 k = FLAC__bitmath_ilog2(parameter);
674 if(parameter == 1u<<k) {
675 unsigned pattern;
676
677 FLAC__ASSERT(k <= 30);
678
679 msbs = uval >> k;
680 total_bits = 1 + k + msbs;
681 pattern = 1 << k; /* the unary end bit */
682 pattern |= (uval & ((1u<<k)-1)); /* the binary LSBs */
683
684 if(total_bits <= 32) {
685 if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits))
686 return false;
687 }
688 else {
689 /* write the unary MSBs */
690 if(!FLAC__bitwriter_write_zeroes(bw, msbs))
691 return false;
692 /* write the unary end bit and binary LSBs */
693 if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, k+1))
694 return false;
695 }
696 }
697 else {
698 unsigned q, r, d;
699
700 d = (1 << (k+1)) - parameter;
701 q = uval / parameter;
702 r = uval - (q * parameter);
703 /* write the unary MSBs */
704 if(!FLAC__bitwriter_write_zeroes(bw, q))
705 return false;
706 /* write the unary end bit */
707 if(!FLAC__bitwriter_write_raw_uint32(bw, 1, 1))
708 return false;
709 /* write the binary LSBs */
710 if(r >= d) {
711 if(!FLAC__bitwriter_write_raw_uint32(bw, r+d, k+1))
712 return false;
713 }
714 else {
715 if(!FLAC__bitwriter_write_raw_uint32(bw, r, k))
716 return false;
717 }
718 }
719 return true;
720 }
721 #endif /* UNUSED */
722
FLAC__bitwriter_write_utf8_uint32(FLAC__BitWriter * bw,FLAC__uint32 val)723 FLAC__bool FLAC__bitwriter_write_utf8_uint32(FLAC__BitWriter *bw, FLAC__uint32 val)
724 {
725 FLAC__bool ok = 1;
726
727 FLAC__ASSERT(0 != bw);
728 FLAC__ASSERT(0 != bw->buffer);
729
730 FLAC__ASSERT(!(val & 0x80000000)); /* this version only handles 31 bits */
731
732 if(val < 0x80) {
733 return FLAC__bitwriter_write_raw_uint32(bw, val, 8);
734 }
735 else if(val < 0x800) {
736 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xC0 | (val>>6), 8);
737 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (val&0x3F), 8);
738 }
739 else if(val < 0x10000) {
740 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xE0 | (val>>12), 8);
741 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>6)&0x3F), 8);
742 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (val&0x3F), 8);
743 }
744 else if(val < 0x200000) {
745 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xF0 | (val>>18), 8);
746 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>12)&0x3F), 8);
747 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>6)&0x3F), 8);
748 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (val&0x3F), 8);
749 }
750 else if(val < 0x4000000) {
751 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xF8 | (val>>24), 8);
752 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>18)&0x3F), 8);
753 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>12)&0x3F), 8);
754 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>6)&0x3F), 8);
755 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (val&0x3F), 8);
756 }
757 else {
758 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xFC | (val>>30), 8);
759 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>24)&0x3F), 8);
760 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>18)&0x3F), 8);
761 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>12)&0x3F), 8);
762 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>6)&0x3F), 8);
763 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (val&0x3F), 8);
764 }
765
766 return ok;
767 }
768
FLAC__bitwriter_write_utf8_uint64(FLAC__BitWriter * bw,FLAC__uint64 val)769 FLAC__bool FLAC__bitwriter_write_utf8_uint64(FLAC__BitWriter *bw, FLAC__uint64 val)
770 {
771 FLAC__bool ok = 1;
772
773 FLAC__ASSERT(0 != bw);
774 FLAC__ASSERT(0 != bw->buffer);
775
776 FLAC__ASSERT(!(val & FLAC__U64L(0xFFFFFFF000000000))); /* this version only handles 36 bits */
777
778 if(val < 0x80) {
779 return FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)val, 8);
780 }
781 else if(val < 0x800) {
782 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xC0 | (FLAC__uint32)(val>>6), 8);
783 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
784 }
785 else if(val < 0x10000) {
786 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xE0 | (FLAC__uint32)(val>>12), 8);
787 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
788 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
789 }
790 else if(val < 0x200000) {
791 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xF0 | (FLAC__uint32)(val>>18), 8);
792 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
793 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
794 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
795 }
796 else if(val < 0x4000000) {
797 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xF8 | (FLAC__uint32)(val>>24), 8);
798 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
799 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
800 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
801 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
802 }
803 else if(val < 0x80000000) {
804 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xFC | (FLAC__uint32)(val>>30), 8);
805 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>24)&0x3F), 8);
806 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
807 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
808 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
809 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
810 }
811 else {
812 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xFE, 8);
813 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>30)&0x3F), 8);
814 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>24)&0x3F), 8);
815 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
816 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
817 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
818 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
819 }
820
821 return ok;
822 }
823
FLAC__bitwriter_zero_pad_to_byte_boundary(FLAC__BitWriter * bw)824 FLAC__bool FLAC__bitwriter_zero_pad_to_byte_boundary(FLAC__BitWriter *bw)
825 {
826 /* 0-pad to byte boundary */
827 if(bw->bits & 7u)
828 return FLAC__bitwriter_write_zeroes(bw, 8 - (bw->bits & 7u));
829 else
830 return true;
831 }
832
833 /* These functions are declared inline in this file but are also callable as
834 * externs from elsewhere.
835 * According to the C99 spec, section 6.7.4, simply providing a function
836 * prototype in a header file without 'inline' and making the function inline
837 * in this file should be sufficient.
838 * Unfortunately, the Microsoft VS compiler doesn't pick them up externally. To
839 * fix that we add extern declarations here.
840 */
841 extern FLAC__bool FLAC__bitwriter_write_zeroes(FLAC__BitWriter *bw, unsigned bits);
842 extern FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, unsigned bits);
843 extern FLAC__bool FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, unsigned bits);
844 extern FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val);
845 extern FLAC__bool FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], unsigned nvals);
846