Ticket #2686: aac-improvements-wip.patch

libavcodec/aaccoder.c

@@ -57 +57 @@
     run_value_bits_long, run_value_bits_short
 };
 
-
 /**
  * Quantize one coefficient.
  * @return absolute value of the quantized coefficient
@@ -282 +281 @@
     return maxval;
 }
 
+static float find_max_absval(int group_len, int swb_size, const float *scaled) {
+    float maxval = 0.0f;
+    int w2, i;
+    for (w2 = 0; w2 < group_len; w2++) {
+        for (i = 0; i < swb_size; i++) {
+            maxval = FFMAX(maxval, fabs(scaled[w2*128+i]));
+        }
+    }
+    return maxval;
+}
+
 static int find_min_book(float maxval, int sf) {
     float Q = ff_aac_pow2sf_tab[POW_SF2_ZERO - sf + SCALE_ONE_POS - SCALE_DIV_512];
     float Q34 = sqrtf(Q * sqrtf(Q));
@@ -701 +711 @@
                 sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];
 }
 
+#define sclip(x) av_clip(x,60,218)
+
 /**
  * two-loop quantizers search taken from ISO 13818-7 Appendix C
  */
 static void search_for_quantizers_twoloop(AVCodecContext *avctx,
                                           AACEncContext *s,
                                           SingleChannelElement *sce,
-                                          const float lambda)
+                                          float lambda)
 {
     int start = 0, i, w, w2, g;
-    int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate / avctx->channels * (lambda / 120.f);
-    float dists[128] = { 0 }, uplims[128];
+    int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate 
+        / ((avctx->flags & CODEC_FLAG_QSCALE) ? 2.0f : avctx->channels) 
+        * (lambda / 120.f);
+    int toomanybits, toofewbits;
+    float dists[128] = { 0 }, uplims[128], energies[128];
     float maxvals[128];
-    int fflag, minscaler;
+    
+    /* rdlambda controls the maximum tolerated distortion. Twoloop
+     * will keep iterating until it fails to lower it or it reaches
+     * ulimit * rdlambda. Keeping it low increases quality on difficult
+     * signals, but lower it too much, and bits will be taken from weak
+     * signals, creating "holes". A balance is necesary. 
+     */
+    float rdlambda = av_clipf(2 * 120.f / lambda, 0.0625f, 16.0f);
+    float rdmax = (avctx->flags & CODEC_FLAG_QSCALE) ? 4.0f : 1.0f;
+    
+    /* sfoffs controls an offset of optmium allocation that will be
+     * applied based on lambda. Keep it real and modest, the loop
+     * will take care of the rest, this just accelerates convergence
+     */
+    float sfoffs = av_clipf((120.0f - lambda) * 0.1f, -5, 10);
+    
+    int fflag, minscaler, nminscaler, minrdsf;
     int its  = 0;
     int allz = 0;
-    float minthr = INFINITY, maxthr = 0.0f;
-    float iminthr, ilogmaxthr;
+    int tbits;
+    
+    /* zeroscale controls a multiplier of the threshold, if band energy
+     * is below this, a zero is forced. Keep it lower than 1, unless
+     * low lambda is used, because energy < threshold doesn't mean there's
+     * no audible signal outright, it's just energy. Also make it rise
+     * slower than rdlambda, as rdscale has due compensation with
+     * noisy band depriorization below, whereas zeroing logic is rather dumb
+     */
+    float zeroscale;
+    if (lambda > 120.f)
+        zeroscale = av_clipf(powf(120.f / lambda, 0.25f), 0.0625f, 1.0f);
+    else if (lambda < 80.f)
+        zeroscale = av_clipf(powf(80.f / lambda, 0.25f), 1.0f, 2.0f);
+    else
+        zeroscale = 1.f;
+    
+    
+    if (s->psy.bitres.alloc >= 0) {
+        // Psy granted us extra bits to use, from the reservoire
+        destbits = s->psy.bitres.alloc * (lambda / 120.f);
+    }
+    
+    if (avctx->flags & CODEC_FLAG_QSCALE) {
+        // When using a constant Q-scale, be lenient on bit over/underflow
+        toomanybits = destbits * 2;
+        toofewbits = destbits / 2;
+    } else {
+        // When using ABR, be strict
+        toomanybits = destbits + destbits/16;
+        toofewbits = destbits - destbits/16;
+    }
 
     // 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);
+    toomanybits = FFMIN(toomanybits, 5800);
+    toofewbits = FFMIN(toofewbits, 5800);
     //XXX: some heuristic to determine initial quantizers will reduce search time
     //determine zero bands and upper limits
     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
         for (g = 0;  g < sce->ics.num_swb; g++) {
             int nz = 0;
-            float uplim = 0.0f;
+            float uplim = INFINITY;
+            float energy = 0.0f;
             for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
                 FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
-                uplim += band->threshold;
-                if (band->energy <= band->threshold || band->threshold == 0.0f) {
+                if (band->energy <= band->threshold * zeroscale || band->threshold == 0.0f) {
                     sce->zeroes[(w+w2)*16+g] = 1;
                     continue;
                 }
+                if (uplim > band->threshold) {
+                    uplim = band->threshold;
+                    energy = band->energy;
+                }
                 nz = 1;
             }
-            uplims[w*16+g] = uplim *512;
+            if (!nz)
+                uplim = 0.0f;
+            uplims[w*16+g] = uplim;
+            energies[w*16+g] = energy;
             sce->zeroes[w*16+g] = !nz;
-            if (nz) {
-                minthr = FFMIN(minthr, uplim);
-                maxthr = FFMAX(maxthr, uplim);
-            }
             allz |= nz;
         }
     }
