← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libav/trusty-proposed

« back to all changes in this revision

Viewing changes to libavcodec/ffv1.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2013-10-22 23:24:08 UTC
  • mfrom: (1.3.36 sid)
  • Revision ID: package-import@ubuntu.com-20131022232408-b8tvvn4pyzri9mi3
Tags: 6:9.10-1ubuntu1
https://launchpad.net/bugs/1243235
https://launchpad.net/bugs/1180288
https://launchpad.net/bugs/1242802
* Build all -extra flavors from this source package, as libav got demoted
  from main to universe, cf LP: #1243235
* Simplify debian/rules to follow exactly the code that debian executes
* New upstream (LP: #1180288) fixes lots of security issues (LP: #1242802)
* Merge from unstable, remaining changes:
  - build-depend on libtiff5-dev rather than libtiff4-dev,
    avoids FTBFS caused by imlib
  - follow the regular debian codepaths

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/ffv1.c
25
25
 * FF Video Codec 1 (a lossless codec)
26
26
 */
27
27
 
 
28
#include "libavutil/avassert.h"
28
29
#include "avcodec.h"
29
30
#include "get_bits.h"
30
31
#include "put_bits.h"
32
33
#include "rangecoder.h"
33
34
#include "golomb.h"
34
35
#include "mathops.h"
35
 
#include "libavutil/avassert.h"
36
 
 
37
 
#define MAX_PLANES 4
38
 
#define CONTEXT_SIZE 32
39
 
 
40
 
#define MAX_QUANT_TABLES 8
41
 
#define MAX_CONTEXT_INPUTS 5
42
 
 
43
 
extern const uint8_t ff_log2_run[41];
44
 
 
45
 
static const int8_t quant5_10bit[256]={
46
 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
50
 
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
51
 
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
52
 
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
53
 
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
54
 
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
55
 
-2,-2,-2,-2,-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,-1,
59
 
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
60
 
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
61
 
-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
62
 
};
63
 
 
64
 
static const int8_t quant5[256]={
65
 
 0, 1, 1, 1, 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,-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,-2,-2,-2,-2,-2,-2,-2,-2,
77
 
-2,-2,-2,-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,-2,-2,-2,-2,-2,-2,-2,-2,
80
 
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
81
 
};
82
 
 
83
 
static const int8_t quant9_10bit[256]={
84
 
 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
85
 
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 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, 4, 4, 4, 4, 4, 4, 4, 4,
88
 
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89
 
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90
 
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91
 
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
92
 
-4,-4,-4,-4,-4,-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,-3,-3,-3,-3,-3,-3,-3,
97
 
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
98
 
-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
99
 
-2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
100
 
};
101
 
 
102
 
static const int8_t quant11[256]={
103
 
 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 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, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
106
 
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
107
 
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
108
 
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
109
 
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
110
 
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
111
 
-5,-5,-5,-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,-4,-4,
117
 
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
118
 
-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
119
 
};
120
 
 
121
 
static const uint8_t ver2_state[256]= {
122
 
   0,  10,  10,  10,  10,  16,  16,  16,  28,  16,  16,  29,  42,  49,  20,  49,
123
 
  59,  25,  26,  26,  27,  31,  33,  33,  33,  34,  34,  37,  67,  38,  39,  39,
124
 
  40,  40,  41,  79,  43,  44,  45,  45,  48,  48,  64,  50,  51,  52,  88,  52,
125
 
  53,  74,  55,  57,  58,  58,  74,  60, 101,  61,  62,  84,  66,  66,  68,  69,
126
 
  87,  82,  71,  97,  73,  73,  82,  75, 111,  77,  94,  78,  87,  81,  83,  97,
127
 
  85,  83,  94,  86,  99,  89,  90,  99, 111,  92,  93, 134,  95,  98, 105,  98,
128
 
 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
129
 
 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
130
 
 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
131
 
 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
132
 
 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
133
 
 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
134
 
 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
135
 
 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
136
 
 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
137
 
 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
138
 
};
139
 
 
140
 
typedef struct VlcState{
141
 
    int16_t drift;
142
 
    uint16_t error_sum;
143
 
    int8_t bias;
144
 
    uint8_t count;
145
 
} VlcState;
146
 
 
147
 
typedef struct PlaneContext{
148
 
    int16_t quant_table[MAX_CONTEXT_INPUTS][256];
149
 
    int quant_table_index;
150
 
    int context_count;
151
 
    uint8_t (*state)[CONTEXT_SIZE];
152
 
    VlcState *vlc_state;
153
 
    uint8_t interlace_bit_state[2];
154
 
} PlaneContext;
155
 
 
156
 
#define MAX_SLICES 256
157
 
 
158
 
typedef struct FFV1Context{
159
 
    AVCodecContext *avctx;
160
 
    RangeCoder c;
161
 
    GetBitContext gb;
162
 
    PutBitContext pb;
163
 
    uint64_t rc_stat[256][2];
164
 
    uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
165
 
    int version;
166
 
    int width, height;
167
 
    int chroma_h_shift, chroma_v_shift;
168
 
    int flags;
169
 
    int picture_number;
170
 
    AVFrame picture;
171
 
    int plane_count;
172
 
    int ac;                              ///< 1=range coder <-> 0=golomb rice
173
 
    PlaneContext plane[MAX_PLANES];
174
 
    int16_t quant_table[MAX_CONTEXT_INPUTS][256];
175
 
    int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
176
 
    int context_count[MAX_QUANT_TABLES];
177
 
    uint8_t state_transition[256];
178
 
    uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
179
 
    int run_index;
180
 
    int colorspace;
181
 
    int16_t *sample_buffer;
182
 
    int gob_count;
183
 
 
184
 
    int quant_table_count;
185
 
 
186
 
    DSPContext dsp;
187
 
 
188
 
    struct FFV1Context *slice_context[MAX_SLICES];
189
 
    int slice_count;
190
 
    int num_v_slices;
191
 
    int num_h_slices;
192
 
    int slice_width;
193
 
    int slice_height;
194
 
    int slice_x;
195
 
    int slice_y;
196
 
}FFV1Context;
197
 
 
198
 
static av_always_inline int fold(int diff, int bits){
199
 
    if(bits==8)
200
 
        diff= (int8_t)diff;
201
 
    else{
202
 
        diff+= 1<<(bits-1);
203
 
        diff&=(1<<bits)-1;
204
 
        diff-= 1<<(bits-1);
205
 
    }
206
 
 
207
 
    return diff;
208
 
}
209
 
 
210
 
static inline int predict(int16_t *src, int16_t *last)
211
 
{
212
 
    const int LT= last[-1];
213
 
    const int  T= last[ 0];
214
 
    const int L =  src[-1];
215
 
 
216
 
    return mid_pred(L, L + T - LT, T);
217
 
}
218
 
 
219
 
static inline int get_context(PlaneContext *p, int16_t *src,
220
 
                              int16_t *last, int16_t *last2)
221
 
{
222
 
    const int LT= last[-1];
223
 
    const int  T= last[ 0];
224
 
    const int RT= last[ 1];
225
 
    const int L =  src[-1];
226
 
 
227
 
    if(p->quant_table[3][127]){
228
 
        const int TT= last2[0];
229
 
        const int LL=  src[-2];
230
 
        return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
231
 
              +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
232
 
    }else
233
 
        return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
234
 
}
235
 
 
236
 
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
237
 
    int i,j,k,m;
238
 
    double l2tab[256];
239
 
 
240
 
    for(i=1; i<256; i++)
241
 
        l2tab[i]= log2(i/256.0);
242
 
 
243
 
    for(i=0; i<256; i++){
244
 
        double best_len[256];
245
 
        double p= i/256.0;
246
 
 
247
 
        for(j=0; j<256; j++)
248
 
            best_len[j]= 1<<30;
249
 
 
250
 
        for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
251
 
            double occ[256]={0};
252
 
            double len=0;
253
 
            occ[j]=1.0;
254
 
            for(k=0; k<256; k++){
255
 
                double newocc[256]={0};
256
 
                for(m=0; m<256; m++){
257
 
                    if(occ[m]){
258
 
                        len -=occ[m]*(     p *l2tab[    m]
259
 
                                      + (1-p)*l2tab[256-m]);
260
 
                    }
261
 
                }
262
 
                if(len < best_len[k]){
263
 
                    best_len[k]= len;
264
 
                    best_state[i][k]= j;
265
 
                }
266
 
                for(m=0; m<256; m++){
267
 
                    if(occ[m]){
268
 
                        newocc[    one_state[    m]] += occ[m]*   p ;
269
 
                        newocc[256-one_state[256-m]] += occ[m]*(1-p);
270
 
                    }
271
 
                }
272
 
                memcpy(occ, newocc, sizeof(occ));
273
 
            }
274
 
        }
275
 
    }
276
 
}
277
 
 
278
 
