FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/sbc.c	Lines:	0	137	0.0 %
Date:	2021-01-20 23:14:43	Branches:	0	130	0.0 %


/*
 * Bluetooth low-complexity, subband codec (SBC)
 *
 * Copyright (C) 2017  Aurelien Jacobs <aurel@gnuage.org>
 * Copyright (C) 2012-2013  Intel Corporation
 * Copyright (C) 2008-2010  Nokia Corporation
 * Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
 * Copyright (C) 2004-2005  Henryk Ploetz <henryk@ploetzli.ch>
 * Copyright (C) 2005-2008  Brad Midgley <bmidgley@xmission.com>
 *
 * 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
 */

/**
 * @file
 * SBC common functions for the encoder and decoder
 */

#include "avcodec.h"
#include "sbc.h"

/* A2DP specification: Appendix B, page 69 */
static const int sbc_offset4[4][4] = {
    { -1, 0, 0, 0 },
    { -2, 0, 0, 1 },
    { -2, 0, 0, 1 },
    { -2, 0, 0, 1 }
};

/* A2DP specification: Appendix B, page 69 */
static const int sbc_offset8[4][8] = {
    { -2, 0, 0, 0, 0, 0, 0, 1 },
    { -3, 0, 0, 0, 0, 0, 1, 2 },
    { -4, 0, 0, 0, 0, 0, 1, 2 },
    { -4, 0, 0, 0, 0, 0, 1, 2 }
};

/*
 * Calculates the CRC-8 of the first len bits in data
 */
uint8_t ff_sbc_crc8(const AVCRC *ctx, const uint8_t *data, size_t len)
{
    size_t byte_length = len >> 3;
    int bit_length = len & 7;
    uint8_t crc;

    crc = av_crc(ctx, 0x0F, data, byte_length);

    if (bit_length) {
        uint8_t bits = data[byte_length];
        while (bit_length--) {
            int8_t mask = bits ^ crc;
            crc = (crc << 1) ^ ((mask >> 7) & 0x1D);
            bits <<= 1;
        }
    }

    return crc;
}

/*
 * Code straight from the spec to calculate the bits array
 * Takes a pointer to the frame in question and a pointer to the bits array
 */
