Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ 68ca24e6

History | View | Annotate | Download (30.4 KB)

1
/*
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
 * FF Video Codec 1 (an experimental lossless codec)
25
 */
26

    
27
#include "common.h"
28
#include "avcodec.h"
29
#include "dsputil.h"
30
#include "cabac.h"
31
#include "golomb.h"
32

    
33
#define MAX_PLANES 4
34
#define CONTEXT_SIZE 32
35

    
36
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
 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, 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
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
57
 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

    
145
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
};
150

    
151
typedef struct VlcState{
152
    int16_t drift;
153
    uint16_t error_sum;
154
    int8_t bias;
155
    uint8_t count;
156
} VlcState;
157

    
158
typedef struct PlaneContext{
159
    int context_count;
160
    uint8_t (*state)[CONTEXT_SIZE];
161
    VlcState *vlc_state;
162
    uint8_t interlace_bit_state[2];
163
} PlaneContext;
164

    
165
typedef struct FFV1Context{
166
    AVCodecContext *avctx;
167
    CABACContext c;
168
    GetBitContext gb;
169
    PutBitContext pb;
170
    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
    int ac;                              ///< 1-> CABAC 0-> golomb rice
178
    PlaneContext plane[MAX_PLANES];
179
    int16_t quant_table[5][256];
180
    int run_index;
181
    int colorspace;
182
    
183
    DSPContext dsp; 
184
}FFV1Context;
185

    
186
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
    const int LT= last[-1];
200
    const int  T= last[ 0];
201
    const int L =  src[-1];
202

    
203
    return mid_pred(L, L + T - LT, T);
204
}
205

    
206
static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
207
    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
}
220

    
221
/**
222
 * put 
223
 */
224
static inline void put_symbol(CABACContext *c, uint8_t *state, int v, int is_signed, int max_exp){
225
    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
        
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
            for(i=e-1; i>=0; i--){
241
                put_cabac(c, state+16+e+i, (a>>i)&1); //17..29
242
            }
243
            if(is_signed)
244
                put_cabac(c, state+9 + e, v < 0); //9..16
245
        }
246
    }else{
247
        put_cabac(c, state+0, 1);
248
    }
249
}
250

    
251
static inline int get_symbol(CABACContext *c, uint8_t *state, int is_signed, int max_exp){
252
    if(get_cabac(c, state+0))
253
        return 0;
254
    else{
255
        int i, e;
256
 
257
        for(e=0; e<max_exp; e++){ 
258
            int a= 1<<e;
259

    
260
            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

    
265
                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
    }
273
}
274

    
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
static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
307
    int i, k, code;
308
//printf("final: %d ", v);
309
    v = fold(v - state->bias, bits);
310

    
311
    i= state->count;
312
    k=0;
313
    while(i < state->error_sum){ //FIXME optimize
314
        k++;
315
        i += i;
316
    }
317

    
318
    assert(k<=8);
319

    
320
#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
    set_ur_golomb(pb, code, k, 12, bits);
331

    
332
    update_vlc_state(state, v);
333
}
334

    
335
static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
336
    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

    
345
    assert(k<=8);
346

    
347
    v= get_ur_golomb(gb, k, 12, bits);
348
//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

    
350
    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
#endif
359

    
360
    ret= fold(v + state->bias, bits);
361
    
362
    update_vlc_state(state, v);
363
//printf("final: %d\n", ret);
364
    return ret;
365
}
366

    
367
static inline void encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
368
    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
        context= get_context(s, sample[1]+x, sample[0]+x, sample[2]+x);
379
        diff= sample[1][x] - predict(sample[1]+x, sample[0]+x);
380

    
381
        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

    
431
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
432
    int x,y;
433
    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
    s->run_index=0;
436
    
437
    memset(sample_buffer, 0, sizeof(sample_buffer));
438
    
