ffmpeg / libavcodec / flac.c @ 3abe5fbd
History  View  Annotate  Download (22 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 flac.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 "avcodec.h" 
40 
#include "bitstream.h" 
41 
#include "golomb.h" 
42 
#include "crc.h" 
43  
44 
#undef NDEBUG

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

52 
INDEPENDENT, 
53 
LEFT_SIDE, 
54 
RIGHT_SIDE, 
55 
MID_SIDE, 
56 
}; 
57  
58 
typedef struct FLACContext { 
59 
AVCodecContext *avctx; 
60 
GetBitContext gb; 
61  
62 
int min_blocksize, max_blocksize;

63 
int min_framesize, max_framesize;

64 
int samplerate, channels;

65 
int blocksize/*, last_blocksize*/; 
66 
int bps, curr_bps;

67 
enum decorrelation_type decorrelation;

68  
69 
int32_t *decoded[MAX_CHANNELS]; 
70 
uint8_t *bitstream; 
71 
int bitstream_size;

72 
int bitstream_index;

73 
unsigned int allocated_bitstream_size; 
74 
} FLACContext; 
75  
76 
#define METADATA_TYPE_STREAMINFO 0 
77  
78 
static int sample_rate_table[] = 
79 
{ 0, 0, 0, 0, 
80 
8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000, 
81 
0, 0, 0, 0 }; 
82  
83 
static int sample_size_table[] = 
84 
{ 0, 8, 12, 0, 16, 20, 24, 0 }; 
85  
86 
static 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 
int64_t val; 
93 
GET_UTF8(val, get_bits(gb, 8), return 1;) 
94 
return val;

95 
} 
96  
97 
static void metadata_streaminfo(FLACContext *s); 
98 
static void allocate_buffers(FLACContext *s); 
99 
static int metadata_parse(FLACContext *s); 
100  
101 
static int flac_decode_init(AVCodecContext * avctx) 
102 
{ 
103 
FLACContext *s = avctx>priv_data; 
104 
s>avctx = avctx; 
105  
106 
if (avctx>extradata_size > 4) { 
107 
/* initialize based on the demuxersupplied streamdata header */

108 
init_get_bits(&s>gb, avctx>extradata, avctx>extradata_size*8);

109 
if (avctx>extradata_size == FLAC_STREAMINFO_SIZE) {

110 
metadata_streaminfo(s); 
111 
allocate_buffers(s); 
112 
} else {

113 
metadata_parse(s); 
114 
} 
115 
} 
116  
117 
return 0; 
118 
} 
119  
120 
static void dump_headers(FLACContext *s) 
121 
{ 
122 
av_log(s>avctx, AV_LOG_DEBUG, " Blocksize: %d .. %d (%d)\n", s>min_blocksize, s>max_blocksize, s>blocksize);

123 
av_log(s>avctx, AV_LOG_DEBUG, " Framesize: %d .. %d\n", s>min_framesize, s>max_framesize);

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

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

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

127 
} 
128  
129 
static void allocate_buffers(FLACContext *s){ 
130 
int i;

131  
132 
assert(s>max_blocksize); 
133  
134 
if(s>max_framesize == 0 && s>max_blocksize){ 
135 
s>max_framesize= (s>channels * s>bps * s>max_blocksize + 7)/ 8; //FIXME header overhead 
136 
} 
137  
138 
for (i = 0; i < s>channels; i++) 
139 
{ 
140 
s>decoded[i] = av_realloc(s>decoded[i], sizeof(int32_t)*s>max_blocksize);

141 
} 
142  
143 
s>bitstream= av_fast_realloc(s>bitstream, &s>allocated_bitstream_size, s>max_framesize); 
144 
} 
145  
146 
static void metadata_streaminfo(FLACContext *s) 
147 
{ 
148 
/* mandatory streaminfo */

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

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

151  
152 
s>min_framesize = get_bits_long(&s>gb, 24);

153 
s>max_framesize = get_bits_long(&s>gb, 24);

154  
155 
s>samplerate = get_bits_long(&s>gb, 20);

156 
s>channels = get_bits(&s>gb, 3) + 1; 
157 
s>bps = get_bits(&s>gb, 5) + 1; 
158  
159 
s>avctx>channels = s>channels; 
160 
s>avctx>sample_rate = s>samplerate; 
161  
162 
skip_bits(&s>gb, 36); /* total num of samples */ 
163  
164 
skip_bits(&s>gb, 64); /* md5 sum */ 
165 
skip_bits(&s>gb, 64); /* md5 sum */ 
166  
167 
dump_headers(s); 
168 
} 
169  
170 
/**

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

172 
* the fLaC marker.

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

174 
* parse metadata

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

176 
*/

