• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavcodec/aaccoder.c

Go to the documentation of this file.
00001 /*
00002  * AAC coefficients encoder
00003  * Copyright (C) 2008-2009 Konstantin Shishkov
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00027 /***********************************
00028  *              TODOs:
00029  * speedup quantizer selection
00030  * add sane pulse detection
00031  ***********************************/
00032 
00033 #include "avcodec.h"
00034 #include "put_bits.h"
00035 #include "aac.h"
00036 #include "aacenc.h"
00037 #include "aactab.h"
00038 
00040 static const uint8_t run_value_bits_long[64] = {
00041      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
00042      5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5, 10,
00043     10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
00044     10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 15
00045 };
00046 
00048 static const uint8_t run_value_bits_short[16] = {
00049     3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 9
00050 };
00051 
00052 static const uint8_t *run_value_bits[2] = {
00053     run_value_bits_long, run_value_bits_short
00054 };
00055 
00056 
00062 static av_always_inline int quant(float coef, const float Q)
00063 {
00064     float a = coef * Q;
00065     return sqrtf(a * sqrtf(a)) + 0.4054;
00066 }
00067 
00068 static void quantize_bands(int (*out)[2], const float *in, const float *scaled,
00069                            int size, float Q34, int is_signed, int maxval)
00070 {
00071     int i;
00072     double qc;
00073     for (i = 0; i < size; i++) {
00074         qc = scaled[i] * Q34;
00075         out[i][0] = (int)FFMIN(qc,          (double)maxval);
00076         out[i][1] = (int)FFMIN(qc + 0.4054, (double)maxval);
00077         if (is_signed && in[i] < 0.0f) {
00078             out[i][0] = -out[i][0];
00079             out[i][1] = -out[i][1];
00080         }
00081     }
00082 }
00083 
00084 static void abs_pow34_v(float *out, const float *in, const int size)
00085 {
00086 #ifndef USE_REALLY_FULL_SEARCH
00087     int i;
00088     for (i = 0; i < size; i++) {
00089         float a = fabsf(in[i]);
00090         out[i] = sqrtf(a * sqrtf(a));
00091     }
00092 #endif /* USE_REALLY_FULL_SEARCH */
00093 }
00094 
00095 static const uint8_t aac_cb_range [12] = {0, 3, 3, 3, 3, 9, 9, 8, 8, 13, 13, 17};
00096 static const uint8_t aac_cb_maxval[12] = {0, 1, 1, 2, 2, 4, 4, 7, 7, 12, 12, 16};
00097 
00103 static float quantize_and_encode_band_cost(struct AACEncContext *s,
00104                                 PutBitContext *pb, const float *in,
00105                                 const float *scaled, int size, int scale_idx,
00106                                 int cb, const float lambda, const float uplim,
00107                                 int *bits)
00108 {
00109     const float IQ = ff_aac_pow2sf_tab[200 + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
00110     const float  Q = ff_aac_pow2sf_tab[200 - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
00111     const float CLIPPED_ESCAPE = 165140.0f*IQ;
00112     int i, j, k;
00113     float cost = 0;
00114     const int dim = cb < FIRST_PAIR_BT ? 4 : 2;
00115     int resbits = 0;
00116 #ifndef USE_REALLY_FULL_SEARCH
00117     const float  Q34 = sqrtf(Q * sqrtf(Q));
00118     const int range  = aac_cb_range[cb];
00119     const int maxval = aac_cb_maxval[cb];
00120     int offs[4];
00121 #endif /* USE_REALLY_FULL_SEARCH */
00122 
00123     if (!cb) {
00124         for (i = 0; i < size; i++)
00125             cost += in[i]*in[i];
00126         if (bits)
00127             *bits = 0;
00128         return cost * lambda;
00129     }
00130 #ifndef USE_REALLY_FULL_SEARCH
00131     offs[0] = 1;
00132     for (i = 1; i < dim; i++)
00133         offs[i] = offs[i-1]*range;
00134     if (!scaled) {
00135         abs_pow34_v(s->scoefs, in, size);
00136         scaled = s->scoefs;
00137     }
00138     quantize_bands(s->qcoefs, in, scaled, size, Q34, !IS_CODEBOOK_UNSIGNED(cb), maxval);
00139 #endif /* USE_REALLY_FULL_SEARCH */
00140     for (i = 0; i < size; i += dim) {
00141         float mincost;
00142         int minidx  = 0;
00143         int minbits = 0;
00144         const float *vec;
00145 #ifndef USE_REALLY_FULL_SEARCH
00146         int (*quants)[2] = &s->qcoefs[i];
00147         mincost = 0.0f;
00148         for (j = 0; j < dim; j++)
00149             mincost += in[i+j]*in[i+j];
00150         minidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40;
00151         minbits = ff_aac_spectral_bits[cb-1][minidx];
00152         mincost = mincost * lambda + minbits;
00153         for (j = 0; j < (1<<dim); j++) {
00154             float rd = 0.0f;
00155             int curbits;
00156             int curidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40;
00157             int same   = 0;
00158             for (k = 0; k < dim; k++) {
00159                 if ((j & (1 << k)) && quants[k][0] == quants[k][1]) {
00160                     same = 1;
00161                     break;
00162                 }
00163             }
00164             if (same)
00165                 continue;
00166             for (k = 0; k < dim; k++)
00167                 curidx += quants[k][!!(j & (1 << k))] * offs[dim - 1 - k];
00168             curbits =  ff_aac_spectral_bits[cb-1][curidx];
00169             vec     = &ff_aac_codebook_vectors[cb-1][curidx*dim];
00170 #else
00171         mincost = INFINITY;
00172         vec = ff_aac_codebook_vectors[cb-1];
00173         for (j = 0; j < ff_aac_spectral_sizes[cb-1]; j++, vec += dim) {
00174             float rd = 0.0f;
00175             int curbits = ff_aac_spectral_bits[cb-1][j];
00176             int curidx = j;
00177 #endif /* USE_REALLY_FULL_SEARCH */
00178             if (IS_CODEBOOK_UNSIGNED(cb)) {
00179                 for (k = 0; k < dim; k++) {
00180                     float t = fabsf(in[i+k]);
00181                     float di;
00182                     if (vec[k] == 64.0f) { //FIXME: slow
00183                         //do not code with escape sequence small values
00184                         if (t < 39.0f*IQ) {
00185                             rd = INFINITY;
00186                             break;
00187                         }
00188                         if (t >= CLIPPED_ESCAPE) {
00189                             di = t - CLIPPED_ESCAPE;
00190                             curbits += 21;
00191                         } else {
00192                             int c = av_clip(quant(t, Q), 0, 8191);
00193                             di = t - c*cbrtf(c)*IQ;
00194                             curbits += av_log2(c)*2 - 4 + 1;
00195                         }
00196                     } else {
00197                         di = t - vec[k]*IQ;
00198                     }
00199                     if (vec[k] != 0.0f)
00200                         curbits++;
00201                     rd += di*di;
00202                 }
00203             } else {
00204                 for (k = 0; k < dim; k++) {
00205                     float di = in[i+k] - vec[k]*IQ;
00206                     rd += di*di;
00207                 }
00208             }
00209             rd = rd * lambda + curbits;
00210             if (rd < mincost) {
00211                 mincost = rd;
00212                 minidx  = curidx;
00213                 minbits = curbits;
00214             }
00215         }
00216         cost    += mincost;
00217         resbits += minbits;
00218         if (cost >= uplim)
00219             return uplim;
00220         if (pb) {
00221         put_bits(pb, ff_aac_spectral_bits[cb-1][minidx], ff_aac_spectral_codes[cb-1][minidx]);
00222         if (IS_CODEBOOK_UNSIGNED(cb))
00223             for (j = 0; j < dim; j++)
00224                 if (ff_aac_codebook_vectors[cb-1][minidx*dim+j] != 0.0f)
00225                     put_bits(pb, 1, in[i+j] < 0.0f);
00226         if (cb == ESC_BT) {
00227             for (j = 0; j < 2; j++) {
00228                 if (ff_aac_codebook_vectors[cb-1][minidx*2+j] == 64.0f) {
00229                     int coef = av_clip(quant(fabsf(in[i+j]), Q), 0, 8191);
00230                     int len = av_log2(coef);
00231 
00232                     put_bits(pb, len - 4 + 1, (1 << (len - 4 + 1)) - 2);
00233                     put_bits(pb, len, coef & ((1 << len) - 1));
00234                 }
00235             }
00236         }
00237         }
00238     }
00239 
00240     if (bits)
00241         *bits = resbits;
00242     return cost;
00243 }
00244 static float quantize_band_cost(struct AACEncContext *s, const float *in,
00245                                 const float *scaled, int size, int scale_idx,
00246                                 int cb, const float lambda, const float uplim,
00247                                 int *bits)
00248 {
00249     return quantize_and_encode_band_cost(s, NULL, in, scaled, size, scale_idx,
00250                                          cb, lambda, uplim, bits);
00251 }
00252 
00253 static void quantize_and_encode_band(struct AACEncContext *s, PutBitContext *pb,
00254                                      const float *in, int size, int scale_idx,
00255                                      int cb, const float lambda)
00256 {
00257     quantize_and_encode_band_cost(s, pb, in, NULL, size, scale_idx, cb, lambda,
00258                                   INFINITY, NULL);
00259 }
00260 
00264 typedef struct BandCodingPath {
00265     int prev_idx; 
00266     float cost;   
00267     int run;
00268 } BandCodingPath;
00269 
00273 static void encode_window_bands_info(AACEncContext *s, SingleChannelElement *sce,
00274                                      int win, int group_len, const float lambda)
00275 {
00276     BandCodingPath path[120][12];
00277     int w, swb, cb, start, start2, size;
00278     int i, j;
00279     const int max_sfb  = sce->ics.max_sfb;
00280     const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
00281     const int run_esc  = (1 << run_bits) - 1;
00282     int idx, ppos, count;
00283     int stackrun[120], stackcb[120], stack_len;
00284     float next_minrd = INFINITY;
00285     int next_mincb = 0;
00286 
00287     abs_pow34_v(s->scoefs, sce->coeffs, 1024);
00288     start = win*128;
00289     for (cb = 0; cb < 12; cb++) {
00290         path[0][cb].cost     = 0.0f;
00291         path[0][cb].prev_idx = -1;
00292         path[0][cb].run      = 0;
00293     }
00294     for (swb = 0; swb < max_sfb; swb++) {
00295         start2 = start;
00296         size = sce->ics.swb_sizes[swb];
00297         if (sce->zeroes[win*16 + swb]) {
00298             for (cb = 0; cb < 12; cb++) {
00299                 path[swb+1][cb].prev_idx = cb;
00300                 path[swb+1][cb].cost     = path[swb][cb].cost;
00301                 path[swb+1][cb].run      = path[swb][cb].run + 1;
00302             }
00303         } else {
00304             float minrd = next_minrd;
00305             int mincb = next_mincb;
00306             next_minrd = INFINITY;
00307             next_mincb = 0;
00308             for (cb = 0; cb < 12; cb++) {
00309                 float cost_stay_here, cost_get_here;
00310                 float rd = 0.0f;
00311                 for (w = 0; w < group_len; w++) {
00312                     FFPsyBand *band = &s->psy.psy_bands[s->cur_channel*PSY_MAX_BANDS+(win+w)*16+swb];
00313                     rd += quantize_band_cost(s, sce->coeffs + start + w*128,
00314                                              s->scoefs + start + w*128, size,
00315                                              sce->sf_idx[(win+w)*16+swb], cb,
00316                                              lambda / band->threshold, INFINITY, NULL);
00317                 }
00318                 cost_stay_here = path[swb][cb].cost + rd;
00319                 cost_get_here  = minrd              + rd + run_bits + 4;
00320                 if (   run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
00321                     != run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])
00322                     cost_stay_here += run_bits;
00323                 if (cost_get_here < cost_stay_here) {
00324                     path[swb+1][cb].prev_idx = mincb;
00325                     path[swb+1][cb].cost     = cost_get_here;
00326                     path[swb+1][cb].run      = 1;
00327                 } else {
00328                     path[swb+1][cb].prev_idx = cb;
00329                     path[swb+1][cb].cost     = cost_stay_here;
00330                     path[swb+1][cb].run      = path[swb][cb].run + 1;
00331                 }
00332                 if (path[swb+1][cb].cost < next_minrd) {
00333                     next_minrd = path[swb+1][cb].cost;
00334                     next_mincb = cb;
00335                 }
00336             }
00337         }
00338         start += sce->ics.swb_sizes[swb];
00339     }
00340 
00341     //convert resulting path from backward-linked list
00342     stack_len = 0;
00343     idx       = 0;
00344     for (cb = 1; cb < 12; cb++)
00345         if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)
00346             idx = cb;
00347     ppos = max_sfb;
00348     while (ppos > 0) {
00349         cb = idx;
00350         stackrun[stack_len] = path[ppos][cb].run;
00351         stackcb [stack_len] = cb;
00352         idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;
00353         ppos -= path[ppos][cb].run;
00354         stack_len++;
00355     }
00356     //perform actual band info encoding
00357     start = 0;
00358     for (i = stack_len - 1; i >= 0; i--) {
00359         put_bits(&s->pb, 4, stackcb[i]);
00360         count = stackrun[i];
00361         memset(sce->zeroes + win*16 + start, !stackcb[i], count);
00362         //XXX: memset when band_type is also uint8_t
00363         for (j = 0; j < count; j++) {
00364             sce->band_type[win*16 + start] =  stackcb[i];
00365             start++;
00366         }
00367         while (count >= run_esc) {
00368             put_bits(&s->pb, run_bits, run_esc);
00369             count -= run_esc;
00370         }
00371         put_bits(&s->pb, run_bits, count);
00372     }
00373 }
00374 
00375 typedef struct TrellisPath {
00376     float cost;
00377     int prev;
00378     int min_val;
00379     int max_val;
00380 } TrellisPath;
00381 
00382 #define TRELLIS_STAGES 121
00383 #define TRELLIS_STATES 256
00384 
00385 static void search_for_quantizers_anmr(AVCodecContext *avctx, AACEncContext *s,
00386                                        SingleChannelElement *sce,
00387                                        const float lambda)
00388 {
00389     int q, w, w2, g, start = 0;
00390     int i, j;
00391     int idx;
00392     TrellisPath paths[TRELLIS_STAGES][TRELLIS_STATES];
00393     int bandaddr[TRELLIS_STAGES];
00394     int minq;
00395     float mincost;
00396 
00397     for (i = 0; i < TRELLIS_STATES; i++) {
00398         paths[0][i].cost    = 0.0f;
00399         paths[0][i].prev    = -1;
00400         paths[0][i].min_val = i;
00401         paths[0][i].max_val = i;
00402     }
00403     for (j = 1; j < TRELLIS_STAGES; j++) {
00404         for (i = 0; i < TRELLIS_STATES; i++) {
00405             paths[j][i].cost    = INFINITY;
00406             paths[j][i].prev    = -2;
00407             paths[j][i].min_val = INT_MAX;
00408             paths[j][i].max_val = 0;
00409         }
00410     }
00411     idx = 1;
00412     abs_pow34_v(s->scoefs, sce->coeffs, 1024);
00413     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
00414         start = w*128;
00415         for (g = 0; g < sce->ics.num_swb; g++) {
00416             const float *coefs = sce->coeffs + start;
00417             float qmin, qmax;
00418             int nz = 0;
00419 
00420             bandaddr[idx] = w * 16 + g;
00421             qmin = INT_MAX;
00422             qmax = 0.0f;
00423             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
00424                 FFPsyBand *band = &s->psy.psy_bands[s->cur_channel*PSY_MAX_BANDS+(w+w2)*16+g];
00425                 if (band->energy <= band->threshold || band->threshold == 0.0f) {
00426                     sce->zeroes[(w+w2)*16+g] = 1;
00427                     continue;
00428                 }
00429                 sce->zeroes[(w+w2)*16+g] = 0;
00430                 nz = 1;
00431                 for (i = 0; i < sce->ics.swb_sizes[g]; i++) {
00432                     float t = fabsf(coefs[w2*128+i]);
00433                     if (t > 0.0f)
00434                         qmin = FFMIN(qmin, t);
00435                     qmax = FFMAX(qmax, t);
00436                 }
00437             }
00438             if (nz) {
00439                 int minscale, maxscale;
00440                 float minrd = INFINITY;
00441                 //minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped
00442                 minscale = av_clip_uint8(log2(qmin)*4 - 69 + SCALE_ONE_POS - SCALE_DIV_512);
00443                 //maximum scalefactor index is when maximum coefficient after quantizing is still not zero
00444                 maxscale = av_clip_uint8(log2(qmax)*4 +  6 + SCALE_ONE_POS - SCALE_DIV_512);
00445                 for (q = minscale; q < maxscale; q++) {
00446                     float dists[12], dist;
00447                     memset(dists, 0, sizeof(dists));
00448                     for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
00449                         FFPsyBand *band = &s->psy.psy_bands[s->cur_channel*PSY_MAX_BANDS+(w+w2)*16+g];
00450                         int cb;
00451                         for (cb = 0; cb <= ESC_BT; cb++)
00452                             dists[cb] += quantize_band_cost(s, coefs + w2*128, s->scoefs + start + w2*128, sce->ics.swb_sizes[g],
00453                                                             q, cb, lambda / band->threshold, INFINITY, NULL);
00454                     }
00455                     dist = dists[0];
00456                     for (i = 1; i <= ESC_BT; i++)
00457                         dist = FFMIN(dist, dists[i]);
00458                     minrd = FFMIN(minrd, dist);
00459 
00460                     for (i = FFMAX(q - SCALE_MAX_DIFF, 0); i < FFMIN(q + SCALE_MAX_DIFF, TRELLIS_STATES); i++) {
00461                         float cost;
00462                         int minv, maxv;
00463                         if (isinf(paths[idx - 1][i].cost))
00464                             continue;
00465                         cost = paths[idx - 1][i].cost + dist
00466                                + ff_aac_scalefactor_bits[q - i + SCALE_DIFF_ZERO];
00467                         minv = FFMIN(paths[idx - 1][i].min_val, q);
00468                         maxv = FFMAX(paths[idx - 1][i].max_val, q);
00469                         if (cost < paths[idx][q].cost && maxv-minv < SCALE_MAX_DIFF) {
00470                             paths[idx][q].cost    = cost;
00471                             paths[idx][q].prev    = i;
00472                             paths[idx][q].min_val = minv;
00473                             paths[idx][q].max_val = maxv;
00474                         }
00475                     }
00476                 }
00477             } else {
00478                 for (q = 0; q < TRELLIS_STATES; q++) {
00479                     if (!isinf(paths[idx - 1][q].cost)) {
00480                         paths[idx][q].cost = paths[idx - 1][q].cost + 1;
00481                         paths[idx][q].prev = q;
00482                         paths[idx][q].min_val = FFMIN(paths[idx - 1][q].min_val, q);
00483                         paths[idx][q].max_val = FFMAX(paths[idx - 1][q].max_val, q);
00484                         continue;
00485                     }
00486                     for (i = FFMAX(q - SCALE_MAX_DIFF, 0); i < FFMIN(q + SCALE_MAX_DIFF, TRELLIS_STATES); i++) {
00487                         float cost;
00488                         int minv, maxv;
00489                         if (isinf(paths[idx - 1][i].cost))
00490                             continue;
00491                         cost = paths[idx - 1][i].cost + ff_aac_scalefactor_bits[q - i + SCALE_DIFF_ZERO];
00492                         minv = FFMIN(paths[idx - 1][i].min_val, q);
00493                         maxv = FFMAX(paths[idx - 1][i].max_val, q);
00494                         if (cost < paths[idx][q].cost && maxv-minv < SCALE_MAX_DIFF) {
00495                             paths[idx][q].cost    = cost;
00496                             paths[idx][q].prev    = i;
00497                             paths[idx][q].min_val = minv;
00498                             paths[idx][q].max_val = maxv;
00499                         }
00500                     }
00501                 }
00502             }
00503             sce->zeroes[w*16+g] = !nz;
00504             start += sce->ics.swb_sizes[g];
00505             idx++;
00506         }
00507     }
00508     idx--;
00509     mincost = paths[idx][0].cost;
00510     minq    = 0;
00511     for (i = 1; i < TRELLIS_STATES; i++) {
00512         if (paths[idx][i].cost < mincost) {
00513             mincost = paths[idx][i].cost;
00514             minq = i;
00515         }
00516     }
00517     while (idx) {
00518         sce->sf_idx[bandaddr[idx]] = minq;
00519         minq = paths[idx][minq].prev;
00520         idx--;
00521     }
00522     //set the same quantizers inside window groups
00523     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
00524         for (g = 0;  g < sce->ics.num_swb; g++)
00525             for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)
00526                 sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];
00527 }
00528 
00532 static void search_for_quantizers_twoloop(AVCodecContext *avctx,
00533                                           AACEncContext *s,
00534                                           SingleChannelElement *sce,
00535                                           const float lambda)
00536 {
00537     int start = 0, i, w, w2, g;
00538     int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate / avctx->channels;
00539     float dists[128], uplims[128];
00540     int fflag, minscaler;
00541     int its  = 0;
00542     int allz = 0;
00543     float minthr = INFINITY;
00544 
00545     //XXX: some heuristic to determine initial quantizers will reduce search time
00546     memset(dists, 0, sizeof(dists));
00547     //determine zero bands and upper limits
00548     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
00549         for (g = 0;  g < sce->ics.num_swb; g++) {
00550             int nz = 0;
00551             float uplim = 0.0f;
00552             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
00553                 FFPsyBand *band = &s->psy.psy_bands[s->cur_channel*PSY_MAX_BANDS+(w+w2)*16+g];
00554                 uplim += band->threshold;
00555                 if (band->energy <= band->threshold || band->threshold == 0.0f) {
00556                     sce->zeroes[(w+w2)*16+g] = 1;
00557                     continue;
00558                 }
00559                 nz = 1;
00560             }
00561             uplims[w*16+g] = uplim *512;
00562             sce->zeroes[w*16+g] = !nz;
00563             if (nz)
00564                 minthr = FFMIN(minthr, uplim);
00565             allz = FFMAX(allz, nz);
00566         }
00567     }
00568     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
00569         for (g = 0;  g < sce->ics.num_swb; g++) {
00570             if (sce->zeroes[w*16+g]) {
00571                 sce->sf_idx[w*16+g] = SCALE_ONE_POS;
00572                 continue;
00573             }
00574             sce->sf_idx[w*16+g] = SCALE_ONE_POS + FFMIN(log2(uplims[w*16+g]/minthr)*4,59);
00575         }
00576     }
00577 
00578     if (!allz)
00579         return;
00580     abs_pow34_v(s->scoefs, sce->coeffs, 1024);
00581     //perform two-loop search
00582     //outer loop - improve quality
00583     do {
00584         int tbits, qstep;
00585         minscaler = sce->sf_idx[0];
00586         //inner loop - quantize spectrum to fit into given number of bits
00587         qstep = its ? 1 : 32;
00588         do {
00589             int prev = -1;
00590             tbits = 0;
00591             fflag = 0;
00592             for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
00593                 start = w*128;
00594                 for (g = 0;  g < sce->ics.num_swb; g++) {
00595                     const float *coefs = sce->coeffs + start;
00596                     const float *scaled = s->scoefs + start;
00597                     int bits = 0;
00598                     int cb;
00599                     float mindist = INFINITY;
00600                     int minbits = 0;
00601 
00602                     if (sce->zeroes[w*16+g] || sce->sf_idx[w*16+g] >= 218) {
00603                         start += sce->ics.swb_sizes[g];
00604                         continue;
00605                     }
00606                     minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);
00607                     for (cb = 0; cb <= ESC_BT; cb++) {
00608                         float dist = 0.0f;
00609                         int bb = 0;
00610                         for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
00611                             int b;
00612                             dist += quantize_band_cost(s, coefs + w2*128,
00613                                                        scaled + w2*128,
00614                                                        sce->ics.swb_sizes[g],
00615                                                        sce->sf_idx[w*16+g],
00616                                                        cb,
00617                                                        lambda,
00618                                                        INFINITY,
00619                                                        &b);
00620                             bb += b;
00621                         }
00622                         if (dist < mindist) {
00623                             mindist = dist;
00624                             minbits = bb;
00625                         }
00626                     }
00627                     dists[w*16+g] = (mindist - minbits) / lambda;
00628                     bits = minbits;
00629                     if (prev != -1) {
00630                         bits += ff_aac_scalefactor_bits[sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO];
00631                     }
00632                     tbits += bits;
00633                     start += sce->ics.swb_sizes[g];
00634                     prev = sce->sf_idx[w*16+g];
00635                 }
00636             }
00637             if (tbits > destbits) {
00638                 for (i = 0; i < 128; i++)
00639                     if (sce->sf_idx[i] < 218 - qstep)
00640                         sce->sf_idx[i] += qstep;
00641             } else {
00642                 for (i = 0; i < 128; i++)
00643                     if (sce->sf_idx[i] > 60 - qstep)
00644                         sce->sf_idx[i] -= qstep;
00645             }
00646             qstep >>= 1;
00647             if (!qstep && tbits > destbits*1.02)
00648                 qstep = 1;
00649             if (sce->sf_idx[0] >= 217)
00650                 break;
00651         } while (qstep);
00652 
00653         fflag = 0;
00654         minscaler = av_clip(minscaler, 60, 255 - SCALE_MAX_DIFF);
00655         for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
00656             start = w*128;
00657             for (g = 0; g < sce->ics.num_swb; g++) {
00658                 int prevsc = sce->sf_idx[w*16+g];
00659                 if (dists[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > 60)
00660                     sce->sf_idx[w*16+g]--;
00661                 sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler, minscaler + SCALE_MAX_DIFF);
00662                 sce->sf_idx[w*16+g] = FFMIN(sce->sf_idx[w*16+g], 219);
00663                 if (sce->sf_idx[w*16+g] != prevsc)
00664                     fflag = 1;
00665             }
00666         }
00667         its++;
00668     } while (fflag && its < 10);
00669 }
00670 
00671 static void search_for_quantizers_faac(AVCodecContext *avctx, AACEncContext *s,
00672                                        SingleChannelElement *sce,
00673                                        const float lambda)
00674 {
00675     int start = 0, i, w, w2, g;
00676     float uplim[128], maxq[128];
00677     int minq, maxsf;
00678     float distfact = ((sce->ics.num_windows > 1) ? 85.80 : 147.84) / lambda;
00679     int last = 0, lastband = 0, curband = 0;
00680     float avg_energy = 0.0;
00681     if (sce->ics.num_windows == 1) {
00682         start = 0;
00683         for (i = 0; i < 1024; i++) {
00684             if (i - start >= sce->ics.swb_sizes[curband]) {
00685                 start += sce->ics.swb_sizes[curband];
00686                 curband++;
00687             }
00688             if (sce->coeffs[i]) {
00689                 avg_energy += sce->coeffs[i] * sce->coeffs[i];
00690                 last = i;
00691                 lastband = curband;
00692             }
00693         }
00694     } else {
00695         for (w = 0; w < 8; w++) {
00696             const float *coeffs = sce->coeffs + w*128;
00697             start = 0;
00698             for (i = 0; i < 128; i++) {
00699                 if (i - start >= sce->ics.swb_sizes[curband]) {
00700                     start += sce->ics.swb_sizes[curband];
00701                     curband++;
00702                 }
00703                 if (coeffs[i]) {
00704                     avg_energy += coeffs[i] * coeffs[i];
00705                     last = FFMAX(last, i);
00706                     lastband = FFMAX(lastband, curband);
00707                 }
00708             }
00709         }
00710     }
00711     last++;
00712     avg_energy /= last;
00713     if (avg_energy == 0.0f) {
00714         for (i = 0; i < FF_ARRAY_ELEMS(sce->sf_idx); i++)
00715             sce->sf_idx[i] = SCALE_ONE_POS;
00716         return;
00717     }
00718     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
00719         start = w*128;
00720         for (g = 0; g < sce->ics.num_swb; g++) {
00721             float *coefs   = sce->coeffs + start;
00722             const int size = sce->ics.swb_sizes[g];
00723             int start2 = start, end2 = start + size, peakpos = start;
00724             float maxval = -1, thr = 0.0f, t;
00725             maxq[w*16+g] = 0.0f;
00726             if (g > lastband) {
00727                 maxq[w*16+g] = 0.0f;
00728                 start += size;
00729                 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++)
00730                     memset(coefs + w2*128, 0, sizeof(coefs[0])*size);
00731                 continue;
00732             }
00733             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
00734                 for (i = 0; i < size; i++) {
00735                     float t = coefs[w2*128+i]*coefs[w2*128+i];
00736                     maxq[w*16+g] = FFMAX(maxq[w*16+g], fabsf(coefs[w2*128 + i]));
00737                     thr += t;
00738                     if (sce->ics.num_windows == 1 && maxval < t) {
00739                         maxval  = t;
00740                         peakpos = start+i;
00741                     }
00742                 }
00743             }
00744             if (sce->ics.num_windows == 1) {
00745                 start2 = FFMAX(peakpos - 2, start2);
00746                 end2   = FFMIN(peakpos + 3, end2);
00747             } else {
00748                 start2 -= start;
00749                 end2   -= start;
00750             }
00751             start += size;
00752             thr = pow(thr / (avg_energy * (end2 - start2)), 0.3 + 0.1*(lastband - g) / lastband);
00753             t   = 1.0 - (1.0 * start2 / last);
00754             uplim[w*16+g] = distfact / (1.4 * thr + t*t*t + 0.075);
00755         }
00756     }
00757     memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
00758     abs_pow34_v(s->scoefs, sce->coeffs, 1024);
00759     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
00760         start = w*128;
00761         for (g = 0;  g < sce->ics.num_swb; g++) {
00762             const float *coefs  = sce->coeffs + start;
00763             const float *scaled = s->scoefs   + start;
00764             const int size      = sce->ics.swb_sizes[g];
00765             int scf, prev_scf, step;
00766             int min_scf = -1, max_scf = 256;
00767             float curdiff;
00768             if (maxq[w*16+g] < 21.544) {
00769                 sce->zeroes[w*16+g] = 1;
00770                 start += size;
00771                 continue;
00772             }
00773             sce->zeroes[w*16+g] = 0;
00774             scf  = prev_scf = av_clip(SCALE_ONE_POS - SCALE_DIV_512 - log2(1/maxq[w*16+g])*16/3, 60, 218);
00775             step = 16;
00776             for (;;) {
00777                 float dist = 0.0f;
00778                 int quant_max;
00779 
00780                 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
00781                     int b;
00782                     dist += quantize_band_cost(s, coefs + w2*128,
00783                                                scaled + w2*128,
00784                                                sce->ics.swb_sizes[g],
00785                                                scf,
00786                                                ESC_BT,
00787                                                lambda,
00788                                                INFINITY,
00789                                                &b);
00790                     dist -= b;
00791                 }
00792                 dist *= 1.0f / 512.0f / lambda;
00793                 quant_max = quant(maxq[w*16+g], ff_aac_pow2sf_tab[200 - scf + SCALE_ONE_POS - SCALE_DIV_512]);
00794                 if (quant_max >= 8191) { // too much, return to the previous quantizer
00795                     sce->sf_idx[w*16+g] = prev_scf;
00796                     break;
00797                 }
00798                 prev_scf = scf;
00799                 curdiff = fabsf(dist - uplim[w*16+g]);
00800                 if (curdiff <= 1.0f)
00801                     step = 0;
00802                 else
00803                     step = log2(curdiff);
00804                 if (dist > uplim[w*16+g])
00805                     step = -step;
00806                 scf += step;
00807                 scf = av_clip_uint8(scf);
00808                 step = scf - prev_scf;
00809                 if (FFABS(step) <= 1 || (step > 0 && scf >= max_scf) || (step < 0 && scf <= min_scf)) {
00810                     sce->sf_idx[w*16+g] = av_clip(scf, min_scf, max_scf);
00811                     break;
00812                 }
00813                 if (step > 0)
00814                     min_scf = prev_scf;
00815                 else
00816                     max_scf = prev_scf;
00817             }
00818             start += size;
00819         }
00820     }
00821     minq = sce->sf_idx[0] ? sce->sf_idx[0] : INT_MAX;
00822     for (i = 1; i < 128; i++) {
00823         if (!sce->sf_idx[i])
00824             sce->sf_idx[i] = sce->sf_idx[i-1];
00825         else
00826             minq = FFMIN(minq, sce->sf_idx[i]);
00827     }
00828     if (minq == INT_MAX)
00829         minq = 0;
00830     minq = FFMIN(minq, SCALE_MAX_POS);
00831     maxsf = FFMIN(minq + SCALE_MAX_DIFF, SCALE_MAX_POS);
00832     for (i = 126; i >= 0; i--) {
00833         if (!sce->sf_idx[i])
00834             sce->sf_idx[i] = sce->sf_idx[i+1];
00835         sce->sf_idx[i] = av_clip(sce->sf_idx[i], minq, maxsf);
00836     }
00837 }
00838 
00839 static void search_for_quantizers_fast(AVCodecContext *avctx, AACEncContext *s,
00840                                        SingleChannelElement *sce,
00841                                        const float lambda)
00842 {
00843     int start = 0, i, w, w2, g;
00844     int minq = 255;
00845 
00846     memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
00847     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
00848         start = w*128;
00849         for (g = 0; g < sce->ics.num_swb; g++) {
00850             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
00851                 FFPsyBand *band = &s->psy.psy_bands[s->cur_channel*PSY_MAX_BANDS+(w+w2)*16+g];
00852                 if (band->energy <= band->threshold) {
00853                     sce->sf_idx[(w+w2)*16+g] = 218;
00854                     sce->zeroes[(w+w2)*16+g] = 1;
00855                 } else {
00856                     sce->sf_idx[(w+w2)*16+g] = av_clip(SCALE_ONE_POS - SCALE_DIV_512 + log2(band->threshold), 80, 218);
00857                     sce->zeroes[(w+w2)*16+g] = 0;
00858                 }
00859                 minq = FFMIN(minq, sce->sf_idx[(w+w2)*16+g]);
00860             }
00861         }
00862     }
00863     for (i = 0; i < 128; i++) {
00864         sce->sf_idx[i] = 140;
00865         //av_clip(sce->sf_idx[i], minq, minq + SCALE_MAX_DIFF - 1);
00866     }
00867     //set the same quantizers inside window groups
00868     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
00869         for (g = 0;  g < sce->ics.num_swb; g++)
00870             for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)
00871                 sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];
00872 }
00873 
00874 static void search_for_ms(AACEncContext *s, ChannelElement *cpe,
00875                           const float lambda)
00876 {
00877     int start = 0, i, w, w2, g;
00878     float M[128], S[128];
00879     float *L34 = s->scoefs, *R34 = s->scoefs + 128, *M34 = s->scoefs + 128*2, *S34 = s->scoefs + 128*3;
00880     SingleChannelElement *sce0 = &cpe->ch[0];
00881     SingleChannelElement *sce1 = &cpe->ch[1];
00882     if (!cpe->common_window)
00883         return;
00884     for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {
00885         for (g = 0;  g < sce0->ics.num_swb; g++) {
00886             if (!cpe->ch[0].zeroes[w*16+g] && !cpe->ch[1].zeroes[w*16+g]) {
00887                 float dist1 = 0.0f, dist2 = 0.0f;
00888                 for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {
00889                     FFPsyBand *band0 = &s->psy.psy_bands[(s->cur_channel+0)*PSY_MAX_BANDS+(w+w2)*16+g];
00890                     FFPsyBand *band1 = &s->psy.psy_bands[(s->cur_channel+1)*PSY_MAX_BANDS+(w+w2)*16+g];
00891                     float minthr = FFMIN(band0->threshold, band1->threshold);
00892                     float maxthr = FFMAX(band0->threshold, band1->threshold);
00893                     for (i = 0; i < sce0->ics.swb_sizes[g]; i++) {
00894                         M[i] = (sce0->coeffs[start+w2*128+i]
00895                               + sce1->coeffs[start+w2*128+i]) * 0.5;
00896                         S[i] =  sce0->coeffs[start+w2*128+i]
00897                               - sce1->coeffs[start+w2*128+i];
00898                     }
00899                     abs_pow34_v(L34, sce0->coeffs+start+w2*128, sce0->ics.swb_sizes[g]);
00900                     abs_pow34_v(R34, sce1->coeffs+start+w2*128, sce0->ics.swb_sizes[g]);
00901                     abs_pow34_v(M34, M,                         sce0->ics.swb_sizes[g]);
00902                     abs_pow34_v(S34, S,                         sce0->ics.swb_sizes[g]);
00903                     dist1 += quantize_band_cost(s, sce0->coeffs + start + w2*128,
00904                                                 L34,
00905                                                 sce0->ics.swb_sizes[g],
00906                                                 sce0->sf_idx[(w+w2)*16+g],
00907                                                 sce0->band_type[(w+w2)*16+g],
00908                                                 lambda / band0->threshold, INFINITY, NULL);
00909                     dist1 += quantize_band_cost(s, sce1->coeffs + start + w2*128,
00910                                                 R34,
00911                                                 sce1->ics.swb_sizes[g],
00912                                                 sce1->sf_idx[(w+w2)*16+g],
00913                                                 sce1->band_type[(w+w2)*16+g],
00914                                                 lambda / band1->threshold, INFINITY, NULL);
00915                     dist2 += quantize_band_cost(s, M,
00916                                                 M34,
00917                                                 sce0->ics.swb_sizes[g],
00918                                                 sce0->sf_idx[(w+w2)*16+g],
00919                                                 sce0->band_type[(w+w2)*16+g],
00920                                                 lambda / maxthr, INFINITY, NULL);
00921                     dist2 += quantize_band_cost(s, S,
00922                                                 S34,
00923                                                 sce1->ics.swb_sizes[g],
00924                                                 sce1->sf_idx[(w+w2)*16+g],
00925                                                 sce1->band_type[(w+w2)*16+g],
00926                                                 lambda / minthr, INFINITY, NULL);
00927                 }
00928                 cpe->ms_mask[w*16+g] = dist2 < dist1;
00929             }
00930             start += sce0->ics.swb_sizes[g];
00931         }
00932     }
00933 }
00934 
00935 AACCoefficientsEncoder ff_aac_coders[] = {
00936     {
00937         search_for_quantizers_faac,
00938         encode_window_bands_info,
00939         quantize_and_encode_band,
00940         search_for_ms,
00941     },
00942     {
00943         search_for_quantizers_anmr,
00944         encode_window_bands_info,
00945         quantize_and_encode_band,
00946         search_for_ms,
00947     },
00948     {
00949         search_for_quantizers_twoloop,
00950         encode_window_bands_info,
00951         quantize_and_encode_band,
00952         search_for_ms,
00953     },
00954     {
00955         search_for_quantizers_fast,
00956         encode_window_bands_info,
00957         quantize_and_encode_band,
00958         search_for_ms,
00959     },
00960 };

Generated on Fri Sep 16 2011 17:17:32 for FFmpeg by  doxygen 1.7.1