Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ cbabccc3

History | View | Annotate | Download (36.8 KB)

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

    
23
/**
24
 * @file
25
 * FF Video Codec 1 (a lossless codec)
26
 */
27

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

    
36
#define MAX_PLANES 4
37
#define CONTEXT_SIZE 32
38

    
39
extern const uint8_t ff_log2_run[32];
40

    
41
static const int8_t quant3[256]={
42
 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
43
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
44
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
45
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
46
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
47
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
48
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
49
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
50
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
51
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
52
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
53
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
54
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
55
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
56
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
57
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
58
};
59

    
60
static const int8_t quant5_10bit[256]={
61
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
62
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
63
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
64
 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
65
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
66
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
67
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
68
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
69
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
70
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
71
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
72
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
73
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,
74
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
75
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
76
-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
77
};
78

    
79
static const int8_t quant5[256]={
80
 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
81
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
82
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
83
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
84
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
85
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
86
 2, 2, 2, 2, 2, 2, 2, 2, 2, 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,-2,-2,
89
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
90
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
91
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
92
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
93
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
94
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
95
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
96
};
97
static const int8_t quant7[256]={
98
 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
99
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
100
 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
101
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
102
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
103
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
104
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
105
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
106
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
107
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
108
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
109
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
110
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
111
-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
112
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
113
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
114
};
115
static const int8_t quant9[256]={
116
 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
117
 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
118
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
119
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
120
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
121
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
122
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 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,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
125
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
126
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
127
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
128
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
129
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
130
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
131
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
132
};
133
static const int8_t quant9_10bit[256]={
134
 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
135
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
136
 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
137
 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
138
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
139
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
140
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
141
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
142
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
143
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
144
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
145
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
146
-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,
147
-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
148
-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
149
-2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
150
};
151

    
152
static const int8_t quant11[256]={
153
 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
154
 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
155
 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
156
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
157
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
158
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
159
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
160
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
161
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
162
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
163
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
164
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
165
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
166
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
167
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
168
-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
169
};
170
static const int8_t quant13[256]={
171
 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
172
 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
173
 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
174
 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
175
 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
176
 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
177
 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
178
 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
179
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
180
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
181
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
182
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
183
-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
184
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
185
-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
186
-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
187
};
188

    
189
static const uint8_t ver2_state[256]= {
190
   0,  10,  10,  10,  10,  16,  16,  16,  28,  16,  16,  29,  42,  49,  20,  49,
191
  59,  25,  26,  26,  27,  31,  33,  33,  33,  34,  34,  37,  67,  38,  39,  39,
192
  40,  40,  41,  79,  43,  44,  45,  45,  48,  48,  64,  50,  51,  52,  88,  52,
193
  53,  74,  55,  57,  58,  58,  74,  60, 101,  61,  62,  84,  66,  66,  68,  69,
194
  87,  82,  71,  97,  73,  73,  82,  75, 111,  77,  94,  78,  87,  81,  83,  97,
195
  85,  83,  94,  86,  99,  89,  90,  99, 111,  92,  93, 134,  95,  98, 105,  98,
196
 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
197
 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
198
 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
199
 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
200
 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
201
 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
202
 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
203
 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
204
 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
205
 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
206
};
207

    
208
typedef struct VlcState{
209
    int16_t drift;
210
    uint16_t error_sum;
211
    int8_t bias;
212
    uint8_t count;
213
} VlcState;
214

    
215
typedef struct PlaneContext{
216
    int context_count;
217
    uint8_t (*state)[CONTEXT_SIZE];
218
    VlcState *vlc_state;
219
    uint8_t interlace_bit_state[2];
220
} PlaneContext;
221

    
222
typedef struct FFV1Context{
223
    AVCodecContext *avctx;
224
    RangeCoder c;
225
    GetBitContext gb;
226
    PutBitContext pb;
227
    int version;
228
    int width, height;
229
    int chroma_h_shift, chroma_v_shift;
230
    int flags;
231
    int picture_number;
232
    AVFrame picture;
233
    int plane_count;
234
    int ac;                              ///< 1=range coder <-> 0=golomb rice
235
    PlaneContext plane[MAX_PLANES];
236
    int16_t quant_table[5][256];
237
    uint8_t state_transition[256];
238
    int run_index;
239
    int colorspace;
240
    int_fast16_t *sample_buffer;
241

    
242
    DSPContext dsp;
243
}FFV1Context;
244

    
245
static av_always_inline int fold(int diff, int bits){
246
    if(bits==8)
247
        diff= (int8_t)diff;
248
    else{
249
        diff+= 1<<(bits-1);
250
        diff&=(1<<bits)-1;
251
        diff-= 1<<(bits-1);
252
    }
253

    
254
    return diff;
255
}
256

    
257
static inline int predict(int_fast16_t *src, int_fast16_t *last){
258
    const int LT= last[-1];
259
    const int  T= last[ 0];
260
    const int L =  src[-1];
261

    
262
    return mid_pred(L, L + T - LT, T);
263
}
264

    
265
static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
266
    const int LT= last[-1];
