Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ fbb89806

History | View | Annotate | Download (30.4 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 598401ce Michael Niedermayer
        context= get_context(s, sample[1]+x, sample[0]+x, sample[2]+x);
379 2cbb7820 Michael Niedermayer
        diff= sample[1][x] - predict(sample[1]+x, sample[0]+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
//            printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, (int)get_bit_count(&s->pb));
413
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
    int x,y;
433 598401ce Michael Niedermayer
    int_fast16_t sample_buffer[3][w+6];
434
    int_fast16_t *sample[3]= {sample_buffer[0]+3, sample_buffer[1]+3, sample_buffer[2]+3};
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 2cbb7820 Michael Niedermayer
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
441 5e20f836 Michael Niedermayer
442 d9ced4ca Michael Niedermayer
        sample[0]= sample[1];
443 598401ce Michael Niedermayer
        sample[1]= sample[2];
444
        sample[2]= temp;
445 11e659c2 Michael Niedermayer
        
446 d9ced4ca Michael Niedermayer
        sample[1][-1]= sample[0][0  ];
447
        sample[0][ w]= sample[0][w-1];
448 2cbb7820 Michael Niedermayer
//{START_TIMER
449
        for(x=0; x<w; x++){
450
            sample[1][x]= src[x + stride*y];
451
        }
452
        encode_line(s, w, sample, plane_index, 8);
453
//STOP_TIMER("encode line")}
454
    }
455
}
456 5e20f836 Michael Niedermayer
457 2cbb7820 Michael Niedermayer
static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
458
    int x, y, p;
459
    int_fast16_t sample_buffer[3][2][w+6];
460
    int_fast16_t *sample[3][2]= {
461
        {sample_buffer[0][0]+3, sample_buffer[0][1]+3},
462
        {sample_buffer[1][0]+3, sample_buffer[1][1]+3},
463
        {sample_buffer[2][0]+3, sample_buffer[2][1]+3}};
464
    s->run_index=0;
465
    
466
    memset(sample_buffer, 0, sizeof(sample_buffer));
467
    
468
    for(y=0; y<h; y++){
469 5e20f836 Michael Niedermayer
        for(x=0; x<w; x++){
470 2cbb7820 Michael Niedermayer
            int v= src[x + stride*y];
471
            int b= v&0xFF;
472
            int g= (v>>8)&0xFF;
473
            int r= (v>>16)&0xFF;
474 5e20f836 Michael Niedermayer
            
475 2cbb7820 Michael Niedermayer
            b -= g;
476
            r -= g;
477
            g += (b + r)>>2;
478
            b += 0x100;
479
            r += 0x100;
480
            
481
//            assert(g>=0 && b>=0 && r>=0);
482
//            assert(g<256 && b<512 && r<512);
483
            sample[0][0][x]= g;
484
            sample[1][0][x]= b;
485
            sample[2][0][x]= r;
486 11e659c2 Michael Niedermayer
        }
487 2cbb7820 Michael Niedermayer
        for(p=0; p<3; p++){
488
            int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
489 c2f1b2cb Michael Niedermayer
490 2cbb7820 Michael Niedermayer
            sample[p][0]= sample[p][1];
491
            sample[p][1]= temp;
492
493
            sample[p][1][-1]= sample[p][0][0  ];
494
            sample[p][0][ w]= sample[p][0][w-1];
495
            encode_line(s, w, sample[p], FFMIN(p, 1), 9);
496 5e20f836 Michael Niedermayer
        }
497
    }
