aaccoder.c 44 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * AAC coefficients encoder
 * Copyright (C) 2008-2009 Konstantin Shishkov
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
23
 * @file
24 25 26 27 28 29 30 31 32
 * AAC coefficients encoder
 */

/***********************************
 *              TODOs:
 * speedup quantizer selection
 * add sane pulse detection
 ***********************************/

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

35
#include <float.h>
36
#include "libavutil/mathematics.h"
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
#include "avcodec.h"
#include "put_bits.h"
#include "aac.h"
#include "aacenc.h"
#include "aactab.h"

/** bits needed to code codebook run value for long windows */
static const uint8_t run_value_bits_long[64] = {
     5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
     5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5, 10,
    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 15
};

/** bits needed to code codebook run value for short windows */
static const uint8_t run_value_bits_short[16] = {
    3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 9
};

56
static const uint8_t *run_value_bits[2] = {
57 58 59 60 61 62 63 64 65 66 67
    run_value_bits_long, run_value_bits_short
};


/**
 * Quantize one coefficient.
 * @return absolute value of the quantized coefficient
 * @see 3GPP TS26.403 5.6.2 "Scalefactor determination"
 */
static av_always_inline int quant(float coef, const float Q)
{
68 69
    float a = coef * Q;
    return sqrtf(a * sqrtf(a)) + 0.4054;
70 71
}

72
static void quantize_bands(int *out, const float *in, const float *scaled,
73
                           int size, float Q34, int is_signed, int maxval)
74 75 76 77 78
{
    int i;
    double qc;
    for (i = 0; i < size; i++) {
        qc = scaled[i] * Q34;
79
        out[i] = (int)FFMIN(qc + 0.4054, (double)maxval);
80
        if (is_signed && in[i] < 0.0f) {
81
            out[i] = -out[i];
82 83 84 85
        }
    }
}

86
static void abs_pow34_v(float *out, const float *in, const int size)
87 88 89
{
#ifndef USE_REALLY_FULL_SEARCH
    int i;
90 91 92 93
    for (i = 0; i < size; i++) {
        float a = fabsf(in[i]);
        out[i] = sqrtf(a * sqrtf(a));
    }
94 95 96 97 98 99 100 101 102 103 104
#endif /* USE_REALLY_FULL_SEARCH */
}

static const uint8_t aac_cb_range [12] = {0, 3, 3, 3, 3, 9, 9, 8, 8, 13, 13, 17};
static const uint8_t aac_cb_maxval[12] = {0, 1, 1, 2, 2, 4, 4, 7, 7, 12, 12, 16};

/**
 * Calculate rate distortion cost for quantizing with given codebook
 *
 * @return quantization distortion
 */
105 106
static av_always_inline float quantize_and_encode_band_cost_template(
                                struct AACEncContext *s,
107
                                PutBitContext *pb, const float *in,
108 109
                                const float *scaled, int size, int scale_idx,
                                int cb, const float lambda, const float uplim,
110 111
                                int *bits, int BT_ZERO, int BT_UNSIGNED,
                                int BT_PAIR, int BT_ESC)
112
{
113 114 115 116
    const int q_idx = POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512;
    const float Q   = ff_aac_pow2sf_tab [q_idx];
    const float Q34 = ff_aac_pow34sf_tab[q_idx];
    const float IQ  = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
117
    const float CLIPPED_ESCAPE = 165140.0f*IQ;
118
    int i, j;
119
    float cost = 0;
120
    const int dim = BT_PAIR ? 2 : 4;
121
    int resbits = 0;
122
    const int range  = aac_cb_range[cb];
123
    const int maxval = aac_cb_maxval[cb];
124
    int off;
125

126
    if (BT_ZERO) {
127
        for (i = 0; i < size; i++)
128
            cost += in[i]*in[i];
129 130
        if (bits)
            *bits = 0;
131
        return cost * lambda;
132
    }
133 134 135 136
    if (!scaled) {
        abs_pow34_v(s->scoefs, in, size);
        scaled = s->scoefs;
    }
137 138
    quantize_bands(s->qcoefs, in, scaled, size, Q34, !BT_UNSIGNED, maxval);
    if (BT_UNSIGNED) {
139 140 141 142
        off = 0;
    } else {
        off = maxval;
    }
143
    for (i = 0; i < size; i += dim) {
144
        const float *vec;
145 146 147 148 149 150 151 152
        int *quants = s->qcoefs + i;
        int curidx = 0;
        int curbits;
        float rd = 0.0f;
        for (j = 0; j < dim; j++) {
            curidx *= range;
            curidx += quants[j] + off;
        }
153 154 155
        curbits =  ff_aac_spectral_bits[cb-1][curidx];
        vec     = &ff_aac_codebook_vectors[cb-1][curidx*dim];
        if (BT_UNSIGNED) {
156 157
            for (j = 0; j < dim; j++) {
                float t = fabsf(in[i+j]);
158
                float di;
159
                if (BT_ESC && vec[j] == 64.0f) { //FIXME: slow
160 161 162
                    if (t >= CLIPPED_ESCAPE) {
                        di = t - CLIPPED_ESCAPE;
                        curbits += 21;
163
                    } else {
164 165 166
                        int c = av_clip(quant(t, Q), 0, 8191);
                        di = t - c*cbrtf(c)*IQ;
                        curbits += av_log2(c)*2 - 4 + 1;
167
                    }
168
                } else {
169
                    di = t - vec[j]*IQ;
170
                }
171
                if (vec[j] != 0.0f)
172 173 174 175
                    curbits++;
                rd += di*di;
            }
        } else {
176 177
            for (j = 0; j < dim; j++) {
                float di = in[i+j] - vec[j]*IQ;
178
                rd += di*di;
179
            }
180
        }
181 182
        cost    += rd * lambda + curbits;
        resbits += curbits;
183
        if (cost >= uplim)
184
            return uplim;
185
        if (pb) {
Alex Converse's avatar
Alex Converse committed
186 187 188 189 190 191 192 193 194 195 196 197 198 199
            put_bits(pb, ff_aac_spectral_bits[cb-1][curidx], ff_aac_spectral_codes[cb-1][curidx]);
            if (BT_UNSIGNED)
                for (j = 0; j < dim; j++)
                    if (ff_aac_codebook_vectors[cb-1][curidx*dim+j] != 0.0f)
                        put_bits(pb, 1, in[i+j] < 0.0f);
            if (BT_ESC) {
                for (j = 0; j < 2; j++) {
                    if (ff_aac_codebook_vectors[cb-1][curidx*2+j] == 64.0f) {
                        int coef = av_clip(quant(fabsf(in[i+j]), Q), 0, 8191);
                        int len = av_log2(coef);

                        put_bits(pb, len - 4 + 1, (1 << (len - 4 + 1)) - 2);
                        put_bits(pb, len, coef & ((1 << len) - 1));
                    }
200 201 202 203
                }
            }
        }
    }
204 205 206 207 208

    if (bits)
        *bits = resbits;
    return cost;
}
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229