267
    const int  T= last[ 0];
268
    const int RT= last[ 1];
269
    const int L =  src[-1];
270

    
271
    if(f->quant_table[3][127]){
272
        const int TT= last2[0];
273
        const int LL=  src[-2];
274
        return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
275
              +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
276
    }else
277
        return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
278
}
279

    
280
static inline void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed){
281
    int i;
282

    
283
    if(v){
284
        const int a= FFABS(v);
285
        const int e= av_log2(a);
286
        put_rac(c, state+0, 0);
287
        if(e<=9){
288
            for(i=0; i<e; i++){
289
                put_rac(c, state+1+i, 1);  //1..10
290
            }
291
            put_rac(c, state+1+i, 0);
292

    
293
            for(i=e-1; i>=0; i--){
294
                put_rac(c, state+22+i, (a>>i)&1); //22..31
295
            }
296

    
297
            if(is_signed)
298
                put_rac(c, state+11 + e, v < 0); //11..21
299
        }else{
300
            for(i=0; i<e; i++){
301
                put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
302
            }
303
            put_rac(c, state+1+9, 0);
304

    
305
            for(i=e-1; i>=0; i--){
306
                put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
307
            }
308

    
309
            if(is_signed)
310
                put_rac(c, state+11 + 10, v < 0); //11..21
311
        }
312
    }else{
313
        put_rac(c, state+0, 1);
314
    }
315
}
316

    
317
static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
318
    put_symbol_inline(c, state, v, is_signed);
319
}
320

    
321
static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
322
    if(get_rac(c, state+0))
323
        return 0;
324
    else{
325
        int i, e, a;
326
        e= 0;
327
        while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
328
            e++;
329
        }
330

    
331
        a= 1;
332
        for(i=e-1; i>=0; i--){
333
            a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
334
        }
335

    
336
        e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
337
        return (a^e)-e;
338
    }
339
}
340

    
341
static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
342
    return get_symbol_inline(c, state, is_signed);
343
}
344

    
345
static inline void update_vlc_state(VlcState * const state, const int v){
346
    int drift= state->drift;
347
    int count= state->count;
348
    state->error_sum += FFABS(v);
349
    drift += v;
350

    
351
    if(count == 128){ //FIXME variable
352
        count >>= 1;
353
        drift >>= 1;
354
        state->error_sum >>= 1;
355
    }
356
    count++;
357

    
358
    if(drift <= -count){
359
        if(state->bias > -128) state->bias--;
360

    
361
        drift += count;
362
        if(drift <= -count)
363
            drift= -count + 1;
364
    }else if(drift > 0){
365
        if(state->bias <  127) state->bias++;
366

    
367
        drift -= count;
368
        if(drift > 0)
369
            drift= 0;
370
    }
371

    
372
    state->drift= drift;
373
    state->count= count;
374
}
375

    
376
static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
377
    int i, k, code;
378
//printf("final: %d ", v);
379
    v = fold(v - state->bias, bits);
380

    
381
    i= state->count;
382
    k=0;
