Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ 199436b9

History | View | Annotate | Download (29.9 KB)

1
/*
2
 * FFV1 codec for libavcodec
3
 *
4
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22

    
23
/**
24
 * @file ffv1.c
25
 * FF Video Codec 1 (an experimental lossless codec)
26
 */
27

    
28
#include "avcodec.h"
29
#include "bitstream.h"
30
#include "dsputil.h"
31
#include "rangecoder.h"
32
#include "golomb.h"
33
#include "mathops.h"
34

    
35
#define MAX_PLANES 4
36
#define CONTEXT_SIZE 32
37

    
38
extern const uint8_t ff_log2_run[32];
39

    
40
static const int8_t quant3[256]={
41
 0, 0, 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,-1,
53
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
54
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
55
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
56
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
57
};
58
static const int8_t quant5[256]={
59
 0, 1, 1, 1, 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,-2,-2,-2,
71
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
72
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
73
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
74
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
75
};
76
static const int8_t quant7[256]={
77
 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
78
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
79
 2, 2, 2, 2, 2, 2, 2, 2, 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,-3,-3,-3,-3,-3,-3,-3,
87
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
88
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
89
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
90
-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
91
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
92
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
93
};
94
static const int8_t quant9[256]={
95
 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
96
 3, 3, 3, 3, 3, 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,-4,-4,-4,-4,
106
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
107
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
108
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
109
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
110
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
111
};
112
static const int8_t quant11[256]={
113
 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
114
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
115
 4, 4, 4, 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,-5,-5,
123
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
124
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
125
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
126
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
127
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
128
-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
129
};
130
static const int8_t quant13[256]={
131
 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
132
 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
133
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
134
 5, 5, 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,-6,
140
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
141
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
142
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
143
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
144
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
145
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
146
-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
147
};
148

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

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

    
163
typedef struct FFV1Context{
164
    AVCodecContext *avctx;
165
    RangeCoder c;
166
    GetBitContext gb;
167
    PutBitContext pb;
168
    int version;
169
    int width, height;
170
    int chroma_h_shift, chroma_v_shift;
171
    int flags;
172
    int picture_number;
173
    AVFrame picture;
174
    int plane_count;
175
    int ac;                              ///< 1-> CABAC 0-> golomb rice
176
    PlaneContext plane[MAX_PLANES];
177
    int16_t quant_table[5][256];
178
    int run_index;
179
    int colorspace;
180

    
181
    DSPContext dsp;
182
}FFV1Context;
183

    
184
static av_always_inline int fold(int diff, int bits){
185
    if(bits==8)
186
        diff= (int8_t)diff;
187
    else{
188
        diff+= 1<<(bits-1);
189
        diff&=(1<<bits)-1;
190
        diff-= 1<<(bits-1);
191
    }
192

    
193
    return diff;
194
}
195

    
196
static inline int predict(int_fast16_t *src, int_fast16_t *last){
197
    const int LT= last[-1];
198
    const int  T= last[ 0];
199
    const int L =  src[-1];
200

    
201
    return mid_pred(L, L + T - LT, T);
202
}
203

    
204
static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
205
    const int LT= last[-1];
206
    const int  T= last[ 0];
207
    const int RT= last[ 1];
208
    const int L =  src[-1];
209

    
210
    if(f->quant_table[3][127]){
211
        const int TT= last2[0];
212
        const int LL=  src[-2];
213
        return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
214
              +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
215
    }else
216
        return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
217
}
218

    
219
static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
220
    int i;
221

    
222
    if(v){
223
        const int a= FFABS(v);
224
        const int e= av_log2(a);
225
        put_rac(c, state+0, 0);
226

    
227
        assert(e<=9);
228

    
229
        for(i=0; i<e; i++){
230
            put_rac(c, state+1+i, 1);  //1..10
231
        }
232
        put_rac(c, state+1+i, 0);
233

    
234
        for(i=e-1; i>=0; i--){
235
            put_rac(c, state+22+i, (a>>i)&1); //22..31
236
        }
237

    
238
        if(is_signed)
239
            put_rac(c, state+11 + e, v < 0); //11..21
240
    }else{
241
        put_rac(c, state+0, 1);
242
    }
243
}
244

    
245
static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
246
    if(get_rac(c, state+0))
