Mercurial > libavcodec.hg
comparison flacdec.c @ 8656:6565469fb8d1 libavcodec
flacdec: cosmetics: use consistent coding style (K&R)
author | jbr |
---|---|
date | Sat, 24 Jan 2009 18:51:43 +0000 |
parents | cc6f01be6614 |
children | 62c52fff9ac0 |
comparison
equal
deleted
inserted
replaced
8655:14ccee231565 | 8656:6565469fb8d1 |
---|---|
87 static const int blocksize_table[] = { | 87 static const int blocksize_table[] = { |
88 0, 192, 576<<0, 576<<1, 576<<2, 576<<3, 0, 0, | 88 0, 192, 576<<0, 576<<1, 576<<2, 576<<3, 0, 0, |
89 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7 | 89 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7 |
90 }; | 90 }; |
91 | 91 |
92 static int64_t get_utf8(GetBitContext *gb){ | 92 static int64_t get_utf8(GetBitContext *gb) |
93 { | |
93 int64_t val; | 94 int64_t val; |
94 GET_UTF8(val, get_bits(gb, 8), return -1;) | 95 GET_UTF8(val, get_bits(gb, 8), return -1;) |
95 return val; | 96 return val; |
96 } | 97 } |
97 | 98 |
98 static void allocate_buffers(FLACContext *s); | 99 static void allocate_buffers(FLACContext *s); |
99 static int metadata_parse(FLACContext *s); | 100 static int metadata_parse(FLACContext *s); |
100 | 101 |
101 static av_cold int flac_decode_init(AVCodecContext * avctx) | 102 static av_cold int flac_decode_init(AVCodecContext *avctx) |
102 { | 103 { |
103 FLACContext *s = avctx->priv_data; | 104 FLACContext *s = avctx->priv_data; |
104 s->avctx = avctx; | 105 s->avctx = avctx; |
105 | 106 |
106 if (avctx->extradata_size > 4) { | 107 if (avctx->extradata_size > 4) { |
125 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate); | 126 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate); |
126 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels); | 127 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels); |
127 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps); | 128 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps); |
128 } | 129 } |
129 | 130 |
130 static void allocate_buffers(FLACContext *s){ | 131 static void allocate_buffers(FLACContext *s) |
132 { | |
131 int i; | 133 int i; |
132 | 134 |
133 assert(s->max_blocksize); | 135 assert(s->max_blocksize); |
134 | 136 |
135 if(s->max_framesize == 0 && s->max_blocksize){ | 137 if (s->max_framesize == 0 && s->max_blocksize) { |
136 s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead | 138 s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead |
137 } | 139 } |
138 | 140 |
139 for (i = 0; i < s->channels; i++) | 141 for (i = 0; i < s->channels; i++) { |
140 { | |
141 s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize); | 142 s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize); |
142 } | 143 } |
143 | 144 |
144 if(s->allocated_bitstream_size < s->max_framesize) | 145 if (s->allocated_bitstream_size < s->max_framesize) |
145 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize); | 146 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize); |
146 } | 147 } |
147 | 148 |
148 void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, | 149 void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, |
149 const uint8_t *buffer) | 150 const uint8_t *buffer) |
191 do { | 192 do { |
192 metadata_last = get_bits1(&s->gb); | 193 metadata_last = get_bits1(&s->gb); |
193 metadata_type = get_bits(&s->gb, 7); | 194 metadata_type = get_bits(&s->gb, 7); |
194 metadata_size = get_bits_long(&s->gb, 24); | 195 metadata_size = get_bits_long(&s->gb, 24); |
195 | 196 |
196 if(get_bits_count(&s->gb) + 8*metadata_size > s->gb.size_in_bits){ | 197 if (get_bits_count(&s->gb) + 8*metadata_size > s->gb.size_in_bits) { |
197 skip_bits_long(&s->gb, initial_pos - get_bits_count(&s->gb)); | 198 skip_bits_long(&s->gb, initial_pos - get_bits_count(&s->gb)); |
198 break; | 199 break; |
199 } | 200 } |
200 | 201 |
201 if (metadata_size) { | 202 if (metadata_size) { |
203 case METADATA_TYPE_STREAMINFO: | 204 case METADATA_TYPE_STREAMINFO: |
204 ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, s->gb.buffer+get_bits_count(&s->gb)/8); | 205 ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, s->gb.buffer+get_bits_count(&s->gb)/8); |
205 streaminfo_updated = 1; | 206 streaminfo_updated = 1; |
206 | 207 |
207 default: | 208 default: |
208 for (i=0; i<metadata_size; i++) | 209 for (i = 0; i < metadata_size; i++) |
209 skip_bits(&s->gb, 8); | 210 skip_bits(&s->gb, 8); |
210 } | 211 } |
211 } | 212 } |
212 } while (!metadata_last); | 213 } while (!metadata_last); |
213 | 214 |
222 { | 223 { |
223 int i, tmp, partition, method_type, rice_order; | 224 int i, tmp, partition, method_type, rice_order; |
224 int sample = 0, samples; | 225 int sample = 0, samples; |
225 | 226 |
226 method_type = get_bits(&s->gb, 2); | 227 method_type = get_bits(&s->gb, 2); |
227 if (method_type > 1){ | 228 if (method_type > 1) { |
228 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n", method_type); | 229 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n", method_type); |
229 return -1; | 230 return -1; |
230 } | 231 } |
231 | 232 |
232 rice_order = get_bits(&s->gb, 4); | 233 rice_order = get_bits(&s->gb, 4); |
237 return -1; | 238 return -1; |
238 } | 239 } |
239 | 240 |
240 sample= | 241 sample= |
241 i= pred_order; | 242 i= pred_order; |
242 for (partition = 0; partition < (1 << rice_order); partition++) | 243 for (partition = 0; partition < (1 << rice_order); partition++) { |
243 { | |
244 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5); | 244 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5); |
245 if (tmp == (method_type == 0 ? 15 : 31)) | 245 if (tmp == (method_type == 0 ? 15 : 31)) { |
246 { | |
247 tmp = get_bits(&s->gb, 5); | 246 tmp = get_bits(&s->gb, 5); |
248 for (; i < samples; i++, sample++) | 247 for (; i < samples; i++, sample++) |
249 s->decoded[channel][sample] = get_sbits(&s->gb, tmp); | 248 s->decoded[channel][sample] = get_sbits(&s->gb, tmp); |
250 } | 249 } else { |
251 else | 250 for (; i < samples; i++, sample++) { |
252 { | |
253 for (; i < samples; i++, sample++){ | |
254 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0); | 251 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0); |
255 } | 252 } |
256 } | 253 } |
257 i= 0; | 254 i= 0; |
258 } | 255 } |
265 const int blocksize = s->blocksize; | 262 const int blocksize = s->blocksize; |
266 int32_t *decoded = s->decoded[channel]; | 263 int32_t *decoded = s->decoded[channel]; |
267 int a, b, c, d, i; | 264 int a, b, c, d, i; |
268 | 265 |
269 /* warm up samples */ | 266 /* warm up samples */ |
270 for (i = 0; i < pred_order; i++) | 267 for (i = 0; i < pred_order; i++) { |
271 { | |
272 decoded[i] = get_sbits(&s->gb, s->curr_bps); | 268 decoded[i] = get_sbits(&s->gb, s->curr_bps); |
273 } | 269 } |
274 | 270 |
275 if (decode_residuals(s, channel, pred_order) < 0) | 271 if (decode_residuals(s, channel, pred_order) < 0) |
276 return -1; | 272 return -1; |
277 | 273 |
278 if(pred_order > 0) | 274 if (pred_order > 0) |
279 a = decoded[pred_order-1]; | 275 a = decoded[pred_order-1]; |
280 if(pred_order > 1) | 276 if (pred_order > 1) |
281 b = a - decoded[pred_order-2]; | 277 b = a - decoded[pred_order-2]; |
282 if(pred_order > 2) | 278 if (pred_order > 2) |
283 c = b - decoded[pred_order-2] + decoded[pred_order-3]; | 279 c = b - decoded[pred_order-2] + decoded[pred_order-3]; |
284 if(pred_order > 3) | 280 if (pred_order > 3) |
285 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4]; | 281 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4]; |
286 | 282 |
287 switch(pred_order) | 283 switch (pred_order) { |
288 { | 284 case 0: |
289 case 0: | 285 break; |
290 break; | 286 case 1: |
291 case 1: | 287 for (i = pred_order; i < blocksize; i++) |
292 for (i = pred_order; i < blocksize; i++) | 288 decoded[i] = a += decoded[i]; |
293 decoded[i] = a += decoded[i]; | 289 break; |
294 break; | 290 case 2: |
295 case 2: | 291 for (i = pred_order; i < blocksize; i++) |
296 for (i = pred_order; i < blocksize; i++) | 292 decoded[i] = a += b += decoded[i]; |
297 decoded[i] = a += b += decoded[i]; | 293 break; |
298 break; | 294 case 3: |
299 case 3: | 295 for (i = pred_order; i < blocksize; i++) |
300 for (i = pred_order; i < blocksize; i++) | 296 decoded[i] = a += b += c += decoded[i]; |
301 decoded[i] = a += b += c += decoded[i]; | 297 break; |
302 break; | 298 case 4: |
303 case 4: | 299 for (i = pred_order; i < blocksize; i++) |
304 for (i = pred_order; i < blocksize; i++) | 300 decoded[i] = a += b += c += d += decoded[i]; |
305 decoded[i] = a += b += c += d += decoded[i]; | 301 break; |
306 break; | 302 default: |
307 default: | 303 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); |
308 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); | 304 return -1; |
309 return -1; | |
310 } | 305 } |
311 | 306 |
312 return 0; | 307 return 0; |
313 } | 308 } |
314 | 309 |
318 int coeff_prec, qlevel; | 313 int coeff_prec, qlevel; |
319 int coeffs[pred_order]; | 314 int coeffs[pred_order]; |
320 int32_t *decoded = s->decoded[channel]; | 315 int32_t *decoded = s->decoded[channel]; |
321 | 316 |
322 /* warm up samples */ | 317 /* warm up samples */ |
323 for (i = 0; i < pred_order; i++) | 318 for (i = 0; i < pred_order; i++) { |
324 { | |
325 decoded[i] = get_sbits(&s->gb, s->curr_bps); | 319 decoded[i] = get_sbits(&s->gb, s->curr_bps); |
326 } | 320 } |
327 | 321 |
328 coeff_prec = get_bits(&s->gb, 4) + 1; | 322 coeff_prec = get_bits(&s->gb, 4) + 1; |
329 if (coeff_prec == 16) | 323 if (coeff_prec == 16) { |
330 { | |
331 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n"); | 324 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n"); |
332 return -1; | 325 return -1; |
333 } | 326 } |
334 qlevel = get_sbits(&s->gb, 5); | 327 qlevel = get_sbits(&s->gb, 5); |
335 if(qlevel < 0){ | 328 if (qlevel < 0) { |
336 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n", qlevel); | 329 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n", qlevel); |
337 return -1; | 330 return -1; |
338 } | 331 } |
339 | 332 |
340 for (i = 0; i < pred_order; i++) | 333 for (i = 0; i < pred_order; i++) { |
341 { | |
342 coeffs[i] = get_sbits(&s->gb, coeff_prec); | 334 coeffs[i] = get_sbits(&s->gb, coeff_prec); |
343 } | 335 } |
344 | 336 |
345 if (decode_residuals(s, channel, pred_order) < 0) | 337 if (decode_residuals(s, channel, pred_order) < 0) |
346 return -1; | 338 return -1; |
347 | 339 |
348 if (s->bps > 16) { | 340 if (s->bps > 16) { |
349 int64_t sum; | 341 int64_t sum; |
350 for (i = pred_order; i < s->blocksize; i++) | 342 for (i = pred_order; i < s->blocksize; i++) { |
351 { | |
352 sum = 0; | 343 sum = 0; |
353 for (j = 0; j < pred_order; j++) | 344 for (j = 0; j < pred_order; j++) |
354 sum += (int64_t)coeffs[j] * decoded[i-j-1]; | 345 sum += (int64_t)coeffs[j] * decoded[i-j-1]; |
355 decoded[i] += sum >> qlevel; | 346 decoded[i] += sum >> qlevel; |
356 } | 347 } |
357 } else { | 348 } else { |
358 for (i = pred_order; i < s->blocksize-1; i += 2) | 349 for (i = pred_order; i < s->blocksize-1; i += 2) { |
359 { | |
360 int c; | 350 int c; |
361 int d = decoded[i-pred_order]; | 351 int d = decoded[i-pred_order]; |
362 int s0 = 0, s1 = 0; | 352 int s0 = 0, s1 = 0; |
363 for (j = pred_order-1; j > 0; j--) | 353 for (j = pred_order-1; j > 0; j--) { |
364 { | |
365 c = coeffs[j]; | 354 c = coeffs[j]; |
366 s0 += c*d; | 355 s0 += c*d; |
367 d = decoded[i-j]; | 356 d = decoded[i-j]; |
368 s1 += c*d; | 357 s1 += c*d; |
369 } | 358 } |
371 s0 += c*d; | 360 s0 += c*d; |
372 d = decoded[i] += s0 >> qlevel; | 361 d = decoded[i] += s0 >> qlevel; |
373 s1 += c*d; | 362 s1 += c*d; |
374 decoded[i+1] += s1 >> qlevel; | 363 decoded[i+1] += s1 >> qlevel; |
375 } | 364 } |
376 if (i < s->blocksize) | 365 if (i < s->blocksize) { |
377 { | |
378 int sum = 0; | 366 int sum = 0; |
379 for (j = 0; j < pred_order; j++) | 367 for (j = 0; j < pred_order; j++) |
380 sum += coeffs[j] * decoded[i-j-1]; | 368 sum += coeffs[j] * decoded[i-j-1]; |
381 decoded[i] += sum >> qlevel; | 369 decoded[i] += sum >> qlevel; |
382 } | 370 } |
389 { | 377 { |
390 int type, wasted = 0; | 378 int type, wasted = 0; |
391 int i, tmp; | 379 int i, tmp; |
392 | 380 |
393 s->curr_bps = s->bps; | 381 s->curr_bps = s->bps; |
394 if(channel == 0){ | 382 if (channel == 0) { |
395 if(s->decorrelation == RIGHT_SIDE) | 383 if (s->decorrelation == RIGHT_SIDE) |
396 s->curr_bps++; | 384 s->curr_bps++; |
397 }else{ | 385 } else { |
398 if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE) | 386 if (s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE) |
399 s->curr_bps++; | 387 s->curr_bps++; |
400 } | 388 } |
401 | 389 |
402 if (get_bits1(&s->gb)) | 390 if (get_bits1(&s->gb)) { |
403 { | |
404 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n"); | 391 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n"); |
405 return -1; | 392 return -1; |
406 } | 393 } |
407 type = get_bits(&s->gb, 6); | 394 type = get_bits(&s->gb, 6); |
408 | 395 |
409 if (get_bits1(&s->gb)) | 396 if (get_bits1(&s->gb)) { |
410 { | |
411 wasted = 1; | 397 wasted = 1; |
412 while (!get_bits1(&s->gb)) | 398 while (!get_bits1(&s->gb)) |
413 wasted++; | 399 wasted++; |
414 s->curr_bps -= wasted; | 400 s->curr_bps -= wasted; |
415 } | 401 } |
416 | 402 |
417 //FIXME use av_log2 for types | 403 //FIXME use av_log2 for types |
418 if (type == 0) | 404 if (type == 0) { |
419 { | |
420 tmp = get_sbits(&s->gb, s->curr_bps); | 405 tmp = get_sbits(&s->gb, s->curr_bps); |
421 for (i = 0; i < s->blocksize; i++) | 406 for (i = 0; i < s->blocksize; i++) |
422 s->decoded[channel][i] = tmp; | 407 s->decoded[channel][i] = tmp; |
423 } | 408 } else if (type == 1) { |
424 else if (type == 1) | |
425 { | |
426 for (i = 0; i < s->blocksize; i++) | 409 for (i = 0; i < s->blocksize; i++) |
427 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps); | 410 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps); |
428 } | 411 } else if ((type >= 8) && (type <= 12)) { |
429 else if ((type >= 8) && (type <= 12)) | |
430 { | |
431 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0) | 412 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0) |
432 return -1; | 413 return -1; |
433 } | 414 } else if (type >= 32) { |
434 else if (type >= 32) | |
435 { | |
436 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) | 415 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) |
437 return -1; | 416 return -1; |
438 } | 417 } else { |
439 else | |
440 { | |
441 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n"); | 418 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n"); |
442 return -1; | 419 return -1; |
443 } | 420 } |
444 | 421 |
445 if (wasted) | 422 if (wasted) { |
446 { | |
447 int i; | 423 int i; |
448 for (i = 0; i < s->blocksize; i++) | 424 for (i = 0; i < s->blocksize; i++) |
449 s->decoded[channel][i] <<= wasted; | 425 s->decoded[channel][i] <<= wasted; |
450 } | 426 } |
451 | 427 |
464 assignment = get_bits(&s->gb, 4); /* channel assignment */ | 440 assignment = get_bits(&s->gb, 4); /* channel assignment */ |
465 if (assignment < 8 && s->channels == assignment+1) | 441 if (assignment < 8 && s->channels == assignment+1) |
466 decorrelation = INDEPENDENT; | 442 decorrelation = INDEPENDENT; |
467 else if (assignment >=8 && assignment < 11 && s->channels == 2) | 443 else if (assignment >=8 && assignment < 11 && s->channels == 2) |
468 decorrelation = LEFT_SIDE + assignment - 8; | 444 decorrelation = LEFT_SIDE + assignment - 8; |
469 else | 445 else { |
470 { | |
471 av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels); | 446 av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels); |
472 return -1; | 447 return -1; |
473 } | 448 } |
474 | 449 |
475 sample_size_code = get_bits(&s->gb, 3); | 450 sample_size_code = get_bits(&s->gb, 3); |
476 if(sample_size_code == 0) | 451 if (sample_size_code == 0) |
477 bps= s->bps; | 452 bps= s->bps; |
478 else if((sample_size_code != 3) && (sample_size_code != 7)) | 453 else if ((sample_size_code != 3) && (sample_size_code != 7)) |
479 bps = sample_size_table[sample_size_code]; | 454 bps = sample_size_table[sample_size_code]; |
480 else | 455 else { |
481 { | |
482 av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", sample_size_code); | 456 av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", sample_size_code); |
483 return -1; | 457 return -1; |
484 } | 458 } |
485 | 459 |
486 if (get_bits1(&s->gb)) | 460 if (get_bits1(&s->gb)) { |
487 { | |
488 av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n"); | 461 av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n"); |
489 return -1; | 462 return -1; |
490 } | 463 } |
491 | 464 |
492 if(get_utf8(&s->gb) < 0){ | 465 if (get_utf8(&s->gb) < 0) { |
493 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n"); | 466 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n"); |
494 return -1; | 467 return -1; |
495 } | 468 } |
496 | 469 |
497 if (blocksize_code == 0) | 470 if (blocksize_code == 0) |
501 else if (blocksize_code == 7) | 474 else if (blocksize_code == 7) |
502 blocksize = get_bits(&s->gb, 16)+1; | 475 blocksize = get_bits(&s->gb, 16)+1; |
503 else | 476 else |
504 blocksize = blocksize_table[blocksize_code]; | 477 blocksize = blocksize_table[blocksize_code]; |
505 | 478 |
506 if(blocksize > s->max_blocksize){ | 479 if (blocksize > s->max_blocksize) { |
507 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize); | 480 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize); |
508 return -1; | 481 return -1; |
509 } | 482 } |
510 | 483 |
511 if(blocksize * s->channels * sizeof(int16_t) > alloc_data_size) | 484 if (blocksize * s->channels * sizeof(int16_t) > alloc_data_size) |
512 return -1; | 485 return -1; |
513 | 486 |
514 if (sample_rate_code == 0){ | 487 if (sample_rate_code == 0) |
515 samplerate= s->samplerate; | 488 samplerate= s->samplerate; |
516 }else if (sample_rate_code < 12) | 489 else if (sample_rate_code < 12) |
517 samplerate = sample_rate_table[sample_rate_code]; | 490 samplerate = sample_rate_table[sample_rate_code]; |
518 else if (sample_rate_code == 12) | 491 else if (sample_rate_code == 12) |
519 samplerate = get_bits(&s->gb, 8) * 1000; | 492 samplerate = get_bits(&s->gb, 8) * 1000; |
520 else if (sample_rate_code == 13) | 493 else if (sample_rate_code == 13) |
521 samplerate = get_bits(&s->gb, 16); | 494 samplerate = get_bits(&s->gb, 16); |
522 else if (sample_rate_code == 14) | 495 else if (sample_rate_code == 14) |
523 samplerate = get_bits(&s->gb, 16) * 10; | 496 samplerate = get_bits(&s->gb, 16) * 10; |
524 else{ | 497 else { |
525 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code); | 498 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code); |
526 return -1; | 499 return -1; |
527 } | 500 } |
528 | 501 |
529 skip_bits(&s->gb, 8); | 502 skip_bits(&s->gb, 8); |
530 crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, | 503 crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, |
531 s->gb.buffer, get_bits_count(&s->gb)/8); | 504 s->gb.buffer, get_bits_count(&s->gb)/8); |
532 if(crc8){ | 505 if (crc8) { |
533 av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8); | 506 av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8); |
534 return -1; | 507 return -1; |
535 } | 508 } |
536 | 509 |
537 s->blocksize = blocksize; | 510 s->blocksize = blocksize; |
540 s->decorrelation= decorrelation; | 513 s->decorrelation= decorrelation; |
541 | 514 |
542 // dump_headers(s->avctx, (FLACStreaminfo *)s); | 515 // dump_headers(s->avctx, (FLACStreaminfo *)s); |
543 | 516 |
544 /* subframes */ | 517 /* subframes */ |
545 for (i = 0; i < s->channels; i++) | 518 for (i = 0; i < s->channels; i++) { |
546 { | |
547 if (decode_subframe(s, i) < 0) | 519 if (decode_subframe(s, i) < 0) |
548 return -1; | 520 return -1; |
549 } | 521 } |
550 | 522 |
551 align_get_bits(&s->gb); | 523 align_get_bits(&s->gb); |
565 int16_t *samples = data; | 537 int16_t *samples = data; |
566 int alloc_data_size= *data_size; | 538 int alloc_data_size= *data_size; |
567 | 539 |
568 *data_size=0; | 540 *data_size=0; |
569 | 541 |
570 if(s->max_framesize == 0){ | 542 if (s->max_framesize == 0) { |
571 s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header | 543 s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header |
572 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize); | 544 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize); |
573 } | 545 } |
574 | 546 |
575 if(1 && s->max_framesize){//FIXME truncated | 547 if (1 && s->max_framesize) { //FIXME truncated |
576 if(s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C')) | 548 if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C')) |
577 buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize)); | 549 buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize)); |
578 input_buf_size= buf_size; | 550 input_buf_size= buf_size; |
579 | 551 |
580 if(s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index) | 552 if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index) |
581 return -1; | 553 return -1; |
582 | 554 |
583 if(s->allocated_bitstream_size < s->bitstream_size + buf_size) | 555 if (s->allocated_bitstream_size < s->bitstream_size + buf_size) |
584 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size); | 556 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size); |
585 | 557 |
586 if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){ | 558 if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) { |
587 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size); | 559 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size); |
588 s->bitstream_index=0; | 560 s->bitstream_index=0; |
589 } | 561 } |
590 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size); | 562 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size); |
591 buf= &s->bitstream[s->bitstream_index]; | 563 buf= &s->bitstream[s->bitstream_index]; |
592 buf_size += s->bitstream_size; | 564 buf_size += s->bitstream_size; |
593 s->bitstream_size= buf_size; | 565 s->bitstream_size= buf_size; |
594 | 566 |
595 if(buf_size < s->max_framesize && input_buf_size){ | 567 if (buf_size < s->max_framesize && input_buf_size) { |
596 return input_buf_size; | 568 return input_buf_size; |
597 } | 569 } |
598 } | 570 } |
599 | 571 |
600 init_get_bits(&s->gb, buf, buf_size*8); | 572 init_get_bits(&s->gb, buf, buf_size*8); |
601 | 573 |
602 if(metadata_parse(s)) | 574 if (metadata_parse(s)) |
603 goto end; | 575 goto end; |
604 | 576 |
605 tmp = show_bits(&s->gb, 16); | 577 tmp = show_bits(&s->gb, 16); |
606 if((tmp & 0xFFFE) != 0xFFF8){ | 578 if ((tmp & 0xFFFE) != 0xFFF8) { |
607 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n"); | 579 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n"); |
608 while(get_bits_count(&s->gb)/8+2 < buf_size && (show_bits(&s->gb, 16) & 0xFFFE) != 0xFFF8) | 580 while (get_bits_count(&s->gb)/8+2 < buf_size && (show_bits(&s->gb, 16) & 0xFFFE) != 0xFFF8) |
609 skip_bits(&s->gb, 8); | 581 skip_bits(&s->gb, 8); |
610 goto end; // we may not have enough bits left to decode a frame, so try next time | 582 goto end; // we may not have enough bits left to decode a frame, so try next time |
611 } | 583 } |
612 skip_bits(&s->gb, 16); | 584 skip_bits(&s->gb, 16); |
613 if (decode_frame(s, alloc_data_size) < 0){ | 585 if (decode_frame(s, alloc_data_size) < 0) { |
614 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n"); | 586 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n"); |
615 s->bitstream_size=0; | 587 s->bitstream_size=0; |
616 s->bitstream_index=0; | 588 s->bitstream_index=0; |
617 return -1; | 589 return -1; |
618 } | 590 } |
619 | 591 |
620 #define DECORRELATE(left, right)\ | 592 #define DECORRELATE(left, right)\ |
621 assert(s->channels == 2);\ | 593 assert(s->channels == 2);\ |
622 for (i = 0; i < s->blocksize; i++)\ | 594 for (i = 0; i < s->blocksize; i++) {\ |
623 {\ | |
624 int a= s->decoded[0][i];\ | 595 int a= s->decoded[0][i];\ |
625 int b= s->decoded[1][i];\ | 596 int b= s->decoded[1][i];\ |
626 *samples++ = ((left) << (24 - s->bps)) >> 8;\ | 597 *samples++ = ((left) << (24 - s->bps)) >> 8;\ |
627 *samples++ = ((right) << (24 - s->bps)) >> 8;\ | 598 *samples++ = ((right) << (24 - s->bps)) >> 8;\ |
628 }\ | 599 }\ |
629 break; | 600 break; |
630 | 601 |
631 switch(s->decorrelation) | 602 switch (s->decorrelation) { |
632 { | 603 case INDEPENDENT: |
633 case INDEPENDENT: | 604 for (j = 0; j < s->blocksize; j++) { |
634 for (j = 0; j < s->blocksize; j++) | 605 for (i = 0; i < s->channels; i++) |
635 { | 606 *samples++ = (s->decoded[i][j] << (24 - s->bps)) >> 8; |
636 for (i = 0; i < s->channels; i++) | 607 } |
637 *samples++ = (s->decoded[i][j] << (24 - s->bps)) >> 8; | 608 break; |
638 } | 609 case LEFT_SIDE: |
639 break; | 610 DECORRELATE(a,a-b) |
640 case LEFT_SIDE: | 611 case RIGHT_SIDE: |
641 DECORRELATE(a,a-b) | 612 DECORRELATE(a+b,b) |
642 case RIGHT_SIDE: | 613 case MID_SIDE: |
643 DECORRELATE(a+b,b) | 614 DECORRELATE( (a-=b>>1) + b, a) |
644 case MID_SIDE: | |
645 DECORRELATE( (a-=b>>1) + b, a) | |
646 } | 615 } |
647 | 616 |
648 *data_size = (int8_t *)samples - (int8_t *)data; | 617 *data_size = (int8_t *)samples - (int8_t *)data; |
649 | 618 |
650 end: | 619 end: |
651 i= (get_bits_count(&s->gb)+7)/8; | 620 i= (get_bits_count(&s->gb)+7)/8; |
652 if(i > buf_size){ | 621 if (i > buf_size) { |
653 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size); | 622 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size); |
654 s->bitstream_size=0; | 623 s->bitstream_size=0; |
655 s->bitstream_index=0; | 624 s->bitstream_index=0; |
656 return -1; | 625 return -1; |
657 } | 626 } |
658 | 627 |
659 if(s->bitstream_size){ | 628 if (s->bitstream_size) { |
660 s->bitstream_index += i; | 629 s->bitstream_index += i; |
661 s->bitstream_size -= i; | 630 s->bitstream_size -= i; |
662 return input_buf_size; | 631 return input_buf_size; |
663 }else | 632 } else |
664 return i; | 633 return i; |
665 } | 634 } |
666 | 635 |
667 static av_cold int flac_decode_close(AVCodecContext *avctx) | 636 static av_cold int flac_decode_close(AVCodecContext *avctx) |
668 { | 637 { |
669 FLACContext *s = avctx->priv_data; | 638 FLACContext *s = avctx->priv_data; |
670 int i; | 639 int i; |
671 | 640 |
672 for (i = 0; i < s->channels; i++) | 641 for (i = 0; i < s->channels; i++) { |
673 { | |
674 av_freep(&s->decoded[i]); | 642 av_freep(&s->decoded[i]); |
675 } | 643 } |
676 av_freep(&s->bitstream); | 644 av_freep(&s->bitstream); |
677 | 645 |
678 return 0; | 646 return 0; |
679 } | 647 } |
680 | 648 |
681 static void flac_flush(AVCodecContext *avctx){ | 649 static void flac_flush(AVCodecContext *avctx) |
650 { | |
682 FLACContext *s = avctx->priv_data; | 651 FLACContext *s = avctx->priv_data; |
683 | 652 |
684 s->bitstream_size= | 653 s->bitstream_size= |
685 s->bitstream_index= 0; | 654 s->bitstream_index= 0; |
686 } | 655 } |