Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ 72415b2a

History | View | Annotate | Download (34.6 KB)

1
/*
2
 * FFV1 codec for libavcodec
3
 *
4
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22

    
23
/**
24
 * @file libavcodec/ffv1.c
25
 * FF Video Codec 1 (a lossless codec)
26
 */
27

    
28
#include "avcodec.h"
29
#include "get_bits.h"
30
#include "put_bits.h"
31
#include "dsputil.h"
32
#include "rangecoder.h"
33
#include "golomb.h"
34
#include "mathops.h"
35

    
36
#define MAX_PLANES 4
37
#define CONTEXT_SIZE 32
38

    
39
extern const uint8_t ff_log2_run[32];
40

    
41
static const int8_t quant3[256]={
42
 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
43
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
44
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
45
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
46
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
47
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
48
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
49
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
50
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
51
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
52
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
53
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
54
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
55
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
56
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
57
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
58
};
59

    
60
static const int8_t quant5_10bit[256]={
61
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
62
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
63
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
64
 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
65
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
66
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
67
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
68
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
69
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
70
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
71
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
72
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
73
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,
74
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
75
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
76
-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
77
};
78

    
79
static const int8_t quant5[256]={
80
 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
81
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
82
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
83
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
84
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
85
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
86
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
87
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
88
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
89
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
90
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
91
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
92
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
93
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
94
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
95
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
96
};
97
static const int8_t quant7[256]={
98
 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
99
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
100
 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
101
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
102
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
103
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
104
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
105
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
106
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
107
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
108
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
109
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
110
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
111
-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
112
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
113
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
114
};
115
static const int8_t quant9[256]={
116
 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
117
 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
118
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
119
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
120
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
121
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
122
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
123
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
124
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
125
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
126
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
127
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
128
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
129
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
130
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
131
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
132
};
133
static const int8_t quant9_10bit[256]={
134
 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
135
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
136
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
137
 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
138
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
139
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
140
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
141
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
142
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
143
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
144
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
145
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
146
-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,
147
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
148
-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
149
-2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
150
};
151

    
152
static const int8_t quant11[256]={
153
 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
154
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
155
 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
156
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
157
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
158
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
159
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
160
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
161
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
162
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
163
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
164
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
165
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
166
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
167
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
168
-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
169
};
170
static const int8_t quant13[256]={
171
 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
172
 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
173
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
174
 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
175
 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
176
 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
177
 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
178
 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
179
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
180
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
181
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
182
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
183
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
184
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
185
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
186
-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
187
};
188

    
189
typedef struct VlcState{
190
    int16_t drift;
191
    uint16_t error_sum;
192
    int8_t bias;
193
    uint8_t count;
194
} VlcState;
195

    
196
typedef struct PlaneContext{
197
    int context_count;
198
    uint8_t (*state)[CONTEXT_SIZE];
199
    VlcState *vlc_state;
200
    uint8_t interlace_bit_state[2];
201
} PlaneContext;
202

    
203
typedef struct FFV1Context{
204
    AVCodecContext *avctx;
205
    RangeCoder c;
206
    GetBitContext gb;
207
    PutBitContext pb;
208
    int version;
209
    int width, height;
210
    int chroma_h_shift, chroma_v_shift;
211
    int flags;
212
    int picture_number;
213
    AVFrame picture;
214
    int plane_count;
215
    int ac;                              ///< 1=range coder <-> 0=golomb rice
216
    PlaneContext plane[MAX_PLANES];
217
    int16_t quant_table[5][256];
218
    int run_index;
219
    int colorspace;
220

    
221
    DSPContext dsp;
222
}FFV1Context;
223

    
224
static av_always_inline int fold(int diff, int bits){
225
    if(bits==8)
226
        diff= (int8_t)diff;
227
    else{
228
        diff+= 1<<(bits-1);
229
        diff&=(1<<bits)-1;
230
        diff-= 1<<(bits-1);
231
    }
232

    
233
    return diff;
234
}
235

    
236
static inline int predict(int_fast16_t *src, int_fast16_t *last){
237
    const int LT= last[-1];
238
    const int  T= last[ 0];
239
    const int L =  src[-1];
240

    
241
    return mid_pred(L, L + T - LT, T);
242
}
243

    
244
static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
245
    const int LT= last[-1];
