Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ 9eda2f94

History | View | Annotate | Download (29.9 KB)

1 5e20f836 Michael Niedermayer
/*
2
 * FFV1 codec for libavcodec
3
 *
4
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 *
20
 */
21
 
22
/**
23
 * @file ffv1.c
24 dc7cb06a Dan Christiansen
 * FF Video Codec 1 (an experimental lossless codec)
25 5e20f836 Michael Niedermayer
 */
26
27
#include "common.h"
28
#include "avcodec.h"
29
#include "dsputil.h"
30
#include "cabac.h"
31 11e659c2 Michael Niedermayer
#include "golomb.h"
32 5e20f836 Michael Niedermayer
33
#define MAX_PLANES 4
34 c2f1b2cb Michael Niedermayer
#define CONTEXT_SIZE 32
35
36 11e659c2 Michael Niedermayer
static const int8_t quant3[256]={
37
 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
38
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
39
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
40
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
41
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
42
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
43 5e20f836 Michael Niedermayer
 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 11e659c2 Michael Niedermayer
-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, 0,
53
};
54
static const int8_t quant5[256]={
55
 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
56 5e20f836 Michael Niedermayer
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
57 11e659c2 Michael Niedermayer
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
58
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
59
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
60
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
61
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
62
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
63
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
64
-2,-2,-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,-1,-1,-1,
71
};
72
static const int8_t quant7[256]={
73
 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
74
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
75
 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
76
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
77
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
78
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
79
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
80
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
81
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
82
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
83
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
84
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
85
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
86
-3,-3,-3,-3,-3,-3,-3,-3,-3,-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,-1,-1,
89
};
90
static const int8_t quant9[256]={
91
 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
92
 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
93
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
94
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
95
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
96
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
97
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
98
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
99
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
100
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
101
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
102
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
103
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
104
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
105
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
106
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
107
};
108
static const int8_t quant11[256]={
109
 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
110
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
111
 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
112
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
113
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
114
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
115
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
116
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
117
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
118
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
119
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
120
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
121
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
122
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-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,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
125
};
126
static const int8_t quant13[256]={
127
 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
128
 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
129
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
130
 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
131
 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
132
 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
133
 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
134
 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
135
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
136
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
137
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
138
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
139
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
140
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
141
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
142
-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
143
};
144 5e20f836 Michael Niedermayer
145 11e659c2 Michael Niedermayer
static const uint8_t log2_run[32]={
146
 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 
147
 4, 4, 5, 5, 6, 6, 7, 7, 
148
 8, 9,10,11,12,13,14,15,
149 5e20f836 Michael Niedermayer
};
150
151 11e659c2 Michael Niedermayer
typedef struct VlcState{
152
    int16_t drift;
153
    uint16_t error_sum;
154
    int8_t bias;
155
    uint8_t count;
156
} VlcState;
157
158 5e20f836 Michael Niedermayer
typedef struct PlaneContext{
159
    int context_count;
160 c2f1b2cb Michael Niedermayer
    uint8_t (*state)[CONTEXT_SIZE];
161 11e659c2 Michael Niedermayer
    VlcState *vlc_state;
162 5e20f836 Michael Niedermayer
    uint8_t interlace_bit_state[2];
163
} PlaneContext;
164
165
typedef struct FFV1Context{
166
    AVCodecContext *avctx;
167
    CABACContext c;
168 11e659c2 Michael Niedermayer
    GetBitContext gb;
169
    PutBitContext pb;
170 5e20f836 Michael Niedermayer
    int version;
171
    int width, height;
172
    int chroma_h_shift, chroma_v_shift;
173
    int flags;
174
    int picture_number;
175
    AVFrame picture;
176
    int plane_count;
177 11e659c2 Michael Niedermayer
    int ac;                              ///< 1-> CABAC 0-> golomb rice
178 5e20f836 Michael Niedermayer
    PlaneContext plane[MAX_PLANES];
179 11e659c2 Michael Niedermayer
    int16_t quant_table[5][256];
180 2cbb7820 Michael Niedermayer
    int run_index;
181
    int colorspace;
182 5e20f836 Michael Niedermayer
    
183
    DSPContext dsp; 
184
}FFV1Context;
185
186 2cbb7820 Michael Niedermayer
static always_inline int fold(int diff, int bits){
187
    if(bits==8)
188
        diff= (int8_t)diff;
189
    else{
190
        diff+= 1<<(bits-1);
191
        diff&=(1<<bits)-1;
192
        diff-= 1<<(bits-1);
193
    }
194
195
    return diff;
196
}
197
198
static inline int predict(int_fast16_t *src, int_fast16_t *last){
199 11e659c2 Michael Niedermayer
    const int LT= last[-1];
200
    const int  T= last[ 0];
201
    const int L =  src[-1];
202 5e20f836 Michael Niedermayer
203 25bd2349 Michael Niedermayer
    return mid_pred(L, L + T - LT, T);
204 5e20f836 Michael Niedermayer
}
205
206 2cbb7820 Michael Niedermayer
static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
207 11e659c2 Michael Niedermayer
    const int LT= last[-1];