#define QUANTIZE_AND_ENCODE_BAND_COST_FUNC(NAME, BT_ZERO, BT_UNSIGNED, BT_PAIR, BT_ESC) \
static float quantize_and_encode_band_cost_ ## NAME(                                        \
                                struct AACEncContext *s,                                \
                                PutBitContext *pb, const float *in,                     \
                                const float *scaled, int size, int scale_idx,           \
                                int cb, const float lambda, const float uplim,          \
                                int *bits) {                                            \
    return quantize_and_encode_band_cost_template(                                      \
                                s, pb, in, scaled, size, scale_idx,                     \
                                BT_ESC ? ESC_BT : cb, lambda, uplim, bits,              \
                                BT_ZERO, BT_UNSIGNED, BT_PAIR, BT_ESC);                 \
}

QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ZERO,  1, 0, 0, 0)
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(SQUAD, 0, 0, 0, 0)
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(UQUAD, 0, 1, 0, 0)
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(SPAIR, 0, 0, 1, 0)
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(UPAIR, 0, 1, 1, 0)
QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ESC,   0, 1, 1, 1)

230
static float (*const quantize_and_encode_band_cost_arr[])(
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
                                struct AACEncContext *s,
                                PutBitContext *pb, const float *in,
                                const float *scaled, int size, int scale_idx,
                                int cb, const float lambda, const float uplim,
                                int *bits) = {
    quantize_and_encode_band_cost_ZERO,
    quantize_and_encode_band_cost_SQUAD,
    quantize_and_encode_band_cost_SQUAD,
    quantize_and_encode_band_cost_UQUAD,
    quantize_and_encode_band_cost_UQUAD,
    quantize_and_encode_band_cost_SPAIR,
    quantize_and_encode_band_cost_SPAIR,
    quantize_and_encode_band_cost_UPAIR,
    quantize_and_encode_band_cost_UPAIR,
    quantize_and_encode_band_cost_UPAIR,
    quantize_and_encode_band_cost_UPAIR,
    quantize_and_encode_band_cost_ESC,
};

#define quantize_and_encode_band_cost(                                  \
                                s, pb, in, scaled, size, scale_idx, cb, \
                                lambda, uplim, bits)                    \
    quantize_and_encode_band_cost_arr[cb](                              \
                                s, pb, in, scaled, size, scale_idx, cb, \
                                lambda, uplim, bits)

257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
static float quantize_band_cost(struct AACEncContext *s, const float *in,
                                const float *scaled, int size, int scale_idx,
                                int cb, const float lambda, const float uplim,
                                int *bits)
{
    return quantize_and_encode_band_cost(s, NULL, in, scaled, size, scale_idx,
                                         cb, lambda, uplim, bits);
}

static void quantize_and_encode_band(struct AACEncContext *s, PutBitContext *pb,
                                     const float *in, int size, int scale_idx,
                                     int cb, const float lambda)
{
    quantize_and_encode_band_cost(s, pb, in, NULL, size, scale_idx, cb, lambda,
                                  INFINITY, NULL);
272 273
}

274
static float find_max_val(int group_len, int swb_size, const float *scaled) {
275
    float maxval = 0.0f;
276
    int w2, i;
277 278 279 280 281
    for (w2 = 0; w2 < group_len; w2++) {
        for (i = 0; i < swb_size; i++) {
            maxval = FFMAX(maxval, scaled[w2*128+i]);
        }
    }
282 283 284 285
    return maxval;
}

static int find_min_book(float maxval, int sf) {
286
    float Q = ff_aac_pow2sf_tab[POW_SF2_ZERO - sf + SCALE_ONE_POS - SCALE_DIV_512];
287 288
    float Q34 = sqrtf(Q * sqrtf(Q));
    int qmaxval, cb;
289 290 291 292 293 294 295 296 297 298 299
    qmaxval = maxval * Q34 + 0.4054f;
    if      (qmaxval ==  0) cb = 0;
    else if (qmaxval ==  1) cb = 1;
    else if (qmaxval ==  2) cb = 3;
    else if (qmaxval <=  4) cb = 5;
    else if (qmaxval <=  7) cb = 7;
    else if (qmaxval <= 12) cb = 9;
    else                    cb = 11;
    return cb;
}

300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
/**
 * structure used in optimal codebook search
 */
typedef struct BandCodingPath {
    int prev_idx; ///< pointer to the previous path point
    float cost;   ///< path cost
    int run;
} BandCodingPath;

/**
 * Encode band info for single window group bands.
 */