383
    while(i < state->error_sum){ //FIXME optimize
384
        k++;
385
        i += i;
386
    }
387

    
388
    assert(k<=8);
389

    
390
#if 0 // JPEG LS
391
    if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
392
    else                                         code= v;
393
#else
394
     code= v ^ ((2*state->drift + state->count)>>31);
395
#endif
396

    
397
//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);
398
    set_sr_golomb(pb, code, k, 12, bits);
399

    
400
    update_vlc_state(state, v);
401
}
402

    
403
static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
404
    int k, i, v, ret;
405

    
406
    i= state->count;
407
    k=0;
408
    while(i < state->error_sum){ //FIXME optimize
409
        k++;
410
        i += i;
411
    }
412

    
413
    assert(k<=8);
414

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

    
418
#if 0 // JPEG LS
419
    if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
420
#else
421
     v ^= ((2*state->drift + state->count)>>31);
422
#endif
423

    
424
    ret= fold(v + state->bias, bits);
425

    
426
    update_vlc_state(state, v);
427
//printf("final: %d\n", ret);
428
    return ret;
429
}
430

    
431
#if CONFIG_FFV1_ENCODER
432
static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
433
    PlaneContext * const p= &s->plane[plane_index];
434
    RangeCoder * const c= &s->c;
435
    int x;
436
    int run_index= s->run_index;
437
    int run_count=0;
438
    int run_mode=0;
439

    
440
    if(s->ac){
441
        if(c->bytestream_end - c->bytestream < w*20){
442
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
443
            return -1;
444
        }
445
    }else{
446
        if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
447
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
448
            return -1;
449
        }
450
    }
451

    
452
    for(x=0; x<w; x++){
453
        int diff, context;
454

    
455
        context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
456
        diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
457

    
458
        if(context < 0){
459
            context = -context;
460
            diff= -diff;
461
        }
462

    
463
        diff= fold(diff, bits);
464

    
465
        if(s->ac){
466
            put_symbol_inline(c, p->state[context], diff, 1);
467
        }else{
468
            if(context == 0) run_mode=1;
469

    
470
            if(run_mode){
471

    
472
                if(diff){
473
                    while(run_count >= 1<<ff_log2_run[run_index]){
474
                        run_count -= 1<<ff_log2_run[run_index];
475
                        run_index++;
476
                        put_bits(&s->pb, 1, 1);
477
                    }
478

    
479
                    put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
480
                    if(run_index) run_index--;
481
                    run_count=0;
482
                    run_mode=0;
483
                    if(diff>0) diff--;
484
                }else{
485
                    run_count++;
486
                }
487
            }
488

    
489
//            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));
490

    
491
            if(run_mode == 0)
492
                put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
493
        }
494
    }
495
    if(run_mode){
496
        while(run_count >= 1<<ff_log2_run[run_index]){
497
            run_count -= 1<<ff_log2_run[run_index];
498
            run_index++;
499
            put_bits(&s->pb, 1, 1);
500
        }
501

    
502
        if(run_count)
503
            put_bits(&s->pb, 1, 1);
504
    }
505
    s->run_index= run_index;
506

    
507
    return 0;
508
}
509

    
510
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
511
    int x,y,i;
512
    const int ring_size= s->avctx->context_model ? 3 : 2;
513
    int_fast16_t *sample[3];
514
    s->run_index=0;
515

    
516
    memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
517

    
518
    for(y=0; y<h; y++){
519
        for(i=0; i<ring_size; i++)
520
            sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
521

    
522
        sample[0][-1]= sample[1][0  ];
523
        sample[1][ w]= sample[1][w-1];
524
//{START_TIMER
525
        if(s->avctx->bits_per_raw_sample<=8){
526
            for(x=0; x<w; x++){
527
                sample[0][x]= src[x + stride*y];
528
            }
529
            encode_line(s, w, sample, plane_index, 8);
530
        }else{
531
            for(x=0; x<w; x++){
532
                sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
533
            }
534
            encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
535
        }
536
//STOP_TIMER("encode line")}
537
    }
538
}
539

    
540
static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
541
    int x, y, p, i;