208
    const int  T= last[ 0];
209
    const int RT= last[ 1];
210
    const int L =  src[-1];
211
212
    if(f->quant_table[3][127]){
213
        const int TT= last2[0];
214
        const int LL=  src[-2];
215
        return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
216
              +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
217
    }else
218
        return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
219 5e20f836 Michael Niedermayer
}
220 c2f1b2cb Michael Niedermayer
221 5e20f836 Michael Niedermayer
/**
222
 * put 
223
 */
224 085565f7 Michael Niedermayer
static inline void put_symbol(CABACContext *c, uint8_t *state, int v, int is_signed, int max_exp){
225 5e20f836 Michael Niedermayer
    int i;
226
227
    if(v){
228
        const int a= ABS(v);
229
        const int e= av_log2(a);
230
231
        put_cabac(c, state+0, 0);
232 085565f7 Michael Niedermayer
        
233
        for(i=0; i<e; i++){
234
            put_cabac(c, state+1+i, 1);  //1..8
235
        }
236
237
        if(e<max_exp){
238
            put_cabac(c, state+1+i, 0);      //1..8
239
240 5e20f836 Michael Niedermayer
            for(i=e-1; i>=0; i--){
241 085565f7 Michael Niedermayer
                put_cabac(c, state+16+e+i, (a>>i)&1); //17..29
242 5e20f836 Michael Niedermayer
            }
243
            if(is_signed)
244 085565f7 Michael Niedermayer
                put_cabac(c, state+9 + e, v < 0); //9..16
245 5e20f836 Michael Niedermayer
        }
246
    }else{
247
        put_cabac(c, state+0, 1);
248
    }
249
}
250
251 085565f7 Michael Niedermayer
static inline int get_symbol(CABACContext *c, uint8_t *state, int is_signed, int max_exp){
252 5e20f836 Michael Niedermayer
    if(get_cabac(c, state+0))
253
        return 0;
254
    else{
255 085565f7 Michael Niedermayer
        int i, e;
256
 
257
        for(e=0; e<max_exp; e++){ 
258 5e20f836 Michael Niedermayer
            int a= 1<<e;
259
260 085565f7 Michael Niedermayer
            if(get_cabac(c, state + 1 + e)==0){ // 1..8
261
                for(i=e-1; i>=0; i--){
262
                    a += get_cabac(c, state+16+e+i)<<i; //17..29
263
                }
264 5e20f836 Michael Niedermayer
265 085565f7 Michael Niedermayer
                if(is_signed && get_cabac(c, state+9 + e)) //9..16
266
                    return -a;
267
                else
268
                    return a;
269
            }
270
        }
271
        return -(1<<e);
272 5e20f836 Michael Niedermayer
    }
273
}
274 11e659c2 Michael Niedermayer
275
static inline void update_vlc_state(VlcState * const state, const int v){
276
    int drift= state->drift;
277
    int count= state->count;
278
    state->error_sum += ABS(v);
279
    drift += v;
280
281
    if(count == 128){ //FIXME variable
282
        count >>= 1;
283
        drift >>= 1;
284
        state->error_sum >>= 1;
285
    }
286
    count++;
287
288
    if(drift <= -count){
289
        if(state->bias > -128) state->bias--;
290
        
291
        drift += count;
292
        if(drift <= -count)
293
            drift= -count + 1;
294
    }else if(drift > 0){
295
        if(state->bias <  127) state->bias++;
296
        
297
        drift -= count;
298
        if(drift > 0) 
299
            drift= 0;
300
    }
301
302
    state->drift= drift;
303
    state->count= count;
304
}
305
306 2cbb7820 Michael Niedermayer
static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
307 11e659c2 Michael Niedermayer
    int i, k, code;
308
//printf("final: %d ", v);
309 2cbb7820 Michael Niedermayer
    v = fold(v - state->bias, bits);
310
311 11e659c2 Michael Niedermayer
    i= state->count;
312
    k=0;
313
    while(i < state->error_sum){ //FIXME optimize
314
        k++;
315
        i += i;
316
    }
317 d9e6a6c6 Michael Niedermayer
318
    assert(k<=8);
319
320 11e659c2 Michael Niedermayer
#if 0 // JPEG LS
321
    if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
322
    else                                         code= v;
323
#else
324
     code= v ^ ((2*state->drift + state->count)>>31);
325
#endif
326
    
327
    code = -2*code-1;
328
    code^= (code>>31);
329
//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);
330 2cbb7820 Michael Niedermayer
    set_ur_golomb(pb, code, k, 12, bits);
331 11e659c2 Michael Niedermayer
332
    update_vlc_state(state, v);
