LCOV - code coverage report
Current view: top level - libavcodec - dss_sp.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 243 266 91.4 %
Date: 2017-12-18 20:14:19 Functions: 18 18 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Digital Speech Standard - Standard Play mode (DSS SP) audio decoder.
       3             :  * Copyright (C) 2014 Oleksij Rempel <linux@rempel-privat.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             : #include "libavutil/channel_layout.h"
      23             : #include "libavutil/common.h"
      24             : #include "libavutil/mem.h"
      25             : #include "libavutil/opt.h"
      26             : 
      27             : #include "avcodec.h"
      28             : #include "get_bits.h"
      29             : #include "internal.h"
      30             : 
      31             : #define SUBFRAMES 4
      32             : #define PULSE_MAX 8
      33             : 
      34             : #define DSS_SP_FRAME_SIZE        42
      35             : #define DSS_SP_SAMPLE_COUNT     (66 * SUBFRAMES)
      36             : #define DSS_SP_FORMULA(a, b, c) ((int)((((a) * (1 << 15)) + (b) * (unsigned)(c)) + 0x4000) >> 15)
      37             : 
      38             : typedef struct DssSpSubframe {
      39             :     int16_t gain;
      40             :     int32_t combined_pulse_pos;
      41             :     int16_t pulse_pos[7];
      42             :     int16_t pulse_val[7];
      43             : } DssSpSubframe;
      44             : 
      45             : typedef struct DssSpFrame {
      46             :     int16_t filter_idx[14];
      47             :     int16_t sf_adaptive_gain[SUBFRAMES];
      48             :     int16_t pitch_lag[SUBFRAMES];
      49             :     struct DssSpSubframe sf[SUBFRAMES];
      50             : } DssSpFrame;
      51             : 
      52             : typedef struct DssSpContext {
      53             :     AVCodecContext *avctx;
      54             :     int32_t excitation[288 + 6];
      55             :     int32_t history[187];
      56             :     DssSpFrame fparam;
      57             :     int32_t working_buffer[SUBFRAMES][72];
      58             :     int32_t audio_buf[15];
      59             :     int32_t err_buf1[15];
      60             :     int32_t lpc_filter[14];
      61             :     int32_t filter[15];
      62             :     int32_t vector_buf[72];
      63             :     int noise_state;
      64             :     int32_t err_buf2[15];
      65             : 
      66             :     int pulse_dec_mode;
      67             : 
      68             :     DECLARE_ALIGNED(16, uint8_t, bits)[DSS_SP_FRAME_SIZE +
      69             :                                        AV_INPUT_BUFFER_PADDING_SIZE];
      70             : } DssSpContext;
      71             : 
      72             : /*
      73             :  * Used for the coding/decoding of the pulse positions for the MP-MLQ codebook.
      74             :  */
      75             : static const uint32_t dss_sp_combinatorial_table[PULSE_MAX][72] = {
      76             :     {       0,         0,         0,          0,          0,          0,
      77             :             0,         0,         0,          0,          0,          0,
      78             :             0,         0,         0,          0,          0,          0,
      79             :             0,         0,         0,          0,          0,          0,
      80             :             0,         0,         0,          0,          0,          0,
      81             :             0,         0,         0,          0,          0,          0,
      82             :             0,         0,         0,          0,          0,          0,
      83             :             0,         0,         0,          0,          0,          0,
      84             :             0,         0,         0,          0,          0,          0,
      85             :             0,         0,         0,          0,          0,          0,
      86             :             0,         0,         0,          0,          0,          0,
      87             :             0,         0,         0,          0,          0,          0 },
      88             :     {       0,         1,         2,          3,          4,          5,
      89             :             6,         7,         8,          9,         10,         11,
      90             :            12,        13,        14,         15,         16,         17,
      91             :            18,        19,        20,         21,         22,         23,
      92             :            24,        25,        26,         27,         28,         29,
      93             :            30,        31,        32,         33,         34,         35,
      94             :            36,        37,        38,         39,         40,         41,
      95             :            42,        43,        44,         45,         46,         47,
      96             :            48,        49,        50,         51,         52,         53,
      97             :            54,        55,        56,         57,         58,         59,
      98             :            60,        61,        62,         63,         64,         65,
      99             :            66,        67,        68,         69,         70,         71 },
     100             :     {       0,         0,         1,          3,          6,         10,
     101             :            15,        21,        28,         36,         45,         55,
     102             :            66,        78,        91,        105,        120,        136,
     103             :           153,       171,       190,        210,        231,        253,
     104             :           276,       300,       325,        351,        378,        406,
     105             :           435,       465,       496,        528,        561,        595,
     106             :           630,       666,       703,        741,        780,        820,
     107             :           861,       903,       946,        990,       1035,       1081,
     108             :          1128,      1176,      1225,       1275,       1326,       1378,
     109             :          1431,      1485,      1540,       1596,       1653,       1711,
     110             :          1770,      1830,      1891,       1953,       2016,       2080,
     111             :          2145,      2211,      2278,       2346,       2415,       2485 },
     112             :     {       0,         0,         0,          1,          4,         10,
     113             :            20,        35,        56,         84,        120,        165,
     114             :           220,       286,       364,        455,        560,        680,
     115             :           816,       969,      1140,       1330,       1540,       1771,
     116             :          2024,      2300,      2600,       2925,       3276,       3654,
     117             :          4060,      4495,      4960,       5456,       5984,       6545,
     118             :          7140,      7770,      8436,       9139,       9880,      10660,
     119             :         11480,     12341,     13244,      14190,      15180,      16215,
     120             :         17296,     18424,     19600,      20825,      22100,      23426,
     121             :         24804,     26235,     27720,      29260,      30856,      32509,
     122             :         34220,     35990,     37820,      39711,      41664,      43680,
     123             :         45760,     47905,     50116,      52394,      54740,      57155 },
     124             :     {       0,         0,         0,          0,          1,          5,
     125             :            15,        35,        70,        126,        210,        330,
     126             :           495,       715,      1001,       1365,       1820,       2380,
     127             :          3060,      3876,      4845,       5985,       7315,       8855,
     128             :         10626,     12650,     14950,      17550,      20475,      23751,
     129             :         27405,     31465,     35960,      40920,      46376,      52360,
     130             :         58905,     66045,     73815,      82251,      91390,     101270,
     131             :        111930,    123410,    135751,     148995,     163185,     178365,
     132             :        194580,    211876,    230300,     249900,     270725,     292825,
     133             :        316251,    341055,    367290,     395010,     424270,     455126,
     134             :        487635,    521855,    557845,     595665,     635376,     677040,
     135             :        720720,    766480,    814385,     864501,     916895,     971635 },
     136             :     {       0,         0,         0,          0,          0,          1,
     137             :             6,        21,        56,        126,        252,        462,
     138             :           792,      1287,      2002,       3003,       4368,       6188,
     139             :          8568,     11628,     15504,      20349,      26334,      33649,
     140             :         42504,     53130,     65780,      80730,      98280,     118755,
     141             :        142506,    169911,    201376,     237336,     278256,     324632,
     142             :        376992,    435897,    501942,     575757,     658008,     749398,
     143             :        850668,    962598,   1086008,    1221759,    1370754,    1533939,
     144             :       1712304,   1906884,   2118760,    2349060,    2598960,    2869685,
     145             :       3162510,   3478761,   3819816,    4187106,    4582116,    5006386,
     146             :       5461512,   5949147,   6471002,    7028847,    7624512,    8259888,
     147             :       8936928,   9657648,  10424128,   11238513,   12103014,   13019909 },
     148             :     {       0,         0,         0,          0,          0,          0,
     149             :             1,         7,        28,         84,        210,        462,
     150             :           924,      1716,      3003,       5005,       8008,      12376,
     151             :         18564,     27132,     38760,      54264,      74613,     100947,
     152             :        134596,    177100,    230230,     296010,     376740,     475020,
     153             :        593775,    736281,    906192,    1107568,    1344904,    1623160,
     154             :       1947792,   2324784,   2760681,    3262623,    3838380,    4496388,
     155             :       5245786,   6096454,   7059052,    8145060,    9366819,   10737573,
     156             :      12271512,  13983816,  15890700,   18009460,   20358520,   22957480,
     157             :      25827165,  28989675,  32468436,   36288252,   40475358,   45057474,
     158             :      50063860,  55525372,  61474519,   67945521,   74974368,   82598880,
     159             :      90858768,  99795696, 109453344,  119877472,  131115985,  143218999 },
     160             :     {       0,         0,         0,          0,          0,          0,
     161             :             0,         1,         8,         36,        120,        330,
     162             :           792,      1716,      3432,       6435,      11440,      19448,
     163             :         31824,     50388,     77520,     116280,     170544,     245157,
     164             :        346104,    480700,    657800,     888030,    1184040,    1560780,
     165             :       2035800,   2629575,   3365856,    4272048,    5379616,    6724520,
     166             :       8347680,  10295472,  12620256,   15380937,   18643560,   22481940,
     167             :      26978328,  32224114,  38320568,   45379620,   53524680,   62891499,
     168             :      73629072,  85900584,  99884400,  115775100,  133784560,  154143080,
     169             :     177100560, 202927725, 231917400,  264385836,  300674088,  341149446,
     170             :     386206920, 436270780, 491796152,  553270671,  621216192,  696190560,
     171             :     778789440, 869648208, 969443904, 1078897248, 1198774720, 1329890705 },
     172             : };
     173             : 
     174             : static const int16_t dss_sp_filter_cb[14][32] = {
     175             :     { -32653, -32587, -32515, -32438, -32341, -32216, -32062, -31881,
     176             :       -31665, -31398, -31080, -30724, -30299, -29813, -29248, -28572,
     177             :       -27674, -26439, -24666, -22466, -19433, -16133, -12218,  -7783,
     178             :        -2834,   1819,   6544,  11260,  16050,  20220,  24774,  28120 },
     179             : 
     180             :     { -27503, -24509, -20644, -17496, -14187, -11277,  -8420,  -5595,
     181             :        -3013,   -624,   1711,   3880,   5844,   7774,   9739,  11592,
     182             :        13364,  14903,  16426,  17900,  19250,  20586,  21803,  23006,
     183             :        24142,  25249,  26275,  27300,  28359,  29249,  30118,  31183 },
     184             : 
     185             :     { -27827, -24208, -20943, -17781, -14843, -11848,  -9066,  -6297,
     186             :        -3660,   -910,   1918,   5025,   8223,  11649,  15086,  18423,
     187             :            0,      0,      0,      0,      0,      0,      0,      0,
     188             :            0,      0,      0,      0,      0,      0,      0,      0 },
     189             : 
     190             :     { -17128, -11975,  -8270,  -5123,  -2296,    183,   2503,   4707,
     191             :         6798,   8945,  11045,  13239,  15528,  18248,  21115,  24785,
     192             :            0,      0,      0,      0,      0,      0,      0,      0,
     193             :            0,      0,      0,      0,      0,      0,      0,      0 },
     194             : 
     195             :     { -21557, -17280, -14286, -11644,  -9268,  -7087,  -4939,  -2831,
     196             :         -691,   1407,   3536,   5721,   8125,  10677,  13721,  17731,
     197             :            0,      0,      0,      0,      0,      0,      0,      0,
     198             :            0,      0,      0,      0,      0,      0,      0,      0 },
     199             : 
     200             :     { -15030, -10377,  -7034,  -4327,  -1900,    364,   2458,   4450,
     201             :         6422,   8374,  10374,  12486,  14714,  16997,  19626,  22954,
     202             :            0,      0,      0,      0,      0,      0,      0,      0,
     203             :            0,      0,      0,      0,      0,      0,      0,      0 },
     204             : 
     205             :     { -16155, -12362,  -9698,  -7460,  -5258,  -3359,  -1547,    219,
     206             :         1916,   3599,   5299,   6994,   8963,  11226,  13716,  16982,
     207             :            0,      0,      0,      0,      0,      0,      0,      0,
     208             :            0,      0,      0,      0,      0,      0,      0,      0 },
     209             : 
     210             :     { -14742,  -9848,  -6921,  -4648,  -2769,  -1065,    499,   2083,
     211             :         3633,   5219,   6857,   8580,  10410,  12672,  15561,  20101,
     212             :            0,      0,      0,      0,      0,      0,      0,      0,
     213             :            0,      0,      0,      0,      0,      0,      0,      0 },
     214             : 
     215             :     { -11099,  -7014,  -3855,  -1025,   1680,   4544,   7807,  11932,
     216             :            0,      0,      0,      0,      0,      0,      0,      0,
     217             :            0,      0,      0,      0,      0,      0,      0,      0,
     218             :            0,      0,      0,      0,      0,      0,      0,      0 },
     219             : 
     220             :     {  -9060,  -4570,  -1381,   1419,   4034,   6728,   9865,  14149,
     221             :            0,      0,      0,      0,      0,      0,      0,      0,
     222             :            0,      0,      0,      0,      0,      0,      0,      0,
     223             :            0,      0,      0,      0,      0,      0,      0,      0 },
     224             : 
     225             :     { -12450,  -7985,  -4596,  -1734,    961,   3629,   6865,  11142,
     226             :            0,      0,      0,      0,      0,      0,      0,      0,
     227             :            0,      0,      0,      0,      0,      0,      0,      0,
     228             :            0,      0,      0,      0,      0,      0,      0,      0 },
     229             : 
     230             :     { -11831,  -7404,  -4010,  -1096,   1606,   4291,   7386,  11482,
     231             :            0,      0,      0,      0,      0,      0,      0,      0,
     232             :            0,      0,      0,      0,      0,      0,      0,      0,
     233             :            0,      0,      0,      0,      0,      0,      0,      0 },
     234             : 
     235             :     { -13404,  -9250,  -5995,  -3312,   -890,   1594,   4464,   8198,
     236             :            0,      0,      0,      0,      0,      0,      0,      0,
     237             :            0,      0,      0,      0,      0,      0,      0,      0,
     238             :            0,      0,      0,      0,      0,      0,      0,      0 },
     239             : 
     240             :     { -11239,  -7220,  -4040,  -1406,    971,   3321,   6006,   9697,
     241             :            0,      0,      0,      0,      0,      0,      0,      0,
     242             :            0,      0,      0,      0,      0,      0,      0,      0,
     243             :            0,      0,      0,      0,      0,      0,      0,      0 },
     244             : };
     245             : 
     246             : static const uint16_t  dss_sp_fixed_cb_gain[64] = {
     247             :        0,    4,    8,   13,   17,   22,   26,   31,
     248             :       35,   40,   44,   48,   53,   58,   63,   69,
     249             :       76,   83,   91,   99,  109,  119,  130,  142,
     250             :      155,  170,  185,  203,  222,  242,  265,  290,
     251             :      317,  346,  378,  414,  452,  494,  540,  591,
     252             :      646,  706,  771,  843,  922, 1007, 1101, 1204,
     253             :     1316, 1438, 1572, 1719, 1879, 2053, 2244, 2453,
     254             :     2682, 2931, 3204, 3502, 3828, 4184, 4574, 5000,
     255             : };
     256             : 
     257             : static const int16_t  dss_sp_pulse_val[8] = {
     258             :     -31182, -22273, -13364, -4455, 4455, 13364, 22273, 31182
     259             : };
     260             : 
     261             : static const uint16_t binary_decreasing_array[] = {
     262             :     32767, 16384, 8192, 4096, 2048, 1024, 512, 256,
     263             :     128, 64, 32, 16, 8, 4, 2,
     264             : };
     265             : 
     266             : static const uint16_t dss_sp_unc_decreasing_array[] = {
     267             :     32767, 26214, 20972, 16777, 13422, 10737, 8590, 6872,
     268             :     5498, 4398, 3518, 2815, 2252, 1801, 1441,
     269             : };
     270             : 
     271             : static const uint16_t dss_sp_adaptive_gain[] = {
     272             :      102,  231,  360,  488,  617,  746,  875, 1004,
     273             :     1133, 1261, 1390, 1519, 1648, 1777, 1905, 2034,
     274             :     2163, 2292, 2421, 2550, 2678, 2807, 2936, 3065,
     275             :     3194, 3323, 3451, 3580, 3709, 3838, 3967, 4096,
     276             : };
     277             : 
     278             : static const int32_t dss_sp_sinc[67] = {
     279             :       262,   293,   323,   348,   356,   336,   269,   139,
     280             :       -67,  -358,  -733, -1178, -1668, -2162, -2607, -2940,
     281             :     -3090, -2986, -2562, -1760,  -541,  1110,  3187,  5651,
     282             :      8435, 11446, 14568, 17670, 20611, 23251, 25460, 27125,
     283             :     28160, 28512, 28160,
     284             :     27125, 25460, 23251, 20611, 17670, 14568, 11446,  8435,
     285             :      5651,  3187,  1110,  -541, -1760, -2562, -2986, -3090,
     286             :     -2940, -2607, -2162, -1668, -1178,  -733,  -358,   -67,
     287             :       139,   269,   336,   356,   348,   323,   293,   262,
     288             : };
     289             : 
     290           2 : static av_cold int dss_sp_decode_init(AVCodecContext *avctx)
     291             : {
     292           2 :     DssSpContext *p = avctx->priv_data;
     293           2 :     avctx->channel_layout = AV_CH_LAYOUT_MONO;
     294           2 :     avctx->sample_fmt     = AV_SAMPLE_FMT_S16;
     295           2 :     avctx->channels       = 1;
     296           2 :     avctx->sample_rate    = 11025;
     297             : 
     298           2 :     memset(p->history, 0, sizeof(p->history));
     299           2 :     p->pulse_dec_mode = 1;
     300           2 :     p->avctx          = avctx;
     301             : 
     302           2 :     return 0;
     303             : }
     304             : 
     305          30 : static void dss_sp_unpack_coeffs(DssSpContext *p, const uint8_t *src)
     306             : {
     307             :     GetBitContext gb;
     308          30 :     DssSpFrame *fparam = &p->fparam;
     309             :     int i;
     310             :     int subframe_idx;
     311             :     uint32_t combined_pitch;
     312             :     uint32_t tmp;
     313             :     uint32_t pitch_lag;
     314             : 
     315         660 :     for (i = 0; i < DSS_SP_FRAME_SIZE; i += 2) {
     316         630 :         p->bits[i]     = src[i + 1];
     317         630 :         p->bits[i + 1] = src[i];
     318             :     }
     319             : 
     320          30 :     init_get_bits(&gb, p->bits, DSS_SP_FRAME_SIZE * 8);
     321             : 
     322          90 :     for (i = 0; i < 2; i++)
     323          60 :         fparam->filter_idx[i] = get_bits(&gb, 5);
     324         210 :     for (; i < 8; i++)
     325         180 :         fparam->filter_idx[i] = get_bits(&gb, 4);
     326         210 :     for (; i < 14; i++)
     327         180 :         fparam->filter_idx[i] = get_bits(&gb, 3);
     328             : 
     329         150 :     for (subframe_idx = 0; subframe_idx < 4; subframe_idx++) {
     330         120 :         fparam->sf_adaptive_gain[subframe_idx] = get_bits(&gb, 5);
     331             : 
     332         120 :         fparam->sf[subframe_idx].combined_pulse_pos = get_bits_long(&gb, 31);
     333             : 
     334         120 :         fparam->sf[subframe_idx].gain = get_bits(&gb, 6);
     335             : 
     336         960 :         for (i = 0; i < 7; i++)
     337         840 :             fparam->sf[subframe_idx].pulse_val[i] = get_bits(&gb, 3);
     338             :     }
     339             : 
     340         150 :     for (subframe_idx = 0; subframe_idx < 4; subframe_idx++) {
     341         120 :         unsigned int C72_binomials[PULSE_MAX] = {
     342             :             72, 2556, 59640, 1028790, 13991544, 156238908, 1473109704,
     343             :             3379081753
     344             :         };
     345         120 :         unsigned int combined_pulse_pos =
     346         120 :             fparam->sf[subframe_idx].combined_pulse_pos;
     347         120 :         int index = 6;
     348             : 
     349         120 :         if (combined_pulse_pos < C72_binomials[PULSE_MAX - 1]) {
     350         120 :             if (p->pulse_dec_mode) {
     351             :                 int pulse, pulse_idx;
     352         120 :                 pulse              = PULSE_MAX - 1;
     353         120 :                 pulse_idx          = 71;
     354         120 :                 combined_pulse_pos =
     355         120 :                     fparam->sf[subframe_idx].combined_pulse_pos;
     356             : 
     357             :                 /* this part seems to be close to g723.1 gen_fcb_excitation()
     358             :                  * RATE_6300 */
     359             : 
     360             :                 /* TODO: what is 7? size of subframe? */
     361         960 :                 for (i = 0; i < 7; i++) {
     362        8910 :                     for (;
     363             :                          combined_pulse_pos <
     364        8070 :                          dss_sp_combinatorial_table[pulse][pulse_idx];
     365        7230 :                          --pulse_idx)
     366             :                         ;
     367         840 :                     combined_pulse_pos -=
     368         840 :                         dss_sp_combinatorial_table[pulse][pulse_idx];
     369         840 :                     pulse--;
     370         840 :                     fparam->sf[subframe_idx].pulse_pos[i] = pulse_idx;
     371             :                 }
     372             :             }
     373             :         } else {
     374           0 :             p->pulse_dec_mode = 0;
     375             : 
     376             :             /* why do we need this? */
     377           0 :             fparam->sf[subframe_idx].pulse_pos[6] = 0;
     378             : 
     379           0 :             for (i = 71; i >= 0; i--) {
     380           0 :                 if (C72_binomials[index] <= combined_pulse_pos) {
     381           0 :                     combined_pulse_pos -= C72_binomials[index];
     382             : 
     383           0 :                     fparam->sf[subframe_idx].pulse_pos[6 - index] = i;
     384             : 
     385           0 :                     if (!index)
     386           0 :                         break;
     387           0 :                     --index;
     388             :                 }
     389           0 :                 --C72_binomials[0];
     390           0 :                 if (index) {
     391             :                     int a;
     392           0 :                     for (a = 0; a < index; a++)
     393           0 :                         C72_binomials[a + 1] -= C72_binomials[a];
     394             :                 }
     395             :             }
     396             :         }
     397             :     }
     398             : 
     399          30 :     combined_pitch = get_bits(&gb, 24);
     400             : 
     401          30 :     fparam->pitch_lag[0] = (combined_pitch % 151) + 36;
     402             : 
     403          30 :     combined_pitch /= 151;
     404             : 
     405          90 :     for (i = 1; i < SUBFRAMES - 1; i++) {
     406          60 :         fparam->pitch_lag[i] = combined_pitch % 48;
     407          60 :         combined_pitch      /= 48;
     408             :     }
     409          30 :     if (combined_pitch > 47) {
     410           0 :         av_log (p->avctx, AV_LOG_WARNING, "combined_pitch was too large\n");
     411           0 :         combined_pitch = 0;
     412             :     }
     413          30 :     fparam->pitch_lag[i] = combined_pitch;
     414             : 
     415          30 :     pitch_lag = fparam->pitch_lag[0];
     416         120 :     for (i = 1; i < SUBFRAMES; i++) {
     417          90 :         if (pitch_lag > 162) {
     418          11 :             fparam->pitch_lag[i] += 162 - 23;
     419             :         } else {
     420          79 :             tmp = pitch_lag - 23;
     421          79 :             if (tmp < 36)
     422          17 :                 tmp = 36;
     423          79 :             fparam->pitch_lag[i] += tmp;
     424             :         }
     425          90 :         pitch_lag = fparam->pitch_lag[i];
     426             :     }
     427          30 : }
     428             : 
     429          30 : static void dss_sp_unpack_filter(DssSpContext *p)
     430             : {
     431             :     int i;
     432             : 
     433         450 :     for (i = 0; i < 14; i++)
     434         420 :         p->lpc_filter[i] = dss_sp_filter_cb[i][p->fparam.filter_idx[i]];
     435          30 : }
     436             : 
     437          30 : static void dss_sp_convert_coeffs(int32_t *lpc_filter, int32_t *coeffs)
     438             : {
     439             :     int a, a_plus, i;
     440             : 
     441          30 :     coeffs[0] = 0x2000;
     442         450 :     for (a = 0; a < 14; a++) {
     443         420 :         a_plus         = a + 1;
     444         420 :         coeffs[a_plus] = lpc_filter[a] >> 2;
     445         420 :         if (a_plus / 2 >= 1) {
     446        1860 :             for (i = 1; i <= a_plus / 2; i++) {
     447             :                 int coeff_1, coeff_2, tmp;
     448             : 
     449        1470 :                 coeff_1 = coeffs[i];
     450        1470 :                 coeff_2 = coeffs[a_plus - i];
     451             : 
     452        1470 :                 tmp = DSS_SP_FORMULA(coeff_1, lpc_filter[a], coeff_2);
     453        1470 :                 coeffs[i] = av_clip_int16(tmp);
     454             : 
     455        1470 :                 tmp = DSS_SP_FORMULA(coeff_2, lpc_filter[a], coeff_1);
     456        1470 :                 coeffs[a_plus - i] = av_clip_int16(tmp);
     457             :             }
     458             :         }
     459             :     }
     460          30 : }
     461             : 
     462         120 : static void dss_sp_add_pulses(int32_t *vector_buf,
     463             :                               const struct DssSpSubframe *sf)
     464             : {
     465             :     int i;
     466             : 
     467         960 :     for (i = 0; i < 7; i++)
     468        2520 :         vector_buf[sf->pulse_pos[i]] += (dss_sp_fixed_cb_gain[sf->gain] *
     469        1680 :                                          dss_sp_pulse_val[sf->pulse_val[i]] +
     470         840 :                                          0x4000) >> 15;
     471         120 : }
     472             : 
     473         120 : static void dss_sp_gen_exc(int32_t *vector, int32_t *prev_exc,
     474             :                            int pitch_lag, int gain)
     475             : {
     476             :     int i;
     477             : 
     478             :     /* do we actually need this check? we can use just [a3 - i % a3]
     479             :      * for both cases */
     480         120 :     if (pitch_lag < 72)
     481        2336 :         for (i = 0; i < 72; i++)
     482        2304 :             vector[i] = prev_exc[pitch_lag - i % pitch_lag];
     483             :     else
     484        6424 :         for (i = 0; i < 72; i++)
     485        6336 :             vector[i] = prev_exc[pitch_lag - i];
     486             : 
     487        8760 :     for (i = 0; i < 72; i++) {
     488        8640 :         int tmp = gain * vector[i] >> 11;
     489        8640 :         vector[i] = av_clip_int16(tmp);
     490             :     }
     491         120 : }
     492             : 
     493         720 : static void dss_sp_scale_vector(int32_t *vec, int bits, int size)
     494             : {
     495             :     int i;
     496             : 
     497         720 :     if (bits < 0)
     498       12600 :         for (i = 0; i < size; i++)
     499       12240 :             vec[i] = vec[i] >> -bits;
     500             :     else
     501       12600 :         for (i = 0; i < size; i++)
     502       12240 :             vec[i] = vec[i] * (1 << bits);
     503         720 : }
     504             : 
     505         120 : static void dss_sp_update_buf(int32_t *hist, int32_t *vector)
     506             : {
     507             :     int i;
     508             : 
     509       13800 :     for (i = 114; i > 0; i--)
     510       13680 :         vector[i + 72] = vector[i];
     511             : 
     512        8760 :     for (i = 0; i < 72; i++)
     513        8640 :         vector[72 - i] = hist[i];
     514         120 : }
     515             : 
     516         240 : static void dss_sp_shift_sq_sub(const int32_t *filter_buf,
     517             :                                 int32_t *error_buf, int32_t *dst)
     518             : {
     519             :     int a;
     520             : 
     521       17520 :     for (a = 0; a < 72; a++) {
     522             :         int i, tmp;
     523             : 
     524       17280 :         tmp = dst[a] * filter_buf[0];
     525             : 
     526      259200 :         for (i = 14; i > 0; i--)
     527      241920 :             tmp -= error_buf[i] * (unsigned)filter_buf[i];
     528             : 
     529      259200 :         for (i = 14; i > 0; i--)
     530      241920 :             error_buf[i] = error_buf[i - 1];
     531             : 
     532       17280 :         tmp = (int)(tmp + 4096U) >> 13;
     533             : 
     534       17280 :         error_buf[1] = tmp;
     535             : 
     536       17280 :         dst[a] = av_clip_int16(tmp);
     537             :     }
     538         240 : }
     539             : 
     540         120 : static void dss_sp_shift_sq_add(const int32_t *filter_buf, int32_t *audio_buf,
     541             :                                 int32_t *dst)
     542             : {
     543             :     int a;
     544             : 
     545        8760 :     for (a = 0; a < 72; a++) {
     546        8640 :         int i, tmp = 0;
     547             : 
     548        8640 :         audio_buf[0] = dst[a];
     549             : 
     550      138240 :         for (i = 14; i >= 0; i--)
     551      129600 :             tmp += audio_buf[i] * filter_buf[i];
     552             : 
     553      129600 :         for (i = 14; i > 0; i--)
     554      120960 :             audio_buf[i] = audio_buf[i - 1];
     555             : 
     556        8640 :         tmp = (tmp + 4096) >> 13;
     557             : 
     558        8640 :         dst[a] = av_clip_int16(tmp);
     559             :     }
     560         120 : }
     561             : 
     562         240 : static void dss_sp_vec_mult(const int32_t *src, int32_t *dst,
     563             :                             const int16_t *mult)
     564             : {
     565             :     int i;
     566             : 
     567         240 :     dst[0] = src[0];
     568             : 
     569        3600 :     for (i = 1; i < 15; i++)
     570        3360 :         dst[i] = (src[i] * mult[i] + 0x4000) >> 15;
     571         240 : }
     572             : 
     573         120 : static int dss_sp_get_normalize_bits(int32_t *vector_buf, int16_t size)
     574             : {
     575             :     unsigned int val;
     576             :     int max_val;
     577             :     int i;
     578             : 
     579         120 :     val = 1;
     580        8760 :     for (i = 0; i < size; i++)
     581        8640 :         val |= FFABS(vector_buf[i]);
     582             : 
     583         999 :     for (max_val = 0; val <= 0x4000; ++max_val)
     584         879 :         val *= 2;
     585         120 :     return max_val;
     586             : }
     587             : 
     588         240 : static int dss_sp_vector_sum(DssSpContext *p, int size)
     589             : {
     590         240 :     int i, sum = 0;
     591       17520 :     for (i = 0; i < size; i++)
     592       17280 :         sum += FFABS(p->vector_buf[i]);
     593         240 :     return sum;
     594             : }
     595             : 
     596         120 : static void dss_sp_sf_synthesis(DssSpContext *p, int32_t lpc_filter,
     597             :                                 int32_t *dst, int size)
     598             : {
     599             :     int32_t tmp_buf[15];
     600             :     int32_t noise[72];
     601         120 :     int bias, vsum_2 = 0, vsum_1 = 0, v36, normalize_bits;
     602             :     int i, tmp;
     603             : 
     604         120 :     if (size > 0) {
     605         120 :         vsum_1 = dss_sp_vector_sum(p, size);
     606             : 
     607         120 :         if (vsum_1 > 0xFFFFF)
     608           0 :             vsum_1 = 0xFFFFF;
     609             :     }
     610             : 
     611         120 :     normalize_bits = dss_sp_get_normalize_bits(p->vector_buf, size);
     612             : 
     613         120 :     dss_sp_scale_vector(p->vector_buf, normalize_bits - 3, size);
     614         120 :     dss_sp_scale_vector(p->audio_buf, normalize_bits, 15);
     615         120 :     dss_sp_scale_vector(p->err_buf1, normalize_bits, 15);
     616             : 
     617         120 :     v36 = p->err_buf1[1];
     618             : 
     619         120 :     dss_sp_vec_mult(p->filter, tmp_buf, binary_decreasing_array);
     620         120 :     dss_sp_shift_sq_add(tmp_buf, p->audio_buf, p->vector_buf);
     621             : 
     622         120 :     dss_sp_vec_mult(p->filter, tmp_buf, dss_sp_unc_decreasing_array);
     623         120 :     dss_sp_shift_sq_sub(tmp_buf, p->err_buf1, p->vector_buf);
     624             : 
     625             :     /* lpc_filter can be negative */
     626         120 :     lpc_filter = lpc_filter >> 1;
     627         120 :     if (lpc_filter >= 0)
     628           0 :         lpc_filter = 0;
     629             : 
     630         120 :     if (size > 1) {
     631        8640 :         for (i = size - 1; i > 0; i--) {
     632        8520 :             tmp = DSS_SP_FORMULA(p->vector_buf[i], lpc_filter,
     633             :                                  p->vector_buf[i - 1]);
     634        8520 :             p->vector_buf[i] = av_clip_int16(tmp);
     635             :         }
     636             :     }
     637             : 
     638         120 :     tmp              = DSS_SP_FORMULA(p->vector_buf[0], lpc_filter, v36);
     639         120 :     p->vector_buf[0] = av_clip_int16(tmp);
     640             : 
     641         120 :     dss_sp_scale_vector(p->vector_buf, -normalize_bits, size);
     642         120 :     dss_sp_scale_vector(p->audio_buf, -normalize_bits, 15);
     643         120 :     dss_sp_scale_vector(p->err_buf1, -normalize_bits, 15);
     644             : 
     645         120 :     if (size > 0)
     646         120 :         vsum_2 = dss_sp_vector_sum(p, size);
     647             : 
     648         120 :     if (vsum_2 >= 0x40)
     649         120 :         tmp = (vsum_1 << 11) / vsum_2;
     650             :     else
     651           0 :         tmp = 1;
     652             : 
     653         120 :     bias     = 409 * tmp >> 15 << 15;
     654         120 :     tmp      = (bias + 32358 * p->noise_state) >> 15;
     655         120 :     noise[0] = av_clip_int16(tmp);
     656             : 
     657        8640 :     for (i = 1; i < size; i++) {
     658        8520 :         tmp      = (bias + 32358 * noise[i - 1]) >> 15;
     659        8520 :         noise[i] = av_clip_int16(tmp);
     660             :     }
     661             : 
     662         120 :     p->noise_state = noise[size - 1];
     663        8760 :     for (i = 0; i < size; i++) {
     664        8640 :         tmp    = (p->vector_buf[i] * noise[i]) >> 11;
     665        8640 :         dst[i] = av_clip_int16(tmp);
     666             :     }
     667         120 : }
     668             : 
     669          30 : static void dss_sp_update_state(DssSpContext *p, int32_t *dst)
     670             : {
     671          30 :     int i, offset = 6, counter = 0, a = 0;
     672             : 
     673         210 :     for (i = 0; i < 6; i++)
     674         180 :         p->excitation[i] = p->excitation[288 + i];
     675             : 
     676        8670 :     for (i = 0; i < 72 * SUBFRAMES; i++)
     677        8640 :         p->excitation[6 + i] = dst[i];
     678             : 
     679             :     do {
     680        7920 :         int tmp = 0;
     681             : 
     682       55440 :         for (i = 0; i < 6; i++)
     683       47520 :             tmp += p->excitation[offset--] * dss_sp_sinc[a + i * 11];
     684             : 
     685        7920 :         offset += 7;
     686             : 
     687        7920 :         tmp >>= 15;
     688        7920 :         dst[counter] = av_clip_int16(tmp);
     689             : 
     690        7920 :         counter++;
     691             : 
     692        7920 :         a = (a + 1) % 11;
     693        7920 :         if (!a)
     694         720 :             offset++;
     695        7920 :     } while (offset < FF_ARRAY_ELEMS(p->excitation));
     696          30 : }
     697             : 
     698          30 : static void dss_sp_32to16bit(int16_t *dst, int32_t *src, int size)
     699             : {
     700             :     int i;
     701             : 
     702        7950 :     for (i = 0; i < size; i++)
     703        7920 :         dst[i] = av_clip_int16(src[i]);
     704          30 : }
     705             : 
     706          30 : static int dss_sp_decode_one_frame(DssSpContext *p,
     707             :                                    int16_t *abuf_dst, const uint8_t *abuf_src)
     708             : {
     709             :     int i, j;
     710             : 
     711          30 :     dss_sp_unpack_coeffs(p, abuf_src);
     712             : 
     713          30 :     dss_sp_unpack_filter(p);
     714             : 
     715          30 :     dss_sp_convert_coeffs(p->lpc_filter, p->filter);
     716             : 
     717         150 :     for (j = 0; j < SUBFRAMES; j++) {
     718         240 :         dss_sp_gen_exc(p->vector_buf, p->history,
     719         120 :                        p->fparam.pitch_lag[j],
     720         120 :                        dss_sp_adaptive_gain[p->fparam.sf_adaptive_gain[j]]);
     721             : 
     722         120 :         dss_sp_add_pulses(p->vector_buf, &p->fparam.sf[j]);
     723             : 
     724         120 :         dss_sp_update_buf(p->vector_buf, p->history);
     725             : 
     726        8760 :         for (i = 0; i < 72; i++)
     727        8640 :             p->vector_buf[i] = p->history[72 - i];
     728             : 
     729         120 :         dss_sp_shift_sq_sub(p->filter,
     730         120 :                             p->err_buf2, p->vector_buf);
     731             : 
     732         120 :         dss_sp_sf_synthesis(p, p->lpc_filter[0],
     733             :                             &p->working_buffer[j][0], 72);
     734             :     }
     735             : 
     736          30 :     dss_sp_update_state(p, &p->working_buffer[0][0]);
     737             : 
     738          30 :     dss_sp_32to16bit(abuf_dst,
     739             :                      &p->working_buffer[0][0], 264);
     740          30 :     return 0;
     741             : }
     742             : 
     743          30 : static int dss_sp_decode_frame(AVCodecContext *avctx, void *data,
     744             :                                int *got_frame_ptr, AVPacket *avpkt)
     745             : {
     746          30 :     DssSpContext *p    = avctx->priv_data;
     747          30 :     AVFrame *frame     = data;
     748          30 :     const uint8_t *buf = avpkt->data;
     749          30 :     int buf_size       = avpkt->size;
     750             : 
     751             :     int16_t *out;
     752             :     int ret;
     753             : 
     754          30 :     if (buf_size < DSS_SP_FRAME_SIZE) {
     755           0 :         if (buf_size)
     756           0 :             av_log(avctx, AV_LOG_WARNING,
     757             :                    "Expected %d bytes, got %d - skipping packet.\n",
     758             :                    DSS_SP_FRAME_SIZE, buf_size);
     759           0 :         *got_frame_ptr = 0;
     760           0 :         return AVERROR_INVALIDDATA;
     761             :     }
     762             : 
     763          30 :     frame->nb_samples = DSS_SP_SAMPLE_COUNT;
     764          30 :     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
     765           0 :         return ret;
     766             : 
     767          30 :     out = (int16_t *)frame->data[0];
     768             : 
     769          30 :     dss_sp_decode_one_frame(p, out, buf);
     770             : 
     771          30 :     *got_frame_ptr = 1;
     772             : 
     773          30 :     return DSS_SP_FRAME_SIZE;
     774             : }
     775             : 
     776             : AVCodec ff_dss_sp_decoder = {
     777             :     .name           = "dss_sp",
     778             :     .long_name      = NULL_IF_CONFIG_SMALL("Digital Speech Standard - Standard Play mode (DSS SP)"),
     779             :     .type           = AVMEDIA_TYPE_AUDIO,
     780             :     .id             = AV_CODEC_ID_DSS_SP,
     781             :     .priv_data_size = sizeof(DssSpContext),
     782             :     .init           = dss_sp_decode_init,
     783             :     .decode         = dss_sp_decode_frame,
     784             :     .capabilities   = AV_CODEC_CAP_DR1,
     785             : };

Generated by: LCOV version 1.13