1 #include "flac.h"
2 #include "../pcmconv.h"
3 #include "../buffer.h"
4 #include <string.h>
5 #include <ctype.h>
6 #include <errno.h>
7
8 /********************************************************
9 Audio Tools, a module and set of tools for manipulating audio data
10 Copyright (C) 2007-2014 Brian Langenberger
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 *******************************************************/
26
27 #ifndef STANDALONE
28 int
FlacDecoder_init(decoders_FlacDecoder * self,PyObject * args,PyObject * kwds)29 FlacDecoder_init(decoders_FlacDecoder *self,
30 PyObject *args, PyObject *kwds)
31 {
32 PyObject *file;
33 self->bitstream = NULL;
34
35 self->seektable = a_obj_new((ARRAY_COPY_FUNC)seekpoint_copy,
36 free,
37 NULL);
38
39 self->subframe_data = aa_int_new();
40 self->residuals = a_int_new();
41 self->qlp_coeffs = a_int_new();
42 self->framelist_data = a_int_new();
43 self->audiotools_pcm = NULL;
44 self->beginning_of_frames = NULL;
45 self->remaining_samples = 0;
46
47 if (!PyArg_ParseTuple(args, "O", &file)) {
48 return -1;
49 } else {
50 Py_INCREF(file);
51 }
52
53 /*treat file as Python-implemented file-like object*/
54 self->bitstream = br_open_external(
55 file,
56 BS_BIG_ENDIAN,
57 4096,
58 (ext_read_f)br_read_python,
59 (ext_setpos_f)bs_setpos_python,
60 (ext_getpos_f)bs_getpos_python,
61 (ext_free_pos_f)bs_free_pos_python,
62 (ext_seek_f)bs_fseek_python,
63 (ext_close_f)bs_close_python,
64 (ext_free_f)bs_free_python_decref);
65
66 /*read the STREAMINFO block, SEEKTABLE block
67 and setup the total number of samples to read*/
68 if (flacdec_read_metadata(self->bitstream,
69 &(self->streaminfo),
70 self->seektable,
71 &(self->channel_mask))) {
72 self->streaminfo.channels = 0;
73 return -1;
74 }
75
76 /*place mark at beginning of stream but after metadata
77 in case seeking is needed*/
78 if (!setjmp(*br_try(self->bitstream))) {
79 self->beginning_of_frames = self->bitstream->getpos(self->bitstream);
80 br_etry(self->bitstream);
81 } else {
82 br_etry(self->bitstream);
83 PyErr_SetString(PyExc_IOError, "unable to mark beginning of stream");
84 return -1;
85 }
86
87 self->remaining_samples = self->streaminfo.total_samples;
88
89 /*initialize the output MD5 sum*/
90 audiotools__MD5Init(&(self->md5));
91 self->perform_validation = 1;
92 self->stream_finalized = 0;
93
94 /*setup a framelist generator function*/
95 if ((self->audiotools_pcm = open_audiotools_pcm()) == NULL)
96 return -1;
97
98 /*mark stream as not closed and ready for reading*/
99 self->closed = 0;
100
101 return 0;
102 }
103
104 PyObject*
FlacDecoder_close(decoders_FlacDecoder * self,PyObject * args)105 FlacDecoder_close(decoders_FlacDecoder* self,
106 PyObject *args)
107 {
108 /*mark stream as closed so more calls to read()
109 generate ValueErrors*/
110 self->closed = 1;
111
112 /*close internal stream itself*/
113 self->bitstream->close_internal_stream(self->bitstream);
114
115 Py_INCREF(Py_None);
116 return Py_None;
117 }
118
119 static PyObject*
FlacDecoder_enter(decoders_FlacDecoder * self,PyObject * args)120 FlacDecoder_enter(decoders_FlacDecoder* self, PyObject *args)
121 {
122 Py_INCREF(self);
123 return (PyObject *)self;
124 }
125
126 static PyObject*
FlacDecoder_exit(decoders_FlacDecoder * self,PyObject * args)127 FlacDecoder_exit(decoders_FlacDecoder* self, PyObject *args)
128 {
129 self->closed = 1;
130 self->bitstream->close_internal_stream(self->bitstream);
131 Py_INCREF(Py_None);
132 return Py_None;
133 }
134
135 void
FlacDecoder_dealloc(decoders_FlacDecoder * self)136 FlacDecoder_dealloc(decoders_FlacDecoder *self)
137 {
138
139 self->subframe_data->del(self->subframe_data);
140 self->residuals->del(self->residuals);
141 self->qlp_coeffs->del(self->qlp_coeffs);
142 self->framelist_data->del(self->framelist_data);
143 Py_XDECREF(self->audiotools_pcm);
144
145 /*clean out seek mark, if necessary*/
146 if (self->beginning_of_frames != NULL) {
147 self->beginning_of_frames->del(self->beginning_of_frames);
148 }
149
150 if (self->bitstream != NULL) {
151 self->bitstream->free(self->bitstream);
152 }
153
154 self->seektable->del(self->seektable);
155
156 Py_TYPE(self)->tp_free((PyObject*)self);
157 }
158
159 PyObject*
FlacDecoder_new(PyTypeObject * type,PyObject * args,PyObject * kwds)160 FlacDecoder_new(PyTypeObject *type,
161 PyObject *args, PyObject *kwds)
162 {
163 decoders_FlacDecoder *self;
164
165 self = (decoders_FlacDecoder *)type->tp_alloc(type, 0);
166
167 return (PyObject *)self;
168 }
169
170 static PyObject*
FlacDecoder_sample_rate(decoders_FlacDecoder * self,void * closure)171 FlacDecoder_sample_rate(decoders_FlacDecoder *self, void *closure)
172 {
173 return Py_BuildValue("i", self->streaminfo.sample_rate);
174 }
175
176 static PyObject*
FlacDecoder_bits_per_sample(decoders_FlacDecoder * self,void * closure)177 FlacDecoder_bits_per_sample(decoders_FlacDecoder *self, void *closure)
178 {
179 return Py_BuildValue("i", self->streaminfo.bits_per_sample);
180 }
181
182 static PyObject*
FlacDecoder_channels(decoders_FlacDecoder * self,void * closure)183 FlacDecoder_channels(decoders_FlacDecoder *self, void *closure)
184 {
185 return Py_BuildValue("i", self->streaminfo.channels);
186 }
187
188 static PyObject*
FlacDecoder_channel_mask(decoders_FlacDecoder * self,void * closure)189 FlacDecoder_channel_mask(decoders_FlacDecoder *self, void *closure)
190 {
191 return Py_BuildValue("i", self->channel_mask);
192 }
193
194 PyObject*
FlacDecoder_read(decoders_FlacDecoder * self,PyObject * args)195 FlacDecoder_read(decoders_FlacDecoder* self, PyObject *args)
196 {
197 uint16_t crc16 = 0;
198 int channel;
199 struct flac_frame_header frame_header;
200 PyObject* framelist;
201 flac_status error;
202
203 if (self->closed) {
204 PyErr_SetString(PyExc_ValueError, "cannot read closed stream");
205 return NULL;
206 }
207
208 self->subframe_data->reset(self->subframe_data);
209
210 /*if all samples have been read, return an empty FrameList*/
211 if (self->stream_finalized) {
212 return empty_FrameList(self->audiotools_pcm,
213 self->streaminfo.channels,
214 self->streaminfo.bits_per_sample);
215 }
216
217 if (self->remaining_samples < 1) {
218 self->stream_finalized = 1;
219
220 if (FlacDecoder_verify_okay(self)) {
221 return empty_FrameList(self->audiotools_pcm,
222 self->streaminfo.channels,
223 self->streaminfo.bits_per_sample);
224 } else {
225 PyErr_SetString(PyExc_ValueError,
226 "MD5 mismatch at end of stream");
227 return NULL;
228 }
229 }
230
231 if (!setjmp(*br_try(self->bitstream))) {
232 /*add callback for CRC16 calculation*/
233 self->bitstream->add_callback(self->bitstream, (bs_callback_f)flac_crc16, &crc16);
234
235 /*read frame header*/
236 if ((error = flacdec_read_frame_header(self->bitstream,
237 &(self->streaminfo),
238 &frame_header)) != OK) {
239 self->bitstream->pop_callback(self->bitstream, NULL);
240 PyErr_SetString(PyExc_ValueError, FlacDecoder_strerror(error));
241 br_etry(self->bitstream);
242 return NULL;
243 }
244
245 /*read 1 subframe per channel*/
246 for (channel = 0; channel < frame_header.channel_count; channel++)
247 if ((error =
248 flacdec_read_subframe(
249 self->bitstream,
250 self->qlp_coeffs,
251 self->residuals,
252 (unsigned int)MIN(frame_header.block_size,
253 self->remaining_samples),
254 flacdec_subframe_bits_per_sample(&frame_header,
255 channel),
256 self->subframe_data->append(self->subframe_data))) != OK) {
257 self->bitstream->pop_callback(self->bitstream, NULL);
258 PyErr_SetString(PyExc_ValueError, FlacDecoder_strerror(error));
259 br_etry(self->bitstream);
260 return NULL;
261 }
262
263 /*handle difference channels, if any*/
264 flacdec_decorrelate_channels(frame_header.channel_assignment,
265 self->subframe_data,
266 self->framelist_data);
267
268 /*check CRC-16*/
269 self->bitstream->byte_align(self->bitstream);
270 self->bitstream->read(self->bitstream, 16);
271 self->bitstream->pop_callback(self->bitstream, NULL);
272 if (crc16 != 0) {
273 PyErr_SetString(PyExc_ValueError, "invalid checksum in frame");
274 br_etry(self->bitstream);
275 return NULL;
276 }
277
278 /*decrement remaining samples*/
279 self->remaining_samples -= frame_header.block_size;
280 } else {
281 /*handle I/O error during read*/
282 self->bitstream->pop_callback(self->bitstream, NULL);
283 PyErr_SetString(PyExc_IOError, "EOF reading frame");
284 br_etry(self->bitstream);
285 return NULL;
286 }
287
288 br_etry(self->bitstream);
289
290 framelist = a_int_to_FrameList(self->audiotools_pcm,
291 self->framelist_data,
292 frame_header.channel_count,
293 frame_header.bits_per_sample);
294 if (framelist != NULL) {
295 /*update MD5 sum*/
296 if (FlacDecoder_update_md5sum(self, framelist) == OK)
297 /*return pcm.FrameList Python object*/
298 return framelist;
299 else {
300 Py_DECREF(framelist);
301 return NULL;
302 }
303 } else {
304 return NULL;
305 }
306 }
307
308 static PyObject*
FlacDecoder_seek(decoders_FlacDecoder * self,PyObject * args)309 FlacDecoder_seek(decoders_FlacDecoder* self, PyObject *args)
310 {
311 long long seeked_offset;
312
313 const a_obj* seektable = self->seektable;
314 uint64_t pcm_frames_offset = 0;
315 uint64_t byte_offset = 0;
316 unsigned i;
317
318 if (self->closed) {
319 PyErr_SetString(PyExc_ValueError, "cannot seek closed stream");
320 return NULL;
321 }
322
323 if (!PyArg_ParseTuple(args, "L", &seeked_offset))
324 return NULL;
325
326 if (seeked_offset < 0) {
327 PyErr_SetString(PyExc_ValueError, "cannot seek to negative value");
328 return NULL;
329 }
330
331 self->stream_finalized = 0;
332
333 /*find latest seekpoint whose first sample is <= seeked_offset
334 or 0 if there are no seekpoints in the seektable*/
335 for (i = 0; i < seektable->len; i++) {
336 struct flac_SEEKPOINT* seekpoint = seektable->_[i];
337 if (seekpoint->sample_number <= seeked_offset) {
338 pcm_frames_offset = seekpoint->sample_number;
339 byte_offset = seekpoint->byte_offset;
340 } else {
341 break;
342 }
343 }
344
345 /*position bitstream to indicated value in file*/
346 if (!setjmp(*br_try(self->bitstream))) {
347 self->bitstream->setpos(self->bitstream, self->beginning_of_frames);
348 while (byte_offset) {
349 /*perform this in chunks in case seeked distance
350 is longer than a "long" taken by fseek*/
351 const uint64_t seek = MIN(byte_offset, LONG_MAX);
352 self->bitstream->seek(self->bitstream,
353 (long)seek,
354 BS_SEEK_CUR);
355 byte_offset -= seek;
356 }
357 br_etry(self->bitstream);
358 } else {
359 br_etry(self->bitstream);
360 PyErr_SetString(PyExc_IOError, "I/O error seeking in stream");
361 return NULL;
362 }
363
364 /*reset stream's total remaining frames*/
365 self->remaining_samples = (self->streaminfo.total_samples -
366 pcm_frames_offset);
367
368 if (pcm_frames_offset == 0) {
369 /*if pcm_frames_offset is 0, reset MD5 validation*/
370 audiotools__MD5Init(&(self->md5));
371 self->perform_validation = 1;
372 } else {
373 /*otherwise, disable MD5 validation altogether at end of stream*/
374 self->perform_validation = 0;
375 }
376
377 /*return actual PCM frames position in file*/
378 return Py_BuildValue("K", pcm_frames_offset);
379 }
380
381 static void
increment_offset(uint8_t value,unsigned long long * offset)382 increment_offset(uint8_t value, unsigned long long *offset)
383 {
384 *offset += 1;
385 }
386
387 static PyObject*
FlacDecoder_offsets(decoders_FlacDecoder * self,PyObject * args)388 FlacDecoder_offsets(decoders_FlacDecoder* self, PyObject *args)
389 {
390 int channel;
391 struct flac_frame_header frame_header;
392 flac_status error;
393 PyObject* offsets = PyList_New(0);
394 PyObject* offset_pair;
395 unsigned long long total_offset = 0;
396 unsigned samples;
397 unsigned long long offset;
398
399 self->bitstream->add_callback(self->bitstream,
400 (bs_callback_f)increment_offset,
401 &total_offset);
402
403 while (self->remaining_samples > 0) {
404 self->subframe_data->reset(self->subframe_data);
405 offset = total_offset;
406
407 if (!setjmp(*br_try(self->bitstream))) {
408 /*read frame header*/
409 if ((error = flacdec_read_frame_header(self->bitstream,
410 &(self->streaminfo),
411 &frame_header)) != OK) {
412 PyErr_SetString(PyExc_ValueError, FlacDecoder_strerror(error));
413 goto error;
414 }
415
416 samples = frame_header.block_size;
417
418 /*read 1 subframe per channel*/
419 for (channel = 0; channel < frame_header.channel_count; channel++)
420 if ((error =
421 flacdec_read_subframe(
422 self->bitstream,
423 self->qlp_coeffs,
424 self->residuals,
425 (unsigned int)MIN(frame_header.block_size,
426 self->remaining_samples),
427 flacdec_subframe_bits_per_sample(&frame_header,
428 channel),
429 self->subframe_data->append(self->subframe_data))) !=
430 OK) {
431 PyErr_SetString(PyExc_ValueError,
432 FlacDecoder_strerror(error));
433 goto error;
434 }
435
436 /*read CRC-16*/
437 self->bitstream->byte_align(self->bitstream);
438 self->bitstream->read(self->bitstream, 16);
439
440 /*decrement remaining samples*/
441 self->remaining_samples -= frame_header.block_size;
442
443 /*add offset pair to our list*/
444 offset_pair = Py_BuildValue("(K, I)", offset, samples);
445 PyList_Append(offsets, offset_pair);
446 Py_DECREF(offset_pair);
447 } else {
448 /*handle I/O error during read*/
449 PyErr_SetString(PyExc_IOError, "EOF reading frame");
450 goto error;
451 }
452
453 br_etry(self->bitstream);
454 }
455
456 self->stream_finalized = 1;
457 self->bitstream->pop_callback(self->bitstream, NULL);
458
459 return offsets;
460 error:
461 Py_XDECREF(offsets);
462 br_etry(self->bitstream);
463 self->bitstream->pop_callback(self->bitstream, NULL);
464
465 return NULL;
466 }
467
468 flac_status
FlacDecoder_update_md5sum(decoders_FlacDecoder * self,PyObject * framelist)469 FlacDecoder_update_md5sum(decoders_FlacDecoder *self,
470 PyObject *framelist)
471 {
472 if (self->perform_validation) {
473 PyObject *string = PyObject_CallMethod(framelist,
474 "to_bytes","ii",
475 0,
476 1);
477 char *string_buffer;
478 Py_ssize_t length;
479
480 if (string != NULL) {
481 if (PyBytes_AsStringAndSize(string,
482 &string_buffer,
483 &length) == 0) {
484 audiotools__MD5Update(&(self->md5),
485 (unsigned char *)string_buffer,
486 length);
487 Py_DECREF(string);
488 return OK;
489 } else {
490 Py_DECREF(string);
491 return ERROR;
492 }
493 } else {
494 return ERROR;
495 }
496 } else {
497 return OK;
498 }
499 }
500
501 int
FlacDecoder_verify_okay(decoders_FlacDecoder * self)502 FlacDecoder_verify_okay(decoders_FlacDecoder *self)
503 {
504 if (self->perform_validation) {
505 unsigned char stream_md5sum[16];
506 const static unsigned char blank_md5sum[16] = {0, 0, 0, 0, 0, 0, 0, 0,
507 0, 0, 0, 0, 0, 0, 0, 0};
508
509 audiotools__MD5Final(stream_md5sum, &(self->md5));
510
511 return ((memcmp(self->streaminfo.md5sum, blank_md5sum, 16) == 0) ||
512 (memcmp(stream_md5sum, self->streaminfo.md5sum, 16) == 0));
513 } else {
514 return 1;
515 }
516 }
517
518 #endif
519
520 static unsigned
channel_bits(unsigned channel_mask)521 channel_bits(unsigned channel_mask)
522 {
523 unsigned bits = 0;
524 while (channel_mask > 0) {
525 bits += (channel_mask & 0x1);
526 channel_mask >>= 1;
527 }
528 return bits;
529 }
530
531 static void
flacdec_read_vorbis_comment(BitstreamReader * comment,unsigned channel_count,int * channel_mask)532 flacdec_read_vorbis_comment(BitstreamReader *comment,
533 unsigned channel_count,
534 int *channel_mask)
535 {
536 struct bs_buffer *line = buf_new();
537 unsigned line_len;
538 unsigned total_lines;
539 const char mask_prefix[] =
540 "WAVEFORMATEXTENSIBLE_CHANNEL_MASK=";
541
542 comment->set_endianness(comment, BS_LITTLE_ENDIAN);
543
544 if (!setjmp(*br_try(comment))) {
545 /*skip over vendor string*/
546 line_len = comment->read(comment, 32);
547 comment->skip_bytes(comment, line_len);
548
549 /*walk through all entries in the comment*/
550 for (total_lines = comment->read(comment, 32);
551 total_lines > 0;
552 total_lines--) {
553 const char *s;
554
555 /*populate entry one character at a time
556 (this avoids allocating a big chunk of space
557 if the length field is something way too large)*/
558 buf_reset(line);
559
560 for (line_len = comment->read(comment, 32);
561 line_len > 0;
562 line_len--) {
563 buf_putc(
564 toupper((int)comment->read(comment, 8)),
565 line);
566 }
567 buf_putc(0, line); /*NULL terminator*/
568
569 s = (const char *)buf_window_start(line);
570
571 /*if line starts with mask prefix*/
572 if (strstr(s, mask_prefix) == s) {
573 /*convert rest of line to base-16 integer*/
574 unsigned mask = (unsigned)strtoul(
575 s + strlen(mask_prefix), NULL, 16);
576 /*and populate mask field if its number of channel bits
577 matches the stream's channel count*/
578 if (channel_bits(mask) == channel_count) {
579 *channel_mask = mask;
580 }
581 }
582 }
583 br_etry(comment);
584 } else {
585 /*read error in VORBIS_COMMENT
586 (probably invalid length field somewhere)*/
587 br_etry(comment);
588 }
589
590 buf_close(line);
591 }
592
593 int
flacdec_read_metadata(BitstreamReader * bitstream,struct flac_STREAMINFO * streaminfo,a_obj * seektable,int * channel_mask)594 flacdec_read_metadata(BitstreamReader *bitstream,
595 struct flac_STREAMINFO *streaminfo,
596 a_obj *seektable,
597 int *channel_mask)
598 {
599 enum {
600 fL = 0x1,
601 fR = 0x2,
602 fC = 0x4,
603 LFE = 0x8,
604 bL = 0x10,
605 bR = 0x20,
606 bC = 0x100,
607 sL = 0x200,
608 sR = 0x400
609 };
610
611 if (!setjmp(*br_try(bitstream))) {
612 unsigned last_block;
613
614 if (bitstream->read(bitstream, 32) != 0x664C6143u) {
615 #ifndef STANDALONE
616 PyErr_SetString(PyExc_ValueError, "not a FLAC file");
617 #endif
618 br_etry(bitstream);
619 return 1;
620 }
621
622 do {
623 last_block = bitstream->read(bitstream, 1);
624 const unsigned block_type = bitstream->read(bitstream, 7);
625 const unsigned block_length = bitstream->read(bitstream, 24);
626
627 switch (block_type) {
628 case 0: /*STREAMINFO*/
629 streaminfo->minimum_block_size =
630 bitstream->read(bitstream, 16);
631 streaminfo->maximum_block_size =
632 bitstream->read(bitstream, 16);
633 streaminfo->minimum_frame_size =
634 bitstream->read(bitstream, 24);
635 streaminfo->maximum_frame_size =
636 bitstream->read(bitstream, 24);
637 streaminfo->sample_rate =
638 bitstream->read(bitstream, 20);
639 streaminfo->channels =
640 bitstream->read(bitstream, 3) + 1;
641 streaminfo->bits_per_sample =
642 bitstream->read(bitstream, 5) + 1;
643 streaminfo->total_samples =
644 bitstream->read_64(bitstream, 36);
645
646 bitstream->read_bytes(bitstream, streaminfo->md5sum, 16);
647
648 /*default channel mask based on channel count*/
649 switch (streaminfo->channels) {
650 case 1:
651 *channel_mask = fC;
652 break;
653 case 2:
654 *channel_mask = fL | fR;
655 break;
656 case 3:
657 *channel_mask = fL | fR | fC;
658 break;
659 case 4:
660 *channel_mask = fL | fR | bL | bR;
661 break;
662 case 5:
663 *channel_mask = fL | fR | fC | bL | bR;
664 break;
665 case 6:
666 *channel_mask = fL | fR | fC | LFE | bL | bR;
667 break;
668 case 7:
669 *channel_mask = fL | fR | fC | LFE | bC | sL | sR;
670 break;
671 case 8:
672 *channel_mask = fL | fR | fC | LFE | bL | bR | sL | sR;
673 break;
674 default:
675 /*shouldn't be able to happen*/
676 *channel_mask = 0;
677 break;
678 }
679 break;
680 case 3: /*SEEKTABLE*/
681 {
682 unsigned seekpoints = block_length / 18;
683 seektable->reset_for(seektable, seekpoints);
684
685 for (; seekpoints > 0; seekpoints--) {
686 struct flac_SEEKPOINT seekpoint;
687 seekpoint.sample_number =
688 bitstream->read_64(bitstream, 64);
689 seekpoint.byte_offset =
690 bitstream->read_64(bitstream, 64);
691 seekpoint.samples =
692 bitstream->read(bitstream, 16);
693 seektable->append(seektable, &seekpoint);
694 }
695 }
696 break;
697 case 4: /*VORBIS_COMMENT*/
698 {
699 /*Vorbis comment's channel mask - if any -
700 overrides default one from channel count */
701 BitstreamReader *comment =
702 bitstream->substream(bitstream, block_length);
703
704 flacdec_read_vorbis_comment(comment,
705 streaminfo->channels,
706 channel_mask);
707
708 comment->close(comment);
709 }
710 break;
711 default: /*all other blocks*/
712 bitstream->skip(bitstream, block_length * 8);
713 break;
714 }
715 } while (!last_block);
716
717 br_etry(bitstream);
718 return 0;
719 } else {
720 #ifndef STANDALONE
721 PyErr_SetString(PyExc_IOError, "EOF while reading metadata");
722 #endif
723 br_etry(bitstream);
724 return 1;
725 }
726 }
727
728 flac_status
flacdec_read_frame_header(BitstreamReader * bitstream,struct flac_STREAMINFO * streaminfo,struct flac_frame_header * header)729 flacdec_read_frame_header(BitstreamReader *bitstream,
730 struct flac_STREAMINFO *streaminfo,
731 struct flac_frame_header *header)
732 {
733 unsigned block_size_bits;
734 unsigned sample_rate_bits;
735 uint8_t crc8 = 0;
736
737 if (!setjmp(*br_try(bitstream))) {
738 bitstream->add_callback(bitstream, (bs_callback_f)flac_crc8, &crc8);
739
740 /*read and verify sync code*/
741 if (bitstream->read(bitstream, 14) != 0x3FFE) {
742 bitstream->pop_callback(bitstream, NULL);
743 br_etry(bitstream);
744 return ERR_INVALID_SYNC_CODE;
745 }
746
747 /*read and verify reserved bit*/
748 if (bitstream->read(bitstream, 1) != 0) {
749 bitstream->pop_callback(bitstream, NULL);
750 br_etry(bitstream);
751 return ERR_INVALID_RESERVED_BIT;
752 }
753
754 header->blocking_strategy = bitstream->read(bitstream, 1);
755
756 block_size_bits = bitstream->read(bitstream, 4);
757 sample_rate_bits = bitstream->read(bitstream, 4);
758 header->channel_assignment = bitstream->read(bitstream, 4);
759 switch (header->channel_assignment) {
760 case 0x8:
761 case 0x9:
762 case 0xA:
763 header->channel_count = 2;
764 break;
765 default:
766 header->channel_count = header->channel_assignment + 1;
767 break;
768 }
769
770 switch (bitstream->read(bitstream, 3)) {
771 case 0:
772 header->bits_per_sample = streaminfo->bits_per_sample;
773 break;
774 case 1:
775 header->bits_per_sample = 8; break;
776 case 2:
777 header->bits_per_sample = 12; break;
778 case 4:
779 header->bits_per_sample = 16; break;
780 case 5:
781 header->bits_per_sample = 20; break;
782 case 6:
783 header->bits_per_sample = 24; break;
784 default:
785 return ERR_INVALID_BITS_PER_SAMPLE;
786 }
787 bitstream->read(bitstream, 1); /*padding*/
788
789 header->frame_number = read_utf8(bitstream);
790
791 switch (block_size_bits) {
792 case 0x0: header->block_size = streaminfo->maximum_block_size;
793 break;
794 case 0x1: header->block_size = 192; break;
795 case 0x2: header->block_size = 576; break;
796 case 0x3: header->block_size = 1152; break;
797 case 0x4: header->block_size = 2304; break;
798 case 0x5: header->block_size = 4608; break;
799 case 0x6: header->block_size = bitstream->read(bitstream, 8) + 1;
800 break;
801 case 0x7: header->block_size = bitstream->read(bitstream, 16) + 1;
802 break;
803 case 0x8: header->block_size = 256; break;
804 case 0x9: header->block_size = 512; break;
805 case 0xA: header->block_size = 1024; break;
806 case 0xB: header->block_size = 2048; break;
807 case 0xC: header->block_size = 4096; break;
808 case 0xD: header->block_size = 8192; break;
809 case 0xE: header->block_size = 16384; break;
810 case 0xF: header->block_size = 32768; break;
811 }
812
813 switch (sample_rate_bits) {
814 case 0x0: header->sample_rate = streaminfo->sample_rate; break;
815 case 0x1: header->sample_rate = 88200; break;
816 case 0x2: header->sample_rate = 176400; break;
817 case 0x3: header->sample_rate = 192000; break;
818 case 0x4: header->sample_rate = 8000; break;
819 case 0x5: header->sample_rate = 16000; break;
820 case 0x6: header->sample_rate = 22050; break;
821 case 0x7: header->sample_rate = 24000; break;
822 case 0x8: header->sample_rate = 32000; break;
823 case 0x9: header->sample_rate = 44100; break;
824 case 0xA: header->sample_rate = 48000; break;
825 case 0xB: header->sample_rate = 96000; break;
826 case 0xC: header->sample_rate = bitstream->read(bitstream, 8) * 1000;
827 break;
828 case 0xD: header->sample_rate = bitstream->read(bitstream, 16);
829 break;
830 case 0xE: header->sample_rate = bitstream->read(bitstream, 16) * 10;
831 break;
832 case 0xF:
833 return ERR_INVALID_SAMPLE_RATE;
834 }
835
836 /*check for valid CRC-8 value*/
837 bitstream->read(bitstream, 8);
838
839 /*no more I/O after this point*/
840 bitstream->pop_callback(bitstream, NULL);
841 br_etry(bitstream);
842
843 if (crc8 != 0)
844 return ERR_INVALID_FRAME_CRC;
845
846 /*Once we've read everything,
847 ensure the values are compatible with STREAMINFO.*/
848
849 if (streaminfo->sample_rate != header->sample_rate) {
850 return ERR_SAMPLE_RATE_MISMATCH;
851 }
852 if (streaminfo->channels != header->channel_count) {
853 return ERR_CHANNEL_COUNT_MISMATCH;
854 }
855 if (streaminfo->bits_per_sample != header->bits_per_sample) {
856 return ERR_BITS_PER_SAMPLE_MISMATCH;
857 }
858 if (header->block_size > streaminfo->maximum_block_size) {
859 return ERR_MAXIMUM_BLOCK_SIZE_EXCEEDED;
860 }
861
862 return OK;
863 } else {
864 /*push read error to calling function*/
865 bitstream->pop_callback(bitstream, NULL);
866 br_etry(bitstream);
867 br_abort(bitstream);
868 return OK; /*won't get here*/
869 }
870 }
871
872 flac_status
flacdec_read_subframe(BitstreamReader * bitstream,a_int * qlp_coeffs,a_int * residuals,unsigned block_size,unsigned bits_per_sample,a_int * samples)873 flacdec_read_subframe(BitstreamReader* bitstream,
874 a_int* qlp_coeffs,
875 a_int* residuals,
876 unsigned block_size,
877 unsigned bits_per_sample,
878 a_int* samples)
879 {
880 struct flac_subframe_header subframe_header;
881 unsigned i;
882 flac_status error = OK;
883
884 if (flacdec_read_subframe_header(
885 bitstream,
886 &subframe_header) == ERR_INVALID_SUBFRAME_TYPE)
887 return ERR_INVALID_SUBFRAME_TYPE;
888
889 /*account for wasted bits-per-sample*/
890 if (subframe_header.wasted_bits_per_sample > 0)
891 bits_per_sample -= subframe_header.wasted_bits_per_sample;
892
893 switch (subframe_header.type) {
894 case FLAC_SUBFRAME_CONSTANT:
895 error = flacdec_read_constant_subframe(bitstream,
896 block_size,
897 bits_per_sample,
898 samples);
899 break;
900 case FLAC_SUBFRAME_VERBATIM:
901 error = flacdec_read_verbatim_subframe(bitstream,
902 block_size,
903 bits_per_sample,
904 samples);
905 break;
906 case FLAC_SUBFRAME_FIXED:
907 error = flacdec_read_fixed_subframe(bitstream,
908 residuals,
909 subframe_header.order,
910 block_size,
911 bits_per_sample,
912 samples);
913 break;
914 case FLAC_SUBFRAME_LPC:
915 error = flacdec_read_lpc_subframe(bitstream,
916 qlp_coeffs,
917 residuals,
918 subframe_header.order,
919 block_size,
920 bits_per_sample,
921 samples);
922 break;
923 }
924
925 if (error != OK)
926 return error;
927
928 /*reinsert wasted bits-per-sample, if necessary*/
929 if (subframe_header.wasted_bits_per_sample > 0)
930 for (i = 0; i < block_size; i++)
931 samples->_[i] <<= subframe_header.wasted_bits_per_sample;
932
933 return OK;
934 }
935
936 flac_status
flacdec_read_subframe_header(BitstreamReader * bitstream,struct flac_subframe_header * subframe_header)937 flacdec_read_subframe_header(BitstreamReader *bitstream,
938 struct flac_subframe_header *subframe_header)
939 {
940 unsigned subframe_type;
941
942 bitstream->read(bitstream, 1); /*padding*/
943 subframe_type = bitstream->read(bitstream, 6);
944 if (subframe_type == 0) {
945 subframe_header->type = FLAC_SUBFRAME_CONSTANT;
946 subframe_header->order = 0;
947 } else if (subframe_type == 1) {
948 subframe_header->type = FLAC_SUBFRAME_VERBATIM;
949 subframe_header->order = 0;
950 } else if ((subframe_type & 0x38) == 0x08) {
951 subframe_header->type = FLAC_SUBFRAME_FIXED;
952 subframe_header->order = subframe_type & 0x07;
953 } else if ((subframe_type & 0x20) == 0x20) {
954 subframe_header->type = FLAC_SUBFRAME_LPC;
955 subframe_header->order = (subframe_type & 0x1F) + 1;
956 } else {
957 return ERR_INVALID_SUBFRAME_TYPE;
958 }
959
960 if (bitstream->read(bitstream, 1) == 0) {
961 subframe_header->wasted_bits_per_sample = 0;
962 } else {
963 subframe_header->wasted_bits_per_sample = bitstream->read_unary(
964 bitstream, 1) + 1;
965 }
966
967 return OK;
968 }
969
970 unsigned int
flacdec_subframe_bits_per_sample(struct flac_frame_header * frame_header,unsigned int channel_number)971 flacdec_subframe_bits_per_sample(struct flac_frame_header *frame_header,
972 unsigned int channel_number) {
973 if (((frame_header->channel_assignment == 0x8) &&
974 (channel_number == 1)) ||
975 ((frame_header->channel_assignment == 0x9) &&
976 (channel_number == 0)) ||
977 ((frame_header->channel_assignment == 0xA) &&
978 (channel_number == 1))) {
979 return frame_header->bits_per_sample + 1;
980 } else {
981 return frame_header->bits_per_sample;
982 }
983 }
984
985 flac_status
flacdec_read_constant_subframe(BitstreamReader * bitstream,unsigned block_size,unsigned bits_per_sample,a_int * samples)986 flacdec_read_constant_subframe(BitstreamReader* bitstream,
987 unsigned block_size,
988 unsigned bits_per_sample,
989 a_int* samples)
990 {
991 const int value = bitstream->read_signed(bitstream, bits_per_sample);
992
993 samples->mset(samples, block_size, value);
994
995 return OK;
996 }
997
998 flac_status
flacdec_read_verbatim_subframe(BitstreamReader * bitstream,unsigned block_size,unsigned bits_per_sample,a_int * samples)999 flacdec_read_verbatim_subframe(BitstreamReader* bitstream,
1000 unsigned block_size,
1001 unsigned bits_per_sample,
1002 a_int* samples)
1003 {
1004 unsigned i;
1005
1006 samples->reset_for(samples, block_size);
1007
1008 for (i = 0; i < block_size; i++)
1009 a_append(samples,
1010 bitstream->read_signed(bitstream, bits_per_sample));
1011
1012 return OK;
1013 }
1014
1015 flac_status
flacdec_read_fixed_subframe(BitstreamReader * bitstream,a_int * residuals,unsigned order,unsigned block_size,unsigned bits_per_sample,a_int * samples)1016 flacdec_read_fixed_subframe(BitstreamReader* bitstream,
1017 a_int* residuals,
1018 unsigned order,
1019 unsigned block_size,
1020 unsigned bits_per_sample,
1021 a_int* samples)
1022 {
1023 unsigned i;
1024 flac_status error;
1025 int* s_data;
1026 int* r_data;
1027
1028 /*ensure that samples->data won't be realloc'ated*/
1029 samples->reset_for(samples, block_size);
1030 s_data = samples->_;
1031
1032 /*read "order" number of warm-up samples*/
1033 for (i = 0; i < order; i++) {
1034 a_append(samples,
1035 bitstream->read_signed(bitstream, bits_per_sample));
1036 }
1037
1038 /*read the residual block*/
1039 if ((error = flacdec_read_residual(bitstream,
1040 order,
1041 block_size,
1042 residuals)) != OK)
1043 return error;
1044 else
1045 r_data = residuals->_;
1046
1047 /*calculate subframe samples from warm-up samples and residual*/
1048 switch (order) {
1049 case 0:
1050 samples->extend(samples, residuals);
1051 break;
1052 case 1:
1053 for (i = 1; i < block_size; i++)
1054 a_append(samples, s_data[i - 1] + r_data[i - 1]);
1055 break;
1056 case 2:
1057 for (i = 2; i < block_size; i++)
1058 a_append(samples,
1059 (2 * s_data[i - 1]) -
1060 s_data[i - 2] +
1061 r_data[i - 2]);
1062 break;
1063 case 3:
1064 for (i = 3; i < block_size; i++)
1065 a_append(samples,
1066 (3 * s_data[i - 1]) -
1067 (3 * s_data[i - 2]) +
1068 s_data[i - 3] +
1069 r_data[i - 3]);
1070 break;
1071 case 4:
1072 for (i = 4; i < block_size; i++)
1073 a_append(samples,
1074 (4 * s_data[i - 1]) -
1075 (6 * s_data[i - 2]) +
1076 (4 * s_data[i - 3]) -
1077 s_data[i - 4] +
1078 r_data[i - 4]);
1079
1080 break;
1081 default:
1082 return ERR_INVALID_FIXED_ORDER;
1083 }
1084
1085 return OK;
1086 }
1087
1088 flac_status
flacdec_read_lpc_subframe(BitstreamReader * bitstream,a_int * qlp_coeffs,a_int * residuals,unsigned order,unsigned block_size,unsigned bits_per_sample,a_int * samples)1089 flacdec_read_lpc_subframe(BitstreamReader* bitstream,
1090 a_int* qlp_coeffs,
1091 a_int* residuals,
1092 unsigned order,
1093 unsigned block_size,
1094 unsigned bits_per_sample,
1095 a_int* samples)
1096 {
1097 unsigned i;
1098 unsigned qlp_precision;
1099 unsigned qlp_shift_needed;
1100
1101 int* s_data;
1102 int* r_data;
1103 int* qlp_data;
1104 flac_status error;
1105
1106 qlp_coeffs->reset(qlp_coeffs);
1107 samples->reset_for(samples, block_size);
1108 s_data = samples->_;
1109
1110 /*read order number of warm-up samples*/
1111 for (i = 0; i < order; i++) {
1112 a_append(samples,
1113 bitstream->read_signed(bitstream, bits_per_sample));
1114 }
1115
1116 /*read QLP precision*/
1117 qlp_precision = bitstream->read(bitstream, 4) + 1;
1118
1119 /*read QLP shift needed*/
1120 qlp_shift_needed = bitstream->read_signed(bitstream, 5);
1121 qlp_shift_needed = MAX(qlp_shift_needed, 0);
1122
1123 /*read order number of QLP coefficients of size qlp_precision*/
1124 for (i = 0; i < order; i++) {
1125 qlp_coeffs->append(qlp_coeffs,
1126 bitstream->read_signed(bitstream, qlp_precision));
1127 }
1128
1129 qlp_data = qlp_coeffs->_;
1130
1131 /*read the residual*/
1132 if ((error = flacdec_read_residual(bitstream, order,
1133 block_size, residuals)) != OK)
1134 return error;
1135 else
1136 r_data = residuals->_;
1137
1138 /*calculate subframe samples from warm-up samples and residual*/
1139 for (i = order; i < block_size; i++) {
1140 int64_t accumulator = 0;
1141 unsigned j;
1142 for (j = 0; j < order; j++) {
1143 accumulator += (int64_t)qlp_data[j] * (int64_t)s_data[i - j - 1];
1144 }
1145
1146 a_append(samples,
1147 (int)(accumulator >> qlp_shift_needed) + r_data[i - order]);
1148 }
1149
1150 return OK;
1151 }
1152
1153 flac_status
flacdec_read_residual(BitstreamReader * bitstream,unsigned order,unsigned block_size,a_int * residuals)1154 flacdec_read_residual(BitstreamReader* bitstream,
1155 unsigned order,
1156 unsigned block_size,
1157 a_int* residuals)
1158 {
1159 const unsigned coding_method = bitstream->read(bitstream, 2);
1160 const unsigned partition_order = bitstream->read(bitstream, 4);
1161 const unsigned total_partitions = 1 << partition_order;
1162 unsigned partition;
1163
1164 unsigned int (*read)(struct BitstreamReader_s* bs, unsigned int count);
1165 unsigned int (*read_unary)(struct BitstreamReader_s* bs, int stop_bit);
1166
1167 read = bitstream->read;
1168 read_unary = bitstream->read_unary;
1169
1170 residuals->reset(residuals);
1171
1172 /*read 2^partition_order number of partitions*/
1173 for (partition = 0; partition < total_partitions; partition++) {
1174 int partition_samples;
1175 unsigned rice_parameter;
1176 unsigned escape_code;
1177
1178 /*each partition after the first contains
1179 block_size / (2 ^ partition_order) number of residual values*/
1180 if (partition == 0) {
1181 partition_samples = (int)(block_size /
1182 (1 << partition_order)) - order;
1183 partition_samples = MAX(partition_samples, 0);
1184 } else {
1185 partition_samples = block_size / (1 << partition_order);
1186 }
1187
1188 switch (coding_method) {
1189 case 0:
1190 rice_parameter = bitstream->read(bitstream, 4);
1191 if (rice_parameter == 0xF)
1192 escape_code = bitstream->read(bitstream, 5);
1193 else
1194 escape_code = 0;
1195 break;
1196 case 1:
1197 rice_parameter = bitstream->read(bitstream, 5);
1198 if (rice_parameter == 0x1F)
1199 escape_code = bitstream->read(bitstream, 5);
1200 else
1201 escape_code = 0;
1202 break;
1203 default:
1204 return ERR_INVALID_CODING_METHOD;
1205 }
1206
1207 residuals->resize_for(residuals, partition_samples);
1208 if (!escape_code) {
1209 for (;partition_samples; partition_samples--) {
1210 const unsigned msb = read_unary(bitstream, 1);
1211 const unsigned lsb = read(bitstream, rice_parameter);
1212 const unsigned value = (msb << rice_parameter) | lsb;
1213 if (value & 1) {
1214 a_append(residuals, -((int)value >> 1) - 1);
1215 } else {
1216 a_append(residuals, (int)value >> 1);
1217 }
1218 }
1219 } else {
1220 for (;partition_samples; partition_samples--) {
1221 a_append(residuals,
1222 bitstream->read_signed(bitstream, escape_code));
1223 }
1224 }
1225 }
1226
1227 return OK;
1228 }
1229
1230
1231 void
flacdec_decorrelate_channels(unsigned channel_assignment,const aa_int * subframes,a_int * framelist)1232 flacdec_decorrelate_channels(unsigned channel_assignment,
1233 const aa_int* subframes,
1234 a_int* framelist) {
1235 unsigned i,j;
1236 const unsigned channel_count = subframes->len;
1237 const unsigned block_size = subframes->_[0]->len;
1238
1239 framelist->reset_for(framelist, channel_count * block_size);
1240
1241 switch (channel_assignment) {
1242 case 0x8:
1243 /*left-difference*/
1244 assert(subframes->len == 2);
1245 assert(subframes->_[0]->len == subframes->_[1]->len);
1246 for (i = 0; i < block_size; i++) {
1247 a_append(framelist, subframes->_[0]->_[i]);
1248 a_append(framelist, (subframes->_[0]->_[i] -
1249 subframes->_[1]->_[i]));
1250 }
1251 break;
1252 case 0x9:
1253 /*difference-right*/
1254 assert(subframes->len == 2);
1255 assert(subframes->_[0]->len == subframes->_[1]->len);
1256 for (i = 0; i < block_size; i++) {
1257 a_append(framelist, (subframes->_[0]->_[i] +
1258 subframes->_[1]->_[i]));
1259 a_append(framelist, subframes->_[1]->_[i]);
1260 }
1261 break;
1262 case 0xA:
1263 /*mid-side*/
1264 assert(subframes->len == 2);
1265 assert(subframes->_[0]->len == subframes->_[1]->len);
1266 for (i = 0; i < block_size; i++) {
1267 int64_t mid = subframes->_[0]->_[i];
1268 int32_t side = subframes->_[1]->_[i];
1269 mid = (mid << 1) | (side & 1);
1270 a_append(framelist, (int)((mid + side) >> 1));
1271 a_append(framelist, (int)((mid - side) >> 1));
1272 }
1273 break;
1274 default:
1275 /*independent*/
1276 #ifndef NDEBUG
1277 for (j = 0; j < channel_count; j++) {
1278 assert(subframes->_[0]->len == subframes->_[j]->len);
1279 }
1280 #endif
1281 for (i = 0; i < block_size; i++) {
1282 for (j = 0; j < channel_count; j++) {
1283 a_append(framelist, subframes->_[j]->_[i]);
1284 }
1285 }
1286 break;
1287 }
1288 }
1289
1290
1291 const char*
FlacDecoder_strerror(flac_status error)1292 FlacDecoder_strerror(flac_status error)
1293 {
1294 switch (error) {
1295 case OK:
1296 return "No Error";
1297 case ERROR:
1298 return "Error";
1299 case ERR_INVALID_SYNC_CODE:
1300 return "invalid sync code";
1301 case ERR_INVALID_RESERVED_BIT:
1302 return "invalid reserved bit";
1303 case ERR_INVALID_BITS_PER_SAMPLE:
1304 return "invalid bits per sample";
1305 case ERR_INVALID_SAMPLE_RATE:
1306 return "invalid sample rate";
1307 case ERR_INVALID_FRAME_CRC:
1308 return "invalid checksum in frame header";
1309 case ERR_SAMPLE_RATE_MISMATCH:
1310 return "frame sample rate does not match STREAMINFO sample rate";
1311 case ERR_CHANNEL_COUNT_MISMATCH:
1312 return "frame channel count does not match STREAMINFO channel count";
1313 case ERR_BITS_PER_SAMPLE_MISMATCH:
1314 return "frame bits-per-sample does not match "
1315 "STREAMINFO bits per sample";
1316 case ERR_MAXIMUM_BLOCK_SIZE_EXCEEDED:
1317 return "frame block size exceeds STREAMINFO's maximum block size";
1318 case ERR_INVALID_CODING_METHOD:
1319 return "invalid residual partition coding method";
1320 case ERR_INVALID_FIXED_ORDER:
1321 return "invalid FIXED subframe order";
1322 case ERR_INVALID_SUBFRAME_TYPE:
1323 return "invalid subframe type";
1324 default:
1325 return "Unknown Error";
1326 }
1327 }
1328
1329 unsigned
read_utf8(BitstreamReader * stream)1330 read_utf8(BitstreamReader *stream)
1331 {
1332 unsigned total_bytes = stream->read_unary(stream, 0);
1333 unsigned value = stream->read(stream, 7 - total_bytes);
1334 for (;total_bytes > 1; total_bytes--) {
1335 value = (value << 6) | (stream->read(stream, 8) & 0x3F);
1336 }
1337
1338 return value;
1339 }
1340
1341 struct flac_SEEKPOINT*
seekpoint_copy(struct flac_SEEKPOINT * seekpoint)1342 seekpoint_copy(struct flac_SEEKPOINT* seekpoint)
1343 {
1344 struct flac_SEEKPOINT* new_seekpoint =
1345 malloc(sizeof(struct flac_SEEKPOINT));
1346
1347 new_seekpoint->sample_number = seekpoint->sample_number;
1348 new_seekpoint->byte_offset = seekpoint->byte_offset;
1349 new_seekpoint->samples = seekpoint->samples;
1350
1351 return new_seekpoint;
1352 }
1353
1354
1355 #ifdef EXECUTABLE
1356 #include <string.h>
1357 #include <errno.h>
1358
main(int argc,char * argv[])1359 int main(int argc, char* argv[]) {
1360 FILE* file;
1361 BitstreamReader* reader;
1362 struct flac_STREAMINFO streaminfo;
1363 a_obj* seektable;
1364 int channel_mask;
1365 uint64_t remaining_frames;
1366
1367 a_int* qlp_coeffs;
1368 a_int* residuals;
1369 aa_int* subframe_data;
1370 a_int* framelist_data;
1371
1372 FrameList_int_to_char_converter converter;
1373 unsigned char *output_data;
1374 unsigned output_data_size;
1375
1376 audiotools__MD5Context md5;
1377 unsigned char stream_md5sum[16];
1378 const static unsigned char blank_md5sum[16] = {0, 0, 0, 0, 0, 0, 0, 0,
1379 0, 0, 0, 0, 0, 0, 0, 0};
1380
1381 if (argc < 2) {
1382 fprintf(stderr, "*** Usage: %s <file.flac>\n", argv[0]);
1383 return 1;
1384 }
1385
1386 /*open input file for reading*/
1387 if ((file = fopen(argv[1], "rb")) == NULL) {
1388 fprintf(stderr, "*** %s: %s\n", argv[1], strerror(errno));
1389 return 1;
1390 } else {
1391 /*open bitstream and setup temporary arrays/buffers*/
1392 reader = br_open(file, BS_BIG_ENDIAN);
1393 seektable = a_obj_new((ARRAY_COPY_FUNC)seekpoint_copy,
1394 free,
1395 NULL);
1396 qlp_coeffs = a_int_new();
1397 residuals = a_int_new();
1398 subframe_data = aa_int_new();
1399 framelist_data = a_int_new();
1400
1401 output_data = malloc(1);
1402 output_data_size = 1;
1403 }
1404
1405 /*read initial metadata blocks*/
1406 if (flacdec_read_metadata(reader, &streaminfo, seektable, &channel_mask)) {
1407 fprintf(stderr, "*** Error reading streaminfo\n");
1408 goto error;
1409 } else {
1410 remaining_frames = streaminfo.total_samples;
1411 }
1412
1413 /*initialize the output MD5 sum*/
1414 audiotools__MD5Init(&md5);
1415
1416 /*setup a framelist converter function*/
1417 converter = FrameList_get_int_to_char_converter(streaminfo.bits_per_sample,
1418 0,
1419 1);
1420
1421 while (remaining_frames) {
1422 unsigned pcm_size;
1423
1424 qlp_coeffs->reset(qlp_coeffs);
1425 residuals->reset(residuals);
1426 subframe_data->reset(subframe_data);
1427 framelist_data->reset(framelist_data);
1428
1429 if (!setjmp(*br_try(reader))) {
1430 flac_status error;
1431 struct flac_frame_header frame_header;
1432 unsigned channel;
1433 uint16_t crc16 = 0;
1434
1435 /*add callback for CRC16 calculation*/
1436 reader->add_callback(reader, (bs_callback_f)flac_crc16, &crc16);
1437
1438 /*read frame header*/
1439 if ((error = flacdec_read_frame_header(reader,
1440 &streaminfo,
1441 &frame_header)) != OK) {
1442 reader->pop_callback(reader, NULL);
1443 br_etry(reader);
1444 fprintf(stderr, "*** Error: %s\n", FlacDecoder_strerror(error));
1445 goto error;
1446 }
1447
1448 /*read 1 subframe per channels*/
1449 for (channel = 0; channel < frame_header.channel_count; channel++)
1450 if ((error =
1451 flacdec_read_subframe(
1452 reader,
1453 qlp_coeffs,
1454 residuals,
1455 (unsigned)MIN(frame_header.block_size,
1456 remaining_frames),
1457 flacdec_subframe_bits_per_sample(&frame_header,
1458 channel),
1459 subframe_data->append(subframe_data))) != OK) {
1460 reader->pop_callback(reader, NULL);
1461 br_etry(reader);
1462 fprintf(stderr, "*** Error: %s\n",
1463 FlacDecoder_strerror(error));
1464 goto error;
1465 }
1466
1467 /*handle difference channels, if any*/
1468 flacdec_decorrelate_channels(frame_header.channel_assignment,
1469 subframe_data,
1470 framelist_data);
1471
1472 /*check CRC-16*/
1473 reader->byte_align(reader);
1474 reader->read(reader, 16);
1475 reader->pop_callback(reader, NULL);
1476 if (crc16 != 0) {
1477 br_etry(reader);
1478 fprintf(stderr, "*** Error: invalid checksum in frame\n");
1479 goto error;
1480 }
1481
1482 /*decrement remaining frames*/
1483 remaining_frames -= frame_header.block_size;
1484
1485 br_etry(reader);
1486 } else {
1487 /*handle I/O error during read*/
1488 reader->pop_callback(reader, NULL);
1489 br_etry(reader);
1490 fprintf(stderr, "*** I/O Error reading frame\n");
1491 goto error;
1492 }
1493
1494 /*convert framelist to string*/
1495 pcm_size = (streaminfo.bits_per_sample / 8) * framelist_data->len;
1496 if (pcm_size > output_data_size) {
1497 output_data_size = pcm_size;
1498 output_data = realloc(output_data, output_data_size);
1499 }
1500 FrameList_samples_to_char(output_data,
1501 framelist_data->_,
1502 converter,
1503 framelist_data->len,
1504 streaminfo.bits_per_sample);
1505
1506 /*update MD5 sum*/
1507 audiotools__MD5Update(&md5, output_data, pcm_size);
1508
1509 /*output framelist as string to stdout*/
1510 fwrite(output_data, sizeof(unsigned char), pcm_size, stdout);
1511 }
1512
1513 /*verify MD5 sum*/
1514 audiotools__MD5Final(stream_md5sum, &md5);
1515
1516 if (!((memcmp(streaminfo.md5sum, blank_md5sum, 16) == 0) ||
1517 (memcmp(stream_md5sum, streaminfo.md5sum, 16) == 0))) {
1518 fprintf(stderr, "*** MD5 mismatch at end of stream\n");
1519 goto error;
1520 }
1521
1522 reader->close(reader);
1523 seektable->del(seektable);
1524 qlp_coeffs->del(qlp_coeffs);
1525 residuals->del(residuals);
1526 subframe_data->del(subframe_data);
1527 framelist_data->del(framelist_data);
1528
1529 free(output_data);
1530
1531 return 0;
1532 error:
1533 reader->close(reader);
1534 seektable->del(seektable);
1535 qlp_coeffs->del(qlp_coeffs);
1536 residuals->del(residuals);
1537 subframe_data->del(subframe_data);
1538 framelist_data->del(framelist_data);
1539
1540 free(output_data);
1541
1542 return 1;
1543 }
1544 #endif
1545