src/libFLAC/bitwriter.c : Remove dead code.
[flac.git] / src / libFLAC / bitwriter.c
1 /* libFLAC - Free Lossless Audio Codec library
2  * Copyright (C) 2000-2009  Josh Coalson
3  * Copyright (C) 2011-2013  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 #if 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
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
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
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
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
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
170 void FLAC__bitwriter_clear(FLAC__BitWriter *bw)
171 {
172         bw->words = bw->bits = 0;
173 }
174
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
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
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
229 FLAC__bool FLAC__bitwriter_is_byte_aligned(const FLAC__BitWriter *bw)
230 {
231         return ((bw->bits & 7) == 0);
232 }
233
234 unsigned FLAC__bitwriter_get_input_bits_unconsumed(const FLAC__BitWriter *bw)
235 {
236         return FLAC__TOTAL_BITS(bw);
237 }
238
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
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
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
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
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
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
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
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
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
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
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
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<<1) ^ (*vals>>31);
524
525                 msbits = uval >> parameter;
526
527                 if(bw->bits && bw->bits + msbits + lsbits < FLAC__BITS_PER_WORD) { /* i.e. if the whole thing fits in the current uint32_t */
528                         /* ^^^ if bw->bits is 0 then we may have filled the buffer and have no free uint32_t to work in */
529                         bw->bits = bw->bits + msbits + lsbits;
530                         uval |= mask1; /* set stop bit */
531                         uval &= mask2; /* mask off unused top bits */
532                         bw->accum <<= msbits + lsbits;
533                         bw->accum |= uval;
534                 }
535                 else {
536                         /* slightly pessimistic size check but faster than "<= bw->words + (bw->bits+msbits+lsbits+FLAC__BITS_PER_WORD-1)/FLAC__BITS_PER_WORD" */
537                         /* OPT: pessimism may cause flurry of false calls to grow_ which eat up all savings before it */
538                         if(bw->capacity <= bw->words + bw->bits + msbits + 1/*lsbits always fit in 1 uint32_t*/ && !bitwriter_grow_(bw, msbits+lsbits))
539                                 return false;
540
541                         if(msbits) {
542                                 /* first part gets to word alignment */
543                                 if(bw->bits) {
544                                         left = FLAC__BITS_PER_WORD - bw->bits;
545                                         if(msbits < left) {
546                                                 bw->accum <<= msbits;
547                                                 bw->bits += msbits;
548                                                 goto break1;
549                                         }
550                                         else {
551                                                 bw->accum <<= left;
552                                                 msbits -= left;
553                                                 bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum);
554                                                 bw->bits = 0;
555                                         }
556                                 }
557                                 /* do whole words */
558                                 while(msbits >= FLAC__BITS_PER_WORD) {
559                                         bw->buffer[bw->words++] = 0;
560                                         msbits -= FLAC__BITS_PER_WORD;
561                                 }
562                                 /* do any leftovers */
563                                 if(msbits > 0) {
564                                         bw->accum = 0;
565                                         bw->bits = msbits;
566                                 }
567                         }
568 break1:
569                         uval |= mask1; /* set stop bit */
570                         uval &= mask2; /* mask off unused top bits */
571
572                         left = FLAC__BITS_PER_WORD - bw->bits;
573                         if(lsbits < left) {
574                                 bw->accum <<= lsbits;
575                                 bw->accum |= uval;
576                                 bw->bits += lsbits;
577                         }
578                         else {
579                                 /* if bw->bits == 0, left==FLAC__BITS_PER_WORD which will always
580                                  * be > lsbits (because of previous assertions) so it would have
581                                  * triggered the (lsbits<left) case above.
582                                  */
583                                 FLAC__ASSERT(bw->bits);
584                                 FLAC__ASSERT(left < FLAC__BITS_PER_WORD);
585                                 bw->accum <<= left;
586                                 bw->accum |= uval >> (bw->bits = lsbits - left);
587                                 bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum);
588                                 bw->accum = uval;
589                         }
590                 }
591                 vals++;
592                 nvals--;
593         }
594         return true;
595 }
596
597 #if 0 /* UNUSED */
598 FLAC__bool FLAC__bitwriter_write_golomb_signed(FLAC__BitWriter *bw, int val, unsigned parameter)
599 {
600         unsigned total_bits, msbs, uval;
601         unsigned k;
602
603         FLAC__ASSERT(0 != bw);
604         FLAC__ASSERT(0 != bw->buffer);
605         FLAC__ASSERT(parameter > 0);
606
607         /* fold signed to unsigned */
608         if(val < 0)
609                 uval = (unsigned)(((-(++val)) << 1) + 1);
610         else
611                 uval = (unsigned)(val << 1);
612
613         k = FLAC__bitmath_ilog2(parameter);
614         if(parameter == 1u<<k) {
615                 unsigned pattern;
616
617                 FLAC__ASSERT(k <= 30);
618
619                 msbs = uval >> k;
620                 total_bits = 1 + k + msbs;
621                 pattern = 1 << k; /* the unary end bit */
622                 pattern |= (uval & ((1u<<k)-1)); /* the binary LSBs */
623
624                 if(total_bits <= 32) {
625                         if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits))
626                                 return false;
627                 }
628                 else {
629                         /* write the unary MSBs */
630                         if(!FLAC__bitwriter_write_zeroes(bw, msbs))
631                                 return false;
632                         /* write the unary end bit and binary LSBs */
633                         if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, k+1))
634                                 return false;
635                 }
636         }
637         else {
638                 unsigned q, r, d;
639
640                 d = (1 << (k+1)) - parameter;
641                 q = uval / parameter;
642                 r = uval - (q * parameter);
643                 /* write the unary MSBs */
644                 if(!FLAC__bitwriter_write_zeroes(bw, q))
645                         return false;
646                 /* write the unary end bit */
647                 if(!FLAC__bitwriter_write_raw_uint32(bw, 1, 1))
648                         return false;
649                 /* write the binary LSBs */
650                 if(r >= d) {
651                         if(!FLAC__bitwriter_write_raw_uint32(bw, r+d, k+1))
652                                 return false;
653                 }
654                 else {
655                         if(!FLAC__bitwriter_write_raw_uint32(bw, r, k))
656                                 return false;
657                 }
658         }
659         return true;
660 }
661
662 FLAC__bool FLAC__bitwriter_write_golomb_unsigned(FLAC__BitWriter *bw, unsigned uval, unsigned parameter)
663 {
664         unsigned total_bits, msbs;
665         unsigned k;
666
667         FLAC__ASSERT(0 != bw);
668         FLAC__ASSERT(0 != bw->buffer);
669         FLAC__ASSERT(parameter > 0);
670
671         k = FLAC__bitmath_ilog2(parameter);
672         if(parameter == 1u<<k) {
673                 unsigned pattern;
674
675                 FLAC__ASSERT(k <= 30);
676
677                 msbs = uval >> k;
678                 total_bits = 1 + k + msbs;
679                 pattern = 1 << k; /* the unary end bit */
680                 pattern |= (uval & ((1u<<k)-1)); /* the binary LSBs */
681
682                 if(total_bits <= 32) {
683                         if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, total_bits))
684                                 return false;
685                 }
686                 else {
687                         /* write the unary MSBs */
688                         if(!FLAC__bitwriter_write_zeroes(bw, msbs))
689                                 return false;
690                         /* write the unary end bit and binary LSBs */
691                         if(!FLAC__bitwriter_write_raw_uint32(bw, pattern, k+1))
692                                 return false;
693                 }
694         }
695         else {
696                 unsigned q, r, d;
697
698                 d = (1 << (k+1)) - parameter;
699                 q = uval / parameter;
700                 r = uval - (q * parameter);
701                 /* write the unary MSBs */
702                 if(!FLAC__bitwriter_write_zeroes(bw, q))
703                         return false;
704                 /* write the unary end bit */
705                 if(!FLAC__bitwriter_write_raw_uint32(bw, 1, 1))
706                         return false;
707                 /* write the binary LSBs */
708                 if(r >= d) {
709                         if(!FLAC__bitwriter_write_raw_uint32(bw, r+d, k+1))
710                                 return false;
711                 }
712                 else {
713                         if(!FLAC__bitwriter_write_raw_uint32(bw, r, k))
714                                 return false;
715                 }
716         }
717         return true;
718 }
719 #endif /* UNUSED */
720
721 FLAC__bool FLAC__bitwriter_write_utf8_uint32(FLAC__BitWriter *bw, FLAC__uint32 val)
722 {
723         FLAC__bool ok = 1;
724
725         FLAC__ASSERT(0 != bw);
726         FLAC__ASSERT(0 != bw->buffer);
727
728         FLAC__ASSERT(!(val & 0x80000000)); /* this version only handles 31 bits */
729
730         if(val < 0x80) {
731                 return FLAC__bitwriter_write_raw_uint32(bw, val, 8);
732         }
733         else if(val < 0x800) {
734                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xC0 | (val>>6), 8);
735                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (val&0x3F), 8);
736         }
737         else if(val < 0x10000) {
738                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xE0 | (val>>12), 8);
739                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>6)&0x3F), 8);
740                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (val&0x3F), 8);
741         }
742         else if(val < 0x200000) {
743                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xF0 | (val>>18), 8);
744                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>12)&0x3F), 8);
745                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>6)&0x3F), 8);
746                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (val&0x3F), 8);
747         }
748         else if(val < 0x4000000) {
749                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xF8 | (val>>24), 8);
750                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>18)&0x3F), 8);
751                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>12)&0x3F), 8);
752                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>6)&0x3F), 8);
753                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (val&0x3F), 8);
754         }
755         else {
756                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xFC | (val>>30), 8);
757                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>24)&0x3F), 8);
758                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>18)&0x3F), 8);
759                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>12)&0x3F), 8);
760                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | ((val>>6)&0x3F), 8);
761                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (val&0x3F), 8);
762         }
763
764         return ok;
765 }
766
767 FLAC__bool FLAC__bitwriter_write_utf8_uint64(FLAC__BitWriter *bw, FLAC__uint64 val)
768 {
769         FLAC__bool ok = 1;
770
771         FLAC__ASSERT(0 != bw);
772         FLAC__ASSERT(0 != bw->buffer);
773
774         FLAC__ASSERT(!(val & FLAC__U64L(0xFFFFFFF000000000))); /* this version only handles 36 bits */
775
776         if(val < 0x80) {
777                 return FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)val, 8);
778         }
779         else if(val < 0x800) {
780                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xC0 | (FLAC__uint32)(val>>6), 8);
781                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
782         }
783         else if(val < 0x10000) {
784                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xE0 | (FLAC__uint32)(val>>12), 8);
785                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
786                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
787         }
788         else if(val < 0x200000) {
789                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xF0 | (FLAC__uint32)(val>>18), 8);
790                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
791                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
792                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
793         }
794         else if(val < 0x4000000) {
795                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xF8 | (FLAC__uint32)(val>>24), 8);
796                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
797                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
798                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
799                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
800         }
801         else if(val < 0x80000000) {
802                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xFC | (FLAC__uint32)(val>>30), 8);
803                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>24)&0x3F), 8);
804                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
805                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
806                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
807                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
808         }
809         else {
810                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0xFE, 8);
811                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>30)&0x3F), 8);
812                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>24)&0x3F), 8);
813                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>18)&0x3F), 8);
814                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>12)&0x3F), 8);
815                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)((val>>6)&0x3F), 8);
816                 ok &= FLAC__bitwriter_write_raw_uint32(bw, 0x80 | (FLAC__uint32)(val&0x3F), 8);
817         }
818
819         return ok;
820 }
821
822 FLAC__bool FLAC__bitwriter_zero_pad_to_byte_boundary(FLAC__BitWriter *bw)
823 {
824         /* 0-pad to byte boundary */
825         if(bw->bits & 7u)
826                 return FLAC__bitwriter_write_zeroes(bw, 8 - (bw->bits & 7u));
827         else
828                 return true;
829 }
830
831 /* These functions a declared inline in this file but are also callable as
832  * externs from elsewhere.
833  * According to the C99 sepc, section 6.7.4, simply providing a function
834  * prototype in a header file without 'inline' and making the function inline
835  * in this file should be sufficient.
836  * Unfortunately, the Microsoft VS compiler doesn't pick them up externally. To
837  * fix that we add extern declarations here.
838  */
839 extern FLAC__bool FLAC__bitwriter_write_zeroes(FLAC__BitWriter *bw, unsigned bits);
840 extern FLAC__bool FLAC__bitwriter_write_raw_int32(FLAC__BitWriter *bw, FLAC__int32 val, unsigned bits);
841 extern FLAC__bool FLAC__bitwriter_write_raw_uint64(FLAC__BitWriter *bw, FLAC__uint64 val, unsigned bits);
842 extern FLAC__bool FLAC__bitwriter_write_raw_uint32_little_endian(FLAC__BitWriter *bw, FLAC__uint32 val);
843 extern FLAC__bool FLAC__bitwriter_write_byte_block(FLAC__BitWriter *bw, const FLAC__byte vals[], unsigned nvals);