LCOV - code coverage report
Current view: top level - libavcodec - flacdsp_lpc_template.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 43 64 67.2 %
Date: 2017-12-15 18:13:28 Functions: 4 4 100.0 %

          Line data    Source code
       1             : /*
       2             :  * This file is part of FFmpeg.
       3             :  *
       4             :  * FFmpeg is free software; you can redistribute it and/or
       5             :  * modify it under the terms of the GNU Lesser General Public
       6             :  * License as published by the Free Software Foundation; either
       7             :  * version 2.1 of the License, or (at your option) any later version.
       8             :  *
       9             :  * FFmpeg is distributed in the hope that it will be useful,
      10             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12             :  * Lesser General Public License for more details.
      13             :  *
      14             :  * You should have received a copy of the GNU Lesser General Public
      15             :  * License along with FFmpeg; if not, write to the Free Software
      16             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      17             :  */
      18             : 
      19             : #include <stdint.h>
      20             : #include "libavutil/avutil.h"
      21             : #include "mathops.h"
      22             : 
      23             : #undef FUNC
      24             : #undef sum_type
      25             : #undef MUL
      26             : #undef CLIP
      27             : #undef FSUF
      28             : 
      29             : #define FUNC(n) AV_JOIN(n ## _, SAMPLE_SIZE)
      30             : 
      31             : #if SAMPLE_SIZE == 32
      32             : #   define sum_type  int64_t
      33             : #   define MUL(a, b) MUL64(a, b)
      34             : #   define CLIP(x) av_clipl_int32(x)
      35             : #else
      36             : #   define sum_type  int32_t
      37             : #   define MUL(a, b) ((a) * (b))
      38             : #   define CLIP(x) (x)
      39             : #endif
      40             : 
      41             : #define LPC1(x) {           \
      42             :     int c = coefs[(x)-1];   \
      43             :     p0   += MUL(c, s);      \
      44             :     s     = smp[i-(x)+1];   \
      45             :     p1   += MUL(c, s);      \
      46             : }
      47             : 
      48        2324 : static av_always_inline void FUNC(lpc_encode_unrolled)(int32_t *res,
      49             :                                   const int32_t *smp, int len, int order,
      50             :                                   const int32_t *coefs, int shift, int big)
      51             : {
      52             :     int i;
      53    12222563 :     for (i = order; i < len; i += 2) {
      54    12220239 :         int s  = smp[i-order];
      55    12220239 :         sum_type p0 = 0, p1 = 0;
      56    12220239 :         if (big) {
      57     5723294 :             switch (order) {
      58           0 :             case 32: LPC1(32)
      59           0 :             case 31: LPC1(31)
      60           0 :             case 30: LPC1(30)
      61           0 :             case 29: LPC1(29)
      62           0 :             case 28: LPC1(28)
      63           0 :             case 27: LPC1(27)
      64           0 :             case 26: LPC1(26)
      65           0 :             case 25: LPC1(25)
      66           0 :             case 24: LPC1(24)
      67           0 :             case 23: LPC1(23)
      68           0 :             case 22: LPC1(22)
      69           0 :             case 21: LPC1(21)
      70           0 :             case 20: LPC1(20)
      71           0 :             case 19: LPC1(19)
      72           0 :             case 18: LPC1(18)
      73           0 :             case 17: LPC1(17)
      74           0 :             case 16: LPC1(16)
      75           0 :             case 15: LPC1(15)
      76           0 :             case 14: LPC1(14)
      77           0 :             case 13: LPC1(13)
      78     3395124 :             case 12: LPC1(12)
      79     3395124 :             case 11: LPC1(11)
      80     5723294 :             case 10: LPC1(10)
      81     5723294 :             case  9: LPC1( 9)
      82     5723294 :                      LPC1( 8)
      83     5723294 :                      LPC1( 7)
      84     5723294 :                      LPC1( 6)
      85     5723294 :                      LPC1( 5)
      86     5723294 :                      LPC1( 4)
      87     5723294 :                      LPC1( 3)
      88     5723294 :                      LPC1( 2)
      89     5723294 :                      LPC1( 1)
      90             :             }
      91             :         } else {
      92     6496945 :             switch (order) {
      93      991632 :             case  8: LPC1( 8)
      94     3777151 :             case  7: LPC1( 7)
      95     4032562 :             case  6: LPC1( 6)
      96     4301896 :             case  5: LPC1( 5)
      97     6421698 :             case  4: LPC1( 4)
      98     6487729 :             case  3: LPC1( 3)
      99     6487729 :             case  2: LPC1( 2)
     100     6496945 :             case  1: LPC1( 1)
     101             :             }
     102             :         }
     103    12220239 :         res[i  ] = smp[i  ] - CLIP(p0 >> shift);
     104    12220239 :         res[i+1] = smp[i+1] - CLIP(p1 >> shift);
     105             :     }
     106        2324 : }
     107             : 
     108        2324 : static void FUNC(flac_lpc_encode_c)(int32_t *res, const int32_t *smp, int len,
     109             :                                     int order, const int32_t *coefs, int shift)
     110             : {
     111             :     int i;
     112       20518 :     for (i = 0; i < order; i++)
     113       18194 :         res[i] = smp[i];
     114             : #if CONFIG_SMALL
     115             :     for (i = order; i < len; i += 2) {
     116             :         int j;
     117             :         int s  = smp[i];
     118             :         sum_type p0 = 0, p1 = 0;
     119             :         for (j = 0; j < order; j++) {
     120             :             int c = coefs[j];
     121             :             p1   += MUL(c, s);
     122             :             s     = smp[i-j-1];
     123             :             p0   += MUL(c, s);
     124             :         }
     125             :         res[i  ] = smp[i  ] - CLIP(p0 >> shift);
     126             :         res[i+1] = smp[i+1] - CLIP(p1 >> shift);
     127             :     }
     128             : #else
     129        2324 :     switch (order) {
     130           4 :     case  1: FUNC(lpc_encode_unrolled)(res, smp, len,     1, coefs, shift, 0); break;
     131           0 :     case  2: FUNC(lpc_encode_unrolled)(res, smp, len,     2, coefs, shift, 0); break;
     132          29 :     case  3: FUNC(lpc_encode_unrolled)(res, smp, len,     3, coefs, shift, 0); break;
     133         323 :     case  4: FUNC(lpc_encode_unrolled)(res, smp, len,     4, coefs, shift, 0); break;
     134         117 :     case  5: FUNC(lpc_encode_unrolled)(res, smp, len,     5, coefs, shift, 0); break;
     135         111 :     case  6: FUNC(lpc_encode_unrolled)(res, smp, len,     6, coefs, shift, 0); break;
     136         604 :     case  7: FUNC(lpc_encode_unrolled)(res, smp, len,     7, coefs, shift, 0); break;
     137         432 :     case  8: FUNC(lpc_encode_unrolled)(res, smp, len,     8, coefs, shift, 0); break;
     138         704 :     default: FUNC(lpc_encode_unrolled)(res, smp, len, order, coefs, shift, 1); break;
     139             :     }
     140             : #endif
     141        2324 : }
     142             : 
     143             : /* Comment for clarity/de-obfuscation.
     144             :  *
     145             :  * for (int i = order; i < len; i++) {
     146             :  *     int32_t p = 0;
     147             :  *     for (int j = 0; j < order; j++) {
     148             :  *         int c = coefs[j];
     149             :  *         int s = smp[(i-1)-j];
     150             :  *         p    += c*s;
     151             :  *     }
     152             :  *     res[i] = smp[i] - (p >> shift);
     153             :  * }
     154             :  *
     155             :  * The CONFIG_SMALL code above simplifies to this, in the case of SAMPLE_SIZE
     156             :  * not being equal to 32 (at the present time that means for 16-bit audio). The
     157             :  * code above does 2 samples per iteration.  Commit bfdd5bc (made all the way
     158             :  * back in 2007) says that way is faster.
     159             :  */

Generated by: LCOV version 1.13