ffmpeg / libavcodec / flacdec.c @ d36beb3f
History  View  Annotate  Download (20 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

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 
#include "libavutil/crc.h" 
39 
#include "avcodec.h" 
40 
#include "internal.h" 
41 
#include "get_bits.h" 
42 
#include "bytestream.h" 
43 
#include "golomb.h" 
44 
#include "flac.h" 
45 
#include "flacdata.h" 
46  
47 
#undef NDEBUG

48 
#include <assert.h> 
49  
50 
typedef struct FLACContext { 
51 
FLACSTREAMINFO 
52  
53 
AVCodecContext *avctx; ///< parent AVCodecContext

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

55  
56 
int blocksize; ///< number of samples in the current frame 
57 
int curr_bps; ///< bps for current subframe, adjusted for channel correlation and wasted bits 
58 
int sample_shift; ///< shift required to make output samples 16bit or 32bit 
59 
int is32; ///< flag to indicate if output should be 32bit instead of 16bit 
60 
int ch_mode; ///< channel decorrelation type in the current frame 
61 
int got_streaminfo; ///< indicates if the STREAMINFO has been read 
62  
63 
int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples

64 
} FLACContext; 
65  
66 
static void allocate_buffers(FLACContext *s); 
67  
68 
int ff_flac_is_extradata_valid(AVCodecContext *avctx,

69 
enum FLACExtradataFormat *format,

70 
uint8_t **streaminfo_start) 
71 
{ 
72 
if (!avctx>extradata  avctx>extradata_size < FLAC_STREAMINFO_SIZE) {

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

74 
return 0; 
75 
} 
76 
if (AV_RL32(avctx>extradata) != MKTAG('f','L','a','C')) { 
77 
/* extradata contains STREAMINFO only */

78 
if (avctx>extradata_size != FLAC_STREAMINFO_SIZE) {

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

80 
FLAC_STREAMINFO_SIZEavctx>extradata_size); 
81 
} 
82 
*format = FLAC_EXTRADATA_FORMAT_STREAMINFO; 
83 
*streaminfo_start = avctx>extradata; 
84 
} else {

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

87 
return 0; 
88 
} 
89 
*format = FLAC_EXTRADATA_FORMAT_FULL_HEADER; 
90 
*streaminfo_start = &avctx>extradata[8];

91 
} 
92 
return 1; 
93 
} 
94  
95 
static av_cold int flac_decode_init(AVCodecContext *avctx) 
96 
{ 
97 
enum FLACExtradataFormat format;

98 
uint8_t *streaminfo; 
99 
FLACContext *s = avctx>priv_data; 
100 
s>avctx = avctx; 
101  
102 
avctx>sample_fmt = AV_SAMPLE_FMT_S16; 
103  
104 
/* for now, the raw FLAC header is allowed to be passed to the decoder as

105 
frame data instead of extradata. */

106 
if (!avctx>extradata)

107 
return 0; 
108  
109 
if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))

110 
return 1; 
111  
112 
/* initialize based on the demuxersupplied streamdata header */

113 
ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo); 
114 
if (s>bps > 16) 
115 
avctx>sample_fmt = AV_SAMPLE_FMT_S32; 
116 
else

117 
avctx>sample_fmt = AV_SAMPLE_FMT_S16; 
118 
allocate_buffers(s); 
119 
s>got_streaminfo = 1;

120  
121 
return 0; 
122 
} 
123  
124 
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s) 
125 
{ 
126 
av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s>max_blocksize);

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

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

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

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

131 
} 
132  
133 
static void allocate_buffers(FLACContext *s) 
134 
{ 
135 
int i;

136  
137 
assert(s>max_blocksize); 
138  
139 
for (i = 0; i < s>channels; i++) { 
140 
s>decoded[i] = av_realloc(s>decoded[i], 
141 
sizeof(int32_t)*s>max_blocksize);

142 
} 
143 
} 
144  
145 
void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, 
146 
const uint8_t *buffer)

147 
{ 
148 
GetBitContext gb; 
149 
init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);

150  
151 
skip_bits(&gb, 16); /* skip min blocksize */ 
152 
s>max_blocksize = get_bits(&gb, 16);

153 
if (s>max_blocksize < FLAC_MIN_BLOCKSIZE) {

154 
av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",

155 
s>max_blocksize); 
156 
s>max_blocksize = 16;

157 
} 
158  
159 
skip_bits(&gb, 24); /* skip min frame size */ 
160 
s>max_framesize = get_bits_long(&gb, 24);