static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2]){
279
 
    int i;
280
 
 
281
 
#define put_rac(C,S,B) \
282
 
do{\
283
 
    if(rc_stat){\
284
 
    rc_stat[*(S)][B]++;\
285
 
        rc_stat2[(S)-state][B]++;\
286
 
    }\
287
 
    put_rac(C,S,B);\
288
 
}while(0)
289
 
 
290
 
    if(v){
291
 
        const int a= FFABS(v);
292
 
        const int e= av_log2(a);
293
 
        put_rac(c, state+0, 0);
294
 
        if(e<=9){
295
 
            for(i=0; i<e; i++){
296
 
                put_rac(c, state+1+i, 1);  //1..10
297
 
            }
298
 
            put_rac(c, state+1+i, 0);
299
 
 
300
 
            for(i=e-1; i>=0; i--){
301
 
                put_rac(c, state+22+i, (a>>i)&1); //22..31
302
 
            }
303
 
 
304
 
            if(is_signed)
305
 
                put_rac(c, state+11 + e, v < 0); //11..21
306
 
        }else{
307
 
            for(i=0; i<e; i++){
308
 
                put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
309
 
            }
310
 
            put_rac(c, state+1+9, 0);
311
 
 
312
 
            for(i=e-1; i>=0; i--){
313
 
                put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
314
 
            }
315
 
 
316
 
            if(is_signed)
317
 
                put_rac(c, state+11 + 10, v < 0); //11..21
318
 
        }
319
 
    }else{
320
 
        put_rac(c, state+0, 1);
321
 
    }
322
 
#undef put_rac
323
 
}
324
 
 
325
 
static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
326
 
    put_symbol_inline(c, state, v, is_signed, NULL, NULL);
327
 
}
328
 
 
329
 
static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
330
 
    if(get_rac(c, state+0))
331
 
        return 0;
332
 
    else{
333
 
        int i, e, a;
334
 
        e= 0;
335
 
        while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
336
 
            e++;
337
 
        }
338
 
 
339
 
        a= 1;
340
 
        for(i=e-1; i>=0; i--){
341
 
            a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
342
 
        }
343
 
 
344
 
        e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
345
 
        return (a^e)-e;
346
 
    }
347
 
}
348
 
 
349
 
static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
350
 
    return get_symbol_inline(c, state, is_signed);
351
 
}
352
 
 
353
 
static inline void update_vlc_state(VlcState * const state, const int v){
354
 
    int drift= state->drift;
355
 
    int count= state->count;
356
 
    state->error_sum += FFABS(v);
357
 
    drift += v;
358
 
 
359
 
    if(count == 128){ //FIXME variable
360
 
        count >>= 1;
361
 
        drift >>= 1;
362
 
        state->error_sum >>= 1;
363
 
    }
364
 
    count++;
365
 
 
366
 
    if(drift <= -count){
367
 
        if(state->bias > -128) state->bias--;
368
 
 
369
 
        drift += count;
370
 
        if(drift <= -count)
371
 
            drift= -count + 1;
372
 
    }else if(drift > 0){
373
 
        if(state->bias <  127) state->bias++;
374
 
 
375
 
        drift -= count;
376
 
        if(drift > 0)
377
 
            drift= 0;
378
 
    }
379
 
 
380
 
    state->drift= drift;
381
 
    state->count= count;
382
 
}
383
 
 
384
 
static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
385
 
    int i, k, code;
386
 
//printf("final: %d ", v);
387
 
    v = fold(v - state->bias, bits);
388
 
 
389
 
    i= state->count;
390
 
    k=0;
391
 
    while(i < state->error_sum){ //FIXME optimize
392
 
        k++;
393
 
        i += i;
394
 
    }
395
 
 
396
 
    assert(k<=8);
397
 
 
398
 
#if 0 // JPEG LS
399
 
    if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
400
 
    else                                         code= v;
401
 
#else
402
 
     code= v ^ ((2*state->drift + state->count)>>31);
403
 
#endif
404
 
 
405
 
//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);
406
 
    set_sr_golomb(pb, code, k, 12, bits);
407
 
 
408
 
    update_vlc_state(state, v);
409
 
}
410
 
 
411
 
static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
412
 
    int k, i, v, ret;
413
 
 
414
 
    i= state->count;
415
 
    k=0;
416
 
    while(i < state->error_sum){ //FIXME optimize
417
 
        k++;
418
 
        i += i;
419
 
    }
420
 
 
421
 
    assert(k<=8);
422
 
 
423
 
    v= get_sr_golomb(gb, k, 12, bits);
424
 
//printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
425
 
 
426
 
#if 0 // JPEG LS
427
 
    if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
428
 
#else
429
 
     v ^= ((2*state->drift + state->count)>>31);
430
 
#endif
431
 
 
432
 
    ret= fold(v + state->bias, bits);
433
 
 
434
 
    update_vlc_state(state, v);
435
 
//printf("final: %d\n", ret);
436
 
    return ret;
437
 
}
438
 
 
439
 
#if CONFIG_FFV1_ENCODER
440
 
static av_always_inline int encode_line(FFV1Context *s, int w,
441
 
                                        int16_t *sample[2],
442
 
                                        int plane_index, int bits)
443
 
{
444
 
    PlaneContext * const p= &s->plane[plane_index];
445
 
    RangeCoder * const c= &s->c;
446
 
    int x;
447
 
    int run_index= s->run_index;
448
 
    int run_count=0;
449
 
    int run_mode=0;
450
 
 
451
 
    if(s->ac){
452
 
        if(c->bytestream_end - c->bytestream < w*20){
453
 
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
454
 
            return -1;
455
 
        }
456
 
    }else{
457
 
        if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
458
 
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
459
 
            return -1;
460
 
        }
461
 
    }
462
 
 
463
 
    for(x=0; x<w; x++){
464
 
        int diff, context;
465
 
 
466
 
        context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
467
 
        diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
468
 
 
469
 
        if(context < 0){
470
 
            context = -context;
471
 
            diff= -diff;
472
 
        }
473
 
 
474
 
        diff= fold(diff, bits);
475
 
 
476
 
        if(s->ac){
477
 
            if(s->flags & CODEC_FLAG_PASS1){
478
 
                put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
479
 
            }else{
480
 
                put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
481
 
            }
482
 
        }else{
483
 
            if(context == 0) run_mode=1;
484
 
 
485
 
            if(run_mode){
486
 
 
487
 
                if(diff){
488
 
                    while(run_count >= 1<<ff_log2_run[run_index]){
489
 
                        run_count -= 1<<ff_log2_run[run_index];
490
 
                        run_index++;
491
 
                        put_bits(&s->pb, 1, 1);
492
 
                    }
493
 
 
494
 
                    put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
495
 
                    if(run_index) run_index--;
496
 
                    run_count=0;
497
 
                    run_mode=0;
498
 
                    if(diff>0) diff--;
499
 
                }else{
500
 
                    run_count++;
501
 
                }
502
 
            }
503
 
 
504
 
//            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));
505
 
 
506
 
            if(run_mode == 0)
507
 
                put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
508
 
        }
509
 
    }
510
 
    if(run_mode){
511
 
        while(run_count >= 1<<ff_log2_run[run_index]){
512
 
            run_count -= 1<<ff_log2_run[run_index];
513
 
            run_index++;
514
 
            put_bits(&s->pb, 1, 1);
515
 
        }
516
 
 
517
 
        if(run_count)
518
 
            put_bits(&s->pb, 1, 1);
519
 
    }
520
 
    s->run_index= run_index;
521
 
 
522
 
    return 0;
523
 
}
524
 
 
525
 
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
526
 
    int x,y,i;
527
 
    const int ring_size= s->avctx->context_model ? 3 : 2;
528
 
    int16_t *sample[3];
529
 
    s->run_index=0;
530
 
 
531
 
    memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
532
 
 
533
 
    for(y=0; y<h; y++){
534
 
        for(i=0; i<ring_size; i++)
535
 
            sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
536
 
 
537
 
        sample[0][-1]= sample[1][0  ];
538
 
        sample[1][ w]= sample[1][w-1];
539
 
//{START_TIMER
540
 
        if(s->avctx->bits_per_raw_sample<=8){
541
 
            for(x=0; x<w; x++){
542
 
                sample[0][x]= src[x + stride*y];
543
 
            }
544
 
            encode_line(s, w, sample, plane_index, 8);
545
 
        }else{
546
 
            for(x=0; x<w; x++){
547
 
                sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
548
 
            }
549
 
            encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
550
 
        }
551
 
//STOP_TIMER("encode line")}
552
 
    }
553
 
}
554
 
 
555
 
static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
556
 
    int x, y, p, i;
557
 
    const int ring_size= s->avctx->context_model ? 3 : 2;
558
 
    int16_t *sample[3][3];
559
 
    s->run_index=0;
560
 
 
561
 
    memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
