Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ 5d7bc46c

History | View | Annotate | Download (34.4 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
        s->version= 1;
677
    case PIX_FMT_YUV444P:
678
    case PIX_FMT_YUV422P:
679
    case PIX_FMT_YUV420P:
680
    case PIX_FMT_YUV411P:
681
    case PIX_FMT_YUV410P:
682
        s->colorspace= 0;
683
        break;
684
    case PIX_FMT_RGB32:
685
        s->colorspace= 1;
686
        break;
687
    default:
688
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
689
        return -1;
690
    }
691
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
692

    
693
    s->picture_number=0;
694

    
695
    return 0;
696
}
697
#endif /* CONFIG_FFV1_ENCODER */
698

    
699

    
700
static void clear_state(FFV1Context *f){
701
    int i, j;
702

    
703
    for(i=0; i<f->plane_count; i++){
704
        PlaneContext *p= &f->plane[i];
705

    
706
        p->interlace_bit_state[0]= 128;
707
        p->interlace_bit_state[1]= 128;
708

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

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

    
733
    ff_init_range_encoder(c, buf, buf_size);
734
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
735

    
736
    *p = *pict;
737
    p->pict_type= FF_I_TYPE;
738

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

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

    
755
    if(f->colorspace==0){
756
        const int chroma_width = -((-width )>>f->chroma_h_shift);
757
        const int chroma_height= -((-height)>>f->chroma_v_shift);
758

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

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

    
768
    f->picture_number++;
769

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

    
779
static av_cold int common_end(AVCodecContext *avctx){
780
    FFV1Context *s = avctx->priv_data;
781
    int i;
782

    
783
    for(i=0; i<s->plane_count; i++){
784
        PlaneContext *p= &s->plane[i];
785

    
786
        av_freep(&p->state);
787
        av_freep(&p->vlc_state);
788
    }
789

    
790
    return 0;
791
}
792

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

    
801
    for(x=0; x<w; x++){
802
        int diff, context, sign;
803

    
804
        context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
805
        if(context < 0){
806
            context= -context;
807
            sign=1;
808
        }else
809
            sign=0;
810

    
811

    
812
        if(s->ac){
813
            diff= get_symbol_inline(c, p->state[context], 1);
814
        }else{
815
            if(context == 0 && run_mode==0) run_mode=1;
816

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

    
840
//            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));
841
        }
842

    
843
        if(sign) diff= -diff;
844

    
845
        sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
846
    }
847
    s->run_index= run_index;
848
}
849

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

    
857
    s->run_index=0;
858

    
859
    memset(sample_buffer, 0, sizeof(sample_buffer));
860

    
861
    for(y=0; y<h; y++){
862
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
863

    
864
        sample[0]= sample[1];
865
        sample[1]= temp;
866

    
867
        sample[1][-1]= sample[0][0  ];
868
        sample[0][ w]= sample[0][w-1];
869

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

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

    
895
    s->run_index=0;
896

    
897
    memset(sample_buffer, 0, sizeof(sample_buffer));
898

    
899
    for(y=0; y<h; y++){
900
        for(p=0; p<3; p++){
901
            int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
902

    
903
            sample[p][0]= sample[p][1];
904
            sample[p][1]= temp;
905

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

    
915
//            assert(g>=0 && b>=0 && r>=0);
916
//            assert(g<256 && b<512 && r<512);
917

    
918
            b -= 0x100;
919
            r -= 0x100;
920
            g -= (b + r)>>2;
921
            b += g;
922
            r += g;
923

    
924
            src[x + stride*y]= b + (g<<8) + (r<<16);
925
        }
926
    }
927
}
928

    
929
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
930
    int v;
931
    int i=0;
932
    uint8_t state[CONTEXT_SIZE];
933

    
934
    memset(state, 128, sizeof(state));
935

    
936
    for(v=0; i<128 ; v++){
937
        int len= get_symbol(c, state, 0) + 1;
938

    
939
        if(len + i > 128) return -1;
940

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

    
949
    for(i=1; i<128; i++){
950
        quant_table[256-i]= -quant_table[i];
951
    }
952
    quant_table[128]= -quant_table[127];
953

    
954
    return 2*v - 1;
955
}
956

    
957
static int read_header(FFV1Context *f){
958
    uint8_t state[CONTEXT_SIZE];
959
    int i, context_count;
960
    RangeCoder * const c= &f->c;
961

    
962
    memset(state, 128, sizeof(state));
963

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

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

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

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

    
1020
    for(i=0; i<f->plane_count; i++){
1021
        PlaneContext * const p= &f->plane[i];
1022

    
1023
        p->context_count= context_count;
1024

    
1025
        if(f->ac){
1026
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
1027
        }else{
1028
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
1029
        }
1030
    }
1031

    
1032
    return 0;
1033
}
1034

    
1035
static av_cold int decode_init(AVCodecContext *avctx)
1036
{
1037
//    FFV1Context *s = avctx->priv_data;
1038

    
1039
    common_init(avctx);
1040

    
1041
    return 0;
1042
}
1043

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

    
1055
    AVFrame *picture = data;
1056

    
1057
    ff_init_range_decoder(c, buf, buf_size);
1058
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1059

    
1060

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

    
1073
    p->reference= 0;
1074
    if(avctx->get_buffer(avctx, p) < 0){
1075
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1076
        return -1;
1077
    }
1078

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

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

    
1091
    if(f->colorspace==0){
1092
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1093
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1094
        decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
1095

    
1096
        decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
1097
        decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
1098
    }else{
1099
        decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
1100
    }
1101

    
1102
    emms_c();
1103

    
1104
    f->picture_number++;
1105

    
1106
    *picture= *p;
1107

    
1108
    avctx->release_buffer(avctx, p); //FIXME
1109

    
1110
    *data_size = sizeof(AVFrame);
1111

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

    
1119
    return bytes_read;
1120
}
1121

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

    
1136
#if CONFIG_FFV1_ENCODER
1137
AVCodec ffv1_encoder = {
1138
    "ffv1",
1139
    CODEC_TYPE_VIDEO,
1140
    CODEC_ID_FFV1,
1141
    sizeof(FFV1Context),
1142
    encode_init,
1143
    encode_frame,
1144
    common_end,
1145
    .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},
1146
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1147
};
1148
#endif