Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ 029911d1

History | View | Annotate | Download (26.9 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 (a 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
    
181
    DSPContext dsp; 
182
}FFV1Context;
183

    
184
static inline int predict(uint8_t *src, uint8_t *last){
185
    const int LT= last[-1];
186
    const int  T= last[ 0];
187
    const int L =  src[-1];
188

    
189
    return mid_pred(L, L + T - LT, T);
190
}
191

    
192
static inline int get_context(FFV1Context *f, uint8_t *src, uint8_t *last, uint8_t *last2){
193
    const int LT= last[-1];
194
    const int  T= last[ 0];
195
    const int RT= last[ 1];
196
    const int L =  src[-1];
197

    
198
    if(f->quant_table[3][127]){
199
        const int TT= last2[0];
200
        const int LL=  src[-2];
201
        return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
202
              +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
203
    }else
204
        return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
205
}
206

    
207
/**
208
 * put 
209
 */
210
static inline void put_symbol(CABACContext *c, uint8_t *state, int v, int is_signed, int max_exp){
211
    int i;
212

    
213
    if(v){
214
        const int a= ABS(v);
215
        const int e= av_log2(a);
216

    
217
        put_cabac(c, state+0, 0);
218
        
219
        for(i=0; i<e; i++){
220
            put_cabac(c, state+1+i, 1);  //1..8
221
        }
222

    
223
        if(e<max_exp){
224
            put_cabac(c, state+1+i, 0);      //1..8
225

    
226
            for(i=e-1; i>=0; i--){
227
                put_cabac(c, state+16+e+i, (a>>i)&1); //17..29
228
            }
229
            if(is_signed)
230
                put_cabac(c, state+9 + e, v < 0); //9..16
231
        }
232
    }else{
233
        put_cabac(c, state+0, 1);
234
    }
235
}
236

    
237
static inline int get_symbol(CABACContext *c, uint8_t *state, int is_signed, int max_exp){
238
    if(get_cabac(c, state+0))
239
        return 0;
240
    else{
241
        int i, e;
242
 
243
        for(e=0; e<max_exp; e++){ 
244
            int a= 1<<e;
245

    
246
            if(get_cabac(c, state + 1 + e)==0){ // 1..8
247
                for(i=e-1; i>=0; i--){
248
                    a += get_cabac(c, state+16+e+i)<<i; //17..29
249
                }
250

    
251
                if(is_signed && get_cabac(c, state+9 + e)) //9..16
252
                    return -a;
253
                else
254
                    return a;
255
            }
256
        }
257
        return -(1<<e);
258
    }
259
}
260

    
261
static inline void update_vlc_state(VlcState * const state, const int v){
262
    int drift= state->drift;
263
    int count= state->count;
264
    state->error_sum += ABS(v);
265
    drift += v;
266

    
267
    if(count == 128){ //FIXME variable
268
        count >>= 1;
269
        drift >>= 1;
270
        state->error_sum >>= 1;
271
    }
272
    count++;
273

    
274
    if(drift <= -count){
275
        if(state->bias > -128) state->bias--;
276
        
277
        drift += count;
278
        if(drift <= -count)
279
            drift= -count + 1;
280
    }else if(drift > 0){
281
        if(state->bias <  127) state->bias++;
282
        
283
        drift -= count;
284
        if(drift > 0) 
285
            drift= 0;
286
    }
287

    
288
    state->drift= drift;
289
    state->count= count;
290
}
291

    
292
static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v){
293
    int i, k, code;
294
//printf("final: %d ", v);
295
    v = (int8_t)(v - state->bias);
296
    
297
    i= state->count;
298
    k=0;
299
    while(i < state->error_sum){ //FIXME optimize
300
        k++;
301
        i += i;
302
    }
303

    
304
    assert(k<=8);
305

    
306
#if 0 // JPEG LS
307
    if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
308
    else                                         code= v;
309
#else
310
     code= v ^ ((2*state->drift + state->count)>>31);
311
#endif
312
    
313
    code = -2*code-1;
314
    code^= (code>>31);
315
//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);
316
    set_ur_golomb(pb, code, k, 12, 8);
317

    
318
    update_vlc_state(state, v);
319
}
320

    
321
static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state){
322
    int k, i, v, ret;
323

    
324
    i= state->count;
325
    k=0;
326
    while(i < state->error_sum){ //FIXME optimize
327
        k++;
328
        i += i;
329
    }
330

    
331
    assert(k<=8);
332

    
333
    v= get_ur_golomb(gb, k, 12, 8);
334
//printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
335

    
336
    v++;
337
    if(v&1) v=  (v>>1);
338
    else    v= -(v>>1);
339

    
340
#if 0 // JPEG LS
341
    if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
342
#else
343
     v ^= ((2*state->drift + state->count)>>31);
344
#endif
345

    
346
    ret= (int8_t)(v + state->bias);
347
    
348
    update_vlc_state(state, v);
349
//printf("final: %d\n", ret);
350
    return ret;
351
}
352

    
353

    
354

    
355
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
356
    PlaneContext * const p= &s->plane[plane_index];