498
}
499
500 11e659c2 Michael Niedermayer
static void write_quant_table(CABACContext *c, int16_t *quant_table){
501 5e20f836 Michael Niedermayer
    int last=0;
502
    int i;
503 c2f1b2cb Michael Niedermayer
    uint8_t state[CONTEXT_SIZE]={0};
504 5e20f836 Michael Niedermayer
505 11e659c2 Michael Niedermayer
    for(i=1; i<128 ; i++){
506 5e20f836 Michael Niedermayer
        if(quant_table[i] != quant_table[i-1]){
507 085565f7 Michael Niedermayer
            put_symbol(c, state, i-last-1, 0, 7);
508 5e20f836 Michael Niedermayer
            last= i;
509
        }
510
    }
511 085565f7 Michael Niedermayer
    put_symbol(c, state, i-last-1, 0, 7);
512 5e20f836 Michael Niedermayer
}
513
514
static void write_header(FFV1Context *f){
515 c2f1b2cb Michael Niedermayer
    uint8_t state[CONTEXT_SIZE]={0};
516 5e20f836 Michael Niedermayer
    int i;
517
    CABACContext * const c= &f->c;
518
519 085565f7 Michael Niedermayer
    put_symbol(c, state, f->version, 0, 7);
520
    put_symbol(c, state, f->avctx->coder_type, 0, 7);
521 2cbb7820 Michael Niedermayer
    put_symbol(c, state, f->colorspace, 0, 7); //YUV cs type 
522 5e20f836 Michael Niedermayer
    put_cabac(c, state, 1); //chroma planes
523 085565f7 Michael Niedermayer
        put_symbol(c, state, f->chroma_h_shift, 0, 7);
524
        put_symbol(c, state, f->chroma_v_shift, 0, 7);
525 5e20f836 Michael Niedermayer
    put_cabac(c, state, 0); //no transparency plane
526
527 11e659c2 Michael Niedermayer
    for(i=0; i<5; i++)
528
        write_quant_table(c, f->quant_table[i]);
529 5e20f836 Michael Niedermayer
}
530
531
static int common_init(AVCodecContext *avctx){
532
    FFV1Context *s = avctx->priv_data;
533 c2f1b2cb Michael Niedermayer
    int width, height;
534 5e20f836 Michael Niedermayer
535
    s->avctx= avctx;
536
    s->flags= avctx->flags;
537
        
538
    dsputil_init(&s->dsp, avctx);
539
    
540
    width= s->width= avctx->width;
541
    height= s->height= avctx->height;
542
    
543
    assert(width && height);
544
545
    return 0;
546
}
547
548
static int encode_init(AVCodecContext *avctx)
549
{
550
    FFV1Context *s = avctx->priv_data;
551
    int i;
552
553
    common_init(avctx);
554
 
555
    s->version=0;
556 11e659c2 Michael Niedermayer
    s->ac= avctx->coder_type;
557 5e20f836 Michael Niedermayer
    
558 27fc5352 Michael Niedermayer
    s->plane_count=2;
559 11e659c2 Michael Niedermayer
    for(i=0; i<256; i++){
560
        s->quant_table[0][i]=           quant11[i];
561
        s->quant_table[1][i]=        11*quant11[i];
562
        if(avctx->context_model==0){
563
            s->quant_table[2][i]=     11*11*quant11[i];
564
            s->quant_table[3][i]=
565
            s->quant_table[4][i]=0;
566
        }else{
567
            s->quant_table[2][i]=     11*11*quant5 [i];
568
            s->quant_table[3][i]=   5*11*11*quant5 [i];
569
            s->quant_table[4][i]= 5*5*11*11*quant5 [i];
570
        }
571
    }
572 5e20f836 Michael Niedermayer
573
    for(i=0; i<s->plane_count; i++){
574
        PlaneContext * const p= &s->plane[i];
575 11e659c2 Michael Niedermayer
               
576
        if(avctx->context_model==0){
577
            p->context_count= (11*11*11+1)/2;
578
        }else{        
579
            p->context_count= (11*11*5*5*5+1)/2;
580
        }
581
582
        if(s->ac){
583
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
584
        }else{
585
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
586
        }
587 5e20f836 Michael Niedermayer
    }
588
589
    avctx->coded_frame= &s->picture;
590
    switch(avctx->pix_fmt){
591
    case PIX_FMT_YUV444P:
592
    case PIX_FMT_YUV422P:
593
    case PIX_FMT_YUV420P:
594
    case PIX_FMT_YUV411P:
595
    case PIX_FMT_YUV410P:
596 2cbb7820 Michael Niedermayer
        s->colorspace= 0;
597
        break;
598
    case PIX_FMT_RGBA32:
599
        s->colorspace= 1;
600 5e20f836 Michael Niedermayer
        break;
601
    default:
602 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
603 5e20f836 Michael Niedermayer
        return -1;
604
    }
605 2cbb7820 Michael Niedermayer
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
606
607 5e20f836 Michael Niedermayer
    s->picture_number=0;
608
    
609
    return 0;
610
}
611
612
613
static void clear_state(FFV1Context *f){
614 c2f1b2cb Michael Niedermayer
    int i, j;
615 5e20f836 Michael Niedermayer
616
    for(i=0; i<f->plane_count; i++){
617
        PlaneContext *p= &f->plane[i];
618
619
        p->interlace_bit_state[0]= 0;
620
        p->interlace_bit_state[1]= 0;
621
        
622 c2f1b2cb Michael Niedermayer
        for(j=0; j<p->context_count; j++){
623 11e659c2 Michael Niedermayer
            if(f->ac){
624
                memset(p->state[j], 0, sizeof(uint8_t)*CONTEXT_SIZE);
625
                p->state[j][7] = 2*62;
626
            }else{
627
                p->vlc_state[j].drift= 0;
628
                p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
629
                p->vlc_state[j].bias= 0;
630
                p->vlc_state[j].count= 1;
631
            }
632 c2f1b2cb Michael Niedermayer
        }
633 5e20f836 Michael Niedermayer
    }
634
}
635
636
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
637
    FFV1Context *f = avctx->priv_data;
