Mercurial > libavcodec.hg
comparison aacsbr.c @ 11833:9103a9b3573a libavcodec
aacdec: Rename avccontext to avctx.
author | alexc |
---|---|
date | Sat, 05 Jun 2010 15:22:19 +0000 |
parents | ed3d232c9d31 |
children | 67206bbbab10 |
comparison
equal
deleted
inserted
replaced
11832:e522dbf60abd | 11833:9103a9b3573a |
---|---|
291 previous = present; | 291 previous = present; |
292 } | 292 } |
293 bands[num_bands-1] = stop - previous; | 293 bands[num_bands-1] = stop - previous; |
294 } | 294 } |
295 | 295 |
296 static int check_n_master(AVCodecContext *avccontext, int n_master, int bs_xover_band) | 296 static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band) |
297 { | 297 { |
298 // Requirements (14496-3 sp04 p205) | 298 // Requirements (14496-3 sp04 p205) |
299 if (n_master <= 0) { | 299 if (n_master <= 0) { |
300 av_log(avccontext, AV_LOG_ERROR, "Invalid n_master: %d\n", n_master); | 300 av_log(avctx, AV_LOG_ERROR, "Invalid n_master: %d\n", n_master); |
301 return -1; | 301 return -1; |
302 } | 302 } |
303 if (bs_xover_band >= n_master) { | 303 if (bs_xover_band >= n_master) { |
304 av_log(avccontext, AV_LOG_ERROR, | 304 av_log(avctx, AV_LOG_ERROR, |
305 "Invalid bitstream, crossover band index beyond array bounds: %d\n", | 305 "Invalid bitstream, crossover band index beyond array bounds: %d\n", |
306 bs_xover_band); | 306 bs_xover_band); |
307 return -1; | 307 return -1; |
308 } | 308 } |
309 return 0; | 309 return 0; |
347 break; | 347 break; |
348 case 88200: case 96000: case 128000: case 176400: case 192000: | 348 case 88200: case 96000: case 128000: case 176400: case 192000: |
349 sbr_offset_ptr = sbr_offset[5]; | 349 sbr_offset_ptr = sbr_offset[5]; |
350 break; | 350 break; |
351 default: | 351 default: |
352 av_log(ac->avccontext, AV_LOG_ERROR, | 352 av_log(ac->avctx, AV_LOG_ERROR, |
353 "Unsupported sample rate for SBR: %d\n", sbr->sample_rate); | 353 "Unsupported sample rate for SBR: %d\n", sbr->sample_rate); |
354 return -1; | 354 return -1; |
355 } | 355 } |
356 | 356 |
357 sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq]; | 357 sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq]; |
365 } else if (spectrum->bs_stop_freq == 14) { | 365 } else if (spectrum->bs_stop_freq == 14) { |
366 sbr->k[2] = 2*sbr->k[0]; | 366 sbr->k[2] = 2*sbr->k[0]; |
367 } else if (spectrum->bs_stop_freq == 15) { | 367 } else if (spectrum->bs_stop_freq == 15) { |
368 sbr->k[2] = 3*sbr->k[0]; | 368 sbr->k[2] = 3*sbr->k[0]; |
369 } else { | 369 } else { |
370 av_log(ac->avccontext, AV_LOG_ERROR, | 370 av_log(ac->avctx, AV_LOG_ERROR, |
371 "Invalid bs_stop_freq: %d\n", spectrum->bs_stop_freq); | 371 "Invalid bs_stop_freq: %d\n", spectrum->bs_stop_freq); |
372 return -1; | 372 return -1; |
373 } | 373 } |
374 sbr->k[2] = FFMIN(64, sbr->k[2]); | 374 sbr->k[2] = FFMIN(64, sbr->k[2]); |
375 | 375 |
380 max_qmf_subbands = 35; | 380 max_qmf_subbands = 35; |
381 } else if (sbr->sample_rate >= 48000) | 381 } else if (sbr->sample_rate >= 48000) |
382 max_qmf_subbands = 32; | 382 max_qmf_subbands = 32; |
383 | 383 |
384 if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) { | 384 if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) { |
385 av_log(ac->avccontext, AV_LOG_ERROR, | 385 av_log(ac->avctx, AV_LOG_ERROR, |
386 "Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]); | 386 "Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]); |
387 return -1; | 387 return -1; |
388 } | 388 } |
389 | 389 |
390 if (!spectrum->bs_freq_scale) { | 390 if (!spectrum->bs_freq_scale) { |
391 unsigned int dk; | 391 unsigned int dk; |
392 int k2diff; | 392 int k2diff; |
393 | 393 |
394 dk = spectrum->bs_alter_scale + 1; | 394 dk = spectrum->bs_alter_scale + 1; |
395 sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1; | 395 sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1; |
396 if (check_n_master(ac->avccontext, sbr->n_master, sbr->spectrum_params.bs_xover_band)) | 396 if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band)) |
397 return -1; | 397 return -1; |
398 | 398 |
399 for (k = 1; k <= sbr->n_master; k++) | 399 for (k = 1; k <= sbr->n_master; k++) |
400 sbr->f_master[k] = dk; | 400 sbr->f_master[k] = dk; |
401 | 401 |
426 } | 426 } |
427 | 427 |
428 num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2; | 428 num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2; |
429 | 429 |
430 if (num_bands_0 <= 0) { // Requirements (14496-3 sp04 p205) | 430 if (num_bands_0 <= 0) { // Requirements (14496-3 sp04 p205) |
431 av_log(ac->avccontext, AV_LOG_ERROR, "Invalid num_bands_0: %d\n", num_bands_0); | 431 av_log(ac->avctx, AV_LOG_ERROR, "Invalid num_bands_0: %d\n", num_bands_0); |
432 return -1; | 432 return -1; |
433 } | 433 } |
434 | 434 |
435 vk0[0] = 0; | 435 vk0[0] = 0; |
436 | 436 |
440 vdk0_max = vk0[num_bands_0]; | 440 vdk0_max = vk0[num_bands_0]; |
441 | 441 |
442 vk0[0] = sbr->k[0]; | 442 vk0[0] = sbr->k[0]; |
443 for (k = 1; k <= num_bands_0; k++) { | 443 for (k = 1; k <= num_bands_0; k++) { |
444 if (vk0[k] <= 0) { // Requirements (14496-3 sp04 p205) | 444 if (vk0[k] <= 0) { // Requirements (14496-3 sp04 p205) |
445 av_log(ac->avccontext, AV_LOG_ERROR, "Invalid vDk0[%d]: %d\n", k, vk0[k]); | 445 av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk0[%d]: %d\n", k, vk0[k]); |
446 return -1; | 446 return -1; |
447 } | 447 } |
448 vk0[k] += vk0[k-1]; | 448 vk0[k] += vk0[k-1]; |
449 } | 449 } |
450 | 450 |
470 qsort(vk1 + 1, num_bands_1, sizeof(vk1[1]), qsort_comparison_function_int16); | 470 qsort(vk1 + 1, num_bands_1, sizeof(vk1[1]), qsort_comparison_function_int16); |
471 | 471 |
472 vk1[0] = sbr->k[1]; | 472 vk1[0] = sbr->k[1]; |
473 for (k = 1; k <= num_bands_1; k++) { | 473 for (k = 1; k <= num_bands_1; k++) { |
474 if (vk1[k] <= 0) { // Requirements (14496-3 sp04 p205) | 474 if (vk1[k] <= 0) { // Requirements (14496-3 sp04 p205) |
475 av_log(ac->avccontext, AV_LOG_ERROR, "Invalid vDk1[%d]: %d\n", k, vk1[k]); | 475 av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk1[%d]: %d\n", k, vk1[k]); |
476 return -1; | 476 return -1; |
477 } | 477 } |
478 vk1[k] += vk1[k-1]; | 478 vk1[k] += vk1[k-1]; |
479 } | 479 } |
480 | 480 |
481 sbr->n_master = num_bands_0 + num_bands_1; | 481 sbr->n_master = num_bands_0 + num_bands_1; |
482 if (check_n_master(ac->avccontext, sbr->n_master, sbr->spectrum_params.bs_xover_band)) | 482 if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band)) |
483 return -1; | 483 return -1; |
484 memcpy(&sbr->f_master[0], vk0, | 484 memcpy(&sbr->f_master[0], vk0, |
485 (num_bands_0 + 1) * sizeof(sbr->f_master[0])); | 485 (num_bands_0 + 1) * sizeof(sbr->f_master[0])); |
486 memcpy(&sbr->f_master[num_bands_0 + 1], vk1 + 1, | 486 memcpy(&sbr->f_master[num_bands_0 + 1], vk1 + 1, |
487 num_bands_1 * sizeof(sbr->f_master[0])); | 487 num_bands_1 * sizeof(sbr->f_master[0])); |
488 | 488 |
489 } else { | 489 } else { |
490 sbr->n_master = num_bands_0; | 490 sbr->n_master = num_bands_0; |
491 if (check_n_master(ac->avccontext, sbr->n_master, sbr->spectrum_params.bs_xover_band)) | 491 if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band)) |
492 return -1; | 492 return -1; |
493 memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0])); | 493 memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0])); |
494 } | 494 } |
495 } | 495 } |
496 | 496 |
522 // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5. | 522 // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5. |
523 // After this check the final number of patches can still be six which is | 523 // After this check the final number of patches can still be six which is |
524 // illegal however the Coding Technologies decoder check stream has a final | 524 // illegal however the Coding Technologies decoder check stream has a final |
525 // count of 6 patches | 525 // count of 6 patches |
526 if (sbr->num_patches > 5) { | 526 if (sbr->num_patches > 5) { |
527 av_log(ac->avccontext, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches); | 527 av_log(ac->avctx, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches); |
528 return -1; | 528 return -1; |
529 } | 529 } |
530 | 530 |
531 sbr->patch_num_subbands[sbr->num_patches] = FFMAX(sb - usb, 0); | 531 sbr->patch_num_subbands[sbr->num_patches] = FFMAX(sb - usb, 0); |
532 sbr->patch_start_subband[sbr->num_patches] = sbr->k[0] - odd - sbr->patch_num_subbands[sbr->num_patches]; | 532 sbr->patch_start_subband[sbr->num_patches] = sbr->k[0] - odd - sbr->patch_num_subbands[sbr->num_patches]; |
561 sbr->m[1] = sbr->f_tablehigh[sbr->n[1]] - sbr->f_tablehigh[0]; | 561 sbr->m[1] = sbr->f_tablehigh[sbr->n[1]] - sbr->f_tablehigh[0]; |
562 sbr->kx[1] = sbr->f_tablehigh[0]; | 562 sbr->kx[1] = sbr->f_tablehigh[0]; |
563 | 563 |
564 // Requirements (14496-3 sp04 p205) | 564 // Requirements (14496-3 sp04 p205) |
565 if (sbr->kx[1] + sbr->m[1] > 64) { | 565 if (sbr->kx[1] + sbr->m[1] > 64) { |
566 av_log(ac->avccontext, AV_LOG_ERROR, | 566 av_log(ac->avctx, AV_LOG_ERROR, |
567 "Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]); | 567 "Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]); |
568 return -1; | 568 return -1; |
569 } | 569 } |
570 if (sbr->kx[1] > 32) { | 570 if (sbr->kx[1] > 32) { |
571 av_log(ac->avccontext, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]); | 571 av_log(ac->avctx, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]); |
572 return -1; | 572 return -1; |
573 } | 573 } |
574 | 574 |
575 sbr->f_tablelow[0] = sbr->f_tablehigh[0]; | 575 sbr->f_tablelow[0] = sbr->f_tablehigh[0]; |
576 temp = sbr->n[1] & 1; | 576 temp = sbr->n[1] & 1; |
578 sbr->f_tablelow[k] = sbr->f_tablehigh[2 * k - temp]; | 578 sbr->f_tablelow[k] = sbr->f_tablehigh[2 * k - temp]; |
579 | 579 |
580 sbr->n_q = FFMAX(1, lrintf(sbr->spectrum_params.bs_noise_bands * | 580 sbr->n_q = FFMAX(1, lrintf(sbr->spectrum_params.bs_noise_bands * |
581 log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3 | 581 log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3 |
582 if (sbr->n_q > 5) { | 582 if (sbr->n_q > 5) { |
583 av_log(ac->avccontext, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q); | 583 av_log(ac->avctx, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q); |
584 return -1; | 584 return -1; |
585 } | 585 } |
586 | 586 |
587 sbr->f_tablenoise[0] = sbr->f_tablelow[0]; | 587 sbr->f_tablenoise[0] = sbr->f_tablelow[0]; |
588 temp = 0; | 588 temp = 0; |
636 num_rel_lead = ch_data->bs_num_env - 1; | 636 num_rel_lead = ch_data->bs_num_env - 1; |
637 if (ch_data->bs_num_env == 1) | 637 if (ch_data->bs_num_env == 1) |
638 ch_data->bs_amp_res = 0; | 638 ch_data->bs_amp_res = 0; |
639 | 639 |
640 if (ch_data->bs_num_env > 4) { | 640 if (ch_data->bs_num_env > 4) { |
641 av_log(ac->avccontext, AV_LOG_ERROR, | 641 av_log(ac->avctx, AV_LOG_ERROR, |
642 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n", | 642 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n", |
643 ch_data->bs_num_env); | 643 ch_data->bs_num_env); |
644 return -1; | 644 return -1; |
645 } | 645 } |
646 | 646 |
691 num_rel_lead = get_bits(gb, 2); | 691 num_rel_lead = get_bits(gb, 2); |
692 num_rel_trail = get_bits(gb, 2); | 692 num_rel_trail = get_bits(gb, 2); |
693 ch_data->bs_num_env = num_rel_lead + num_rel_trail + 1; | 693 ch_data->bs_num_env = num_rel_lead + num_rel_trail + 1; |
694 | 694 |
695 if (ch_data->bs_num_env > 5) { | 695 if (ch_data->bs_num_env > 5) { |
696 av_log(ac->avccontext, AV_LOG_ERROR, | 696 av_log(ac->avctx, AV_LOG_ERROR, |
697 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n", | 697 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n", |
698 ch_data->bs_num_env); | 698 ch_data->bs_num_env); |
699 return -1; | 699 return -1; |
700 } | 700 } |
701 | 701 |
712 get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env); | 712 get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env); |
713 break; | 713 break; |
714 } | 714 } |
715 | 715 |
716 if (bs_pointer > ch_data->bs_num_env + 1) { | 716 if (bs_pointer > ch_data->bs_num_env + 1) { |
717 av_log(ac->avccontext, AV_LOG_ERROR, | 717 av_log(ac->avctx, AV_LOG_ERROR, |
718 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n", | 718 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n", |
719 bs_pointer); | 719 bs_pointer); |
720 return -1; | 720 return -1; |
721 } | 721 } |
722 | 722 |
723 for (i = 1; i <= ch_data->bs_num_env; i++) { | 723 for (i = 1; i <= ch_data->bs_num_env; i++) { |
724 if (ch_data->t_env[i-1] > ch_data->t_env[i]) { | 724 if (ch_data->t_env[i-1] > ch_data->t_env[i]) { |
725 av_log(ac->avccontext, AV_LOG_ERROR, "Non monotone time borders\n"); | 725 av_log(ac->avctx, AV_LOG_ERROR, "Non monotone time borders\n"); |
726 return -1; | 726 return -1; |
727 } | 727 } |
728 } | 728 } |
729 | 729 |
730 ch_data->bs_num_noise = (ch_data->bs_num_env > 1) + 1; | 730 ch_data->bs_num_noise = (ch_data->bs_num_env > 1) + 1; |
905 { | 905 { |
906 //TODO - implement ps_data for parametric stereo parsing | 906 //TODO - implement ps_data for parametric stereo parsing |
907 switch (bs_extension_id) { | 907 switch (bs_extension_id) { |
908 case EXTENSION_ID_PS: | 908 case EXTENSION_ID_PS: |
909 if (!ac->m4ac.ps) { | 909 if (!ac->m4ac.ps) { |
910 av_log(ac->avccontext, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n"); | 910 av_log(ac->avctx, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n"); |
911 skip_bits_long(gb, *num_bits_left); // bs_fill_bits | 911 skip_bits_long(gb, *num_bits_left); // bs_fill_bits |
912 *num_bits_left = 0; | 912 *num_bits_left = 0; |
913 } else { | 913 } else { |
914 #if 0 | 914 #if 0 |
915 *num_bits_left -= ff_ps_data(gb, ps); | 915 *num_bits_left -= ff_ps_data(gb, ps); |
916 #else | 916 #else |
917 av_log_missing_feature(ac->avccontext, "Parametric Stereo is", 0); | 917 av_log_missing_feature(ac->avctx, "Parametric Stereo is", 0); |
918 skip_bits_long(gb, *num_bits_left); // bs_fill_bits | 918 skip_bits_long(gb, *num_bits_left); // bs_fill_bits |
919 *num_bits_left = 0; | 919 *num_bits_left = 0; |
920 #endif | 920 #endif |
921 } | 921 } |
922 break; | 922 break; |
923 default: | 923 default: |
924 av_log_missing_feature(ac->avccontext, "Reserved SBR extensions are", 1); | 924 av_log_missing_feature(ac->avctx, "Reserved SBR extensions are", 1); |
925 skip_bits_long(gb, *num_bits_left); // bs_fill_bits | 925 skip_bits_long(gb, *num_bits_left); // bs_fill_bits |
926 *num_bits_left = 0; | 926 *num_bits_left = 0; |
927 break; | 927 break; |
928 } | 928 } |
929 } | 929 } |
1004 if (read_sbr_channel_pair_element(ac, sbr, gb)) { | 1004 if (read_sbr_channel_pair_element(ac, sbr, gb)) { |
1005 sbr->start = 0; | 1005 sbr->start = 0; |
1006 return get_bits_count(gb) - cnt; | 1006 return get_bits_count(gb) - cnt; |
1007 } | 1007 } |
1008 } else { | 1008 } else { |
1009 av_log(ac->avccontext, AV_LOG_ERROR, | 1009 av_log(ac->avctx, AV_LOG_ERROR, |
1010 "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac); | 1010 "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac); |
1011 sbr->start = 0; | 1011 sbr->start = 0; |
1012 return get_bits_count(gb) - cnt; | 1012 return get_bits_count(gb) - cnt; |
1013 } | 1013 } |
1014 if (get_bits1(gb)) { // bs_extended_data | 1014 if (get_bits1(gb)) { // bs_extended_data |
1031 int err; | 1031 int err; |
1032 err = sbr_make_f_master(ac, sbr, &sbr->spectrum_params); | 1032 err = sbr_make_f_master(ac, sbr, &sbr->spectrum_params); |
1033 if (err >= 0) | 1033 if (err >= 0) |
1034 err = sbr_make_f_derived(ac, sbr); | 1034 err = sbr_make_f_derived(ac, sbr); |
1035 if (err < 0) { | 1035 if (err < 0) { |
1036 av_log(ac->avccontext, AV_LOG_ERROR, | 1036 av_log(ac->avctx, AV_LOG_ERROR, |
1037 "SBR reset failed. Switching SBR to pure upsampling mode.\n"); | 1037 "SBR reset failed. Switching SBR to pure upsampling mode.\n"); |
1038 sbr->start = 0; | 1038 sbr->start = 0; |
1039 } | 1039 } |
1040 } | 1040 } |
1041 | 1041 |
1083 | 1083 |
1084 num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7; | 1084 num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7; |
1085 bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3); | 1085 bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3); |
1086 | 1086 |
1087 if (bytes_read > cnt) { | 1087 if (bytes_read > cnt) { |
1088 av_log(ac->avccontext, AV_LOG_ERROR, | 1088 av_log(ac->avctx, AV_LOG_ERROR, |
1089 "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read); | 1089 "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read); |
1090 } | 1090 } |
1091 return cnt; | 1091 return cnt; |
1092 } | 1092 } |
1093 | 1093 |
1378 while (g <= sbr->n_q && k >= sbr->f_tablenoise[g]) | 1378 while (g <= sbr->n_q && k >= sbr->f_tablenoise[g]) |
1379 g++; | 1379 g++; |
1380 g--; | 1380 g--; |
1381 | 1381 |
1382 if (g < 0) { | 1382 if (g < 0) { |
1383 av_log(ac->avccontext, AV_LOG_ERROR, | 1383 av_log(ac->avctx, AV_LOG_ERROR, |
1384 "ERROR : no subband found for frequency %d\n", k); | 1384 "ERROR : no subband found for frequency %d\n", k); |
1385 return -1; | 1385 return -1; |
1386 } | 1386 } |
1387 | 1387 |
1388 alpha[0] = alpha1[p][0] * bw_array[g] * bw_array[g]; | 1388 alpha[0] = alpha1[p][0] * bw_array[g] * bw_array[g]; |