void ff_sbc_calculate_bits(const struct sbc_frame *frame, int (*bits)[8])
{
    int subbands = frame->subbands;
    uint8_t sf = frame->frequency;

    if (frame->mode == MONO || frame->mode == DUAL_CHANNEL) {
        int bitneed[2][8], loudness, max_bitneed, bitcount, slicecount, bitslice;
        int ch, sb;

        for (ch = 0; ch < frame->channels; ch++) {
            max_bitneed = 0;
            if (frame->allocation == SNR) {
                for (sb = 0; sb < subbands; sb++) {
                    bitneed[ch][sb] = frame->scale_factor[ch][sb];
                    if (bitneed[ch][sb] > max_bitneed)
                        max_bitneed = bitneed[ch][sb];
                }
            } else {
                for (sb = 0; sb < subbands; sb++) {
                    if (frame->scale_factor[ch][sb] == 0)
                        bitneed[ch][sb] = -5;
                    else {
                        if (subbands == 4)
                            loudness = frame->scale_factor[ch][sb] - sbc_offset4[sf][sb];
                        else
                            loudness = frame->scale_factor[ch][sb] - sbc_offset8[sf][sb];
                        if (loudness > 0)
                            bitneed[ch][sb] = loudness / 2;
                        else
                            bitneed[ch][sb] = loudness;
                    }
                    if (bitneed[ch][sb] > max_bitneed)
                        max_bitneed = bitneed[ch][sb];
                }
            }

            bitcount = 0;
            slicecount = 0;
            bitslice = max_bitneed + 1;
            do {
                bitslice--;
                bitcount += slicecount;
                slicecount = 0;
                for (sb = 0; sb < subbands; sb++) {
                    if ((bitneed[ch][sb] > bitslice + 1) && (bitneed[ch][sb] < bitslice + 16))
                        slicecount++;
                    else if (bitneed[ch][sb] == bitslice + 1)
                        slicecount += 2;
                }
            } while (bitcount + slicecount < frame->bitpool);

            if (bitcount + slicecount == frame->bitpool) {
                bitcount += slicecount;
                bitslice--;
            }

            for (sb = 0; sb < subbands; sb++) {
                if (bitneed[ch][sb] < bitslice + 2)
                    bits[ch][sb] = 0;
                else {
                    bits[ch][sb] = bitneed[ch][sb] - bitslice;
                    if (bits[ch][sb] > 16)
                        bits[ch][sb] = 16;
                }
            }

            for (sb = 0; bitcount < frame->bitpool &&
                            sb < subbands; sb++) {
                if ((bits[ch][sb] >= 2) && (bits[ch][sb] < 16)) {
                    bits[ch][sb]++;
                    bitcount++;
                } else if ((bitneed[ch][sb] == bitslice + 1) && (frame->bitpool > bitcount + 1)) {
                    bits[ch][sb] = 2;
                    bitcount += 2;
                }
            }

            for (sb = 0; bitcount < frame->bitpool &&
                            sb < subbands; sb++) {
                if (bits[ch][sb] < 16) {
                    bits[ch][sb]++;
                    bitcount++;
                }
            }

        }

    } else if (frame->mode == STEREO || frame->mode == JOINT_STEREO) {
        int bitneed[2][8], loudness, max_bitneed, bitcount, slicecount, bitslice;
        int ch, sb;

        max_bitneed = 0;
        if (frame->allocation == SNR) {
            for (ch = 0; ch < 2; ch++) {
                for (sb = 0; sb < subbands; sb++) {
                    bitneed[ch][sb] = frame->scale_factor[ch][sb];
                    if (bitneed[ch][sb] > max_bitneed)
                        max_bitneed = bitneed[ch][sb];
                }
            }
        } else {
            for (ch = 0; ch < 2; ch++) {
                for (sb = 0; sb < subbands; sb++) {
                    if (frame->scale_factor[ch][sb] == 0)
                        bitneed[ch][sb] = -5;
                    else {
                        if (subbands == 4)
                            loudness = frame->scale_factor[ch][sb] - sbc_offset4[sf][sb];
                        else
                            loudness = frame->scale_factor[ch][sb] - sbc_offset8[sf][sb];
                        if (loudness > 0)
                            bitneed[ch][sb] = loudness / 2;
                        else
                            bitneed[ch][sb] = loudness;
                    }
                    if (bitneed[ch][sb] > max_bitneed)
                        max_bitneed = bitneed[ch][sb];
                }
            }
        }

        bitcount = 0;
        slicecount = 0;
        bitslice = max_bitneed + 1;
        do {
            bitslice--;
            bitcount += slicecount;
            slicecount = 0;
            for (ch = 0; ch < 2; ch++) {
                for (sb = 0; sb < subbands; sb++) {
                    if ((bitneed[ch][sb] > bitslice + 1) && (bitneed[ch][sb] < bitslice + 16))
                        slicecount++;
                    else if (bitneed[ch][sb] == bitslice + 1)
                        slicecount += 2;
                }
            }
        } while (bitcount + slicecount < frame->bitpool);

        if (bitcount + slicecount == frame->bitpool) {
            bitcount += slicecount;
            bitslice--;
        }

        for (ch = 0; ch < 2; ch++) {
            for (sb = 0; sb < subbands; sb++) {
                if (bitneed[ch][sb] < bitslice + 2) {
                    bits[ch][sb] = 0;
                } else {
                    bits[ch][sb] = bitneed[ch][sb] - bitslice;
                    if (bits[ch][sb] > 16)
                        bits[ch][sb] = 16;
                }
            }
        }

        ch = 0;
        sb = 0;
        while (bitcount < frame->bitpool) {
            if ((bits[ch][sb] >= 2) && (bits[ch][sb] < 16)) {
                bits[ch][sb]++;
                bitcount++;
            } else if ((bitneed[ch][sb] == bitslice + 1) && (frame->bitpool > bitcount + 1)) {
                bits[ch][sb] = 2;
                bitcount += 2;
            }
            if (ch == 1) {
                ch = 0;
                sb++;
                if (sb >= subbands)
                    break;
            } else
                ch = 1;
        }

        ch = 0;
        sb = 0;
        while (bitcount < frame->bitpool) {
            if (bits[ch][sb] < 16) {
                bits[ch][sb]++;
                bitcount++;
            }
            if (ch == 1) {
                ch = 0;
                sb++;
                if (sb >= subbands)
                    break;
            } else
                ch = 1;
        }

    }

}


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* Bluetooth low-complexity, subband codec (SBC)
3			*
4			* Copyright (C) 2017 Aurelien Jacobs <aurel@gnuage.org>
5			* Copyright (C) 2012-2013 Intel Corporation
6			* Copyright (C) 2008-2010 Nokia Corporation
7			* Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
8			* Copyright (C) 2004-2005 Henryk Ploetz <henryk@ploetzli.ch>
9			* Copyright (C) 2005-2008 Brad Midgley <bmidgley@xmission.com>
10			*
11			* This file is part of FFmpeg.
12			*
13			* FFmpeg is free software; you can redistribute it and/or
14			* modify it under the terms of the GNU Lesser General Public
15			* License as published by the Free Software Foundation; either
16			* version 2.1 of the License, or (at your option) any later version.
17			*
18			* FFmpeg is distributed in the hope that it will be useful,
19			* but WITHOUT ANY WARRANTY; without even the implied warranty of
20			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21			* Lesser General Public License for more details.
22			*
23			* You should have received a copy of the GNU Lesser General Public
24			* License along with FFmpeg; if not, write to the Free Software
25			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26			*/
27
28			/**
29			* @file
30			* SBC common functions for the encoder and decoder
31			*/
32
33			#include "avcodec.h"
34			#include "sbc.h"
35
36			/* A2DP specification: Appendix B, page 69 */
37			static const int sbc_offset4[4][4] = {
38			{ -1, 0, 0, 0 },
39			{ -2, 0, 0, 1 },
40			{ -2, 0, 0, 1 },
41			{ -2, 0, 0, 1 }
42			};
43
44			/* A2DP specification: Appendix B, page 69 */
45			static const int sbc_offset8[4][8] = {
46			{ -2, 0, 0, 0, 0, 0, 0, 1 },
47			{ -3, 0, 0, 0, 0, 0, 1, 2 },
48			{ -4, 0, 0, 0, 0, 0, 1, 2 },
49			{ -4, 0, 0, 0, 0, 0, 1, 2 }
50			};
51
52			/*
53			* Calculates the CRC-8 of the first len bits in data
54			*/
55			uint8_t ff_sbc_crc8(const AVCRC ctx, const uint8_t data, size_t len)
56			{
57			size_t byte_length = len >> 3;
58			int bit_length = len & 7;
59			uint8_t crc;
60
61			crc = av_crc(ctx, 0x0F, data, byte_length);
62
63			if (bit_length) {
64			uint8_t bits = data[byte_length];
65			while (bit_length--) {
66			int8_t mask = bits ^ crc;
67			crc = (crc << 1) ^ ((mask >> 7) & 0x1D);
68			bits <<= 1;
69			}
70			}
71
72			return crc;
73			}
74
75			/*
76			* Code straight from the spec to calculate the bits array
77			* Takes a pointer to the frame in question and a pointer to the bits array
78			*/
79			void ff_sbc_calculate_bits(const struct sbc_frame frame, int (bits)[8])
80			{
81			int subbands = frame->subbands;
82			uint8_t sf = frame->frequency;
83
84			if (frame->mode == MONO \|\| frame->mode == DUAL_CHANNEL) {
85			int bitneed[2][8], loudness, max_bitneed, bitcount, slicecount, bitslice;
86			int ch, sb;
87
88			for (ch = 0; ch < frame->channels; ch++) {
89			max_bitneed = 0;
90			if (frame->allocation == SNR) {
91			for (sb = 0; sb < subbands; sb++) {
92			bitneed[ch][sb] = frame->scale_factor[ch][sb];
93			if (bitneed[ch][sb] > max_bitneed)
94			max_bitneed = bitneed[ch][sb];
95			}
96			} else {
97			for (sb = 0; sb < subbands; sb++) {
98			if (frame->scale_factor[ch][sb] == 0)
99			bitneed[ch][sb] = -5;
100			else {
101			if (subbands == 4)
102			loudness = frame->scale_factor[ch][sb] - sbc_offset4[sf][sb];
103			else
104			loudness = frame->scale_factor[ch][sb] - sbc_offset8[sf][sb];
105			if (loudness > 0)
106			bitneed[ch][sb] = loudness / 2;
107			else
108			bitneed[ch][sb] = loudness;
109			}
110			if (bitneed[ch][sb] > max_bitneed)
111			max_bitneed = bitneed[ch][sb];
112			}
113			}
114
115			bitcount = 0;
116			slicecount = 0;
117			bitslice = max_bitneed + 1;
118			do {
119			bitslice--;
120			bitcount += slicecount;
121			slicecount = 0;
122			for (sb = 0; sb < subbands; sb++) {
123			if ((bitneed[ch][sb] > bitslice + 1) && (bitneed[ch][sb] < bitslice + 16))
124			slicecount++;
125			else if (bitneed[ch][sb] == bitslice + 1)
126			slicecount += 2;
127			}
128			} while (bitcount + slicecount < frame->bitpool);
129
130			if (bitcount + slicecount == frame->bitpool) {
131			bitcount += slicecount;
132			bitslice--;
133			}
134
135			for (sb = 0; sb < subbands; sb++) {
136			if (bitneed[ch][sb] < bitslice + 2)
137			bits[ch][sb] = 0;
138			else {
139			bits[ch][sb] = bitneed[ch][sb] - bitslice;
140			if (bits[ch][sb] > 16)
141			bits[ch][sb] = 16;
142			}
143			}
144
145			for (sb = 0; bitcount < frame->bitpool &&
146			sb < subbands; sb++) {
147			if ((bits[ch][sb] >= 2) && (bits[ch][sb] < 16)) {
148			bits[ch][sb]++;
149			bitcount++;
150			} else if ((bitneed[ch][sb] == bitslice + 1) && (frame->bitpool > bitcount + 1)) {
151			bits[ch][sb] = 2;
152			bitcount += 2;
153			}
154			}
155
156			for (sb = 0; bitcount < frame->bitpool &&
157			sb < subbands; sb++) {
158			if (bits[ch][sb] < 16) {
159			bits[ch][sb]++;
160			bitcount++;
161			}
162			}
163
164			}
165
166			} else if (frame->mode == STEREO \|\| frame->mode == JOINT_STEREO) {
167			int bitneed[2][8], loudness, max_bitneed, bitcount, slicecount, bitslice;
168			int ch, sb;
169
170			max_bitneed = 0;
171			if (frame->allocation == SNR) {
172			for (ch = 0; ch < 2; ch++) {
173			for (sb = 0; sb < subbands; sb++) {
174			bitneed[ch][sb] = frame->scale_factor[ch][sb];
175			if (bitneed[ch][sb] > max_bitneed)
176			max_bitneed = bitneed[ch][sb];
177			}
178			}
179			} else {
180			for (ch = 0; ch < 2; ch++) {
181			for (sb = 0; sb < subbands; sb++) {
182			if (frame->scale_factor[ch][sb] == 0)
183			bitneed[ch][sb] = -5;
184			else {
185			if (subbands == 4)
186			loudness = frame->scale_factor[ch][sb] - sbc_offset4[sf][sb];
187			else
188			loudness = frame->scale_factor[ch][sb] - sbc_offset8[sf][sb];
189			if (loudness > 0)
190			bitneed[ch][sb] = loudness / 2;
191			else
192			bitneed[ch][sb] = loudness;
193			}
194			if (bitneed[ch][sb] > max_bitneed)
195			max_bitneed = bitneed[ch][sb];
196			}
197			}
198			}
199
200			bitcount = 0;
201			slicecount = 0;
202			bitslice = max_bitneed + 1;
203			do {
204			bitslice--;
205			bitcount += slicecount;
206			slicecount = 0;
207			for (ch = 0; ch < 2; ch++) {
208			for (sb = 0; sb < subbands; sb++) {
209			if ((bitneed[ch][sb] > bitslice + 1) && (bitneed[ch][sb] < bitslice + 16))
210			slicecount++;
211			else if (bitneed[ch][sb] == bitslice + 1)
212			slicecount += 2;
213			}
214			}
215			} while (bitcount + slicecount < frame->bitpool);
216
217			if (bitcount + slicecount == frame->bitpool) {
218			bitcount += slicecount;
219			bitslice--;
220			}
221
222			for (ch = 0; ch < 2; ch++) {
223			for (sb = 0; sb < subbands; sb++) {
224			if (bitneed[ch][sb] < bitslice + 2) {
225			bits[ch][sb] = 0;
226			} else {
227			bits[ch][sb] = bitneed[ch][sb] - bitslice;
228			if (bits[ch][sb] > 16)
229			bits[ch][sb] = 16;
230			}
231			}
232			}
233
234			ch = 0;
235			sb = 0;
236			while (bitcount < frame->bitpool) {
237			if ((bits[ch][sb] >= 2) && (bits[ch][sb] < 16)) {
238			bits[ch][sb]++;
239			bitcount++;
240			} else if ((bitneed[ch][sb] == bitslice + 1) && (frame->bitpool > bitcount + 1)) {
241			bits[ch][sb] = 2;
242			bitcount += 2;
243			}
244			if (ch == 1) {
245			ch = 0;
246			sb++;
247			if (sb >= subbands)
248			break;
249			} else
250			ch = 1;
251			}
252
253			ch = 0;
254			sb = 0;
255			while (bitcount < frame->bitpool) {
256			if (bits[ch][sb] < 16) {
257			bits[ch][sb]++;
258			bitcount++;
259			}
260			if (ch == 1) {
261			ch = 0;
262			sb++;
263			if (sb >= subbands)
264			break;
265			} else
266			ch = 1;
267			}
268
269			}
270
271			}