247
        return 0;
248
    else{
249
        int i, e, a;
250
        e= 0;
251
        while(get_rac(c, state+1 + e)){ //1..10
252
            e++;
253
        }
254
        assert(e<=9);
255

    
256
        a= 1;
257
        for(i=e-1; i>=0; i--){
258
            a += a + get_rac(c, state+22 + i); //22..31
259
        }
260

    
261
        if(is_signed && get_rac(c, state+11 + e)) //11..21
262
            return -a;
263
        else
264
            return a;
265
    }
266
}
267

    
268
static inline void update_vlc_state(VlcState * const state, const int v){
269
    int drift= state->drift;
270
    int count= state->count;
271
    state->error_sum += FFABS(v);
272
    drift += v;
273

    
274
    if(count == 128){ //FIXME variable
275
        count >>= 1;
276
        drift >>= 1;
277
        state->error_sum >>= 1;
278
    }
279
    count++;
280

    
281
    if(drift <= -count){
282
        if(state->bias > -128) state->bias--;
283

    
284
        drift += count;
285
        if(drift <= -count)
286
            drift= -count + 1;
287
    }else if(drift > 0){
288
        if(state->bias <  127) state->bias++;
289

    
290
        drift -= count;
291
        if(drift > 0)
292
            drift= 0;
293
    }
294

    
295
    state->drift= drift;
296
    state->count= count;
297
}
298

    
299
static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
300
    int i, k, code;
301
//printf("final: %d ", v);
302
    v = fold(v - state->bias, bits);
303

    
304
    i= state->count;
305
    k=0;
306
    while(i < state->error_sum){ //FIXME optimize
307
        k++;
308
        i += i;
309
    }
310

    
311
    assert(k<=8);
312

    
313
#if 0 // JPEG LS
314
    if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
315
    else                                         code= v;
316
#else
317
     code= v ^ ((2*state->drift + state->count)>>31);
318
#endif
319

    
320
//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);
321
    set_sr_golomb(pb, code, k, 12, bits);
322

    
323
    update_vlc_state(state, v);
324
}
325

    
326
static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
327
    int k, i, v, ret;
328

    
329
    i= state->count;
330
    k=0;
331
    while(i < state->error_sum){ //FIXME optimize
332
        k++;
333
        i += i;
334
    }
335

    
336
    assert(k<=8);
337

    
338
    v= get_sr_golomb(gb, k, 12, bits);
339
//printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
340

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

    
347
    ret= fold(v + state->bias, bits);
348

    
349
    update_vlc_state(state, v);
350
//printf("final: %d\n", ret);
351
    return ret;
352
}
353

    
354
#if CONFIG_FFV1_ENCODER
355
static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
356
    PlaneContext * const p= &s->plane[plane_index];
357
    RangeCoder * const c= &s->c;
358
    int x;
359
    int run_index= s->run_index;
360
    int run_count=0;
361
    int run_mode=0;
362

    
363
    if(s->ac){
364
        if(c->bytestream_end - c->bytestream < w*20){
365
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
366
            return -1;
367
        }
368
    }else{
369
        if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
370
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
371
            return -1;
372
        }
373
    }