562
 
 
563
 
    for(y=0; y<h; y++){
564
 
        for(i=0; i<ring_size; i++)
565
 
            for(p=0; p<3; p++)
566
 
                sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
567
 
 
568
 
        for(x=0; x<w; x++){
569
 
            int v= src[x + stride*y];
570
 
            int b= v&0xFF;
571
 
            int g= (v>>8)&0xFF;
572
 
            int r= (v>>16)&0xFF;
573
 
 
574
 
            b -= g;
575
 
            r -= g;
576
 
            g += (b + r)>>2;
577
 
            b += 0x100;
578
 
            r += 0x100;
579
 
 
580
 
//            assert(g>=0 && b>=0 && r>=0);
581
 
//            assert(g<256 && b<512 && r<512);
582
 
            sample[0][0][x]= g;
583
 
            sample[1][0][x]= b;
584
 
            sample[2][0][x]= r;
585
 
        }
586
 
        for(p=0; p<3; p++){
587
 
            sample[p][0][-1]= sample[p][1][0  ];
588
 
            sample[p][1][ w]= sample[p][1][w-1];
589
 
            encode_line(s, w, sample[p], FFMIN(p, 1), 9);
590
 
        }
591
 
    }
592
 
}
593
 
 
594
 
static void write_quant_table(RangeCoder *c, int16_t *quant_table){
595
 
    int last=0;
596
 
    int i;
597
 
    uint8_t state[CONTEXT_SIZE];
598
 
    memset(state, 128, sizeof(state));
599
 
 
600
 
    for(i=1; i<128 ; i++){
601
 
        if(quant_table[i] != quant_table[i-1]){
602
 
            put_symbol(c, state, i-last-1, 0);
603
 
            last= i;
604
 
        }
605
 
    }
606
 
    put_symbol(c, state, i-last-1, 0);
607
 
}
608
 
 
609
 
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
610
 
    int i;
611
 
    for(i=0; i<5; i++)
612
 
        write_quant_table(c, quant_table[i]);
613
 
}
614
 
 
615
 
static void write_header(FFV1Context *f){
616
 
    uint8_t state[CONTEXT_SIZE];
617
 
    int i, j;
618
 
    RangeCoder * const c= &f->slice_context[0]->c;
619
 
 
620
 
    memset(state, 128, sizeof(state));
621
 
 
622
 
    if(f->version < 2){
623
 
        put_symbol(c, state, f->version, 0);
624
 
        put_symbol(c, state, f->ac, 0);
625
 
        if(f->ac>1){
626
 
            for(i=1; i<256; i++){
627
 
                put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
628
 
            }
629
 
        }
630
 
        put_symbol(c, state, f->colorspace, 0); //YUV cs type
631
 
        if(f->version>0)
632
 
            put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
633
 
        put_rac(c, state, 1); //chroma planes
634
 
            put_symbol(c, state, f->chroma_h_shift, 0);
635
 
            put_symbol(c, state, f->chroma_v_shift, 0);
636
 
        put_rac(c, state, 0); //no transparency plane
637
 
 
638
 
        write_quant_tables(c, f->quant_table);
639
 
    }else{
640
 
        put_symbol(c, state, f->slice_count, 0);
641
 
        for(i=0; i<f->slice_count; i++){
642
 
            FFV1Context *fs= f->slice_context[i];
643
 
            put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
644
 
            put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
645
 
            put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
646
 
            put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
647
 
            for(j=0; j<f->plane_count; j++){
648
 
                put_symbol(c, state, f->plane[j].quant_table_index, 0);
649
 
                av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
650
 
            }
651
 
        }
652
 
    }
653
 
}
654
 
#endif /* CONFIG_FFV1_ENCODER */
655
 
 
656
 
static av_cold int common_init(AVCodecContext *avctx){
 
36
#include "ffv1.h"
 
37
 
 
38
const int8_t ffv1_quant5_10bit[256] = {
 
39
     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  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,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
 
43
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
 
44
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
 
45
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
 
46
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
 
47
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
 
48
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
 
49
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
 
50
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
 
51
    -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -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, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,
 
55
};
 
56
 
 
57
const int8_t ffv1_quant5[256] = {
 
58
     0,  1,  1,  1,  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, -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, -1, -1, -1,
 
74
};
 
75
 
 
76
const int8_t ffv1_quant9_10bit[256] = {
 
77
     0,  0,  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,
 
78
     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  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,  4,  4,  4,  4,  4,  4,  4,  4,
 
81
     4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
 
82
     4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
 
83
     4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
 
84
     4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
 
85
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
 
86
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
 
87
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
 
88
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
 
89
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,
 
90
    -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
 
91
    -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
 
92
    -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,
 
93
};
 
94
 
 
95
const int8_t ffv1_quant11[256] = {
 
96
     0,  1,  2,  2,  2,  3,  3,  3,  3,  3,  3,  3,  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,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
 
99
     5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
 
100
     5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
 
101
     5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
 
102
     5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
 
103
     5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
 
104
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
 
105
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
 
106
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
 
107
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
 
108
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,
 
109
    -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,
 
110
    -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,
 
111
    -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,
 
112
};
 
113
 
 
114
const uint8_t ffv1_ver2_state[256] = {
 
115
      0,  10,  10,  10,  10,  16,  16,  16,  28,  16,  16,  29,  42,  49,  20,  49,
 
116
     59,  25,  26,  26,  27,  31,  33,  33,  33,  34,  34,  37,  67,  38,  39,  39,
 
117
     40,  40,  41,  79,  43,  44,  45,  45,  48,  48,  64,  50,  51,  52,  88,  52,
 
118
     53,  74,  55,  57,  58,  58,  74,  60,  101, 61,  62,  84,  66,  66,  68,  69,
 
119
     87,  82,  71,  97,  73,  73,  82,  75,  111, 77,  94,  78,  87,  81,  83,  97,
 
120
     85,  83,  94,  86,  99,  89,  90,  99,  111, 92,  93,  134, 95,  98,  105, 98,
 
121
    105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
 
122
    115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
 
123
    165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
 
124
    147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
 
125
    172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
 
126
    175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
 
127
    197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
 
128
    209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
 
129
    226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
 
130
    241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
 
131
};
 
132
 
 
133
 
 
134
int ffv1_common_init(AVCodecContext *avctx)
 
135
{
657
136
    FFV1Context *s = avctx->priv_data;
658
137
 
659
 
    s->avctx= avctx;
660
 
    s->flags= avctx->flags;
661
 
 
662
 
    dsputil_init(&s->dsp, avctx);
663
 
 
664
 
    s->width = avctx->width;
665
 
    s->height= avctx->height;
666
 
 
667
 
    assert(s->width && s->height);
668
 
    //defaults
669
 
    s->num_h_slices=1;
670
 
    s->num_v_slices=1;
671
 
 
672
 
 
673
 
    return 0;
674
 
}
675
 
 
676
 
static int init_slice_state(FFV1Context *f){
677
 
    int i, j;
678
 
 
679
 
    for(i=0; i<f->slice_count; i++){
680
 
        FFV1Context *fs= f->slice_context[i];
681
 
        for(j=0; j<f->plane_count; j++){
682
 
            PlaneContext * const p= &fs->plane[j];
683
 
 
684
 
            if(fs->ac){
685
 
                if(!p->    state) p->    state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
686
 
                if(!p->    state)
687
 
                    return AVERROR(ENOMEM);
688
 
            }else{
689
 
                if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
690
 
                if(!p->vlc_state)
691
 
                    return AVERROR(ENOMEM);
692
 
            }
693
 
        }
694
 
 
695
 
        if (fs->ac>1){
696
 
            //FIXME only redo if state_transition changed
697
 
            for(j=1; j<256; j++){
698
 
                fs->c.one_state [    j]= fs->state_transition[j];
699
 
                fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
700
 
            }
701
 
        }
702
 
    }
703
 
 
704
 
    return 0;
705
 
}
706
 
 
707
 
static av_cold int init_slice_contexts(FFV1Context *f){
 
138
    s->avctx = avctx;
 
139
    s->flags = avctx->flags;
 
140
 
 
141
    if (!avctx->width || !avctx->height)
 
142
        return AVERROR_INVALIDDATA;
 
143
 
 
144
    avcodec_get_frame_defaults(&s->picture);
 
145
 
 
146
    ff_dsputil_init(&s->dsp, avctx);
 
147
 
 
148
    s->width  = avctx->width;
 
149
    s->height = avctx->height;
 
150
 
 
151
    // defaults
 
152
    s->num_h_slices = 1;
 
153
    s->num_v_slices = 1;
 
154
 
 
155
    return 0;
 
156
}
 
157
 
 
158
int ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs)
 