638
    CABACContext * const c= &f->c;
639
    AVFrame *pict = data;
640
    const int width= f->width;
641
    const int height= f->height;
642
    AVFrame * const p= &f->picture;
643 11e659c2 Michael Niedermayer
    int used_count= 0;
644 5e20f836 Michael Niedermayer
645
    if(avctx->strict_std_compliance >= 0){
646 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"
647 5e20f836 Michael Niedermayer
               "use vstrict=-1 to use it anyway\n");
648
        return -1;
649
    }
650
        
651
    ff_init_cabac_encoder(c, buf, buf_size);
652
    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
653
    
654
    *p = *pict;
655
    p->pict_type= FF_I_TYPE;
656
    
657
    if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
658
        put_cabac_bypass(c, 1);
659
        p->key_frame= 1;
660
        write_header(f);
661
        clear_state(f);
662
    }else{
663
        put_cabac_bypass(c, 0);
664
        p->key_frame= 0;
665
    }
666
667 11e659c2 Michael Niedermayer
    if(!f->ac){
668
        used_count += put_cabac_terminate(c, 1);
669
//printf("pos=%d\n", used_count);
670 ed7debda Alex Beregszaszi
        init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
671 11e659c2 Michael Niedermayer
    }
672
    
673 2cbb7820 Michael Niedermayer
    if(f->colorspace==0){
674 5e20f836 Michael Niedermayer
        const int chroma_width = -((-width )>>f->chroma_h_shift);
675
        const int chroma_height= -((-height)>>f->chroma_v_shift);
676
677
        encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
678
679
        encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
680 27fc5352 Michael Niedermayer
        encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
681 2cbb7820 Michael Niedermayer
    }else{
682
        encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
683 5e20f836 Michael Niedermayer
    }
684
    emms_c();
685
    
686
    f->picture_number++;
687
688 11e659c2 Michael Niedermayer
    if(f->ac){
689
        return put_cabac_terminate(c, 1);
690
    }else{
691
        flush_put_bits(&f->pb); //nicer padding FIXME
692
        return used_count + (get_bit_count(&f->pb)+7)/8;
693
    }
694 5e20f836 Michael Niedermayer
}
695
696
static void common_end(FFV1Context *s){
697
    int i; 
698
699
    for(i=0; i<s->plane_count; i++){
700
        PlaneContext *p= &s->plane[i];
701
702
        av_freep(&p->state);
703
    }
704
}
705
706
static int encode_end(AVCodecContext *avctx)
707
{
708
    FFV1Context *s = avctx->priv_data;
709
710
    common_end(s);
711
712
    return 0;
713
}
714
715 598401ce Michael Niedermayer
static inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
716 5e20f836 Michael Niedermayer
    PlaneContext * const p= &s->plane[plane_index];
717
    CABACContext * const c= &s->c;
718 2cbb7820 Michael Niedermayer
    int x;
719
    int run_count=0;
720
    int run_mode=0;
721
    int run_index= s->run_index;
