GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/cabac_functions.h Lines: 32 34 94.1 %
Date: 2019-11-18 18:00:01 Branches: 12 14 85.7 %

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
22205
static void refill(CABACContext *c){
59
#if CABAC_BITS == 16
60
22205
        c->low+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
61
#else
62
        c->low+= c->bytestream[0]<<1;
63
#endif
64
22205
    c->low -= CABAC_MASK;
65
#if !UNCHECKED_BITSTREAM_READER
66
20135
    if (c->bytestream < c->bytestream_end)
67
#endif
68
22160
        c->bytestream += CABAC_BITS / 8;
69
22205
}
70
#endif
71
72
#ifndef get_cabac_terminate
73
9813341
static inline void renorm_cabac_decoder_once(CABACContext *c){
74
9813341
    int shift= (uint32_t)(c->range - 0x100)>>31;
75
9813341
    c->range<<= shift;
76
9813341
    c->low  <<= shift;
77
9813341
    if(!(c->low & CABAC_MASK))
78
22205
        refill(c);
79
9813341
}
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
80270529
static int av_noinline av_unused get_cabac_noinline(CABACContext *c, uint8_t * const state){
135
80270529
    return get_cabac_inline(c,state);
136
}
137
138
977990186
static int av_unused get_cabac(CABACContext *c, uint8_t * const state){
139
977990186
    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
9879955
static int av_unused get_cabac_terminate(CABACContext *c){
182
9879955
    c->range -= 2;
183
9879955
    if(c->low < c->range<<(CABAC_BITS+1)){
184
9813341
        renorm_cabac_decoder_once(c);
185
9813341
        return 0;
186
    }else{
187
66614
        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 */