542
    const int ring_size= s->avctx->context_model ? 3 : 2;
543
    int_fast16_t *sample[3][3];
544
    s->run_index=0;
545

    
546
    memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
547

    
548
    for(y=0; y<h; y++){
549
        for(i=0; i<ring_size; i++)
550
            for(p=0; p<3; p++)
551
                sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
552

    
553
        for(x=0; x<w; x++){
554
            int v= src[x + stride*y];
555
            int b= v&0xFF;
556
            int g= (v>>8)&0xFF;
557
            int r= (v>>16)&0xFF;
558

    
559
            b -= g;
560
            r -= g;
561
            g += (b + r)>>2;
562
            b += 0x100;
563
            r += 0x100;
564

    
565
//            assert(g>=0 && b>=0 && r>=0);
566
//            assert(g<256 && b<512 && r<512);
567
            sample[0][0][x]= g;
568
            sample[1][0][x]= b;
569
            sample[2][0][x]= r;
570
        }
571
        for(p=0; p<3; p++){
572
            sample[p][0][-1]= sample[p][1][0  ];
573
            sample[p][1][ w]= sample[p][1][w-1];
574
            encode_line(s, w, sample[p], FFMIN(p, 1), 9);
575
        }
576
    }
577
}
578

    
579
static void write_quant_table(RangeCoder *c, int16_t *quant_table){
580
    int last=0;
581
    int i;
582
    uint8_t state[CONTEXT_SIZE];
583
    memset(state, 128, sizeof(state));
584

    
585
    for(i=1; i<128 ; i++){
586
        if(quant_table[i] != quant_table[i-1]){
587
            put_symbol(c, state, i-last-1, 0);
588
            last= i;
589
        }
590
    }
591
    put_symbol(c, state, i-last-1, 0);
592
}
593

    
594
static void write_header(FFV1Context *f){
595
    uint8_t state[CONTEXT_SIZE];
596
    int i;
597
    RangeCoder * const c= &f->c;
598

    
599
    memset(state, 128, sizeof(state));
600

    
601
    put_symbol(c, state, f->version, 0);
602
    put_symbol(c, state, f->ac, 0);
603
    if(f->ac>1){
604
        for(i=1; i<256; i++){
605
            f->state_transition[i]=ver2_state[i];
606
            put_symbol(c, state, ver2_state[i] - c->one_state[i], 1);
607
        }
608
    }
609
    put_symbol(c, state, f->colorspace, 0); //YUV cs type
610
    if(f->version>0)
611
        put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
612
    put_rac(c, state, 1); //chroma planes
613
        put_symbol(c, state, f->chroma_h_shift, 0);
614
        put_symbol(c, state, f->chroma_v_shift, 0);
615
    put_rac(c, state, 0); //no transparency plane
616

    
617
    for(i=0; i<5; i++)
618
        write_quant_table(c, f->quant_table[i]);
619
}
620
#endif /* CONFIG_FFV1_ENCODER */
621

    
622
static av_cold int common_init(AVCodecContext *avctx){
623
    FFV1Context *s = avctx->priv_data;
624

    
625
    s->avctx= avctx;
626
    s->flags= avctx->flags;
627

    
628
    dsputil_init(&s->dsp, avctx);
629

    
630
    s->width = avctx->width;
631
    s->height= avctx->height;
632

    
633
    assert(s->width && s->height);
634

    
635
    s->sample_buffer = av_malloc(6 * (s->width+6) * sizeof(*s->sample_buffer));
636
    if (!s->sample_buffer)
637
        return AVERROR(ENOMEM);
638

    
639
    return 0;
640
}
641

    
642
#if CONFIG_FFV1_ENCODER
643
static av_cold int encode_init(AVCodecContext *avctx)
644
{
645
    FFV1Context *s = avctx->priv_data;
646
    int i;
647

    
648
    common_init(avctx);
649

    
650
    s->version=0;
651
    s->ac= avctx->coder_type ? 2:0;
652

    
653
    s->plane_count=2;
654
    for(i=0; i<256; i++){
655
        if(avctx->bits_per_raw_sample <=8){
656
            s->quant_table[0][i]=           quant11[i];
657
            s->quant_table[1][i]=        11*quant11[i];
658
            if(avctx->context_model==0){
659
                s->quant_table[2][i]=     11*11*quant11[i];
660
                s->quant_table[3][i]=
661
                s->quant_table[4][i]=0;
662
            }else{
663
                s->quant_table[2][i]=     11*11*quant5 [i];
664
                s->quant_table[3][i]=   5*11*11*quant5 [i];
665
                s->quant_table[4][i]= 5*5*11*11*quant5 [i];
666
            }
667
        }else{
668
            s->quant_table[0][i]=           quant9_10bit[i];
669
            s->quant_table[1][i]=        11*quant9_10bit[i];
670
            if(avctx->context_model==0){
671
                s->quant_table[2][i]=     11*11*quant9_10bit[i];
672
                s->quant_table[3][i]=
673
                s->quant_table[4][i]=0;
674
            }else{
675
                s->quant_table[2][i]=     11*11*quant5_10bit[i];
676
                s->quant_table[3][i]=   5*11*11*quant5_10bit[i];
677
                s->quant_table[4][i]= 5*5*11*11*quant5_10bit[i];
678
            }
679
        }
680
    }
681

    
682
    for(i=0; i<s->plane_count; i++){
683
        PlaneContext * const p= &s->plane[i];
684

    
685
        if(avctx->context_model==0){
686
            p->context_count= (11*11*11+1)/2;
687
        }else{
688
            p->context_count= (11*11*5*5*5+1)/2;
689
        }
690

    
691
        if(s->ac){
692
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
693
        }else{
694
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
695
        }
696
    }
697

    
698
    avctx->coded_frame= &s->picture;
699
    switch(avctx->pix_fmt){
700
    case PIX_FMT_YUV444P16:
701
    case PIX_FMT_YUV422P16:
702
    case PIX_FMT_YUV420P16:
703
        if(avctx->bits_per_raw_sample <=8){
704
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
705
            return -1;
706
        }
707
        if(!s->ac){
708
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
709
            return -1;
710
        }
711
        s->version= 1;
712
    case PIX_FMT_YUV444P:
713
    case PIX_FMT_YUV422P:
714
    case PIX_FMT_YUV420P:
715
    case PIX_FMT_YUV411P:
716
    case PIX_FMT_YUV410P:
717
        s->colorspace= 0;
718
        break;
719
    case PIX_FMT_RGB32:
720
        s->colorspace= 1;
721
        break;
722
    default:
723
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
724
        return -1;
725
    }
726
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
727

    
728
    s->picture_number=0;
729

    
730
    return 0;
731
}
732
#endif /* CONFIG_FFV1_ENCODER */
733

    
734

    
735
static void clear_state(FFV1Context *f){
736
    int i, j;
737

    
738
    for(i=0; i<f->plane_count; i++){
739
        PlaneContext *p= &f->plane[i];
740

    
741
        p->interlace_bit_state[0]= 128;
742
        p->interlace_bit_state[1]= 128;
743

    
744
        for(j=0; j<p->context_count; j++){
745
            if(f->ac){
746
                memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
747
            }else{
748
                p->vlc_state[j].drift= 0;
749
                p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
750
                p->vlc_state[j].bias= 0;
751
                p->vlc_state[j].count= 1;
752
            }
753
        }
754
    }
755
}
756

    
757
#if CONFIG_FFV1_ENCODER
758
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
759
    FFV1Context *f = avctx->priv_data;