357
    CABACContext * const c= &s->c;
358
    int x,y;
359
    uint8_t sample_buffer[2][w+6];
360
    uint8_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
361
    int run_index=0;
362
    
363
    memset(sample_buffer, 0, sizeof(sample_buffer));
364
    
365
    for(y=0; y<h; y++){
366
        uint8_t *temp= sample[0]; //FIXME try a normal buffer
367
        int run_count=0;
368
        int run_mode=0;
369

    
370
        sample[0]= sample[1];
371
        sample[1]= temp;
372
        
373
        sample[1][-1]= sample[0][0  ];
374
        sample[0][ w]= sample[0][w-1];
375

    
376
        for(x=0; x<w; x++){
377
            uint8_t *temp_src= src + x + stride*y;
378
            int diff, context;
379
            
380
            context= get_context(s, sample[1]+x, sample[0]+x, sample[1]+x);
381
            diff= temp_src[0] - predict(sample[1]+x, sample[0]+x);
382

    
383
            if(context < 0){
384
                context = -context;
385
                diff= -diff;
386
            }
387

    
388
            diff= (int8_t)diff;
389

    
390
            if(s->ac){
391
                put_symbol(c, p->state[context], diff, 1, 7);
392
            }else{
393
                if(context == 0) run_mode=1;
394
                
395
                if(run_mode){
396

    
397
                    if(diff){
398
                        while(run_count >= 1<<log2_run[run_index]){
399
                            run_count -= 1<<log2_run[run_index];
400
                            run_index++;
401
                            put_bits(&s->pb, 1, 1);
402
                        }
403
                        
404
                        put_bits(&s->pb, 1 + log2_run[run_index], run_count);
405
                        if(run_index) run_index--;
406
                        run_count=0;
407
                        run_mode=0;
408
                        if(diff>0) diff--;
409
                    }else{
410
                        run_count++;
411
                    }
412
                }
413
                
414
//                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));
415

    
416
                if(run_mode == 0)
417
                    put_vlc_symbol(&s->pb, &p->vlc_state[context], diff);
418
            }
419

    
420
            sample[1][x]= temp_src[0];
421
        }
422
        if(run_mode){
423
            while(run_count >= 1<<log2_run[run_index]){
424
                run_count -= 1<<log2_run[run_index];
425
                run_index++;
426
                put_bits(&s->pb, 1, 1);
427
            }
428

    
429
            if(run_count)
430
                put_bits(&s->pb, 1, 1);
431
        }
432
    }
