falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

aacdec: Rename avccontext to avctx. 

Originally committed as revision 23488 to svn://svn.ffmpeg.org/ffmpeg/trunk
tags/n0.8
Alex Converse 15 years ago
parent
4cd5100caf
commit
dd8871a63b
3 changed files with 86 additions and 86 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +58
    -58
      libavcodec/aac.c
  2. +1
    -1
      libavcodec/aac.h
  3. +27
    -27
      libavcodec/aacsbr.c

+ 58
- 58
libavcodec/aac.c View File

@@ -120,7 +120,7 @@ static ChannelElement *get_che(AACContext *ac, int type, int elem_id)
int err_printed = 0;
while (ac->tags_seen_this_frame[type][elem_id] && elem_id < MAX_ELEM_ID) {
if (ac->output_configured < OC_LOCKED && !err_printed) {
av_log(ac->avccontext, AV_LOG_WARNING, "Duplicate channel tag found, attempting to remap.\n");
av_log(ac->avctx, AV_LOG_WARNING, "Duplicate channel tag found, attempting to remap.\n");
err_printed = 1;
}
elem_id++;
@@ -225,7 +225,7 @@ static av_cold int output_configure(AACContext *ac,
enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
int channel_config, enum OCStatus oc_type)
{
AVCodecContext *avctx = ac->avccontext;
AVCodecContext *avctx = ac->avctx;
int i, type, channels = 0, ret;

memcpy(che_pos, new_che_pos, 4 * MAX_ELEM_ID * sizeof(new_che_pos[0][0]));
@@ -308,7 +308,7 @@ static int decode_pce(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_EL

sampling_index = get_bits(gb, 4);
if (ac->m4ac.sampling_index != sampling_index)
av_log(ac->avccontext, AV_LOG_WARNING, "Sample rate index in program config element does not match the sample rate index configured by the container.\n");
av_log(ac->avctx, AV_LOG_WARNING, "Sample rate index in program config element does not match the sample rate index configured by the container.\n");

num_front = get_bits(gb, 4);
num_side = get_bits(gb, 4);
@@ -339,7 +339,7 @@ static int decode_pce(AACContext *ac, enum ChannelPosition new_che_pos[4][MAX_EL
/* comment field, first byte is length */
comment_len = get_bits(gb, 8) * 8;
if (get_bits_left(gb) < comment_len) {
av_log(ac->avccontext, AV_LOG_ERROR, overread_err);
av_log(ac->avctx, AV_LOG_ERROR, overread_err);
return -1;
}
skip_bits_long(gb, comment_len);
@@ -359,7 +359,7 @@ static av_cold int set_default_channel_config(AACContext *ac,
int channel_config)
{
if (channel_config < 1 || channel_config > 7) {
av_log(ac->avccontext, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
av_log(ac->avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",
channel_config);
return -1;
}
@@ -404,7 +404,7 @@ static int decode_ga_specific_config(AACContext *ac, GetBitContext *gb,
int extension_flag, ret;

if (get_bits1(gb)) { // frameLengthFlag
av_log_missing_feature(ac->avccontext, "960/120 MDCT window is", 1);
av_log_missing_feature(ac->avctx, "960/120 MDCT window is", 1);
return -1;
}

@@ -468,7 +468,7 @@ static int decode_audio_specific_config(AACContext *ac, void *data,
if ((i = ff_mpeg4audio_get_config(&ac->m4ac, data, data_size)) < 0)
return -1;
if (ac->m4ac.sampling_index > 12) {
av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
return -1;
}

@@ -481,7 +481,7 @@ static int decode_audio_specific_config(AACContext *ac, void *data,
return -1;
break;
default:
av_log(ac->avccontext, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n",
av_log(ac->avctx, AV_LOG_ERROR, "Audio object type %s%d is not supported.\n",
ac->m4ac.sbr == 1? "SBR+" : "", ac->m4ac.object_type);
return -1;
}
@@ -524,20 +524,20 @@ static void reset_predictor_group(PredictorState *ps, int group_num)
reset_predict_state(&ps[i]);
}

static av_cold int aac_decode_init(AVCodecContext *avccontext)
static av_cold int aac_decode_init(AVCodecContext *avctx)
{
AACContext *ac = avccontext->priv_data;
AACContext *ac = avctx->priv_data;
int i;

ac->avccontext = avccontext;
ac->m4ac.sample_rate = avccontext->sample_rate;
ac->avctx = avctx;
ac->m4ac.sample_rate = avctx->sample_rate;

if (avccontext->extradata_size > 0) {
if (decode_audio_specific_config(ac, avccontext->extradata, avccontext->extradata_size))
if (avctx->extradata_size > 0) {
if (decode_audio_specific_config(ac, avctx->extradata, avctx->extradata_size))
return -1;
}

avccontext->sample_fmt = SAMPLE_FMT_S16;
avctx->sample_fmt = SAMPLE_FMT_S16;

AAC_INIT_VLC_STATIC( 0, 304);
AAC_INIT_VLC_STATIC( 1, 270);
@@ -553,7 +553,7 @@ static av_cold int aac_decode_init(AVCodecContext *avccontext)

ff_aac_sbr_init();

dsputil_init(&ac->dsp, avccontext);
dsputil_init(&ac->dsp, avctx);

ac->random_state = 0x1f2e3d4c;

@@ -607,7 +607,7 @@ static int skip_data_stream_element(AACContext *ac, GetBitContext *gb)
align_get_bits(gb);

if (get_bits_left(gb) < 8 * count) {
av_log(ac->avccontext, AV_LOG_ERROR, overread_err);
av_log(ac->avctx, AV_LOG_ERROR, overread_err);
return -1;
}
skip_bits_long(gb, 8 * count);
@@ -621,7 +621,7 @@ static int decode_prediction(AACContext *ac, IndividualChannelStream *ics,
if (get_bits1(gb)) {
ics->predictor_reset_group = get_bits(gb, 5);
if (ics->predictor_reset_group == 0 || ics->predictor_reset_group > 30) {
av_log(ac->avccontext, AV_LOG_ERROR, "Invalid Predictor Reset Group.\n");
av_log(ac->avctx, AV_LOG_ERROR, "Invalid Predictor Reset Group.\n");
return -1;
}
}
@@ -640,7 +640,7 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
GetBitContext *gb, int common_window)
{
if (get_bits1(gb)) {
av_log(ac->avccontext, AV_LOG_ERROR, "Reserved bit set.\n");
av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n");
memset(ics, 0, sizeof(IndividualChannelStream));
return -1;
}
@@ -681,11 +681,11 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
return -1;
}
} else if (ac->m4ac.object_type == AOT_AAC_LC) {
av_log(ac->avccontext, AV_LOG_ERROR, "Prediction is not allowed in AAC-LC.\n");
av_log(ac->avctx, AV_LOG_ERROR, "Prediction is not allowed in AAC-LC.\n");
memset(ics, 0, sizeof(IndividualChannelStream));
return -1;
} else {
av_log_missing_feature(ac->avccontext, "Predictor bit set but LTP is", 1);
av_log_missing_feature(ac->avctx, "Predictor bit set but LTP is", 1);
memset(ics, 0, sizeof(IndividualChannelStream));
return -1;
}
@@ -693,7 +693,7 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
}

if (ics->max_sfb > ics->num_swb) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Number of scalefactor bands in group (%d) exceeds limit (%d).\n",
ics->max_sfb, ics->num_swb);
memset(ics, 0, sizeof(IndividualChannelStream));
@@ -724,18 +724,18 @@ static int decode_band_types(AACContext *ac, enum BandType band_type[120],
int sect_len_incr;
int sect_band_type = get_bits(gb, 4);
if (sect_band_type == 12) {
av_log(ac->avccontext, AV_LOG_ERROR, "invalid band type\n");
av_log(ac->avctx, AV_LOG_ERROR, "invalid band type\n");
return -1;
}
while ((sect_len_incr = get_bits(gb, bits)) == (1 << bits) - 1)
sect_end += sect_len_incr;
sect_end += sect_len_incr;
if (get_bits_left(gb) < 0) {
av_log(ac->avccontext, AV_LOG_ERROR, overread_err);
av_log(ac->avctx, AV_LOG_ERROR, overread_err);
return -1;
}
if (sect_end > ics->max_sfb) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Number of bands (%d) exceeds limit (%d).\n",
sect_end, ics->max_sfb);
return -1;
@@ -780,7 +780,7 @@ static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb,
for (; i < run_end; i++, idx++) {
offset[2] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
if (offset[2] > 255U) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"%s (%d) out of range.\n", sf_str[2], offset[2]);
return -1;
}
@@ -793,7 +793,7 @@ static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb,
else
offset[1] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
if (offset[1] > 255U) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"%s (%d) out of range.\n", sf_str[1], offset[1]);
return -1;
}
@@ -803,7 +803,7 @@ static int decode_scalefactors(AACContext *ac, float sf[120], GetBitContext *gb,
for (; i < run_end; i++, idx++) {
offset[0] += get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60;
if (offset[0] > 255U) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"%s (%d) out of range.\n", sf_str[0], offset[0]);
return -1;
}
@@ -860,7 +860,7 @@ static int decode_tns(AACContext *ac, TemporalNoiseShaping *tns,
tns->length[w][filt] = get_bits(gb, 6 - 2 * is8);

if ((tns->order[w][filt] = get_bits(gb, 5 - 2 * is8)) > tns_max_order) {
av_log(ac->avccontext, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.\n",
av_log(ac->avctx, AV_LOG_ERROR, "TNS filter order %d is greater than maximum %d.\n",
tns->order[w][filt], tns_max_order);
tns->order[w][filt] = 0;
return -1;
@@ -1179,7 +1179,7 @@ static int decode_spectrum_and_dequant(AACContext *ac, float coef[1024],
b = 31 - av_log2(~b);

if (b > 8) {
av_log(ac->avccontext, AV_LOG_ERROR, "error in spectral data, ESC overflow\n");
av_log(ac->avctx, AV_LOG_ERROR, "error in spectral data, ESC overflow\n");
return -1;
}

@@ -1232,7 +1232,7 @@ static int decode_spectrum_and_dequant(AACContext *ac, float coef[1024],
return 0;

err_cb_overflow:
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Read beyond end of ff_aac_codebook_vectors[%d][]. index %d >= %d\n",
band_type[idx], err_idx, ff_aac_spectral_sizes[band_type[idx]]);
return -1;
@@ -1353,18 +1353,18 @@ static int decode_ics(AACContext *ac, SingleChannelElement *sce,
if (!scale_flag) {
if ((pulse_present = get_bits1(gb))) {
if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
av_log(ac->avccontext, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n");
av_log(ac->avctx, AV_LOG_ERROR, "Pulse tool not allowed in eight short sequence.\n");
return -1;
}
if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
av_log(ac->avccontext, AV_LOG_ERROR, "Pulse data corrupt or invalid.\n");
av_log(ac->avctx, AV_LOG_ERROR, "Pulse data corrupt or invalid.\n");
return -1;
}
}
if ((tns->present = get_bits1(gb)) && decode_tns(ac, tns, gb, ics))
return -1;
if (get_bits1(gb)) {
av_log_missing_feature(ac->avccontext, "SSR", 1);
av_log_missing_feature(ac->avctx, "SSR", 1);
return -1;
}
}
@@ -1464,7 +1464,7 @@ static int decode_cpe(AACContext *ac, GetBitContext *gb, ChannelElement *cpe)
cpe->ch[1].ics.use_kb_window[1] = i;
ms_present = get_bits(gb, 2);
if (ms_present == 3) {
av_log(ac->avccontext, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
av_log(ac->avctx, AV_LOG_ERROR, "ms_present = 3 is reserved.\n");
return -1;
} else if (ms_present)
decode_mid_side_stereo(cpe, gb, ms_present);
@@ -1651,14 +1651,14 @@ static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,
crc_flag++;
case EXT_SBR_DATA:
if (!che) {
av_log(ac->avccontext, AV_LOG_ERROR, "SBR was found before the first channel element.\n");
av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n");
return res;
} else if (!ac->m4ac.sbr) {
av_log(ac->avccontext, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n");
av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n");
skip_bits_long(gb, 8 * cnt - 4);
return res;
} else if (ac->m4ac.sbr == -1 && ac->output_configured == OC_LOCKED) {
av_log(ac->avccontext, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n");
av_log(ac->avctx, AV_LOG_ERROR, "Implicit SBR was found with a first occurrence after the first frame.\n");
skip_bits_long(gb, 8 * cnt - 4);
return res;
} else {
@@ -1744,7 +1744,7 @@ static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce, float
// imdct
if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
if (ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE)
av_log(ac->avccontext, AV_LOG_WARNING,
av_log(ac->avctx, AV_LOG_WARNING,
"Transition from an ONLY_LONG or LONG_STOP to an EIGHT_SHORT sequence detected. "
"If you heard an audible artifact, please submit the sample to the FFmpeg developers.\n");
for (i = 0; i < 1024; i += 128)
@@ -1810,7 +1810,7 @@ static void apply_dependent_coupling(AACContext *ac,
const float *src = cce->ch[0].coeffs;
int g, i, group, k, idx = 0;
if (ac->m4ac.object_type == AOT_AAC_LTP) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Dependent coupling is not supported together with LTP\n");
return;
}
@@ -1945,25 +1945,25 @@ static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)
ac->m4ac.sample_rate = hdr_info.sample_rate;
ac->m4ac.sampling_index = hdr_info.sampling_index;
ac->m4ac.object_type = hdr_info.object_type;
if (!ac->avccontext->sample_rate)
ac->avccontext->sample_rate = hdr_info.sample_rate;
if (!ac->avctx->sample_rate)
ac->avctx->sample_rate = hdr_info.sample_rate;
if (hdr_info.num_aac_frames == 1) {
if (!hdr_info.crc_absent)
skip_bits(gb, 16);
} else {
av_log_missing_feature(ac->avccontext, "More than one AAC RDB per ADTS frame is", 0);
av_log_missing_feature(ac->avctx, "More than one AAC RDB per ADTS frame is", 0);
return -1;
}
}
return size;
}

static int aac_decode_frame(AVCodecContext *avccontext, void *data,
static int aac_decode_frame(AVCodecContext *avctx, void *data,
int *data_size, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
AACContext *ac = avccontext->priv_data;
AACContext *ac = avctx->priv_data;
ChannelElement *che = NULL, *che_prev = NULL;
GetBitContext gb;
enum RawDataBlockType elem_type, elem_type_prev = TYPE_END;
@@ -1976,11 +1976,11 @@ static int aac_decode_frame(AVCodecContext *avccontext, void *data,

if (show_bits(&gb, 12) == 0xfff) {
if (parse_adts_frame_header(ac, &gb) < 0) {
av_log(avccontext, AV_LOG_ERROR, "Error decoding AAC frame header.\n");
av_log(avctx, AV_LOG_ERROR, "Error decoding AAC frame header.\n");
return -1;
}
if (ac->m4ac.sampling_index > 12) {
av_log(ac->avccontext, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
av_log(ac->avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", ac->m4ac.sampling_index);
return -1;
}
}
@@ -1991,7 +1991,7 @@ static int aac_decode_frame(AVCodecContext *avccontext, void *data,
elem_id = get_bits(&gb, 4);

if (elem_type < TYPE_DSE && !(che=get_che(ac, elem_type, elem_id))) {
av_log(ac->avccontext, AV_LOG_ERROR, "channel element %d.%d is not allocated\n", elem_type, elem_id);
av_log(ac->avctx, AV_LOG_ERROR, "channel element %d.%d is not allocated\n", elem_type, elem_id);
return -1;
}

@@ -2023,7 +2023,7 @@ static int aac_decode_frame(AVCodecContext *avccontext, void *data,
if ((err = decode_pce(ac, new_che_pos, &gb)))
break;
if (ac->output_configured > OC_TRIAL_PCE)
av_log(avccontext, AV_LOG_ERROR,
av_log(avctx, AV_LOG_ERROR,
"Not evaluating a further program_config_element as this construct is dubious at best.\n");
else
err = output_configure(ac, ac->che_pos, new_che_pos, 0, OC_TRIAL_PCE);
@@ -2034,7 +2034,7 @@ static int aac_decode_frame(AVCodecContext *avccontext, void *data,
if (elem_id == 15)
elem_id += get_bits(&gb, 8) - 1;
if (get_bits_left(&gb) < 8 * elem_id) {
av_log(avccontext, AV_LOG_ERROR, overread_err);
av_log(avctx, AV_LOG_ERROR, overread_err);
return -1;
}
while (elem_id > 0)
@@ -2054,7 +2054,7 @@ static int aac_decode_frame(AVCodecContext *avccontext, void *data,
return err;

if (get_bits_left(&gb) < 3) {
av_log(avccontext, AV_LOG_ERROR, overread_err);
av_log(avctx, AV_LOG_ERROR, overread_err);
return -1;
}
}
@@ -2064,20 +2064,20 @@ static int aac_decode_frame(AVCodecContext *avccontext, void *data,
multiplier = (ac->m4ac.sbr == 1) ? ac->m4ac.ext_sample_rate > ac->m4ac.sample_rate : 0;
samples <<= multiplier;
if (ac->output_configured < OC_LOCKED) {
avccontext->sample_rate = ac->m4ac.sample_rate << multiplier;
avccontext->frame_size = samples;
avctx->sample_rate = ac->m4ac.sample_rate << multiplier;
avctx->frame_size = samples;
}

data_size_tmp = samples * avccontext->channels * sizeof(int16_t);
data_size_tmp = samples * avctx->channels * sizeof(int16_t);
if (*data_size < data_size_tmp) {
av_log(avccontext, AV_LOG_ERROR,
av_log(avctx, AV_LOG_ERROR,
"Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",
*data_size, data_size_tmp);
return -1;
}
*data_size = data_size_tmp;

ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, samples, avccontext->channels);
ac->dsp.float_to_int16_interleave(data, (const float **)ac->output_data, samples, avctx->channels);

if (ac->output_configured)
ac->output_configured = OC_LOCKED;
@@ -2090,9 +2090,9 @@ static int aac_decode_frame(AVCodecContext *avccontext, void *data,
return buf_size > buf_offset ? buf_consumed : buf_size;
}

static av_cold int aac_decode_close(AVCodecContext *avccontext)
static av_cold int aac_decode_close(AVCodecContext *avctx)
{
AACContext *ac = avccontext->priv_data;
AACContext *ac = avctx->priv_data;
int i, type;

for (i = 0; i < MAX_ELEM_ID; i++) {


+ 1
- 1
libavcodec/aac.h View File

@@ -241,7 +241,7 @@ typedef struct {
* main AAC context
*/
typedef struct {
AVCodecContext * avccontext;
AVCodecContext * avctx;

MPEG4AudioConfig m4ac;



+ 27
- 27
libavcodec/aacsbr.c View File

@@ -293,15 +293,15 @@ static void make_bands(int16_t* bands, int start, int stop, int num_bands)
bands[num_bands-1] = stop - previous;
}

static int check_n_master(AVCodecContext *avccontext, int n_master, int bs_xover_band)
static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
{
// Requirements (14496-3 sp04 p205)
if (n_master <= 0) {
av_log(avccontext, AV_LOG_ERROR, "Invalid n_master: %d\n", n_master);
av_log(avctx, AV_LOG_ERROR, "Invalid n_master: %d\n", n_master);
return -1;
}
if (bs_xover_band >= n_master) {
av_log(avccontext, AV_LOG_ERROR,
av_log(avctx, AV_LOG_ERROR,
"Invalid bitstream, crossover band index beyond array bounds: %d\n",
bs_xover_band);
return -1;
@@ -349,7 +349,7 @@ static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
sbr_offset_ptr = sbr_offset[5];
break;
default:
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Unsupported sample rate for SBR: %d\n", sbr->sample_rate);
return -1;
}
@@ -367,7 +367,7 @@ static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
} else if (spectrum->bs_stop_freq == 15) {
sbr->k[2] = 3*sbr->k[0];
} else {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Invalid bs_stop_freq: %d\n", spectrum->bs_stop_freq);
return -1;
}
@@ -382,7 +382,7 @@ static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
max_qmf_subbands = 32;

if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]);
return -1;
}
@@ -393,7 +393,7 @@ static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,

dk = spectrum->bs_alter_scale + 1;
sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1;
if (check_n_master(ac->avccontext, sbr->n_master, sbr->spectrum_params.bs_xover_band))
if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band))
return -1;

for (k = 1; k <= sbr->n_master; k++)
@@ -428,7 +428,7 @@ static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2;

if (num_bands_0 <= 0) { // Requirements (14496-3 sp04 p205)
av_log(ac->avccontext, AV_LOG_ERROR, "Invalid num_bands_0: %d\n", num_bands_0);
av_log(ac->avctx, AV_LOG_ERROR, "Invalid num_bands_0: %d\n", num_bands_0);
return -1;
}

@@ -442,7 +442,7 @@ static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
vk0[0] = sbr->k[0];
for (k = 1; k <= num_bands_0; k++) {
if (vk0[k] <= 0) { // Requirements (14496-3 sp04 p205)
av_log(ac->avccontext, AV_LOG_ERROR, "Invalid vDk0[%d]: %d\n", k, vk0[k]);
av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk0[%d]: %d\n", k, vk0[k]);
return -1;
}
vk0[k] += vk0[k-1];
@@ -472,14 +472,14 @@ static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
vk1[0] = sbr->k[1];
for (k = 1; k <= num_bands_1; k++) {
if (vk1[k] <= 0) { // Requirements (14496-3 sp04 p205)
av_log(ac->avccontext, AV_LOG_ERROR, "Invalid vDk1[%d]: %d\n", k, vk1[k]);
av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk1[%d]: %d\n", k, vk1[k]);
return -1;
}
vk1[k] += vk1[k-1];
}

sbr->n_master = num_bands_0 + num_bands_1;
if (check_n_master(ac->avccontext, sbr->n_master, sbr->spectrum_params.bs_xover_band))
if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band))
return -1;
memcpy(&sbr->f_master[0], vk0,
(num_bands_0 + 1) * sizeof(sbr->f_master[0]));
@@ -488,7 +488,7 @@ static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,

} else {
sbr->n_master = num_bands_0;
if (check_n_master(ac->avccontext, sbr->n_master, sbr->spectrum_params.bs_xover_band))
if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band))
return -1;
memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
}
@@ -524,7 +524,7 @@ static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)
// illegal however the Coding Technologies decoder check stream has a final
// count of 6 patches
if (sbr->num_patches > 5) {
av_log(ac->avccontext, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches);
av_log(ac->avctx, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches);
return -1;
}

@@ -563,12 +563,12 @@ static int sbr_make_f_derived(AACContext *ac, SpectralBandReplication *sbr)

// Requirements (14496-3 sp04 p205)
if (sbr->kx[1] + sbr->m[1] > 64) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]);
return -1;
}
if (sbr->kx[1] > 32) {
av_log(ac->avccontext, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]);
av_log(ac->avctx, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]);
return -1;
}

@@ -580,7 +580,7 @@ static int sbr_make_f_derived(AACContext *ac, SpectralBandReplication *sbr)
sbr->n_q = FFMAX(1, lrintf(sbr->spectrum_params.bs_noise_bands *
log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3
if (sbr->n_q > 5) {
av_log(ac->avccontext, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q);
av_log(ac->avctx, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q);
return -1;
}

@@ -638,7 +638,7 @@ static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
ch_data->bs_amp_res = 0;

if (ch_data->bs_num_env > 4) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
ch_data->bs_num_env);
return -1;
@@ -693,7 +693,7 @@ static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
ch_data->bs_num_env = num_rel_lead + num_rel_trail + 1;

if (ch_data->bs_num_env > 5) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
ch_data->bs_num_env);
return -1;
@@ -714,7 +714,7 @@ static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
}

if (bs_pointer > ch_data->bs_num_env + 1) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
bs_pointer);
return -1;
@@ -722,7 +722,7 @@ static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,

for (i = 1; i <= ch_data->bs_num_env; i++) {
if (ch_data->t_env[i-1] > ch_data->t_env[i]) {
av_log(ac->avccontext, AV_LOG_ERROR, "Non monotone time borders\n");
av_log(ac->avctx, AV_LOG_ERROR, "Non monotone time borders\n");
return -1;
}
}
@@ -907,21 +907,21 @@ static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,
switch (bs_extension_id) {
case EXTENSION_ID_PS:
if (!ac->m4ac.ps) {
av_log(ac->avccontext, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
av_log(ac->avctx, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
skip_bits_long(gb, *num_bits_left); // bs_fill_bits
*num_bits_left = 0;
} else {
#if 0
*num_bits_left -= ff_ps_data(gb, ps);
#else
av_log_missing_feature(ac->avccontext, "Parametric Stereo is", 0);
av_log_missing_feature(ac->avctx, "Parametric Stereo is", 0);
skip_bits_long(gb, *num_bits_left); // bs_fill_bits
*num_bits_left = 0;
#endif
}
break;
default:
av_log_missing_feature(ac->avccontext, "Reserved SBR extensions are", 1);
av_log_missing_feature(ac->avctx, "Reserved SBR extensions are", 1);
skip_bits_long(gb, *num_bits_left); // bs_fill_bits
*num_bits_left = 0;
break;
@@ -1006,7 +1006,7 @@ static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr,
return get_bits_count(gb) - cnt;
}
} else {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
sbr->start = 0;
return get_bits_count(gb) - cnt;
@@ -1033,7 +1033,7 @@ static void sbr_reset(AACContext *ac, SpectralBandReplication *sbr)
if (err >= 0)
err = sbr_make_f_derived(ac, sbr);
if (err < 0) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"SBR reset failed. Switching SBR to pure upsampling mode.\n");
sbr->start = 0;
}
@@ -1085,7 +1085,7 @@ int ff_decode_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,
bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);

if (bytes_read > cnt) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
}
return cnt;
@@ -1380,7 +1380,7 @@ static int sbr_hf_gen(AACContext *ac, SpectralBandReplication *sbr,
g--;

if (g < 0) {
av_log(ac->avccontext, AV_LOG_ERROR,
av_log(ac->avctx, AV_LOG_ERROR,
"ERROR : no subband found for frequency %d\n", k);
return -1;
}


Write Preview
Loading…
Cancel
Save