246
    const int  T= last[ 0];
247
    const int RT= last[ 1];
248
    const int L =  src[-1];
249

    
250
    if(f->quant_table[3][127]){
251
        const int TT= last2[0];
252
        const int LL=  src[-2];
253
        return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
254
              +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
255
    }else
256
        return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
257
}
258

    
259
static inline void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed){
260
    int i;
261

    
262
    if(v){
263
        const int a= FFABS(v);
264
        const int e= av_log2(a);
265
        put_rac(c, state+0, 0);
266
        if(e<=9){
267
            for(i=0; i<e; i++){
268
                put_rac(c, state+1+i, 1);  //1..10
269
            }
270
            put_rac(c, state+1+i, 0);
271

    
272
            for(i=e-1; i>=0; i--){
273
                put_rac(c, state+22+i, (a>>i)&1); //22..31
274
            }
275

    
276
            if(is_signed)
277
                put_rac(c, state+11 + e, v < 0); //11..21
278
        }else{
279
            for(i=0; i<e; i++){
280
                put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
281
            }
282
            put_rac(c, state+1+9, 0);
283

    
284
            for(i=e-1; i>=0; i--){
285
                put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
286
            }
287

    
288
            if(is_signed)
289
                put_rac(c, state+11 + 10, v < 0); //11..21
290
        }
291
    }else{
292
        put_rac(c, state+0, 1);
293
    }
294
}
295

    
296
static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
297
    put_symbol_inline(c, state, v, is_signed);
298
}
299

    
300
static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
301
    if(get_rac(c, state+0))
302
        return 0;
303
    else{
304
        int i, e, a;
305
        e= 0;
306
        while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
307
            e++;
308
        }
309

    
310
        a= 1;
311
        for(i=e-1; i>=0; i--){
312
            a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
313
        }
314

    
315
        e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
316
        return (a^e)-e;
317
    }
318
}
319

    
320
static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
321
    return get_symbol_inline(c, state, is_signed);
322
}
323

    
324
static inline void update_vlc_state(VlcState * const state, const int v){
325
    int drift= state->drift;
326
    int count= state->count;
327
    state->error_sum += FFABS(v);
328
    drift += v;
329

    
330
    if(count == 128){ //FIXME variable
331
        count >>= 1;
332
        drift >>= 1;
333
        state->error_sum >>= 1;
334
    }
335
    count++;
336

    
337
    if(drift <= -count){
338
        if(state->bias > -128) state->bias--;
339

    
340
        drift += count;
341
        if(drift <= -count)
342
            drift= -count + 1;
343
    }else if(drift > 0){
344
        if(state->bias <  127) state->bias++;
345

    
346
        drift -= count;
347
        if(drift > 0)
348
            drift= 0;
349
    }
350

    
351
    state->drift= drift;
352
    state->count= count;
353
}
354

    
355
static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
356
    int i, k, code;
357
//printf("final: %d ", v);
358
    v = fold(v - state->bias, bits);
359

    
360
    i= state->count;
361
    k=0;
362
    while(i < state->error_sum){ //FIXME optimize
363
        k++;
364
        i += i;
365
    }
366

    
367
    assert(k<=8);
368

    
369
#if 0 // JPEG LS
370
    if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
371
    else                                         code= v;
372
#else
373
     code= v ^ ((2*state->drift + state->count)>>31);
374
#endif
375

    
376
//printf("v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code, state->bias, state->error_sum, state->drift, state->count, k);
377
    set_sr_golomb(pb, code, k, 12, bits);
378

    
379
    update_vlc_state(state, v);
380
}
381

    
382
static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
383
    int k, i, v, ret;