333
}
334
335 2cbb7820 Michael Niedermayer
static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
336 11e659c2 Michael Niedermayer
    int k, i, v, ret;
337
338
    i= state->count;
339
    k=0;
340
    while(i < state->error_sum){ //FIXME optimize
341
        k++;
342
        i += i;
343
    }
344 d9e6a6c6 Michael Niedermayer
345
    assert(k<=8);
346
347 2cbb7820 Michael Niedermayer
    v= get_ur_golomb(gb, k, 12, bits);
348 11e659c2 Michael Niedermayer
//printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
349 d9e6a6c6 Michael Niedermayer
350 11e659c2 Michael Niedermayer
    v++;
351
    if(v&1) v=  (v>>1);
352
    else    v= -(v>>1);
353
354
#if 0 // JPEG LS
355
    if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
356
#else
357
     v ^= ((2*state->drift + state->count)>>31);
358 5e20f836 Michael Niedermayer
#endif
359
360 2cbb7820 Michael Niedermayer
    ret= fold(v + state->bias, bits);
361 11e659c2 Michael Niedermayer
    
362
    update_vlc_state(state, v);
363
//printf("final: %d\n", ret);
364
    return ret;
365
}
366
367 598401ce Michael Niedermayer
static inline void encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
368 2cbb7820 Michael Niedermayer
    PlaneContext * const p= &s->plane[plane_index];
369
    CABACContext * const c= &s->c;
370
    int x;
371
    int run_index= s->run_index;
372
    int run_count=0;
373
    int run_mode=0;
374
375
    for(x=0; x<w; x++){
376
        int diff, context;
377
        
378 c172913a Michael Niedermayer
        context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
379
        diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
380 11e659c2 Michael Niedermayer
381 2cbb7820 Michael Niedermayer
        if(context < 0){
382
            context = -context;
383
            diff= -diff;
384
        }
385
386
        diff= fold(diff, bits);
387
        
388
        if(s->ac){
389
            put_symbol(c, p->state[context], diff, 1, bits-1);
390
        }else{
391
            if(context == 0) run_mode=1;
392
            
393
            if(run_mode){
394
395
                if(diff){
396
                    while(run_count >= 1<<log2_run[run_index]){
397
                        run_count -= 1<<log2_run[run_index];
398
                        run_index++;
399
                        put_bits(&s->pb, 1, 1);
400
                    }
401
                    
402
                    put_bits(&s->pb, 1 + log2_run[run_index], run_count);
403
                    if(run_index) run_index--;
404
                    run_count=0;
405
                    run_mode=0;
406
                    if(diff>0) diff--;
407
                }else{
408
                    run_count++;
409
                }
410
            }
411
            
412 fe455f33 Alex Beregszaszi
//            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));
413 2cbb7820 Michael Niedermayer
414
            if(run_mode == 0)
415
                put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
416
        }
417
    }
418
    if(run_mode){
419
        while(run_count >= 1<<log2_run[run_index]){
420
            run_count -= 1<<log2_run[run_index];
421
            run_index++;
422
            put_bits(&s->pb, 1, 1);
423
        }
424
425
        if(run_count)
426
            put_bits(&s->pb, 1, 1);
427
    }
428
    s->run_index= run_index;
429
}
430 11e659c2 Michael Niedermayer
431 5e20f836 Michael Niedermayer
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
432 c172913a Michael Niedermayer
    int x,y,i;
433
    const int ring_size=2;
434
    int_fast16_t sample_buffer[ring_size][w+6], *sample[ring_size];
435 2cbb7820 Michael Niedermayer
    s->run_index=0;
436 5e20f836 Michael Niedermayer
    
437 d9ced4ca Michael Niedermayer
    memset(sample_buffer, 0, sizeof(sample_buffer));
438 5e20f836 Michael Niedermayer
    
439
    for(y=0; y<h; y++){
440 c172913a Michael Niedermayer
        for(i=0; i<ring_size; i++)
441
            sample[i]= sample_buffer[(h+i-y)%ring_size]+3;
442 11e659c2 Michael Niedermayer
        
443 c172913a Michael Niedermayer
        sample[0][-1]= sample[1][0  ];
444
        sample[1][ w]= sample[1][w-1];
445 2cbb7820 Michael Niedermayer
//{START_TIMER
446
        for(x=0; x<w; x++){
447 c172913a Michael Niedermayer
            sample[0][x]= src[x + stride*y];
448 2cbb7820 Michael Niedermayer
        }
449
        encode_line(s, w, sample, plane_index, 8);
450
//STOP_TIMER("encode line")}
451
    }
452
}
453 5e20f836 Michael Niedermayer
454 2cbb7820 Michael Niedermayer
static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
455 c172913a Michael Niedermayer
    int x, y, p, i;
456
    const int ring_size=2;
