FFmpeg coverage

GCC Code Coverage Report

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