"Fossies" - the Fresh Open Source Software Archive

Member "ffmpeg-4.0.1/libavcodec/aacenc_pred.c" (13 Apr 2018, 12730 Bytes) of package /linux/misc/ffmpeg-4.0.1.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "aacenc_pred.c" see the Fossies "Dox" file reference documentation.

    1 /*
    2  * AAC encoder main-type prediction
    3  * Copyright (C) 2015 Rostislav Pehlivanov
    4  *
    5  * This file is part of FFmpeg.
    6  *
    7  * FFmpeg is free software; you can redistribute it and/or
    8  * modify it under the terms of the GNU Lesser General Public
    9  * License as published by the Free Software Foundation; either
   10  * version 2.1 of the License, or (at your option) any later version.
   11  *
   12  * FFmpeg is distributed in the hope that it will be useful,
   13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   15  * Lesser General Public License for more details.
   16  *
   17  * You should have received a copy of the GNU Lesser General Public
   18  * License along with FFmpeg; if not, write to the Free Software
   19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   20  */
   21 
   22 /**
   23  * @file
   24  * AAC encoder main-type prediction
   25  * @author Rostislav Pehlivanov ( atomnuker gmail com )
   26  */
   27 
   28 #include "aactab.h"
   29 #include "aacenc_pred.h"
   30 #include "aacenc_utils.h"
   31 #include "aacenc_is.h"            /* <- Needed for common window distortions */
   32 #include "aacenc_quantization.h"
   33 
   34 #define RESTORE_PRED(sce, sfb) \
   35         if (sce->ics.prediction_used[sfb]) {\
   36             sce->ics.prediction_used[sfb] = 0;\
   37             sce->band_type[sfb] = sce->band_alt[sfb];\
   38         }
   39 
   40 static inline float flt16_round(float pf)
   41 {
   42     union av_intfloat32 tmp;
   43     tmp.f = pf;
   44     tmp.i = (tmp.i + 0x00008000U) & 0xFFFF0000U;
   45     return tmp.f;
   46 }
   47 
   48 static inline float flt16_even(float pf)
   49 {
   50     union av_intfloat32 tmp;
   51     tmp.f = pf;
   52     tmp.i = (tmp.i + 0x00007FFFU + (tmp.i & 0x00010000U >> 16)) & 0xFFFF0000U;
   53     return tmp.f;
   54 }
   55 
   56 static inline float flt16_trunc(float pf)
   57 {
   58     union av_intfloat32 pun;
   59     pun.f = pf;
   60     pun.i &= 0xFFFF0000U;
   61     return pun.f;
   62 }
   63 
   64 static inline void predict(PredictorState *ps, float *coef, float *rcoef, int set)
   65 {
   66     float k2;
   67     const float a     = 0.953125; // 61.0 / 64
   68     const float alpha = 0.90625;  // 29.0 / 32
   69     const float   k1 = ps->k1;
   70     const float   r0 = ps->r0,     r1 = ps->r1;
   71     const float cor0 = ps->cor0, cor1 = ps->cor1;
   72     const float var0 = ps->var0, var1 = ps->var1;
   73     const float e0 = *coef - ps->x_est;
   74     const float e1 = e0 - k1 * r0;
   75 
   76     if (set)
   77         *coef = e0;
   78 
   79     ps->cor1 = flt16_trunc(alpha * cor1 + r1 * e1);
   80     ps->var1 = flt16_trunc(alpha * var1 + 0.5f * (r1 * r1 + e1 * e1));
   81     ps->cor0 = flt16_trunc(alpha * cor0 + r0 * e0);
   82     ps->var0 = flt16_trunc(alpha * var0 + 0.5f * (r0 * r0 + e0 * e0));
   83     ps->r1   = flt16_trunc(a * (r0 - k1 * e0));
   84     ps->r0   = flt16_trunc(a * e0);
   85 
   86     /* Prediction for next frame */
   87     ps->k1   = ps->var0 > 1 ? ps->cor0 * flt16_even(a / ps->var0) : 0;
   88     k2       = ps->var1 > 1 ? ps->cor1 * flt16_even(a / ps->var1) : 0;
   89     *rcoef   = ps->x_est = flt16_round(ps->k1*ps->r0 + k2*ps->r1);
   90 }
   91 
   92 static inline void reset_predict_state(PredictorState *ps)
   93 {
   94     ps->r0    = 0.0f;
   95     ps->r1    = 0.0f;
   96     ps->k1    = 0.0f;
   97     ps->cor0  = 0.0f;
   98     ps->cor1  = 0.0f;
   99     ps->var0  = 1.0f;
  100     ps->var1  = 1.0f;
  101     ps->x_est = 0.0f;
  102 }
  103 
  104 static inline void reset_all_predictors(PredictorState *ps)
  105 {
  106     int i;
  107     for (i = 0; i < MAX_PREDICTORS; i++)
  108         reset_predict_state(&ps[i]);
  109 }
  110 
  111 static inline void reset_predictor_group(SingleChannelElement *sce, int group_num)
  112 {
  113     int i;
  114     PredictorState *ps = sce->predictor_state;
  115     for (i = group_num - 1; i < MAX_PREDICTORS; i += 30)
  116         reset_predict_state(&ps[i]);
  117 }
  118 
  119 void ff_aac_apply_main_pred(AACEncContext *s, SingleChannelElement *sce)
  120 {
  121     int sfb, k;
  122     const int pmax = FFMIN(sce->ics.max_sfb, ff_aac_pred_sfb_max[s->samplerate_index]);
  123 
  124     if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
  125         for (sfb = 0; sfb < pmax; sfb++) {
  126             for (k = sce->ics.swb_offset[sfb]; k < sce->ics.swb_offset[sfb + 1]; k++) {
  127                 predict(&sce->predictor_state[k], &sce->coeffs[k], &sce->prcoeffs[k],
  128                         sce->ics.predictor_present && sce->ics.prediction_used[sfb]);
  129             }
  130         }
  131         if (sce->ics.predictor_reset_group) {
  132             reset_predictor_group(sce, sce->ics.predictor_reset_group);
  133         }
  134     } else {
  135         reset_all_predictors(sce->predictor_state);
  136     }
  137 }
  138 
  139 /* If inc = 0 you can check if this returns 0 to see if you can reset freely */
  140 static inline int update_counters(IndividualChannelStream *ics, int inc)
  141 {
  142     int i;
  143     for (i = 1; i < 31; i++) {
  144         ics->predictor_reset_count[i] += inc;
  145         if (ics->predictor_reset_count[i] > PRED_RESET_FRAME_MIN)
  146             return i; /* Reset this immediately */
  147     }
  148     return 0;
  149 }
  150 
  151 void ff_aac_adjust_common_pred(AACEncContext *s, ChannelElement *cpe)
  152 {
  153     int start, w, w2, g, i, count = 0;
  154     SingleChannelElement *sce0 = &cpe->ch[0];
  155     SingleChannelElement *sce1 = &cpe->ch[1];
  156     const int pmax0 = FFMIN(sce0->ics.max_sfb, ff_aac_pred_sfb_max[s->samplerate_index]);
  157     const int pmax1 = FFMIN(sce1->ics.max_sfb, ff_aac_pred_sfb_max[s->samplerate_index]);
  158     const int pmax  = FFMIN(pmax0, pmax1);
  159 
  160     if (!cpe->common_window ||
  161         sce0->ics.window_sequence[0] == EIGHT_SHORT_SEQUENCE ||
  162         sce1->ics.window_sequence[0] == EIGHT_SHORT_SEQUENCE)
  163         return;
  164 
  165     for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {
  166         start = 0;
  167         for (g = 0; g < sce0->ics.num_swb; g++) {
  168             int sfb = w*16+g;
  169             int sum = sce0->ics.prediction_used[sfb] + sce1->ics.prediction_used[sfb];
  170             float ener0 = 0.0f, ener1 = 0.0f, ener01 = 0.0f;
  171             struct AACISError ph_err1, ph_err2, *erf;
  172             if (sfb < PRED_SFB_START || sfb > pmax || sum != 2) {
  173                 RESTORE_PRED(sce0, sfb);
  174                 RESTORE_PRED(sce1, sfb);
  175                 start += sce0->ics.swb_sizes[g];
  176                 continue;
  177             }
  178             for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {
  179                 for (i = 0; i < sce0->ics.swb_sizes[g]; i++) {
  180                     float coef0 = sce0->pcoeffs[start+(w+w2)*128+i];
  181                     float coef1 = sce1->pcoeffs[start+(w+w2)*128+i];
  182                     ener0  += coef0*coef0;
  183                     ener1  += coef1*coef1;
  184                     ener01 += (coef0 + coef1)*(coef0 + coef1);
  185                 }
  186             }
  187             ph_err1 = ff_aac_is_encoding_err(s, cpe, start, w, g,
  188                                              ener0, ener1, ener01, 1, -1);
  189             ph_err2 = ff_aac_is_encoding_err(s, cpe, start, w, g,
  190                                              ener0, ener1, ener01, 1, +1);
  191             erf = ph_err1.error < ph_err2.error ? &ph_err1 : &ph_err2;
  192             if (erf->pass) {
  193                 sce0->ics.prediction_used[sfb] = 1;
  194                 sce1->ics.prediction_used[sfb] = 1;
  195                 count++;
  196             } else {
  197                 RESTORE_PRED(sce0, sfb);
  198                 RESTORE_PRED(sce1, sfb);
  199             }
  200             start += sce0->ics.swb_sizes[g];
  201         }
  202     }
  203 
  204     sce1->ics.predictor_present = sce0->ics.predictor_present = !!count;
  205 }
  206 
  207 static void update_pred_resets(SingleChannelElement *sce)
  208 {
  209     int i, max_group_id_c, max_frame = 0;
  210     float avg_frame = 0.0f;
  211     IndividualChannelStream *ics = &sce->ics;
  212 
  213     /* Update the counters and immediately update any frame behind schedule */
  214     if ((ics->predictor_reset_group = update_counters(&sce->ics, 1)))
  215         return;
  216 
  217     for (i = 1; i < 31; i++) {
  218         /* Count-based */
  219         if (ics->predictor_reset_count[i] > max_frame) {
  220             max_group_id_c = i;
  221             max_frame = ics->predictor_reset_count[i];
  222         }
  223         avg_frame = (ics->predictor_reset_count[i] + avg_frame)/2;
  224     }
  225 
  226     if (max_frame > PRED_RESET_MIN) {
  227         ics->predictor_reset_group = max_group_id_c;
  228     } else {
  229         ics->predictor_reset_group = 0;
  230     }
  231 }
  232 
  233 void ff_aac_search_for_pred(AACEncContext *s, SingleChannelElement *sce)
  234 {
  235     int sfb, i, count = 0, cost_coeffs = 0, cost_pred = 0;
  236     const int pmax = FFMIN(sce->ics.max_sfb, ff_aac_pred_sfb_max[s->samplerate_index]);
  237     float *O34  = &s->scoefs[128*0], *P34 = &s->scoefs[128*1];
  238     float *SENT = &s->scoefs[128*2], *S34 = &s->scoefs[128*3];
  239     float *QERR = &s->scoefs[128*4];
  240 
  241     if (sce->ics.window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
  242         sce->ics.predictor_present = 0;
  243         return;
  244     }
  245 
  246     if (!sce->ics.predictor_initialized) {
  247         reset_all_predictors(sce->predictor_state);
  248         sce->ics.predictor_initialized = 1;
  249         memcpy(sce->prcoeffs, sce->coeffs, 1024*sizeof(float));
  250         for (i = 1; i < 31; i++)
  251             sce->ics.predictor_reset_count[i] = i;
  252     }
  253 
  254     update_pred_resets(sce);
  255     memcpy(sce->band_alt, sce->band_type, sizeof(sce->band_type));
  256 
  257     for (sfb = PRED_SFB_START; sfb < pmax; sfb++) {
  258         int cost1, cost2, cb_p;
  259         float dist1, dist2, dist_spec_err = 0.0f;
  260         const int cb_n = sce->zeroes[sfb] ? 0 : sce->band_type[sfb];
  261         const int cb_min = sce->zeroes[sfb] ? 0 : 1;
  262         const int cb_max = sce->zeroes[sfb] ? 0 : RESERVED_BT;
  263         const int start_coef = sce->ics.swb_offset[sfb];
  264         const int num_coeffs = sce->ics.swb_offset[sfb + 1] - start_coef;
  265         const FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[sfb];
  266 
  267         if (start_coef + num_coeffs > MAX_PREDICTORS ||
  268             (s->cur_channel && sce->band_type[sfb] >= INTENSITY_BT2) ||
  269             sce->band_type[sfb] == NOISE_BT)
  270             continue;
  271 
  272         /* Normal coefficients */
  273         s->abs_pow34(O34, &sce->coeffs[start_coef], num_coeffs);
  274         dist1 = quantize_and_encode_band_cost(s, NULL, &sce->coeffs[start_coef], NULL,
  275                                               O34, num_coeffs, sce->sf_idx[sfb],
  276                                               cb_n, s->lambda / band->threshold, INFINITY, &cost1, NULL, 0);
  277         cost_coeffs += cost1;
  278 
  279         /* Encoded coefficients - needed for #bits, band type and quant. error */
  280         for (i = 0; i < num_coeffs; i++)
  281             SENT[i] = sce->coeffs[start_coef + i] - sce->prcoeffs[start_coef + i];
  282         s->abs_pow34(S34, SENT, num_coeffs);
  283         if (cb_n < RESERVED_BT)
  284             cb_p = av_clip(find_min_book(find_max_val(1, num_coeffs, S34), sce->sf_idx[sfb]), cb_min, cb_max);
  285         else
  286             cb_p = cb_n;
  287         quantize_and_encode_band_cost(s, NULL, SENT, QERR, S34, num_coeffs,
  288                                       sce->sf_idx[sfb], cb_p, s->lambda / band->threshold, INFINITY,
  289                                       &cost2, NULL, 0);
  290 
  291         /* Reconstructed coefficients - needed for distortion measurements */
  292         for (i = 0; i < num_coeffs; i++)
  293             sce->prcoeffs[start_coef + i] += QERR[i] != 0.0f ? (sce->prcoeffs[start_coef + i] - QERR[i]) : 0.0f;
  294         s->abs_pow34(P34, &sce->prcoeffs[start_coef], num_coeffs);
  295         if (cb_n < RESERVED_BT)
  296             cb_p = av_clip(find_min_book(find_max_val(1, num_coeffs, P34), sce->sf_idx[sfb]), cb_min, cb_max);
  297         else
  298             cb_p = cb_n;
  299         dist2 = quantize_and_encode_band_cost(s, NULL, &sce->prcoeffs[start_coef], NULL,
  300                                               P34, num_coeffs, sce->sf_idx[sfb],
  301                                               cb_p, s->lambda / band->threshold, INFINITY, NULL, NULL, 0);
  302         for (i = 0; i < num_coeffs; i++)
  303             dist_spec_err += (O34[i] - P34[i])*(O34[i] - P34[i]);
  304         dist_spec_err *= s->lambda / band->threshold;
  305         dist2 += dist_spec_err;
  306 
  307         if (dist2 <= dist1 && cb_p <= cb_n) {
  308             cost_pred += cost2;
  309             sce->ics.prediction_used[sfb] = 1;
  310             sce->band_alt[sfb]  = cb_n;
  311             sce->band_type[sfb] = cb_p;
  312             count++;
  313         } else {
  314             cost_pred += cost1;
  315             sce->band_alt[sfb] = cb_p;
  316         }
  317     }
  318 
  319     if (count && cost_coeffs < cost_pred) {
  320         count = 0;
  321         for (sfb = PRED_SFB_START; sfb < pmax; sfb++)
  322             RESTORE_PRED(sce, sfb);
  323         memset(&sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used));
  324     }
  325 
  326     sce->ics.predictor_present = !!count;
  327 }
  328 
  329 /**
  330  * Encoder predictors data.
  331  */
  332 void ff_aac_encode_main_pred(AACEncContext *s, SingleChannelElement *sce)
  333 {
  334     int sfb;
  335     IndividualChannelStream *ics = &sce->ics;
  336     const int pmax = FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[s->samplerate_index]);
  337 
  338     if (s->profile != FF_PROFILE_AAC_MAIN ||
  339         !ics->predictor_present)
  340         return;
  341 
  342     put_bits(&s->pb, 1, !!ics->predictor_reset_group);
  343     if (ics->predictor_reset_group)
  344         put_bits(&s->pb, 5, ics->predictor_reset_group);
  345     for (sfb = 0; sfb < pmax; sfb++)
  346         put_bits(&s->pb, 1, ics->prediction_used[sfb]);
  347 }