457
    int_fast16_t sample_buffer[3][ring_size][w+6], *sample[3][ring_size];
458 2cbb7820 Michael Niedermayer
    s->run_index=0;
459
    
460
    memset(sample_buffer, 0, sizeof(sample_buffer));
461
    
462
    for(y=0; y<h; y++){
463 c172913a Michael Niedermayer
        for(i=0; i<ring_size; i++)
464
            for(p=0; p<3; p++)
465
                sample[p][i]= sample_buffer[p][(h+i-y)%ring_size]+3;
466
467 5e20f836 Michael Niedermayer
        for(x=0; x<w; x++){
468 2cbb7820 Michael Niedermayer
            int v= src[x + stride*y];
469
            int b= v&0xFF;
470
            int g= (v>>8)&0xFF;
471
            int r= (v>>16)&0xFF;
472 5e20f836 Michael Niedermayer
            
473 2cbb7820 Michael Niedermayer
            b -= g;
474
            r -= g;
475
            g += (b + r)>>2;
476
            b += 0x100;
477
            r += 0x100;
478
            
479
//            assert(g>=0 && b>=0 && r>=0);
480
//            assert(g<256 && b<512 && r<512);
481
            sample[0][0][x]= g;
482
            sample[1][0][x]= b;
483
            sample[2][0][x]= r;
484 11e659c2 Michael Niedermayer
        }
485 2cbb7820 Michael Niedermayer
        for(p=0; p<3; p++){
486 c172913a Michael Niedermayer
            sample[p][0][-1]= sample[p][1][0  ];
487
            sample[p][1][ w]= sample[p][1][w-1];
488 2cbb7820 Michael Niedermayer
            encode_line(s, w, sample[p], FFMIN(p, 1), 9);
489 5e20f836 Michael Niedermayer
        }
490
    }
