ffmpeg / libavcodec / flac.c @ 8a01fc47
History  View  Annotate  Download (23.6 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., 59 Temple Place, Suite 330, Boston, MA 021111307 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 "golomb.h" 
38  
39 
#undef NDEBUG

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

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

58 
int min_framesize, max_framesize;

59 
int samplerate, channels;

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

62 
enum decorrelation_type decorrelation;

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

67 
int bitstream_index;

68 
int allocated_bitstream_size;

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

122 
{ 
123 
uint64_t val; 
124 
int ones=0, bytes; 
125 

126 
while(get_bits1(gb))

127 
ones++; 
128  
129 
if (ones==0) bytes=0; 
130 
else if(ones==1) return 1; 
131 
else bytes= ones  1; 
132 

133 
val= get_bits(gb, 7ones);

134 
while(bytes){

135 
const int tmp = get_bits(gb, 8); 
136 

137 
if((tmp>>6) != 2) 
138 
return 1; 
139 
val<<=6;

140 
val= tmp&0x3F;

141 
} 
142 
return val;

143 
} 
144  
145 
static int skip_utf8(GetBitContext *gb) 
146 
{ 
147 
int ones=0, bytes; 
148 

149 
while(get_bits1(gb))

150 
ones++; 
151  
152 
if (ones==0) bytes=0; 
153 
else if(ones==1) return 1; 
154 
else bytes= ones  1; 
155 

156 
skip_bits(gb, 7ones);

157 
while(bytes){

158 
const int tmp = get_bits(gb, 8); 
159 

160 
if((tmp>>6) != 2) 
161 
return 1; 
162 
} 
163 
return 0; 
164 
} 
165  
166 
static int get_crc8(const uint8_t *buf, int count){ 
167 
int crc=0; 
168 
int i;

169 

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

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

186 
if (avctx>extradata_size == FLAC_STREAMINFO_SIZE) {

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

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

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

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

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

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

202 
} 
203  
204 
static void allocate_buffers(FLACContext *s){ 
205 
int i;

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

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

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

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

226  
227 
s>min_framesize = get_bits_long(&s>gb, 24);

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

229 

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

231 
s>channels = get_bits(&s>gb, 3) + 1; 
232 
s>bps = get_bits(&s>gb, 5) + 1; 
233 

234 
s>avctx>channels = s>channels; 
235 
s>avctx>sample_rate = s>samplerate; 
236  
237 
skip_bits(&s>gb, 36); /* total num of samples */ 
238 

239 
skip_bits(&s>gb, 64); /* md5 sum */ 
240 
skip_bits(&s>gb, 64); /* md5 sum */ 
241 

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

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

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

253 
return 1; 
254 
} 
255 

256 
rice_order = get_bits(&s>gb, 4);

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

265 
if (tmp == 15) 
266 
{ 
267 
av_log(s>avctx, AV_LOG_DEBUG, "fixed len partition\n");

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

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

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

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

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

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

277 
} 
278 
} 
279 
i= 0;

280 
} 
281  
282 
// av_log(s>avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);

283  
284 
return 0; 
285 
} 
286  
287 
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order) 
288 
{ 
289 
int i;

290 

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

292 

293 
/* warm up samples */

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

295 

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

300 
} 
301 

302 
if (decode_residuals(s, channel, pred_order) < 0) 
303 
return 1; 
304  
305 
switch(pred_order)

306 
{ 
307 
case 0: 
308 
break;

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

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

312 
break;

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

315 
s>decoded[channel][i] += 2*s>decoded[channel][i1] 
316 
 s>decoded[channel][i2];

317 
break;

318 
case 3: 
319 
for (i = pred_order; i < s>blocksize; i++)

320 
s>decoded[channel][i] += 3*s>decoded[channel][i1] 
321 
 3*s>decoded[channel][i2] 
322 
+ s>decoded[channel][i3];

323 
break;

324 
case 4: 
325 
for (i = pred_order; i < s>blocksize; i++)

326 
s>decoded[channel][i] += 4*s>decoded[channel][i1] 
327 
 6*s>decoded[channel][i2] 
328 
+ 4*s>decoded[channel][i3] 
329 
 s>decoded[channel][i4];

330 
break;

331 
default:

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

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

342 
int coeff_prec, qlevel;

343 
int coeffs[pred_order];

344 

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

346 

347 
/* warm up samples */

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

349 

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

354 
} 
355 

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

360 
return 1; 
361 
} 
362 
// av_log(s>avctx, AV_LOG_DEBUG, " qlp coeff prec: %d\n", coeff_prec);

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

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

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

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

