FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/flacdsp_lpc_template.c	Lines:	43	64	67.2 %
Date:	2020-07-13 04:22:34	Branches:	23	49	46.9 %


/*
 * 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.2)

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		4648	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	✓✓	24445126	for (i = order; i < len; i += 2) {
54		24440478	int s = smp[i-order];
55		24440478	sum_type p0 = 0, p1 = 0;
56	✓✓	24440478	if (big) {
57	✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗	11446588	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		6790248	case 12: LPC1(12)
79		6790248	case 11: LPC1(11)
80		11446588	case 10: LPC1(10)
81		11446588	case 9: LPC1( 9)
82		11446588	LPC1( 8)
83		11446588	LPC1( 7)
84		11446588	LPC1( 6)
85		11446588	LPC1( 5)
86		11446588	LPC1( 4)
87		11446588	LPC1( 3)
88		11446588	LPC1( 2)
89		11446588	LPC1( 1)
90			}
91			} else {
92	✓✓✓✓ ✓✓✗✓ ✗	12993890	switch (order) {
93		1983264	case 8: LPC1( 8)
94		7554302	case 7: LPC1( 7)
95		8065124	case 6: LPC1( 6)
96		8603792	case 5: LPC1( 5)
97		12843396	case 4: LPC1( 4)
98		12975458	case 3: LPC1( 3)
99		12975458	case 2: LPC1( 2)
100		12993890	case 1: LPC1( 1)
101			}
102			}
103		24440478	res[i ] = smp[i ] - CLIP(p0 >> shift);
104		24440478	res[i+1] = smp[i+1] - CLIP(p1 >> shift);
105			}
106		4648	}
107
108		4648	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	✓✓	41036	for (i = 0; i < order; i++)
113		36388	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	✓✗✓✓ ✓✓✓✓ ✓	4648	switch (order) {
130		8	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		58	case 3: FUNC(lpc_encode_unrolled)(res, smp, len, 3, coefs, shift, 0); break;
133		646	case 4: FUNC(lpc_encode_unrolled)(res, smp, len, 4, coefs, shift, 0); break;
134		234	case 5: FUNC(lpc_encode_unrolled)(res, smp, len, 5, coefs, shift, 0); break;
135		222	case 6: FUNC(lpc_encode_unrolled)(res, smp, len, 6, coefs, shift, 0); break;
136		1208	case 7: FUNC(lpc_encode_unrolled)(res, smp, len, 7, coefs, shift, 0); break;
137		864	case 8: FUNC(lpc_encode_unrolled)(res, smp, len, 8, coefs, shift, 0); break;
138		1408	default: FUNC(lpc_encode_unrolled)(res, smp, len, order, coefs, shift, 1); break;
139			}
140			#endif
141		4648	}
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			*/