760
    RangeCoder * const c= &f->c;
761
    AVFrame *pict = data;
762
    const int width= f->width;
763
    const int height= f->height;
764
    AVFrame * const p= &f->picture;
765
    int used_count= 0;
766
    uint8_t keystate=128;
767

    
768
    ff_init_range_encoder(c, buf, buf_size);
769
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
770

    
771
    *p = *pict;
772
    p->pict_type= FF_I_TYPE;
773

    
774
    if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
775
        put_rac(c, &keystate, 1);
776
        p->key_frame= 1;
777
        write_header(f);
778
        clear_state(f);
779
    }else{
780
        put_rac(c, &keystate, 0);
781
        p->key_frame= 0;
782
    }
783

    
784
    if(!f->ac){
785
        used_count += ff_rac_terminate(c);
786
//printf("pos=%d\n", used_count);
787
        init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
788
    }else if (f->ac>1){
789
        int i;
790
        for(i=1; i<256; i++){
791
            c->one_state[i]= f->state_transition[i];
792
            c->zero_state[256-i]= 256-c->one_state[i];
793
        }
794
    }
795

    
796
    if(f->colorspace==0){
797
        const int chroma_width = -((-width )>>f->chroma_h_shift);
798
        const int chroma_height= -((-height)>>f->chroma_v_shift);
799

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

    
802
        encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
803
        encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
804
    }else{
805
        encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
806
    }