-    iminthr = 1.0f / minthr;
-    ilogmaxthr = 12.0f / log2f(FFMAX(2.0f,maxthr*512*iminthr));
+    
+    /* Compute initial scalers */
+    minscaler = 65535;
     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]) {
                 sce->sf_idx[w*16+g] = SCALE_ONE_POS;
                 continue;
             }
-            sce->sf_idx[w*16+g] = SCALE_ONE_POS + FFMIN(log2f(uplims[w*16+g]*iminthr)*ilogmaxthr+59-12-1,59);
+            /* log2f-to-distortion ratio is, technically, 2 (1.5db = 4, but it's power vs level so it's 2). 
+             * But, as offsets are applied, low-frequency signals are too sensitive to the induced distortion,
+             * so we make scaling more conservative by choosing a lower log2f-to-distortion ratio, and thus
+             * more robust.
+             */
+            sce->sf_idx[w*16+g] = SCALE_ONE_POS + 1.75*log2f(FFMAX(0.125f,uplims[w*16+g])) + sfoffs;
+            minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);
         }
     }
-
+    
+    /* Clip */
+    minscaler = av_clip(minscaler, SCALE_ONE_POS - SCALE_DIV_512, SCALE_MAX_POS - SCALE_DIV_512);
+    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]) 
+                sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler, minscaler + SCALE_MAX_DIFF - 1);
+    
     if (!allz)
         return;
     abs_pow34_v(s->scoefs, sce->coeffs, 1024);
@@ -771 +851 @@
         }
     }
 
+    /* Scale uplims to match rate distortion to quality 
+     * and apply noisy band depriorization.
+     * Maxval-energy ratio gives us an idea of how noisy the band is. 
+     * If maxval^2 ~ energy, then that band is mostly noise, and we can relax
+     * rate distortion requirements.
+     */
+    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++) {
+            float max = find_max_absval(sce->ics.group_len[w], sce->ics.swb_sizes[g], sce->coeffs + start);
+            if (max > 0) {
+                float energy2uplim = energies[w*16+g] / (max*max*sce->ics.swb_sizes[g]);
+                energy2uplim = FFMAX(0.0625f, FFMIN(1.0f,energy2uplim));
+                uplims[w*16+g] *= av_clipf(rdlambda * rdlambda * energy2uplim, 0.0625f, rdmax);
+                start += sce->ics.swb_sizes[g];
+            }
+        }
+    }
+
     //perform two-loop search
     //outer loop - improve quality
     do {
-        int tbits, qstep;
-        minscaler = sce->sf_idx[0];
+        int qstep;
         //inner loop - quantize spectrum to fit into given number of bits
         qstep = its ? 1 : 32;
         do {
@@ -795 +893 @@
                         start += sce->ics.swb_sizes[g];
                         continue;
                     }
-                    minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);
                     cb = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);
                     for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
                         int b;
@@ -818 +915 @@
                     prev = sce->sf_idx[w*16+g];
                 }
             }
