fix assertion failure
[ffmpeg.git] / libavcodec / rangecoder.h
1 /*
2  * Range coder
3  * Copyright (c) 2004 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 /**
24  * @file rangecoder.h
25  * Range coder.
26  */
27
28 typedef struct RangeCoder{
29     int low;
30     int range;
31     int outstanding_count;
32     int outstanding_byte;
33     uint8_t zero_state[256];
34     uint8_t  one_state[256];
35     uint8_t *bytestream_start;
36     uint8_t *bytestream;
37     uint8_t *bytestream_end;
38 }RangeCoder;
39
40 void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size);
41 void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf, int buf_size);
42 int ff_rac_terminate(RangeCoder *c);
43 void ff_build_rac_states(RangeCoder *c, int factor, int max_p);
44
45 static inline void renorm_encoder(RangeCoder *c){
46     //FIXME optimize
47     while(c->range < 0x100){
48         if(c->outstanding_byte < 0){
49             c->outstanding_byte= c->low>>8;
50         }else if(c->low <= 0xFF00){
51             *c->bytestream++ = c->outstanding_byte;
52             for(;c->outstanding_count; c->outstanding_count--)
53                 *c->bytestream++ = 0xFF;
54             c->outstanding_byte= c->low>>8;
55         }else if(c->low >= 0x10000){
56             *c->bytestream++ = c->outstanding_byte + 1;
57             for(;c->outstanding_count; c->outstanding_count--)
58                 *c->bytestream++ = 0x00;
59             c->outstanding_byte= (c->low>>8) & 0xFF;
60         }else{
61             c->outstanding_count++;
62         }
63
64         c->low = (c->low & 0xFF)<<8;
65         c->range <<= 8;
66     }
67 }
68
69 static inline int get_rac_count(RangeCoder *c){
70     int x= c->bytestream - c->bytestream_start + c->outstanding_count;
71     if(c->outstanding_byte >= 0)
72         x++;
73     return 8*x - av_log2(c->range);
74 }
75
76 static inline void put_rac(RangeCoder *c, uint8_t * const state, int bit){
77     int range1= (c->range * (*state)) >> 8;
78
79     assert(*state);
80     assert(range1 < c->range);
81     assert(range1 > 0);
82     if(!bit){
83         c->range -= range1;
84         *state= c->zero_state[*state];
85     }else{
86         c->low += c->range - range1;
87         c->range = range1;
88         *state= c->one_state[*state];
89     }
90
91     renorm_encoder(c);
92 }
93
94 static inline void refill(RangeCoder *c){
95     if(c->range < 0x100){
96         c->range <<= 8;
97         c->low <<= 8;
98         if(c->bytestream < c->bytestream_end)
99             c->low+= c->bytestream[0];
100         c->bytestream++;
101     }
102 }
103
104 static inline int get_rac(RangeCoder *c, uint8_t * const state){
105     int range1= (c->range * (*state)) >> 8;
106     int attribute_unused one_mask;
107
108     c->range -= range1;
109 #if 1
110     if(c->low < c->range){
111         *state= c->zero_state[*state];
112         refill(c);
113         return 0;
114     }else{
115         c->low -= c->range;
116         *state= c->one_state[*state];
117         c->range = range1;
118         refill(c);
119         return 1;
120     }
121 #else
122     one_mask= (c->range - c->low-1)>>31;
123
124     c->low -= c->range & one_mask;
125     c->range += (range1 - c->range) & one_mask;
126
127     *state= c->zero_state[(*state) + (256&one_mask)];
128
129     refill(c);
130
131     return one_mask&1;
132 #endif
133 }
134