ffmpeg / libavcodec / flac.c @ 5509bffa
History  View  Annotate  Download (23.8 KB)
1 
/*


2 
* FLAC (Free Lossless Audio Codec) decoder

3 
* Copyright (c) 2003 Alex Beregszaszi

4 
*

5 
* This library is free software; you can redistribute it and/or

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

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

8 
* version 2 of the License, or (at your option) any later version.

9 
*

10 
* This library is distributed in the hope that it will be useful,

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

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

13 
* Lesser General Public License for more details.

14 
*

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

16 
* License along with this library; if not, write to the Free Software

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

18 
*/

19  
20 
/**

21 
* @file flac.c

22 
* FLAC (Free Lossless Audio Codec) decoder

23 
* @author Alex Beregszaszi

24 
*

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

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

27 
*

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

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

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

31 
* by data starting with the 0xFFF8 marker.

32 
*/

33  
34 
#include <limits.h> 
35  
36 
#include "avcodec.h" 
37 
#include "bitstream.h" 
38 
#include "golomb.h" 
39  
40 
#undef NDEBUG

41 
#include <assert.h> 
42  
43 
#define MAX_CHANNELS 8 
44 
#define MAX_BLOCKSIZE 65535 
45 
#define FLAC_STREAMINFO_SIZE 34 
46  
47 
enum decorrelation_type {

48 
INDEPENDENT, 
49 
LEFT_SIDE, 
50 
RIGHT_SIDE, 
51 
MID_SIDE, 
52 
}; 
53  
54 
typedef struct FLACContext { 
55 
AVCodecContext *avctx; 
56 
GetBitContext gb; 
57  
58 
int min_blocksize, max_blocksize;

59 
int min_framesize, max_framesize;

60 
int samplerate, channels;

61 
int blocksize/*, last_blocksize*/; 
62 
int bps, curr_bps;

63 
enum decorrelation_type decorrelation;

64  
65 
int32_t *decoded[MAX_CHANNELS]; 
66 
uint8_t *bitstream; 
67 
int bitstream_size;

68 
int bitstream_index;

69 
int allocated_bitstream_size;

70 
} FLACContext; 
71  
72 
#define METADATA_TYPE_STREAMINFO 0 
73  
74 
static int sample_rate_table[] = 
75 
{ 0, 0, 0, 0, 
76 
8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000, 
77 
0, 0, 0, 0 }; 
78  
79 
static int sample_size_table[] = 
80 
{ 0, 8, 12, 0, 16, 20, 24, 0 }; 
81  
82 
static int blocksize_table[] = { 
83 
0, 192, 576<<0, 576<<1, 576<<2, 576<<3, 0, 0, 
84 
256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7 
85 
}; 
86  
87 
static const uint8_t table_crc8[256] = { 
88 
0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15, 
89 
0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d, 
90 
0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65, 
91 
0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d, 
92 
0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5, 
93 
0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd, 
94 
0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85, 
95 
0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd, 
96 
0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2, 
97 
0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea, 
98 
0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2, 
99 
0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a, 
100 
0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32, 
101 
0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a, 
102 
0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42, 
103 
0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a, 
104 
0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c, 
105 
0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4, 
106 
0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec, 
107 
0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4, 
108 
0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c, 
109 
0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44, 
110 
0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c, 
111 
0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34, 
112 
0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b, 
113 
0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63, 
114 
0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b, 
115 
0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13, 
116 
0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb, 
117 
0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83, 
118 
0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb, 
119 
0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3 
120 
}; 
121  
122 
static int64_t get_utf8(GetBitContext *gb)

123 
{ 
124 
uint64_t val; 
125 
int ones=0, bytes; 
126  
127 
while(get_bits1(gb))

128 
ones++; 
129  
130 
if (ones==0) bytes=0; 
131 
else if(ones==1) return 1; 
132 
else bytes= ones  1; 
133  
134 
val= get_bits(gb, 7ones);

135 
while(bytes){

136 
const int tmp = get_bits(gb, 8); 
137  
138 
if((tmp>>6) != 2) 
139 
return 1; 
140 
val<<=6;

141 
val= tmp&0x3F;

142 
} 
143 
return val;

144 
} 
145  
146 
#if 0

147 
static int skip_utf8(GetBitContext *gb)