433
}
434

    
435
static void write_quant_table(CABACContext *c, int16_t *quant_table){
436
    int last=0;
437
    int i;
438
    uint8_t state[CONTEXT_SIZE]={0};
439

    
440
    for(i=1; i<128 ; i++){
441
        if(quant_table[i] != quant_table[i-1]){
442
            put_symbol(c, state, i-last-1, 0, 7);
443
            last= i;
444
        }
445
    }
446
    put_symbol(c, state, i-last-1, 0, 7);
447
}
448

    
449
static void write_header(FFV1Context *f){
450
    uint8_t state[CONTEXT_SIZE]={0};
451
    int i;
452
    CABACContext * const c= &f->c;
453

    
454
    put_symbol(c, state, f->version, 0, 7);
455
    put_symbol(c, state, f->avctx->coder_type, 0, 7);
456
    put_symbol(c, state, 0, 0, 7); //YUV cs type 
457
    put_cabac(c, state, 1); //chroma planes
458
        put_symbol(c, state, f->chroma_h_shift, 0, 7);
459
        put_symbol(c, state, f->chroma_v_shift, 0, 7);
460
    put_cabac(c, state, 0); //no transparency plane
461

    
462
    for(i=0; i<5; i++)
463
        write_quant_table(c, f->quant_table[i]);
464
}
465

    
466
static int common_init(AVCodecContext *avctx){
467
    FFV1Context *s = avctx->priv_data;
468
    int width, height;
469

    
470
    s->avctx= avctx;
471
    s->flags= avctx->flags;
472
        
473
    dsputil_init(&s->dsp, avctx);
474
    
475
    width= s->width= avctx->width;
476
    height= s->height= avctx->height;
477
    
478
    assert(width && height);
479

    
480
    return 0;
481
}
482

    
483
static int encode_init(AVCodecContext *avctx)
484
{
485
    FFV1Context *s = avctx->priv_data;
486
    int i;
487

    
488
    common_init(avctx);
489
 
490
    s->version=0;
491
    s->ac= avctx->coder_type;
492
    
493
    s->plane_count=2;
494
    for(i=0; i<256; i++){
495
        s->quant_table[0][i]=           quant11[i];
496
        s->quant_table[1][i]=        11*quant11[i];
497
        if(avctx->context_model==0){
498
            s->quant_table[2][i]=     11*11*quant11[i];
499
            s->quant_table[3][i]=
500
            s->quant_table[4][i]=0;
501
        }else{
502
            s->quant_table[2][i]=     11*11*quant5 [i];
503
            s->quant_table[3][i]=   5*11*11*quant5 [i];
504
            s->quant_table[4][i]= 5*5*11*11*quant5 [i];
505
        }
506
    }
507

    
508
    for(i=0; i<s->plane_count; i++){
509
        PlaneContext * const p= &s->plane[i];
510
               
511
        if(avctx->context_model==0){
512
            p->context_count= (11*11*11+1)/2;
513
        }else{        
514
            p->context_count= (11*11*5*5*5+1)/2;
515
        }
516

    
517
        if(s->ac){
518
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
519
        }else{
520
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
521
        }
522
    }
523

    
524
    avctx->coded_frame= &s->picture;
525
    switch(avctx->pix_fmt){
526
    case PIX_FMT_YUV444P:
527
    case PIX_FMT_YUV422P:
528
    case PIX_FMT_YUV420P:
529
    case PIX_FMT_YUV411P:
530
    case PIX_FMT_YUV410P:
531
        avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
532
        break;
533
    default:
534
        fprintf(stderr, "format not supported\n");
535
        return -1;
536
    }
537
    
538
   
539
    s->picture_number=0;
540
    
541
    return 0;
542
}
543

    
544

    
545
static void clear_state(FFV1Context *f){
546
    int i, j;
547

    
548
    for(i=0; i<f->plane_count; i++){
549
        PlaneContext *p= &f->plane[i];
550

    
551
        p->interlace_bit_state[0]= 0;
552
        p->interlace_bit_state[1]= 0;
553
        
554
        for(j=0; j<p->context_count; j++){
555
            if(f->ac){
556
                memset(p->state[j], 0, sizeof(uint8_t)*CONTEXT_SIZE);
557
                p->state[j][7] = 2*62;
558
            }else{
559
                p->vlc_state[j].drift= 0;
560
                p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
561
                p->vlc_state[j].bias= 0;
562
                p->vlc_state[j].count= 1;
563
            }
564
        }
565
    }
566
}
567

    
568
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
569
    FFV1Context *f = avctx->priv_data;