161  
162 
s>samplerate = get_bits_long(&gb, 20);

163 
s>channels = get_bits(&gb, 3) + 1; 
164 
s>bps = get_bits(&gb, 5) + 1; 
165  
166 
avctx>channels = s>channels; 
167 
avctx>sample_rate = s>samplerate; 
168 
avctx>bits_per_raw_sample = s>bps; 
169  
170 
s>samples = get_bits_long(&gb, 32) << 4; 
171 
s>samples = get_bits(&gb, 4);

172  
173 
skip_bits_long(&gb, 64); /* md5 sum */ 
174 
skip_bits_long(&gb, 64); /* md5 sum */ 
175  
176 
dump_headers(avctx, s); 
177 
} 
178  
179 
void ff_flac_parse_block_header(const uint8_t *block_header, 
180 
int *last, int *type, int *size) 
181 
{ 
182 
int tmp = bytestream_get_byte(&block_header);

183 
if (last)

184 
*last = tmp & 0x80;

185 
if (type)

186 
*type = tmp & 0x7F;

187 
if (size)

188 
*size = bytestream_get_be24(&block_header); 
189 
} 
190  
191 
/**

192 
* Parse the STREAMINFO from an inline header.

193 
* @param s the flac decoding context

194 
* @param buf input buffer, starting with the "fLaC" marker

195 
* @param buf_size buffer size

196 
* @return nonzero if metadata is invalid

197 
*/

198 
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size) 
199 
{ 
200 
int metadata_type, metadata_size;

201  
202 
if (buf_size < FLAC_STREAMINFO_SIZE+8) { 
203 
/* need more data */

204 
return 0; 
205 
} 
206 
ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size); 
207 
if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO 

208 
metadata_size != FLAC_STREAMINFO_SIZE) { 
209 
return AVERROR_INVALIDDATA;

210 
} 
211 
ff_flac_parse_streaminfo(s>avctx, (FLACStreaminfo *)s, &buf[8]);

212 
allocate_buffers(s); 
213 
s>got_streaminfo = 1;

214  
215 
return 0; 
216 
} 
217  
218 
/**

219 
* Determine the size of an inline header.

220 
* @param buf input buffer, starting with the "fLaC" marker

221 
* @param buf_size buffer size

222 
* @return number of bytes in the header, or 0 if more data is needed

223 
*/

224 
static int get_metadata_size(const uint8_t *buf, int buf_size) 
225 
{ 
226 
int metadata_last, metadata_size;

227 
const uint8_t *buf_end = buf + buf_size;

228  
229 
buf += 4;

230 
do {

231 
ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);

232 
buf += 4;

233 
if (buf + metadata_size > buf_end) {

234 
/* need more data in order to read the complete header */

235 
return 0; 
236 
} 
237 
buf += metadata_size; 
238 
} while (!metadata_last);

239  
240 
return buf_size  (buf_end  buf);

241 
} 
242  
243 
static int decode_residuals(FLACContext *s, int channel, int pred_order) 
244 
{ 
245 
int i, tmp, partition, method_type, rice_order;

246 
int sample = 0, samples; 
247  
248 
method_type = get_bits(&s>gb, 2);

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

251 
method_type); 
252 
return 1; 
253 
} 
254  
255 
rice_order = get_bits(&s>gb, 4);

256  
257 
samples= s>blocksize >> rice_order; 
258 
if (pred_order > samples) {

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

260 
pred_order, samples); 
261 
return 1; 
262 
} 
263  
264 
sample= 
265 
i= pred_order; 
266 
for (partition = 0; partition < (1 << rice_order); partition++) { 
267 
tmp = get_bits(&s>gb, method_type == 0 ? 4 : 5); 
268 
if (tmp == (method_type == 0 ? 15 : 31)) { 
269 
tmp = get_bits(&s>gb, 5);

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

271 
s>decoded[channel][sample] = get_sbits_long(&s>gb, tmp); 
272 
} else {

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

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

275 
} 
276 
} 
277 
i= 0;