148 
{

149 
int ones=0, bytes;

150 

151 
while(get_bits1(gb))

152 
ones++;

153 

154 
if (ones==0) bytes=0;

155 
else if(ones==1) return 1;

156 
else bytes= ones  1;

157 

158 
skip_bits(gb, 7ones);

159 
while(bytes){

160 
const int tmp = get_bits(gb, 8);

161 

162 
if((tmp>>6) != 2)

163 
return 1;

164 
}

165 
return 0;

166 
}

167 
#endif

168  
169 
static int get_crc8(const uint8_t *buf, int count){ 
170 
int crc=0; 
171 
int i;

172  
173 
for(i=0; i<count; i++){ 
174 
crc = table_crc8[crc ^ buf[i]]; 
175 
} 
176  
177 
return crc;

178 
} 
179  
180 
static void metadata_streaminfo(FLACContext *s); 
181 
static void dump_headers(FLACContext *s); 
182  
183 
static int flac_decode_init(AVCodecContext * avctx) 
184 
{ 
185 
FLACContext *s = avctx>priv_data; 
186 
s>avctx = avctx; 
187  
188 
/* initialize based on the demuxersupplied streamdata header */

189 
if (avctx>extradata_size == FLAC_STREAMINFO_SIZE) {

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

191 
metadata_streaminfo(s); 
192 
dump_headers(s); 
193 
} 
194  
195 
return 0; 
196 
} 
197  
198 
static void dump_headers(FLACContext *s) 
199 
{ 
200 
av_log(s>avctx, AV_LOG_DEBUG, " Blocksize: %d .. %d (%d)\n", s>min_blocksize, s>max_blocksize, s>blocksize);

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

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

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

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

205 
} 
206  
207 
static void allocate_buffers(FLACContext *s){ 
208 
int i;

209  
210 
assert(s>max_blocksize); 
211  
212 
if(s>max_framesize == 0 && s>max_blocksize){ 
213 
s>max_framesize= (s>channels * s>bps * s>max_blocksize + 7)/ 8; //FIXME header overhead 
214 
} 
215  
216 
for (i = 0; i < s>channels; i++) 
217 
{ 
218 
s>decoded[i] = av_realloc(s>decoded[i], sizeof(int32_t)*s>max_blocksize);

219 
} 
220  
221 
s>bitstream= av_fast_realloc(s>bitstream, &s>allocated_bitstream_size, s>max_framesize); 
222 
} 
223  
224 
static void metadata_streaminfo(FLACContext *s) 
225 
{ 
226 
/* mandatory streaminfo */

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

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

229  
230 
s>min_framesize = get_bits_long(&s>gb, 24);

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

232  
233 
s>samplerate = get_bits_long(&s>gb, 20);

234 
s>channels = get_bits(&s>gb, 3) + 1; 
235 
s>bps = get_bits(&s>gb, 5) + 1; 
236  
237 
s>avctx>channels = s>channels; 
238 
s>avctx>sample_rate = s>samplerate; 
239  
240 
skip_bits(&s>gb, 36); /* total num of samples */ 
241  
242 
skip_bits(&s>gb, 64); /* md5 sum */ 
243 
skip_bits(&s>gb, 64); /* md5 sum */ 
244  
245 
allocate_buffers(s); 
246 
} 
247  
248 
static int decode_residuals(FLACContext *s, int channel, int pred_order) 
249 
{ 
250 
int i, tmp, partition, method_type, rice_order;

251 
int sample = 0, samples; 
252  
253 
method_type = get_bits(&s>gb, 2);

254 
if (method_type != 0){ 
255 
av_log(s>avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);

256 
return 1; 
257 
} 
258  
259 
rice_order = get_bits(&s>gb, 4);

260  
261 
samples= s>blocksize >> rice_order; 
262  
263 
sample= 
264 
i= pred_order; 
265 
for (partition = 0; partition < (1 << rice_order); partition++) 
266 
{ 
267 
tmp = get_bits(&s>gb, 4);

268 
if (tmp == 15) 
269 
{ 
270 
av_log(s>avctx, AV_LOG_DEBUG, "fixed len partition\n");

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

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

273 
s>decoded[channel][sample] = get_sbits(&s>gb, tmp); 
274 
} 
275 
else

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

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

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

280 
} 
281 
} 
282 
i= 0;