491
}
492
493 11e659c2 Michael Niedermayer
static void write_quant_table(CABACContext *c, int16_t *quant_table){
494 5e20f836 Michael Niedermayer
    int last=0;
495
    int i;
496 c2f1b2cb Michael Niedermayer
    uint8_t state[CONTEXT_SIZE]={0};
497 5e20f836 Michael Niedermayer
498 11e659c2 Michael Niedermayer
    for(i=1; i<128 ; i++){
499 5e20f836 Michael Niedermayer
        if(quant_table[i] != quant_table[i-1]){
500 085565f7 Michael Niedermayer
            put_symbol(c, state, i-last-1, 0, 7);
501 5e20f836 Michael Niedermayer
            last= i;
502
        }
503
    }
504 085565f7 Michael Niedermayer
    put_symbol(c, state, i-last-1, 0, 7);
505 5e20f836 Michael Niedermayer
}
506
507
static void write_header(FFV1Context *f){
508 c2f1b2cb Michael Niedermayer
    uint8_t state[CONTEXT_SIZE]={0};
509 5e20f836 Michael Niedermayer
    int i;
510
    CABACContext * const c= &f->c;
511
512 085565f7 Michael Niedermayer
    put_symbol(c, state, f->version, 0, 7);
513
    put_symbol(c, state, f->avctx->coder_type, 0, 7);
514 2cbb7820 Michael Niedermayer
    put_symbol(c, state, f->colorspace, 0, 7); //YUV cs type 
515 5e20f836 Michael Niedermayer
    put_cabac(c, state, 1); //chroma planes
516 085565f7 Michael Niedermayer
        put_symbol(c, state, f->chroma_h_shift, 0, 7);
517
        put_symbol(c, state, f->chroma_v_shift, 0, 7);
518 5e20f836 Michael Niedermayer
    put_cabac(c, state, 0); //no transparency plane
519
520 11e659c2 Michael Niedermayer
    for(i=0; i<5; i++)
521
        write_quant_table(c, f->quant_table[i]);
522 5e20f836 Michael Niedermayer
}
523
524
static int common_init(AVCodecContext *avctx){
525
    FFV1Context *s = avctx->priv_data;
526 c2f1b2cb Michael Niedermayer
    int width, height;
527 5e20f836 Michael Niedermayer
528
    s->avctx= avctx;
529
    s->flags= avctx->flags;
530
        
531
    dsputil_init(&s->dsp, avctx);
532
    
533
    width= s->width= avctx->width;
534
    height= s->height= avctx->height;
535
    
536
    assert(width && height);
537
538
    return 0;
539
}
540
541
static int encode_init(AVCodecContext *avctx)
542
{
543
    FFV1Context *s = avctx->priv_data;
544
    int i;
545
546
    common_init(avctx);
547
 
548
    s->version=0;
549 11e659c2 Michael Niedermayer
    s->ac= avctx->coder_type;
550 5e20f836 Michael Niedermayer
    
551 27fc5352 Michael Niedermayer
    s->plane_count=2;
552 11e659c2 Michael Niedermayer
    for(i=0; i<256; i++){
553
        s->quant_table[0][i]=           quant11[i];
554
        s->quant_table[1][i]=        11*quant11[i];
555
        if(avctx->context_model==0){
556
            s->quant_table[2][i]=     11*11*quant11[i];
557
            s->quant_table[3][i]=
558
            s->quant_table[4][i]=0;
559
        }else{
560
            s->quant_table[2][i]=     11*11*quant5 [i];
561
            s->quant_table[3][i]=   5*11*11*quant5 [i];
562
            s->quant_table[4][i]= 5*5*11*11*quant5 [i];
563
        }
564
    }
565 5e20f836 Michael Niedermayer
566
    for(i=0; i<s->plane_count; i++){
567
        PlaneContext * const p= &s->plane[i];
568 11e659c2 Michael Niedermayer
               
569
        if(avctx->context_model==0){
570
            p->context_count= (11*11*11+1)/2;
571
        }else{        
572
            p->context_count= (11*11*5*5*5+1)/2;
573
        }
574
575
        if(s->ac){
576
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
577
        }else{
578
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
579
        }
580 5e20f836 Michael Niedermayer
    }
581
582
    avctx->coded_frame= &s->picture;
583
    switch(avctx->pix_fmt){
584
    case PIX_FMT_YUV444P:
585
    case PIX_FMT_YUV422P:
586
    case PIX_FMT_YUV420P:
587
    case PIX_FMT_YUV411P:
588
    case PIX_FMT_YUV410P:
589 2cbb7820 Michael Niedermayer
        s->colorspace= 0;
590
        break;
591
    case PIX_FMT_RGBA32:
592
        s->colorspace= 1;
593 5e20f836 Michael Niedermayer
        break;
594
    default:
595 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
596 5e20f836 Michael Niedermayer
        return -1;
597
    }
598 2cbb7820 Michael Niedermayer
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
599
600 5e20f836 Michael Niedermayer
    s->picture_number=0;
601
    
602
    return 0;
603
}
604
605
606
static void clear_state(FFV1Context *f){
607 c2f1b2cb Michael Niedermayer
    int i, j;
608 5e20f836 Michael Niedermayer
609
    for(i=0; i<f->plane_count; i++){
610
        PlaneContext *p= &f->plane[i];
611
612
        p->interlace_bit_state[0]= 0;
613
        p->interlace_bit_state[1]= 0;
614
        
615 c2f1b2cb Michael Niedermayer
        for(j=0; j<p->context_count; j++){
616 11e659c2 Michael Niedermayer
            if(f->ac){
617
                memset(p->state[j], 0, sizeof(uint8_t)*CONTEXT_SIZE);
618
                p->state[j][7] = 2*62;
619
            }else{
620
                p->vlc_state[j].drift= 0;
621
                p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
622
                p->vlc_state[j].bias= 0;
623
                p->vlc_state[j].count= 1;
624
            }
625 c2f1b2cb Michael Niedermayer
        }
626 5e20f836 Michael Niedermayer
    }
627
}
628
629
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
630
    FFV1Context *f = avctx->priv_data;
631
    CABACContext * const c= &f->c;
632
    AVFrame *pict = data;
633
    const int width= f->width;
634
    const int height= f->height;
635
    AVFrame * const p= &f->picture;
636 11e659c2 Michael Niedermayer
    int used_count= 0;
637 5e20f836 Michael Niedermayer
638
    if(avctx->strict_std_compliance >= 0){
639 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "this codec is under development, files encoded with it wont be decodeable with future versions!!!\n"
640 5e20f836 Michael Niedermayer
               "use vstrict=-1 to use it anyway\n");
641
        return -1;
642
    }
643
        
644
    ff_init_cabac_encoder(c, buf, buf_size);
645
    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
646 e5017ab8 Laurent Aimar
    c->lps_state[2] = 1;
647
    c->lps_state[3] = 0;
648 5e20f836 Michael Niedermayer
    
649
    *p = *pict;
650
    p->pict_type= FF_I_TYPE;
651
    
652
    if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
653
        put_cabac_bypass(c, 1);
654
        p->key_frame= 1;
655
        write_header(f);
656
        clear_state(f);
657
    }else{
658
        put_cabac_bypass(c, 0);
659
        p->key_frame= 0;
660
    }
661
662 11e659c2 Michael Niedermayer
    if(!f->ac){
663
        used_count += put_cabac_terminate(c, 1);
664
//printf("pos=%d\n", used_count);
665 ed7debda Alex Beregszaszi
        init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
666 11e659c2 Michael Niedermayer
    }
667
    
