Statistics
| Branch: | Revision:

ffmpeg / libavcodec / cabac.h @ f259747b

History | View | Annotate | Download (8.69 KB)

1
/*
2
 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
3
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 *
19
 */
20
 
21
/**
22
 * @file cabac.h
23
 * Context Adaptive Binary Arithmetic Coder.
24
 */
25

    
26

    
27
#undef NDEBUG
28
#include <assert.h>
29

    
30
typedef struct CABACContext{
31
    int low;
32
    int range;
33
    int outstanding_count;
34
#ifdef STRICT_LIMITS
35
    int symCount;
36
#endif
37
    uint8_t lps_range[2*64][4];   ///< rangeTabLPS
38
    uint8_t lps_state[2*64];      ///< transIdxLPS
39
    uint8_t mps_state[2*64];      ///< transIdxMPS
40
    uint8_t *bytestream_start;
41
    uint8_t *bytestream;
42
    int bits_left;                ///<
43
    PutBitContext pb;
44
}CABACContext;
45

    
46
extern const uint8_t ff_h264_lps_range[64][4];
47
extern const uint8_t ff_h264_mps_state[64];
48
extern const uint8_t ff_h264_lps_state[64];
49

    
50
void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size);
51
void ff_init_cabac_decoder(CABACContext *c, uint8_t *buf, int buf_size);
52
void ff_init_cabac_states(CABACContext *c, uint8_t const (*lps_range)[4], 
53
                          uint8_t const *mps_state, uint8_t const *lps_state, int state_count);
54

    
55

    
56
static inline void put_cabac_bit(CABACContext *c, int b){
57
    put_bits(&c->pb, 1, b); 
58
    for(;c->outstanding_count; c->outstanding_count--){ 
59
        put_bits(&c->pb, 1, 1-b);
60
    }
61
}
62

    
63
static inline void renorm_cabac_encoder(CABACContext *c){
64
    while(c->range < 0x100){
65
        //FIXME optimize
66
        if(c->low<0x100){
67
            put_cabac_bit(c, 0);
68
        }else if(c->low<0x200){
69
            c->outstanding_count++;
70
            c->low -= 0x100;
71
        }else{
72
            put_cabac_bit(c, 1);
73
            c->low -= 0x200;
74
        }
75
        
76
        c->range+= c->range;
77
        c->low += c->low;
78
    }
79
}
80

    
81
static inline void put_cabac(CABACContext *c, uint8_t * const state, int bit){
82
    int RangeLPS= c->lps_range[*state][((c->range)>>6)&3];
83
    
84
    if(bit == ((*state)&1)){
85
        c->range -= RangeLPS;
86
        *state= c->mps_state[*state];
87
    }else{
88
        c->low += c->range - RangeLPS;
89
        c->range = RangeLPS;
90
        *state= c->lps_state[*state];
91
    }
92
    
93
    renorm_cabac_encoder(c);
94

    
95
#ifdef STRICT_LIMITS
96
    c->symCount++;
97
#endif
98
}
99

    
100
static inline void put_cabac_static(CABACContext *c, int RangeLPS, int bit){
101
    assert(c->range > RangeLPS);
102

    
103
    if(!bit){
104
        c->range -= RangeLPS;
105
    }else{
106
        c->low += c->range - RangeLPS;
107
        c->range = RangeLPS;
108
    }
109

    
110
    renorm_cabac_encoder(c);
111

    
112
#ifdef STRICT_LIMITS
113
    c->symCount++;
114
#endif
115
}
116

    
117
/**
118
 * @param bit 0 -> write zero bit, !=0 write one bit
119
 */
120
static inline void put_cabac_bypass(CABACContext *c, int bit){
121
    c->low += c->low;
122

    
123
    if(bit){
124
        c->low += c->range;
125
    }
126
//FIXME optimize
127
    if(c->low<0x200){
128
        put_cabac_bit(c, 0);
129
    }else if(c->low<0x400){
130
        c->outstanding_count++;
131
        c->low -= 0x200;
132
    }else{
133
        put_cabac_bit(c, 1);
134
        c->low -= 0x400;
135
    }
136
        
137
#ifdef STRICT_LIMITS
138
    c->symCount++;
139
#endif
140
}
141

    
142
/**
143
 *
144
 * @return the number of bytes written
145
 */
146
static inline int put_cabac_terminate(CABACContext *c, int bit){
147
    c->range -= 2;
148

    
149
    if(!bit){
150
        renorm_cabac_encoder(c);
151
    }else{
152
        c->low += c->range;
153
        c->range= 2;
154
        
155
        renorm_cabac_encoder(c);
156

    
157
        assert(c->low <= 0x1FF);
158
        put_cabac_bit(c, c->low>>9);
159
        put_bits(&c->pb, 2, ((c->low>>7)&3)|1);
160
        
161
        flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong
162
    }
163
        
164
#ifdef STRICT_LIMITS
165
    c->symCount++;
166
#endif
167

    
168
    return (get_bit_count(&c->pb)+7)>>3;
169
}
170

    
171
/**
172
 * put (truncated) unary binarization.
173
 */
