ffmpeg / libavcodec / flacdec.c @ ee4d0322
History  View  Annotate  Download (22.2 KB)
1 
/*


2 
* FLAC (Free Lossless Audio Codec) decoder

3 
* Copyright (c) 2003 Alex Beregszaszi

4 
*

5 
* This file is part of FFmpeg.

6 
*

7 
* FFmpeg is free software; you can redistribute it and/or

8 
* modify it under the terms of the GNU Lesser General Public

9 
* License as published by the Free Software Foundation; either

10 
* version 2.1 of the License, or (at your option) any later version.

11 
*

12 
* FFmpeg is distributed in the hope that it will be useful,

13 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

14 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 
* Lesser General Public License for more details.

16 
*

17 
* You should have received a copy of the GNU Lesser General Public

18 
* License along with FFmpeg; if not, write to the Free Software

19 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

20 
*/

21  
22 
/**

23 
* @file libavcodec/flacdec.c

24 
* FLAC (Free Lossless Audio Codec) decoder

25 
* @author Alex Beregszaszi

26 
*

27 
* For more information on the FLAC format, visit:

28 
* http://flac.sourceforge.net/

29 
*

30 
* This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed

31 
* through, starting from the initial 'fLaC' signature; or by passing the

32 
* 34byte streaminfo structure through avctx>extradata[_size] followed

33 
* by data starting with the 0xFFF8 marker.

34 
*/

35  
36 
#include <limits.h> 
37  
38 
#define ALT_BITSTREAM_READER

39 
#include "libavutil/crc.h" 
40 
#include "avcodec.h" 
41 
#include "bitstream.h" 
42 
#include "golomb.h" 
43 
#include "flac.h" 
44  
45 
#undef NDEBUG

46 
#include <assert.h> 
47  
48 
#define MAX_CHANNELS 8 
49 
#define MAX_BLOCKSIZE 65535 
50  
51 
enum decorrelation_type {

52 
INDEPENDENT, 
53 
LEFT_SIDE, 
54 
RIGHT_SIDE, 
55 
MID_SIDE, 
56 
}; 
57  
58 
typedef struct FLACContext { 
59 
FLACSTREAMINFO 
60  
61 
AVCodecContext *avctx; ///< parent AVCodecContext

62 
GetBitContext gb; ///< GetBitContext initialized to start at the current frame

63  
64 
int blocksize; ///< number of samples in the current frame 
65 
int curr_bps; ///< bps for current subframe, adjusted for channel correlation and wasted bits 
66 
int sample_shift; ///< shift required to make output samples 16bit or 32bit 
67 
int is32; ///< flag to indicate if output should be 32bit instead of 16bit 
68 
enum decorrelation_type decorrelation; ///< channel decorrelation type in the current frame 
69  
70 
int32_t *decoded[MAX_CHANNELS]; ///< decoded samples

71 
uint8_t *bitstream; 
72 
unsigned int bitstream_size; 
73 
unsigned int bitstream_index; 
74 
unsigned int allocated_bitstream_size; 
75 
} FLACContext; 
76  
77 
static const int sample_rate_table[] = 
78 
{ 0,

79 
88200, 176400, 192000, 
80 
8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000, 
81 
0, 0, 0, 0 }; 
82  
83 
static const int sample_size_table[] = 
84 
{ 0, 8, 12, 0, 16, 20, 24, 0 }; 
85  
86 
static const int blocksize_table[] = { 
87 
0, 192, 576<<0, 576<<1, 576<<2, 576<<3, 0, 0, 
88 
256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7 
89 
}; 
90  
91 
static int64_t get_utf8(GetBitContext *gb)

