LCOV - code coverage report
Current view: top level - libavcodec - aaccoder_trellis.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 98 98 100.0 %
Date: 2018-02-24 03:21:38 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /*
       2             :  * AAC encoder trellis codebook selector
       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 encoder trellis codebook selector
      25             :  * @author Konstantin Shishkov
      26             :  */
      27             : 
      28             : /**
      29             :  * This file contains a template for the codebook_trellis_rate selector function.
      30             :  * It needs to be provided, externally, as an already included declaration,
      31             :  * the following functions from aacenc_quantization/util.h. They're not included
      32             :  * explicitly here to make it possible to provide alternative implementations:
      33             :  *  - quantize_band_cost_bits
      34             :  *  - abs_pow34_v
      35             :  */
      36             : 
      37             : #ifndef AVCODEC_AACCODER_TRELLIS_H
      38             : #define AVCODEC_AACCODER_TRELLIS_H
      39             : 
      40             : #include <float.h>
      41             : #include "libavutil/mathematics.h"
      42             : #include "avcodec.h"
      43             : #include "put_bits.h"
      44             : #include "aac.h"
      45             : #include "aacenc.h"
      46             : #include "aactab.h"
      47             : #include "aacenctab.h"
      48             : 
      49             : /**
      50             :  * structure used in optimal codebook search
      51             :  */
      52             : typedef struct TrellisBandCodingPath {
      53             :     int prev_idx; ///< pointer to the previous path point
      54             :     float cost;   ///< path cost
      55             :     int run;
      56             : } TrellisBandCodingPath;
      57             : 
      58             : 
      59       12420 : static void codebook_trellis_rate(AACEncContext *s, SingleChannelElement *sce,
      60             :                                   int win, int group_len, const float lambda)
      61             : {
      62             :     TrellisBandCodingPath path[120][CB_TOT_ALL];
      63             :     int w, swb, cb, start, size;
      64             :     int i, j;
      65       12420 :     const int max_sfb  = sce->ics.max_sfb;
      66       12420 :     const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
      67       12420 :     const int run_esc  = (1 << run_bits) - 1;
      68             :     int idx, ppos, count;
      69             :     int stackrun[120], stackcb[120], stack_len;
      70       12420 :     float next_minbits = INFINITY;
      71       12420 :     int next_mincb = 0;
      72             : 
      73       12420 :     s->abs_pow34(s->scoefs, sce->coeffs, 1024);
      74       12420 :     start = win*128;
      75      198720 :     for (cb = 0; cb < CB_TOT_ALL; cb++) {
      76      186300 :         path[0][cb].cost     = run_bits+4;
      77      186300 :         path[0][cb].prev_idx = -1;
      78      186300 :         path[0][cb].run      = 0;
      79             :     }
      80      563754 :     for (swb = 0; swb < max_sfb; swb++) {
      81      551334 :         size = sce->ics.swb_sizes[swb];
      82      551334 :         if (sce->zeroes[win*16 + swb]) {
      83       15155 :             float cost_stay_here = path[swb][0].cost;
      84       15155 :             float cost_get_here  = next_minbits + run_bits + 4;
      85       30310 :             if (   run_value_bits[sce->ics.num_windows == 8][path[swb][0].run]
      86       15155 :                 != run_value_bits[sce->ics.num_windows == 8][path[swb][0].run+1])
      87          32 :                 cost_stay_here += run_bits;
      88       15155 :             if (cost_get_here < cost_stay_here) {
      89         239 :                 path[swb+1][0].prev_idx = next_mincb;
      90         239 :                 path[swb+1][0].cost     = cost_get_here;
      91         239 :                 path[swb+1][0].run      = 1;
      92             :             } else {
      93       14916 :                 path[swb+1][0].prev_idx = 0;
      94       14916 :                 path[swb+1][0].cost     = cost_stay_here;
      95       14916 :                 path[swb+1][0].run      = path[swb][0].run + 1;
      96             :             }
      97       15155 :             next_minbits = path[swb+1][0].cost;
      98       15155 :             next_mincb = 0;
      99      227325 :             for (cb = 1; cb < CB_TOT_ALL; cb++) {
     100      212170 :                 path[swb+1][cb].cost = 61450;
     101      212170 :                 path[swb+1][cb].prev_idx = -1;
     102      212170 :                 path[swb+1][cb].run = 0;
     103             :             }
     104             :         } else {
     105      536179 :             float minbits = next_minbits;
     106      536179 :             int mincb = next_mincb;
     107      536179 :             int startcb = sce->band_type[win*16+swb];
     108      536179 :             startcb = aac_cb_in_map[startcb];
     109      536179 :             next_minbits = INFINITY;
     110      536179 :             next_mincb = 0;
     111     3071653 :             for (cb = 0; cb < startcb; cb++) {
     112     2535474 :                 path[swb+1][cb].cost = 61450;
     113     2535474 :                 path[swb+1][cb].prev_idx = -1;
     114     2535474 :                 path[swb+1][cb].run = 0;
     115             :             }
     116     6043390 :             for (cb = startcb; cb < CB_TOT_ALL; cb++) {
     117             :                 float cost_stay_here, cost_get_here;
     118     5507211 :                 float bits = 0.0f;
     119     5507211 :                 if (cb >= 12 && sce->band_type[win*16+swb] != aac_cb_out_map[cb]) {
     120     1569089 :                     path[swb+1][cb].cost = 61450;
     121     1569089 :                     path[swb+1][cb].prev_idx = -1;
     122     1569089 :                     path[swb+1][cb].run = 0;
     123     1569089 :                     continue;
     124             :                 }
     125     7950128 :                 for (w = 0; w < group_len; w++) {
     126    12036018 :                     bits += quantize_band_cost_bits(s, &sce->coeffs[start + w*128],
     127     4012006 :                                                &s->scoefs[start + w*128], size,
     128     4012006 :                                                sce->sf_idx[win*16+swb],
     129     4012006 :                                                aac_cb_out_map[cb],
     130             :                                                0, INFINITY, NULL, NULL, 0);
     131             :                 }
     132     3938122 :                 cost_stay_here = path[swb][cb].cost + bits;
     133     3938122 :                 cost_get_here  = minbits            + bits + run_bits + 4;
     134     7876244 :                 if (   run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
     135     3938122 :                     != run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])
     136        3766 :                     cost_stay_here += run_bits;
     137     3938122 :                 if (cost_get_here < cost_stay_here) {
     138     2539381 :                     path[swb+1][cb].prev_idx = mincb;
     139     2539381 :                     path[swb+1][cb].cost     = cost_get_here;
     140     2539381 :                     path[swb+1][cb].run      = 1;
     141             :                 } else {
     142     1398741 :                     path[swb+1][cb].prev_idx = cb;
     143     1398741 :                     path[swb+1][cb].cost     = cost_stay_here;
     144     1398741 :                     path[swb+1][cb].run      = path[swb][cb].run + 1;
     145             :                 }
     146     3938122 :                 if (path[swb+1][cb].cost < next_minbits) {
     147     1116187 :                     next_minbits = path[swb+1][cb].cost;
     148     1116187 :                     next_mincb = cb;
     149             :                 }
     150             :             }
     151             :         }
     152      551334 :         start += sce->ics.swb_sizes[swb];
     153             :     }
     154             : 
     155             :     //convert resulting path from backward-linked list
     156       12420 :     stack_len = 0;
     157       12420 :     idx       = 0;
     158      186300 :     for (cb = 1; cb < CB_TOT_ALL; cb++)
     159      173880 :         if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)
     160       18094 :             idx = cb;
     161       12420 :     ppos = max_sfb;
     162       94061 :     while (ppos > 0) {
     163             :         av_assert1(idx >= 0);
     164       69221 :         cb = idx;
     165       69221 :         stackrun[stack_len] = path[ppos][cb].run;
     166       69221 :         stackcb [stack_len] = cb;
     167       69221 :         idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;
     168       69221 :         ppos -= path[ppos][cb].run;
     169       69221 :         stack_len++;
     170             :     }
     171             :     //perform actual band info encoding
     172       12420 :     start = 0;
     173       81641 :     for (i = stack_len - 1; i >= 0; i--) {
     174       69221 :         cb = aac_cb_out_map[stackcb[i]];
     175       69221 :         put_bits(&s->pb, 4, cb);
     176       69221 :         count = stackrun[i];
     177       69221 :         memset(sce->zeroes + win*16 + start, !cb, count);
     178             :         //XXX: memset when band_type is also uint8_t
     179      620555 :         for (j = 0; j < count; j++) {
     180      551334 :             sce->band_type[win*16 + start] = cb;
     181      551334 :             start++;
     182             :         }
     183      140092 :         while (count >= run_esc) {
     184        1650 :             put_bits(&s->pb, run_bits, run_esc);
     185        1650 :             count -= run_esc;
     186             :         }
     187       69221 :         put_bits(&s->pb, run_bits, count);
     188             :     }
     189       12420 : }
     190             : 
     191             : 
     192             : #endif /* AVCODEC_AACCODER_TRELLIS_H */

Generated by: LCOV version 1.13