159
{
 
160
    int j;
 
161
 
 
162
    fs->plane_count  = f->plane_count;
 
163
    fs->transparency = f->transparency;
 
164
    for (j = 0; j < f->plane_count; j++) {
 
165
        PlaneContext *const p = &fs->plane[j];
 
166
 
 
167
        if (fs->ac) {
 
168
            if (!p->state)
 
169
                p->state = av_malloc(CONTEXT_SIZE * p->context_count *
 
170
                                     sizeof(uint8_t));
 
171
            if (!p->state)
 
172
                return AVERROR(ENOMEM);
 
173
        } else {
 
174
            if (!p->vlc_state)
 
175
                p->vlc_state = av_malloc(p->context_count * sizeof(VlcState));
 
176
            if (!p->vlc_state)
 
177
                return AVERROR(ENOMEM);
 
178
        }
 
179
    }
 
180
 
 
181
    if (fs->ac > 1) {
 
182
        //FIXME only redo if state_transition changed
 
183
        for (j = 1; j < 256; j++) {
 
184
            fs->c.one_state[j]        = f->state_transition[j];
 
185
            fs->c.zero_state[256 - j] = 256 - fs->c.one_state[j];
 
186
        }
 
187
    }
 
188
 
 
189
    return 0;
 
190
}
 
191
 
 
192
av_cold int ffv1_init_slice_contexts(FFV1Context *f)
 