177 
static int metadata_parse(FLACContext *s) 
178 
{ 
179 
int i, metadata_last, metadata_type, metadata_size, streaminfo_updated=0; 
180  
181 
if (show_bits_long(&s>gb, 32) == MKBETAG('f','L','a','C')) { 
182 
skip_bits(&s>gb, 32);

183  
184 
av_log(s>avctx, AV_LOG_DEBUG, "STREAM HEADER\n");

185 
do {

186 
metadata_last = get_bits1(&s>gb); 
187 
metadata_type = get_bits(&s>gb, 7);

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

189  
190 
av_log(s>avctx, AV_LOG_DEBUG, 
191 
" metadata block: flag = %d, type = %d, size = %d\n",

192 
metadata_last, metadata_type, metadata_size); 
193 
if (metadata_size) {

194 
switch (metadata_type) {

195 
case METADATA_TYPE_STREAMINFO:

196 
metadata_streaminfo(s); 
197 
streaminfo_updated = 1;

198 
break;

199  
200 
default:

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

203 
} 
204 
} 
205 
} while (!metadata_last);

206  
207 
if (streaminfo_updated)

208 
allocate_buffers(s); 
209 
return 1; 
210 
} 
211 
return 0; 
212 
} 
213  
214 
static int decode_residuals(FLACContext *s, int channel, int pred_order) 
215 
{ 
216 
int i, tmp, partition, method_type, rice_order;

217 
int sample = 0, samples; 
218  
219 
method_type = get_bits(&s>gb, 2);

220 
if (method_type > 1){ 
221 
av_log(s>avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);

222 
return 1; 
223 
} 
224  
225 
rice_order = get_bits(&s>gb, 4);

226  
227 
samples= s>blocksize >> rice_order; 
228 
if (pred_order > samples) {

229 
av_log(s>avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n", pred_order, samples);

230 
return 1; 
231 
} 
232  
233 
sample= 
234 
i= pred_order; 
235 
for (partition = 0; partition < (1 << rice_order); partition++) 
236 
{ 
237 
tmp = get_bits(&s>gb, method_type == 0 ? 4 : 5); 
238 
if (tmp == (method_type == 0 ? 15 : 31)) 
239 
{ 
240 
av_log(s>avctx, AV_LOG_DEBUG, "fixed len partition\n");

241 
tmp = get_bits(&s>gb, 5);

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

243 
s>decoded[channel][sample] = get_sbits(&s>gb, tmp); 
244 
} 
245 
else

246 
{ 
247 
// av_log(s>avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);

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

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

250 
} 
251 
} 
252 
i= 0;

253 
} 
254  
255 
// av_log(s>avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);

256  
257 
return 0; 
258 
} 
259  
260 
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order) 
261 
{ 
262 
const int blocksize = s>blocksize; 
263 
int32_t *decoded = s>decoded[channel]; 
264 
int a, b, c, d, i;

265  
266 
// av_log(s>avctx, AV_LOG_DEBUG, " SUBFRAME FIXED\n");

267  
268 
/* warm up samples */

269 
// av_log(s>avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order);

270  
271 
for (i = 0; i < pred_order; i++) 
272 
{ 
273 
decoded[i] = get_sbits(&s>gb, s>curr_bps); 
274 
// av_log(s>avctx, AV_LOG_DEBUG, " %d: %d\n", i, s>decoded[channel][i]);

275 
} 
276  
277 
if (decode_residuals(s, channel, pred_order) < 0) 
278 
return 1; 
279  
280 
a = decoded[pred_order1];

281 
b = a  decoded[pred_order2];

282 
c = b  decoded[pred_order2] + decoded[pred_order3]; 
283 
d = c  decoded[pred_order2] + 2*decoded[pred_order3]  decoded[pred_order4]; 
284  
285 
switch(pred_order)

286 
{ 
287 
case 0: 
288 
break;

289 
case 1: 
290 
for (i = pred_order; i < blocksize; i++)

291 
decoded[i] = a += decoded[i]; 
292 
break;

293 
case 2: 
294 
for (i = pred_order; i < blocksize; i++)

295 
decoded[i] = a += b += decoded[i]; 
296 
break;

297 
case 3: 
298 
for (i = pred_order; i < blocksize; i++)

299 
decoded[i] = a += b += c += decoded[i]; 
300 
break;

301 
case 4: 
302 
for (i = pred_order; i < blocksize; i++)

303 
decoded[i] = a += b += c += d += decoded[i]; 
304 
break;

305 
default:

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

307 
return 1; 
308 
} 
309  
310 
return 0; 
311 
} 
312  
313 
static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order) 
314 
{ 
315 
int i, j;

316 
int coeff_prec, qlevel;

317 
int coeffs[pred_order];

318 
int32_t *decoded = s>decoded[channel]; 
319  
320 
// av_log(s>avctx, AV_LOG_DEBUG, " SUBFRAME LPC\n");

321  
322 
/* warm up samples */

323 
// av_log(s>avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order);

324  
325 
for (i = 0; i < pred_order; i++) 
326 
{ 
327 
decoded[i] = get_sbits(&s>gb, s>curr_bps); 
328 
// av_log(s>avctx, AV_LOG_DEBUG, " %d: %d\n", i, decoded[i]);

329 
} 
330  
331 
coeff_prec = get_bits(&s>gb, 4) + 1; 
332 
if (coeff_prec == 16) 
333 
{ 
334 
av_log(s>avctx, AV_LOG_DEBUG, "invalid coeff precision\n");

335 
return 1; 
336 
} 
337 
// av_log(s>avctx, AV_LOG_DEBUG, " qlp coeff prec: %d\n", coeff_prec);

338 
qlevel = get_sbits(&s>gb, 5);

339 
// av_log(s>avctx, AV_LOG_DEBUG, " quant level: %d\n", qlevel);

340 
if(qlevel < 0){ 
341 
av_log(s>avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);

342 
return 1; 
343 
} 
344  
345 
for (i = 0; i < pred_order; i++) 
346 
{ 
347 
coeffs[i] = get_sbits(&s>gb, coeff_prec); 
348 
// av_log(s>avctx, AV_LOG_DEBUG, " %d: %d\n", i, coeffs[i]);

349 
} 
350  
351 
if (decode_residuals(s, channel, pred_order) < 0) 
352 
return 1; 
353  
354 
if (s>bps > 16) { 
355 
int64_t sum; 
356 
for (i = pred_order; i < s>blocksize; i++)

357 
{ 
358 
sum = 0;

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

361 
decoded[i] += sum >> qlevel; 
362 
} 
363 
} else {

364 
for (i = pred_order; i < s>blocksize1; i += 2) 
365 
{ 
366 
int c;

367 
int d = decoded[ipred_order];

368 
int s0 = 0, s1 = 0; 
369 
for (j = pred_order1; j > 0; j) 
370 
{ 
371 
c = coeffs[j]; 
372 
s0 += c*d; 
373 
d = decoded[ij]; 
374 
s1 += c*d; 
375 
} 
376 
c = coeffs[0];

377 
s0 += c*d; 
378 
d = decoded[i] += s0 >> qlevel; 
379 
s1 += c*d; 
380 
decoded[i+1] += s1 >> qlevel;

381 
} 
382 
if (i < s>blocksize)

383 
{ 
384 
int sum = 0; 
385 
for (j = 0; j < pred_order; j++) 
386 
sum += coeffs[j] * decoded[ij1];

387 
decoded[i] += sum >> qlevel; 
388 
} 
389 
} 
390  
391 
return 0; 
392 
} 
393  
394 
static inline int decode_subframe(FLACContext *s, int channel) 
395 
{ 
396 
int type, wasted = 0; 
397 
int i, tmp;

398  
399 
s>curr_bps = s>bps; 
400 
if(channel == 0){ 
401 
if(s>decorrelation == RIGHT_SIDE)

402 
s>curr_bps++; 
403 
}else{

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

405 
s>curr_bps++; 
406 
} 
407  
408 
if (get_bits1(&s>gb))

409 
{ 
410 
av_log(s>avctx, AV_LOG_ERROR, "invalid subframe padding\n");

411 
return 1; 
412 
} 
413 
type = get_bits(&s>gb, 6);

414 
// wasted = get_bits1(&s>gb);

415  
416 
// if (wasted)

417 
// {

418 
// while (!get_bits1(&s>gb))

419 
// wasted++;

420 
// if (wasted)

421 
// wasted++;

422 
// s>curr_bps = wasted;

423 
// }

424 
#if 0

425 
wasted= 16  av_log2(show_bits(&s>gb, 17));

426 
skip_bits(&s>gb, wasted+1);

427 
s>curr_bps = wasted;

428 
#else

429 
if (get_bits1(&s>gb))

430 
{ 
431 
wasted = 1;

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

433 
wasted++; 
434 
s>curr_bps = wasted; 
435 
av_log(s>avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);

436 
} 
437 
#endif

438 
//FIXME use av_log2 for types

439 
if (type == 0) 
440 
{ 
441 
av_log(s>avctx, AV_LOG_DEBUG, "coding type: constant\n");

442 
tmp = get_sbits(&s>gb, s>curr_bps); 
443 
for (i = 0; i < s>blocksize; i++) 
444 
s>decoded[channel][i] = tmp; 
445 
} 
446 
else if (type == 1) 
447 
{ 
448 
av_log(s>avctx, AV_LOG_DEBUG, "coding type: verbatim\n");

449 
for (i = 0; i < s>blocksize; i++) 
450 
s>decoded[channel][i] = get_sbits(&s>gb, s>curr_bps); 
451 
} 
452 
else if ((type >= 8) && (type <= 12)) 
453 
{ 
454 
// av_log(s>avctx, AV_LOG_DEBUG, "coding type: fixed\n");

455 
if (decode_subframe_fixed(s, channel, type & ~0x8) < 0) 
456 
return 1; 
457 
} 
458 
else if (type >= 32) 
459 
{ 
460 
// av_log(s>avctx, AV_LOG_DEBUG, "coding type: lpc\n");

461 
if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) 
462 
return 1; 
463 
} 
464 
else