283 
} 
284  
285 
// av_log(s>avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);

286  
287 
return 0; 
288 
} 
289  
290 
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order) 
291 
{ 
292 
int i;

293  
294 
// av_log(s>avctx, AV_LOG_DEBUG, " SUBFRAME FIXED\n");

295  
296 
/* warm up samples */

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

298  
299 
for (i = 0; i < pred_order; i++) 
300 
{ 
301 
s>decoded[channel][i] = get_sbits(&s>gb, s>curr_bps); 
302 
// av_log(s>avctx, AV_LOG_DEBUG, " %d: %d\n", i, s>decoded[channel][i]);

303 
} 
304  
305 
if (decode_residuals(s, channel, pred_order) < 0) 
306 
return 1; 
307  
308 
switch(pred_order)

309 
{ 
310 
case 0: 
311 
break;

312 
case 1: 
313 
for (i = pred_order; i < s>blocksize; i++)

314 
s>decoded[channel][i] += s>decoded[channel][i1];

315 
break;

316 
case 2: 
317 
for (i = pred_order; i < s>blocksize; i++)

318 
s>decoded[channel][i] += 2*s>decoded[channel][i1] 
319 
 s>decoded[channel][i2];

320 
break;

321 
case 3: 
322 
for (i = pred_order; i < s>blocksize; i++)

323 
s>decoded[channel][i] += 3*s>decoded[channel][i1] 
324 
 3*s>decoded[channel][i2] 
325 
+ s>decoded[channel][i3];

326 
break;

327 
case 4: 
328 
for (i = pred_order; i < s>blocksize; i++)

329 
s>decoded[channel][i] += 4*s>decoded[channel][i1] 
330 
 6*s>decoded[channel][i2] 
331 
+ 4*s>decoded[channel][i3] 
332 
 s>decoded[channel][i4];

333 
break;

334 
default:

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

336 
return 1; 
337 
} 
338  
339 
return 0; 
340 
} 
341  
342 
static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order) 
343 
{ 
344 
int sum, i, j;

345 
int coeff_prec, qlevel;

346 
int coeffs[pred_order];

347  
348 
// av_log(s>avctx, AV_LOG_DEBUG, " SUBFRAME LPC\n");

349  
350 
/* warm up samples */

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

352  
353 
for (i = 0; i < pred_order; i++) 
354 
{ 
355 
s>decoded[channel][i] = get_sbits(&s>gb, s>curr_bps); 
356 
// av_log(s>avctx, AV_LOG_DEBUG, " %d: %d\n", i, s>decoded[channel][i]);

357 
} 
358  
359 
coeff_prec = get_bits(&s>gb, 4) + 1; 
360 
if (coeff_prec == 16) 
361 
{ 
362 
av_log(s>avctx, AV_LOG_DEBUG, "invalid coeff precision\n");

363 
return 1; 
364 
} 
365 
// av_log(s>avctx, AV_LOG_DEBUG, " qlp coeff prec: %d\n", coeff_prec);

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

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

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

370 
return 1; 
371 
} 
372  
373 
for (i = 0; i < pred_order; i++) 
374 
{ 
375 
coeffs[i] = get_sbits(&s>gb, coeff_prec); 
376 
// av_log(s>avctx, AV_LOG_DEBUG, " %d: %d\n", i, coeffs[i]);

377 
} 
378  
379 
if (decode_residuals(s, channel, pred_order) < 0) 
380 
return 1; 
381  
382 
for (i = pred_order; i < s>blocksize; i++)

383 
{ 
384 
sum = 0;

385 
for (j = 0; j < pred_order; j++) 
386 
sum += coeffs[j] * s>decoded[channel][ij1];

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

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

401 
s>curr_bps++; 
402 
}else{

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

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

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

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

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

414  
415 
// if (wasted)

416 
// {

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

418 
// wasted++;

419 
// if (wasted)

420 
// wasted++;

421 
// s>curr_bps = wasted;

422 
// }

423 
#if 0

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

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

426 
s>curr_bps = wasted;

427 
#else

428 
if (get_bits1(&s>gb))

429 
{ 
430 
wasted = 1;

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

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

435 
} 
436 
#endif

437 
//FIXME use av_log2 for types

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

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

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

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

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

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

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

470 
{ 
471 
int i;

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

482 
int decorrelation, bps, blocksize, samplerate;

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

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

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

493 
else

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

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

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

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

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

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

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

518 
return 1; 
519 
} 
520 
#if 0

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

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

523 
}else{

524 
}