374

    
375
    for(x=0; x<w; x++){
376
        int diff, context;
377

    
378
        context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
379
        diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
380

    
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);
390
        }else{
391
            if(context == 0) run_mode=1;
392

    
393
            if(run_mode){
394

    
395
                if(diff){
396
                    while(run_count >= 1<<ff_log2_run[run_index]){
397
                        run_count -= 1<<ff_log2_run[run_index];
398
                        run_index++;
399
                        put_bits(&s->pb, 1, 1);
400
                    }
401

    
402
                    put_bits(&s->pb, 1 + ff_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)put_bits_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<<ff_log2_run[run_index]){
420
            run_count -= 1<<ff_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
    return 0;
431
}
432

    
433
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
434
    int x,y,i;
435
    const int ring_size= s->avctx->context_model ? 3 : 2;
436
    int_fast16_t sample_buffer[ring_size][w+6], *sample[ring_size];
437
    s->run_index=0;
438

    
439
    memset(sample_buffer, 0, sizeof(sample_buffer));
440

    
441
    for(y=0; y<h; y++){
442
        for(i=0; i<ring_size; i++)
443
            sample[i]= sample_buffer[(h+i-y)%ring_size]+3;
444

    
445
        sample[0][-1]= sample[1][0  ];
446
        sample[1][ w]= sample[1][w-1];
447
//{START_TIMER
448
        for(x=0; x<w; x++){
449
            sample[0][x]= src[x + stride*y];
450
        }
451
        encode_line(s, w, sample, plane_index, 8);
452
//STOP_TIMER("encode line")}
453
    }
454
}
455

    
456
static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
457
    int x, y, p, i;
458
    const int ring_size= s->avctx->context_model ? 3 : 2;
459
    int_fast16_t sample_buffer[3][ring_size][w+6], *sample[3][ring_size];
460
    s->run_index=0;
461

    
462
    memset(sample_buffer, 0, sizeof(sample_buffer));
463

    
464
    for(y=0; y<h; y++){
465
        for(i=0; i<ring_size; i++)
466
            for(p=0; p<3; p++)
467
                sample[p][i]= sample_buffer[p][(h+i-y)%ring_size]+3;
468

    
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
            sample[p][0][-1]= sample[p][1][0  ];
489
            sample[p][1][ w]= sample[p][1][w-1];
490
            encode_line(s, w, sample[p], FFMIN(p, 1), 9);
491
        }
492
    }
493
}
494

    
495
static void write_quant_table(RangeCoder *c, int16_t *quant_table){
496
    int last=0;
497
    int i;
498
    uint8_t state[CONTEXT_SIZE];
499
    memset(state, 128, sizeof(state));
500

    
501
    for(i=1; i<128 ; i++){
502
        if(quant_table[i] != quant_table[i-1]){
503
            put_symbol(c, state, i-last-1, 0);
504
            last= i;
505
        }
506
    }
507
    put_symbol(c, state, i-last-1, 0);
508
}
509

    
510
static void write_header(FFV1Context *f){
511
    uint8_t state[CONTEXT_SIZE];
512
    int i;
513
    RangeCoder * const c= &f->c;
514

    
515
    memset(state, 128, sizeof(state));
516

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

    
525
    for(i=0; i<5; i++)
526
        write_quant_table(c, f->quant_table[i]);
527
}
528
#endif /* CONFIG_FFV1_ENCODER */
529

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

    
534
    s->avctx= avctx;
535
    s->flags= avctx->flags;
536

    
537
    dsputil_init(&s->dsp, avctx);
538

    
539
    width= s->width= avctx->width;
540
    height= s->height= avctx->height;
541

    
542
    assert(width && height);
543

    
544
    return 0;