722
723
    for(x=0; x<w; x++){
724
        int diff, context, sign;
725
         
726
        context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
727
        if(context < 0){
728
            context= -context;
729
            sign=1;
730
        }else
731
            sign=0;
732
        
733
734
        if(s->ac)
735
            diff= get_symbol(c, p->state[context], 1, bits-1);
736
        else{
737
            if(context == 0 && run_mode==0) run_mode=1;
738
            
739
            if(run_mode){
740
                if(run_count==0 && run_mode==1){
741
                    if(get_bits1(&s->gb)){
742
                        run_count = 1<<log2_run[run_index];
743
                        if(x + run_count <= w) run_index++;
744
                    }else{
745
                        if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
746
                        else run_count=0;
747
                        if(run_index) run_index--;
748
                        run_mode=2;
749
                    }
750
                }
751
                run_count--;
752
                if(run_count < 0){
753
                    run_mode=0;
754
                    run_count=0;
755
                    diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
756
                    if(diff>=0) diff++;
757
                }else
758
                    diff=0;
759
            }else
760
                diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
761
            
762
//            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));
763
        }
764
765
        if(sign) diff= -diff;
766
767
        sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
768
    }
769
    s->run_index= run_index;        
770
}
771
772
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
773
    int x, y;
774
    int_fast16_t sample_buffer[2][w+6];
775
    int_fast16_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
776
777
    s->run_index=0;
778 5e20f836 Michael Niedermayer
    
779 d9ced4ca Michael Niedermayer
    memset(sample_buffer, 0, sizeof(sample_buffer));
780 5e20f836 Michael Niedermayer
    
781
    for(y=0; y<h; y++){
782 2cbb7820 Michael Niedermayer
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
783 5e20f836 Michael Niedermayer
784 d9ced4ca Michael Niedermayer
        sample[0]= sample[1];
785
        sample[1]= temp;
786 5e20f836 Michael Niedermayer
787 d9ced4ca Michael Niedermayer
        sample[1][-1]= sample[0][0  ];
788
        sample[0][ w]= sample[0][w-1];
789 2cbb7820 Michael Niedermayer
        
790
//{START_TIMER
791
        decode_line(s, w, sample, plane_index, 8);
792 5e20f836 Michael Niedermayer
        for(x=0; x<w; x++){
793 2cbb7820 Michael Niedermayer
            src[x + stride*y]= sample[1][x];
794
        }
795
//STOP_TIMER("decode-line")}
796
    }
797
}
798 5e20f836 Michael Niedermayer
799 2cbb7820 Michael Niedermayer
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
800
    int x, y, p;
801
    int_fast16_t sample_buffer[3][2][w+6];
802
    int_fast16_t *sample[3][2]= {
803
        {sample_buffer[0][0]+3, sample_buffer[0][1]+3},
804
        {sample_buffer[1][0]+3, sample_buffer[1][1]+3},
805
        {sample_buffer[2][0]+3, sample_buffer[2][1]+3}};
806
807
    s->run_index=0;
808
    
809
    memset(sample_buffer, 0, sizeof(sample_buffer));
810
    
811
    for(y=0; y<h; y++){
812
        for(p=0; p<3; p++){
813
            int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
814
815
            sample[p][0]= sample[p][1];
816
            sample[p][1]= temp;
817 5e20f836 Michael Niedermayer
818 2cbb7820 Michael Niedermayer
            sample[p][1][-1]= sample[p][0][0  ];
819
            sample[p][0][ w]= sample[p][0][w-1];
820
            decode_line(s, w, sample[p], FFMIN(p, 1), 9);
821
        }
822
        for(x=0; x<w; x++){
823
            int g= sample[0][1][x];
824
            int b= sample[1][1][x];
825
            int r= sample[2][1][x];
826 11e659c2 Michael Niedermayer
827 2cbb7820 Michael Niedermayer
//            assert(g>=0 && b>=0 && r>=0);
828
//            assert(g<256 && b<512 && r<512);
829 5e20f836 Michael Niedermayer
            
830 2cbb7820 Michael Niedermayer
            b -= 0x100;
831
            r -= 0x100;
832
            g -= (b + r)>>2;
833
            b += g;
834
            r += g;
835
            
836
            src[x + stride*y]= b + (g<<8) + (r<<16);
837 5e20f836 Michael Niedermayer
        }
838
    }