439
    for(y=0; y<h; y++){
440
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
441

    
442
        sample[0]= sample[1];
443
        sample[1]= sample[2];
444
        sample[2]= temp;
445
        
446
        sample[1][-1]= sample[0][0  ];
447
        sample[0][ w]= sample[0][w-1];
448
//{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

    
457
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
        for(x=0; x<w; x++){
470
            int v= src[x + stride*y];
471
            int b= v&0xFF;
472
            int g= (v>>8)&0xFF;
473
            int r= (v>>16)&0xFF;
474
            
475
            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
        }
487
        for(p=0; p<3; p++){
488
            int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
489

    
490
            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
        }
497
    }
498
}
499

    
500
static void write_quant_table(CABACContext *c, int16_t *quant_table){
501
    int last=0;
502
    int i;
503
    uint8_t state[CONTEXT_SIZE]={0};
504

    
505
    for(i=1; i<128 ; i++){
506
        if(quant_table[i] != quant_table[i-1]){
507
            put_symbol(c, state, i-last-1, 0, 7);
508
            last= i;
509
        }
510
    }
511
    put_symbol(c, state, i-last-1, 0, 7);
512
}
513

    
514
static void write_header(FFV1Context *f){
515
    uint8_t state[CONTEXT_SIZE]={0};
516
    int i;
517
    CABACContext * const c= &f->c;
518

    
519
    put_symbol(c, state, f->version, 0, 7);
520
    put_symbol(c, state, f->avctx->coder_type, 0, 7);
521
    put_symbol(c, state, f->colorspace, 0, 7); //YUV cs type 
522
    put_cabac(c, state, 1); //chroma planes
523
        put_symbol(c, state, f->chroma_h_shift, 0, 7);
524
        put_symbol(c, state, f->chroma_v_shift, 0, 7);
525
    put_cabac(c, state, 0); //no transparency plane
526

    
527
    for(i=0; i<5; i++)
528
        write_quant_table(c, f->quant_table[i]);
529
}
530

    
531
static int common_init(AVCodecContext *avctx){
532
    FFV1Context *s = avctx->priv_data;
533
    int width, height;
534

    
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
    s->ac= avctx->coder_type;
557
    
558
    s->plane_count=2;
559
    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

    
573
    for(i=0; i<s->plane_count; i++){
574
        PlaneContext * const p= &s->plane[i];
575
               
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
    }
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
        s->colorspace= 0;
597
        break;
598
    case PIX_FMT_RGBA32:
599
        s->colorspace= 1;
600
        break;
601
    default:
602
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
603
        return -1;
604
    }
605
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
606

    
607
    s->picture_number=0;
608
    
609
    return 0;
610
}
611

    
612

    
613
static void clear_state(FFV1Context *f){
614
    int i, j;
615

    
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
        for(j=0; j<p->context_count; j++){
623
            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
        }
633
    }
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
    int used_count= 0;
644

    
645
    if(avctx->strict_std_compliance >= 0){
646
        av_log(avctx, AV_LOG_ERROR, "this codec is under development, files encoded with it wont be decodeable with future versions!!!\n"
647
               "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
    if(!f->ac){
668
        used_count += put_cabac_terminate(c, 1);
669
//printf("pos=%d\n", used_count);
670
        init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
671
    }
672
    
673
    if(f->colorspace==0){
674
        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
        encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
681
    }else{
682
        encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
683
    }
684
    emms_c();
685
    
686
    f->picture_number++;
687

    
688
    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
}
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
static inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
716
    PlaneContext * const p= &s->plane[plane_index];
717
    CABACContext * const c= &s->c;
718
    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
    
779
    memset(sample_buffer, 0, sizeof(sample_buffer));
780
    
781
    for(y=0; y<h; y++){
782
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
783

    
784
        sample[0]= sample[1];
785
        sample[1]= temp;
786

    
787
        sample[1][-1]= sample[0][0  ];
788
        sample[0][ w]= sample[0][w-1];
789
        
790
//{START_TIMER
791
        decode_line(s, w, sample, plane_index, 8);
792
        for(x=0; x<w; x++){
793
            src[x + stride*y]= sample[1][x];
794
        }
795
//STOP_TIMER("decode-line")}
796
    }
797
}
798

    
799
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

    
818
            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

    