-            if (tbits > destbits) {
-                for (i = 0; i < 128; i++) 
-                    if (sce->sf_idx[i] < 218 - qstep) 
-                        sce->sf_idx[i] += qstep;
-            } else if (tbits < destbits) {
-                for (i = 0; i < 128; i++) 
-                    if (sce->sf_idx[i] > 60 + qstep) 
-                        sce->sf_idx[i] -= qstep;
+            if (tbits > toomanybits) {
+                for (i = 0; i < 128; i++)
+                    if (sce->sf_idx[i] < (SCALE_MAX_POS - SCALE_DIV_512))
+                        sce->sf_idx[i] = FFMIN(SCALE_MAX_POS, sce->sf_idx[i] + qstep);
+            } else if (tbits < toofewbits) {
+                for (i = 0; i < 128; i++)
+                    if (sce->sf_idx[i] > SCALE_ONE_POS)
+                        sce->sf_idx[i] = FFMAX(SCALE_ONE_POS, sce->sf_idx[i] - qstep);
             }
             qstep >>= 1;
-            if (!qstep && tbits > destbits*1.02 && sce->sf_idx[0] < 217)
+            if (!qstep && tbits > toomanybits && sce->sf_idx[0] < 217)
                 qstep = 1;
         } while (qstep);
 
+        minscaler = SCALE_MAX_POS;
+        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])
+                    minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);
+
         fflag = 0;
-        minscaler = av_clip(minscaler, 60, 255 - SCALE_MAX_DIFF);
+        minscaler = nminscaler = av_clip(minscaler, SCALE_ONE_POS - SCALE_DIV_512, SCALE_MAX_POS - SCALE_DIV_512);
+        minrdsf = (avctx->flags & CODEC_FLAG_QSCALE) ? 60 : minscaler;
         for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
             for (g = 0; g < sce->ics.num_swb; g++) {
                 int prevsc = sce->sf_idx[w*16+g];
-                if (dists[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > 60) {
+                if (dists[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > minrdsf) {
                     if (find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]-1))
                         sce->sf_idx[w*16+g]--;
                     else //Try to make sure there is some energy in every band
                         sce->sf_idx[w*16+g]-=2;
                 }
-                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);
+                sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minrdsf, minscaler + SCALE_MAX_DIFF);
+                sce->sf_idx[w*16+g] = FFMIN(sce->sf_idx[w*16+g], SCALE_MAX_POS - SCALE_DIV_512);
                 if (sce->sf_idx[w*16+g] != prevsc)
                     fflag = 1;
+                nminscaler = FFMIN(nminscaler, sce->sf_idx[w*16+g]);
                 sce->band_type[w*16+g] = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);
             }
         }
+        if (nminscaler < minscaler) {
+            // Drecreased some scalers below minscaler. Must re-clamp.
+            minscaler = nminscaler;
+            for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) 
+                for (g = 0; g < sce->ics.num_swb; g++) 
+                    sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler, minscaler + SCALE_MAX_DIFF);
+        }
         its++;
-    } while (fflag && its < 10);
+    } while (fflag && its < 20);
+    
+    /* Fill implicit zeroes */
+    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->band_type[w*16+g] == 0)
+                sce->zeroes[w*16+g] = 1;
 }
 
 static void search_for_quantizers_faac(AVCodecContext *avctx, AACEncContext *s,
@@ -1028 +1146 @@
 {
     int w, w2, g;
     float lowlambda = av_clipf(120.f / lambda, 0.85f, 1.f);
-    float rlambda = av_clipf(120.f / lambda, 0.75f, 2.f);
+    float rlambda = av_clipf(120.f / lambda, 0.75f, 10.f);
     const int minq = av_clip(2 * log2f(120.f / lambda) + 150, 100, 218 - SCALE_MAX_DIFF);
     const int maxq = minq + SCALE_MAX_DIFF - 1;
 
@@ -1041 +1159 @@
                     sce->sf_idx[(w+w2)*16+g] = maxq;
                     sce->zeroes[(w+w2)*16+g] = 1;
                 } else {
-                    sce->sf_idx[(w+w2)*16+g] = av_clip(SCALE_ONE_POS - SCALE_DIV_512 + log2f(band->threshold * rlambda), minq, maxq);
+                    sce->sf_idx[(w+w2)*16+g] = av_clip(SCALE_ONE_POS - SCALE_DIV_512 + 1.414*log2f(band->threshold * rlambda), minq, maxq);
                     sce->zeroes[(w+w2)*16+g] = 0;
                 }
             }
         }
     }
     //set the same quantizers inside window groups