668 2cbb7820 Michael Niedermayer
    if(f->colorspace==0){
669 5e20f836 Michael Niedermayer
        const int chroma_width = -((-width )>>f->chroma_h_shift);
670
        const int chroma_height= -((-height)>>f->chroma_v_shift);
671
672
        encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
673
674
        encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
675 27fc5352 Michael Niedermayer
        encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
676 2cbb7820 Michael Niedermayer
    }else{
677
        encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
678 5e20f836 Michael Niedermayer
    }
679
    emms_c();
680
    
681
    f->picture_number++;
682
683 11e659c2 Michael Niedermayer
    if(f->ac){
684
        return put_cabac_terminate(c, 1);
685
    }else{
686
        flush_put_bits(&f->pb); //nicer padding FIXME
687 fe455f33 Alex Beregszaszi
        return used_count + (put_bits_count(&f->pb)+7)/8;
688 11e659c2 Michael Niedermayer
    }
689 5e20f836 Michael Niedermayer
}
690
691
static void common_end(FFV1Context *s){
692
    int i; 
693
694
    for(i=0; i<s->plane_count; i++){
695
        PlaneContext *p= &s->plane[i];
696
697
        av_freep(&p->state);
698
    }
699
}
700
701
static int encode_end(AVCodecContext *avctx)
702
{
703
    FFV1Context *s = avctx->priv_data;
704
705
    common_end(s);
706
707
    return 0;
708
}
709
710 598401ce Michael Niedermayer
static inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
711 5e20f836 Michael Niedermayer
    PlaneContext * const p= &s->plane[plane_index];
712
    CABACContext * const c= &s->c;
713 2cbb7820 Michael Niedermayer
    int x;
714
    int run_count=0;
715
    int run_mode=0;
716
    int run_index= s->run_index;
717
718
    for(x=0; x<w; x++){
719
        int diff, context, sign;
720
         
721
        context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
722
        if(context < 0){
723
            context= -context;
724
            sign=1;
725
        }else
726
            sign=0;
727
        
728
729
        if(s->ac)
730
            diff= get_symbol(c, p->state[context], 1, bits-1);
731
        else{
732
            if(context == 0 && run_mode==0) run_mode=1;
733
            
734
            if(run_mode){
735
                if(run_count==0 && run_mode==1){
736
                    if(get_bits1(&s->gb)){
737
                        run_count = 1<<log2_run[run_index];
738
                        if(x + run_count <= w) run_index++;
739
                    }else{
740
                        if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
741
                        else run_count=0;
742
                        if(run_index) run_index--;
743
                        run_mode=2;
744
                    }
745
                }
746
                run_count--;
747
                if(run_count < 0){
748
                    run_mode=0;
749
                    run_count=0;
750
                    diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
751
                    if(diff>=0) diff++;
752
                }else
753
                    diff=0;
754
            }else
755
                diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
756
            
757
//            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));
758
        }
759
760
        if(sign) diff= -diff;
761
762
        sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
763
    }
764
    s->run_index= run_index;        
765
}
766
767
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
768
    int x, y;
769
    int_fast16_t sample_buffer[2][w+6];
770
    int_fast16_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
771
772
    s->run_index=0;
773 5e20f836 Michael Niedermayer
    
774 d9ced4ca Michael Niedermayer
    memset(sample_buffer, 0, sizeof(sample_buffer));
775 5e20f836 Michael Niedermayer
    
776
    for(y=0; y<h; y++){
777 2cbb7820 Michael Niedermayer
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
778 5e20f836 Michael Niedermayer
779 d9ced4ca Michael Niedermayer
        sample[0]= sample[1];
780
        sample[1]= temp;
781 5e20f836 Michael Niedermayer
782 d9ced4ca Michael Niedermayer
        sample[1][-1]= sample[0][0  ];
783
        sample[0][ w]= sample[0][w-1];
784 2cbb7820 Michael Niedermayer
        
785
//{START_TIMER
786
        decode_line(s, w, sample, plane_index, 8);
787 5e20f836 Michael Niedermayer
        for(x=0; x<w; x++){
788 2cbb7820 Michael Niedermayer
            src[x + stride*y]= sample[1][x];
789
        }
790
//STOP_TIMER("decode-line")}
791
    }
792
}
793 5e20f836 Michael Niedermayer
794 2cbb7820 Michael Niedermayer
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
795
    int x, y, p;
796
    int_fast16_t sample_buffer[3][2][w+6];
797
    int_fast16_t *sample[3][2]= {
798
        {sample_buffer[0][0]+3, sample_buffer[0][1]+3},
799
        {sample_buffer[1][0]+3, sample_buffer[1][1]+3},
800
        {sample_buffer[2][0]+3, sample_buffer[2][1]+3}};
801
802
    s->run_index=0;
803
    
804
    memset(sample_buffer, 0, sizeof(sample_buffer));
805
    