193
{
708
194
    int i;
709
195
 
710
 
    f->slice_count= f->num_h_slices * f->num_v_slices;
 
196
    f->slice_count = f->num_h_slices * f->num_v_slices;
 
197
    if (f->slice_count <= 0) {
 
198
        av_log(f->avctx, AV_LOG_ERROR, "Invalid number of slices\n");
 
199
        return AVERROR(EINVAL);
 
200
    }
711
201
 
712
 
    for(i=0; i<f->slice_count; i++){
713
 
        FFV1Context *fs= av_mallocz(sizeof(*fs));
714
 
        int sx= i % f->num_h_slices;
715
 
        int sy= i / f->num_h_slices;
716
 
        int sxs= f->avctx->width * sx    / f->num_h_slices;
717
 
        int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
718
 
        int sys= f->avctx->height* sy    / f->num_v_slices;
719
 
        int sye= f->avctx->height*(sy+1) / f->num_v_slices;
720
 
        f->slice_context[i]= fs;
 
202
    for (i = 0; i < f->slice_count; i++) {
 
203
        FFV1Context *fs = av_mallocz(sizeof(*fs));
 
204
        int sx          = i % f->num_h_slices;
 
205
        int sy          = i / f->num_h_slices;
 
206
        int sxs         = f->avctx->width  *  sx      / f->num_h_slices;
 
207
        int sxe         = f->avctx->width  * (sx + 1) / f->num_h_slices;
 
208
        int sys         = f->avctx->height *  sy      / f->num_v_slices;
 
209
        int sye         = f->avctx->height * (sy + 1) / f->num_v_slices;
 
210
        f->slice_context[i] = fs;
721
211
        memcpy(fs, f, sizeof(*fs));
722
212
        memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
723
213
 
724
 
        fs->slice_width = sxe - sxs;
725
 
        fs->slice_height= sye - sys;
726
 
        fs->slice_x     = sxs;
727
 
        fs->slice_y     = sys;
 
214
        fs->slice_width  = sxe - sxs;
 
215
        fs->slice_height = sye - sys;
 
216
        fs->slice_x      = sxs;
 
217
        fs->slice_y      = sys;
728
218
 
729
 
        fs->sample_buffer = av_malloc(9 * (fs->width+6) * sizeof(*fs->sample_buffer));
 
219
        fs->sample_buffer = av_malloc(3 * MAX_PLANES * (fs->width + 6) *
 
220
                                      sizeof(*fs->sample_buffer));
730
221
        if (!fs->sample_buffer)
731
222
            return AVERROR(ENOMEM);
732
223
    }
733
224
    return 0;
734
225
}
735
226
 
736
 
static int allocate_initial_states(FFV1Context *f){
 
227
int ffv1_allocate_initial_states(FFV1Context *f)
 
228
{
737
229
    int i;
738
230
 
739
 
    for(i=0; i<f->quant_table_count; i++){
740
 
        f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
741
 
        if(!f->initial_states[i])
 
231
    for (i = 0; i < f->quant_table_count; i++) {
 
232
        f->initial_states[i] = av_malloc(f->context_count[i] *
 
233
                                         sizeof(*f->initial_states[i]));
 
234
        if (!f->initial_states[i])
742
235
            return AVERROR(ENOMEM);
743
 
        memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
744
 
    }
745
 
    return 0;
746
 
}
747
 
 
748
 
#if CONFIG_FFV1_ENCODER
749
 
static int write_extra_header(FFV1Context *f){
750
 
    RangeCoder * const c= &f->c;
751
 
    uint8_t state[CONTEXT_SIZE];
752
 
    int i, j, k;
753
 
    uint8_t state2[32][CONTEXT_SIZE];
754
 
 
755
 
    memset(state2, 128, sizeof(state2));
756
 
    memset(state, 128, sizeof(state));
757
 
 
758
 
    f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
759
 
    ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
760
 
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
761
 
 
762
 
    put_symbol(c, state, f->version, 0);
763
 
    put_symbol(c, state, f->ac, 0);
764
 
    if(f->ac>1){
765
 
        for(i=1; i<256; i++){
766
 
            put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
767
 
        }
768
 
    }
769
 
    put_symbol(c, state, f->colorspace, 0); //YUV cs type
770
 
    put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
771
 
    put_rac(c, state, 1); //chroma planes
772
 
        put_symbol(c, state, f->chroma_h_shift, 0);
773
 
        put_symbol(c, state, f->chroma_v_shift, 0);
774
 
    put_rac(c, state, 0); //no transparency plane
775
 
    put_symbol(c, state, f->num_h_slices-1, 0);
776
 
    put_symbol(c, state, f->num_v_slices-1, 0);
777
 
 
778
 
    put_symbol(c, state, f->quant_table_count, 0);
779
 
    for(i=0; i<f->quant_table_count; i++)
780
 
        write_quant_tables(c, f->quant_tables[i]);
781
 
 
782
 
    for(i=0; i<f->quant_table_count; i++){
783
 
        for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
784
 
            if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
785
 
                break;
786
 
        if(j<f->context_count[i]*CONTEXT_SIZE){
787
 
            put_rac(c, state, 1);
788
 
            for(j=0; j<f->context_count[i]; j++){
789
 
                for(k=0; k<CONTEXT_SIZE; k++){
790
 
                    int pred= j ? f->initial_states[i][j-1][k] : 128;
791
 
                    put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
792
 
                }
793
 
            }
794
 
        }else{
795
 
            put_rac(c, state, 0);
796
 
        }
797
 
    }
798
 
 
799
 
    f->avctx->extradata_size= ff_rac_terminate(c);
800
 
 
801
 
    return 0;
802
 
}
803
 
 
804
 
static int sort_stt(FFV1Context *s, uint8_t stt[256]){
805
 
    int i,i2,changed,print=0;
806
 
 
807
 
    do{
808
 
        changed=0;
809
 
        for(i=12; i<244; i++){
810
 
            for(i2=i+1; i2<245 && i2<i+4; i2++){
811
 
#define COST(old, new) \
812
 
    s->rc_stat[old][0]*-log2((256-(new))/256.0)\
813
 
   +s->rc_stat[old][1]*-log2(     (new) /256.0)
814
 
 
815
 
#define COST2(old, new) \
816
 
    COST(old, new)\
817
 
   +COST(256-(old), 256-(new))
818
 
 
819
 
                double size0= COST2(i, i ) + COST2(i2, i2);
820
 
                double sizeX= COST2(i, i2) + COST2(i2, i );
821
 
                if(sizeX < size0 && i!=128 && i2!=128){
822
 
                    int j;
823
 
                    FFSWAP(int, stt[    i], stt[    i2]);
824
 
                    FFSWAP(int, s->rc_stat[i    ][0],s->rc_stat[    i2][0]);
825
 
                    FFSWAP(int, s->rc_stat[i    ][1],s->rc_stat[    i2][1]);
826
 
                    if(i != 256-i2){
827
 
                        FFSWAP(int, stt[256-i], stt[256-i2]);
828
 
                        FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
829
 
                        FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
830
 
                    }
831
 
                    for(j=1; j<256; j++){
832
 
                        if     (stt[j] == i ) stt[j] = i2;
833
 
                        else if(stt[j] == i2) stt[j] = i ;
834
 
                        if(i != 256-i2){
835
 
                            if     (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
836
 
                            else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
837
 
                        }
838
 
                    }
839
 
                    print=changed=1;
840
 
                }
841
 
            }
842
 
        }
843
 
    }while(changed);
844
 
    return print;
845
 
}
846
 
 
847
 
static av_cold int encode_init(AVCodecContext *avctx)
848
 
{
849
 
    FFV1Context *s = avctx->priv_data;
850
 
    int i, j, k, m;
851
 
 
852
 
    common_init(avctx);
853
 
 
854
 
    s->version=0;
855
 
    s->ac= avctx->coder_type ? 2:0;
856
 
 
857
 
    if(s->ac>1)
858
 
        for(i=1; i<256; i++)
859
 
            s->state_transition[i]=ver2_state[i];
860
 
 
861
 
    s->plane_count=2;
862
 
    for(i=0; i<256; i++){
863
 
        s->quant_table_count=2;
864
 
        if(avctx->bits_per_raw_sample <=8){
865
 
            s->quant_tables[0][0][i]=           quant11[i];
866
 
            s->quant_tables[0][1][i]=        11*quant11[i];
867
 
            s->quant_tables[0][2][i]=     11*11*quant11[i];
868
 
            s->quant_tables[1][0][i]=           quant11[i];
869
 
            s->quant_tables[1][1][i]=        11*quant11[i];
870
 
            s->quant_tables[1][2][i]=     11*11*quant5 [i];
871
 
            s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
872
 
            s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
873
 
        }else{
874
 
            s->quant_tables[0][0][i]=           quant9_10bit[i];
875
 
            s->quant_tables[0][1][i]=        11*quant9_10bit[i];
876
 
            s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
877
 
            s->quant_tables[1][0][i]=           quant9_10bit[i];
878
 
            s->quant_tables[1][1][i]=        11*quant9_10bit[i];
879
 
            s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
880
 
            s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
881
 
            s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
882
 
        }
883
 
    }
884
 
    s->context_count[0]= (11*11*11+1)/2;
885
 
    s->context_count[1]= (11*11*5*5*5+1)/2;
886
 
    memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
887
 
 
888
 
    for(i=0; i<s->plane_count; i++){
889
 
        PlaneContext * const p= &s->plane[i];
890
 
 
891
 
        memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
892
 
        p->quant_table_index= avctx->context_model;
893
 
        p->context_count= s->context_count[p->quant_table_index];
894
 
    }
895
 
 
896
 
    if(allocate_initial_states(s) < 0)
897
 
        return AVERROR(ENOMEM);
898
 
 
899
 
    avctx->coded_frame= &s->picture;
900
 
    switch(avctx->pix_fmt){
901
 
    case PIX_FMT_YUV444P16:
902
 
    case PIX_FMT_YUV422P16:
903
 
    case PIX_FMT_YUV420P16:
904
 
        if(avctx->bits_per_raw_sample <=8){
905
 
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
906
 
            return -1;
907
 
        }
908
 
        if(!s->ac){
909
 
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
910
 
            return -1;
911
 
        }
912
 
        s->version= FFMAX(s->version, 1);
913
 
    case PIX_FMT_YUV444P:
914
 
    case PIX_FMT_YUV422P:
915
 
    case PIX_FMT_YUV420P:
916
 
    case PIX_FMT_YUV411P:
917
 
    case PIX_FMT_YUV410P:
918
 
        s->colorspace= 0;
919
 
        break;
920
 
    case PIX_FMT_RGB32:
921
 
        s->colorspace= 1;
922
 
        break;
923
 
    default:
924
 
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
925
 
        return -1;
926
 
    }
927
 
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
928
 
 
929
 
    s->picture_number=0;
930
 
 
931
 
    if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
932
 
        for(i=0; i<s->quant_table_count; i++){
933
 
            s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
934
 
            if(!s->rc_stat2[i])
935
 
                return AVERROR(ENOMEM);
936
 
        }
937
 
    }
938
 
    if(avctx->stats_in){
939
 
        char *p= avctx->stats_in;
940
 
        uint8_t best_state[256][256];
941
 
        int gob_count=0;
942
 
        char *next;
943
 
 
944
 
        av_assert0(s->version>=2);
945
 
 
946
 
        for(;;){
947
 
            for(j=0; j<256; j++){
948
 
                for(i=0; i<2; i++){
949
 
                    s->rc_stat[j][i]= strtol(p, &next, 0);
950
 
                    if(next==p){
951
 
                        av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
952
 
                        return -1;
953
 
                    }
954
 
                    p=next;
955
 
                }
956
 
            }
957
 
            for(i=0; i<s->quant_table_count; i++){
958
 
                for(j=0; j<s->context_count[i]; j++){
959
 
                    for(k=0; k<32; k++){
960
 
                        for(m=0; m<2; m++){
961
 
                            s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
962
 
                            if(next==p){
963
 
                                av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
964
 
                                return -1;
965
 
                            }
966
 
                            p=next;
967
 
                        }
968
 
                    }
969
 
                }
970
 
            }
971
 
            gob_count= strtol(p, &next, 0);
972
 
            if(next==p || gob_count <0){
973
 
                av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
974
 
                return -1;
975
 
            }
976
 
            p=next;
977
 
            while(*p=='\n' || *p==' ') p++;
978
 
            if(p[0]==0) break;
979
 
        }
980
 
        sort_stt(s, s->state_transition);
981
 
 
982
 
        find_best_state(best_state, s->state_transition);
983
 
 
984
 
        for(i=0; i<s->quant_table_count; i++){
985
 
            for(j=0; j<s->context_count[i]; j++){
986
 
                for(k=0; k<32; k++){
987
 
                    double p= 128;
988
 
                    if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
989
 
                        p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
990
 
                    }
991
 
                    s->initial_states[i][j][k]= best_state[av_clip(round(p), 1, 255)][av_clip((s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1])/gob_count, 0, 255)];
992
 
                }
993
 
            }
994
 
        }
995
 
    }
996
 
 
997
 
    if(s->version>1){
998
 
        s->num_h_slices=2;
999
 
        s->num_v_slices=2;
1000
 
        write_extra_header(s);
1001
 
    }
1002
 
 
1003
 
    if(init_slice_contexts(s) < 0)
1004
 
        return -1;
1005
 
    if(init_slice_state(s) < 0)
1006
 
        return -1;
1007
 
 
1008
 
#define STATS_OUT_SIZE 1024*1024*6
1009
 
    if(avctx->flags & CODEC_FLAG_PASS1){
1010
 
        avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
1011
 
        for(i=0; i<s->quant_table_count; i++){
1012
 
            for(j=0; j<s->slice_count; j++){
1013
 
                FFV1Context *sf= s->slice_context[j];
1014
 
                av_assert0(!sf->rc_stat2[i]);
1015
 
                sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
1016
 
                if(!sf->rc_stat2[i])
1017
 
                    return AVERROR(ENOMEM);
1018
 
            }
1019
 
        }
1020
 
    }
1021
 
 
1022
 
    return 0;
1023
 
}
1024
 
#endif /* CONFIG_FFV1_ENCODER */
1025
 
 
1026
 
 
1027
 
static void clear_state(FFV1Context *f){
1028
 
    int i, si, j;
1029
 
 
1030
 
    for(si=0; si<f->slice_count; si++){
1031
 
        FFV1Context *fs= f->slice_context[si];
1032
 
        for(i=0; i<f->plane_count; i++){
1033
 
            PlaneContext *p= &fs->plane[i];
1034
 
 
1035
 
            p->interlace_bit_state[0]= 128;
1036
 
            p->interlace_bit_state[1]= 128;
1037
 
 
1038
 
            if(fs->ac){
1039
 
                if(f->initial_states[p->quant_table_index]){
1040
 
                    memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1041
 
                }else
1042
 
                memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1043
 
            }else{
1044
 
            for(j=0; j<p->context_count; j++){
1045
 
                    p->vlc_state[j].drift= 0;
1046
 
                    p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1047
 
                    p->vlc_state[j].bias= 0;
1048
 
                    p->vlc_state[j].count= 1;
1049
 
            }
1050
 
            }
1051
 
        }
1052
 
    }
1053
 
}
1054
 
 
1055
 
#if CONFIG_FFV1_ENCODER
1056
 
static int encode_slice(AVCodecContext *c, void *arg){
1057
 
    FFV1Context *fs= *(void**)arg;
1058
 
    FFV1Context *f= fs->avctx->priv_data;
1059
 
    int width = fs->slice_width;
1060
 
    int height= fs->slice_height;
1061
 
    int x= fs->slice_x;
1062
 
    int y= fs->slice_y;
1063
 
    AVFrame * const p= &f->picture;
1064
 
 
1065
 
    if(f->colorspace==0){
1066
 
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1067
 
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1068
 
        const int cx= x>>f->chroma_h_shift;
1069
 
        const int cy= y>>f->chroma_v_shift;
1070
 
 
1071
 
        encode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1072
 
 
1073
 
        encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1074
 
        encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1075
 
    }else{
1076
 
        encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1077
 
    }
1078
 
    emms_c();
1079
 
 
1080
 
    return 0;
1081
 
}
1082
 
 
1083
 
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1084
 
    FFV1Context *f = avctx->priv_data;
1085
 
    RangeCoder * const c= &f->slice_context[0]->c;
1086
 
    AVFrame *pict = data;
1087
 
    AVFrame * const p= &f->picture;
1088
 
    int used_count= 0;
1089
 
    uint8_t keystate=128;
1090
 
    uint8_t *buf_p;
1091
 
    int i;
1092
 
 
1093
 
    ff_init_range_encoder(c, buf, buf_size);
1094
 
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1095
 
 
1096
 
    *p = *pict;
1097
 
    p->pict_type= AV_PICTURE_TYPE_I;
1098
 
 
1099
 
    if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1100
 
        put_rac(c, &keystate, 1);
1101
 
        p->key_frame= 1;
1102
 
        f->gob_count++;
1103
 
        write_header(f);
1104
 
        clear_state(f);
1105
 
    }else{
1106
 
        put_rac(c, &keystate, 0);
1107
 
        p->key_frame= 0;
1108
 
    }
