FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/cabac_functions.h	Lines:	32	34	94.1 %
Date:	2020-09-28 00:47:38	Branches:	12	14	85.7 %


/*
 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
 *
 * 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
 * Context Adaptive Binary Arithmetic Coder inline functions
 */

#ifndef AVCODEC_CABAC_FUNCTIONS_H
#define AVCODEC_CABAC_FUNCTIONS_H

#include <stdint.h>

#include "cabac.h"
#include "config.h"

#ifndef UNCHECKED_BITSTREAM_READER
#define UNCHECKED_BITSTREAM_READER !CONFIG_SAFE_BITSTREAM_READER
#endif

#if ARCH_AARCH64
#   include "aarch64/cabac.h"
#endif
#if ARCH_ARM
#   include "arm/cabac.h"
#endif
#if ARCH_X86
#   include "x86/cabac.h"
#endif
#if ARCH_MIPS
#   include "mips/cabac.h"
#endif

static const uint8_t * const ff_h264_norm_shift = ff_h264_cabac_tables + H264_NORM_SHIFT_OFFSET;
static const uint8_t * const ff_h264_lps_range = ff_h264_cabac_tables + H264_LPS_RANGE_OFFSET;
static const uint8_t * const ff_h264_mlps_state = ff_h264_cabac_tables + H264_MLPS_STATE_OFFSET;
static const uint8_t * const ff_h264_last_coeff_flag_offset_8x8 = ff_h264_cabac_tables + H264_LAST_COEFF_FLAG_OFFSET_8x8_OFFSET;

#if !defined(get_cabac_bypass) || !defined(get_cabac_terminate)
static void refill(CABACContext *c){
#if CABAC_BITS == 16
        c->low+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
#else
        c->low+= c->bytestream[0]<<1;
#endif
    c->low -= CABAC_MASK;
#if !UNCHECKED_BITSTREAM_READER
    if (c->bytestream < c->bytestream_end)
#endif
        c->bytestream += CABAC_BITS / 8;
}
#endif

#ifndef get_cabac_terminate
static inline void renorm_cabac_decoder_once(CABACContext *c){
    int shift= (uint32_t)(c->range - 0x100)>>31;
    c->range<<= shift;
    c->low  <<= shift;
    if(!(c->low & CABAC_MASK))
        refill(c);
}
#endif

#ifndef get_cabac_inline
static void refill2(CABACContext *c){
    int i;
    unsigned x;
#if !HAVE_FAST_CLZ
    x= c->low ^ (c->low-1);
    i= 7 - ff_h264_norm_shift[x>>(CABAC_BITS-1)];
#else
    i = ff_ctz(c->low) - CABAC_BITS;
#endif

    x= -CABAC_MASK;

#if CABAC_BITS == 16
        x+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
#else
        x+= c->bytestream[0]<<1;
#endif

    c->low += x<<i;
#if !UNCHECKED_BITSTREAM_READER
    if (c->bytestream < c->bytestream_end)
#endif
        c->bytestream += CABAC_BITS/8;
}
#endif

#ifndef get_cabac_inline
static av_always_inline int get_cabac_inline(CABACContext *c, uint8_t * const state){
    int s = *state;
    int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + s];
    int bit, lps_mask;

    c->range -= RangeLPS;
    lps_mask= ((c->range<<(CABAC_BITS+1)) - c->low)>>31;

    c->low -= (c->range<<(CABAC_BITS+1)) & lps_mask;
    c->range += (RangeLPS - c->range) & lps_mask;

    s^=lps_mask;
    *state= (ff_h264_mlps_state+128)[s];
    bit= s&1;

    lps_mask= ff_h264_norm_shift[c->range];
    c->range<<= lps_mask;
    c->low  <<= lps_mask;
    if(!(c->low & CABAC_MASK))
        refill2(c);
    return bit;
}
#endif

static int av_noinline av_unused get_cabac_noinline(CABACContext *c, uint8_t * const state){
    return get_cabac_inline(c,state);
}

static int av_unused get_cabac(CABACContext *c, uint8_t * const state){
    return get_cabac_inline(c,state);
}

#ifndef get_cabac_bypass
static int av_unused get_cabac_bypass(CABACContext *c){
    int range;
    c->low += c->low;

    if(!(c->low & CABAC_MASK))
        refill(c);

    range= c->range<<(CABAC_BITS+1);
    if(c->low < range){
        return 0;
    }else{
        c->low -= range;
        return 1;
    }
}
#endif