174
static inline void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){
175
    int i;
176
    
177
    assert(v <= max);
178
    
179
#if 1
180
    for(i=0; i<v; i++){
181
        put_cabac(c, state, 1);
182
        if(i < max_index) state++;
183
    }
184
    if(truncated==0 || v<max)
185
        put_cabac(c, state, 0);
186
#else
187
    if(v <= max_index){
188
        for(i=0; i<v; i++){
189
            put_cabac(c, state+i, 1);
190
        }
191
        if(truncated==0 || v<max)
192
            put_cabac(c, state+i, 0);
193
    }else{
194
        for(i=0; i<=max_index; i++){
195
            put_cabac(c, state+i, 1);
196
        }
197
        for(; i<v; i++){
198
            put_cabac(c, state+max_index, 1);
199
        }
200
        if(truncated==0 || v<max)
201
            put_cabac(c, state+max_index, 0);
202
    }
203
#endif
204
}
205

    
206
/**
207
 * put unary exp golomb k-th order binarization.
208
 */
209
static inline void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int max, int is_signed, int k, int max_index){
210
    int i;
211
    
212
    if(v==0)
213
        put_cabac(c, state, 0);
214
    else{
215
        const int sign= v < 0;
216
        
217
        if(is_signed) v= ABS(v);
218
        
219
        if(v<max){
220
            for(i=0; i<v; i++){
221
                put_cabac(c, state, 1);
222
                if(i < max_index) state++;
223
            }
224

    
225
            put_cabac(c, state, 0);
226
        }else{
227
            int m= 1<<k;
228

    
229
            for(i=0; i<max; i++){
230
                put_cabac(c, state, 1);
231
                if(i < max_index) state++;
232
            }
233

    
234
            v -= max;
235
            while(v >= m){ //FIXME optimize
236
                put_cabac_bypass(c, 1);
237
                v-= m;
238
                m+= m;
239
            }
240
            put_cabac_bypass(c, 0);
241
            while(m>>=1){
242
                put_cabac_bypass(c, v&m);
243
            }
244
        }
245

    
246
        if(is_signed)
247
            put_cabac_bypass(c, sign);
248
    }
249
}
250

    
251
static inline void renorm_cabac_decoder(CABACContext *c){
252
    while(c->range < 0x10000){
253
        c->range+= c->range;
254
        c->low+= c->low;
255
        if(--c->bits_left == 0){
256
            c->low+= *c->bytestream++;
257
            c->bits_left= 8;
258
        }
259
    }
260
}
261

    
262
static inline int get_cabac(CABACContext *c, uint8_t * const state){
263
    int RangeLPS= c->lps_range[*state][((c->range)>>14)&3]<<8;
264
    int bit;
265
    
266
    c->range -= RangeLPS;
267
    if(c->low < c->range){
268
        bit= (*state)&1;
269
        *state= c->mps_state[*state];
270
    }else{
271
        bit= ((*state)&1)^1;
272
        c->low -= c->range;
273
        c->range = RangeLPS;
274
        *state= c->lps_state[*state];
275
    }
276
    renorm_cabac_decoder(c);
277
    
278
    return bit;    
279
}
280

    
281
static inline int get_cabac_static(CABACContext *c, int RangeLPS){
282
    int bit;
283
    
284
    c->range -= RangeLPS;
285
    if(c->low < c->range){
286
        bit= 0;
287
    }else{
288
        bit= 1;
289
        c->low -= c->range;
290
        c->range = RangeLPS;
291
    }
292
    renorm_cabac_decoder(c);
293
    
294
    return bit;    
295
}
296

    
297
static inline int get_cabac_bypass(CABACContext *c){
298
    c->low += c->low;
299

    
300
    if(--c->bits_left == 0){
301
        c->low+= *c->bytestream++;
302
        c->bits_left= 8;
303
    }
304
    
305
    if(c->low < c->range){
306
        return 0;
307
    }else{
308
        c->low -= c->range;
309
        return 1;
310
    }
311
}
312

    
313
/**
314
 *
315
 * @return the number of bytes read or 0 if no end
316
 */
317
static inline int get_cabac_terminate(CABACContext *c){
318
    c->range -= 2<<8;
319
    if(c->low < c->range){
320
        renorm_cabac_decoder(c);    
321
        return 0;
322
    }else{
323
        return c->bytestream - c->bytestream_start;
324
    }    
325
}
326

    
327
/**
328
 * get (truncated) unnary binarization.
329
 */
330
static inline int get_cabac_u(CABACContext *c, uint8_t * state, int max, int max_index, int truncated){
331
    int i;
332
    
333
    for(i=0; i<max; i++){ 
334
        if(get_cabac(c, state)==0)
335
            return i;
336
            
337
        if(i< max_index) state++;
338
    }
339

    
340
    return truncated ? max : -1;
341
}
342

    
343
/**
344
 * get unary exp golomb k-th order binarization.
345
 */
346
static inline int get_cabac_ueg(CABACContext *c, uint8_t * state, int max, int is_signed, int k, int max_index){
347
    int i, v;
348
    int m= 1<<k;
349
    
350
    if(get_cabac(c, state)==0) 
351
        return 0;
352
        
353
    if(0 < max_index) state++;
354
    
355
    for(i=1; i<max; i++){ 
356
        if(get_cabac(c, state)==0){
357
            if(is_signed && get_cabac_bypass(c)){
358
                return -i;
359
            }else
360
                return i;
361
        }
362

    
363
        if(i < max_index) state++;
364
    }
365
    
366
    while(get_cabac_bypass(c)){
367
        i+= m;
368
        m+= m;
369
    }
370
    
371
    v=0;
372
    while(m>>=1){
373
        v+= v + get_cabac_bypass(c);
374
    }
375
    i += v;
376

    
377
    if(is_signed && get_cabac_bypass(c)){
378
        return -i;
379
    }else
380
        return i;
381
}