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++;
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]));
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);
/* 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);
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;
}
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;
}
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;
}
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;
}
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);
ff_aac_sbr_init();
- dsputil_init(&ac->dsp, avccontext);
+ dsputil_init(&ac->dsp, avctx);
ac->random_state = 0x1f2e3d4c;
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);
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;
}
}
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;
}
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;
}
}
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));
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;
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;
}
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;
}
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;
}
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;
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;
}
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;
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;
}
}
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);
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 {
// 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)
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;
}
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;
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;
}
}
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;
}
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);
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)
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;
}
}
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;
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++) {
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;
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;
}
} 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;
}
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;
}
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++)
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;
}
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];
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]));
} 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]));
}
// 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;
}
// 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;
}
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;
}
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;
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;
}
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;
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;
}
}
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;
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;
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;
}
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;
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;
}