static void encode_window_bands_info(AACEncContext *s, SingleChannelElement *sce,
                                     int win, int group_len, const float lambda)
{
    BandCodingPath path[120][12];
Mans Rullgard's avatar
Mans Rullgard committed
316
    int w, swb, cb, start, size;
317
    int i, j;
318
    const int max_sfb  = sce->ics.max_sfb;
319
    const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
320
    const int run_esc  = (1 << run_bits) - 1;
321 322 323 324 325 326 327
    int idx, ppos, count;
    int stackrun[120], stackcb[120], stack_len;
    float next_minrd = INFINITY;
    int next_mincb = 0;

    abs_pow34_v(s->scoefs, sce->coeffs, 1024);
    start = win*128;
328
    for (cb = 0; cb < 12; cb++) {
329
        path[0][cb].cost     = 0.0f;
330
        path[0][cb].prev_idx = -1;
331
        path[0][cb].run      = 0;
332
    }
333
    for (swb = 0; swb < max_sfb; swb++) {
334
        size = sce->ics.swb_sizes[swb];
335 336
        if (sce->zeroes[win*16 + swb]) {
            for (cb = 0; cb < 12; cb++) {
337
                path[swb+1][cb].prev_idx = cb;
338 339
                path[swb+1][cb].cost     = path[swb][cb].cost;
                path[swb+1][cb].run      = path[swb][cb].run + 1;
340
            }
341
        } else {
342 343 344 345
            float minrd = next_minrd;
            int mincb = next_mincb;
            next_minrd = INFINITY;
            next_mincb = 0;
346
            for (cb = 0; cb < 12; cb++) {
347 348
                float cost_stay_here, cost_get_here;
                float rd = 0.0f;
349
                for (w = 0; w < group_len; w++) {
350
                    FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(win+w)*16+swb];
351 352 353 354 355 356 357
                    rd += quantize_band_cost(s, sce->coeffs + start + w*128,
                                             s->scoefs + start + w*128, size,
                                             sce->sf_idx[(win+w)*16+swb], cb,
                                             lambda / band->threshold, INFINITY, NULL);
                }
                cost_stay_here = path[swb][cb].cost + rd;
                cost_get_here  = minrd              + rd + run_bits + 4;
358
                if (   run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
359
                    != run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
                    cost_stay_here += run_bits;
                if (cost_get_here < cost_stay_here) {
                    path[swb+1][cb].prev_idx = mincb;
                    path[swb+1][cb].cost     = cost_get_here;
                    path[swb+1][cb].run      = 1;
                } else {
                    path[swb+1][cb].prev_idx = cb;
                    path[swb+1][cb].cost     = cost_stay_here;
                    path[swb+1][cb].run      = path[swb][cb].run + 1;
                }
                if (path[swb+1][cb].cost < next_minrd) {
                    next_minrd = path[swb+1][cb].cost;
                    next_mincb = cb;
                }
            }
        }
        start += sce->ics.swb_sizes[swb];
    }

    //convert resulting path from backward-linked list
    stack_len = 0;
381
    idx       = 0;
382
    for (cb = 1; cb < 12; cb++)
383
        if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)
384 385
            idx = cb;
    ppos = max_sfb;
386
    while (ppos > 0) {
387 388 389 390 391 392 393 394 395
        cb = idx;
        stackrun[stack_len] = path[ppos][cb].run;
        stackcb [stack_len] = cb;
        idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;
        ppos -= path[ppos][cb].run;
        stack_len++;
    }
    //perform actual band info encoding
    start = 0;
396
    for (i = stack_len - 1; i >= 0; i--) {
397 398 399 400
        put_bits(&s->pb, 4, stackcb[i]);
        count = stackrun[i];
        memset(sce->zeroes + win*16 + start, !stackcb[i], count);
        //XXX: memset when band_type is also uint8_t
401
        for (j = 0; j < count; j++) {
402 403 404
            sce->band_type[win*16 + start] =  stackcb[i];
            start++;
        }
405
        while (count >= run_esc) {
406 407 408 409 410 411 412
            put_bits(&s->pb, run_bits, run_esc);
            count -= run_esc;
        }
        put_bits(&s->pb, run_bits, count);
    }
}