839
}
840
841 11e659c2 Michael Niedermayer
static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){
842 5e20f836 Michael Niedermayer
    int v;
843
    int i=0;
844 c2f1b2cb Michael Niedermayer
    uint8_t state[CONTEXT_SIZE]={0};
845 5e20f836 Michael Niedermayer
846 11e659c2 Michael Niedermayer
    for(v=0; i<128 ; v++){
847 085565f7 Michael Niedermayer
        int len= get_symbol(c, state, 0, 7) + 1;
848 5e20f836 Michael Niedermayer
849 11e659c2 Michael Niedermayer
        if(len + i > 128) return -1;
850 5e20f836 Michael Niedermayer
        
851
        while(len--){
852 11e659c2 Michael Niedermayer
            quant_table[i] = scale*v;
853
            i++;
854 5e20f836 Michael Niedermayer
//printf("%2d ",v);
855
//if(i%16==0) printf("\n");
856
        }
857
    }
858 11e659c2 Michael Niedermayer
859
    for(i=1; i<128; i++){
860
        quant_table[256-i]= -quant_table[i];
861
    }
862
    quant_table[128]= -quant_table[127];
863 5e20f836 Michael Niedermayer
    
864 11e659c2 Michael Niedermayer
    return 2*v - 1;
865 5e20f836 Michael Niedermayer
}
866
867
static int read_header(FFV1Context *f){
868 c2f1b2cb Michael Niedermayer
    uint8_t state[CONTEXT_SIZE]={0};
869 11e659c2 Michael Niedermayer
    int i, context_count;
870 5e20f836 Michael Niedermayer
    CABACContext * const c= &f->c;
871
    
872 085565f7 Michael Niedermayer
    f->version= get_symbol(c, state, 0, 7);
873
    f->ac= f->avctx->coder_type= get_symbol(c, state, 0, 7);
874 2cbb7820 Michael Niedermayer
    f->colorspace= get_symbol(c, state, 0, 7); //YUV cs type
875 5e20f836 Michael Niedermayer
    get_cabac(c, state); //no chroma = false
876 085565f7 Michael Niedermayer
    f->chroma_h_shift= get_symbol(c, state, 0, 7);
877
    f->chroma_v_shift= get_symbol(c, state, 0, 7);
878 5e20f836 Michael Niedermayer
    get_cabac(c, state); //transparency plane
879 27fc5352 Michael Niedermayer
    f->plane_count= 2;
880 085565f7 Michael Niedermayer
881 2cbb7820 Michael Niedermayer
    if(f->colorspace==0){
882
        switch(16*f->chroma_h_shift + f->chroma_v_shift){
883
        case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
884
        case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
885
        case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
886
        case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
887
        case 0x33: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
888
        default:
889 9b879566 Michel Bardiaux
            av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
890 2cbb7820 Michael Niedermayer
            return -1;
891
        }
892
    }else if(f->colorspace==1){
893
        if(f->chroma_h_shift || f->chroma_v_shift){
894 9b879566 Michel Bardiaux
            av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
895 2cbb7820 Michael Niedermayer
            return -1;
896
        }
897
        f->avctx->pix_fmt= PIX_FMT_RGBA32;
898
    }else{
899 9b879566 Michel Bardiaux
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
900 085565f7 Michael Niedermayer
        return -1;
901
    }
902 2cbb7820 Michael Niedermayer
903 085565f7 Michael Niedermayer
//printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
904
905 11e659c2 Michael Niedermayer
    context_count=1;
906
    for(i=0; i<5; i++){
907
        context_count*= read_quant_table(c, f->quant_table[i], context_count);
908 085565f7 Michael Niedermayer
        if(context_count < 0){
909 9b879566 Michel Bardiaux
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
910 085565f7 Michael Niedermayer
            return -1;
911
        }
912 11e659c2 Michael Niedermayer
    }
913
    context_count= (context_count+1)/2;
914
    
915 5e20f836 Michael Niedermayer
    for(i=0; i<f->plane_count; i++){
916
        PlaneContext * const p= &f->plane[i];
917
918 11e659c2 Michael Niedermayer
        p->context_count= context_count;
919
920
        if(f->ac){
921
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
922
        }else{
923
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
924
        }
925 5e20f836 Michael Niedermayer
    }
926
    
927
    return 0;
928
}
929
930
static int decode_init(AVCodecContext *avctx)
931
{
932 11e659c2 Michael Niedermayer
//    FFV1Context *s = avctx->priv_data;
933 5e20f836 Michael Niedermayer
934
    common_init(avctx);
935
    
936
    return 0;
937
}
938
939
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
940
    FFV1Context *f = avctx->priv_data;