570
    CABACContext * const c= &f->c;
571
    AVFrame *pict = data;
572
    const int width= f->width;
573
    const int height= f->height;
574
    AVFrame * const p= &f->picture;
575
    int used_count= 0;
576

    
577
    if(avctx->strict_std_compliance >= 0){
578
        printf("this codec is under development, files encoded with it wont be decodeable with future versions!!!\n"
579
               "use vstrict=-1 to use it anyway\n");
580
        return -1;
581
    }
582
        
583
    ff_init_cabac_encoder(c, buf, buf_size);
584
    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
585
    
586
    *p = *pict;
587
    p->pict_type= FF_I_TYPE;
588
    
589
    if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
590
        put_cabac_bypass(c, 1);
591
        p->key_frame= 1;
592
        write_header(f);
593
        clear_state(f);
594
    }else{
595
        put_cabac_bypass(c, 0);
596
        p->key_frame= 0;
597
    }
598

    
599
    if(!f->ac){
600
        used_count += put_cabac_terminate(c, 1);
601
//printf("pos=%d\n", used_count);
602
        init_put_bits(&f->pb, buf + used_count, buf_size - used_count, NULL, NULL);
603
    }
604
    
605
    if(1){
606
        const int chroma_width = -((-width )>>f->chroma_h_shift);
607
        const int chroma_height= -((-height)>>f->chroma_v_shift);
608

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

    
611
        encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
612
        encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
613
    }
614
    emms_c();
615
    
616
    f->picture_number++;
617

    
618
    if(f->ac){
619
        return put_cabac_terminate(c, 1);
620
    }else{
621
        flush_put_bits(&f->pb); //nicer padding FIXME
622
        return used_count + (get_bit_count(&f->pb)+7)/8;
623
    }
624
}
625

    
626
static void common_end(FFV1Context *s){
627
    int i; 
628

    
629
    for(i=0; i<s->plane_count; i++){
630
        PlaneContext *p= &s->plane[i];
631

    
632
        av_freep(&p->state);
633
    }
634
}
635

    
636
static int encode_end(AVCodecContext *avctx)
637
{
638
    FFV1Context *s = avctx->priv_data;
639

    
640
    common_end(s);
641

    
642
    return 0;
643
}
644

    
645
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
646
    PlaneContext * const p= &s->plane[plane_index];
647
    CABACContext * const c= &s->c;
648
    int x,y;
649
    uint8_t sample_buffer[2][w+6];
650
    uint8_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
651
    int run_index=0;
652
    
653
    memset(sample_buffer, 0, sizeof(sample_buffer));
654
    
655
    for(y=0; y<h; y++){
656
        uint8_t *temp= sample[0]; //FIXME try a normal buffer
657
        int run_count=0;
658
        int run_mode=0;
659

    
660
        sample[0]= sample[1];
661
        sample[1]= temp;
662

    
663
        sample[1][-1]= sample[0][0  ];
664
        sample[0][ w]= sample[0][w-1];
665

    
666
        for(x=0; x<w; x++){
667
            uint8_t *temp_src= src + x + stride*y;
668
            int diff, context, sign;
669
             
670
            context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
671
            if(context < 0){
672
                context= -context;
673
                sign=1;
674
            }else
675
                sign=0;
676
            
677

    
678
            if(s->ac)
679
                diff= get_symbol(c, p->state[context], 1, 7);
680
            else{
681
                if(context == 0 && run_mode==0) run_mode=1;
682
                
683
                if(run_mode){
684
                    if(run_count==0 && run_mode==1){
685
                        if(get_bits1(&s->gb)){
686
                            run_count = 1<<log2_run[run_index];
687
                            if(x + run_count <= w) run_index++;
688
                        }else{
689
                            if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
690
                            else run_count=0;
691
                            if(run_index) run_index--;
692
                            run_mode=2;
693
                        }
694
                    }
695
                    run_count--;
696
                    if(run_count < 0){
697
                        run_mode=0;
698
                        run_count=0;
699
                        diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]);
700
                        if(diff>=0) diff++;
701
                    }else
702
                        diff=0;
703
                }else
704
                    diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]);