806
    for(y=0; y<h; y++){
807
        for(p=0; p<3; p++){
808
            int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
809
810
            sample[p][0]= sample[p][1];
811
            sample[p][1]= temp;
812 5e20f836 Michael Niedermayer
813 2cbb7820 Michael Niedermayer
            sample[p][1][-1]= sample[p][0][0  ];
814
            sample[p][0][ w]= sample[p][0][w-1];
815
            decode_line(s, w, sample[p], FFMIN(p, 1), 9);
816
        }
817
        for(x=0; x<w; x++){
818
            int g= sample[0][1][x];
819
            int b= sample[1][1][x];
820
            int r= sample[2][1][x];
821 11e659c2 Michael Niedermayer
822 2cbb7820 Michael Niedermayer
//            assert(g>=0 && b>=0 && r>=0);
823
//            assert(g<256 && b<512 && r<512);
824 5e20f836 Michael Niedermayer
            
825 2cbb7820 Michael Niedermayer
            b -= 0x100;
826
            r -= 0x100;
827
            g -= (b + r)>>2;
828
            b += g;
829
            r += g;
830
            
831
            src[x + stride*y]= b + (g<<8) + (r<<16);
832 5e20f836 Michael Niedermayer
        }
833
    }
834
}
835
836 11e659c2 Michael Niedermayer
static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){
837 5e20f836 Michael Niedermayer
    int v;
838
    int i=0;
839 c2f1b2cb Michael Niedermayer
    uint8_t state[CONTEXT_SIZE]={0};
840 5e20f836 Michael Niedermayer
841 11e659c2 Michael Niedermayer
    for(v=0; i<128 ; v++){
842 085565f7 Michael Niedermayer
        int len= get_symbol(c, state, 0, 7) + 1;
843 5e20f836 Michael Niedermayer
844 11e659c2 Michael Niedermayer
        if(len + i > 128) return -1;
845 5e20f836 Michael Niedermayer
        
846
        while(len--){
847 11e659c2 Michael Niedermayer
            quant_table[i] = scale*v;
848
            i++;
849 5e20f836 Michael Niedermayer
//printf("%2d ",v);
850
//if(i%16==0) printf("\n");
851
        }
852
    }
853 11e659c2 Michael Niedermayer
854
    for(i=1; i<128; i++){
855
        quant_table[256-i]= -quant_table[i];
856
    }
857
    quant_table[128]= -quant_table[127];
858 5e20f836 Michael Niedermayer
    
859 11e659c2 Michael Niedermayer
    return 2*v - 1;
860 5e20f836 Michael Niedermayer
}
861
862
static int read_header(FFV1Context *f){
863 c2f1b2cb Michael Niedermayer
    uint8_t state[CONTEXT_SIZE]={0};
864 11e659c2 Michael Niedermayer
    int i, context_count;
865 5e20f836 Michael Niedermayer
    CABACContext * const c= &f->c;
866
    
867 085565f7 Michael Niedermayer
    f->version= get_symbol(c, state, 0, 7);
868
    f->ac= f->avctx->coder_type= get_symbol(c, state, 0, 7);
869 2cbb7820 Michael Niedermayer
    f->colorspace= get_symbol(c, state, 0, 7); //YUV cs type
870 5e20f836 Michael Niedermayer
    get_cabac(c, state); //no chroma = false
871 085565f7 Michael Niedermayer
    f->chroma_h_shift= get_symbol(c, state, 0, 7);
872
    f->chroma_v_shift= get_symbol(c, state, 0, 7);
873 5e20f836 Michael Niedermayer
    get_cabac(c, state); //transparency plane
874 27fc5352 Michael Niedermayer
    f->plane_count= 2;
875 085565f7 Michael Niedermayer
876 2cbb7820 Michael Niedermayer
    if(f->colorspace==0){
877
        switch(16*f->chroma_h_shift + f->chroma_v_shift){
878
        case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
879
        case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
880
        case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
881
        case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
882
        case 0x33: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
883
        default:
884 9b879566 Michel Bardiaux
            av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
885 2cbb7820 Michael Niedermayer
            return -1;
886
        }
887
    }else if(f->colorspace==1){
888
        if(f->chroma_h_shift || f->chroma_v_shift){
889 9b879566 Michel Bardiaux
            av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
890 2cbb7820 Michael Niedermayer
            return -1;
891
        }
892
        f->avctx->pix_fmt= PIX_FMT_RGBA32;
893
    }else{
894 9b879566 Michel Bardiaux
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
895 085565f7 Michael Niedermayer
        return -1;
896
    }
897 2cbb7820 Michael Niedermayer
898 085565f7 Michael Niedermayer
//printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
899
900 11e659c2 Michael Niedermayer
    context_count=1;
901
    for(i=0; i<5; i++){
902
        context_count*= read_quant_table(c, f->quant_table[i], context_count);
903 085565f7 Michael Niedermayer
        if(context_count < 0){
904 9b879566 Michel Bardiaux
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
905 085565f7 Michael Niedermayer
            return -1;
906
        }
907 11e659c2 Michael Niedermayer
    }
908
    context_count= (context_count+1)/2;
909
    
910 5e20f836 Michael Niedermayer
    for(i=0; i<f->plane_count; i++){
911
        PlaneContext * const p= &f->plane[i];
912
913 11e659c2 Michael Niedermayer
        p->context_count= context_count;
914
915
        if(f->ac){
916
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
917
        }else{
918
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
919
        }
920 5e20f836 Michael Niedermayer
    }
921
    
922
    return 0;
923
}
924
925
static int decode_init(AVCodecContext *avctx)
926
{
927 11e659c2 Michael Niedermayer
//    FFV1Context *s = avctx->priv_data;
928 5e20f836 Michael Niedermayer
929
    common_init(avctx);
930
    
931
    return 0;
932
}
933
934
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
935
    FFV1Context *f = avctx->priv_data;