545
}
546

    
547
#if CONFIG_FFV1_ENCODER
548
static av_cold 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_RGB32:
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
#endif /* CONFIG_FFV1_ENCODER */
612

    
613

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

    
617
    for(i=0; i<f->plane_count; i++){
618
        PlaneContext *p= &f->plane[i];
619

    
620
        p->interlace_bit_state[0]= 128;
621
        p->interlace_bit_state[1]= 128;
622

    
623
        for(j=0; j<p->context_count; j++){
624
            if(f->ac){
625
                memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
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
#if CONFIG_FFV1_ENCODER
637
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
638
    FFV1Context *f = avctx->priv_data;
639
    RangeCoder * const c= &f->c;
640
    AVFrame *pict = data;
641
    const int width= f->width;
642
    const int height= f->height;
643
    AVFrame * const p= &f->picture;
644
    int used_count= 0;
645
    uint8_t keystate=128;
646

    
647
    ff_init_range_encoder(c, buf, buf_size);
648
//    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
649
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
650

    
651
    *p = *pict;
652
    p->pict_type= FF_I_TYPE;
653

    
654
    if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
655
        put_rac(c, &keystate, 1);
656
        p->key_frame= 1;
657
        write_header(f);
658
        clear_state(f);
659
    }else{
660
        put_rac(c, &keystate, 0);
661
        p->key_frame= 0;
662
    }
663

    
664
    if(!f->ac){
665
        used_count += ff_rac_terminate(c);
666
//printf("pos=%d\n", used_count);
667
        init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
668
    }
669

    
670
    if(f->colorspace==0){
671
        const int chroma_width = -((-width )>>f->chroma_h_shift);
672
        const int chroma_height= -((-height)>>f->chroma_v_shift);
673

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

    
676
        encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
677
        encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
678
    }else{
679
        encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
680
    }
681
    emms_c();
682

    
683
    f->picture_number++;
684

    
685
    if(f->ac){
686
        return ff_rac_terminate(c);
687
    }else{
688
        flush_put_bits(&f->pb); //nicer padding FIXME
689
        return used_count + (put_bits_count(&f->pb)+7)/8;
690
    }
691
}
692
#endif /* CONFIG_FFV1_ENCODER */
693

    
694
static av_cold int common_end(AVCodecContext *avctx){
695
    FFV1Context *s = avctx->priv_data;
696
    int i;
697

    
698
    for(i=0; i<s->plane_count; i++){
699
        PlaneContext *p= &s->plane[i];
700

    
701
        av_freep(&p->state);
702
        av_freep(&p->vlc_state);
703
    }
704

    
705
    return 0;
706
}
707

    
708
static inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
709
    PlaneContext * const p= &s->plane[plane_index];
710
    RangeCoder * const c= &s->c;
711
    int x;
712
    int run_count=0;
713
    int run_mode=0;
714
    int run_index= s->run_index;
715

    
716
    for(x=0; x<w; x++){
717
        int diff, context, sign;
718

    
719
        context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
720
        if(context < 0){
721
            context= -context;
722
            sign=1;
723
        }else
724
            sign=0;
725

    
726

    
727
        if(s->ac){
728
            diff= get_symbol(c, p->state[context], 1);
729
        }else{
730
            if(context == 0 && run_mode==0) run_mode=1;
731

    
732
            if(run_mode){
733
                if(run_count==0 && run_mode==1){
734
                    if(get_bits1(&s->gb)){
735
                        run_count = 1<<ff_log2_run[run_index];
736
                        if(x + run_count <= w) run_index++;
737
                    }else{
738
                        if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
739
                        else run_count=0;
740
                        if(run_index) run_index--;
741
                        run_mode=2;
742
                    }
743
                }
744
                run_count--;
745
                if(run_count < 0){
746
                    run_mode=0;
747
                    run_count=0;
748
                    diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
749
                    if(diff>=0) diff++;
750
                }else
751
                    diff=0;
752
            }else
753
                diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
754

    
755
//            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));
756
        }
757

    
758
        if(sign) diff= -diff;
759

    
760
        sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
761
    }
762
    s->run_index= run_index;
763
}
764

    
765
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
766
    int x, y;
767
    int_fast16_t sample_buffer[2][w+6];
768
    int_fast16_t *sample[2];
769
    sample[0]=sample_buffer[0]+3;
770
    sample[1]=sample_buffer[1]+3;
771

    
772
    s->run_index=0;
773

    
774
    memset(sample_buffer, 0, sizeof(sample_buffer));
775

    
776
    for(y=0; y<h; y++){
777
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
778

    
779
        sample[0]= sample[1];
780
        sample[1]= temp;
781

    
782
        sample[1][-1]= sample[0][0  ];
783
        sample[0][ w]= sample[0][w-1];
784

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

    
794
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
795
    int x, y, p;
796
    int_fast16_t sample_buffer[3][2][w+6];
797
    int_fast16_t *sample[3][2];
798
    for(x=0; x<3; x++){
799
        sample[x][0] = sample_buffer[x][0]+3;
800
        sample[x][1] = sample_buffer[x][1]+3;
801
    }
802

    
803
    s->run_index=0;
804

    
805
    memset(sample_buffer, 0, sizeof(sample_buffer));
806

    
807
    for(y=0; y<h; y++){
808
        for(p=0; p<3; p++){
809
            int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
810

    
811
            sample[p][0]= sample[p][1];
812
            sample[p][1]= temp;
813

    
814
            sample[p][1][-1]= sample[p][0][0  ];
815
            sample[p][0][ w]= sample[p][0][w-1];
816
            decode_line(s, w, sample[p], FFMIN(p, 1), 9);
817
        }
818
        for(x=0; x<w; x++){
819
            int g= sample[0][1][x];
820
            int b= sample[1][1][x];
821
            int r= sample[2][1][x];
822

    
823
//            assert(g>=0 && b>=0 && r>=0);
824
//            assert(g<256 && b<512 && r<512);
825

    
826
            b -= 0x100;
827
            r -= 0x100;
828
            g -= (b + r)>>2;
829
            b += g;
830
            r += g;
831

    
832
            src[x + stride*y]= b + (g<<8) + (r<<16);
833
        }
834
    }
835
}
836

    
837
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
838
    int v;