807
    emms_c();
808

    
809
    f->picture_number++;
810

    
811
    if(f->ac){
812
        return ff_rac_terminate(c);
813
    }else{
814
        flush_put_bits(&f->pb); //nicer padding FIXME
815
        return used_count + (put_bits_count(&f->pb)+7)/8;
816
    }
817
}
818
#endif /* CONFIG_FFV1_ENCODER */
819

    
820
static av_cold int common_end(AVCodecContext *avctx){
821
    FFV1Context *s = avctx->priv_data;
822
    int i;
823

    
824
    for(i=0; i<s->plane_count; i++){
825
        PlaneContext *p= &s->plane[i];
826

    
827
        av_freep(&p->state);
828
        av_freep(&p->vlc_state);
829
    }
830

    
831
    av_freep(&s->sample_buffer);
832

    
833
    return 0;
834
}
835

    
836
static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
837
    PlaneContext * const p= &s->plane[plane_index];
838
    RangeCoder * const c= &s->c;
839
    int x;
840
    int run_count=0;
841
    int run_mode=0;
842
    int run_index= s->run_index;
843

    
844
    for(x=0; x<w; x++){
845
        int diff, context, sign;
846

    
847
        context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
848
        if(context < 0){
849
            context= -context;
850
            sign=1;
851
        }else
852
            sign=0;
853

    
854

    
855
        if(s->ac){
856
            diff= get_symbol_inline(c, p->state[context], 1);
857
        }else{
858
            if(context == 0 && run_mode==0) run_mode=1;
859

    
860
            if(run_mode){
861
                if(run_count==0 && run_mode==1){
862
                    if(get_bits1(&s->gb)){
863
                        run_count = 1<<ff_log2_run[run_index];
864
                        if(x + run_count <= w) run_index++;
865
                    }else{
866
                        if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
867
                        else run_count=0;
868
                        if(run_index) run_index--;
869
                        run_mode=2;
870
                    }
871
                }
872
                run_count--;
873
                if(run_count < 0){
874
                    run_mode=0;
875
                    run_count=0;
876
                    diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
877
                    if(diff>=0) diff++;
878
                }else
879
                    diff=0;
880
            }else
881
                diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
882

    
883
//            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));
884
        }
885

    
886
        if(sign) diff= -diff;
887

    
888
        sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
889
    }
890
    s->run_index= run_index;
891
}
892

    
893
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
894
    int x, y;
895
    int_fast16_t *sample[2];
896
    sample[0]=s->sample_buffer    +3;
897
    sample[1]=s->sample_buffer+w+6+3;
898

    
899
    s->run_index=0;
900

    
901
    memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
902

    
903
    for(y=0; y<h; y++){
904
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
905

    
906
        sample[0]= sample[1];
907
        sample[1]= temp;
908

    
909
        sample[1][-1]= sample[0][0  ];
910
        sample[0][ w]= sample[0][w-1];
911

    
912
//{START_TIMER
913
        if(s->avctx->bits_per_raw_sample <= 8){
914
            decode_line(s, w, sample, plane_index, 8);
915
            for(x=0; x<w; x++){
916
                src[x + stride*y]= sample[1][x];
917
            }
918
        }else{
919
            decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
920
            for(x=0; x<w; x++){
921
                ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
922
            }
923
        }
924
//STOP_TIMER("decode-line")}
925
    }