941
    CABACContext * const c= &f->c;
942
    const int width= f->width;
943
    const int height= f->height;
944
    AVFrame * const p= &f->picture;
945
    int bytes_read;
946
947
    AVFrame *picture = data;
948
949
    *data_size = 0;
950
951
    /* no supplementary picture */
952
    if (buf_size == 0)
953
        return 0;
954
955
    ff_init_cabac_decoder(c, buf, buf_size);
956
    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
957
958
    p->pict_type= FF_I_TYPE; //FIXME I vs. P
959
    if(get_cabac_bypass(c)){
960
        p->key_frame= 1;
961
        read_header(f);
962
        clear_state(f);
963
    }else{
964
        p->key_frame= 0;
965
    }
966 085565f7 Michael Niedermayer
967
    p->reference= 0;
968
    if(avctx->get_buffer(avctx, p) < 0){
969 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
970 085565f7 Michael Niedermayer
        return -1;
971
    }
972
973 5e20f836 Michael Niedermayer
    if(avctx->debug&FF_DEBUG_PICT_INFO)
974 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
975 5e20f836 Michael Niedermayer
    
976 11e659c2 Michael Niedermayer
    if(!f->ac){
977
        bytes_read = get_cabac_terminate(c);
978 9b879566 Michel Bardiaux
        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n");
979 11e659c2 Michael Niedermayer
//printf("pos=%d\n", bytes_read);
980
        init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
981 1df1df0b Fabrice Bellard
    } else {
982
        bytes_read = 0; /* avoid warning */
983 11e659c2 Michael Niedermayer
    }
984 5e20f836 Michael Niedermayer
    
985 2cbb7820 Michael Niedermayer
    if(f->colorspace==0){
986 5e20f836 Michael Niedermayer
        const int chroma_width = -((-width )>>f->chroma_h_shift);
987
        const int chroma_height= -((-height)>>f->chroma_v_shift);
988
        decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
989
        
990
        decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
991 27fc5352 Michael Niedermayer
        decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
992 2cbb7820 Michael Niedermayer
    }else{
993
        decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
994 5e20f836 Michael Niedermayer
    }
995
        
996
    emms_c();
997
998
    f->picture_number++;
999
1000
    *picture= *p;
1001
    
1002
    avctx->release_buffer(avctx, p); //FIXME
1003
1004
    *data_size = sizeof(AVFrame);
1005
    
1006 11e659c2 Michael Niedermayer
    if(f->ac){
1007
        bytes_read= get_cabac_terminate(c);
1008 9b879566 Michel Bardiaux
        if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1009 11e659c2 Michael Niedermayer
    }else{
1010
        bytes_read+= (get_bits_count(&f->gb)+7)/8;
1011
    }
1012
1013 5e20f836 Michael Niedermayer
    return bytes_read;
1014
}
1015
1016
static int decode_end(AVCodecContext *avctx)
1017
{
1018
    FFV1Context *s = avctx->priv_data;
1019
    int i;
1020
    
1021
    if(avctx->get_buffer == avcodec_default_get_buffer){
1022
        for(i=0; i<4; i++){
1023
            av_freep(&s->picture.base[i]);
1024
            s->picture.data[i]= NULL;
1025
        }
1026
        av_freep(&s->picture.opaque);
1027
    }
1028
1029
    return 0;
1030
}
1031
1032
AVCodec ffv1_decoder = {
1033
    "ffv1",
1034
    CODEC_TYPE_VIDEO,
1035
    CODEC_ID_FFV1,
1036
    sizeof(FFV1Context),
1037
    decode_init,
1038
    NULL,
1039
    decode_end,
1040
    decode_frame,
1041 c2f1b2cb Michael Niedermayer
    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1042 5e20f836 Michael Niedermayer
    NULL
1043
};
1044
1045 2a250222 Michael Niedermayer
#ifdef CONFIG_ENCODERS
1046 5e20f836 Michael Niedermayer
AVCodec ffv1_encoder = {
1047
    "ffv1",
1048
    CODEC_TYPE_VIDEO,
1049
    CODEC_ID_FFV1,
1050
    sizeof(FFV1Context),
1051
    encode_init,
1052
    encode_frame,
1053
    encode_end,
1054
};
1055 2a250222 Michael Niedermayer
#endif