465 
{ 
466 
av_log(s>avctx, AV_LOG_ERROR, "invalid coding type\n");

467 
return 1; 
468 
} 
469  
470 
if (wasted)

471 
{ 
472 
int i;

473 
for (i = 0; i < s>blocksize; i++) 
474 
s>decoded[channel][i] <<= wasted; 
475 
} 
476  
477 
return 0; 
478 
} 
479  
480 
static int decode_frame(FLACContext *s, int alloc_data_size) 
481 
{ 
482 
int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;

483 
int decorrelation, bps, blocksize, samplerate;

484  
485 
blocksize_code = get_bits(&s>gb, 4);

486  
487 
sample_rate_code = get_bits(&s>gb, 4);

488  
489 
assignment = get_bits(&s>gb, 4); /* channel assignment */ 
490 
if (assignment < 8 && s>channels == assignment+1) 
491 
decorrelation = INDEPENDENT; 
492 
else if (assignment >=8 && assignment < 11 && s>channels == 2) 
493 
decorrelation = LEFT_SIDE + assignment  8;

494 
else

495 
{ 
496 
av_log(s>avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", assignment, s>channels);

497 
return 1; 
498 
} 
499  
500 
sample_size_code = get_bits(&s>gb, 3);

501 
if(sample_size_code == 0) 
502 
bps= s>bps; 
503 
else if((sample_size_code != 3) && (sample_size_code != 7)) 
504 
bps = sample_size_table[sample_size_code]; 
505 
else

506 
{ 
507 
av_log(s>avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", sample_size_code);

508 
return 1; 
509 
} 
510  
511 
if (get_bits1(&s>gb))

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

514 
return 1; 
515 
} 
516  
517 
if(get_utf8(&s>gb) < 0){ 
518 
av_log(s>avctx, AV_LOG_ERROR, "utf8 fscked\n");

519 
return 1; 
520 
} 
521 
#if 0

522 
if (/*((blocksize_code == 6)  (blocksize_code == 7)) &&*/

523 
(s>min_blocksize != s>max_blocksize)){

524 
}else{

525 
}

526 
#endif

527  
528 
if (blocksize_code == 0) 
529 
blocksize = s>min_blocksize; 
530 
else if (blocksize_code == 6) 
531 
blocksize = get_bits(&s>gb, 8)+1; 
532 
else if (blocksize_code == 7) 
533 
blocksize = get_bits(&s>gb, 16)+1; 
534 
else

535 
blocksize = blocksize_table[blocksize_code]; 
536  
537 
if(blocksize > s>max_blocksize){

538 
av_log(s>avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s>max_blocksize);

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

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

556 
av_log(s>avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", 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);

574  
575 
/* subframes */

576 
for (i = 0; i < s>channels; i++) 
577 
{ 
578 
// av_log(s>avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s>decoded[i], s>residual[i]);

579 
if (decode_subframe(s, i) < 0) 
580 
return 1; 
581 
} 
582  
583 
align_get_bits(&s>gb); 
584  
585 
/* frame footer */

586 
skip_bits(&s>gb, 16); /* data crc */ 
587  
588 
return 0; 
589 
} 
590  
591 
static int flac_decode_frame(AVCodecContext *avctx, 
592 
void *data, int *data_size, 
593 
uint8_t *buf, int buf_size)

594 
{ 
595 
FLACContext *s = avctx>priv_data; 
596 
int tmp = 0, i, j = 0, input_buf_size = 0; 
597 
int16_t *samples = data; 
598 
int alloc_data_size= *data_size;

599  
600 
*data_size=0;

601  
602 
if(s>max_framesize == 0){ 
603 
s>max_framesize= 65536; // should hopefully be enough for the first header 
604 
s>bitstream= av_fast_realloc(s>bitstream, &s>allocated_bitstream_size, s>max_framesize); 
605 
} 
606  
607 
if(1 && s>max_framesize){//FIXME truncated 
608 
buf_size= FFMAX(FFMIN(buf_size, s>max_framesize  s>bitstream_size), 0);

609 
input_buf_size= buf_size; 
610  
611 
if(s>bitstream_index + s>bitstream_size + buf_size > s>allocated_bitstream_size){

612 
// printf("memmove\n");

613 
memmove(s>bitstream, &s>bitstream[s>bitstream_index], s>bitstream_size); 
614 
s>bitstream_index=0;

615 
} 
616 
memcpy(&s>bitstream[s>bitstream_index + s>bitstream_size], buf, buf_size); 
617 
buf= &s>bitstream[s>bitstream_index]; 
618 
buf_size += s>bitstream_size; 
619 
s>bitstream_size= buf_size; 
620  
621 
if(buf_size < s>max_framesize){

622 
// printf("wanna more data ...\n");

623 
return input_buf_size;

624 
} 
625 
} 
626  
627 
init_get_bits(&s>gb, buf, buf_size*8);

628  
629 
if (!metadata_parse(s))

630 
{ 
631 
tmp = show_bits(&s>gb, 16);

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

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

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

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

641 
s>bitstream_size=0;

642 
s>bitstream_index=0;

643 
return 1; 
644 
} 
645 
} 
646  
647  
648 
#if 0

649 
/* fix the channel order here */

650 
if (s>order == MID_SIDE)

651 
{

652 
short *left = samples;

653 
short *right = samples + s>blocksize;

654 
for (i = 0; i < s>blocksize; i += 2)

655 
{

656 
uint32_t x = s>decoded[0][i];

657 
uint32_t y = s>decoded[0][i+1];

658 

659 
right[i] = x  (y / 2);

660 
left[i] = right[i] + y;

661 
}

662 
*data_size = 2 * s>blocksize;

663 
}

664 
else

665 
{

666 
for (i = 0; i < s>channels; i++)

667 
{

668 
switch(s>order)

669 
{

670 
case INDEPENDENT:

671 
for (j = 0; j < s>blocksize; j++)

672 
samples[(s>blocksize*i)+j] = s>decoded[i][j];

673 
break;

674 
case LEFT_SIDE:

675 
case RIGHT_SIDE:

676 
if (i == 0)

677 
for (j = 0; j < s>blocksize; j++)

678 
samples[(s>blocksize*i)+j] = s>decoded[0][j];

679 
else

680 
for (j = 0; j < s>blocksize; j++)

681 
samples[(s>blocksize*i)+j] = s>decoded[0][j]  s>decoded[i][j];

682 
break;

683 
// case MID_SIDE:

684 
// av_log(s>avctx, AV_LOG_DEBUG, "midside unsupported\n");

685 
}

686 
*data_size += s>blocksize;

687 
}

688 
}

689 
#else

690 
#define DECORRELATE(left, right)\

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

692 
for (i = 0; i < s>blocksize; i++)\ 
693 
{\ 
694 
int a= s>decoded[0][i];\ 
695 
int b= s>decoded[1][i];\ 
696 
*samples++ = ((left) << (24  s>bps)) >> 8;\ 
697 
*samples++ = ((right) << (24  s>bps)) >> 8;\ 
698 
}\ 
699 
break;

700  
701 
switch(s>decorrelation)

702 
{ 
703 
case INDEPENDENT:

704 
for (j = 0; j < s>blocksize; j++) 
705 
{ 
706 
for (i = 0; i < s>channels; i++) 
707 
*samples++ = (s>decoded[i][j] << (24  s>bps)) >> 8; 
708 
} 
709 
break;

710 
case LEFT_SIDE:

711 
DECORRELATE(a,ab) 
712 
case RIGHT_SIDE:

713 
DECORRELATE(a+b,b) 
714 
case MID_SIDE:

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

716 
} 
717 
#endif

718  
719 
*data_size = (int8_t *)samples  (int8_t *)data; 
720 
// av_log(s>avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);

721  
722 
// s>last_blocksize = s>blocksize;

723 
end:

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

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

727 
s>bitstream_size=0;

728 
s>bitstream_index=0;

729 
return 1; 
730 
} 
731  
732 
if(s>bitstream_size){

733 
s>bitstream_index += i; 
734 
s>bitstream_size = i; 
735 
return input_buf_size;

736 
}else

737 
return i;

738 
} 
739  
740 
static int flac_decode_close(AVCodecContext *avctx) 
741 
{ 
742 
FLACContext *s = avctx>priv_data; 
743 
int i;

744  
745 
for (i = 0; i < s>channels; i++) 
746 
{ 
747 
av_freep(&s>decoded[i]); 
748 
} 
749 
av_freep(&s>bitstream); 
750  
751 
return 0; 
752 
} 
753  
754 
static void flac_flush(AVCodecContext *avctx){ 
755 
FLACContext *s = avctx>priv_data; 
756  
757 
s>bitstream_size= 
758 
s>bitstream_index= 0;

759 
} 
760  
761 
AVCodec flac_decoder = { 
762 
"flac",

763 
CODEC_TYPE_AUDIO, 
764 
CODEC_ID_FLAC, 
765 
sizeof(FLACContext),

766 
flac_decode_init, 
767 
NULL,

768 
flac_decode_close, 
769 
flac_decode_frame, 
770 
.flush= flac_flush, 
771 
}; 