278 
} 
279  
280 
return 0; 
281 
} 
282  
283 
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order) 
284 
{ 
285 
const int blocksize = s>blocksize; 
286 
int32_t *decoded = s>decoded[channel]; 
287 
int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;

288  
289 
/* warm up samples */

290 
for (i = 0; i < pred_order; i++) { 
291 
decoded[i] = get_sbits_long(&s>gb, s>curr_bps); 
292 
} 
293  
294 
if (decode_residuals(s, channel, pred_order) < 0) 
295 
return 1; 
296  
297 
if (pred_order > 0) 
298 
a = decoded[pred_order1];

299 
if (pred_order > 1) 
300 
b = a  decoded[pred_order2];

301 
if (pred_order > 2) 
302 
c = b  decoded[pred_order2] + decoded[pred_order3]; 
303 
if (pred_order > 3) 
304 
d = c  decoded[pred_order2] + 2*decoded[pred_order3]  decoded[pred_order4]; 
305  
306 
switch (pred_order) {

307 
case 0: 
308 
break;

309 
case 1: 
310 
for (i = pred_order; i < blocksize; i++)

311 
decoded[i] = a += decoded[i]; 
312 
break;

313 
case 2: 
314 
for (i = pred_order; i < blocksize; i++)

315 
decoded[i] = a += b += decoded[i]; 
316 
break;

317 
case 3: 
318 
for (i = pred_order; i < blocksize; i++)

319 
decoded[i] = a += b += c += decoded[i]; 
320 
break;

321 
case 4: 
322 
for (i = pred_order; i < blocksize; i++)

323 
decoded[i] = a += b += c += d += decoded[i]; 
324 
break;

325 
default:

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

327 
return 1; 
328 
} 
329  
330 
return 0; 
331 
} 
332  
333 
static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order) 
334 
{ 
335 
int i, j;

336 
int coeff_prec, qlevel;

337 
int coeffs[32]; 
338 
int32_t *decoded = s>decoded[channel]; 
339  
340 
/* warm up samples */

341 
for (i = 0; i < pred_order; i++) { 
342 
decoded[i] = get_sbits_long(&s>gb, s>curr_bps); 
343 
} 
344  
345 
coeff_prec = get_bits(&s>gb, 4) + 1; 
346 
if (coeff_prec == 16) { 
347 
av_log(s>avctx, AV_LOG_ERROR, "invalid coeff precision\n");

348 
return 1; 
349 
} 
350 
qlevel = get_sbits(&s>gb, 5);

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

353 
qlevel); 
354 
return 1; 
355 
} 
356  
357 
for (i = 0; i < pred_order; i++) { 
358 
coeffs[i] = get_sbits(&s>gb, coeff_prec); 
359 
} 
360  
361 
if (decode_residuals(s, channel, pred_order) < 0) 
362 
return 1; 
363  
364 
if (s>bps > 16) { 
365 
int64_t sum; 
366 
for (i = pred_order; i < s>blocksize; i++) {

367 
sum = 0;

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

370 
decoded[i] += sum >> qlevel; 
371 
} 
372 
} else {

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

375 
int d = decoded[ipred_order];

376 
int s0 = 0, s1 = 0; 
377 
for (j = pred_order1; j > 0; j) { 
378 
c = coeffs[j]; 
379 
s0 += c*d; 
380 
d = decoded[ij]; 
381 
s1 += c*d; 
382 
} 
383 
c = coeffs[0];

384 
s0 += c*d; 
385 
d = decoded[i] += s0 >> qlevel; 
386 
s1 += c*d; 
387 
decoded[i+1] += s1 >> qlevel;

388 
} 
389 
if (i < s>blocksize) {

390 
int sum = 0; 
391 
for (j = 0; j < pred_order; j++) 
392 
sum += coeffs[j] * decoded[ij1];

393 
decoded[i] += sum >> qlevel; 
394 
} 
395 
} 
396  
397 
return 0; 
398 
} 
399  
400 
static inline int decode_subframe(FLACContext *s, int channel) 
401 
{ 
402 
int type, wasted = 0; 
403 
int i, tmp;

404  
405 
s>curr_bps = s>bps; 
406 
if (channel == 0) { 
407 
if (s>ch_mode == FLAC_CHMODE_RIGHT_SIDE)

408 
s>curr_bps++; 
409 
} else {

410 
if (s>ch_mode == FLAC_CHMODE_LEFT_SIDE  s>ch_mode == FLAC_CHMODE_MID_SIDE)

411 
s>curr_bps++; 
412 
} 
413  
414 
if (get_bits1(&s>gb)) {

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

416 
return 1; 
417 
} 
418 
type = get_bits(&s>gb, 6);

419  
420 
if (get_bits1(&s>gb)) {

421 
wasted = 1;

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

423 
wasted++; 
424 
s>curr_bps = wasted; 
425 
} 
426 
if (s>curr_bps > 32) { 
427 
av_log_missing_feature(s>avctx, "decorrelated bit depth > 32", 0); 
428 
return 1; 
429 
} 
430  
431 
//FIXME use av_log2 for types

432 
if (type == 0) { 
433 
tmp = get_sbits_long(&s>gb, s>curr_bps); 
434 
for (i = 0; i < s>blocksize; i++) 
435 
s>decoded[channel][i] = tmp; 
436 
} else if (type == 1) { 
437 
for (i = 0; i < s>blocksize; i++) 
438 
s>decoded[channel][i] = get_sbits_long(&s>gb, s>curr_bps); 
439 
} else if ((type >= 8) && (type <= 12)) { 
440 
if (decode_subframe_fixed(s, channel, type & ~0x8) < 0) 
441 
return 1; 
442 
} else if (type >= 32) { 
443 
if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) 
444 
return 1; 
445 
} else {

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

447 
return 1; 
448 
} 
449  
450 
if (wasted) {

451 
int i;

452 
for (i = 0; i < s>blocksize; i++) 
453 
s>decoded[channel][i] <<= wasted; 
454 
} 
455  
456 
return 0; 
457 
} 
458  
459 
static int decode_frame(FLACContext *s) 
460 
{ 
461 
int i;

462 
GetBitContext *gb = &s>gb; 
463 
FLACFrameInfo fi; 
464  
465 
if (ff_flac_decode_frame_header(s>avctx, gb, &fi, 0)) { 
466 
av_log(s>avctx, AV_LOG_ERROR, "invalid frame header\n");

467 
return 1; 
468 
} 
469  
470 
if (s>channels && fi.channels != s>channels) {

471 
av_log(s>avctx, AV_LOG_ERROR, "switching channel layout midstream "

472 
"is not supported\n");

473 
return 1; 
474 
} 
475 
s>channels = s>avctx>channels = fi.channels; 
476 
s>ch_mode = fi.ch_mode; 
477  
478 
if (!s>bps && !fi.bps) {

479 
av_log(s>avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");

480 
return 1; 
481 
} 
482 
if (!fi.bps) {

483 
fi.bps = s>bps; 
484 
} else if (s>bps && fi.bps != s>bps) { 
485 
av_log(s>avctx, AV_LOG_ERROR, "switching bps midstream is not "

486 
"supported\n");

487 
return 1; 
488 
} 
489 
s>bps = s>avctx>bits_per_raw_sample = fi.bps; 
490  
491 
if (s>bps > 16) { 
492 
s>avctx>sample_fmt = AV_SAMPLE_FMT_S32; 
493 
s>sample_shift = 32  s>bps;

494 
s>is32 = 1;

495 
} else {

496 
s>avctx>sample_fmt = AV_SAMPLE_FMT_S16; 
497 
s>sample_shift = 16  s>bps;

498 
s>is32 = 0;

499 
} 
500  
501 
if (!s>max_blocksize)

502 
s>max_blocksize = FLAC_MAX_BLOCKSIZE; 
503 
if (fi.blocksize > s>max_blocksize) {

504 
av_log(s>avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,

505 
s>max_blocksize); 
506 
return 1; 
507 
} 
508 
s>blocksize = fi.blocksize; 
509  
510 
if (!s>samplerate && !fi.samplerate) {

511 
av_log(s>avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"

512 
" or frame header\n");

513 
return 1; 
514 
} 
515 
if (fi.samplerate == 0) { 
516 
fi.samplerate = s>samplerate; 
517 
} else if (s>samplerate && fi.samplerate != s>samplerate) { 
518 
av_log(s>avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",

519 
s>samplerate, fi.samplerate); 
520 
} 
521 
s>samplerate = s>avctx>sample_rate = fi.samplerate; 
522  
523 
if (!s>got_streaminfo) {

524 
allocate_buffers(s); 
525 
s>got_streaminfo = 1;

526 
dump_headers(s>avctx, (FLACStreaminfo *)s); 
527 
} 
528  
529 
// dump_headers(s>avctx, (FLACStreaminfo *)s);

530  
531 
/* subframes */

532 
for (i = 0; i < s>channels; i++) { 
533 
if (decode_subframe(s, i) < 0) 
534 
return 1; 
535 
} 
536  
537 
align_get_bits(gb); 
538  
539 
/* frame footer */

540 
skip_bits(gb, 16); /* data crc */ 
541  
542 
return 0; 
543 
} 
544  
545 
static int flac_decode_frame(AVCodecContext *avctx, 
546 
void *data, int *data_size, 
547 
AVPacket *avpkt) 
548 
{ 
549 
const uint8_t *buf = avpkt>data;

550 
int buf_size = avpkt>size;

551 
FLACContext *s = avctx>priv_data; 
552 
int i, j = 0, bytes_read = 0; 
553 
int16_t *samples_16 = data; 
554 
int32_t *samples_32 = data; 
555 
int alloc_data_size= *data_size;

556 
int output_size;

557  
558 
*data_size=0;

559  
560 
if (s>max_framesize == 0) { 
561 
s>max_framesize = 
562 
ff_flac_get_max_frame_size(s>max_blocksize ? s>max_blocksize : FLAC_MAX_BLOCKSIZE, 
563 
FLAC_MAX_CHANNELS, 32);

564 
} 
565  
566 
/* check that there is at least the smallest decodable amount of data.

567 
this amount corresponds to the smallest valid FLAC frame possible.

568 
FF F8 69 02 00 00 9A 00 00 34 46 */

569 
if (buf_size < FLAC_MIN_FRAME_SIZE)

570 
return buf_size;

571  
572 
/* check for inline header */

573 
if (AV_RB32(buf) == MKBETAG('f','L','a','C')) { 
574 
if (!s>got_streaminfo && parse_streaminfo(s, buf, buf_size)) {

575 
av_log(s>avctx, AV_LOG_ERROR, "invalid header\n");

576 
return 1; 
577 
} 
578 
return get_metadata_size(buf, buf_size);

579 
} 
580  
581 
/* decode frame */

582 
init_get_bits(&s>gb, buf, buf_size*8);

583 
if (decode_frame(s) < 0) { 
584 
av_log(s>avctx, AV_LOG_ERROR, "decode_frame() failed\n");

585 
return 1; 
586 
} 
587 
bytes_read = (get_bits_count(&s>gb)+7)/8; 
588  
589 
/* check if allocated data size is large enough for output */

590 
output_size = s>blocksize * s>channels * (s>is32 ? 4 : 2); 
591 
if (output_size > alloc_data_size) {

592 
av_log(s>avctx, AV_LOG_ERROR, "output data size is larger than "

593 
"allocated data size\n");

594 
return 1; 
595 
} 
596 
*data_size = output_size; 
597  
598 
#define DECORRELATE(left, right)\

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

600 
for (i = 0; i < s>blocksize; i++) {\ 
601 
int a= s>decoded[0][i];\ 
602 
int b= s>decoded[1][i];\ 
603 
if (s>is32) {\

604 
*samples_32++ = (left) << s>sample_shift;\ 
605 
*samples_32++ = (right) << s>sample_shift;\ 
606 
} else {\

607 
*samples_16++ = (left) << s>sample_shift;\ 
608 
*samples_16++ = (right) << s>sample_shift;\ 
609 
}\ 
610 
}\ 
611 
break;

612  
613 
switch (s>ch_mode) {

614 
case FLAC_CHMODE_INDEPENDENT:

615 
for (j = 0; j < s>blocksize; j++) { 
616 
for (i = 0; i < s>channels; i++) { 
617 
if (s>is32)

618 
*samples_32++ = s>decoded[i][j] << s>sample_shift; 
619 
else

620 
*samples_16++ = s>decoded[i][j] << s>sample_shift; 
621 
} 
622 
} 
623 
break;

624 
case FLAC_CHMODE_LEFT_SIDE:

625 
DECORRELATE(a,ab) 
626 
case FLAC_CHMODE_RIGHT_SIDE:

627 
DECORRELATE(a+b,b) 
628 
case FLAC_CHMODE_MID_SIDE:

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

630 
} 
631  
632 
if (bytes_read > buf_size) {

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

634 
return 1; 
635 
} 
636 
if (bytes_read < buf_size) {

637 
av_log(s>avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",

638 
buf_size  bytes_read, buf_size); 
639 
} 
640  
641 
return bytes_read;

642 
} 
643  
644 
static av_cold int flac_decode_close(AVCodecContext *avctx) 
645 
{ 
646 
FLACContext *s = avctx>priv_data; 
647 
int i;

648  
649 
for (i = 0; i < s>channels; i++) { 
650 
av_freep(&s>decoded[i]); 
651 
} 
652  
653 
return 0; 
654 
} 
655  
656 
AVCodec ff_flac_decoder = { 
657 
"flac",

658 
AVMEDIA_TYPE_AUDIO, 
659 
CODEC_ID_FLAC, 
660 
sizeof(FLACContext),

661 
flac_decode_init, 
662 
NULL,

663 
flac_decode_close, 
664 
flac_decode_frame, 
665 
.long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),

666 
}; 