384

    
385
    i= state->count;
386
    k=0;
387
    while(i < state->error_sum){ //FIXME optimize
388
        k++;
389
        i += i;
390
    }
391

    
392
    assert(k<=8);
393

    
394
    v= get_sr_golomb(gb, k, 12, bits);
395
//printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
396

    
397
#if 0 // JPEG LS
398
    if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
399
#else
400
     v ^= ((2*state->drift + state->count)>>31);
401
#endif
402

    
403
    ret= fold(v + state->bias, bits);
404

    
405
    update_vlc_state(state, v);
406
//printf("final: %d\n", ret);
407
    return ret;
408
}
409

    
410
#if CONFIG_FFV1_ENCODER
411
static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
412
    PlaneContext * const p= &s->plane[plane_index];
413
    RangeCoder * const c= &s->c;
414
    int x;
415
    int run_index= s->run_index;
416
    int run_count=0;
417
    int run_mode=0;
418

    
419
    if(s->ac){
420
        if(c->bytestream_end - c->bytestream < w*20){
421
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
422
            return -1;
423
        }
424
    }else{
425
        if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
426
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
427
            return -1;
428
        }
429
    }
430

    
431
    for(x=0; x<w; x++){
432
        int diff, context;
433

    
434
        context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
435
        diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
436

    
437
        if(context < 0){
438
            context = -context;
439
            diff= -diff;
440
        }
441

    
442
        diff= fold(diff, bits);
443

    
444
        if(s->ac){
445
            put_symbol_inline(c, p->state[context], diff, 1);
446
        }else{
447
            if(context == 0) run_mode=1;
448

    
449
            if(run_mode){
450

    
451
                if(diff){
452
                    while(run_count >= 1<<ff_log2_run[run_index]){
453
                        run_count -= 1<<ff_log2_run[run_index];
454
                        run_index++;
455
                        put_bits(&s->pb, 1, 1);
456
                    }
457

    
458
                    put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
459
                    if(run_index) run_index--;
460
                    run_count=0;
461
                    run_mode=0;
462
                    if(diff>0) diff--;
463
                }else{
464
                    run_count++;
465
                }
466
            }
467

    
468
//            printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, (int)put_bits_count(&s->pb));
469

    
470
            if(run_mode == 0)
471
                put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
472
        }
473
    }
474
    if(run_mode){
475
        while(run_count >= 1<<ff_log2_run[run_index]){
476
            run_count -= 1<<ff_log2_run[run_index];
477
            run_index++;
478
            put_bits(&s->pb, 1, 1);
479
        }
480

    
481
        if(run_count)
482
            put_bits(&s->pb, 1, 1);
483
    }
484
    s->run_index= run_index;
485

    
486
    return 0;
487
}
488

    
489
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
490
    int x,y,i;
491
    const int ring_size= s->avctx->context_model ? 3 : 2;
492
    int_fast16_t sample_buffer[ring_size][w+6], *sample[ring_size];
493
    s->run_index=0;
494

    
495
    memset(sample_buffer, 0, sizeof(sample_buffer));
496

    
497
    for(y=0; y<h; y++){
498
        for(i=0; i<ring_size; i++)
499
            sample[i]= sample_buffer[(h+i-y)%ring_size]+3;
500

    
501
        sample[0][-1]= sample[1][0  ];
502
        sample[1][ w]= sample[1][w-1];
503
//{START_TIMER
504
        if(s->avctx->bits_per_raw_sample<=8){
505
            for(x=0; x<w; x++){
506
                sample[0][x]= src[x + stride*y];
507
            }
508
            encode_line(s, w, sample, plane_index, 8);
509
        }else{
510
            for(x=0; x<w; x++){
511
                sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
512
            }
513
            encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
514
        }
515
//STOP_TIMER("encode line")}
516
    }
517
}
518

    
519
static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
520
    int x, y, p, i;
521
    const int ring_size= s->avctx->context_model ? 3 : 2;
