falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
75016 Commits
32 Branches
310MB
Tree: b6cc8ec7ec
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b6cc8ec7ec'
${ noResults }
FFmpeg/libavcodec/aaccoder.c

1081 lines
43KB
Raw Blame History 

  1. /*

  2.  * AAC coefficients encoder

  3.  * Copyright (C) 2008-2009 Konstantin Shishkov

  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 coefficients encoder

  25.  */

  26. 

  27. /***********************************

  28.  *              TODOs:

  29.  * speedup quantizer selection

  30.  * add sane pulse detection

  31.  ***********************************/

  32. 

  33. #include "libavutil/libm.h" // brought forward to work around cygwin header breakage

  34. 

  35. #include <float.h>

  36. #include "libavutil/mathematics.h"

  37. #include "avcodec.h"

  38. #include "put_bits.h"

  39. #include "aac.h"

  40. #include "aacenc.h"

  41. #include "aactab.h"

  42. #include "aacenctab.h"

  43. #include "aacenc_utils.h"

  44. #include "aacenc_quantization.h"

  45. #include "aac_tablegen_decl.h"

  46. 

  47. #include "aacenc_is.h"

  48. #include "aacenc_tns.h"

  49. #include "aacenc_pred.h"

  50. 

  51. /** Frequency in Hz for lower limit of noise substitution **/

  52. #define NOISE_LOW_LIMIT 4000

  53. 

  54. /* Parameter of f(x) = a*(lambda/100), defines the maximum fourier spread

  55.  * beyond which no PNS is used (since the SFBs contain tone rather than noise) */

  56. #define NOISE_SPREAD_THRESHOLD 0.9673f

  57. 

  58. /* Parameter of f(x) = a*(100/lambda), defines how much PNS is allowed to

  59.  * replace low energy non zero bands */

  60. #define NOISE_LAMBDA_REPLACE 1.948f

  61. 

  62. /**

  63.  * structure used in optimal codebook search

  64.  */

  65. typedef struct BandCodingPath {

  66.     int prev_idx; ///< pointer to the previous path point

  67.     float cost;   ///< path cost

  68.     int run;

  69. } BandCodingPath;

  70. 

  71. /**

  72.  * Encode band info for single window group bands.

  73.  */

  74. static void encode_window_bands_info(AACEncContext *s, SingleChannelElement *sce,

  75.                                      int win, int group_len, const float lambda)

  76. {

  77.     BandCodingPath path[120][CB_TOT_ALL];

  78.     int w, swb, cb, start, size;

  79.     int i, j;

  80.     const int max_sfb  = sce->ics.max_sfb;

  81.     const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;

  82.     const int run_esc  = (1 << run_bits) - 1;

  83.     int idx, ppos, count;

  84.     int stackrun[120], stackcb[120], stack_len;

  85.     float next_minrd = INFINITY;

  86.     int next_mincb = 0;

  87. 

  88.     abs_pow34_v(s->scoefs, sce->coeffs, 1024);

  89.     start = win*128;

  90.     for (cb = 0; cb < CB_TOT_ALL; cb++) {

  91.         path[0][cb].cost     = 0.0f;

  92.         path[0][cb].prev_idx = -1;

  93.         path[0][cb].run      = 0;

  94.     }

  95.     for (swb = 0; swb < max_sfb; swb++) {

  96.         size = sce->ics.swb_sizes[swb];

  97.         if (sce->zeroes[win*16 + swb]) {

  98.             for (cb = 0; cb < CB_TOT_ALL; cb++) {

  99.                 path[swb+1][cb].prev_idx = cb;

  100.                 path[swb+1][cb].cost     = path[swb][cb].cost;

  101.                 path[swb+1][cb].run      = path[swb][cb].run + 1;

  102.             }

  103.         } else {

  104.             float minrd = next_minrd;

  105.             int mincb = next_mincb;

  106.             next_minrd = INFINITY;

  107.             next_mincb = 0;

  108.             for (cb = 0; cb < CB_TOT_ALL; cb++) {

  109.                 float cost_stay_here, cost_get_here;

  110.                 float rd = 0.0f;

  111.                 if (cb >= 12 && sce->band_type[win*16+swb] < aac_cb_out_map[cb] ||

  112.                     cb  < aac_cb_in_map[sce->band_type[win*16+swb]] && sce->band_type[win*16+swb] > aac_cb_out_map[cb]) {

  113.                     path[swb+1][cb].prev_idx = -1;

  114.                     path[swb+1][cb].cost     = INFINITY;

  115.                     path[swb+1][cb].run      = path[swb][cb].run + 1;

  116.                     continue;

  117.                 }

  118.                 for (w = 0; w < group_len; w++) {

  119.                     FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(win+w)*16+swb];

  120.                     rd += quantize_band_cost(s, &sce->coeffs[start + w*128],

  121.                                              &s->scoefs[start + w*128], size,

  122.                                              sce->sf_idx[(win+w)*16+swb], aac_cb_out_map[cb],

  123.                                              lambda / band->threshold, INFINITY, NULL, 0);

  124.                 }

  125.                 cost_stay_here = path[swb][cb].cost + rd;

  126.                 cost_get_here  = minrd              + rd + run_bits + 4;

  127.                 if (   run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]

  128.                     != run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])

  129.                     cost_stay_here += run_bits;

  130.                 if (cost_get_here < cost_stay_here) {

  131.                     path[swb+1][cb].prev_idx = mincb;

  132.                     path[swb+1][cb].cost     = cost_get_here;

  133.                     path[swb+1][cb].run      = 1;

  134.                 } else {

  135.                     path[swb+1][cb].prev_idx = cb;

  136.                     path[swb+1][cb].cost     = cost_stay_here;

  137.                     path[swb+1][cb].run      = path[swb][cb].run + 1;

  138.                 }

  139.                 if (path[swb+1][cb].cost < next_minrd) {

  140.                     next_minrd = path[swb+1][cb].cost;

  141.                     next_mincb = cb;

  142.                 }

  143.             }

  144.         }

  145.         start += sce->ics.swb_sizes[swb];

  146.     }

  147. 

  148.     //convert resulting path from backward-linked list

  149.     stack_len = 0;

  150.     idx       = 0;

  151.     for (cb = 1; cb < CB_TOT_ALL; cb++)

  152.         if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)

  153.             idx = cb;

  154.     ppos = max_sfb;

  155.     while (ppos > 0) {

  156.         av_assert1(idx >= 0);

  157.         cb = idx;

  158.         stackrun[stack_len] = path[ppos][cb].run;

  159.         stackcb [stack_len] = cb;

  160.         idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;

  161.         ppos -= path[ppos][cb].run;

  162.         stack_len++;

  163.     }

  164.     //perform actual band info encoding

  165.     start = 0;

  166.     for (i = stack_len - 1; i >= 0; i--) {

  167.         cb = aac_cb_out_map[stackcb[i]];

  168.         put_bits(&s->pb, 4, cb);

  169.         count = stackrun[i];

  170.         memset(sce->zeroes + win*16 + start, !cb, count);

  171.         //XXX: memset when band_type is also uint8_t

  172.         for (j = 0; j < count; j++) {

  173.             sce->band_type[win*16 + start] = cb;

  174.             start++;

  175.         }

  176.         while (count >= run_esc) {

  177.             put_bits(&s->pb, run_bits, run_esc);

  178.             count -= run_esc;

  179.         }

  180.         put_bits(&s->pb, run_bits, count);

  181.     }

  182. }

  183. 

  184. static void codebook_trellis_rate(AACEncContext *s, SingleChannelElement *sce,

  185.                                   int win, int group_len, const float lambda)

  186. {

  187.     BandCodingPath path[120][CB_TOT_ALL];

  188.     int w, swb, cb, start, size;

  189.     int i, j;

  190.     const int max_sfb  = sce->ics.max_sfb;

  191.     const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;

  192.     const int run_esc  = (1 << run_bits) - 1;

  193.     int idx, ppos, count;

  194.     int stackrun[120], stackcb[120], stack_len;

  195.     float next_minbits = INFINITY;

  196.     int next_mincb = 0;

  197. 

  198.     abs_pow34_v(s->scoefs, sce->coeffs, 1024);

  199.     start = win*128;

  200.     for (cb = 0; cb < CB_TOT_ALL; cb++) {

  201.         path[0][cb].cost     = run_bits+4;

  202.         path[0][cb].prev_idx = -1;

  203.         path[0][cb].run      = 0;

  204.     }

  205.     for (swb = 0; swb < max_sfb; swb++) {

  206.         size = sce->ics.swb_sizes[swb];

  207.         if (sce->zeroes[win*16 + swb]) {

  208.             float cost_stay_here = path[swb][0].cost;

  209.             float cost_get_here  = next_minbits + run_bits + 4;

  210.             if (   run_value_bits[sce->ics.num_windows == 8][path[swb][0].run]

  211.                 != run_value_bits[sce->ics.num_windows == 8][path[swb][0].run+1])

  212.                 cost_stay_here += run_bits;

  213.             if (cost_get_here < cost_stay_here) {

  214.                 path[swb+1][0].prev_idx = next_mincb;

  215.                 path[swb+1][0].cost     = cost_get_here;

  216.                 path[swb+1][0].run      = 1;

  217.             } else {

  218.                 path[swb+1][0].prev_idx = 0;

  219.                 path[swb+1][0].cost     = cost_stay_here;

  220.                 path[swb+1][0].run      = path[swb][0].run + 1;

  221.             }

  222.             next_minbits = path[swb+1][0].cost;

  223.             next_mincb = 0;

  224.             for (cb = 1; cb < CB_TOT_ALL; cb++) {

  225.                 path[swb+1][cb].cost = 61450;

  226.                 path[swb+1][cb].prev_idx = -1;

  227.                 path[swb+1][cb].run = 0;

  228.             }

  229.         } else {

  230.             float minbits = next_minbits;

  231.             int mincb = next_mincb;

  232.             int startcb = sce->band_type[win*16+swb];

  233.             startcb = aac_cb_in_map[startcb];

  234.             next_minbits = INFINITY;

  235.             next_mincb = 0;

  236.             for (cb = 0; cb < startcb; cb++) {

  237.                 path[swb+1][cb].cost = 61450;

  238.                 path[swb+1][cb].prev_idx = -1;

  239.                 path[swb+1][cb].run = 0;

  240.             }

  241.             for (cb = startcb; cb < CB_TOT_ALL; cb++) {

  242.                 float cost_stay_here, cost_get_here;

  243.                 float bits = 0.0f;

  244.                 if (cb >= 12 && sce->band_type[win*16+swb] != aac_cb_out_map[cb]) {

  245.                     path[swb+1][cb].cost = 61450;

  246.                     path[swb+1][cb].prev_idx = -1;

  247.                     path[swb+1][cb].run = 0;

  248.                     continue;

  249.                 }

  250.                 for (w = 0; w < group_len; w++) {

  251.                     bits += quantize_band_cost(s, &sce->coeffs[start + w*128],

  252.                                                &s->scoefs[start + w*128], size,

  253.                                                sce->sf_idx[win*16+swb],

  254.                                                aac_cb_out_map[cb],

  255.                                                0, INFINITY, NULL, 0);

  256.                 }

  257.                 cost_stay_here = path[swb][cb].cost + bits;

  258.                 cost_get_here  = minbits            + bits + run_bits + 4;

  259.                 if (   run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]

  260.                     != run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])

  261.                     cost_stay_here += run_bits;

  262.                 if (cost_get_here < cost_stay_here) {

  263.                     path[swb+1][cb].prev_idx = mincb;

  264.                     path[swb+1][cb].cost     = cost_get_here;

  265.                     path[swb+1][cb].run      = 1;

  266.                 } else {

  267.                     path[swb+1][cb].prev_idx = cb;

  268.                     path[swb+1][cb].cost     = cost_stay_here;

  269.                     path[swb+1][cb].run      = path[swb][cb].run + 1;

  270.                 }

  271.                 if (path[swb+1][cb].cost < next_minbits) {

  272.                     next_minbits = path[swb+1][cb].cost;

  273.                     next_mincb = cb;

  274.                 }

  275.             }

  276.         }

  277.         start += sce->ics.swb_sizes[swb];

  278.     }

  279. 

  280.     //convert resulting path from backward-linked list

  281.     stack_len = 0;

  282.     idx       = 0;

  283.     for (cb = 1; cb < CB_TOT_ALL; cb++)

  284.         if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)

  285.             idx = cb;

  286.     ppos = max_sfb;

  287.     while (ppos > 0) {

  288.         av_assert1(idx >= 0);

  289.         cb = idx;

  290.         stackrun[stack_len] = path[ppos][cb].run;

  291.         stackcb [stack_len] = cb;

  292.         idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;

  293.         ppos -= path[ppos][cb].run;

  294.         stack_len++;

  295.     }

  296.     //perform actual band info encoding

  297.     start = 0;

  298.     for (i = stack_len - 1; i >= 0; i--) {

  299.         cb = aac_cb_out_map[stackcb[i]];

  300.         put_bits(&s->pb, 4, cb);

  301.         count = stackrun[i];

  302.         memset(sce->zeroes + win*16 + start, !cb, count);

  303.         //XXX: memset when band_type is also uint8_t

  304.         for (j = 0; j < count; j++) {

  305.             sce->band_type[win*16 + start] = cb;

  306.             start++;

  307.         }

  308.         while (count >= run_esc) {

  309.             put_bits(&s->pb, run_bits, run_esc);

  310.             count -= run_esc;

  311.         }

  312.         put_bits(&s->pb, run_bits, count);

  313.     }

  314. }

  315. 

  316. typedef struct TrellisPath {

  317.     float cost;

  318.     int prev;

  319. } TrellisPath;

  320. 

  321. #define TRELLIS_STAGES 121

  322. #define TRELLIS_STATES (SCALE_MAX_DIFF+1)

  323. 

  324. static void set_special_band_scalefactors(AACEncContext *s, SingleChannelElement *sce)

  325. {

  326.     int w, g, start = 0;

  327.     int minscaler_n = sce->sf_idx[0], minscaler_i = sce->sf_idx[0];

  328.     int bands = 0;

  329. 

  330.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  331.         start = 0;

  332.         for (g = 0;  g < sce->ics.num_swb; g++) {

  333.             if (sce->band_type[w*16+g] == INTENSITY_BT || sce->band_type[w*16+g] == INTENSITY_BT2) {

  334.                 sce->sf_idx[w*16+g] = av_clip(roundf(log2f(sce->is_ener[w*16+g])*2), -155, 100);

  335.                 minscaler_i = FFMIN(minscaler_i, sce->sf_idx[w*16+g]);

  336.                 bands++;

  337.             } else if (sce->band_type[w*16+g] == NOISE_BT) {

  338.                 sce->sf_idx[w*16+g] = av_clip(roundf(log2f(sce->pns_ener[w*16+g])*2), -100, 155);

  339.                 minscaler_n = FFMIN(minscaler_n, sce->sf_idx[w*16+g]);

  340.                 bands++;

  341.             }

  342.             start += sce->ics.swb_sizes[g];

  343.         }

  344.     }

  345. 

  346.     if (!bands)

  347.         return;

  348. 

  349.     /* Clip the scalefactor indices */

  350.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  351.         for (g = 0;  g < sce->ics.num_swb; g++) {

  352.             if (sce->band_type[w*16+g] == INTENSITY_BT || sce->band_type[w*16+g] == INTENSITY_BT2) {

  353.                 sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler_i, minscaler_i + SCALE_MAX_DIFF);

  354.             } else if (sce->band_type[w*16+g] == NOISE_BT) {

  355.                 sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler_n, minscaler_n + SCALE_MAX_DIFF);

  356.             }

  357.         }

  358.     }

  359. }

  360. 

  361. static void search_for_quantizers_anmr(AVCodecContext *avctx, AACEncContext *s,

  362.                                        SingleChannelElement *sce,

  363.                                        const float lambda)

  364. {

  365.     int q, w, w2, g, start = 0;

  366.     int i, j;

  367.     int idx;

  368.     TrellisPath paths[TRELLIS_STAGES][TRELLIS_STATES];

  369.     int bandaddr[TRELLIS_STAGES];

  370.     int minq;

  371.     float mincost;

  372.     float q0f = FLT_MAX, q1f = 0.0f, qnrgf = 0.0f;

  373.     int q0, q1, qcnt = 0;

  374. 

  375.     for (i = 0; i < 1024; i++) {

  376.         float t = fabsf(sce->coeffs[i]);

  377.         if (t > 0.0f) {

  378.             q0f = FFMIN(q0f, t);

  379.             q1f = FFMAX(q1f, t);

  380.             qnrgf += t*t;

  381.             qcnt++;

  382.         }

  383.     }

  384. 

  385.     if (!qcnt) {

  386.         memset(sce->sf_idx, 0, sizeof(sce->sf_idx));

  387.         memset(sce->zeroes, 1, sizeof(sce->zeroes));

  388.         return;

  389.     }

  390. 

  391.     //minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped

  392.     q0 = coef2minsf(q0f);

  393.     //maximum scalefactor index is when maximum coefficient after quantizing is still not zero

  394.     q1 = coef2maxsf(q1f);

  395.     if (q1 - q0 > 60) {

  396.         int q0low  = q0;

  397.         int q1high = q1;

  398.         //minimum scalefactor index is when maximum nonzero coefficient after quantizing is not clipped

  399.         int qnrg = av_clip_uint8(log2f(sqrtf(qnrgf/qcnt))*4 - 31 + SCALE_ONE_POS - SCALE_DIV_512);

  400.         q1 = qnrg + 30;

  401.         q0 = qnrg - 30;

  402.         if (q0 < q0low) {

  403.             q1 += q0low - q0;

  404.             q0  = q0low;

  405.         } else if (q1 > q1high) {

  406.             q0 -= q1 - q1high;

  407.             q1  = q1high;

  408.         }

  409.     }

  410. 

  411.     for (i = 0; i < TRELLIS_STATES; i++) {

  412.         paths[0][i].cost    = 0.0f;

  413.         paths[0][i].prev    = -1;

  414.     }

  415.     for (j = 1; j < TRELLIS_STAGES; j++) {

  416.         for (i = 0; i < TRELLIS_STATES; i++) {

  417.             paths[j][i].cost    = INFINITY;

  418.             paths[j][i].prev    = -2;

  419.         }

  420.     }

  421.     idx = 1;

  422.     abs_pow34_v(s->scoefs, sce->coeffs, 1024);

  423.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  424.         start = w*128;

  425.         for (g = 0; g < sce->ics.num_swb; g++) {

  426.             const float *coefs = &sce->coeffs[start];

  427.             float qmin, qmax;

  428.             int nz = 0;

  429. 

  430.             bandaddr[idx] = w * 16 + g;

  431.             qmin = INT_MAX;

  432.             qmax = 0.0f;

  433.             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

  434.                 FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];

  435.                 if (band->energy <= band->threshold || band->threshold == 0.0f) {

  436.                     sce->zeroes[(w+w2)*16+g] = 1;

  437.                     continue;

  438.                 }

  439.                 sce->zeroes[(w+w2)*16+g] = 0;

  440.                 nz = 1;

  441.                 for (i = 0; i < sce->ics.swb_sizes[g]; i++) {

  442.                     float t = fabsf(coefs[w2*128+i]);

  443.                     if (t > 0.0f)

  444.                         qmin = FFMIN(qmin, t);

  445.                     qmax = FFMAX(qmax, t);

  446.                 }

  447.             }

  448.             if (nz) {

  449.                 int minscale, maxscale;

  450.                 float minrd = INFINITY;

  451.                 float maxval;

  452.                 //minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped

  453.                 minscale = coef2minsf(qmin);

  454.                 //maximum scalefactor index is when maximum coefficient after quantizing is still not zero

  455.                 maxscale = coef2maxsf(qmax);

  456.                 minscale = av_clip(minscale - q0, 0, TRELLIS_STATES - 1);

  457.                 maxscale = av_clip(maxscale - q0, 0, TRELLIS_STATES);

  458.                 maxval = find_max_val(sce->ics.group_len[w], sce->ics.swb_sizes[g], s->scoefs+start);

  459.                 for (q = minscale; q < maxscale; q++) {

  460.                     float dist = 0;

  461.                     int cb = find_min_book(maxval, sce->sf_idx[w*16+g]);

  462.                     for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

  463.                         FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];

  464.                         dist += quantize_band_cost(s, coefs + w2*128, s->scoefs + start + w2*128, sce->ics.swb_sizes[g],

  465.                                                    q + q0, cb, lambda / band->threshold, INFINITY, NULL, 0);

  466.                     }

  467.                     minrd = FFMIN(minrd, dist);

  468. 

  469.                     for (i = 0; i < q1 - q0; i++) {

  470.                         float cost;

  471.                         cost = paths[idx - 1][i].cost + dist

  472.                                + ff_aac_scalefactor_bits[q - i + SCALE_DIFF_ZERO];

  473.                         if (cost < paths[idx][q].cost) {

  474.                             paths[idx][q].cost    = cost;

  475.                             paths[idx][q].prev    = i;

  476.                         }

  477.                     }

  478.                 }

  479.             } else {

  480.                 for (q = 0; q < q1 - q0; q++) {

  481.                     paths[idx][q].cost = paths[idx - 1][q].cost + 1;

  482.                     paths[idx][q].prev = q;

  483.                 }

  484.             }

  485.             sce->zeroes[w*16+g] = !nz;

  486.             start += sce->ics.swb_sizes[g];

  487.             idx++;

  488.         }

  489.     }

  490.     idx--;

  491.     mincost = paths[idx][0].cost;

  492.     minq    = 0;

  493.     for (i = 1; i < TRELLIS_STATES; i++) {

  494.         if (paths[idx][i].cost < mincost) {

  495.             mincost = paths[idx][i].cost;

  496.             minq = i;

  497.         }

  498.     }

  499.     while (idx) {

  500.         sce->sf_idx[bandaddr[idx]] = minq + q0;

  501.         minq = paths[idx][minq].prev;

  502.         idx--;

  503.     }

  504.     //set the same quantizers inside window groups

  505.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])

  506.         for (g = 0;  g < sce->ics.num_swb; g++)

  507.             for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)

  508.                 sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];

  509. }

  510. 

  511. /**

  512.  * two-loop quantizers search taken from ISO 13818-7 Appendix C

  513.  */

  514. static void search_for_quantizers_twoloop(AVCodecContext *avctx,

  515.                                           AACEncContext *s,

  516.                                           SingleChannelElement *sce,

  517.                                           const float lambda)

  518. {

  519.     int start = 0, i, w, w2, g;

  520.     int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate / avctx->channels * (lambda / 120.f);

  521.     float dists[128] = { 0 }, uplims[128] = { 0 };

  522.     float maxvals[128];

  523.     int fflag, minscaler;

  524.     int its  = 0;

  525.     int allz = 0;

  526.     float minthr = INFINITY;

  527. 

  528.     // for values above this the decoder might end up in an endless loop

  529.     // due to always having more bits than what can be encoded.

  530.     destbits = FFMIN(destbits, 5800);

  531.     //XXX: some heuristic to determine initial quantizers will reduce search time

  532.     //determine zero bands and upper limits

  533.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  534.         for (g = 0;  g < sce->ics.num_swb; g++) {

  535.             int nz = 0;

  536.             float uplim = 0.0f, energy = 0.0f;

  537.             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

  538.                 FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];

  539.                 uplim  += band->threshold;

  540.                 energy += band->energy;

  541.                 if (band->energy <= band->threshold || band->threshold == 0.0f) {

  542.                     sce->zeroes[(w+w2)*16+g] = 1;

  543.                     continue;

  544.                 }

  545.                 nz = 1;

  546.             }

  547.             uplims[w*16+g] = uplim *512;

  548.             sce->zeroes[w*16+g] = !nz;

  549.             if (nz)

  550.                 minthr = FFMIN(minthr, uplim);

  551.             allz |= nz;

  552.         }

  553.     }

  554.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  555.         for (g = 0;  g < sce->ics.num_swb; g++) {

  556.             if (sce->zeroes[w*16+g]) {

  557.                 sce->sf_idx[w*16+g] = SCALE_ONE_POS;

  558.                 continue;

  559.             }

  560.             sce->sf_idx[w*16+g] = SCALE_ONE_POS + FFMIN(log2f(uplims[w*16+g]/minthr)*4,59);

  561.         }

  562.     }

  563. 

  564.     if (!allz)

  565.         return;

  566.     abs_pow34_v(s->scoefs, sce->coeffs, 1024);

  567. 

  568.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  569.         start = w*128;

  570.         for (g = 0;  g < sce->ics.num_swb; g++) {

  571.             const float *scaled = s->scoefs + start;

  572.             maxvals[w*16+g] = find_max_val(sce->ics.group_len[w], sce->ics.swb_sizes[g], scaled);

  573.             start += sce->ics.swb_sizes[g];

  574.         }

  575.     }

  576. 

  577.     //perform two-loop search

  578.     //outer loop - improve quality

  579.     do {

  580.         int tbits, qstep;

  581.         minscaler = sce->sf_idx[0];

  582.         //inner loop - quantize spectrum to fit into given number of bits

  583.         qstep = its ? 1 : 32;

  584.         do {

  585.             int prev = -1;

  586.             tbits = 0;

  587.             for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  588.                 start = w*128;

  589.                 for (g = 0;  g < sce->ics.num_swb; g++) {

  590.                     const float *coefs = &sce->coeffs[start];

  591.                     const float *scaled = &s->scoefs[start];

  592.                     int bits = 0;

  593.                     int cb;

  594.                     float dist = 0.0f;

  595. 

  596.                     if (sce->zeroes[w*16+g] || sce->sf_idx[w*16+g] >= 218) {

  597.                         start += sce->ics.swb_sizes[g];

  598.                         continue;

  599.                     }

  600.                     minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);

  601.                     cb = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);

  602.                     for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

  603.                         int b;

  604.                         dist += quantize_band_cost(s, coefs + w2*128,

  605.                                                    scaled + w2*128,

  606.                                                    sce->ics.swb_sizes[g],

  607.                                                    sce->sf_idx[w*16+g],

  608.                                                    cb,

  609.                                                    1.0f,

  610.                                                    INFINITY,

  611.                                                    &b,

  612.                                                    0);

  613.                         bits += b;

  614.                     }

  615.                     dists[w*16+g] = dist - bits;

  616.                     if (prev != -1) {

  617.                         bits += ff_aac_scalefactor_bits[sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO];

  618.                     }

  619.                     tbits += bits;

  620.                     start += sce->ics.swb_sizes[g];

  621.                     prev = sce->sf_idx[w*16+g];

  622.                 }

  623.             }

  624.             if (tbits > destbits) {

  625.                 for (i = 0; i < 128; i++)

  626.                     if (sce->sf_idx[i] < 218 - qstep)

  627.                         sce->sf_idx[i] += qstep;

  628.             } else {

  629.                 for (i = 0; i < 128; i++)

  630.                     if (sce->sf_idx[i] > 60 - qstep)

  631.                         sce->sf_idx[i] -= qstep;

  632.             }

  633.             qstep >>= 1;

  634.             if (!qstep && tbits > destbits*1.02 && sce->sf_idx[0] < 217)

  635.                 qstep = 1;

  636.         } while (qstep);

  637. 

  638.         fflag = 0;

  639.         minscaler = av_clip(minscaler, 60, 255 - SCALE_MAX_DIFF);

  640. 

  641.         for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  642.             for (g = 0; g < sce->ics.num_swb; g++) {

  643.                 int prevsc = sce->sf_idx[w*16+g];

  644.                 if (dists[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > 60) {

  645.                     if (find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]-1))

  646.                         sce->sf_idx[w*16+g]--;

  647.                     else //Try to make sure there is some energy in every band

  648.                         sce->sf_idx[w*16+g]-=2;

  649.                 }

  650.                 sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler, minscaler + SCALE_MAX_DIFF);

  651.                 sce->sf_idx[w*16+g] = FFMIN(sce->sf_idx[w*16+g], 219);

  652.                 if (sce->sf_idx[w*16+g] != prevsc)

  653.                     fflag = 1;

  654.                 sce->band_type[w*16+g] = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);

  655.             }

  656.         }

  657.         its++;

  658.     } while (fflag && its < 10);

  659. }

  660. 

  661. static void search_for_quantizers_faac(AVCodecContext *avctx, AACEncContext *s,

  662.                                        SingleChannelElement *sce,

  663.                                        const float lambda)

  664. {

  665.     int start = 0, i, w, w2, g;

  666.     float uplim[128], maxq[128];

  667.     int minq, maxsf;

  668.     float distfact = ((sce->ics.num_windows > 1) ? 85.80 : 147.84) / lambda;

  669.     int last = 0, lastband = 0, curband = 0;

  670.     float avg_energy = 0.0;

  671.     if (sce->ics.num_windows == 1) {

  672.         start = 0;

  673.         for (i = 0; i < 1024; i++) {

  674.             if (i - start >= sce->ics.swb_sizes[curband]) {

  675.                 start += sce->ics.swb_sizes[curband];

  676.                 curband++;

  677.             }

  678.             if (sce->coeffs[i]) {

  679.                 avg_energy += sce->coeffs[i] * sce->coeffs[i];

  680.                 last = i;

  681.                 lastband = curband;

  682.             }

  683.         }

  684.     } else {

  685.         for (w = 0; w < 8; w++) {

  686.             const float *coeffs = &sce->coeffs[w*128];

  687.             curband = start = 0;

  688.             for (i = 0; i < 128; i++) {

  689.                 if (i - start >= sce->ics.swb_sizes[curband]) {

  690.                     start += sce->ics.swb_sizes[curband];

  691.                     curband++;

  692.                 }

  693.                 if (coeffs[i]) {

  694.                     avg_energy += coeffs[i] * coeffs[i];

  695.                     last = FFMAX(last, i);

  696.                     lastband = FFMAX(lastband, curband);

  697.                 }

  698.             }

  699.         }

  700.     }

  701.     last++;

  702.     avg_energy /= last;

  703.     if (avg_energy == 0.0f) {

  704.         for (i = 0; i < FF_ARRAY_ELEMS(sce->sf_idx); i++)

  705.             sce->sf_idx[i] = SCALE_ONE_POS;

  706.         return;

  707.     }

  708.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  709.         start = w*128;

  710.         for (g = 0; g < sce->ics.num_swb; g++) {

  711.             float *coefs   = &sce->coeffs[start];

  712.             const int size = sce->ics.swb_sizes[g];

  713.             int start2 = start, end2 = start + size, peakpos = start;

  714.             float maxval = -1, thr = 0.0f, t;

  715.             maxq[w*16+g] = 0.0f;

  716.             if (g > lastband) {

  717.                 maxq[w*16+g] = 0.0f;

  718.                 start += size;

  719.                 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++)

  720.                     memset(coefs + w2*128, 0, sizeof(coefs[0])*size);

  721.                 continue;

  722.             }

  723.             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

  724.                 for (i = 0; i < size; i++) {

  725.                     float t = coefs[w2*128+i]*coefs[w2*128+i];

  726.                     maxq[w*16+g] = FFMAX(maxq[w*16+g], fabsf(coefs[w2*128 + i]));

  727.                     thr += t;

  728.                     if (sce->ics.num_windows == 1 && maxval < t) {

  729.                         maxval  = t;

  730.                         peakpos = start+i;

  731.                     }

  732.                 }

  733.             }

  734.             if (sce->ics.num_windows == 1) {

  735.                 start2 = FFMAX(peakpos - 2, start2);

  736.                 end2   = FFMIN(peakpos + 3, end2);

  737.             } else {

  738.                 start2 -= start;

  739.                 end2   -= start;

  740.             }

  741.             start += size;

  742.             thr = pow(thr / (avg_energy * (end2 - start2)), 0.3 + 0.1*(lastband - g) / lastband);

  743.             t   = 1.0 - (1.0 * start2 / last);

  744.             uplim[w*16+g] = distfact / (1.4 * thr + t*t*t + 0.075);

  745.         }

  746.     }

  747.     memset(sce->sf_idx, 0, sizeof(sce->sf_idx));

  748.     abs_pow34_v(s->scoefs, sce->coeffs, 1024);

  749.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  750.         start = w*128;

  751.         for (g = 0;  g < sce->ics.num_swb; g++) {

  752.             const float *coefs  = &sce->coeffs[start];

  753.             const float *scaled = &s->scoefs[start];

  754.             const int size      = sce->ics.swb_sizes[g];

  755.             int scf, prev_scf, step;

  756.             int min_scf = -1, max_scf = 256;

  757.             float curdiff;

  758.             if (maxq[w*16+g] < 21.544) {

  759.                 sce->zeroes[w*16+g] = 1;

  760.                 start += size;

  761.                 continue;

  762.             }

  763.             sce->zeroes[w*16+g] = 0;

  764.             scf  = prev_scf = av_clip(SCALE_ONE_POS - SCALE_DIV_512 - log2f(1/maxq[w*16+g])*16/3, 60, 218);

  765.             for (;;) {

  766.                 float dist = 0.0f;

  767.                 int quant_max;

  768. 

  769.                 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

  770.                     int b;

  771.                     dist += quantize_band_cost(s, coefs + w2*128,

  772.                                                scaled + w2*128,

  773.                                                sce->ics.swb_sizes[g],

  774.                                                scf,

  775.                                                ESC_BT,

  776.                                                lambda,

  777.                                                INFINITY,

  778.                                                &b,

  779.                                                0);

  780.                     dist -= b;

  781.                 }

  782.                 dist *= 1.0f / 512.0f / lambda;

  783.                 quant_max = quant(maxq[w*16+g], ff_aac_pow2sf_tab[POW_SF2_ZERO - scf + SCALE_ONE_POS - SCALE_DIV_512], ROUND_STANDARD);

  784.                 if (quant_max >= 8191) { // too much, return to the previous quantizer

  785.                     sce->sf_idx[w*16+g] = prev_scf;

  786.                     break;

  787.                 }

  788.                 prev_scf = scf;

  789.                 curdiff = fabsf(dist - uplim[w*16+g]);

  790.                 if (curdiff <= 1.0f)

  791.                     step = 0;

  792.                 else

  793.                     step = log2f(curdiff);

  794.                 if (dist > uplim[w*16+g])

  795.                     step = -step;

  796.                 scf += step;

  797.                 scf = av_clip_uint8(scf);

  798.                 step = scf - prev_scf;

  799.                 if (FFABS(step) <= 1 || (step > 0 && scf >= max_scf) || (step < 0 && scf <= min_scf)) {

  800.                     sce->sf_idx[w*16+g] = av_clip(scf, min_scf, max_scf);

  801.                     break;

  802.                 }

  803.                 if (step > 0)

  804.                     min_scf = prev_scf;

  805.                 else

  806.                     max_scf = prev_scf;

  807.             }

  808.             start += size;

  809.         }

  810.     }

  811.     minq = sce->sf_idx[0] ? sce->sf_idx[0] : INT_MAX;

  812.     for (i = 1; i < 128; i++) {

  813.         if (!sce->sf_idx[i])

  814.             sce->sf_idx[i] = sce->sf_idx[i-1];

  815.         else

  816.             minq = FFMIN(minq, sce->sf_idx[i]);

  817.     }

  818.     if (minq == INT_MAX)

  819.         minq = 0;

  820.     minq = FFMIN(minq, SCALE_MAX_POS);

  821.     maxsf = FFMIN(minq + SCALE_MAX_DIFF, SCALE_MAX_POS);

  822.     for (i = 126; i >= 0; i--) {

  823.         if (!sce->sf_idx[i])

  824.             sce->sf_idx[i] = sce->sf_idx[i+1];

  825.         sce->sf_idx[i] = av_clip(sce->sf_idx[i], minq, maxsf);

  826.     }

  827. }

  828. 

  829. static void search_for_quantizers_fast(AVCodecContext *avctx, AACEncContext *s,

  830.                                        SingleChannelElement *sce,

  831.                                        const float lambda)

  832. {

  833.     int i, w, w2, g;

  834.     int minq = 255;

  835. 

  836.     memset(sce->sf_idx, 0, sizeof(sce->sf_idx));

  837.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  838.         for (g = 0; g < sce->ics.num_swb; g++) {

  839.             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

  840.                 FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];

  841.                 if (band->energy <= band->threshold) {

  842.                     sce->sf_idx[(w+w2)*16+g] = 218;

  843.                     sce->zeroes[(w+w2)*16+g] = 1;

  844.                 } else {

  845.                     sce->sf_idx[(w+w2)*16+g] = av_clip(SCALE_ONE_POS - SCALE_DIV_512 + log2f(band->threshold), 80, 218);

  846.                     sce->zeroes[(w+w2)*16+g] = 0;

  847.                 }

  848.                 minq = FFMIN(minq, sce->sf_idx[(w+w2)*16+g]);

  849.             }

  850.         }

  851.     }

  852.     for (i = 0; i < 128; i++) {

  853.         sce->sf_idx[i] = 140;

  854.         //av_clip(sce->sf_idx[i], minq, minq + SCALE_MAX_DIFF - 1);

  855.     }

  856.     //set the same quantizers inside window groups

  857.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])

  858.         for (g = 0;  g < sce->ics.num_swb; g++)

  859.             for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)

  860.                 sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];

  861. }

  862. 

  863. static void search_for_pns(AACEncContext *s, AVCodecContext *avctx, SingleChannelElement *sce)

  864. {

  865.     FFPsyBand *band;

  866.     int w, g, w2, i, start, count = 0;

  867.     float *PNS = &s->scoefs[0*128], *PNS34 = &s->scoefs[1*128];

  868.     float *NOR34 = &s->scoefs[3*128];

  869.     const float lambda = s->lambda;

  870.     const float freq_mult = avctx->sample_rate/(1024.0f/sce->ics.num_windows)/2.0f;

  871.     const float thr_mult = NOISE_LAMBDA_REPLACE*(100.0f/lambda);

  872.     const float spread_threshold = NOISE_SPREAD_THRESHOLD*(lambda/100.f);

  873. 

  874.     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

  875.         start = 0;

  876.         for (g = 0;  g < sce->ics.num_swb; g++) {

  877.             int noise_sfi, try_pns = 0;

  878.             float dist1 = 0.0f, dist2 = 0.0f, noise_amp;

  879.             float pns_energy = 0.0f, energy_ratio, dist_thresh;

  880.             float sfb_energy = 0.0f, threshold = 0.0f, spread = 0.0f;

  881.             float freq_boost = FFMAX(0.88f*start*freq_mult/NOISE_LOW_LIMIT, 1.0f);

  882.             if (start*freq_mult < NOISE_LOW_LIMIT) {

  883.                 start += sce->ics.swb_sizes[g];

  884.                 continue;

  885.             } else {

  886.                 dist_thresh = FFMIN(0.008f*(NOISE_LOW_LIMIT/start*freq_mult), 1.11f);

  887.             }

  888.             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

  889.                 band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];

  890.                 sfb_energy += band->energy;

  891.                 spread     += band->spread;

  892.                 threshold  += band->threshold;

  893.             }

  894. 

  895.             if (sce->zeroes[w*16+g]) {

  896.                 try_pns = 1;

  897.             } else if (sfb_energy < threshold*freq_boost) {

  898.                 try_pns = 1;

  899.             } else if (spread > spread_threshold) {

  900.                 try_pns = 0;

  901.             } else if (sfb_energy < threshold*thr_mult*freq_boost) {

  902.                 try_pns = 1;

  903.             }

  904. 

  905.             if (!try_pns || !sfb_energy) {

  906.                 start += sce->ics.swb_sizes[g];

  907.                 continue;

  908.             }

  909. 

  910.             noise_sfi = av_clip(roundf(log2f(sfb_energy)*2), -100, 155); /* Quantize */

  911.             noise_amp = -ff_aac_pow2sf_tab[noise_sfi + POW_SF2_ZERO];    /* Dequantize */

  912.             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

  913.                 float band_energy, scale;

  914.                 band = &s->psy.ch[s->cur_channel+0].psy_bands[(w+w2)*16+g];

  915.                 for (i = 0; i < sce->ics.swb_sizes[g]; i++)

  916.                     PNS[i] = s->random_state = lcg_random(s->random_state);

  917.                 band_energy = s->fdsp->scalarproduct_float(PNS, PNS, sce->ics.swb_sizes[g]);

  918.                 scale = noise_amp/sqrtf(band_energy);

  919.                 s->fdsp->vector_fmul_scalar(PNS, PNS, scale, sce->ics.swb_sizes[g]);

  920.                 pns_energy += s->fdsp->scalarproduct_float(PNS, PNS, sce->ics.swb_sizes[g]);

  921.                 abs_pow34_v(NOR34, &sce->coeffs[start+(w+w2)*128], sce->ics.swb_sizes[g]);

  922.                 abs_pow34_v(PNS34, PNS, sce->ics.swb_sizes[g]);

  923.                 dist1 += quantize_band_cost(s, &sce->coeffs[start + (w+w2)*128],

  924.                                             NOR34,

  925.                                             sce->ics.swb_sizes[g],

  926.                                             sce->sf_idx[(w+w2)*16+g],

  927.                                             sce->band_alt[(w+w2)*16+g],

  928.                                             lambda/band->threshold, INFINITY, NULL, 0);

  929.                 dist2 += quantize_band_cost(s, PNS,

  930.                                             PNS34,

  931.                                             sce->ics.swb_sizes[g],

  932.                                             noise_sfi,

  933.                                             NOISE_BT,

  934.                                             lambda/band->threshold, INFINITY, NULL, 0);

  935.             }

  936.             energy_ratio = sfb_energy/pns_energy; /* Compensates for quantization error */

  937.             sce->pns_ener[w*16+g] = energy_ratio*sfb_energy;

  938.             if (energy_ratio > 0.80f && energy_ratio < 1.20f && dist1/dist2 > dist_thresh) {

  939.                 sce->band_type[w*16+g] = NOISE_BT;

  940.                 sce->zeroes[w*16+g] = 0;

  941.                 if (sce->band_type[w*16+g-1] != NOISE_BT && /* Prevent holes */

  942.                     sce->band_type[w*16+g-2] == NOISE_BT) {

  943.                     sce->band_type[w*16+g-1] = NOISE_BT;

  944.                     sce->zeroes[w*16+g-1] = 0;

  945.                 }

  946.                 count++;

  947.             }

  948.             start += sce->ics.swb_sizes[g];

  949.         }

  950.     }

  951. }

  952. 

  953. static void search_for_ms(AACEncContext *s, ChannelElement *cpe)

  954. {

  955.     int start = 0, i, w, w2, g;

  956.     float M[128], S[128];

  957.     float *L34 = s->scoefs, *R34 = s->scoefs + 128, *M34 = s->scoefs + 128*2, *S34 = s->scoefs + 128*3;

  958.     const float lambda = s->lambda;

  959.     SingleChannelElement *sce0 = &cpe->ch[0];

  960.     SingleChannelElement *sce1 = &cpe->ch[1];

  961.     if (!cpe->common_window)

  962.         return;

  963.     for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {

  964.         start = 0;

  965.         for (g = 0;  g < sce0->ics.num_swb; g++) {

  966.             if (!cpe->ch[0].zeroes[w*16+g] && !cpe->ch[1].zeroes[w*16+g]) {

  967.                 float dist1 = 0.0f, dist2 = 0.0f;

  968.                 for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {

  969.                     FFPsyBand *band0 = &s->psy.ch[s->cur_channel+0].psy_bands[(w+w2)*16+g];

  970.                     FFPsyBand *band1 = &s->psy.ch[s->cur_channel+1].psy_bands[(w+w2)*16+g];

  971.                     float minthr = FFMIN(band0->threshold, band1->threshold);

  972.                     float maxthr = FFMAX(band0->threshold, band1->threshold);

  973.                     for (i = 0; i < sce0->ics.swb_sizes[g]; i++) {

  974.                         M[i] = (sce0->coeffs[start+(w+w2)*128+i]

  975.                               + sce1->coeffs[start+(w+w2)*128+i]) * 0.5;

  976.                         S[i] =  M[i]

  977.                               - sce1->coeffs[start+(w+w2)*128+i];

  978.                     }

  979.                     abs_pow34_v(L34, sce0->coeffs+start+(w+w2)*128, sce0->ics.swb_sizes[g]);

  980.                     abs_pow34_v(R34, sce1->coeffs+start+(w+w2)*128, sce0->ics.swb_sizes[g]);

  981.                     abs_pow34_v(M34, M,                         sce0->ics.swb_sizes[g]);

  982.                     abs_pow34_v(S34, S,                         sce0->ics.swb_sizes[g]);

  983.                     dist1 += quantize_band_cost(s, &sce0->coeffs[start + (w+w2)*128],

  984.                                                 L34,

  985.                                                 sce0->ics.swb_sizes[g],

  986.                                                 sce0->sf_idx[(w+w2)*16+g],

  987.                                                 sce0->band_type[(w+w2)*16+g],

  988.                                                 lambda / band0->threshold, INFINITY, NULL, 0);

  989.                     dist1 += quantize_band_cost(s, &sce1->coeffs[start + (w+w2)*128],

  990.                                                 R34,

  991.                                                 sce1->ics.swb_sizes[g],

  992.                                                 sce1->sf_idx[(w+w2)*16+g],

  993.                                                 sce1->band_type[(w+w2)*16+g],

  994.                                                 lambda / band1->threshold, INFINITY, NULL, 0);

  995.                     dist2 += quantize_band_cost(s, M,

  996.                                                 M34,

  997.                                                 sce0->ics.swb_sizes[g],

  998.                                                 sce0->sf_idx[(w+w2)*16+g],

  999.                                                 sce0->band_type[(w+w2)*16+g],

  1000.                                                 lambda / maxthr, INFINITY, NULL, 0);

  1001.                     dist2 += quantize_band_cost(s, S,

  1002.                                                 S34,

  1003.                                                 sce1->ics.swb_sizes[g],

  1004.                                                 sce1->sf_idx[(w+w2)*16+g],

  1005.                                                 sce1->band_type[(w+w2)*16+g],

  1006.                                                 lambda / minthr, INFINITY, NULL, 0);

  1007.                 }

  1008.                 cpe->ms_mask[w*16+g] = dist2 < dist1;

  1009.             }

  1010.             start += sce0->ics.swb_sizes[g];

  1011.         }

  1012.     }

  1013. }

  1014. 

  1015. AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB] = {

  1016.     [AAC_CODER_FAAC] = {

  1017.         search_for_quantizers_faac,

  1018.         encode_window_bands_info,

  1019.         quantize_and_encode_band,

  1020.         ff_aac_encode_tns_info,

  1021.         ff_aac_encode_main_pred,

  1022.         ff_aac_adjust_common_prediction,

  1023.         ff_aac_apply_main_pred,

  1024.         ff_aac_apply_tns,

  1025.         set_special_band_scalefactors,

  1026.         search_for_pns,

  1027.         ff_aac_search_for_tns,

  1028.         search_for_ms,

  1029.         ff_aac_search_for_is,

  1030.         ff_aac_search_for_pred,

  1031.     },

  1032.     [AAC_CODER_ANMR] = {

  1033.         search_for_quantizers_anmr,

  1034.         encode_window_bands_info,

  1035.         quantize_and_encode_band,

  1036.         ff_aac_encode_tns_info,

  1037.         ff_aac_encode_main_pred,

  1038.         ff_aac_adjust_common_prediction,

  1039.         ff_aac_apply_main_pred,

  1040.         ff_aac_apply_tns,

  1041.         set_special_band_scalefactors,

  1042.         search_for_pns,

  1043.         ff_aac_search_for_tns,

  1044.         search_for_ms,

  1045.         ff_aac_search_for_is,

  1046.         ff_aac_search_for_pred,

  1047.     },

  1048.     [AAC_CODER_TWOLOOP] = {

  1049.         search_for_quantizers_twoloop,

  1050.         codebook_trellis_rate,

  1051.         quantize_and_encode_band,

  1052.         ff_aac_encode_tns_info,

  1053.         ff_aac_encode_main_pred,

  1054.         ff_aac_adjust_common_prediction,

  1055.         ff_aac_apply_main_pred,

  1056.         ff_aac_apply_tns,

  1057.         set_special_band_scalefactors,

  1058.         search_for_pns,

  1059.         ff_aac_search_for_tns,

  1060.         search_for_ms,

  1061.         ff_aac_search_for_is,

  1062.         ff_aac_search_for_pred,

  1063.     },

  1064.     [AAC_CODER_FAST] = {

  1065.         search_for_quantizers_fast,

  1066.         encode_window_bands_info,

  1067.         quantize_and_encode_band,

  1068.         ff_aac_encode_tns_info,

  1069.         ff_aac_encode_main_pred,

  1070.         ff_aac_adjust_common_prediction,

  1071.         ff_aac_apply_main_pred,

  1072.         ff_aac_apply_tns,

  1073.         set_special_band_scalefactors,

  1074.         search_for_pns,

  1075.         ff_aac_search_for_tns,

  1076.         search_for_ms,

  1077.         ff_aac_search_for_is,

  1078.         ff_aac_search_for_pred,

  1079.     },

  1080. };