-    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++)
-                sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];
+    if (sce->ics.num_windows > 1) {
+        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->ics.group_len[w] > 1) {
+                    int avg_sf_idx = 0;
+                    for (w2 = 0; w2 < sce->ics.group_len[w]; w2++)
+                        avg_sf_idx += sce->sf_idx[w*16+g];
+                    avg_sf_idx /= sce->ics.group_len[w];
+                    for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)
+                        sce->sf_idx[(w+w2)*16+g] = avg_sf_idx;
+                }
+            }
+        }
+    }
 }
 
 static void search_for_ms(AACEncContext *s, ChannelElement *cpe,
@@ -1065 +1193 @@
     if (!cpe->common_window)
         return;
     for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {
+        int min_sf_idx_mid[8];
+        int min_sf_idx_side[8];
+        for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {
+            min_sf_idx_mid[w2] = SCALE_MAX_POS;
+            min_sf_idx_side[w2] = SCALE_MAX_POS;
+            for (g = 0; g < sce0->ics.num_swb; g++) {
+                if (!sce0->zeroes[w*16+g])
+                    min_sf_idx_mid[w2] = FFMIN(min_sf_idx_mid[w2], sce0->sf_idx[(w+w2)*16+g]);
+                if (!sce1->zeroes[w*16+g])
+                    min_sf_idx_side[w2] = FFMIN(min_sf_idx_side[w2], sce1->sf_idx[(w+w2)*16+g]);
+            }
+        }
+        
         for (g = 0;  g < sce0->ics.num_swb; g++) {
             if (!cpe->ch[0].zeroes[w*16+g] && !cpe->ch[1].zeroes[w*16+g]) {
                 float dist1 = 0.0f, dist2 = 0.0f;
+                int B0 = 0, B1 = 0;
+                int wmidcb[8], wsidcb[8];
                 for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {
                     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];
                     float minthr = FFMIN(band0->threshold, band1->threshold);
-                    float avgthr = 0.5f*(band0->threshold + band1->threshold);
+                    int minidx = FFMIN(sce0->sf_idx[(w+w2)*16+g], sce1->sf_idx[(w+w2)*16+g]);
+                    int mididx = av_clip(minidx, min_sf_idx_mid[w2], min_sf_idx_mid[w2] + SCALE_MAX_DIFF);
+                    int sididx = av_clip(minidx-1, min_sf_idx_side[w2], min_sf_idx_side[w2] + SCALE_MAX_DIFF);
+                    float Mmax = 0.0f, Smax = 0.0f;
+                    int midcb, sidcb;
+                    int b1,b2,b3,b4;
                     for (i = 0; i < sce0->ics.swb_sizes[g]; i++) {
                         M[i] = (sce0->coeffs[start+w2*128+i]
                               + sce1->coeffs[start+w2*128+i]) * 0.5;
@@ -1083 +1231 @@
                     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]);
+                    for (i = 0; i < sce0->ics.swb_sizes[g]; i++ ) {
+                        Mmax = FFMAX(Mmax, M34[i]);
+                        Smax = FFMAX(Smax, S34[i]);
+                    }
+                    wmidcb[w2] = midcb = find_min_book(Mmax, mididx);
+                    wsidcb[w2] = sidcb = find_min_book(Smax, sididx);
                     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);
+                                                lambda / band0->threshold, INFINITY, &b1);
                     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);
+                                                lambda / band1->threshold, INFINITY, &b2);
                     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 / avgthr, INFINITY, NULL);
+                                                mididx,
+                                                midcb,
+                                                lambda / minthr, INFINITY, &b3);
                     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);