374 
} 
375 

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

380 
{ 
381 
sum = 0;

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

384 
s>decoded[channel][i] += sum >> qlevel; 
385 
} 
386 

387 
return 0; 
388 
} 
389  
390 
static inline int decode_subframe(FLACContext *s, int channel) 
391 
{ 
392 
int type, wasted = 0; 
393 
int i, tmp;

394 

395 
s>curr_bps = s>bps; 
396 
if(channel == 0){ 
397 
if(s>decorrelation == RIGHT_SIDE)

398 
s>curr_bps++; 
399 
}else{

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

401 
s>curr_bps++; 
402 
} 
403  
404 
if (get_bits1(&s>gb))

405 
{ 
406 
av_log(s>avctx, AV_LOG_DEBUG, "invalid subframe padding\n");

407 
return 1; 
408 
} 
409 
type = get_bits(&s>gb, 6);

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

411 

412 
// if (wasted)

413 
// {

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

415 
// wasted++;

416 
// if (wasted)

417 
// wasted++;

418 
// s>curr_bps = wasted;

419 
// }

420 
#if 0

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

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

423 
s>curr_bps = wasted;

424 
#else

425 
if (get_bits1(&s>gb))

426 
{ 
427 
wasted = 1;

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

429 
wasted++; 
430 
s>curr_bps = wasted; 
431 
av_log(s>avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);

432 
} 
433 
#endif

434 
//FIXME use av_log2 for types

435 
if (type == 0) 
436 
{ 
437 
av_log(s>avctx, AV_LOG_DEBUG, "coding type: constant\n");

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

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

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

457 
if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) 
458 
return 1; 
459 
} 
460 
else

461 
{ 
462 
av_log(s>avctx, AV_LOG_DEBUG, "invalid coding type\n");

463 
return 1; 
464 
} 
465 

466 
if (wasted)

467 
{ 
468 
int i;

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

479 
int decorrelation, bps, blocksize, samplerate;

480 

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

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

484 

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

490 
else

491 
{ 
492 
av_log(s>avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s>channels);

493 
return 1; 
494 
} 
495 

496 
sample_size_code = get_bits(&s>gb, 3);

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

502 
{ 
503 
av_log(s>avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);

504 
return 1; 
505 
} 
506  
507 
if (get_bits1(&s>gb))

508 
{ 
509 
av_log(s>avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");

510 
return 1; 
511 
} 
512 

513 
if(get_utf8(&s>gb) < 0){ 
514 
av_log(s>avctx, AV_LOG_ERROR, "utf8 fscked\n");

515 
return 1; 
516 
} 
517 
#if 0

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

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

520 
}else{

521 
}

522 
#endif

523 

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

531 
blocksize = blocksize_table[blocksize_code]; 
532  
533 
if(blocksize > s>max_blocksize){

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

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

546 
else if (sample_rate_code == 14) 
547 
samplerate = get_bits(&s>gb, 16) * 10; 
548 
else{

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

550 
return 1; 
551 
} 
552  
553 
skip_bits(&s>gb, 8);

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

555 
if(crc8){

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

557 
return 1; 
558 
} 
559 

560 
s>blocksize = blocksize; 
561 
s>samplerate = samplerate; 
562 
s>bps = bps; 
563 
s>decorrelation= decorrelation; 
564  
565 
// dump_headers(s);

566  
567 
/* subframes */

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

571 
if (decode_subframe(s, i) < 0) 
572 
return 1; 
573 
} 
574 

575 
align_get_bits(&s>gb); 
576  
577 
/* frame footer */

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

586 
{ 
587 
FLACContext *s = avctx>priv_data; 
588 
int metadata_last, metadata_type, metadata_size;

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

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

603 
memmove(s>bitstream, &s>bitstream[s>bitstream_index], s>bitstream_size); 
604 
s>bitstream_index=0;

605 
} 
606 
memcpy(&s>bitstream[s>bitstream_index + s>bitstream_size], buf, buf_size); 
607 
buf= &s>bitstream[s>bitstream_index]; 
608 
buf_size += s>bitstream_size; 
609 
s>bitstream_size= buf_size; 
610 

611 
if(buf_size < s>max_framesize){

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

613 
return input_buf_size;

614 
} 
615 
} 
616  
617 
init_get_bits(&s>gb, buf, buf_size*8);

618 

619 
/* fLaC signature (be) */