522
    int_fast16_t sample_buffer[3][ring_size][w+6], *sample[3][ring_size];
523
    s->run_index=0;
524

    
525
    memset(sample_buffer, 0, sizeof(sample_buffer));
526

    
527
    for(y=0; y<h; y++){
528
        for(i=0; i<ring_size; i++)
529
            for(p=0; p<3; p++)
530
                sample[p][i]= sample_buffer[p][(h+i-y)%ring_size]+3;
531

    
532
        for(x=0; x<w; x++){
533
            int v= src[x + stride*y];
534
            int b= v&0xFF;
535
            int g= (v>>8)&0xFF;
536
            int r= (v>>16)&0xFF;
537

    
538
            b -= g;
539
            r -= g;
540
            g += (b + r)>>2;
541
            b += 0x100;
542
            r += 0x100;
543

    
544
//            assert(g>=0 && b>=0 && r>=0);
545
//            assert(g<256 && b<512 && r<512);
546
            sample[0][0][x]= g;
547
            sample[1][0][x]= b;
548
            sample[2][0][x]= r;
549
        }
550
        for(p=0; p<3; p++){
551
            sample[p][0][-1]= sample[p][1][0  ];
552
            sample[p][1][ w]= sample[p][1][w-1];
553
            encode_line(s, w, sample[p], FFMIN(p, 1), 9);
554
        }
555
    }
