Head

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/flacdsp_lpc_template.c	Lines:	43	64	67.2 %
Date:	2020-01-27 20:17:04	Branches:	9	49	18.4 %


/*
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdint.h>
#include "libavutil/avutil.h"
#include "mathops.h"

#undef FUNC
#undef sum_type
#undef MUL
#undef CLIP
#undef FSUF

#define FUNC(n) AV_JOIN(n ## _, SAMPLE_SIZE)

#if SAMPLE_SIZE == 32
#   define sum_type  int64_t
#   define MUL(a, b) MUL64(a, b)
#   define CLIP(x) av_clipl_int32(x)
#else
#   define sum_type  int32_t
#   define MUL(a, b) ((a) * (b))
#   define CLIP(x) (x)
#endif

#define LPC1(x) {           \
    int c = coefs[(x)-1];   \
    p0   += MUL(c, s);      \
    s     = smp[i-(x)+1];   \
    p1   += MUL(c, s);      \
}

static av_always_inline void FUNC(lpc_encode_unrolled)(int32_t *res,
                                  const int32_t *smp, int len, int order,
                                  const int32_t *coefs, int shift, int big)
{
    int i;
    for (i = order; i < len; i += 2) {
        int s  = smp[i-order];
        sum_type p0 = 0, p1 = 0;
        if (big) {
            switch (order) {
            case 32: LPC1(32)
            case 31: LPC1(31)
            case 30: LPC1(30)
            case 29: LPC1(29)
            case 28: LPC1(28)
            case 27: LPC1(27)
            case 26: LPC1(26)
            case 25: LPC1(25)
            case 24: LPC1(24)
            case 23: LPC1(23)
            case 22: LPC1(22)
            case 21: LPC1(21)
            case 20: LPC1(20)
            case 19: LPC1(19)
            case 18: LPC1(18)
            case 17: LPC1(17)
            case 16: LPC1(16)
            case 15: LPC1(15)
            case 14: LPC1(14)
            case 13: LPC1(13)
            case 12: LPC1(12)
            case 11: LPC1(11)
            case 10: LPC1(10)
            case  9: LPC1( 9)
                     LPC1( 8)
                     LPC1( 7)
                     LPC1( 6)
                     LPC1( 5)
                     LPC1( 4)
                     LPC1( 3)
                     LPC1( 2)
                     LPC1( 1)
            }
        } else {
            switch (order) {
            case  8: LPC1( 8)
            case  7: LPC1( 7)
            case  6: LPC1( 6)
            case  5: LPC1( 5)
            case  4: LPC1( 4)
            case  3: LPC1( 3)
            case  2: LPC1( 2)
            case  1: LPC1( 1)
            }
        }
        res[i  ] = smp[i  ] - CLIP(p0 >> shift);
        res[i+1] = smp[i+1] - CLIP(p1 >> shift);
    }
}

static void FUNC(flac_lpc_encode_c)(int32_t *res, const int32_t *smp, int len,
                                    int order, const int32_t *coefs, int shift)
{
    int i;
    for (i = 0; i < order; i++)
        res[i] = smp[i];
#if CONFIG_SMALL
    for (i = order; i < len; i += 2) {
        int j;
        int s  = smp[i];
        sum_type p0 = 0, p1 = 0;
        for (j = 0; j < order; j++) {
            int c = coefs[j];
            p1   += MUL(c, s);
            s     = smp[i-j-1];
            p0   += MUL(c, s);
        }
        res[i  ] = smp[i  ] - CLIP(p0 >> shift);
        res[i+1] = smp[i+1] - CLIP(p1 >> shift);
    }
#else
    switch (order) {
    case  1: FUNC(lpc_encode_unrolled)(res, smp, len,     1, coefs, shift, 0); break;
    case  2: FUNC(lpc_encode_unrolled)(res, smp, len,     2, coefs, shift, 0); break;
    case  3: FUNC(lpc_encode_unrolled)(res, smp, len,     3, coefs, shift, 0); break;
    case  4: FUNC(lpc_encode_unrolled)(res, smp, len,     4, coefs, shift, 0); break;
    case  5: FUNC(lpc_encode_unrolled)(res, smp, len,     5, coefs, shift, 0); break;
    case  6: FUNC(lpc_encode_unrolled)(res, smp, len,     6, coefs, shift, 0); break;
    case  7: FUNC(lpc_encode_unrolled)(res, smp, len,     7, coefs, shift, 0); break;
    case  8: FUNC(lpc_encode_unrolled)(res, smp, len,     8, coefs, shift, 0); break;
    default: FUNC(lpc_encode_unrolled)(res, smp, len, order, coefs, shift, 1); break;
    }
#endif
}

/* Comment for clarity/de-obfuscation.
 *
 * for (int i = order; i < len; i++) {
 *     int32_t p = 0;
 *     for (int j = 0; j < order; j++) {
 *         int c = coefs[j];
 *         int s = smp[(i-1)-j];
 *         p    += c*s;
 *     }
 *     res[i] = smp[i] - (p >> shift);
 * }
 *
 * The CONFIG_SMALL code above simplifies to this, in the case of SAMPLE_SIZE
 * not being equal to 32 (at the present time that means for 16-bit audio). The
 * code above does 2 samples per iteration.  Commit bfdd5bc (made all the way
 * back in 2007) says that way is faster.
 */


Generated by: GCOVR (Version 4.1)

Line	Branch	Exec	Source
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		33	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	✓✓	75280	for (i = order; i < len; i += 2) {
54		75247	int s = smp[i-order];
55		75247	sum_type p0 = 0, p1 = 0;
56	✗✓	75247	if (big) {
57	✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗	5723294	switch (order) {
58			case 32: LPC1(32)
59			case 31: LPC1(31)
60			case 30: LPC1(30)
61			case 29: LPC1(29)
62			case 28: LPC1(28)
63			case 27: LPC1(27)
64			case 26: LPC1(26)
65			case 25: LPC1(25)
66			case 24: LPC1(24)
67			case 23: LPC1(23)
68			case 22: LPC1(22)
69			case 21: LPC1(21)
70			case 20: LPC1(20)
71			case 19: LPC1(19)
72			case 18: LPC1(18)
73			case 17: LPC1(17)
74			case 16: LPC1(16)
75			case 15: LPC1(15)
76			case 14: LPC1(14)
77			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	✗✗✗✗ ✗✓✗✓ ✗	75247	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		66031	case 3: LPC1( 3)
99		66031	case 2: LPC1( 2)
100		75247	case 1: LPC1( 1)
101			}
102			}
103		75247	res[i ] = smp[i ] - CLIP(p0 >> shift);
104		75247	res[i+1] = smp[i+1] - CLIP(p1 >> shift);
105			}
106		33	}
107
108		33	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	✓✓	124	for (i = 0; i < order; i++)
113		91	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	✓✗✓✗ ✗✗✗✗ ✗	33	switch (order) {
130		4	case 1: FUNC(lpc_encode_unrolled)(res, smp, len, 1, coefs, shift, 0); break;
131			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		33	}
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			*/