1109
 
 
1110
 
    if(!f->ac){
1111
 
        used_count += ff_rac_terminate(c);
1112
 
//printf("pos=%d\n", used_count);
1113
 
        init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
1114
 
    }else if (f->ac>1){
1115
 
        int i;
1116
 
        for(i=1; i<256; i++){
1117
 
            c->one_state[i]= f->state_transition[i];
1118
 
            c->zero_state[256-i]= 256-c->one_state[i];
1119
 
        }
1120
 
    }
1121
 
 
1122
 
    for(i=1; i<f->slice_count; i++){
1123
 
        FFV1Context *fs= f->slice_context[i];
1124
 
        uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
1125
 
        int len= buf_size/f->slice_count;
1126
 
 
1127
 
        if(fs->ac){
1128
 
            ff_init_range_encoder(&fs->c, start, len);
1129
 
        }else{
1130
 
            init_put_bits(&fs->pb, start, len);
1131
 
        }
1132
 
    }
1133
 
    avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1134
 
 
1135
 
    buf_p=buf;
1136
 
    for(i=0; i<f->slice_count; i++){
1137
 
        FFV1Context *fs= f->slice_context[i];
1138
 
        int bytes;
1139
 
 
1140
 
        if(fs->ac){
1141
 
            uint8_t state=128;
1142
 
            put_rac(&fs->c, &state, 0);
1143
 
            bytes= ff_rac_terminate(&fs->c);
1144
 
        }else{
1145
 
            flush_put_bits(&fs->pb); //nicer padding FIXME
1146
 
            bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1147
 
            used_count= 0;
1148
 
        }
1149
 
        if(i>0){
1150
 
            av_assert0(bytes < buf_size/f->slice_count);
1151
 
            memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1152
 
            av_assert0(bytes < (1<<24));
1153
 
            AV_WB24(buf_p+bytes, bytes);
1154
 
            bytes+=3;
1155
 
        }
1156
 
        buf_p += bytes;
1157
 
    }
1158
 
 
1159
 
    if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1160
 
        int j, k, m;
1161
 
        char *p= avctx->stats_out;
1162
 
        char *end= p + STATS_OUT_SIZE;
1163
 
 
1164
 
        memset(f->rc_stat, 0, sizeof(f->rc_stat));
1165
 
        for(i=0; i<f->quant_table_count; i++)
1166
 
            memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1167
 
 
1168
 
        for(j=0; j<f->slice_count; j++){
1169
 
            FFV1Context *fs= f->slice_context[j];
1170
 
            for(i=0; i<256; i++){
1171
 
                f->rc_stat[i][0] += fs->rc_stat[i][0];
1172
 
                f->rc_stat[i][1] += fs->rc_stat[i][1];
1173
 
            }
1174
 
            for(i=0; i<f->quant_table_count; i++){
1175
 
                for(k=0; k<f->context_count[i]; k++){
1176
 
                    for(m=0; m<32; m++){
1177
 
                        f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1178
 
                        f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1179
 
                    }
1180
 
                }
1181
 
            }
1182
 
        }
1183
 
 
1184
 
        for(j=0; j<256; j++){
1185
 
            snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1186
 
            p+= strlen(p);
1187
 
        }
1188
 
        snprintf(p, end-p, "\n");
1189
 
 
1190
 
        for(i=0; i<f->quant_table_count; i++){
1191
 
            for(j=0; j<f->context_count[i]; j++){
1192
 
                for(m=0; m<32; m++){
1193
 
                    snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1194
 
                    p+= strlen(p);
1195
 
                }
1196
 
            }
1197
 
        }
1198
 
        snprintf(p, end-p, "%d\n", f->gob_count);
1199
 
    } else if(avctx->flags&CODEC_FLAG_PASS1)
1200
 
        avctx->stats_out[0] = '\0';
1201
 
 
1202
 
    f->picture_number++;
1203
 
    return buf_p-buf;
1204
 
}
1205
 
#endif /* CONFIG_FFV1_ENCODER */
1206
 
 
1207
 
static av_cold int common_end(AVCodecContext *avctx){
 
236
        memset(f->initial_states[i], 128,
 
237
               f->context_count[i] * sizeof(*f->initial_states[i]));
 
238
    }
 
239
    return 0;
 
240
}
 
241
 
 
242
void ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
 
243
{
 
244
    int i, j;
 
245
 
 
246
    for (i = 0; i < f->plane_count; i++) {
 
247
        PlaneContext *p = &fs->plane[i];
 
248
 
 
249
        p->interlace_bit_state[0] = 128;
 
250
        p->interlace_bit_state[1] = 128;
 
251
 
 
252
        if (fs->ac) {
 
253
            if (f->initial_states[p->quant_table_index]) {
 
254
                memcpy(p->state, f->initial_states[p->quant_table_index],
 
255
                       CONTEXT_SIZE * p->context_count);
 
256
            } else
 
257
                memset(p->state, 128, CONTEXT_SIZE * p->context_count);
 
258
        } else {
 
259
            for (j = 0; j < p->context_count; j++) {
 
260
                p->vlc_state[j].drift     = 0;
 
261
                p->vlc_state[j].error_sum = 4;    //FFMAX((RANGE + 32)/64, 2);
 
262
                p->vlc_state[j].bias      = 0;
 
263
                p->vlc_state[j].count     = 1;
 
264
            }
 
265
        }
 
266
    }
 
267
}
 
268
 
 
269
av_cold int ffv1_close(AVCodecContext *avctx)
 