413 414 415 416
static void codebook_trellis_rate(AACEncContext *s, SingleChannelElement *sce,
                                  int win, int group_len, const float lambda)
{
    BandCodingPath path[120][12];
Mans Rullgard's avatar
Mans Rullgard committed
417
    int w, swb, cb, start, size;
418 419 420 421 422 423
    int i, j;
    const int max_sfb  = sce->ics.max_sfb;
    const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
    const int run_esc  = (1 << run_bits) - 1;
    int idx, ppos, count;
    int stackrun[120], stackcb[120], stack_len;
424
    float next_minbits = INFINITY;
425 426 427 428 429 430 431 432 433 434 435 436
    int next_mincb = 0;

    abs_pow34_v(s->scoefs, sce->coeffs, 1024);
    start = win*128;
    for (cb = 0; cb < 12; cb++) {
        path[0][cb].cost     = run_bits+4;
        path[0][cb].prev_idx = -1;
        path[0][cb].run      = 0;
    }
    for (swb = 0; swb < max_sfb; swb++) {
        size = sce->ics.swb_sizes[swb];
        if (sce->zeroes[win*16 + swb]) {
437
            float cost_stay_here = path[swb][0].cost;
438
            float cost_get_here  = next_minbits + run_bits + 4;
439 440 441 442 443 444 445 446 447 448 449 450
            if (   run_value_bits[sce->ics.num_windows == 8][path[swb][0].run]
                != run_value_bits[sce->ics.num_windows == 8][path[swb][0].run+1])
                cost_stay_here += run_bits;
            if (cost_get_here < cost_stay_here) {
                path[swb+1][0].prev_idx = next_mincb;
                path[swb+1][0].cost     = cost_get_here;
                path[swb+1][0].run      = 1;
            } else {
                path[swb+1][0].prev_idx = 0;
                path[swb+1][0].cost     = cost_stay_here;
                path[swb+1][0].run      = path[swb][0].run + 1;
            }
451
            next_minbits = path[swb+1][0].cost;
452 453 454 455 456
            next_mincb = 0;
            for (cb = 1; cb < 12; cb++) {
                path[swb+1][cb].cost = 61450;
                path[swb+1][cb].prev_idx = -1;
                path[swb+1][cb].run = 0;
457 458
            }
        } else {
459
            float minbits = next_minbits;
460 461
            int mincb = next_mincb;
            int startcb = sce->band_type[win*16+swb];
462
            next_minbits = INFINITY;
463 464 465 466 467 468 469 470
            next_mincb = 0;
            for (cb = 0; cb < startcb; cb++) {
                path[swb+1][cb].cost = 61450;
                path[swb+1][cb].prev_idx = -1;
                path[swb+1][cb].run = 0;
            }
            for (cb = startcb; cb < 12; cb++) {
                float cost_stay_here, cost_get_here;
471
                float bits = 0.0f;
472
                for (w = 0; w < group_len; w++) {
473 474 475 476
                    bits += quantize_band_cost(s, sce->coeffs + start + w*128,
                                               s->scoefs + start + w*128, size,
                                               sce->sf_idx[(win+w)*16+swb], cb,
                                               0, INFINITY, NULL);
477
                }
478 479
                cost_stay_here = path[swb][cb].cost + bits;
                cost_get_here  = minbits            + bits + run_bits + 4;
480 481 482 483 484 485 486 487 488 489 490 491
                if (   run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
                    != run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])
                    cost_stay_here += run_bits;
                if (cost_get_here < cost_stay_here) {
                    path[swb+1][cb].prev_idx = mincb;
                    path[swb+1][cb].cost     = cost_get_here;
                    path[swb+1][cb].run      = 1;
                } else {
                    path[swb+1][cb].prev_idx = cb;
                    path[swb+1][cb].cost     = cost_stay_here;
                    path[swb+1][cb].run      = path[swb][cb].run + 1;
                }
492 493
                if (path[swb+1][cb].cost < next_minbits) {
                    next_minbits = path[swb+1][cb].cost;
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
                    next_mincb = cb;
                }
            }
        }
        start += sce->ics.swb_sizes[swb];
    }

    //convert resulting path from backward-linked list
    stack_len = 0;
    idx       = 0;
    for (cb = 1; cb < 12; cb++)
        if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)
            idx = cb;
    ppos = max_sfb;
    while (ppos > 0) {
509
        av_assert1(idx >= 0);
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535
        cb = idx;
        stackrun[stack_len] = path[ppos][cb].run;
        stackcb [stack_len] = cb;
        idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;
        ppos -= path[ppos][cb].run;
        stack_len++;
    }
    //perform actual band info encoding
    start = 0;
    for (i = stack_len - 1; i >= 0; i--) {
        put_bits(&s->pb, 4, stackcb[i]);
        count = stackrun[i];
        memset(sce->zeroes + win*16 + start, !stackcb[i], count);
        //XXX: memset when band_type is also uint8_t
        for (j = 0; j < count; j++) {
            sce->band_type[win*16 + start] =  stackcb[i];
            start++;
        }
        while (count >= run_esc) {
            put_bits(&s->pb, run_bits, run_esc);
            count -= run_esc;
        }
        put_bits(&s->pb, run_bits, count);
    }
}

536 537
/** Return the minimum scalefactor where the quantized coef does not clip. */
static av_always_inline uint8_t coef2minsf(float coef) {
538
    return av_clip_uint8(log2f(coef)*4 - 69 + SCALE_ONE_POS - SCALE_DIV_512);
539 540 541 542
}

/** Return the maximum scalefactor where the quantized coef is not zero. */
static av_always_inline uint8_t coef2maxsf(float coef) {
543
    return av_clip_uint8(log2f(coef)*4 +  6 + SCALE_ONE_POS - SCALE_DIV_512);
544 545
}

546 547 548 549 550
typedef struct TrellisPath {
    float cost;
    int prev;
} TrellisPath;

551
#define TRELLIS_STAGES 121
552
#define TRELLIS_STATES (SCALE_MAX_DIFF+1)
553

554
static void search_for_quantizers_anmr(AVCodecContext *avctx, AACEncContext *s,
555 556
                                       SingleChannelElement *sce,
                                       const float lambda)