+                                                sididx,
+                                                sidcb,
+                                                lambda / minthr, INFINITY, &b4);
+                    B0 += b1+b2;
+                    B1 += b3+b4;
+                    dist1 -= B0;
+                    dist2 -= B1;
+                }
+                cpe->ms_mask[w*16+g] = dist2 < dist1 && B1 < B0;
+                if (cpe->ms_mask[w*16+g]) {
+                    for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {
+                        int minidx = FFMIN(sce0->sf_idx[(w+w2)*16+g], sce1->sf_idx[(w+w2)*16+g]);
+                        int mididx = av_clip(minidx, min_sf_idx_mid[w2], min_sf_idx_mid[w2] + SCALE_MAX_DIFF);
+                        int sididx = av_clip(minidx-1, min_sf_idx_side[w2], min_sf_idx_side[w2] + SCALE_MAX_DIFF);
+                        sce0->sf_idx[(w+w2)*16+g] = mididx;
+                        sce0->band_type[(w+w2)*16+g] = wmidcb[w2];
+                        sce1->sf_idx[(w+w2)*16+g] = sididx;
+                        sce1->band_type[(w+w2)*16+g] = wsidcb[w2];
+                    }
                 }
-                cpe->ms_mask[w*16+g] = dist2 < dist1;
             }
             start += sce0->ics.swb_sizes[g];
         }

libavcodec/aacenc.c

@@ -591 +591 @@
             put_bits(&s->pb, 4, chan_el_counter[tag]++);
             for (ch = 0; ch < chans; ch++)
                 coeffs[ch] = cpe->ch[ch].coeffs;
+            s->psy.bitres.alloc = -1;
             s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);
             for (ch = 0; ch < chans; ch++) {
-                s->cur_channel = start_ch * 2 + ch;
+                s->cur_channel = start_ch + ch;
                 s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);
             }
             cpe->common_window = 0;
@@ -609 +610 @@
                     }
                 }
             }
-            s->cur_channel = start_ch * 2;
+            s->cur_channel = start_ch;
             if (s->options.stereo_mode && cpe->common_window) {
                 if (s->options.stereo_mode > 0) {
                     IndividualChannelStream *ics = &cpe->ch[0].ics;
@@ -621 +622 @@
                 }
             }
             adjust_frame_information(cpe, chans);
-            if (cpe->ms_mode) {
-                /* Re-evaluate psy model and quantization selection based on
-                   MS-transformed channels */
-                s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);
-                for (ch = 0; ch < chans; ch++) {
-                    s->cur_channel = start_ch * 2 + ch;
-                    s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);
-                }
-            }
             if (chans == 2) {
                 put_bits(&s->pb, 1, cpe->common_window);
                 if (cpe->common_window) {

libavcodec/aacpsy.c

@@ -297 +297 @@
     float bark;
     int i, j, g, start;
     float prev, minscale, minath, minsnr, pe_min;
-    const int chan_bitrate = ctx->avctx->bit_rate / ctx->avctx->channels;
+    const int chan_bitrate = ctx->avctx->bit_rate / ((ctx->avctx->flags & CODEC_FLAG_QSCALE) ? 2.0f : ctx->avctx->channels);
     const int bandwidth    = ctx->avctx->cutoff ? ctx->avctx->cutoff : AAC_CUTOFF(ctx->avctx);
     const float num_bark   = calc_bark((float)bandwidth);
 
@@ -389 +389 @@
                                                  int channel, int prev_type)
 {
     int i, j;
-    int br               = ctx->avctx->bit_rate / ctx->avctx->channels;
+    int br               = ((AacPsyContext*)ctx->model_priv_data)->chan_bitrate;
     int attack_ratio     = br <= 16000 ? 18 : 10;
     AacPsyContext *pctx = (AacPsyContext*) ctx->model_priv_data;
     AacPsyChannel *pch  = &pctx->ch[channel];
@@ -679 +679 @@
         desired_pe *= av_clipf(pctx->pe.previous / PSY_3GPP_BITS_TO_PE(ctx->bitres.bits),
                                0.85f, 1.15f);
     pctx->pe.previous = PSY_3GPP_BITS_TO_PE(desired_bits);
+    ctx->bitres.alloc = desired_bits;
 
     if (desired_pe < pe) {
         /* 5.6.1.3.4 "First Estimation of the reduction value" */

libavcodec/psymodel.h

@@ -88 +88 @@
     struct {
         int size;                     ///< size of the bitresevoir in bits
         int bits;                     ///< number of bits used in the bitresevoir
+        int alloc;                    ///< number of bits allocated by the psy, or -1 if no allocation was done
     } bitres;
 
     void* model_priv_data;            ///< psychoacoustic model implementation private data