Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ 5509bffa

History | View | Annotate | Download (29.8 KB)

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