557 558
{
    int q, w, w2, g, start = 0;
559
    int i, j;
560
    int idx;
561 562
    TrellisPath paths[TRELLIS_STAGES][TRELLIS_STATES];
    int bandaddr[TRELLIS_STAGES];
563 564
    int minq;
    float mincost;
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
    float q0f = FLT_MAX, q1f = 0.0f, qnrgf = 0.0f;
    int q0, q1, qcnt = 0;

    for (i = 0; i < 1024; i++) {
        float t = fabsf(sce->coeffs[i]);
        if (t > 0.0f) {
            q0f = FFMIN(q0f, t);
            q1f = FFMAX(q1f, t);
            qnrgf += t*t;
            qcnt++;
        }
    }

    if (!qcnt) {
        memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
        memset(sce->zeroes, 1, sizeof(sce->zeroes));
        return;
    }

    //minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped
585
    q0 = coef2minsf(q0f);
586
    //maximum scalefactor index is when maximum coefficient after quantizing is still not zero
587
    q1 = coef2maxsf(q1f);
588 589 590 591
    if (q1 - q0 > 60) {
        int q0low  = q0;
        int q1high = q1;
        //minimum scalefactor index is when maximum nonzero coefficient after quantizing is not clipped
592
        int qnrg = av_clip_uint8(log2f(sqrtf(qnrgf/qcnt))*4 - 31 + SCALE_ONE_POS - SCALE_DIV_512);
593 594 595 596 597 598 599 600 601 602
        q1 = qnrg + 30;
        q0 = qnrg - 30;
        if (q0 < q0low) {
            q1 += q0low - q0;
            q0  = q0low;
        } else if (q1 > q1high) {
            q0 -= q1 - q1high;
            q1  = q1high;
        }
    }
603

604
    for (i = 0; i < TRELLIS_STATES; i++) {
605 606
        paths[0][i].cost    = 0.0f;
        paths[0][i].prev    = -1;
607
    }
608 609
    for (j = 1; j < TRELLIS_STAGES; j++) {
        for (i = 0; i < TRELLIS_STATES; i++) {
610 611 612
            paths[j][i].cost    = INFINITY;
            paths[j][i].prev    = -2;
        }
613
    }
614
    idx = 1;
615
    abs_pow34_v(s->scoefs, sce->coeffs, 1024);
616
    for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
617
        start = w*128;
618
        for (g = 0; g < sce->ics.num_swb; g++) {
619 620 621 622
            const float *coefs = sce->coeffs + start;
            float qmin, qmax;
            int nz = 0;

623
            bandaddr[idx] = w * 16 + g;
624 625
            qmin = INT_MAX;
            qmax = 0.0f;
626
            for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
627
                FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
628
                if (band->energy <= band->threshold || band->threshold == 0.0f) {
629 630 631 632 633
                    sce->zeroes[(w+w2)*16+g] = 1;
                    continue;
                }
                sce->zeroes[(w+w2)*16+g] = 0;
                nz = 1;
634
                for (i = 0; i < sce->ics.swb_sizes[g]; i++) {
635
                    float t = fabsf(coefs[w2*128+i]);
636
                    if (t > 0.0f)
637 638
                        qmin = FFMIN(qmin, t);
                    qmax = FFMAX(qmax, t);
639 640
                }
            }
641
            if (nz) {
642 643
                int minscale, maxscale;
                float minrd = INFINITY;
644
                float maxval;
645
                //minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped
646
                minscale = coef2minsf(qmin);
647
                //maximum scalefactor index is when maximum coefficient after quantizing is still not zero
648
                maxscale = coef2maxsf(qmax);
649 650
                minscale = av_clip(minscale - q0, 0, TRELLIS_STATES - 1);
                maxscale = av_clip(maxscale - q0, 0, TRELLIS_STATES);
651
                maxval = find_max_val(sce->ics.group_len[w], sce->ics.swb_sizes[g], s->scoefs+start);
652
                for (q = minscale; q < maxscale; q++) {
653
                    float dist = 0;
654
                    int cb = find_min_book(maxval, sce->sf_idx[w*16+g]);
655
                    for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
656
                        FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
657
                        dist += quantize_band_cost(s, coefs + w2*128, s->scoefs + start + w2*128, sce->ics.swb_sizes[g],
Alex Converse's avatar
Alex Converse committed
658
                                                   q + q0, cb, lambda / band->threshold, INFINITY, NULL);
659
                    }
660
                    minrd = FFMIN(minrd, dist);
661

662
                    for (i = 0; i < q1 - q0; i++) {
663
                        float cost;
664
                        cost = paths[idx - 1][i].cost + dist
665
                               + ff_aac_scalefactor_bits[q - i + SCALE_DIFF_ZERO];
666
                        if (cost < paths[idx][q].cost) {
667 668
                            paths[idx][q].cost    = cost;
                            paths[idx][q].prev    = i;
669 670 671
                        }
                    }
                }
672
            } else {
673
                for (q = 0; q < q1 - q0; q++) {
Alex Converse's avatar
Alex Converse committed
674 675
                    paths[idx][q].cost = paths[idx - 1][q].cost + 1;
                    paths[idx][q].prev = q;
676 677 678 679
                }
            }
            sce->zeroes[w*16+g] = !nz;
            start += sce->ics.swb_sizes[g];
680
            idx++;
681 682
        }
    }
683 684 685
    idx--;
    mincost = paths[idx][0].cost;
    minq    = 0;
686
    for (i = 1; i < TRELLIS_STATES; i++) {
687 688 689
        if (paths[idx][i].cost < mincost) {
            mincost = paths[idx][i].cost;
            minq = i;
690 691
        }
    }
692
    while (idx) {
693
        sce->sf_idx[bandaddr[idx]] = minq + q0;
694 695
        minq = paths[idx][minq].prev;
        idx--;
696 697
    }
    //set the same quantizers inside window groups
698 699 700
    for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
        for (g = 0;  g < sce->ics.num_swb; g++)
            for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)
701 702 703 704 705 706
                sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];
}

/**
 * two-loop quantizers search taken from ISO 13818-7 Appendix C
 */
707 708 709 710
static void search_for_quantizers_twoloop(AVCodecContext *avctx,
                                          AACEncContext *s,
                                          SingleChannelElement *sce,
                                          const float lambda)
711 712
{
    int start = 0, i, w, w2, g;
713
    int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate / avctx->channels * (lambda / 120.f);
714
    float dists[128] = { 0 }, uplims[128];
715
    float maxvals[128];
716
    int fflag, minscaler;
717
    int its  = 0;
718 719 720
    int allz = 0;
    float minthr = INFINITY;

721 722 723
    // for values above this the decoder might end up in an endless loop
    // due to always having more bits than what can be encoded.
    destbits = FFMIN(destbits, 5800);
724 725
    //XXX: some heuristic to determine initial quantizers will reduce search time
    //determine zero bands and upper limits
726 727
    for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
        for (g = 0;  g < sce->ics.num_swb; g++) {
728 729
            int nz = 0;
            float uplim = 0.0f;
730
            for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
731
                FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
732
                uplim += band->threshold;
733
                if (band->energy <= band->threshold || band->threshold == 0.0f) {
734 735 736 737 738 739 740
                    sce->zeroes[(w+w2)*16+g] = 1;
                    continue;
                }
                nz = 1;
            }
            uplims[w*16+g] = uplim *512;
            sce->zeroes[w*16+g] = !nz;
741
            if (nz)
742
                minthr = FFMIN(minthr, uplim);
743
            allz |= nz;
744 745
        }
    }