556
}
557

    
558
static void write_quant_table(RangeCoder *c, int16_t *quant_table){
559
    int last=0;
560
    int i;
561
    uint8_t state[CONTEXT_SIZE];
562
    memset(state, 128, sizeof(state));
563

    
564
    for(i=1; i<128 ; i++){
565
        if(quant_table[i] != quant_table[i-1]){
566
            put_symbol(c, state, i-last-1, 0);
567
            last= i;
568
        }
569
    }
570
    put_symbol(c, state, i-last-1, 0);
571
}
572

    
573
static void write_header(FFV1Context *f){
574
    uint8_t state[CONTEXT_SIZE];
575
    int i;
576
    RangeCoder * const c= &f->c;
577

    
578
    memset(state, 128, sizeof(state));
579

    
580
    put_symbol(c, state, f->version, 0);
581
    put_symbol(c, state, f->avctx->coder_type, 0);
582
    put_symbol(c, state, f->colorspace, 0); //YUV cs type
583
    if(f->version>0)
584
        put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
585
    put_rac(c, state, 1); //chroma planes
586
        put_symbol(c, state, f->chroma_h_shift, 0);
587
        put_symbol(c, state, f->chroma_v_shift, 0);
588
    put_rac(c, state, 0); //no transparency plane
589

    
590
    for(i=0; i<5; i++)
591
        write_quant_table(c, f->quant_table[i]);
592
}
593
#endif /* CONFIG_FFV1_ENCODER */
594

    
595
static av_cold int common_init(AVCodecContext *avctx){
596
    FFV1Context *s = avctx->priv_data;
597

    
598
    s->avctx= avctx;
599
    s->flags= avctx->flags;
600

    
601
    dsputil_init(&s->dsp, avctx);
602

    
603
    s->width = avctx->width;
604
    s->height= avctx->height;
605

    
606
    assert(s->width && s->height);
607

    
608
    return 0;
609
}
610

    
611
#if CONFIG_FFV1_ENCODER
612
static av_cold int encode_init(AVCodecContext *avctx)
613
{
614
    FFV1Context *s = avctx->priv_data;
615
    int i;
616

    
617
    common_init(avctx);
618

    
619
    s->version=0;
620
    s->ac= avctx->coder_type;
621

    
622
    s->plane_count=2;
623
    for(i=0; i<256; i++){
624
        if(avctx->bits_per_raw_sample <=8){
625
            s->quant_table[0][i]=           quant11[i];
626
            s->quant_table[1][i]=        11*quant11[i];
627
            if(avctx->context_model==0){
628
                s->quant_table[2][i]=     11*11*quant11[i];
629
                s->quant_table[3][i]=
630
                s->quant_table[4][i]=0;
631
            }else{
632
                s->quant_table[2][i]=     11*11*quant5 [i];
633
                s->quant_table[3][i]=   5*11*11*quant5 [i];
634
                s->quant_table[4][i]= 5*5*11*11*quant5 [i];
635
            }
636
        }else{
637
            s->quant_table[0][i]=           quant9_10bit[i];
638
            s->quant_table[1][i]=        11*quant9_10bit[i];
639
            if(avctx->context_model==0){
640
                s->quant_table[2][i]=     11*11*quant9_10bit[i];
641
                s->quant_table[3][i]=
642
                s->quant_table[4][i]=0;
643
            }else{
644
                s->quant_table[2][i]=     11*11*quant5_10bit[i];
645
                s->quant_table[3][i]=   5*11*11*quant5_10bit[i];
646
                s->quant_table[4][i]= 5*5*11*11*quant5_10bit[i];
647
            }
648
        }
649
    }
650

    
651
    for(i=0; i<s->plane_count; i++){
652
        PlaneContext * const p= &s->plane[i];
653

    
654
        if(avctx->context_model==0){
655
            p->context_count= (11*11*11+1)/2;
656
        }else{
657
            p->context_count= (11*11*5*5*5+1)/2;
658
        }
659

    
660
        if(s->ac){
661
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
662
        }else{
663
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
664
        }
665
    }
666

    
667
    avctx->coded_frame= &s->picture;
668
    switch(avctx->pix_fmt){
669
    case PIX_FMT_YUV444P16:
670
    case PIX_FMT_YUV422P16:
671
    case PIX_FMT_YUV420P16:
672
        if(avctx->bits_per_raw_sample <=8){
673
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
674
            return -1;
675
        }
676
        if(!s->ac){
677
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
678
            return -1;
679
        }
680
        s->version= 1;
681
    case PIX_FMT_YUV444P:
682
    case PIX_FMT_YUV422P:
683
    case PIX_FMT_YUV420P:
684
    case PIX_FMT_YUV411P:
685
    case PIX_FMT_YUV410P:
686
        s->colorspace= 0;
687
        break;
688
    case PIX_FMT_RGB32:
689
        s->colorspace= 1;
690
        break;
691
    default:
692
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
693
        return -1;
694
    }
695
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
696

    
697
    s->picture_number=0;
698

    
699
    return 0;
700
}
701
#endif /* CONFIG_FFV1_ENCODER */
702

    
703

    
704
static void clear_state(FFV1Context *f){
705
    int i, j;
706

    
707
    for(i=0; i<f->plane_count; i++){
708
        PlaneContext *p= &f->plane[i];
709

    
710
        p->interlace_bit_state[0]= 128;
711
        p->interlace_bit_state[1]= 128;
712

    
713
        for(j=0; j<p->context_count; j++){
714
            if(f->ac){
715
                memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
716
            }else{
717
                p->vlc_state[j].drift= 0;
718
                p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
719
                p->vlc_state[j].bias= 0;
720
                p->vlc_state[j].count= 1;
721
            }
722
        }
723
    }
724
}
725

    
726
#if CONFIG_FFV1_ENCODER
727
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
728
    FFV1Context *f = avctx->priv_data;
729
    RangeCoder * const c= &f->c;
730
    AVFrame *pict = data;
731
    const int width= f->width;
732
    const int height= f->height;
733
    AVFrame * const p= &f->picture;
734
    int used_count= 0;
735
    uint8_t keystate=128;
736

    
737
    ff_init_range_encoder(c, buf, buf_size);
738
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
739

    
740
    *p = *pict;
741
    p->pict_type= FF_I_TYPE;
742

    
743
    if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
744
        put_rac(c, &keystate, 1);
745
        p->key_frame= 1;
746
        write_header(f);
747
        clear_state(f);