926
}
927

    
928
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
929
    int x, y, p;
930
    int_fast16_t *sample[3][2];
931
    for(x=0; x<3; x++){
932
        sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
933
        sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
934
    }
935

    
936
    s->run_index=0;
937

    
938
    memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
939

    
940
    for(y=0; y<h; y++){
941
        for(p=0; p<3; p++){
942
            int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
943

    
944
            sample[p][0]= sample[p][1];
945
            sample[p][1]= temp;
946

    
947
            sample[p][1][-1]= sample[p][0][0  ];
948
            sample[p][0][ w]= sample[p][0][w-1];
949
            decode_line(s, w, sample[p], FFMIN(p, 1), 9);
950
        }
951
        for(x=0; x<w; x++){
952
            int g= sample[0][1][x];
953
            int b= sample[1][1][x];
954
            int r= sample[2][1][x];
955

    
956
//            assert(g>=0 && b>=0 && r>=0);
957
//            assert(g<256 && b<512 && r<512);
958

    
959
            b -= 0x100;
960
            r -= 0x100;
961
            g -= (b + r)>>2;
962
            b += g;
963
            r += g;
964

    
965
            src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
966
        }
967
    }
968
}
969

    
970
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
971
    int v;
972
    int i=0;
973
    uint8_t state[CONTEXT_SIZE];
974

    
975
    memset(state, 128, sizeof(state));
976

    
977
    for(v=0; i<128 ; v++){
978
        int len= get_symbol(c, state, 0) + 1;
979

    
980
        if(len + i > 128) return -1;
981

    
982
        while(len--){
983
            quant_table[i] = scale*v;
984
            i++;
985
//printf("%2d ",v);
986
//if(i%16==0) printf("\n");
987
        }
988
    }
989

    
990
    for(i=1; i<128; i++){
991
        quant_table[256-i]= -quant_table[i];
992
    }
993
    quant_table[128]= -quant_table[127];
994

    
995
    return 2*v - 1;
996
}
997

    
998
static int read_header(FFV1Context *f){
999
    uint8_t state[CONTEXT_SIZE];
1000
    int i, context_count;
1001
    RangeCoder * const c= &f->c;
1002

    
1003
    memset(state, 128, sizeof(state));
1004

    
1005
    f->version= get_symbol(c, state, 0);
1006
    f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1007
    if(f->ac>1){
1008
        for(i=1; i<256; i++){
1009
            f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1010
        }
1011
    }
1012
    f->colorspace= get_symbol(c, state, 0); //YUV cs type
1013
    if(f->version>0)
1014
        f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1015
    get_rac(c, state); //no chroma = false
1016
    f->chroma_h_shift= get_symbol(c, state, 0);
1017
    f->chroma_v_shift= get_symbol(c, state, 0);
1018
    get_rac(c, state); //transparency plane
1019
    f->plane_count= 2;
1020

    
1021
    if(f->colorspace==0){
1022
        if(f->avctx->bits_per_raw_sample<=8){
1023
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1024
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1025
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1026
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1027
            case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1028
            case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1029
            default:
1030
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1031
                return -1;
1032
            }
1033
        }else{
1034
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1035
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1036
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1037
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1038
            default:
1039
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1040
                return -1;
1041
            }
1042
        }
1043
    }else if(f->colorspace==1){
1044
        if(f->chroma_h_shift || f->chroma_v_shift){
1045
            av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1046
            return -1;
1047
        }
1048
        f->avctx->pix_fmt= PIX_FMT_RGB32;
1049
    }else{
1050
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1051
        return -1;
1052
    }
1053

    
1054
//printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1055

    
1056
    context_count=1;
1057
    for(i=0; i<5; i++){
1058
        context_count*= read_quant_table(c, f->quant_table[i], context_count);
1059
        if(context_count < 0 || context_count > 32768){
1060
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1061
            return -1;
1062
        }
1063
    }