746 747 748
    for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
        for (g = 0;  g < sce->ics.num_swb; g++) {
            if (sce->zeroes[w*16+g]) {
749 750 751
                sce->sf_idx[w*16+g] = SCALE_ONE_POS;
                continue;
            }
752
            sce->sf_idx[w*16+g] = SCALE_ONE_POS + FFMIN(log2f(uplims[w*16+g]/minthr)*4,59);
753 754 755
        }
    }

756
    if (!allz)
757 758
        return;
    abs_pow34_v(s->scoefs, sce->coeffs, 1024);
759 760 761 762 763 764 765 766 767 768

    for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
        start = w*128;
        for (g = 0;  g < sce->ics.num_swb; g++) {
            const float *scaled = s->scoefs + start;
            maxvals[w*16+g] = find_max_val(sce->ics.group_len[w], sce->ics.swb_sizes[g], scaled);
            start += sce->ics.swb_sizes[g];
        }
    }

769 770
    //perform two-loop search
    //outer loop - improve quality
771
    do {
772 773 774 775
        int tbits, qstep;
        minscaler = sce->sf_idx[0];
        //inner loop - quantize spectrum to fit into given number of bits
        qstep = its ? 1 : 32;
776
        do {
777 778 779
            int prev = -1;
            tbits = 0;
            fflag = 0;
780
            for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
781
                start = w*128;
782
                for (g = 0;  g < sce->ics.num_swb; g++) {
783 784 785 786
                    const float *coefs = sce->coeffs + start;
                    const float *scaled = s->scoefs + start;
                    int bits = 0;
                    int cb;
787
                    float dist = 0.0f;
788

789 790
                    if (sce->zeroes[w*16+g] || sce->sf_idx[w*16+g] >= 218) {
                        start += sce->ics.swb_sizes[g];
791
                        continue;
792
                    }
793
                    minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);
794
                    cb = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);
Alex Converse's avatar
Alex Converse committed
795 796 797 798 799 800 801
                    for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
                        int b;
                        dist += quantize_band_cost(s, coefs + w2*128,
                                                   scaled + w2*128,
                                                   sce->ics.swb_sizes[g],
                                                   sce->sf_idx[w*16+g],
                                                   cb,
802
                                                   1.0f,
Alex Converse's avatar
Alex Converse committed
803 804 805 806
                                                   INFINITY,
                                                   &b);
                        bits += b;
                    }
807
                    dists[w*16+g] = dist - bits;
808
                    if (prev != -1) {
809 810 811 812 813 814 815
                        bits += ff_aac_scalefactor_bits[sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO];
                    }
                    tbits += bits;
                    start += sce->ics.swb_sizes[g];
                    prev = sce->sf_idx[w*16+g];
                }
            }
816
            if (tbits > destbits) {
817 818
                for (i = 0; i < 128; i++)
                    if (sce->sf_idx[i] < 218 - qstep)
819
                        sce->sf_idx[i] += qstep;
820
            } else {
821 822
                for (i = 0; i < 128; i++)
                    if (sce->sf_idx[i] > 60 - qstep)
823 824 825
                        sce->sf_idx[i] -= qstep;
            }
            qstep >>= 1;
826
            if (!qstep && tbits > destbits*1.02 && sce->sf_idx[0] < 217)
827
                qstep = 1;
828
        } while (qstep);
829 830 831

        fflag = 0;
        minscaler = av_clip(minscaler, 60, 255 - SCALE_MAX_DIFF);
832 833
        for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
            for (g = 0; g < sce->ics.num_swb; g++) {
834
                int prevsc = sce->sf_idx[w*16+g];
835
                if (dists[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > 60) {
836
                    if (find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]-1))
Young Han Lee's avatar
Young Han Lee committed
837
                        sce->sf_idx[w*16+g]--;
838 839 840
                    else //Try to make sure there is some energy in every band
                        sce->sf_idx[w*16+g]-=2;
                }
841 842
                sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler, minscaler + SCALE_MAX_DIFF);
                sce->sf_idx[w*16+g] = FFMIN(sce->sf_idx[w*16+g], 219);
843
                if (sce->sf_idx[w*16+g] != prevsc)
844
                    fflag = 1;
845
                sce->band_type[w*16+g] = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);
846 847 848
            }
        }
        its++;
849
    } while (fflag && its < 10);
850 851 852
}

static void search_for_quantizers_faac(AVCodecContext *avctx, AACEncContext *s,
853 854
                                       SingleChannelElement *sce,
                                       const float lambda)