705
                
706
//                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));
707
            }
708

    
709
            if(sign) diff= (int8_t)(-diff); //FIXME remove cast
710

    
711
            sample[1][x]=
712
            temp_src[0] = predict(sample[1] + x, sample[0] + x) + diff;
713
            
714
            assert(diff>= -128 && diff <= 127);
715
        }
716
    }
717
}
718

    
719
static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){
720
    int v;
721
    int i=0;
722
    uint8_t state[CONTEXT_SIZE]={0};
723

    
724
    for(v=0; i<128 ; v++){
725
        int len= get_symbol(c, state, 0, 7) + 1;
726

    
727
        if(len + i > 128) return -1;
728
        
729
        while(len--){
730
            quant_table[i] = scale*v;
731
            i++;
732
//printf("%2d ",v);
733
//if(i%16==0) printf("\n");
734
        }
735
    }
736

    
737
    for(i=1; i<128; i++){
738
        quant_table[256-i]= -quant_table[i];
739
    }
740
    quant_table[128]= -quant_table[127];
741
    
742
    return 2*v - 1;
743
}
744

    
745
static int read_header(FFV1Context *f){
746
    uint8_t state[CONTEXT_SIZE]={0};
747
    int i, context_count;
748
    CABACContext * const c= &f->c;
749
    
750
    f->version= get_symbol(c, state, 0, 7);
751
    f->ac= f->avctx->coder_type= get_symbol(c, state, 0, 7);
752
    get_symbol(c, state, 0, 7); //YUV cs type
753
    get_cabac(c, state); //no chroma = false
754
    f->chroma_h_shift= get_symbol(c, state, 0, 7);
755
    f->chroma_v_shift= get_symbol(c, state, 0, 7);
756
    get_cabac(c, state); //transparency plane
757
    f->plane_count= 2;
758

    
759
    switch(16*f->chroma_h_shift + f->chroma_v_shift){
760
    case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
761
    case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
762
    case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
763
    case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
764
    case 0x33: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
765
    default:
766
        fprintf(stderr, "format not supported\n");
767
        return -1;
768
    }
769
//printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
770

    
771
    context_count=1;
772
    for(i=0; i<5; i++){
773
        context_count*= read_quant_table(c, f->quant_table[i], context_count);
774
        if(context_count < 0){
775
            printf("read_quant_table error\n");
776
            return -1;
777
        }
778
    }
779
    context_count= (context_count+1)/2;
780
    
781
    for(i=0; i<f->plane_count; i++){
782
        PlaneContext * const p= &f->plane[i];
783

    
784
        p->context_count= context_count;
785

    
786
        if(f->ac){
787
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
788
        }else{
789
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
790
        }
791
    }
792
    
793
    return 0;
794
}
795

    
796
static int decode_init(AVCodecContext *avctx)
797
{
798
//    FFV1Context *s = avctx->priv_data;
799

    
800
    common_init(avctx);
801
    
802
#if 0    
803
    switch(s->bitstream_bpp){
804
    case 12:
805
        avctx->pix_fmt = PIX_FMT_YUV420P;
806
        break;
807
    case 16:
808
        avctx->pix_fmt = PIX_FMT_YUV422P;
809
        break;
810
    case 24:
811
    case 32:
812
        if(s->bgr32){
813
            avctx->pix_fmt = PIX_FMT_RGBA32;
814
        }else{
815
            avctx->pix_fmt = PIX_FMT_BGR24;
816
        }
817
        break;
818
    default:
819
        assert(0);
820
    }
821
#endif
822
    
823
    return 0;
824
}
825

    
826
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
827
    FFV1Context *f = avctx->priv_data;
