Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ 84c1b149

History | View | Annotate | Download (34.8 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 (an experimental 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-> CABAC 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->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){
673
            av_log(avctx, AV_LOG_ERROR, "More than 8 bit per component is still experimental and no gurantee is yet made for future compatibility\n"
674
               "Use vstrict=-2 / -strict -2 to use it anyway.\n");
675
            return -1;
676
        }
677
        if(avctx->bits_per_raw_sample <=8){
678
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
679
            return -1;
680
        }
681
        s->version= 1;
682
    case PIX_FMT_YUV444P:
683
    case PIX_FMT_YUV422P:
684
    case PIX_FMT_YUV420P:
685
    case PIX_FMT_YUV411P:
686
    case PIX_FMT_YUV410P:
687
        s->colorspace= 0;
688
        break;
689
    case PIX_FMT_RGB32:
690
        s->colorspace= 1;
691
        break;
692
    default:
693
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
694
        return -1;
695
    }
696
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
697

    
698
    s->picture_number=0;
699

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

    
704

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

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

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

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

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

    
738
    ff_init_range_encoder(c, buf, buf_size);
739
//    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
740
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
741

    
742
    *p = *pict;
743
    p->pict_type= FF_I_TYPE;
744

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

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

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

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

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

    
774
    f->picture_number++;
775

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

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

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

    
792
        av_freep(&p->state);
793
        av_freep(&p->vlc_state);
794
    }
795

    
796
    return 0;
797
}
798

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

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

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

    
817

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

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

    
846
//            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));
847
        }
848

    
849
        if(sign) diff= -diff;
850

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

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

    
863
    s->run_index=0;
864

    
865
    memset(sample_buffer, 0, sizeof(sample_buffer));
866

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

    
870
        sample[0]= sample[1];
871
        sample[1]= temp;
872

    
873
        sample[1][-1]= sample[0][0  ];
874
        sample[0][ w]= sample[0][w-1];
875

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

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

    
901
    s->run_index=0;
902

    
903
    memset(sample_buffer, 0, sizeof(sample_buffer));
904

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

    
909
            sample[p][0]= sample[p][1];
910
            sample[p][1]= temp;
911

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

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

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

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

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

    
940
    memset(state, 128, sizeof(state));
941

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

    
945
        if(len + i > 128) return -1;
946

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

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

    
960
    return 2*v - 1;
961
}
962

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

    
968
    memset(state, 128, sizeof(state));
969

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

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

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

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

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

    
1029
        p->context_count= context_count;
1030

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

    
1038
    return 0;
1039
}
1040

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

    
1045
    common_init(avctx);
1046

    
1047
    return 0;
1048
}
1049

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

    
1061
    AVFrame *picture = data;
1062

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

    
1066

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

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

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

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

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

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

    
1108
    emms_c();
1109

    
1110
    f->picture_number++;
1111

    
1112
    *picture= *p;
1113

    
1114
    avctx->release_buffer(avctx, p); //FIXME
1115

    
1116
    *data_size = sizeof(AVFrame);
1117

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

    
1125
    return bytes_read;
1126
}
1127

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

    
1142
#if CONFIG_FFV1_ENCODER
1143
AVCodec ffv1_encoder = {
1144
    "ffv1",
1145
    CODEC_TYPE_VIDEO,
1146
    CODEC_ID_FFV1,
1147
    sizeof(FFV1Context),
1148
    encode_init,
1149
    encode_frame,
1150
    common_end,
1151
    .pix_fmts= (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},
1152
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg codec #1"),
1153
};
1154
#endif