270
{
1208
271
    FFV1Context *s = avctx->priv_data;
1209
272
    int i, j;
1210
273
 
1211
274
    if (avctx->codec->decode && s->picture.data[0])
1212
275
        avctx->release_buffer(avctx, &s->picture);
 
276
    if (avctx->codec->decode && s->last_picture.data[0])
 
277
        avctx->release_buffer(avctx, &s->last_picture);
1213
278
 
1214
 
    for(j=0; j<s->slice_count; j++){
1215
 
        FFV1Context *fs= s->slice_context[j];
1216
 
        for(i=0; i<s->plane_count; i++){
1217
 
            PlaneContext *p= &fs->plane[i];
 
279
    for (j = 0; j < s->slice_count; j++) {
 
280
        FFV1Context *fs = s->slice_context[j];
 
281
        for (i = 0; i < s->plane_count; i++) {
 
282
            PlaneContext *p = &fs->plane[i];
1218
283
 
1219
284
            av_freep(&p->state);
1220
285
            av_freep(&p->vlc_state);
1223
288
    }
1224
289
 
1225
290
    av_freep(&avctx->stats_out);
1226
 
    for(j=0; j<s->quant_table_count; j++){
 
291
    for (j = 0; j < s->quant_table_count; j++) {
1227
292
        av_freep(&s->initial_states[j]);
1228
 
        for(i=0; i<s->slice_count; i++){
1229
 
            FFV1Context *sf= s->slice_context[i];
 
293
        for (i = 0; i < s->slice_count; i++) {
 
294
            FFV1Context *sf = s->slice_context[i];
1230
295
            av_freep(&sf->rc_stat2[j]);
1231
296
        }
1232
297
        av_freep(&s->rc_stat2[j]);
1233
298
    }
1234
299
 
1235
 
    for(i=0; i<s->slice_count; i++){
 
300
    for (i = 0; i < s->slice_count; i++)
1236
301
        av_freep(&s->slice_context[i]);
1237
 
    }
1238
 
 
1239
 
    return 0;
1240
 
}
1241
 
 
1242
 
static av_always_inline void decode_line(FFV1Context *s, int w,
1243
 
                                         int16_t *sample[2],
1244
 
                                         int plane_index, int bits)
1245
 
{
1246
 
    PlaneContext * const p= &s->plane[plane_index];
1247
 
    RangeCoder * const c= &s->c;
1248
 
    int x;
1249
 
    int run_count=0;
1250
 
    int run_mode=0;
1251
 
    int run_index= s->run_index;
1252
 
 
1253
 
    for(x=0; x<w; x++){
1254
 
        int diff, context, sign;
1255
 
 
1256
 
        context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1257
 
        if(context < 0){
1258
 
            context= -context;
1259
 
            sign=1;
1260
 
        }else
1261
 
            sign=0;
1262
 
 
1263
 
        av_assert2(context < p->context_count);
1264
 
 
1265
 
        if(s->ac){
1266
 
            diff= get_symbol_inline(c, p->state[context], 1);
1267
 
        }else{
1268
 
            if(context == 0 && run_mode==0) run_mode=1;
1269
 
 
1270
 
            if(run_mode){
1271
 
                if(run_count==0 && run_mode==1){
1272
 
                    if(get_bits1(&s->gb)){
1273
 
                        run_count = 1<<ff_log2_run[run_index];
1274
 
                        if(x + run_count <= w) run_index++;
1275
 
                    }else{
1276
 
                        if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1277
 
                        else run_count=0;
1278
 
                        if(run_index) run_index--;
1279
 
                        run_mode=2;
1280
 
                    }
1281
 
                }
1282
 
                run_count--;
1283
 
                if(run_count < 0){
1284
 
                    run_mode=0;
1285
 
                    run_count=0;
1286
 
                    diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1287
 
                    if(diff>=0) diff++;
1288
 
                }else
1289
 
                    diff=0;
1290
 
            }else
1291
 
                diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1292
 
 
1293
 
//            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));
1294
 
        }
1295
 
 
1296
 
        if(sign) diff= -diff;
1297
 
 
1298
 
        sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1299
 
    }
1300
 
    s->run_index= run_index;
1301
 
}
1302
 
 
1303
 
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1304
 
    int x, y;
1305
 
    int16_t *sample[2];
1306
 
    sample[0]=s->sample_buffer    +3;
1307
 
    sample[1]=s->sample_buffer+w+6+3;
1308
 
 
1309
 
    s->run_index=0;
1310
 
 
1311
 
    memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1312
 
 
1313
 
    for(y=0; y<h; y++){
1314
 
        int16_t *temp = sample[0]; //FIXME try a normal buffer
1315
 
 
1316
 
        sample[0]= sample[1];
1317
 
        sample[1]= temp;
1318
 
 
1319
 
        sample[1][-1]= sample[0][0  ];
1320
 
        sample[0][ w]= sample[0][w-1];
1321
 
 
1322
 
//{START_TIMER
1323
 
        if(s->avctx->bits_per_raw_sample <= 8){
1324
 
            decode_line(s, w, sample, plane_index, 8);
1325
 
            for(x=0; x<w; x++){
1326
 
                src[x + stride*y]= sample[1][x];
1327
 
            }
1328
 
        }else{
1329
 
            decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1330
 
            for(x=0; x<w; x++){
1331
 
                ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1332
 
            }
1333
 
        }
1334
 
//STOP_TIMER("decode-line")}
1335
 
    }
1336
 
}
1337
 
 
1338
 
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1339
 
    int x, y, p;
1340
 
    int16_t *sample[3][2];
1341
 
    for(x=0; x<3; x++){
1342
 
        sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1343
 
        sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1344
 
    }
1345
 
 
1346
 
    s->run_index=0;
1347
 
 
1348
 
    memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1349
 
 
1350
 
    for(y=0; y<h; y++){
1351
 
        for(p=0; p<3; p++){
1352
 
            int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1353
 
 
1354
 
            sample[p][0]= sample[p][1];
1355
 
            sample[p][1]= temp;
1356
 
 
1357
 
            sample[p][1][-1]= sample[p][0][0  ];
1358
 
            sample[p][0][ w]= sample[p][0][w-1];
1359
 
            decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1360
 
        }
1361
 
        for(x=0; x<w; x++){
1362
 
            int g= sample[0][1][x];
1363
 
            int b= sample[1][1][x];
1364
 
            int r= sample[2][1][x];
1365
 
 
1366
 
//            assert(g>=0 && b>=0 && r>=0);
1367
 
//            assert(g<256 && b<512 && r<512);
1368
 
 
1369
 
            b -= 0x100;
1370
 
            r -= 0x100;
1371
 
            g -= (b + r)>>2;
1372
 
            b += g;
1373
 
            r += g;
1374
 
 
1375
 
            src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1376
 
        }
1377
 
    }
1378
 
}
1379
 
 
1380
 
static int decode_slice(AVCodecContext *c, void *arg){
1381
 
    FFV1Context *fs= *(void**)arg;
1382
 
    FFV1Context *f= fs->avctx->priv_data;
1383
 
    int width = fs->slice_width;
1384
 
    int height= fs->slice_height;
1385
 
    int x= fs->slice_x;
1386
 
    int y= fs->slice_y;
1387
 
    AVFrame * const p= &f->picture;
1388
 
 
1389
 
    av_assert1(width && height);
1390
 
    if(f->colorspace==0){
1391
 
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1392
 
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1393
 
        const int cx= x>>f->chroma_h_shift;
1394
 
        const int cy= y>>f->chroma_v_shift;
1395
 
        decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1396
 
 
1397
 
        decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1398
 
        decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1399
 
    }else{
1400
 
        decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1401
 
    }
1402
 
 
1403
 
    emms_c();
1404
 
 
1405
 
    return 0;
1406
 
}
1407
 
 
1408
 
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1409
 
    int v;
1410
 
    int i=0;
1411
 
    uint8_t state[CONTEXT_SIZE];
1412
 
 
1413
 
    memset(state, 128, sizeof(state));
1414
 
 
1415
 
    for(v=0; i<128 ; v++){
1416
 
        int len= get_symbol(c, state, 0) + 1;
1417
 
 
1418
 
        if(len + i > 128) return -1;
1419
 
 
1420
 
        while(len--){
1421
 
            quant_table[i] = scale*v;
1422
 
            i++;
1423
 
//printf("%2d ",v);
1424
 
//if(i%16==0) printf("\n");
1425
 
        }
1426
 
    }
1427
 
 
1428
 
    for(i=1; i<128; i++){
1429
 
        quant_table[256-i]= -quant_table[i];
1430
 
    }
1431
 
    quant_table[128]= -quant_table[127];
1432
 
 
1433
 
    return 2*v - 1;
1434
 
}
1435
 
 
1436
 
static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1437
 
    int i;
1438
 
    int context_count=1;
1439
 
 
1440
 
    for(i=0; i<5; i++){
1441
 
        context_count*= read_quant_table(c, quant_table[i], context_count);
1442
 
        if(context_count > 32768U){
1443
 
            return -1;
1444
 
        }
1445
 
    }
1446
 
    return (context_count+1)/2;
1447
 
}
1448
 
 
1449
 
static int read_extra_header(FFV1Context *f){
1450
 
    RangeCoder * const c= &f->c;
1451
 
    uint8_t state[CONTEXT_SIZE];
1452
 
    int i, j, k;
1453
 
    uint8_t state2[32][CONTEXT_SIZE];
1454
 
 
1455
 
    memset(state2, 128, sizeof(state2));
1456
 
    memset(state, 128, sizeof(state));
1457
 
 
1458
 
    ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1459
 
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1460
 
 
1461
 
    f->version= get_symbol(c, state, 0);
1462
 
    f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1463
 
    if(f->ac>1){
1464
 
        for(i=1; i<256; i++){
1465
 
            f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1466
 
        }
1467
 
    }
1468
 
    f->colorspace= get_symbol(c, state, 0); //YUV cs type
1469
 
    f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1470
 
    get_rac(c, state); //no chroma = false
1471
 
    f->chroma_h_shift= get_symbol(c, state, 0);
1472
 
    f->chroma_v_shift= get_symbol(c, state, 0);
1473
 
    get_rac(c, state); //transparency plane
1474
 
    f->plane_count= 2;
1475
 
    f->num_h_slices= 1 + get_symbol(c, state, 0);
1476
 
    f->num_v_slices= 1 + get_symbol(c, state, 0);
1477
 
    if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1478
 
        av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1479
 
        return -1;
1480
 
    }
1481
 
 
1482
 
    f->quant_table_count= get_symbol(c, state, 0);
1483
 
    if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1484
 
        return -1;
1485
 
    for(i=0; i<f->quant_table_count; i++){
1486
 
        if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1487
 
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1488
 
            return -1;
1489
 
        }
1490
 
    }
1491
 
 
1492
 
    if(allocate_initial_states(f) < 0)
1493
 
        return AVERROR(ENOMEM);
1494
 
 
1495
 
    for(i=0; i<f->quant_table_count; i++){
1496
 
        if(get_rac(c, state)){
1497
 
            for(j=0; j<f->context_count[i]; j++){
1498
 
                for(k=0; k<CONTEXT_SIZE; k++){
1499
 
                    int pred= j ? f->initial_states[i][j-1][k] : 128;
1500
 
                    f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1501
 
                }
1502
 
            }
1503
 
        }
1504
 
    }