748
    }else{
749
        put_rac(c, &keystate, 0);
750
        p->key_frame= 0;
751
    }
752

    
753
    if(!f->ac){
754
        used_count += ff_rac_terminate(c);
755
//printf("pos=%d\n", used_count);
756
        init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
757
    }
758

    
759
    if(f->colorspace==0){
760
        const int chroma_width = -((-width )>>f->chroma_h_shift);
761
        const int chroma_height= -((-height)>>f->chroma_v_shift);
762

    
763
        encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
764

    
765
        encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
766
        encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
767
    }else{
768
        encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
769
    }
770
    emms_c();
771

    
772
    f->picture_number++;
773

    
774
    if(f->ac){
775
        return ff_rac_terminate(c);
776
    }else{
777
        flush_put_bits(&f->pb); //nicer padding FIXME
778
        return used_count + (put_bits_count(&f->pb)+7)/8;
779
    }
780
}
781
#endif /* CONFIG_FFV1_ENCODER */
782

    
783
static av_cold int common_end(AVCodecContext *avctx){
784
    FFV1Context *s = avctx->priv_data;
785
    int i;
786

    
787
    for(i=0; i<s->plane_count; i++){
788
        PlaneContext *p= &s->plane[i];
789

    
790
        av_freep(&p->state);
791
        av_freep(&p->vlc_state);
792
    }
793

    
794
    return 0;
795
}
796

    
797
static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
798
    PlaneContext * const p= &s->plane[plane_index];
799
    RangeCoder * const c= &s->c;
800
    int x;
801
    int run_count=0;
802
    int run_mode=0;
803
    int run_index= s->run_index;
804

    
805
    for(x=0; x<w; x++){
806
        int diff, context, sign;
807

    
808
        context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
809
        if(context < 0){
810
            context= -context;
811
            sign=1;
812
        }else
813
            sign=0;
814

    
815

    
816
        if(s->ac){
817
            diff= get_symbol_inline(c, p->state[context], 1);
818
        }else{
819
            if(context == 0 && run_mode==0) run_mode=1;
820

    
821
            if(run_mode){
822
                if(run_count==0 && run_mode==1){
823
                    if(get_bits1(&s->gb)){
824
                        run_count = 1<<ff_log2_run[run_index];
825
                        if(x + run_count <= w) run_index++;
826
                    }else{
827
                        if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
828
                        else run_count=0;
829
                        if(run_index) run_index--;
830
                        run_mode=2;
831
                    }
832
                }
833
                run_count--;
834
                if(run_count < 0){
835
                    run_mode=0;
836
                    run_count=0;
837
                    diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
838
                    if(diff>=0) diff++;
839
                }else
840
                    diff=0;
841
            }else
842
                diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
843

    
844
//            printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, get_bits_count(&s->gb));
845
        }
846

    
847
        if(sign) diff= -diff;
848

    
849
        sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
850
    }
851
    s->run_index= run_index;
852
}
853

    
854
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
855
    int x, y;
856
    int_fast16_t sample_buffer[2][w+6];
857
    int_fast16_t *sample[2];
858
    sample[0]=sample_buffer[0]+3;
859
    sample[1]=sample_buffer[1]+3;
860

    
861
    s->run_index=0;
862

    
863
    memset(sample_buffer, 0, sizeof(sample_buffer));
864

    
865
    for(y=0; y<h; y++){
866
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
867

    
868
        sample[0]= sample[1];
869
        sample[1]= temp;
870

    
871
        sample[1][-1]= sample[0][0  ];
872
        sample[0][ w]= sample[0][w-1];
873

    
874
//{START_TIMER
875
        if(s->avctx->bits_per_raw_sample <= 8){
876
            decode_line(s, w, sample, plane_index, 8);
877
            for(x=0; x<w; x++){
878
                src[x + stride*y]= sample[1][x];
879
            }
880
        }else{
881
            decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
882
            for(x=0; x<w; x++){
883
                ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
884
            }
885
        }
886
//STOP_TIMER("decode-line")}
887
    }