827
//            assert(g>=0 && b>=0 && r>=0);
828
//            assert(g<256 && b<512 && r<512);
829
            
830
            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
        }
838
    }
839
}
840

    
841
static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){
842
    int v;
843
    int i=0;
844
    uint8_t state[CONTEXT_SIZE]={0};
845

    
846
    for(v=0; i<128 ; v++){
847
        int len= get_symbol(c, state, 0, 7) + 1;
848

    
849
        if(len + i > 128) return -1;
850
        
851
        while(len--){
852
            quant_table[i] = scale*v;
853
            i++;
854
//printf("%2d ",v);
855
//if(i%16==0) printf("\n");
856
        }
857
    }
858

    
859
    for(i=1; i<128; i++){
860
        quant_table[256-i]= -quant_table[i];
861
    }
862
    quant_table[128]= -quant_table[127];
863
    
864
    return 2*v - 1;
865
}
866

    
867
static int read_header(FFV1Context *f){
868
    uint8_t state[CONTEXT_SIZE]={0};
869
    int i, context_count;
870
    CABACContext * const c= &f->c;
871
    
872
    f->version= get_symbol(c, state, 0, 7);
873
    f->ac= f->avctx->coder_type= get_symbol(c, state, 0, 7);
874
    f->colorspace= get_symbol(c, state, 0, 7); //YUV cs type
875
    get_cabac(c, state); //no chroma = false
876
    f->chroma_h_shift= get_symbol(c, state, 0, 7);
877
    f->chroma_v_shift= get_symbol(c, state, 0, 7);
878
    get_cabac(c, state); //transparency plane
879
    f->plane_count= 2;
880

    
881
    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
            av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
890
            return -1;
891
        }
892
    }else if(f->colorspace==1){
893
        if(f->chroma_h_shift || f->chroma_v_shift){
894
            av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
895
            return -1;
896
        }
897
        f->avctx->pix_fmt= PIX_FMT_RGBA32;
898
    }else{
899
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
900
        return -1;
901
    }
902

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

    
905
    context_count=1;
906
    for(i=0; i<5; i++){
907
        context_count*= read_quant_table(c, f->quant_table[i], context_count);
908
        if(context_count < 0){
909
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
910
            return -1;
911
        }
912
    }
913
    context_count= (context_count+1)/2;
914
    
915
    for(i=0; i<f->plane_count; i++){
916
        PlaneContext * const p= &f->plane[i];
917

    
918
        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
    }
926
    
927
    return 0;
928
}
929

    
930
static int decode_init(AVCodecContext *avctx)
931
{
932
//    FFV1Context *s = avctx->priv_data;
933

    
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

    
967
    p->reference= 0;
968
    if(avctx->get_buffer(avctx, p) < 0){
969
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
970
        return -1;
971
    }
972

    
973
    if(avctx->debug&FF_DEBUG_PICT_INFO)
974
        av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
975
    
976
    if(!f->ac){
977
        bytes_read = get_cabac_terminate(c);
978
        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n");
979
//printf("pos=%d\n", bytes_read);
980
        init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
981
    } else {
982
        bytes_read = 0; /* avoid warning */
983
    }
984
    
985
    if(f->colorspace==0){
986
        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
        decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
992
    }else{
993
        decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
994
    }
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
    if(f->ac){
1007
        bytes_read= get_cabac_terminate(c);
1008
        if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1009
    }else{
1010
        bytes_read+= (get_bits_count(&f->gb)+7)/8;
1011
    }
1012

    
1013
    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
    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1042
    NULL
1043
};
1044

    
1045
#ifdef CONFIG_ENCODERS
1046
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
#endif