1505
 
 
1506
 
    return 0;
1507
 
}
1508
 
 
1509
 
static int read_header(FFV1Context *f){
1510
 
    uint8_t state[CONTEXT_SIZE];
1511
 
    int i, j, context_count;
1512
 
    RangeCoder * const c= &f->slice_context[0]->c;
1513
 
 
1514
 
    memset(state, 128, sizeof(state));
1515
 
 
1516
 
    if(f->version < 2){
1517
 
        f->version= get_symbol(c, state, 0);
1518
 
        f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1519
 
        if(f->ac>1){
1520
 
            for(i=1; i<256; i++){
1521
 
                f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1522
 
            }
1523
 
        }
1524
 
        f->colorspace= get_symbol(c, state, 0); //YUV cs type
1525
 
        if(f->version>0)
1526
 
            f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1527
 
        get_rac(c, state); //no chroma = false
1528
 
        f->chroma_h_shift= get_symbol(c, state, 0);
1529
 
        f->chroma_v_shift= get_symbol(c, state, 0);
1530
 
        get_rac(c, state); //transparency plane
1531
 
        f->plane_count= 2;
1532
 
    }
1533
 
 
1534
 
    if(f->colorspace==0){
1535
 
        if(f->avctx->bits_per_raw_sample<=8){
1536
 
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1537
 
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1538
 
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1539
 
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1540
 
            case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1541
 
            case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1542
 
            default:
1543
 
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1544
 
                return -1;
1545
 
            }
1546
 
        }else{
1547
 
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1548
 
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1549
 
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1550
 
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1551
 
            default:
1552
 
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1553
 
                return -1;
1554
 
            }
1555
 
        }
1556
 
    }else if(f->colorspace==1){
1557
 
        if(f->chroma_h_shift || f->chroma_v_shift){
1558
 
            av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1559
 
            return -1;
1560
 
        }
1561
 
        f->avctx->pix_fmt= PIX_FMT_RGB32;
1562
 
    }else{
1563
 
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1564
 
        return -1;
1565
 
    }
1566
 
 
1567
 
//printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1568
 
    if(f->version < 2){
1569
 
        context_count= read_quant_tables(c, f->quant_table);
1570
 
        if(context_count < 0){
1571
 
                av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1572
 
                return -1;
1573
 
        }
1574
 
    }else{
1575
 
        f->slice_count= get_symbol(c, state, 0);
1576
 
        if(f->slice_count > (unsigned)MAX_SLICES)
1577
 
            return -1;
1578
 
    }
1579
 
 
1580
 
    for(j=0; j<f->slice_count; j++){
1581
 
        FFV1Context *fs= f->slice_context[j];
1582
 
        fs->ac= f->ac;
1583
 
 
1584
 
        if(f->version >= 2){
1585
 
            fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1586
 
            fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1587
 
            fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1588
 
            fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1589
 
 
1590
 
            fs->slice_x /= f->num_h_slices;
1591
 
            fs->slice_y /= f->num_v_slices;
1592
 
            fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1593
 
            fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1594
 
            if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1595
 
                return -1;
1596
 
            if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1597
 
                || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1598
 
                return -1;
1599
 
        }
1600
 
 
1601
 
        for(i=0; i<f->plane_count; i++){
1602
 
            PlaneContext * const p= &fs->plane[i];
1603
 
 
1604
 
            if(f->version >= 2){
1605
 
                int idx=get_symbol(c, state, 0);
1606
 
                if(idx > (unsigned)f->quant_table_count){
1607
 
                    av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1608
 
                    return -1;
1609
 
                }
1610
 
                p->quant_table_index= idx;
1611
 
                memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1612
 
                context_count= f->context_count[idx];
1613
 
            }else{
1614
 
                memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1615
 
            }
1616
 
 
1617
 
            if(p->context_count < context_count){
1618
 
                av_freep(&p->state);
1619
 
                av_freep(&p->vlc_state);
1620
 
            }
1621
 
            p->context_count= context_count;
1622
 
        }
1623
 
    }
1624
 
 
1625
 
    return 0;
1626
 
}
1627
 
 
1628
 
static av_cold int decode_init(AVCodecContext *avctx)
1629
 
{
1630
 
    FFV1Context *f = avctx->priv_data;
1631
 
 
1632
 
    common_init(avctx);
1633
 
 
1634
 
    if(avctx->extradata && read_extra_header(f) < 0)
1635
 
        return -1;
1636
 
 
1637
 
    if(init_slice_contexts(f) < 0)
1638
 
        return -1;
1639
 
 
1640
 
    return 0;
1641
 
}
1642
 
 
1643
 
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1644
 
    const uint8_t *buf = avpkt->data;
1645
 
    int buf_size = avpkt->size;
1646
 
    FFV1Context *f = avctx->priv_data;
1647
 
    RangeCoder * const c= &f->slice_context[0]->c;
1648
 
    AVFrame * const p= &f->picture;
1649
 
    int bytes_read, i;
1650
 
    uint8_t keystate= 128;
1651
 
    const uint8_t *buf_p;
1652
 
 
1653
 
    AVFrame *picture = data;
1654
 
 
1655
 
    /* release previously stored data */
1656
 
    if (p->data[0])
1657
 
        avctx->release_buffer(avctx, p);
1658
 
 
1659
 
    ff_init_range_decoder(c, buf, buf_size);
1660
 
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1661
 
 
1662
 
 
1663
 
    p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1664
 
    if(get_rac(c, &keystate)){
1665
 
        p->key_frame= 1;
1666
 
        if(read_header(f) < 0)
1667
 
            return -1;
1668
 
        if(init_slice_state(f) < 0)
1669
 
            return -1;
1670
 
 
1671
 
        clear_state(f);
1672
 
    }else{
1673
 
        p->key_frame= 0;
1674
 
    }
1675
 
    if(f->ac>1){
1676
 
        int i;
1677
 
        for(i=1; i<256; i++){
1678
 
            c->one_state[i]= f->state_transition[i];
1679
 
            c->zero_state[256-i]= 256-c->one_state[i];
1680
 
        }
1681
 
    }
1682
 
 
1683
 
    p->reference= 0;
1684
 
    if(avctx->get_buffer(avctx, p) < 0){
1685
 
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1686
 
        return -1;
1687
 
    }
1688
 
 
1689
 
    if(avctx->debug&FF_DEBUG_PICT_INFO)
1690
 
        av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1691
 
 
1692
 
    if(!f->ac){
1693
 
        bytes_read = c->bytestream - c->bytestream_start - 1;
1694
 
        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1695
 
//printf("pos=%d\n", bytes_read);
1696
 
        init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
1697
 
    } else {
1698
 
        bytes_read = 0; /* avoid warning */
1699
 
    }
1700
 
 
1701
 
    buf_p= buf + buf_size;
1702
 
    for(i=f->slice_count-1; i>0; i--){
1703
 
        FFV1Context *fs= f->slice_context[i];
1704
 
        int v= AV_RB24(buf_p-3)+3;
1705
 
        if(buf_p - buf <= v){
1706
 
            av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1707
 
            return -1;
1708
 
        }
1709
 
        buf_p -= v;
1710
 
        if(fs->ac){
1711
 
            ff_init_range_decoder(&fs->c, buf_p, v);
1712
 
        }else{
1713
 
            init_get_bits(&fs->gb, buf_p, v * 8);
1714
 
        }
1715
 
    }
1716
 
 
1717
 
    avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1718
 
    f->picture_number++;
1719
 
 
1720
 
    *picture= *p;
1721
 
    *data_size = sizeof(AVFrame);
1722
 
 
1723
 
    return buf_size;
1724
 
}
1725
 
 
1726
 
AVCodec ff_ffv1_decoder = {
1727
 
    .name           = "ffv1",
1728
 
    .type           = AVMEDIA_TYPE_VIDEO,
1729
 
    .id             = CODEC_ID_FFV1,
1730
 
    .priv_data_size = sizeof(FFV1Context),
1731
 
    .init           = decode_init,
1732
 
    .close          = common_end,
1733
 
    .decode         = decode_frame,
1734
 
    .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
1735
 
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1736
 
};
1737
 
 
1738
 
#if CONFIG_FFV1_ENCODER
1739
 
AVCodec ff_ffv1_encoder = {
1740
 
    .name           = "ffv1",
1741
 
    .type           = AVMEDIA_TYPE_VIDEO,
1742
 
    .id             = CODEC_ID_FFV1,
1743
 
    .priv_data_size = sizeof(FFV1Context),
1744
 
    .init           = encode_init,
1745
 
    .encode         = encode_frame,
1746
 
    .close          = common_end,
1747
 
    .capabilities = CODEC_CAP_SLICE_THREADS,
1748
 
    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_NONE},
1749
 
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1750
 
};
1751
 
#endif
 
302
 
 
303
    return 0;
 
304
}