936
    CABACContext * const c= &f->c;
937
    const int width= f->width;
938
    const int height= f->height;
939
    AVFrame * const p= &f->picture;
940
    int bytes_read;
941
942
    AVFrame *picture = data;
943
944
    /* no supplementary picture */
945
    if (buf_size == 0)
946
        return 0;
947
948
    ff_init_cabac_decoder(c, buf, buf_size);
949
    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
950 e5017ab8 Laurent Aimar
    c->lps_state[2] = 1;
951
    c->lps_state[3] = 0;
952
953 5e20f836 Michael Niedermayer
954
    p->pict_type= FF_I_TYPE; //FIXME I vs. P
955
    if(get_cabac_bypass(c)){
956
        p->key_frame= 1;
957
        read_header(f);
958
        clear_state(f);
959
    }else{
960
        p->key_frame= 0;
961
    }
962 085565f7 Michael Niedermayer
963
    p->reference= 0;
964
    if(avctx->get_buffer(avctx, p) < 0){
965 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
966 085565f7 Michael Niedermayer
        return -1;
967
    }
968
969 5e20f836 Michael Niedermayer
    if(avctx->debug&FF_DEBUG_PICT_INFO)
970 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
971 5e20f836 Michael Niedermayer
    
972 11e659c2 Michael Niedermayer
    if(!f->ac){
973
        bytes_read = get_cabac_terminate(c);
974 9b879566 Michel Bardiaux
        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n");
975 11e659c2 Michael Niedermayer
//printf("pos=%d\n", bytes_read);
976
        init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
977 1df1df0b Fabrice Bellard
    } else {
978
        bytes_read = 0; /* avoid warning */
979 11e659c2 Michael Niedermayer
    }
980 5e20f836 Michael Niedermayer
    
981 2cbb7820 Michael Niedermayer
    if(f->colorspace==0){
982 5e20f836 Michael Niedermayer
        const int chroma_width = -((-width )>>f->chroma_h_shift);
983
        const int chroma_height= -((-height)>>f->chroma_v_shift);
984
        decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
985
        
986
        decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
987 27fc5352 Michael Niedermayer
        decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
988 2cbb7820 Michael Niedermayer
    }else{
989
        decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
990 5e20f836 Michael Niedermayer
    }
991
        
992
    emms_c();
993
994
    f->picture_number++;
995
996
    *picture= *p;
997
    
998
    avctx->release_buffer(avctx, p); //FIXME
999
1000
    *data_size = sizeof(AVFrame);
1001
    
1002 11e659c2 Michael Niedermayer
    if(f->ac){
1003
        bytes_read= get_cabac_terminate(c);
1004 9b879566 Michel Bardiaux
        if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1005 11e659c2 Michael Niedermayer
    }else{
1006
        bytes_read+= (get_bits_count(&f->gb)+7)/8;
1007
    }
1008
1009 5e20f836 Michael Niedermayer
    return bytes_read;
1010
}
1011
1012
AVCodec ffv1_decoder = {
1013
    "ffv1",
1014
    CODEC_TYPE_VIDEO,
1015
    CODEC_ID_FFV1,
1016
    sizeof(FFV1Context),
1017
    decode_init,
1018
    NULL,
1019 eea8c08f Michael Niedermayer
    NULL,
1020 5e20f836 Michael Niedermayer
    decode_frame,
1021 c2f1b2cb Michael Niedermayer
    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1022 5e20f836 Michael Niedermayer
    NULL
1023
};
1024
1025 2a250222 Michael Niedermayer
#ifdef CONFIG_ENCODERS
1026 5e20f836 Michael Niedermayer
AVCodec ffv1_encoder = {
1027
    "ffv1",
1028
    CODEC_TYPE_VIDEO,
1029
    CODEC_ID_FFV1,
1030
    sizeof(FFV1Context),
1031
    encode_init,
1032
    encode_frame,
1033
    encode_end,
1034
};
1035 2a250222 Michael Niedermayer
#endif