92 
{ 
93 
int64_t val; 
94 
GET_UTF8(val, get_bits(gb, 8), return 1;) 
95 
return val;

96 
} 
97  
98 
static void allocate_buffers(FLACContext *s); 
99  
100 
int ff_flac_is_extradata_valid(AVCodecContext *avctx,

101 
enum FLACExtradataFormat *format,

102 
uint8_t **streaminfo_start) 
103 
{ 
104 
if (!avctx>extradata  avctx>extradata_size < FLAC_STREAMINFO_SIZE) {

105 
av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");

106 
return 0; 
107 
} 
108 
if (AV_RL32(avctx>extradata) != MKTAG('f','L','a','C')) { 
109 
/* extradata contains STREAMINFO only */

110 
if (avctx>extradata_size != FLAC_STREAMINFO_SIZE) {

111 
av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",

112 
FLAC_STREAMINFO_SIZEavctx>extradata_size); 
113 
} 
114 
*format = FLAC_EXTRADATA_FORMAT_STREAMINFO; 
115 
*streaminfo_start = avctx>extradata; 
116 
} else {

117 
if (avctx>extradata_size < 8+FLAC_STREAMINFO_SIZE) { 
118 
av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");

119 
return 0; 
120 
} 
121 
*format = FLAC_EXTRADATA_FORMAT_FULL_HEADER; 
122 
*streaminfo_start = &avctx>extradata[8];

123 
} 
124 
return 1; 
125 
} 
126  
127 
static av_cold int flac_decode_init(AVCodecContext *avctx) 
128 
{ 
129 
enum FLACExtradataFormat format;

130 
uint8_t *streaminfo; 
131 
FLACContext *s = avctx>priv_data; 
132 
s>avctx = avctx; 
133  
134 
avctx>sample_fmt = SAMPLE_FMT_S16; 
135  
136 
/* for now, the raw FLAC header is allowed to be passed to the decoder as

137 
frame data instead of extradata. */

138 
if (!avctx>extradata)

139 
return 0; 
140  
141 
if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))

142 
return 1; 
143  
144 
/* initialize based on the demuxersupplied streamdata header */

145 
ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo); 
146 
allocate_buffers(s); 
147  
148 
return 0; 
149 
} 
150  
151 
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s) 
152 
{ 
153 
av_log(avctx, AV_LOG_DEBUG, " Blocksize: %d .. %d\n", s>min_blocksize,

154 
s>max_blocksize); 
155 
av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s>max_framesize);

156 
av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s>samplerate);

157 
av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s>channels);

158 
av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s>bps);

159 
} 
160  
161 
static void allocate_buffers(FLACContext *s) 
162 
{ 
163 
int i;

164  
165 
assert(s>max_blocksize); 
166  
167 
if (s>max_framesize == 0 && s>max_blocksize) { 
168 
// FIXME header overhead

169 
s>max_framesize= (s>channels * s>bps * s>max_blocksize + 7)/ 8; 
170 
} 
171  
172 
for (i = 0; i < s>channels; i++) { 
173 
s>decoded[i] = av_realloc(s>decoded[i], 
174 
sizeof(int32_t)*s>max_blocksize);

175 
} 
176  
177 
if (s>allocated_bitstream_size < s>max_framesize)

178 
s>bitstream= av_fast_realloc(s>bitstream, 
179 
&s>allocated_bitstream_size, 
180 
s>max_framesize); 
181 
} 
182  
183 
void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, 
184 
const uint8_t *buffer)

185 
{ 
186 
GetBitContext gb; 
187 
init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);

188  
189 
/* mandatory streaminfo */

190 
s>min_blocksize = get_bits(&gb, 16);

191 
s>max_blocksize = get_bits(&gb, 16);

192  
193 
skip_bits(&gb, 24); /* skip min frame size */ 
194 
s>max_framesize = get_bits_long(&gb, 24);

195  
196 
s>samplerate = get_bits_long(&gb, 20);

197 
s>channels = get_bits(&gb, 3) + 1; 
198 
s>bps = get_bits(&gb, 5) + 1; 
199  
200 
avctx>channels = s>channels; 
201 
avctx>sample_rate = s>samplerate; 
202 
avctx>bits_per_raw_sample = s>bps; 
203 
if (s>bps > 16) 
204 
avctx>sample_fmt = SAMPLE_FMT_S32; 
205 
else

206 
avctx>sample_fmt = SAMPLE_FMT_S16; 
207  
208 
s>samples = get_bits_long(&gb, 32) << 4; 
209 
s>samples = get_bits(&gb, 4);

