LCOV - code coverage report
Current view: top level - libavcodec - gsmdec_template.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 81 81 100.0 %
Date: 2017-12-11 20:48:03 Functions: 9 9 100.0 %

          Line data    Source code
       1             : /*
       2             :  * gsm 06.10 decoder
       3             :  * Copyright (c) 2010 Reimar Döffinger <Reimar.Doeffinger@gmx.de>
       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             :  * GSM decoder
      25             :  */
      26             : 
      27             : #include "get_bits.h"
      28             : #include "gsm.h"
      29             : #include "gsmdec_data.h"
      30             : 
      31        2720 : static void apcm_dequant_add(GetBitContext *gb, int16_t *dst, const int *frame_bits)
      32             : {
      33             :     int i, val;
      34        2720 :     int maxidx = get_bits(gb, 6);
      35        2720 :     const int16_t *tab = ff_gsm_dequant_tab[maxidx];
      36       38080 :     for (i = 0; i < 13; i++) {
      37       35360 :         val = get_bits(gb, frame_bits[i]);
      38       35360 :         dst[3 * i] += tab[ff_gsm_requant_tab[frame_bits[i]][val]];
      39             :     }
      40        2720 : }
      41             : 
      42     1963840 : static inline int gsm_mult(int a, int b)
      43             : {
      44     1963840 :     return (int)(a * (SUINT)b + (1 << 14)) >> 15;
      45             : }
      46             : 
      47        2720 : static void long_term_synth(int16_t *dst, int lag, int gain_idx)
      48             : {
      49             :     int i;
      50        2720 :     const int16_t *src = dst - lag;
      51        2720 :     uint16_t gain = ff_gsm_long_term_gain_tab[gain_idx];
      52      111520 :     for (i = 0; i < 40; i++)
      53      108800 :         dst[i] = gsm_mult(gain, src[i]);
      54        2720 : }
      55             : 
      56        5440 : static inline int decode_log_area(int coded, int factor, int offset)
      57             : {
      58        5440 :     coded <<= 10;
      59        5440 :     coded -= offset;
      60        5440 :     return gsm_mult(coded, factor) * 2;
      61             : }
      62             : 
      63       21760 : static av_noinline int get_rrp(int filtered)
      64             : {
      65       21760 :     int abs = FFABS(filtered);
      66       21760 :     if      (abs < 11059) abs <<= 1;
      67        1552 :     else if (abs < 20070) abs += 11059;
      68          88 :     else                  abs = (abs >> 2) + 26112;
      69       21760 :     return filtered < 0 ? -abs : abs;
      70             : }
      71             : 
      72      108800 : static int filter_value(int in, int rrp[8], int v[9])
      73             : {
      74             :     int i;
      75      979200 :     for (i = 7; i >= 0; i--) {
      76      870400 :         in -= gsm_mult(rrp[i], v[i]);
      77      870400 :         v[i + 1] = v[i] + gsm_mult(rrp[i], in);
      78             :     }
      79      108800 :     v[0] = in;
      80      108800 :     return in;
      81             : }
      82             : 
      83         680 : static void short_term_synth(GSMContext *ctx, int16_t *dst, const int16_t *src)
      84             : {
      85             :     int i;
      86             :     int rrp[8];
      87         680 :     int *lar = ctx->lar[ctx->lar_idx];
      88         680 :     int *lar_prev = ctx->lar[ctx->lar_idx ^ 1];
      89        6120 :     for (i = 0; i < 8; i++)
      90        5440 :         rrp[i] = get_rrp((lar_prev[i] >> 2) + (lar_prev[i] >> 1) + (lar[i] >> 2));
      91        9520 :     for (i = 0; i < 13; i++)
      92        8840 :         dst[i] = filter_value(src[i], rrp, ctx->v);
      93             : 
      94        6120 :     for (i = 0; i < 8; i++)
      95        5440 :         rrp[i] = get_rrp((lar_prev[i] >> 1) + (lar     [i] >> 1));
      96       10200 :     for (i = 13; i < 27; i++)
      97        9520 :         dst[i] = filter_value(src[i], rrp, ctx->v);
      98             : 
      99        6120 :     for (i = 0; i < 8; i++)
     100        5440 :         rrp[i] = get_rrp((lar_prev[i] >> 2) + (lar     [i] >> 1) + (lar[i] >> 2));
     101        9520 :     for (i = 27; i < 40; i++)
     102        8840 :         dst[i] = filter_value(src[i], rrp, ctx->v);
     103             : 
     104        6120 :     for (i = 0; i < 8; i++)
     105        5440 :         rrp[i] = get_rrp(lar[i]);
     106       82280 :     for (i = 40; i < 160; i++)
     107       81600 :         dst[i] = filter_value(src[i], rrp, ctx->v);
     108             : 
     109         680 :     ctx->lar_idx ^= 1;
     110         680 : }
     111             : 
     112         680 : static int postprocess(int16_t *data, int msr)
     113             : {
     114             :     int i;
     115      109480 :     for (i = 0; i < 160; i++) {
     116      108800 :         msr = av_clip_int16(data[i] + gsm_mult(msr, 28180));
     117      108800 :         data[i] = av_clip_int16(msr * 2) & ~7;
     118             :     }
     119         680 :     return msr;
     120             : }
     121             : 
     122         680 : static int gsm_decode_block(AVCodecContext *avctx, int16_t *samples,
     123             :                             GetBitContext *gb, int mode)
     124             : {
     125         680 :     GSMContext *ctx = avctx->priv_data;
     126             :     int i;
     127         680 :     int16_t *ref_dst = ctx->ref_buf + 120;
     128         680 :     int *lar = ctx->lar[ctx->lar_idx];
     129         680 :     lar[0] = decode_log_area(get_bits(gb, 6), 13107,  1 << 15);
     130         680 :     lar[1] = decode_log_area(get_bits(gb, 6), 13107,  1 << 15);
     131         680 :     lar[2] = decode_log_area(get_bits(gb, 5), 13107, (1 << 14) + 2048*2);
     132         680 :     lar[3] = decode_log_area(get_bits(gb, 5), 13107, (1 << 14) - 2560*2);
     133         680 :     lar[4] = decode_log_area(get_bits(gb, 4), 19223, (1 << 13) +   94*2);
     134         680 :     lar[5] = decode_log_area(get_bits(gb, 4), 17476, (1 << 13) - 1792*2);
     135         680 :     lar[6] = decode_log_area(get_bits(gb, 3), 31454, (1 << 12) -  341*2);
     136         680 :     lar[7] = decode_log_area(get_bits(gb, 3), 29708, (1 << 12) - 1144*2);
     137             : 
     138        3400 :     for (i = 0; i < 4; i++) {
     139        2720 :         int lag      = get_bits(gb, 7);
     140        2720 :         int gain_idx = get_bits(gb, 2);
     141        2720 :         int offset   = get_bits(gb, 2);
     142        2720 :         lag = av_clip(lag, 40, 120);
     143        2720 :         long_term_synth(ref_dst, lag, gain_idx);
     144        2720 :         apcm_dequant_add(gb, ref_dst + offset, ff_gsm_apcm_bits[mode][i]);
     145        2720 :         ref_dst += 40;
     146             :     }
     147         680 :     memcpy(ctx->ref_buf, ctx->ref_buf + 160, 120 * sizeof(*ctx->ref_buf));
     148         680 :     short_term_synth(ctx, samples, ctx->ref_buf + 120);
     149             :     // for optimal speed this could be merged with short_term_synth,
     150             :     // not done yet because it is a bit ugly
     151         680 :     ctx->msr = postprocess(samples, ctx->msr);
     152         680 :     return 0;
     153             : }

Generated by: LCOV version 1.13