828
    CABACContext * const c= &f->c;
829
    const int width= f->width;
830
    const int height= f->height;
831
    AVFrame * const p= &f->picture;
832
    int bytes_read;
833

    
834
    AVFrame *picture = data;
835

    
836
    *data_size = 0;
837

    
838
    /* no supplementary picture */
839
    if (buf_size == 0)
840
        return 0;
841

    
842
    ff_init_cabac_decoder(c, buf, buf_size);
843
    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
844

    
845
    p->pict_type= FF_I_TYPE; //FIXME I vs. P
846
    if(get_cabac_bypass(c)){
847
        p->key_frame= 1;
848
        read_header(f);
849
        clear_state(f);
850
    }else{
851
        p->key_frame= 0;
852
    }
853

    
854
    p->reference= 0;
855
    if(avctx->get_buffer(avctx, p) < 0){
856
        fprintf(stderr, "get_buffer() failed\n");
857
        return -1;
858
    }
859

    
860
    if(avctx->debug&FF_DEBUG_PICT_INFO)
861
        printf("keyframe:%d coder:%d\n", p->key_frame, f->ac);
862
    
863
    if(!f->ac){
864
        bytes_read = get_cabac_terminate(c);
865
        if(bytes_read ==0) printf("error at end of AC stream\n");
866
//printf("pos=%d\n", bytes_read);
867
        init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
868
    }
869
    
870
    if(1){
871
        const int chroma_width = -((-width )>>f->chroma_h_shift);
872
        const int chroma_height= -((-height)>>f->chroma_v_shift);
873
        decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
874
        
875
        decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
876
        decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
877
    }
878
        
879
    emms_c();
880

    
881
    f->picture_number++;
882

    
883
    *picture= *p;
884
    
885
    avctx->release_buffer(avctx, p); //FIXME
886

    
887
    *data_size = sizeof(AVFrame);
888
    
889
    if(f->ac){
890
        bytes_read= get_cabac_terminate(c);
891
        if(bytes_read ==0) printf("error at end of frame\n");
892
    }else{
893
        bytes_read+= (get_bits_count(&f->gb)+7)/8;
894
    }
895

    
896
    return bytes_read;
897
}
898

    
899
static int decode_end(AVCodecContext *avctx)
900
{
901
    FFV1Context *s = avctx->priv_data;
902
    int i;
903
    
904
    if(avctx->get_buffer == avcodec_default_get_buffer){
905
        for(i=0; i<4; i++){
906
            av_freep(&s->picture.base[i]);
907
            s->picture.data[i]= NULL;
908
        }
909
        av_freep(&s->picture.opaque);
910
    }
911

    
912
    return 0;
913
}
914

    
915
AVCodec ffv1_decoder = {
916
    "ffv1",
917
    CODEC_TYPE_VIDEO,
918
    CODEC_ID_FFV1,
919
    sizeof(FFV1Context),
920
    decode_init,
921
    NULL,
922
    decode_end,
923
    decode_frame,
924
    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
925
    NULL
926
};
927

    
928
#ifdef CONFIG_ENCODERS
929
AVCodec ffv1_encoder = {
930
    "ffv1",
931
    CODEC_TYPE_VIDEO,
932
    CODEC_ID_FFV1,
933
    sizeof(FFV1Context),
934
    encode_init,
935
    encode_frame,
936
    encode_end,
937
};
938
#endif