210  
211 
skip_bits_long(&gb, 64); /* md5 sum */ 
212 
skip_bits_long(&gb, 64); /* md5 sum */ 
213  
214 
dump_headers(avctx, s); 
215 
} 
216  
217 
/**

218 
* Parse a list of metadata blocks. This list of blocks must begin with

219 
* the fLaC marker.

220 
* @param s the flac decoding context containing the gb bit reader used to

221 
* parse metadata

222 
* @return 1 if some metadata was read, 0 if no fLaC marker was found

223 
*/

224 
static int metadata_parse(FLACContext *s) 
225 
{ 
226 
int i, metadata_last, metadata_type, metadata_size, streaminfo_updated=0; 
227 
int initial_pos= get_bits_count(&s>gb);

228  
229 
if (show_bits_long(&s>gb, 32) == MKBETAG('f','L','a','C')) { 
230 
skip_bits_long(&s>gb, 32);

231  
232 
do {

233 
metadata_last = get_bits1(&s>gb); 
234 
metadata_type = get_bits(&s>gb, 7);

235 
metadata_size = get_bits_long(&s>gb, 24);

236  
237 
if (get_bits_count(&s>gb) + 8*metadata_size > s>gb.size_in_bits) { 
238 
skip_bits_long(&s>gb, initial_pos  get_bits_count(&s>gb)); 
239 
break;

240 
} 
241  
242 
if (metadata_size) {

243 
switch (metadata_type) {

244 
case FLAC_METADATA_TYPE_STREAMINFO:

245 
ff_flac_parse_streaminfo(s>avctx, (FLACStreaminfo *)s, 
246 
s>gb.buffer+get_bits_count(&s>gb)/8);

247 
streaminfo_updated = 1;

248  
249 
default:

250 
for (i = 0; i < metadata_size; i++) 
251 
skip_bits(&s>gb, 8);

252 
} 
253 
} 
254 
} while (!metadata_last);

255  
256 
if (streaminfo_updated)

257 
allocate_buffers(s); 
258 
return 1; 
259 
} 
260 
return 0; 
261 
} 
262  
263 
static int decode_residuals(FLACContext *s, int channel, int pred_order) 
264 
{ 
265 
int i, tmp, partition, method_type, rice_order;

266 
int sample = 0, samples; 
267  
268 
method_type = get_bits(&s>gb, 2);

269 
if (method_type > 1) { 
270 
av_log(s>avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",

271 
method_type); 
272 
return 1; 
273 
} 
274  
275 
rice_order = get_bits(&s>gb, 4);

276  
277 
samples= s>blocksize >> rice_order; 
278 
if (pred_order > samples) {

279 
av_log(s>avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",

280 
pred_order, samples); 
281 
return 1; 
282 
} 
283  
284 
sample= 
285 
i= pred_order; 
286 
for (partition = 0; partition < (1 << rice_order); partition++) { 
287 
tmp = get_bits(&s>gb, method_type == 0 ? 4 : 5); 
288 
if (tmp == (method_type == 0 ? 15 : 31)) { 
289 
tmp = get_bits(&s>gb, 5);

290 
for (; i < samples; i++, sample++)

291 
s>decoded[channel][sample] = get_sbits(&s>gb, tmp); 
292 
} else {

293 
for (; i < samples; i++, sample++) {

294 
s>decoded[channel][sample] = get_sr_golomb_flac(&s>gb, tmp, INT_MAX, 0);

295 
} 
296 
} 
297 
i= 0;

298 
} 
299  
300 
return 0; 
301 
} 
302  
303 
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order) 
304 
{ 
305 
const int blocksize = s>blocksize; 
306 
int32_t *decoded = s>decoded[channel]; 
307 
int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;

308  
309 
/* warm up samples */

310 
for (i = 0; i < pred_order; i++) { 
311 
decoded[i] = get_sbits(&s>gb, s>curr_bps); 
312 
} 
313  
314 
if (decode_residuals(s, channel, pred_order) < 0) 
315 
return 1; 
316  
317 
if (pred_order > 0) 
318 
a = decoded[pred_order1];

319 
if (pred_order > 1) 
320 
b = a  decoded[pred_order2];

321 
if (pred_order > 2) 
322 
c = b  decoded[pred_order2] + decoded[pred_order3]; 
323 
if (pred_order > 3) 
324 
d = c  decoded[pred_order2] + 2*decoded[pred_order3]  decoded[pred_order4]; 
325  
326 
switch (pred_order) {

327 
case 0: 
328 
break;

329 
case 1: 
330 
for (i = pred_order; i < blocksize; i++)

331 
decoded[i] = a += decoded[i]; 
332 
break;

333 
case 2: 
334 
for (i = pred_order; i < blocksize; i++)

335 
decoded[i] = a += b += decoded[i]; 
336 
break;

337 
case 3: 
338 
for (i = pred_order; i < blocksize; i++)

339 
decoded[i] = a += b += c += decoded[i]; 
340 
break;

341 
case 4: 
342 
for (i = pred_order; i < blocksize; i++)

343 
decoded[i] = a += b += c += d += decoded[i]; 
344 
break;

345 
default:

346 
av_log(s>avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);

347 
return 1; 
348 
} 
349  
350 
return 0; 
351 
} 
352  
353 
static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order) 
354 
{ 
355 
int i, j;

356 
int coeff_prec, qlevel;

357 
int coeffs[pred_order];

358 
int32_t *decoded = s>decoded[channel]; 
359  
360 
/* warm up samples */

361 
for (i = 0; i < pred_order; i++) { 
362 
decoded[i] = get_sbits(&s>gb, s>curr_bps); 
363 
} 
364  
365 
coeff_prec = get_bits(&s>gb, 4) + 1; 
366 
if (coeff_prec == 16) { 
367 
av_log(s>avctx, AV_LOG_ERROR, "invalid coeff precision\n");

368 
return 1; 
369 
} 
370 
qlevel = get_sbits(&s>gb, 5);

371 
if (qlevel < 0) { 
372 
av_log(s>avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",

373 
qlevel); 
374 
return 1; 
375 
} 
376  
377 
for (i = 0; i < pred_order; i++) { 
378 
coeffs[i] = get_sbits(&s>gb, coeff_prec); 
379 
} 
380  
381 
if (decode_residuals(s, channel, pred_order) < 0) 
382 
return 1; 
383  
384 
if (s>bps > 16) { 
385 
int64_t sum; 
386 
for (i = pred_order; i < s>blocksize; i++) {

387 
sum = 0;

388 
for (j = 0; j < pred_order; j++) 
389 
sum += (int64_t)coeffs[j] * decoded[ij1];

390 
decoded[i] += sum >> qlevel; 
391 
} 
392 
} else {

393 
for (i = pred_order; i < s>blocksize1; i += 2) { 
394 
int c;

395 
int d = decoded[ipred_order];

396 
int s0 = 0, s1 = 0; 
397 
for (j = pred_order1; j > 0; j) { 
398 
c = coeffs[j]; 
399 
s0 += c*d; 
400 
d = decoded[ij]; 
401 
s1 += c*d; 
402 
} 
403 
c = coeffs[0];

404 
s0 += c*d; 
405 
d = decoded[i] += s0 >> qlevel; 
406 
s1 += c*d; 
407 
decoded[i+1] += s1 >> qlevel;

408 
} 
409 
if (i < s>blocksize) {

410 
int sum = 0; 
411 
for (j = 0; j < pred_order; j++) 
412 
sum += coeffs[j] * decoded[ij1];

413 
decoded[i] += sum >> qlevel; 
414 
} 
415 
} 
416  
417 
return 0; 
418 
} 
419  
420 
static inline int decode_subframe(FLACContext *s, int channel) 
421 
{ 
422 
int type, wasted = 0; 
423 
int i, tmp;

424  
425 
s>curr_bps = s>bps; 
426 
if (channel == 0) { 
427 
if (s>decorrelation == RIGHT_SIDE)

428 
s>curr_bps++; 
429 
} else {

430 
if (s>decorrelation == LEFT_SIDE  s>decorrelation == MID_SIDE)

431 
s>curr_bps++; 
432 
} 
433  
434 
if (get_bits1(&s>gb)) {

435 
av_log(s>avctx, AV_LOG_ERROR, "invalid subframe padding\n");

436 
return 1; 
437 
} 
438 
type = get_bits(&s>gb, 6);

439  
440 
if (get_bits1(&s>gb)) {

441 
wasted = 1;

442 
while (!get_bits1(&s>gb))

443 
wasted++; 
444 
s>curr_bps = wasted; 
445 
} 
446  
447 
//FIXME use av_log2 for types

448 
if (type == 0) { 
449 
tmp = get_sbits(&s>gb, s>curr_bps); 
450 
for (i = 0; i < s>blocksize; i++) 
451 
s>decoded[channel][i] = tmp; 
452 
} else if (type == 1) { 
453 
for (i = 0; i < s>blocksize; i++) 
454 
s>decoded[channel][i] = get_sbits(&s>gb, s>curr_bps); 
455 
} else if ((type >= 8) && (type <= 12)) { 
456 
if (decode_subframe_fixed(s, channel, type & ~0x8) < 0) 
457 
return 1; 
458 
} else if (type >= 32) { 
459 
if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) 
460 
return 1; 
461 
} else {

462 
av_log(s>avctx, AV_LOG_ERROR, "invalid coding type\n");

463 
return 1; 
464 
} 
465  
466 
if (wasted) {

467 
int i;

468 
for (i = 0; i < s>blocksize; i++) 
469 
s>decoded[channel][i] <<= wasted; 
470 
} 
471  
472 
return 0; 
473 
} 
474  
475 
static int decode_frame(FLACContext *s, int alloc_data_size) 
476 
{ 
477 
int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;

478 
int decorrelation, bps, blocksize, samplerate;

479  
480 
blocksize_code = get_bits(&s>gb, 4);

481  
482 
sample_rate_code = get_bits(&s>gb, 4);

483  
484 
assignment = get_bits(&s>gb, 4); /* channel assignment */ 
485 
if (assignment < 8 && s>channels == assignment+1) 
486 
decorrelation = INDEPENDENT; 
487 
else if (assignment >=8 && assignment < 11 && s>channels == 2) 
488 
decorrelation = LEFT_SIDE + assignment  8;

489 
else {

490 
av_log(s>avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n",

491 
assignment, s>channels); 
492 
return 1; 
493 
} 
494  
495 
sample_size_code = get_bits(&s>gb, 3);

496 
if (sample_size_code == 0) 
497 
bps= s>bps; 
498 
else if ((sample_size_code != 3) && (sample_size_code != 7)) 
499 
bps = sample_size_table[sample_size_code]; 
500 
else {

501 
av_log(s>avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n",

502 
sample_size_code); 
503 
return 1; 
504 
} 
505 
if (bps > 16) { 
506 
s>avctx>sample_fmt = SAMPLE_FMT_S32; 
507 
s>sample_shift = 32  bps;

508 
s>is32 = 1;

509 
} else {

510 
s>avctx>sample_fmt = SAMPLE_FMT_S16; 
511 
s>sample_shift = 16  bps;

512 
s>is32 = 0;

513 
} 
514 
s>bps = s>avctx>bits_per_raw_sample = bps; 
515  
516 
if (get_bits1(&s>gb)) {

517 
av_log(s>avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");

518 
return 1; 
519 
} 
520  
521 
if (get_utf8(&s>gb) < 0) { 
522 
av_log(s>avctx, AV_LOG_ERROR, "utf8 fscked\n");

523 
return 1; 
524 
} 
525  
526 
if (blocksize_code == 0) 
527 
blocksize = s>min_blocksize; 
528 
else if (blocksize_code == 6) 
529 
blocksize = get_bits(&s>gb, 8)+1; 
530 
else if (blocksize_code == 7) 
531 
blocksize = get_bits(&s>gb, 16)+1; 
532 
else

533 
blocksize = blocksize_table[blocksize_code]; 
534  
535 
if (blocksize > s>max_blocksize) {

536 
av_log(s>avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize,

537 
s>max_blocksize); 
538 
return 1; 
539 
} 
540  
541 
if (blocksize * s>channels * sizeof(int16_t) > alloc_data_size) 
542 
return 1; 
543  
544 
if (sample_rate_code == 0) 
545 
samplerate= s>samplerate; 
546 
else if (sample_rate_code < 12) 
547 
samplerate = sample_rate_table[sample_rate_code]; 
548 
else if (sample_rate_code == 12) 
549 
samplerate = get_bits(&s>gb, 8) * 1000; 
550 
else if (sample_rate_code == 13) 
551 
samplerate = get_bits(&s>gb, 16);

552 
else if (sample_rate_code == 14) 
553 
samplerate = get_bits(&s>gb, 16) * 10; 
554 
else {

555 
av_log(s>avctx, AV_LOG_ERROR, "illegal sample rate code %d\n",

556 
sample_rate_code); 
557 
return 1; 
558 
} 
559  
560 
skip_bits(&s>gb, 8);

561 
crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,

562 
s>gb.buffer, get_bits_count(&s>gb)/8);

563 
if (crc8) {

564 
av_log(s>avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);

565 
return 1; 
566 
} 
567  
568 
s>blocksize = blocksize; 
569 
s>samplerate = samplerate; 
570 
s>bps = bps; 
571 
s>decorrelation= decorrelation; 
572  
573 
// dump_headers(s>avctx, (FLACStreaminfo *)s);

574  
575 
/* subframes */

576 
for (i = 0; i < s>channels; i++) { 
577 
if (decode_subframe(s, i) < 0) 
578 
return 1; 
579 
} 
580  
581 
align_get_bits(&s>gb); 
582  
583 
/* frame footer */

584 
skip_bits(&s>gb, 16); /* data crc */ 
585  
586 
return 0; 
587 
} 
588  
589 
static int flac_decode_frame(AVCodecContext *avctx, 
590 
void *data, int *data_size, 
591 
const uint8_t *buf, int buf_size) 
592 
{ 
593 
FLACContext *s = avctx>priv_data; 
594 
int tmp = 0, i, j = 0, input_buf_size = 0; 
595 
int16_t *samples_16 = data; 
596 
int32_t *samples_32 = data; 
597 
int alloc_data_size= *data_size;

598  
599 
*data_size=0;

600  
601 
if (s>max_framesize == 0) { 
602 
s>max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header 
603 
s>bitstream= av_fast_realloc(s>bitstream, &s>allocated_bitstream_size, s>max_framesize); 
604 
} 
605  
606 
if (1 && s>max_framesize) { //FIXME truncated 
607 
if (s>bitstream_size < 4  AV_RL32(s>bitstream) != MKTAG('f','L','a','C')) 
608 
buf_size= FFMIN(buf_size, s>max_framesize  FFMIN(s>bitstream_size, s>max_framesize)); 
609 
input_buf_size= buf_size; 
610  
611 
if (s>bitstream_size + buf_size < buf_size  s>bitstream_index + s>bitstream_size + buf_size < s>bitstream_index)

612 
return 1; 
613  
614 
if (s>allocated_bitstream_size < s>bitstream_size + buf_size)

615 
s>bitstream= av_fast_realloc(s>bitstream, &s>allocated_bitstream_size, s>bitstream_size + buf_size); 
616  
617 
if (s>bitstream_index + s>bitstream_size + buf_size > s>allocated_bitstream_size) {

618 
memmove(s>bitstream, &s>bitstream[s>bitstream_index], 
619 
s>bitstream_size); 
620 
s>bitstream_index=0;

621 
} 
622 
memcpy(&s>bitstream[s>bitstream_index + s>bitstream_size], 
623 
buf, buf_size); 
624 
buf= &s>bitstream[s>bitstream_index]; 
625 
buf_size += s>bitstream_size; 
626 
s>bitstream_size= buf_size; 
627  
628 
if (buf_size < s>max_framesize && input_buf_size) {

629 
return input_buf_size;

630 
} 
631 
} 
632  
633 
init_get_bits(&s>gb, buf, buf_size*8);

634  
635 
if (metadata_parse(s))

636 
goto end;

637  
638 
tmp = show_bits(&s>gb, 16);

639 
if ((tmp & 0xFFFE) != 0xFFF8) { 
640 
av_log(s>avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");

641 
while (get_bits_count(&s>gb)/8+2 < buf_size && (show_bits(&s>gb, 16) & 0xFFFE) != 0xFFF8) 
642 
skip_bits(&s>gb, 8);

643 
goto end; // we may not have enough bits left to decode a frame, so try next time 
644 
} 
645 
skip_bits(&s>gb, 16);

646 
if (decode_frame(s, alloc_data_size) < 0) { 
647 
av_log(s>avctx, AV_LOG_ERROR, "decode_frame() failed\n");

648 
s>bitstream_size=0;

649 
s>bitstream_index=0;

650 
return 1; 
651 
} 
652  
653 
#define DECORRELATE(left, right)\

654 
assert(s>channels == 2);\

655 
for (i = 0; i < s>blocksize; i++) {\ 
656 
int a= s>decoded[0][i];\ 
657 
int b= s>decoded[1][i];\ 
658 
if (s>is32) {\

659 
*samples_32++ = (left) << s>sample_shift;\ 
660 
*samples_32++ = (right) << s>sample_shift;\ 
661 
} else {\

662 
*samples_16++ = (left) << s>sample_shift;\ 
663 
*samples_16++ = (right) << s>sample_shift;\ 
664 
}\ 
665 
}\ 
666 
break;

667  
668 
switch (s>decorrelation) {

669 
case INDEPENDENT:

670 
for (j = 0; j < s>blocksize; j++) { 
671 
for (i = 0; i < s>channels; i++) { 
672 
if (s>is32)

673 
*samples_32++ = s>decoded[i][j] << s>sample_shift; 
674 
else

675 
*samples_16++ = s>decoded[i][j] << s>sample_shift; 
676 
} 
677 
} 
678 
break;

679 
case LEFT_SIDE:

680 
DECORRELATE(a,ab) 
681 
case RIGHT_SIDE:

682 
DECORRELATE(a+b,b) 
683 
case MID_SIDE:

684 
DECORRELATE( (a=b>>1) + b, a)

685 
} 
686  
687 
*data_size = s>blocksize * s>channels * (s>is32 ? 4 : 2); 
688  
689 
end:

690 
i= (get_bits_count(&s>gb)+7)/8; 
691 
if (i > buf_size) {

692 
av_log(s>avctx, AV_LOG_ERROR, "overread: %d\n", i  buf_size);

693 
s>bitstream_size=0;

694 
s>bitstream_index=0;

695 
return 1; 
696 
} 
697  
698 
if (s>bitstream_size) {

699 
s>bitstream_index += i; 
700 
s>bitstream_size = i; 
701 
return input_buf_size;

702 
} else

703 
return i;

704 
} 
705  
706 
static av_cold int flac_decode_close(AVCodecContext *avctx) 
707 
{ 
708 
FLACContext *s = avctx>priv_data; 
709 
int i;

710  
711 
for (i = 0; i < s>channels; i++) { 
712 
av_freep(&s>decoded[i]); 
713 
} 
714 
av_freep(&s>bitstream); 
715  
716 
return 0; 
717 
} 
718  
719 
static void flac_flush(AVCodecContext *avctx) 
720 
{ 
721 
FLACContext *s = avctx>priv_data; 
722  
723 
s>bitstream_size= 
724 
s>bitstream_index= 0;

725 
} 
726  
727 
AVCodec flac_decoder = { 
728 
"flac",

729 
CODEC_TYPE_AUDIO, 
730 
CODEC_ID_FLAC, 
731 
sizeof(FLACContext),

732 
flac_decode_init, 
733 
NULL,

734 
flac_decode_close, 
735 
flac_decode_frame, 
736 
CODEC_CAP_DELAY, 
737 
.flush= flac_flush, 
738 
.long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),

739 
}; 