525 
#endif

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

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

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

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

549 
else if (sample_rate_code == 14) 
550 
samplerate = get_bits(&s>gb, 16) * 10; 
551 
else{

552 
av_log(s>avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);

553 
return 1; 
554 
} 
555  
556 
skip_bits(&s>gb, 8);

557 
crc8= get_crc8(s>gb.buffer, get_bits_count(&s>gb)/8);

558 
if(crc8){

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

560 
return 1; 
561 
} 
562  
563 
s>blocksize = blocksize; 
564 
s>samplerate = samplerate; 
565 
s>bps = bps; 
566 
s>decorrelation= decorrelation; 
567  
568 
// dump_headers(s);

569  
570 
/* subframes */

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

574 
if (decode_subframe(s, i) < 0) 
575 
return 1; 
576 
} 
577  
578 
align_get_bits(&s>gb); 
579  
580 
/* frame footer */

581 
skip_bits(&s>gb, 16); /* data crc */ 
582  
583 
return 0; 
584 
} 
585  
586 
static int flac_decode_frame(AVCodecContext *avctx, 
587 
void *data, int *data_size, 
588 
uint8_t *buf, int buf_size)

589 
{ 
590 
FLACContext *s = avctx>priv_data; 
591 
int metadata_last, metadata_type, metadata_size;

592 
int tmp = 0, i, j = 0, input_buf_size = 0; 
593 
int16_t *samples = data; 
594  
595 
if(s>max_framesize == 0){ 
596 
s>max_framesize= 65536; // should hopefully be enough for the first header 
597 
s>bitstream= av_fast_realloc(s>bitstream, &s>allocated_bitstream_size, s>max_framesize); 
598 
} 
599  
600 
if(1 && s>max_framesize){//FIXME truncated 
601 
buf_size= FFMAX(FFMIN(buf_size, s>max_framesize  s>bitstream_size), 0);

602 
input_buf_size= buf_size; 
603  
604 
if(s>bitstream_index + s>bitstream_size + buf_size > s>allocated_bitstream_size){

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

606 
memmove(s>bitstream, &s>bitstream[s>bitstream_index], s>bitstream_size); 
607 
s>bitstream_index=0;

608 
} 
609 
memcpy(&s>bitstream[s>bitstream_index + s>bitstream_size], buf, buf_size); 
610 
buf= &s>bitstream[s>bitstream_index]; 
611 
buf_size += s>bitstream_size; 
612 
s>bitstream_size= buf_size; 
613  
614 
if(buf_size < s>max_framesize){

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

616 
return input_buf_size;

617 
} 
618 
} 
619  
620 
init_get_bits(&s>gb, buf, buf_size*8);

621  
622 
/* fLaC signature (be) */

623 
if (show_bits_long(&s>gb, 32) == bswap_32(ff_get_fourcc("fLaC"))) 
624 
{ 
625 
skip_bits(&s>gb, 32);

626  
627 
av_log(s>avctx, AV_LOG_DEBUG, "STREAM HEADER\n");

628 
do {

629 
metadata_last = get_bits(&s>gb, 1);

630 
metadata_type = get_bits(&s>gb, 7);

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

632  
633 
av_log(s>avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",

634 
metadata_last, metadata_type, 
635 
metadata_size); 
636 
if(metadata_size){

637 
switch(metadata_type)

638 
{ 
639 
case METADATA_TYPE_STREAMINFO:{

640 
metadata_streaminfo(s); 
641  
642 
/* Buffer might have been reallocated, reinit bitreader */

643 
if(buf != &s>bitstream[s>bitstream_index])

644 
{ 
645 
int bits_count = get_bits_count(&s>gb);

646 
buf= &s>bitstream[s>bitstream_index]; 
647 
init_get_bits(&s>gb, buf, buf_size*8);

648 
skip_bits(&s>gb, bits_count); 
649 
} 
650  
651 
dump_headers(s); 
652 
break;}

653 
default:

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

656 
} 
657 
} 
658 
} while(!metadata_last);

659 
} 
660 
else

661 
{ 
662  
663 
tmp = show_bits(&s>gb, 16);

664 
if(tmp != 0xFFF8){ 
665 
av_log(s>avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");

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

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

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

673 
s>bitstream_size=0;

674 
s>bitstream_index=0;

675 
return 1; 
676 
} 
677 
} 
678  
679  
680 
#if 0

681 
/* fix the channel order here */

682 
if (s>order == MID_SIDE)

683 
{

684 
short *left = samples;

685 
short *right = samples + s>blocksize;

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

687 
{

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

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

690 

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

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

693 
}

694 
*data_size = 2 * s>blocksize;

695 
}

696 
else

697 
{

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

699 
{

700 
switch(s>order)

701 
{

702 
case INDEPENDENT:

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

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

705 
break;

706 
case LEFT_SIDE:

707 
case RIGHT_SIDE:

708 
if (i == 0)

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

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

711 
else

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

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

714 
break;

715 
// case MID_SIDE:

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

717 
}

718 
*data_size += s>blocksize;

719 
}

720 
}

721 
#else

722 
switch(s>decorrelation)

723 
{ 
724 
case INDEPENDENT:

725 
for (j = 0; j < s>blocksize; j++) 
726 
{ 
727 
for (i = 0; i < s>channels; i++) 
728 
*(samples++) = s>decoded[i][j]; 
729 
} 
730 
break;

731 
case LEFT_SIDE:

732 
assert(s>channels == 2);

733 
for (i = 0; i < s>blocksize; i++) 
734 
{ 
735 
*(samples++) = s>decoded[0][i];

736 
*(samples++) = s>decoded[0][i]  s>decoded[1][i]; 
737 
} 
738 
break;

739 
case RIGHT_SIDE:

740 
assert(s>channels == 2);

741 
for (i = 0; i < s>blocksize; i++) 
742 
{ 
743 
*(samples++) = s>decoded[0][i] + s>decoded[1][i]; 
744 
*(samples++) = s>decoded[1][i];

745 
} 
746 
break;

747 
case MID_SIDE:

748 
assert(s>channels == 2);

749 
for (i = 0; i < s>blocksize; i++) 
750 
{ 
751 
int mid, side;

752 
mid = s>decoded[0][i];

753 
side = s>decoded[1][i];

754  
755 
#if 1 //needs to be checked but IMHO it should be binary identical 
756 
mid = side>>1;

757 
*(samples++) = mid + side; 
758 
*(samples++) = mid; 
759 
#else

760  
761 
mid <<= 1;

762 
if (side & 1) 
763 
mid++; 
764 
*(samples++) = (mid + side) >> 1;

765 
*(samples++) = (mid  side) >> 1;

766 
#endif

767 
} 
768 
break;

769 
} 
770 
#endif

771  
772 
*data_size = (int8_t *)samples  (int8_t *)data; 
773 
// av_log(s>avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);

774  
775 
// s>last_blocksize = s>blocksize;

776 
end:

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

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

780 
s>bitstream_size=0;

781 
s>bitstream_index=0;

782 
return 1; 
783 
} 
784  
785 
if(s>bitstream_size){

786 
s>bitstream_index += i; 
787 
s>bitstream_size = i; 
788 
return input_buf_size;

789 
}else

790 
return i;

791 
} 
792  
793 
static int flac_decode_close(AVCodecContext *avctx) 
794 
{ 
795 
FLACContext *s = avctx>priv_data; 
796 
int i;

797  
798 
for (i = 0; i < s>channels; i++) 
799 
{ 
800 
av_freep(&s>decoded[i]); 
801 
} 
802 
av_freep(&s>bitstream); 
803  
804 
return 0; 
805 
} 
806  
807 
static void flac_flush(AVCodecContext *avctx){ 
808 
FLACContext *s = avctx>priv_data; 
809  
810 
s>bitstream_size= 
811 
s>bitstream_index= 0;

812 
} 
813  
814 
AVCodec flac_decoder = { 
815 
"flac",

816 
CODEC_TYPE_AUDIO, 
817 
CODEC_ID_FLAC, 
818 
sizeof(FLACContext),

819 
flac_decode_init, 
820 
NULL,

821 
flac_decode_close, 
822 
flac_decode_frame, 
823 
.flush= flac_flush, 
824 
}; 