← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/ffv1.c

  • Committer: Bazaar Package Importer
  • Author(s): Christian Marillat
  • Date: 2004-08-29 10:53:42 UTC
  • Revision ID: james.westby@ubuntu.com-20040829105342-qgmnry37eadfkoxx
Tags: upstream-1.1.3
Import upstream version 1.1.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/ffv1.c
 
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
    } else {
 
869
        bytes_read = 0; /* avoid warning */
 
870
    }
 
871
    
 
872
    if(1){
 
873
        const int chroma_width = -((-width )>>f->chroma_h_shift);
 
874
        const int chroma_height= -((-height)>>f->chroma_v_shift);
 
875
        decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
 
876
        
 
877
        decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
 
878
        decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
 
879
    }
 
880
        
 
881
    emms_c();
 
882
 
 
883
    f->picture_number++;
 
884
 
 
885
    *picture= *p;
 
886
    
 
887
    avctx->release_buffer(avctx, p); //FIXME
 
888
 
 
889
    *data_size = sizeof(AVFrame);
 
890
    
 
891
    if(f->ac){
 
892
        bytes_read= get_cabac_terminate(c);
 
893
        if(bytes_read ==0) printf("error at end of frame\n");
 
894
    }else{
 
895
        bytes_read+= (get_bits_count(&f->gb)+7)/8;
 
896
    }
 
897
 
 
898
    return bytes_read;
 
899
}
 
900
 
 
901
static int decode_end(AVCodecContext *avctx)
 
902
{
 
903
    FFV1Context *s = avctx->priv_data;
 
904
    int i;
 
905
    
 
906
    if(avctx->get_buffer == avcodec_default_get_buffer){
 
907
        for(i=0; i<4; i++){
 
908
            av_freep(&s->picture.base[i]);
 
909
            s->picture.data[i]= NULL;
 
910
        }
 
911
        av_freep(&s->picture.opaque);
 
912
    }
 
913
 
 
914
    return 0;
 
915
}
 
916
 
 
917
AVCodec ffv1_decoder = {
 
918
    "ffv1",
 
919
    CODEC_TYPE_VIDEO,
 
920
    CODEC_ID_FFV1,
 
921
    sizeof(FFV1Context),
 
922
    decode_init,
 
923
    NULL,
 
924
    decode_end,
 
925
    decode_frame,
 
926
    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
 
927
    NULL
 
928
};
 
929
 
 
930
#ifdef CONFIG_ENCODERS
 
931
AVCodec ffv1_encoder = {
 
932
    "ffv1",
 
933
    CODEC_TYPE_VIDEO,
 
934
    CODEC_ID_FFV1,
 
935
    sizeof(FFV1Context),
 
936
    encode_init,
 
937
    encode_frame,
 
938
    encode_end,
 
939
};
 
940
#endif