888
}
889

    
890
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
891
    int x, y, p;
892
    int_fast16_t sample_buffer[3][2][w+6];
893
    int_fast16_t *sample[3][2];
894
    for(x=0; x<3; x++){
895
        sample[x][0] = sample_buffer[x][0]+3;
896
        sample[x][1] = sample_buffer[x][1]+3;
897
    }
898

    
899
    s->run_index=0;
900

    
901
    memset(sample_buffer, 0, sizeof(sample_buffer));
902

    
903
    for(y=0; y<h; y++){
904
        for(p=0; p<3; p++){
905
            int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
906

    
907
            sample[p][0]= sample[p][1];
908
            sample[p][1]= temp;
909

    
910
            sample[p][1][-1]= sample[p][0][0  ];
911
            sample[p][0][ w]= sample[p][0][w-1];
912
            decode_line(s, w, sample[p], FFMIN(p, 1), 9);
913
        }
914
        for(x=0; x<w; x++){
915
            int g= sample[0][1][x];
916
            int b= sample[1][1][x];
917
            int r= sample[2][1][x];
918

    
919
//            assert(g>=0 && b>=0 && r>=0);
920
//            assert(g<256 && b<512 && r<512);
921

    
922
            b -= 0x100;
923
            r -= 0x100;
924
            g -= (b + r)>>2;
925
            b += g;
926
            r += g;
927

    
928
            src[x + stride*y]= b + (g<<8) + (r<<16);
929
        }
930
    }
931
}
932

    
933
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
934
    int v;
935
    int i=0;
936
    uint8_t state[CONTEXT_SIZE];
937

    
938
    memset(state, 128, sizeof(state));
939

    
940
    for(v=0; i<128 ; v++){
941
        int len= get_symbol(c, state, 0) + 1;
942

    
943
        if(len + i > 128) return -1;
944

    
945
        while(len--){
946
            quant_table[i] = scale*v;
947
            i++;
948
//printf("%2d ",v);
949
//if(i%16==0) printf("\n");
950
        }
951
    }
952

    
953
    for(i=1; i<128; i++){
954
        quant_table[256-i]= -quant_table[i];
955
    }
956
    quant_table[128]= -quant_table[127];
957

    
958
    return 2*v - 1;
959
}
960

    
961
static int read_header(FFV1Context *f){
962
    uint8_t state[CONTEXT_SIZE];
963
    int i, context_count;
964
    RangeCoder * const c= &f->c;
965

    
966
    memset(state, 128, sizeof(state));
967

    
968
    f->version= get_symbol(c, state, 0);
969
    f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
970
    f->colorspace= get_symbol(c, state, 0); //YUV cs type
971
    if(f->version>0)
972
        f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
973
    get_rac(c, state); //no chroma = false
974
    f->chroma_h_shift= get_symbol(c, state, 0);
975
    f->chroma_v_shift= get_symbol(c, state, 0);
976
    get_rac(c, state); //transparency plane
977
    f->plane_count= 2;
978

    
979
    if(f->colorspace==0){
980
        if(f->avctx->bits_per_raw_sample<=8){
981
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
982
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
983
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
984
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
985
            case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
986
            case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
987
            default:
988
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
989
                return -1;
990
            }
991
        }else{
992
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
993
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
994
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
995
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
996
            default:
997
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
998
                return -1;
999
            }
1000
        }
1001
    }else if(f->colorspace==1){
1002
        if(f->chroma_h_shift || f->chroma_v_shift){
1003
            av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1004
            return -1;
1005
        }
1006
        f->avctx->pix_fmt= PIX_FMT_RGB32;
1007
    }else{
1008
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1009
        return -1;
1010
    }
1011

    
1012
//printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1013

    
1014
    context_count=1;
1015
    for(i=0; i<5; i++){
1016
        context_count*= read_quant_table(c, f->quant_table[i], context_count);
1017
        if(context_count < 0 || context_count > 32768){
1018
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1019
            return -1;
1020
        }
1021
    }