#ifndef get_cabac_bypass_sign
static av_always_inline int get_cabac_bypass_sign(CABACContext *c, int val){
    int range, mask;
    c->low += c->low;

    if(!(c->low & CABAC_MASK))
        refill(c);

    range= c->range<<(CABAC_BITS+1);
    c->low -= range;
    mask= c->low >> 31;
    range &= mask;
    c->low += range;
    return (val^mask)-mask;
}
#endif

/**
 * @return the number of bytes read or 0 if no end
 */
#ifndef get_cabac_terminate
static int av_unused get_cabac_terminate(CABACContext *c){
    c->range -= 2;
    if(c->low < c->range<<(CABAC_BITS+1)){
        renorm_cabac_decoder_once(c);
        return 0;
    }else{
        return c->bytestream - c->bytestream_start;
    }
}
#endif

/**
 * Skip @p n bytes and reset the decoder.
 * @return the address of the first skipped byte or NULL if there's less than @p n bytes left
 */
#ifndef skip_bytes
static av_unused const uint8_t* skip_bytes(CABACContext *c, int n) {
    const uint8_t *ptr = c->bytestream;

    if (c->low & 0x1)
        ptr--;
#if CABAC_BITS == 16
    if (c->low & 0x1FF)
        ptr--;
#endif
    if ((int) (c->bytestream_end - ptr) < n)
        return NULL;
    if (ff_init_cabac_decoder(c, ptr + n, c->bytestream_end - ptr - n) < 0)
        return NULL;

    return ptr;
}
#endif