855 856 857 858 859 860 861
{
    int start = 0, i, w, w2, g;
    float uplim[128], maxq[128];
    int minq, maxsf;
    float distfact = ((sce->ics.num_windows > 1) ? 85.80 : 147.84) / lambda;
    int last = 0, lastband = 0, curband = 0;
    float avg_energy = 0.0;
862
    if (sce->ics.num_windows == 1) {
863
        start = 0;
864 865
        for (i = 0; i < 1024; i++) {
            if (i - start >= sce->ics.swb_sizes[curband]) {
866 867 868
                start += sce->ics.swb_sizes[curband];
                curband++;
            }
869
            if (sce->coeffs[i]) {
870 871 872 873 874
                avg_energy += sce->coeffs[i] * sce->coeffs[i];
                last = i;
                lastband = curband;
            }
        }
875 876
    } else {
        for (w = 0; w < 8; w++) {
877
            const float *coeffs = sce->coeffs + w*128;
878
            curband = start = 0;
879 880
            for (i = 0; i < 128; i++) {
                if (i - start >= sce->ics.swb_sizes[curband]) {
881 882 883
                    start += sce->ics.swb_sizes[curband];
                    curband++;
                }
884
                if (coeffs[i]) {
885 886 887 888 889 890 891 892 893
                    avg_energy += coeffs[i] * coeffs[i];
                    last = FFMAX(last, i);
                    lastband = FFMAX(lastband, curband);
                }
            }
        }
    }
    last++;
    avg_energy /= last;
894 895
    if (avg_energy == 0.0f) {
        for (i = 0; i < FF_ARRAY_ELEMS(sce->sf_idx); i++)
896 897 898
            sce->sf_idx[i] = SCALE_ONE_POS;
        return;
    }
899
    for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
900
        start = w*128;
901
        for (g = 0; g < sce->ics.num_swb; g++) {
902
            float *coefs   = sce->coeffs + start;
903 904 905 906
            const int size = sce->ics.swb_sizes[g];
            int start2 = start, end2 = start + size, peakpos = start;
            float maxval = -1, thr = 0.0f, t;
            maxq[w*16+g] = 0.0f;
907
            if (g > lastband) {
908 909
                maxq[w*16+g] = 0.0f;
                start += size;
910
                for (w2 = 0; w2 < sce->ics.group_len[w]; w2++)
911 912 913
                    memset(coefs + w2*128, 0, sizeof(coefs[0])*size);
                continue;
            }
914 915
            for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
                for (i = 0; i < size; i++) {
916
                    float t = coefs[w2*128+i]*coefs[w2*128+i];
917
                    maxq[w*16+g] = FFMAX(maxq[w*16+g], fabsf(coefs[w2*128 + i]));
918
                    thr += t;
919
                    if (sce->ics.num_windows == 1 && maxval < t) {
920
                        maxval  = t;
921 922 923 924
                        peakpos = start+i;
                    }
                }
            }
925
            if (sce->ics.num_windows == 1) {
926 927
                start2 = FFMAX(peakpos - 2, start2);
                end2   = FFMIN(peakpos + 3, end2);
928
            } else {
929 930 931 932 933
                start2 -= start;
                end2   -= start;
            }
            start += size;
            thr = pow(thr / (avg_energy * (end2 - start2)), 0.3 + 0.1*(lastband - g) / lastband);
934
            t   = 1.0 - (1.0 * start2 / last);
935 936 937 938 939
            uplim[w*16+g] = distfact / (1.4 * thr + t*t*t + 0.075);
        }
    }
    memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
    abs_pow34_v(s->scoefs, sce->coeffs, 1024);
940
    for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
941
        start = w*128;
942
        for (g = 0;  g < sce->ics.num_swb; g++) {
943 944 945
            const float *coefs  = sce->coeffs + start;
            const float *scaled = s->scoefs   + start;
            const int size      = sce->ics.swb_sizes[g];
946
            int scf, prev_scf, step;
947
            int min_scf = -1, max_scf = 256;
948
            float curdiff;
949
            if (maxq[w*16+g] < 21.544) {
950 951 952 953 954
                sce->zeroes[w*16+g] = 1;
                start += size;
                continue;
            }
            sce->zeroes[w*16+g] = 0;
955
            scf  = prev_scf = av_clip(SCALE_ONE_POS - SCALE_DIV_512 - log2f(1/maxq[w*16+g])*16/3, 60, 218);
956
            step = 16;
957
            for (;;) {
958 959 960
                float dist = 0.0f;
                int quant_max;

961
                for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
962 963 964 965 966 967
                    int b;
                    dist += quantize_band_cost(s, coefs + w2*128,
                                               scaled + w2*128,
                                               sce->ics.swb_sizes[g],
                                               scf,
                                               ESC_BT,
968
                                               lambda,
969 970 971 972
                                               INFINITY,
                                               &b);
                    dist -= b;
                }
973
                dist *= 1.0f / 512.0f / lambda;
974
                quant_max = quant(maxq[w*16+g], ff_aac_pow2sf_tab[POW_SF2_ZERO - scf + SCALE_ONE_POS - SCALE_DIV_512]);
975
                if (quant_max >= 8191) { // too much, return to the previous quantizer
976 977 978 979 980
                    sce->sf_idx[w*16+g] = prev_scf;
                    break;
                }
                prev_scf = scf;
                curdiff = fabsf(dist - uplim[w*16+g]);
981
                if (curdiff <= 1.0f)
982 983
                    step = 0;
                else
984
                    step = log2f(curdiff);
985
                if (dist > uplim[w*16+g])
986
                    step = -step;
987
                scf += step;
988
                scf = av_clip_uint8(scf);
989
                step = scf - prev_scf;
990
                if (FFABS(step) <= 1 || (step > 0 && scf >= max_scf) || (step < 0 && scf <= min_scf)) {
991
                    sce->sf_idx[w*16+g] = av_clip(scf, min_scf, max_scf);
992 993
                    break;
                }
994
                if (step > 0)
995
                    min_scf = prev_scf;
996
                else
997
                    max_scf = prev_scf;
998 999 1000 1001 1002
            }
            start += size;
        }
    }
    minq = sce->sf_idx[0] ? sce->sf_idx[0] : INT_MAX;
1003 1004
    for (i = 1; i < 128; i++) {
        if (!sce->sf_idx[i])
1005 1006 1007 1008
            sce->sf_idx[i] = sce->sf_idx[i-1];
        else
            minq = FFMIN(minq, sce->sf_idx[i]);
    }
1009 1010
    if (minq == INT_MAX)
        minq = 0;
1011 1012
    minq = FFMIN(minq, SCALE_MAX_POS);
    maxsf = FFMIN(minq + SCALE_MAX_DIFF, SCALE_MAX_POS);
1013 1014
    for (i = 126; i >= 0; i--) {
        if (!sce->sf_idx[i])
1015 1016 1017 1018 1019 1020
            sce->sf_idx[i] = sce->sf_idx[i+1];
        sce->sf_idx[i] = av_clip(sce->sf_idx[i], minq, maxsf);
    }
}

