LCOV - code coverage report
Current view: top level - src/libavcodec - aaccoder_trellis.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 98 98 100.0 %
Date: 2017-08-17 10:06:07 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       12899 : 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       12899 :     const int max_sfb  = sce->ics.max_sfb;
      66       12899 :     const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
      67       12899 :     const int run_esc  = (1 << run_bits) - 1;
      68             :     int idx, ppos, count;
      69             :     int stackrun[120], stackcb[120], stack_len;
      70       12899 :     float next_minbits = INFINITY;
      71       12899 :     int next_mincb = 0;
      72             : 
      73       12899 :     s->abs_pow34(s->scoefs, sce->coeffs, 1024);
      74       12899 :     start = win*128;
      75      206384 :     for (cb = 0; cb < CB_TOT_ALL; cb++) {
      76      193485 :         path[0][cb].cost     = run_bits+4;
      77      193485 :         path[0][cb].prev_idx = -1;
      78      193485 :         path[0][cb].run      = 0;
      79             :     }
      80      573549 :     for (swb = 0; swb < max_sfb; swb++) {
      81      560650 :         size = sce->ics.swb_sizes[swb];
      82      560650 :         if (sce->zeroes[win*16 + swb]) {
      83        2631 :             float cost_stay_here = path[swb][0].cost;
      84        2631 :             float cost_get_here  = next_minbits + run_bits + 4;
      85        5262 :             if (   run_value_bits[sce->ics.num_windows == 8][path[swb][0].run]
      86        2631 :                 != run_value_bits[sce->ics.num_windows == 8][path[swb][0].run+1])
      87          18 :                 cost_stay_here += run_bits;
      88        2631 :             if (cost_get_here < cost_stay_here) {
      89         259 :                 path[swb+1][0].prev_idx = next_mincb;
      90         259 :                 path[swb+1][0].cost     = cost_get_here;
      91         259 :                 path[swb+1][0].run      = 1;
      92             :             } else {
      93        2372 :                 path[swb+1][0].prev_idx = 0;
      94        2372 :                 path[swb+1][0].cost     = cost_stay_here;
      95        2372 :                 path[swb+1][0].run      = path[swb][0].run + 1;
      96             :             }
      97        2631 :             next_minbits = path[swb+1][0].cost;
      98        2631 :             next_mincb = 0;
      99       39465 :             for (cb = 1; cb < CB_TOT_ALL; cb++) {
     100       36834 :                 path[swb+1][cb].cost = 61450;
     101       36834 :                 path[swb+1][cb].prev_idx = -1;
     102       36834 :                 path[swb+1][cb].run = 0;
     103             :             }
     104             :         } else {
     105      558019 :             float minbits = next_minbits;
     106      558019 :             int mincb = next_mincb;
     107      558019 :             int startcb = sce->band_type[win*16+swb];
     108      558019 :             startcb = aac_cb_in_map[startcb];
     109      558019 :             next_minbits = INFINITY;
     110      558019 :             next_mincb = 0;
     111     3271284 :             for (cb = 0; cb < startcb; cb++) {
     112     2713265 :                 path[swb+1][cb].cost = 61450;
     113     2713265 :                 path[swb+1][cb].prev_idx = -1;
     114     2713265 :                 path[swb+1][cb].run = 0;
     115             :             }
     116     6215039 :             for (cb = startcb; cb < CB_TOT_ALL; cb++) {
     117             :                 float cost_stay_here, cost_get_here;
     118     5657020 :                 float bits = 0.0f;
     119     5657020 :                 if (cb >= 12 && sce->band_type[win*16+swb] != aac_cb_out_map[cb]) {
     120     1634997 :                     path[swb+1][cb].cost = 61450;
     121     1634997 :                     path[swb+1][cb].prev_idx = -1;
     122     1634997 :                     path[swb+1][cb].run = 0;
     123     1634997 :                     continue;
     124             :                 }
     125     8119972 :                 for (w = 0; w < group_len; w++) {
     126    12293847 :                     bits += quantize_band_cost_bits(s, &sce->coeffs[start + w*128],
     127     4097949 :                                                &s->scoefs[start + w*128], size,
     128     4097949 :                                                sce->sf_idx[win*16+swb],
     129     4097949 :                                                aac_cb_out_map[cb],
     130             :                                                0, INFINITY, NULL, NULL, 0);
     131             :                 }
     132     4022023 :                 cost_stay_here = path[swb][cb].cost + bits;
     133     4022023 :                 cost_get_here  = minbits            + bits + run_bits + 4;
     134     8044046 :                 if (   run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
     135     4022023 :                     != run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])
     136        5292 :                     cost_stay_here += run_bits;
     137     4022023 :                 if (cost_get_here < cost_stay_here) {
     138     2441122 :                     path[swb+1][cb].prev_idx = mincb;
     139     2441122 :                     path[swb+1][cb].cost     = cost_get_here;
     140     2441122 :                     path[swb+1][cb].run      = 1;
     141             :                 } else {
     142     1580901 :                     path[swb+1][cb].prev_idx = cb;
     143     1580901 :                     path[swb+1][cb].cost     = cost_stay_here;
     144     1580901 :                     path[swb+1][cb].run      = path[swb][cb].run + 1;
     145             :                 }
     146     4022023 :                 if (path[swb+1][cb].cost < next_minbits) {
     147     1202092 :                     next_minbits = path[swb+1][cb].cost;
     148     1202092 :                     next_mincb = cb;
     149             :                 }
     150             :             }
     151             :         }
     152      560650 :         start += sce->ics.swb_sizes[swb];
     153             :     }
     154             : 
     155             :     //convert resulting path from backward-linked list
     156       12899 :     stack_len = 0;
     157       12899 :     idx       = 0;
     158      193485 :     for (cb = 1; cb < CB_TOT_ALL; cb++)
     159      180586 :         if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)
     160       19692 :             idx = cb;
     161       12899 :     ppos = max_sfb;
     162       87155 :     while (ppos > 0) {
     163             :         av_assert1(idx >= 0);
     164       61357 :         cb = idx;
     165       61357 :         stackrun[stack_len] = path[ppos][cb].run;
     166       61357 :         stackcb [stack_len] = cb;
     167       61357 :         idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;
     168       61357 :         ppos -= path[ppos][cb].run;
     169       61357 :         stack_len++;
     170             :     }
     171             :     //perform actual band info encoding
     172       12899 :     start = 0;
     173       74256 :     for (i = stack_len - 1; i >= 0; i--) {
     174       61357 :         cb = aac_cb_out_map[stackcb[i]];
     175       61357 :         put_bits(&s->pb, 4, cb);
     176       61357 :         count = stackrun[i];
     177       61357 :         memset(sce->zeroes + win*16 + start, !cb, count);
     178             :         //XXX: memset when band_type is also uint8_t
     179      622007 :         for (j = 0; j < count; j++) {
     180      560650 :             sce->band_type[win*16 + start] = cb;
     181      560650 :             start++;
     182             :         }
     183      125493 :         while (count >= run_esc) {
     184        2779 :             put_bits(&s->pb, run_bits, run_esc);
     185        2779 :             count -= run_esc;
     186             :         }
     187       61357 :         put_bits(&s->pb, run_bits, count);
     188             :     }
     189       12899 : }
     190             : 
     191             : 
     192             : #endif /* AVCODEC_AACCODER_TRELLIS_H */

Generated by: LCOV version 1.13