839
    int i=0;
840
    uint8_t state[CONTEXT_SIZE];
841

    
842
    memset(state, 128, sizeof(state));
843

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

    
847
        if(len + i > 128) return -1;
848

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

    
857
    for(i=1; i<128; i++){
858
        quant_table[256-i]= -quant_table[i];
859
    }
860
    quant_table[128]= -quant_table[127];
861

    
862
    return 2*v - 1;
863
}
864

    
865
static int read_header(FFV1Context *f){
866
    uint8_t state[CONTEXT_SIZE];
867
    int i, context_count;
868
    RangeCoder * const c= &f->c;
869

    
870
    memset(state, 128, sizeof(state));
871

    
872
    f->version= get_symbol(c, state, 0);
873
    f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
874
    f->colorspace= get_symbol(c, state, 0); //YUV cs type
875
    get_rac(c, state); //no chroma = false
876
    f->chroma_h_shift= get_symbol(c, state, 0);
877
    f->chroma_v_shift= get_symbol(c, state, 0);
878
    get_rac(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 0x22: 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_RGB32;
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 || context_count > 32768){
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 av_cold 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, const uint8_t *buf, int buf_size){
940
    FFV1Context *f = avctx->priv_data;
941
    RangeCoder * 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
    uint8_t keystate= 128;
947

    
948
    AVFrame *picture = data;
949

    
950
    ff_init_range_decoder(c, buf, buf_size);
951
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
952

    
953

    
954
    p->pict_type= FF_I_TYPE; //FIXME I vs. P
955
    if(get_rac(c, &keystate)){
956
        p->key_frame= 1;
957
        if(read_header(f) < 0)
958
            return -1;
959
        clear_state(f);
960
    }else{
961
        p->key_frame= 0;
962
    }
963
    if(!f->plane[0].state && !f->plane[0].vlc_state)
964
        return -1;
965

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

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

    
975
    if(!f->ac){
976
        bytes_read = c->bytestream - c->bytestream_start - 1;
977
        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
978
//printf("pos=%d\n", bytes_read);
979
        init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
980
    } else {
981
        bytes_read = 0; /* avoid warning */
982
    }
983

    
984
    if(f->colorspace==0){
985
        const int chroma_width = -((-width )>>f->chroma_h_shift);
986
        const int chroma_height= -((-height)>>f->chroma_v_shift);
987
        decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
988

    
989
        decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
990
        decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
991
    }else{
992
        decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
993
    }
994

    
995
    emms_c();
996

    
997
    f->picture_number++;
998

    
999
    *picture= *p;
1000

    
1001
    avctx->release_buffer(avctx, p); //FIXME
1002

    
1003
    *data_size = sizeof(AVFrame);
1004

    
1005
    if(f->ac){
1006
        bytes_read= c->bytestream - c->bytestream_start - 1;
1007
        if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1008
    }else{
1009
        bytes_read+= (get_bits_count(&f->gb)+7)/8;
1010
    }
1011

    
1012
    return bytes_read;
1013
}
1014

    
1015
AVCodec ffv1_decoder = {
1016
    "ffv1",
1017
    CODEC_TYPE_VIDEO,
1018
    CODEC_ID_FFV1,
1019
    sizeof(FFV1Context),
1020
    decode_init,
1021
    NULL,
1022
    common_end,
1023
    decode_frame,
1024
    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1025
    NULL,
1026
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg codec #1"),
1027
};
1028

    
1029
#if CONFIG_FFV1_ENCODER
1030
AVCodec ffv1_encoder = {
1031
    "ffv1",
1032
    CODEC_TYPE_VIDEO,
1033
    CODEC_ID_FFV1,
1034
    sizeof(FFV1Context),
1035
    encode_init,
1036
    encode_frame,
1037
    common_end,
1038
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_NONE},
1039
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg codec #1"),
1040
};
1041
#endif