static void search_for_quantizers_fast(AVCodecContext *avctx, AACEncContext *s,
1021 1022
                                       SingleChannelElement *sce,
                                       const float lambda)
1023
{
Mans Rullgard's avatar
Mans Rullgard committed
1024
    int i, w, w2, g;
1025 1026 1027
    int minq = 255;

    memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
1028 1029 1030
    for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
        for (g = 0; g < sce->ics.num_swb; g++) {
            for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
1031
                FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
1032
                if (band->energy <= band->threshold) {
1033 1034
                    sce->sf_idx[(w+w2)*16+g] = 218;
                    sce->zeroes[(w+w2)*16+g] = 1;
1035
                } else {
1036
                    sce->sf_idx[(w+w2)*16+g] = av_clip(SCALE_ONE_POS - SCALE_DIV_512 + log2f(band->threshold), 80, 218);
1037 1038 1039 1040 1041 1042
                    sce->zeroes[(w+w2)*16+g] = 0;
                }
                minq = FFMIN(minq, sce->sf_idx[(w+w2)*16+g]);
            }
        }
    }
1043
    for (i = 0; i < 128; i++) {
1044 1045
        sce->sf_idx[i] = 140;
        //av_clip(sce->sf_idx[i], minq, minq + SCALE_MAX_DIFF - 1);
1046 1047
    }
    //set the same quantizers inside window groups
1048 1049 1050
    for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
        for (g = 0;  g < sce->ics.num_swb; g++)
            for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)
1051 1052 1053
                sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];
}

1054 1055
static void search_for_ms(AACEncContext *s, ChannelElement *cpe,
                          const float lambda)
1056 1057 1058 1059 1060 1061
{
    int start = 0, i, w, w2, g;
    float M[128], S[128];
    float *L34 = s->scoefs, *R34 = s->scoefs + 128, *M34 = s->scoefs + 128*2, *S34 = s->scoefs + 128*3;
    SingleChannelElement *sce0 = &cpe->ch[0];
    SingleChannelElement *sce1 = &cpe->ch[1];
1062
    if (!cpe->common_window)
1063
        return;
1064 1065 1066
    for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {
        for (g = 0;  g < sce0->ics.num_swb; g++) {
            if (!cpe->ch[0].zeroes[w*16+g] && !cpe->ch[1].zeroes[w*16+g]) {
1067
                float dist1 = 0.0f, dist2 = 0.0f;
1068
                for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {
1069 1070
                    FFPsyBand *band0 = &s->psy.ch[s->cur_channel+0].psy_bands[(w+w2)*16+g];
                    FFPsyBand *band1 = &s->psy.ch[s->cur_channel+1].psy_bands[(w+w2)*16+g];
1071 1072
                    float minthr = FFMIN(band0->threshold, band1->threshold);
                    float maxthr = FFMAX(band0->threshold, band1->threshold);
1073
                    for (i = 0; i < sce0->ics.swb_sizes[g]; i++) {
1074
                        M[i] = (sce0->coeffs[start+w2*128+i]
1075
                              + sce1->coeffs[start+w2*128+i]) * 0.5;
1076
                        S[i] =  M[i]
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
                              - sce1->coeffs[start+w2*128+i];
                    }
                    abs_pow34_v(L34, sce0->coeffs+start+w2*128, sce0->ics.swb_sizes[g]);
                    abs_pow34_v(R34, sce1->coeffs+start+w2*128, sce0->ics.swb_sizes[g]);
                    abs_pow34_v(M34, M,                         sce0->ics.swb_sizes[g]);
                    abs_pow34_v(S34, S,                         sce0->ics.swb_sizes[g]);
                    dist1 += quantize_band_cost(s, sce0->coeffs + start + w2*128,
                                                L34,
                                                sce0->ics.swb_sizes[g],
                                                sce0->sf_idx[(w+w2)*16+g],
                                                sce0->band_type[(w+w2)*16+g],
                                                lambda / band0->threshold, INFINITY, NULL);
                    dist1 += quantize_band_cost(s, sce1->coeffs + start + w2*128,
                                                R34,
                                                sce1->ics.swb_sizes[g],
                                                sce1->sf_idx[(w+w2)*16+g],
                                                sce1->band_type[(w+w2)*16+g],
                                                lambda / band1->threshold, INFINITY, NULL);
                    dist2 += quantize_band_cost(s, M,
                                                M34,
                                                sce0->ics.swb_sizes[g],
                                                sce0->sf_idx[(w+w2)*16+g],
                                                sce0->band_type[(w+w2)*16+g],
                                                lambda / maxthr, INFINITY, NULL);
                    dist2 += quantize_band_cost(s, S,
                                                S34,
                                                sce1->ics.swb_sizes[g],
                                                sce1->sf_idx[(w+w2)*16+g],
                                                sce1->band_type[(w+w2)*16+g],
                                                lambda / minthr, INFINITY, NULL);
                }
                cpe->ms_mask[w*16+g] = dist2 < dist1;
            }
            start += sce0->ics.swb_sizes[g];
        }
    }
}

1115
AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB] = {
1116
    [AAC_CODER_FAAC] = {
1117
        search_for_quantizers_faac,
1118
        encode_window_bands_info,
1119
        quantize_and_encode_band,
1120
        search_for_ms,
1121
    },
1122
    [AAC_CODER_ANMR] = {
1123 1124 1125
        search_for_quantizers_anmr,
        encode_window_bands_info,
        quantize_and_encode_band,
1126
        search_for_ms,
1127
    },
1128
    [AAC_CODER_TWOLOOP] = {
1129
        search_for_quantizers_twoloop,
1130
        codebook_trellis_rate,
1131
        quantize_and_encode_band,
1132
        search_for_ms,
1133
    },
1134
    [AAC_CODER_FAST] = {
1135 1136 1137
        search_for_quantizers_fast,
        encode_window_bands_info,
        quantize_and_encode_band,
1138
        search_for_ms,
1139 1140
    },
};