1064
    context_count= (context_count+1)/2;
1065

    
1066
    for(i=0; i<f->plane_count; i++){
1067
        PlaneContext * const p= &f->plane[i];
1068

    
1069
        p->context_count= context_count;
1070

    
1071
        if(f->ac){
1072
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
1073
        }else{
1074
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
1075
        }
1076
    }
1077

    
1078
    return 0;
1079
}
1080

    
1081
static av_cold int decode_init(AVCodecContext *avctx)
1082
{
1083
//    FFV1Context *s = avctx->priv_data;
1084

    
1085
    common_init(avctx);
1086

    
1087
    return 0;
1088
}
1089

    
1090
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1091
    const uint8_t *buf = avpkt->data;
1092
    int buf_size = avpkt->size;
1093
    FFV1Context *f = avctx->priv_data;
1094
    RangeCoder * const c= &f->c;
1095
    const int width= f->width;
1096
    const int height= f->height;
1097
    AVFrame * const p= &f->picture;
1098
    int bytes_read;
1099
    uint8_t keystate= 128;
1100

    
1101
    AVFrame *picture = data;
1102

    
1103
    ff_init_range_decoder(c, buf, buf_size);
1104
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1105

    
1106

    
1107
    p->pict_type= FF_I_TYPE; //FIXME I vs. P
1108
    if(get_rac(c, &keystate)){
1109
        p->key_frame= 1;
1110
        if(read_header(f) < 0)
1111
            return -1;
1112
        clear_state(f);
1113
    }else{
1114
        p->key_frame= 0;
1115
    }
1116
    if(f->ac>1){
1117
        int i;
1118
        for(i=1; i<256; i++){
1119
            c->one_state[i]= f->state_transition[i];
1120
            c->zero_state[256-i]= 256-c->one_state[i];
1121
        }
1122
    }
1123

    
1124
    if(!f->plane[0].state && !f->plane[0].vlc_state)
1125
        return -1;
1126

    
1127
    p->reference= 0;
1128
    if(avctx->get_buffer(avctx, p) < 0){
1129
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1130
        return -1;
1131
    }
1132

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

    
1136
    if(!f->ac){
1137
        bytes_read = c->bytestream - c->bytestream_start - 1;
1138
        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1139
//printf("pos=%d\n", bytes_read);
1140
        init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
1141
    } else {
1142
        bytes_read = 0; /* avoid warning */
1143
    }
1144

    
1145
    if(f->colorspace==0){
1146
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1147
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1148
        decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
1149

    
1150
        decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
1151
        decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
1152
    }else{
1153
        decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
1154
    }
1155

    
1156
    emms_c();
1157

    
1158
    f->picture_number++;
1159

    
1160
    *picture= *p;
1161

    
1162
    avctx->release_buffer(avctx, p); //FIXME
1163

    
1164
    *data_size = sizeof(AVFrame);
1165

    
1166
    if(f->ac){
1167
        bytes_read= c->bytestream - c->bytestream_start - 1;
1168
        if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1169
    }else{
1170
        bytes_read+= (get_bits_count(&f->gb)+7)/8;
1171
    }
1172

    
1173
    return bytes_read;
1174
}
1175

    
1176
AVCodec ffv1_decoder = {
1177
    "ffv1",
1178
    AVMEDIA_TYPE_VIDEO,
1179
    CODEC_ID_FFV1,
1180
    sizeof(FFV1Context),
1181
    decode_init,
1182
    NULL,
1183
    common_end,
1184
    decode_frame,
1185
    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1186
    NULL,
1187
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1188
};
1189

    
1190
#if CONFIG_FFV1_ENCODER
1191
AVCodec ffv1_encoder = {
1192
    "ffv1",
1193
    AVMEDIA_TYPE_VIDEO,
1194
    CODEC_ID_FFV1,
1195
    sizeof(FFV1Context),
1196
    encode_init,
1197
    encode_frame,
1198
    common_end,
1199
    .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},
1200
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1201
};
1202
#endif