620 
if (show_bits_long(&s>gb, 32) == bswap_32(ff_get_fourcc("fLaC"))) 
621 
{ 
622 
skip_bits(&s>gb, 32);

623  
624 
av_log(s>avctx, AV_LOG_DEBUG, "STREAM HEADER\n");

625 
do {

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

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

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

629 

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

631 
metadata_last, metadata_type, 
632 
metadata_size); 
633 
if(metadata_size){

634 
switch(metadata_type)

635 
{ 
636 
case METADATA_TYPE_STREAMINFO:

637 
metadata_streaminfo(s); 
638 
dump_headers(s); 
639 
break;

640 
default:

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

643 
} 
644 
} 
645 
} while(!metadata_last);

646 
} 
647 
else

648 
{ 
649 

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

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

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

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

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

660 
s>bitstream_size=0;

661 
s>bitstream_index=0;

662 
return 1; 
663 
} 
664 
} 
665  
666 

667 
#if 0

668 
/* fix the channel order here */

669 
if (s>order == MID_SIDE)

670 
{

671 
short *left = samples;

672 
short *right = samples + s>blocksize;

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

674 
{

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

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

677 

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

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

680 
}

681 
*data_size = 2 * s>blocksize;

682 
}

683 
else

684 
{

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

686 
{

687 
switch(s>order)

688 
{

689 
case INDEPENDENT:

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

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

692 
break;

693 
case LEFT_SIDE:

694 
case RIGHT_SIDE:

695 
if (i == 0)

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

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

698 
else

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

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

701 
break;

702 
// case MID_SIDE:

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

704 
}

705 
*data_size += s>blocksize;

706 
}

707 
}

708 
#else

709 
switch(s>decorrelation)

710 
{ 
711 
case INDEPENDENT:

712 
for (j = 0; j < s>blocksize; j++) 
713 
{ 
714 
for (i = 0; i < s>channels; i++) 
715 
*(samples++) = s>decoded[i][j]; 
716 
} 
717 
break;

718 
case LEFT_SIDE:

719 
assert(s>channels == 2);

720 
for (i = 0; i < s>blocksize; i++) 
721 
{ 
722 
*(samples++) = s>decoded[0][i];

723 
*(samples++) = s>decoded[0][i]  s>decoded[1][i]; 
724 
} 
725 
break;

726 
case RIGHT_SIDE:

727 
assert(s>channels == 2);

728 
for (i = 0; i < s>blocksize; i++) 
729 
{ 
730 
*(samples++) = s>decoded[0][i] + s>decoded[1][i]; 
731 
*(samples++) = s>decoded[1][i];

732 
} 
733 
break;

734 
case MID_SIDE:

735 
assert(s>channels == 2);

736 
for (i = 0; i < s>blocksize; i++) 
737 
{ 
738 
int mid, side;

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

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

741  
742 
#if 1 //needs to be checked but IMHO it should be binary identical 
743 
mid = side>>1;

744 
*(samples++) = mid + side; 
745 
*(samples++) = mid; 
746 
#else

747 

748 
mid <<= 1;

749 
if (side & 1) 
750 
mid++; 
751 
*(samples++) = (mid + side) >> 1;

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

753 
#endif

754 
} 
755 
break;

756 
} 
757 
#endif

758  
759 
*data_size = (int8_t *)samples  (int8_t *)data; 
760 
// av_log(s>avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);

761  
762 
// s>last_blocksize = s>blocksize;

763 
end:

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

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

767 
s>bitstream_size=0;

768 
s>bitstream_index=0;

769 
return 1; 
770 
} 
771  
772 
if(s>bitstream_size){

773 
s>bitstream_index += i; 
774 
s>bitstream_size = i; 
775 
return input_buf_size;

776 
}else

777 
return i;

778 
} 
779  
780 
static int flac_decode_close(AVCodecContext *avctx) 
781 
{ 
782 
FLACContext *s = avctx>priv_data; 
783 
int i;

784 

785 
for (i = 0; i < s>channels; i++) 
786 
{ 
787 
av_freep(&s>decoded[i]); 
788 
} 
789 
av_freep(&s>bitstream); 
790 

791 
return 0; 
792 
} 
793  
794 
static void flac_flush(AVCodecContext *avctx){ 
795 
FLACContext *s = avctx>priv_data; 
796  
797 
s>bitstream_size= 
798 
s>bitstream_index= 0;

799 
} 
800  
801 
AVCodec flac_decoder = { 
802 
"flac",

803 
CODEC_TYPE_AUDIO, 
804 
CODEC_ID_FLAC, 
805 
sizeof(FLACContext),

806 
flac_decode_init, 
807 
NULL,

808 
flac_decode_close, 
809 
flac_decode_frame, 
810 
.flush= flac_flush, 
811 
}; 