1022
    context_count= (context_count+1)/2;
1023

    
1024
    for(i=0; i<f->plane_count; i++){
1025
        PlaneContext * const p= &f->plane[i];
1026

    
1027
        p->context_count= context_count;
1028

    
1029
        if(f->ac){
1030
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
1031
        }else{
1032
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
1033
        }
1034
    }
1035

    
1036
    return 0;
1037
}
1038

    
1039
static av_cold int decode_init(AVCodecContext *avctx)
1040
{
1041
//    FFV1Context *s = avctx->priv_data;
1042

    
1043
    common_init(avctx);
1044

    
1045
    return 0;
1046
}
1047

    
1048
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1049
    const uint8_t *buf = avpkt->data;
1050
    int buf_size = avpkt->size;
1051
    FFV1Context *f = avctx->priv_data;
1052
    RangeCoder * const c= &f->c;
1053
    const int width= f->width;
1054
    const int height= f->height;
1055
    AVFrame * const p= &f->picture;
1056
    int bytes_read;
1057
    uint8_t keystate= 128;
1058

    
1059
    AVFrame *picture = data;
1060

    
1061
    ff_init_range_decoder(c, buf, buf_size);
1062
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1063

    
1064

    
1065
    p->pict_type= FF_I_TYPE; //FIXME I vs. P
1066
    if(get_rac(c, &keystate)){
1067
        p->key_frame= 1;
1068
        if(read_header(f) < 0)
1069
            return -1;
1070
        clear_state(f);
1071
    }else{
1072
        p->key_frame= 0;
1073
    }
1074
    if(!f->plane[0].state && !f->plane[0].vlc_state)
1075
        return -1;
1076

    
1077
    p->reference= 0;
1078
    if(avctx->get_buffer(avctx, p) < 0){
1079
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1080
        return -1;
1081
    }
1082

    
1083
    if(avctx->debug&FF_DEBUG_PICT_INFO)
1084
        av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1085

    
1086
    if(!f->ac){
1087
        bytes_read = c->bytestream - c->bytestream_start - 1;
1088
        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1089
//printf("pos=%d\n", bytes_read);
1090
        init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
1091
    } else {
1092
        bytes_read = 0; /* avoid warning */
1093
    }
1094

    
1095
    if(f->colorspace==0){
1096
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1097
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1098
        decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
1099

    
1100
        decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
1101
        decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
1102
    }else{
1103
        decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
1104
    }
1105

    
1106
    emms_c();
1107

    
1108
    f->picture_number++;
1109

    
1110
    *picture= *p;
1111

    
1112
    avctx->release_buffer(avctx, p); //FIXME
1113

    
1114
    *data_size = sizeof(AVFrame);
1115

    
1116
    if(f->ac){
1117
        bytes_read= c->bytestream - c->bytestream_start - 1;
1118
        if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1119
    }else{
1120
        bytes_read+= (get_bits_count(&f->gb)+7)/8;
1121
    }
1122

    
1123
    return bytes_read;
1124
}
1125

    
1126
AVCodec ffv1_decoder = {
1127
    "ffv1",
1128
    AVMEDIA_TYPE_VIDEO,
1129
    CODEC_ID_FFV1,
1130
    sizeof(FFV1Context),
1131
    decode_init,
1132
    NULL,
1133
    common_end,
1134
    decode_frame,
1135
    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1136
    NULL,
1137
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1138
};
1139

    
1140
#if CONFIG_FFV1_ENCODER
1141
AVCodec ffv1_encoder = {
1142
    "ffv1",
1143
    AVMEDIA_TYPE_VIDEO,
1144
    CODEC_ID_FFV1,
1145
    sizeof(FFV1Context),
1146
    encode_init,
1147
    encode_frame,
1148
    common_end,
1149
    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_NONE},
1150
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1151
};
1152
#endif