#endif /* AVCODEC_CABAC_FUNCTIONS_H */


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
3			* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
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			/**
23			* @file
24			* Context Adaptive Binary Arithmetic Coder inline functions
25			*/
26
27			#ifndef AVCODEC_CABAC_FUNCTIONS_H
28			#define AVCODEC_CABAC_FUNCTIONS_H
29
30			#include <stdint.h>
31
32			#include "cabac.h"
33			#include "config.h"
34
35			#ifndef UNCHECKED_BITSTREAM_READER
36			#define UNCHECKED_BITSTREAM_READER !CONFIG_SAFE_BITSTREAM_READER
37			#endif
38
39			#if ARCH_AARCH64
40			# include "aarch64/cabac.h"
41			#endif
42			#if ARCH_ARM
43			# include "arm/cabac.h"
44			#endif
45			#if ARCH_X86
46			# include "x86/cabac.h"
47			#endif
48			#if ARCH_MIPS
49			# include "mips/cabac.h"
50			#endif
51
52			static const uint8_t * const ff_h264_norm_shift = ff_h264_cabac_tables + H264_NORM_SHIFT_OFFSET;
53			static const uint8_t * const ff_h264_lps_range = ff_h264_cabac_tables + H264_LPS_RANGE_OFFSET;
54			static const uint8_t * const ff_h264_mlps_state = ff_h264_cabac_tables + H264_MLPS_STATE_OFFSET;
55			static const uint8_t * const ff_h264_last_coeff_flag_offset_8x8 = ff_h264_cabac_tables + H264_LAST_COEFF_FLAG_OFFSET_8x8_OFFSET;
56
57			#if !defined(get_cabac_bypass) \|\| !defined(get_cabac_terminate)
58		22203	static void refill(CABACContext *c){
59			#if CABAC_BITS == 16
60		22203	c->low+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
61			#else
62			c->low+= c->bytestream[0]<<1;
63			#endif
64		22203	c->low -= CABAC_MASK;
65			#if !UNCHECKED_BITSTREAM_READER
66	✓✓	20133	if (c->bytestream < c->bytestream_end)
67			#endif
68		22158	c->bytestream += CABAC_BITS / 8;
69		22203	}
70			#endif
71
72			#ifndef get_cabac_terminate
73		9814387	static inline void renorm_cabac_decoder_once(CABACContext *c){
74		9814387	int shift= (uint32_t)(c->range - 0x100)>>31;
75		9814387	c->range<<= shift;
76		9814387	c->low <<= shift;
77	✓✓	9814387	if(!(c->low & CABAC_MASK))
78		22203	refill(c);
79		9814387	}
80			#endif
81
82			#ifndef get_cabac_inline
83			static void refill2(CABACContext *c){
84			int i;
85			unsigned x;
86			#if !HAVE_FAST_CLZ
87			x= c->low ^ (c->low-1);
88			i= 7 - ff_h264_norm_shift[x>>(CABAC_BITS-1)];
89			#else
90			i = ff_ctz(c->low) - CABAC_BITS;
91			#endif
92
93			x= -CABAC_MASK;
94
95			#if CABAC_BITS == 16
96			x+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
97			#else
98			x+= c->bytestream[0]<<1;
99			#endif
100
101			c->low += x<<i;
102			#if !UNCHECKED_BITSTREAM_READER
103			if (c->bytestream < c->bytestream_end)
104			#endif
105			c->bytestream += CABAC_BITS/8;
106			}
107			#endif
108
109			#ifndef get_cabac_inline
110			static av_always_inline int get_cabac_inline(CABACContext c, uint8_t const state){
111			int s = *state;
112			int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + s];
113			int bit, lps_mask;
114
115			c->range -= RangeLPS;
116			lps_mask= ((c->range<<(CABAC_BITS+1)) - c->low)>>31;
117
118			c->low -= (c->range<<(CABAC_BITS+1)) & lps_mask;
119			c->range += (RangeLPS - c->range) & lps_mask;
120
121			s^=lps_mask;
122			*state= (ff_h264_mlps_state+128)[s];
123			bit= s&1;
124
125			lps_mask= ff_h264_norm_shift[c->range];
126			c->range<<= lps_mask;
127			c->low <<= lps_mask;
128			if(!(c->low & CABAC_MASK))
129			refill2(c);
130			return bit;
131			}
132			#endif
133
134		80278402	static int av_noinline av_unused get_cabac_noinline(CABACContext c, uint8_t const state){
135		80278402	return get_cabac_inline(c,state);
136			}
137
138		978095188	static int av_unused get_cabac(CABACContext c, uint8_t const state){
139		978095188	return get_cabac_inline(c,state);
140			}
141
142			#ifndef get_cabac_bypass
143			static int av_unused get_cabac_bypass(CABACContext *c){
144			int range;
145			c->low += c->low;
146
147			if(!(c->low & CABAC_MASK))
148			refill(c);
149
150			range= c->range<<(CABAC_BITS+1);
151			if(c->low < range){
152			return 0;
153			}else{
154			c->low -= range;
155			return 1;
156			}
157			}
158			#endif
159
160			#ifndef get_cabac_bypass_sign
161			static av_always_inline int get_cabac_bypass_sign(CABACContext *c, int val){
162			int range, mask;
163			c->low += c->low;
164
165			if(!(c->low & CABAC_MASK))
166			refill(c);
167
168			range= c->range<<(CABAC_BITS+1);
169			c->low -= range;
170			mask= c->low >> 31;
171			range &= mask;
172			c->low += range;
173			return (val^mask)-mask;
174			}
175			#endif
176
177			/**
178			* @return the number of bytes read or 0 if no end
179			*/
180			#ifndef get_cabac_terminate
181		9881006	static int av_unused get_cabac_terminate(CABACContext *c){
182		9881006	c->range -= 2;
183	✓✓	9881006	if(c->low < c->range<<(CABAC_BITS+1)){
184		9814387	renorm_cabac_decoder_once(c);
185		9814387	return 0;
186			}else{
187		66619	return c->bytestream - c->bytestream_start;
188			}
189			}
190			#endif
191
192			/**
193			* Skip @p n bytes and reset the decoder.
194			* @return the address of the first skipped byte or NULL if there's less than @p n bytes left
195			*/
196			#ifndef skip_bytes
197		20013	static av_unused const uint8_t* skip_bytes(CABACContext *c, int n) {
198		20013	const uint8_t *ptr = c->bytestream;
199
200	✓✓	20013	if (c->low & 0x1)
201		1143	ptr--;
202			#if CABAC_BITS == 16
203	✓✓	20013	if (c->low & 0x1FF)
204		10896	ptr--;
205			#endif
206	✗✓	20013	if ((int) (c->bytestream_end - ptr) < n)
207			return NULL;
208	✗✓	20013	if (ff_init_cabac_decoder(c, ptr + n, c->bytestream_end - ptr - n) < 0)
209			return NULL;
210
211		20013	return ptr;
212			}
213			#endif
214
215			#endif /* AVCODEC_CABAC_FUNCTIONS_H */